Index: /CMT/v1r20/ChangeLog
===================================================================
--- /CMT/v1r20/ChangeLog	(revision 368)
+++ /CMT/v1r20/ChangeLog	(revision 368)
@@ -0,0 +1,5483 @@
+2007-01-02 Vincent Garonne <garonne@lal.in2p3.fr> 322
+
+	* source/cmt_parser.cxx:  update to deal with the action return status code
+	 and the -no_auto_imports differents cases.
+	* source/cmt_constituents.cxx: Add support for the -import=PkgA,PkgB
+	* source/cmt_error.*: update to deal with the action return status code 
+	* source/cmt.cxx: return status code	
+	
+2007-31-01 Vincent Garonne <garonne@lal.in2p3.fr> 321
+
+	* cmt_deps_builder.cxx:  Add support for space, line continuing character, etc.
+
+2006-15-11 Vincent Garonne <garonne@lal.in2p3.fr> 320
+
+    * mgr/fragments/group, mgr/fragments/nmake/group: Add macros $(${GROUP}_pre_constituents),  $(${GROUP}_post_constituents) for having target executed by default.
+    
+2006-14-11 Vincent Garonne <garonne@lal.in2p3.fr> 319
+
+    *  cmt.h, cmt_parser.cxx: Generate a native_version.cmt file if the <package>_native_version macro exists at the config step.
+
+2006-14-11 Vincent Garonne <garonne@lal.in2p3.fr> 318
+
+    *  cmt_tag.cxx: Correct the fact that "apply_tag" protected by a private section is exported in all the clients packages.
+
+2006-10-24    <arnault@lal.in2p3.fr> 317
+
+	* source\cmt_cmtpath_pattern.cxx (apply): Implement the two
+	different traversal modes for the project graph
+
+	* source\cmt_cmtpath_pattern.h (class CmtPathPattern): Add extra
+	arguments to action and add AND a new attribute to hold the
+	possible revert mode in the project traversal
+
+	* source\cmt_syntax.cxx (class KwdCmtPathPatternRevert): Implement
+	the parsing of the new keyword simply by adding an extra optional
+	arg to the CmtPathPattern::action
+	(SyntaxParser): Add a new keyword cmtpath_pattern_revert to handle
+	project traversal in reverse order (wrt the current order of
+	cmtpath_pattern)
+
+2006-18-10 Vincent Garonne <garonne@lal.in2p3.fr> 317
+
+    *  cmt_commands.*, cmt_parser.cxx, cmt.h: Add the -disable_warnings option to not print certains warnings, e.g. the CMTSITE value etc.
+    
+2006-12-10 Vincent Garonne <garonne@lal.in2p3.fr> 316
+
+    * source/cmt_parser.cxx, source/cmt_syntax.cxx, source/cmt_use.*: Enable and propagate the -native_version syntax at the use level. 
+     IMPORTANT NOTES: STILL NOT FINISHED.
+     
+2006-12-10 Vincent Garonne <garonne@lal.in2p3.fr> 315
+
+    * source/cmt_std.h: add __APPLE__ for removing compilation warnings    
+
+2006-11-10 Vincent Garonne <garonne@lal.in2p3.fr> 314
+
+    * source/cmt_project.*: Add two functions - get_project_releases, select_release    
+    * source/cmt_project.*: Add support for wildcarded project dependencies
+
+2006-10-10 Vincent Garonne <garonne@lal.in2p3.fr> 313
+
+    * source/cmt_symbol.*, source/cmt_parser.*, source/cmt_commands.*, source/cmt_syntax.*, source/cmt.h: Add support for the show project author command
+    * src/setup.*: Add auto-expand for project_author
+ 
+2006-09-28 Vincent Garonne <garonne@lal.in2p3.fr> 312
+
+	* source/cmt_symbol.cxx: Bug fixed on the windows platform.  
+
+2006-08-17 Vincent Garonne <garonne@lal.in2p3.fr> 311
+
+        * source/cmt_syntax.cxx: Add support for author syntax to project
+
+2006-06-15 Vincent Garonne <garonne@lal.in2p3.fr> 310
+
+        * source/cmt_system.cxx: Correct touch function to conserve permission 
+
+2006-06-15 Vincent Garonne <garonne@lal.in2p3.fr> 309
+
+        * mgr/fragments/application, mgr/fragments/c_library, mgr/fragments/cleanup_librarymgr/fragments/cpp, mgr/fragments/cpp_library, mgr/fragments/dependencies, mgr/fragments/fortran_library, mgr/fragments/library: Add the support for the PRINT_PREREQISITES mode during the make operation
+
+	* mgr/fragments/library: Fixed a bug
+
+2006-05-31 Vincent Garonne <garonne@lal.in2p3.fr> 308
+
+        * source/cmt_cvs: Add modification to deal with non working checkout by creating the cvs files manually ,e.g. cvs entries.
+        * source/cmt_cvs: Add the "-f" option which supposes to force cvs to ignore the .cvsrc file during cvs command execution. 
+
+2006-05-20  Christian Arnault  <arnault@lal.in2p3.fr> 307
+
+	* source/cmt_pattern.cxx (expand): Make use of
+	use->get_cmtpath_and_offset to compute the project of the package
+	when expanding the <project> template to fix packages with offset
+
+2006-04-25 Vincent Garonne <garonne@lal.in2p3.fr> 306
+
+        * cmt_generator.cxx: Add the fixe recommend by markus to deal with extern c data on visual
+
+2006-04-25 Vincent Garonne <garonne@lal.in2p3.fr> 305
+
+        * mgr/fragments/cleanup_header, mgr/fragments/constituent: Add a PEDANTIC option for building which stop 
+        directly after detecting a missing file or target 
+        
+        * mgr/fragments/constituent, mgr/fragments/constituents_header, mgr/fragments/cleanup_header, 
+        mgr/fragments/make_header : correct some bad behaviours and change the internal file name convention
+        *setup* -> *_setup* 
+
+2006-04-25 Vincent Garonne <garonne@lal.in2p3.fr> 304
+
+        * source/cmt_parser.cxx: Remove only the specific makefiles depending on the platform, e.g. remove *.make 
+        on linux and *.nmake on windows
+
+2006-04-25 Vincent Garonne <garonne@lal.in2p3.fr> 303
+
+        * source/cmt_commands.cxx, source/cmt_commands.h, source/cmt_parser.cxx, source/cmt_parser.h: Add a new cmt          
+        command "relocate" to generate only setup script whithout makefile
+
+        * src/setup.tcsh : Enable the auto-expand mechanism for the relocate command
+
+2006-04-25 Vincent Garonne <garonne@lal.in2p3.fr> 302
+
+        * source/cmt_cvs.cxx: Do the exact mathing for tag during recursive checkout operation
+
+2006-04-24   Christian Arnault  <arnault@lal.in2p3.fr> 301
+
+        * source/cmt_pattern.cxx(expand): Add support for a <project> template in patterns
+
+2006-14-03   Christian Arnault  <arnault@lal.in2p3.fr> 300
+
+	* source/cmt_cvs.cxx: Switch checkout sequence from multi-co to multi update
+
+2006-03-01  Vincent Garonne <garonne@lal.in2p3.fr> 299
+
+	* mgr/requirements: Enable tag v1r18 for the HEAD version 
+
+2006-02-24  Christian Arnault  <arnault@lal.in2p3.fr> 298
+
+	* mgr/requirements: Suppress automatic installation of share/bin & share/lib in CLASSPATH for with_installarea
+
+	* source/cmt_project.cxx (create_project): Suppress a warning message
+
+	* source/cmt_commands.cxx (do_check): Suppress automatic warnings for do_check_configuration
+	(do_setup): idem for cmt setup
+
+2006-02-10  Vincent Garonne <garonne@lal.in2p3.fr> 297
+
+        * mgr/requirements: Fill <project>_installarea_linkopts in addition to cmt_installarea_linkopts
+
+2006-02-09  Christian Arnault  <arnault@lal.in2p3.fr> 296
+
+        * mgr/requirements: Fill <project>_installarea_linkopts in addition to cmt_installarea_linkopts
+
+2006-02-07  Christian Arnault  <arnault@lal.in2p3.fr> 295
+
+	* mgr/requirements: Protect cmtpath_patterns with strategies
+	use $(CMTCONFIG) instead of $(tag) in cmtpath_patterns
+
+	* source/cmt_parser.cxx (configure_cmt_path): Suppress warnings for bad paths at this stage
+	(do_check_configuration): Add set_standard_macros for do_check_configuration
+
+	* source/cmt_commands.cxx (do_check): Activate warnings for check configuration and for setup 
+
+	* source/cmt_symbol.cxx (filter_path_value): Don't kill path item when they don't exist.
+	(action): Reset all_sets_done at each symbol definition.
+	(all_set): Protect against internal recursivity
+	(all_print): Print path settings here.
+	(check_all_paths): Add a new function to check all paths.
+	(SetBuilder::build): suppress detetion of overridings from here (move to SymbolValueList::show)
+	(PathBuilder::build): suppress detetion of overridings from here (move to SymbolValueList::show)
+	(MacroBuilder::build): suppress detetion of overridings from here (move to SymbolValueList::show)
+	(ActionBuilder::build): suppress detetion of overridings from here (move to SymbolValueList::show)
+	(SymbolValueList::show): Keep reset to null actions
+	Print overridings
+
+	* source/cmt_system.cxx: Add include cmt_map.h for putenv management
+	(class CMTPathManager): Suppress generation of an error when the CMTPATH item does not exist 
+
+2006-02-06  Christian Arnault  <arnault@lal.in2p3.fr> 294
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Uses the new CmtSystem::putenv API
+
+	* source/cmt_symbol.cxx (all_set): Uses the new CmtSystem::putenv API to fix setup problems 
+
+	* source/cmt_system.h (class CmtSystem): Modifying the API of the internal putenv function 
+
+	* source/cmt_system.cxx (putenv): Replacing the old putenv implementation with a new one using a static map
+	of all used environment variables so as to ensure a stable string
+
+2006-01-31    <arnault@lal.in2p3.fr> 293
+
+	* source/cmt_parser.cxx (configure_cmt_path): Force a warning when CMTPATH contains a non existing item.
+
+	* source/cmt_awk.cxx (scan_path): Restore commented debug printouts after fix.
+
+	* source/cmt_parser.cxx (run): Fix the parsing of requirements file for do_show_clients for use statements without version.
+
+	* source/cmt_awk.cxx (scan_path): Detect the non-version-directory mode and launches the run with appropriate flag.
+
+	* source/cmt_awk.h (class PathScanner): Add an argument to mark that the scanned package
+	uses no version directory.
+
+	* mgr/requirements: Removed obsolete pp_cflags for Linux (ticket #15)
+
+2006-01-27 <garonne@lal.in2p3.fr>
+
+	* source/cmt_parser.cxx: Allow with_version_directory option for users.
+
+2006-01-09    <arnault@lal.in2p3.fr> 292
+
+	* source/cmt_project.cxx (create_project): Access CMTPROJECTPATH through 
+	symbol or getenv
+
+	* source/cmt_symbol.cxx (get_env_value): Make use of the global 
+	display inhibitor to ensure that temporary value builder will not
+	show unexpected output.
+
+	* source/cmt_symbol.h (class Symbol): Define a special accessor function for
+	retrieving the value a symbols associated with an env. var. (typically
+	for CMTPATH like variables)
+
+	* source/cmt_symbol.cxx (action): Trigger the Cmt::configure_cmt_path 
+	from CMTPROJECTPATH like CMTPATH
+
+2005-10-31  Christian Arnault  <arnault@lal.in2p3.fr> 291
+
+	* source/cmt_system.cxx (is_version_directory): Permit version
+	directories not starting by a letter (eg 1.0)
+
+2005-10-30    <arnault@lal.in2p3.fr> 290
+
+	* source/cmt_symbol.cxx (all_set): Must expand PATH values before
+	filtering and setting them
+
+2005-10-28    <arnault@lal.in2p3.fr> 289
+
+	* cmt/fragments/cleanup_header: Temporary hack to deal with missing files
+	and to avoid infinite loops in make. However, this must be seen as a ugly hack
+	since it considers an Atlas use case with config.h.in. This hack is 
+	harmless to any user of this special file though.
+
+	* source/cmt.h
+	* source/cmt_parser.cxx
+	* source/cmt_commands.h
+	* source/cmt_commands.cxx
+	* doc/CMTDoc.xml: Add a -warnings option to display various warning messages
+ 
+2005-10-18    <arnault@lal.in2p3.fr> 288
+
+	* mgr/Makefile (bintar): Prepare and cleanup binary directories
+	before creating tar balls.
+
+	* mgr/Makefile (Export): Move the docs target from bintar to Export
+
+	* source/cmt_symbol.cxx (print): Filter path values before
+	setting them externally
+
+	* source/cmt_symbol.cxx (all_set): Filter path values before
+	setting them internally
+
+	* source/cmt_parser.cxx (configure_cmt_path): Filter out CMTPATH
+	before creating or updating projects from the CMTPATH value
+
+	* source/cmt_symbol.h (class Symbol): Add a static function to
+	filter out faulty items in a PATH symbol
+
+2005-10-17    <arnault@lal.in2p3.fr> 287
+
+	* mgr/Makefile (cmtexe): Use -quiet option whenever using cmt
+	within the Makefile of CMT
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Protect against
+	empty protocol level (for backward compatibility)
+
+2005-10-15    <arnault@lal.in2p3.fr> 286
+
+	* source/cmt_project.cxx (use_action): Consider empty release for
+	Windows (test_directory on Windows does not work with a trailing
+	backslash)
+
+2005-10-11  Christian Arnault  <arnault@lal.in2p3.fr> 285
+
+	* source/cmt_project.cxx (create_project): Protection against
+	single level directories in CMTPATH (/xxx)
+
+2005-10-11    <arnault@lal.in2p3.fr> 284
+
+	* mgr/fragments/nmake/constituent (clean): Protect against
+	unexisting makefile fragment when running the clean target
+
+	* source/cmt_parser.cxx (class StandardMacroBuilder): Enclose
+	items in the use_requirements macro into double quotes using the q
+	macro. This to cope with spaces in directories on Windows.
+	(dos_script_prefix): Add quotes for the -path argument 
+
+	* mgr/requirements: Add a macro definition to hold a double-quote
+
+2005-09-13    <arnault@lal.in2p3.fr> 283
+
+	* mgr/CMT.pacman: Add constraint on version of pacman
+	Use ./INSTALL instead of just INSTALL
+
+2005-09-29  Christian Arnault  <arnault@lal.in2p3.fr> 283
+
+	* mgr/fragments/nmake/constituents_trailer (makefilesclean): Remove references to checkuses
+	* mgr/fragments/constituents_header (config): Remove references to checkuses
+	* mgr/fragments/constituents_trailer (makefilesclean): Remove references to checkuses
+	* mgr/fragments/make_header (dirs): Remove references to checkuses
+	* mgr/fragments/make_setup (config): Remove references to checkuses
+
+	* source/cmt_parser.cxx (do_broadcast): bug fix: the set_standard_macro was not called 
+	prior to set all EVs before the broadcast loop
+
+2005-09-09    <arnault@lal.in2p3.fr> 282
+
+	* mgr/Makefile: Adapt (fix) to changes in the doc directory.
+
+2005-09-07    <arnault@lal.in2p3.fr> 281
+
+	* source/cmt_version.h: fix tag v1r18p20050901
+
+        * source/cmt_cvs.h: Fix bug when generating version.cmt file after checkout
+
+2005-09-05    <arnault@lal.in2p3.fr> 280
+
+	* source/cmt_std.h: Fix std context for CYGWIN
+
+2005-09-05  Christian Arnault  <arnault@lal.in2p3.fr> 279
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Fix do_need_version
+
+	* source/cmt_project.cxx (StrategyMgr): Initialize VersionStrategy using default
+
+2005-09-05    <arnault@lal.in2p3.fr> 278
+
+	* source\cmt_parser.cxx (do_create): Make use of the
+	structure strategy for creating package directory structure.
+
+	* source\cmt_cvs.cxx (class CvsImplementation): Make use of the
+	structure strategy for creating package directory structure.
+
+	* source\cmt_parser.cxx (do_show_strategies): Display the structure strategy
+
+	* source\cmt_syntax.cxx (class KwdStructureStrategy): Create the
+	parsing function for Structure strategies
+
+	* source\cmt_parser.h (enum CmtStructuringStyle): By default the
+	structuring style is initialized with default_structuring_style
+	instead of with_version_directory in order to remember whether the
+	default has been overridden using EV or command option.
+
+	* source\cmt_project.cxx (configure): Initialize the VersionDirectory strategy
+	(StrategyMgr): Create the VersionDirectory strategy entry.
+
+	* source\cmt_parser.h (enum): Add a StructureStrategy to define with/out version directory.
+
+2005-09-05  Christian Arnault  <arnault@lal.in2p3.fr> 277
+
+	* mgr/cmt_buildcvsinfos2.sh (module): Adapt to the new syntax by adding the protocol level.
+
+	* source/cmt_include.cxx (action): Submit include_dirs statement to private scoping
+
+2005-09-01  Christian Arnault  <arnault@lal.in2p3.fr> 276
+
+	* source/cmt_use.cxx (get_strategy): Implement the get_strategy function
+
+	* source/cmt_use.h (class Use): Install the get_strategy function as a member function.
+
+	* source/cmt_symbol.cxx (all_set): Generate all XXXROOT and XXXCONFIG evs according
+	to the strategies.
+
+	* source/cmt_parser.cxx (get_strategy): Make the use argument of the function a required argument
+	ie suppress the default arg to Use::current ()
+	Prepare to migrate this function as a member function of Use
+
+2005-08-31  Christian Arnault  <arnault@lal.in2p3.fr> 275
+
+	* source/cmt.h (class Cmt): Making the get_strategy function a member function 
+	rather than a private local one
+
+	* mgr/fragments/constituent (uninstall): Protect against missing un/install targets
+	* mgr/fragments/nmake/constituent (uninstall): Protect against missing un/install targets
+
+	* mgr/fragments/cmt_action_runner_header: Add install and uninstall dummy target
+	* mgr/fragments/nmake/cmt_action_runner_header: Add install and uninstall dummy target
+
+	* mgr/cmt_uninstall_action.bat: [Fix] typo
+
+	* source/cmt_project.cxx (create_project): When create a parent-less project, link it to 
+	previous top project(s) and upgrade strategies
+	(class VisitorForFillCMTPATH): [Fix] Should not add the path separator
+
+	* source/cmt_project.h (class Project): Add a function to ask if a project has parents
+
+	* source/cmt_include.cxx (parse): When expanding include, the use must be trasmitted to new includes
+
+2005-08-30  Christian Arnault  <arnault@lal.in2p3.fr> 275
+
+	* source/cmt_parser.cxx (class StandardMacroBuilder): Parse all includes for Current use
+
+	* source/cmt_include.cxx: Do the parse_all operation in the context of one Use.
+
+	* source/cmt_include.h (class Include): Do the parse_all operation in the context of one Use.
+
+	* source/cmt_project.cxx (create): Return a boolean status to show success of the creation
+
+	* source/cmt_project.h (class Project): create function returns a boolean that
+	describes if the creation was successful. In case of success the current directory
+	is in the cmt directory of the project. 
+
+	* source/cmt_system.cxx (scan_dir): Fix a bug
+
+	* source/cmt_deps_builder.cxx (build_deps_text): Fix state change when in single line comment
+
+2005-08-19  Christian Arnault  <arnault@lal.in2p3.fr> 274
+
+	* source/cmt_use.cxx (fill_includes_macro): skip include_dirs entries with empty name
+
+	* source/cmt_project.cxx (show_all): Use the top project when current is not defined
+	(start_visit): idem
+	(class VisitorForFillCMTPATH): Initialize CMTPATH to empty when filling in CMTPATH for all projects
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Add the get_module function to compute the CVS module
+	from the requested package/offset
+	(class CvsImplementation): Add a check_structure to verify various structures before doing the checkout
+	(class CvsImplementation): Ask for the checkout when the directory structure is in place but 
+	when the CMT structure is NOT in place. Useful for mounting disks before the checkout.
+
+	* source/cmt_parser.cxx (class StandardMacroBuilder): Apply the post-processing of include_dirs statements.
+	(get_strategy): Get the top project to compute a strategy when the current project is not defined
+	in order to avoid losing all strategies for standalone packages.
+
+	* source/cmt_include.h (class Include): Suppress print_all and print_filters obsolete functions
+	* source/cmt_include.cxx: Suppress print_all and print_filters obsolete functions
+	(parse): Add a post-processing step to expand include_dirs statements at set_standard_macros stage
+
+	* source/cmt_deps_builder.cxx (build_deps_text): Fix and Change the way source files are parsed 
+	for computing dependencies. Fill a cmt_string at once and traverse the string without any additional 
+	copy.
+
+2005-07-21  Christian Arnault  <arnault@lal.in2p3.fr> 274
+
+	* source/cmt_symbol.cxx (build): Clean up unneeded path separators
+
+2005-07-19  Christian Arnault  <arnault@lal.in2p3.fr> 274
+
+	* source/cmt_symbol.cxx (build): Suppress old test in CommandPathRemoveRegexp
+
+2005-05-09  Christian Arnault  <arnault@lal.in2p3.fr> 273
+
+	* source/cmt_use.cxx (fill_standard_macros): Fix a bug in setting
+	the project macros (missing CR)
+
+2005-05-02  Christian Arnault  <arnault@lal.in2p3.fr> 272
+
+	* source/cmt_version.h: Prepare v1r18p20050501
+
+	* source/cmt_cvs.cxx: Adding CMTPATH internal management
+	Improve broadcast operation after recursive checkouts
+
+2005-05-01  Christian Arnault  <arnault@lal.in2p3.fr> 272
+
+	* mgr/Makefile (pacman): Create the pacman file for that version.
+
+	* mgr/CMT.pacman: Migrate to Pacman3
+
+	* source/cmt_cvs.cxx: Supporting project checkout
+	recursive project checkouts
+	without_version_directory mode
+	container statements in project files.
+	alias version directory
+	Various cleanup and restructuring operations
+
+	* mgr/requirements: Adapt for shared libs on CYGWIN (thanks to Guy Barrand)
+
+	* src/setup.zsh: Add cmt subprojects command
+
+	* src/setup.tcsh: Add cmt subprojects command
+
+2005-04-26  Christian Arnault  <arnault@lal.in2p3.fr> 271
+
+	* source/cmt_cvs.cxx: Add recursive passes for cvs co -R on projects (not completed)
+	Add support/checking of protocol level against CVS pluggin
+	Detection of non-installation of the CVS pluggin
+
+	* mgr/requirements: Add a macro cmt_cvs_protocol_level to specify
+	the expected protocol level with the CVS pluggin
+
+2005-04-25    <arnault@lal.in2p3.fr> 270
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Accept empty
+	argument for queries on subprojects
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Accept empty
+	argument for queries on subpackages
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Selection for
+	getting the mudule contents is done using the structure
+	information.
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Isolate specific
+	behaviour into dedicated functions for getting the specific
+	contents for packages or for projects.
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Retrieve fields
+	for structure and subprojects from the CVS pluggin.
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Manage the
+	protocol level related with the version of the CVS pluggin.
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Suppress all dots
+	from the tmpdir due to problems on Windows
+
+	* source/cmt_cvs.cxx (class CvsImplementation): Add support for
+	struture_info and subprojects coming from the new CVS pluggin
+
+	* source/cmt_parser.cxx (do_cvssubprojects): Handle the
+	cvssubprojects command
+	(parser): Commands related with CVS should at least read the
+	requirements file of CMT
+
+	* source/cmt_parser.h (enum): Add cvssubprojects action
+
+	* source/cmt_commands.cxx (CommandHelp): Add help for
+	cvssubprojects command
+
+	* source/cmt_commands.cxx (do_cvssubprojects): Accept empty
+	argument to query for subprojects at top of the repository
+
+	* source/cmt_commands.cxx (do_cvssubpackages): Accept empty
+	argument to query for subpackages at top of the repository
+
+	* source/cmt_commands.cxx (ArgParser): Manage cvssubprojects command.
+
+	* source/cmt_commands.h (class ArgParser): Add cvssubprojects command
+
+	* source/cmt_use.cxx (fill_standard_macros): Production of a new
+	standard macro for obtaining the project releases
+
+	* source/cmt_cvs.h (class Cvs): Add the subprojects function to
+	query CVS about the existing subprojects of a given module.
+
+2005-04-23  Christian Arnault  <arnault@lal.in2p3.fr> 269
+
+	* source/cmt_project.h (class Project): container and
+	container_version access methods
+
+	* source/cmt_project.cxx (container_action): Implementation of the
+	container statement
+
+	* source/cmt_project.h (class Project): Add handling of the container statement
+
+	* source/cmt_syntax.cxx (class KwdContainer): Add support of the
+	project container package
+	(SyntaxParser): idem
+
+2005-04-21  Christian Arnault  <arnault@lal.in2p3.fr> 268
+
+	* source/cmt_project.cxx (create_project): Check pwd for finding
+	projects.
+
+	* source/cmt_symbol.cxx (find_path_entry): Look for existing PATH
+	entries by comparing the real path rather than the logical
+	path. Use pwd everywhere (or CmtSystem::compress_path when the
+	path is not exactly found)
+	
+
+2005-04-14  Christian Arnault  <arnault@lal.in2p3.fr> 267
+
+	* source/cmt_system.cxx (class CMTPathManager): CMTUSERCONTEXT and
+	CMTHOME environments give a specific name to the associated
+	project.
+
+	* source/cmt_project.cxx (create_project): Fixing the project
+	naming scheme. Project name specified in the project files take
+	precedence over the names found in the path.
+
+2005-04-13  Christian Arnault  <arnault@lal.in2p3.fr> 266
+
+	* source/cmt_commands.cxx (do_cvstags, do_cvssubpackages): Fix arg counting.
+
+2005-04-12  Christian Arnault  <arnault@lal.in2p3.fr> 265
+
+	* source/cmt_project.cxx (create_project): Restructure the
+	algorithm for detection of project structuring cases. Construct a
+	finite list of cases.
+	(has_parent): Implement recursive query function
+	(has_child): Implement recursive query function
+	(add_parent, add_child): Use the recursive detection to avoid cycles.
+
+	* source/cmt_project.h (class Project): Add has_parent and
+	has_child functions to protect against recursive cycles
+
+2005-04-02  Christian Arnault  <arnault@lal.in2p3.fr> 264
+
+        * source/cmt_version.h (CMTVERSION): Prepare for v1r18p20050401
+
+	* mgr/requirements: use ln -fs for cmt_installarea_command
+
+2005-03-31  Christian Arnault  <arnault@lal.in2p3.fr> 263
+
+	* doc/ReleaseNotes: prepare release notes
+	
+	* source/cmt_project.cxx (create_project): Fix settings of the project name.
+
+2005-03-30  Christian Arnault  <arnault@lal.in2p3.fr> 262
+
+	* mgr/NMake (demo): Adapt to the new syntax of cmt create_project
+
+	* source/cmt_project.cxx (create_project): Suppress several warnings
+
+2005-03-30  Christian Arnault  <arnault@lal.in2p3.fr> 261
+
+	* doc/table.html: Install link to the Trac bug reporting system.  
+
+2005-03-30  Christian Arnault  <arnault@lal.in2p3.fr> 261
+
+	* source/cmt_project.cxx (create): The create function now creates
+	the complete directory hierarchy for the project including the
+	release level(s). Can accept a path.
+	(create_project): Don't assume a release level.
+
+	* source/cmt_project.h (class Project): The create function now
+	accepts a release and a path argument
+
+	* source/cmt_commands.cxx (show): Suppress debug printouts
+	* source/cmt_parser.cxx (do_help): Suppress debug printouts
+
+	* source/cmt_system.cxx (is_version_directory): Accept HEAD/head as a valid version directory.
+
+2005-03-30  Christian Arnault  <arnault@lal.in2p3.fr> 260
+
+	* doc/CMTDoc.xml: work on the doc (unfinished)
+
+	* source/cmt_project.cxx (use_action): The name specification of a
+	project use statement is used to create the project.
+ 
+	* source/cmt_project.cxx (create_project): Implement the algo to
+	construct or discover the real project name and release from the
+	context. The new algo supports release specifications as a
+	multi-level directory definition.
+
+	* source/cmt_project.cxx (get_release_from_path): Function to
+	retreive the release sub-string from a path, given the project
+	name.
+
+	* source/cmt_project.h (class ProjectFactory): Add the project
+	name as first argument to the create_project function.
+
+	* source/cmt_system.cxx (class CMTPathManager): when specified
+	from a CMTPATH item, the project creation has to guess the project
+	name.
+
+	* mgr/Makefile (gendoc): Suppress the | output modifier
+
+2005-03-16  Christian Arnault  <arnault@lal.in2p3.fr> 259
+
+	* mgr/fragments/dependencies: We need to reconsider all sources to
+	recompute all dependencies that may have changed due to
+	configuration changes. Thus the -all_sources is added
+
+2005-03-15  Christian Arnault  <arnault@lal.in2p3.fr> 258
+
+	* source/cmt_parser.cxx (clear): Add m_autoconfigure_cmtpath
+	variable to discard autoconfiguration of CMTPATH during initial
+	phases of the configuration.
+	
+	(guess_current_project): Once the current project is known, the
+	CMTPATH is re-generated from the effective knowledge of the
+	project graph.
+
+	(do_setup): Add a check of the configuration when doing cmt setup
+
+	(do_check_configuration): analyze the tags coming from arguments
+	or from CMTSITE to detect mistypings. This is done by checking the
+	effective usage of those tags.
+
+	(configure_cmt_path): Analyze CMTPATH from either the symbol value
+	or from the EV, before asking the project factory to create the
+	projects from it.
+
+	(get_strategy): Add a generic local function to query the strategy elements.
+
+	* source/cmt_project.cxx (add): Manage conflicts between project
+	release requests on a strict basis (no wild card - exact match
+	only)
+
+	* source/cmt_project.h (class ProjectFactory): No longer need m_first and m_previous
+
+	* source/cmt_project.cxx (create_project): Implement a graph of projects.
+	(create_project): Interpret the first top level directory as the project release
+	
+	(create_project): Interpret the second top level directory as the
+	project name when it's not defined in the project file. So we
+	don't create a dummy project name anymore Project<n>.
+
+	* source/cmt_commands.cxx (ArgParser): Suppress obsolete +path option
+	(parse): Initialize the m_action value to none to fix a bad management of unknown commands
+	(do_filter): Implement the cmt filter command
+
+	* source/cmt_error.cxx (class Error): Add unknown_command and
+	project_release_conflict errors
+
+	* source/cmt_syntax.cxx (class KwdBuildStrategy): Apply the
+	restructuration of strategy management to strategy decoding
+
+	(class KwdSetupStrategy): idem
+	(class KwdUse): Support the use statement for project files
+	(SyntaxParser): Support the use statement for project files
+
+	* source/cmt_project.h (class StrategyDef): Create a class to hold
+	the definition of all strategy elements	
+	(class Strategy): Create a class to hold the application of a strategy into a project
+	(class StrategyMgr): Create a singleton to manage the strategy definitions
+	(class ProjectFactory): Add parent argument to create_project to handle the project graph
+	(class IProjectVisitor): Create a class to visit the project graph
+	(class Project): Transport all definitions related with strategies into Strategy objects
+
+	* source/cmt_system.cxx (class CMTPathManager): Add a class to
+	interact with the ProjectFactory to convert CMTPATH specifications
+	into projects
+
+	(get_cmt_paths): Suppress the setting from $CMTPATH. This is
+	replaced by a selective understanding of the source of CMTPATH
+	either from the symbol (when defined in a requirements file) or
+	from the EV. This selection is performed in
+	Cmt::configure_cmt_path.
+
+	(get_cmt_paths): Suppress the definition of a CMTPATH entry for CMT itself
+
+2005-03-10    <arnault@lal.in2p3.fr> 257
+
+	* mgr/NMake (demo): Add project file to the demo context.
+
+2005-03-04  Christian Arnault  <arnault@lal.in2p3.fr> 256
+
+	* source/cmt_project.cxx: Ongoing work for redefining Project graphs. 
+
+2005-03-03  Christian Arnault  <arnault@lal.in2p3.fr> 255
+
+	* source/cmt_project.cxx (add): Manage project release conflicts.
+
+	* source/cmt_error.h (class CmtError): Add project_release_conflict error
+	* source/cmt_error.cxx (class Error): Add project_release_conflict error
+
+	* source/cmt_project.h (class Project): Introduce the management
+	of release information in projects
+
+	* source/cmt_parser.cxx (do_check_configuration): Finally suppress the checking of CMTCONFIG 
+	(do_setup): Add do_check_configuration to check some tag settings.
+
+2005-03-02  Christian Arnault  <arnault@lal.in2p3.fr> 254
+
+	* source/cmt_symbol.h (class Symbol): Add an optional argument to build_macro_value to switch display mode
+
+	* source/cmt_symbol.cxx (show_macro): Improve the display mode so as to display only once the macro construction steps
+
+	* source/cmt_parser.cxx (guess_current_project): Regenerate CMTPATH from the effective set of subprojects.
+
+	* source/cmt_commands.cxx (parse): Handle unexpected arguments
+
+	* source/cmt_error.cxx (class Error): Added unknown_command error
+	* source/cmt_error.h (class CmtError): Added unknown_command error
+
+	* source/cmt_commands.cxx (do_filter): Missing implementation for the filter command
+
+2005-03-01  Christian Arnault  <arnault@lal.in2p3.fr> 254
+
+	* source/cmt_tag.cxx (use_operand): Add way of checking internal structure of a tag
+	* source/cmt_tag.cxx (use_ref): Add way of checking internal structure of a tag
+	* source/cmt_tag.h (class Tag): Add way of checking internal structure of a tag
+	* source/cmt_symbol.h (class Symbol): Add way of checking if a tag is used by symbols.
+	* source/cmt_symbol.cxx (print): Suppress the "export" action after defining an alias in Sh mode
+	* source/cmt_project.cxx: Introduce use_action 
+	* source/cmt_syntax.cxx (SyntaxParser): Add support to use statements in project files
+	* source/cmt_project.cxx (create_project): Add comments
+
+2005-02-14  Christian Arnault  <arnault@lal.in2p3.fr> 253
+
+	* src/Makefile.header (common_target): mktemp refuses to create
+	subdirectory when TMPDIR specifies something different than /tmp
+	that does not exist yet.
+
+2005-02-07  Christian Arnault  <arnault@lal.in2p3.fr> 252
+
+	* source/cmt_system.cxx (scan_dir): Fix a bug that killed the cmt
+	show packages command in some cases
+
+2005-02-03    <arnault@lal.in2p3.fr> 251
+
+	* source/cmt_commands.cxx (do_cvstags): fix arg counting
+	* source/cmt_commands.cxx (do_cvssubpackages): fix arg counting
+
+2004-12-14    <arnault@lal.in2p3.fr> 250
+
+	* source/cmt_parser.cxx (class StandardMacroBuilder): Fix a bug
+	that caused a premature exit from the scan of constituents.
+
+2004-12-13    <arnault@lal.in2p3.fr> 249
+
+	* source/cmt_constituent.cxx (parse): Add a specific behaviour for
+	documents generated for actions so as to keep the action_value
+	definition unparsed.
+
+2004-12-03 <arnault@lal.in2p3.fr> 248
+
+	* mgr/fragments/nmake/library: apply patches from Pere about installing pdb files for Debug mode
+
+2004-12-01    <arnault@lal.in2p3.fr> 247
+
+	* source/cmt_version.h (CMTVERSION): Prepare for tagging v1r18p20041201
+
+	* source/cmt.h (class Cmt): Fix typo
+
+2004-12-01  Christian Arnault  <arnault@lal.in2p3.fr> 246
+
+	* mgr/cmt_uninstall_action.sh: Better management of directory removal
+
+2004-12-01  Christian Arnault  <arnault@lal.in2p3.fr> 246
+
+	* mgr/fragments/application (install): 
+	* mgr/fragments/library (install): 
+	* mgr/fragments/library_no_share (install): 
+	* mgr/fragments/install_includes_header (install): 
+	* mgr/fragments/jar (install): 
+	* mgr/fragments/java_header (install): Remove the connection
+	between uninstall and clean targets. So now when gmake clean is
+	run no uinstallation occurs in the installation area.
+
+2004-11-11    <arnault@lal.in2p3.fr> 245
+
+	* source/cmt_parser.h: 
+	* source/cmt_project.cxx: 
+	* source/cmt_project.h: 
+	* source/cmt_syntax.cxx: 
+	* source/cmt_parser.cxx: 
+	* doc/CMTDoc.xml: Suppress obsolete (and useless) makefile strategy
+
+	* source/cmt_parser.cxx (print_context): the setup strategy is
+	really used to generate the ROOT and CONFIG env. vars.
+
+	* source/cmt_parser.cxx (get_setup_strategy): Get the setup
+	strategy for each use so as to really build ROOT or CONFIG
+	according to the real project of the use
+
+2004-11-09    <arnault@lal.in2p3.fr> 244
+
+	* source/cmt_version.h: Preparing version tag for v1r18
+	
+	* mgr/requirements:
+	* source/cmt_parser.h:
+	* source/cmt_projects.cxx: Change default build strategy to without_installarea
+
+2004-11-08    <arnault@lal.in2p3.fr> 243
+
+	* mgr/Makefile (docs): Do some cleanup
+
+	* source/cmt_parser.cxx (do_build_library_links): make use of the
+	new library_install_command macro
+
+	* mgr/requirements: Create a new macro library_install_command for
+	defining how to actually install libraries through the
+	<package>_libraries macro.
+
+2004-11-02  Christian Arnault  <arnault@lal.in2p3.fr> 242
+
+	* source/cmt_commands.cxx (option_tag): When resetting tags one
+	need to also call again guess_current_project
+	
+	(option_tag): In fact on can simply reset all active tags, and
+	regenerate activations rather than clearing all tags.
+
+	* source/cmt_parser.cxx (guess_current_project): Fix a typo
+
+	* source/cmt_tag.cxx (get_default): Make the tag Default a static
+	object to avoid killing it.
+
+
+2004-11-01    <arnault@lal.in2p3.fr> 241
+
+	* source/cmt_parser.cxx (guess_current_project): Implement the
+	detection of the current project
+
+	* source/cmt_parser.cxx (configure): Add the detection of the
+	current project through a project file above the current directory
+
+2004-10-30  Christian Arnault  <arnault@lal.in2p3.fr> 240
+
+	* source/cmt_parser.cxx (class StandardMacroBuilder): Apply the
+	cmtpath_patterns before setting up the installarea parameters so
+	as to let the patterns really define the
+	<project>_installarea_prefix for instance.
+	
+	(set_standard_macros): Remove this first setting of installarea
+	because it's better done only once.
+
+	* mgr/fragments/constituent: Remove a debug message
+
+	* mgr/requirements: Prepare for new tag v1r18
+
+	* mgr/cmt_uninstall_action.sh: 
+	* mgr/cmt_install_action.sh: Late fixes
+
+2004-10-29    <arnault@lal.in2p3.fr> 239
+
+	* source/cmt_parser.cxx (set_standard_macros): Restructure the
+	StandardMacroBuilder to provide all steps.  Move upward the
+	fill_for_install_area to make all cmtpath_patterns applied before
+	manging other macros. This caused the include_dirs installed in a
+	cmtpath_pattern useless.
+
+	* source/cmt_list.h (class cmt_list): few fixes for CYGWIN
+
+	* mgr/requirements: CYGWIN tag implies Linux
+
+	* mgr/fragments/install_includes_header (uninstall): 
+	* mgr/fragments/java_header (install): 
+	* mgr/fragments/jar (install): 
+	* mgr/fragments/library_no_share (install): 
+	* mgr/fragments/library (install): 
+	* mgr/fragments/application (install): 
+	* mgr/cmt_install_action.sh: 
+	* mgr/cmt_uninstall_action.sh: Improve the argument passing scheme
+	to make it more flexible. Add an argument to get cmtpath, to check
+	it against pwd. However this should never occur since cmt itself
+	is supposed to never generate CMTNSTALLAREA when this is not
+	appropriate.
+
+	* source/cmt_install_area.cxx (setup_current_installarea): Consider <project>_installarea_prefix
+
+	* source/cmt_system.cxx (compress_path): Fix a bug: when detecting
+	the aaa/bbb/../ccc pattern, "bbb" cannot be ".." nor "." nor
+	contain a macro reference.
+
+2004-10-25    <arnault@lal.in2p3.fr> 238
+
+	* source/cmt_parser.cxx (do_run): Force the settings of EVs
+	before launching the run action
+
+	* source/cmt_parser.cxx (do_broadcast): Force the settings of EVs
+	before launching the bro action
+
+	* source/cmt_commands.cxx (do_run): The run command now transmits all arguments
+
+	* source/cmt_list.h: Prepare a list class for future use. This be
+	used to handle the constituent order mechanisms.
+
+	* mgr/Makefile: 
+	* mgr/NMake (post_build): Add a post_build step to re-generate the
+	cmt_dependencies.[n]make file (one version in mgr without the
+	stamps and one version in $(bin) with them)
+	
+	* source/cmt_generators.h (class DependencyGenerator): 
+	* source/cmt_generators.cxx (build): Add an option -no_stamps to
+	buid dependencies so as to generate a version of the dependency
+	files without the extra stamps specifications and with no stamp
+	file generation. This is need to generate the bootstrap dependency
+	file for cmt itself.
+
+	* source/cmt_generators.cxx: 
+	* source/cmt_generators.h (class DependencyGenerator): 
+	* source/cmt_generator.h (class CmtGenerator): Revisit the construction of dependencies files:
+	The dependencies file is split as one file fragment per dependency line (ie per file)
+	This dep fragment is installed into $(bin)/<constituent>/*.stamp
+	a dep to this stamp file is installed in the dependency line
+	the stamps file is only touched when it changes
+	All this to ensure that recompilations are done when anythin in th configuration is changed
+
+	* source/cmt_map.h (cmt_vmap): Introduce cmt_vmap to construct
+	maps of objects by value
+
+	* source/cmt.h (class Cmt): Restart of set settings can be
+	manually triggered. Typically to ensure that they are really set
+	just before launching an action
+
+	* mgr/cmt_make_shlib_common.sh (temp_shlib): Suppress the
+	automatic construction of bundles on Darwin
+
+	* source/cmt_system.cxx (add_cmt_path): Adding protections of
+	validity of CMTPATH entries
+
+	* source/cmt.h:
+	* source/cmt_parser.h:
+	* source/cmt_parser.cxx:
+	* source/cmt_command.h:
+	* source/cmt_command.cxx: Introducing classes for command line parsing
+	All decoding of the cmt command line arguments are transfered there.
+	The decoding is also rationalized.
+	actions can be seen as cmt command extensions
+	better preparing of EVs before running actions
+	prepare the Makefile default file before running actions
+	improve the generic management of options
+	* cmt.h: Introduction of the CmtContext class to hold global state variables
+	for Cmt. The Cmt class now only contains static functions.
+
+	* src/source: Major restructuring of the directories:
+	All real sources of cmt now go to ../source
+	../src only contains stuff that need to be exported
+	../fragments is transfered to mgr/fragments.
+
+	* doc/gendoc.py (Book.book_start): Produce the revision date of the documentation
+	Install the real version tag in the doc.
+
+	* doc/CMTDoc.xml: Improving the doc
+
+2004-10-17    <arnault@lal.in2p3.fr> 238
+
+	* mgr/cmt_make_shlib_common.sh: Suppress the systematic creation
+	of a bundle in Darwin context
+
+2004-09-28    <arnault@lal.in2p3.fr> 237
+
+	* src/cmt_system.cxx (compress_path): The algorithm must ignore
+	the following pattern: xxxx/$(mmm)/../yyyy which cannot be reduced
+	to xxxx/yyyy. In fact it nows expands the path when macros are in it
+
+2004-09-27    <arnault@lal.in2p3.fr> 237
+
+	* src/NMakefile.header (check_config): Ensure that configuration
+	checking is performed first.
+
+	* src/Makefile.header (check_config): Ensure that configuration
+	checking is performed first.
+
+	* src/cmt_use.cxx (need_new): Only display the incompatible case.
+
+	* src/cmt_use.cxx (reach_package): IncompatibleMajorIds is no
+	longer considered. Id comparison is no longer rejected in any
+	case.
+
+	* src/cmt_use.cxx (compare_versions): Really compare major ids. No
+	longer produce IncompatibleMajorIds
+
+	* src/cmt_use.cxx (enum): Add cases to completely analyze the major ids
+
+	* src/cmt_use.cxx (operate): 
+
+	* src/cmt_system.cxx (get_cmt_paths): Suppress the systematic
+	addition of $CMTROOT in CMTPATH items!
+
+	* src/cmt_awk.cxx (scan_path): really stop the too deep recursion
+
+2004-09-01    <arnault@lal.in2p3.fr> 236
+
+	* src/cmt_version.h (CMTVERSION): v1r16p20040901
+
+	* doc/ReleaseNotes.html: Prepare next tagging
+
+	* mgr/Makefile: Adapt for the new CMTBIN convention
+
+	* src/cmt_model.cxx (filter): Substitute <cmt:null/> only just
+	before printing for empty vector elements
+
+2004-08-31    <arnault@lal.in2p3.fr> 235
+
+	* doc/CMTDoc.xml: Improve the doc.
+
+	* src/cmt_model.cxx (strict_expand): Support parameter values enclosed in simple quotes 
+	Only display endl at the very end or recursion.
+
+	* src/cmt_project.cxx (configure): Fix typo in tag excludes
+
+2004-08-30  Christian Arnault  <arnault@lal.in2p3.fr> 234
+
+	* mgr/requirements: Keep 3 digits for the compiler version
+	* mgr/Makefile: augment support for SLC3 machines
+	* mgr/cmt_linux_version.sh: idem
+
+2004-08-30    <arnault@lal.in2p3.fr> 233
+
+	* doc/CMTDoc.xml: 
+	* doc/table.html: Install the reference to CeCILL licences
+	* doc/download.html: 
+	* doc/intro.html: 
+	* doc/copyright.html: 
+
+	* fragments/dependencies: Trigger the reconstruction of dependency
+	file when the setup changes.
+
+	* fragments/constituents_header (first): Do not ovverride
+	<package>_setup.make when identical. This permits its use as a
+	real stamp file to trigger reconstruction of dependency files.
+
+	* mgr/Makefile (cpp): Take into account the new convention for
+	CMTBIN (suffixed with `uname -m`)
+
+	* mgr/cmt_system.sh: improve the default value of CMTCONFIG on Cygwin
+
+	* mgr/requirements: Improve the cleaning and setting of PATH
+	vaiables WRT installation area strategy
+
+	* src/cmt_parser.cxx (dos_script_prefix): Standalone packages
+	don't need ..\.. in the -path option of DOS setup scripts
+
+	* src/setup.sh (CMTBIN): Suffix CMTBIN with `uname -m` on Unix machines
+	* src/setup.csh: idem
+
+2004-08-26    <arnault@lal.in2p3.fr> 232
+
+	* src/setup.bat: Suppress the rem--- lines
+	* src/demo/demoA/init.bat: Suppress the rem--- lines
+	* src/demo/demoB/init.bat: Suppress the rem--- lines
+
+2004-08-25  Christian Arnault  <arnault@lal.in2p3.fr> 231
+
+	* src/setup.tcsh: Fix typo
+
+	* src/cmt_license.sh: Add template file to include in a various sources (commented by hash signs)
+	* src/cmt_license.h: Add template file to include in a C++ source
+
+	* src/cmt_parser.cxx (do_expand_model): Add a -test internal
+	option to the expand model command to test regular expressions.
+
+	* src/cmt_regexp.cxx (match): a or_node matches the longest
+	 matching alternate patterns, instead of the first one.
+
+	* src/cmt_system.cxx (split): Detect \" and \' patterns and ignore
+	them as word separators. So a text containing "a b c" d e \"x\" will result in 4 fields
+	a b c
+	d
+	e
+	\"x\"
+
+	* src/cmt_model.cxx (strict_expand): Implement the strict model
+	expansion. The new syntax for definning model is:
+
+	<cmts:name att="value" ... />         for a single expansion
+	<cmtv:name att="v1 v2 v3 ..." ... />  for a multiple expansion
+
+	The element <cmt:null/> may be used in a vector value to specify an empty value.
+
+	name is the name of a declared make_fragment as usual.
+	
+
+2004-08-23  Christian Arnault  <arnault@lal.in2p3.fr> 230
+
+	* src/cmt_regexp.h (class cmt_regexp): Adding comparison operator
+	and extraction operator to regexp::iterator
+
+	* src/cmt_parser.cxx (do_expand_model): Parse the -strict option
+
+	* src/cmt_model.h (class CmtModel): Start designing the support
+	for stricter model expansion (to support model files in XML)
+
+	* src/cmt_license.txt: First introduction of the license text (obtained from CeCILL)
+
+	* src/Makefile.header (all): Evaluate the result of the cmt check
+	configuration and stop Make if it terminates in error.
+
+	* src/cmt_generators.cxx (analyze_file): Evaluate if the file
+	exists. Only generate its SourceFile if it exists or can be built
+	(build): Accumulate the file names only if they can be built.
+
+	* src/cmt_generators.h (class DocumentGenerator): Make
+	analyze_file return if the file is not found.
+	(class LibraryGenerator): idem
+
+	* src/cmt_parser.cxx (parser): Make the configure_error a fatal error.
+
+	* src/Makefile.header (common_target): Improve the tmpdir mechanisms. Support ${TMPDIR}
+
+	* src/cmt_parser.cxx (dos_script_prefix): Suppress the -quiet
+	option in the setup scripts now that errors are sent to stderr
+	instead of stdout.
+
+	* src/cmt_constituent.cxx (class constituents_action_iterator): Use cerr instead of cout
+
+	* src/cmt_fragment.cxx (copy): Use cerr instead of cout
+
+	* src/cmt_generators.cxx (java_file_action, build, build): Use cerr instead of cout
+
+	* src/cmt_parser.cxx (do_awk): typo
+	(do_filter, parse_arguments, parser): Use cerr instead of cout
+
+	* src/cmt_use.cxx (install_library, get_all_clients, operate): Use cerr instead of cout
+
+	* src/cmt_system.cxx (remove_file, remove_directory): Use cerr instead of cout
+
+	* src/cmt_tag.cxx (action_apply): Use cerr instead of cout
+
+	* src/cmt_symbol.cxx (create, build): Use cerr instead of cout
+
+	* src/cmt_pattern.cxx (action): Use cerr instead of cout
+
+	* src/cmt_syntax.cxx: general substitution of cout to cerr
+
+	* src/cmt_error.cxx (get_error_name): format text only
+	(print): Use cerr instead of cout
+
+	* src/cmt_lock.cxx (check): format text only
+
+2004-08-20  Christian Arnault  <arnault@lal.in2p3.fr> 229
+
+	* mgr/requirements: Protect the cmt_installare_linkopts against
+	ambiguous tag settings
+
+	* src/cmt_awk.cxx (scan_path): First compress the path before
+	calling the actual recursive scanner
+	(scan_path): Completely revisit the scan algorithm to better
+	account for directory structures and version.cmt files and package
+	statements.
+
+	* src/cmt_project.cxx (create_project): The project file parsing
+	must occur after setting the project chain. This caused wrong tag
+	propagation across the Project chain.
+
+2004-08-04  Christian Arnault  <arnault@lal.in2p3.fr> 228
+
+	* src/cmt_parser.cxx (do_create): use only compressed paths
+	(do_remove): idem
+
+	* src/cmt_use.cxx (get_cmtpath_and_offset): Need to compress the cmtpath to suppress .. patterns
+
+	* src/cmt_system.cxx (compress_path): Compress the pattern /xxx/.. or xxx/.. instead of xxx/../
+
+2004-07-01    <arnault@lal.in2p3.fr> 227
+
+	* src/cmt_version.h: Prepare tagging v1r16p20040701
+
+	* src\cmt_parser.h: idem
+
+	* src\cmt.h (class Cmt): Suppress version strategy
+
+	* src\cmt_parser.cxx (do_show_strategies): Suppress version strategy
+
+2004-06-30    <arnault@lal.in2p3.fr> 226
+
+	* src\cmt_version.h (CMTVERSION): Prepare tagging v1r16p20040630
+
+	* src/cmt_generator.cxx (class WinDefAwk): Better generation of .def files for DATA
+
+2004-06-24    <arnault@lal.in2p3.fr> 225
+
+	* src/cmt_use.cxx (need_new): fix a bug that impacted on the order of
+	compatible use requests with different specifications.
+
+	* src\cmt_symbol.cxx (build): Add a debug print
+	(SymbolValueList::show): only display actions with a non empty value
+
+	* src\cmt_use.cxx (add): improve the debug statements (no change to algo)
+
+	* mgr\requirements: Improve the removal operations for Windows in the cmtpath_patterns
+
+2004-06-12    <arnault@lal.in2p3.fr> 225
+
+	* src\cmt_parser.cxx (need_prototypes): Fix access to prototype mask of build strategy
+
+2004-05-28  Christian Arnault  <arnault@lal.in2p3.fr> 224
+
+	* Tagging v1r16p20040527
+
+	* src/demo/demo1.cmt: Add a test for -target_tag option
+
+	* src/cmt_parser.cxx (do_build_library_links): Transfered the code
+	to install a lib symlink into cmt_use.cxx
+
+	* src/cmt_use.cxx (same_dirs): Add a local helper function to
+	check if two directory specifications point to the same location
+	(install_library): Common local function to really create a
+	symlink to a file either into ../$(tag) or into $(CMTINSTALLAREA)/$(tag)/lib
+	(build_library_links): Build all the library links for a Use.
+
+	* src/cmt_use.h (class Use): Add a function to build the library links (the code is
+	extracted from Cmt::do_build_library_links () )
+
+2004-05-27    <arnault@lal.in2p3.fr> 223
+
+	* src\cmt_version.h (CMTVERSION): Prepare for real tagging v1r16p20040527
+	* doc\download.html: idem
+
+	* doc\CMTDoc.xml: Update the doc for the new -target_tag option
+
+	* src\cmt_constituent.cxx (add_for_action): Actions always have a target tag.
+
+	* src\demo\demoA\requirements: Add a -target_tag option to demoA target to test this feature.
+
+	* fragments\constituent: Construct or not a local tag makefile according to has_target_tag
+	* fragments\nmake\constituent: id
+	* fragments\make_header: id
+	* fragments\nmake\make_header: id
+
+	* src\cmt_generators.cxx (LibraryGenerator::build): 
+	(DocumentGenerator::build): Transmit m_HASTARGETTAG
+
+	* src\cmt_generator.cxx (reset): Initialize the new m_HASTARGETTAG variable.
+
+	* src\cmt_generator.h (class CmtGenerator): Add a m_HASTARGETTAG
+	Variable to propagate the target_tag ability of the constituents
+
+	* src\cmt_constituent.cxx (show): Display the -target_tag option
+	(class constituents_action_iterator): Parse the -target_tag option
+
+	* src\cmt_constituent.h (class Constituent): Add support for the
+	new -target_tag option, to control the per-constituent generation
+	of the target tag. So add a field has_target_tag
+	
+
+2004-05-25  Christian Arnault  <arnault@lal.in2p3.fr> 222
+
+	* mgr/requirements: Use $(tag) instead of ${CMTCONFIG} in all cmtpath_pattern s
+
+	* src/NMakefile.header (tags): idem
+	* src/Makefile.header (tags): idem
+	* fragments/nmake/make_header: idem
+	* fragments/nmake/constituents_header (tags): idem
+	* fragments/make_header (tags): idem
+	* fragments/constituents_header (tags): prefix the tags macro with $(tag)
+
+2004-05-25    <arnault@lal.in2p3.fr> 221
+
+	* src\cmt_version.h (CMTVERSION): Prepare for tagging v1r16p20040525
+
+	* mgr\NMake (gendoc): Add a new target to generate html from xml
+
+2004-05-25    <arnault@lal.in2p3.fr> 220
+
+	* mgr\NMake (cmttag): Convert VisualC.nmake into VisualC_cmt.nmake
+	* fragments\nmake\constituent: Generate tag file for the target
+
+2004-05-18    <arnault@lal.in2p3.fr> 219
+
+	* mgr\requirements: Add cmt_log.cxx in the source list
+
+	* src\cmt_tag.cxx (add): First replacements of debug messages using log
+	* src\cmt_parser.cxx (configure_tags): idem
+
+2004-05-18    <arnault@lal.in2p3.fr> 219
+
+	* src\cmt_log.h (class CmtLog): Introducing a centralized log message facility
+	* src\cmt_log.cxx: first implementation
+
+2004-05-18  Christian Arnault  <arnault@lal.in2p3.fr> 218
+
+	* fragments/nmake/make_header (tags): idem
+
+	* fragments/nmake/constituent: Update to generate the target_XXX tag
+
+	* src/cmt_parser.cxx (parse_arguments): Activate the tag target_<action> when "cmt do <action>" is run
+
+	* fragments/constituent: Generate the target_${CONSTITUENT} tag
+
+2004-05-17  Christian Arnault  <arnault@lal.in2p3.fr> 218
+
+	* fragments/constituent: Propagate cmt_lock_pid for temporary files
+	Generate a tag makefile specific to the constituent
+
+	* fragments/constituents_header (first): Improve the printout for CMTCONFIG
+
+	* fragments/make_header (tags): Generate the target_${CONSTITUENT} tag
+
+	* mgr/requirements: Don't generate the tags macro from CMT. Only do it from the Makefile fragments.
+
+	* src/cmt_generators.cxx (build): Add PACKAGE variable to individual constituent fragment
+
+2004-05-13  Christian Arnault  <arnault@lal.in2p3.fr> 217
+
+	* fragments/constituent: idem
+
+	* fragments/constituents_header (cmt_final_setup): Implement a READONLY mode that generates all intermediate files in /tmp/CMT_*
+
+	* src/Makefile.header (tags): Implement a READONLY mode that generates all intermediate files in /tmp/CMT_*
+	(common_target): Make use of the new -out=file option of the cmt build constituents_makefile command
+
+	* src/cmt_generator.cxx (build_constituents_makefile): idem
+
+	* src/cmt_generator.h (class Generator): Add the argument list to the build_constituents_makefile function
+
+	* src/cmt_generators.cxx (build): idem
+
+	* src/cmt_generators.h (class ConstituentsMakefileGenerator): Add the argument list to the build function
+
+	* src/cmt_parser.cxx (configure): Chain configure_home, configure_user_context and configure_cmtpat
+	(do_build_constituents_makefile): Propagate arguments to the Generator::build_constituents_makefile method
+	(parse_arguments): Accumulate extra-arguments for build constituents_makefile command
+	(parse_arguments): Restore the home,user_context and cmtpath configurations for the -tag=xxx option
+
+	* src/cmt_project.cxx (set_build_strategy): Get tags from their names rather than from their pointer to fix a pointer bug
+	(set_setup_strategy): idem
+
+	* src/cmt_tag.cxx (action_apply): Adding several debug printouts
+
+2004-05-10    <arnault@lal.in2p3.fr> 216
+
+	* doc\CMTDoc.xml: Add a section on package semantics
+
+2004-05-07  Christian Arnault  <arnault@lal.in2p3.fr> 215
+
+	* mgr/requirements: Improve support for CEL
+	Upgrade system_version_query_command for Darwin
+
+2004-05-06  Christian Arnault  <arnault@lal.in2p3.fr> 215
+
+	* src/cmt_tag.cxx (action_apply): apply_tag now supports the tag
+	name given through a symbol expression
+
+	* mgr/cmt_linux_version.sh: Support for Entreprise Linux
+
+	* mgr/requirements: Create automatic tags from cmt_hardware
+	cmt_system_version and cmt_compiler_version.
+	Set the macro shlibsuffix for Win32
+
+	* mgr/cmt_filter3_version.sh: Add a filtering procedure to keep 3 digits in the compiler version
+
+2004-05-05  Christian Arnault  <arnault@lal.in2p3.fr> 214
+
+	* src/cmt_syntax.cxx (parse_requirements): Close all scope sections once the requirements file is parsed.
+
+	* src/cmt_use.cxx (close_scope_sections): Implement by clearing the vector of scope sections.
+
+	* src/cmt_use.h (class Use): Add close_scope_sections to be called
+	at the end of parsing a requirements file.
+
+2004-05-03  Christian Arnault  <arnault@lal.in2p3.fr> 213
+
+	* doc/ReleaseNotes.html: Fix typo
+
+	* src/cmt_system.cxx (is_version_directory): Misunderstands
+	version specifications of the form v1r2p (without a trailing
+	number)
+
+2004-05-03  Christian Arnault  <arnault@lal.in2p3.fr> 212
+
+	* src/cmt_parser.cxx (configure): Configure home and user_context
+	before configuring cmtpaths to associate projects with CMTHOME and
+	CMTUSERCONTEXT
+	(configure_cmt_path): Reset the project factory before creating all projects
+	(configure_user_context): Add a debugging printout
+
+	* src/cmt_system.cxx (get_cmt_paths): Remove the initialization of
+	the project factory from there to transfer it to the caller (eg
+	cmt_parser::configure_cmt_path)
+
+	* src/cmt_parser.cxx (use_special_requirements): Expects a
+	statically defined version "v0" for all special uses.
+
+	(configure_cmt_path): Associate a project with CMTHOME and CMTUSERCONTEXT to manage strategies.
+
+	* src/cmt_use.cxx (show_all): Adapt to new naming convention:
+	display the static version explicitly.
+
+	* src/cmt_system.cxx (get_home_package): Convert CMTHOME package
+	name from "CMTHOME context" to CMTHOME and manage a version
+	through standard mechanisms (version is statically defined as v0)
+	(is_home_package): Adpat to new naming convention
+	(get_user_context_package): Idem for CMTUSERCONTEXT
+	(is_user_context_package): Adapt to new naming convention
+
+2004-04-30  Christian Arnault  <arnault@lal.in2p3.fr> 211
+
+	* mgr/cmt_install_action.sh: Use /bin/pwd instead of raw pwd [Thanks to Traudl]
+	* mgr/cmt_uninstall_action.sh: idem
+	* mgr/cmt_make_shlib.sh: idem
+	* mgr/cmt_make_shlib_common.sh: idem
+	* fragments/install_includes_header: idem
+
+	* mgr/requirements: Perform path_remove all before path_prepend in
+	the cmtpath_pattern. Thus state two separate cmtpath_patterns.
+
+2004-04-02    <arnault@lal.in2p3.fr> 210
+
+	* src\cmt_project.cxx (scan_paths): Late patch for LynxOS limitation
+
+	* src\cmt_version.h: Prepare for v1r16
+
+2004-03-29    <arnault@lal.in2p3.fr> 209
+
+	* mgr/Makefile: Set compiler options for CYGWIN
+
+2004-03-27  Christian Arnault  <arnault@lal.in2p3.fr> 208
+
+	* src/cmt_syntax.cxx (class KwdSetupStrategy): Implement setup strategy decoding for projects
+
+2004-03-27  Christian Arnault  <arnault@lal.in2p3.fr> 207
+
+	* src/cmt_system.h (class IProjectFactory): Suppress the configure entry point
+
+	* src/cmt_system.cxx (get_cmt_paths): see below
+
+	* src/cmt_project.h (class ProjectFactory): No longer need to configure from ProjectFactory
+
+	* src/cmt_project.cxx (configure): Fix typo mixing prototypes and no_prototypes tags
+	(add): Systematically create tags just after naming the project.
+
+	* src/cmt_project.h (class Project): Only create tags once
+
+	* src/cmt_syntax.h (class SyntaxParser): Introduce the different
+	syntax parsing schemes for requirements files and projects files.
+	(class SyntaxParser): Rename do_parse_requirements_text and
+	do_parse_requirements_text into do_parse_text and do_parse_line.
+
+2004-03-27  Christian Arnault  <arnault@lal.in2p3.fr> 206
+
+	* src/cmt_syntax.cxx (action): Define a default implementation for project actions
+	(class KwdBuildStrategy): Define a project action
+	(class KwdProject): idem
+	(class KwdSetupStrategy): idem
+
+	* src/cmt_syntax.h (class Kwd): Introduce an action for project files (simply virtual)
+	(class SyntaxParser): Restructure, cleanup and sort the entry points
+	(class SyntaxParser): Introduce a map of project keywords
+
+	* src/cmt_project.cxx (class ProjectReader): Start support for more statements in the project file
+
+	* src/cmt_pattern.cxx (action): Augment the decoding logic to be more fault tolerant 
+	(add): Temporarily force the word quoting
+	Add various debuggin printouts
+
+	* src/cmt_parser.cxx (parser): Force the Use* argument type
+
+	* src/cmt_cvs.cxx (class CvsImplementation): Install a constructor for setting default values
+	(class CvsImplementation): Set default verse mode to false
+
+2004-03-24  Christian Arnault  <arnault@lal.in2p3.fr> 206
+
+	* src/cmt_cvs.cxx (class CvsImplementation): Reset default verbose mode to off.
+
+2004-03-23  Christian Arnault  <arnault@lal.in2p3.fr> 205
+
+	* src/cmt_pattern.cxx (class PatternCache): Introduce a cache for
+	the get_paths operation. To save recursive executions.
+
+	* src/cmt_pattern.h (class PatternList): Navigate in pattern list through PatternList
+
+	* src/cmt_vector.h (cmt_vector): Trying to optimize vector by changing the frame size
+
+	* doc/cmt-mode.el (cmt-mode-map): Revert completion key to <Esc>-<tab>
+
+2004-03-22  Christian Arnault  <arnault@lal.in2p3.fr> 205
+
+	* src/cmt_symbol.cxx (resolve_value): Optimize by checking if $%` exist in the text to expand.
+	(create): Missing "alias" case
+
+	* src/cmt_parser.cxx (do_show_action): Missing "alias" case
+	(do_show_macro): idem
+
+	* src/cmt_project.cxx (clear): Improve the clear function to
+	ensure a proper initialization
+
+	* src/cmt_system.cxx (get_home_directory): Use ::getenv rather than CmtSystem::getenv.
+
+2004-03-19  Christian Arnault  <arnault@lal.in2p3.fr> 205
+
+        * doc/emacs.html: doc on the new emacs mode for CMT
+	* doc/table.html: include emacs.html
+
+2004-03-19  Christian Arnault  <arnault@lal.in2p3.fr> 204
+
+	* src/cmt_symbol.cxx (all_set): Only set non empty environment variables 
+
+2004-03-22    <arnault@lal.in2p3.fr> 203
+
+	* src\cmt_parser.cxx (get_build_strategy): Create a local helper
+	function to retrieve the build strategy from the current project.
+	(get_setup_strategy): Idem for the setup strategy
+	(parse_arguments): Add a protection against the killing -tag= with empty argument.
+	(reach_current_package): Specify the use object (current use)
+	(class StandardMacroBuilder): Isolate the construction of the CMTVERSION macro into a function
+	(class StandardMacroBuilder): Setting of basic standard macros
+	specific to packages is transfered to Use::fill_standard_macros
+	(set_standard_macros): Apply all cmtpath_patterns independently of the build strategy.
+
+	* src\cmt_symbol.cxx (action): Expand the tag name to permit tag
+	expressions containing macros.
+
+	* src\cmt_syntax.cxx (parse_requirements): Define the standard
+	macros before reading the requirements file.
+
+	* src\cmt_use.cxx (fill_standard_macros): Implement it (move code from cmt_parser.cxx)
+	* src\cmt_use.h (class Use): Add fill_standard_macros function to
+	fill in all standard macros for a given use before reading its
+	requirements file.
+
+	* mgr\requirements: Add exclusions between basic tags
+	Adapt cmtpath_pattern to new strategy management 
+
+	* fragments\nmake\constituents_header (tags): id.
+	* fragments\nmake\constituent: id.
+	* fragments\constituent: Add -quiet to CMT command.
+
+2004-03-19    <arnault@lal.in2p3.fr> 203
+
+	* src\cmt_parser.cxx (get_build_strategy): Install a local
+	accessor function to get the build strategy either from the
+	current project or from m_current_build_strategy.
+
+2004-03-16    <arnault@lal.in2p3.fr> 202
+
+	* src/cmt_parser.cxx (fill_for_branches): Add a protection against empty current project
+
+	* src\cmt_system.cxx (get_cmt_paths): Make use of the new
+	CmtSystem::get_home_directory function
+
+	* src\cmt_parser.cxx (class CmtMountFilterParser): Create a FAwk
+	parser to decode mout_filter files.
+	(configure_current_dir): Make use of the CmtMountFilterParser
+	class to parse cmt_mount_filter and .cmtrc files.
+
+	* src\cmt_system.cxx (get_home_directory): Implementation.
+
+	* src\cmt_system.h (class CmtSystem): Introduced to get ${HOME} in
+	a portable way
+
+2004-03-03  Christian Arnault  <arnault@lal.in2p3.fr> 201
+
+	* src/cmt_parser.cxx (print_context): Use the new projet based setup strategy
+
+	* src/cmt_cvs.cxx: suppress some verbose printouts
+
+2004-02-25    <arnault@lal.in2p3.fr> 200
+
+	* src\cmt_pattern.cxx (action): add use to warning messages
+
+	* doc\CMTDoc.xml: improvements
+
+	* doc\gendoc.py (Book.book_start): Set a padding on top of every rule
+
+	* src\cmt_cmtpath_pattern.h (class CmtPathPattern): No need to duplicate the vector of words.
+
+	* src\cmt_cmtpath_pattern.cxx (add): Construct the cmt statement as a one line statement
+
+	* src\cmt_cmtpath_pattern.h (class CmtPathPattern): Add an expansion line in the class
+
+	* src\cmt_pattern.cxx (add): Construct the cmt statement as a one line statement
+	(expand): Create a temporary replacement for full line
+	(action): relax the syntax by permitting spaces around the "=" sign. 
+	Add checks for the template name to be expected by the pattern.
+
+	* src\cmt_pattern.h (class Pattern): Add an expansion line in the class
+
+2004-02-19    <arnault@lal.in2p3.fr> 200
+
+	* src\cmt_project.cxx (configure): Preset the tags of the default strategies 
+
+	* src\cmt_tag.cxx (show_definition): Suppress the display of the internal Default tag
+
+2004-02-13    <arnault@lal.in2p3.fr> 200
+
+	* src\cmt_parser.cxx (class StandardMacroBuilder): Fill <package>_project macro
+	(class StandardMacroBuilder): Fill <package>_project macro
+
+	* src\cmt_project.cxx (get_current): No need to cd
+
+2004-02-13  Christian Arnault  <arnault@lal.in2p3.fr> 199
+
+	* src/cmt_symbol.cxx: implement the XxxRemoveRegexp
+
+	* src/cmt_parser.cxx: idem
+	* src/cmt_constituent.cxx: idem 
+	* src/cmt_symbol.cxx: idem
+	* src/cmt_symbol.h (class Symbol): Change the action stored in Symbol into a new enum SymbolType.
+
+	* src/cmt_symbol.cxx: idem
+	* src/cmt_syntax.cxx (SyntaxParser): idem
+	* src/cmt_parser.h (enum): Introduce regexp-based remove operations for symbols
+
+2004-02-10  Christian Arnault  <arnault@lal.in2p3.fr> 198
+
+	* src/cmt_parser.cxx (actor): Rename PackageCollector into ClientCollector
+
+2004-02-09  Christian Arnault  <arnault@lal.in2p3.fr> 198
+
+	* fragments/installer: add a / everywhere for consistency
+
+	* src/cmt_symbol.cxx (build): Restrict warning on symbol overriding to show macro and show set
+
+2004-02-13    <arnault@lal.in2p3.fr>
+
+	* doc\CMTDoc.xml: Work on the doc towards v1r16
+
+	* doc\gendoc.py (Book.plain_char_data): Keep space characters from raw text
+	(Book.book_start): Introduce style sheet.
+
+2004-02-06  Christian Arnault  <arnault@lal.in2p3.fr> 197
+
+	* src/cmt_cvs.cxx (class CvsImplementation): use -quiet for all internal cmt commands
+
+	* src/cmt_string.cxx (erase): Replace strcpy by an explicit loop
+
+	* src/cmt_cvs.cxx: Added -n and -v options to support simulation and verbose modes
+
+	* src/cmt_system.cxx (execute): Change the status value. Back to the Unix standard 0 = ok
+
+	* fragments/nmake/library: idem
+	* fragments/library: Install the dependency to the ${CONSTITUENT}stamps macro like for application
+
+	* src/cmt_system.cxx (reduce_file_separators): Improve the reduction algorithm
+
+2004-02-05    <arnault@lal.in2p3.fr> 196
+
+	* src\cmt_parser.cxx: Remove cmtpath database from Cmt class
+	Rename FileScanner into PathScanner and transfer it to CmtSystem
+	(configure_cmt_path): Use the ProjectFactory to create Projects from CMTPATH
+	(do_broadcast): Projects now fill the selections.
+	(do_show_clients): Projects used to search clients
+	(do_show_packages): idem
+	(do_show_path): idem
+	(do_show_strategies): Projects reached to get strategies
+	(do_show_versions): Projects used to search versions
+	(parse_arguments): +path managed by adding a project
+	(reach_current_package): Definitively suppress "current package" source of CMTPATH
+
+	* src\cmt_use.cxx (class UseProjectAction): Intoduce an action
+	pattern to iterate into Project database
+	(move_to): Use the Project::broadcast mechanism to locate the package.
+
+	* src\cmt_use.h (class Use): Make UseProjectAction friend of class Use
+
+	* src\cmt_system.cxx (add_cmt_path): 
+	(add_cmt_paths_from_text): 
+	(add_cmt_paths): 
+	(get_cmt_paths): Use IProjectFactory
+
+	* src\cmt_system.h (class IProjectFactory): Add abstract interface
+	for creating projects form cmtpath entries
+	(class CmtSystem): Change the API to using IProjectFactory
+
+	* src\cmt_project.cxx: Implement project management
+
+	* src\cmt_syntax.cxx (class KwdBuildStrategy): 
+	(class KwdSetupStrategy): Change strategies from new masks and into Projects
+
+	* src\cmt_parser.h (enum): Change the masks for strategies to
+	improve the reliability of exclusive options, and inheritance
+	between projects.
+
+	* src\cmt_cmtpath_pattern.cxx (class CmtPathPatternProjectAction):
+	Introduce new actor pattern for broadcasting to project
+	database. Used to apply all cmtpath_patterns
+	(apply): Expand the <project> parameter
+	(expand): idem
+
+	* src\cmt_cmtpath_pattern.h (class CmtPathPattern): Add project argument to expand
+
+	* src\cmt_awk.h (class PathScanner): Add the PathScanner class (imported from cmt_parser.cxx)
+	* src\cmt_awk.cxx (PathScanner): 
+
+	* src\cmt.h (class Cmt): Transfer cmtpath management to Project
+
+	* doc\CMTDoc.xml: 
+	* src\cmt_syntax.cxx (class KwdBuildStrategy): 
+	* src\cmt_project.h (class Project): 
+	* src\cmt_project.cxx (set_build_strategy): 
+	* src\cmt_parser.cxx (set_standard_macros): Rename X_install_area symbols into X_installarea
+	* src\cmt_install_area.cxx: Rename X_install_area symbols into X_installarea 
+	* src\cmt_install_area.h: Rename X_install_area symbols into X_installarea 
+
+	* mgr\requirements: Setting Project-oriented settings for installation area patterns.
+
+2004-01-27    <arnault@lal.in2p3.fr> 195
+
+	* fragments\nmake\installer: Fixes from Pere.
+
+2004-01-20    <arnault@vmlinux> 194
+
+	* Try on CVStrac ticket #1
+
+	* src/cmt_symbol.cxx (action): Ensure that the constituents macro is always private.
+
+	* src/cmt_parser.cxx (reach_current_package): Fix missing configuration bit.
+	Cures the bug of missing <PACKAGE>VERSION when using cmt -use=...
+
+2004-01-17    <arnault@lal.in2p3.frARNAULT@NB-ARNAULT> 193
+
+	* src\cmt_syntax.cxx (CommandParser): Add helps for create_project command
+
+	* src\cmt_parser.h (enum): Add action_create_project
+
+	* src\cmt.h (class Cmt): Add do_create_project function 
+
+2004-01-13    <arnault@vmlinux> 192
+
+	* src/cmt_parser.cxx (dos_script_prefix): Suppress spaces before
+	continuation character in DOS format
+
+2004-01-13  Christian Arnault  <arnault@lal.in2p3.fr> 191
+
+	* src/cmt_symbol.cxx (add_value_to_list): Fix for not discarding too much value_lists
+
+2004-01-10    <arnault@vmlinux> 190
+
+	* src/cmt_syntax.cxx (class KwdBuildStrategy): Start getting the
+	strategy from project(experimental??)
+
+	* src/cmt_project.cxx (find_by_cmtpath): We also accept paths specified using a substring
+	(configure): Configure in reverse order
+	(action): Add experimental -index and -select options
+
+	* src/cmt_install_area.cxx (setup_current_install_area): Make CMTINSTALLAREA a macro instead of a set
+
+2004-01-08  Christian Arnault  <arnault@lal.in2p3.fr> 189
+
+	* src/cmt_use.cxx (reach_package): Fix bug in version comparison when working in non-version-directory mode
+	* mgr/requirements: use $(CMTCONFIG) instead of $(tag) for setting PATH etc.. in cmtpath_pattern
+
+2003-12-19  Christian Arnault  <arnault@lal.in2p3.fr> 188
+
+	* src/cmt_use.h (class Use): Remove the project relationship between Use and Project
+
+2003-12-18    <arnault@lal.in2p3.fr> 187
+
+	* src\cmt_constituent.h (class Constituent): 
+	* src\cmt_constituent.cxx (add_for_action): Implement the constituent equivalent to actions
+	(parse_all): Generate the constituent equivalents for all macros
+
+	* fragments\cmt_action_runner: 
+	* fragments\cmt_action_runner_header: 
+	* fragments\nmake\cmt_action_runner_header: The new generic make fragment for running actions
+
+	* fragments\nmake\dependencies: 
+	* fragments\dependencies: Suppress dependency computation when the
+	QUICK macro is defined
+
+	* fragments\nmake\library: 
+	* fragments\library: 
+	* fragments\application: 
+	* fragments\nmake\application: Add dependency to requirements to rebuild application
+
+	* src\cmt_parser.cxx (do_config): Suppress install area cleanup action from cmt config
+	(do_setup): idem
+
+2003-12-16    <arnault@lal.in2p3.fr> 187
+
+	* src\cmt_constituent.cxx (class constituents_action_iterator):
+	Added syntax check on -xxx options for constituents
+
+	* src\cmt_parser.cxx: Implement Action support.
+	Added: (to support Actions)
+		do_do
+		do_show_action
+		do_show_action_names
+		do_show_action_value
+		do_show_actions
+	removed: (after introducing Scope Sections)
+		get_scope
+		set_scope
+		m_scope
+
+	* src\cmt_parser.h (enum): Added 
+		CommandAction
+		CommandEndPrivate
+		CommandEndPublic
+
+		action_show_action_xxx
+
+	* src\cmt_constituent.cxx (class constituents_action_iterator):
+	Added a syntax checking action.
+
+	* src\cmt_use.cxx:
+	* src\cmt_use.h (class Use): Support Scope Section concept.
+	A Use object holds a vector of ScopeSections
+	Added functions
+		push_scope_section
+		pop_scope_section
+		get_current_scope
+	Changed attributes:
+		scope -> initial_scope
+
+	* src\cmt_syntax.cxx (class KwdAction): New keyword
+	(class KwdEndPrivate): new keyword
+	(class KwdEndPublic): new keyword
+	(class KwdPrivate): Ignore this pattern on current use
+	(class KwdPublic): Ignore this pattern on current use
+	(CommandParser): Update help texts for new action concepts
+
+	* src\cmt_symbol.cxx (class ActionBuilder): new Action objects are
+	implemented as a new category of symbols. Therefore all mechanisms
+	have been extended to support the new concept.
+
+	old scope attribute is replaced by accesses to Scope Sections from
+	the Use objects.
+
+	* src\cmt_symbol.h (class Symbol): Suppress useless scope attribute and valid () function
+
+	* src\cmt_scope_section.cxx: New Support for Scope Sections
+
+	* src\cmt_scope_section.h: New Support for Scope Sections
+
+	* src\cmt_fragment.cxx (action): Switch to using Scope Sections
+
+	* src\cmt.h (class Cmt): Added: (to support Actions)
+		do_do
+		do_show_action
+		do_show_action_names
+		do_show_action_value
+		do_show_actions
+	removed: (after introducing Scope Sections)
+		get_scope
+		set_scope
+		m_scope
+
+	* mgr\requirements: Adding support for Scope sections to handle
+	private or public sections. Now private and public sections can be
+	ended with the new keywords end_private and end_public. Ending
+	keywords switch back to the previous scope active before the most
+	recent opening keyword.
+
+	Adding cmt_scope_section.cxx to the sources of the cmt application.
+	
+
+2003-12-12  Christian Arnault  <arnault@lal.in2p3.fr> 186
+
+	* mgr/cmt_install_action.sh (a): Improve checking of pwd WRT CMTINSTALLAREA
+	* mgr/cmt_uninstall_action.sh (a): idem
+
+	* mgr/cmt_mount_filter: Restore definitions
+
+	* src/cmt_syntax.cxx (do_parse): Evolution of the requirements
+	file syntax: apply_pattern can be omitted (ie. pattern names are
+	understood as extensions to the basic CMT language)
+
+	* src/cmt_pattern.cxx (action): Add error detection when applying the wrong pattern name
+	Prepare for the next change of the syntax which accepts pattern names as plain CMT keywords
+
+	* src/cmt_parser.cxx (find_in_cmt_paths): Fix construction of the
+	<package>_cmtpath when symlinks exist along pwd
+
+2003-12-08  Christian Arnault  <arnault@lal.in2p3.fr> 186
+
+	* src/cmt_parser.cxx (do_build_library_links): Fix : should make
+	use of the library_prefix and suffix.
+
+2003-12-06   Christian Arnault  <arnault@lal.in2p3.fr> 185
+
+	* src\cmt_syntax.cxx (do_parse): When a keyword is not found,
+	expect an implicit pattern application.
+
+	* src\cmt_pattern.cxx (action): Add a protection against pattern not found
+	Support lines starting with pattern-name or with apply_pattern.
+
+2003-11-21  Christian Arnault  <arnault@lal.in2p3.fr> 185
+
+	* mgr/cmt_install_action.bat: Typo
+
+	* mgr/requirements: Typo in macro cmt_uninstalldir_action
+
+2003-11-20  Christian Arnault  <arnault@lal.in2p3.fr> 184
+
+	* src/cmt_version.h (CMTVERSION): Preparing new tag v1r14p20031120
+
+	* src/cmt_syntax.cxx (CommandParser): Help on cmt build CMT_pacman 
+
+	* src/cmt_parser.cxx (parse_arguments): Implement cmt build
+	CMT_pacman command to generate the effective pacman manifest file
+	for CMT.
+
+	* src/cmt.h (class Cmt): Add Cmt::do_build_CMT_pacman function
+
+	* src/cmt_parser.h (enum): Add cmt build CMT_pacman command
+
+	* src/setup.zsh: Upgrade zsh completion settings
+
+	* src/setup.tcsh: Upgrade tcsh completion settings
+
+	* fragments/group (all_groups): Add a new standard macro
+	$(<group>_dependencies) to specify global dependencies for a
+	group.
+
+	* fragments/constituents_trailer (binclean): Dont remove *.make* when cleaning.
+	Add a message for binclean.
+
+	* src/cmt_use.cxx (add): Improve the warning message for package not found
+	(reduce_path): Display the package path using a reusable format (used by show fragments)
+
+2003-11-19  Christian Arnault  <arnault@lal.in2p3.fr> 183
+
+	* src/cmt_constituent.cxx (class constituents_action_iterator): Empty group means no group.
+
+	* src/cmt_parser.cxx (install_library): Factor out the basic
+	operation for installing a library
+	(do_build_library_links): Make use of the new install_library
+	operation. Add special operation for Darwin to install bundles
+
+	* src/cmt_syntax.cxx (class KwdBuildStrategy): Fix cumulative settings of the strategies 
+	(class KwdSetupStrategy): idem
+
+	* mgr/cmt_make_shlib_common.sh: Add support to generate bundles for Darwin
+
+2003-11-14  Christian Arnault  <arnault@lal.in2p3.fr> 182
+
+	* src/cmt_install_area.cxx (setup): Continue setup even without current installation area
+	(config): Apply all cmtpath_patterns even  without current installation area
+	(build_current_install_area): Make use of Cmt::find_in_cmt_paths
+
+	* src/cmt_parser.cxx (configure_current_cmtpath): Make use of the
+	new find_in_cmt_paths function
+	(do_setup): Always call CmtInstallAreaMgr::setup even if current installation area is empty 
+	(find_in_cmt_paths): first implementation
+	(get_cmt_path_pwds): first implementation
+	(class StandardMacroBuilder::fill_for_use_cmtpath): Make use of the
+	new find_in_cmt_paths function
+
+	* src/cmt.h (class Cmt): Adding find_in_cmt_paths to locate a path
+	from all specified CMTPATH entries (considering the dual flavours
+	of each entry)
+	Adding get_cmt_path_pwds to access alternal values of cmtpath entries
+
+2003-11-12  Christian Arnault  <arnault@lal.in2p3.fr> 181
+
+	* fragments/nmake/constituents_trailer (binclean): Fix typo for Windows
+
+2003-11-06  Christian Arnault  <arnault@lal.in2p3.fr> 180
+
+	* mgr/CMT.pacman: Add generic pacman file. 
+	All instances of the "<version>" pattern need to be substituted by 
+	the effective version of CMT to make it a real pacman file
+
+2003-10-29  Christian Arnault  <arnault@lal.in2p3.fr> 179
+
+	* tagging v1r14p20031027
+
+	* mgr/cmt_build_release.sh (version): Add the rebuilding of Linux
+	version at Lyon (without getting the result back)
+
+	* doc/documents.html: Install release notes from the documents page
+
+	* doc/ReleaseNotes.html: Create ReleaseNotes web page (suppress ReleaseNotes.txt)
+
+	* mgr/Makefile (docs): 
+	Add installation of ReleaseNotes.html
+
+2003-10-27  Christian Arnault  <arnault@lal.in2p3.fr> 178
+
+	* src/cmt_version.h (CMTVERSION): prepare tagging of v1r14p20031027
+
+	* mgr/requirements: cmt_installarea_prefix must be defined
+	externally to the cmtpath_pattern.
+
+2003-10-22  Christian Arnault  <arnault@lal.in2p3.fr> 177
+
+	* src/cmt_version.h (CMTVERSION): prepare tagging of v1r14p20031022
+
+	* mgr/cmt_installdir_excludes.txt: New file containing the list of
+	patterns to exclude in installing a directory
+
+	* fragments/nmake/install_includes_header (install): Add support for exclude files
+
+	* mgr/cmt_installdir_action.bat: Add support for exclude files
+	* mgr/cmt_uninstalldir_action.bat: Add tests
+	* mgr/cmt_uninstall_action.bat: Add tests
+	* mgr/cmt_install_action.bat: Add tests
+
+	* src/cmt_parser.cxx (set_standard_macros): First define the
+	current installation area before defining all other standard
+	symbols (and making the final parsing of constituents)
+
+	* src/cmt_install_area.cxx (setup_current_install_area): Implement
+	the definition of the CMTINSTALLAREA symbol	
+	(setup): Differentiate the setting of CMTINSTALLAREA symbol from
+	applying cmtpath patterns
+
+	* src/cmt_install_area.h (class CmtInstallAreaMgr): Split setup in
+	two parts : first define the CMTINSTALLAREA symbol, then apply all
+	cmtpath patterns
+
+2003-10-21  Christian Arnault  <arnault@lal.in2p3.fr> 176
+
+	* mgr/cmt_build_release.sh: Start a procedure for remotely building a CMT release
+
+	* mgr/cmt_installdir_action.bat: Added test on existing result.
+
+	* fragments/nmake/install_includes_header (install_dir): Use $() instead of ${}
+
+	* mgr/requirements: Add definition for cmt_installdir_action
+
+	* src/cmt_parser.cxx (class StandardMacroBuilder): Generate
+	<package>_cmtpath and <package>_offset macros also for the current
+	package
+
+	* src/cmt_system.cxx (remove_directory): Add a # for error messages
+	(remove_file): idem
+
+2003-10-14    <arnault@vmlinux> 175
+
+	* src/cmt_version.h (CMTVERSION): Prepare tagging v1r14p20031014
+
+	* src/cmt_use.cxx (compare_versions): Add a function to compare
+	two version strings.
+	(reach_package): Add the effective version checking for
+	no_version_directory style when version.cmt exists.
+
+	* doc/CMTDoc.xml: Suppress version strategy documentation since
+	this mechanism is not really maintained.
+
+	* src/cmt_use.cxx (reach_package): Add effective check of version
+	even in no_version_directory style
+
+2003-10-13    <arnault@vmlinux> 175
+
+	* fragments/* : Add start and end markers to all make fragments.  
+
+2003-10-09    <arnault@lal.in2p3.fr> 175
+
+	* src\cmt_parser.cxx (do_broadcast): Suppress the catching of
+	return status=2 for last executed command
+
+2003-10-02  Christian Arnault  <arnault@lal.in2p3.fr> 175
+
+        * src/cmt_system.cxx (cd): putenv requires that the string is static !!
+
+2003-10-01    <arnault@vmlinux> 174
+
+	* src/cmt_use.cxx (class use_action_iterator): Force auto_imports
+	to On when context is unspecified.
+
+	* src/cmt_use.h (class Use): Add a new set_selected_version
+	function for switching from one use to another one, better wrt
+	various criteria. When switching, m_index and auto_imports are
+	transfered from the unselected to the newly selected.
+
+2003-09-26    <arnault@vmlinux> 173
+
+	* src/cmt_system.cxx (cd): Change the PWD environment variable, in
+	case it's not done by the underlying OS
+
+2003-09-24  Christian Arnault  <arnault@lal.in2p3.fr> 172
+
+	* src/cmt_use.cxx (show_cycles): optimizing a bit
+	(find_index): idem
+	(set_auto_imports_state): idem
+	(move): idem
+	(reorder): idem
+	(unselect_all): idem
+	(get_selected_version): idem
+	(get_paths): Improve the algorithm to save multiple vector manipulations
+
+	* src/cmt_parser.cxx: Follow all symbol->build_macro_value by
+	Symbol::expand to really expand all possible macro
+	references. This caused a bug when inline re-confirguring
+	CMTUSERCONTEXT (etc.) with a value containing a ref to another
+	symbol.
+
+	* mgr/Makefile (cpp): Add -O2 option for Linux platform
+	(cpp): Add support for profiling setup for LinuxProf platform
+
+2003-09-18    <arnault@vmlinux>
+
+        * mgr/cmt_uninstall_action.sh (a): Fix the consistency check of pwd vs CMTINSTALLAREA
+        * mgr/cmt_install_action.sh (a): idem
+
+2003-09-18  Christian Arnault  <arnault@lal.in2p3.fr> 171
+
+	* mgr/Makefile (cpp): Set IGNORE_PWD for OSF1 and LynxOS
+
+	* src/cmt_system.cxx (pwd): Add an option to ignore PWD since on
+	some machines this does not work well with the chdir function.
+
+	* doc/CMTDoc.xml: improvements
+
+2003-09-17  Christian Arnault  <arnault@lal.in2p3.fr> 170
+
+	* src/cmt_parser.cxx (class StandardMacroBuilder): Add the
+	production of the new macros <package>_cmtpath <package>_offset
+	(class StandardMacroBuilder): Implement the generation of
+	<package>_cmtpath <package>_offset macros
+
+	* fragments/constituent: Add the same dependency list onto
+	constituent makefile fragment than onto the constituent itself so
+	as to enforce the build order also for make fragments.
+
+	* src/cmt_use.cxx (get_paths, get_selected_version): Remove static
+	declaration for a local variable (caused a serious bug !!)
+	Lots of debug prints improved.
+
+2003-09-16  Christian Arnault  <arnault@lal.in2p3.fr> 170
+
+	* src/cmt_symbol.cxx (action): fix setup_script calling mechanism
+	in no_version style : should get it from ../cmt rather than ../mgr
+
+2003-09-16    <arnault@vmlinux> 169
+
+	* mgr/cmt_uninstall_action.sh (full_source_name): idem
+
+	* mgr/cmt_install_action.sh: add a protection when current
+	directory is outside any installation area
+
+	
+	* mgr/NMake (CMTINSTALLAREA): idem
+	(cmttag): Improve the filter for VisualC tag file generation
+	(required to remove all location specific info)
+	Change the target from cmt to cmttag (ie this is NO LONGER done by default!!)
+
+	* mgr/Makefile (CMTINSTALLAREA): Inhibit all INSTALLAREA mechanism
+	when rebuilding cmt itself
+
+	* src/cmt_parser.cxx (get_current_style): First Implementation
+	(dos_script_prefix): Use current_style rather than
+	current_structuring_style to select path pattern
+
+	* src/cmt.h (class Cmt): Add get function to access m_current_style
+
+2003-09-16  Christian Arnault  <arnault@lal.in2p3.fr> 168
+
+	* src/cmt_use.cxx (find_index): Add a protection when a package
+	was not found
+
+2003-08-14  Christian Arnault  <arnault@lal.in2p3.fr> 168
+
+	* src/cmt_generators.cxx (LibraryGenerator::build): new syntax for get_all_files
+	(DocumentGenerator::build): idem
+	(MSDEVGenerator::build_project): idem
+	(VSNETGenerator::build_project): idem
+	(DependencyGenerator::build): idem
+
+	* src/cmt_generator.h (class CmtGenerator): Add an argument for
+	selection patterns.
+
+	* src/cmt_generator.cxx (get_all_files): Apply the selection
+	patterns.  Support wilcarded suffixes (*.*)
+
+	* src/cmt_generators.cxx (DocumentGenerator::build): Add path
+	compression when analyzing file names.
+	(ConstituentsMakefileGenerator::build): suppress unused declarations
+
+	* src/cmt_constituent.cxx (show): display select paterns
+	(class constituents_action_iterator): Handle the new -k= option for selection pattern
+	(clear): clear selection patterns
+
+	* src/cmt_constituent.h (class Constituent): Add select regexps similar to excludes
+
+2003-08-13  Christian Arnault  <arnault@lal.in2p3.fr> 168
+
+	* src/cmt_use.cxx (show_all): Standardize the output format of
+	show uses to ensure that we always have in the last part: 
+
+	use <package> <version> [<offset>] (<path>) (<qualifier>) (...)
+
+	or (with -quiet)
+	
+	use <package> <version> [<offset>]
+
+	Also fix a bug when trying to remove offset from real_path...
+	
+
+2003-08-11  Christian Arnault  <arnault@lal.in2p3.fr> 167
+
+	* mgr/Makefile (bintar): Dynamically gets the list of binaries
+	available of this machine. Then constructs CMTDownload.html
+	accordingly.
+
+	* doc/CMTDownload1.html: First part of CMTDownload.html
+	* doc/CMTDownload2.html: Last part of  CMTDownload.html
+
+	* doc/installations.doc: upgrade list of porting machines
+
+	* src/cmt_version.h (CMTVERSION): new patch tag v1r14p20030811
+
+	* src/cmt_use.cxx (show_sub_uses): Display the original request
+	instead of the registered sub use (which may be different than the
+	request)
+
+	* src/cmt_use.h (class Use): Add context_use in the argument list
+	to display the use that created this request
+	
+	(class Use): Add a vector of the real requests (well only those that ended up in a sub use) 
+
+	* src/cmt_use.cxx (need_new): Dispay the incompatibility message
+	in need_new rather than in the BestFitSelector, since
+	corresponding uses may have been discarded then.
+
+	* src/cmt_system.cxx (is_version_directory): return all -1 values
+	when version specification is just '*'
+
+2003-08-08    <arnault@lal.in2p3.fr> 166
+
+	* mgr\requirements: Tuning pour CYGWIN
+
+2003-08-06  Christian Arnault  <arnault@lal.in2p3.fr> 165
+
+	* src/cmt_symbol.cxx (create): Same reasons (LynxOS) => convert a
+	static array of strings into a switch statement (not quite
+	elegant). May move back in some future if problem is solved on
+	LynxOS.
+
+	* src/cmt_syntax.cxx (CommandParser): Initialze the new help_texts
+	by filling in a vector rather that from a static array of
+	cmt_string (too bad...)
+
+	* src/cmt_syntax.h (class CommandParser): Need to redefine the
+	management of static arrays of objects due to a bug in c++
+	compiler on LynxOS... A Workaround is found by transfering static
+	arrays into the singleton => m_helps and m_help_texts
+
+2003-08-06    <arnault@lal.in2p3.fr> 164
+
+	* src\cmt_parser.cxx (dos_script_prefix): Adapt the generation of
+	setup.bat scripts so as to account for the new DOS device constructs
+	\\xxx\aaa
+
+	* src\setup.bat: Add /D to the cd command to support CMT on a
+	different device
+
+2003-08-05    <arnault@lal.in2p3.fr> 163
+
+	* src/cmt_parser.cxx (dos_script_prefix): remove device from path
+	when device takes the conventional form. new form (\\xxx\) is not
+	yet handled.
+
+	* src/cmt_install_area.cxx (config): Don't produce output messages in quiet mode
+
+2003-08-05  Christian Arnault  <arnault@lal.in2p3.fr> 163
+
+	* src/cmt_system.cxx (pwd): Make use of the PWD environment
+	variable when it is defined to detect current directory in place
+	of getcwd (keep gettcwd when PWD is not defined or on WIN32)
+
+	* fragments/install_includes_header (install): Avoid useless
+	re-installation of include file area
+
+	* src/cmt_use.cxx (add): When m_index is exchanged between two
+	uses, the discarded flag must be upgraded accordingly	
+	(class use_action_iterator): Suppress trailing slash characters on
+	package offset specifications.
+
+	* src/cmt_parser.cxx (class StandardMacroBuilder): Define
+	package_cmtpath instead of just cmtpath as the standard macro, in
+	order to avoid conflict with CMTPATH env. var. on Windows.
+	(do_broadcast): Define the pattern <package_cmtpath> instead of
+	<cmtpath> for broadcast command templates
+
+	* src/cmt_use.cxx (need_new): first consider the already registered use
+	(add): Fix a bug in the algorithm for checking registrations of uses.
+	(class use_action_iterator): Remove trailing slashes from prefix specifications
+
+2003-06-20  Christian Arnault  <arnault@lal.in2p3.fr> 162
+
+	* src/cmt_version.h: new patch id 20030620
+
+	* mgr/Makefile (gendoc): Add a target to convert XML doc into HTML
+	(so far only available at CERN)
+
+	* doc/gendoc.py (Book.plain_char_data): improvements.
+
+	* src/cmt_parser.cxx (do_broadcast): Fix evaluation of <cmtpath>
+	<package_offset> in -global mode
+
+2003-06-19    <arnault@lal.in2p3.fr> 161
+
+	* src/cmt_system.cxx (add_cmt_path): Fix cmtpath checking for
+	devices on Windows
+
+2003-06-19  Christian Arnault  <arnault@lal.in2p3.fr> 160
+
+	* fragments/nmake/library_no_share: Use the @<< syntax of nmake to
+	cope with long list of OBJS
+	* fragments/nmake/application: idem
+	* fragments/nmake/library: idem
+
+2003-06-18  Christian Arnault  <arnault@lal.in2p3.fr> 159
+
+	* mgr/requirements: Use ln -s for the cmt_install_area_command
+
+	* fragments/application (install_dir): Use $(tag) instead of $(CMTCONFIG)
+	* fragments/library (install_dir): Use $(tag) instead of $(CMTCONFIG)
+	* fragments/library_no_share (install_dir): Use $(tag) instead of $(CMTCONFIG)
+	* fragments/nmake/application (install_dir): Use $(tag) instead of $(CMTCONFIG)
+	* fragments/nmake/library (install_dir): Use $(tag) instead of $(CMTCONFIG)
+	* fragments/nmake/library_no_share (install_dir): Use $(tag) instead of $(CMTCONFIG)
+
+	* mgr/requirements: use cp -s and not cp -l to create symlinks
+
+2003-06-16  Christian Arnault  <arnault@lal.in2p3.fr> 158
+
+	* src/cmt_version.h (CMTVERSION): New Tag 20030616
+
+	* src/Makefile.header (common_target): Make use of the mktemp
+	shell function
+
+	* doc/CMTDoc.xml: Doc
+
+	* src/cmt.h (class Cmt): Add get_current_cmtpath and
+	get_current_offset functions.
+
+	* src/cmt_parser.cxx (configure_current_cmtpath): Implement (set
+	m_current_cmtpath and m_current_offset)
+
+	* src/cmt.h (class Cmt): Add configure_current_cmtpath function
+
+	* src/cmt_parser.cxx (class StandardMacroBuilder): Add standard
+	macros cmtpath and package_offset
+	(do_broadcast): Add substitutions of <package>, <version>, <cmtpath>, <package_offset>
+	(class StandardMacroBuilder): Set m_current_cmtpath and m_current_offset
+
+	* src/cmt.h (class Cmt): Adding current value for cmtpath and offset
+
+	* mgr/requirements: Use symlink instead of cp as default transfer
+	action into installation area
+
+2003-06-12  Christian Arnault  <arnault@lal.in2p3.fr> 157
+
+	* src/cmt_pattern.cxx : fix a bug in ApplyPattern::action: macros 
+	should NOT be expanded when parsing the statement. Only the 
+	pattern name may be expanded.
+	Second fix: when a pattern is re-defined, the Pattern object must be 
+	properly reset.
+
+2003-06-04    <arnault@vmlinux> 156
+
+	* src/cmt_version.h (CMTVERSION): Tag the version to v1r14p20030605
+
+	* mgr/build_from_rpm.sh (tempdir): Add a shell script for testing
+	the source kit (not complete)
+
+	* mgr/install_from_rpm.sh: Add a shell script for testing the
+	generated binary RPM.
+
+	* mgr/Makefile (rpm): Add the rpm target to build RPMs into ../rpm 
+
+	* mgr/CMT.spec: Add an RPM spec file for CMT. Only the binary kit
+	has been tested successfully
+
+	* doc/install.html: Document the usage of the CMT RPM
+
+	* src/cmt_parser.cxx (dos_script_prefix): Use %TEMP% instead of
+	%HOMEDRIVE%%HOMEPATH% for temporary setup files on Windows
+
+2003-06-04  Christian Arnault  <arnault@lal.in2p3.fr> 155
+
+	* fragments/install_includes_header (install): Fixed wrong test on
+	CMTINSTALLAREA
+
+	* src/cmt_syntax.cxx (parse_requirements): Transfer the scoping
+	algorithm to parse_requirements_text so that patterns supplying
+	private statements will work nicely.
+	(parse_requirements_text): see above
+
+2003-05-23  Christian Arnault  <arnault@lal.in2p3.fr> 154
+
+	* src/Makefile.header: removing apparently obsolete MAKEFLAGS
+	filtering mechanisms on -j option
+
+	* src/setup.zsh: Add cmt show cycles zsh expansion
+
+	* src/cmt_parser.cxx (parser): Add cmt show cycles parsing and support
+
+	* src/cmt_syntax.cxx (CommandParser): Add show_cycles info
+
+	* src/cmt_parser.h (enum): Add action_show_cycles
+
+	* src/cmt.h (class Cmt): Add cmt show cycles command to display use cycles
+
+2003-05-22  Christian Arnault  <arnault@lal.in2p3.fr> 153
+
+	* src/cmt_std.h: Suppress include ios for new header style
+
+	* src/cmt_parser.cxx (parse_arguments): Install a -private option to
+	the show_use_paths action. When -private is present on the command
+	line then the private uses are reached.
+	(parse_arguments): Make the --private or --public option a global
+	option to control on all CMT commands whether we reach or not the
+	private uses.
+
+	* src/cmt_use.cxx (class use_action_iterator): Detect the new
+	scope filtering mode to actually reach the private uses
+
+	* src/cmt_parser.cxx: Set the scope filtering mode when
+	appropriate (cmt_show_uses, cmt_show_use_paths, cmt_broadcast,
+	cmt_set_versions, cmt_show_setup)
+
+	* src/cmt.h (class Cmt): Add m_scope_filtering_mode attribute
+
+	* src/cmt_parser.cxx (get_scope_filtering_mode): Implement the new function
+	(set_scope_filtering_mode): Implement the new function
+
+	* src/cmt.h (class Cmt): Add set_scope_filtering_mode function
+	  (class Cmt): Add get_scope_filtering_mode function
+
+	* src/cmt_parser.h (enum): Add a scope filtering mode to block or
+	reach private uses
+
+2003-05-21  Christian Arnault  <arnault@lal.in2p3.fr> 153
+
+	* src/cmt_use.cxx (get_all_clients): Public interface to private
+	get_all_clients
+	(get_all_clients): Actual recursive implementation for getting all
+	paths to a given client
+
+	* src/cmt_use.h (class Use): Implement two new get_all_clients
+	functions to acquire all paths to a given client of a package (one
+	public with simple interface and one private with temporary
+	storage).
+
+	* src/cmt_use.cxx (class use_action_iterator): traverse complete
+	use graph for action_show_use_paths
+
+	* src/cmt_std.h: Set new C++ header style on Linux
+
+	* src/setup.zsh: Add cmt show use_paths to auto-expansion definition 
+
+	* src/cmt_syntax.cxx (CommandParser): Add help for cmt show use_paths
+	(get_help_texts): idem
+
+	* src/cmt_parser.cxx (do_show_use_paths): implement do_show_use_paths function
+	(parse_arguments): parse cmt show use_paths <package>
+	(parser): idem
+
+	* src/cmt.h (class Cmt): add do_show_use_paths function
+
+	* src/cmt_parser.h (enum): Start implementing a new feature: cmt
+	show use_paths <package> to display all possible paths between the
+	current package and the specified package.
+
+2003-05-19    <arnault@lal.in2p3.fr> 152
+
+	* mgr\cmt_linux_version.sh: add a script for querying linux
+	version for various distributions (contribution from Clark McGrew
+	<clark.mcgrew@sunysb.edu>)
+
+	* src\cmt_symbol.cxx (show_macro): re-apply suppress_OS_delimiter
+	when generating the tag makefile, but only on WIN32 context.
+
+	* src\cmt_pattern.cxx (class apply_pattern_action_iterator): Add
+	action iterator to expand macros before parsing line.
+
+	* src\cmt_fragment.cxx (class fragment_action_iterator): Add
+	action iterator to expand macros before parsing line.
+
+	* src\cmt_fragment.cxx (action): Hide make_fragments in private
+	sections like macros
+
+	* mgr\requirements: Introduce the generic Unix tag for all Unix platforms
+	
+	* src\cmt_parser.cxx (dos_script_prefix): Factor out the writing
+	of DOS setup and cleanup scripts.
+
+	* mgr\INSTALL.bat: No longer need nmake to generate the setup.bat
+	script of CMT, thanks to the %~d0%~p0 mechanism (copy from src is enough).
+
+	* src\setup.bat: Install a generic mechanism for finding the
+	current drive letter (unfortunately this mechanism does not work
+	in any possible Unix shell)
+
+	* src\cmt_parser.cxx (install_setup_scripts): Apply the drive
+	letter mechanism to setup scripts
+
+2003-05-17    <arnault@lal.in2p3.fr> 151
+
+	* mgr\requirements: Typo in the cmtpath_pattern : use_includes 
+
+2003-05-14    <arnault@lal.in2p3.fr> 150
+
+	* src\cmt_parser.cxx (restore_all_tags): Bug in managing
+	-tag=<taglist> argument due to the separator in m_extra_tags :
+	force a separator before and after all tags in the list
+	(parse_arguments): idem
+	(print): idem
+
+2003-05-13    <arnault@lal.in2p3.fr> 149
+
+	* fragments/tex: install correction from Marie Anne
+
+2003-05-12    <arnault@lal.in2p3.fr> 148
+
+	* mgr/cmt_linux_version.sh: Adding a script to retrieve Linux version and distribution 
+
+	* mgr/requirements: Add declaration of install_includes fragments
+
+	* fragments/install_includes_header: Make fragment for installing
+	include directory but only for those following the standard
+	pattern of ../<package>
+
+	* fragments/install_includes: 
+	* fragments/nmake/install_includes_header: 
+
+	* mgr/cmt_installdir_action.bat: Special treatment of directory
+	installation
+	* mgr/cmt_uninstalldir_action.bat: 
+
+	* fragments/constituents_trailer (remove_library_links): Add a
+	remove_library_links target
+	* fragments/nmake/constituents_trailer: idem
+
+	* fragments/constituent (uninstall): Suppress dependencies for
+	uninstall target
+	* fragments/nmake/constituent (uninstall): idem
+
+2003-05-11    <arnault@lal.in2p3.fr> 147
+
+	* mgr\requirements: Add search libpath to installarea for WIN32
+
+	* fragments\nmake\library (install): bug (typo) in target names
+
+	* mgr\cmt_install_action.bat: use rem comments instead of #
+	* mgr\cmt_uninstall_action.bat: idem
+
+	* mgr\NMake (cmt): Filter out the include and lib definitions in
+	VisualC.nmake for cmt itself.
+
+	* src\cmt_parser.cxx (scan_path): Suppress unused variable
+
+	* src\cmt_std.h (OLD_HEADERS): Adopt new header style for WIN32
+
+	* mgr\requirements: Add compiler option for exception handling in VisualC
+
+2003-05-05  Christian Arnault  <arnault@lal.in2p3.fr> 146
+
+	* src/cmt_use.cxx (add): Set the warning for package not found a real warning.
+
+	* src/cmt_parser.cxx (do_setup): Change the info message to be
+	displayed only when appropriate
+
+2003-05-05    <arnault@lal.in2p3.fr> 145
+
+	* src/cmt_version.h: v1r14
+
+	* doc/CMTDoc.xml: Improve the doc
+
+	* doc/gendoc.py (Book.syntax_start): Add an attribute name in
+	syntax for avoiding name conflicts
+
+	* fragments/nmake/jar (install): 
+	* fragments/nmake/java_header (install): 
+	* fragments/nmake/library_no_share (install): 
+	* fragments/nmake/library (install): 
+	* fragments/nmake/application (install): 
+
+	* fragments/jar (install): 
+	* fragments/java_header (install): 
+	* fragments/library_no_share (install): 
+	* fragments/library (install): 
+	* fragments/application (install): apply the centralized scripts
+
+	* mgr/cmt_uninstall_action.bat: 
+	* mgr/cmt_install_action.bat: 
+	* mgr/cmt_uninstall_action.sh:
+	* mgr/cmt_install_action.sh: Scripts for doing
+	(un)installation into the current installation area
+
+2003-05-02  Christian Arnault  <arnault@lal.in2p3.fr> 144
+
+	* fragments/application (uninstall, install): 
+	* fragments/library (uninstall, install): 
+	* fragments/library_no_share (uninstall, install): 
+	* fragments/java_header (uninstall, install): 
+	* fragments/jar (uninstall, install): 
+	* fragments/constituent (install, uninstall): Add (un)install actions
+	idem for nmake
+	
+
+2003-05-02    <arnault@lal.in2p3.fr> 143
+
+	* doc/gendoc.py : Create a new mechanism for generating HTML
+	documentation from an XML representation.
+
+2003-04-30  Christian Arnault  <arnault@lal.in2p3.fr> 142
+
+	* src/cmt_parser.cxx (do_show_strategies): Display the Setup strategy
+
+	* src/cmt_syntax.cxx (class KwdSetupStrategy): Decode the
+	[no_]cleanup option for the setup_strategy in requirements file
+
+	* src/cmt_parser.cxx (parse_arguments): Decode the -no_cleanup option
+	(do_setup): Apply the cleanup only when the setup strategy permits it
+	(do_config): idem
+
+	* src/cmt_parser.h (enum): Add NoCleanup possibility to the SetupStrategy
+
+2003-04-16  Christian Arnault  <carnault@lxplus051.cern.ch> 141
+
+	* src/cmt_parser.cxx (run): Bug in PackageCollector::run current
+	directory missed the package name. (for cmt show clients)
+
+2003-04-12    <arnault@lal.in2p3.fr> 140
+
+	* src\cmt_generators.cxx: Add excludes to all calls to get_all_files 
+
+	* src\cmt_generator.h (class CmtGenerator): Add exclude expressions
+
+	* src\cmt_constituent.cxx (class constituents_action_iterator):
+	Implement the -x=<pattern> option to the constituent to exclude
+	patterns. Create regexps for each pattern.
+	(show): Show excludes
+
+	* src\cmt_constituent.h (class Constituent): Add a vector of
+	regexp for exclude specs.
+
+	* src\cmt_regexp.cxx (set): Implement the set function.
+
+	* src\cmt_regexp.h (class cmt_regexp): Introduce a default
+	constructor and a set function
+
+	* src\cmt_generators.cxx:
+	* src\cmt_generator.cxx: Strong restruring of generator architecture:
+	  + create a CmtGenerator basic class for all generators
+	  + create derived classes for all categories of generators
+                 ApplicationGenerator
+                 LibraryGenerator
+                 DocumentGenerator
+                 ReadmeGenerator
+                 PrototypeGenerator
+                 DefaultMakefileGenerator
+                 MSDEVGenerator
+                 VSNETGenerator
+                 MakeSetupGenerator
+                 ConstituentsMakefileGenerator
+                 DependencyGenerator
+	  + transfer new stuff in cmt_generators.h/.cxx
+	  + transfer all utility functions (get_all_files etc...) into the base class
+	  + optimize handling of Variable and FragmentHandle objects per Generator class 
+	
+
+	* src\cmt_install_area.cxx (config): suppress echo in quiet mode
+
+	* src\cmt_parser.cxx (install_test_setup_scripts): Protect tempfile against spaces in paths
+	(install_test_cleanup_scripts): idem
+	(install_setup_scripts): idem
+	(install_cleanup_scripts): idem
+
+2003-04-11  Christian Arnault  <carnault@lxplus051.cern.ch> 139
+
+	* src/cmt_parser.cxx (do_run_sequence): Sequences are removed from
+	cmt.cxx and implemented in a dedicated source file.
+
+	* src/cmt_sequence.h (class SequenceRunner): Adding cmt_sequence.h
+	(defining sequences)
+
+	* src/cmt_sequence.cxx (filter): Adding cmt_sequence.cxx (extracted
+	from cmt.cxx)
+
+	* src/cmt_generator.cxx (get_all_files): Return a count of non
+	empty file names.
+	(build_library_makefile): Ensure that get_all_files is done only
+	once.
+	(build_document_makefile): Ensure that get_all_files is done only
+	once (not completed yet)
+	(class DocumentMakefileGenerator): Start creating an object model
+	for makefile generators. Create derived classes of
+	MakefileGenerator for Application, Library, document
+
+	* src/cmt_constituent.h (class Constituent): Add excludes vector
+	of exclusions
+
+	* src/cmt_constituent.cxx (class constituents_action_iterator):
+	Start implementing exclusion mechanisms on constituent sources.
+	We add a -x=<pattern> cumulative option to the constituent syntax
+	
+2003-04-07    <arnault@lal.in2p3.fr> 138
+
+	* src\cmt_generator.cxx: Add DIRNAME Variable
+	Add new fragments for vcproj
+
+2003-04-05    <arnault@lal.in2p3.fr> 138
+
+	* mgr\requirements: define VC7 VC7debug tags for vsnet
+
+	* src\cmt_generator.cxx (class MakefileGenerator): Add vsnetdir variable
+	Add declarations for vsnet fragments
+	(reset): Install vsnetdir as ..\VisualC
+	(pseudoGUID): Implement an algorithm for creating GUIDs
+	(build_vsnet_workspace): 
+	(build_vsnet): 
+
+	* src\cmt_generator.h (class Generator): Declare
+	build_vsnet_workspace and build_vsnet methods
+
+	* src\cmt_constituent.cxx (build_all_vsnet_files): Implement for vsnet
+	(build_vsnet_file): Implement for vsnet
+
+	* src\cmt_constituent.h (class Constituent): Add build_all_vsnet_files
+	(class Constituent): Add build_vsnet_file
+
+	* src\cmt_parser.cxx (class StandardMacroBuilder): Add macro
+	<constituent>_GUID for vsnet.
+	(parser): Implement cmt build vsnet actions
+
+	* src\cmt_syntax.cxx (CommandParser): Add help about cmt build vsnet
+
+	* src\cmt_parser.h (enum): Add action_build_vsnet
+
+	* src\cmt.h (class Cmt): Add Visual Sudio.Net support (From Toby Burnett)
+
+2003-04-03  Christian Arnault  <carnault@lxplus051.cern.ch> 137
+
+	* src/cmt_parser.cxx (do_setup): Do a config action to the
+	installation area in order to perform a cleanup operation during
+	the source setup
+
+	* src/cmt_install_area.cxx (config): Display a message when doing
+	cleanup of installation areas.
+
+	* mgr/requirements: Rename cmt_(un)install_command to cmt_(un)install_area_command
+	Prepare CMTr14 tag from CMTr13
+
+	* fragments/java_header (install_java_bin_dir): idem
+	* fragments/library_no_share (install_lib_dir): idem
+	* fragments/jar (install_java_lib_dir): idem
+	* fragments/library (install_lib_dir): idem
+	* fragments/application (install_bin_dir): idem
+
+2003-04-02  Christian Arnault  <carnault@lxplus051.cern.ch> 136
+
+	* src/cmt_symbol.cxx (build): Bug : the macro_prepend was NOT really prepending.
+
+2003-03-28  Christian Arnault  <carnault@lxplus051.cern.ch> 136
+
+	* src/cmt_parser.cxx (class StandardMacroBuilder): Add CMTVERSION standard macro
+
+2003-03-28    <arnault@lal.in2p3.fr> 135
+
+	* src\cmt_parser.cxx (configure_version_tag): Create three new predefined tags:
+	   CMTv<n>
+	   CMTr<n>
+	   CMTp<n>
+	to describe the current version, release and patch of CMT.
+
+	* src\cmt_parser.h (enum): Adding PriorityVersion for marking the
+	priority of the new automatic version tag
+
+	* src\cmt_parser.cxx (configure_version_tag): Implement
+	configure_version_tag method to create a tag for the version of
+	CMT
+
+	* src\cmt.h (class Cmt): Adding configure_version_tag method to
+	create a tag for the version of CMT
+
+	* src\cmt_symbol.cxx (all_set): Ensure that all path separators
+	are back-slash on windows.
+
+	* fragments\nmake\jar:  Adapt for the new convention (subdirectory for the CONSTITUENT)
+	(install_java_lib_dir):  Add installation area mechanisms
+
+	* fragments\nmake\java: Adapt for the new convention (subdirectory for the CONSTITUENT)
+
+	* fragments\nmake\java_header (install_java_bin_dir): Add installation area mechanisms
+
+2003-03-21  Christian Arnault  <carnault@lxplus051.cern.ch> 134
+
+	* src/cmt_parser.cxx (parser): cmt run must be recursive for used
+	packages (in order to get all environment variables set)
+
+2003-03-20  Christian Arnault  <carnault@lxplus051.cern.ch> 133
+
+	* src/cmt_symbol.cxx (show): Implement common SymbolValueList::show method.
+
+	* src/cmt_symbol.h (class SymbolValueList): Factor out printing SymbolValues
+
+	* src/cmt_symbol.cxx (create): Give use context in warning message
+
+	* src/cmt_symbol.h (class Symbol): Add Use* argument to print
+	context in warning messages
+
+	* src/cmt_parser.cxx (vector_to_string): Ignore empty entries to
+	avoid duplicate separators
+
+2003-03-20  Christian Arnault  <carnault@lxplus051.cern.ch> 132
+
+	* src/cmt_error.cxx (print): Consistently set the prefix "#CMT> "
+	to all error messages and print outs
+	* src/cmt_triggers.cxx (filter): idem
+	* src/cmt_use.cxx (add): idem
+	* src/cmt_generator.cxx (build_default_makefile): idem
+	* src/cmt_symbol.cxx (create): idem
+	* src/cmt_parser.cxx (do_show_macro): idem
+
+	* src/cmt_symbol.cxx (create): Handle the unconsistent multiple
+	declarations of sets as macros (and vice versa)
+
+	* src/cmt_error.cxx (class Error): Add warning error text
+	* src/cmt_error.h (class CmtError): Add warning error code
+
+	* src/cmt_parser.cxx (reach_current_package): Suppress error print
+	when requirements file is not found
+	(do_show_macro): Improve the error message in the 
+	"cmt show macro/set" command
+
+2003-03-20  Christian Arnault  <carnault@lxplus051.cern.ch> 131
+
+	* src/cmt_parser.cxx (reach_current_package): 
+	* src/cmt_install_area.h (class CmtInstallAreaMgr): Factor out the
+	construction of the current installation area
+
+	* src/cmt_install_area.cxx (setup): Filters out "default path" for
+	constructing the current installation area
+	(config): idem
+
+	* src/cmt_cmtpath_pattern.cxx (apply): Suppress "default path" (ie
+	CMTPATH of CMT) from application of cmtpath_patterns
+
+	* src/cmt_parser.cxx (get_cmt_path_sources): Add accessor to cmtpath_sources
+
+	* src/cmt.h (class Cmt): Add accessor to cmtpath_sources
+
+2003-03-18  Christian Arnault  <carnault@lxplus051.cern.ch> 130
+
+	* src/cmt_cmtpath_pattern.cxx (apply): Optimize the substitution
+	of "<path>" in cmtpath_patterns by avoiding a loop over path items
+	when the pattern does not contain "<path>" at all
+
+2003-03-13  Christian Arnault  <carnault@lxplus051.cern.ch> 130
+
+	* mgr/requirements: Add -classpath $(src) to java compilation
+
+	* src/cmt_generator.cxx (analyze_file): Default copy action for
+	files with no language is applied only to java contexts
+
+2003-03-12  Christian Arnault  <carnault@lxplus051.cern.ch> 130
+
+	* fragments/java_copy: Use this fragment for default action on
+	sources with no language
+
+	* src/cmt_generator.cxx (module_file_action): Install default
+	(copy) action for source files with no language.
+
+	* fragments/java_header: Building jar files with * rather than *.class
+
+	* fragments/jar: Building jar files with * rather than *.class
+
+	* fragments/java_header: Syntax fix for generating manifest file
+
+2003-03-11  Christian Arnault  <carnault@lxplus051.cern.ch> 129
+
+	* src/setup.zsh: Add show cmtpath_patterns option
+
+	* src/cmt_generator.cxx (analyze_file): Add constituent sub
+	directory to output for java files
+
+	* fragments/jar: Add constituent sub directory to ../classes to
+	store *.class and jar files
+
+	* fragments/java_header (install_java_bin_dir): Apply installation
+	area mechanisms for java application
+
+	* mgr/requirements: Need both share/bin and share/lib for installarea
+
+2003-03-10  Christian Arnault  <carnault@lxplus051.cern.ch> 129
+
+	* src/cmt_cmtpath_pattern.cxx (apply): CMTPATH patterns should be
+	applied in revers order
+
+	* mgr/requirements: bug fix (missing backslash)
+
+	* src/cmt_install_area.cxx (config): Bug fix
+
+2003-03-09    <ARNAULT@lal.in2p3.fr> 128
+
+	* src\cmt_install_area.cxx (setup): Make use of the cmt_installarea_prefix macro
+	(config): idem
+
+2003-03-08    <ARNAULT@lal.in2p3.fr> 128
+
+	* mgr\requirements: Define the cmt_installarea_prefix macro to
+	parameterize the common prefix to be added to all CMTPATH entries
+	for installation areas
+
+2003-03-06    <ARNAULT@lal.in2p3.fr> 127
+
+	* src\cmt_install_area.cxx (config): Introduce the new macro
+	cmt_installarea_paths used to declare all PATHS inside the
+	installareas that will need to be checked for consistency when
+	doing cmt config
+
+	* src\cmt_install_area.h (class CmtInstallAreaMgr): Remove
+	set_path, add_path_pattern, apply_path_patterns function since
+	they are all managed through cmtpath_patterns
+
+	* src\cmt_parser.cxx (do_show_cmtpath_patterns): Do set_standard_macros
+
+	* src\cmt_install_area.cxx (setup): Launch the CmtPathPattern::apply_all ()
+
+	* src\cmt_parser.cxx (parser): Add parsing of cmt show cmtpath_patterns
+
+	* src\cmt_syntax.cxx: Add parsing of cmt show cmtpath_patterns
+
+	* src\cmt_parser.h (enum): Add action_show_cmtpath_patterns
+
+	* src\cmt_database.cxx (cmtpath_patterns): Add CmtPathPatternVector object
+
+	* src\cmt_database.h (class Database): Add CmtPathPatternVector
+
+	* src\cmt_cmtpath_pattern.cxx: Install partial reproduction of cmt_pattern.cxx
+
+	* src\cmt_cmtpath_pattern.h: Create cmt_cmtpath_pattern.h
+	(class CmtPathPattern): Install partial reproduction of cmt_pattern.h
+
+	* mgr\requirements: Add the source file cmt_cmtpath_pattern.cxx
+
+	* src\cmt_syntax.cxx (class KwdCmtPathPattern): add parser object
+	for the new CommandCmtPathPattern.
+
+	* src\cmt_parser.h (enum): Add CommandCmtPathPattern to declare
+	CMTPATH patterns to be applied onto all CMTPATH items.
+
+2003-03-06    <ARNAULT@lal.in2p3.fr> 126
+
+	* src\cmt_symbol.cxx (all_set): Add debug informattion
+
+	* src\cmt_parser.cxx (do_run): Do set_standard_macros before
+	running
+
+2003-03-06  Christian Arnault  <carnault@lxplus051.cern.ch> 125
+
+	* src/cmt_system.h (class CmtSystem): Adding putenv to set environment variables
+	* src/cmt_system.cxx (putenv): idem
+
+	* src/cmt_symbol.cxx (class SetBuilder): The build and clean
+	function should return string object rather that referencing the
+	string object attribute (protection against recursive calls)
+	(class PathBuilder): idem
+	(class MacroBuilder): idem
+	(class ScriptBuilder): idem
+	(resolve_value): Add comments and improve variable naming
+	(resolve_value): idem
+	(resolve_value_for_macros): idem
+	(suppress_OS_delimiters): idem
+
+	* src/Makefile.header (common_target): Use /tmp to 
+	create temporary (and disposable) make fragments.  Rearrange
+
+	* mgr/Makefile (cpp): Provide support to build on LinuxDebug 
+
+	* fragments/constituents_header (cmt_lock_setup): Use /tmp to
+	create temporary (and disposable) make fragments.  Rearrange
+	statements in the building of $(tag).make so as to ensure that
+	echo statements are only done when things are ok.
+
+	* src/cmt_parser.cxx (install_cleanup_scripts): Define CMTROOT
+	only if it is NOT defined yet. Goal is to keep user defined
+	version of CMT.
+	(install_setup_scripts): idem
+	(install_test_cleanup_scripts): idem
+	(install_test_setup_scripts): idem
+
+2003-02-27  Christian Arnault  <carnault@lxplus051.cern.ch> 125
+
+	* src/cmt_symbol.h (class ValueBuilder): due to recursivity,
+	Builder function cannot share the temporary string value
+
+2003-02-26  Christian Arnault  <carnault@lxplus051.cern.ch> 125
+
+	* src/cmt_parser.cxx (do_run): Add Symbol::all_set
+	(do_broadcast): idem (before the loop over packages)
+
+	* src/cmt_symbol.cxx (all_set): Install the mechanism to set
+	environment variables (using putenv) into CMT. This function is
+	called before running the CmtSystem::execute function.
+	
+	* src/cmt_symbol.h (class Symbol): Remove the tabs argument of the
+	print and print_clean methods (obsolete)
+
+	* src/cmt_symbol.cxx (resolve_value): rename the argument for the
+	symbol name (it applies for any symbol, not just for macros)
+	(resolve_value): Improve comments
+	(resolve_value_for_macros): Improve comments
+	(resolve_macro_value): factor out at least one of the resolve macro algorithms
+
+2003-02-24  Christian Arnault  <carnault@lxplus051.cern.ch> 124
+
+	* src/cmt_generator.cxx (build_dependencies): Surrounding
+	dependencies by quotes does not please gmake. We have to check
+	what happens on Darwin (ie what about path names with spaces?)
+	
+2003-02-14    <ARNAULT@lal.in2p3.fr> 123
+
+	* mgr\requirements: Use XCOPY instead of copy for the install
+	commands to support the directory copy
+
+	* fragments\installer: Suppress the need to specify install_dir
+	with trailing slash
+
+	* fragments\nmake\installer: Add installer for Windows
+
+	* src\cmt_generator.cxx (build_dependencies): Add double quotes to
+	support file names with non standard characters (eg spaces) (not
+	only on Windows).	
+	(filter_path): Add the filter operation to work on one sigle
+	file. The filter_paths function becomes obsolete and is removed.
+	(analyze_document_file): Use filter_path instead of filter_paths
+	(proto_file_action): idem
+	(module_file_action): idem
+	(build_library_makefile): idem
+	(build_document_makefile): idem
+	(build_dependencies): idem
+	(build_document_makefile): Support sources being directories
+	(module_file_action): idem
+
+	* mgr\cmt_install_action.bat: idem
+	* mgr\cmt_uninstall_action.bat: idem
+	* fragments\nmake\library_no_share (install_lib_dir): idem
+	* fragments\nmake\library (install_lib_dir): idem
+	* fragments\nmake\application (install_bin_dir): idem
+
+2003-02-11  Christian Arnault  <carnault@lxplus051.cern.ch> 122
+
+	* src/cmt_cvs.cxx (class CvsImplementation): Adding explicit error
+	message when base directory cannot be created during the checkout.
+
+2003-02-06  Christian Arnault  <carnault@lxplus051.cern.ch> 121
+
+	* src/Makefile.header (clean): Remove the pseudo config target for
+	the clean target
+	
+2003-02-04  Christian Arnault  <carnault@lxplus051.cern.ch> 120
+
+	* src/cmt_use.cxx (add): Add protection against recursive use
+	statement to current_use
+
+2003-02-04    <ARNAULT@lal.in2p3.fr> 119
+
+	* src\cmt_use.cxx (need_new): Add protection against recursive use
+	statement to current_use
+
+2003-01-31  Christian Arnault  <carnault@lxplus051.cern.ch> 118
+
+	* mgr/requirements : library_prefix should be empty for WIN32
+
+	* src/cmt_parser.cxx (install_setup_scripts): Protect the setup
+	script generation against cases where : structuring style is set
+	to without_version_directory and verion tag cannot be determined
+	(eg. if the version file does not exist). Then, the -version=xxx
+	option is suppressed from the setup script generation.
+	(install_test_cleanup_scripts): idem
+
+	* src/Makefile.header (common_target): Suppress a debug settings
+
+2003-01-28    <ARNAULT@lal.in2p3.fr> 117
+
+	* src\cmt_install_area.cxx (instance): Suppress the production of
+	LD_LIBRARY_PATH installation specs for WIN32
+
+	* fragments\nmake\library_no_share (install_lib_dir): 
+	* fragments\nmake\library (install_lib_dir): 	
+	* fragments\nmake\application (install_bin_dir): Add install area mechanisms for WIN32
+
+2003-01-24  Christian Arnault  <carnault@lxplus032.cern.ch> 116
+
+	* src/cmt_install_area.cxx (instance): The constuction of the
+	instance also declares the path patterns.
+
+	(setup): Make use of the path_patterns to generate CMT statements
+
+	(get_install_area): The current install area is preserved in the
+	InstallAreaMgr instance (singleton).
+
+	(set_path): (only used internally) build a path expression from a pattern
+
+	(setup): Provide additional -L... options towards the install area
+	for use_linkopts ad shlibbuilder
+	
+	(config): Perform the cleanup operation onto the current installation area:
+	  check the all ref-files still refer to existing files.
+	  if not erase the corresponding installed file.
+
+	* src/cmt_install_area.h (class CmtInstallPathPattern): New class
+	for storing generic patterns for (PATH/directories) duets
+	generation and management inside install area mechanisms.  The
+	point is to describe special conventions for things to be
+	installed within the installation area.
+
+	We describe that in terms of a set of :
+	
+	   o path-like variable names
+	   o subdirectory patterns bellow $CMTINSTALLAREA
+
+	All those patterns will be used to configure the installation area
+	and to expand the specified PATH-like variables.
+
+	   Ex: 
+	      PATH            is associated with ${CMTCONFIG}/bin
+	      LD_LIBRARY_PATH is associated with ${CMTCONFIG}/lib
+	      CLASSPATH       is associated with share/bin
+
+	   we could think of having those patterns defined in the
+	   requirements file.
+
+	* src/cmt_parser.cxx (do_remove_library_links): Handle symlinks
+	induced by the <package>_libraries macros through INSTALLAREA
+	mechanisms
+	(do_build_library_links): (idem)
+	(set_standard_macros): Setup operations for InstallArea have been
+	grouped using InstallPathPatterns
+	(do_config): Add cleanup of install area
+
+2003-01-23  Christian Arnault  <carnault@lxplus032.cern.ch> 115
+
+	* src/cmt_syntax.cxx (class KwdBuildStrategy): Support extension
+	of build_strategy with install_area mechanisms.
+
+	* src/cmt_system.cxx (mkdir): Suppress the error message when one
+	cannot create a directory
+
+	* fragments/application (install_bin_dir): 
+	* fragments/library_no_share (install_lib_dir): 
+	* fragments/library (install_lib_dir): Use CMTINSTALLAREA instead of INSTALLAREA
+
+	* src/cmt_parser.cxx (do_build_library_links): Use install area
+	mechanisms when the build_strategy is active rather than
+	symlinking into the binary directory of the package.
+
+	(set_standard_macros): Add the generation of CMTINSTALLAREA
+	environment variable, the prepending of PATH, LD_LIBRARY_PATH,
+	CLASSPATH when install_area is active
+
+	* src/cmt_install_area.cxx: 
+	* src/cmt_install_area.h (class CmtInstallAreaMgr): New class for
+	managing install area mechanisms.
+
+	* src/cmt_parser.h (enum): Add InstallArea in BuildStrategy
+
+2003-01-22  Christian Arnault  <carnault@lxplus032.cern.ch> 114
+
+	* src/cmt_use.cxx (find_index): Bad use of a static local variable
+	implying wrong management of -import= options
+	(get_index): Adding accessor function to m_index private attribute
+
+	* src/Makefile.header (.DEFAULT): Remove temporary debugging action 
+
+2003-01-21  Christian Arnault  <carnault@lxplus032.cern.ch> 113
+
+	* src/cmt_symbol.cxx (all_print): Restore two-steps process for
+	generating setenv calls (first normal env. variables then path-like)
+	(all_print_clean): 
+
+2002-12-20  Christian Arnault  <carnault@lxplus032.cern.ch> 112
+
+	* src/cmt_parser.cxx (do_show_strategies): put a space character 
+
+	* mgr/Makefile (cpp): Add the -O2 compiler option on default platforms
+
+	* mgr/requirements: Privately try the construction of the new CMTCONFIG
+
+	* src/cmt_parser.cxx (parse_arguments): Add cmt --version equivalence to cmt version
+
+2002-12-19  Christian Arnault  <carnault@lxplus032.cern.ch> 111
+
+	* mgr/requirements: Change the name of cmt_cc_version.sh to
+	cmt_dcc_version.sh for case insentivity of Darwin file system
+
+	* fragments/application (install_lib_dir): 
+	* fragments/library (install_lib_dir): 
+	* fragments/library_no_share (install_lib_dir): 
+
+2002-12-18  Christian Arnault  <carnault@lxplus032.cern.ch> 110
+
+	* src/cmt_symbol.cxx (resolve_value_for_macros): We have to
+	suppress the conversion from %xxx% to $(xxx) on non-windows
+	platform, since there were some occurrences of %xxx% patterns,
+	which have a meaning in unix world!!
+
+	* src/Makefile.header (.DEFAULT): Only run once sub-makefile
+
+	* src/cmt_symbol.cxx (all_print_clean): Keep order of generation
+	of sets and paths (instead of sets then paths)
+
+	* mgr/cmt_cc_version.sh: Helper scripts for compiler query commands
+	* mgr/cmt_cxx_version.sh: 
+	* mgr/cmt_CC_version.sh: 
+	* mgr/cmt_gcc_version.sh: 
+
+	* mgr/cmt_filter_version.sh: 
+
+	* fragments/constituents_header (first): Make use of cmt show setup
+	
+	* src/cmt_parser.cxx (do_show_setup): Display sections rather than from the Makefile
+	
+	* src/cmt_use.cxx (class use_action_iterator): action_show_setup
+	traverses the private subtrees (like show_uses)
+
+	* src/cmt.h (class Cmt): 
+	* src/cmt_parser.cxx (do_show_setup): 
+	* src/cmt_parser.h (enum): Add action_show_setup for grouping show uses,tags,path
+
+	* mgr/requirements: Manage a common (sh/csh) style for output
+	redirection for system query commands
+
+	* fragments/library_no_share (install_lib_dir): 
+	* fragments/library (install_lib_dir): 
+	* fragments/application (install_bin_dir): Use cmt_install_command
+	instead of install_command for install area mechanisms to avoit
+	conflicts with the installer document generator
+
+2002-12-18    <ARNAULT@lal.in2p3.fr> 109
+
+	* src\cmt_parser.cxx (do_show_strategies): Add display of setup strategy
+	(print_context): Apply the build strategy
+
+	* src\cmt.h (class Cmt): Add get/set current_setup_strategy methods
+	(class Cmt): Add m_current_setup_strategy attribute
+
+	* src\cmt_parser.h (enum): Add SetuStrategy enumeration
+
+	* src\cmt_syntax.cxx (class KwdSetupStrategy): Add SetupStrategy class 
+
+	* src\cmt_parser.h (enum): Add setup_strategy keyword to control
+	the production of <PACKAGE>CONFIG and <PACKAGE>ROOT env. variables
+
+	* src\cmt_parser.cxx (class StandardMacroBuilder): Add few debug printouts
+
+	* src\cmt_use.cxx (find_index): The returned index must be the
+	m_index attribute of the Use object rather than the index in the
+	use list of the package!!
+
+2002-12-16  Christian Arnault  <carnault@lxplus032.cern.ch> 108
+
+	* src/Makefile.header (binclean): Add a quick binclean target
+	(all): prepend a systematic config target 
+
+	* fragments/constituents_header (all): Suppress dummy messages in gmake all and config
+
+2002-12-16    <ARNAULT@lal.in2p3.fr> 107
+
+	* src\cmt.h (class Cmt): do_help remembers of the current action
+	being parsed to have cmt help action
+
+	* src\cmt_syntax.h (class CommandParser): Command parsing
+	mechanisms. So far only the help is handled. General map-based
+	parsing mechanism is foreseen
+
+	* src\cmt_parser.h (enum ActionType): Add global actions for
+	build, check, show only for error and help management
+
+	* src\cmt_syntax.cxx (show): Command Help management introduced (will be improved)
+
+	* src\cmt_parser.cxx (parse_arguments): Improve command help with SyntaxParser  
+
+	* mgr\requirements: Adding specs for query commands on WIN32
+
+2002-12-12  Christian Arnault  <carnault@lxplus032.cern.ch> 106
+
+	* mgr/Makefile: Remove the mail sending after CMT rebuild... (!!!)
+
+	* src/cmt_symbol.cxx (resolve_macro_value): Detects patterns like:
+	`$(macro-name)` within symbol definitions. The specified macro is expected 
+	to contain a shell command that will then be executed when expanding 
+	the macro.
+
+	* mgr/requirements: Add some system information queries:
+	hardware
+	system_version
+	compiler_version
+
+	* mgr/cmt_filter_version.sh: Add a filtering script for system version
+	informations.
+
+2002-12-12    <ARNAULT@lal.in2p3.fr> 105
+
+	* mgr\requirements:  make use of SyntaxParser
+	* src\cmt_triggers.cxx: idem
+	* src\cmt_use.cxx: idem
+	* src\cmt_parser.cxx: idem
+	* src\cmt_pattern.cxx: idem
+
+	* src\cmt_syntax.cxx: 
+	* src\cmt_syntax.h (class Kwd): Introduce the new syntax parsing
+	mechanism. It is based on a cmt_map of keyword objects. All requirements parsing 
+	operations are now implemented in the SyntaxParser singleton.
+
+	* src\cmt_parser.cxx (do_build_library_links): Introduce the
+	cmt_symlink_cmd macro to override the internal management of
+	symlink creation in case this is unavailable (eg on Windows)
+
+2002-12-11  Christian Arnault  <arnault@lal.in2p3.fr> 104
+
+	* src/cmt_parser.cxx (do_set_versions): Make use of cmt broadcast
+	to install version files in all packages. Inherit broadcast syntax.
+	
+	(do_broadcast): Add possibility to use template like in patterns
+	Start with <version>.
+
+	* mgr/Makefile (cpp): Add profiling option
+
+	* fragments/check_java (check): Add run options
+
+	* src/cmt_use.cxx (find): Use Package grouping of uses
+	(find_index): Use index registration information
+	(move): Use index registration information
+	(reorder): idem
+	(need_new): Revisit the algo to avoid useless multiple reading of requirements files 
+	(add): Use index registration information
+	(operate): Improve for without version directory style
+	(Package): Introduce Package grouping of Use objects 
+
+	* src/cmt_parser.cxx (do_set_versions): Use Package::is_cmt feature.
+
+	* src/cmt_string.cxx (replace): Optimize by reducing the calls to strlen.
+
+	* src/cmt_generator.cxx (build_dependencies): Use Package::is_cmt feature.
+
+	* src/cmt_include.cxx (print_all): Use Package::is_cmt feature.
+
+	* src/cmt_script.cxx (all_print_clean): Use Package::is_cmt feature.
+
+	* src/cmt_database.cxx (pattern_list_map): Discard dump features
+
+	* src/cmt_database.h (class Database): Restore tag management.
+	Introduce PatternList and Package management
+
+	* src/cmt_project.cxx (class ProjectMgr): Suppress tag management
+	from projects. Make it back to global management (from Database)
+
+	* src/cmt_pattern.h (class PatternList): Introduce PatternList
+	class to group pattern by names. This class contains a list of
+	Patterns of the same name but originating from different uses.
+
+	* src/cmt_use.h (class Use): renaming uses() to get_ordered_uses() and
+	all_uses() to get_instances ()
+
+2002-12-10  Christian Arnault  <arnault@lal.in2p3.fr> 103
+
+	* src/cmt_project.h (class Project): Add a tag_map to manage tags 
+
+	* src/cmt_tag.cxx (add): Add a tag_map to manage tags
+
+	* src/cmt_tag.h (class Tag): Introduce a map of tags
+
+	* src/cmt_database.cxx (symbol_map): install a map of symbols
+
+	* src/cmt_database.h (class Database): install a map of symbols
+
+	* src/cmt_symbol.cxx (create): Use symbol map to find existing symbols
+	(find): idem
+	(symbol_map): access to the map of symbols from the database
+	(clear_all): clear the database and the map
+
+	* src/cmt_symbol.h (class Symbol): Introduce the new typedef
+	SymbolMap for a cmt_map of Symbols
+
+	* src/cmt_map.h: Introduce cmt_map.h implementing a map (binary tree)
+
+	* src/cmt_regexp.cxx (cmt_regexp): Rename cmt_node to cmt_regexp_node
+	* src/cmt_regexp.h: Rename cmt_node to cmt_regexp_node
+
+2002-12-09  Christian Arnault  <arnault@lal.in2p3.fr> 102
+
+	* fragments/check_java (check): Add run options (global and local)
+
+2002-12-09  Christian Arnault  <carnault@lxplus032.cern.ch> 101
+
+	* mgr/requirements: Fix typo (trailing backslash)
+
+	* src/cmt_parser.cxx (parser): Add set versions operation to perform a
+	global set version onto all used packages.
+	(do_set_versions): Start implementing a draft scenario
+	(parser): the set versions action require parsing the use graph.
+
+	* src/cmt.h (class Cmt): idem.
+	
+	* src/cmt_parser.h (enum): idem
+
+	* src/cmt_parser.cxx (configure_current_package): Set the default
+	version expression in absence of both version directory AND
+	version file to "v*" (instead of "v0")
+
+	* src/Makefile.header (binclean): Add new standard target for
+	erasing at once the $(bin) directory
+
+2002-12-08    <ARNAULT@lal.in2p3.fr> 100
+
+	* src\cmt_parser.cxx (do_set_version): 
+	(scan_path): Improving the management of various structuring styles for the FileScanner.
+	(do_show_strategies): Displays structuring style in show_strategies
+	(reach_current_package): Prepare the removal of automatic addition of the
+	current package area to CMTPATH...
+	(do_config): Fix discovery of structuring style
+	(configure_current_package): Fix discovery of structuring style
+	(class SequenceRunner): Accept version argument in sequence files
+
+	* src\cmt.h (class Cmt): 
+	* src\cmt_parser.h (enum): Add set version command to install version.cmt file
+
+	* src\cmt_system.cxx (is_version_directory): Handle wild cards in
+	version ids detection
+
+	* mgr\requirements: Add Darwin definitions
+
+	* mgr\cmt_make_shlib_common.sh (temp_shlib): Protect against
+	module files with space in their names
+
+	* mgr\requirements: try to remove CMT/v from PATH rather then CMT
+	only so as to keep subpackages of CMT
+
+	* src\cmt_use.cxx (set_auto_imports_state): fix a bug on use pointer comparisons.
+
+	* fragments\nmake\constituent: 
+	* fragments\nmake\constituents_header (dirs): fix naming scheme : only .nmake
+
+	* mgr\NMake (cmt): protect VisualC.nmake generation against
+	reminder of the physical location of the rebuild
+
+	* src\demo\demoA\requirements: Add PATH towards java on Windows
+
+	* mgr\NMake: Add a target to re-generate VisualC.nmake inside CMT
+	so as to have proper nmake demo
+
+	* mgr\requirements: provide debug_option for WIN32 platform
+
+	* fragments\nmake\make_header (tags): Suppressed
+	$(CMTCONFIG),$(CMTEXTRATAGS) and only keep $(CMTEXTRATAGS)
+
+	* fragments\nmake\constituents_trailer: added to NMake family
+	* fragments\nmake\group: added to NMake family 
+
+2002-12-05    <ARNAULT@lal.in2p3.fr> 99
+
+	* src\cmt_vector.h (cmt_vector): replace static int frame_size by
+	enum {frame_size} to C++ ANSI compliance.
+
+	* src\cmt_use.cxx (BestFitSelector::operate): When structurig
+	style is withut-version-directory, the version field of the
+	package may still contain wild cards. This has to be considered
+	when checking compatibility.
+
+2002-12-04  Christian Arnault  <carnault@lxplus032.cern.ch> 98
+
+	* src/cmt_use.cxx (set_auto_imports_state): bug fix (corresponding to v1r12p20021129)
+
+2002-10-30  Christian Arnault  <carnault@lxplus032.cern.ch> 97
+
+	* src/cmt_vector.h (cmt_vector): define frame_size as a static
+	const int instead of enum
+
+2002-10-15  Christian Arnault  <carnault@lxplus032.cern.ch> 96
+
+	* src/cmt_use.cxx: Protect against use objects badly recorded
+	within auto_imports_state vectors
+
+	* src\cmt_parser.cxx (scan_path): Fix algo to scan packages to
+	cope with no-version style
+	(class StandardMacroBuilder): Fix no-auto-imports algo 
+
+2002-09-24  Christian Arnault  <arnault@lal.in2p3.fr> 95
+
+	* mgr/ChangeLog.php: Introduce the online filter for ChangeLog file
+
+	* doc/documents.html: Use PHP to filter out ChangeLog
+
+	* mgr/Makefile (docs): Install ChangeLog and ChangeLog.php into web site
+
+	* src/setup.zsh: Add an empty leading line to avoid shell problems...
+
+	* src/Makefile.header (config): force the rebuild of $(tag).make
+
+2002-08-06  Christian Arnault  <arnault@lal.in2p3.fr> 94
+
+	* fragments/library: Split action list so as to force the rebuild
+	of shared libraries when it has been lost while shstamp is still
+	there.
+
+2002-06-21    <arnault@lal.in2p3.fr> 93
+
+	* src/cmt_parser.cxx (class SequenceRunner): Add support for comments in the sequence files
+	(do_show_macro_names): 
+	(do_show_set_names): 
+	(print_symbol_names): 
+	
+	(class StandardMacroBuilder): prepare the production of
+	<constituent>_use_linkopts but let it unsused for the time being
+
+	(class StandardMacroBuilder): fix a typo
+	
+	(class StandardMacroBuilder): fix a bug
+
+	* src/cmt_parser.h (enum): 
+	* src/cmt.h (class Cmt): Adding do_show_macro_names,
+	do_show_set_names, print_symbol_names functions
+
+	* src/setup.tcsh: 
+	* src/setup.zsh: move the -quiet option before verb to avoid confusion with new syntax for show xxxs
+
+	* src/demo/tprivate.cmt: 
+	* src/demo/demo1.cmt: improve test sequences
+
+	* mgr/requirements: add the macro preproc to prepare new scheme
+	for dependency generation using cpp -MD
+
+	* mgr/Makefile (cpp): Specialize default cpp according to the platform
+	(hosts): we don't need BOOL hosts anymore
+	(demo): the demo sequence now exploits the sequence runner of CMT
+	(tprivate): new test sequence on private uses.
+
+	* mgr/ChangeLog.awk: Adding this awk script to convert the ChangeLg file int HTML format
+
+	* doc/CMTDownload.html: 
+	* doc/download.html: 
+	* doc/install.html: doc improvements
+
+	* fragments/application: Temporarily stop using $(${CONSTITUENT}_use_linkopts)
+
+	* src/NMakefile.header (tag): 
+	* src/Makefile.header (tags): 
+	* fragments/nmake/constituents_header (tag):
+	* fragments/nmake/make_header (tag):
+	* fragments/constituents_header (tag):
+	* fragments/make_header (tag): Add $CMTCONFIG to tags
+
+2002-05-29    <arnault@lal.in2p3.fr> 92
+
+        * src\cmt_database.cxx: 
+        * src\cmt_database.h: 
+        * src\cmt_project.h (class Project): 
+        * src\cmt_project.cxx (Project): Introduce Project management
+
+        * mgr\requirements: Define the default project CMT
+
+        * src\cmt_parser.h (enum): 
+        * src\cmt_parser.cxx (select): 
+                Introduce apply_tag statements<br>
+                Introduce first iteration on project management
+        
+        * src\cmt_symbol.cxx (action): replace direct access to member of
+        tag objects by accessor functions.
+
+        * src\cmt_tag.cxx (add): 
+        * src\cmt_tag.h (class Tag): 
+                Clean up the for private members only<br>
+                introduce action_apply to activate a tag from a requirements file<br>
+                introduce tag expressions -> this defines primary tags versus
+                computed ones. Selection is either obtained from m_selected for
+                primary tags or computed from operands otherwise.
+                so far only AND expressions are available.
+
+2002-05-28  Christian Arnault  <arnault@lal.in2p3.fr> 91
+
+        * src/cmt_symbol.cxx (select_last): Make use of Tag::is_selected 
+
+        * src/cmt_tag.cxx (is_selected): 
+        * src/cmt_tag.h (class Tag): Add and_operands for defining tags
+        from a bool expression of primary tags. Move selected to private
+        area to ensure usage of is_selected which may compute the
+        selection state from operands. The embedded state is now reserved
+        to primary tags.
+
+2002-05-28  Christian Arnault  <carnault@lxplus040.cern.ch> 90
+
+        * src/cmt_awk.cxx (class Parser): Replace the basic parsing engine
+        by the local Parser class. It takes care of both EOL styles (Unix
+        and Win) and of trailing backslashes for continuations.
+
+        * src/cmt_awk.h (class Awk): Added a function inc_line_number to
+        increment the line number from the external text parser.
+
+        * src/cmt_cvs.cxx (filter): Added debug messages
+
+        * src/cmt_parser.cxx (do_awk): 
+        * src/cmt_parser.h (enum): Added action_awk
+        * src/cmt.h (class Cmt): Added do_awk function for testing the Awk operator.
+
+2002-05-27    <arnault@lal.in2p3.fr> 89
+
+        * doc\todo.html: Adding entries
+
+2002-05-24  Christian Arnault  <carnault@lxplus012.cern.ch> 88
+
+        * src/cmt_cvs.cxx (class CvsImplementation): fix few problems with
+        no_version_directory.
+
+2002-05-23  Christian Arnault  <arnault@lal.in2p3.fr> 87
+
+        * src/demo/scenario.awk: Adapt to handle without_version_directory style
+
+        * src/demo/demo1.cmt: fix a typo 
+
+        * src/cmt_parser.cxx (parse_requirements): Fixing bug on private
+        macros for without_version_directory style
+
+        * mgr/Makefile (demo): Improving the demo scenario manager
+
+2002-05-22  Christian Arnault  <arnault@lal.in2p3.fr> 86
+
+        * doc/download.html: 
+        * doc/CMTDownload.html: 
+        * src/cmt_version.h (CMTVERSION): preparing tagging for v1r13...
+
+        * src/cmt_use.h (class Use): new helpers
+
+        * src/cmt_use.cxx (class use_action_iterator): re-design the scope
+        hiding for private uses (was buggy for first level private uses)
+        (reach_package): structuring style
+        (get_full_path): new helper for centralizing the full package path
+        computation
+        (reduce_path): new helper to normal form with $<PACKAGE>ROOT
+        (get_paths): add debug prints
+        (show_sub_uses): structuring style
+
+        * src/cmt_system.h (class CmtSystem): 
+        * src/cmt_system.cxx (reduce_file_separators): helper to reduce
+        multiple file separators into one
+        (is_package_directory): structuring style
+
+        * src/cmt_pattern.cxx (apply): add debug prints
+
+        * src/cmt_parser.h (enum): Add CmtStructuringStyle options
+
+        * src/cmt_parser.cxx: 
+         Introducing support for structuring style. 
+         m_current_structuring_style global variable
+         (scan_path): 
+         (scan_package): 
+         (run): 
+         (PackageCollector::run): 
+         (configure): calling configure_current_structuring_style
+         (configure_current_package): 
+         (configure_current_structuring_style): new method
+         (do_broadcast): use Use::get_full_path
+         (do_config): 
+         (do_create): 
+         (do_help): 
+         (do_lock): suppress unused local variable
+         (do_remove): 
+         (do_show_macros): add pattern for selection instead of default '*'
+         (do_show_sets): idem
+         (do_unlock): suppress unused local variable
+         (get_current_strategy): new method
+         (install_cleanup_scripts): install cleanup scripts on windows
+         (load): 
+         (parse_arguments): re-number argument array
+         (parse_arguments): support arguments for cmt show macros
+         (parse_arguments): support arguments for cmt show sets
+         (parse_arguments): -with_version_directory option
+         (parse_arguments): -without_version_directory option
+         (parse_requirements): 
+         (parser): support arguments for cmt show macros
+         (parser): support arguments for cmt show sets
+         (print_context): use Use::get_full_path
+         (print_macros): selection pattern (reg. expression) on symbols
+         (reach_current_package): 
+         (set_standard_macros): add getting pwd
+         (set_standard_macros): structuring style
+
+        * src/cmt_generator.cxx 
+         (SourceFile::set): use CmtSystem::reduce_file_separators 
+         (prepare_use_context): idem
+         (prepare_use_context): use Use::get_full_path
+         (set_full_name): idem
+         (build_make_setup): idem
+
+        * src/cmt_fragment.cxx
+         (print): use Use::reduce_path factorization
+         (locate): use Use::get_full_path factorization
+         (locate): Support structuring style options
+
+        * src/cmt_cvs.cxx: 
+          + need cmt.h for accessing structuring style
+          + support for structuring style
+
+        * src/cmt.h (class Cmt): 
+        Adding support for structuring style
+	
+        do_show_macros now accepts arguments
+
+        do_show_sets now accepts arguments
+
+        print_macros now accepts a pattern for selecting symbols
+
+        * src/demo/tprivate.cmt: Scenario for testing private uses and
+        -no_auto_imports
+
+        * src/demo/demo1.cmt: Scenario for the general test/demo sequence. 
+        
+        * src/demo/scenario.awk: Add a script for installing
+        scenarios. This script can
+          - create packages
+          - install text files relatively to the packages.
+
+        * mgr/Makefile (demo): Replace the copy operations for the demo
+        targets by an awk-based mechanism (only for Unix -> keep old
+        mechanism for Windows). The scenario.awk script is able to create
+        packages and install text files into the newly created packages.
+
+        Add a target (a scenario) for testing private uses and
+        -no_auto_imports
+
+        Add an help target describing all special targets.
+
+        * fragments/constituents_header (first): Differentiate setup.make
+        with the package name when $(bin) is common.
+
+2002-05-17  unknown  <arnault@lal.in2p3.fr> 85
+
+        * doc/todo.html: Adding a web page for ToDo list, and bug reports.
+
+        * src/cmt_parser.cxx (install_test_setup_scripts): 
+        * src/cmt_parser.cxx (install_test_cleanup_scripts): Fix the bug
+        to "source setup" standalone with a current directory outside the
+        package itself.
+
+2002-05-15  Christian Arnault  <arnault@asc.lal.in2p3.fr> 84
+
+        * src/cmt_version.h (CMTVERSION): Preparing the new tag v1r12p20020515
+
+        * doc/CMTDoc.html: Upgrade the documentation.
+
+        * src/setup.tcsh:
+        * src/setup.zsh: Add all_tags to the list of know show options
+
+        * src/cmt_tag.cxx (show_definition): 
+        * src/cmt_tag.h (class Tag): Added Tag::show_definition
+        (unfiltered show method wrt the selected state)
+
+        * src/cmt_parser.cxx (do_help): Implement the new cmt show all_tags command.
+
+        * src/cmt.h (class Cmt): Added Cmt::do_show_all_tags ()
+
+        * src/cmt_parser.h (enum): Added action_show_all_tags
+
+        * mgr/requirements: remove -I$(inc) from default value of ccomp
+        macro (no longer needed and has side effects)
+
+        * src/cmt_use.cxx (add): Protect against null use pointer when not found.
+
+        * src/cmt_tag.cxx (action): do increase the tag ref list when
+        overridden. It used to be un-overridden...
+
+        * fragments/constituents_trailer (clean): add a semi-colon between the two shell commands.
+        
+        * src/cmt_system.cxx (create_symlink): Explicit .c_str() in system calls.
+
+        * doc/table.html: setup a direct URL to CVSWeb rather than through
+        an intermediate page
+
+2002-04-12  Christian Arnault  <carnault@lxplus030.cern.ch> 84
+
+        * doc/CMTDoc.html: 
+        * src/setup.zsh: 
+        * src/setup.tcsh: 
+        * src/cmt_parser.cxx (do_help): 
+        * src/cmt.h (class Cmt): 
+        * src/cmt_parser.h (enum): introduce action_show_all_tags do
+        display all defined tags (while action_show_tags only shows all
+        active tags)
+
+        * fragments/constituents_trailer (clean): typo in the clean target.
+
+2002-04-11    <arnault@lal.in2p3.fr> 83
+
+        * src\cmt_parser.cxx (print_clean): Suppress the unset of CMTCONFIG
+
+2002-04-10    <arnault@lal.in2p3.fr> 82
+
+        * fragments\library: 
+        * fragments\library_no_share: Suppress the experimental change for 
+        erasing the object files after filling the library
+
+2002-04-10  Christian Arnault  <carnault@lxplus044.cern.ch> 81
+
+        * src/cmt_version.h: preparing tagging for v1r12
+
+
+        
+        * mgr/requirements: Adapt to Darwin
+
+        * src/cmt_symbol.cxx (action): 
+        * src/cmt_use.cxx (action): 
+        * src/cmt_use.h (class Use): Introduce m_has_native_version
+
+        * mgr/requirements: Add standard $(library_prefix) and $(library_suffix) macros
+
+        * mgr/cmt_make_shlib_common.sh (temp_shlib): Set verbose mode to
+        the linker command and control it through the QUIET macro. Fix the
+        temporary expansion directory
+        
+        * mgr/cmt_make_shlib_common.sh (temp_shlib): 
+        * fragments/library_header: 
+        * fragments/cleanup_library: Add standard $(library_prefix) and $(library_suffix) macros
+
+        * fragments/constituents_trailer (makefilesclean): 
+        * fragments/constituent: remove specific makefile fragments for
+        the constituents (instead of *.make)
+
+        * fragments/library_no_share: 
+        * fragments/library: erase *.o files after filling the library
+
+        * src/cmt_use.h (class Use): Add use::sub_use_auto_imports to save
+        specifications on sub uses. Add Use::set_auto_imports to possibly
+        promote auto_imports to sub uses when it is changed from Off to
+        On.
+
+        * src/cmt_parser.h (enum): 
+        * src/cmt_pattern.cxx (show_all_applied_patterns): 
+        * src/cmt_pattern.h (class Pattern): adding Pattern::show_all_applied_patterns ()
+        * src/setup.tcsh: 
+        * src/setup.zsh: 
+        * src/cmt_parser.cxx (do_help): 
+        * src/cmt.h (class Cmt): Adding Cmt::do_show_applied_patterns for
+        the new command "cmt show applied_patterns"
+
+2002-04-04  Christian Arnault  <carnault@lxplus044.cern.ch> 80
+
+        * src/cmt_use.cxx (add): Protect against duplicated registration of
+        current_use.
+
+        * src/cmt_parser.cxx (install_setup_scripts): Append an empty line
+        at the end of the generated setup script (problem on some shells)
+        
+        * src/cmt_parser.cxx (do_create): 
+        * src/cmt.h (class Cmt): Change the signature of the do_create
+        function to receive its arguments from the "arguments" list rather
+        than changing current_package etc...
+
+        * src/Makefile.header: Add a systematic config target (for backward compatibility)
+
+        * fragments/constituents_trailer (binclean): added the binclean
+        target to completely remove the binary directory at once.
+
+        * fragments/make_header: 
+        * fragments/constituents_header: 
+        * fragments/nmake/make_header (CMTEXTRATAGS): 
+        * fragments/nmake/constituents_header (CMTEXTRATAGS): Remove the settings of CMTCONFIG
+
+2002-03-22  Christian Arnault  <carnault@lxplus037.cern.ch> 79
+
+        * src/cmt_symbol.cxx (suppress_OS_delimiters): operate on %...%
+        patterns only on Windows machines.
+
+2002-03-20  Christian Arnault  <carnault@lxplus042.cern.ch> 78
+
+        * mgr/Makefile (Atlas): Suppress HP rebuild for Atlas group
+
+        * src/cmt_cvs.cxx (filter): Improve the recursive passes and
+        handle the new qualifiers of the use statements.
+
+        * fragments/cleanup_header (clean): Fix bad insertion of the .DEFAULT target
+
+        * src/cmt_symbol.cxx (suppress_OS_delimiters): Introduce this new
+        function to ensure that only $() syntax is used in tag makefiles
+        (ie suppress ${} and %% syntaxes)
+        (show_macro): apply this new function for action_build_tag_makefile
+
+        * src/cmt_generator.cxx (reset): Do not generate the Visual
+        directory on non-windows machines
+
+        * fragments/group (clean): Suppress one echo on gmake clean
+
+2002-03-14  Christian Arnault  <carnault@lxplus037.cern.ch> 77
+
+        * src/cmt_parser.cxx (set_standard_macros): Cleanup management of m_current_tag
+
+2002-03-07  Christian Arnault  <carnault@lxplus048.cern.ch> 76
+
+        * src/cmt_parser.cxx (print_context): Suppress the automatic
+        settings of CMTEXTRATAGS
+
+        * src/Makefile.header: Do not change CMTCONFIG
+        * src/NMakefile.header: Do not change CMTCONFIG
+
+2002-02-27  Christian Arnault  <carnault@lxplus042.cern.ch> 75
+
+        * fragments/jar: Adding removal of jar file for clean target
+
+        * src/cmt_use.cxx (show_sub_uses): show no_auto_imports status
+
+        * src/cmt_parser.cxx (reach_current_package): reapply global
+        pattern at once until side effects are solved in user projects.
+
+        * fragments/jar: Apply an old fix to Unix fragments (was applied
+        to Windows only)
+
+2002-02-26  Christian Arnault  <carnault@lxplus016.cern.ch> 74
+
+        * src/cmt_use.cxx (move_to): select_alternate must be applied
+        after reach_package for searches against an absolute path or
+        against the current directory.
+
+2002-02-25    <arnault@lal.in2p3.fr> 73
+
+        * fragments/cleanup_header (clean): Add default action
+
+        * src/Makefile.header (common_target): Remove debug print
+
+        * src\cmt_parser.cxx (parse_requirements): Apply global patterns
+        right after parsing a requirements file, and only considering the
+        Use context, one at a time (rather than applying all global
+        patterns to all Uses at once after reading all requirements file)
+
+        * src\cmt_pattern.cxx (apply_all_globals): 
+        * src\cmt_pattern.h (class Pattern): Add a method to apply all
+        global patterns in the context of only one Use object.
+
+2002-02-24    <arnault@lal.in2p3.fr> 72
+
+        * src\cmt_system.cxx (command_separator): New method for getting
+        the shell command separator (& or ;)
+
+        * src\cmt_cvs.cxx (class CvsImplementation): Add
+        CmtSystem::command_separator() between cvs co of each branch
+        (instead of newlines).
+
+        * src\cmt_system.cxx (has_device): Accepts the \\xxx\ syntax as a
+        device name in file paths on windows.
+
+        * src\cmt_parser.cxx (configure_cmt_path): Hide show_set action
+        when recursive definition of CMTCONFIG
+
+        * src\cmt_use.cxx (need_new): Some optimizations
+        
+        * src\cmt_use.cxx (move_to): Exchange the priority of CMTPATH
+        versus version when selecting the best version.
+
+        * src\cmt_parser.cxx (use_cmt): Hide CMTDEBUG while parsing the
+        requirements of CMT itself
+
+2002-02-20  Christian Arnault  <arnault@lal.in2p3.fr> 71
+
+        * src/cmt_parser.cxx (do_broadcast): Fix a bug for setting the
+         style the the Current use. This effect was induced by the new
+         mechanism for constructing the Current Use object, now a singleton
+         of the Use class.
+
+2002-02-07    <arnault@lal.in2p3.fr> 70
+
+        * src\cmt_use.cxx (change_path): Add a m_located flag in Use class
+        to record the success of the package localization. Test against
+        this info instead of real_path to allow for package found in
+        current directory (where real_path stays empty)
+
+        * src\cmt_parser.cxx (configure): 
+
+        * src\cmt_use.cxx (show_sub_uses): Ensure that the cmt show uses
+        displays the correct scoping information for uses and
+        sub-uses. cmt show uses also displays the full tree even when it
+        contains private uses.
+
+2002-02-06    <arnault@lal.in2p3.fr> 69
+
+        * src\cmt_use.cxx (class use_action_iterator): Install UseContext
+        to manage proper propagation of -no_auto_imports
+
+2002-01-30    <arnault@lal.in2p3.fr> 68
+
+        * src/cmt_parser.cxx (parse_arguments): Fix the bug of private
+        environment variables which could not be set even within the
+        package (bug in the management of the -pack= -version= -path=
+        options).
+
+        * src/cmt.h : Install all attributes of the Cmt class as private
+        attributes, and make them follow the convention : m_xxx. This
+        implies to install few accessor methods.
+
+2002-01-29    <arnault@lal.in2p3.fr> 67
+
+        * src/cmt_use.cxx (class use_action_iterator): The private uses
+        are accessed for 
+            - broadcast operations
+            - show uses operations
+
+        * src/cmt_symbol.cxx (action): Expands the specified script name
+        for the setup_script and cleanup_script statement.
+          Protect against empty script names.
+
+2002-01-11  Christian Arnault  <carnault@lxplus035.cern.ch> parallelbuilds
+
+        * src/Makefile.header: Reorganize basic Makefile fragment
+        generation to permit better support for parallel & concurrent
+        builds.  Mimize also the number of makefile fragments generated
+        and kept : only $(tag).make remains in ../cmt . All other are
+        thrown away after use.
+
+        Make those changes a branch "parallelbuilds"
+        
+
+2002-01-09  Christian Arnault  <carnault@lxplus001.cern.ch> 66
+
+        * src/NMakefile.header (tags): Apply the fix for tags onto
+        NMakefile.header
+
+2002-01-07    <arnault@lal.in2p3.fr> 65
+
+        * src/Makefile.header (tags): Attempt to fix the continuity break
+        between v1r9 and v1r10, by re-installing the possibility to use
+        gmake tag=<...> rather than having to use source setup.[c]sh
+        -tag=<...>
+
+        (This fix has to be tested before any validation)
+
+2001-11-26  Christian Arnault  <carnault@atlas50.cern.ch> 64
+
+        * Tagging v1r10p20011126
+        
+        * src/Makefile.header: tag is now ${CMTCONFIG} and tags ${CMTEXTRATAGS}
+
+        * mgr/requirements: Provide the macro tags as ${CMTEXTRATAGS}
+
+        * src/cmt_tag.cxx: Various changes in strategy for tags:
+          - tag inclusion (defined by the "tag" statement) transmits the priority.
+          - tag selection can be discarded by exclusion specifications. Exclusion 
+          qualifies a set of contradictory tags. Contradictory tags will be selected
+          according to their priority or to their declaration order in case of
+          equal priority.
+
+        * src/cmt_parser.h (enum Priority): Change the priority list:
+        Arguments get highest priority
+        then CMTCONFIG
+        then user tags (those defined in requirements)
+
+        * fragments/make_setup: produce uses.make and tags.make
+
+        * src/cmt_parser.cxx (parse_arguments): 
+        * src/cmt.h (class Cmt): Suppress the mechanism of
+        primary_tag. CMTCONFIG is enough.
+
+2001-11-21  Christian Arnault  <carnault@lxplus040.cern.ch> 63
+
+        * src/cmt_symbol.cxx (add_value_to_list): fix protection on
+        value_list.size () to start at 1 (not at 2)
+
+        * src/cmt_symbol.cxx (build): Reflective values of Sets should
+        consider previous setenv settings.
+
+        * src/cmt_generator.cxx (build_dependencies): Using ../$(tag) for
+        output base of the dependencies fragment rather then
+        Cmt::current_tag
+
+        * src/Makefile.header (CMTPRIMARYTAG): tag=... argument of gmake
+        will override CMTPRIMARYTAG. However internal tag macro is only
+        replaced with ${CMTCONFIG}
+
+        * fragments/make_setup (config): create a tags.log (for cmt show
+        tags)
+
+        * mgr/cmt_make_shlib_common.sh: Add the ${lib} prefix to the
+        temporary expansion directory. Fix a bug in sed filter for all
+        module files.
+
+        * src/cmt_parser.cxx (configure_tags): Add a protection against
+        absence of CMTPRIMARYTAG
+
+        * src/cmt_system.cxx (create_symlink): 
+        * src/cmt_system.h (class CmtSystem): Adding the create_symlink
+        function.
+
+        * src/cmt_parser.cxx (do_build_library_links): Using direct system
+        calls to create symlinks.
+
+2001-11-13  Christian Arnault  <carnault@lxplus010.cern.ch> 62
+
+        * Tagging v1r10p20011113
+
+        * mgr/requirements:
+        * src/constituents.make (build_library_links): Define macros for
+        build_library_links and remove_library_links
+
+        * fragments/make_setup (config): Add build_library_links target
+
+        * src/cmt_parser.cxx (set_standard_macros): Fix bad production of
+        use_includes when private is used.
+
+        * src/cmt_parser.cxx (do_broadcast): Fix -begin=<pattern> error
+
+2001-11-08  Christian Arnault  <carnault@lxplus028.cern.ch> 61
+
+        * src/cmt_version.h: tagging v1r10
+
+        * src/cmt_system.cxx (add_cmt_path): Get cwd alias to each selected path.
+
+        * src/cmt.h (class Cmt): Add cmt_path_cwd vector of all CMTPATH
+        entries normalized to getcwd.
+
+        * src/cmt_generator.cxx (java_file_action): 
+        * src/cmt_generator.cxx (proto_file_action):
+        * src/cmt_generator.cxx (module_file_action): Pass reference to the constituent in order
+        to transmit constituent variables to the fragment.
+
+        * src/cmt_parser.cxx (set_standard_macros): Insert a space
+        character for all generated macro_append operations.
+
+        * src/cmt_fragment.cxx (xxxcopy): 
+        * src/cmt_fragment.h (class Variable): Adding the expansion of
+        fragments variables using both the ${} syntax AND the $() syntax.
+
+        * src/cmt_tag.h :
+        * src/cmt_tag.cxx (is_selected): Change the Tag::selected attribute to bool.
+
+2001-11-07  Christian Arnault  <carnault@lxplus006.cern.ch> 60
+
+        * src/cmt_symbol.cxx (build): Implement the possibilty to have
+        reflexive asignment to symbols: when a symbol value is exactly
+        specified (from set, macro or path statements) using $(<name>) or
+        ${<name>} or %<name>% then the old value is preserved for all
+        corresponding selectors.
+
+        * src/cmt_parser.cxx (set_standard_macros): Re-activate -import
+        options (that had been discarded!)
+
+        * src/cmt_use.cxx (add): Generate an error when a package is not
+        found (the error was only generated at "cmt show uses")
+
+        * src/cmt_constituent.cxx (show): Display -import options
+
+        * fragments/dependencies: Force checking $(bin) 
+
+        * fragments/constituent: Adding some printout to display when
+        constituent fragment is rebuilt
+
+        * src/cmt_parser.cxx (set_standard_macros): Re-validate
+        -no_auto_imports option for use and -import options for
+        constituents.
+
+2001-11-06  Christian Arnault  <carnault@lxplus038.cern.ch> 59
+
+        * src/cmt_generator.cxx (build_document_makefile): protect against
+        missing files (causing infinite loops in Make)
+
+2001-11-05  Christian Arnault  <carnault@lxplus005.cern.ch> 58
+
+        * mgr/Makefile (application_suffix): Define application_suffix in
+        the CMT's Makefile
+
+        * src/cmt_parser.cxx (print_context): Do not generate ROOT and
+        CONFIG for cmt_standalone packages.
+
+        * mgr/requirements: Reomving the cmt_selector.cxx source file.
+
+        * src/constituents.make: Force the dirs target for
+        build_library_links
+
+        * src/cmt_parser.cxx (restore_all_tags): Get the value of
+        CMTPRIMARYTAG to configure Cmt::primary_tag.
+
+        Leave unchanged the primary_tag and the extra_tags except if
+        overridden through the -tagxxx= options
+
+        * src/cmt_parser.h (enum): Add PrioritySite in the list of
+        possible priorities.
+
+        * src/cmt.h (class Cmt): Add the restore_all_tags function. Add
+        the extra_tags attribute . Change the strategy of tag persistency:
+
+          o CMTPRIMARYTAG always contains what had been specified using
+        the -tag= option,
+
+          o CMTEXTRATAGS contains what had been manipulated by -tag_add=
+        and -tag_remove= options.
+
+          o CMTCONFIG is setup independently of the primary tag.
+
+        * src/Makefile.header (primary_tag): Propagate tags using
+        CMTPRIMARYTAG instead of CMTCONFIG (except when CMTPRIMARYtAG is
+        not yet defined)
+
+        * src/cmt_constituent.cxx (parse): Fix the word parsing for
+        constituent specification...
+
+2001-11-02  Christian Arnault  <arnault@asc.lal.in2p3.fr> 57
+
+        * src/cmt.h
+        * src/cmt_database.cxx
+        * src/cmt_database.h
+        * src/cmt_parser.cxx
+        * src/cmt_parser.h
+        * src/cmt_selector.cxx
+        * src/cmt_selector.h
+        * src/cmt_symbol.cxx
+        * src/cmt_symbol.h
+        * src/cmt_tag.cxx
+
+        * src/cmt_tag.h:
+        Suppressing cmt_selector objects (only tags are needed!!)
+        Add tag_exclude keyword for building tag-exclusions.
+
+2001-10-31  Christian Arnault  <carnault@atlas50.cern.ch> 56
+
+        * mgr/requirements: Don't need to explicitly declare make_fragment
+        headers (automatically declared in the -header= option)
+
+        * src/cmt_symbol.cxx (print_clean): Cleaning up path variables may
+        be either unsetenv when the result is empty or setenv if not.
+        
+        * fragments/application_launcher: evolution
+
+        * src/cmt_parser.cxx (configure_tags): protect against empty
+        declaration of CMTCONFIG : by default will take uname...
+
+2001-10-30  Christian Arnault  <carnault@atlas50.cern.ch> 55
+
+        * src/cmt_symbol.cxx (clean): Implement the cleanup correctly,
+        with in particular the cleanup of the path variables.
+
+        * src/cmt_parser.cxx (print_context): improve output of cmt show tags
+
+        * src/cmt_symbol.h (class Symbol): Add clean_macro_value for
+        building the result of the clean operations induced by this symbol
+        (only implemented for path_xxx)
+
+        * src/cmt_parser.cxx: New post-context requirements file :
+        user_context in addition to home package.  Added Use* use
+        arguments to configure_xxx functions to transfer.
+
+        * src/cmt_parser.cxx(configure_cmt_path): Attempt to make use of
+        CMTPATH definitions from requirements files.
+
+        * src/cmt_parser.cxx(configure_config_selector): Install context
+        information for tag creation
+
+        * src/cmt_parser.cxx(configure_home): Attempt to make use of
+        CMTHOME definitions from requirements files.
+
+        * src/cmt_parser.cxx(configure_user_context): Install user_context
+        management
+
+        * src/cmt_parser.cxx(configure_site_selector): Get CMTSITE from
+        requirements as well
+
+        * src/cmt_parser.cxx(configure_tags): Add a configure_tags
+        finction to retreive tags from all possible sources: CMTCONFIG
+        (from req) then CMTPRIMARYTAG then CMTCONFIG then CMTBIN then
+        append all CMTEXTRATAGS.
+
+        * src/cmt_parser.cxx(parse_arguments): fix parsing bug for the
+        -home= argument
+
+        * src/cmt_parser.cxx(parser): Set action_show_path to be recursive
+
+        * src/cmt_parser.cxx(parser): Call the HOME package just after
+        using CMT. Call the use_context package just after reaching the
+        current package.
+
+        * src/cmt_parser.cxx(print_clean): reformat the output (with
+        newlines). Clear CMTPRIMARYTAG CMTEXTRATAGS and CMTCONFIG.
+
+        * src/cmt_parser.cxx(print_context): set CMTPRIMARYTAG
+        CMTEXTRATAGS and CMTCONFIG from the current definitions.
+
+        * src/cmt_parser.cxx(set_standard_macros): Rationalize the
+        production of current_tag
+
+        * src/cmt_parser.cxx(use_user_context_requirements): 
+
+        * src/cmt_use.cxx (show_all): Display new user_context package
+
+        * src/cmt_use.cxx (class use_action_iterator): query function ok()
+        includes both home_package and user_context_package
+
+        * src/cmt_use.cxx (reach_package): special treatment for
+        home_package and user_context_package since they do not follow the
+        standard location scheme.
+
+        * src/cmt_use.cxx (add): Improve the detection of packages not found.
+
+        * src/cmt_tag.cxx (unmark): Reset the use pointer
+
+        * src/cmt_tag.cxx (action): Install the use origin.
+
+        * src/cmt_tag.cxx (add): Install the use origin and the context
+        information. It will be reset to the new context in case of
+        re-definition. Suppress various excessive debug printouts.
+
+        * src/cmt_tag.cxx (clear): clear use and context new information
+
+        * src/cmt_tag.cxx (show): Improve the display of tags with
+        hierarchical display of subtags and context information.
+
+        * src/cmt_tag.h (class Tag): Added Use* use parameter to action
+        and add methods. Store a pointer to the package (Use*) who
+        originated the definition, and a context string to qualify the
+        definition.
+
+        * src/cmt_system.h (class CmtSystem): 
+        * src/cmt_system.cxx (add_cmt_paths_from_text): Factor out the
+        code to register a set of CMTPATH entries, with the context
+        information.
+        
+        * src/cmt_system.cxx (is_home_package): Add is_home_package and
+        is_user_context_package query functions.
+
+        * src/cmt_system.cxx (get_cmt_site): Default site is empty
+        (instead of LAL)
+
+        * src/cmt_symbol.cxx (print_clean): Suppress some obsolete
+        print_tabs () formattings. Apply unset instead of unset for
+        aliases as well.
+        
+        * src/cmt_symbol.cxx (action): Add special treatment for CMTXXX
+        environment variables : the new setting has to be taken into
+        account as soon as it is parsed.
+
+        * src/cmt_selector.cxx (create): remove some debug code.
+
+        * src/cmt_generator.cxx (build_default_makefile): Produce only
+        Makefile on Unix and only NMake on Windows.
+
+        * mgr/requirements: Renaming new script_launcher fragments into
+        application_launcher
+
+        * src/cmt.h (class Cmt): Added Use* use arguments to configure_xxx
+        functions to transfer.
+        
+        Added use_user_context_requirements () to include post-context
+        requirements file.
+
+        Added the static value primary_tag to store the primary tag.
+        
+
+        * src/cmt_generator.cxx (build_default_makefile): Create Makefile
+        only un Unix and NMake only on WIN32
+
+2001-10-24  Christian Arnault  <carnault@lxplus038.cern.ch> 55
+
+        * src/cmt_parser.cxx (parser): add the recursive property to
+        action_show_path.
+
+        * src/cmt_system.h (class CmtSystem): 
+        * src/cmt_system.cxx (get_user_context_package): 
+        * src/cmt_system.cxx (is_user_context_package): 
+        * src/cmt_use.cxx (add): 
+        (show_all): 
+        (class use_action_iterator): 
+        (reach_package): 
+        (add): 
+        * src/cmt_parser.cxx (configure): 
+        * src/cmt_parser.cxx (parser): 
+        * src/cmt_parser.cxx (parse_arguments): 
+        * src/cmt_parser.cxx (configure_user_context): 
+        * src/cmt.h (class Cmt): 
+
+        Adding user_context equivalent of CMTHOME support for post
+        requirements file. The corresponding env. var. is CMTUSERCONTEXT.
+        The complete scheme for supporting PRE-parsed HOME requirements
+        file is exactly copied to those POST-parsed files.
+
+        * mgr/requirements: 
+        * fragments/script_launcher_header: 
+        * fragments/script_launcher:         
+        * fragments/script_launcher_trailer: Introduce a new document
+        generator for launching scripts. The same convention as the
+        check_application is reused, for pre-action, argument passing and
+        post-action. Several scripts (specified in the source list of the
+        document) can be executed in sequence.
+
+        * src/cmt_use.cxx (class use_action_iterator): 
+        * src/cmt_system.cxx (is_home_package): 
+        * src/cmt_system.h (class CmtSystem): Add the is_home_package
+        function to encapsulate the syntax of a HOME package (and apply it
+        in Use::use_action_iterator)
+
+        * src/cmt_symbol.cxx (action): Prepare specific actions when the
+        parsed symbol is one of the CMTXXX standard symbols. So far
+           CMTHOME -> re-configure home.
+
+        * src/cmt_parser.cxx (parser): apply use_home_requirements right
+        after reading CMT requirements file (ie. before reading current
+        package)
+
+        * src/cmt_parser.cxx (configure_home): understand the possible
+        "set CMTHOME" declarations (but keep $CMTHOME)
+
+        * src/cmt_parser.cxx (reach_current_package): * src/cmt_system.cxx
+        (get_cmt_paths): Restore the automatic addition of "current
+        package" in the CMTPATH list.
+
+        * src/cmt_parser.cxx (parse_arguments): bad parsing of the
+        -home=xxx argument
+
+        
+
+2001-10-23  Christian Arnault  <carnault@lxplus007.cern.ch> 54
+
+        * mgr/Makefile (demo): Need to add CMTPATH towards ${CMTROOT}/demo
+        since CMTPATH to current package is no longer supported !!!
+
+        * fragments/nmake/check_application (check): 
+        * fragments/nmake/cleanup_application: 
+        * fragments/nmake/application_header: 
+        * fragments/nmake/application: 
+        * fragments/application: 
+        * fragments/application_header: 
+        * fragments/cleanup_application: 
+        * fragments/check_application (check): 
+        * mgr/requirements: Create a new standard macro
+        "application_suffix" for making possible to change the .exe
+        default suffix of applications
+
+2001-10-22  Christian Arnault  <carnault@lxplus026.cern.ch> 53
+
+        * src/cmt_parser.cxx :
+        * src/cmt_system.cxx : Suppress the automatic addition of current 
+        package's path into CMTPATH.
+
+        * mgr/Makefile: Change the method to rebuild
+        cmt_dependencies by copying what is obtained from CVS. Rebuild it
+        manually when needed.
+
+2001-10-19  Christian Arnault  <carnault@lxplus025.cern.ch> 52
+
+        * fragments/make_setup (config): Creating uses.log needs to use an
+        intermediate temporary file
+
+        * src\setup.[c]sh : Avoid re-definition of CMTCONFIG
+
+        * src\cmt_use.cxx (add): temporarily discard the mecanism by which
+        uses.log files are read before the requirements files.
+
+        * src\cmt_system.cxx (is_version_directory): returns -1 for fields
+        that were wildcarded
+
+        * src\cmt_use.cxx (add): 
+        * src\cmt_use.cxx (need_new):         
+        * src\cmt_use.cxx (BestFitSelector::operate): Start the
+        implementation of priority control between explicit use
+        specification over wildcarded ..
+
+        * src\cmt_parser.cxx (reach_current_package): Change the value of
+        the CMTPATH for the current package once it has been reached (but
+        before reading its requirements file)
+        
+        * src\cmt_parser.cxx (install_setup_scripts): (improvement) Add the transfer of
+        arguments towards cmt.exe into setup.bat
+
+        * src\cmt_system.cxx (get_cmt_paths): (bug fix) path_sources was
+        not cleared as paths.
+        Prepend "current path" to the path list under "current package".
+
+        * src\cmt_parser.cxx (parse_arguments): (bug fix) Suppress
+        enclosing quotes around cmt.exe arguments so that setup.bat can
+        transmit arguments properly
+
+        call setup.bat "-tag_add=a,b,c"
+
+2001-10-18  Christian Arnault  <carnault@lxplus047.cern.ch> 51
+
+        * src/cmt_parser.cxx (set_standard_macros): Set current_tag to
+        CMTBIN when in CMT itself (not complete yet)
+        
+        * src/cmt_generator.cxx (build_dependencies): Use CMTBIN for CMT
+        itself (instead of current_tag) well this should be cured later on
+        to ensure that current_tag is always set to CMTBIN for CMT itself
+
+        * src/cmt_version.h (CMTVERSION): install v1r10 (not tagged yet)
+
+        * mgr/cmt_system.sh: Do not try to use AFS on Darwin and LynxOS.
+
+        * src/setup.[c]sh: Define CMTBIN as `uname` on Unix and CMTCONFIG
+        as `cmt_system.sh`
+
+        * src/cmt_symbol.cxx (show_macro): the trailing space must be
+        added only for WIN32 !!
+
+2001-10-17  Christian Arnault  <carnault@lxplus047.cern.ch> 50
+
+        * src/cmt_symbol.cxx (show_macro): add a trailing space on all
+        macro definitions (to avoid problem of trailing backslash)
+        
+        * src/cmt_parser.cxx (set_standard_macro): remove the insertion of
+        trailing spaces after the last backslash for WIN32/NMake
+
+        * src/constituents.make (all): (bug fix) re-install the
+        build_library_links action for the all target
+
+2001-10-11  Christian Arnault  <carnault@lxplus021.cern.ch> 49
+
+        * src/cmt_version.h: Tagging for v1r9p20011011
+        
+        * fragments/library: (bug fix) transmit both -tag=<tag> and
+        -tag_add=<tag_list> to cmt_make_shlib_common.sh
+
+2001-10-11  Christian Arnault  <arnault@asc.lal.in2p3.fr> 48
+
+        * src/cmt_parser.cxx: remove debug print options
+
+2001-10-10  Christian Arnault  <arnault@asc.lal.in2p3.fr> 47
+
+        * src/cmt_parser.cxx (parse_arguments): fix problems in multiple
+        tag management.
+
+        converge in the question of HOME requirements file to support
+          - no default
+          - define the path to the HOME requirements file in ${CMTHOME}
+
+        converge in the arguments for manipulating the extra tags
+          -tag=<tag>
+          -tag_add=<tag-list>
+          -tag_remove=<tag-list>
+
+2001-10-03  Christian Arnault  <carnault@lxplus036.cern.ch> 46
+
+        * src/constituents.make (makefilesclean): Make all action lists
+        run in one single shell (ie. use ;\ everywhere)
+
+        Make an explicit target for build_library_links
+        Make it called before any group
+
+2001-10-02  Christian Arnault  <carnault@lxplus007.cern.ch> 45
+
+        * src/cmt_awk.h (class Awk): add a state variable
+        (m_continuation_allowed) which when true, take into account the
+        trailing backslashes, so as to first accumulate continued lines
+        into one. Add the allow_continuation method to base Awk class.
+
+2001-10-01  Christian Arnault  <carnault@lxplus034.cern.ch> 44
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Bug in
+        checkout_from_requirements. Did not accept leading spaces on use
+        statements.
+
+2001-09-27  Christian Arnault  <carnault@lxplus036.cern.ch> 43
+
+        * src/cmt_version.h: Tagging for v1r9p20010927
+
+        * src/setup.zsh: add the -begin option to the auto-expansion.
+
+        * src/cmt_use.cxx (show_all): Visualize the HOME package when
+        applicable.
+
+        * src/cmt_system.cxx (get_home_package): (also do some formatting
+        cleanup)
+        
+        * src/cmt_system.h (class CmtSystem): Adding get_home_package
+        function to build the name given to the HOME package (provides the
+        HOME requirements file)
+
+2001-09-26  Christian Arnault  <arnault@asc.lal.in2p3.fr> 42
+
+        * src/cmt_parser.cxx (do_show_macro): Improving error detection on
+        cmt show macro/set
+
+        * doc/CMTDoc.html: Improve the doc.
+
+        * src/cmt_parser.cxx (print): produce the CMTEXTRATAGS environment
+        variable, at setup time.
+                             (parse_arguments): take into account this new 
+        env.var. to retreive previous extra tags.
+
+        * src/Makefile.header: Add the CMTEXTRATAGS environment variable
+        to propagate additional tags to Make.
+        
+        * fragments/make_setup: 
+        * fragments/constituent: 
+        * src/Makefile.header:
+        * src/constituents.make: Adding  -tag=$(tags) to all calls to cmtexe
+
+        * src/cmt_system.h (class CmtSystem): Adding the bool testenv
+        (name) function to test if an environment variable is defined or
+        not.
+
+        * src/cmt_parser.cxx (use_home_requirements): 
+        * src/cmt.h (class Cmt): Adding support of CMTHOME environment
+        variable for specifying home requirements file. Default value will
+        be ${HOME}. And can be overridden through the -home=<directory>
+        global option. An explicit empty value (or set to eg. NONE) will
+        discard the feature
+
+        * src/cmt_parser.cxx (parse_arguments): Implement the tag list
+        (comma separated list of extra tags) option -tag=<tag-list> to
+        specify a list of tags to validate.
+
+2001-09-25  Christian Arnault  <carnault@lxplus034.cern.ch> 41
+
+        * src/setup.csh: fixed PATH settings (may accept a path with space
+        characters eg. for Darwin)
+        
+        * mgr/cmt_system.sh: Insert the knowledge of Darwin OS (Mac OS
+        X). The default CMTCONFIG will be Darwin.
+
+        * src/constituents.make (makefilesclean): Ensure that removal of
+        makefile fragments is performed AFTER all cleanup uperations.
+
+        * src/cmt_parser.cxx (use_home_requirements): Add the systematic
+        search for a requirements file located in ${HOME}. This
+        requirements file when found, is systematically parsed AFTER the
+        requirements file of the current package has been parsed (so as to
+        give the highest precedence to its statements)
+        
+        (do_remove_library_links): Upgrade "remove library_links" to make
+        it compliant to the algorithm used in "build library_links"
+
+2001-09-24  Christian Arnault  <carnault@lxplus014.cern.ch> 40
+
+        * src/cmt.h (class Cmt): * src/cmt_parser.cxx (configure): Add a
+        global configure_error variable to store the possible error
+        produced during the configuration.
+        (install_test_setup_scripts): Add the -quiet option to the build
+        temporary_name command used in setup script generation.
+
+        * src/cmt_error.cxx (get_last_error): 
+        * src/cmt_error.h (class CmtError): Add get_last_error to retrieve
+        the formatted text of the last error.
+
+        * src/cmt_symbol.cxx (create): 
+                             (all_print): 
+                             (print): 
+                             (build): 
+        * src/cmt_parser.cxx (select): Understand the "path" statement as
+        a complete re-definition of a path-like variable.
+
+        * src/cmt_system.cxx (add_cmt_path): 
+        * src/cmt_error.cxx (class Error): 
+        * src/cmt_error.h (class CmtError): Adding "path not found" error
+        code, for CMTPATH checking.
+
+        * src/cmt_pattern.cxx ((const cmt_string& name): Return a warning
+        for pattern not found.
+
+        * src/cmt_error.h (class CmtError): 
+        * src/cmt_error.cxx (class Error): Adding "pattern not found" error
+        code, for showing diagnostics in "cmt show pattern"
+
+        * src/cmt_parser.cxx (do_show_macro): Return a warning for symbol
+        not found.
+
+        * src/cmt_error.h (class CmtError): 
+        * src/cmt_error.cxx (class Error): Adding "symbol not found" error
+        code, for showing diagnostics in "cmt show macro/set"
+
+2001-09-19  Christian Arnault  <carnault@lxplus045.cern.ch> 39
+
+        * mgr/cmt_make_shlib_common.sh : return a status value which
+        reflects the success or failure of the shared library build
+        command.
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Discard the versions
+        specified with wild cards in the recursive checkout.
+
+        * src/cmt_triggers.cxx: Protect the error messages in the trigger
+        facility by Cmt::quiet.
+
+        * src/cmt_constituent.cxx (class constituents_action_iterator):
+        temporarily discard the -triggers option.
+
+2001-08-24  Christian Arnault  <carnault@lxplus011.cern.ch> 38
+
+        Tagging v1r9p2001p0824
+
+2001-08-24  Christian Arnault  <carnault@lxplus011.cern.ch> 38
+
+        * mgr/cmt_system.sh: Improve the reliability of the cmt_system.sh
+        script against variants of "fs sysname"
+
+2001-08-23  Christian Arnault  <carnault@lxplus030.cern.ch> 37
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Since the tag filter
+        is back to cmtcvs.cxx, the temporary forced tag filter in CMT is
+        removed.
+
+        * src/setup.zsh: upgrade the completion for the broadcast command.
+
+        * src/cmt_parser.cxx (do_broadcast): Make the -select independent
+        of the -local or -global options. This is achieved by adding a
+        "path_selections" list only managed by the -depth, -local -global
+        modifiers while the "selections" list is managed by the -select
+        modifier. The -exclude is left unchanged.
+
+2001-08-22  Christian Arnault  <carnault@lxplus024.cern.ch> 36
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Add the possibility
+        to transmit a flag to the CVS pluggin, by inserting a /cmtcvstest
+        in the module name to import. This will have to be decoded by the
+        CVS pluggin itself !!
+
+2001-08-21  Christian Arnault  <carnault@lxplus013.cern.ch> 35
+
+        * src/setup.tcsh: Improving the tcsh completion mechanism (for cmt co).
+
+        * src/setup.zsh: Improving the zsh completion mechanism (for cmt co).
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Converging on HEAD
+        management strategy...
+
+        Starting implementation of the Atlas filter for CVS tags right
+        into cmt_cvs.cxx rather than inside the CVS pluggin...
+
+2001-08-20  Christian Arnault  <carnault@lxplus028.cern.ch> 34
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Improving the
+        recursive checkout process
+
+2001-08-20    <arnault@lal.in2p3.fr> 33
+
+        * src\cmt_cvs.cxx (class CvsImplementation): Reorganizing some CVS operations:<ul>
+          <li> Apply the CMTCVSOFFSET env. variable to all actions (tags, branches, subpackages)
+          <li> cleanup checkout algorithms (remove some obsolete variables)
+          <li> add the -requirements <requirements-file-path> option to checkout according to
+            a set of use statements.
+          <li> remove the inheritance to Awk of CvsImplementation to split the filter into 2
+            phases (implemented as 2 separated Awk derived classes) RecursivePass1 and
+            RecursivePass2.</ul>
+
+2001-08-16  Christian Arnault  <carnault@lxplus046.cern.ch> 32
+
+        * src/cmt_symbol.cxx (print): Bug in path_remove when the
+        specified path variable only contained one item : the remove
+        operation was not applied.
+
+2001-07-20  Christian Arnault  <arnault@lal.in2p3.fr> 31
+
+        * src/cmt_version.h: setting the patch v1r9p20010720
+
+2001-07-20  Christian Arnault  <carnault@lxplus019.cern.ch> 30
+
+        * src/cmt_regexp.h (cmt_regexp::begin): Add an optional pos
+        argument to the begin method.
+
+        * doc/CMTDoc.html: Improvements, English cleanup...
+
+2001-07-18  Christian Arnault  <carnault@lxplus041.cern.ch> 29
+
+        * src/cmt_cvs.cxx (CvsImplementation::checkout_package): Change
+        the mechanism to get top files, since the " -d . " does not work
+        anymore when CVSROOT is set to kserver!!!!
+
+2001-07-16  Christian Arnault  <carnault@lxplus030.cern.ch> 28
+
+        * doc/CMTDoc.html: Old PREFIX fragment variable has been replaced
+        by FILEPATH long ago. This was not upgraded in the doc.
+
+        * fragments/constituent: The -f <file> MUST be specified BEFORE
+        other Make flags!!
+
+        * fragments/dependencies: Tried to comment out the dependencies to
+        cmt_path.make etc... but it confused the dependencies fragment
+        production. Uncomment it but need to understand the side effect.
+
+2001-07-09  Christian Arnault  <carnault@lxplus012.cern.ch> 27
+
+        * src/cmt_generator.cxx (build_readme): Bug: the VERSION variable
+        was not used for installing the readme_trailer (although the
+        documentation was mentioning it)
+
+2001-07-04  Christian Arnault  <carnault@lxplus034.cern.ch> 26
+
+        * src/cmt_version.h: setting the patch v1r9p20010704
+
+2001-07-02  Christian Arnault  <carnault@lxplus034.cern.ch> 25
+
+        * fragments/dependencies: Cleaning some old debug printouts.
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Bug in replacing the
+        wild card expression. v5r* has to be replaced by v5r0 while v5*
+        has to be replaced by v5 in case no matching tag exists in the CVS
+        repository.  Other bug : All split operations should be performed
+        against " \t" (include tab character)
+
+2001-06-29  Christian Arnault  <carnault@lxplus047.cern.ch> 24
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Final Validation of
+        the change in the implementation of the m_installed stack used to
+        avoid recursion due to dependency cycles.
+
+2001-06-22  Christian Arnault  <carnault@lxplus020.cern.ch> 23
+
+        * src/cmt_cvs.cxx (class CvsImplementation): doing some
+        optimizations for the big checkout operations.
+
+        * src/cmt_parser.cxx (do_config): Remove .[n]make files also from
+        the binary directory.
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Always fetch the cmt
+        branch at HEAD even if the checkout operation is applied to a
+        required tag (temporary feature).
+
+2001-06-18    <arnault@lal.in2p3.fr> 22
+
+        * src\cmt_cvs.cxx (class CvsImplementation): insert a space
+        between top tags and other tags.
+
+        * mgr\cmt_make_shlib.bat: Write extra options received through
+        arguments into a temporary option file, used by @<optionfile> to
+        resolve line-too-long prolems.
+
+        * fragments\nmake\cpp_library: 
+        * fragments\nmake\cpp:
+        Add the /Tp qualifier for allowing non-standard file suffixes.
+
+2001-06-05  Christian Arnault  <arnault@lal.in2p3.fr> 22
+
+        * src/cmt_use.cxx (class use_action_iterator): Default to the
+        -no_auto_import was to keep the most recent specification. Change
+        this to always request auto_import by default, (unless otherwise
+        specified)
+
+2001-06-01  Christian Arnault  <arnault@lal.in2p3.fr> 22
+
+        * src/cmt_parser.cxx (do_broadcast): Bug fix in do_broadcast: the
+        -begin option wrongly implied the -global option.
+
+2001-06-13    <arnault@lal.in2p3.fr> 22
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Improving the
+        strategy for getting version tags from the repository:
+          o If a request specifies a tag which is not applied to the 
+            requirements file, the specified tag is used to create the
+            version directory but the HEAD is used in the repository.
+          o CvsImplementation::show_cvs_infos () :
+            stores all received infos into xxx_info corresponding
+            local properties. Thus this method is only called once per
+            package.
+          o Error messages are really obtained from the error_info field.
+
+2001-05-30  Christian Arnault  <arnault@lal.in2p3.fr> 22
+
+        * src/cmt_generator.cxx (build_document_makefile):
+        * src/cmt_system.cxx (get_dot_suffix): fix bug for file_names
+        without any suffix
+
+        * src/cmt.h & src/cmt_parser.cxx (set_standard_macros): Add a
+        state standard_macros_done to protect against multiple calls to
+        set_standard_macros.
+
+2001-05-28  Christian Arnault  <arnault@lal.in2p3.fr> 22
+
+        * src/cmt_cvs.cxx (class CvsImplementation): display the tags in a
+        one-per-line basis instead of space separated when doing cmt
+        cvstags.
+
+        * src/cmt_use.cxx (operate): Make the version selector operator a
+        little bit more quiet...
+
+2001-05-25  Christian Arnault  <arnault@lal.in2p3.fr> 22
+
+        * mgr/Makefile (demo): improve the gmake check action in the demo
+        target.
+
+        * src/cmt_use.cxx (fill_macro_all): build use_xxx standard macros
+        using macro_append instead of macro.
+
+2001-05-22  Christian Arnault  <arnault@lal.in2p3.fr> 22
+
+        * src/cmt_parser.cxx (do_broadcast): Fix the default (-local)
+        option to act as -depth=1.
+        Improve some error messages.
+
+2001-05-21    <arnault@lal.in2p3.fr> 21
+
+        * src\setup.bat: Improved skeleton for setup.bat. Base it on
+        CMTBIN rather than on CMTCONFIG. Do not override CMTCONFIG if
+        defined by the user. Do not care about PATH for Visual tools.
+
+        * mgr\install.mak: change the strategy for building the setup.bat
+        script for CMT itself at INSTALL time. Now copy ..\src\setup.bat
+        skeleton.
+
+        * mgr\requirements: Fix WIN32/VisualC tag definitions and PATH
+        settings for cleaner handling of default tag overriding.
+
+        * src\cmt_use.cxx (operate): Implement the algorithm for using
+        aliases to alternate version specification in uses.
+
+-------------------------------------------------------------------------------------
+2001-05-18  Christian Arnault  <arnault@lal.in2p3.fr> 21
+
+        -> Tag CMTv1r9p20010521
+
+        * src/cmt_use.cxx (show_sub_uses): Start the implementation of
+        version_alias and path_alias for equivalencing two version naming
+        policies.
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Adding the -o offset
+        option to cmt checkout for specifying a global offset to the base
+        CVS repository. This offset will be prepended to all modules
+        during the various CVS operations.
+
+        the m_offset attribute is added to the CvsImplementation class.
+
+        (class CvsImplementation): Improve protection against CVS modules
+        not found.
+        
+        (class CvsImplementation): Added the --help option the cmt checkout.
+
+2001-07-10  Christian Arnault  <carnault@lxplus017.cern.ch> b-21
+
+        * mgr/requirements: add the -tag=$(tag) option to the
+        build_dependencies macro.
+
+        * fragments/dependencies: take the improvements into account.
+
+        * src/cmt_generator.cxx (build_dependencies): Improve the
+        dependency builder: re-generate all entries of the
+        <constituent>_dependencies.make that are missing from the complete
+        source list (thus regenerate it when it is empty).
+        Optimize the file scan for getting the new source list.
+
+        * src/cmt_parser.cxx (do_build_dependencies): Dynamically shifts
+        arguments of the build dependencies command to keep only the
+        new-source-list. The complete command being 
+        "cmt <args> build dependencies <constituent-name> <new-source-list>"
+        
+        (do_config): drop all makefile fragments from the mgr/cmt
+        directory AND from the binary directory.
+
+2001-05-11  Christian Arnault  <arnault@lal.in2p3.fr> 20
+
+        * Moving to v1r8
+        
+        
+2001-05-11  Christian Arnault  <arnault@lal.in2p3.fr> 19
+
+        * src/cmt_deps_builder.cxx (): Augmented local internal
+        line buffer (from 1024 to 16384).
+
+        * doc/CMTDoc.html: document the new &lt;package>_root macro
+
+        * src/cmt_parser.cxx (set_standard_macros) (get_best_form): Define
+        a new set of standard macros using the pattern <package>_root
+        similar to <PACKAGE>ROOT except that this new definition uses the
+        get_best_form, with a relative path to the package. The
+        <PACKAGE>ROOT macro is restored to the previous convention, that
+        it uses the absolute path.
+        
+        * src/cmt_use.cxx (fill_includes_macro): Adapt the
+        fill_includes_macro to use the new <package>_root standard macro
+
+
+2001-05-10  Christian Arnault  <arnault@lal.in2p3.fr> 18
+
+        * src/cmt_parser.cxx (do_broadcast): Add the -begin=<pattern>
+        option to start the broadcast loop from a given package. This
+        option can be combined with other options such as -select or
+        -exclude.
+
+        * src/cmt_generator.cxx (filter_paths): Suppress two unused
+        variables.
+
+        * src/cmt_use.cxx (add): Bug fixing: during the discovery of
+        versions requested for a given package, the discarded versions
+        were not correctly replaced by the finally selected version,
+        especially in the Use::get_paths method. The
+        Use::get_selected_version has been added to obtain the effective
+        replacement for a discarded version.
+
+        * fragments/check_application: suppress the ". setup.sh" before
+        application run.
+
+2001-05-04  Christian Arnault  <carnault@lxplus023.cern.ch> 17
+
+        * src/cmt_parser.cxx (set_standard_macros): The production of all
+        use_xxx standard macros now is based on a "macro_append" keyword
+        instead of "macro", since "macro" resets all previous
+        definitions. Therefore if the user's requirements did augment
+        those use_xxx macros, these specifications would be ignored.
+        
+        (do_broadcast): Set the -local option to broadcast the
+        default. Add the -global option to revert to the old default (with
+        no selection and to any depth)
+
+2001-05-03  Christian Arnault  <carnault@lxplus019.cern.ch> 17
+
+        * src/cmt_symbol.cxx (add_value_to_list): A new macro or set
+        keyword resets (discards) all previous definitions for the
+        corresponding symbol.
+
+        * src/cmt_symbol.h (class SymbolValueList): Added an attribute
+        discarded for symbol resetting.
+
+        * src/cmt_parser.cxx (print_macros): Exclude scripts from macros
+        defined in the $(tag).make file.
+
+2001-04-27  Christian Arnault  <carnault@lxplus022.cern.ch> 16
+
+        * src/cmt_parser.cxx (get_best_form): Validate the compression
+        algorithm for paths to packages (only for the macro <PACKAGE>ROOT
+        - this is still not true for the <PACKAGE>ROOT environment
+        variable) into a relative form when it is shorter than the
+        absolute form.
+
+        * src/cmt_system.cxx (compress_path): Fix the algorithm for
+        compressing the patterns "aaaa/xxxx/../bbbb" into aaaa/bbbb.
+
+        * src/cmt_generator.cxx (filter_paths): use
+        CmtSystem::compress_path instead of duplicating its algorithm for
+        erasing "/aaa/.." patterns
+
+2001-04-25  Christian Arnault  <carnault@lxplus022.cern.ch> 15
+
+        * src/cmt_parser.cxx (set_standard_macros): Prepare the production
+        of <PACKAGE>ROOT macros as relative paths rather than absolute
+        ones, when the relative expression is shorter than the absolute
+        one. Temporarily, trigger that feature by setting the
+        CMTTESTPREFIX environment variable until absence of side effects
+        is confirmed.
+
+2001-04-18  Christian Arnault  <carnault@atlas009.cern.ch> 15
+
+        * src/cmt_generator.cxx (build_readme): bug when generating the
+        readme_trailer fragment : the PACKAGE variable should be reset to
+        current.
+
+2001-04-11  Christian Arnault  <arnault@lal.in2p3.fr> 15
+
+        * src/cmt_generator.h (class Generator): 
+        * src/cmt_parser.cxx (do_build_readme): 
+        * src/cmt.h (class Cmt): do_build_readme now propagates argument list
+
+        * fragments/readme_trailer:
+        * src/cmt_generator.cxx (build_readme): Added DATE and USER information when building the README.html file. readme_trailer fragment updated accordingly.
+        
+        (build_readme): Add the -url=<url> argument to the cmt build
+        readme command. The specified URL will be used in place of the
+        package path when generating the URL for used packages.
+
+2001-04-18  Christian Arnault  <arnault@lal.in2p3.fr> 14
+
+        * src/cmt_symbol.cxx (build): In all builder objects, symbol value
+        lists registered by discarded Uses are now ignored.
+
+        * src/cmt_symbol.h (class SymbolValue): cleanup a comment.
+
+        * src/cmt_symbol.cxx (print): protect setup script execution
+        against missing files.
+
+2001-04-10  Christian Arnault  <arnault@lal.in2p3.fr> 13
+
+        * src/cmt_generator.cxx (build_readme): 
+        * fragments/readme_use: building readme.html requires to know the
+        mgr/cmt style of each used package. This fragment now requires a
+        fourth variable MGRSTYLE which reflects the use->mgr_style
+        attribute. Generator::build_readme fills in this new variable.
+
+2001-04-06  Christian Arnault  <arnault@lal.in2p3.fr> 12
+
+        * src/cmt_parser.cxx 
+        (reach_current_package): Use CmtSystem::getenv instead of base getenv
+        
+        * src/cmt_symbol.cxx (action): Now really private stuff is
+        selected when access is at UserMode and scope is Private.
+
+        * src/cmt_use.cxx (add): This method does not need to maintain
+        current scope and access mode any longer.
+
+        * src/cmt_parser.cxx (parse_requirements): Cmt::parse_requirements
+        now manages the AccessMode and Scope when recursing into
+        requirements files of used packages.
+
+        Cmt::scope          handles the sticky state provided by private/public statements
+        Cmt::current_access handles the access mode that reflects the situation of the user
+
+        * src/cmt_parser.h (enum): introduce the AccessMode to distinguish
+        between DeveloperMode (when pwd is in the current package
+        directory) and UserMode (otherwise).
+
+        * src/cmt.h (class Cmt): Cmt::current_mode is now current_access
+        and is of type AccessMode
+
+        * src/cmt_parser.cxx (reach_current_package): Use
+        CmtSystem::getenv instead of base getenv
+
+        * src/cmt_use.cxx (Use::get_paths): 
+        * src/cmt_pattern.cxx (Pattern::apply ()) : bug in computing the
+        path between two Uses. The result now includes the current Use.
+
+2001-04-05    <arnault@lal.in2p3.fr> 12
+
+        * src\cmt_tag.cxx (Tag::add(const cmt_string& name, int priority):
+        clear a newly created Tag object (to deal with the reuse of old
+        objects)
+
+        * src\cmt_pattern.cxx (Pattern::add) : clear a newly created
+        pattern object (to deal with the reuse of old objects)
+
+        * src\cmt_use.h (class Use): Add Use::author_action and
+        Use::manager_action to fill in the author and manager information.
+
+        * src\cmt_parser.cxx (select): fill in author and manager values
+        with the complete line. When several author and manager statements
+        are provided, fill in as several lines (separated with a new-line).
+
+        * src\cmt_generator.cxx (analyze_file (const Constituent&
+        constituent, const cmt_string& file) : production of objects for
+        libraries and applications is strictly identical.
+
+2001-04-03  Christian Arnault  <arnault@lal.in2p3.fr> 11
+
+        * src/cmt_constituent.cxx (clear): constituent.parameters was not
+        cleared in Constituent::clear
+
+        * src/cmt_symbol.cxx (build): add cleanup ValueList objects after
+        their addition for ensuring a really new value (due to cmt_string
+        optimizing)
+
+2001-04-03  Christian Arnault  <carnault@atlas006.cern.ch> 10
+
+        * mgr/Makefile: Operate the demo targets on different make action
+        lines
+
+        * src/Makefile.header: Added -tag=$(tag) to cmt actions
+
+        * fragments/generator_header: create the output directory if
+        needed
+
+2001-04-02    <arnault@lal.in2p3.fr> 9
+
+        * fragments\nmake\constituent: added the -tag=$(tag) option to cmt
+        build actions
+
+        * src\cmt_parser.cxx (parser): show_constituentxxx recursively
+        reads used requirements files
+
+        * src\cmt_pattern.cxx (Pattern::apply () const): protection added
+        for the case where the pattern is applied to the package that
+        defines it.
+
+2001-03-29  Christian Arnault  <carnault@atlas005.cern.ch> 8
+
+        * src/cmt_use.cxx (get_paths): 
+        * src/cmt_use.h (class Use): 
+        * src/cmt_pattern.h (class IgnorePattern): 
+        * src/cmt_pattern.cxx (const apply): Bug in apply global patterns
+        : a pattern defined in one package should only be applied to the
+        Uses that are on one of the paths between the current Use and the
+        one wher the pattern is defined (and not to the Uses that never
+        pretend to inherit that pattern!!!)
+
+        This required to implement the Use::get_paths which fills in the
+        inclusive list of all Uses that are between two Uses.
+
+2001-03-27  Christian Arnault  <carnault@lxplus017.cern.ch> 7
+
+        * fragments/dependencies: protection against missing dependency
+        make fragment during clean operations.
+
+        * src/cmt_constituent.cxx (class constituents_action_iterator):
+        the -suffix= option was hidden by the user variable specification
+        while parsing the constituent parameters.
+
+2001-03-23  Christian Arnault  <carnault@atlas007.cern.ch> 6
+
+        * mgr/requirements: clean up WIN32 tag variants definitions
+
+        * src/Makefile.header (setup.make): Display of the target in case
+        of target not found (.DEFAULT)
+
+        * fragments/make_setup (csh): few checks
+
+        * fragments/installer: add the creation of $(install_dir) if
+        needed
+
+2001-03-21  Christian Arnault  <arnault@lal.in2p3.fr> 5
+
+        * src/cmt_parser.cxx (parse_arguments): When the tag specified in
+        the command line arguments (using -tag=<tag>) is the same as
+        CMTCONFIG, then still validate the tag given by uname
+
+        * fragments/dependencies: generate
+        ${CONSTITUENT}_dependencies.make into $(bin)
+
+        * fragments/constituent: generate ${CONSTITUENT}.make into $(bin)
+
+        * src/cmt_constituent.cxx (parse): 
+        * src/cmt_constituent.h (class Constituent): Added the two-step
+        parsing of the constituents specifications : first stage during
+        parsing of the requirements file, parameters are simply stored in
+        the constituent object and not interpreted. Second stage : after
+        building the standard macros (once requirements files have
+        entirely been read) then constituent objects are parsed.
+
+        * src/cmt_parser.cxx: Add Constituent::parse_all in
+        Cmt::set_standard_macros to finalize the constituent
+        parsing. Install set_standard_macros in several additional actions
+
+
+
+2001-03-16  Christian Arnault  <arnault@lal.in2p3.fr> 4
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Get the files at the
+        top directory when doing a cmt checkout.  
+
+        Only checkout at head for the top package (ie do not recurse at
+        head) and when -r is not specified.
+
+        * src/cmt_symbol.cxx (resolve_value_for_macros): Perform the
+        substitution of ${} to %% (or reverse) even if the env. var. is
+        not defined in CMT.
+
+        * src/cmt_parser.cxx (install_setup_scripts): Setup scripts on
+        Windows generate the temporary expansion script in
+        %HOMEDRIVE%%HOMEPATH%.
+
+2001-03-16  Christian Arnault  <carnault@atlas009.cern.ch> 3
+
+        * mgr/requirements: clean up variants for VisualC and
+        VisualC/debug
+
+2001-03-15    <arnault@lal.in2p3.fr> 2
+
+        * src\cmt_use.cxx (class use_action_iterator): Strange name
+        conflict: the use_action_iterator::set method is in conflict with
+        something else when the class is named "action_iterator" (is it a
+        conflict with the same private class defined in Symbol.cxx ??)
+
+        * src\NMakefile.header (cmtexe): Fix for re-building cmt when
+        cmt.exe does not exist.
+
+2001-03-13  Christian Arnault  <arnault@lal.in2p3.fr> 1
+
+        * src/cmt_use.cxx (class action_iterator): Introducing the
+        action_iterator class for managing the local expansion of macros
+        in the syntax parser (similart to what was done in Symbol::action)
+
+        * src/cmt_generator.cxx (Generator::build_make_setup) when
+        generating setup.make, the default value for constituents is
+        extracted from the constituents macro.
+
+2001-03-06  Christian Arnault  <arnault@lal.in2p3.fr>
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Show both top tags
+        and non-top tags in cmt cvstags.
+
+        * doc/CMT.htm: Addition of several slide shows (from Atlas)
+
+        * mgr/cmt_buildcvsinfos2.sh (error): The awk script had to be
+        protected against multiple ocurrences of the /symbols/,/locks/
+        pattern.
+
+        Implement both in python and in shell script the differntiated
+        production of top tags and non-top tags. Top tags are the set of
+        tags sharing the most recent CVS tagged version id (ie. the HEAD
+        may be more recent)
+
+2001-03-05    <arnault@lal.in2p3.fr>
+
+        * src\cmt_parser.cxx (do_build_library_links): Handle libraries
+        specified as a full path in <package>_libraries
+
+        * src\cmt_parser.cxx (print_context): 
+        * src\cmt_symbol.cxx (all_print): Use one line per
+        env. var. assignment when generating setup scripts (instead of ;
+        separated instructions) . The latter style should be no longer
+        needed since we use temporary files.
+
+        * src\cmt_parser.cxx (set_standard_macros): Add CMTCONFIG to the
+        standard sets, so as to let it known as a plain "symbol"
+
+2001-03-02    <arnault@lal.in2p3.fr>
+
+        * src\cmt_system.h: introduce the CmtSystem::ev_open () and
+        CmtSystem::ev_close () to get the OS-dependent pattern for
+        environment variable definition.
+
+        * src\cmt_symbol.cxx (resolve_value_for_macros): Substitute
+        patterns ${xxx} or %xxx% to the appropriate OS-dependent pattern
+        when producing "set" values only (this is only done when the
+        pattern is not already the good one)
+
+        * src\cmt_parser.cxx (install_setup_scripts): Changed
+        >>${tempfile} into >${tempfile} in setup scripts (fix a constraint
+        in csh)
+
+2001-02-26  Christian Arnault  <arnault@lal.in2p3.fr>
+
+        * src/cmt_parser.cxx (do_build_temporary_name): Add the build
+        temporary_name command to supply that missing function on various
+        shells.
+        (install_test_setup_scripts): Apply this new build service to
+        setup scripts generation.
+
+        * src/Makefile.header: Needed a trailing end-of-line
+
+2001-02-15  Christian Arnault  <arnault@lal.in2p3.fr>
+
+        * src/cmt_cvs.cxx (class CvsImplementation): Fix misuse of
+        checkout_package arguments (confusion between package path and
+        checkout directory)
+
+2001-02-26    <arnault@lal.in2p3.fr>
+
+        * src\cmt_parser.cxx (install_test_setup_scripts): use mktemp for
+        setup scripts.
+
+        * mgr\requirements: Suppress local private configuration of
+        MSVC++. It has to be done previously to operate on CMT (even
+        before making the INSTALL.bat)
+
+2001-02-26  Christian Arnault  <arnault@lal.in2p3.fr>
+
+        * src/cmt_deps_builder.cxx ((char* ptr,
+                              state_def& state,
+                              const cmt_string& dir_name,
+                              int current_path_index,
+                              const CmtSystem::cmt_string_vector& include_paths,
+                              const CmtSystem::cmt_string_vector& substitutions,
+                              CmtSystem::cmt_string_vector& all_deps,
+                              CmtSystem::cmt_string_vector& deps)
+        * src/cmt_generator.cxx ((const cmt_string& file_name)
+
+        Rollback recent change to work on cmt_strings rather than char* to
+        restore speed.
+
+2001-02-15  Christian Arnault  <arnault@lal.in2p3.fr>
+
+        * src/cmt_generator.cxx (build_dependencies): Restore the
+        mechanism that takes into account the arguments, and the source
+        list when -all_sources option is provided.
+
+        * mgr/requirements: change /machine:I386 into /machine:IX86 as
+        link option for VisualC
+
+2001-02-13    <arnault@lal.in2p3.fr>
+
+        * src\cmt_generator.cxx (build_dependencies): Do not require the
+        source list from the arguments. Instead, get the sources directly
+        from the constituents definition.
+
+        The "cmt build dependencies" now only requires the constituent name. 
+
+        * src\cmt_deps_builder.cxx: Read files at once into a cmt_string
+        and work from the text instead of reainf line by line from the file.
+
+        Install the detection of fortran include statements
+
+2001-02-06    <arnault@lal.in2p3.fr>
+
+        * src\cmt_use.cxx: clean up space & tabs
+
+        * cmt_parser.cxx (parse_requirements_text): Abort the parser in
+        case of error, but only for check configuration command.
+
+        * NMakefile.header (lex_echo): Add -quiet option to cmt command
+        except cmt check configuration
+        
+        * constituents.nmake: Add -quiet option to cmt command
+
+2001-01-30    <arnault@lal.in2p3.fr>
+
+        * all dsp fragments : suppress the Win32 Release
+        configuration. Only keep the Win32 Debug. This makes possible the
+        generation of msdev using the syntax cmt build msdev
+        -tag=VisualCdbg
+
+2001-01-30    <arnault@lal.in2p3.fr>
+
+        * mgr/cmt_buildcvsinfos.py: first attempt to make the cvs script
+        written in Python
+
+        * mgr/requirements: Consistently base Windows tag on VisualC rather
+        than WIN32
+
+        upgraded setup.tcsh setup.zsh
+
+        introduced cmt show include_dirs
+        
+        introduced cmt show constituent <name>
+
+        bug in Pattern::add : overridden patterns were not cleared.
+
+        cmt config must recursively get used packages (at least to get patterns)
+
+        introduced cmt show pattern_names (at least for completion mechanisms)        
+          new action : action_show_pattern_names
+
+        experimental work started on build triggers
+        
+          macro build_triggers
+                implied_library_prefix
+                implied_library_sufffix
+
+          new library option -triggers
+          new constituent attribute build_triggers
+          new fragment dependencies_and_triggers for libraries
+
+        bug in cmt_system.cxx::scan_dir
+
+        Recursively get all requirements file in cmt config action
+
+
+        Changed strategy for argument parsing error detection
+        
+2001-01-30    <arnault@lal.in2p3.fr>
+
+        * cmt_use.cxx ((const cmt_string& from_path) : bug in detection of
+        "use pack " without version specification at all (ie equiv. to
+        *). We needed to check we are on a real CMT package.
+
+        * cmt_constituent.cxx (class action_iterator): Expand the macros
+        before acting upon a constituent specification. Each expanded word
+        may then result in several words. Thus the line parser is
+        re-implemented through a local operator class "action_iterator",
+        in charge of filling up a new constituent object from the expanded
+        statement. (Note that this mechanism could perfectly be reused for
+        other statements eg "use" !!!)
+
+        * cmt_parser.cxx (set_standard_macros): Implement all_constituents
+        and all_constituentsclean unconditionally.
+
+        * NMakefile.header (checkuses): if defined statements require that
+        the macro to test is provided without quotes.
+
+        * cmt_generator.cxx: Apply the new convention of installing object
+        files into $(bin)${CONSTITUENTS} also for applications (was only
+        done for libraries)
+
+        * cmt_parser.cxx (print_context): Take the current CONFIG name
+        from CmtSystem::get_cmt_config rather than recursively calling
+        "cmt system", when generating setup scripts.
+
+        * cmt_cvs.cxx (class CvsImplementation): Use '/' ínstead of
+        CmtSystem::file_separator for CVS-only file specs.
+
+2000-12-26    <arnault@lal.in2p3.fr>
+
+        * cmt_fragment.h (class Fragment and FragmentHandle): Install all
+        variants of (win)copy methods that act upon a cmt_string instead
+        of a FILE*.
+
+        * cmt_model.cxx: Create the implementation file for CmtModel 
+
+        * cmt_model.h (class CmtModel): Create the CmtModel class
+
+        * cmt_parser.cxx (do_expand_model): Add the new command verb :
+        'expand model' and all associated features
+        (do_expand_model): call the CmtModel::expand
+
Index: /CMT/v1r20/Visual/all.dsp
===================================================================
--- /CMT/v1r20/Visual/all.dsp	(revision 368)
+++ /CMT/v1r20/Visual/all.dsp	(revision 368)
@@ -0,0 +1,52 @@
+# Microsoft Developer Studio Project File - Name="all" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Generic Project" 0x010a
+
+CFG=all - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "all.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "all.mak" CFG="all - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "all - Win32 Debug" (based on "Win32 (x86) Generic Project")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+MTL=midl.exe
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "..\VisualC"
+# PROP BASE Intermediate_Dir "..\VisualC"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Target_Dir ""
+
+# Begin Target
+
+# Name "all - Win32 Debug"
+# Begin Group "cmt"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\mgr\requirements
+# End Source File
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/cmt.dsp
===================================================================
--- /CMT/v1r20/Visual/cmt.dsp	(revision 368)
+++ /CMT/v1r20/Visual/cmt.dsp	(revision 368)
@@ -0,0 +1,685 @@
+# Microsoft Developer Studio Project File - Name="cmt" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=cmt - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "cmt.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "cmt.mak" CFG="cmt - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "cmt - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "..\VisualC"
+# PROP BASE Intermediate_Dir "..\VisualC"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC\cmt"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+F90=df.exe
+# ADD BASE F90 /nopdbfile /debug:full /optimize:0
+# ADD F90 /nopdbfile /debug:full /optimize:0
+MTL=midl.exe
+# ADD BASE CPP /nologo /MD /W3 /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /c
+# ADD CPP /nologo /MD /W3 /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 /subsystem:console /debug /machine:IX86 /pdbtype:sept
+# ADD LINK32 advapi32.lib /subsystem:console /debug /machine:IX86 /pdbtype:sept
+# Begin Target
+
+# Name "cmt - Win32 Debug"
+# Begin Source File
+
+SOURCE=..\src\cmt.cxx
+DEP_CPP_CMT_C=\
+	"..\src\cmt.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_awk.cxx
+DEP_CPP_CMT_A=\
+	"..\src\cmt_awk.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_branch.cxx
+DEP_CPP_CMT_B=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_constituent.cxx
+DEP_CPP_CMT_CO=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_generator.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_cvs.cxx
+DEP_CPP_CMT_CV=\
+	"..\src\cmt.h"\
+	"..\src\cmt_awk.h"\
+	"..\src\cmt_cvs.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_database.cxx
+DEP_CPP_CMT_D=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_deps_builder.cxx
+DEP_CPP_CMT_DE=\
+	"..\src\cmt.h"\
+	"..\src\cmt_deps_builder.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_error.cxx
+DEP_CPP_CMT_E=\
+	"..\src\cmt_error.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_fragment.cxx
+DEP_CPP_CMT_F=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_generator.cxx
+DEP_CPP_CMT_G=\
+	"..\src\cmt.h"\
+	"..\src\cmt_awk.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_deps_builder.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_generator.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_group.cxx
+DEP_CPP_CMT_GR=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_include.cxx
+DEP_CPP_CMT_I=\
+	"..\src\cmt.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_install_area.cxx
+DEP_CPP_CMT_IN=\
+	"..\src\cmt.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_install_area.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_syntax.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_language.cxx
+DEP_CPP_CMT_L=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_lock.cxx
+DEP_CPP_CMT_LO=\
+	"..\src\cmt.h"\
+	"..\src\cmt_error.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_lock.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_model.cxx
+DEP_CPP_CMT_M=\
+	"..\src\cmt.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_model.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_parser.cxx
+DEP_CPP_CMT_P=\
+	"..\src\cmt.h"\
+	"..\src\cmt_awk.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_cvs.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_error.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_generator.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_install_area.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_lock.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_model.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_syntax.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_triggers.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	"..\src\cmt_version.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_pattern.cxx
+DEP_CPP_CMT_PA=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_error.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_syntax.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_project.cxx
+DEP_CPP_CMT_PR=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_regexp.cxx
+DEP_CPP_CMT_R=\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_script.cxx
+DEP_CPP_CMT_S=\
+	"..\src\cmt.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_string.cxx
+DEP_CPP_CMT_ST=\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_symbol.cxx
+DEP_CPP_CMT_SY=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_syntax.cxx
+DEP_CPP_CMT_SYN=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_error.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_syntax.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_system.cxx
+DEP_CPP_CMT_SYS=\
+	"..\src\cmt_error.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_tag.cxx
+DEP_CPP_CMT_T=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_triggers.cxx
+DEP_CPP_CMT_TR=\
+	"..\src\cmt.h"\
+	"..\src\cmt_awk.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_syntax.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_triggers.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_use.cxx
+DEP_CPP_CMT_U=\
+	"..\src\cmt.h"\
+	"..\src\cmt_branch.h"\
+	"..\src\cmt_constituent.h"\
+	"..\src\cmt_database.h"\
+	"..\src\cmt_error.h"\
+	"..\src\cmt_fragment.h"\
+	"..\src\cmt_group.h"\
+	"..\src\cmt_include.h"\
+	"..\src\cmt_language.h"\
+	"..\src\cmt_map.h"\
+	"..\src\cmt_parser.h"\
+	"..\src\cmt_pattern.h"\
+	"..\src\cmt_project.h"\
+	"..\src\cmt_regexp.h"\
+	"..\src\cmt_script.h"\
+	"..\src\cmt_std.h"\
+	"..\src\cmt_string.h"\
+	"..\src\cmt_symbol.h"\
+	"..\src\cmt_syntax.h"\
+	"..\src\cmt_system.h"\
+	"..\src\cmt_tag.h"\
+	"..\src\cmt_use.h"\
+	"..\src\cmt_vector.h"\
+	
+# End Source File
+# End Target
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# End Project
Index: /CMT/v1r20/Visual/cmt.dsw
===================================================================
--- /CMT/v1r20/Visual/cmt.dsw	(revision 368)
+++ /CMT/v1r20/Visual/cmt.dsw	(revision 368)
@@ -0,0 +1,43 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+###############################################################################
+
+Project: "all"=.\all.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+
+    Begin Project Dependency
+    Project_Dep_Name cmt
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "cmt"=.\cmt.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
Index: /CMT/v1r20/Visual/cmtlib.dsp
===================================================================
--- /CMT/v1r20/Visual/cmtlib.dsp	(revision 368)
+++ /CMT/v1r20/Visual/cmtlib.dsp	(revision 368)
@@ -0,0 +1,292 @@
+# Microsoft Developer Studio Project File - Name="cmtlib" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=cmtlib - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "cmtlib.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "cmtlib.mak" CFG="cmtlib - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "cmtlib - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "cmtlib - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "cmtlib - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\src" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "cmtlib - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\src" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "cmtlib - Win32 Release"
+# Name "cmtlib - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\src\cmt_awk.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_branch.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_constituent.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_cvs.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_database.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_deps_builder.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_error.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_fragment.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_generator.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_group.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_include.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_language.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_lock.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_model.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_parser.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_pattern.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_regexp.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_script.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_string.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_symbol.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_system.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_tag.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_triggers.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_use.cxx
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\src\cmt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_awk.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_branch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_constituent.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_cvs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_deps_builder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_error.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_fragment.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_generator.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_include.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_lock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_model.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_parser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_pattern.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_regexp.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_script.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_selector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_std.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_string.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_symbol.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_system.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_tag.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_triggers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_use.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_vector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\cmt_version.h
+# End Source File
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/cmtw.cxx
===================================================================
--- /CMT/v1r20/Visual/cmtw.cxx	(revision 368)
+++ /CMT/v1r20/Visual/cmtw.cxx	(revision 368)
@@ -0,0 +1,1597 @@
+#include <stdio.h>
+
+//---------------------------------------------------------------------
+#include <windows.h>   // required for all Windows applications
+#include "resource.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <io.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "cmtw_utils.h"
+
+#include "cmt.h"
+#include "cmt_use.h"
+#include "cmt_constituent.h"
+#include "cmt_generator.h"
+#include "cmt_system.h"
+#include "cmt_symbol.h"
+#include "cmt_tag.h"
+#include "cmt_error.h"
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+#define USE_THREADS 1
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+//
+//    Class definitions
+//
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+class Cmtw;
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+class PackageCreator : public WDialog
+{
+public:
+  PackageCreator (Cmtw& cmtw);
+  
+  int run (HINSTANCE instance, HWND father);
+  virtual void action (UINT message_type,
+                       WPARAM parameter1,
+                       LPARAM parameter2);
+  void init_action ();
+  void menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2);
+
+private:
+  Cmtw& _cmtw;
+};
+//---------------------------------------------------------------------
+
+//--------------------------------------------------------------------- 
+class CMT_Run : public WDialog 
+{ 
+public: 
+  CMT_Run (Cmtw& cmtw); 
+   
+  int run (HINSTANCE instance, HWND father); 
+  void action (UINT message_type, 
+               WPARAM parameter1, 
+               LPARAM parameter2); 
+ 
+  void init_action (); 
+ 
+  void menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2); 
+ 
+private: 
+  Cmtw& _cmtw; 
+}; 
+//--------------------------------------------------------------------- 
+ 
+//---------------------------------------------------------------------
+class ConstituentEditor : public WDialog
+{
+public:
+  ConstituentEditor (cmt_string& line, Cmtw& cmtw);
+  
+  int run (HINSTANCE instance, HWND father);
+  virtual void action (UINT message_type,
+                       WPARAM parameter1,
+                       LPARAM parameter2);
+  void init_action ();
+  void menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2);
+  
+private:
+  cmt_string& _line;
+  Cmtw& _cmtw;
+  WEdit _type;
+  WEdit _name;
+  WList _modules;
+};
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+class path_selector : public CmtThread
+{
+public:
+  static path_selector& instance ();
+  
+  void start (const cmt_string& path);
+  void run ();
+  
+private:
+  path_selector ();
+
+  cmt_string _path;
+};
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+class Cmtw
+{
+public:
+  static Cmtw& instance ();
+  BOOL initialize (HINSTANCE instance, HINSTANCE previous_instance, 
+                   int show_mode);
+  BOOL run ();
+  void disable_package_menu_items ();
+  void enable_package_menu_items ();
+  void do_show_uses ();
+  void do_select_path ();
+  void do_select_package (const cmt_string& name = "");
+  void do_select_version ();
+  void do_select_tag (const cmt_string& name);
+  void do_config ();
+  void do_save_requirements ();
+  void do_genmake ();
+  void do_genmsdev ();
+  void do_build_make_setup ();
+  void do_build_constituents_makefile ();
+  void do_build_constituent_makefiles ();
+  bool is_version (const cmt_string& name);
+  void select_package (const cmt_string& path, 
+                       const cmt_string& package);
+  void select_path (const cmt_string& path,
+                    const cmt_string& prefix = "", 
+                    int level = 0);
+  int show_tags (HWND window, int x, int y, cmt_string& selected_name);
+  
+  const char* _application_name;
+  const char* _title;
+
+  HINSTANCE _instance;
+  HWND _window;
+
+  HWND _the_dialog;
+
+  WList _path_list;
+  WList _package_list;
+  WEdit _package;
+  WList _version_list; 
+
+  WList _requirements; 
+ 
+  WList _show_uses;
+  WList _show_constituents;
+  WList _show_macros;
+  WList _show_sets;
+  WList _output; 
+ 
+  WRadio _set_uses; 
+  WRadio _set_constituents; 
+  WRadio _set_macros; 
+  WRadio _set_sets; 
+  WRadio _set_output; 
+ 
+  WTab  _tab;
+  WEdit _tag; 
+  CmtMutex dir_mutex;
+
+private:
+
+  Cmtw ();
+
+  static LRESULT CALLBACK process_messages (HWND window,
+                                            UINT message_type,
+                                            WPARAM parameter1,
+                                            LPARAM parameter2);
+  static LRESULT CALLBACK handle_dialog (HWND dialog,
+                                         UINT message_type,
+                                         WPARAM parameter1,
+                                         LPARAM parameter2);
+  
+  HANDLE* _objects;
+  int _object_count;
+};
+//---------------------------------------------------------------------
+
+
+
+//---------------------------------------------------------------------
+int APIENTRY WinMain (HINSTANCE instance,
+                      HINSTANCE previous_instance,
+                      LPSTR command_line,
+                      int show_mode)
+//---------------------------------------------------------------------
+{                
+  Cmtw& cmtw = Cmtw::instance ();
+
+  cmtw.initialize (instance, previous_instance, show_mode);
+
+  return cmtw.run ();
+
+  UNREFERENCED_PARAMETER (command_line);
+
+  return (0);
+}
+
+
+
+//---------------------------------------------------------------------
+//
+//    Class implementations
+//
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+PackageCreator::PackageCreator (Cmtw& cmtw) : _cmtw (cmtw)
+{
+}
+
+int PackageCreator::run (HINSTANCE instance, HWND father)
+{
+  return (WDialog::run (instance, father, IDD_NEWPACKAGE));
+}
+
+void PackageCreator::action (UINT message_type,
+                             WPARAM parameter1,
+                             LPARAM parameter2)
+{
+}
+
+void PackageCreator::init_action ()
+{
+  WList list (_dialog, IDNP_PATHLIST);
+  
+  list.copy (_cmtw._path_list);
+}
+
+void PackageCreator::menu_action (int menu_item, 
+                                  WPARAM parameter1, 
+                                  LPARAM parameter2)
+{
+  switch (menu_item) 
+    {
+    case IDOK:
+      {
+        WList list (_dialog, IDNP_PATHLIST);
+        WEdit p (_dialog, IDNP_PACKAGE);
+        WEdit v (_dialog, IDNP_VERSION);
+        WEdit pr (_dialog, IDNP_PREFIX);
+        
+        cmt_string path = list.get_selected ();
+        cmt_string package = p.get ();
+        cmt_string version = v.get ();
+        cmt_string prefix = pr.get ();
+
+        mysb s (_cmtw._output);
+        cout << "cmt config " << package << " " <<
+          version << " " << 
+          path << " " <<
+          prefix << endl;
+
+        if ((package != "") &&
+            (version != ""))
+          {
+            if (prefix != "")
+              { 
+				if (path != "") 
+				{
+                  path += CmtSystem::file_separator (); 
+				}
+                path += prefix;
+              } 
+			Cmt::configure ();
+            Cmt::do_create (package, version, path);
+          }
+      }
+      break;
+    case IDCANCEL:
+      break;
+    default:
+      break;
+    }
+}
+//---------------------------------------------------------------------
+
+//--------------------------------------------------------------------- 
+CMT_Run::CMT_Run (Cmtw& cmtw) : _cmtw (cmtw) 
+{ 
+} 
+ 
+int CMT_Run::run (HINSTANCE instance, HWND father) 
+{ 
+  return (WDialog::run (instance, father, IDD_CMT)); 
+} 
+ 
+void CMT_Run::action (UINT message_type, 
+                      WPARAM parameter1, 
+                      LPARAM parameter2) 
+{ 
+} 
+ 
+void CMT_Run::init_action () 
+{ 
+} 
+ 
+void CMT_Run::menu_action (int menu_item,  
+                           WPARAM parameter1,  
+                           LPARAM parameter2) 
+{ 
+  switch (menu_item)  
+    { 
+    case IDCMT_EXECUTE: 
+		{ 
+			WEdit command (_dialog, IDCMT_COMMAND); 
+			WList output (_dialog, IDCMT_OUTPUT); 
+			 
+			cmt_string c = "cmt "; 
+			c += command.get (); 
+ 
+			output.clear (); 
+			{ 
+				mysb s (output); 
+				cout << c << endl; 
+				Cmt::parser (c); 
+			} 
+		} 
+      break; 
+    case IDCANCEL: 
+      break; 
+    default: 
+      break; 
+    } 
+} 
+//--------------------------------------------------------------------- 
+ 
+//---------------------------------------------------------------------
+path_selector& path_selector::instance ()
+{
+  static path_selector the_instance;
+
+  return (the_instance);
+}
+
+path_selector::path_selector ()
+{
+}
+
+void path_selector::start (const cmt_string& path)
+{
+  Cmtw& cmtw = Cmtw::instance ();
+
+  if (is_running ()) 
+    {
+      {
+        mysb s (cmtw._output);
+        cout << "Path selector already running. Please retry later..." << endl;
+      }
+      return;
+    }
+
+  _path = path;
+  CmtThread::start ();
+}
+
+void path_selector::run ()
+{
+  Cmtw& cmtw = Cmtw::instance ();
+
+  cmtw._package_list.clear ();
+  cmtw._version_list.clear ();
+  cmtw._requirements.clear ();
+  cmtw._show_uses.clear ();
+  cmtw._show_constituents.clear ();
+  cmtw._tag.clear ();
+  cmtw._show_macros.clear ();
+  cmtw._show_sets.clear ();
+  cmtw._output.clear ();
+
+  {
+    mysb s (cmtw._output);
+    cout << "Path selector started." << endl;
+  }
+
+  cmtw.disable_package_menu_items ();
+
+  cmtw.select_path (_path);
+
+  {
+    mysb s (cmtw._output);
+    cout << "Path selector terminated." << endl;
+  }
+
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+ConstituentEditor::ConstituentEditor (cmt_string& line, Cmtw& cmtw) : 
+        _line (line), _cmtw (cmtw)
+{
+}
+
+int ConstituentEditor::run (HINSTANCE instance, HWND father)
+{
+  return (WDialog::run (instance, father, IDD_CONSTITUENT));
+}
+
+void ConstituentEditor::action (UINT message_type,
+                                WPARAM parameter1,
+                                LPARAM parameter2)
+{
+}
+
+void ConstituentEditor::init_action ()
+{
+  _type.init (_dialog, IDCE_TYPE);
+  _name.init (_dialog, IDCE_NAME);
+  _modules.init (_dialog, IDCE_MODULES);
+
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (_line,  " ", words);
+
+  if (words.size () >= 2)
+    {
+      const cmt_string& t = words[0];
+      if ((t == "library") ||
+          (t == "application"))
+        {
+          const cmt_string& name = words[1];
+
+          Constituent* constituent = Constituent::find (name);
+          if (constituent != 0)
+            {
+              _type.set (t);
+              _name.set (name);
+              _modules.set (constituent->modules);
+            }
+        }
+    }
+}
+
+void ConstituentEditor::menu_action (int menu_item, 
+                                     WPARAM parameter1, 
+                                     LPARAM parameter2)
+{
+  switch (menu_item) 
+    {
+    case IDOK:
+      break;
+    case IDCANCEL:
+      break;
+    case IDCE_MODULES:
+      if (HIWORD (parameter1) == LBN_DBLCLK)
+        {
+          cmt_string file_name = _modules.get_selected ();
+          cmt_string line = Generator::build_dependencies (file_name);
+
+          mysb sb (_cmtw._output);
+          cout << line << endl;
+        }
+      break;
+    case IDCE_EDITMODULES:
+      {
+        ListEditor editor (_modules);
+        editor.run (_cmtw._instance, _dialog);
+      }
+      break;
+    default:
+      break;
+    }
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+Cmtw& Cmtw::instance ()
+{
+  static Cmtw the_instance;
+  
+  return (the_instance);
+}
+
+BOOL Cmtw::initialize (HINSTANCE instance, HINSTANCE previous_instance, 
+                       int show_mode)
+{
+  WNDCLASS  window_class;
+  
+  // Fill in window class structure with parameters that describe the
+  // main window.
+  
+  if (!previous_instance) 
+    {
+      window_class.style         = CS_OWNDC;
+      window_class.lpfnWndProc   = (WNDPROC) process_messages;
+      window_class.cbClsExtra    = 0;
+      window_class.cbWndExtra    = 0;
+      window_class.hInstance     = instance;
+      window_class.hIcon         = LoadIcon (instance, _application_name);
+      window_class.hCursor       = LoadCursor (NULL, IDC_ARROW);
+      window_class.hbrBackground = (HBRUSH) (COLOR_MENU+1);
+      window_class.lpszMenuName  = "TEXTFXMENU";
+      window_class.lpszClassName = _application_name;
+      
+      if (!RegisterClass (&window_class)) return (FALSE);
+    }
+  
+  _instance = instance;
+  
+  _window = CreateWindow (_application_name,
+                          _title,
+                          WS_OVERLAPPEDWINDOW,
+                          CW_USEDEFAULT, 0, 440, 590,
+                          NULL,
+                          NULL,
+                          _instance,
+                          NULL);
+  
+  // If window could not be created, return "failure"
+  
+  if (!_window)
+    {
+      return (FALSE);
+    }
+  
+  ShowWindow (_window, show_mode);
+  UpdateWindow (_window);
+  
+  return (TRUE);
+}
+
+BOOL Cmtw::run ()
+{
+  MSG message;
+  DWORD result;
+  HANDLE objects[1];
+  int count = 0;
+
+  while (TRUE)
+    {
+      result = MsgWaitForMultipleObjects (count, objects, FALSE, 
+                                          INFINITE, QS_ALLINPUT);
+      if (result == (WAIT_OBJECT_0 + count))
+        {
+          while (PeekMessage (&message, NULL, 0, 0, PM_REMOVE))
+            {
+              if ((_the_dialog == NULL) ||
+                  !IsDialogMessage (_the_dialog, &message))
+                {
+                  if (!TranslateAccelerator (message.hwnd, NULL, &message))
+                    {
+                      if (message.message == WM_QUIT) return (0);
+
+                      TranslateMessage (&message);
+                      DispatchMessage (&message);
+                    }
+                }
+            }
+        }
+      else
+        {
+          // For future async objects
+        }
+    }
+                
+  return (message.wParam);
+}
+
+void Cmtw::disable_package_menu_items ()
+{
+  HMENU menu = GetMenu (_window);
+  EnableMenuItem (menu, IDM_CONFIG, MFS_GRAYED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_GENMAKE, MFS_GRAYED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_GENMSDEV, MFS_GRAYED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_BUILDSETUP, MFS_GRAYED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_BUILDCONSTITUENTSMAKEFILE, 
+                  MFS_GRAYED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_BUILDCONSTITUENTMAKEFILE, 
+                  MFS_GRAYED | MF_BYCOMMAND);
+
+  _show_uses.disable ();
+  _show_constituents.disable ();
+  _show_macros.disable ();
+  _show_sets.disable ();
+  _requirements.disable ();
+}
+                        
+void Cmtw::enable_package_menu_items ()
+{
+  HMENU menu = GetMenu (_window);
+  EnableMenuItem (menu, IDM_CONFIG, MFS_ENABLED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_GENMAKE, MFS_ENABLED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_GENMSDEV, MFS_ENABLED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_BUILDSETUP, MFS_ENABLED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_BUILDCONSTITUENTSMAKEFILE, 
+                  MFS_ENABLED | MF_BYCOMMAND);
+  EnableMenuItem (menu, IDM_BUILDCONSTITUENTMAKEFILE, 
+                  MFS_GRAYED | MF_BYCOMMAND);
+
+  _show_uses.enable ();
+  _show_constituents.enable ();
+  _show_macros.enable ();
+  _show_sets.enable ();
+  _requirements.enable ();
+}
+                        
+void Cmtw::do_show_uses ()
+{
+  mysb s (_show_uses);
+  Use::show_all ();
+}
+  
+void Cmtw::do_select_path ()
+{
+  cmt_string path = _path_list.get_selected ();
+
+  path_selector& selector = path_selector::instance ();
+      
+#ifdef USE_THREADS
+  selector.start (path);
+#else
+  {
+    mysb s (_output);
+    cout << "running thread "<< endl;
+  }
+      
+  _package_list.clear ();
+  _version_list.clear ();
+  _requirements.clear ();
+  _show_uses.clear ();
+  _show_constituents.clear ();
+  _tag.clear ();
+  _show_macros.clear ();
+  _show_sets.clear ();
+  _output.clear ();
+      
+  disable_package_menu_items ();
+      
+  select_path (path);
+#endif
+}
+  
+void Cmtw::do_select_package (const cmt_string& name)
+{
+  _requirements.clear ();
+  _show_uses.clear ();
+  _show_constituents.clear ();
+  _tag.clear ();
+  _show_macros.clear ();
+  _show_sets.clear ();
+  _output.clear ();
+      
+  disable_package_menu_items ();
+      
+  cmt_string path;
+  cmt_string package;
+      
+  path = _path_list.get_selected ();
+      
+  if (name == "") package = _package_list.get_selected ();
+  else package = name;
+      
+  select_package (path, package);
+}
+  
+void Cmtw::do_select_version ()
+{
+  cmt_string path;
+  cmt_string package;
+  cmt_string version;
+  bool ok;
+      
+  path = _path_list.get_selected ();
+      
+  package = _package.get ();
+  if (package == "") package = _package_list.get_selected ();
+      
+  version = _version_list.get_selected ();
+      
+  _requirements.clear ();
+  _tag.clear ();
+  _show_uses.clear ();
+  _show_constituents.clear ();
+  _show_macros.clear ();
+  _show_sets.clear ();
+  _output.clear ();
+      
+  if (version == "")
+    {
+      mysb s (_output);
+      cout << "Please select a version first" << endl;
+      return;
+    }
+      
+  {
+    mysb s (_output);
+    ok = Cmt::load (path, package, version);
+    _requirements.set ("requirements");
+  }
+
+  if (!ok)
+  {
+    mysb s (_output);
+	CmtError::print ();
+  }
+  else
+  { 
+  {
+    mysb s (_output);
+    Cmt::set_standard_macros ();
+  }
+      
+  {
+    mysb s (_show_uses);
+	Cmt::action = action_show_uses;   
+	Cmt::quiet = false; 
+    Use::show_all ();
+  }
+  { 
+    mysb s (_show_constituents);
+	Cmt::action = action_show_constituents; 
+	Cmt::quiet = true; 
+    Constituent::show_all ();
+  } 
+  { 
+    mysb s (_show_macros); 
+	Cmt::action = action_show_macros;
+    Cmt::print_macros (Csh);
+  } 
+  { 
+    mysb s (_show_sets); 
+	Cmt::action = action_show_sets;
+    Cmt::print_macros (Csh);
+  } 
+  { 
+    Symbol* symbol = Symbol::find ("tag");
+    if (symbol != 0)
+      { 
+        const cmt_string tag = symbol->build_macro_value ();
+        _tag.set (tag);
+      } 
+  } 
+  }
+  enable_package_menu_items ();
+}
+  
+void Cmtw::do_select_tag (const cmt_string& name)
+{
+  cmt_string path;
+  cmt_string package;
+  cmt_string version;
+  bool ok;
+      
+  path    = _path_list.get_selected ();
+      
+  package = _package.get ();
+  if (package == "") package = _package_list.get_selected ();
+      
+  version = _version_list.get_selected ();
+      
+  _show_macros.clear ();
+  {
+    mysb s (_output);
+    ok = Cmt::load (path, package, version, name);
+  }
+  if (!ok) return;
+      
+  Cmt::quiet = true; 
+  Cmt::set_standard_macros ();
+      
+  {
+    mysb s (_show_macros);
+    Cmt::print_macros (Csh);
+  }
+}
+  
+void Cmtw::do_config ()
+{
+  mysb s (_output);
+  Cmt::do_config ();
+}
+  
+void Cmtw::do_save_requirements ()
+{
+  cmt_string text;
+      
+  _requirements.get (text);
+      
+  FILE* f = fopen ("requirements", "wb");
+  if (f != NULL)
+    {
+      text.write (f);
+      fclose (f);
+    }
+}
+  
+void Cmtw::do_genmake ()
+{
+  cmt_string line = _show_constituents.get_selected ();
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " ", words);
+      
+  if (words.size () >= 2)
+    {
+      const cmt_string& t = words[0];
+      if ((t == "library") ||
+          (t == "application"))
+        {
+          const cmt_string& name = words[1];
+              
+          mysb s (_output);
+          Cmt::build_makefile (name);
+        }
+    }
+  else
+    {
+      mysb s (_output);
+      Cmt::build_makefile ("");
+    }
+}
+  
+void Cmtw::do_genmsdev ()
+{
+  cmt_string line = _show_constituents.get_selected ();
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " ", words);
+      
+  if (words.size () >= 2)
+    {
+      const cmt_string& t = words[0];
+      if ((t == "library") ||
+          (t == "application"))
+        {
+          const cmt_string& name = words[1];
+              
+          mysb s (_output);
+          Cmt::build_msdev_file (name);
+        }
+    }
+  else
+    {
+      mysb s (_output);
+      Cmt::build_msdev_file ("");
+    }
+}
+  
+void Cmtw::do_build_make_setup ()
+{
+  cmt_string package = _package_list.get_selected ();
+  cmt_string version = _version_list.get_selected ();
+      
+  if ((package != "") && (version != ""))
+    {
+      mysb s (_output);
+      Generator::build_make_setup (package);
+    }
+}
+  
+void Cmtw::do_build_constituents_makefile ()
+{
+  cmt_string package = _package_list.get_selected ();
+  cmt_string version = _version_list.get_selected ();
+      
+  if ((package != "") && (version != ""))
+    {
+      mysb s (_output);
+      Generator::build_constituents_makefile (package);
+    }
+}
+  
+void Cmtw::do_build_constituent_makefiles ()
+{
+  cmt_string package;
+  cmt_string version;
+      
+  package = _package_list.get_selected ();
+  if (package == "") package = _package.get ();
+      
+  version = _version_list.get_selected ();
+      
+  if ((package != "") && (version != ""))
+    {
+      cmt_string line = _show_constituents.get_selected ();
+      CmtSystem::cmt_string_vector words;
+	  
+	  CmtSystem::split (line, " ", words);
+          
+      if (words.size () >= 2)
+        {
+          const cmt_string& t = words[0];
+          if ((t == "library") ||
+              (t == "application"))
+            {
+              int i;
+                  
+              const cmt_string& name = words[1];
+              mysb s (_output);
+              Generator::build_constituent_makefile (name);
+                  
+              for (i = 2; i < words.size (); i++)
+                {
+                  const cmt_string& module = words[i];
+                  Generator::build_dependencies (module);
+                }
+            }
+        }
+    }
+}
+  
+bool Cmtw::is_version (const cmt_string& name)
+{
+  const cmt_string numbers = "0123456789";
+  const int starting  = 0;
+  const int at_key    = 1;
+  const int at_number = 2;
+
+  int state = starting;
+  int pos;
+  
+  for (pos = 0; pos < name.size (); pos++)
+    {
+      char c = name[pos];
+
+      if (numbers.find (c) == cmt_string::npos)
+        {
+          switch (state)
+            {
+              case starting:
+                state = at_key;
+                break;
+              case at_key:
+                return (false);
+              case at_number:
+                state = at_key;
+                break;
+            }
+        }
+      else
+        {
+          switch (state)
+            {
+              case starting:
+                return (false);
+              case at_key:
+                state = at_number;
+                break;
+              case at_number:
+                break;
+            }
+        }
+    }
+  
+  return ((state == at_number));
+}
+  
+void Cmtw::select_package (const cmt_string& path, 
+                           const cmt_string& package)
+{
+    //
+    // Only do something if it is a directory.
+    //
+
+  _version_list.clear ();
+      
+  bool test;
+
+  cmt_string pattern = path;
+  pattern += CmtSystem::file_separator ();
+  pattern += package;
+
+  /*
+  {
+    mysb sb (_output);
+    cout << "scan> testing directory pattern=" << pattern << endl;
+  }
+  */
+
+  dir_mutex.lock ();
+  test = CmtSystem::test_directory (pattern);
+  dir_mutex.unlock ();
+  if (!test) return;
+
+    //
+    // The scan_dir requests a pattern <dir>/<name> to scan <dir>
+    //
+
+  pattern += CmtSystem::file_separator ();
+  pattern += "*";
+
+  CmtSystem::cmt_string_vector list;
+
+  dir_mutex.lock ();
+  CmtSystem::scan_dir (pattern, list);
+  dir_mutex.unlock ();
+
+  if (list.size () == 0) return;
+
+  int i;
+  for (i = 0; i < list.size (); i++)
+    {
+      const cmt_string& name = list[i];
+
+      /*
+      {
+        mysb sb (_output);
+        cout << "scan10> name=" << name;
+      }
+      */
+
+      cmt_string version;
+      CmtSystem::basename (name, version);
+
+      if (is_version (version))
+        {
+          cmt_string req;
+
+          req = name;
+          req += CmtSystem::file_separator ();
+          req += "cmt";
+          req += CmtSystem::file_separator ();
+          req += "requirements";
+
+          dir_mutex.lock ();
+          test = CmtSystem::test_file (req);
+          dir_mutex.unlock ();
+          if (test)
+            {
+              _version_list.append (version);
+            }
+          else
+            {
+              req = name;
+              req += CmtSystem::file_separator ();
+              req += "mgr";
+              req += CmtSystem::file_separator ();
+              req += "requirements";
+
+              dir_mutex.lock ();
+              test = CmtSystem::test_file (req);
+              dir_mutex.unlock ();
+              if (test)
+			  {
+                 _version_list.append (version);
+			  }
+            }
+        }
+      else
+        {
+          /*
+          {
+            mysb sb (_output);
+            cout << " -> stop" << endl;
+          }
+          */
+        }
+    }
+}
+
+void Cmtw::select_path (const cmt_string& path, 
+                        const cmt_string& prefix, 
+                        int level)
+{
+  long handle = 0;
+    //
+    // Only do something if it is a directory.
+    //
+
+  cmt_string full_path = path;
+  if (prefix != "")
+    {
+      full_path += CmtSystem::file_separator ();
+      full_path += prefix;
+    }
+
+  if (full_path[full_path.size () -1] == ':')
+    {
+      full_path += CmtSystem::file_separator ();
+    }
+
+  /*
+  {
+    mysb sb (_output);
+    cout << "scan> testing directory " << full_path << endl;
+  }
+  */
+
+  bool test;
+
+  dir_mutex.lock ();
+  test = CmtSystem::test_directory (full_path);
+  dir_mutex.unlock ();
+  if (!test) return;
+
+    //
+    // The scan_dir requests a pattern <dir>/<name> to scan <dir>
+    //
+  cmt_string pattern = full_path;
+  pattern += CmtSystem::file_separator ();
+  pattern += "*";
+
+  CmtSystem::cmt_string_vector list;
+
+  dir_mutex.lock ();
+  CmtSystem::scan_dir (pattern, list);
+  dir_mutex.unlock ();
+
+  if (list.size () == 0) return;
+
+    // Will be set if at least one directory is a version directory
+  bool has_package = false;
+      
+  cmt_string pack;
+  CmtSystem::basename (full_path, pack);
+
+  int i;
+  for (i = 0; i < list.size (); i++)
+    {
+      const cmt_string& name = list[i];
+
+      /*
+      {
+        mysb sb (_output);
+        cout << "scan8> level=" << level << " name=" << name;
+      }
+      */
+
+      cmt_string version;
+      CmtSystem::basename (name, version);
+
+        //
+        //  All entries at this level may be "legal" version directories.
+        //
+        //  So we go down but no more then one level deep.
+        //  The next level we request that the entry is a version
+        //  and that there is a mgr/requirements file below.
+        //
+
+      if (level == 0)
+        {
+          /*
+          {
+            mysb sb (_output);
+            cout << " -> down" << endl;
+          }
+          */
+
+          cmt_string p = "";
+
+          if (prefix != "")
+            {
+              p += prefix;
+              p += CmtSystem::file_separator ();
+            }
+
+          p += version;
+
+          select_path (path, p, level + 1);
+        }
+      else if (is_version (version))
+        {
+          cmt_string req;
+
+          req = name;
+          req += CmtSystem::file_separator ();
+          req += "cmt";
+          req += CmtSystem::file_separator ();
+          req += "requirements";
+
+          dir_mutex.lock ();
+          test = CmtSystem::test_file (req);
+          dir_mutex.unlock ();
+          if (test)
+            {
+              /*
+              {
+                mysb sb (_output);
+                cout << " -> mgr" << endl;
+                cout << pack << " " << version << " " << full_path << endl;
+              }
+              */
+
+              has_package = true;
+
+              break;
+            }
+          else
+            {
+              req = name;
+              req += CmtSystem::file_separator ();
+              req += "mgr";
+              req += CmtSystem::file_separator ();
+              req += "requirements";
+
+              dir_mutex.lock ();
+              test = CmtSystem::test_file (req);
+              dir_mutex.unlock ();
+              if (test)
+			  {
+                has_package = true;
+
+                break;
+			  }
+            }
+        }
+      else
+        {
+          /*
+          {
+            mysb sb (_output);
+            cout << " -> stop" << endl;
+          }
+          */
+        }
+    }
+
+  if (has_package)
+    {
+        //
+        // At least one version was found here.
+        //
+
+      _package_list.append (prefix);
+
+      select_path (path, prefix, 0);
+    }
+}
+  
+int Cmtw::show_tags (HWND window, int x, int y, cmt_string& selected_name)
+{
+  const Tag::TagPtrVector& tags = Tag::tags ();
+      
+  int selected;
+      
+  HMENU menu = CreatePopupMenu ();
+      
+  for (int i = 0; i < tags.size (); i++)
+    {
+      Tag* tag = tags[i];
+          
+      if (tag != 0)
+        {
+          AppendMenu (menu, MFT_STRING, IDM_FIRSTTAG + i, 
+                      tag->name.c_str ());
+        }
+    }
+      
+  selected = (int) TrackPopupMenu (menu, TPM_TOPALIGN | 
+                                   TPM_LEFTALIGN | 
+                                   TPM_RETURNCMD, 
+                                   x, y, 0, window, NULL);
+      
+  if (selected >= IDM_FIRSTTAG)
+    {
+      char name[80];
+          
+      GetMenuString (menu, selected - IDM_FIRSTTAG, name, sizeof (name), 
+                     MF_BYPOSITION);
+          
+      selected_name = name;
+          
+      _tag.set (selected_name);
+          
+      do_select_tag (selected_name);
+    }
+      
+  return (selected);
+}
+
+Cmtw::Cmtw () : _application_name ("CMTW"), _title ("CMTW Test Application")
+{
+  _the_dialog = 0;
+  _objects = 0;
+  _object_count = 0;
+}
+
+LRESULT CALLBACK Cmtw::process_messages (HWND window,
+                                         UINT message_type,
+                                         WPARAM parameter1,
+                                         LPARAM parameter2)
+{
+  Cmtw& cmtw = Cmtw::instance ();
+      
+  int menu_item;
+  static HPEN blue_pen;
+  static HPEN red_pen;
+      
+  SetLastError (0);
+      
+  switch (message_type) 
+    {         
+    case WM_CREATE:
+      {
+        HDC context;
+        LOGFONT log_font;
+        HFONT font;
+            
+        context = GetDC (window);
+            
+        memset (&log_font, 0, sizeof(LOGFONT));
+        log_font.lfHeight = -72;
+        strcpy ((LPSTR) &(log_font.lfFaceName), "arial");
+            
+        font = CreateFontIndirect (&log_font); 
+        SelectObject (context, font);
+            
+        blue_pen = CreatePen (PS_SOLID, 1, RGB(0,0,255));
+        red_pen  = CreatePen (PS_SOLID, 1, RGB(255,0,0));
+      }
+          
+      cmtw._window = window;
+          
+      cmtw._the_dialog = CreateDialog (cmtw._instance, 
+                                       MAKEINTRESOURCE(IDD_DIALOGBAR), 
+                                       window,
+                                       (DLGPROC) handle_dialog);
+          
+      cmtw.disable_package_menu_items ();
+          
+      break;
+          
+    case WM_COMMAND:
+      menu_item = LOWORD (parameter1);
+          
+      switch (menu_item) 
+        {
+        case IDM_EXIT:
+          DestroyWindow (window);
+          break;
+        case IDM_CONFIG:
+          cmtw.do_config ();
+          break;
+        case IDM_GENMAKE:
+          cmtw.do_genmake ();
+          break;
+        case IDM_GENMSDEV:
+          cmtw.do_genmsdev ();
+          break;
+        case IDM_BUILDSETUP:
+          cmtw.do_build_make_setup ();
+          break;
+        case IDM_BUILDCONSTITUENTSMAKEFILE:
+          cmtw.do_build_constituents_makefile ();
+          break;
+        case IDM_BUILDCONSTITUENTMAKEFILE:
+          cmtw.do_build_constituent_makefiles ();
+          break;
+        case IDM_NEWPACKAGE:
+          {
+            PackageCreator creator (cmtw);
+                
+            creator.run (cmtw._instance, window);
+          }
+          break;
+        case IDM_CMT: 
+          { 
+            CMT_Run cmt (cmtw); 
+                 
+            cmt.run (cmtw._instance, window); 
+          } 
+          break; 
+        default:
+          return (DefWindowProc (window, message_type, 
+                                 parameter1, parameter2));
+        }
+      break;
+    case WM_DESTROY:
+      PostQuitMessage (0);
+      break;
+    default:
+      return (DefWindowProc (window, message_type, parameter1, parameter2));
+    }
+  return (0);
+}
+  
+LRESULT CALLBACK Cmtw::handle_dialog (HWND dialog,
+                                      UINT message_type,
+                                      WPARAM parameter1,
+                                      LPARAM parameter2)
+{
+  Cmtw& cmtw = Cmtw::instance ();
+      
+  int menu_item;
+      
+  switch (message_type) 
+    {
+    case WM_CREATE:
+      break;
+    case WM_SETFONT:
+      break;
+    case WM_INITDIALOG:
+      {
+        int x = 0;
+        int y = 0;
+        int width;
+        int height;
+        RECT rectangle;
+            
+        GetWindowRect (dialog, &rectangle);
+            
+        width = rectangle.right - rectangle.left;
+        height = rectangle.bottom - rectangle.top;
+            
+        MoveWindow (cmtw._window, x, y, width, height, TRUE);
+      }
+          
+      cmtw._path_list.init (dialog, IDM_PATHLIST);
+      cmtw._package_list.init (dialog, IDM_PACKAGELIST);
+      cmtw._package.init (dialog, IDM_PACKAGE);
+      cmtw._version_list.init (dialog, IDM_VERSIONLIST); 
+
+      cmtw._requirements.init (dialog, IDM_REQUIREMENTS); 
+ 
+      cmtw._show_uses.init (dialog, IDM_USES);
+      cmtw._show_constituents.init (dialog, IDM_CONSTITUENTS);
+      cmtw._show_macros.init (dialog, IDM_MACROS);
+      cmtw._show_sets.init (dialog, IDM_SETS);
+      cmtw._output.init (dialog, IDM_OUTPUT); 
+ 
+      cmtw._set_uses.init (dialog, IDM_SETUSES); 
+      cmtw._set_constituents.init (dialog, IDM_SETCONSTITUENTS); 
+      cmtw._set_macros.init (dialog, IDM_SETMACROS); 
+      cmtw._set_sets.init (dialog, IDM_SETSETS); 
+      cmtw._set_output.init (dialog, IDM_SETOUTPUT); 
+ 
+      cmtw._tag.init (dialog, IDM_TAG); 
+ 
+	  cmtw._tab.add ("uses",          
+		  cmtw._show_uses,  
+		  cmtw._set_uses); 
+	  cmtw._tab.add ("constituents",  
+		  cmtw._show_constituents, 
+		  cmtw._set_constituents); 
+	  cmtw._tab.add ("macros",        
+		  cmtw._show_macros, 
+		  cmtw._set_macros); 
+	  cmtw._tab.add ("sets",        
+		  cmtw._show_sets, 
+		  cmtw._set_sets); 
+	  cmtw._tab.add ("output",        
+		  cmtw._output, 
+		  cmtw._set_output); 
+	   
+	  cmtw._tab.select ("uses"); 
+ 
+      { 
+        CmtSystem::cmt_string_vector paths;
+        CmtSystem::cmt_string_vector path_sources;
+
+        CmtSystem::get_cmt_paths (paths, path_sources);
+            
+        cmtw._path_list.set (paths);
+      } 
+          
+      break;
+    case WM_COMMAND:
+      menu_item = LOWORD (parameter1);
+          
+      switch (menu_item) 
+        {
+        case IDM_PATHLIST:
+          if (HIWORD (parameter1) == LBN_DBLCLK)
+            {
+              cmtw.do_select_path ();
+            }
+          break;
+        case IDM_PACKAGELIST:
+          if (HIWORD (parameter1) == LBN_DBLCLK)
+            {
+              cmtw.do_select_package ();
+            }
+          break;
+        case IDM_PACKAGE:
+          { 
+            cmt_string name = cmtw._package.get ();
+            cmtw.do_select_package (name);
+          } 
+          break;
+        case IDM_VERSIONLIST:
+          if (HIWORD (parameter1) == LBN_DBLCLK)
+            {
+              cmtw.do_select_version ();
+            }
+          break;
+        case IDM_USES:
+          break;
+        case IDM_CONSTITUENTS:
+          if (HIWORD (parameter1) == LBN_DBLCLK)
+            {
+              cmt_string line = cmtw._show_constituents.get_selected ();
+              ConstituentEditor editor (line, cmtw);
+                  
+              editor.run (cmtw._instance, dialog);
+            }
+          else
+            {
+              cmt_string line = cmtw._show_constituents.get_selected ();
+                  
+              HMENU menu = GetMenu (cmtw._window);
+                  
+              if (line == "")
+                {
+                  EnableMenuItem (menu, IDM_BUILDCONSTITUENTMAKEFILE, 
+                                  MFS_GRAYED | MF_BYCOMMAND);
+                }
+              else
+                {
+                  EnableMenuItem (menu, IDM_BUILDCONSTITUENTMAKEFILE, 
+                                  MFS_ENABLED | MF_BYCOMMAND);
+                }
+            }
+          break;
+        case IDM_TAG:
+          {
+            int x = 0;
+            int y = 0;
+            RECT rectangle;
+                
+            GetWindowRect (GetDlgItem (dialog, IDM_TAG), &rectangle);
+            x = rectangle.left;
+            y = rectangle.top;
+                
+            cmt_string name (80);
+            int selected = cmtw.show_tags (dialog, x, y, name);
+          } 
+          break;
+        case IDM_SETUSES: 
+			cmtw._tab.select ("uses"); 
+          break; 
+        case IDM_SETMACROS: 
+			cmtw._tab.select ("macros"); 
+          break; 
+        case IDM_SETSETS: 
+			cmtw._tab.select ("sets"); 
+          break; 
+        case IDM_SETCONSTITUENTS: 
+			cmtw._tab.select ("constituents"); 
+          break; 
+        case IDM_SETOUTPUT: 
+			cmtw._tab.select ("output"); 
+          break; 
+        case IDM_MACROS:
+          if (HIWORD (parameter1) == LBN_DBLCLK)
+            {
+              cmt_string line = cmtw._show_macros.get_selected ();
+              mysb s (cmtw._output);
+              cout << line << endl;
+            }
+          break;
+        case IDM_REQUIREMENTS:
+          if (HIWORD (parameter1) == LBN_DBLCLK)
+            {
+              ListEditor editor (cmtw._requirements);
+                  
+              editor.run (cmtw._instance, dialog);
+            }
+          break;
+        case IDM_EDITREQUIREMENTS:
+          {
+            ListEditor editor (cmtw._requirements);
+                
+            editor.run (cmtw._instance, dialog);
+          } 
+          break;
+        case IDM_SAVEREQUIREMENTS:
+          {
+            cmtw.do_save_requirements ();
+          }
+          break;
+        case IDM_EDITPATHS:
+          {
+            ListEditor editor (cmtw._path_list);
+                
+            editor.run (cmtw._instance, dialog);
+          }
+          break;
+        case IDM_OUTPUT:
+          break;
+        }
+      break;
+    case WM_ACTIVATE:
+      menu_item = LOWORD (parameter1);
+          
+      break;
+    default:
+      return (FALSE);
+    }
+  return (TRUE);
+}
+//---------------------------------------------------------------------
+
Index: /CMT/v1r20/Visual/cmtw.dsp
===================================================================
--- /CMT/v1r20/Visual/cmtw.dsp	(revision 368)
+++ /CMT/v1r20/Visual/cmtw.dsp	(revision 368)
@@ -0,0 +1,127 @@
+# Microsoft Developer Studio Project File - Name="cmtw" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=cmtw - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "cmtw.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "cmtw.mak" CFG="cmtw - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "cmtw - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "cmtw - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "cmtw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "../win32"
+# PROP BASE Intermediate_Dir "../win32"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\src" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF  "$(CFG)" == "cmtw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "../win32debug"
+# PROP BASE Intermediate_Dir "../win32debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../src" /I "..\src" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "cmtw - Win32 Release"
+# Name "cmtw - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\cmtw.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmtw.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmtw.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmtw_utils.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=.\cmtw_utils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\customizer.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\fragments\dsw_all_project.txt
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\error_listener.java
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/cmtw.rc
===================================================================
--- /CMT/v1r20/Visual/cmtw.rc	(revision 368)
+++ /CMT/v1r20/Visual/cmtw.rc	(revision 368)
@@ -0,0 +1,355 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// French (France) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
+#ifdef _WIN32
+LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_NEWPACKAGE DIALOG DISCARDABLE  0, 0, 122, 130
+STYLE DS_MODALFRAME | DS_NOIDLEMSG | DS_3DLOOK | DS_CENTER | DS_CENTERMOUSE | 
+    WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Create a package"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,7,109,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,65,109,50,14
+    LTEXT           "Package:",IDC_STATIC,7,63,33,8
+    LTEXT           "Version:",IDC_STATIC,7,80,29,8
+    LTEXT           "Root path:",IDC_STATIC,5,5,40,8
+    LISTBOX         IDNP_PATHLIST,5,15,109,40,LBS_SORT | LBS_USETABSTOPS | 
+                    LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL | 
+                    WS_HSCROLL | WS_TABSTOP
+    EDITTEXT        IDNP_PACKAGE,45,60,70,14,ES_AUTOHSCROLL
+    EDITTEXT        IDNP_VERSION,45,75,70,14,ES_AUTOHSCROLL
+    LTEXT           "Prefix:",IDC_STATIC,7,94,21,8
+    EDITTEXT        IDNP_PREFIX,45,90,70,14,ES_AUTOHSCROLL
+END
+
+IDD_DIALOGBAR DIALOG DISCARDABLE  0, 0, 284, 319
+STYLE DS_MODALFRAME | WS_CHILD | WS_VISIBLE
+FONT 8, "MS Sans Serif"
+BEGIN
+    EDITTEXT        IDM_PACKAGE,97,84,90,12,ES_AUTOHSCROLL
+    LTEXT           "Paths:",IDC_STATIC,10,5,22,8,SS_CENTERIMAGE
+    LTEXT           "Packages:",IDC_STATIC,102,5,38,8,SS_CENTERIMAGE
+    LTEXT           "Versions:",IDC_STATIC,194,5,30,8,SS_CENTERIMAGE
+    LISTBOX         IDM_PATHLIST,2,15,89,65,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+    LISTBOX         IDM_PACKAGELIST,97,15,89,65,LBS_SORT | 
+                    LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL | 
+                    WS_HSCROLL | WS_GROUP | WS_TABSTOP
+    LISTBOX         IDM_VERSIONLIST,188,15,89,65,LBS_SORT | 
+                    LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL | 
+                    WS_HSCROLL | WS_TABSTOP
+    LISTBOX         IDM_REQUIREMENTS,59,105,218,53,LBS_SORT | 
+                    LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL | 
+                    WS_HSCROLL | WS_TABSTOP
+    LISTBOX         IDM_USES,2,181,275,108,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+    LISTBOX         IDM_CONSTITUENTS,2,180,275,109,LBS_SORT | 
+                    LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | WS_VSCROLL | 
+                    WS_HSCROLL | WS_TABSTOP
+    LISTBOX         IDM_MACROS,2,181,275,108,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+    LISTBOX         IDM_OUTPUT,2,180,275,109,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+    PUSHBUTTON      "edit...",IDM_EDITREQUIREMENTS,5,113,27,10,BS_CENTER | 
+                    BS_VCENTER
+    PUSHBUTTON      "edit...",IDM_EDITPATHS,34,3,25,11
+    PUSHBUTTON      "Save",IDM_SAVEREQUIREMENTS,3,127,27,10
+    PUSHBUTTON      "Tag",IDM_TAG,225,164,52,13
+    GROUPBOX        "Requirements",IDC_STATIC,2,99,275,63
+    CONTROL         "Uses",IDM_SETUSES,"Button",BS_AUTORADIOBUTTON | 
+                    WS_GROUP,2,166,34,11
+    CONTROL         "Constituents",IDM_SETCONSTITUENTS,"Button",
+                    BS_AUTORADIOBUTTON | WS_GROUP,40,166,56,11
+    CONTROL         "Macros",IDM_SETMACROS,"Button",BS_AUTORADIOBUTTON | 
+                    WS_GROUP,100,166,43,11
+    CONTROL         "Output",IDM_SETOUTPUT,"Button",BS_AUTORADIOBUTTON | 
+                    WS_GROUP,185,166,56,11
+    CONTROL         "Sets",IDM_SETSETS,"Button",BS_AUTORADIOBUTTON,147,166,
+                    34,11
+    LISTBOX         IDM_SETS,2,182,275,107,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+END
+
+IDD_LISTEDIT DIALOGEX 0, 0, 237, 116
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "List editor"
+FONT 8, "MS Sans Serif", 0, 0, 0x1
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,7,95,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,64,95,50,14
+    LISTBOX         IDLE_LIST,7,7,223,85,LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP,WS_EX_ACCEPTFILES
+    PUSHBUTTON      "Add",IDLE_ADD,121,95,50,14
+    PUSHBUTTON      "Remove",IDLE_REMOVE,180,95,50,14
+END
+
+IDD_TEXTEDIT DIALOG DISCARDABLE  0, 0, 186, 47
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Text editor"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,7,26,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,129,26,50,14
+    EDITTEXT        IDTE_TEXT,7,7,172,12,ES_AUTOHSCROLL
+END
+
+IDD_CONSTITUENT DIALOG DISCARDABLE  0, 0, 186, 121
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Constituent editor"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,7,100,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,129,100,50,14
+    LTEXT           "Static",IDCE_TYPE,7,7,41,9
+    LTEXT           "Static",IDCE_NAME,54,7,125,12
+    LISTBOX         IDCE_MODULES,7,44,172,52,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "Modules:",IDC_STATIC,7,31,37,9
+    PUSHBUTTON      "Edit...",IDCE_EDITMODULES,44,29,32,11
+END
+
+IDD_USES DIALOG DISCARDABLE  0, 0, 245, 52
+STYLE DS_MODALFRAME | WS_CHILD | WS_VISIBLE
+FONT 8, "MS Sans Serif"
+BEGIN
+    LISTBOX         IDM_USES,6,6,233,40,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+END
+
+IDD_CMT DIALOG DISCARDABLE  0, 0, 186, 159
+STYLE DS_MODALFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | 
+    WS_CAPTION | WS_SYSMENU
+CAPTION "cmt"
+FONT 8, "MS Sans Serif"
+BEGIN
+    PUSHBUTTON      "OK",IDOK,71,138,50,14,NOT WS_TABSTOP
+    PUSHBUTTON      "Cancel",IDCANCEL,129,138,50,14,NOT WS_TABSTOP
+    LTEXT           "cmt",IDC_STATIC,7,7,12,14,SS_CENTERIMAGE
+    EDITTEXT        IDCMT_COMMAND,22,7,157,14,ES_AUTOHSCROLL | ES_WANTRETURN
+    LISTBOX         IDCMT_OUTPUT,7,24,172,110,LBS_SORT | 
+                    LBS_NOINTEGRALHEIGHT | LBS_DISABLENOSCROLL | LBS_NOSEL | 
+                    WS_VSCROLL | WS_HSCROLL | WS_TABSTOP
+    DEFPUSHBUTTON   "Execute",IDCMT_EXECUTE,7,138,50,14
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    IDD_NEWPACKAGE, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 115
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 123
+    END
+
+    IDD_DIALOGBAR, DIALOG
+    BEGIN
+        LEFTMARGIN, 2
+        RIGHTMARGIN, 277
+        BOTTOMMARGIN, 289
+    END
+
+    IDD_LISTEDIT, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 230
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 109
+    END
+
+    IDD_TEXTEDIT, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 179
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 40
+    END
+
+    IDD_CONSTITUENT, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 179
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 114
+    END
+
+    IDD_USES, DIALOG
+    BEGIN
+        LEFTMARGIN, 6
+        RIGHTMARGIN, 239
+        TOPMARGIN, 6
+        BOTTOMMARGIN, 46
+    END
+
+    IDD_CMT, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 179
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 152
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+CMTW                    ICON    DISCARDABLE     "CMTW.ICO"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+TEXTFXMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "New package",                 IDM_NEWPACKAGE
+        MENUITEM "E&xit",                       IDM_EXIT
+    END
+    POPUP "Actions"
+    BEGIN
+        MENUITEM "Configure",                   IDM_CONFIG
+        MENUITEM "Generate make",               IDM_GENMAKE
+        MENUITEM "Generate MSDEV",              IDM_GENMSDEV
+        MENUITEM "Build make setup",            IDM_BUILDSETUP
+        MENUITEM "Build constituents makefile", IDM_BUILDCONSTITUENTSMAKEFILE
+
+        MENUITEM "Build all constituent makefiles", 
+                                                IDM_BUILDCONSTITUENTMAKEFILE
+        MENUITEM "cmt ...",                     IDM_CMT
+    END
+END
+
+
+#ifndef _MAC
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,0,1
+ PRODUCTVERSION 1,0,0,1
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040c04b0"
+        BEGIN
+            VALUE "Comments", "\0"
+            VALUE "CompanyName", "LAL\0"
+            VALUE "FileDescription", "cmtw\0"
+            VALUE "FileVersion", "1, 0, 0, 1\0"
+            VALUE "InternalName", "cmtw\0"
+            VALUE "LegalCopyright", "Copyright © 1999\0"
+            VALUE "LegalTrademarks", "\0"
+            VALUE "OriginalFilename", "cmtw.exe\0"
+            VALUE "PrivateBuild", "\0"
+            VALUE "ProductName", "LAL cmtw\0"
+            VALUE "ProductVersion", "1, 0, 0, 1\0"
+            VALUE "SpecialBuild", "\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x40c, 1200
+    END
+END
+
+#endif    // !_MAC
+
+#endif    // French (France) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
Index: /CMT/v1r20/Visual/cmtw_utils.cxx
===================================================================
--- /CMT/v1r20/Visual/cmtw_utils.cxx	(revision 368)
+++ /CMT/v1r20/Visual/cmtw_utils.cxx	(revision 368)
@@ -0,0 +1,937 @@
+ 
+//--------------------------------------------------------------------- 
+#include "cmtw_utils.h" 
+#include <windowsx.h> 
+#include "resource.h" 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+WWindow::WWindow () 
+{ 
+  _window = NULL; 
+} 
+ 
+void WWindow::enable () 
+{ 
+  EnableWindow (_window, TRUE); 
+} 
+ 
+void WWindow::disable () 
+{ 
+  EnableWindow (_window, FALSE); 
+} 
+ 
+void WWindow::show () 
+{ 
+  ShowWindow (_window, SW_SHOW); 
+} 
+ 
+void WWindow::hide () 
+{ 
+  ShowWindow (_window, SW_HIDE); 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+WEdit::WEdit () 
+{ 
+  _edit = NULL; 
+} 
+ 
+WEdit::WEdit (HWND edit) 
+{ 
+  _edit = edit; 
+  _window = _edit; 
+} 
+ 
+WEdit::WEdit (HWND container, int id) 
+{ 
+  _edit = GetDlgItem (container, id); 
+  _window = _edit; 
+} 
+ 
+void WEdit::init (HWND container, int id) 
+{ 
+  _edit = GetDlgItem (container, id); 
+  _window = _edit; 
+} 
+ 
+WEdit& WEdit::operator = (HWND edit) 
+{ 
+  _edit = edit; 
+  _window = _edit; 
+  return (*this); 
+} 
+ 
+void WEdit::set (const char* text) 
+{ 
+  int status = SendMessage (_edit, WM_SETTEXT, (WPARAM) 0, (LPARAM) text); 
+} 
+ 
+void WEdit::set (const cmt_string& text) 
+{ 
+  set (text.c_str ()); 
+} 
+ 
+void WEdit::clear () 
+{ 
+  set (""); 
+} 
+ 
+cmt_string WEdit::get () const 
+{ 
+  int size = SendMessage (_edit, WM_GETTEXTLENGTH, (WPARAM) 0, (LPARAM) 0); 
+ 
+  cmt_string text (size); 
+ 
+  SendMessage (_edit, WM_GETTEXT, (WPARAM) size + 1, (LPARAM) text.c_str ()); 
+ 
+  return (text); 
+} 
+ 
+void WEdit::copy (const WEdit& other) 
+{ 
+  clear (); 
+  set (other.get ()); 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+WRadio::WRadio () 
+{ 
+  _radio = NULL; 
+} 
+ 
+WRadio::WRadio (HWND radio) 
+{ 
+  _radio  = radio; 
+  _window = _radio; 
+} 
+ 
+WRadio::WRadio (HWND container, int id) 
+{ 
+  _radio = GetDlgItem (container, id); 
+  _window = _radio; 
+} 
+ 
+void WRadio::init (HWND container, int id) 
+{ 
+  _radio = GetDlgItem (container, id); 
+  _window = _radio; 
+} 
+ 
+WRadio& WRadio::operator = (HWND radio) 
+{ 
+  _radio  = radio; 
+  _window = _radio; 
+  return (*this); 
+} 
+ 
+void WRadio::set (bool state) 
+{ 
+  int status = SendMessage (_radio, BM_SETCHECK,  
+	  (WPARAM) (state) ? BST_CHECKED : BST_UNCHECKED, 
+	  (LPARAM) 0); 
+} 
+ 
+bool WRadio::get () const 
+{ 
+  bool result = (SendMessage (_radio,  
+	  BM_GETCHECK, (WPARAM) 0, (LPARAM) 0) == BST_CHECKED); 
+ 
+  return (result); 
+} 
+ 
+void WRadio::copy (const WRadio& other) 
+{ 
+  set (other.get ()); 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+WList::WList () 
+{ 
+  _list = NULL; 
+  _selected_index = -1; 
+  _width = 0; 
+} 
+ 
+WList::WList (HWND list) 
+{ 
+  _list = list; 
+  _window = _list; 
+  _width = get_width (); 
+  set_extent (); 
+  get_selected_index (); 
+} 
+ 
+WList::WList (HWND container, int id) 
+{ 
+  _list = GetDlgItem (container, id); 
+  _window = _list; 
+  _width = get_width (); 
+  set_extent (); 
+  get_selected_index (); 
+} 
+ 
+void WList::init (HWND container, int id) 
+{ 
+  _list = GetDlgItem (container, id); 
+  _window = _list; 
+  _width = get_width (); 
+  set_extent (); 
+  get_selected_index (); 
+} 
+ 
+WList& WList::operator = (HWND list) 
+{ 
+  _list = list; 
+  _window = _list; 
+  _width = get_width (); 
+  set_extent (); 
+  get_selected_index (); 
+  return (*this); 
+} 
+ 
+void WList::append (const char* text) 
+{ 
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) -1, (LPARAM) text); 
+  int w = strlen (text); 
+  if (w > _width)  
+  { 
+    _width = w; 
+    set_extent (); 
+  } 
+} 
+ 
+void WList::append (const cmt_string& text) 
+{ 
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) -1, (LPARAM) text.c_str ()); 
+  int w = text.size (); 
+  if (w > _width)  
+  { 
+    _width = w; 
+    set_extent (); 
+  } 
+} 
+ 
+void WList::insert (int index, const cmt_string& text) 
+{ 
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) index, (LPARAM) text.c_str ()); 
+  int w = text.size (); 
+  if (w > _width)  
+  { 
+    _width = w; 
+    set_extent (); 
+  } 
+} 
+ 
+void WList::modify (int index, const cmt_string& text) 
+{ 
+  SendMessage (_list, LB_DELETESTRING, (WPARAM) index, (LPARAM) 0); 
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) index, (LPARAM) text.c_str ()); 
+ 
+  _width = get_width (); 
+  set_extent (); 
+} 
+ 
+void WList::delete_item (int index) 
+{ 
+  SendMessage (_list, LB_DELETESTRING, (WPARAM) index, (LPARAM) 0); 
+ 
+  _width = get_width (); 
+  set_extent (); 
+} 
+ 
+void WList::clear () 
+{ 
+  SendMessage (_list, LB_RESETCONTENT, (WPARAM) 0, (LPARAM) 0); 
+  _selected_index = -1; 
+  _width = 0; 
+  set_extent (); 
+} 
+ 
+void WList::cancel_selection () 
+{ 
+  SendMessage (_list, LB_SETCURSEL, (WPARAM) -1, (LPARAM) 0); 
+  _selected_index = -1; 
+} 
+ 
+int WList::get_selected_index () 
+{ 
+  int index; 
+                 
+  index = SendMessage (_list, LB_GETCURSEL, (WPARAM) 0, (LPARAM) 0); 
+  _selected_index = index; 
+ 
+  return (index); 
+} 
+ 
+void WList::set_selected_index (int index) 
+{ 
+  SendMessage (_list, LB_SETCURSEL, (WPARAM) index, (LPARAM) 0); 
+  _selected_index = index; 
+} 
+ 
+cmt_string WList::get_selected () 
+{ 
+  int index = get_selected_index (); 
+ 
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0); 
+ 
+  cmt_string text (size + 1); 
+ 
+  SendMessage (_list, LB_GETTEXT, (WPARAM) index, (LPARAM) text.c_str ()); 
+ 
+  return (text); 
+} 
+ 
+int WList::get_item_count () const 
+{ 
+  int item; 
+         
+  item = SendMessage (_list, LB_GETCOUNT, (WPARAM) 0, (LPARAM) 0); 
+ 
+  return (item); 
+} 
+ 
+cmt_string WList::get_item (int index) const 
+{ 
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0); 
+ 
+  cmt_string text (size + 1); 
+         
+  SendMessage (_list, LB_GETTEXT, (WPARAM) index, (LPARAM) text.c_str ()); 
+ 
+  return (text); 
+} 
+ 
+void WList::get_item (int index, cmt_string& text) const 
+{ 
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0); 
+ 
+  static cmt_string temp; 
+  temp.resize (size); 
+	   
+  SendMessage (_list, LB_GETTEXT, (WPARAM) index, (LPARAM) temp.c_str ()); 
+ 
+  text = temp; 
+} 
+ 
+int WList::get_item_length (int index) const 
+{ 
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0); 
+ 
+  return (size); 
+} 
+ 
+void WList::copy (const WList& other) 
+{ 
+  int items; 
+  int i; 
+ 
+  clear (); 
+ 
+  items = other.get_item_count (); 
+  for (i = 0; i < items; i++) 
+    { 
+      append (other.get_item (i)); 
+    } 
+} 
+ 
+void WList::set (const CmtSystem::cmt_string_vector& v, int first) 
+{ 
+  int i; 
+ 
+  clear (); 
+ 
+  for (i = first; i < v.size (); i++) 
+    { 
+      append (v[i]); 
+    } 
+} 
+ 
+void WList::set (const cmt_string& file_name) 
+{ 
+  clear (); 
+ 
+  cmt_string text; 
+  cmt_string line; 
+  int pos; 
+  int max_pos; 
+ 
+  text.read (file_name); 
+ 
+  pos = 0; 
+  max_pos = text.size (); 
+ 
+  for (pos = 0; pos < max_pos;) 
+    { 
+      int cr = text.find (pos, "\r\n"); 
+      int nl = text.find (pos, '\n');  
+      int first = nl; 
+      int length = 1; 
+ 
+      if (cr != cmt_string::npos) 
+        { 
+          if (nl == cmt_string::npos) 
+            { 
+              first = cr; 
+              length = 2; 
+            } 
+          else 
+            { 
+              first = (nl < cr) ? nl : cr; 
+              length = (nl < cr) ? 1 : 2; 
+            } 
+        } 
+ 
+      if (first == cmt_string::npos) 
+        { 
+          text.substr (pos, line); 
+          pos = max_pos; 
+        } 
+      else if (first > pos) 
+        { 
+          text.substr (pos, first - pos, line); 
+          pos = first + length; 
+        } 
+      else 
+        { 
+          line = ""; 
+          pos += length; 
+        } 
+ 
+      append (line); 
+    } 
+} 
+ 
+void WList::get (CmtSystem::cmt_string_vector& v) const 
+{ 
+  int count = get_item_count (); 
+  int i; 
+ 
+  v.clear (); 
+ 
+  for (i = 0; i < count; i++) 
+    { 
+      v.push_back (get_item (i)); 
+    } 
+} 
+ 
+void WList::get (cmt_string& s) const 
+{ 
+  int count = get_item_count (); 
+  int i; 
+ 
+  s = ""; 
+ 
+  for (i = 0; i < count; i++) 
+    { 
+      if (i > 0) s += '\n'; 
+      s += get_item (i); 
+    } 
+} 
+ 
+void WList::set_extent () 
+{ 
+  int width = get_extent (); 
+  ListBox_SetHorizontalExtent (_list, width); 
+} 
+ 
+int WList::get_width () const 
+{ 
+  if (_list == 0) return (0); 
+ 
+  int count = get_item_count (); 
+  int w = 0; 
+ 
+  int i; 
+  for (i = 0; i < count; i++) 
+  { 
+	  int length = get_item_length (i); 
+	  if (length > w) w = length; 
+  } 
+ 
+  return (w); 
+} 
+ 
+int WList::get_extent () const 
+{ 
+  if (_width == 0) return (0); 
+ 
+  cmt_string text (_width + 1); 
+ 
+  HDC context = GetDC (_list); 
+  int saved_context = SaveDC (context); 
+  HFONT font = GetWindowFont (_list); 
+  if (font != NULL) SelectFont (context, font); 
+ 
+  int w = 0; 
+ 
+  int count = get_item_count (); 
+ 
+  int i; 
+  for (i = 0; i < count; i++) 
+  { 
+	  SIZE size; 
+ 
+	  get_item (i, text); 
+	  GetTextExtentPoint32 (context, text.c_str (), text.size (), &size); 
+	  if (size.cx > w) w = size.cx; 
+  } 
+ 
+  RestoreDC (context, saved_context); 
+  ReleaseDC (_list, context); 
+ 
+  w += GetSystemMetrics (SM_CXVSCROLL); 
+ 
+  return (w); 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+void WTab::add (const cmt_string& key, WWindow& window, WRadio& radio) 
+{ 
+	_keys.push_back (key); 
+	_windows.push_back (&window); 
+	_radios.push_back (&radio); 
+} 
+ 
+void WTab::select (const cmt_string& key) 
+{ 
+	int i; 
+	for (i = 0; i < _keys.size (); i++) 
+	{ 
+		const cmt_string& k = _keys[i]; 
+		if (k == key) 
+		{ 
+			for (int j = 0; j < _keys.size (); j++) 
+			{ 
+				WWindow* w = _windows[j]; 
+				WRadio* r = _radios[j]; 
+				if (i == j)  
+				{ 
+					w->show (); 
+					r->set (true); 
+				} 
+				else 
+				{ 
+					w->hide (); 
+					r->set (false); 
+				} 
+			} 
+			return; 
+		} 
+	} 
+} 
+ 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+mysb::mysb (WList& list) : _list (list) 
+{ 
+    //list_clear (list); 
+  _buf = 0; 
+#ifdef OLD_HEADERS 
+  _old = cout.rdbuf (); 
+  cout = this; 
+#else 
+  _old = cout.rdbuf (this); 
+#endif 
+} 
+ 
+mysb::~mysb () 
+{ 
+  if (_buf != 0) 
+  { 
+    delete _buf; 
+	_buf = 0; 
+  } 
+ 
+#ifdef OLD_HEADERS 
+  cout = _old; 
+#else 
+  cout.rdbuf (_old); 
+#endif 
+} 
+ 
+int_type mysb::overflow (int_type c) 
+{ 
+  if (_buf == 0) 
+  { 
+    _buf = new cmt_string; 
+  } 
+ 
+  cmt_string& buf = *_buf; 
+ 
+  if (c == '\n') 
+    { 
+      _list.append (buf); 
+      buf = ""; 
+    } 
+  else 
+    { 
+      buf += c; 
+    } 
+  return (c); 
+} 
+         
+int mysb::underflow () 
+{ 
+  return (EOF); 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+WDialog::WDialog () 
+{ 
+} 
+ 
+void WDialog::action (UINT message_type, 
+                      WPARAM parameter1, 
+                      LPARAM parameter2) 
+{ 
+} 
+ 
+void WDialog::init_action () 
+{ 
+} 
+ 
+void WDialog::menu_action (int menu_item, 
+                           WPARAM parameter1, 
+                           LPARAM parameter2) 
+{ 
+  switch (menu_item)  
+    { 
+      case IDOK: 
+        break; 
+      case IDCANCEL: 
+        break; 
+      default: 
+        break; 
+    } 
+} 
+ 
+int WDialog::run (HINSTANCE instance, HWND father, int id) 
+{ 
+  return (DialogBoxParam (instance,  
+                          MAKEINTRESOURCE(id),  
+                          father, 
+                          (DLGPROC) proc, 
+                          (LPARAM) this)); 
+} 
+ 
+LRESULT CALLBACK WDialog::proc (HWND dialog, 
+                                UINT message_type, 
+                                WPARAM parameter1, 
+                                LPARAM parameter2) 
+{ 
+  static cmt_vector <WDialog*> objects; 
+  WDialog* object = NULL; 
+  int menu_item; 
+ 
+  switch (message_type)  
+    { 
+      case WM_CREATE: 
+        break; 
+      case WM_SETFONT: 
+        break; 
+      case WM_INITDIALOG: 
+        object = (WDialog*) parameter2; 
+        if (object != NULL) 
+          { 
+            objects.push_back (object); 
+ 
+            object->_dialog = dialog; 
+            object->init_action (); 
+          } 
+        break; 
+      case WM_COMMAND: 
+        menu_item = LOWORD (parameter1); 
+ 
+        if (objects.size () > 0) 
+          { 
+            object = objects.back (); 
+          } 
+ 
+        if (object != NULL) 
+          { 
+            object->menu_action (menu_item, parameter1, parameter2); 
+          } 
+ 
+        switch (menu_item)  
+          { 
+            case IDOK: 
+              EndDialog (dialog, IDOK); 
+              objects.pop_back (); 
+              break; 
+            case IDCANCEL: 
+              EndDialog (dialog, IDCANCEL); 
+              objects.pop_back (); 
+              break; 
+            default: 
+              break; 
+          } 
+        break; 
+      default: 
+        if (objects.size () > 0) 
+          { 
+            object = objects.back (); 
+          } 
+ 
+        if (object != NULL) 
+          { 
+            object->action (message_type, parameter1, parameter2); 
+          } 
+        return (FALSE); 
+    } 
+  return (TRUE); 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+TextEditor::TextEditor (cmt_string& ref) : _ref (ref) 
+{ 
+} 
+ 
+int TextEditor::run (HINSTANCE instance, HWND father) 
+{ 
+  return (WDialog::run (instance, father, IDD_TEXTEDIT)); 
+} 
+ 
+void TextEditor::action (UINT message_type, 
+                         WPARAM parameter1, 
+                         LPARAM parameter2) 
+{ 
+} 
+ 
+void TextEditor::init_action () 
+{ 
+  _edit = GetDlgItem (_dialog, IDTE_TEXT); 
+  _edit.set (_ref); 
+} 
+ 
+void TextEditor::menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2) 
+{ 
+  switch (menu_item)  
+    { 
+      case IDOK: 
+        _ref = _edit.get (); 
+        break; 
+      case IDCANCEL: 
+        break; 
+      default: 
+        break; 
+    } 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+ListEditor::ListEditor (WList& list) : _ref_list (list) 
+{ 
+} 
+ 
+int ListEditor::run (HINSTANCE instance, HWND father) 
+{ 
+  _instance = instance; 
+  return (WDialog::run (instance, father, IDD_LISTEDIT)); 
+} 
+ 
+void ListEditor::action (UINT message_type, 
+                         WPARAM parameter1, 
+                         LPARAM parameter2) 
+{ 
+} 
+ 
+void ListEditor::set_position (int index) 
+{ 
+  _list.set_selected_index (index); 
+  _selected_index = index; 
+  _last_index = index; 
+} 
+ 
+void ListEditor::init_action () 
+{ 
+  _list.init (_dialog, IDLE_LIST); 
+  _list.copy (_ref_list); 
+  _ref_selected_index = _ref_list.get_selected_index (); 
+  _list.set_selected_index (_ref_selected_index); 
+  _selected_index = _ref_selected_index; 
+  _last_index = _ref_selected_index; 
+} 
+ 
+void ListEditor::menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2) 
+{ 
+  int index = _list.get_selected_index (); 
+ 
+  switch (menu_item)  
+    { 
+      case IDOK: 
+        _ref_list.copy (_list); 
+        _ref_list.set_selected_index (_ref_selected_index); 
+        break; 
+      case IDCANCEL: 
+        break; 
+      case IDLE_ADD: 
+      { 
+        cmt_string s; 
+        TextEditor editor (s); 
+ 
+        if (editor.run (_instance, _dialog) == IDOK) 
+          { 
+            _list.insert (index, s); 
+          } 
+      } 
+      break; 
+      case IDLE_REMOVE: 
+      { 
+        if (index != -1) 
+          { 
+            _list.delete_item (index); 
+          } 
+      } 
+      break; 
+      case IDLE_LIST: 
+     { 
+        switch (HIWORD(parameter1)) 
+          { 
+            case LBN_DBLCLK: 
+            { 
+              if (index == -1) index = _last_index; 
+              cmt_string s = _list.get_item (index); 
+              TextEditor editor (s); 
+         
+              if (editor.run (_instance, _dialog) == IDOK) 
+                { 
+                  _list.modify (index, s); 
+                } 
+              _list.set_selected_index (index); 
+              _selected_index = index; 
+              _last_index = index; 
+            } 
+            break; 
+            case LBN_SELCHANGE: 
+              if (_selected_index == -1) 
+                { 
+                  _selected_index = index; 
+                  _last_index = index; 
+                } 
+              else if (_selected_index == index) 
+                { 
+                  _list.cancel_selection (); 
+                  _selected_index = -1; 
+                } 
+              else 
+                { 
+                  _selected_index = index; 
+                  _last_index = index; 
+                } 
+              break; 
+            case LBN_SELCANCEL: 
+            { 
+            } 
+            break; 
+          } 
+      } 
+      break; 
+      default: 
+        break; 
+    } 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+CmtMutex::CmtMutex () 
+{ 
+  InitializeCriticalSection (&_section); 
+} 
+ 
+CmtMutex::~CmtMutex () 
+{ 
+  DeleteCriticalSection (&_section); 
+} 
+ 
+void CmtMutex::lock () 
+{ 
+  EnterCriticalSection (&_section); 
+} 
+ 
+void CmtMutex::unlock () 
+{ 
+  LeaveCriticalSection (&_section); 
+} 
+//--------------------------------------------------------------------- 
+ 
+//--------------------------------------------------------------------- 
+CmtThread::CmtThread () 
+{ 
+  _shutdown = FALSE; 
+  _running = FALSE; 
+} 
+ 
+CmtThread::~CmtThread () 
+{ 
+} 
+ 
+void CmtThread::run () 
+{ 
+} 
+ 
+bool CmtThread::is_running () 
+{ 
+  bool result = false; 
+ 
+  _mutex.lock (); 
+  result = _running; 
+  _mutex.unlock (); 
+ 
+  return (result); 
+} 
+ 
+void CmtThread::set_running () 
+{ 
+  _mutex.lock (); 
+  _running = TRUE; 
+  _mutex.unlock (); 
+} 
+ 
+void CmtThread::reset_running () 
+{ 
+  _mutex.lock (); 
+  _running = FALSE; 
+  _mutex.unlock (); 
+} 
+ 
+bool CmtThread::start () 
+{ 
+  if (!is_running ()) 
+    { 
+      _thread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) run_it, 
+                              this, 0, &_id); 
+ 
+	  return (TRUE); 
+    } 
+  else 
+    { 
+	  return (FALSE); 
+    } 
+} 
+ 
+void CmtThread::stop () 
+{ 
+  _mutex.lock (); 
+  _shutdown = TRUE; 
+  _mutex.unlock (); 
+ 
+  WaitForSingleObject (_thread, INFINITE); 
+} 
+ 
+void CmtThread::run_it (CmtThread* thread) 
+{ 
+  thread->set_running (); 
+  thread->run (); 
+  thread->reset_running (); 
+} 
+//--------------------------------------------------------------------- 
+ 
Index: /CMT/v1r20/Visual/cmtw_utils.h
===================================================================
--- /CMT/v1r20/Visual/cmtw_utils.h	(revision 368)
+++ /CMT/v1r20/Visual/cmtw_utils.h	(revision 368)
@@ -0,0 +1,247 @@
+#ifndef __cmtw_utils_h__ 
+#define __cmtw_utils_h__ 
+ 
+#include <windows.h> 
+#include "cmt.h" 
+ 
+//------------------------------------------------------------------- 
+class WWindow 
+{ 
+public: 
+  WWindow (); 
+ 
+  void enable (); 
+  void disable (); 
+  void show (); 
+  void hide (); 
+ 
+protected: 
+  HWND _window; 
+}; 
+//------------------------------------------------------------------- 
+ 
+//------------------------------------------------------------------- 
+class WEdit : public WWindow 
+{ 
+public: 
+  WEdit (); 
+  WEdit (HWND edit); 
+  WEdit (HWND container, int id); 
+ 
+  void init (HWND container, int id); 
+  WEdit& operator = (HWND edit); 
+  void set (const char* text); 
+  void set (const cmt_string& text); 
+  void clear (); 
+  cmt_string get () const; 
+  void copy (const WEdit& other); 
+ 
+private: 
+  HWND _edit; 
+}; 
+//------------------------------------------------------------------- 
+ 
+//------------------------------------------------------------------- 
+class WRadio : public WWindow 
+{ 
+public: 
+  WRadio (); 
+  WRadio (HWND radio); 
+  WRadio (HWND container, int id); 
+ 
+  void init (HWND container, int id); 
+  WRadio& operator = (HWND radio); 
+  void set (bool state); 
+  bool get () const; 
+  void copy (const WRadio& other); 
+ 
+private: 
+  HWND _radio; 
+}; 
+//------------------------------------------------------------------- 
+ 
+//------------------------------------------------------------------- 
+class WList : public WWindow 
+{ 
+public: 
+  WList (); 
+  WList (HWND list); 
+  WList (HWND container, int id); 
+ 
+  void init (HWND container, int id); 
+  WList& operator = (HWND list); 
+  void append (const char* text); 
+  void append (const cmt_string& text); 
+  void insert (int index, const cmt_string& text); 
+  void modify (int index, const cmt_string& text); 
+  void delete_item (int index); 
+  void clear (); 
+  void cancel_selection (); 
+  int get_selected_index (); 
+  void set_selected_index (int index); 
+  cmt_string get_selected (); 
+  int get_item_count () const; 
+  cmt_string get_item (int index) const; 
+  void get_item (int index, cmt_string& text) const; 
+  int get_item_length (int index) const; 
+  void copy (const WList& other); 
+  void set (const CmtSystem::cmt_string_vector& v, int first = 0); 
+  void set (const cmt_string& file_name); 
+  void get (CmtSystem::cmt_string_vector& v) const; 
+  void get (cmt_string& s) const; 
+  void set_extent (); 
+  int get_width () const; 
+  int get_extent () const; 
+ 
+private: 
+  HWND _list; 
+  int _selected_index; 
+  int _width; 
+}; 
+//------------------------------------------------------------------- 
+ 
+//------------------------------------------------------------------- 
+class WTab 
+{ 
+public: 
+	void add (const cmt_string& key, WWindow& window, WRadio& radio); 
+	void select (const cmt_string& key); 
+ 
+private: 
+	cmt_vector<cmt_string> _keys; 
+	cmt_vector<WWindow*>   _windows; 
+	cmt_vector<WRadio*>    _radios; 
+}; 
+//------------------------------------------------------------------- 
+ 
+/*---------------------------------------------------------------------*/ 
+class mysb :public streambuf 
+{ 
+public: 
+  mysb (WList& list); 
+  ~mysb (); 
+ 
+private: 
+  int_type overflow (int_type c); 
+  int underflow (); 
+ 
+  streambuf* _old; 
+  cmt_string* _buf; 
+  WList& _list; 
+}; 
+/*---------------------------------------------------------------------*/ 
+ 
+/*---------------------------------------------------------------------*/ 
+class WDialog 
+{ 
+public: 
+  WDialog (); 
+ 
+  virtual void action (UINT message_type, 
+                       WPARAM parameter1, 
+                       LPARAM parameter2); 
+  virtual void init_action (); 
+  virtual void menu_action (int menu_item, 
+                            WPARAM parameter1, 
+                            LPARAM parameter2); 
+ 
+protected: 
+ 
+  int run (HINSTANCE instance, HWND father, int id); 
+ 
+  HWND _dialog; 
+ 
+private: 
+ 
+  static LRESULT CALLBACK proc (HWND dialog, 
+                                UINT message_type, 
+                                WPARAM parameter1, 
+                                LPARAM parameter2); 
+}; 
+/*---------------------------------------------------------------------*/ 
+ 
+/*---------------------------------------------------------------------*/ 
+class TextEditor : public WDialog 
+{ 
+public: 
+  TextEditor (cmt_string& ref); 
+ 
+  int run (HINSTANCE instance, HWND father); 
+  virtual void action (UINT message_type, 
+                       WPARAM parameter1, 
+                       LPARAM parameter2); 
+  void init_action (); 
+  void menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2); 
+ 
+private: 
+  cmt_string& _ref; 
+  WEdit _edit; 
+}; 
+/*---------------------------------------------------------------------*/ 
+ 
+/*---------------------------------------------------------------------*/ 
+class ListEditor : public WDialog 
+{ 
+public: 
+  ListEditor (WList& list); 
+ 
+  int run (HINSTANCE instance, HWND father); 
+  virtual void action (UINT message_type, 
+                       WPARAM parameter1, 
+                       LPARAM parameter2); 
+  void set_position (int index); 
+  void init_action (); 
+  void menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2); 
+ 
+private: 
+  WList& _ref_list; 
+  WList _list; 
+  HINSTANCE _instance; 
+  int _selected_index; 
+  int _last_index; 
+  int _ref_selected_index; 
+}; 
+/*---------------------------------------------------------------------*/ 
+ 
+/*---------------------------------------------------------------------*/ 
+class CmtMutex 
+{ 
+public: 
+  CmtMutex (); 
+  ~CmtMutex (); 
+ 
+  void lock (); 
+  void unlock (); 
+ 
+private: 
+  CRITICAL_SECTION _section; 
+}; 
+/*---------------------------------------------------------------------*/ 
+ 
+/*---------------------------------------------------------------------*/ 
+class CmtThread 
+{ 
+public: 
+  CmtThread (); 
+  virtual ~CmtThread (); 
+ 
+  virtual void run (); 
+  bool is_running (); 
+  void set_running (); 
+  void reset_running (); 
+  bool start (); 
+  void stop (); 
+ 
+private: 
+  static void run_it (CmtThread* thread); 
+ 
+  HANDLE _thread; 
+  DWORD _id; 
+  CmtMutex _mutex; 
+  bool _shutdown; 
+  bool _running; 
+}; 
+/*---------------------------------------------------------------------*/ 
+ 
+ 
+#endif 
Index: /CMT/v1r20/Visual/cvsmove.cxx
===================================================================
--- /CMT/v1r20/Visual/cvsmove.cxx	(revision 368)
+++ /CMT/v1r20/Visual/cvsmove.cxx	(revision 368)
@@ -0,0 +1,125 @@
+
+#include "cmt_std.h"
+#include "cmt_system.h"
+
+//----------------------------------------------------------
+class FileScanner
+{
+public:
+  class actor
+  {
+  public:
+    virtual void run ()
+    {
+    }
+  };
+
+  FileScanner (const cmt_string& new_root);
+  bool scan (actor& a);
+
+private:
+  void scan (int level, actor& a);
+
+  cmt_string _root;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+FileScanner::FileScanner (const cmt_string& new_root) : _root(new_root)
+  //----------------------------------------------------------
+{
+}
+
+//----------------------------------------------------------
+bool FileScanner::scan (actor& a)
+//----------------------------------------------------------
+{
+  scan (0, a);
+
+  return (true);
+}
+
+//----------------------------------------------------------
+void FileScanner::scan (int level, actor& a)
+//----------------------------------------------------------
+{
+  CmtSystem::cmt_string_vector list;
+
+  CmtSystem::scan_dir ("*", list);
+
+  if (list.size () == 0) return;
+
+  // Will be set if at least one directory is a version directory
+  bool has_cvs = false;
+
+  if (CmtSystem::test_directory ("CVS")) has_cvs = true;
+
+  if (!has_cvs) return;
+
+  cmt_string cvs_root;
+  cmt_string cvs_repository;
+
+  cvs_root.read ("CVS/Root");
+  cvs_repository.read ("CVS/Repository");
+
+  int pos;
+
+  if (cvs_root[0] == ':')
+  {
+	  pos = cvs_root.find_last_of (":");
+	  if (pos != cmt_string::npos)
+	  {
+		  cvs_root.erase (0, pos);
+	  }
+  }
+
+  pos = cvs_repository.find (cvs_root);
+  if (pos == 0)
+  {
+	  cvs_repository.replace (cvs_root, _root);
+  }
+  
+  if (_root.write ("CVS/Root"))
+  {
+	  cout << "CVS root changed from " << cvs_root << " to " << _root << endl;
+  }
+  else
+  {
+	  cout << "cannot change CVS root in " << CmtSystem::pwd () << endl;
+  }
+
+  if (cvs_repository.write ("CVS/Repository"))
+  {
+	  cout << "CVS repository changed from " << cvs_root << " to " << _root << endl;
+  }
+  else
+  {
+	  cout << "cannot change CVS repository in " << CmtSystem::pwd () << endl;
+  }
+
+  int i;
+  for (i = 0; i < list.size (); i++)
+    {
+      cmt_string& name = list[i];
+
+	  if (name[0] == CmtSystem::file_separator ()) name.erase (0, 1);
+
+	  if (CmtSystem::test_directory (name))
+	  {
+		  CmtSystem::cd (name);
+		  scan (level + 1, a);
+		  CmtSystem::cd ("..");
+	  }
+    }
+}
+
+int main (int argc, char* argv[])
+{
+	FileScanner scanner ("/cvs");
+	FileScanner::actor actor;
+	
+	CmtSystem::cd ("..");
+	scanner.scan (actor);
+
+	return (0);
+}
Index: /CMT/v1r20/Visual/cvsmove.dsp
===================================================================
--- /CMT/v1r20/Visual/cvsmove.dsp	(revision 368)
+++ /CMT/v1r20/Visual/cvsmove.dsp	(revision 368)
@@ -0,0 +1,98 @@
+# Microsoft Developer Studio Project File - Name="cvsmove" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=cvsmove - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "cvsmove.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "cvsmove.mak" CFG="cvsmove - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "cvsmove - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "cvsmove - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "cvsmove - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "cvsmove - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "cvsmove___Win32_Debug"
+# PROP BASE Intermediate_Dir "cvsmove___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "cvsmove - Win32 Release"
+# Name "cvsmove - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/doc.dsp
===================================================================
--- /CMT/v1r20/Visual/doc.dsp	(revision 368)
+++ /CMT/v1r20/Visual/doc.dsp	(revision 368)
@@ -0,0 +1,71 @@
+# Microsoft Developer Studio Project File - Name="doc" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Generic Project" 0x010a
+
+CFG=doc - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "doc.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "doc.mak" CFG="doc - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "doc - Win32 Release" (based on "Win32 (x86) Generic Project")
+!MESSAGE "doc - Win32 Debug" (based on "Win32 (x86) Generic Project")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+MTL=midl.exe
+
+!IF  "$(CFG)" == "doc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+
+!ELSEIF  "$(CFG)" == "doc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "doc___Win32_Debug"
+# PROP BASE Intermediate_Dir "doc___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "doc___Win32_Debug"
+# PROP Intermediate_Dir "doc___Win32_Debug"
+# PROP Target_Dir ""
+
+!ENDIF 
+
+# Begin Target
+
+# Name "doc - Win32 Release"
+# Name "doc - Win32 Debug"
+# Begin Source File
+
+SOURCE=..\doc\CMTDoc.html
+# End Source File
+# Begin Source File
+
+SOURCE=.\html.java
+# End Source File
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/html.dsp
===================================================================
--- /CMT/v1r20/Visual/html.dsp	(revision 368)
+++ /CMT/v1r20/Visual/html.dsp	(revision 368)
@@ -0,0 +1,67 @@
+# Microsoft Developer Studio Project File - Name="html" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Generic Project" 0x010a
+
+CFG=html - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "html.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "html.mak" CFG="html - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "html - Win32 Release" (based on "Win32 (x86) Generic Project")
+!MESSAGE "html - Win32 Debug" (based on "Win32 (x86) Generic Project")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+MTL=midl.exe
+
+!IF  "$(CFG)" == "html - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+
+!ELSEIF  "$(CFG)" == "html - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "html___Win32_Debug"
+# PROP BASE Intermediate_Dir "html___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "html___Win32_Debug"
+# PROP Intermediate_Dir "html___Win32_Debug"
+# PROP Target_Dir ""
+
+!ENDIF 
+
+# Begin Target
+
+# Name "html - Win32 Release"
+# Name "html - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\html.java
+# End Source File
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/install.dsp
===================================================================
--- /CMT/v1r20/Visual/install.dsp	(revision 368)
+++ /CMT/v1r20/Visual/install.dsp	(revision 368)
@@ -0,0 +1,123 @@
+# Microsoft Developer Studio Project File - Name="install" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=install - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "install.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "install.mak" CFG="install - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "install - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "install - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "install - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\src" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF  "$(CFG)" == "install - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "install___Win32_Debug"
+# PROP BASE Intermediate_Dir "install___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\src" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "install - Win32 Release"
+# Name "install - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\src\install.cxx
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\install_utils.cxx
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\src\install_resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\install_utils.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# Begin Source File
+
+SOURCE=..\src\install.rc
+# End Source File
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/jcmt.dsp
===================================================================
--- /CMT/v1r20/Visual/jcmt.dsp	(revision 368)
+++ /CMT/v1r20/Visual/jcmt.dsp	(revision 368)
@@ -0,0 +1,111 @@
+# Microsoft Developer Studio Project File - Name="jcmt" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Generic Project" 0x010a
+
+CFG=jcmt - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "jcmt.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "jcmt.mak" CFG="jcmt - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "jcmt - Win32 Release" (based on "Win32 (x86) Generic Project")
+!MESSAGE "jcmt - Win32 Debug" (based on "Win32 (x86) Generic Project")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+MTL=midl.exe
+
+!IF  "$(CFG)" == "jcmt - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Target_Dir ""
+
+!ELSEIF  "$(CFG)" == "jcmt - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "jcmt___Win32_Debug"
+# PROP BASE Intermediate_Dir "jcmt___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\VisualC"
+# PROP Intermediate_Dir "..\VisualC"
+# PROP Target_Dir ""
+
+!ENDIF 
+
+# Begin Target
+
+# Name "jcmt - Win32 Release"
+# Name "jcmt - Win32 Debug"
+# Begin Source File
+
+SOURCE=..\java\cmt_list.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\cmt_package.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\cmt_parser.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\customizer.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\DynamicTree.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\DynamicTreeListener.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\error_listener.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\general_editor.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\requirements_editor.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\submit_listener.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\texec.java
+# End Source File
+# Begin Source File
+
+SOURCE=..\java\use.java
+# End Source File
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/p.cxx
===================================================================
--- /CMT/v1r20/Visual/p.cxx	(revision 368)
+++ /CMT/v1r20/Visual/p.cxx	(revision 368)
@@ -0,0 +1,119 @@
+#include <stdio.h> 
+ 
+#include "heure.h" 
+ 
+static int N; 
+static heure* valeur; 
+static bool* ok; 
+static bool* solution; 
+static heure seuil; 
+static heure grand_total; 
+ 
+//------------------------------------------------------ 
+void permutations (int valeurs, int possibilites, int pos = 0) 
+//------------------------------------------------------ 
+{ 
+	if (valeurs <= 0) 
+	{ 
+		// c'est la fin 
+		heure total; 
+		int k; 
+ 
+		// On calcule le total des valeurs marquees 
+ 
+		for (k = 0; k < N; k++) 
+		{ 
+			if (ok[k]) total += valeur[k]; 
+		} 
+ 
+		if (total <= seuil) 
+		{ 
+			if (total > grand_total) 
+			{ 
+				// nouveau total 
+				grand_total = total; 
+				 
+				for (k = 0; k < N; k++) 
+				{ 
+					solution[k] = ok[k]; 
+				} 
+			} 
+			else 
+			{ 
+				// pas mieux 
+			} 
+		} 
+		else 
+		{ 
+			// trop grand 
+		} 
+		 
+		return; 
+	} 
+ 
+	// Protection : ca ne devrait jamais arriver !!! 
+	if (valeurs > possibilites) return; 
+ 
+	// On essaie en utilisant la première case 
+	ok[pos] = true; 
+	permutations (valeurs-1, possibilites-1, pos+1); 
+ 
+	// On essaie en n'utilisant pas la première case 
+	ok[pos] = false; 
+	permutations (valeurs, possibilites-1, pos+1); 
+} 
+ 
+//------------------------------------------------------ 
+int main (int argc, char* argv[]) 
+//------------------------------------------------------ 
+{ 
+	// Recuperation des parametres 
+	// 
+	//  Le premier est le seuil 
+	argc--; 
+	argv++; 
+ 
+	seuil = argv[0]; 
+ 
+	//  Ensuite on a N valeurs 
+	argc--; 
+	argv++; 
+ 
+	N = argc; 
+ 
+	valeur   = new heure[N]; 
+ 
+	int k; 
+ 
+	for (k = 0; k < N; k++) 
+	{ 
+		valeur[k] = argv[0]; 
+		argc--; 
+		argv++; 
+	} 
+ 
+	// On a besoin de N etats pour cocher les valeurs. 
+	// Et d'une copie pour la solution. 
+	ok       = new bool[N]; 
+	solution = new bool[N]; 
+ 
+	// On essaie les permutations successivement pour 
+	// des nombres de valeurs de + en + grands parmi N 
+	for (k = 1; k <= N; k++) 
+	{ 
+		permutations (k, N); 
+	} 
+	 
+	for (k = 0; k < N; k++) 
+	{ 
+		valeur[k].print (); 
+		if (solution[k]) printf (" <--- "); 
+		printf ("\n"); 
+	} 
+	printf ("-----\n"); 
+	grand_total.print (); 
+	printf ("\n"); 
+	 
+	return (0); 
+} 
+ 
Index: /CMT/v1r20/Visual/p.dsp
===================================================================
--- /CMT/v1r20/Visual/p.dsp	(revision 368)
+++ /CMT/v1r20/Visual/p.dsp	(revision 368)
@@ -0,0 +1,104 @@
+# Microsoft Developer Studio Project File - Name="p" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=p - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "p.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "p.mak" CFG="p - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "p - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "p - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "p - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "p - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "p___Win32_Debug"
+# PROP BASE Intermediate_Dir "p___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "p___Win32_Debug"
+# PROP Intermediate_Dir "p___Win32_Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "p - Win32 Release"
+# Name "p - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\p.cxx
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\heure.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/popen.cxx
===================================================================
--- /CMT/v1r20/Visual/popen.cxx	(revision 368)
+++ /CMT/v1r20/Visual/popen.cxx	(revision 368)
@@ -0,0 +1,30 @@
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <direct.h>
+ 
+int main () 
+{ 
+    if (!_chdir ("C:/dev/TCm/v1/Win32Debug") == 0) return (1);
+
+	FILE* f = _popen ("dumpbin /symbols tcmlib.lib", "r"); 
+	if (f == NULL) 
+	{ 
+		printf ("rate\n"); 
+	} 
+	else 
+	{ 
+		char line[256]; 
+		char* ptr; 
+ 
+		printf ("ok\n"); 
+ 
+		while ((ptr = fgets (line, sizeof (line), f)) != NULL) 
+		{ 
+			printf ("> %s\n", line); 
+		} 
+		printf ("ok\n"); 
+		_pclose (f); 
+	}
+
+	return (0);
+} 
Index: /CMT/v1r20/Visual/popen.dsp
===================================================================
--- /CMT/v1r20/Visual/popen.dsp	(revision 368)
+++ /CMT/v1r20/Visual/popen.dsp	(revision 368)
@@ -0,0 +1,100 @@
+# Microsoft Developer Studio Project File - Name="popen" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=popen - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "popen.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "popen.mak" CFG="popen - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "popen - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "popen - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "popen - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "popen - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "popen___Win32_Debug"
+# PROP BASE Intermediate_Dir "popen___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../VisualC"
+# PROP Intermediate_Dir "../VisualC"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "popen - Win32 Release"
+# Name "popen - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\popen.cxx
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/resource.h
===================================================================
--- /CMT/v1r20/Visual/resource.h	(revision 368)
+++ /CMT/v1r20/Visual/resource.h	(revision 368)
@@ -0,0 +1,72 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by cmtw.rc
+//
+#define IDD_DIALOGBAR                   101
+#define IDD_NEWPACKAGE                  102
+#define IDD_LISTEDIT                    103
+#define IDD_TEXTEDIT                    104
+#define IDD_CONSTITUENT                 105
+#define IDD_USES                        106
+#define IDD_CONSTITUENTS                107
+#define IDD_MACROS                      108
+#define IDD_CMT                         109
+#define IDB_BITMAP1                     113
+#define IDM_NEWPACKAGE                  201
+#define IDM_EXIT                        202
+#define IDM_CONFIG                      203
+#define IDM_GENMAKE                     204
+#define IDM_GENMSDEV                    205
+#define IDM_BUILDSETUP                  206
+#define IDM_BUILDCONSTITUENTSMAKEFILE   207
+#define IDM_BUILDCONSTITUENTMAKEFILE    208
+#define IDM_CMT                         209
+#define IDC_FRAMEUSES                   306
+#define IDM_PATHLIST                    1001
+#define IDM_PACKAGELIST                 1002
+#define IDM_VERSIONLIST                 1003
+#define IDM_REQUIREMENTS                1004
+#define IDM_USES                        1005
+#define IDM_CONSTITUENTS                1006
+#define IDM_MACROS                      1007
+#define IDM_OUTPUT                      1008
+#define IDM_EDITREQUIREMENTS            1009
+#define IDM_EDITPATHS                   1010
+#define IDM_PACKAGE                     1011
+#define IDM_SAVEREQUIREMENTS            1012
+#define IDM_TAG                         1013
+#define IDM_SETUSES                     1014
+#define IDM_SETCONSTITUENTS             1015
+#define IDM_SETMACROS                   1016
+#define IDM_SETSETS                     1017
+#define IDM_SETS                        1018
+#define IDM_FIRSTTAG                    1100
+#define IDM_SETOUTPUT                   1103
+#define IDNP_PATHLIST                   2001
+#define IDNP_PACKAGE                    2002
+#define IDNP_VERSION                    2003
+#define IDNP_PREFIX                     2006
+#define IDLE_LIST                       3001
+#define IDLE_ADD                        3002
+#define IDLE_REMOVE                     3003
+#define IDLE_DEBUG                      3004
+#define IDTE_TEXT                       4001
+#define IDCE_TYPE                       5001
+#define IDCE_NAME                       5002
+#define IDCE_MODULES                    5003
+#define IDCE_EDITMODULES                5004
+#define IDCMT_COMMAND                   6001
+#define IDCMT_OUTPUT                    6002
+#define IDCMT_EXECUTE                   6003
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NO_MFC                     1
+#define _APS_NEXT_RESOURCE_VALUE        114
+#define _APS_NEXT_COMMAND_VALUE         135
+#define _APS_NEXT_CONTROL_VALUE         1107
+#define _APS_NEXT_SYMED_VALUE           148
+#endif
+#endif
Index: /CMT/v1r20/Visual/tcout.cxx
===================================================================
--- /CMT/v1r20/Visual/tcout.cxx	(revision 368)
+++ /CMT/v1r20/Visual/tcout.cxx	(revision 368)
@@ -0,0 +1,56 @@
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <iostream> 
+#include <fstream> 
+ 
+using namespace std; 
+ 
+char buf[256]; 
+int index = 0; 
+ 
+class mysb : public streambuf 
+{ 
+	int overflow (int c) 
+	{ 
+		buf[index] = c; 
+		buf[index + 1] = 0; 
+		index++; 
+		if ((index > 200) || (c == '\n')) 
+		{ 
+			printf ("> %s\n", buf); 
+			index = 0; 
+		} 
+		return (1); 
+	} 
+	int underflow () 
+	{ 
+		return (EOF); 
+	} 
+}; 
+ 
+int main () 
+{ 
+	mysb s; 
+	streambuf* old; 
+ 
+	ifstream f ("../mgr/requirements"); 
+	if (f) 
+	{ 
+		cout << "opened" << endl; 
+		f.close (); 
+	} 
+ 
+	cout << "aaa" << endl; 
+ 
+	old = cout.rdbuf (&s); 
+	//cout = &s; 
+ 
+	cout << "bbb" << endl; 
+ 
+	old = cout.rdbuf (old); 
+	//cout = old; 
+ 
+	cout << "ccc" << endl; 
+ 
+	return (0); 
+} 
Index: /CMT/v1r20/Visual/tcout.dsp
===================================================================
--- /CMT/v1r20/Visual/tcout.dsp	(revision 368)
+++ /CMT/v1r20/Visual/tcout.dsp	(revision 368)
@@ -0,0 +1,89 @@
+# Microsoft Developer Studio Project File - Name="tcout" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=tcout - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "tcout.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "tcout.mak" CFG="tcout - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "tcout - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "tcout - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "tcout - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "../win32"
+# PROP BASE Intermediate_Dir "../win32"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../win32"
+# PROP Intermediate_Dir "../win32d"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "tcout - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "../win32debug"
+# PROP BASE Intermediate_Dir "../win32debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../VisualC"
+# PROP Intermediate_Dir "../VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "tcout - Win32 Release"
+# Name "tcout - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\tcout.cxx
+# End Source File
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/tdir.cxx
===================================================================
--- /CMT/v1r20/Visual/tdir.cxx	(revision 368)
+++ /CMT/v1r20/Visual/tdir.cxx	(revision 368)
@@ -0,0 +1,16 @@
+#include <stdio.h> 
+#include <direct.h> 
+ 
+int main (int argc, char* argv[]) 
+{ 
+	argc--; 
+	argv++; 
+	while (argc > 0) 
+	{ 
+		int status = _chdir (argv[0]); 
+		printf ("status = %d\n", status); 
+		argc--; 
+		argv++; 
+	} 
+	return (0); 
+} 
Index: /CMT/v1r20/Visual/tdir.dsp
===================================================================
--- /CMT/v1r20/Visual/tdir.dsp	(revision 368)
+++ /CMT/v1r20/Visual/tdir.dsp	(revision 368)
@@ -0,0 +1,89 @@
+# Microsoft Developer Studio Project File - Name="tdir" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=tdir - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "tdir.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "tdir.mak" CFG="tdir - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "tdir - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "tdir - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "tdir - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "../win32"
+# PROP BASE Intermediate_Dir "../win32"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../win32"
+# PROP Intermediate_Dir "../win32"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "tdir - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "../win32debug"
+# PROP BASE Intermediate_Dir "../win32debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../VisualC"
+# PROP Intermediate_Dir "../VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\src\\" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "tdir - Win32 Release"
+# Name "tdir - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\tdir.cxx
+# End Source File
+# End Target
+# End Project
Index: /CMT/v1r20/Visual/tistream.cxx
===================================================================
--- /CMT/v1r20/Visual/tistream.cxx	(revision 368)
+++ /CMT/v1r20/Visual/tistream.cxx	(revision 368)
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <iostream.h>
+
+int main ()
+{
+  char buffer[2048];
+
+  FILE* f;
+  f = fopen ("/lal/CMT/v1r3/temp/fragments/dsw_project", "rb");
+  if (f != NULL)
+  {
+    fseek (f, 0L, SEEK_END);
+    int size = ftell (f);
+    fseek (f, 0L, SEEK_SET);
+
+    cout << "size = " << size << endl;
+
+    fread (buffer, size, 1, f);
+
+    int i;
+
+    for (i = 0; i < size; i++)
+    {
+      if ((i % 16) == 0)
+      {
+        cout << endl;
+        cout << i << "> ";
+      }
+      cout << (int) buffer[i] << ' ';
+    }
+
+    fclose (f);
+  }
+}
+
Index: /CMT/v1r20/Visual/tstring.cxx
===================================================================
--- /CMT/v1r20/Visual/tstring.cxx	(revision 368)
+++ /CMT/v1r20/Visual/tstring.cxx	(revision 368)
@@ -0,0 +1,18 @@
+ 
+#include "iostream.h" 
+ 
+#include "cmt_std.h" 
+#include "cmt_string.h" 
+ 
+int main () 
+{ 
+	cmt_string a = "1234567890"; 
+ 
+	cmt_string b = a.substr (5); 
+ 
+	a.erase (0, 5); 
+ 
+	cout << "a=[" << a << "] b=[" << b << "]" << endl; 
+ 
+	return 0; 
+} 
Index: /CMT/v1r20/Visual/tstring.dsp
===================================================================
--- /CMT/v1r20/Visual/tstring.dsp	(revision 368)
+++ /CMT/v1r20/Visual/tstring.dsp	(revision 368)
@@ -0,0 +1,89 @@
+# Microsoft Developer Studio Project File - Name="tstring" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=tstring - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "tstring.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "tstring.mak" CFG="tstring - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "tstring - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "tstring - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "tstring - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "../win32"
+# PROP BASE Intermediate_Dir "../win32"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../win32"
+# PROP Intermediate_Dir "../win32"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "NDEBUG"
+# ADD RSC /l 0x40c /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "tstring - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "../win32debug"
+# PROP BASE Intermediate_Dir "../win32debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../VisualC"
+# PROP Intermediate_Dir "../VisualC"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\src\\" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\VisualC\cmtlib.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "tstring - Win32 Release"
+# Name "tstring - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\tstring.cxx
+# End Source File
+# End Target
+# End Project
Index: /CMT/v1r20/contrib/cvsmove/cvsmove.cxx
===================================================================
--- /CMT/v1r20/contrib/cvsmove/cvsmove.cxx	(revision 368)
+++ /CMT/v1r20/contrib/cvsmove/cvsmove.cxx	(revision 368)
@@ -0,0 +1,167 @@
+
+#include "cmt_std.h"
+#include "cmt_system.h"
+
+//----------------------------------------------------------
+class FileScanner
+{
+public:
+  class actor
+  {
+  public:
+    virtual void run ()
+    {
+    }
+  };
+
+  FileScanner (const cmt_string& new_root);
+  bool scan (actor& a);
+
+private:
+  void scan (int level, actor& a);
+
+  cmt_string m_root;
+  cmt_string m_full_root;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+FileScanner::FileScanner (const cmt_string& new_root) : 
+  m_root(new_root),
+  m_full_root(new_root)
+//----------------------------------------------------------
+{
+  if (m_root[0] == ':')
+    {
+      //
+      // The new CVS root points to a remote repository.
+      //
+      int pos = m_root.find_last_of (":");
+      if (pos != cmt_string::npos)
+	{
+	  m_root.erase (0, pos);
+	}
+      else
+	{
+	  // A syntax error ???
+	  cout << "The new CVS root is wrongly specified :[" << m_full_root << "]" << endl;
+	}
+    }
+}
+
+//----------------------------------------------------------
+bool FileScanner::scan (actor& a)
+//----------------------------------------------------------
+{
+  scan (0, a);
+
+  return (true);
+}
+
+//----------------------------------------------------------
+void FileScanner::scan (int level, actor& a)
+//----------------------------------------------------------
+{
+  CmtSystem::cmt_string_vector list;
+
+  CmtSystem::scan_dir ("*", list);
+
+  if (list.size () == 0) return;
+
+  // Will be set if at least one sub-directory is a CVS directory
+  bool has_cvs = false;
+
+  if (CmtSystem::test_directory ("CVS")) has_cvs = true;
+
+  if (!has_cvs) return;
+
+  cmt_string cvs_root;
+  cmt_string cvs_repository;
+
+  cvs_root.read ("CVS/Root");
+  cvs_repository.read ("CVS/Repository");
+
+  int pos;
+
+  if (cvs_root[0] == ':')
+    {
+      //
+      // The current CVS root points to a remote repository.
+      //
+      pos = cvs_root.find_last_of (":");
+      if (pos != cmt_string::npos)
+	{
+	  cvs_root.erase (0, pos);
+	}
+      else
+	{
+	  // A syntax error ???
+	  cout << "The CVS/Root file is corrupted" << endl;
+	  return;
+	}
+    }
+
+  pos = cvs_repository.find (cvs_root);
+  if (pos == 0)
+    {
+      cvs_repository.replace (cvs_root, m_root);
+    }
+  else
+    {
+      // This case should never happen !!!
+      cout << "The CVS/Repository file does not match CVS/Root" << endl;
+      return;
+    }
+  
+  if (m_full_root.write ("CVS/Root"))
+    {
+      cout << "CVS root changed from " << cvs_root << " to " << m_full_root << endl;
+    }
+  else
+    {
+      cout << "cannot change CVS root in " << CmtSystem::pwd () << endl;
+    }
+
+  if (cvs_repository.write ("CVS/Repository"))
+    {
+      cout << "CVS repository changed from " << cvs_root << " to " << m_root << endl;
+    }
+  else
+    {
+      cout << "cannot change CVS repository in " << CmtSystem::pwd () << endl;
+    }
+
+  int i;
+  for (i = 0; i < list.size (); i++)
+    {
+      cmt_string& name = list[i];
+
+      if (name[0] == CmtSystem::file_separator ()) name.erase (0, 1);
+
+      if (CmtSystem::test_directory (name))
+	{
+	  CmtSystem::cd (name);
+	  scan (level + 1, a);
+	  CmtSystem::cd ("..");
+	}
+    }
+}
+
+int main (int argc, char* argv[])
+{
+  if (argc < 2)
+    {
+      printf ("cvsmove <new-repository>\n");
+      return (1);
+    }
+
+  cmt_string new_repository = argv[1];
+
+  FileScanner scanner (new_repository);
+  FileScanner::actor actor;
+	
+  CmtSystem::cd ("..");
+  scanner.scan (actor);
+
+  return (0);
+}
Index: /CMT/v1r20/contrib/cvsmove/requirements
===================================================================
--- /CMT/v1r20/contrib/cvsmove/requirements	(revision 368)
+++ /CMT/v1r20/contrib/cvsmove/requirements	(revision 368)
@@ -0,0 +1,8 @@
+
+
+macro_append cppflags ' $(ppcmd)"$(CMTROOT)/src"'
+
+macro cvsmovelinkopts "advapi32.lib"
+
+application cvsmove cvsmove.cxx -s=$(CMTROOT)/src cmt_string.cxx cmt_system.cxx
+
Index: /CMT/v1r20/contrib/scenario1.bat
===================================================================
--- /CMT/v1r20/contrib/scenario1.bat	(revision 368)
+++ /CMT/v1r20/contrib/scenario1.bat	(revision 368)
@@ -0,0 +1,115 @@
+
+@echo off
+
+rem
+rem Test de -no_auto_import
+rem
+
+rem
+rem  4 packages A, B, C, D
+rem
+
+set scroot=%CMTROOT%\demo\scenario1
+
+set CMTPATH=%scroot%
+
+rmdir /Q /S %scroot%
+mkdir %scroot%
+cmt create A v1 %scroot%
+cmt create B v1 %scroot%
+cmt create C v1 %scroot%
+cmt create D v1 %scroot%
+
+cd %scroot%
+
+echo #ifndef __$(package)_h__       > template.h
+echo #define __$(package)_h__      >> template.h
+echo class $(package)              >> template.h
+echo {                             >> template.h
+echo   public:                     >> template.h
+echo     $(package) ();            >> template.h
+echo     void f ();                >> template.h
+echo };                            >> template.h
+echo #endif                        >> template.h
+
+echo #include "$(package).h"        > template.cxx
+echo #include "stdio.h"            >> template.cxx
+echo $(package)::$(package) ()     >> template.cxx
+echo {                             >> template.cxx
+echo }                             >> template.cxx
+echo void $(package)::f ()         >> template.cxx
+echo {                             >> template.cxx
+echo   printf ("$(package)::f\n"); >> template.cxx
+echo }                             >> template.cxx
+
+echo package $(package) >requirements
+echo macro $(package)_linkopts "%scroot%\$(package)\v1\%CMTCONFIG%\$(package).lib" >>requirements
+echo library $(package) $(package).cxx >>requirements
+echo path_append PATH "%scroot%\$(package)\v1\%CMTCONFIG%" >>requirements
+
+cd %scroot%\B\v1\cmt
+cmt filter %scroot%\template.h ..\src\B.h
+cmt filter %scroot%\template.cxx ..\src\B.cxx
+cmt filter %scroot%\requirements requirements
+nmake /f nmake
+
+cd %scroot%\C\v1\cmt
+cmt filter %scroot%\template.h ..\src\C.h
+cmt filter %scroot%\template.cxx ..\src\C.cxx
+cmt filter %scroot%\requirements requirements
+nmake /f nmake
+
+cd %scroot%\D\v1\cmt
+cmt filter %scroot%\template.h ..\src\D.h
+cmt filter %scroot%\template.cxx ..\src\D.cxx
+cmt filter %scroot%\requirements requirements
+nmake /f nmake
+
+cd %scroot%\A\v1\cmt
+
+echo package A                   > requirements
+echo use B v1                   >> requirements
+echo use C v1 -no_auto_imports  >> requirements
+echo use D v1 -no_auto_imports  >> requirements
+echo application b -check b.cxx >> requirements
+echo application c -check -import=C c.cxx >> requirements
+echo application d -check -import=C -import=D d.cxx >> requirements
+
+echo #include "B.h"              > ..\src\b.cxx
+echo int main ()                >> ..\src\b.cxx
+echo {                          >> ..\src\b.cxx
+echo   B b;                     >> ..\src\b.cxx
+echo   b.f ();                  >> ..\src\b.cxx
+echo   return (0);              >> ..\src\b.cxx
+echo }                          >> ..\src\b.cxx
+
+echo #include "B.h"              > ..\src\c.cxx
+echo #include "C.h"             >> ..\src\c.cxx
+echo int main ()                >> ..\src\c.cxx
+echo {                          >> ..\src\c.cxx
+echo   B b;                     >> ..\src\c.cxx
+echo   b.f ();                  >> ..\src\c.cxx
+echo   C c;                     >> ..\src\c.cxx
+echo   c.f ();                  >> ..\src\c.cxx
+echo   return (0);              >> ..\src\c.cxx
+echo }                          >> ..\src\c.cxx
+
+echo #include "B.h"              > ..\src\d.cxx
+echo #include "C.h"             >> ..\src\d.cxx
+echo #include "D.h"             >> ..\src\d.cxx
+echo int main ()                >> ..\src\d.cxx
+echo {                          >> ..\src\d.cxx
+echo   B b;                     >> ..\src\d.cxx
+echo   b.f ();                  >> ..\src\d.cxx
+echo   C c;                     >> ..\src\d.cxx
+echo   c.f ();                  >> ..\src\d.cxx
+echo   D d;                     >> ..\src\d.cxx
+echo   d.f ();                  >> ..\src\d.cxx
+echo   return (0);              >> ..\src\d.cxx
+echo }                          >> ..\src\d.cxx
+
+call setup
+nmake /f nmake 
+nmake /f nmake check
+
+cd %CMTROOT%\contrib
Index: /CMT/v1r20/contrib/scenario1.sh
===================================================================
--- /CMT/v1r20/contrib/scenario1.sh	(revision 368)
+++ /CMT/v1r20/contrib/scenario1.sh	(revision 368)
@@ -0,0 +1,115 @@
+
+#test
+
+#
+# Test de -no_auto_import
+#
+
+#
+#  4 packages A, B, C, D
+#
+
+scroot=${CMTROOT}/demo/scenario1
+
+CMTPATH=${scroot}
+
+rm -Rf ${scroot}
+mkdir -p ${scroot}
+cmt create A v1 ${scroot}
+cmt create B v1 ${scroot}
+cmt create C v1 ${scroot}
+cmt create D v1 ${scroot}
+
+cd ${scroot}
+
+echo '#ifndef __$(package)_h__     '  > template.h
+echo '#define __$(package)_h__     ' >> template.h
+echo 'class $(package)             ' >> template.h
+echo '{                            ' >> template.h
+echo '  public:                    ' >> template.h
+echo '    $(package) ();           ' >> template.h
+echo '    void f ();               ' >> template.h
+echo '};                           ' >> template.h
+echo '#endif                       ' >> template.h
+
+echo '#include "$(package).h"      '  > template.cxx
+echo '#include "stdio.h"           ' >> template.cxx
+echo '$(package)::$(package) ()    ' >> template.cxx
+echo '{                            ' >> template.cxx
+echo '}                            ' >> template.cxx
+echo 'void $(package)::f ()        ' >> template.cxx
+echo '{                            ' >> template.cxx
+echo '  printf ("$(package)::f\\n");' >> template.cxx
+echo '}                            ' >> template.cxx
+
+echo 'package $(package)' >requirements
+echo 'macro $(package)_linkopts "-L$(PACKAGE_ROOT)/${CMTCONFIG} -l$(package)" WIN32 "$(PACKAGE_ROOT)/${CMTCONFIG}/$(package).lib"' >>requirements
+echo 'library $(package) $(package).cxx' >>requirements
+echo 'path_append PATH "${scroot}/$(package)/v1/${CMTCONFIG}"' >>requirements
+
+cd ${scroot}/B/v1/cmt
+cmt filter ${scroot}/template.h ../src/B.h
+cmt filter ${scroot}/template.cxx ../src/B.cxx
+cmt filter ${scroot}/requirements requirements
+gmake
+
+cd ${scroot}/C/v1/cmt
+cmt filter ${scroot}/template.h ../src/C.h
+cmt filter ${scroot}/template.cxx ../src/C.cxx
+cmt filter ${scroot}/requirements requirements
+gmake
+
+cd ${scroot}/D/v1/cmt
+cmt filter ${scroot}/template.h ../src/D.h
+cmt filter ${scroot}/template.cxx ../src/D.cxx
+cmt filter ${scroot}/requirements requirements
+gmake
+
+cd ${scroot}/A/v1/cmt
+
+echo 'package A                 '  > requirements
+echo 'use B v1                  ' >> requirements
+echo 'use C v1 -no_auto_imports ' >> requirements
+echo 'use D v1 -no_auto_imports ' >> requirements
+echo 'application b -check b.cxx' >> requirements
+echo 'application c -check -import=C c.cxx' >> requirements
+echo 'application d -check -import=C -import=D d.cxx' >> requirements
+
+echo '#include "B.h"           '   > ../src/b.cxx
+echo 'int main ()              '  >> ../src/b.cxx
+echo '{                        '  >> ../src/b.cxx
+echo '  B b;                   '  >> ../src/b.cxx
+echo '  b.f ();                '  >> ../src/b.cxx
+echo '  return (0);            '  >> ../src/b.cxx
+echo '}                        '  >> ../src/b.cxx
+
+echo '#include "B.h"           '   > ../src/c.cxx
+echo '#include "C.h"           '  >> ../src/c.cxx
+echo 'int main ()              '  >> ../src/c.cxx
+echo '{                        '  >> ../src/c.cxx
+echo '  B b;                   '  >> ../src/c.cxx
+echo '  b.f ();                '  >> ../src/c.cxx
+echo '  C c;                   '  >> ../src/c.cxx
+echo '  c.f ();                '  >> ../src/c.cxx
+echo '  return (0);            '  >> ../src/c.cxx
+echo '}                        '  >> ../src/c.cxx
+
+echo '#include "B.h"           '   > ../src/d.cxx
+echo '#include "C.h"           '  >> ../src/d.cxx
+echo '#include "D.h"           '  >> ../src/d.cxx
+echo 'int main ()              '  >> ../src/d.cxx
+echo '{                        '  >> ../src/d.cxx
+echo '  B b;                   '  >> ../src/d.cxx
+echo '  b.f ();                '  >> ../src/d.cxx
+echo '  C c;                   '  >> ../src/d.cxx
+echo '  c.f ();                '  >> ../src/d.cxx
+echo '  D d;                   '  >> ../src/d.cxx
+echo '  d.f ();                '  >> ../src/d.cxx
+echo '  return (0);            '  >> ../src/d.cxx
+echo '}                        '  >> ../src/d.cxx
+
+. setup.sh
+
+gmake check
+
+cd ${CMTROOT}/contrib
Index: /CMT/v1r20/contrib/scenario2.bat
===================================================================
--- /CMT/v1r20/contrib/scenario2.bat	(revision 368)
+++ /CMT/v1r20/contrib/scenario2.bat	(revision 368)
@@ -0,0 +1,45 @@
+
+@echo off
+
+rem
+rem Testing environment variables and path variables
+rem
+
+rem
+rem  o 3 packages A, B, C
+rem  o Package C defines a macro M and some env. variables.
+rem  o Package C defines an env. var. T which contains references
+rem    to other macros or env. vars.
+rem
+
+set scroot=%CMTROOT%\demo\scenario2
+
+set CMTPATH=%scroot%
+
+rmdir /Q /S %scroot%
+mkdir %scroot%
+cmt create A v1 %scroot%
+cmt create B v1 %scroot%
+cmt create C v1 %scroot%
+
+cd %scroot%\C\v1\cmt
+
+echo package C                          > requirements
+echo macro_append M "Z"                >> requirements
+echo macro M "mmm" aaa "mam" bbb "mbm" >> requirements
+echo set   S "sss" aaa "sas" bbb "sbs" >> requirements
+echo set   T "${M}ttt${S}$(tag)" WIN32 "${M}ttt%%S%%$(tag)" >> requirements
+
+cd %scroot%\B\v1\cmt
+
+cd %scroot%\A\v1\cmt
+
+echo package A                   > requirements
+echo use B v1                   >> requirements
+echo use C v1                   >> requirements
+
+cmt show sets
+cmt show sets -tag=aaa
+cmt show set T
+
+cd %CMTROOT%\contrib
Index: /CMT/v1r20/contrib/scenario2.sh
===================================================================
--- /CMT/v1r20/contrib/scenario2.sh	(revision 368)
+++ /CMT/v1r20/contrib/scenario2.sh	(revision 368)
@@ -0,0 +1,43 @@
+
+#
+# Testing environment variables and path variables
+#
+
+#
+#  o 3 packages A, B, C
+#  o Package C defines a macro M and some env. variables.
+#  o Package C defines an env. var. T which contains references
+#    to other macros or env. vars.
+#
+
+scroot=${CMTROOT}/demo/scenario2
+
+CMTPATH=${scroot}
+
+rm -Rf ${scroot}
+mkdir -p ${scroot}
+cmt create A v1 ${scroot}
+cmt create B v1 ${scroot}
+cmt create C v1 ${scroot}
+
+cd ${scroot}/C/v1/cmt
+
+echo 'package C                        '  > requirements
+echo 'macro_append M "Z"               ' >> requirements
+echo 'macro M "mmm" aaa "mam" bbb "mbm"' >> requirements
+echo 'set   S "sss" aaa "sas" bbb "sbs"' >> requirements
+echo 'set   T "${M}ttt${S}$(tag)" WIN32 "${M}ttt%%S%%$(tag)"' >> requirements
+
+cd ${scroot}/B/v1/cmt
+
+cd ${scroot}/A/v1/cmt
+
+echo 'package A '                  > requirements
+echo 'use B v1  '                 >> requirements
+echo 'use C v1  '                 >> requirements
+
+cmt show sets
+cmt show sets -tag=aaa
+cmt show set T
+
+cd ${CMTROOT}/contrib
Index: /CMT/v1r20/contrib/scenario4.py
===================================================================
--- /CMT/v1r20/contrib/scenario4.py	(revision 368)
+++ /CMT/v1r20/contrib/scenario4.py	(revision 368)
@@ -0,0 +1,148 @@
+
+import sys
+import os
+
+#------------------------------------------------------------
+def CVSROOT () :
+    return ('/dev/CMT/v1r7/demo/scenario4/cvsroot')
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def scroot () :
+    s = os.environ ['CMTROOT'] + '/demo/scenario4'
+    return (s)
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def remove_dir (d):
+    if not os.path.exists (d) : return
+    
+    for f in os.listdir(d) :
+        name = d + '/' + f
+        if os.path.isdir (name) : remove_dir (name)
+        else :
+            os.chmod (name, 0777)
+            os.remove (name)
+
+    os.rmdir (d)
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def setuses (package, uses) :
+    prefix = os.path.dirname (package)
+    name = os.path.basename (package)
+
+    # print ('pre=[' + prefix + '] name=[' + name + ']')
+
+    if prefix is '' : os.chdir (scroot ())
+    else : os.chdir (scroot () + '/' + prefix)
+
+    os.chdir (name)
+    os.chdir ('v1/cmt')
+
+    f = open ('requirements', 'a+b')
+
+    for u in uses :
+        p = os.path.dirname (u)
+        n = os.path.basename (u)
+        #print ('use ' + n + ' v1 ' + p)
+        f.write ('use ' + n + ' v1 ' + p + '\n')
+        
+    f.close ()
+    
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def cvsimport (package, prefix = '') :
+    if prefix is '' : os.chdir (scroot ())
+    else : os.chdir (scroot () + '/' + prefix)
+    
+    if not os.path.exists ('CVS') : os.mkdir ('CVS')
+    if not os.path.exists ('CVS/Entries') : 
+        f = open ('CVS/Entries', 'wb')
+        f.write ('\n')
+        f.close ()
+    if not os.path.exists ('CVS/Repository') : 
+        f = open ('CVS/Repository', 'wb')
+        f.write (prefix + '\n')
+        f.close ()
+    if not os.path.exists ('CVS/Root') : 
+        f = open ('CVS/Root', 'wb')
+        f.write (CVSROOT () + '\n')
+        f.close ()
+
+    os.system ('cvs -d ' + CVSROOT () + ' add ' + package)
+    os.system ('cvs -d ' + CVSROOT () + ' ci -m "" ')
+
+    os.chdir (package)
+    os.chdir ('v1')
+
+    if not os.path.exists ('CVS') : os.mkdir ('CVS')
+    if not os.path.exists ('CVS/Entries') : 
+        f = open ('CVS/Entries', 'wb')
+        f.write ('\n')
+        f.close ()
+    if not os.path.exists ('CVS/Repository') : 
+        f = open ('CVS/Repository', 'wb')
+        if prefix is '' : f.write (package + '\n')
+        else : f.write (prefix + '/' + package + '\n')
+        f.close ()
+    if not os.path.exists ('CVS/Root') : 
+        f = open ('CVS/Root', 'wb')
+        f.write (CVSROOT () + '\n')
+        f.close ()
+
+    os.system ('cvs -d ' + CVSROOT () + ' add src')
+    os.system ('cvs -d ' + CVSROOT () + ' add cmt')
+    os.system ('cvs -d ' + CVSROOT () + ' ci -m "" ')
+    
+    os.chdir ('cmt')
+    os.system ('cvs -d ' + CVSROOT () + ' add requirements')
+    os.system ('cvs -d ' + CVSROOT () + ' ci -m "" ')
+    os.system ('cvs -d ' + CVSROOT () + ' tag v1 ')
+    os.system ('cvs -d ' + CVSROOT () + ' tag v1r1 ')
+    os.system ('cvs -d ' + CVSROOT () + ' tag v1r2 ')
+    os.system ('cvs -d ' + CVSROOT () + ' tag v2 ')
+    os.system ('cvs -d ' + CVSROOT () + ' tag v2r1 ')
+
+#------------------------------------------------------------
+
+remove_dir (scroot ())
+
+os.mkdir (scroot ())
+os.chdir (scroot ())
+
+os.system ('cmt create A v1')
+os.system ('cmt create B v1 A')
+os.system ('cmt create C v1 A/B')
+os.system ('cmt create D v1 A/B')
+os.system ('cmt create E v1 A')
+os.system ('cmt create F v1 A')
+os.system ('cmt create G v1 ')
+os.system ('cmt create H v1 ')
+os.system ('cmt create I v1 H')
+os.system ('cmt create J v1 H/I')
+os.system ('cmt create K v1 H/I/J')
+
+setuses ('A/B/D', ['A/B/C']);
+setuses ('A/E',   ['A/B/C']);
+setuses ('A/F',   ['A/B/D']);
+setuses ('G',     ['A/B', 'A/B/D', 'A/E']);
+setuses ('H/I',   ['A/E']);
+setuses ('H/I/J', ['A/B/C', 'A/B/D']);
+
+# sys.exit ()
+
+os.system ('cvs -d ' + CVSROOT () + ' init')
+
+cvsimport ('A')
+cvsimport ('B', 'A')
+cvsimport ('C', 'A/B')
+cvsimport ('D', 'A/B')
+cvsimport ('E', 'A')
+cvsimport ('F', 'A')
+cvsimport ('G')
+cvsimport ('H')
+cvsimport ('I', 'H')
+cvsimport ('J', 'H/I')
+
Index: /CMT/v1r20/doc/CMT.htm
===================================================================
--- /CMT/v1r20/doc/CMT.htm	(revision 368)
+++ /CMT/v1r20/doc/CMT.htm	(revision 368)
@@ -0,0 +1,27 @@
+<!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+-->
+
+<html>
+  <head>
+    <title>CMT</title>
+  </head>
+
+  <frameset cols="15%, *" border="4">
+
+    <frame name="Table" 
+           src="table.html"
+           marginheight=0 border="2" noresize scrolling="auto">
+
+    <frame name="Contents"
+           src="intro.html" marginwidth="0"
+           marginheight=0 border="2" noresize scrolling="auto">
+
+  </frameset>
+
+</html>
+
Index: /CMT/v1r20/doc/CMTDoc.html
===================================================================
--- /CMT/v1r20/doc/CMTDoc.html	(revision 368)
+++ /CMT/v1r20/doc/CMTDoc.html	(revision 368)
@@ -0,0 +1,11055 @@
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en"> 
+<html>
+<title>CMT</title>
+<head>
+ <style type="text/css">
+   body {font-face: Arial, Helvetica, Comic Sans MS, Times; color: #000000}
+   tt {color:#00AA00; font-weight: normal; background-color: #eeeeee}
+   pre {color:#FF0000; background-color: #eeeeee; border-style: solid; border-width: 1; border-color: black; padding: 4}
+   pre.cmt {font-family: courier; color:#00AA00; background-color: #eeeeee; border-style: solid; border-width: 1; border-color: black; padding: 4}
+   h2 {color:#0000FF}
+   h3 {color:#00AA00}
+   h4 {color:#997700}
+   a {color:#0000FF; background-color: LightGoldenRodYellow; text-decoration: none}
+   b {font-family: courier; color:#006600; font-weight: normal; %background-color: #eeffee}
+   td.rule {padding-top: 10}
+ </style>
+</head>
+<body bgcolor="#ffffff" link="#550088" alink="#007777" alink="#007777">
+<h1><center>CMT</center>
+<center>Configuration Management Tool</center></h1>
+<h2><center>Version v1r19</center>
+<center>Christian Arnault</center>
+<center><tt>arnault@lal.in2p3.fr</tt></center></h2>
+<center><i>Document revision date : 2006-11-09</i></center><hr><h2><a href="#index">General index</a></h2>
+<hr><h2><a name="Presentation"></a><a href="#index"><tt>&nbsp;1</tt></a> - Presentation</h2>
+<blockquote>
+  <p>This environment, based on some management conventions and
+      comprising several utilities, is an attempt to
+      formalize software production and especially configuration
+      management around a <i>package</i>
+-oriented principle.</p>
+  <p>The notion of <i>packages</i>
+   represents hereafter a set of
+      software components (that may be applications, libraries,
+      documents, tools etc...)  that are to be used for producing a
+  <i>system</i>
+   or a <i>framework</i>
+  .  In such an environment,
+      several persons are assumed to participate in the development and
+      the components themselves are either independent or related to
+    each other.</p>
+  <p>The environment provides conventions (for <i>naming</i>
+      packages, files, directories and for <i>addressing</i>
+   them) and
+      tools for <i>automating</i>
+   as much as possible the implementation
+      of these conventions. It permits the <i>description</i>
+   of the
+      configuration requirements and automatically deduce from the
+      description the effective set of configuration parameters needed
+      to operate the packages (typically for <i>building</i>
+   them or
+  <i>using</i>
+ them).</p>
+  <p><tt>CMT</tt>
+   lays upon some organisational or managerial
+      principles or mechanisms described below. However, it permits in
+      many respects the users or the managers to <i>control</i>
+  ,
+      specialize and customize these mechanisms, through
+      parameterization, strategy control and generic specifications.
+    <ul>
+    <li> Many such packages are produced and maintained.  </li>
+      <li> Packages sets may be structured in <i>areas</i>
+              implementing a <i>project</i>
+     oriented organization.  </li>
+      <li> The projects represent independent organisations of
+                packages, but may be interconnected as a <i>direct acyclic
+              graph</i>
+     of projects</li>
+      <li> The packages may or not be related with each other
+      	(defining also a <i>direct acyclic graph</i>
+       of packages - not just
+    	a single tree).  </li>
+      <li> The concept of package may be extended to implement
+      	structuring or organizing patterns such as those involved in
+    	project management. </li>
+      <li> Project management policies and behavioural patterns can
+    	be easily expressed and automated by CMT. </li>
+      <li> Each <i>executable application</i>
+       (from now on simply
+      	named <i>applications</i>
+      ) either belongs to a particular
+      	package and/or defines its own environment and then makes use
+    	of some other packages.  </li>
+      <li> Each package can be uniquely identified within the system
+              or the framework by a <i>name</i>
+       which is usually a short
+      <i>mnemonic</i>
+       and which may be also used for isolating its
+              name-space (eg. by <i>prefixing</i>
+       components of the package
+            by its mnemonic).  </li>
+      <li> A package installed in this environment may be
+      <i>exported</i>
+       to a site where the architecture is
+      	reproduced, and as long as the local organisation defined for
+      	the package is preserved through the transport, the
+      	reconstruction procedure will be preserved. Configuration
+      	specifications can be easily provided to cope with machine,
+    	site or system specific features.  </li>
+      <li> Packages are maintained consistently to their declared
+      	relationships to each other through a <i>version</i>
+      	identification model based on :
+        <ul>
+          <li> a version is defined with a mnemonic comprising one
+          	    to three numbers the <i>major</i>
+           id, the <i>minor</i>
+           id,
+          	    and the <i>patch</i>
+         id </li>
+          <li> versions with different major ids are said to be
+                    incompatible, </li>
+          <li> versions with same major ids but different minor ids
+                      are said to be backward compatible with respect of the
+                    minor id ordering.  </li>
+          <li> versions differing only by their patch id are said to
+                    be fully compatible with each other. </li>
+      </ul>
+    </li>
+      <li>Projects are also referenced using a <i>release</i>
+    </li>
+      <li> Version control and management schemes (eg. by using
+      <tt>CVS</tt>
+      ) are usually consistently operated, applying the
+            conventions on organization and version identification.  </li>
+      <li> An application that uses one or several packages managed
+              in this environment should not itself be constrained to be
+              managed by <tt>CMT</tt>
+      . The tools should only require a few
+              exported features (such as a few environment variables) for
+            referencing any given package.  </li>
+      <li> Similarly, a package maintained in this environment must
+              be able to use packages that are <i>not</i>
+       managed in this
+              environment (which are often called <i>external</i>
+       packages).
+    </li>
+  </ul>
+</p>
+  <p>Following these definitions, the basic configuration management
+      operations involved here (and serviced by the <tt>CMT</tt>
+   tools)
+      consist of :
+    <ul>
+      <li> installing the packages in conventional locations so that
+              they can be referenced by each other, following projects or
+            teams structuring paradigms, </li>
+      <li> describing the configuration &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; for each
+              package:
+        <ul>
+        <li> dependencies to other packages, </li>
+          <li> generic behavioural patterns meant to describe
+                      generic configuration items or project specific policies.
+        </li>
+          <li> symbols to be exported to client packages
+                    (environment variables, make macros, etc...)  </li>
+          <li> parameterized configuration activities (documentation
+                    generation, deploiement, installation, etc...)</li>
+          <li> components (also named <i>constituents</i>
+          ) of the
+                    packages (libraries, applications, generated documents) </li>
+        <li> parameterization of the build and test tools </li>
+        <li> parameterization of the deployment tools </li>
+          <li> strategies that <tt>CMT</tt>
+           should follow at run time,
+                    overriding its default ones.  </li>
+      </ul>
+    </li>
+      <li> deducing the effective configuration parameters from the
+      &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; so as to
+              automatize the building phases and the run-time operations and
+              connections between packages (typically for generating
+              makefiles, generating compiler and linker options, shared
+              libraries paths etc...). This construction mechanism follows
+              customizable strategies (eg. for selecting among possible
+            alternate versions of available packages).  </li>
+  </ul>
+</p>
+</blockquote>
+<hr><h2><a name="The conventions"></a><a href="#index"><tt>&nbsp;2</tt></a> - The conventions</h2>
+<blockquote>
+  <p>This environment relies on a set of conventions, mainly for
+      organizing the directories where projects and packages are
+    maintained and developed : </p>
+  <ul>
+    <li> Each package is installed in a standard directory structure
+          defined at least as follows:
+<pre>&lt;some root&gt;/&lt;Package mnemonic&gt;/&lt;version mnemonic&gt;/cmt</pre>
+      <p>or (<i>obsolescent convention</i>
+      )
+<pre>&lt;some root&gt;/&lt;Package mnemonic&gt;/&lt;version mnemonic&gt;/mgr</pre>
+    </p>
+      <p>The &lt;version mnemonic&gt; directory level may also be
+      	omitted, in which case the version information will be stored
+      	inside the cmt directory in a conventional file named
+      <tt>version.cmt</tt>
+       leading to the following alternate
+    	organization:</p>
+<pre>&lt;some root&gt;/&lt;Package mnemonic&gt;/cmt/version.cmt </pre>
+      <p>In both cases, the <tt>cmt</tt>
+       directory holds the main source of information
+              needed by <tt>CMT</tt>
+      : the <i>requirements</i>
+       file. All
+      <tt>CMT</tt>
+      -related operations are generally executed from this
+            directory.</p>
+      <p>This style of organization should be considered as the
+              basic (and unique) criterion for a package to be recognized as
+              a valid <i>CMT package</i>
+      . Any other structuring convention will
+              be supported by CMT and its operations can always be
+            customized to follow them</p>
+      <p>This structure is a central concept since all relationships
+              between packages relies on the package identification which
+              unambiguously and exclusively consists in the duet [
+      <i>package-name</i>
+      , <i>package-version</i>
+       ] (or
+      <i>package-name</i>
+       only when the version directory level is
+            omitted).</p>
+  </li>
+    <li> Constructing the internal structure of a package.
+      <p>Many other parallel directory branches (similar to <tt>cmt</tt>
+      ) such
+              as <tt>src</tt>
+      , <tt>include</tt>
+       or <tt>test</tt>
+       may be freely
+              added to this list according to the specific needs of each
+              package.  In particular, a set of such parallel branches are
+              expected to contain <i>binary</i>
+       outputs (those that
+              compilers, linkers, archive managers or other kinds of code or
+              pseudo-code generators can produce). Their name always
+              corresponds to the particular <i>configuration tag</i>
+       used to
+              produce the output (such as the machine or operating system
+              type). The <tt>CMT</tt>
+         toolkit provides, through the <tt>cmt
+              system</tt>
+       utility, a default value for this token. An
+              environment variable (<tt>CMTCONFIG</tt>
+      ) is also assigned to
+              this value (See the <a href="#Selecting a specific configuration">complete description</a>
+            of configuration tags).</p>
+      <p>Each branch may in addition be freely structured, and there
+            is no constraint to the complexity of this organization.</p>
+<center>
+<a name="Structuring a package - A typical example."></a>
+<img src="Images/InternalPackageStructure.jpg"/>
+</center>
+<center>
+<tt>1</tt> - <i>Structuring a package - A typical example.</i>
+</center>
+  </li>
+  <p></p>
+    <li> Organizing a software base.
+      <p>A software base is generally composed of multiple coherent
+              sets of packages, each installed in its specific root
+              directory and forming different <i>package areas</i>
+       or
+      <i>sub-projects</i>
+    </p>
+      <p>Package areas implement the concept of <i>projects</i>
+       or
+      <i>sub-projects</i>
+       which correspond to the practical
+            organization of the software base.</p>
+      <p>There are no constraints on the number of such sub-projects
+              or areas into which <tt>CMT</tt>
+       packages are installed. We'll
+              see <a HREF="#Localizing a package">later</a>
+       how the
+              different sub-projects can be declared and identified by
+      <tt>CMT</tt>
+    .</p>
+    <p>examples of such organization can be : </p>
+<center>
+<a name="Structuring a sofware base."></a>
+<img src="Images/PackageStructure.jpg"/>
+</center>
+<center>
+<tt>2</tt> - <i>Structuring a sofware base.</i>
+</center>
+  </li>
+</ul>
+</blockquote>
+<hr><h2><a name="The architecture of the environment"></a><a href="#index"><tt>&nbsp;3</tt></a> - The architecture of the environment</h2>
+<blockquote>
+  <p>This environment is based on the fact that one of its packages
+      (named <tt>CMT</tt>
+  ) provides the basic management
+      tools. <tt>CMT</tt>
+  , as a package, has very little specificities
+    and as such itself obeys the general conventions.</p>
+  <p>Then the complete software base is organized in terms of
+      projects (or <i>sub-projects</i>
+  ), containing consistently managed
+      package sets. Projects are localized either globally or
+      individually:
+    <ul>
+      <li>globally using the environment variable
+      <tt>CMTPROJECTPATH</tt>
+       that describes all locations where CMT
+            projects can be found</li>
+      <li>individually using the environment variable
+      <tt>CMTPATH</tt>
+       that describe all package areas where
+            packages can be found</li>
+  </ul>
+      Packages are localized respectively to the projects they belong
+    to.</p>
+  <p>It should be noted that the choice of a location for installing
+      CMT itself is totally independent of the locations where projects
+    are installed and managed.</p>
+  <p><tt>CMT</tt>
+   is operated through one main user interface : the
+  <tt>cmt</tt>
+   command, which operates the <tt>CMT</tt>
+   conventions
+    and which provides a set of services for : </p>
+  <ul>
+    <li> creating a new package. This operation will create or check
+          the local package directory tree and generate several minimal
+          scripts (see the description of the <a HREF="#create">create</a>
+        command), </li>
+    <li> describing or monitoring :
+      <ul>
+        <li> the relationships between the package and other
+                packages </li>
+        <li> the configuration features either specified in the
+                  current package, or imported from related (<i>used</i>
+        )
+                ones. (symbols, patterns, fragments) </li>
+        <li> the constituents of the package in terms of libraries,
+                executables, or generated documents.  </li>
+    </ul>
+  </li>
+    <li> automatically generating the reconstruction scripts
+          (<tt>makefiles</tt>
+  ) from this description.  </li>
+    <li> recursively acting upon the hierarchy of used packages.
+  </li>
+</ul>
+  <p>Several other utilities are also provided for some specific
+      activities (such as the automatic production of shared libraries,
+  <tt>C</tt>
+   prototypes, management of interactions between <tt>CVS</tt>
+      and <tt>CMT</tt>
+   itself, the management of a similar architecture
+      for <tt>Windows</tt>
+   or <tt>OS9</tt>
+  , setting up protections for
+    packages (through locks) etc...). </p>
+<hr><h3><a name="Supported platforms"></a><a href="#index"><tt>&nbsp;3.&nbsp;1</tt></a> - Supported platforms</h3>
+<blockquote>
+<tt>CMT</tt>
+ has been ported and tested on a wide range of
+      machines/operating systems, including :
+  <ul>
+  <li> DEC-Unix V4.0 </li>
+  <li> HP-UX-10 (several types of platforms) </li>
+  <li> AIX-4 </li>
+  <li> Solaris </li>
+  <li> IRIX </li>
+  <li> Several variants of LynxOS </li>
+  <li> All variants of Linux (RedHat, Debian, SuSe, ScientificLinux, ...) </li>
+    <li> Windows 95/98/NT/Windows2000 in various environments:
+      <ul>
+        <li><tt>CYGWIN_NT-5.1</tt>
+       environment </li>
+        <li><tt>nmake</tt>
+       based environment </li>
+        <li><tt>MSDev/VisualC 6</tt>
+       environment</li>
+        <li><tt>MSDev/VisualC 7</tt>
+       environment</li>
+    </ul>
+  </li>
+  <li> Darwin (Mac OS X) </li>
+</ul>
+      This in particular means that a package developped on one
+      platform may be re-configured towards any of these platforms
+      without any change to its configuration description. All
+      platform specific tools will be dynamically reconfigured and
+      parameterized transparently.
+</blockquote>
+</blockquote>
+<hr><h2><a name="Defining and managing projects"></a><a href="#index"><tt>&nbsp;4</tt></a> - Defining and managing projects</h2>
+<blockquote>
+  <p>In the CMT terminology, the complete software base is composed
+      of CMT packages. Those packages are organized into
+      sub-projects. The semantics of a sub-project is very opened since
+      it's merely an area for grouping CMT packages. Typically
+    sub-projects may correspond to</p>
+  <ul>
+    <li>a structuration in software domains, such as Reconstruction,
+        Simulation, Graphics, Core, etc.</li>
+    <li>how responsibilities or management policies are defined and
+        assigned </li>
+    <li>reusing or sharing different software products from
+        different projects</li>
+</ul>
+  <p>Considering the simple structuring aspects of sub-projects, two
+      important configuration parameters (environment variables) handled
+      by CMT must be understood before attempting to manage
+    packages:</p>
+  <ul>
+      <li><a href="#CMTPROJECTPATH"><tt>CMTPROJECTPATH</tt>
+    </a>
+     for a
+          global specification of where projects can be found. This
+          specification should be considered as the standard mechanism for
+          structuring the software base since from it, CMT can and will
+          deduce all other localization parameters (like
+    <tt>CMTPATH</tt>
+    ).<p></p>
+  </li>
+      <li><a href="#CMTPATH"><tt>CMTPATH</tt>
+    </a>
+     offers a more
+          internal mechanism for localizing packages. It's not generally
+          meant to be defined manually since CMT will construct it from
+    <tt>CMTPROJECTPATH</tt>
+    . However, it's important to understand
+          how this configuration parameter is used to locate
+        packages.</li>
+</ul>
+  <p>Projects receive detailed descriptions or specifications in a
+      dedicated <i>project file</i>
+  , always located in a <tt>cmt</tt>
+      directory at their top directory level, and named
+  <tt>cmt/project.cmt</tt>
+  . It can receive the following
+    specifications:</p>
+<pre>
+project &lt;project-name&gt;          [1]
+<i>project-use specifications...</i>   [2]
+<i>strategy specifications...</i>      [3]</pre>
+  <ol>
+    <li>The project name specified here takes precedence over the
+          project name specified in the directory structure. However when
+    <tt>CMTPROJECTPATH</tt>
+     is not specified, this may cause
+          conflicts in the localization of projects. In this case it's
+          highly recommended to always use the same naming convention in
+          project files as in the directory hierarchy.<p></p>
+  </li>
+    <li>Projects are hierarchized as a directed acyclic graph. The
+          minimal hierarchy simply corresponds to the order of the
+    <tt>CMTPATH</tt>
+     items. A more complex hierarchy can be
+          specified through use statements between sub-projects. This
+          hierarchy also defines a <i>parent/child</i>
+     relationship between
+          projects. If a project <tt>A</tt>
+     uses another project
+    <tt>B</tt>
+    , <tt>A</tt>
+     is also named the <i>parent</i>
+     and
+    <tt>B</tt>
+     the <i>child</i>
+    <p></p>
+  </li>
+    <li>CMT Strategies (for build or setup) are separately
+           collected into each project. Therefore one can apply different
+           strategies to different sub-projects. The strategy
+           specifications may appear in requirements file of any package
+           of a project or in the <tt>cmt/project.cmt</tt>
+     project file.
+      <p>By default a project inherits the strategies of its
+             parents. Or if it's the top project, it follows the default
+             strategies defined by CMT (Refer to this 
+      <a href="#The default strategies defined in CMT">appendix</a>
+           to see the default strategies currently defined by CMT).</p>
+    <p></p>
+  </li>
+</ol>
+<hr><h3><a name="The project file"></a><a href="#index"><tt>&nbsp;4.&nbsp;1</tt></a> - The project file</h3>
+<blockquote>
+<p>The project file can be created using the command:</p>
+<pre>
+&gt; cmt create_project &lt;project-name&gt; [&lt;release&gt;] [&lt;path&gt;]
+&gt; cmt create_project &lt;project-name&gt; [&lt;release&gt;] [&lt;path&gt;] [-use=&lt;package&gt;:&lt;version&gt;:&lt;path&gt;]...</pre>
+  <p>This will create the complete directory hierarchy from the
+        current directory (or, when it is specified from the optional
+        project path). It will also create a project file containing the
+        project name, and optionnally will initialize it with some use
+      statements.</p>
+    <blockquote><i>Note that the &lt;release&gt; argument may be
+          left empty (or to an empty string). In this case, the directory
+          hierarchy will be limited to the single level of the project
+        name.</i>
+</blockquote>
+<pre>
+&lt;path&gt;/&lt;project-name&gt;/&lt;release&gt;/cmt/project.cmt
+&lt;path&gt;/&lt;project-name&gt;/cmt/project.cmt</pre>
+<p>As an example, we create the following projects:</p>
+<pre>
+&gt; cmt create_project WorkArea "" /test
+&gt; cmt create_project ProjectA 1.0 /test
+&gt; cmt create_project ProjectB 1.0 /test</pre>
+  <p>And we manually fill <tt>CMTPATH</tt>
+ with:</p>
+<pre>
+/test/WorkArea:/test/ProjectA/1.0:/test/ProjectB/1.0</pre>
+  <p>Then, when standing in the <tt>WorkArea</tt>
+   the following
+      projects will appear displayed from bottom to top as</p>
+<pre>
+&gt; cd /test/WorkArea
+&gt; cmt show projects 
+<i><font COLOR="#000077" face="courier new, courier">WorkArea (in /test/WorkArea) (current)
+  ProjectA 1.0 (in /test/ProjectA/1.0)
+    ProjectB 1.0 (in /test/ProjectB/1.0)</font></i></pre>
+  <p>Of course the preferred way to characterize this software
+        base should rather be based on specifying the relationships
+        between those three sub-projects, through the use statements in
+      the projects files.</p>
+  <p>For instance in our little example, we could add the
+      following statement into the project file of WorkArea:</p>
+<pre>
+use ProjectA 1.0</pre>
+<p>and the following statement into the project file of ProjectB:</p>
+<pre>
+use ProjectB 1.0</pre>
+  <p>Then instead of specifying <tt>CMTPATH</tt>
+   we'd rather
+        simply define <tt>CMTPROJECTPATH</tt>
+ as:</p>
+<pre>
+/test</pre>
+<p>This complete sequence may also be shortened as follows:</p>
+<pre>
+&gt; cmt create_project ProjectB 1.0 /test
+&gt; cmt create_project ProjectA 1.0 /test -use=ProjectB:1.0
+&gt; cmt create_project WorkArea "" /test -use=ProjectA:1.0</pre>
+</blockquote>
+<hr><h3><a name="Projects and strategies"></a><a href="#index"><tt>&nbsp;4.&nbsp;2</tt></a> - Projects and strategies</h3>
+<blockquote>
+  <p>Few behaviours of the configuration management process can be
+        tailored with respect to CMT, via means of defining
+  <i>strategies</i>
+  . Then according to these strategies, CMT will
+      behave in well defined ways.</p>
+  <p>Every strategy setting is a boolean value, instructing CMT to
+        activate or not a given behaviour. As such it defines two
+        mutually exclusive CMT <i>tags</i>
+   and it activates one of
+      them.</p>
+<pre class="cmt">
+&lt;project&gt;_&lt;have_item&gt; 
+&lt;project&gt;_&lt;have_not_item&gt; </pre>
+<p>Examples</p>
+<pre class="cmt">
+&lt;project&gt;_with_install_area
+&lt;project&gt;_without_install_area
+&lt;project&gt;_config
+&lt;project&gt;_no_config
+&lt;project&gt;_root
+&lt;project&gt;_no_root
+&lt;project&gt;_cleanup
+&lt;project&gt;_no_cleanup
+&lt;project&gt;_with_version_directory
+&lt;project&gt;_without_version_directory
+&lt;project&gt;_prototypes
+&lt;project&gt;_no_prototypes</pre>
+  <p>In the context of a hierarchy - <i>a graph</i>
+   - of projects,
+        strategies are transmitted along the graph, according to the use
+        relationships specified between the projects. A project
+        transmits its strategies to its clients except when one of them
+      overrides those strategies.</p>
+  <p>Several mechanisms help defining project specific properties,
+      and more specifically making use of the strategies:</p>
+  <ul>
+    <li>The <tt>&lt;project&gt;</tt>
+     parameter is expanded in the
+    <tt>cmtpath_pattern</tt>
+     construct in addition to the
+    <tt>&lt;path&gt;</tt>
+     parameter. This parameter is assigned
+            the name of the project associated with the running
+    <tt>CMTPATH</tt>
+     entry.  <p></p>
+  </li>
+    <li>The <tt>&lt;project&gt;</tt>
+     parameter is also available
+            for normal patterns. In this case it is assigned the project
+            name associated with the cmtpath parameter for the current
+            package.<p></p>
+  </li>
+    <li>Every project defines a tag of the same name, and the tag
+            of the current project is active.<p></p>
+  </li>
+    <li>The <tt>cmt_installarea_prefix</tt>
+     macro is specialized
+    <i>per project</i>
+     and every project may override the
+    <tt>&lt;project&gt;_installarea_prefix</tt>
+     macro. The default
+            value of any <tt>&lt;project&gt;_installarea_prefix</tt>
+     is
+    <tt>${cmt_installarea_prefix}</tt>
+     (which itself is a global
+            macro that receives a default value from CMT )<p></p>
+  </li>
+</ul>
+</blockquote>
+<hr><h3><a name="CMTPROJECTPATH"></a><a href="#index"><tt>&nbsp;4.&nbsp;3</tt></a> - CMTPROJECTPATH</h3>
+<blockquote>
+  <p>This is an environment variable containing a search list,
+        very similar to the well know Unix or Windows <tt>PATH</tt>
+        environment variable. It specifies a list of file paths where
+        CMT projects can be found. The syntax of this search list
+        follows the standard syntax of search lists, i.e. items are
+        separated using a <tt>:</tt>
+   character on Unix and a <tt>;</tt>
+      character on Windows.</p>
+      <p><blockquote><i>One should understand this search list as the
+            primary mechanism to locate sub-projects in the software base,
+            and therefore packages. This in particular can completely
+            replace the <tt>CMTPATH</tt>
+      -based search mechanism for packages
+            that was used before <tt>v1r18</tt>
+      . However the two mechanisms
+            are still both supported and in fact interact with each
+          other.</i>
+  </blockquote>
+</p>
+  <p>A sub-project in itself is a multi-level directory structure,
+        located below one of the items of this search list, and composed
+      of:</p>
+  <ul>
+  <li>the sub-project name</li>
+  <li>the sub-project release (which may span several directory levels)</li>
+</ul>
+<p>Then, below this directory structure, we find</p>
+  <ul>
+    <li>A project definition file in <tt>cmt/project.cmt</tt>
+  </li>
+  <li>A set of CMT packages</li>
+</ul>
+<p>A typical example of such a structure could be:</p>
+<pre>
+/project-area1/Reconstruction/1.0/cmt/project.cmt
+                                 /RecA/...
+                                 /RecB/...
+/project-area1/Reconstruction/2.0/cmt/project.cmt
+                                 /RecA/...
+                                 /RecB/...
+
+/project-area1/Simulation/1.0/cmt/project.cmt
+                             /SimA/...
+                             /SimB/...
+/project-area1/Core/1.0/cmt/project.cmt
+                       /CoreA/...
+                       /CoreB/...
+
+
+/project-area2/ProductA/1.1.2/cmt/project.cmt
+                             /PA_A/...
+                             /PA_B/...
+                             /PA_C/...
+/project-area2/ProductB/v1r8p3/cmt/project.cmt
+                              /PB_A/...
+                              /PB_B/...
+/project-area2/ProductB/v1r10/cmt/project.cmt
+                             /PB_A/...
+                             /PB_B/...   </pre>
+<p>In this example:</p>
+  <ul>
+    <li>there are two project areas, one for the main developments
+            (<tt>/project-area1</tt>
+    ), and another one for managing
+            external products (<tt>/project-area1</tt>
+  )</li>
+    <li><tt>project-area1</tt>
+     offers three sub-projects
+    <tt>Reconstruction</tt>
+    , <tt>Simulation</tt>
+     and
+    <tt>Core</tt>
+  </li>
+    <li><tt>project-area2</tt>
+     offers two sub-projects
+    <tt>ProductA</tt>
+     and <tt>ProductB</tt>
+  </li>
+    <li>the sub-project <tt>Reconstruction</tt>
+     is available in two
+            releases <tt>1.0</tt>
+     and <tt>2.0</tt>
+  </li>
+    <li>the sub-project <tt>Reconstruction</tt>
+     offers two packages
+    <tt>RecA</tt>
+     and <tt>RecB</tt>
+  </li>
+    <li>the sub-project <tt>ProductB</tt>
+     is available in two
+            releases <tt>v1r8p3</tt>
+     and <tt>v1r10</tt>
+  </li>
+</ul>
+  <p>This search list is used to interpret the <i>use</i>
+        statements written in the project files. This project use
+      statement takes the form:</p>
+<center>
+<table cols="3">
+<tr>
+<td></td>
+<td width="10"></td>
+<td></td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwproject-use-project-use"></a>project-use</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+use
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+project-name
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+project-release
+</i></font>
+</td>
+</tr>
+</table>
+</center>
+  <p>Typically, in our example one could construct the project
+        file of the <tt>Reconstruction</tt>
+ sub-project as follows:</p>
+<pre>
+use Core 1.0
+use ProductA 1.1.2</pre>
+    <p><i>Note that sub-project release identifiers are always
+        considered using a perfect-match principle.</i>
+</p>
+  <p>Structuring the set of sub-projects comprising a software
+        base is sufficient to permit CMT to find <i>all</i>
+   sub-projects
+        and thus <i>all</i>
+   packages in them. Defining
+  <tt>CMTPROJECTPATH</tt>
+  <i>and</i>
+   installing the list of use
+        statements in all appropriate project files entirely suppress
+        the need of manually defining the <tt>CMTPATH</tt>
+   search
+      list.</p>
+</blockquote>
+<hr><h3><a name="CMTPATH"></a><a href="#index"><tt>&nbsp;4.&nbsp;4</tt></a> - CMTPATH</h3>
+<blockquote>
+  <p>This is an environment variable containing a search list,
+        very similar to the well know <tt>PATH</tt>
+   environment
+        variable, containing a list of file paths where CMT packages can
+        be found. The syntax of this search list follows the standard
+        syntax of search lists, i.e. items are separated using a
+  <tt>:</tt>
+   character on Unix and a <tt>;</tt>
+   character on
+      Windows.</p>
+      <p><blockquote><i>When the software base is organized and
+              configured using the <a href="#CMTPROJECTPATH"><tt>CMTPROJECTPATH</tt>
+      </a>
+       search list
+            and project-use statements in the project files, this search
+            list is automatically and internally generated by CMT, and
+            therefore it should not be manually defined nor manipulated. If
+            this is your case, you can skip this
+          section</i>
+  </blockquote>
+</p>
+  <p>It is possible to manually define this search list (when
+  <tt>CMTPROJECTPATH</tt>
+   is not defined or when project files are
+      not provided)</p>
+  <p>There should be one entry per package area, and the list is
+        ordered. The order of items is used to prioritize the package
+      search.</p>
+  <p><tt>CMTPATH</tt>
+ can be specified:</p>
+  <ul>
+    <li>as the environment variable named <tt>CMTPATH</tt>
+<pre>
+sh&gt; export CMTPATH=/home/arnault/mydev:/ProjectB </pre>
+<pre>
+bat&gt; set CMTPATH=/home/arnault/mydev;/ProjectB </pre>
+              or (in a <tt>requirements</tt>
+     file) 
+<pre class="cmt">
+path_append CMTPATH "/home/arnault/mydev"
+path_append CMTPATH "/ProjectB"</pre>
+  </li>
+    <li>in <tt>.cmtrc</tt>
+     files, which can be located either in
+            the current directory, in the <i>home</i>
+     directory of the
+            developper or in <tt>${CMTROOT}/mgr</tt>
+    . The syntax to use in this
+            configuration file is:
+<pre>
+CMTPATH=/home/arnault/mydev:/ProjectB </pre>
+  </li>
+    <li>In the Windows environment, this configuration parameter
+            may also be installed as a <i>Registry</i>
+     under the alternate
+            keys:
+      <ul>
+        <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/path</tt>
+      </li>
+        <li><tt>HKEY_CURRENT_USER/Software/CMT/path</tt>
+      </li>
+    </ul>
+  </li>
+</ul>
+    <blockquote><i>The project file (i.e. the file
+    <tt>cmt/project.cmt</tt>
+    ), when it exists for the current
+          package (i.e. upstream in the directory hierarchy), also
+          provides an automatic value for the <tt>CMTPATH</tt>
+     search
+        list.</i>
+</blockquote>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Installing a new package"></a><a href="#index"><tt>&nbsp;5</tt></a> - Installing a new package</h2>
+<blockquote>
+  <p>We consider here the installation of a user package. Installing
+  <tt>CMT</tt>
+   itself requires special attention and is described in a 
+      dedicated <a href="#Installing CMT for the first time">section</a>
+    of this document.</p>
+  <p>Therefore, we assume that <tt>CMT</tt>
+   is already installed in
+      some location in the system.  One first has to <i>setup</i>
+  <tt>CMT</tt>
+   in order to gain access to the various management
+    utilities, using for example the shell command: </p>
+<pre>
+csh&gt; source /lal/CMT/v1r19/mgr/setup.csh
+
+or 
+
+ksh&gt; . /lal/CMT/v1r19/mgr/setup.sh
+
+or 
+
+dos&gt; call \lal\CMT\v1r19\mgr\setup.bat</pre>
+  <p>Obviously, this operation <i>must</i>
+   be performed (once)
+      before any other <tt>CMT</tt>
+   action. Therefore it is often
+      recommended to install this setup action straight in the
+  <i>login</i>
+ script. </p>
+<blockquote><hr>
+  <i>
+    <p> The <i>setup script</i>
+     used in this example is a constant
+            in the <tt>CMT</tt>
+     environment : every configured package
+            will have one such setup script automatically generated and
+            installed by <tt>CMT</tt>
+    . It is one important entry point to
+            any package (and thus to <tt>CMT</tt>
+     itself). It provides
+            environment variable definitions for all related (<i>used</i>
+    )
+            packages (A corresponding cleanup script is also
+            provided). This script contains a uniform mechanism for
+    <i>interpreting</i>
+     the &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file so as to
+            dynamically define environment variables, aliases for the
+            package itself and all its used packages. It is constructed
+            once per package installation by the <tt>cmt create</tt>
+            command, or restored by the <tt>cmt config</tt>
+     command (if it
+          has been lost).</p>
+</i>
+<hr></blockquote>
+  <p>It is generally good to start by immediately defining a
+  <i>project</i>
+  . This project is our first disk area where CMT
+      packages will be located. Remember that several such projects can
+    be set up and defined. The simplest way to do this is:</p>
+<pre>
+&gt; cmt create_project Dev
+<i><font COLOR="#000077" face="courier new, courier">------------------------------------------
+Configuring environment for project Dev
+CMT version v1r19.
+------------------------------------------
+Installing the cmt directory
+Creating a new project file </font></i></pre>
+  <p>This creates a project structure
+  <tt>Dev/cmt/project.cmt</tt>
+   from the current directory. Once
+      this project has been created we have a complete environment to
+      start creating packages below <tt>Dev</tt>
+ and working out our software base.</p>
+  <p> A package is primarily defined by a <i>name</i>
+   and a
+  <i>version</i>
+   identifier (this duet actually forms the complete
+  <i>package identifier</i>
+  ). These two attributes will be given as
+      arguments to <tt>cmt create</tt>
+   such as in the following example :
+</p>
+<pre>
+csh&gt; cd Dev
+csh&gt; cmt create Foo v1
+<i><font COLOR="#000077" face="courier new, courier">------------------------------------------
+Configuring environment for package Foo version v1.
+CMT version v1r19.                              [1]
+Root set to /home/arnault/Dev.
+System is Linux-i686                                     [2]
+------------------------------------------
+Installing the package directory                         [3]
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts. </font></i></pre>
+  <ol>
+  <li>This shows which actual CMT version you are currently using</li>
+    <li>This shows the current configuration tag (also available by
+          the <tt>cmt system</tt>
+     command). In this example this is a
+    <tt>Linux</tt>
+   machine</li>
+    <li>This shows the detailed construction of the complete
+          directory structure, starting from the top directory which has
+          the name of the package. Since we are creating a completely new
+          package, there will be by default only two branches below the
+          version directory : <tt>cmt</tt>
+     and <tt>src</tt>
+  .</li>
+</ol>
+  <p>The package creation occured from the current directory,
+      creating from there the complete directory tree for this new
+    package.</p>
+  <p>In the next example, we install the package in a completely
+      different area, by explicitly specifying the path to it as a third
+      argument to <tt>cmt create</tt>
+ : </p>
+<pre>
+&gt; cmt create Foo v1 /ProjectB 
+<i><font COLOR="#007700" face="courier new, courier">------------------------------------------
+Configuring environment for package Foo version v1.
+CMT version v1r19.
+Root set to /ProjectB.
+System is Linux-i686
+------------------------------------------
+Installing the path directory
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts. </font></i></pre>
+<p></p>
+    Several file creations occurred at this level : 
+  <ul>
+    <li> a minimal directory tree for the package, including
+    <tt>src</tt>
+     and <tt>cmt</tt>
+     (the other branches will be installed
+        when needed or generated at build time).  </li>
+  <p></p>
+    <li> an empty configuration specification file (named
+    <tt>requirements</tt>
+    ) installed in the <tt>cmt</tt>
+   branch.  </li>
+  <p></p>
+    <li> A minimal <tt>Makefile</tt>
+     (on Unix environments only),
+          containing
+<pre>
+include $(CMTROOT)/src/Makefile.header 
+
+include $(CMTROOT)/src/constituents.make </pre>
+    <p></p>
+            This <tt>Makefile</tt>
+     does not need any further modification to
+            build any of the constituents managed by <tt>CMT</tt>
+    . The
+            intermediate makefile fragments will always be re-generated
+            transparently and automatically at build time. However (and
+            thanks to this feature), this file will not be modified
+    <i>anymore</i>
+     by <tt>CMT</tt>
+     itself. Thus you may insert any
+            particular make statement you would feel appropriate,
+            typically when you ask for operations that cannot be taken
+            - if any - into account by <tt>CMT</tt>
+    .
+  </li>
+  <p></p>
+    <li> A similar minimal <tt>NMake</tt>
+     file (on Windows
+          environments only), containing
+<pre>
+!include $(CMTROOT)\src\NMakefile.header 
+
+!include $(CMTROOT)\src\constituents.nmake </pre>
+  </li>
+  <p></p>
+    <li> the setup and cleanup scripts (one flavour for each shell
+        family).  </li>
+</ul>
+    One <i>may</i>
+ then setup this new package by running the setup
+    script (which will not have much effect yet since the requirements
+    file is empty) :
+<pre>
+sh&gt; cd ~/mydev/Foo/v1/cmt 
+sh&gt; . setup.sh </pre>
+or 
+<pre>
+csh&gt; cd ~/mydev/Foo/v1/cmt 
+csh&gt; source setup.csh </pre>
+or 
+<pre>
+dos&gt; cd \mydev\Foo\v1\cmt 
+dos&gt; call setup.bat</pre>
+  <p>The <tt>FOOROOT</tt>
+   and <tt>FOOCONFIG</tt>
+   environment variables
+    are defined automatically by this operation. </p>
+  <p>It should be noted that running the setup script of a package
+      is not always necessary for building operations. The only
+      situation where running this script <i>may</i>
+   become useful, is
+      when an application is to be run, while requiring domain specific
+      environment variables defined in one of the used packages. Besides
+      this particular situation, running the setup scripts may not be
+    needed at all. </p>
+  <p>Lastly, this newly created package may be removed by the quite
+      similar remove command, using exactly the same arguments as those
+    used for creating the package.</p>
+<pre>csh&gt; cd mydev
+csh&gt; cmt remove Foo v1 
+<i><font COLOR="#000077" face="courier new, courier">------------------------------------------
+Removing package Foo version v1.
+CMT version v1r19.
+Root set to /home/arnault/mydev.
+System is Linux-i686
+------------------------------------------
+Version v1 has been removed from /home/arnault/mydev/Foo
+Package Foo has no more versions. Thus it has been removed.</font></i></pre>
+    or:
+<pre>csh&gt; cmt remove Foo v1 /ProjectB
+<i><font COLOR="#000077" face="courier new, courier">------------------------------------------
+Removing package Foo version v1.
+CMT version v1r19.
+Root set to /ProjectB.
+System is Linux-i686
+------------------------------------------
+Version v1 has been removed from /ProjectB/Foo
+Package Foo has no more versions. Thus it has been removed.</font></i></pre>
+  <p>So far our package is not very useful since no constituent
+      (application or library) is installed yet. You can jump to the
+      section showing how to work on an <a href="#Working on an application">application</a>
+      or on a <a href="#Working on a library">library</a>
+      for details on these operations or we can
+      roughly draw the sequence used to specify and build the simplest
+    application we can think of as follows:</p>
+<pre>
+csh&gt; cd ~/mydev/Foo/v1/cmt
+csh&gt; cat &gt;../src/FooTest.c 
+#include &lt;stdio.h&gt;
+
+int main ()
+{
+  printf ("Hello Foo\n");
+  return (0);
+}
+
+csh&gt; vi requirements 
+... 
+application FooTest FooTest.c 
+csh&gt; gmake
+csh&gt; source setup.csh
+csh&gt; FooTest.exe
+<i><font COLOR="#007700" face="courier new, courier">Hello Foo</font></i></pre>
+  <p>Directly running the application is possible since the
+      application has been installed after being built in
+      an automatic <i>installation area</i>
+   reachable through the
+      standard <tt>PATH</tt>
+ environment variable</p>
+  <p>This can also be integrated in the build process by providing
+    the -check option to the application definition:</p>
+<pre>
+csh&gt; cd ../cmt 
+csh&gt; vi requirements 
+... 
+application FooTest -check FooTest.c 
+csh&gt; gmake check
+<i><font COLOR="#000077" face="courier new, courier">Hello Foo</font></i></pre>
+</blockquote>
+<hr><h2><a name="Localizing a package"></a><a href="#index"><tt>&nbsp;6</tt></a> - Localizing a package</h2>
+<blockquote>
+  <p>In the next sections, we'll see that packages <i>reference</i>
+      each other by means of <i>use</i>
+   relationships. Generally
+      packages are found in different locations, according to the
+      project - or sub-project - they belong to.  <tt>CMT</tt>
+   provides a
+      quite flexible mechanism for <i>localizing</i>
+   the referenced
+    packages. </p>
+  <p>The first ingredient we need at this level is to understand how
+      projects themselves are localized, since packages will be found
+      inside project areas. You should therefore refer to the 
+  <a href="#Defining and managing projects">section on projects</a>
+        where the complete mechanism based on <a href="#CMTPROJECTPATH"><tt>CMTPROJECTPATH</tt>
+  </a>
+     or <a href="#CMTPATH"><tt>CMTPATH</tt>
+  </a>
+ is described.</p>
+  <p>However, there is one special case where this path list can be
+      avoided, i.e. when only one project is considered. In this case,
+      the knowledge of this single project area can simply be deduced
+      from the detection of the project file, created at the top of its
+    disk space.</p>
+  <p>A given version of a given package is always referred to by
+      using a <i>use</i>
+   statement within its <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+      file. This statement should specify the package through three
+  <i>keys</i>
+ :</p>
+  <ul>
+    <li> its name (such as <tt>Bar</tt>
+  ) </li>
+    <li> its version (such as <tt>v7r5</tt>
+  ) </li>
+    <li> optionally its expected absolute location or relative
+          offset
+  </li>
+</ul>
+<pre class="cmt">
+use Bar v7r5                    [1]</pre>
+<i>or</i>
+<pre class="cmt">
+use Bar v7r5 A                  [2]</pre>
+<i>or</i>
+<pre class="cmt">
+use Bar v7r5 /ProjectB/A        [3]</pre>
+  <p>Given these keys, the referenced package is looked for
+      according to a prioritized search list which is (in decreasing
+    priority order) : </p>
+  <ol>
+    <li> the absolute access path, if the <i>use path</i>
+     is
+        absolute (case #3), </li>
+    <li> the access paths registered in the configuration parameter
+      <a href="#CMTPATH"><tt>CMTPATH</tt>
+    </a>
+     (and in decreasing
+        priority, the first element being searched for first).</li>
+</ol>
+  <p>If the <i>path</i>
+   argument is specified as a relative path
+      (case #2 above) (ie. there is no leading <i>slash</i>
+   character or
+      it's not a <i>disk</i>
+   on windows machines), it will be used as an
+  <i>offset</i>
+   to each search case. The search is done starting
+      from the list specified in the <tt>CMTPATH</tt>
+   configuration
+      parameter; and the offset is appended at each searched
+    location.</p>
+  <p>As an example, if the <tt>CMTPATH</tt>
+ parameter contains: </p>
+<pre>
+/home/arnault/mydev:/ProjectB </pre>
+  <p>Then a <i>use</i>
+   statement (defined within a given package)
+    containing : </p>
+<pre class="cmt">
+... 
+use Bar v7r5
+use BarA v1 A</pre>
+    would look for the package <tt>Bar</tt>
+ from :
+  <ol>
+    <li><tt>/home/arnault/mydev/Bar/v7r5/cmt</tt>
+  </li>
+    <li><tt>/ProjectB/Bar/v7r5/cmt</tt>
+  </li>
+</ol>
+    Whereas the package <tt>BarA</tt>
+ would be searched from : 
+  <ol>
+    <li><tt>/home/arnault/mydev/A/BarA/v1/cmt</tt>
+  </li>
+    <li><tt>/ProjectB/A/BarA/v1/cmt</tt>
+  </li>
+</ol>
+    The packages are searched assuming that the directory hierarchy
+    below the access paths always follow the convention :
+  <ol>
+    <li> there is a first directory level exactly named according to
+        the package name (this is case sensitive), </li>
+    <li> then (optionally) the next directory level is named
+        according to the version tag, </li>
+    <li> then there is a branch named <tt>cmt</tt>
+  , </li>
+    <li> lastly there is a <i>requirements</i>
+     file within this
+    <tt>cmt</tt>
+   branch.  </li>
+</ol>
+    Thus the list of access paths is searched for until these
+    conditions are properly met.
+  <p> The actual complete search list can always be visualized by
+      the command:
+<pre>
+&gt; cmt show path
+<i><font COLOR="#000077" face="courier new, courier"># Add path /home/arnault/dev from CMTPATH
+# Add path /ProjectB from CMTPATH
+#
+/home/arnault/dev:/ProjectB</font></i></pre>
+</p>
+</blockquote>
+<hr><h2><a name="Assigning semantics to packages. Common practices"></a><a href="#index"><tt>&nbsp;7</tt></a> - Assigning semantics to packages. Common practices</h2>
+<blockquote>
+    Generally speaking, CMT makes no assumption on how or why is used
+    a package. However past experience has shown that packages can be
+    categorized according to their purpose or their type of contents.
+<hr><h3><a name="The primary package"></a><a href="#index"><tt>&nbsp;7.&nbsp;1</tt></a> - The primary package</h3>
+<blockquote>
+      This is the most general and basic pakage type, which provides
+      actual pieces of software, such as libraries or
+      applications. Generally the main activities performed by such a
+      package include building the software (compiling, linking),
+      testing, generating the documentation, installing, ...
+<p>A typical package of that kind will contain:</p>
+  <ul>
+    <li>a <tt>../src</tt>
+   directory containing the sources of the package</li>
+    <li>a directory for the include files, with a name that will
+    	depend on the structuring policies defined for the
+    	project. Tyical examples are
+<pre>
+../include/
+../&lt;packagename&gt;/</pre>
+  </li>
+    <li>a <tt>../doc</tt>
+   directory for the documentation</li>
+    <li>a <tt>../test</tt>
+   directory for the test programs.</li>
+</ul>
+  <p>The requirements file will generally contain at least
+  <tt>library</tt>
+   and <tt>application</tt>
+ statements.</p>
+</blockquote>
+<hr><h3><a name="The policy package"></a><a href="#index"><tt>&nbsp;7.&nbsp;2</tt></a> - The policy package</h3>
+<blockquote>
+      This kind of package only provides conventions, working methods,
+      general purpose shell scripts but generally provides no software
+      per se. It is designed to gather all policies and management
+      conventions for a project or a sub project.
+  <p>The basic contents of such a package is the requirements file
+      including</p>
+  <ul>
+  <li>strategy definitions</li>
+  <li>pattern definitions</li>
+  <li>general purpose symbol definitions</li>
+</ul>
+  <p>In principle the idea when such a policy package is defined,
+        is that all packages of the project or of the sub-project will
+      use it</p>
+  <p>Global patterns may be specified so as to automate the
+      applying of basic policies and conventions.</p>
+  <p>Typical examples of policies that are profitably specified in
+      such a package are:</p>
+  <ul>
+    <li>include search path convention (using a global pattern
+            with the <tt>include_dir</tt>
+   statement)</li>
+  <li>build or setup strategies</li>
+  <li>compiler or linker generic options</li>
+    <li>defining the project-wide production tools (compiler,
+          documentation generator, etc...)</li>
+    <li>tag associations need to describe the binary tag
+          convention in the project</li>
+</ul>
+  <p>In large projects, it is even often desirable to split the
+        policies into a set of specialized policies and to associate one
+      dedicated policy package with each of those.</p>
+  <ul>
+  <li>policies for the test</li>
+  <li>policies for each programming language</li>
+  <li>policies for documentation management</li>
+  <li>policies for installation and deployment</li>
+  <li>policies for external software organisation</li>
+</ul>
+      Then the global policy package will use them
+</blockquote>
+<hr><h3><a name="The container or management package"></a><a href="#index"><tt>&nbsp;7.&nbsp;3</tt></a> - The container or management package</h3>
+<blockquote>
+      In large projects, it's often useful to decompose the software
+      base into specialized domains (Core software, Graphics,
+      Database, Online, etc...) or subsets of the software (eg per
+      detector in a physics experiment). Then a container package
+      consists in constructing a simple package with only one
+      requirements file in it and only containing a set of use
+      statements.
+  <p>Management activities directly related with the associated
+        sub-domain can then be undertaken through this special
+      package:</p>
+  <ul>
+    <li>version management (such as CVS tagging) of packages
+          belonging to the domain</li>
+  <li>consistently building the domain</li>
+    <li>Generally the <tt>cmt broadcast</tt>
+     command is widely exploited
+  	to perform those management activities.</li>
+</ul>
+  <p> Generally the use statements installed in a container
+        package make use of explicit version specification (and prohibit
+        wild carding) since each version of this container package acts
+        as a reference of the set of version tags validated for the
+      packages of the domain.</p>
+</blockquote>
+<hr><h3><a name="The release package"></a><a href="#index"><tt>&nbsp;7.&nbsp;4</tt></a> - The release package</h3>
+<blockquote>
+      This package is one particular example of the container concept,
+      but dedicated to manage the project-wide activities. This
+      release package is the primary target of the project manager. It
+      will generally receive as its version tags the version tags
+      assigned to the project releases themselves.
+</blockquote>
+<hr><h3><a name="The glue or interface package"></a><a href="#index"><tt>&nbsp;7.&nbsp;5</tt></a> - The glue or interface package</h3>
+<blockquote>
+      This kind of package defines an interface to an existing
+      software product not managed in the context of the project
+      itself. Typical examples concern:
+  <ul>
+    <li>packages shared from external projects that don't use CMT
+          as their configuration tool</li>
+    <li>third party software (free software, commercial products,
+  	...)  locally installed on the development platform.</li>
+</ul>
+  <p>The primary goal fo such a glue package is to convert the
+        management conventions and policies expected by the referenced
+      product to the ones appropriate for the current project.</p>
+  <ul>
+  <li>compiler and linker options</li>
+    <li>run time settings such as environment variable definitions
+    	(<tt>PATH</tt>
+    , <tt>LD_LIBRARY_PATH</tt>
+  , etc..)</li>
+  <li>data file access</li>
+    <li>specification of local installation according to the
+  	project strategy</li>
+</ul>
+  <p>Generally this kind of package only provides a requirements
+        file, or make fragments used to automate some actions (typically
+        when document generation is expected from thie interfaced
+      product)</p>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Managing site dependent features - The CMTSITE environment variable"></a><a href="#index"><tt>&nbsp;8</tt></a> - Managing site dependent features - The CMTSITE environment variable</h2>
+<blockquote>
+  <p>Software bases managed by <tt>CMT</tt>
+   are often replicated to
+      multiple geographically distant sites (as opposed to machines
+      connected through AFS-like WAN). In this kind of situation, some
+      of the configuration parameters (generally those used for instance
+      to reference local installations of <i>external</i>
+   software) take
+    different values. </p>
+  <p>The <tt>CMTSITE</tt>
+   environment variable or <i>registry</i>
+   in
+      Windows environments, is entirely under the control of the
+  <i>site</i>
+   manager and can be set with a value representing
+      the site (typical values may be <tt>LAL</tt>
+  , <tt>Virgo</tt>
+  ,
+  <tt>Atlas</tt>
+  , <tt>LHCb</tt>
+  , <tt>CERN</tt>
+, etc.). </p>
+  <p>This variable, when set, corresponds to a <i>tag</i>
+   which can
+      be used to select different values for make macros or environment
+    variables. </p>
+  <p>A typical use for this tag is to build up actual values for the
+      location path of an external software package. Here we take the
+    example of the Anaphe utility: </p>
+<pre class="cmt">
+macro AnapheTOP "" \
+      CERN  "/afs/cern.ch/sw/lhcxx" \
+      BNL   "/afs/rhic/usatlas/offline/external/lhcxx" \
+      LBNL  "/auto/atlas/sw/lhcxx"</pre>
+</blockquote>
+<hr><h2><a name="Configuring a package"></a><a href="#index"><tt>&nbsp;9</tt></a> - Configuring a package</h2>
+<blockquote>
+  <p>The first ingredient of a proper package configuration is the
+      set of configuration parameters which has to be specified in a
+      text file uniquely named <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+   and necessarily
+      installed in the <tt>cmt</tt>
+ branch of the package directory tree. </p>
+  <p>An empty version of this file is automatically created the
+      first time the package is installed, and the package manager is
+    expected to augment it with configuration specifications. </p>
+  <p>The primary goal of this configuration file is to specify
+  <i>any</i>
+   configuration information for this package. There is
+      virtually no limit to what could be specified there. And we can
+      expect to find exhaustive information about:
+    <ul>
+    <li>the primary constituents of the package</li>
+    <li>how to rebuild the software</li>
+    <li>how to setup and use the software</li>
+    <li>how to transport and deploy the package</li>
+  </ul>
+</p>
+  <p>Many configuration parameters are supposed to be described into
+      this &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file - see the <a href="#The requirements file">detailed</a>
+    syntax specifications here - namely :</p>
+  <ul>
+  <li> the package information about its author(s) and manager(s) </li>
+  <li> the relationships with other packages </li>
+    <li> the package constituents (libraries, applications,
+        documents, etc.) </li>
+    <li> the policy patterns to be applied by clients of this
+        package </li>
+    <li> the parameterization of the tools used in the build process
+        (eg. make macros) </li>
+    <li> the parameterization of the run-time activity
+        (eg. environment variables, search paths, etc.) </li>
+</ul>
+  <p>Generally, every such appropriate parameter will be deduced on
+      demand from the &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file(s) through the various
+      query functions available from the <tt>cmt</tt>
+   main
+      driver. Therefore there is no systematic package re-configuration
+      per se, besides the very first time a package is newly installed
+      in its location (using the <tt>cmt create</tt>
+ action). </p>
+  <p>Query actions (generally provided using the <tt>cmt show ...</tt>
+  <a HREF="#show">family</a>
+   of commands) are to be embedded in the
+      various productivity tools, such as the setup shell scripts, or
+    makefile fragment generators. </p>
+  <p>These query actions always interpret the set of
+  &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; files obtained from the current package
+  <i>and</i>
+   from the packages in the effective <i>used</i>
+      chain. Symbols, tags and other definitions are then computed and
+      built up according to inheritance-like mechanisms set up between
+    used packages. </p>
+  <p>Conversely one may say that parameters defined in a
+  &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file are meant to be exported to the clients of
+    the package.</p>
+  <p>Other configuration parameters are also optionally inserted
+      from the <tt>HOME</tt>
+   and <tt>USER</tt>
+    <a href=""><i>context</i>
+  </a>
+    requirements files</p>
+<p>Typical examples of these query functions are: </p>
+  <ul>
+    <li><tt>cmt setup</tt>
+     builds a shell command line for setting up
+        environment variables </li>
+    <li><tt>cmt show projects</tt>
+     gives the ordered sequence of
+        sub-projects comprising the complete software base </li>
+    <li><tt>cmt show macros</tt>
+     construct the effective set of
+        inherited make macros </li>
+    <li><tt>cmt show uses</tt>
+     gives the ordered and flattened set of
+        used packages </li>
+    <li><tt>cmt show constituents</tt>
+     lists the package's
+        constituents </li>
+    <li><tt>cmt show path</tt>
+     lists the effective search path for
+        packages. </li>
+    <li><tt>cmt show strategies</tt>
+     shows the current setup of
+          various functional <tt>CMT</tt>
+   strategies. </li>
+    <li><tt>cmt show setup</tt>
+     combines in one display the result
+          of <tt>uses</tt>
+    , <tt>tags</tt>
+     and <tt>path</tt>
+  </li>
+</ul>
+</blockquote>
+<hr><h2><a name="Selecting a specific configuration"></a><a href="#index"><tt>10</tt></a> - Selecting a specific configuration</h2>
+<blockquote>
+    A configuration describes the conditions in which the package has
+    to be built (ie. compiled and linked) or applications can be
+    run. This configuration can depend on :
+  <ul>
+    <li> the operating system (such as <i>Linux</i>
+    , <i>Windows</i>
+    ,
+        ...)  </li>
+    <li> the platform (such as <i>Intel</i>
+    , <i>Compaq</i>
+    ,
+    <i>Sun</i>
+  , etc...)  </li>
+  <li> the sub-project into which a package is inserted </li>
+    <li> the choice of the compiler (such as <i>g++</i>
+    ,
+    <i>egcs</i>
+    , <i>CC</i>
+  , etc...)  </li>
+    <li> options used for compiling (such as <i>optimizer</i>
+    ,
+    <i>debugger</i>
+  , etc...)  or linking </li>
+    <li> the context specifications (selecting a particular version
+        of a firmware, selecting a database server, ...)  </li>
+  <li> the site itself</li>
+  <li> the context of a constituent during its rebuild operation</li>
+</ul>
+    Carefully describing this configuration is essential both for
+    maintenance operations (so as to remember the precise conditions
+    in which the package was built) and when the development area is
+<i>shared</i>
+ between machines running different operating
+    systems, or when a project has to be deployed on several sites.
+<hr><h3><a name="Describing a configuration"></a><a href="#index"><tt>10.&nbsp;1</tt></a> - Describing a configuration</h3>
+<blockquote>
+  <p><tt>CMT</tt>
+   relies on several complementary conventions or
+        mechanisms for this description and the associated
+        management. All these conventions rely on the concept of
+  <i>configuration tags</i>
+.</p>
+  <ul>
+    <li>A tag is a symbol that describes one aspect of the
+          configuration.</li>
+    <li>A tag can be <i>active</i>
+     when the corresponding aspect
+    	of the configuration is true or <i>inactive</i>
+   otherwise</li>
+    <li>The set of active tags represents the complete
+    	configuration known by CMT, and can be visualized with the
+    <tt>cmt show tags</tt>
+   command</li>
+    <li>Tags can be combined using logical expressions to form tag
+          associations</li>
+</ul>
+  <ol>
+    <li>Some aspects of the configuration - and their associated tags -
+          are automatically deduced from some standard environment
+          variables that the user is expected to specify (typically using
+          shell commands):<p></p>
+    <p></p>
+      <ul>
+        <li><tt>CMTCONFIG</tt>
+         describes the current settings for producing
+                binary objects. One default value is provided automatically by
+                CMT, but generally project will override it to apply specific
+                conventions.
+<blockquote><hr>
+        The default value is computed by CMT in the
+        	${CMTROOT}/mgr/cmt_system.sh shell script.
+          <p>This script automatically builds a value characterizing
+                    both the machine type and the opebrating system type (using a
+                    mixing of the <tt>uname</tt>
+           standard <tt>UNIX</tt>
+           command with
+                    various operating system specific definitions such as the
+          <tt>AFS</tt>
+           based <tt>fs sysname</tt>
+         command)</p>
+<hr></blockquote>
+        <p></p>
+      </li>
+        <li><tt>CMTSITE</tt>
+         characterizes the current site. Its syntax is
+                completely free<p></p>
+      </li>
+        <li><tt>CMTEXTRATAGS</tt>
+         may contain a space-separated list of
+      	additional tags to systematically activate</li>
+    </ul>
+    <p></p>
+<blockquote><hr>
+      <i>Note that the <tt>CMTBIN</tt>
+       variable which
+            represents the current binary installation of CMT itself does
+          NOT correspond to any tag.</i>
+<hr></blockquote>
+    <p></p>
+  </li>
+    <li>
+          Some aspects of the configuration represents the implicit
+          knowledge CMT gets of the current context:
+    <p></p>
+      <ul>
+        <li>The value given by the <i>uname</i>
+         standard Unix facility
+                is always a valid configuration tag. (eg. <tt>Linux</tt>
+      )</li>
+        <li>The current major version id of CMT is a valid tag and
+        	takes the form <tt>CMTv&lt;n&gt;</tt>
+         (eg. <tt>CMTv1</tt>
+      )</li>
+        <li>The current minor version id of CMT is a valid tag and
+        	takes the form <tt>CMTr&lt;n&gt;</tt>
+         (eg. <tt>CMTr19</tt>
+      )</li>
+        <li>The current patch id of CMT is a valid tag and takes the
+        	form <tt>CMTp&lt;n&gt;</tt>
+         (eg. <tt>CMTp20030616</tt>
+      )</li>
+        <li> The current sub-project to which the current package
+                belongs, and the various tags automatically generated by CMT
+              to qualify the strategy options.</li>
+        <li> The current hardware understood as filled in the
+        <tt>cmt_hardware</tt>
+       macro</li>
+        <li> The current OS understood as filled in the
+        <tt>cmt_system_version</tt>
+       macro</li>
+        <li> The version of the C++ compiler understood as filled in
+                the <tt>cmt_compiler_version</tt>
+       macro</li>
+    </ul>
+    <p></p>
+  </li>
+    <li>
+            During a <tt>make</tt>
+     session, each individual target being
+            rebuilt may define its own context, when the
+    <tt>-target_tag</tt>
+     is set to the associated constituent, and
+            this is materialized with a dedicated tag named
+    <tt>target_&lt;constituent&gt;</tt>
+    .
+      <p>For instance, a package defines a library <tt>A</tt>
+       and an
+              application <tt>P</tt>
+      , both in the default group. Both
+              constituents have their <tt>-target_tag</tt>
+       option set. Thus,
+              when the standard <tt>make</tt>
+       command is run, then those two
+              targets will be rebuilt successively (eg <tt>A</tt>
+       then
+      <tt>B</tt>
+      ). Then, during the build of <tt>A</tt>
+       (and only
+              then) the tag named <tt>target_A</tt>
+       will be active and
+              during the build of <tt>B</tt>
+      , the tag named
+      <tt>target_B</tt>
+    will in turn be active.</p>
+<pre class="cmt">
+library A -target_tag A.cxx
+application P -target_tag P.cxx
+
+macro_append cppflags "" target_A "-DA" target_P "-DP"</pre>
+    <p></p>
+  </li>
+    <li>
+            During the execution of an 
+      <a href="#actions"><tt>action</tt>
+    </a>
+    , a specific context is
+            created, which is materialized with a dedicated tag named
+    <tt>target_&lt;action&gt;</tt>
+    , very similarly to the target
+            tags for constituents.
+    <p></p>
+  </li>
+    <li>
+          User defined tags can be explicitly or implicitly activated:
+    <p></p>
+      <ul>
+        <li>explicitly from the <tt>cmt</tt>
+         command line, using the
+        <tt>-tag=&lt;tag-list&gt;</tt>
+       option </li>
+          <li>explictly from requirements files using the <tt>apply_tag
+        &lt;tag&gt;</tt>
+       syntax</li>
+        <li> implicitly from requirements files using the tag
+        	association syntax, when a tag is associated with an otherwise
+        	activated tag. One example is the <tt>Unix</tt>
+         tag associated
+      	by CMT itself with most Unix variants </li>
+    </ul>
+  </li>
+</ol>
+      The minimal tag set available from CMT can be visualized as
+      follows (note that the exact output will obviously not
+      necessarily be the one presented in this document according to
+      the context effectively used):
+<pre>
+&gt; cd ${CMTROOT}
+&gt; cmt show tags
+<i><font COLOR="#000077" face="courier new, courier">CMTv1 (from CMTVERSION)                                                   [1]
+CMTr19 (from CMTVERSION) package CMT implies [CMTr14]                     [1]
+CMTp20040701 (from CMTVERSION)                                            [1]
+Linux (from uname) package CMT implies [Unix]                             [2]
+i686-rh73-gcc32-opt (from CMTCONFIG)                                      [3]
+CERN (from CMTSITE)                                                       [4]
+CMT_prototypes (from PROJECT) excludes [CMT_no_prototypes]                [5]
+CMT_with_installarea (from PROJECT) excludes [CMT_without_installarea]
+CMT_setup_config (from PROJECT) excludes [CMT_setup_no_config]
+CMT_setup_root (from PROJECT) excludes [CMT_setup_no_root]
+CMT_setup_cleanup (from PROJECT) excludes [CMT_setup_no_cleanup]
+CMTr14 (from package CMT)
+i686 (from package CMT)                                                   [6]
+rh73 (from package CMT)                                                   [7]
+gcc32 (from package CMT)                                                  [8]
+Unix (from package CMT) excludes [WIN32 Win32]                            [9]</font></i></pre>
+  <ol>
+  <li>Implicit tags deduced from the current version of CMT</li>
+  <li>Implicit tag obtained from the uname command (note that there is an associated tag defined here)</li>
+  <li>The current value of CMTCONFIG</li>
+  <li>The current value of CMTSITE</li>
+  <li>The strategy tags</li>
+  <li>Automatic detection of the hardware</li>
+  <li>Automatic detection of the current OS</li>
+  <li>Automatic detection of the C++ compiler version</li>
+  <li>A indirectly activated tag (associated with another active tag)</li>
+</ol>
+</blockquote>
+<hr><h3><a name="Defining the user tags"></a><a href="#index"><tt>10.&nbsp;2</tt></a> - Defining the user tags</h3>
+<blockquote>
+  <p>The user configuration tags can generally be specified though
+      various complementary mechanisms:</p>
+  <ul>
+    <li>CMTSITE and CMTCONFIG can be specified using standard
+          shell commands (setenv, export, set)</li>
+<pre>
+sh&gt; export CMTSITE=CERN</pre>
+  <p></p>
+    <li>CMTSITE and CMTCONFIG can alternatively be specified using
+            the <tt>set</tt>
+   statement in a requirements file</li>
+<pre class="cmt">
+set CMTSITE "CERN"
+set CMTCONFIG "${CMTBIN}" sun "Solaris-CC-dbg"</pre>
+  <p></p>
+    <li> Additional tags may also be associated with other tags,
+            using the <tt>tag</tt>
+     statement (in a requirements file):
+<pre class="cmt">
+tag newtag tag1 tag2 tag3</pre>
+              which means that:
+      <ul>
+        <li><tt>newtag</tt>
+       defines a tag (inactive by default)</li>
+        <li>when <tt>newtag</tt>
+         is active, then both tag1, tag2 and
+                  tag3 are simultaneously active</li>
+    </ul>
+  </li>
+  <p></p>
+    <li>
+    	Tags may be declared as <i>exclusive</i>
+     using the <tt>tag_exclude</tt>
+     syntax.
+<pre class="cmt">
+tag_exclude debug optimized</pre>
+    	  This example implies that the two tags <tt>debug</tt>
+     and
+    <tt>optimized</tt>
+     should never become active simultaneously.
+  </li>
+  <p></p>
+    <li>
+    	Tags are assigned priorities according to the way they have
+    	been defined. The priority is particularly useful for
+    	specifying exclusion. The tag association promotes the
+    	priority of the associated tags to the priority of the
+    	defining tag.
+    	The following decreasing priorities are currently defined by
+    	CMT:
+    <p></p>
+      <ol>
+      <li>tag specified in the command line using the -tag=&lt;tag-list&gt; option</li>
+      <li>tag deduced from CMTCONFIG</li>
+        <li>tag defined in a requirements file using the <tt>tag</tt>
+       syntax</li>
+      <li>tag deduced from CMTSITE</li>
+        <li>tag deduced from <i>uname</i>
+      </li>
+      <li>tags deduced from the version of CMT</li>
+    </ol>
+  </li>
+</ul>
+</blockquote>
+<hr><h3><a name="Activating tags"></a><a href="#index"><tt>10.&nbsp;3</tt></a> - Activating tags</h3>
+<blockquote>
+      By default, <tt>CMTCONFIG</tt>
+  , <tt><i>uname</i>
+</tt>
+ and
+<tt>CMTSITE</tt>
+ (also named system tags) are always active.
+  <p>The tag associated with the current project name as well as
+        those describing the strategy properties of all projects are
+      also always active.</p>
+  <p>The target tags associated with constituents (when the
+  <tt>-target_tag</tt>
+   option was set on them) or with actions are
+        automatically activated during the build of the constituent or
+      during the execution of the action.</p>
+  <p>It is possible to <i>activate</i>
+   other tags through the
+        following arguments to <i>any</i>
+ cmt command:</p>
+  <ul>
+    <li>
+    <tt>-tag=&lt;tag-list&gt;</tt>
+      <p> will cleanup the complete current tag set, and
+                activate the new tags (the system tags are restored).
+    </p>
+  </li>
+    <li>
+    <tt>-tag_add=&lt;tag-list&gt;</tt>
+      <p> will add to the current tag set the tags
+              specified in the comma separated list </p>
+  </li>
+    <li>
+    <tt>-tag_remove=&lt;tag-list&gt;</tt>
+      <p>will remove from the current tag set the tags specified
+                in the comma separated list</p>
+  </li>
+</ul>
+<blockquote><hr>
+      Beware that giving these arguments generally make the selected
+      tag set active only during the selected command. Therefore two
+      different CMT commands run with different tag sets will
+      generally yield different results.
+<hr></blockquote>
+  <p>However it's often useful to state that a given tag or tag
+        set should be active. This can be obtained by the following
+      mechanisms:</p>
+  <ol>
+    <li>
+      <i>Forcing a tag in a requirements file using the <tt>apply_tag</tt>
+    &nbsp;syntax</i>
+    <p></p>
+    	  Eg the following syntax installed in a requirements file
+    	  will force the tag <tt>foo</tt>
+    :
+<pre class="cmt">
+tag_apply foo</pre>
+<pre>
+&gt; cmt show tags
+<i><font COLOR="#000077" face="courier new, courier">CMTv1 (from CMTVERSION)
+CMTr19 (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+Default (from Default)
+foo (from package Foo)</font></i></pre>
+  </li>
+    <li>
+    <i>Implying a tag from another one using the tag association syntax</i>
+<pre class="cmt">
+tag Linux foo</pre>
+<pre>
+&gt; cmt show tags
+<i><font COLOR="#000077" face="courier new, courier">CMTv1 (from CMTVERSION)
+CMTr19 (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname) package Foo implies [foo]
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+Default (from Default)
+foo (from package Foo)</font></i></pre>
+  </li>
+    <li>
+      <i>Through conventionally encoded values of <tt>CMTCONFIG</tt>
+    </i>
+<pre class="cmt">
+tag Linux-foo Linux foo</pre>
+<pre>
+&gt; export CMTCONFIG=Linux-foo
+&gt; cmt show tags
+<i><font COLOR="#000077" face="courier new, courier">CMTv1 (from CMTVERSION)
+CMTr19 (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-foo (from CMTCONFIG) package Foo implies [Linux foo]
+A (From PROJECT)
+Default (from Default)
+Linux-i686 (from package CMT) package CMT implies [Linux]
+foo (from package Foo)</font></i></pre>
+  </li>
+</ol>
+  <p>The current active tag set can always be visualized using the
+  <tt>cmt show tags</tt>
+ command.</p>
+<pre>
+&gt; cmt show tags
+<i><font COLOR="#000077" face="courier new, courier">CMTv1 (from CMTVERSION)
+CMTr19 (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+Default (from Default)
+</font></i>
+&gt; cmt -tag_add=tag1,tag2,tag3 show tags
+<i><font COLOR="#000077" face="courier new, courier">CMTv1 (from CMTVERSION)
+CMTr19 (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+tag1 (from arguments)
+tag2 (from arguments)
+tag3 (from arguments)
+Default (from Default)</font></i></pre>
+<p>Typical usages of those extra tags are:</p>
+  <ul>
+    <li> when using special compiler options (e.g. optimization,
+          debugging, ...)  </li>
+    <li> for switching to different compilers (e.g. <tt>gcc</tt>
+          versus the native compiler) </li>
+    <li> when one uses a special debugging environment such as
+    <tt>Insure</tt>
+     or <tt>Purify</tt>
+  </li>
+    <li> when using special system specific features (such as
+          whether one uses thread-safe algorithms or not) </li>
+</ul>
+  <p>All symbol definitions providing specific values triggered by
+      the active selectors will be selected, such as in:</p>
+<pre class="cmt">
+macro_append cppflags "" \
+             debug    " -g "</pre>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Working on a package"></a><a href="#index"><tt>11</tt></a> - Working on a package</h2>
+<blockquote>
+  <p>In this section, we'll see, through a quite simple scenario,
+      the typical operations generally needed for installing, defining
+      and building a package.  We are continuing the <a href="#Installing a new package">example</a>
+   of the <tt>Foo</tt>
+    package already used in this document. </p>
+<hr><h3><a name="Working on a library"></a><a href="#index"><tt>11.&nbsp;1</tt></a> - Working on a library</h3>
+<blockquote>
+  <p>Let's assume, as a first example, that the <tt>Foo</tt>
+   package
+  <i>is</i>
+   originally composed of one library <tt>libFoo.a</tt>
+        itself made from two sources : <tt>FooA.c</tt>
+   and
+  <tt>FooB.c</tt>
+  . A shared flavour of the library <tt>libFoo.so</tt>
+        or <tt>libFoo.sl</tt>
+   or <tt>libFoo.dll</tt>
+) is also foreseen.</p>
+  <p> The minimal set of branches provided by <tt>CMT</tt>
+   (once the
+  <tt>cmt create</tt>
+   operation has been performed) for a package
+        includes <tt>src</tt>
+   for the sources and <tt>cmt</tt>
+   for the
+  <i>Makefiles</i>
+ and other scripts.</p>
+  <p> The various tools <tt>CMT</tt>
+   provide will be fully exploited
+        if one respects the roles these branches have to play. However
+        it is always possible to extend the default understanding
+  <tt>CMT</tt>
+   gets on the package by appropriate modifiers
+        (typically by overriding <a href="#Standard macros predefined in CMT">standard</a>
+ macros). </p>
+  <p> Assuming the conventional usage is selected, the steps
+        described in this section can be undertaken in order to actually
+      develop a software package. </p>
+  <p> We first have to create the two source files into the
+  <tt>src</tt>
+   branch (typically using our favourite text
+        editor). Then a description of the expected library (ie. built
+        from these two source files) will be entered into the
+  <tt>requirements</tt>
+   file. The minimal syntax required in our
+      example will be :</p>
+<pre>
+csh&gt; cd ../cmt
+csh&gt; vi requirements             (1)
+library Foo FooA.cxx FooB.cxx</pre>
+  <ol>
+    <li> the <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+            file located in the <tt>cmt</tt>
+            branch of the package receives the description of this
+    <i>library</i>
+     component. This is done using one
+    <tt>library</tt>
+   statement.  </li>
+</ol>
+  <p>The <tt>cmt create</tt>
+   command had generated a simple
+  <i>Makefile</i>
+   (or <tt>NMake</tt>
+   file) which is generaly
+        sufficient for all standard operations, since <tt>CMT</tt>
+        continuously and transparently manages the automatic
+        reconstruction of all intermediate makefile fragments. We
+      therefore simply and immediately execute gmake as follows:</p>
+<pre>
+...v1/cmt&gt; gmake QUIET=1
+<i><font COLOR="#000077" face="courier new, courier">------> (Makefile.header) Rebuilding constituents.make
+------> (constituents.make) Rebuilding setup.make Linux-i686.make         [1]
+setup.make ok
+------> (constituents.make) Rebuilding library links
+------> (constituents.make) all done
+------> (constituents.make) Building Foo.make                             [2]
+Library Foo
+------> (constituents.make) Starting Foo
+------> (Foo.make) Rebuilding ../Linux-i686/Foo_dependencies.make         [3]
+rebuilding ../Linux-i686/FooA.o
+rebuilding ../Linux-i686/FooB.o
+rebuilding library
+------> Foo : library ok
+------> Foo ok
+Installing library libFoo.so into /home/arnault/mydev/InstallArea/Linux-i686/lib
+installation done                                                         [4]
+------> (constituents.make) Foo done
+ all ok.
+Linux-i686.make ok
+gmake[2]: `config' is up to date.
+gmake[2]: `all' is up to date.</font></i></pre>
+  <ol>
+    <li> Some intermediate makefile fragments are automatically
+            built to reflect the current effective set of Makefile macros
+              deduced from the configuration (read from the <tt>
+    &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+     file). These fragments are automatically
+            rebuilt (if needed) each time one of the
+    <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+   file changes.  </li>
+    <li> Each component of the package (be it a particular
+    <i>library</i>
+     or a particular <i>executable</i>
+    ) will have
+            its own <i>makefile</i>
+     fragment (named
+    <tt>../${CMTCONFIG}/&lt;name&gt;.[n]mak[e]</tt>
+    ). This dedicated
+    <i>makefile</i>
+     takes care of filling up the library and
+            creating the shared library (on the systems where this is
+          possible).  </li>
+    <li> The directory which is used for the binaries (i.e. the
+            results of compilation or the libraries) has been
+            automatically created by a generic target (<tt>dirs</tt>
+    )
+            which is defined within <tt>[N]Makefile.header</tt>
+    . A new
+            binary directory will be created each time a new value of the
+    <tt>CMTCONFIG</tt>
+     environment variable is defined or a
+    <i>tag</i>
+     is provided on the command line to <tt>make</tt>
+    .
+  </li>
+    <li> An automatic installation mechanism is applied for all
+          successfully built binaries. </li>
+</ol>
+      or, for nmake:
+<pre>
+...v1/cmt&gt; nmake /f nmake </pre>
+  <p>This mechanism relies on some conventional <i>macros</i>
+   and
+        incremental <i>targets</i>
+   used within the specific
+        makefiles. Some are automatically generated, some have to be
+        specified in user packages. It's quite important to understand
+        the list of possible customization macros, since this is the
+        main communication medium between <tt>CMT</tt>
+   and the package
+        manager. See the complete 
+  <a href="#Standard macros predefined in CMT">table</a>
+        of those conventional macro when you want to
+      interact with the standard CMT behaviour.  </p>
+  <p>However, it is also possibble to use a simplified and
+      platform independent form to build a constituent</p>
+<pre>
+...v1/cmt&gt; cmt make </pre>
+  <p>This syntax is identical on all platforms, and also does not
+        require any <tt>cmt config</tt>
+   nor <tt>source setup</tt>
+      operation</p>
+</blockquote>
+<hr><h3><a name="Working on an application"></a><a href="#index"><tt>11.&nbsp;2</tt></a> - Working on an application</h3>
+<blockquote>
+  <p>Assume we now want to add a test program to our
+        development. Then we create a <tt>FooTest.cxx</tt>
+   source, and
+        generate the associated makefile (specifying that it will be an
+      executable instead of a library) : </p>
+<pre>
+csh&gt; cd ../src 
+csh&gt; emacs FooTest.cxx
+... 
+csh&gt; cd ../cmt 
+csh&gt; vi requirements 
+... 
+application FooTest FooTest.cxx</pre>
+      So that we may simply build the complete stuff by running : 
+<pre>
+&gt; cmt make QUIET=1
+<i><font COLOR="#000077" face="courier new, courier">------> (Makefile.header) Rebuilding constituents.make
+------> (constituents.make) Rebuilding setup.make Linux-i686.make
+setup.make ok
+------> (constituents.make) Rebuilding library links
+------> (constituents.make) all done
+------> (constituents.make) Building Foo.make
+Library Foo
+------> (constituents.make) Starting Foo
+------> Foo : library ok
+------> Foo ok
+installation done
+------> (constituents.make) Foo done
+------> (constituents.make) Building FooTest.make
+Application FooTest
+------> (constituents.make) Starting FooTest
+------> (FooTest.make) Rebuilding ../Linux-i686/FooTest_dependencies.make
+rebuilding ../Linux-i686/FooTest.o
+rebuilding ../Linux-i686/FooTest.exe
+------> FooTest ok
+Installing application FooTest.exe into /home/arnault/mydev/InstallArea/Linux-i686/bin
+installation done
+------> (constituents.make) FooTest done
+ all ok.
+Linux-i686.make ok
+gmake[2]: `config' is up to date.
+gmake[2]: `all' is up to date.</font></i></pre>
+      Which shows that a program <tt>FooTest.exe</tt>
+ has been built
+      from our sources. Assuming now that this program needs to access
+      the <tt>Foo</tt>
+ library, we'll just add the following definition
+      in the <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+      file :
+<pre class="cmt">
+... 
+macro Foo_linkopts " -lFoo " \
+      WIN32        " $(FOOROOT)/$(Foo_tag)/Foo.lib "
+... </pre>
+  <p>The <tt>Foo_linkopts</tt>
+   conventional macro will be automatically
+        inserted within the <tt>use_linkopts</tt>
+   macro. And the shared
+        library location will be automatically set to the installation
+      areas.</p>
+  <p>It is also possible to select extra tag sets when running
+        gmake as follows (in this example we first cleanup the previous
+        build and rebuild with debug options added to the compiler and
+      linker commands) :</p>
+<pre>
+&gt; cmt make clean
+&gt; cmt make CMTEXTRATAGS=debug</pre>
+  <p> Like all other make macros used to build a component, the
+  <tt>Foo_linkopts</tt>
+   will be specified within the
+  <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+ which gives several benefits: </p>
+  <ul>
+  <li> variants of the macro definition can be provided </li>
+    <li> monitoring features of <tt>CMT</tt>
+       such as the <tt>cmt show
+            macro Foo_linkopts</tt>
+   command can be used later on </li>
+    <li> macros defined this way may be later on inherited by
+            client packages which will <i>use</i>
+   our package.  </li>
+</ul>
+</blockquote>
+<hr><h3><a name="Working on a test or external application"></a><a href="#index"><tt>11.&nbsp;3</tt></a> - Working on a test or external application</h3>
+<blockquote>
+      It is also possible to work on a <i>test</i>
+ or <i>external</i>
+      application, ie. when one does not wish to configure the
+      development for this application using <tt>CMT</tt>
+. Even in this
+      case, it is possible to benefit from the packages configured
+      using <tt>CMT</tt>
+ by partially using <tt>CMT</tt>
+, just for
+<i>used</i>
+ relationships.
+  <p> Here, no special convention is assumed on the location of
+        the sources, the binaries, the management scripts,
+          etc... However, it is possible to describe in a <tt>
+  &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+   file the <i>use</i>
+   relationships, as well
+        as the <tt>make</tt>
+   macro definitions, quite similarly to the
+        package entirely configured using <tt>CMT</tt>
+. </p>
+  <p> Most of the options provided by the <tt>cmt</tt>
+   user
+      interface are still available in these conditions. </p>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Defining a document generator"></a><a href="#index"><tt>12</tt></a> - Defining a document generator</h2>
+<blockquote>
+  <p> In a Unix environment, documents are built using <tt>make</tt>
+      (well generally its <i>gnu</i>
+   flavour) or <tt>nmake</tt>
+   in Windows
+      environments. The basic mechanism provided in <tt>CMT</tt>
+   relies on
+  <i>make fragment patterns</i>
+   containing instructions on how to
+      rebuild document pieces. Many such generators are provided by
+  <tt>CMT</tt>
+   itself so as to take care of of the most usual cases
+      (e.g. compilations, link operations, archive manipulations,
+      etc...). In addition to those, any package has to possibility to
+      provide a new generator for its own purpose, i.e. either for
+      providing rules for a special kind of document, or even to
+      override the default ones provided by <tt>CMT</tt>
+  . This mechanism
+      is very similar to the definition or re-definition of
+  <i>macros</i>
+   or environment variables in that every new generator
+      has to be first declared in a <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+   file
+      belonging to a package (<tt>CMT</tt>
+   actually declares all its
+      default generators within its <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+   file),
+      allowing all its client packages to transparently acquire the
+    capacity to generate documents of that sort.  </p>
+  <p><tt>CMT</tt>
+   manages two categories of constituents:
+    <ol>
+      <li><i>Applications</i>
+       and <i>Libraries</i>
+       are handled using
+              pre-defined make fragments (mainly related with languages) and
+            behaviour.  </li>
+      <li><i>Documents</i>
+       offer a quite general framework for
+              introducing completely new behaviours through user-defined
+              make fragments. This includes actually generating documents,
+              but also simply performing an operation (in which case
+              sometimes no real <i>document</i>
+     is produced).  </li>
+  </ol>
+</p>
+  <p> In this section we only discuss the latter category and the
+      following paragraphs explain the framework used for defining new
+    document types.  </p>
+  <p>The main concept of this framework is that each document to be
+      generated or manipulated must be associated with a "document-type"
+     (also sometimes named "document-style"), which corresponds to a
+      dedicated make fragment of that name. Then, when specified in a
+  <tt>document</tt>
+   statement, this make fragment will be
+  <i>instanciated</i>
+   once or several times (typically once per
+      source file) to construct a complete and functional make fragment,
+      containing one main target. Both the resulting make fragment and
+    the make target will have the name of the constituent.</p>
+<hr><h3><a name="An example : the tex document-style"></a><a href="#index"><tt>12.&nbsp;1</tt></a> - An example : the tex document-style</h3>
+<blockquote>
+  <p>
+<blockquote><hr>
+    <i>This section discusses one simple example (the
+            production of postscript from latex files) available in the
+            standard <tt>CMT</tt>
+   distribution kit.  </i>
+<hr></blockquote>
+</p>
+  <p>Converting a latex source file into a postcript output
+        implies to chain two text processors, with an intermediate dvi
+      format.</p>
+  <p>The fragment described here exactly performs this sequence,
+        taking care of intermediate file deletion. The document style is
+        named "tex" (the associated fragment shown here and named "tex"
+        is actually provided by <tt>CMT</tt>
+   itself, and can be looked at
+        in <tt>${CMTROOT}/fragments/tex</tt>
+.) :</p>
+<pre class="cmt">
+============ tex ===================================== 
+${CONSTITUENT} :: ${FILEPATH}/${NAME}.ps
+
+${FILEPATH}/${NAME}.dvi : ${FULLNAME} 
+	cd ${doc}; latex ${FULLNAME} 
+
+${FILEPATH}/${NAME}.ps : ${FILEPATH}/${NAME}.dvi 
+	cd ${doc}; dvips ${FILEPATH}/${NAME}.dvi 
+
+${CONSTITUENT}clean ::
+	cd $(doc); /bin/rm -f ${FILEPATH}/${NAME}.ps ${FILEPATH}/${NAME}.dvi
+
+====================================================== </pre>
+  <ul>
+    <li> They are declared in the <tt>CMT</tt>
+    's <a HREF="#The         requirements file">requirements</a>
+     file as follows :
+<pre class="cmt">
+make_fragment tex -header=tex_header</pre>
+              where: 
+      <ol>
+      <p></p>
+      <li> "tex" represents both the fragment name and the document style. </li>
+      <p></p>
+        <li>the <tt>-header=tex_header</tt>
+         option indicates that
+                    the generated makefile fragment will first include this
+                  header (which is actually an empty file in this case)</li>
+      <p></p>
+    </ol>
+  </li>
+    <li> A user package willing to apply this behaviour will have
+            to include in its &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file a statement similar
+            to the following:
+<pre class="cmt">
+document tex MyDoc -s=../doc doc1.tex doc2.tex </pre>
+              where: 
+      <ol>
+      <li> The first parameter "tex" is the document-style </li>
+        <li> The second parameter "MyDoc" is used for building the
+                    constituent's makefile (under the name MyDoc.make) and for
+                  providing the make target "MyDoc". </li>
+        <li> The other parameters (doc1.tex and doc2.tex) are the
+                    sources of the document. Explicit location is required
+                  (since default is currently defined to be ../src) </li>
+        <li> The constituent's makefile MyDoc.make is built as
+                    follows :
+          <ol>
+            <li> Install a copy of the
+            <tt>$CMTROOT/fragments/make_header</tt>
+             generic fragment
+          </li>
+            <li> Install a copy of the <tt>$CMTROOT/fragments/tex_header</tt>
+           fragment </li>
+          <li> For each of the sources, install a copy of the fragment "tex"</li>
+            <li> Install a copy of the <tt>$CMTROOT/fragments/cleanup_header</tt>
+           fragment </li>
+        </ol>
+      </li>
+    </ol>
+    <p>The result for our example is: </p>
+<pre class="cmt">
+=========== MyDoc.make =============================== 
+
+#==================================== 
+#  Document MyDoc 
+# 
+#   Generated   by  
+# 
+#==================================== 
+
+help :: 
+@echo 'MyDoc' 
+
+doc1_dependencies = ../doc/doc1.tex 
+doc2_dependencies = ../doc/doc2.tex 
+
+MyDoc :: ../doc/doc1.ps 
+
+../doc/doc1.dvi : $(doc)doc1.tex 
+	cd ${doc}; latex $(doc)doc1.tex 
+
+../doc/doc1.ps : ../doc/doc1.dvi 
+	cd ${doc}; dvips ../doc/doc1.dvi 
+
+MyDocclean ::
+	cd $(doc); /bin/rm -f ../doc/doc1.ps ../doc/doc1.dvi
+
+MyDoc :: ../doc/doc2.ps 
+
+../doc/doc2.dvi : $(doc)doc2.tex 
+	cd ${doc}; latex $(doc)doc2.tex 
+
+../doc/doc2.ps : ../doc/doc2.dvi 
+	cd ${doc}; dvips ../doc/doc2.dvi 
+
+MyDocclean ::
+	cd $(doc); /bin/rm -f ../doc/doc2.ps ../doc/doc2.dvi
+
+clean :: MyDocclean 
+	cd . 
+
+MyDocclean :: 
+====================================================== </pre>
+  </li>
+</ul>
+</blockquote>
+<hr><h3><a name="How to create and install a new document style"></a><a href="#index"><tt>12.&nbsp;2</tt></a> - How to create and install a new document style</h3>
+<blockquote>
+<blockquote><hr>
+    <p><i>This section presents the general framework
+        for designing a document generator.</i>
+<hr></blockquote>
+</p>
+  <ol>
+    <li> Select a name for the document style. It should not clash
+            with existing ones (use the <tt>cmt show fragments</tt>
+     for a
+          complete list of document types currently defined).</li>
+  <p></p>
+    <li> A fragment exactly named after the document style name
+            must be installed into a subdirectory named <tt>fragments</tt>
+            below the <tt>cmt</tt>
+     branch of a given package (which becomes
+            the <i>provider</i>
+   package).</li>
+  <p></p>
+    <li> Optionally, two other fragments may be installed into the
+            same subdirectory, one of them will be the <i>header</i>
+     of
+            the generated complete fragment, the other will be its
+    <i>trailer</i>
+  </li>
+  <p></p>
+    <li> Those fragments <i>must</i>
+     be declared in the
+    &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file of the provider package as follows:
+<pre class="cmt">
+make_fragment &lt;fragment-name&gt; [ options... ] </pre>
+              where options may be : 
+      <p>
+        <table cellspacing="0" BORDER="1" COLS="2">
+          <tr>
+            <td><tt>-suffix=&lt;suffix&gt;</tt>
+          </td>
+          <td width="500">provide the suffix of the output files (without the dot)</td>
+        </tr>
+          <tr>
+            <td><tt>-header=&lt;header&gt;</tt>
+          </td>
+            <td>provide another make fragment meant to be prepended to 
+                                the constituent's make fragment.</td>
+        </tr>
+          <tr>
+            <td><tt>-trailer=&lt;trailer&gt;</tt>
+          </td>
+            <td>provide another make fragment meant to be
+                                appended to the constituent's make fragment.</td>
+        </tr>
+          <tr>
+            <td><tt>-dependencies</tt>
+          </td>
+            <td>install the automatic generation of dependencies into the 
+                                constituent's make fragment</td>
+        </tr>
+      </table>
+    </p>
+  </li>
+</ol>
+  <p>Once a fragment is installed and declared, it may be used by
+        any <i>client</i>
+   package (ie a package <i>using</i>
+   the
+      provider), and queried upon using the command</p>
+<pre>
+&gt; cmt show fragment &lt;fragment name&gt; </pre>
+  <p>which will show where this fragment is defined (ie. in which
+      of the used packages).</p>
+  <p>The <tt>cmt show fragments</tt>
+   commands lists all declared
+      fragments. </p>
+  <p>If a package re-defines an already declared make fragment, ie
+        it provides a new copy of the fragment (possibly with new copies
+        of the header and the trailer), and declares it inside its
+        requirements file, then this package becomes the new provider
+      for the document style.</p>
+  <p>For building a fragment, one may use pre-defined generic
+        "templates" (which will be substituted when a fragment is copied
+      into the final constituent's makefile).</p>
+  <p>
+    <center>
+      <table cellspacing="0" BORDER="1" COLS="2">
+        <tr>
+          <td width="100"><tt>CONSTITUENT</tt>
+        </td>
+        <td width="400">the constituent name</td>
+      </tr>
+        <tr>
+          <td><tt>CONSTITUENTSUFFIX</tt>
+        </td>
+        <td>the optional constituent's output suffix</td>
+      </tr>
+        <tr>
+          <td><tt>FULLNAME</tt>
+        </td>
+        <td>the full source path name (including directory and suffix)</td>
+      </tr>
+        <tr>
+          <td><tt>FILENAME</tt>
+        </td>
+        <td>the complete source file name (only including the suffix)</td>
+      </tr>
+        <tr>
+          <td><tt>NAME</tt>
+        </td>
+        <td>the short source file name (without directory and suffix)</td>
+      </tr>
+        <tr>
+          <td><tt>FILEPATH</tt>
+        </td>
+        <td>the source directory</td>
+      </tr>
+        <tr>
+          <td><tt>SUFFIX</tt>
+        </td>
+        <td>the suffix provided in the -suffix option</td>
+      </tr>
+        <tr>
+          <td><tt>OBJS</tt>
+        </td>
+          <td>(only available in headers) the list of
+                              outputs, formed by a set of expressions :
+<pre>
+$(${CONSTITUENT}_output)${NAME}${SUFFIX} </pre>
+        </td>
+      </tr>
+    </table>
+  </center>
+</p>
+  <p>Templates must be enclosed between <tt>${</tt>
+   and <tt>}</tt>
+   or between <tt>$(</tt>
+   and
+  <tt>)</tt>
+   and will be substituted at the generation time. Thus, if a
+      fragment contains the following text : </p>
+<pre>
+$(${CONSTITUENT}_output)${NAME}${SUFFIX}</pre>
+  <p>then, the expanded constituent's makefile will contain
+      (refering to the "tex" example)</p>
+<pre>
+$(MyDoc_output)doc1.ps </pre>
+<p>Which shows that make macros may be dynamically generated. </p>
+<center>
+<a name="The architecture of document generation."></a>
+<img src="Images/DocumentGenerator.jpg"/>
+</center>
+<center>
+<tt>3</tt> - <i>The architecture of document generation.</i>
+</center>
+</blockquote>
+<hr><h3><a name="Examples"></a><a href="#index"><tt>12.&nbsp;3</tt></a> - Examples</h3>
+<blockquote>
+  <ol>
+    <li> rootcint 
+    <p>It generates C++ hubs for the Cint interpreter in Root. </p>
+<pre class="cmt">
+========= rootcint ========================================= 
+$(src)${NAME}.cc :: ${FULLNAME}   
+	${rootcint} -f $(src)${NAME}.cc -c ${FULLNAME} 
+============================================================ </pre>
+  </li>
+    <li> agetocxx and agetocxx_header. 
+      <p>It generates C++ source files (xxx.g files) from Atlas' AGE 
+                description files. </p>
+<pre class="cmt">
+========= agetocxx ========================================= 
+output=$(${CONSTITUENT}_output) 
+
+$(output)${NAME}.cxx : $(${NAME}_cxx_dependencies) 
+	(echo '#line 1 "${FULLNAME}"'; cat ${FULLNAME}) > /tmp/${NAME}.gh.c 
+	gcc -E -I$(output) $(use_includes) -D_GNU_SOURCE \ 
+	  cd ${output}; $(agetocxx) -o ${NAME} -ohd ${FILEPATH} \
+	  -ohp ${FILEPATH} /tmp/${NAME}.gh 
+	rm -f /tmp/${NAME}.gh /tmp/${NAME}.gh.c 
+	cd $(bin); $(cppcomp) $(use_cppflags) $(${CONSTITUENT}_cppflags) \
+	  $(${NAME}_cppflags) ${ADDINCLUDE} $(output)${NAME}.cxx 
+	cd $(bin); $(ar) $(${CONSTITUENT}lib) ${NAME}.o; /bin/rm -f ${NAME}.o 
+============================================================ </pre>
+<pre class="cmt">
+========= agetocxx_header ================================== 
+${CONSTITUENT}lib       = $(bin)lib${CONSTITUENT}.a 
+${CONSTITUENT}stamp     = $(bin)${CONSTITUENT}.stamp 
+${CONSTITUENT}shstamp   = $(bin)${CONSTITUENT}.shstamp 
+
+${CONSTITUENT} :: dirs ${CONSTITUENT}LIB 
+	@/bin/echo ${CONSTITUENT} ok 
+
+${CONSTITUENT}LIB :: $(${CONSTITUENT}lib) $(${CONSTITUENT}shstamp) 
+	@/bin/echo ${CONSTITUENT} : library ok 
+
+$(${CONSTITUENT}lib) $(${CONSTITUENT}stamp) :: ${OBJS} 
+	$(ranlib) $(${CONSTITUENT}lib) 
+	cat /dev/null &gt;$(${CONSTITUENT}stamp) 
+
+$(${CONSTITUENT}shstamp) :: $(${CONSTITUENT}stamp) 
+	cd $(bin); $(make_shlib) $(tag) ${CONSTITUENT} \
+	  $(${CONSTITUENT}shlibflags); \
+	  cat /dev/null &gt;$(${CONSTITUENT}shstamp) 
+
+============================================================ </pre>
+              It must be declared as follows : 
+<pre class="cmt">
+make_fragment agetocxx -suffix=cxx -dependencies -header=agetocxx_header </pre>
+  </li>
+</ol>
+</blockquote>
+</blockquote>
+<hr><h2><a name="The tools provided by CMT"></a><a href="#index"><tt>13</tt></a> - The tools provided by CMT</h2>
+<blockquote>
+        The set of conventions and tools provided by <tt>CMT</tt>
+ is 
+        mainly composed of : 
+  <ul>
+    <li>
+                the syntax of the <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+     file, 
+  </li>
+    <li>
+                and the general <tt>cmt</tt>
+     user interface, available in 
+                the <tt>mgr</tt>
+     branch of the <tt>CMT</tt>
+     package. 
+  </li>
+</ul>
+        The <i>setup</i>
+ script found in the <tt>CMT</tt>
+ installation
+        directory actually adds its location to the definition of the
+        standard <tt>UNIX</tt>
+<tt>PATH</tt>
+ environment variable in order to
+        give direct access to the main <tt>cmt</tt>
+ user interface.
+  <p>
+            The sections below will detail the complete syntax of the 
+  <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+   file since it is the basis of most 
+            information required to run the tools as well as the main 
+            commands available through the <tt>cmt</tt>
+ user interface. </p>
+<hr><h3><a name="The requirements file"></a><a href="#index"><tt>13.&nbsp;1</tt></a> - The requirements file</h3>
+<blockquote>
+<hr><h4><a name="The general requirements syntax"></a><a href="#index"><tt>13.&nbsp;1.&nbsp;1</tt></a> - The general requirements syntax</h4>
+<blockquote>
+  <ul>
+    <li>
+                    A requirements file is made of <i>statements</i>
+    , each describing
+                    one named configuration parameter.
+      <p>Statements generally occupy one single line, but may be
+                        split into several lines using the reverse-slash character
+                        (in this case the reverse-slash character <i>must</i>
+       be
+                        the last character on the line or must be only followed
+                      by space characters).</p>
+      <p>Each statement is composed of words separated with spaces
+                     or tabulations.</p>
+      <p>The first word of a statement is the name of the
+                      configuration parameter.</p>
+      <p>The rest of the statement provides the value assigned
+                      to the configuration parameter.</p>
+  </li>
+    <li>
+      <p>Words composing a statement are separated with space or
+                        tab characters. They may also be enclosed in quotes when
+                        they have to include space or tab characters. Single or
+                        double quotes may be freely used, as long as the same type
+                      of quote is used on both sides of the word.</p>
+      <p>Special characters (tabs, carriage-return and
+                          line-feed) may be inserted into the statements using an
+                        XML-based convention:</p>
+      <center>
+        <table cols="2">
+          <tr>
+            <td>
+            <tt>tabulation</tt>
+          </td>
+            <td>
+              <tt><tt>&lt;cmt:tab/&gt;</tt>
+            </tt>
+          </td>
+        </tr>
+          <tr>
+            <td>
+            <tt>carriage-return</tt>
+          </td>
+            <td>
+              <tt><tt>&lt;cmt:cr/&gt;</tt>
+            </tt>
+          </td>
+        </tr>
+          <tr>
+            <td>
+            <tt>line-feed</tt>
+          </td>
+            <td>
+              <tt><tt>&lt;cmt:lf/&gt;</tt>
+            </tt>
+          </td>
+        </tr>
+      </table>
+    </center>
+    <p></p>
+  </li>
+    <li>
+      <p>Comments : they start with the <tt>#</tt>
+       character and 
+                        extend up to the end of the current line. 
+    </p>
+  </li>
+</ul>
+	    The complete  syntax specification is available in <a href="#The complete requirements syntax">Appendix</a>
+.
+</blockquote>
+</blockquote>
+<hr><h3><a name="The concepts handled in the requirements file"></a><a href="#index"><tt>13.&nbsp;2</tt></a> - The concepts handled in the requirements file</h3>
+<blockquote>
+<hr><h4><a name="The package structuring style "></a><a href="#index"><tt>13.&nbsp;2.&nbsp;1</tt></a> - The package structuring style </h4>
+<blockquote>
+  <p>Packages are installed in a directory structure that
+              can optionnally include a version directory (just after
+              the top directory of the package name). This is controlled
+              through the <i>structuring style</i>
+     or <i>structuring
+              strategy</i>
+   parameters specified using one of the
+            following means:</p>
+  <ol>
+    <li>Through the environment variable
+    <tt>CMTSTRUCTURINGSTYLE</tt>
+     taking one of the
+                  alternate values:
+<pre>
+with_version_directory
+without_version_directory</pre>
+    <p></p>
+  </li>
+    <li>Through the command line options
+    <tt>-with_version_directory</tt>
+     or
+    <tt>-without_version_directory</tt>
+    <p></p>
+  </li>
+    <li>Through the <tt>structure_strategy</tt>
+     specification entered into the project file of the current project, using the alternate values:
+<pre>
+with_version_directory
+without_version_directory</pre>
+    <p></p>
+  </li>
+</ol>
+  <p>It should be noted that the command line option will
+              take precedence over the strategy specification, in case
+            of conflict.</p>
+</blockquote>
+<hr><h4><a name="Meta-information : author, manager"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;2</tt></a> - Meta-information : author, manager</h4>
+<blockquote>
+            The author and manager names 
+</blockquote>
+<hr><h4><a name="package, version"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;3</tt></a> - package, version</h4>
+<blockquote>
+            The package name and version. These statements are purely
+            informational.
+</blockquote>
+<hr><h4><a name="Constituents : application, library, document"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;4</tt></a> - Constituents : application, library, document</h4>
+<blockquote>
+  <p>Describe the composition of a constituent. Application
+              and library correspond to the standard meaning of an
+              application (an executable) and a library, while document
+              provides for a quite generic and open mechanism for
+              describing any type of document that can be generated from
+            sources.</p>
+  <p>Applications and libraries are assigned a name (which
+              will correspond to a generated make fragment, and a
+            dedicated make target).</p>
+  <p>A document is first associated with a document type
+              (which must correspond to a previously declared make
+              fragment). The document name is then used to name a
+            dedicated make fragment and a make target.</p>
+  <p>Various options can be used when declaring a
+            constituent:</p>
+  <center>
+    <table cellspacing="0" border="1" cols="3">
+      <tr>
+          <td width="250"><center><i>option</i>
+        </center>
+      </td>
+          <td width="150"><center><i>validity</i>
+        </center>
+      </td>
+          <td width="300"><center><i>usage</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>-s=<i>directory</i>
+        </tt>
+      </td>
+      <td>any</td>
+          <td>switch to a new default directory <a href="#source selection and exclusion"><tt>(1)</tt>
+        </a>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>-x=<i>regexp</i>
+        </tt>
+      </td>
+      <td>any</td>
+          <td>specify an exclusion regular expression to be applied to the sources <a href="#source selection and exclusion"><tt>(1)</tt>
+        </a>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>-k=<i>regexp</i>
+        </tt>
+      </td>
+      <td>any</td>
+          <td>specify a finer selection regular expression to be applied to the sources <a href="#source selection and exclusion"><tt>(1)</tt>
+        </a>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>-no_share</tt>
+      </td>
+      <td>libraries</td>
+      <td>do not generate the shared library</td>
+    </tr>
+      <tr>
+        <td><tt>-no_static</tt>
+      </td>
+      <td>libraries</td>
+        <td>do not generate the static library (<i>not yet implemented</i>
+      )</td>
+    </tr>
+      <tr>
+        <td><tt>-prototypes</tt>
+      </td>
+      <td>applications, libraries</td>
+      <td>do generate the prototype header files</td>
+    </tr>
+      <tr>
+        <td><tt>-no_prototypes</tt>
+      </td>
+      <td>applications, libraries</td>
+      <td>do not generate the prototype header files</td>
+    </tr>
+      <tr>
+        <td><tt>-check</tt>
+      </td>
+      <td>applications</td>
+      <td>generate a check target meant to execute the rebuilt application</td>
+    </tr>
+      <tr>
+        <td><tt>-group=&lt;group-name&gt;</tt>
+      </td>
+      <td>any</td>
+      <td>install the constituent within this group target</td>
+    </tr>
+      <tr>
+        <td><tt>-suffix=&lt;suffix&gt;</tt>
+      </td>
+      <td>applications, libraries</td>
+          <td>provide a suffix to names of all object files generated for this constituent <a href="#suffix option"><tt>(2)</tt>
+        </a>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>-import=&lt;package&gt;</tt>
+      </td>
+      <td>applications, libraries</td>
+        <td>explicitly import for this constituent the standard macros from a package that has the <tt>-no_auto_imports</tt>
+       option set</td>
+    </tr>
+      <tr>
+        <td><tt>-target_tag</tt>
+      </td>
+      <td>any</td>
+        <td>construct a specific tag named
+        <tt>target_&lt;constituent&gt;</tt>
+        . This tag will
+                          only be active during the make session for this
+                            constituent. <a href="#the target tag option"><tt>(4)</tt>
+        </a>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>-windows</tt>
+      </td>
+      <td>applications</td>
+      <td>When used in a Windows environment, generates a GUI-based application (rather than a console application) </td>
+    </tr>
+      <tr>
+        <td><tt>&lt;var-name&gt;=&lt;var-value&gt;</tt>
+      </td>
+      <td>any</td>
+          <td>define a variable and its value to be given to the make fragment <a href="#variable-name option"><tt>(3)</tt>
+        </a>
+      </td>
+    </tr>
+  </table>
+</center>
+  <ol>
+    <li><a name="source selection and exclusion"></a>
+      <p>The sources of the constituents are generally
+                      specified as a set of file names with their suffixes,
+                      and are by default expected from the <tt>../src</tt>
+                    directory</p>
+<pre class="cmt">
+library A A.cxx B.cxx</pre>
+      <p>Then it is possible to change the default search
+                      location as well as to use a simplified wildcarding
+                    syntax:</p>
+<pre class="cmt">
+library A -s=A *.cxx -s=B *.cxx</pre>
+      <ul>
+        <li><tt>-s=A</tt>
+         means that next source files
+                          should be taken searched from <tt>../src/A</tt>
+      </li>
+        <li><tt>-s=B</tt>
+         means that next source files
+                          should be taken searched from
+        <tt>../src/B</tt>
+        . Note that this new specification
+                          is <i>not</i>
+         relative to the previous <tt>-s=A</tt>
+                          but relative to the default search path
+        <tt>../src</tt>
+      </li>
+        <li><tt>*.cxx</tt>
+         indicates that all files with a
+        <tt>.cxx</tt>
+         suffix in the current search path
+                          should be considered
+      </li>
+    </ul>
+      <p>It's also possible to select or exclude files using
+                      regular expressions from general wildcarding
+                    techniques:</p>
+<pre class="cmt">
+library A -s=A -x=[0-9] *.cxx -s=B -k=^B *.cxx</pre>
+      <ul>
+        <li>The exclusion specification <tt>-x=[0-9]</tt>
+                          added to the statement will exclude all files
+                          from <tt>../src/A</tt>
+         containing a <i>number</i>
+       in their name.</li>
+        <li>The selection specification <tt>-k=^B</tt>
+         added
+                          to the statement will select files from
+        <tt>../src/B</tt>
+         strictly starting with the
+        <tt>B</tt>
+       letter.</li>
+    </ul>
+    <p></p>
+  </li>
+    <li><a name="suffix option"></a>
+      <p>When several constituents need to share source
+                      files, (a typical example is for building different
+                      libraries from the same sources but with different
+                      compiler options), it is possible to specify an
+                      optional output suffix with the
+      <tt>-suffix=&lt;suffix&gt;</tt>
+       option. With this
+                      option, every object file name will be automatically
+                      suffixed by the character string
+                      "<tt>&lt;suffix&gt;</tt>
+      ", avoiding name conflicts
+                      between the different targets, as in the following
+                    example:</p>
+<pre class="cmt">
+library AXt  -suffix=Xt  *.cxx
+library AXaw -suffix=Xaw *.cxx</pre>
+  </li>
+    <li><a name="variable-name option"></a>
+      <p>It's possible to specify in the list of parameters
+                      one or more pairs of
+      <tt>variable-name</tt>
+      =<tt>variable-value</tt>
+       (without
+                        any space characters around the<tt><tt>"="</tt>
+      </tt>
+                    character), such as in the next example:</p>
+<pre class="cmt">
+make_fragment doc_to_html                             (1)
+
+document doc_to_html Foo output=FooA.html FooA.doc    (2) (3)</pre>
+      <ol>
+        <li>This makefile fragment is meant to contain some text
+                          conversion actions and defines a <a href="#Defining a                   document generator"> document type</a>
+         named
+        <tt>doc_to_html</tt>
+      .</li>
+        <li>This constituent exploits the document type
+        <tt>doc_to_html</tt>
+         to convert the source <tt>FooA.doc</tt>
+                        into an html file.</li>
+        <li>The user defined template variable named <tt>output</tt>
+                          is specified and assigned the value <tt>FooA.html</tt>
+        . If the
+                          fragment <tt>doc_to_html</tt>
+         contains the string
+        <tt>${output}</tt>
+        , then it will be substituted to
+                        this value.</li>
+    </ol>
+    <p></p>
+  </li>
+    <li><a name="the target tag option"></a>
+      <p>For any constituent that has the
+      <tt>-target_tag</tt>
+       option set, a dedicated
+      <i>tag</i>
+       named <tt>target_&lt;constituent&gt;</tt>
+                      is automatically constructed by CMT. This tag becomes
+                      active during the construction of this constituent
+                      when using <tt>make</tt>
+      , and therefore can be used as
+                      any other tag to select symbol values, or other
+                    configuration parameters.</p>
+  </li>
+</ol>
+</blockquote>
+<hr><h4><a name="Groups"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;5</tt></a> - Groups</h4>
+<blockquote>
+            Groups permit the organization of the constituents that must
+            be consistently built at the same development phases or with similar
+            constraints.
+  <p>Each group is associated with a make target (of the same
+                name) which, when used in the make command, selectively
+              rebuilds all constituents of this group.</p>
+  <p>The default group (into which all constituents are
+                installed by default) is named <tt>all</tt>
+  , therefore,
+                running make without argument, activates the default target
+                (ie. <tt>all</tt>
+).</p>
+  <p>As a typical usage of this mechanism, one may examplify the
+                case in which one or several constituents are making use of
+                one special facility (such as a database service, real-time
+                features, graphical libraries) and therefore might require a
+                controled re-build. This is especially useful for having these
+                constituents only rebuilt on demand rather than rebuilt
+              automatically when the default make command is run.</p>
+<p>One could, for instance specify within the requirements file :</p>
+<pre class="cmt">
+# Constituents belonging to the default <i>all</i> group
+
+<i>... constituents without group specification ...</i>
+library Foo *.cxx
+
+# Constituents belonging to specific groups
+
+library Foo-objy -group=objy &lt;<i>sources making use of Objectivity</i>&gt;
+
+application FooGUI -group=graphics &lt;<i>sources making use of Qt</i>&gt;
+application BarGUI -group=graphics &lt;<i>sources making use of Qt</i>&gt;
+</pre>
+  <i>(Beware of the position of the -group option which must be
+                located after the constituent name. Any other position will be
+              misunderstood by CMT)</i>
+  <p>Then, running <tt>gmake all</tt>
+   would only rebuild the un-grouped
+              constituents, whereas running</p>
+<pre>
+&gt; gmake objy
+&gt; gmake graphics</pre>
+  <p>in the context of the <tt>Foo</tt>
+   package would rebuild <i>objy</i>
+                related or <i>graphics</i>
+ related constituents.</p>
+</blockquote>
+<hr><h4><a name="Languages"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;6</tt></a> - Languages</h4>
+<blockquote>
+            Some computer languages are known by default by <tt>CMT</tt>
+            (<tt>C</tt>
+, <tt>C</tt>
+++, <tt>Fortran77</tt>
+, <tt>Java</tt>
+,
+<tt>lex</tt>
+, <tt>yacc</tt>
+). However it is possible to extend
+            this knowledge to any other langage.
+  <p>We consider here languages that are able to produce object
+              files from sources.</p>
+  <p>Let's take an example. We would like to install support for
+                Fortran90. We first have to <i>declare</i>
+   this new language
+                support to <tt>CMT</tt>
+   within the <tt>requirements</tt>
+   file of
+                one of our packages (Notice that it's not at all required to
+                modify <tt>CMT</tt>
+   itself since all clients of the selected
+              package will inherit the knowledge of this language).</p>
+  <p>The language support is simply named <tt>fortran90</tt>
+   and is
+              declared by the following statement:</p>
+<pre class="cmt">
+language fortran90 \
+  -suffix=f90 -suffix=F90 \             [1]
+  -linker=$(f90link) \                  [2]
+  -preprocessor_command=$(ppcmd)</pre>
+  <ol>
+    <li>The recognized suffixes for source files will be <tt>f90</tt>
+     and <tt>F90</tt>
+  </li>
+    <li>The linker command used to build a Fortran90 application
+                  is described inside the macro named <tt>f90link</tt>
+     (which
+                  must defined in this requirements file but which can also be
+                overridden by clients)</li>
+</ol>
+  <p>The language support being named <tt>fortran90</tt>
+  , two
+              associated make fragments are expected, one under the name
+  <tt>fortran90</tt>
+   (for building application modules), the
+              other with the name <tt>fortran90_library</tt>
+   (for modules
+            meant to be archived), both without extension.</p>
+  <p>These two fragments should be installed in the
+  <tt>fragments</tt>
+   sub-directory of the cmt branch of our
+            package.</p>
+  <p>Due to the similarity of the example to fortran77, we
+              may easily provide the expected fragments simply by
+              copying the f77 fragments found in <tt>CMT</tt>
+   (thus the
+              fragments <tt>${CMTROOT}/fragments/fortran</tt>
+   and
+  <tt>${CMTROOT}/fragments/fortran_library</tt>
+</p>
+  <p>These fragments make use of the <tt>fcomp</tt>
+   macro,
+              which holds the fortran77 compiler command (through the
+  <tt>for</tt>
+ macro).</p>
+<pre class="cmt">
+macro for             "f77" \
+...
+macro fcomp           "$(for) -c $(fincludes) $(fflags) $(pp_fflags)"</pre>
+  <p>We therefore simply replace these macros by new macros
+              named <tt>f90comp</tt>
+   and <tt>f90</tt>
+  , defined as
+            follows:</p>
+<pre class="cmt">
+macro f90             "f90"
+...
+macro f90comp         "$(f90) -c $(fincludes) $(fflags) $(pp_fflags)"</pre>
+  <p>Some languages (this has been seen for example in the
+              IDL generators in Corba environments) do provide several
+              object files from one unique source file. It is possible
+              to specify this feature through the (repetitive)
+  <tt>-extra_output_suffix</tt>
+ option like in:</p>
+<pre class="cmt">
+language idl -suffix=idl -fragment=idl -extra_output_suffix=_skel</pre>
+            where, in this case, two object files are produced for each
+              IDL source file, one named <tt>&lt;<i>name</i>
+&gt;.o</tt>
+ the
+              other named <tt>&lt;<i>name</i>
+&gt;_skel.o</tt>
+.
+</blockquote>
+<hr><h4><a name="Symbols"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;7</tt></a> - Symbols</h4>
+<blockquote>
+  <p>This is a generic concept supporting the notion of
+              valued symbols. Several alternate semantics are
+              implemented by these symbols, all specified using the
+              same syntactic schema, but leading to different behaviours
+            or interpretations by CMT:</p>
+  <ul>
+    <li>The <tt>set</tt>
+     keyword is translated into an environment
+                variable definition.</li>
+    <li>The <tt>macro</tt>
+     keyword is translated into a
+    <tt>make</tt>
+  's macro definition.</li>
+    <li>The <tt>path</tt>
+     keyword is translated into a
+                  prioritized <i>path</i>
+    -like environment variable, which
+                  is supposed to be composed of search paths separated
+                  with colon characters <tt>':'</tt>
+     (on Unix) or semi-colon
+                  characters <tt>';'</tt>
+     (on Windows). It is generally
+                  recommended to construct such a variable by iteratively
+                  concatenating individual items one by one using
+    <tt>path_append</tt>
+     or <tt>path_prepend</tt>
+  </li>
+    <li>The <tt>action</tt>
+     keyword is translated into a shell
+                  command definition, that can be activated using the
+    <tt>cmt do &lt;action&gt;</tt>
+     command or the associated
+    <tt>make</tt>
+   target.</li>
+    <li>The <tt>alias</tt>
+     keyword is translated into a shell alias
+                definition, </li>
+</ul>
+  <p>Variants of these keywords are also provided for
+              modifying already defined symbols. This generally happens
+              when a package needs to modify (append, prepend or
+              subtract) an inherited symbol (ie. which has been already
+            defined by a used package).</p>
+  <p>The translations occur while running either the setup
+                scripts (for alias, set or path) or the make command (for
+              macro and actions).</p>
+<p>All these definitions follow the same pattern:</p>
+<center>
+<table cols="3">
+<tr>
+<td></td>
+<td width="10"></td>
+<td></td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwsymbol-symbol"></a>symbol</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+symbol-type
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+symbol-name
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+default-value
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-expr
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwsymbol-symbol-type"></a>symbol-type</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+definition
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+modification
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwsymbol-definition"></a>definition</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+set
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+path
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+action
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+alias
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwsymbol-modification"></a>modification</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro_prepend
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+macro_append
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove_regexp
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove_all
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove_all_regexp
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+set_prepend
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+set_append
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+set_remove
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+set_remove_regexp
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+path_prepend
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+path_append
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+path_remove
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+path_remove_regexp
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwsymbol-tag-expr"></a>tag-expr</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+tag
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#FF0000">
+&
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+tag
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+</table>
+</center>
+<p></p>
+  <ul>
+    <li>The symbol-name identifies the symbol.<p></p>
+  </li>
+    <li>Values are generally quoted strings (using either
+                  simple or double quotes). They may be unquoted only if
+                  they are composed of one single non-empty word, since
+                  the general syntax parsing relies on space separated
+                  words.<p></p>
+  </li>
+    <li> The default-value is mandatory (although it can be
+                  an empty string) optionally followed by a set of
+                  tag/value pairs, each representing an alternate value
+                  for this symbol.<p></p>
+  </li>
+    <li>Each tag-value pair describes an alternate value to
+                  be used when the corresponding tag or tag-expression is
+                  active.<p></p>
+  </li>
+    <li>When several alternate values are specified through
+                  several tag-value pairs the <i>first</i>
+     matching
+                  condition is selected. Therefore one should always
+                  specify the most contraining condition first.<p></p>
+  </li>
+    <li>The removal operations can be specified using either
+                  plain sub-strings or regular rexpressions. One should
+                  notice that even for the <tt>path_remove_regexp</tt>
+                  operation, full regular expression are expected rather
+                  than file-system wild carding syntaxes.<p></p>
+  </li>
+    <li>The <tt>path_remove</tt>
+     keyword is slightly
+                  specialized since it removes all individual search paths
+                  that <i>contain</i>
+     the specified sub-string.<p></p>
+  </li>
+</ul>
+  <p>Be aware that there is only one name space for
+              all kinds of symbols. Therefore, if a symbol was originally
+              defined using a <tt>macro</tt>
+   statement, using
+  <tt>set_append</tt>
+   to modify it will produce an undefined
+            result (and a warning message).</p>
+  <p>The <a href="#tag, apply_tag">tag</a>
+   expression is
+              used to select one alternate value to replace the default
+            value, using the following matching rule:</p>
+  <ul>
+    <li>The first matching condition in the ordered list of
+                  alternate values is selected, ignoring the following
+                ones</li>
+    <li>A tag expression matches when all tags in the
+                expression are active.</li>
+</ul>
+<p>Examples of such definition are : </p>
+<pre class="cmt">
+package CMT 
+
+macro cflags          "" \
+      LynxOS-VGPW2    "-X" \
+      insure          "-std1" \
+      HP-UX           "+Z" \
+      hp700_ux101     "-fpic -ansi" \
+      alpha           "-std1" \
+      alphat          "-std1" \
+      SunOS           "-KPIC" \
+      WIN32           '/nologo /DWIN32 /MD /W3 $(includes) /c'
+
+macro pp_cflags       "" \
+      LynxOS-VGPW2    "-DVGPW2" \
+      HP-UX           "-D_HPUX_SOURCE" \
+      alphat          "-DCTHREADS" \
+      AIX             "-D_ALL_SOURCE -D_BSD" \
+      Linux           "-Di586"
+
+macro ccomp           "$(cc) -c $(includes) $(cdebugflags) $(cflags) $(pp_cflags)" \
+      VisualC         "cl.exe $(cdebugflags) $(cflags) $(pp_cflags)"
+
+macro clinkflags      ""
+
+macro clink           "$(cc) $(clinkflags)" \
+      VisualC         "link.exe /nologo /machine:IX86 "
+</pre>
+<hr><h5><a name="actions"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;7.&nbsp;1</tt></a> - actions</h5>
+<blockquote>
+              Actions are one of the possible symbols. Their
+              definition as said previously follow the generic
+              conventions for any symbol type, and they implement the
+              concept of a generic shell command.
+<p>An example of a symple action:</p>
+<pre class="cmt">
+action directory "ls $(dir_options)" WIN32 "dir $(dir_options)"</pre>
+  <p>Like other symbols, actions can be visualized using
+                the <tt>cmt show actions</tt>
+     or the <tt>cmt show action
+  &lt;name&gt;</tt>
+ command.</p>
+  <p>Some specialized mechanims are available on actions,
+                in order to execute in various ways the corresponding
+              shell commands.</p>
+<p>Actually two operating modes are supported:</p>
+  <ol>
+    <li>Immediate mode
+      <p>This can be done via the <tt>cmt do</tt>
+     command:</p>
+<pre>&gt; cmt &lt;action-name&gt;</pre>
+    <p>or, when the action name conflicts with a native CMT keyword, </p>
+<pre>&gt; cmt do &lt;action-name&gt;</pre>
+      <p>This mode immediately executes the specified
+                        command, after locally setting all environment
+                      variables known from the current package.</p>
+  </li>
+    <li>Through <tt>make</tt>
+<pre>
+&gt; cmt make &lt;action-name&gt;</pre>
+      <ul>
+        <li>Actions are always associated with a make
+                          target of the same name</li>
+        <li>Action are always defined under a constituent
+        <a href="#Groups">group</a>
+         named
+        <tt>cmt_actions</tt>
+        . This means that action
+                            targets are never activated by default. Instead
+                            they must be explicitly called.
+      </li>
+        <li>Action targets can be made dependent to other
+                            make targets (or vice versa), similarly to other
+                            constituents (libraries, applications, documents),
+                            using the <tt>&lt;name&gt;_dependencies</tt>
+                            macro.
+        <p>Example 1</p>
+<pre class="cmt">
+library A ...
+action B ...
+macro B_dependencies " A "</pre>
+                            In this example when doing <tt>gmake B</tt>
+        , the
+                            library <tt>A</tt>
+         will be rebuilt first.
+        <p>Example 2</p>
+<pre class="cmt">
+library A ...
+action B ...
+macro A_dependencies " B "</pre>
+                            In this example when doing <tt>gmake A</tt>
+         (or
+                            simply <tt>gmake</tt>
+        ), the action <tt>B</tt>
+         will
+                            be executed first.
+      </li>
+    </ul>
+  </li>
+</ol>
+</blockquote>
+</blockquote>
+<hr><h4><a name="use"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;8</tt></a> - use</h4>
+<blockquote>
+  <p>Describe the relationships with other packages; the
+            generic syntax is :</p>
+<pre class="cmt">
+use &lt;package&gt; [ &lt;version&gt; [ &lt;offset&gt; ] ] [ -no_auto_imports=&lt;package&gt; ... ]</pre>
+  <p>Omitting the version specification means that the most
+              recent version (ie. the one with highest ids) that can be
+              found from the search path list will be automatically
+            selected.</p>
+  <p> The <i>offset</i>
+   specification can be relative
+              (i.e. on Unix it does not contain a leading '/'
+              character). In this case, this offset is systematically
+              considered when the package is looked for in the search
+              path list. But it can also be absolute (ie. with a leading
+              '/' character on Unix), in which case this path takes
+              precedence over the standard search path list (see
+            CMTPATH).</p>
+  <p>The additional <tt>-no_auto_imports</tt>
+   options
+              suppress the automatic inheritance of some standard
+              parameters from the specified used packages, such as
+            include paths, compiler flags, ... </p>
+<p> Examples of such relationships are :</p>
+<pre class="cmt">
+use OnX v5r2 
+use CSet v2r3 
+use Gb v2r1 
+
+# A package installed in a sub-directory one step below the root : 
+use CS v3r1 virgo 
+
+# Back to the default root : 
+use Cm v7r3 
+
+# Get the most recent version of CERNLIB
+use CERNLIB</pre>
+  <p>By default, a set of standard macros, which are
+              expected to be specified by used packages, is
+              automatically imported from them (see the <A HREF="#Package customizing macros">detailed list</A>
+   of
+              these macros). This automatic feature can be discarded
+              using the <tt>-no_auto_imports</tt>
+   option to the use
+              statement, or re-activated using the
+  <tt>-auto_imports</tt>
+  . When it is discarded, the macros
+              will not be transparently inherited, but rather, each
+              individual constituent willing to make use of them will
+              have to explicitly import them using the
+    <tt>-import=&lt;<i>package</i>
+  &gt;</tt>
+  <a href="#constituents">option</a>
+.</p>
+  <p>When a <tt>use</tt>
+     statement is in a <a href="#public, private"><tt>private</tt>
+  </a>
+              section, the corresponding used package will only be
+              reached if when <tt>CMT</tt>
+   operations occur in the context
+              of the holder package. Otherwise (ie if the operation
+              occurs in some upper level client package), then this
+  <i>privately</i>
+   used package will be entirely
+                hidden. (<i>This behaviour follows a very similar pattern
+              to the private or public inheritance of C++</i>
+  ). Suppose
+            we have the following organization:</p>
+<pre class="cmt">
+----------------
+package A
+
+use B v1
+use D v1
+----------------
+
+----------------
+package B
+
+private
+use C v1
+use D v1
+----------------
+</pre>
+  <ul>
+    <li> all operations done in the context of package B will <i>see</i>
+   both packages C and D</li>
+    <li> all operations done in the context of package A will <i>see</i>
+   both packages B and D, but not package C</li>
+</ul>
+</blockquote>
+<hr><h4><a name="patterns"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;9</tt></a> - patterns</h4>
+<blockquote>
+  <p>Often, similar configuration items are needed over a
+              set of packages (sometimes over all packages of a
+              project). This reflects either similarities between
+              packages or generic conventions established by a project
+            or a team.</p>
+  <p>Typical examples are the definition of the search path
+              for shared libraries (through the <tt>LD_LIBRARY_PATH</tt>
+              environment variable), the systematic production of test
+            applications, etc.</p>
+  <p>The concept of pattern proposed here implements this
+              genericity. Patterns may be either <i>global</i>
+  , in which
+              case they will be systematically applied onto every
+              package, or <i>local</i>
+   (the default) in which case they
+            will be applied on demand only by each package.</p>
+  <p>The general principle of a pattern is to associate a
+              templated (set of) <tt>cmt</tt>
+   statement(s) with the
+              pattern name. Then every time the pattern is applied, its
+              associated statements are applied as if they were directly
+              specified in the requirements file, replacing the template
+              with its current value. If several statements are to be
+              associated with a given pattern, they will be separated
+              with the <tt>" ; "</tt>
+   separator pattern (beware of really
+              enclosing the <tt>;</tt>
+   character between two space
+            characters).</p>
+  <p>The general syntax for defining a pattern in a
+	    requirements file is:</p>
+<center>
+<table cols="3">
+<tr>
+<td></td>
+<td width="10"></td>
+<td></td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwpattern-pattern"></a>pattern</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+pattern
+</font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#FF0000">
+-global
+</font>
+&nbsp;]&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+pattern-name
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwpattern-cmt-statement">cmt-statement</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#FF0000">
+ ; 
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwpattern-cmt-statement">cmt-statement</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+</table>
+</center>
+  <p>Pattern templates are names enclosed between the
+  <tt>&lt;</tt>
+   and <tt>&gt;</tt>
+   characters. A set of
+              predefined templates are automatically provided by
+  <tt>CMT</tt>
+:</p>
+  <p>
+    <center>
+      <table cellspacing="0" BORDER="1" COLS="2">
+        <tr>
+          <td width="80"><tt>package</tt>
+        </td>
+        <td width="300">the name of the current package</td>
+      </tr>
+        <tr>
+          <td><tt>PACKAGE</tt>
+        </td>
+        <td>the name of the current package in upper case</td>
+      </tr>
+        <tr>
+          <td><tt>version</tt>
+        </td>
+        <td>the version tag of the current package</td>
+      </tr>
+        <tr>
+          <td><tt>path</tt>
+        </td>
+        <td>the access path of the current package</td>
+      </tr>
+        <tr>
+          <td><tt>project</tt>
+        </td>
+        <td>the project name of the current package</td>
+      </tr>
+    </table>
+  </center>
+</p>
+  <p>Then, in addition, user defined templates can be installed
+                within the pattern definitions. Their actual value will be
+              provided as arguments to the apply_pattern statement.</p>
+  <p>User defined templates that have not been assigned a
+              value when the pattern is applied are simply ignored
+            (ie. replaced with an empty string).</p>
+<p>Some examples:</p>
+  <ol>
+    <li>
+    <p>Changing the standard include search path.</p>
+      <p>The standard include path is set by default to
+      <tt>${&lt;package&gt;_root}/src</tt>
+      . However, often projects
+                        need to override this default convention, and typical
+                        example is to set it to a branch named with the package
+                        name. This convention is easily applied by defining a
+                        pattern which will apply the include_path statement as
+                      follows:</p>
+<pre class="cmt">
+pattern -global include_path include_path ${&lt;package&gt;_root}/&lt;package&gt;/</pre>
+      <p>For instance, a package named <tt>PackA</tt>
+       will expand this
+                      pattern as follows:</p>
+<pre class="cmt">
+include_path ${PackA_root}/PackA/</pre>
+  </li>
+    <li>
+      <p>Providing a value to the <tt>LD_LIBRARY_PATH</tt>
+     environment variable</p>
+      <p>On some operating systems (eg. Linux), shared library
+                        paths must be explicited, through an environment
+                      variable. The following pattern can automate this operation:</p>
+<pre class="cmt">
+pattern ld_library_path \
+  path_remove LD_LIBRARY_PATH "/&lt;package&gt;/" ; \
+  path_append LD_LIBRARY_PATH ${&lt;PACKAGE&gt;ROOT}/${CMTCONFIG}</pre>
+      <p>In this example, the pattern was not set global, so
+                        that only packages actually providing shared libraries
+                        would be concerned. These packages will simply have to
+                      apply the pattern as follows:</p>
+<pre class="cmt">
+apply_pattern ld_library_path</pre>
+      <p>The schema installed by this pattern provides first a
+                        cleanup of the <tt>LD_LIBRARY_PATH</tt>
+       environment variable
+                        and then the new assignment. This choice is useful in this
+                        case to avoid conflicting definitions from two different
+                      versions of the same package.</p>
+  </li>
+    <li>
+    <p>Installing a systematic test application in all packages</p>
+      <p>Quality assurance requirements might specify that every
+                        package should provide a test program. One way to enforce
+                        this is to build a global pattern declaring this
+                        application. Then every make command would naturally
+                      ensure its actual presence.</p>
+<pre class="cmt">
+pattern quality_test application &lt;package&gt;test &lt;package&gt;test.cxx &lt;other_sources&gt;</pre>
+      <p>In this example, an additional pattern
+                        (&lt;other_sources&gt;) permits the package to specify
+                        extra source files to the test application (the pattern
+                      assumes at least one source file &lt;package&gt;test.cxx).</p>
+  </li>
+</ol>
+<hr><h5><a name="Applying a pattern"></a><a href="#index"><tt>13.&nbsp;2.&nbsp;9.&nbsp;1</tt></a> - Applying a pattern</h5>
+<blockquote>
+              According to whether the <tt>-global</tt>
+ qualifier was
+              used in the pattern definition, the aplication mode will
+              be completely different.
+  <ol>
+    <li><i>Normal patterns</i>
+      <p>Such patterns must be applied explicitly using
+                        the <tt>apply_pattern</tt>
+     construct</p>
+      <p>Doing so, it is possible to specify custmization
+                      values for user defined template parameters</p>
+<pre class="cmt">
+pattern TA macro &lt;base&gt;AAA "AAA"
+
+apply_pattern TA base=abc
+apply_pattern TA base=def</pre>
+      <p>In the <tt>apply_pattern</tt>
+       syntax, it is even
+                        possible to simply <i>ommit</i>
+       the keyword itself,
+                        and thus using the pattern name as a plain CMT
+                      keyword. The previous example becomes: </p>
+<pre class="cmt">
+TA base=abc
+TA base=def</pre>
+      <p>This can be seen as a way to <i>extend</i>
+       the
+                        CMT language. Notice that there is a risk of a
+                        conflict between the primary CMT keywords and
+                        pattern names then. Suppose that a pattern name is
+                        defined to be exactly a primary CMT keyword. In this
+                        case, the syntax parser will always understand this
+                        name as the CMT primary keyword, and thus won't
+                        override the original syntax. When this (not
+                        recommended) situation occurs, it is therefore
+                        required to use the full notation with an explicit
+      <tt>apply_pattern</tt>
+       keyword, so as to avoid any
+                      possible ambiguity.</p>
+  </li>
+    <li><i>Global patterns</i>
+     (ie when the <tt>-global</tt>
+     qualifier is used
+      <p>In this case, the pattern is automatically applied
+                        to <i>all</i>
+       packages that effectively see the
+                        pattern definition, which includes all clients of
+                      the package defining the pattern.</p>
+      <p>Another consequence of the automatic application
+                        of the pattern, is that it is not possible to give
+                        values to parameters. Therefore it is not
+                        recommended to design global patterns with user
+                      defined parameters.</p>
+      <p>Conversely it is possible to inhibit the
+                        automatic application of a global pattern in a
+                        particular package by using the following
+                      statement:</p>
+<pre class="cmt">
+ignore_pattern &lt;name&gt;</pre>
+  </li>
+</ol>
+</blockquote>
+</blockquote>
+<hr><h4><a name="cmtpath_patterns"></a><a href="#index"><tt>13.&nbsp;2.10</tt></a> - cmtpath_patterns</h4>
+<blockquote>
+  <p>These patterns act quite similarly to the <i>global</i>
+  	    patterns previously described, ie they defines a set of
+  	    CMT statements to be applied in a generic way. The
+  	    difference is that instead of being applied to
+  <i>packages</i>
+  , they are automatically applied to all
+  	    entries in the <tt>CMTPATH</tt>
+ list.</p>
+  <p>Only few system parameters can be used here:
+    <ul>
+      <li><tt>&lt;path&gt;</tt>
+       which stands for any entry
+                    in the CMTPATH list.</li>
+      <li><tt>&lt;project&gt;</tt>
+       which stands for the
+                      project name associated with an entry in the CMTPATH
+                    list.</li>
+  </ul>
+</p>
+<p>As an example suppose we define</p>
+<pre class="cmt">
+path        CMTPATH "/ProjectA"
+path_append CMTPATH "/ProjectB"
+
+cmtpath_pattern \
+  macro_prepend pp_cppflags " -I&lt;path&gt;/InstallArea/include "</pre>
+  <p>this will assemble one <tt>-I</tt>
+   option (towards the
+  	    preprocessor) per entry in CMTPATH, implementing a
+  	    mechanism for a multiple installation area for header
+  	    files. In the example above the resulting macro will
+	    be</p>
+<pre>
+ -I/ProjectA/InstallArea/include -I/ProjectB/InstallArea/include </pre>
+  <p>
+  	    This can be combined with the standard and 
+  <a href="#Generated macros">automatic macros</a>
+  	    (automatically setup for all used packages)
+<pre class="cmt">
+&lt;package&gt;_cmtpath
+&lt;package&gt;_offset</pre>
+  	    which provide the CMTPATH entry and the directory offset
+  	    in this CMTPATH for all used packages.
+</p>
+</blockquote>
+<hr><h4><a name="branches"></a><a href="#index"><tt>13.&nbsp;2.11</tt></a> - branches</h4>
+<blockquote>
+  <p>Describe the specific directory branches to be added while
+              configuring the package.</p>
+<pre class="cmt">
+branches &lt;branch-name&gt; ... </pre>
+  <p> These branches will be created (if needed) at the same
+                level as the <tt>cmt</tt>
+   branch. Typical examples of such
+                required branches may be <tt>include</tt>
+  , <tt>test</tt>
+   or
+  <tt>data</tt>
+.</p>
+</blockquote>
+<hr><h4><a name="Strategy specifications"></a><a href="#index"><tt>13.&nbsp;2.12</tt></a> - Strategy specifications</h4>
+<blockquote>
+  <p>Users can control the behaviour of <tt>CMT</tt>
+   through a
+              set of strategy specifications. The current implementation
+            provides such control over several aspects :</p>
+  <ol>
+    <li>
+    <p>The build strategy</p>
+      <p>This controls some aspects of the building
+                    process. </p>
+    <p>The following keywords are available:</p>
+      <p>
+        <center>
+          <table cellspacing="0" BORDER="1" COLS="2">
+            <tr>
+              <td width="80"><tt>prototypes</tt>
+            </td>
+              <td width="500">C source files will
+                          automatically produce a header file containing
+                                    a prototype of all global entry points</td>
+          </tr>
+            <tr>
+              <td width="80"><tt>no_prototypes</tt>
+            </td>
+              <td width="500">No production of automatic
+                                    prototype header files for C sources</td>
+          </tr>
+            <tr>
+              <td width="80"><tt>with_installarea</tt>
+            </td>
+              <td width="500">The installation area
+                                      mechanisms are activated. This implies
+                                      applying the cmtpath_patterns that may be
+                                    defined (eg in CMT itself)</td>
+          </tr>
+            <tr>
+              <td width="80"><tt>without_installarea</tt>
+            </td>
+              <td width="500">The installation area
+                                    mechanisms are inhibited</td>
+          </tr>
+        </table>
+      </center>
+    </p>
+  </li>
+    <li>
+    <p>The setup strategy</p>
+      <p>This controls various actions that may be performed
+    		during the sourcing of the setup scripts.</p>
+    <p>The following keywords are available:</p>
+      <p>
+        <center>
+          <table cellspacing="0" BORDER="1" COLS="2">
+            <tr>
+              <td width="80"><tt>config</tt>
+            </td>
+              <td width="500">An environment variable
+              &lt;PACKAGE&gt;CONFIG will be generated for all
+                                    packages in the dependency chain</td>
+          </tr>
+            <tr>
+              <td width="80"><tt>no_config</tt>
+            </td>
+              <td width="500">The &lt;PACKAGE&gt;CONFIG
+                                    environment variable is not generated </td>
+          </tr>
+            <tr>
+              <td width="80"><tt>root</tt>
+            </td>
+              <td width="500">An environment variable
+              &lt;PACKAGE&gt;ROOT will be generated for all
+                                    packages in the dependency chain</td>
+          </tr>
+            <tr>
+              <td width="80"><tt>no_root</tt>
+            </td>
+              <td width="500">The &lt;PACKAGE&gt;ROOT
+                                    environment variable is not generated </td>
+          </tr>
+            <tr>
+              <td width="80"><tt>cleanup</tt>
+            </td>
+              <td width="500">The automatic cleanup
+                                      operation to the current installation
+                                    area is launched</td>
+          </tr>
+            <tr>
+              <td width="80"><tt>no_cleanup</tt>
+            </td>
+              <td width="500">The automatic cleanup
+                                      operation to the current installation
+                                    area is not launched</td>
+          </tr>
+        </table>
+      </center>
+    </p>
+  </li>
+</ol>
+  <p>The strategy specifications are setup on a per-project
+              basis. This means that they are generally applicable to
+              all packages of a given sub-project, and can be oerridden
+            in other sub-projecs of the same software base.</p>
+  <p>Every strategy setting defines two mutually exclusive
+            tags and activates one of them.</p>
+<pre class="cmt">
+&lt;project&gt;_&lt;have_item&gt; 
+&lt;project&gt;_&lt;have_not_item&gt; </pre>
+            Examples 
+<pre class="cmt">
+&lt;project&gt;_prototypes
+&lt;project&gt;_no_prototypes
+&lt;project&gt;_with_install_area
+&lt;project&gt;_without_install_area
+&lt;project&gt;_config
+&lt;project&gt;_no_config
+&lt;project&gt;_root
+&lt;project&gt;_no_root
+&lt;project&gt;_cleanup
+&lt;project&gt;_no_cleanup</pre>
+</blockquote>
+<hr><h4><a name="setup_script, cleanup_script"></a><a href="#index"><tt>13.&nbsp;2.13</tt></a> - setup_script, cleanup_script</h4>
+<blockquote>
+  <p>Specify user defined configuration scripts, which will be
+                activated together with the execution of the main
+  <tt>setup</tt>
+   and <tt>cleanup</tt>
+ scripts.</p>
+  <p> The script names may be specified without any access path
+                specification, in this case, they are looked for in the
+  <tt>cmt</tt>
+   or <tt>mgr</tt>
+   branch of the package
+                itself. They may also be specified without any <tt>.csh</tt>
+                or <tt>.sh</tt>
+   suffix, the appropriate suffix will be
+                appended accordingly when needed. Therefore, when such a user
+                configuration script is specified, <tt>CMT</tt>
+   expects that
+                the corresponding shell scripts actually exist in the
+                appropriate directory (the <tt>cmt</tt>
+   branch by default) and
+                is provided in whatever format is appropriate (thus suffixed
+                by <tt>.csh</tt>
+   and/or <tt>.sh</tt>
+).</p>
+</blockquote>
+<hr><h4><a name="include_path"></a><a href="#index"><tt>13.&nbsp;2.14</tt></a> - include_path</h4>
+<blockquote>
+  <p>Override the specification for the default include search
+                path, which is internally set to<br></br>
+    <tt>${&lt;<i>package</i>
+  &gt;_root}/src</tt>
+.</p>
+    <p>Specifying the value <tt><i>none</i>
+  </tt>
+   (a reserved
+              CMT keyword) means that no default include search path is
+              expected from CMT, and thus no <tt>-I</tt>
+   compiler option
+              will be generated by default (generally this means that
+              user include search paths should be specified via explicit
+  <tt>include_dirs</tt>
+ instead).</p>
+    <blockquote><i>
+      <p>Note that this behaviour is expected to become
+                    obsolete in some next release of CMT. The default
+                    include search path of <tt>../src</tt>
+       will then simply
+            disappear, and the <tt>include_path</tt>
+       statement will
+                    become meaningless. When this happens, include search
+                    paths will always have to be explicitly specified using the
+      <tt>include_dirs</tt>
+       statement. In order to anticipate
+                    this evolution, it is suggested to always use
+      <tt>include_path none</tt>
+       and add all include search
+                    directories using the <tt>include_dirs</tt>
+                  statement.</p>
+  </i>
+</blockquote>
+</blockquote>
+<hr><h4><a name="include_dirs"></a><a href="#index"><tt>13.&nbsp;2.15</tt></a> - include_dirs</h4>
+<blockquote>
+  <p>Add explicit specifications for include access
+              paths. The value may be provided through a macro
+            reference.</p>
+<p>The statement is sensitive to private scoping.</p>
+</blockquote>
+<hr><h4><a name="make_fragment"></a><a href="#index"><tt>13.&nbsp;2.16</tt></a> - make_fragment</h4>
+<blockquote>
+  <p>This statement specifies a specialized makefile fragment,
+                used as a building brick to construct the final makefile
+              fragment dedicated to build the constituents.</p>
+  <p>There are basically three categories of such fragments :
+    <ol>
+      <li>some are provided by <tt>CMT</tt>
+       itself (they
+                      correspond to its        internal behaviour)</li>
+    <li>others handle the language support</li>
+    <li>and the        last serve as specialized document generators.</li>
+  </ol>
+</p>
+  <p>The fragments defined in <tt>CMT</tt>
+ can be:</p>
+  <ul>
+    <li> those used to construct the application or library
+                    constituents. Their semantic is 
+                    standardized (they are all associated with a
+    <tt>language</tt>
+     statement in the CMT requirements
+                    file).
+<blockquote><hr>
+      <i>
+                          c c_library cpp cpp_library lex lex_library fortran
+                          fortran_library yacc yacc_library jar jar_header
+                          java java_copy java_header check_java cleanup_java
+    </i>
+<hr></blockquote>
+  </li>
+    <li> those used internally by CMT as primary building
+                    blocks for assembling the makefile. (Generally developers
+                    should not see them). 
+<blockquote><hr>
+      <i>
+                          cleanup_objects application
+                          constituent application_header constituents_header
+                          buildproto protos_header os9_header dependencies
+                          check_application dependencies_and_triggers
+                          check_application_header document_header library
+                          cleanup library_header cleanup_application
+                          library_no_share cleanup_header make_header
+                          cleanup_library
+    </i>
+<hr></blockquote>
+  </li>
+    <li> some document generators which <i>may</i>
+     be used if
+                    needed, but are not mandatory:
+<blockquote><hr>
+      <i>
+                          installer installer_header readme readme_header
+                          readme_trailer readme_use dvi tex generator
+                          generator_header
+    </i>
+<hr></blockquote>
+  </li>
+    <li> those used to generate configuration files for MSVisualC++:
+<blockquote><hr>
+      <i>
+                          dsp_windows_header dsw_all_project
+                          dsw_all_project_dependency dsw_all_project_header
+                          dsw_all_project_trailer dsw_header dsw_project
+                          dsw_trailer dsp_all dsp_application_header
+                          dsp_contents dsp_library_header
+                          dsp_shared_library_header dsp_trailer
+    </i>
+<hr></blockquote>
+  </li>
+</ul>
+  <p>Language fragments should provide two forms, one for the
+                applications (in which case they are named exactly after the
+                language name eg c, cpp, fortran) and the other for the
+                libraries (in which case they have the <tt>_library</tt>
+                suffix (eg. c_library, cpp_library, fortran_library). A set
+                of language definitions (C, C++, Fortran, Java, Lex, Yacc)
+                is provided by CMT itself but it is expected that projects
+                add new languages according to their needs. Event if the
+                make fragment meant to be the implementation of a language
+                support is declared, the language support itself must be
+                declared too, using the <tt>language statement</tt>
+</p>
+  <p>All make fragments are provided as (suffixless) files
+                which must be located in the <tt>fragments</tt>
+                sub-directory inside the cmt/mgr branch of one
+                package. They must also be declared in the requirements
+                file (through the <tt>make_fragment</tt>
+   statement) so as to
+              be visible.</p>
+  <p>A package declaring, and implementing a make fragment may
+                override a fragment of the same name when it is already
+                declared by a used package. This implies in particular that
+                any package <tt>may</tt>
+   freely override any make fragment
+                provided by <tt>CMT</tt>
+   itself (although in this case a deep
+                understanding of what the original fragment does is
+              recommended).</p>
+  <p>Makefile fragments may take any form convenient to the
+                document style, and some special pre-built templates (see
+                the <A HREF="#Standard templates for makefile                      fragments">appendix</A>
+  ) can be used in their body to
+                represent running values, meant to be
+              properly expanded at actual generation time :</p>
+    <p><table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+        <td width="150"><tt>CONSTITUENT</tt>
+      </td>
+      <td width="400">the constituent name</td>
+    </tr>
+      <tr>
+        <td><tt>FULLNAME</tt>
+      </td>
+      <td>the full source path</td>
+    </tr>
+      <tr>
+        <td><tt>FILENAME</tt>
+      </td>
+      <td>the source file name without its path</td>
+    </tr>
+      <tr>
+        <td><tt>NAME</tt>
+      </td>
+      <td>the source file name without its path and suffix</td>
+    </tr>
+      <tr>
+        <td><tt>FILESUFFIX</tt>
+      </td>
+      <td>the dotted file suffix</td>
+    </tr>
+      <tr>
+        <td><tt>FILEPATH</tt>
+      </td>
+      <td>the output path</td>
+    </tr>
+      <tr>
+        <td><tt>SUFFIX</tt>
+      </td>
+      <td>the default suffix for output files</td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="public, private"></a><a href="#index"><tt>13.&nbsp;2.17</tt></a> - public, private</h4>
+<blockquote>
+  <p>The <tt>public</tt>
+   or <tt>private</tt>
+   keywords
+              introduce sections containing <i>public</i>
+   or
+  <i>private</i>
+ statements. This concerns:</p>
+  <ul>
+  <li>the definition of symbols</li>
+  <li>the specification of use relationships</li>
+  <li>the declaration of make fragments</li>
+  <li>the declaration of patterns</li>
+    <li>the declaration of include search paths (via the
+    <tt>include_dirs</tt>
+   statement)</li>
+</ul>
+  <p>Public definitions are meant to be exported to any
+  	    client of the package whereas private ones are only
+  	    available for the package <i>developper</i>
+   ie. when the
+	    current directory is within the package itself.</p>
+  <p>Public use relationships expose the complete sub-tree
+  	    to the package clients, whereas private ones entirely hide
+  	    the sub-tree, expanding it only when the operator really
+  	    acts from within the context of the package. It should be
+  	    noticed that private use relationships are completely
+  	    unvisible from clients, which implies that none of the
+	    definitions (not only symbols) will be set.</p>
+  <p>However, the <tt>cmt broadcast</tt>
+     and <tt>cmt show
+  	    uses</tt>
+   commands are configured to always ignore the
+  	    private specification and therefore will always traverse
+  	    the sub-trees whether they are public or private (in order
+	    to ensure the hierarchy dependencies)</p>
+<hr><h5><a name="Scoping sections"></a><a href="#index"><tt>13.&nbsp;2.17.&nbsp;1</tt></a> - Scoping sections</h5>
+<blockquote>
+              By using the <tt>public</tt>
+ or <tt>private</tt>
+ keywords,
+              one defines <i>scoping</i>
+ sections. This sections
+              continues until:
+  <ul>
+    <li>another scoping statement is found, which simply
+                    switch to this new mode <p></p>
+  </li>
+    <li>an <tt>end_private</tt>
+     or <tt>end_public</tt>
+                    keyword is found, in which case the scoping mode is
+                    reset to the state prior to the previous matching
+    <tt>private</tt>
+     or <tt>public</tt>
+     statement. This
+                    latter mechanisms permits in particular to define
+                      autonomous scoping sections within <a href="#patterns"><tt>pattern</tt>
+    s</a>
+    .  <p></p>
+  </li>
+</ul>
+  <p>By default <tt>cmt</tt>
+   commands operate according to
+                the scoping specifications found in the requirements
+                files of the reachable packages. Ie. in the current
+                package all statements are considered whether being
+                prublic or private, while in used packages, only public
+              statements are considered.</p>
+  <p>This standard behaviour though is not applied when
+                running <tt>cmt broadcast</tt>
+     or <tt>cmt show
+                uses</tt>
+  , and in this case all statements public or
+                private, are always considered, even in used
+              packages.</p>
+  <p>However it is always possible to override the default
+                behaviours by using the <tt>-private</tt>
+   or
+  <tt>-public</tt>
+   modifier to the <tt>cmt</tt>
+              command:</p>
+  <ul>
+    <li><tt>-private</tt>
+      <p>Force the command to consider
+                      all definitions even those installed in private
+                    sections</p>
+    <p></p>
+  </li>
+    <li><tt>-public</tt>
+      <p>Force the command to really
+                    mask the private sections</p>
+    <p></p>
+  </li>
+</ul>
+</blockquote>
+</blockquote>
+<hr><h4><a name="tag, apply_tag"></a><a href="#index"><tt>13.&nbsp;2.18</tt></a> - tag, apply_tag</h4>
+<blockquote>
+  <p>The <tt>tag</tt>
+   keyword provides tag definitions,
+              while the <tt>apply_tag</tt>
+   keyword <i>activates</i>
+ a tag.</p>
+  <p> A tag is a token which can be used to select
+            particular values of symbols.</p>
+  <p> Some tags are automatically constructed by CMT
+              according to its knowledge of the context (see this <a href="#Selecting a specific configuration">section</a>
+   for
+              more details), but they may be also defined within a <a HREF="#The requirements file">requirements</a>
+   file as
+            follows :</p>
+<pre class="cmt">
+tag Foo                [1]
+tag Bar Foo FooA FooB  [2]
+apply_tag Bar          [3]</pre>
+  <ol>
+    <li>This simply declares a tag. This does not
+                  activate it by default<p></p>
+  </li>
+    <li>This construct declares that the tags <tt>Foo</tt>
+    ,
+    <tt>FooA</tt>
+     and <tt>FooB</tt>
+     will become active if
+    <tt>Bar</tt>
+     becomes active. Note that this statement
+                  implicitly <i>declares</i>
+    <tt>FooA</tt>
+     and
+    <tt>FooB</tt>
+    <p></p>
+  </li>
+    <li>This activates the <tt>Bar</tt>
+     tag. Tags that have
+                  been associated with it (in [2]), will all become active
+                  as well.<p></p>
+  </li>
+</ol>
+    <p>Running the setup script (through the <i>source
+              setup.[c]sh</i>
+   or <i>call setup.bat</i>
+   command ) can
+              also receive tag specifications using the
+  <i>-tag=tag-list</i>
+ options.</p>
+</blockquote>
+</blockquote>
+<hr><h3><a name="The general cmt user interface"></a><a href="#index"><tt>13.&nbsp;3</tt></a> - The general cmt user interface</h3>
+<blockquote>
+          This utility (a shell script combined with a <tt>C++</tt>
+          application) provides a centralised access to various commands 
+          to the <tt>CMT</tt>
+ system. The first way to use <tt>cmt</tt>
+ is 
+          to run it without argument, this will print a minimal help text 
+          showing the basic commands and their syntax : 
+<pre>
+&gt; cmt command [option...]
+<i><font COLOR="#000077" face="courier new, courier"> command :
+   none
+   awk
+   broadcast [-select=list] [-exclude=list] [-local] [-global] [-begin=pattern] [-depth=n] &lt;command&gt; : 
+        apply a command to [some of] the used packages
+   build &lt;option&gt;          : build actions. (Try cmt help build)
+   build constituent_makefile &lt;constituent&gt;  : generate constituent Makefile fragment
+   build constituents_makefile : generate constituents.make
+   build dependencies      : generate dependencies
+   build library_links     : build symbolic links towards all imported libraries
+   build make_setup        : build a compiled version of setup scripts
+   build msdev             : generate MSDEV files
+   build CMT_pacman        : generate PACMAN manifest file for CMT
+   build vsnet             : generate VS.NET files
+   build os9_makefile      : generate Makefile for OS9
+   build prototype         : generate prototype file
+   build readme            : generate README.html
+   build tag_makefile      : generate tag specific Makefile
+   build temporary_name    : generate a name for a temprary file
+   build triggers &lt;constituent&gt; : generate library trigger file
+   build windefs &lt;library_name&gt; : generate def file for Windows shared libraries
+   check &lt;option&gt;          : check actions. (Try cmt help check)
+   check configuration     : check configuration
+   check files &lt;old&gt; &lt;new&gt; : compare two files and overrides &lt;old&gt; by &lt;new&gt; if different
+   check version &lt;name&gt;    : check if a name follows a version tag syntax 
+   co | checkout           : perform a cvs checkout over a CMT package
+   cleanup [-csh|-sh|-bat] : generate a cleanup script
+   config                  : generate setup and cleanup scripts
+   create &lt;package&gt; &lt;version&gt; [&lt;path&gt;] : create and configure a new package
+   create_project &lt;project&gt; &lt;name&gt; [&lt;path&gt;] : create and configure a new project
+   cvsbranches &lt;module&gt;      : display the subdirectories for a module
+   cvssubpackages &lt;module&gt;  : display the subpackages for a module
+   cvssubprojects &lt;module&gt;  : display the subprojects for a module
+   cvstags &lt;module&gt;          : display the CVS tags for a module
+   do &lt;action&gt; [&lt;param&gt;=&lt;value&gt;] ... : Execute an action
+   expand model &lt;model&gt;    : 
+   filter &lt;in&gt; &lt;out&gt;       : filter a file against CMT macros and env. variables
+   help | -help | --help   : display this help
+   load
+   lock [&lt;p&gt; &lt;v&gt; [&lt;path&gt;]] : lock a package
+   relocate                  : generate setup and cleanup scripts (without makefiles)
+   remove &lt;package&gt; &lt;version&gt; [&lt;path&gt;] : remove a package version
+   remove library_links    : remove symbolic links towards all imported libraries
+   run '&lt;command&gt;'         : apply a command
+   run_sequence &lt;sequence file&gt; : execute a cmt equence file
+   set version &lt;version&gt;   : generate a version file in the current package
+   set versions            : generate version files into packages
+   setup [-csh|-sh|-bat]   : generate a setup script
+   show &lt;option&gt;           : query actions. (Try cmt help show)
+   show  action &lt;name&gt;     :  a formatted action definition
+   show  action_value &lt;name&gt; :  a raw action definition
+   show  action_names      :  all action names
+   show  actions           :  all action definitions
+   show  all_tags          :  all defined tags
+   show  applied_patterns  :  all patterns actually applied
+   show  author            :  package author
+   show  branches          :  added branches
+   show  clients           :  package clients
+   show  cmtpath_patterns  :  cmtpath_patterns
+   show  constituent &lt;name&gt;:  constituent definition
+   show  constituent_names :  constituent names
+   show  constituents      :  constituent definitions
+   show  cycles            :  cycles in the use graph
+   show  fragment &lt;name&gt;   :  one fragment definition
+   show  fragments         :  fragment definitions
+   show  groups            :  group definitions
+   show  include_dirs      :  
+   show  language &lt;name&gt;   :  language definition
+   show  languages         :  language definitions
+   show  macro &lt;name&gt;      :  a formatted macro definition
+   show  macro_value &lt;name&gt;  :  a raw macro definition
+   show  macro_names       :  all macro names
+   show  macros            :  all macro definitions
+   show  manager           :  package manager
+   show  packages          :  packages reachable from the current context
+   show  path              :  the package search list
+   show  pattern &lt;name&gt;    :  the pattern definition and usages
+   show  pattern_names     :  pattern names
+   show  patterns          :  the pattern definitions
+   show  projects          :  project definitions
+   show  setup             :  setup definitions
+   show  pwd               :  filtered current directory
+   show  set &lt;name&gt;        :  a formatted set definition
+   show  set_names         :  set names
+   show  set_value &lt;name&gt;  :  a raw set definition
+   show  sets              :  set definitions
+   show  strategies        :  all strategies (build & version)
+   show  tags              :  all currently active tags
+   show  use_paths &lt;pack&gt;  :  all paths to the used package
+   show  uses              :  used packages
+   show  version           :  version of the current package
+   show  versions &lt;name&gt;   :  visible versions of the selected package
+   system                  : display the system tag
+   unlock [&lt;p&gt; &lt;v&gt; [&lt;path&gt;]] : unlock a package
+   version                 : version of CMT
+ global options :
+   -quiet                  : don't print errors
+   -use=&lt;p&gt;:&lt;v&gt;:&lt;path&gt;     : set package version path
+   -pack=&lt;package&gt;         : set package
+   -version=&lt;version&gt;      : set version
+   -path=&lt;path&gt;            : set root path
+   -f=&lt;requirement-file&gt;   : set input file
+   -e=&lt;statement&gt;          : add a one line statement
+   -tag=&lt;tag-list&gt;         : select a new tag-set
+   -tag_add=&lt;tag-list&gt;     : add specific comma-separated tag(s)
+   -tag_remove=&lt;tag-list&gt;  : remove specific comma-separated tag(s)
+   -warnings               : display various warnings
+   -with_version_directory : reset to default structuring style
+   -without_version_directory : switch structuring style</font></i></pre>
+<p>The following sections present the detail of each available command. </p>
+<hr><h4><a name="Global options of the cmt command"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;1</tt></a> - Global options of the cmt command</h4>
+<blockquote>
+  <p>These options of the general form
+  <tt>-&lt;option&gt;</tt>
+   or
+  <tt>-&lt;option&gt;=&lt;value&gt;</tt>
+   should be provided
+  <i>before</i>
+   the command itself. They give special hints
+            to cmt onto how to perform the command.</p>
+  <p>Some options have meaning over all commands (such as
+              the <tt>-quiet</tt>
+   option) while some others only have a
+              meaning in the context of some specialized commands (such
+              as the <tt>-with_version_directory</tt>
+   option which is
+              only useful for the <tt>create</tt>
+   or <tt>co</tt>
+            commands)</p>
+  <p>The following table describes the various global
+              options of the <tt>cmt</tt>
+ tool:</p>
+  <table cellspacing="0" BORDER="1" COLS="3">
+    <tr>
+        <td><center><i>option</i>
+      </center>
+    </td>
+        <td><center><i>effect</i>
+      </center>
+    </td>
+        <td><center><i>commands</i>
+      </center>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-quiet</tt>
+    </td>
+    <td>don't print errors</td>
+      <td><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-use=&lt;p&gt;:&lt;v&gt;:&lt;path&gt;</tt>
+    </td>
+    <td>set current package version and path in one option</td>
+      <td><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-pack=&lt;package&gt;</tt>
+    </td>
+    <td rowspan="3">set current package, version and root path</td>
+      <td rowspan="3"><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-version=&lt;version&gt;</tt>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-path=&lt;path&gt;</tt>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-f=&lt;requirement-file&gt;</tt>
+    </td>
+    <td>override input file</td>
+      <td><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-e=&lt;statement&gt;</tt>
+    </td>
+    <td>add a one line statement</td>
+      <td><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-tag=&lt;tag-list&gt;</tt>
+    </td>
+    <td>select a new tag-set</td>
+      <td><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-tag_add=&lt;tag-list&gt;</tt>
+    </td>
+    <td>add specific comma-separated tag(s)</td>
+      <td><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-tag_remove=&lt;tag-list&gt;</tt>
+    </td>
+    <td>remove specific comma-separated tag(s)</td>
+      <td><i>all</i>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-warnings</tt>
+    </td>
+    <td>displays various warnings, such as invalid PATH items</td>
+            <td><table><tr><td><tt>broadcast</tt>
+          </td>
+        </tr>
+            <tr><td><tt>run</tt>
+          </td>
+        </tr>
+            <tr><td><tt>setup</tt>
+          </td>
+        </tr>
+      </table>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-with_version_directory</tt>
+    </td>
+    <td>reset to default structuring style</td>
+            <td><table><tr><td><tt>create</tt>
+          </td>
+        </tr>
+            <tr><td><tt>co</tt>
+          </td>
+        </tr>
+      </table>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>-without_version_directory</tt>
+    </td>
+    <td>switch structuring style</td>
+            <td><table><tr><td><tt>create</tt>
+          </td>
+        </tr>
+            <tr><td><tt>co</tt>
+          </td>
+        </tr>
+      </table>
+    </td>
+  </tr>
+</table>
+</blockquote>
+<hr><h4><a name="cmt broadcast"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;2</tt></a> - cmt broadcast</h4>
+<blockquote>
+            This command tries to repeatedly execute a shell command in the 
+            context of each of the used package of the current package. The 
+            used packages are listed using the <tt>cmt show uses</tt>
+            command, which also indicates in which order the broadcast is 
+            performed. When the <tt>all_packages</tt>
+ option, the set of
+            packages reached by the broadcast is rather the same as the one shown
+            by the <tt>cmt show packages</tt>
+ command, ie all <tt>CMT</tt>
+ packages
+            and versions available through the current <tt>CMTPATH</tt>
+ list.
+  <p>Typical uses of this <i>broadcast</i>
+ operation could be:</p>
+<pre>
+csh&gt; cmt broadcast cmt config
+csh&gt; cmt broadcast - gmake 
+csh&gt; cmt broadcast '(cd ../; cvs -n update)' </pre>
+  <p>The loop over used packages will stop at the first error
+                occurence in the application of the command, except if the
+                command was preceded by a '-' (minus) sign (similarly to the
+              make convention).</p>
+  <p>It is possible to specify a list of selection or
+                exclusion criteria set onto the package path, using the
+                following options, right after the <tt>broadcast</tt>
+                keyword. These selection criteria may be combined (eg one
+                may combine the <i>begin</i>
+   and <i>select</i>
+              modifiers)</p>
+<pre>
+sh&gt; cmt broadcast -begin=Cm gmake                 (1)
+sh&gt; cmt broadcast -select=Cm gmake                (2)
+sh&gt; cmt broadcast -select='/Cm/ /CSet/' gmake     (3)
+sh&gt; cmt broadcast -select=Cm -exclude=Cmo gmake   (4)
+sh&gt; cmt broadcast -local gmake                    (5)
+sh&gt; cmt broadcast -depth=&lt;n&gt; gmake                (6)
+sh&gt; cmt broadcast -global gmake                   (7)
+sh&gt; cmt broadcast -all_packages gmake             (8)</pre>
+<p>According to the option, the loop will only operate onto:</p>
+  <ol>
+    <li>the first package which path contains the string
+    <tt>"Cm"</tt>
+    , and then all other reachable packages (in
+                case other specifiers are used)</li>
+    <li>the packages which path contains the string <tt>"Cm"</tt>
+  </li>
+    <li>the packages which path contains either the string
+    <tt>"/Cm/"</tt>
+     or the string <tt>"/CSet/"</tt>
+  </li>
+    <li>the packages which path contains the string <tt>"Cm"</tt>
+    ,
+                  but which does not contain the string <tt>"Cmo"</tt>
+  </li>
+  <li>the packages at the same level as the current package</li>
+    <li>the packages at the same level as the current package or
+                  among the &lt;n&gt; first entries in the <tt>CMTPATH</tt>
+   list</li>
+  <li>the packages at any level of the CMTPATH search list</li>
+    <li>all the packages and versions currently available
+                  through the <tt>CMTPATH</tt>
+   list</li>
+</ol>
+  <p>The environment variables as specified in the
+              requirements files of the use graph are internally pre-set
+              before running the specified shell command. Thus it's not
+              required to <i>source</i>
+   the setup scripts before using
+              the <tt>broadcast</tt>
+   command
+</p>
+<hr><h5><a name="Specifying the shell command"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;2.&nbsp;1</tt></a> - Specifying the shell command</h5>
+<blockquote>
+  <p>A priori any Unix or DOS shell command can be specified
+  	    in a boadcast command. However, it's important to
+	    understand the order of the various parsing actions:</p>
+  <ol>
+  <li>The current shell first parses the complete command line</li>
+  <li>CMT catches all possible options given to the broadcast command itself</li>
+  <li>CMT then gets the rest of the command line and makes it the shell command to be executed during the broadcast scan.</li>
+  <li>This command line may be subject to template substitution (see below) by CMT</li>
+  <li>Eventually the command line is passed to the local shell (which may then perform additional parsing actions)</li>
+</ol>
+  <p>Considering this complex sequence of parsing, it may be
+  	    appropriate to selectively enclose the shell command
+  	    passed to the broadcast action into quotes. It may even be
+	    sometimes useful to have two levels of quotes</p>
+</blockquote>
+<hr><h5><a name="Templates in the shell command"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;2.&nbsp;2</tt></a> - Templates in the shell command</h5>
+<blockquote>
+  <p>Similarly to what exists in the <a href="#patterns">pattern</a>
+   mechanism, some standard
+  <i>templated</i>
+   values can be embedded inside the
+  	    command to be executed by the broadcast action. They take
+  	    a standard form of
+    <i><tt>&lt;template-name&gt;</tt>
+  </i>
+  . These templates acquire
+  	    their value on each package effectively reached during the
+  	    broadcast scan, and the effective value is substituted
+	    before launching the command. The possible templates are:</p>
+  <table>
+    <tr>
+      <td><tt>&lt;package_cmtpath&gt;</tt>
+    </td>
+    <td>The element in the CMTPATH search list where the package has been found</td>
+  </tr>
+    <tr>
+      <td><tt>&lt;package_offset&gt;</tt>
+    </td>
+    <td>The directory offset to cmtpath</td>
+  </tr>
+    <tr>
+      <td><tt>&lt;package&gt;</tt>
+    </td>
+    <td>The package name</td>
+  </tr>
+    <tr>
+      <td><tt>&lt;version&gt;</tt>
+    </td>
+    <td>The version of the package</td>
+  </tr>
+</table>
+  <p>The next example shows a typical broadcast command listing the
+  	    header files as expected in the conventional location
+  <tt>../&lt;package&gt;</tt>
+ :</p>
+<pre>
+&gt; cmt broadcast 'ls ../&lt;package&gt;'
+<i><font COLOR="#000077" face="courier new, courier">[...]
+#--------------------------------------------------------------
+# Now trying [ ls ../GenzModuleEvent] in /.../GenzModuleEvent/.../cmt (149/609)
+#--------------------------------------------------------------
+CVS  KineHepMcmap.h
+#--------------------------------------------------------------
+# Now trying [ ls ../Tauola_i] in /.../Tauola_i/.../cmt (150/609)
+#--------------------------------------------------------------
+CVS     Jaki.icc        Tauola_i.h    Taurad.h    config.h    rn_tau.h
+Jaki.h  ReadPDGtable.h  Tauola_i.icc  Taurad.icc  polhep.inc  tauola_cblk.inc
+#--------------------------------------------------------------
+# Now trying [ ls ../NavigationEvent] in /.../NavigationEvent/.../cmt (151/609)
+#--------------------------------------------------------------
+CVS  INavigable.h  INavigationCondition.h  INavigationSelector.h
+INavigationToken.h  NavigationToken.h
+[...]</font></i></pre>
+<blockquote><hr>
+	    One should note that when templates are used in a
+	    broadcast command, it's important to enclose the command
+	    in quotes so as to inhibit any possible parsing of the
+<tt>&lt;&gt;</tt>
+ syntax by the shell.
+<hr></blockquote>
+</blockquote>
+</blockquote>
+<hr><h4><a name="cmt build &lt;option&gt;"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;3</tt></a> - cmt build &lt;option&gt;</h4>
+<blockquote>
+  <p>The actions associated with the build options are
+              generally meant for internal use only, and users will
+            rarely (if ever!) apply them manually</p>
+  <p>All build commands are generally meant to change the
+              current package (some file or set of files is
+              generated). Therefore a check against conflicting locks
+              (ie. a lock owned by another user) is performed by all
+            these commands prior to execute it.</p>
+  <ul>
+      <li><tt>[-nmake] constituent_makefile &lt;<i>constituent-name</i>
+    &gt;</tt>
+      <p>This command is internally used by <tt>CMT</tt>
+       in the standard 
+                        Makefile.header fragment. It generates a specific makefile 
+                        fragment (named &lt;<i>constituent-name</i>
+      &gt;.make) 
+                      which is used to re-build this fragment. </p>
+      <p>All such constituent fragments are automatically 
+                      included from the main Makefile. </p>
+      <p>Although this command is meant to be used internally 
+                        (and transparently) by <tt>CMT</tt>
+       when the make command is run, a 
+                        developer may find useful in very rare cases to manually 
+                      re-generate the constituent fragment, using this command.</p>
+      <p>The <tt>-nmake</tt>
+       option (which must precede the
+                        command) provides exactly the same features but in a
+        Windows/nmake context. In this case, all generated
+                        makefiles are suffixed by <tt>.nmake</tt>
+       instead of
+      <tt>.make</tt>
+       for Unix environments. The main makefile is
+                        expected to be named <tt>NMake</tt>
+       and the standard header
+                        is named <tt>NMakefile.header</tt>
+    </p>
+  </li>
+    <li><tt>[-nmake] constituents_makefile</tt>
+      <p>This command is internally (and transparently) used by 
+      <tt>CMT</tt>
+       in the standard Makefile.header fragment, and when the 
+                        make command is run, to generate a specialized make 
+                        fragment containing all "cmt build constituent_makefile" 
+                      commands for a given package. </p>
+      <p>The <tt>-nmake</tt>
+       option (which must precede the
+                        command) provides exactly the same feature but in a
+                        Windows/nmake context. In this case, all generated
+                        makefiles are suffixed by <tt>.nmake</tt>
+       instead of
+      <tt>.make</tt>
+       for Unix environments. The main makefile is
+                        expected to be named <tt>NMake</tt>
+       and the standard header
+                        is named <tt>NMakefile.header</tt>
+    </p>
+  </li>
+    <li><tt>dependencies</tt>
+      <p>This command is internally (and transparently) used by 
+      <tt>CMT</tt>
+       from the constituent specific fragment, and when the 
+                        make command is run, to generate a fragment containing the 
+                      dependencies required by a source file. </p>
+      <p>This fragment contains a set of macro definitions (one 
+                        per constituent source file), each containing the set of 
+                      found dependencies. </p>
+      <p>CMT is able to recursively compute the dependencies
+                      implied by the <tt>include</tt>
+       statements found in
+                      the source files. However it's also possible to make
+               plain use of the standard mechanisms provided by some
+                      standard tools like <tt>cpp -M</tt>
+      . In this case, it
+                      will be required to <i>format</i>
+       the output produced
+                      by the selected tool so as to let CMT parse it and
+                      properly deduce the dependencies. Formatting the
+                      output of external tools may require to interface the
+                    tool itself e.g. using a shell script.</p>
+      <p>The standard CMT macro
+      <tt>$(build_dependencies)</tt>
+       must be used to specify
+                    an alternate dependency builder. The default value is:</p>
+<pre>$(cmtexe) -quiet -tag=$(tags) build dependencies</pre>
+    <p>The expected output format from any dependency builder is as follows:</p>
+      <ul>
+      <li>Each file corresponds to one single dependency line in the output</li>
+        <li>A dependency line should be formatted as follows:
+<pre>&lt;file-name&gt;_&lt;file_suffix&gt;_dependencies = &lt;source&gt; &lt;file&gt; ... </pre>
+        <p>Where:</p>
+          <ul>
+            <li><tt>&lt;file-name&gt;</tt>
+           is given without the file suffix</li>
+            <li><tt>&lt;file_suffix&gt;</tt>
+           is given without the dot</li>
+            <li><tt>&lt;source&gt;</tt>
+           is the path to the source file</li>
+            <li>the list of <tt>&lt;file&gt;</tt>
+           paths corresponds to the effective list of dependent files. This is a list of reative or absolute file paths.</li>
+        </ul>
+      </li>
+    </ul>
+      <p>A Unix shell script in
+      <tt>${CMTROOT}/mgr/cmt_build_deps.sh</tt>
+       is offered
+                        as an example of how to interface the standard <tt>cpp
+                      -M</tt>
+       command with CMT. It can be declared as a
+                    substitute to the internal mechanism as follows:</p>
+<pre>macro build_dependencies "${CMTROOT}/mgr/cmt_build_deps.sh"</pre>
+      <p>Of course this shell script should be considered as
+                      an example and might have to be adapted for other
+                    dependency builders, or for Windows.</p>
+  </li>
+    <li><tt>library_links</tt>
+      <p>This command builds a local symbolic link towards all
+                        exported libraries from the used packages. A package
+                        exports its libraries through the
+        <tt>&lt;<i>package</i>
+      &gt;_libraries</tt>
+       macro which should
+                        contain the list of constituent names corresponding to
+                      libraries that must be exported.</p>
+<pre class="cmt">
+library Foo ...
+library Foo-utils ...
+...
+macro Foo_libraries "Foo Foo-utils"</pre>
+                    The corresponding <tt>cmt remove library_links</tt>
+     command
+                    will remove all these links.
+  </li>
+    <li><tt>msdev</tt>
+      <p>This command generates workspace (.dsw) and project 
+                      (.dsp) files required for the MSDev tool. </p>
+  </li>
+    <li><tt>vsnet</tt>
+      <p>This command generates workspace and project files
+                    required for the Visual.net tool. </p>
+  </li>
+    <li><tt>os9_makefile</tt>
+      <p>This command generates external dedicated
+      <i>makefile</i>
+       fragments for each individual component of
+                        the package (ie. libraries or executable applications) to
+                        be used in OS9 context. It generates specific syntaxes for
+                        the <tt>OS9</tt>
+     operating systems.</p>
+      <p>The output of this tool is a set of files (named with
+                        the components' name and suffixed by <tt>.os9make</tt>
+      ) that
+                        are meant to be <i>included</i>
+       within the main
+      <tt>Makefile</tt>
+     that the developer has to write anyhow.</p>
+      <p>The syntax of the <tt>cmt build os9_makefile</tt>
+       utility 
+                      is as follows : </p>
+<pre>
+sh&gt; cmt build os9_makefile &lt;package&gt; </pre>
+  </li>
+    <li><tt>prototype &lt;source-file-name&gt;</tt>
+      <p>This command is internally (and transparently) used by 
+      <tt>CMT</tt>
+       from the constituent specific fragment, and when the 
+                        make command is run, to generate prototype header files 
+                      from C source files. </p>
+      <p>The prototype header files (named &lt;file-name&gt;.ph) 
+                        will contain prototype definitions for every global entry 
+                      point defined in the corresponding C source file. </p>
+      <p>The effective activation of this feature is controled 
+                        by the build strategy of <tt>CMT</tt>
+      . The build strategy may be 
+                        freely and globally overridden from any &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file, 
+                        using the <tt>build_strategy</tt>
+       cmt statement, providing 
+                      either the "prototypes" or the "no_prototypes" values. </p>
+      <p>In addition, any constituent may locally override this 
+                        strategy using the "-prototypes" or "-no_prototypes" 
+                      modifiers. </p>
+  </li>
+    <li><tt>readme</tt>
+      <p>This command generates a README.html file into the cmt 
+                        branch of the referenced package. This html file will 
+                      include  </p>
+      <ul>
+        <li>a table containing URLs to equivalent pages for 
+                          all used packages,  </li>
+      <li>a copy of the local README file (if it exists). </li>
+    </ul>
+  </li>
+    <li><tt>tag_makefile</tt>
+      <p> This command produces onto the standard output, the
+                        exhaustive list of all macros controled by <tt>CMT</tt>
+      ,
+                        ie. those defined in the requirements files as well as the
+                        standard macros internally built by <tt>CMT</tt>
+      , taking
+                      into account all used packages.</p>
+  </li>
+</ul>
+</blockquote>
+<hr><h4><a name="cmt check configuration"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;4</tt></a> - cmt check configuration</h4>
+<blockquote>
+            This command reads the hierarchy of requirements files 
+            referenced by a package, check them, and signals syntax 
+            errors, version conflicts or other configuration problems. 
+<p>An empty output means that everything is fine. </p>
+</blockquote>
+<hr><h4><a name="cmt check files &lt;reference-file&gt; &lt;new-file&gt;"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;5</tt></a> - cmt check files &lt;reference-file&gt; &lt;new-file&gt;</h4>
+<blockquote>
+            This command compares the reference file to the new file, and 
+            substitues the reference file by the new one if they are 
+            different. 
+  <p>If substitution is performed, a copy (with additional 
+                extension <tt>sav</tt>
+) is produced. </p>
+</blockquote>
+<hr><h4><a name="cmt checkout ..."></a><a href="#index"><tt>13.&nbsp;3.&nbsp;6</tt></a> - cmt checkout ...</h4>
+<blockquote>
+            See the <a href="#Using cvs together with CMT">paragraph</a>
+            on how to use cvs together with <tt>CMT</tt>
+, and more specifically the
+            details on <a href="#Checking a package out from a cvs repository">checkout oprations</a>
+.
+</blockquote>
+<hr><h4><a name="cmt co ..."></a><a href="#index"><tt>13.&nbsp;3.&nbsp;7</tt></a> - cmt co ...</h4>
+<blockquote>
+            This is simply a short cut to the <tt>cmt checkout</tt>
+ command. 
+</blockquote>
+<hr><h4><a name="cmt cleanup [-csh|-sh]"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;8</tt></a> - cmt cleanup [-csh|-sh]</h4>
+<blockquote>
+            This command generates (to the standard output) a set of shell 
+            commands (either for csh or sh shell families) meant to unset 
+            all environment variables specified in the &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; files 
+            of the used packages. 
+  <p>This command is internally used in the cleanup.[c]sh shell 
+                script, itself generated by the <tt>cmt config</tt>
+ command. </p>
+</blockquote>
+<hr><h4><a name="cmt config"></a><a href="#index"><tt>13.&nbsp;3.&nbsp;9</tt></a> - cmt config</h4>
+<blockquote>
+  <p>This command (re-)generates the setup scripts and the
+              manimal Makefile (when it does not exist yet or have been lost).</p>
+<pre>
+csh&gt; cd ~/Packages/Foo/v1/cmt 
+csh&gt; cmt config </pre>
+  <p>To be properly operated, one must <i>already</i>
+   be in
+                the <tt>cmt</tt>
+   or <tt>mgr</tt>
+   branch of a package (where the
+  &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file can
+              be found).</p>
+  <p>This command also performs some cleanup operations
+                (eg. removing all makefile fragments previously
+                generated). Generally speaking, one may say that this
+                command restores the CMT-related files to their original state (ie
+              before any document generation) </p>
+<p>The situations in which it is useful to run this command are:</p>
+  <ul>
+  <li>When the setup or cleanup scripts have been lost</li>
+  <li>When the minimal Makefile have been lost</li>
+    <li>When the version of <tt>CMT</tt>
+   is changed</li>
+  <li>After restoring a package from CVS</li>
+    <li>After having manually changed the directory structure
+                    of a package (using a manual copy operation, or renaming
+                    one of its parent directory, such as the version
+                  directory)</li>
+</ul>
+  <p>It should be noted however that when using
+  <i>actions</i>
+  , such as the one defined by default to
+              launch <tt>make</tt>
+   tools neither <tt>cmt config</tt>
+   nor
+  <tt>source setup</tt>
+ are required any longer.</p>
+</blockquote>
+<hr><h4><a name="cmt create &lt;package&gt; &lt;version&gt; [&lt;area&gt;]"></a><a href="#index"><tt>13.&nbsp;3.10</tt></a> - cmt create &lt;package&gt; &lt;version&gt; [&lt;area&gt;]</h4>
+<blockquote>
+  <p>
+              This command creates a new package or a new version of a package</p>
+<pre>
+csh&gt; cmt create Foo v1 </pre>
+            or:
+<pre>
+csh&gt; cmt create Foo v1 ~/dev</pre>
+  <p>In the first mode (ie. without the <i>area</i>
+   argument)
+              the package will be created in the default path.</p>
+<p>The second mode explicitly provides an alternate path.</p>
+<p>A minimal configuration is installed for this new package:</p>
+  <ul>
+    <li>A <tt>src</tt>
+     and a <tt>cmt</tt>
+   branch</li>
+  <li>A very minimal requirements file</li>
+  <li>The setup and cleanup shell scripts</li>
+  <li>The minimal Makefile</li>
+</ul>
+  <p>A version directory may be created according to the
+              structuring style or structuring strategy parameters
+            specified using one of the following means:</p>
+  <ol>
+    <li>Through the environment variable
+    <tt>CMTSTRUCTURINGSTYLE</tt>
+     taking one of the
+                  alternate values:
+<pre>
+with_version_directory
+without_version_directory</pre>
+    <p></p>
+  </li>
+    <li>Through the command line options
+    <tt>-with_version_directory</tt>
+     or
+    <tt>-without_version_directory</tt>
+    <p></p>
+  </li>
+    <li>Through the <tt>structure_strategy</tt>
+     specification entered into the project file of the current project, using the alternate values:
+<pre>
+with_version_directory
+without_version_directory</pre>
+    <p></p>
+  </li>
+</ol>
+  <p>It should be noted that the command line option will
+              take precedence over the strategy specification, in case
+            of conflict.</p>
+</blockquote>
+<hr><h4><a name="cmt expand model [-strict] &lt;model-string&gt;"></a><a href="#index"><tt>13.&nbsp;3.11</tt></a> - cmt expand model [-strict] &lt;model-string&gt;</h4>
+<blockquote>
+            This command produces on the standard output an
+<i>expansion</i>
+ of the model string given in the
+            argument.
+<p>The expansion consists in:</p>
+  <ul>
+    <li>Expanding macros referenced in the model string
+                  using the standard notations <tt>$()</tt>
+     or
+    <tt>${}</tt>
+     or <tt>%%</tt>
+<pre>
+&gt; cmt expand model "abcd $(CMTVERSION) efgh"
+<i><font COLOR="#000077" face="courier new, courier">abcd v1r19 efgh</font></i></pre>
+  </li>
+    <li><i>Recursively</i>
+     expanding text files with
+                  parameters. The model string must then take a
+                  conventional XML-based syntax:
+<pre>
+&gt; cmt expand model "<i>text</i> &lt;<i>file-name</i> <i>parameter</i>=<i>value</i> ... /&gt; <i>text</i> ..."</pre>
+                    or
+<pre>
+&gt; cmt expand model -strict "<i>text</i> &lt;cmts:<i>file-name</i> <i>parameter</i>='<i>value</i>' ... /&gt; <i>text</i> ..."</pre>
+                    or
+<pre>
+&gt; cmt expand model -strict "<i>text</i> &lt;cmtv:<i>file-name</i> <i>parameter</i>='<i>v1 v2 v3 ...</i>' ... /&gt; <i>text</i> ..."</pre>
+                    Where:
+      <ul>
+        <li><i>file-name</i>
+         is the name of a file declared
+                          using the <tt>make_fragment</tt>
+       statement</li>
+          <li><tt><i>parameter</i>
+          =<i>value</i>
+        </tt>
+         specifies
+                          the value of a parameter that will be substituted in
+                          the file when referenced using the
+          <tt>$(<i>parameter</i>
+        )</tt>
+         notation. Several such
+                        values may be specified in one model string</li>
+        <li>the <tt>-strict</tt>
+         form is useful to handle
+                          XML files, and file names must be prefixed
+                          (<i>namespaced</i>
+        ) by a special keyword
+        <tt>cmts:</tt>
+         or <tt>cmtv:</tt>
+         . 
+          <table>
+              <tr><td><tt>cmts:</tt>
+            </td>
+            <td>Perform a unique substitution over one copy of the file</td>
+          </tr>
+              <tr><td><tt>cmtv:</tt>
+            </td>
+            <td>Perform a multiple substitution over N copies of the file, taking the N space-separated values specified for the parameters</td>
+          </tr>
+        </table>
+      </li>
+    </ul>
+                    The following examples will explain some of the mechanisms.
+      <p>We consider <tt>A</tt>
+     containing:</p>
+<pre>
+A$(P1)B$(P2)C</pre>
+      <p>And <tt>B</tt>
+     containing:</p>
+<pre>
+i&lt;cmts:A P1='j' P2='${P2}'/&gt;k</pre>
+<pre>
+&gt; cmt expand model "abcd &lt;A P1=XXX/&gt; efgh"                                      [1]
+<i><font COLOR="#000077" face="courier new, courier">abcd AXXXBC efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmts:A P1='XXX' P2='YYY'/&gt; efgh"              [2]
+<i><font COLOR="#000077" face="courier new, courier">abcd AXXXBYYYC efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmts:A P1='XXX'/&gt; &lt;cmts:B P2='YYY'/&gt; efgh"    [3]
+<i><font COLOR="#000077" face="courier new, courier">abcd AXXXBC iAjBYYYCk efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmtv:A P1='X Y Z' P2='YYY'/&gt; efgh"            [4]
+<i><font COLOR="#000077" face="courier new, courier">abcd AXBYYYCAYBCAZBC efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmtv:A P1='X Y Z' P2='\"\" &lt;cmt:null/&gt; ZZZ'/&gt; efgh"  [5]
+<i><font COLOR="#000077" face="courier new, courier">abcd AXBCAYBCAZBZZZC efgh</font></i>
+...</pre>
+      <ol>
+        <li>A simple expansion using the non-strict model
+                          syntax. <tt>P1</tt>
+         is substituted, but
+        <tt>$(P2)</tt>
+         becomes empty
+      </li>
+        <li> The same using the strict model. Here P2 is valued.
+      </li>
+        <li>A more complex model, using a recursive
+                          expansion described in <tt>B</tt>
+         showing how
+                        parameter values are transmitted</li>
+        <li>A model showing the multiple expansion. Here
+        <tt>P1</tt>
+         receives 3 values. <tt>P2</tt>
+         has only
+                          one value. The largest vector (3 values) dictates
+                          the number of copies. smaller vectors are completed
+                        by empty values.</li>
+        <li>A model showing the multiple expansion with
+                          empty values in a vector. Here <tt>P1</tt>
+         receives
+                          3 values. <tt>P2</tt>
+         has also 3 values, but only
+                          one non-empty. This examples show the two possible
+                          means of specifying empty vector values: using
+                          either <tt>\"\"</tt>
+         or the reserved keyword
+        <tt>&lt;cmt:null/&gt;</tt>
+      .</li>
+    </ol>
+    <p></p>
+  </li>
+    <li>The file expansion is recursive. This means that
+                  files specified in model elements will themselves be
+                  considered as model texts (ie following the same
+                  syntax), and be expanded in turn. This processus is
+                  entirely recursive, with no limit to the depth. The
+    <i>-strict</i>
+     option, when selected is propagated
+                during the recursion.</li>
+</ul>
+</blockquote>
+<hr><h4><a name="cmt filter &lt;in-file&gt; &lt;out-file&gt;"></a><a href="#index"><tt>13.&nbsp;3.12</tt></a> - cmt filter &lt;in-file&gt; &lt;out-file&gt;</h4>
+<blockquote>
+            This command reads &lt;in-file&gt;, substitutes all occurences 
+            of macro references (taking either the form 
+  <tt>$(<i>macro-name</i>
+)</tt>
+   or <tt>${<i>macro-name</i>
+}</tt>
+            ) by values deduced from corresponding macro specifications 
+            found in the &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; files, and writes the result into 
+&lt;out-file&gt;. 
+  <p>This mechanism is widely internally used by <tt>CMT</tt>
+  , especially 
+                for instanciating make fragments. Then, users may use it for 
+                any kind of document, including maual generation of MSDev 
+              configuration files, etc... </p>
+</blockquote>
+<hr><h4><a name="cmt help | --help"></a><a href="#index"><tt>13.&nbsp;3.13</tt></a> - cmt help | --help</h4>
+<blockquote>
+            This command shows the list of options of the <tt>cmt</tt>
+ driver. 
+</blockquote>
+<hr><h4><a name="cmt lock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]"></a><a href="#index"><tt>13.&nbsp;3.14</tt></a> - cmt lock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]</h4>
+<blockquote>
+            This command tries to set a lock onto the current package (or onto the
+            specified package). This consists in the following operations:
+<p></p>
+  <ol>
+    <li>Check if a conflicting lock is already set onto this
+                  package (ie. a lock owned by another user).</li>
+  <p></p>
+    <li>If not, then install a small text file named <tt>lock.cmt</tt>
+     into the
+    <tt>cmt/mgr</tt>
+     branch of the package, containing the following text: 
+<pre>
+locked by &lt;user-name&gt; date &lt;now&gt;</pre>
+    <p></p>
+  </li>
+    <li>Run a shell command described in the macro named <tt>lock_command</tt>
+     meant to install physical locks onto all files for this version of this package. A typical definition for this macro could be:
+<pre class="cmt">
+macro lock_command   "chmod -R a-w ../*" \
+      WIN32          "attrib /S /D +R ../*"</pre>
+  </li>
+</ol>
+</blockquote>
+<hr><h4><a name="cmt remove &lt;package&gt; &lt;version&gt; [&lt;area&gt;]"></a><a href="#index"><tt>13.&nbsp;3.15</tt></a> - cmt remove &lt;package&gt; &lt;version&gt; [&lt;area&gt;]</h4>
+<blockquote>
+            This command removes one version of the specified package. If
+            the package does not contain a conflicting lock, and if the user is
+            granted enough access rights to remove files, <i>all</i>
+ files below
+            the version directory will be definitively removed. Therefore
+            this command should be used with as much care as possible.
+  <p>The arguments needed to reach the package version to be
+              removed are the same as the ones whic had been used to create it.</p>
+  <p>If the removed version is the last version of this package,
+                (and only if its directory is really empty) the package directory itself
+              will be deleted.</p>
+</blockquote>
+<hr><h4><a name="cmt remove library_links"></a><a href="#index"><tt>13.&nbsp;3.16</tt></a> - cmt remove library_links</h4>
+<blockquote>
+            This command removes symbolic links towards all imported
+              libraries which had been installed using the <tt>
+  <a href="#build">cmt build library_links</a>
+</tt>
+            command. This command is generally transparently executed
+            when one runs <tt>gmake clean</tt>
+</blockquote>
+<hr><h4><a name="cmt run [shell-command]"></a><a href="#index"><tt>13.&nbsp;3.17</tt></a> - cmt run [shell-command]</h4>
+<blockquote>
+            This command runs any shell command, in the context of the 
+<i>current</i>
+ package.  
+  <p>In particular all environment variables defined in
+              requirements file are first set before running the
+                command. This may be seen as a generic <i>application
+              launcher</i>
+.</p>
+  <p>This may be combined with the global options
+    <tt>-pack=<i>package</i>
+  </tt>
+  ,
+    <tt>-version=<i>version</i>
+  </tt>
+  ,
+    <tt>-path=<i>access-path</i>
+  </tt>
+  , to give a direct access
+	    to any package context. </p>
+</blockquote>
+<hr><h4><a name="cmt set version &lt;version&gt;"></a><a href="#index"><tt>13.&nbsp;3.18</tt></a> - cmt set version &lt;version&gt;</h4>
+<blockquote>
+            This command creates and/or fills in the
+<tt>version.cmt</tt>
+ file for a package structured without
+            the version directory.
+  <p>This command has no effect when run in the context of a
+  	    package structured <i>with</i>
+ the version directory</p>
+  <p>This command must be run while being in the context of
+	    one CMT package.</p>
+</blockquote>
+<hr><h4><a name="cmt set versions"></a><a href="#index"><tt>13.&nbsp;3.19</tt></a> - cmt set versions</h4>
+<blockquote>
+              This command applies recursively the <tt>cmt set version
+            ...</tt>
+ command onto all used packages using a broadcast operation.
+  <p>Packages reached during the broadcast scan acquire
+  	    their version from the original use statement. This is
+  	    this specified version which will be stored inside the
+  <tt>version.cmt</tt>
+ files</p>
+</blockquote>
+<hr><h4><a name="cmt setup [-csh|-sh|-bat]"></a><a href="#index"><tt>13.&nbsp;3.20</tt></a> - cmt setup [-csh|-sh|-bat]</h4>
+<blockquote>
+            This command generates (to the standard output) a set of shell
+            commands (either for csh, sh or bat shell families) meant to
+            set all environment variables specified in the 
+<a HREF="#The requirements file">requirements</a>
+ files of the used
+            packages.
+  <p>This command is internally used in the
+  <tt>setup.[c]sh</tt>
+   or <tt>setup.bat</tt>
+   shell script,
+              itself generated by the <tt>cmt config</tt>
+ command.</p>
+</blockquote>
+<hr><h4><a name="cmt show &lt;option&gt;"></a><a href="#index"><tt>13.&nbsp;3.21</tt></a> - cmt show &lt;option&gt;</h4>
+<blockquote>
+  <ul>
+    <li><tt>all_tags</tt>
+  </li>
+    <p>This command displays all currently defined tags,
+  		  even when not currenty active</p>
+    <li><tt>applied_patterns</tt>
+  </li>
+    <p>This command displays all patterns actually applied
+                  in the current package</p>
+    <li><tt>author</tt>
+    <p></p>
+  </li>
+    <li><tt>branches</tt>
+    <p></p>
+  </li>
+    <li><tt>clients &lt;package&gt; [ &lt;version&gt; ]</tt>
+      <p>This command displays all packages that express an
+                        explicit <strong>use</strong>
+       statement onto the specified
+                        package. If no version is specified on the argument list,
+                      then all uses of that package are displayed.</p>
+      <p>Note that the search on clients is <i>not</i>
+                      performed recusively. Thus only clients explicitly
+                    using the specified package will be displayed.</p>
+    <p></p>
+  </li>
+    <li><tt>constituent_names</tt>
+    <p></p>
+  </li>
+    <li><tt>constituents</tt>
+    <p></p>
+  </li>
+    <li><tt>cycles</tt>
+      <p>This command displays all cycles in the use graph
+                      of the current package. Although CMT smoothly accepts
+                      such cycles, it is generally a bad practice to have
+                      cycles in a use graph, because CMT can never decide on
+                      the prefered entry point in the cycle, leading to
+                      somewhat unpredictable results, eg in constructing the
+      <tt>use_linkopts</tt>
+     macro.</p>
+    <p></p>
+  </li>
+    <li><tt>fragment &lt;name&gt;</tt>
+      <p>This command displays the actual location where the
+                        specified make fragment is currently found by <tt>CMT</tt>
+      ,
+                      taking into account possible overridden definitions.</p>
+      <li><tt>fragments</tt>
+      <p>Display the effective location of all declared make fragments </p>
+      <p></p>
+    </li>
+      <li><tt>groups</tt>
+        <p>This command displays all groups possibly defined
+                        in constituents of the current package (using the
+          <tt>-group=&lt;<i>group-name</i>
+        &gt;</tt>
+       option).</p>
+      <p></p>
+    </li>
+      <li><tt>languages</tt>
+        <p>Display al languages declared using the <tt>language</tt>
+       keyword</p>
+      <p></p>
+    </li>
+      <li><tt>macro &lt;name&gt;</tt>
+      <br></br>
+      <tt>set &lt;name&gt;</tt>
+      <br></br>
+      <tt>action &lt;name&gt;</tt>
+        <p>This set of commands displays a quite detailed
+                        explanation on the value assigned to the symbol
+                        (macro, set or action) specified as the additional
+                        argument. It presents in particular each intermediate
+                        assignments made to this symbol by the hierarchy of
+                        used statements, as well as the final result of these
+                      assignment operations. </p>
+        <p>By adding a <tt>-tag=&lt;tag&gt;</tt>
+         option to this
+                        command, it is possible to simulate the behaviour of
+                        this command in another context, without actually
+                        going to a machine or an operating system where this
+                      configuration is defined. </p>
+      <p></p>
+    </li>
+      <li><tt>macro_value &lt;name&gt;</tt>
+      <br></br>
+      <tt>set_value &lt;name&gt;</tt>
+      <br></br>
+      <tt>action_value &lt;name&gt;</tt>
+        <p>This set of commands displays the raw value
+                        assigned to the symbol (macro, set or action)
+                        specified as the additional argument. It only presents
+                        the final result of the assignment operations
+                      performed by used packages. </p>
+        <p>By adding a <tt>-tag=&lt;tag></tt>
+         option to this
+                        command, it is possible to simulate the behaviour of
+                        this command in another context, without actually
+                        going to a machine or an operating system where this
+                      configuration is defined.</p>
+        <p>The typical usage of the <tt>show macro_value</tt>
+                        command is to get at the shell level (rather than
+                        within a <tt>Makefile</tt>
+        ) the value of a macro
+                        definition, providing means of accessing them (quite
+                      similarly to an environment variable) : </p>
+<pre>
+csh&gt; set compiler=`cmt show macro_value cppcomp` 
+csh&gt; ${compiler} .... </pre>
+    </li>
+      <li><tt>macros</tt>
+      <br></br>
+      <tt>sets</tt>
+      <br></br>
+      <tt>actions</tt>
+        <p>This set of commands extracts from the
+        <tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+         file(s) the complete set of
+                        symbol (macro, set or action) definitions, selects the
+                        appropriate <i>tag</i>
+         definition (or uses the one
+                        provided in the <tt>-tag=&lt;tag&gt;</tt>
+         option) and
+                        displays the effective symbol values corresponding to
+                      this tag. </p>
+        <p>This command is typically used to show the
+                        effective list of macros used when running make and
+                        can be also used to build, as an argument list, the
+                      make command as follows : </p>
+<pre>
+csh&gt; eval make `cmt show macros` </pre>
+        <p>This use of <tt>cmt show macros</tt>
+         is directly
+                        installed within the default target provided in the
+                        standard <tt>Makefile.header</tt>
+         file.  Therefore if
+                        this file is included into the package's
+        <tt>Makefile</tt>
+        , macro definitions provided in the
+        &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; files (the one of the currently
+                        built package as well as the ones of the used
+                        packages) will be expanded and provided as arguments
+                      to make. </p>
+        <p>By adding a <tt>-tag=&lt;tag&gt;</tt>
+         option to this
+                        command, it is possible to simulate the behaviour of
+                        this command in another context, without atcually
+                        going to a machine or an operating system where this
+                      configuration is defined. </p>
+    </li>
+      <li><tt>manager</tt>
+      <p></p>
+    </li>
+      <li><tt>packages</tt>
+        <p>This command displays all packages (and all
+                        versions of them) currently reachable through the
+                          current <a href="#Localizing a package">access
+                        path</a>
+         definition (which can be displayed using the
+        <tt>cmt show path</tt>
+       command).</p>
+      <p></p>
+    </li>
+      <li><tt>path</tt>
+        <p>This command displays the complete and effective <a href="#Localizing a package">access path</a>
+         currently
+                      defined using any possible alternate way.</p>
+    </li>
+      <li><tt>pattern &lt;name&gt;</tt>
+        <p>This command displays how and where the specified
+                        pattern is defined, and which packages do apply
+                      it.</p>
+    </li>
+  </li>
+    <li><tt>patterns</tt>
+    <p>This command displays all pattern definitions.</p>
+  </li>
+    <li><tt>projects</tt>
+      <p>This command displays the current knowledge of
+             sub-project definitions and settings. It shows the
+                      project names and their location (ie the corresponding
+                      item in <tt>CMTPATH</tt>
+    </p>
+<pre>
+&gt; cmt show projects
+<i><font COLOR="#000077" face="courier new, courier">PA (in C:\Arnault\test\tprojects\PC) (current)
+Project1 (in C:\Arnault\test\tprojects\PB)
+PA (in C:\Arnault\test\tprojects\PA\1.1)
+Project2 (in C:\Arnault\test\tprojects\P0)
+CMT (in C:\Arnault)</font></i></pre>
+    <p></p>
+  </li>
+    <li><tt>pwd</tt>
+      <p>This command displays a filtered version of the
+                        standard <tt>pwd</tt>
+       unix command. The applied filter takes
+                        into account the set of aliases installed in the standard
+                        configuration file located in
+      <tt>${CMTROOT}/mgr/cmt_mount_filter</tt>
+    .</p>
+      <p>This configuration file contains a set of path aliases
+                        (one per line) each proposing a translation for
+                        non-portable file paths (imposed by mount constraints on
+                      some contexts).</p>
+  </li>
+    <li><tt>setup</tt>
+    <p>This command combines in one go the output of:</p>
+<pre>
+&gt; cmt show uses
+&gt; cmt show tags
+&gt; cmt show path</pre>
+    <p></p>
+  </li>
+    <li><tt>strategies</tt>
+    <p></p>
+  </li>
+    <li><tt>tags</tt>
+  </li>
+    <p>This command displays all currently <i>active</i>
+    		  tags, and what part of the configuration actually
+  		  activates them</p>
+    <li><tt>uses</tt>
+      <p>This command displays the use graph fo the current
+                       package. Private sections of used packages are
+                       reached and considered. This behavior can be changed
+                       to effectively hide the private sections in used
+                       packages by using the <tt>-public</tt>
+     modifier</p>
+<pre>
+&gt; cmt -public show uses</pre>
+    <p>A typical output produced by this command is:</p>
+<pre>
+&gt; cmt show uses 
+<i><font COLOR="#000077" face="courier new, courier"># use GaudiPolicy v*                             [1]
+# use GaudiKernel v* 
+#   use GaudiPolicy v5r*                         [2]
+# use CLHEP v*  (native_version=1.8.2.0)         [3]
+#   use ExternalLibs v4r* 
+#
+# Selection :                                    [4]
+use CMT v1r19 (/afs/cern.ch/sw/contrib)
+use ExternalLibs v4r2p0  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)    [5]
+use CLHEP v2r1820p0  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)
+use GaudiPolicy v5r11p2  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)
+use GaudiKernel v13r5p1  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)</font></i></pre>
+      <ol>
+        <li>The first section of the display (up to the
+        <tt>Selection</tt>
+         keyword) displays the
+                           hierarchical use graph.
+          <p>Use statements as specified in the requirements
+                             files are displayed, rather than the result of the
+                           effective selection performed by CMT</p>
+        <p></p>
+      </li>
+        <li>Sub-uses are expanded only once and indented
+                           according to the depth in the graph<p></p>
+      </li>
+        <li>Various precisions on the use statements are
+                           shown in the first section, such as the scoping
+                           section, the <tt>-no_auto_imports</tt>
+         modifier,
+                           and the <i>native version</i>
+         of this package, (when
+                           a <tt>&lt;package&gt;_native_version</tt>
+         macro has
+                           been defined)<p></p>
+      </li>
+        <li>The second section shows the effective ordered
+                           set of use statements resolved by CMT according to
+                           the combined use specifications.<p></p>
+      </li>
+        <li>On every line the effective location of the
+                           found package is displayed.<p></p>
+      </li>
+    </ol>
+      <p>The <tt>-quiet</tt>
+       option may be used to remove the
+                      first section from the output so as to only display a
+                      simple list of used packages, starting from the
+                    deepest uses.</p>
+    <p></p>
+  </li>
+    <li><tt>use_paths &lt;target-package&gt;</tt>
+  </li>
+    <p>This command displays all possible paths between
+                    the current package and the specified used target
+                  package.</p>
+    <p>In particular this will detect if a package has no
+                    access to another one, due to private use
+                  statements</p>
+    <li><tt>version</tt>
+    <p>This command displays the version tag of the current package.</p>
+  </li>
+    <li><tt>versions &lt;name&gt;</tt>
+      <p>This command displays the reachable versions of the
+                      specified package, looking at the current access paths.</p>
+  </li>
+</ul>
+</blockquote>
+<hr><h4><a name="cmt system"></a><a href="#index"><tt>13.&nbsp;3.22</tt></a> - cmt system</h4>
+<blockquote>
+            This command displays the current value assigned by default to 
+            the <tt>CMTCONFIG</tt>
+ environment variable. 
+</blockquote>
+<hr><h4><a name="cmt unlock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]"></a><a href="#index"><tt>13.&nbsp;3.23</tt></a> - cmt unlock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]</h4>
+<blockquote>
+            This command tries to remove a lock from the current package (or from the
+            specified package). This consists in the following operations:
+  <p>
+    <ol>
+      <li>Check if a conflicting lock is already set onto this
+                        package (ie. a lock owned by another user).
+    </li>
+      <li>If not, then remove the text file named <tt>lock.cmt</tt>
+       from the
+      <tt>cmt/mgr</tt>
+       branch of the package.
+    </li>
+      <li>Run a shell command described in the macro named <tt>unlock_command</tt>
+       meant to remove physical locks from all files for this version of this package. A typical definition for this macro could be:
+<pre class="cmt">
+macro unlock_command "chmod -R g+w ../*" \
+      WIN32          "attrib /S /D -R ../*"</pre>
+    </li>
+  </ol>
+</p>
+</blockquote>
+<hr><h4><a name="cmt version | --version"></a><a href="#index"><tt>13.&nbsp;3.24</tt></a> - cmt version | --version</h4>
+<blockquote>
+            This command shows the current verion of <tt>CMT</tt>
+, including (if 
+            applicable) the actual patch level. This always corresponds to 
+            the corresponding CVS tag assigned to <tt>CMT</tt>
+ sources. 
+</blockquote>
+<hr><h4><a name="cmt cvstags &lt;module&gt;"></a><a href="#index"><tt>13.&nbsp;3.25</tt></a> - cmt cvstags &lt;module&gt;</h4>
+<blockquote>
+            (see the section on <i>how tu use </i>
+<tt>CVS</tt>
+  <i>together 
+                                                              with CMT</i>
+ for more details on this command) 
+</blockquote>
+<hr><h4><a name="cmt cvsbranches &lt;module&gt;"></a><a href="#index"><tt>13.&nbsp;3.26</tt></a> - cmt cvsbranches &lt;module&gt;</h4>
+<blockquote>
+</blockquote>
+<hr><h4><a name="cmt cvssubpackages &lt;module&gt;"></a><a href="#index"><tt>13.&nbsp;3.27</tt></a> - cmt cvssubpackages &lt;module&gt;</h4>
+<blockquote>
+</blockquote>
+<hr><h4><a name="cmt cvssubprojects &lt;module&gt;"></a><a href="#index"><tt>13.&nbsp;3.28</tt></a> - cmt cvssubprojects &lt;module&gt;</h4>
+<blockquote>
+</blockquote>
+</blockquote>
+<hr><h3><a name="The setup and cleanup scripts"></a><a href="#index"><tt>13.&nbsp;4</tt></a> - The setup and cleanup scripts</h3>
+<blockquote>
+          They are produced by the <tt>cmt config</tt>
+ command and their 
+          contents is built according to the specifications stored in the 
+<tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+ file. 
+  <p>One flavour of these scripts is generated per shell family
+              (<tt>csh</tt>
+  , <tt>sh</tt>
+   and <tt>bat</tt>
+  ), yielding the following
+            scripts :</p>
+<pre>
+setup.csh 
+setup.sh 
+setup.bat
+cleanup.csh 
+cleanup.sh </pre>
+<p>The main sections installed within a setup script are : </p>
+  <ol>
+    <li>
+                  Connection to the current version of the <tt>CMT</tt>
+     package. 
+  </li>
+    <li> Setting the set of user defined public variables
+                specified in the &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file (including those
+                defined by all used packages). This is achieved by running
+                the <tt>cmt setup</tt>
+     utility into a temporary file and
+              running this temporary file.  </li>
+    <li>
+                  Activation of the user defined setup and cleanup scripts 
+                  (those specified using the <tt>setup_script</tt>
+     and 
+    <tt>cleanup_script</tt>
+     statements). 
+  </li>
+</ol>
+          It should be noted that these setup scripts do <i>not</i>
+          contain machine specific information (due to the online use of 
+          the <tt>cmt setup</tt>
+ command).  Therefore, it is perfectly 
+          possible to use the same setup script on various platforms (as 
+          soon as they share the directories) and this also shows that the 
+          configuration operation (the <tt>cmt config</tt>
+ command) is 
+          required only once for a set of multiple platforms sharing a 
+          development area. 
+</blockquote>
+<hr><h3><a name="cmt build prototype"></a><a href="#index"><tt>13.&nbsp;5</tt></a> - cmt build prototype</h3>
+<blockquote>
+          This command is only provided for development of <tt>C</tt>
+          modules. It generates a <tt>C</tt>
+ header file containing the 
+          set of prototype statements for all public functions of a given 
+          module. Its output is a file with the same name as the input 
+          source (given as the argument) and suffixed with <tt>.ph</tt>
+. 
+  <p>The generated prototype header file is meant to be included 
+            whereever it is needed (in the module file itself for instance). </p>
+  <p>A typical example of the use of <tt>cmt build prototype</tt>
+            could be : </p>
+<pre>
+csh&gt; cd ../src 
+csh&gt; cmt build prototype FooA.c 
+<i><font COLOR="#000077" face="courier new, courier">Building FooA.ph </font></i></pre>
+  <p>Running <tt>cmt build prototype</tt>
+   will only produce a new 
+              prototype header file if the output is actually different from 
+              the existing one (if it exists) in order to avoid confusing 
+  <i>make</i>
+ checks. </p>
+  <p>The effective use of this facility (which may not be
+              appropriate in all projects) is controlled by one option of the
+            build strategy, which can take one of the two values:</p>
+<pre class="cmt">
+build_strategy prototypes
+build_strategy no_prototypes</pre>
+  <p>In addition to this global strategy specification, each
+              application or library may individually override it using the
+  <tt>-prototypes</tt>
+   or <tt>-no_prototypes</tt>
+ options.</p>
+  <p>Lastly, the actual behaviour of the prototype generator is
+              defined in the standard make macro <tt>build_prototype</tt>
+   (which
+              default to call the <tt>cmt build prototype</tt>
+   command, allowing
+            a user defined behavious to this feature)</p>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Using cvs together with CMT"></a><a href="#index"><tt>14</tt></a> - Using cvs together with CMT</h2>
+<blockquote>
+  <p>Nothing special is apriori required by <tt>CMT</tt>
+   with respect to
+    the use of <tt>CVS</tt>
+  .  Nevertheless, one may advertize some well
+    tested conventions and practices which turned out to ensure a good
+  level of consistency between the two utilities.</p>
+  <p>Although none of these are required, the <tt>cmt</tt>
+   general
+    command provides a few utilities so as to simplify the use of these
+    practices. It should be noted that the added features provided by
+    cmt rely on the possibility to <i>query</i>
+   CVS about the existing
+  <tt>CMT</tt>
+   packages and the possible tags setup for these
+    packages. CVS does not by default permit such query operations
+    (since they require to scan the physical CVS repository). Therefore
+  <tt>CMT</tt>
+   provides a hook to CVS (based upon standard CVS features
+    - not patches) for this. This hook can be installed following a
+    recipe explained in the dedicated 
+  <a href="#The internal mechanism of cmt cvs operations">appendix</a>
+.</p>
+<hr><h3><a name="Importing a package into a cvs repository"></a><a href="#index"><tt>14.&nbsp;1</tt></a> - Importing a package into a cvs repository</h3>
+<blockquote>
+  <p>Generally, everything composing a package (below the
+  <i>version</i>
+   directory and besides the <i>binary</i>
+      directories) is relevant to be imported.  Then choosing a
+  <tt>cvs</tt>
+  <i>module</i>
+   name is generally done on the basis of
+      the package name. Taking the previous examples, one could import
+      the <tt>Foo</tt>
+ package as follows :</p>
+<pre>
+csh&gt; cd ...../Foo/v1 
+csh&gt; cvs import -m "First import" -I alpha -I hp9000s700 Foo LAL v1 </pre>
+<p>In this example, </p>
+  <ul>
+    <li>
+            we have ignored the currently existing binary directories 
+            (here <tt>alpha</tt>
+     and <tt>hp9000s700</tt>
+    ) 
+  </li>
+    <li>
+            the <tt>cvs</tt>
+     module name is identical to the package 
+            name (<tt>Foo</tt>
+    ) 
+  </li>
+    <li>
+            the original symbolic insertion tag is identical to the 
+            version identifier (<tt>v1</tt>
+    ) 
+  </li>
+</ul>
+  <p>The choice of the module name can generally be identical to the
+      package name. However, some site specific management issues may
+      lead to different choices (typically, a top directory where groups
+    of packages are gathered may be inserted).</p>
+  <p>Conversely, using symbolic tags identical to version
+      identifiers appears to be a very good practice. The only
+      constraint induced by <tt>cvs</tt>
+   is that the symbolic tags may not
+      contain <i>dot</i>
+   characters (<tt>'.'</tt>
+  ), whereas no restriction
+      exist from <tt>CMT</tt>
+   itself. Thus version identifiers like
+  <tt>v3r2</tt>
+   will be preferred to the <tt>v3.2</tt>
+ form. </p>
+</blockquote>
+<hr><h3><a name="Checking a package out from a cvs repository"></a><a href="#index"><tt>14.&nbsp;2</tt></a> - Checking a package out from a cvs repository</h3>
+<blockquote>
+  <p>Assuming the previous conventions on module name and version
+      identifier have been selected when importing a package, the
+      following operations will naturally intervene when one need to
+      check a package out (typically to work on it or to install it on
+    some platform) : </p>
+<pre>
+csh&gt; cd &lt;some root&gt;            (1) 
+csh&gt; mkdir Foo                 (2) 
+csh&gt; cd Foo 
+csh&gt; cvs checkout -d v1 Foo    (3) 
+csh&gt; cd v1/cmt 
+csh&gt; cmt config                (4) 
+csh&gt; source setup.csh          (5) 
+csh&gt; [g]make                   (6) </pre>
+  <ol>
+    <li>
+            one always have to select a root directory where to settle 
+            down this copy of the extracted package. This may either be 
+            the so-called <i>default root</i>
+     or any other appropriate 
+            directory. In both cases, the next <tt>cmt config</tt>
+            operation will automatically take care of this effective 
+            location. 
+  </li>
+    <li>
+            creating a base directory with the package name is mandatory 
+            here, and is <i>not</i>
+     taken into account by <tt>cvs</tt>
+            during the <i>chaeckout</i>
+     operation since one wants to 
+            insert the <i>version</i>
+     branch in between. 
+  </li>
+    <li>
+            the package is checked out into a directory named with the 
+            expected version identifier exactly corresponding to the 
+            version currently stored in the <tt>cvs</tt>
+            repository. 
+  </li>
+    <li>
+            then using the <tt>cmt config</tt>
+     command (from the 
+    <tt>cmt</tt>
+     branch) will update the setup scripts against 
+              the <tt><a HREF="#The requirements file">requirements</a>
+    </tt>
+     file and the effective current 
+            package location. 
+  </li>
+    <li>
+            using this updated version of the setup script provides the 
+            appropriate set of environment variables 
+  </li>
+    <li> lastly, rebuilding the entire package is possible simply
+            using the <tt>[g]make</tt>
+     command.
+  </li>
+</ol>
+  <p>The actions decribed just above (from number 2 to number 4
+      included) can also be performed using the <tt>cmt checkout</tt>
+    command. </p>
+<pre>
+&gt; cd &lt;some work area&gt; 
+&gt; cmt checkout [modifier ...] &lt;package&gt; ... 
+<i><font COLOR="#000077" face="courier new, courier">                  
+modifier :
+-l        Do not process used packages (default).
+-R        Process used packages recursively.
+-r rev    Check out version tag. (is sticky)
+-d dir    Check out into dir instead of module name.
+-o offset Offset in the CVS repository
+-n        Simulation mode on
+-v        Verbose mode on
+-help     Print this help</font></i></pre>
+    Thus the previous example would become:
+<pre>
+csh&gt; cd &lt;some root&gt;
+csh&gt; cmt checkout Foo
+csh&gt; cd Foo/v1/cmt 
+csh&gt; source setup.csh
+csh&gt; [g]make</pre>
+</blockquote>
+<hr><h3><a name="Querying CVS about some important infos"></a><a href="#index"><tt>14.&nbsp;3</tt></a> - Querying CVS about some important infos</h3>
+<blockquote>
+    It is possible, using the commands :
+  <ul>
+    <li>
+    <tt>cmt cvstags &lt;module&gt;</tt>
+  </li>
+    <li>
+    <tt>cmt cvsbranches &lt;module&gt;</tt>
+  </li>
+    <li>
+    <tt>cmt cvssubpackages &lt;module&gt;</tt>
+  </li>
+    <li>
+    <tt>cmt cvssubprojects &lt;module&gt;</tt>
+  </li>
+</ul>
+  <p> to query the <tt>CVS</tt>
+   repository about the existing tags
+      installed onto a given <tt>CVS</tt>
+   module, the subdirectories and
+      the subpackages (in the <tt>CMT</tt>
+     meaning, i.e. when a <tt><a HREF="#The requirements file">requirements</a>
+  </tt>
+   file
+    exists). </p>
+<pre>
+&gt; cmt cvstags Cm 
+<i><font COLOR="#000077" face="courier new, courier">v7r6 v7r5 v7r4 v7r3 v7r1 v7 </font></i>
+&gt; cmt cvstags Co 
+<i><font COLOR="#000077" face="courier new, courier">v3r7 v3r6 v3 </font></i></pre>
+  <p>One should notice here that the <tt>cvstags</tt>
+   command can give
+      informations about any type of module, even if it is not managed
+      in the <tt>CMT</tt>
+ environment. </p>
+  <p>However, in order to let this mechanism operate, it is required
+      to install some elements into the physical <tt>CVS</tt>
+   repository
+      (<i> which may require some access rights into it</i>
+  ). This
+      installation procedure (to be done only once in the life of the
+    repositiory) can be achieved through the following command:</p>
+<pre>
+sh&gt; (cd ${CMTROOT}/mgr; gmake installcvs)</pre>
+  <p>However, the details of the procedure is listed below (this
+      section is preferably reserved for system managers and can easily
+    be skipped by standard users):</p>
+  <ol>
+    <li> copy the <tt>cmt_buildcvsinfos2.sh</tt>
+     shell script into the
+          management directory <tt>${CVSROOT}/CVSROOT</tt>
+     as follows :
+<pre>
+sh&gt; cp ${CMTROOT}/mgr/cmt_buildcvsinfos2.sh ${CVSROOT}/CVSROOT </pre>
+  </li>
+    <li> install one special statement in the <tt>loginfo</tt>
+          administrative file as follows :
+<pre>
+sh&gt; cd ... 
+sh&gt; cvs checkout CVSROOT 
+sh&gt; cd CVSROOT 
+sh&gt; vi loginfo 
+... 
+.cmtcvsinfos $CVSROOT/CVSROOT/cmt_buildcvsinfos2.sh 
+sh&gt; cvs commit -m "set up commitinfo for CMT" </pre>
+  </li>
+</ol>
+</blockquote>
+<hr><h3><a name="Working on a package, creating a new release"></a><a href="#index"><tt>14.&nbsp;4</tt></a> - Working on a package, creating a new release</h3>
+<blockquote>
+  <p>This section presents the way to instanciate a new release of
+      a given package, which happens when the foreseen modifications
+      will yield additions or changes to the application programming
+    interface of the package. </p>
+  <p>Then the version tag is supposed to be moved forward, either
+      increasing its minor identifier (in case of simple additions) or
+    its major identifier (in case of changes). </p>
+<p>The following actions should be undertaken then : </p>
+  <ol>
+    <li>
+            understand what is the latest version tag (typically by 
+            using the <tt>cmt cvstags</tt>
+     command). Let's call it 
+    <tt>old-tag</tt>
+    . 
+    <p></p>
+  </li>
+    <li>
+            select (according to the foreseen amount of changes) what 
+            will be the next version tag. Let's call it 
+    <tt>new-tag</tt>
+    . 
+    <p></p>
+  </li>
+    <li>
+            check the most recent version of the package in your 
+            development area : 
+<pre>
+sh&gt; cd &lt;development area&gt; 
+sh&gt; cvs checkout -d &lt;new-tag&gt; &lt;package&gt; </pre>
+  </li>
+    <li>
+            configure this new release, and rebuild it : 
+<pre>
+sh&gt; cd &lt;new-tag&gt;/cmt 
+sh&gt; cmt config 
+sh&gt; source setup.csh 
+sh&gt; [g]make </pre>
+  </li>
+</ol>
+</blockquote>
+<hr><h3><a name="Getting a particular tagged version out of CVS"></a><a href="#index"><tt>14.&nbsp;5</tt></a> - Getting a particular tagged version out of CVS</h3>
+<blockquote>
+  <p>The previous example presented the standard case where one gets
+        the <i>most recent</i>
+   version of a given package. The procedure
+        is only slightly modified when one wants to extract a previously
+        tagged version. Let's imagine that the <tt>Foo</tt>
+   package has
+        evolved by several iterations, leading to several tagged
+        releases in the <tt>cvs</tt>
+   repository (say <tt>v2</tt>
+   and
+  <tt>v3</tt>
+  ). If the <tt>v2</tt>
+   release is to be used (e.g. for
+        understanding and fixing a problem discovered in the running
+      version) one will operate as follows :</p>
+<pre>
+csh&gt; cd &lt;some root&gt; 
+csh&gt; mkdir Foo 
+csh&gt; cd Foo 
+csh&gt; cvs checkout -d v2 -r v2 Foo
+csh&gt; cd v2/cmt 
+csh&gt; cmt config 
+csh&gt; source setup.csh 
+csh&gt; make </pre>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Interfacing an external package with CMT"></a><a href="#index"><tt>15</tt></a> - Interfacing an external package with CMT</h2>
+<blockquote>
+  <p>Very often, external packages (typically commercial products, or
+    third party software) are to be used by packages developped in the
+    context of the <tt>CMT</tt>
+   environment. Although this can obviously
+    done simply by specifying compiler or linker options internally to
+    the client packages, it can be quite powerful to interface these
+    so-called <i>external</i>
+   packages to <tt>CMT</tt>
+   by defining a
+  <i>glue</i>
+   package, where configuration specifications for this
+  external package are detailed.</p>
+<p>Using this approach, one may : </p>
+  <ul>
+    <li>
+                provide a <i>nickname</i>
+     for this external package, 
+  </li>
+    <li>
+                adapt the version tag convention consistently to the
+                project, hiding the version tag specificities of
+                eg. commercial packages.
+  </li>
+    <li>
+                provide compiler options using the the standard make macros 
+    <tt>&lt;package>_cflags</tt>
+    , <tt>&lt;package>_cppflags</tt>
+                or <tt>&lt;package>_fflags</tt>
+    , 
+  </li>
+    <li>
+                specify a set of search paths for the include files, using 
+                the <tt>include_dirs</tt>
+     statement, 
+  </li>
+    <li>
+                provide linker options using the the standard make macros 
+    <tt>&lt;package>_linkopts</tt>
+  </li>
+</ul>
+        Let's consider the example of the <tt>OPACS</tt>
+ package. This 
+        package is provided outside of the <tt>CMT</tt>
+        environment. Providing a directory tree following the 
+<tt>CMT</tt>
+ conventions (ie. a branch named after the version 
+        identifier, then an <tt>cmt</tt>
+ branch) then a 
+<tt>&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;</tt>
+ file, containing (among other statements 
+        not shown for the sake of clarity) : 
+<pre class="cmt">
+package OPACS 
+
+include_dirs ${Wo_root}/include ${Co_root}/include ${Xx_root}/include \
+${Ho_root}/include ${Go_root}/include ${Xo_root}/include 
+
+public 
+macro OPACS_cflags      "-DHAS_XO -DHAS_XM" 
+macro OPACS_cppflags    " $(OPACS_cflags) " 
+
+macro OPACS_linkopts    "$(Wo_linkopts) $(Xo_linkopts) $(Go_linkopts) \
+$(Glo_linkopts) $(Xx_linkopts) $(Ho_linkopts) $(Htmlo_linkopts) \
+$(W3o_linkopts) $(Co_linkopts) $(X_linkopts)" </pre>
+  <p>Then every package or application, client of this 
+  <tt>OPACS</tt>
+   package would have just to provide a use 
+  statement like : </p>
+<pre class="cmt">
+use OPACS v3 </pre>
+  <p>This procedure gives the complete benefit of the use 
+            relationships between packages (a client application 
+            transparently inherits all configuration specifications) while 
+            keeping unchanged the original referenced package, allowing to 
+            apply this approach even to commercial products so that they 
+            may be integrated in resource usage surveys similarly to local 
+          packages. </p>
+</blockquote>
+<hr><h2><a name="The installation area mechanism"></a><a href="#index"><tt>16</tt></a> - The installation area mechanism</h2>
+<blockquote>
+  <p>CMT proposes and implements a flexible architecture for
+    installation areas, meant to group the results of the build process
+    or any other information belonging to packages into shared disk
+    spaces. The typical usage of such installation areas is classical
+    and expect to make only visible to the clients of a given
+    (sub-)project the results of the build process while hiding the
+  details of the package sources.</p>
+<p>the basics of the mechanisms supported by CMT are the following:</p>
+  <ol>
+    <li>The installation area mechanism is activated on demand via a
+        dedicated strategy specification, that can be written either in a
+        requirements file or in a project file. By default the mechanism
+        is <i>not</i>
+     active.<p></p>
+  </li>
+    <li>All mechanisms are customizable on a per-project basis,
+        so as to easily follow the project specific conventions<p></p>
+  </li>
+    <li>However CMT proposes a minimal default behaviour based on the
+        concrete experience in large projects, as well as frequently met
+        practices<p></p>
+  </li>
+    <li>A typical well supported convention is to map the set of
+        installation areas onto the set of CMTPATH entries, associating the
+        concept of CMTPATH splitting with the sub-project
+        organization<p></p>
+  </li>
+    <li>A typical consequence of this approach is that many
+        configuration parameters need to be set according to the list of
+        CMTPATH items. Eg on a Unix system, if one expects to find shared
+        libraries in every installation area, each of them being created
+        in a corresponding CMTPATH entry, one also expects to have
+        LD_LIBRARY_PATH entries accordingly. The mechanism of
+    <tt>cmtpath_pattern</tt>
+     is exactly designed for that.<p></p>
+  </li>
+    <li>The mechanism easily supports the extension for installing
+        binary files (libraries, applications, java classes), runtime
+        files, documentation and header files.<p></p>
+  </li>
+</ol>
+<hr><h3><a name="The default implementation"></a><a href="#index"><tt>16.&nbsp;1</tt></a> - The default implementation</h3>
+<blockquote>
+<p>It is provided in terms of</p>
+  <ol>
+    <li>
+            A set of <tt>cmtpath_pattern</tt>
+    s defined in the CMT requirements
+            file. This can be displayed using the command
+<pre>
+&gt; cmt show cmtpath_patterns</pre>
+    <p></p>
+  </li>
+    <li>
+            A consistent set of actions added to the following make_fragments
+      <table>
+          <tr><td><tt>application</tt>
+        </td>
+        <td>applications</td>
+      </tr>
+          <tr><td><tt>library</tt>
+        </td>
+        <td>shared libraries</td>
+      </tr>
+          <tr><td><tt>library_no_share</tt>
+        </td>
+        <td>static libraries</td>
+      </tr>
+          <tr><td><tt>java_header</tt>
+        </td>
+        <td>Java applications</td>
+      </tr>
+          <tr><td><tt>jar</tt>
+        </td>
+        <td>Java libraries</td>
+      </tr>
+    </table>
+    <p></p>
+  </li>
+    <li>
+    <p>One shell script for installing or uninstalling files or directories</p>
+<pre>
+${CMTROOT}/mgr/cmt_install_action.sh
+${CMTROOT}/mgr/cmt_uninstall_action.sh
+${CMTROOT}/mgr/cmt_install_action.bat
+${CMTROOT}/mgr/cmt_uninstall_action.bat</pre>
+    <p></p>
+  </li>
+    <li>
+      <p>The default architecture of this installation scheme is by
+          default set for each CMTPATH entry to:</p>
+<pre>
+&lt;path&gt;/$(&lt;project&gt;_installarea_prefix)/$(tag)/bin/...                [1]
+                                      /$(tag)/lib/...                [2]
+                                      /include/&lt;package&gt;/...         [3]
+                                      /share/bin/...                 [4]
+                                      /share/lib/...                 [5]
+                                            /...                     [6]
+                                      /doc/&lt;package&gt;/...             [7]
+                                          /...                       [8]</pre>
+      <ol>
+      <li>Platform dependent executables</li>
+      <li>Platform dependent libraries</li>
+      <li>Public header files </li>
+      <li>Platform independent applications (eg Java applications)</li>
+      <li>Platform independent libraries (eg Java libraries)</li>
+      <li>other platform independent files</li>
+      <li>package specific documentations</li>
+      <li>project-wide documentation</li>
+    </ol>
+      <p>The <tt>&lt;project&gt;_installarea_prefix</tt>
+       takes the
+            default value of <tt>$(cmt_installarea_prefix)</tt>
+       for all
+            projects, which itself takes the default value of
+      <tt>InstallArea</tt>
+      . Of course it can be overridden to other
+          values in each project</p>
+  </li>
+</ol>
+  <p>The <tt>cmtpath_patterns</tt>
+   are designed in this
+      implementation for constructing a proper and consistent sequence
+      of system specific environment variables (eg <tt>PATH</tt>
+  ,
+  <tt>LD_LIBRARY_PATH</tt>
+  , <tt>CLASSPATH</tt>
+  ) as well as compiler
+      or linker options so as to transparently refer to the installation
+      area only when it is appropriate to ovverride the local
+    patterns.</p>
+</blockquote>
+<hr><h3><a name="Tuning the installation area mechanisms"></a><a href="#index"><tt>16.&nbsp;2</tt></a> - Tuning the installation area mechanisms</h3>
+<blockquote>
+  <p>First of all every individual sub-project may activate or
+      inhibit the installation area mechanisms using the
+  <tt>build_strategy</tt>
+   statement, with either
+  <tt>with_installarea</tt>
+   or <tt>without_installarea</tt>
+    option.</p>
+  <p>Then a dedicated tag materializes the selected strategy:
+  <tt>&lt;project&gt;_with_installarea</tt>
+   or
+  <tt>&lt;project&gt;_without_installarea</tt>
+</p>
+  <p>This tag set will be used in various macro or set definitions
+    to produce or not the appropriate values</p>
+  <p>CMT manipulate some standard macros or environment variables
+    according to the effective strategy:</p>
+  <table cellspacing="0" border="1">
+    <tr>
+        <td><center><i>name</i>
+      </center>
+    </td>
+        <td><center><i>purpose</i>
+      </center>
+    </td>
+        <td><center><i>default</i>
+      </center>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>cmt_installarea_prefix</tt>
+    </td>
+    <td>The default prefix for all projects</td>
+      <td><tt>InstallArea</tt>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>&lt;project&gt;_installarea_prefix</tt>
+    </td>
+    <td>The prefix for a given sub-project</td>
+      <td><tt>$(cmt_installarea_prefix)</tt>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>&lt;project&gt;_installarea_prefix_remove</tt>
+    </td>
+    <td>The regexp pattern to cleanup symbols</td>
+      <td><tt>$(&lt;project&gt;_installarea_prefix)</tt>
+    </td>
+  </tr>
+    <tr>
+      <td><tt>cmt_installarea_linkopts</tt>
+    </td>
+    <td>Implicit linker options due to the installation area</td>
+    <td>...</td>
+  </tr>
+    <tr>
+      <td><tt>PATH</tt>
+    </td>
+    <td>Accessing the executables in the installation area</td>
+    <td>...</td>
+  </tr>
+    <tr>
+      <td><tt>LD_LIBRARY_PATH</tt>
+    </td>
+    <td>Accessing the shared libraries in the installation area</td>
+    <td>...</td>
+  </tr>
+    <tr>
+      <td><tt>CLASSPATH</tt>
+    </td>
+    <td>Accessing the jar files in the installation area</td>
+    <td>...</td>
+  </tr>
+</table>
+<p></p>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Installing CMT for the first time"></a><a href="#index"><tt>17</tt></a> - Installing CMT for the first time</h2>
+<blockquote>
+  <P>These sections are of interest only if <tt>CMT</tt>
+   is not yet 
+            installed on your site, of if you need a private 
+          installation. </P>
+  <P>The first question you need to answer is the location where 
+            to install <tt>CMT</tt>
+  . This location is typically a disk area where 
+          most of packages managed in your project will be located. </P>
+  <P>Then, you have to fetch the distribution kit from the Web at 
+  <A HREF="http://www.cmtsite.org">http://www.cmtsite.org</A>
+  . You 
+            must get at least the primary distribution kit containing the 
+            basic configuration information and the <tt>CMT</tt>
+   sources. This 
+            operation results in a set of directories hanging below the <tt>CMT</tt>
+            root and the version directory. The src branch contains the 
+            sources of <tt>CMT</tt>
+  , the fragments branch contains the makefile 
+            fragments and the mgr branch contains the scripts needed to build 
+            or operate <tt>CMT</tt>
+. </P>
+<hr><h3><a name="Installing CMT on your Unix site"></a><a href="#index"><tt>17.&nbsp;1</tt></a> - Installing CMT on your Unix site</h3>
+<blockquote>
+  <P>The very first operation after dowloading <tt>CMT</tt>
+            consists in running the <tt>INSTALL</tt>
+   shell script. This
+            will build the setup scripts required by any <tt>CMT</tt>
+          user. </P>
+  <P>Then you may either decide to build <tt>CMT</tt>
+   by yourself or fetch 
+              a pre-built binary from the same Web location. The prebuilt 
+              binary versions may not exist for the actual platform you are 
+              working on. You will see on the distribution page the precise 
+            configurations used for building those binaries. </P>
+  <P>In case you have to build <tt>CMT</tt>
+   yourself, you need a C++ 
+              compiler capable of handling templates (although the support for 
+              STL is not required). There is a Makefile provided in the 
+              distribution kit which takes g++ by default as the compiler. If 
+              you need a specific C++ compiler you will override the cpp macro 
+            as follows: </P>
+<pre>
+sh&gt; gmake cpp=CC </pre>
+  <P>The <tt>cppflags</tt>
+   macro can also be used to override the
+            behaviour of the compilation. </P>
+  <P>Another important concern is the way <tt>CMT</tt>
+   will identify the 
+              platform. <tt>CMT</tt>
+   builds a configuration tag per each type of 
+              platform, and uses this tag for naming the directory where all 
+              binary files will be stored. As such this tag has to be defined 
+              prior to even build <tt>CMT</tt>
+ itself. </P>
+  <P><tt>CMT</tt>
+   builds the default configuration by running the 
+              cmt_system.sh script found in the mgr branch of <tt>CMT</tt>
+  . Run it 
+              manually to see what is the default value provided by this 
+              script. You might consider changing its algorithm for your own 
+            convenience. </P>
+<p>A distribution kit may be obtained at the following URL : </p>
+<pre>
+http://www.cmtsite.org</pre>
+  <p>Once the <tt>tar</tt>
+   file has been downloaded, the 
+            following operations must be achieved : </p>
+  <ol>
+    <li>
+                  Select a root directory where to install 
+    <tt>CMT</tt>
+    . Typically this will correspond to a 
+                  development area or a public distribution area. 
+  </li>
+    <li>
+                  Import the distribution kit mentioned above. 
+  </li>
+    <li>
+                  Uncompress and untar it. 
+  </li>
+    <li>
+                  Configure <tt>CMT</tt>
+    . 
+  </li>
+    <li>
+                  CMT is ready to be used for developing packages. 
+  </li>
+</ol>
+<p>A typical corresponding session could look like : </p>
+<pre>
+csh&gt; cd /Packages 
+csh&gt; &lt;get the tar file from the Web&gt; 
+csh&gt; tar xzf CMTv1r19.tar.gz 
+csh&gt; cd CMT/v1r19/mgr 
+csh&gt; ./INSTALL 
+csh&gt; source setup.csh 
+csh&gt; gmake</pre>
+</blockquote>
+<hr><h3><a name="Installing CMT on a Windows or Windows NT site"></a><a href="#index"><tt>17.&nbsp;2</tt></a> - Installing CMT on a Windows or Windows NT site</h3>
+<blockquote>
+  <p>You first have to fetch the distribution kit from the Web at 
+  <A HREF="http://www.cmtsite.org">http://www.cmtsite.org</A>
+  . You 
+              must get at least the primary distribution kit containing the 
+              basic configuration information and the <tt>CMT</tt>
+   sources. This 
+              operation results in a set of directories hanging below the <tt>CMT</tt>
+              root and the version directory. The binary kit provided for 
+            Windows environments will generally fit your needs. </p>
+  <p>You should consider getting the pre-compiled (for a Windows
+              environment) applications, and especially the
+  <tt>..\VisualC\install.exe</tt>
+   application, which interactively
+              configures the registry entries as described in the
+            next paragraph.</p>
+  <p>The next operation consists in defining a few registries
+              (typically using the standard RegEdit facility or the
+  <tt>install.exe</tt>
+ special application): </p>
+  <UL>
+    <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/root</tt>
+     will
+                contain the root directory where <tt>CMT</tt>
+     is installed
+                (eg. <tt>"e:"</tt>
+  ). </li>
+    <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/version</tt>
+     will
+                contain the current version tag of <tt>CMT</tt>
+                (<tt>"v1r19"</tt>
+   for this version). </li>
+    <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/path/</tt>
+     may
+                optionally contain a set of text values corresponding to
+              the different package global access paths. </li>
+    <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/site</tt>
+     will
+              contain the conventional site name. </li>
+    <li><tt>HKEY_CURRENT_USER/Software/CMT/path/</tt>
+     may
+                contain a set of text of text values corresponding to the
+              different package private access paths. </li>
+</UL>
+  <p>CMT can also be configured to run on DOS-based environments
+              using the <tt>nmake</tt>
+   facility. In this case, the installation
+            procedure is very similar to the Unix one:</p>
+  <p>A typical corresponding session could look like : 
+<pre>
+dos&gt; cd Packages 
+dos&gt; &lt;get the tar file from the Web&gt; 
+dos&gt; cd CMT\v1r19\mgr 
+dos&gt; call INSTALL 
+dos&gt; call setup.bat
+dos&gt; nmake /f nmake</pre>
+</p>
+</blockquote>
+</blockquote>
+<hr><h2><a name="Appendices"></a><a href="#index"><tt>18</tt></a> - Appendices</h2>
+<blockquote>
+<hr><h3><a name="Copyright"></a><a href="#index"><tt>18.&nbsp;1</tt></a> - Copyright</h3>
+<blockquote>
+  <center><b>Copyright LAL and Christian Arnault LAL-Orsay CNRS</b>
+</center>
+  <center><tt>arnault@lal.in2p3.fr</tt>
+</center>
+  <p>This software is a computer program whose purpose is to describe and
+manage software configuration activities.</p>
+  <p>This software is governed by the CeCILL  license under French law and
+  abiding by the rules of distribution of free software.  You can  use, 
+  modify and/ or redistribute the software under the terms of the CeCILL
+  license as circulated by CEA, CNRS and INRIA at the following URL
+      <center><a href="http://www.cecill.info">
+<pre>http://www.cecill.info</pre>
+    </a>
+  </center>
+</p>
+  <p>As a counterpart to the access to the source code and  rights to copy,
+  modify and redistribute granted by the license, users are provided only
+  with a limited warranty  and the software's author,  the holder of the
+  economic rights,  and the successive licensors  have only  limited
+liability. </p>
+  <p>In this respect, the user's attention is drawn to the risks associated
+  with loading,  using,  modifying and/or developing or reproducing the
+  software by the user in light of its specific status of free software,
+  that may mean  that it is complicated to manipulate,  and  that  also
+  therefore means  that it is reserved for developers  and  experienced
+  professionals having in-depth computer knowledge. Users are therefore
+  encouraged to load and test the software's suitability as regards their
+  requirements in conditions enabling the security of their systems and/or 
+  data to be ensured and,  more generally, to use and operate it in the 
+same conditions as regards security. </p>
+  <p>The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.</p>
+</blockquote>
+<hr><h3><a name="Standard make targets predefined in CMT"></a><a href="#index"><tt>18.&nbsp;2</tt></a> - Standard make targets predefined in CMT</h3>
+<blockquote>
+<p>These targets can always be listed through the following command : </p>
+<pre>
+sh&gt; gmake help </pre>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+        <td width="200">
+          <center><i>target</i>
+        </center>
+      </td>
+        <td width="500">
+          <center><i>usage</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>help</tt>
+      </td>
+      <td>Get the list of possible make target for this package.</td>
+    </tr>
+      <tr>
+        <td><tt>all</tt>
+      </td>
+      <td>build all components of this package.</td>
+    </tr>
+      <tr>
+        <td><tt>clean</tt>
+      </td>
+      <td>remove everything that can be rebuilt by make</td>
+    </tr>
+      <tr>
+        <td><tt>binclean</tt>
+      </td>
+        <td>completely remove the <tt>../$(tag)</tt>
+       binary directory</td>
+    </tr>
+      <tr>
+        <td><tt>configclean</tt>
+      </td>
+      <td>remove all intermediate makefile fragments</td>
+    </tr>
+      <tr>
+        <td><tt>install</tt>
+      </td>
+      <td>install binaries of this package to the current installation area</td>
+    </tr>
+      <tr>
+        <td><tt>uninstall</tt>
+      </td>
+      <td>uninstall binaries of this package from the current installation area</td>
+    </tr>
+      <tr>
+        <td><tt>check</tt>
+      </td>
+      <td>run all applications defined with the -check option</td>
+    </tr>
+      <tr>
+        <td><i>component-name</i>
+      </td>
+        <td>only build this 
+                  particular component (as opposed to the <tt>all</tt>
+                  target that tries to build all components of this 
+                package)</td>
+    </tr>
+      <tr>
+        <td><i>group-name</i>
+      </td>
+        <td>build all constituents
+                        belonging to this group (ie. those defined using the same
+                      -group=&lt;group-name&gt; option)</td>
+    </tr>
+  </table>
+</p>
+<p>These targets have to be specified as follows : </p>
+<pre>
+sh&gt; gmake clean 
+sh&gt; gmake Foo </pre>
+</blockquote>
+<hr><h3><a name="Standard macros predefined in CMT"></a><a href="#index"><tt>18.&nbsp;3</tt></a> - Standard macros predefined in CMT</h3>
+<blockquote>
+<hr><h4><a name="CMT static macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;1</tt></a> - CMT static macros</h4>
+<blockquote>
+    These macros provide static data about CMT itself. They cannot be
+    modified by the user.
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+        <td width="150">
+          <center><i>macro</i>
+        </center>
+      </td>
+        <td width="300">
+          <center><i>usage</i>
+        </center>
+      </td>
+        <td width="200">
+          <center><i>default value</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>CMTrelease</tt>
+      </td>
+      <td>gives the current release number of CMT</td>
+        <td><tt>19</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>CMTVERSION</tt>
+      </td>
+      <td>gives the current complete version tag of CMT</td>
+        <td><tt>v1r19</tt>
+      </td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="Structural macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;2</tt></a> - Structural macros</h4>
+<blockquote>
+    These macros describe the structural conventions followed by
+<tt>CMT</tt>
+. They receive a conventional default value from the
+<tt>CMT</tt>
+ requirements file. However, they can be overridden in
+    any package for its own needs.
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+        <td width="150">
+          <center><i>macro</i>
+        </center>
+      </td>
+        <td width="300">
+          <center><i>usage</i>
+        </center>
+      </td>
+        <td width="200">
+          <center><i>default value</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>tag</tt>
+      </td>
+      <td>gives the binary tag</td>
+        <td><tt>${CMTCONFIG}</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>src</tt>
+      </td>
+      <td>the src branch</td>
+        <td><tt>../src/</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>inc</tt>
+      </td>
+      <td>the include branch</td>
+        <td><tt>../src/</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>mgr</tt>
+      </td>
+      <td>the cmt or mgr branch</td>
+        <td><tt>../cmt/</tt>
+         or <tt>../mgr/</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>bin</tt>
+      </td>
+      <td>the branch for binaries</td>
+        <td><tt>../$(&lt;package&gt;_tag)/</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>javabin</tt>
+      </td>
+      <td>the branch for java classes</td>
+        <td><tt>../classes/</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>doc</tt>
+      </td>
+      <td>the doc branch</td>
+        <td><tt>../doc/</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cmt_hardware</tt>
+      </td>
+      <td>the description of the current hardware</td>
+        <td><tt>&lt;none&gt;</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cmt_system_version</tt>
+      </td>
+      <td>the version of the current OS</td>
+        <td><tt>&lt;none&gt;</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cmt_compiler_version</tt>
+      </td>
+      <td>the version of the currently visible C++ compiler </td>
+        <td><tt>&lt;none&gt;</tt>
+      </td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="Language related macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;3</tt></a> - Language related macros</h4>
+<blockquote>
+    These macros are purely conventional. They are expected in the
+    various make fragments available from <tt>CMT</tt>
+ itself for
+    providing the various building actions.
+  <p>During the mechanism of new language declaration and definition
+      available in the <tt>CMT</tt>
+   syntax, developers are expected to
+    define similar conventions for corresponding actions.</p>
+  <p> Their default values are originally defined inside the
+  &nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp; file of the <tt>CMT</tt>
+   package itself but can be
+  <i>redefined</i>
+   by providing a new definition in the package's
+      requirements file using the <tt>macro</tt>
+   statement. The original
+      definition can be <i>completed</i>
+   using the <tt>macro_append</tt>
+      or <tt>macro_prepend</tt>
+ statements.</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+        <td width="150">
+          <center><i>macro</i>
+        </center>
+      </td>
+        <td width="300">
+          <center><i>usage</i>
+        </center>
+      </td>
+        <td width="200">
+          <center><i>default value</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cc</tt>
+      </td>
+      <td>The C compiler</td>
+        <td><tt>cc</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>ccomp</tt>
+      </td>
+      <td>The C compiling command</td>
+        <td><tt>$(cc) -c -I$(inc) $(includes) $(cflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>clink</tt>
+      </td>
+      <td>The C linking command</td>
+        <td><tt>$(cc) $(clinkflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cflags</tt>
+      </td>
+      <td>The C compilation flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>pp_cflags</tt>
+      </td>
+      <td>The preprocessor flags for C</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>clinkflags</tt>
+      </td>
+      <td>The C link flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+  </table>
+</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+        <td width="150"><tt>cpp</tt>
+      </td>
+      <td width="300">The C++ compiler</td>
+        <td width="200"><tt>g++</tt>
+      </td>
+    </tr>
+      <tr>
+        <td width="150"><tt>preproc</tt>
+      </td>
+      <td width="300">The C++ preprocessor</td>
+        <td width="200"><tt>g++ -MD -c </tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cppcomp</tt>
+      </td>
+      <td>The C++ compiling command</td>
+        <td><tt>$(cpp) -c -I$(inc) $(includes) $(cppflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cpplink</tt>
+      </td>
+      <td>The C++ linking command</td>
+        <td><tt>$(cpp) $(cpplinkflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cppflags</tt>
+      </td>
+      <td>The C++ compilation flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>pp_cppflags</tt>
+      </td>
+      <td>The preprocessor flags for C++</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>cpplinkflags</tt>
+      </td>
+      <td>The C++ link flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+  </table>
+</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+        <td width="150"><tt>for</tt>
+      </td>
+      <td width="300">The Fortran compiler</td>
+        <td width="200"><tt>f77</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>fcomp</tt>
+      </td>
+      <td>The Fortran compiling command</td>
+        <td><tt>$(for) -c -I$(inc) $(includes) $(fflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>flink</tt>
+      </td>
+      <td>The Fortran linking command</td>
+        <td><tt>$(for) $(clinkflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>fflags</tt>
+      </td>
+      <td>The Fortran compilation flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>pp_fflags</tt>
+      </td>
+      <td>The preprocessor flags for fortran</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>flinkflags</tt>
+      </td>
+      <td>The Fortran link flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>ppcmd</tt>
+      </td>
+      <td>The include file command for Fortran</td>
+        <td><tt>-I</tt>
+      </td>
+    </tr>
+  </table>
+</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+        <td width="150"><tt>javacomp</tt>
+      </td>
+      <td width="300">The java compiling command</td>
+        <td width="200"><tt>javac</tt>
+      </td>
+    </tr>
+      <tr>
+        <td width="150"><tt>jar</tt>
+      </td>
+      <td>The java archiver command</td>
+        <td><tt>jar</tt>
+      </td>
+    </tr>
+  </table>
+</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+        <td width="150"><tt>lex</tt>
+      </td>
+      <td width="300">The Lex command</td>
+        <td width="200"><tt>lex $(lexflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>lexflags</tt>
+      </td>
+      <td>The Lex flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>yacc</tt>
+      </td>
+      <td>The Yacc command</td>
+        <td><tt>yacc $(yaccflags)</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>yaccflags</tt>
+      </td>
+      <td>The Yacc flags</td>
+        <td><i>none</i>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>ar</tt>
+      </td>
+      <td>The archive command</td>
+        <td><tt>ar -clr</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>ranlib</tt>
+      </td>
+      <td>The ranlib command</td>
+        <td>r<tt>anlib</tt>
+      </td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="Package customizing macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;4</tt></a> - Package customizing macros</h4>
+<blockquote>
+    These macros do not receive default values. They are all prefixed
+    by the package name. They are meant to provide specific variant to
+    the corresponding generic language related macros.
+  <p>They are automatically and by default concatenated by
+  <tt>CMT</tt>
+   to fill in the corresponding global <i>use</i>
+   macros
+        (see appendix on <A HREF="#Generated macros">generated
+      macros</A>
+  ). However, this concatenation mechanism is discarded
+      when the <tt>-no_auto_imports</tt>
+   option is specified in the
+    corresponding use statement.</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+        <td width="250">
+          <center><i>macro</i>
+        </center>
+      </td>
+        <td width="400">
+          <center><i>usage</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_cflags</tt>
+      </td>
+      <td>specific C flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_pp_cflags</tt>
+      </td>
+      <td>specific C preprocessor flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_cppflags</tt>
+      </td>
+      <td>specific C++ flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_pp_cppflags</tt>
+      </td>
+      <td>specific C++ preprocessor flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_fflags</tt>
+      </td>
+      <td>specific Fortran flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_pp_fflags</tt>
+      </td>
+      <td>specific Fortran preprocessor flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_libraries</tt>
+      </td>
+        <td>
+                    gives the (space separated) list of library names exported by this
+                    package. This list is typically used in the 
+        <tt>cmt build library_links</tt>
+         command.
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_linkopts</tt>
+      </td>
+        <td>
+                    provide the linker options required by any application willing to 
+                    access the different libraries offered by the 
+                    package. This may include support for several libraries 
+                    per package. 
+          <p>
+                      A typical example of how to define such a macro could be : </p>
+<pre class="cmt">
+macro Cm_linkopts "-L$(CMROOT)/$(Cm_tag) -lCm -lm" </pre>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_stamps</tt>
+      </td>
+        <td>
+                    may contain a list of <i>stamp</i>
+         file names (or make
+                    targets). Whenever a library is modified, one dedicated
+                    stamp file is re-created, simply to mark the
+                    reconstruction date. The name of this stamp file is
+                      conventionally <tt>&lt;<i>library</i>
+        &gt;.stamp</tt>
+        .  Thus,
+                    a typical definition for this macro could be :
+<pre class="cmt">
+macro Cm_stamps "$(Cm_root)/$(Cm_tag)/Cm.stamp" </pre>
+          <p>Then, these stamp file references are accumulated
+                        into the standard macro named <tt>use_stamps</tt>
+           which is
+                        always installed within the dependency list for
+                        applications, so that whenever one of the libraries used
+                        from the hierarchy of used packages changes, the
+                      application will be automatically rebuilt.</p>
+      </td>
+    </tr>
+  </table>
+</p>
+  <p>The following macros are not subject to automatic concatenation
+      (and therefore are not hidden by the <tt>-no_auto_imports</tt>
+    modifier).</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+        <td width="250">
+          <center><i>macro</i>
+        </center>
+      </td>
+        <td width="400">
+          <center><i>usage</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_native_version</tt>
+      </td>
+        <td>specifies the native version of the external package
+                  referenced by this <i>interface</i>
+         package.<br></br>
+        When this
+                    macro is provided, its value is displayed by the <tt>cmt show
+                  uses</tt>
+       command</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_export_paths</tt>
+      </td>
+        <td>specifies the list of files or directories that
+                  should be exported during the deployment process for
+                  this package. Generally this is only useful for glue
+                packages refering to external software</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_home</tt>
+      </td>
+        <td>specifies the base location for external software
+                  described in glue packages. This macro is generally used to
+                specify the previous one</td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="Constituent specific customizing macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;5</tt></a> - Constituent specific customizing macros</h4>
+<blockquote>
+    These macros do not receive any default values (ie they are empty
+    by default). They are meant to provide for each constituent,
+    specific variants to the corresponding generic language related
+    macros.
+  <p>By convention, they are all prefixed by the constituent
+      name. But macros used for defining compiler options are in
+      addition prefixed by the constituent type (either <tt>lib_</tt>
+  ,
+  <tt>app_</tt>
+   or <tt>doc_</tt>
+).</p>
+  <p>They are used in the various make fragments for fine
+    customization of the build command parameters.</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+          <td><tt>&lt;<i>type</i>
+          &gt;_&lt;<i>constituent</i>
+        &gt;_cflags</tt>
+      </td>
+      <td WIDTH="400">specific C flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>type</i>
+          &gt;_&lt;<i>constituent</i>
+        &gt;_pp_cflags</tt>
+      </td>
+      <td>specific C preprocessor flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>type</i>
+          &gt;_&lt;<i>constituent</i>
+        &gt;_cppflags</tt>
+      </td>
+      <td>specific C++ flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>type</i>
+          &gt;_&lt;<i>constituent</i>
+        &gt;_pp_cppflags</tt>
+      </td>
+      <td>specific C++ preprocessor flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>type</i>
+          &gt;_&lt;<i>constituent</i>
+        &gt;_fflags</tt>
+      </td>
+      <td>specific Fortran flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>type</i>
+          &gt;_&lt;<i>constituent</i>
+        &gt;_pp_fflags</tt>
+      </td>
+      <td>specific Fortran preprocessor flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>constituent</i>
+        &gt;linkopts</tt>
+      </td>
+        <td>
+                    provides additional linker options to the application. It is
+                    complementary to - and should not be confused with - the
+          <tt>&lt;<i>package</i>
+        &gt;_linkopts</tt>
+         macro, which
+                    provides exported linker options required by clients
+                    packages to use the package libraries.
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>constituent</i>
+        &gt;_shlibflags</tt>
+      </td>
+        <td>
+                    provides additional linker options used when building a
+                    shared library. Generally, a simple shared library does
+                    not need any external reference to be resolved at build
+                    time (it is in this case supposed to get its unresolved
+                    references from other shared libraries). However,
+                    (typically when one builds a dynamic loading capable
+                    component) it might be desired to statically link it
+                    with other libraries (making them somewhat private).
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>constituent</i>
+        &gt;_dependencies</tt>
+      </td>
+        <td>
+                    provides user defined dependency specifications for each
+                    constituent. The typical use of this macro is fill it
+                    with the name of the list of some other constituents
+                    which <i>have</i>
+         to be rebuilt first (since each
+                    constituent is associated with a target with the same
+                    name). This is especially needed when one want to use
+                    the parallel gmake (ie. the -j option of gmake).
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>group</i>
+        &gt;_dependencies</tt>
+      </td>
+        <td>
+                    provides user defined dependency specifications for each
+                    group. The typical use of this macro is fill it
+                    with the name of the list of some other constituents
+                    which <i>have</i>
+         to be rebuilt first (since each
+                    constituent is associated with a target with the same
+                    name). This is especially needed when one want to use
+                    the parallel gmake (ie. the -j option of gmake).
+      </td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="Source specific customizing macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;6</tt></a> - Source specific customizing macros</h4>
+<blockquote>
+    These macros do not receive any default values (ie they are empty
+    by default). They are meant to provide for each source file,
+    specific variants to the corresponding generic language related
+    macros.
+  <p>By convention, they are all prefixed by the source file name
+      followed by the source file suffix (either <tt>_c</tt>
+  , <tt>_cxx</tt>
+  ,
+  <tt>_f</tt>
+, etc.)</p>
+  <p>They are used in the various make fragments for fine
+    customization of the build command parameters.</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+          <td WIDTH="300"><tt>&lt;<i>constituent</i>
+          &gt;_&lt;<i>suffix</i>
+        &gt;_cflags</tt>
+      </td>
+      <td WIDTH="300">specific C flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>constituent</i>
+          &gt;_&lt;<i>suffix</i>
+        &gt;_cppflags</tt>
+      </td>
+      <td>specific C++ flags</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>constituent</i>
+          &gt;_&lt;<i>suffix</i>
+        &gt;_fflags</tt>
+      </td>
+      <td>specific Fortran flags</td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="Generated macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;7</tt></a> - Generated macros</h4>
+<blockquote>
+  <p> These macros are automatically <i>generated</i>
+   when any cmt
+      connand is run (and thus when <tt>make</tt>
+ is run).</p>
+  <p>The first set of them provide constant values corresponding to
+  <tt>CMT</tt>
+   based information. They are not meant to be overridden
+      by the user, since they serve as a communication mean between
+  <tt>CMT</tt>
+ and the user.</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+          <td width="200"><tt>&lt;<i>PACKAGE</i>
+        &gt;ROOT</tt>
+      </td>
+        <td width="400">The access path of the package (including
+                  the version branch). This is controlled by the
+        <tt>setup_strategy [no_]root</tt>
+       statement.</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_root</tt>
+      </td>
+        <td>The access path of the package (including the
+                  version branch). This macro is very similar to the
+          <tt>&lt;<i>PACKAGE</i>
+        &gt;ROOT</tt>
+         macro except that
+                  it tries to use a relative path instead of an
+                absolute one. </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>PACKAGE</i>
+        &gt;VERSION</tt>
+      </td>
+      <td>The used version of the package.</td>
+    </tr>
+      <tr>
+        <td><tt>PACKAGE_ROOT</tt>
+      </td>
+      <td>The access path of the current package (including the version branch)</td>
+    </tr>
+      <tr>
+        <td><tt>package</tt>
+      </td>
+      <td>The name of the current package</td>
+    </tr>
+      <tr>
+        <td><tt>version</tt>
+      </td>
+      <td>The version tag of the current package</td>
+    </tr>
+      <tr>
+        <td><tt>package_offset</tt>
+      </td>
+      <td>The directory offset of the current package</td>
+    </tr>
+      <tr>
+        <td><tt>package_cmtpath</tt>
+      </td>
+      <td>The package area where the current package has been found</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_project</tt>
+      </td>
+      <td>The project name to which the corresponding package belongs</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_cmtpath</tt>
+      </td>
+      <td>The package area where the corresponding package has been found</td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_offset</tt>
+      </td>
+      <td>The directory offset of the corresponding package</td>
+    </tr>
+  </table>
+</p>
+  <p>The second set is deduced from the context and from the
+        requirements file of the package. They can be overridden by
+        the user so as to customize the <tt>CMT</tt>
+ behaviour.</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+          <td><tt>&lt;<i>package</i>
+        &gt;_tag</tt>
+      </td>
+      <td width="400">The specific configuration tag for the package. By default it is set to $(tag) but can be freely overridden</td>
+    </tr>
+      <tr>
+        <td><tt>constituents</tt>
+      </td>
+      <td>The ordered set of constituents declared without any group option</td>
+    </tr>
+      <tr>
+          <td><tt><i>&lt;group-name&gt;</i>
+        _constituents</tt>
+      </td>
+      <td>The ordered set of all constituents declared using a group=&lt;group-name&gt; option</td>
+    </tr>
+  </table>
+</p>
+    <p>The third set of generated macros are the <i>global use
+      macros</i>
+  .  They correspond to the concatenation of the
+      corresponding package specific customizing options that can be
+      deduced from the ordered set of <i>use</i>
+   statements found in the
+      requirements file (taking into account the complete hierarchy of
+      used packages with the exception of those specified with the
+  <br></br>
+  <tt>-no_auto_imports</tt>
+ option in their use statement) :</p>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+        <td width="150"><tt>use_cflags</tt>
+      </td>
+      <td width="400">C compiler flags</td>
+    </tr>
+      <tr>
+        <td><tt>use_pp_cflags</tt>
+      </td>
+      <td>Preprocessor flags for the C language</td>
+    </tr>
+      <tr>
+        <td><tt>use_cppflags</tt>
+      </td>
+      <td>C++ compiler flags</td>
+    </tr>
+      <tr>
+        <td><tt>use_pp_cppflags</tt>
+      </td>
+      <td>Preprocessor flags for the C++ language</td>
+    </tr>
+      <tr>
+        <td><tt>use_fflags</tt>
+      </td>
+      <td>Fortran compiler flags</td>
+    </tr>
+      <tr>
+        <td><tt>use_pp_fflags</tt>
+      </td>
+      <td>Preprocessor flags for the Fortran language</td>
+    </tr>
+      <tr>
+        <td><tt>use_libraries</tt>
+      </td>
+      <td>List of library names</td>
+    </tr>
+      <tr>
+        <td><tt>use_linkopts</tt>
+      </td>
+      <td>Linker options</td>
+    </tr>
+      <tr>
+        <td><tt>use_stamps</tt>
+      </td>
+      <td>Dependency stamps</td>
+    </tr>
+      <tr>
+        <td><tt>use_requirements</tt>
+      </td>
+      <td>The set of used requirements</td>
+    </tr>
+      <tr>
+        <td><tt>use_includes</tt>
+      </td>
+      <td>The set of include search paths options for the preprocessor from the used packages</td>
+    </tr>
+      <tr>
+        <td><tt>use_fincludes</tt>
+      </td>
+      <td>The set of include search paths options for the fortran preprocessor from the used packages</td>
+    </tr>
+      <tr>
+        <td><tt>includes</tt>
+      </td>
+      <td>The overall set of include search paths for the preprocessor</td>
+    </tr>
+      <tr>
+        <td><tt>fincludes</tt>
+      </td>
+      <td>The overall set of include search paths options for the fortran preprocessor</td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h4><a name="Macros related with the installation area mechanisms"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;8</tt></a> - Macros related with the installation area mechanisms</h4>
+<blockquote>
+    These macros contain the parameterisation of the installation area
+    mechanisms.
+    <p><font size="-10">
+      <table cellspacing="0" BORDER="1" COLS="2">
+        <tr>
+          <td width="250">
+            <center><i>macro</i>
+          </center>
+        </td>
+          <td width="20">
+            <center><i>usage</i>
+          </center>
+        </td>
+          <td width="300">
+            <center><i>default value</i>
+          </center>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_installarea_command</tt>
+        </td>
+        <td>&nbsp;</td>
+        <td>&nbsp;</td>
+      </tr>
+        <tr>
+          <td><tt>cmt_uninstallarea_command</tt>
+        </td>
+        <td>&nbsp;</td>
+        <td>&nbsp;</td>
+      </tr>
+        <tr>
+          <td><tt>cmt_install_action</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>$(CMTROOT)\mgr\cmt_install_action.bat</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_installdir_action</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>$(CMTROOT)\mgr\cmt_installdir_action.bat</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_uninstall_action</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>$(CMTROOT)\mgr\cmt_uninstall_action.bat</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_uninstalldir_action</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>$(CMTROOT)\mgr\cmt_uninstalldir_action.bat</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_installdir_excludes</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>$(CMTROOT)\mgr\cmt_installdir_excludes.txt</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_installarea_prefix</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>InstallArea</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>&lt;project&gt;_installarea_prefix</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>$(cmt_installarea_prefix)</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>CMTINSTALLAREA</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>C:\Arnault\test\tprojects\PC\InstallArea</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_installarea_paths</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>&nbsp;</tt>
+        </td>
+      </tr>
+        <tr>
+          <td><tt>cmt_installarea_linkopts</tt>
+        </td>
+        <td>&nbsp;</td>
+          <td><tt>&nbsp;</tt>
+        </td>
+      </tr>
+    </table>
+  </font>
+</p>
+</blockquote>
+<hr><h4><a name="Utility macros"></a><a href="#index"><tt>18.&nbsp;3.&nbsp;9</tt></a> - Utility macros</h4>
+<blockquote>
+    These macros are used to specify the behaviour of various actions
+    in CMT.
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="2">
+      <tr>
+          <td width="150"><center><i>macro</i>
+        </center>
+      </td>
+          <td width="250"><center><i>usage</i>
+        </center>
+      </td>
+          <td width="200"><center><i>default on Unix</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>X11_cflags</tt>
+      </td>
+      <td>compilation flags for X11</td>
+        <td><tt>-I/usr/include</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>Xm_cflags</tt>
+      </td>
+      <td>compilation flags for Motif</td>
+        <td><tt>-I/usr/include</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>X_linkopts</tt>
+      </td>
+      <td>Link options for XWindows (and Motif)</td>
+      <td>&nbsp;</td>
+    </tr>
+      <tr>
+        <td><tt>make_shlib</tt>
+      </td>
+      <td>The command used to generate the shared library from the static one</td>
+        <td><tt>${CMTROOT}/mgr/cmt_make_shlib_common.sh extract</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>shlibsuffix</tt>
+      </td>
+      <td>The system dependent suffix for shared libraries</td>
+        <td><tt>so</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>shlibbuilder</tt>
+      </td>
+      <td>The loader used to build the shared library</td>
+        <td><tt>g++</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>shlibflags</tt>
+      </td>
+      <td>The additional options given to the shared library builder</td>
+        <td><tt>-shared</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>application_suffix</tt>
+      </td>
+      <td>The default extension for applications</td>
+        <td><tt>.exe</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>library_prefix</tt>
+      </td>
+      <td>The default name prefix of libraries</td>
+        <td><tt>lib</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>library_suffix</tt>
+      </td>
+      <td>The default name suffix of libraries</td>
+      <td>&nbsp;</td>
+    </tr>
+      <tr>
+        <td><tt>symlink</tt>
+      </td>
+      <td>The command used to install a symbolic link</td>
+        <td><tt>/bin/ln -fs</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt></tt>
+      </td>
+      <td>The command used to remove a symbolic link</td>
+        <td><tt>/bin/rm -f </tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>build_prototype</tt>
+      </td>
+      <td>The command used to generate the C prototype header file (default to the internal cmt dedicated command)</td>
+        <td><tt>$(cmtexe) build prototype</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>build_dependencies</tt>
+      </td>
+      <td>The command used to generate dependencies (default to the internal cmt dedicated command)</td>
+        <td><tt>$(cmtexe) -quiet -tag=$(tags) build dependencies</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>lock_command</tt>
+      </td>
+      <td>The command used to physically lock a package</td>
+        <td><tt>chmod -R a-w ../*</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>unlock_command</tt>
+      </td>
+      <td>The command used to physically unlock a package</td>
+        <td><tt>chmod -R g+w ../*</tt>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>make_hosts</tt>
+      </td>
+        <td>The list of remote host names which exactly require the <tt>make</tt>
+       command</td>
+      <td>&nbsp;</td>
+    </tr>
+      <tr>
+        <td><tt>gmake_hosts</tt>
+      </td>
+        <td>The list of remote host names which exactly require the <tt>gmake</tt>
+       command</td>
+      <td>&nbsp;</td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+</blockquote>
+<hr><h3><a name="Standard tags generated by CMT"></a><a href="#index"><tt>18.&nbsp;4</tt></a> - Standard tags generated by CMT</h3>
+<blockquote>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+          <td width="150"><center><i>tag name</i>
+        </center>
+      </td>
+          <td width="400"><center><i>usage</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>CMTv&lt;n&gt;</tt>
+      </td>
+      <td>Primary version id of CMT</td>
+    </tr>
+      <tr>
+        <td><tt>CMTr&lt;n&gt;</tt>
+      </td>
+      <td>Secondary version id of CMT</td>
+    </tr>
+      <tr>
+        <td><tt>CMTp&lt;n&gt;</tt>
+      </td>
+      <td>Patch id of CMT</td>
+    </tr>
+      <tr>
+        <td><tt>`uname`</tt>
+      </td>
+      <td>The basic platform id</td>
+    </tr>
+      <tr>
+        <td><tt>&lt;project-name&gt;</tt>
+      </td>
+      <td>The current project name</td>
+    </tr>
+      <tr>
+        <td>
+          <table>
+              <tr><td><tt>&lt;project&gt;_prototypes</tt>
+            </td>
+          </tr>
+              <tr><td><tt>&lt;project&gt;_no_prototypes</tt>
+            </td>
+          </tr>
+        </table>
+      </td>
+      <td>The prototypes strategy for each project</td>
+    </tr>
+      <tr>
+        <td>
+          <table>
+              <tr><td><tt>&lt;project&gt;_with_installarea</tt>
+            </td>
+          </tr>
+              <tr><td><tt>&lt;project&gt;_without_installarea</tt>
+            </td>
+          </tr>
+        </table>
+      </td>
+      <td>The installation area strategy for each project</td>
+    </tr>
+      <tr>
+        <td>
+          <table>
+              <tr><td><tt>&lt;project&gt;_setup_config</tt>
+            </td>
+          </tr>
+              <tr><td><tt>&lt;project&gt;_setup_no_config</tt>
+            </td>
+          </tr>
+        </table>
+      </td>
+        <td>The strategy for generating <tt>&lt;P&gt;CONFIG</tt>
+       for each project</td>
+    </tr>
+      <tr>
+        <td>
+          <table>
+              <tr><td><tt>&lt;project&gt;_setup_root</tt>
+            </td>
+          </tr>
+              <tr><td><tt>&lt;project&gt;_setup_no_root</tt>
+            </td>
+          </tr>
+        </table>
+      </td>
+        <td>The strategy for generating <tt>&lt;P&gt;ROOT</tt>
+       for each project</td>
+    </tr>
+      <tr>
+        <td>
+          <table>
+              <tr><td><tt>&lt;project&gt;_setup_cleanup</tt>
+            </td>
+          </tr>
+              <tr><td><tt>&lt;project&gt;_setup_no_cleanup</tt>
+            </td>
+          </tr>
+        </table>
+      </td>
+      <td>The installation area cleanup strategy for each project</td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h3><a name="Standard templates for makefile fragments"></a><a href="#index"><tt>18.&nbsp;5</tt></a> - Standard templates for makefile fragments</h3>
+<blockquote>
+  <p>
+    <table cellspacing="0" BORDER="1" COLS="3">
+      <tr>
+          <td width="150"><center><i>template name</i>
+        </center>
+      </td>
+          <td width="200"><center><i>usage</i>
+        </center>
+      </td>
+          <td width="400"><center><i>used in fragment</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>ADDINCLUDE</tt>
+      </td>
+      <td>additional include path</td>
+        <td>&lt;<i>language</i>
+      &gt; java</td>
+    </tr>
+      <tr>
+        <td><tt>CONSTITUENT</tt>
+      </td>
+      <td>name of the constituent</td>
+        <td>&lt;<i>language</i>
+      &gt; java jar make_header jar_header java_header library_header application_header protos_header library_no_share library application dependencies cleanup_header cleanup_library cleanup_application check_application document_header &lt;document&gt; trailer dsw_all_project_dependency dsw_project dsp_library_header dsp_shared_library_header dsp_windows_header dsp_application_header dsp_trailer constituent check_application_header</td>
+    </tr>
+      <tr>
+        <td><tt>DATE</tt>
+      </td>
+      <td>now</td>
+      <td>make_header</td>
+    </tr>
+      <tr>
+        <td><tt>FILENAME</tt>
+      </td>
+      <td>file name without path</td>
+        <td>buildproto &lt;<i>language</i>
+        &gt;&lt;<i>document</i>
+      &gt;</td>
+    </tr>
+      <tr>
+        <td><tt>FILEPATH</tt>
+      </td>
+      <td>file path</td>
+        <td>buildproto &lt;<i>language</i>
+        &gt;&lt;<i>document</i>
+      &gt;</td>
+    </tr>
+      <tr>
+        <td><tt>FILESUFFIX</tt>
+      </td>
+      <td>file suffix (without dot)</td>
+        <td>&lt;<i>language</i>
+      &gt;</td>
+    </tr>
+      <tr>
+        <td><tt>FILESUFFIX</tt>
+      </td>
+      <td>file suffix (with dot)</td>
+        <td>&lt;<i>document</i>
+      &gt;</td>
+    </tr>
+      <tr>
+        <td><tt>FULLNAME</tt>
+      </td>
+      <td>complete file path and name</td>
+        <td>&lt;<i>language</i>
+        &gt; cleanup &lt;<i>document</i>
+      &gt; dsp_contents</td>
+    </tr>
+      <tr>
+        <td><tt>GROUP</tt>
+      </td>
+      <td>group name</td>
+      <td>constituents_header</td>
+    </tr>
+      <tr>
+        <td><tt>LINE</tt>
+      </td>
+      <td>source files</td>
+        <td>&lt;<i>language</i>
+      &gt; dependencies constituent</td>
+    </tr>
+      <tr>
+        <td><tt>LINKMACRO</tt>
+      </td>
+      <td>link macro</td>
+      <td>application</td>
+    </tr>
+      <tr>
+        <td><tt>NAME</tt>
+      </td>
+      <td>file name without path and suffix</td>
+        <td>buildproto &lt;<i>language</i>
+        &gt; java &lt;<i>document</i>
+      &gt;</td>
+    </tr>
+      <tr>
+        <td><tt>OBJS</tt>
+      </td>
+      <td>object files</td>
+      <td>jar_header java_header jar library_no_share library application cleanup_java document_header trailer</td>
+    </tr>
+      <tr>
+        <td><tt>OUTPUTNAME</tt>
+      </td>
+      <td>output file name</td>
+      <td>java</td>
+    </tr>
+      <tr>
+        <td><tt>PACKAGE</tt>
+      </td>
+      <td>current package name</td>
+        <td>&lt;<i>language</i>
+      &gt; dsw_header dsw_all_project dsw_all_project_trailer dsw_trailer dsp_all readme_header readme readme_use readme_trailer</td>
+    </tr>
+      <tr>
+        <td><tt>PACKAGEPATH</tt>
+      </td>
+      <td>current package location</td>
+      <td>readme_use</td>
+    </tr>
+      <tr>
+        <td><tt>PROTOSTAMPS</tt>
+      </td>
+      <td>prototype stamp files</td>
+      <td>protos_header</td>
+    </tr>
+      <tr>
+        <td><tt>PROTOTARGET</tt>
+      </td>
+      <td>prototype target name</td>
+      <td>library_header application_header</td>
+    </tr>
+      <tr>
+        <td><tt>SUFFIX</tt>
+      </td>
+      <td>document suffix</td>
+        <td>&lt;<i>document</i>
+      &gt;</td>
+    </tr>
+      <tr>
+        <td><tt>TITLE</tt>
+      </td>
+      <td>title for make header</td>
+      <td>make_header</td>
+    </tr>
+      <tr>
+        <td><tt>USER</tt>
+      </td>
+      <td>user name</td>
+      <td>make_header</td>
+    </tr>
+      <tr>
+        <td><tt>VERSION</tt>
+      </td>
+      <td>current package version tag</td>
+      <td>readme_header readme readme_use</td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h3><a name="Makefile generation sequences"></a><a href="#index"><tt>18.&nbsp;6</tt></a> - Makefile generation sequences</h3>
+<blockquote>
+<blockquote><hr>
+    This section describes the various makefile generation sequences
+    provided by <tt>CMT</tt>
+. Each sequence description shows the
+    precise set of <a href="#make_fragment">make fragments</a>
+ used
+    during the operation.
+<hr></blockquote>
+  <p>
+    <table cellspacing="0" border="1" cols="3">
+      <tr>
+          <td width="200"><center><i>Generated makefile</i>
+        </center>
+      </td>
+          <td width="250"><center><i>description</i>
+        </center>
+      </td>
+          <td width="350"><center><i>used make fragments</i>
+        </center>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>constituents.make</tt>
+      </td>
+      <td>the main entry point point for all constituent targets</td>
+        <td>
+          <ol>
+          <li>constituents_header</li>
+          <li>constituent</li>
+          <li>check_application_header</li>
+        </ol>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>constituent</i>
+        &gt;.make</tt>
+      </td>
+      <td>application or library specific make fragment</td>
+        <td>
+          <ol>
+          <li>make_header</li>
+          <li>java_header | jar_header | library_header | application_header</li>
+          <li>protos_header</li>
+          <li>buildproto</li>
+          <li>jar | library | library_no_share | application</li>
+          <li>dependencies</li>
+          <li>&lt;language&gt; | &lt;language&gt;_library | java</li>
+          <li>cleanup_header</li>
+          <li>cleanup</li>
+          <li>cleanup_application</li>
+          <li>cleanup_objects</li>
+          <li>cleanup_java</li>
+          <li>cleanup_library</li>
+          <li>check_application</li>
+        </ol>
+      </td>
+    </tr>
+      <tr>
+          <td><tt>&lt;<i>constituent</i>
+        &gt;.make</tt>
+      </td>
+      <td>document specific make fragment</td>
+        <td>
+          <ol>
+          <li>make_header</li>
+          <li>document_header</li>
+          <li>dependencies</li>
+          <li>&lt;document&gt;</li>
+          <li>&lt;document-trailer&gt;</li>
+          <li>cleanup_header</li>
+        </ol>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>&lt;package&gt;.dsw</tt>
+      </td>
+      <td>Visual workspace configuration files</td>
+        <td>
+          <ol>
+          <li>dsw_header</li>
+          <li>dsw_all_project_header</li>
+          <li>dsw_all_project_dependency</li>
+          <li>dsw_all_project_trailer</li>
+          <li>dsw_project</li>
+          <li>dsw_trailer</li>
+          <li>dsp_all</li>
+        </ol>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>&lt;constituent&gt;.dsp</tt>
+      </td>
+      <td>Visual project configuration files</td>
+        <td>
+          <ol>
+          <li>dsp_library_header | dsp_shared_library_header | dsp_windows_header | dsp_application_header</li>
+          <li>dsp_contents</li>
+          <li>dsp_trailer</li>
+        </ol>
+      </td>
+    </tr>
+      <tr>
+        <td><tt>README</tt>
+      </td>
+      <td>.</td>
+        <td>
+          <ol>
+          <li>readme_header</li>
+          <li>readme</li>
+          <li>readme_use</li>
+          <li>readme_trailer</li>
+        </ol>
+      </td>
+    </tr>
+  </table>
+</p>
+</blockquote>
+<hr><h3><a name="The complete project file syntax"></a><a href="#index"><tt>18.&nbsp;7</tt></a> - The complete project file syntax</h3>
+<blockquote>
+  The syntax of specification statements that can be installed in a
+<tt>project.cmt</tt>
+ file are :
+<center>
+<table cols="3">
+<tr>
+<td width="220"></td>
+<td width="10"></td>
+<td></td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-cmt-statement"></a>cmt-statement</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-build_strategy">build_strategy</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-container">container</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-project">project</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-setup_strategy">setup_strategy</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-structure_strategy">structure_strategy</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-use">use</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-build_strategy"></a>build_strategy</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+build_strategy
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+build-strategy-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-build-strategy-name"></a>build-strategy-name</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+prototypes
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_prototypes
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+with_installarea
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+without_installarea
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-container"></a>container</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+container
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+container-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-version-tag">version-tag</a>
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+access-path
+</i></font>
+&nbsp;]&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-project"></a>project</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+project
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+project-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-setup_strategy"></a>setup_strategy</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+setup_strategy
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+setup-strategy-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-setup-strategy-name"></a>setup-strategy-name</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+config
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_config
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+root
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_root
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+cleanup
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_cleanup
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-structure_strategy"></a>structure_strategy</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+structure_strategy
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+structure-strategy-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-structure-strategy-name"></a>structure-strategy-name</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+with_version_directory
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+without_version_directory
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMTProject-use"></a>use</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+use
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+project-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMTProject-release-tag">release-tag</a>
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+access-path
+</i></font>
+&nbsp;]&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+</table>
+</center>
+</blockquote>
+<hr><h3><a name="The complete requirements syntax"></a><a href="#index"><tt>18.&nbsp;8</tt></a> - The complete requirements syntax</h3>
+<blockquote>
+  The syntax of specification statements that can be installed in a
+<tt>requirements</tt>
+ file are :
+<center>
+<table cols="3">
+<tr>
+<td width="220"></td>
+<td width="10"></td>
+<td></td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-cmt-statement"></a>cmt-statement</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-application">application</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-apply_pattern">apply_pattern</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-apply_tag">apply_tag</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-author">author</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-branches">branches</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-build_strategy">build_strategy</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-cleanup_script">cleanup_script</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-cmtpath_pattern">cmtpath_pattern</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-document">document</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-ignore_pattern">ignore_pattern</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-include_dirs">include_dirs</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-include_path">include_path</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-language">language</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-library">library</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-make_fragment">make_fragment</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-manager">manager</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-package">package</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-pattern">pattern</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-private">private</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-public">public</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-setup_script">setup_script</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-setup_strategy">setup_strategy</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-structure_strategy">structure_strategy</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-symbol">symbol</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag">tag</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag_exclude">tag_exclude</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-use">use</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-version">version</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-alias"></a>alias</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+alias
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+alias-name
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+default-value
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-application"></a>application</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+application
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+application-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-constituent-option">constituent-option</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-source">source</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-constituent-option"></a>constituent-option</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+-no_share
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-no_static
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-prototypes
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-no_prototypes
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-check
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-target_tag
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-group=<font face="courier new, courier" COLOR="#770000"><i>group-name</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-suffix=<font face="courier new, courier" COLOR="#770000"><i>output-suffix</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-import=<font face="courier new, courier" COLOR="#770000"><i>package-name</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+variable-name
+</i></font>
+<font face="courier new, courier" COLOR="#FF0000">
+=
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+variable-value
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-OS9
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-windows
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-source"></a>source</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+name.suffix
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+*.suffix
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+*.*
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-s=<font face="courier new, courier" COLOR="#770000"><i>new-search-path</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-k=<font face="courier new, courier" COLOR="#770000"><i>selection-regexp</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-x=<font face="courier new, courier" COLOR="#770000"><i>exclusion-regexp</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-apply_pattern"></a>apply_pattern</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+apply_pattern
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+pattern-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+template-name
+</i></font>
+<font face="courier new, courier" COLOR="#FF0000">
+=
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-apply_tag"></a>apply_tag</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+apply_tag
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-author"></a>author</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+author
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+author-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-branches"></a>branches</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+branches
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+branch-name
+</i></font>
+&nbsp;...&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-build_strategy"></a>build_strategy</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+build_strategy
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+build-strategy-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-build-strategy-name"></a>build-strategy-name</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+prototypes
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_prototypes
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+with_installarea
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+without_installarea
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-cleanup_script"></a>cleanup_script</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+cleanup_script
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+script-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-cmtpath_pattern"></a>cmtpath_pattern</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+cmtpath_pattern
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-cmt-statement">cmt-statement</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#FF0000">
+ ; 
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-cmt-statement">cmt-statement</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-document"></a>document</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+document
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+document-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-constituent-option">constituent-option</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-source">source</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-ignore_pattern"></a>ignore_pattern</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+ignore_pattern
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+pattern-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-include_dirs"></a>include_dirs</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+include_dirs
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+search-path
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-include_path"></a>include_path</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+include_path
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+search-path
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-language"></a>language</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+language
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+language-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-language-option">language-option</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-language-option"></a>language-option</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+-suffix=<font face="courier new, courier" COLOR="#770000"><i>suffix</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-linker=<font face="courier new, courier" COLOR="#770000"><i>linker-command</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-prototypes
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-preprocessor_command=<font face="courier new, courier" COLOR="#770000"><i>preprocessor_command</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-fragment=<font face="courier new, courier" COLOR="#770000"><i>fragment</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-output_suffix=<font face="courier new, courier" COLOR="#770000"><i>output-suffix</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-extra_output_suffix=<font face="courier new, courier" COLOR="#770000"><i>extra-output-suffix</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-library"></a>library</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+library
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+library-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-constituent-option">constituent-option</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-source">source</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-action"></a>action</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+action
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+action-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-macro"></a>macro</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+macro-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-macro_append"></a>macro_append</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro_append
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+macro-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-macro_prepend"></a>macro_prepend</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro_prepend
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+macro-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-macro_remove"></a>macro_remove</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+macro-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-macro_remove_regexp"></a>macro_remove_regexp</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove_regexp
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+macro-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-macro_remove_all"></a>macro_remove_all</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove_all
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+macro-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-macro_remove_all_regexp"></a>macro_remove_all_regexp</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+macro_remove_all_regexp
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+macro-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-make_fragment"></a>make_fragment</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+make_fragment
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+fragment-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-fragment-option">fragment-option</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-fragment-option"></a>fragment-option</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+-suffix=<font face="courier new, courier" COLOR="#770000"><i>suffix</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-dependencies
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-header=<font face="courier new, courier" COLOR="#770000"><i>fragment</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-trailer=<font face="courier new, courier" COLOR="#770000"><i>fragment</i></font>
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-manager"></a>manager</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+manager
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+manager-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-package"></a>package</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+package
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+package-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-path"></a>path</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+path
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+path-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-path_append"></a>path_append</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+path_append
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+path-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-path_prepend"></a>path_prepend</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+path_prepend
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+path-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-path_remove"></a>path_remove</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+path_remove
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+path-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-path_remove_regexp"></a>path_remove_regexp</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+path_remove_regexp
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+path-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-pattern"></a>pattern</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+pattern
+</font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#FF0000">
+-global
+</font>
+&nbsp;]&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+pattern-name
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-cmt-statement">cmt-statement</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#FF0000">
+ ; 
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-cmt-statement">cmt-statement</a>
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-private"></a>private</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+private
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-public"></a>public</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+public
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-set"></a>set</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+set
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+set-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-set_append"></a>set_append</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+set_append
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+set-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-set_prepend"></a>set_prepend</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+set_prepend
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+set-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-set_remove"></a>set_remove</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+set_remove
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+set-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-set_remove_regexp"></a>set_remove_regexp</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+set_remove_regexp
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+set-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-tag-expr">tag-expr</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+value
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-setup_script"></a>setup_script</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+setup_script
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+script-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-setup_strategy"></a>setup_strategy</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+setup_strategy
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+setup-strategy-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-setup-strategy-name"></a>setup-strategy-name</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+config
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_config
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+root
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_root
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+cleanup
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+no_cleanup
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-structure_strategy"></a>structure_strategy</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+structure_strategy
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+structure-strategy-name
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-structure-strategy-name"></a>structure-strategy-name</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+with_version_directory
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+without_version_directory
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-symbol"></a>symbol</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-alias">alias</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-action">action</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-macro">macro</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-macro_append">macro_append</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-macro_prepend">macro_prepend</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-macro_remove">macro_remove</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-macro_remove_regexp">macro_remove_regexp</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-macro_remove_all">macro_remove_all</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-macro_remove_all_regexp">macro_remove_all_regexp</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-path">path</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-path_append">path_append</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-path_prepend">path_prepend</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-path_remove">path_remove</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-path_remove_regexp">path_remove_regexp</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-set">set</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-set_append">set_append</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-set_prepend">set_prepend</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-set_remove">set_remove</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-set_remove_regexp">set_remove_regexp</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-tag"></a>tag</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+tag
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-tag_exclude"></a>tag_exclude</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+tag_exclude
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-tag-expr"></a>tag-expr</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#FF0000">
+&
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+tag-name
+</i></font>
+&nbsp;...&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-use"></a>use</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+use
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+package-name
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-version-tag">version-tag</a>
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+access-path
+</i></font>
+&nbsp;]&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-use-option">use-option</a>
+</i></font>
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-version"></a>version</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+version
+</font>
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-version-tag">version-tag</a>
+</i></font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-version-tag"></a>version-tag</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-key">key</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+version-number
+</i></font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td></td>
+<td>&nbsp;&nbsp;&nbsp;
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-key">key</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+release-number
+</i></font>
+[&nbsp;
+<font face="courier new, courier" COLOR="#770000"><i>
+<a href="#kwCMT-key">key</a>
+</i></font>
+<font face="courier new, courier" COLOR="#770000"><i>
+patch-number
+</i></font>
+&nbsp;]&nbsp;
+&nbsp;]&nbsp;
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-use-option"></a>use-option</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#FF0000">
+-no_auto_imports
+</font>
+</td>
+</tr>
+<tr>
+<td></td>
+<td>|</td>
+<td>
+<font face="courier new, courier" COLOR="#FF0000">
+-auto_imports
+</font>
+</td>
+</tr>
+<tr>
+<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="kwCMT-key"></a>key</i></font></td>
+<td class="rule">:</td>
+<td class="rule">
+<font face="courier new, courier" COLOR="#770000"><i>
+letter
+</i></font>
+&nbsp;...&nbsp;
+</td>
+</tr>
+</table>
+</center>
+</blockquote>
+<hr><h3><a name="The default strategies defined in CMT"></a><a href="#index"><tt>18.&nbsp;9</tt></a> - The default strategies defined in CMT</h3>
+<blockquote>
+<pre class="cmt">
+  build_strategy prototypes | without_installarea
+  setup_strategy config | root
+  structure_strategy with_version_directory</pre>
+</blockquote>
+<hr><h3><a name="The internal mechanism of cmt cvs operations"></a><a href="#index"><tt>18.10</tt></a> - The internal mechanism of cmt cvs operations</h3>
+<blockquote>
+  Generally, CVS does not handle queries upon the repository (such as
+  knowing all installed modules, all tags of the modules
+  etc..). Various tools such as CVSWeb, LXR etc. provide very powerful
+  answers to this question, but all through a Web browser.
+  <p><tt>CMT</tt>
+   provides a hook that can be installed within a CVS
+    repository, based on a helper script that will be activated upon a
+    particular CVS command, and that is able to perform some level of
+  scan within this repository and return filtered information. </p>
+  <p>More precisely, this helper script (found in
+  <tt>${CMTROOT}/mgr/cmt_buildcvsinfos2.sh</tt>
+  ) is meant to be declared
+    within the <tt>loginfo</tt>
+   management file (see the <a href="http://www.cvshome.org/docs/manual/index.html">CVS manual</a>
+    for more details) as one entry named <tt>.cmtcvsinfos</tt>
+  , able to
+    launch the helper script. This installation can be operated at once
+  using the following sequence:</p>
+<pre>
+sh&gt; cd ${CMTROOT}/mgr
+sh&gt; gmake installcvs</pre>
+  <p>This mechanism is thus fully compatible with standard remote
+  access to the repository.</p>
+  <p>Once the helper script is installed, the mechanism operates as
+    follows (this actually describes the algorithms installed in the
+  <tt>CvsImplementation::show_cvs_infos</tt>
+   method available in
+  <tt>cmt_cvs.cxx</tt>
+     and is transparently run when one uses the <tt>cmt
+      cvs<i>xxx</i>
+   commands</tt>
+):</p>
+  <ol>
+    <li>Find a location for working with temporary files. This is
+        generally deduced from the <tt>${TMPDIR}</tt>
+     environment variable
+        or in <tt>/tmp</tt>
+     (or in the current directory if none of these
+      methods apply).</li>
+    <li>There, install a directory named
+      <tt>cmtcvs/&lt;<i>unique-name</i>
+    &gt;/.cmtcvsinfos</tt>
+  </li>
+    <li>Then, from this directory, try to run a fake import command
+        built as follows:
+<pre>
+cvs -Q import -m cmt .cmtcvsinfos/&lt;protocol-level&gt;/&lt;<i>package-name</i>&gt; CMT v1 </pre>
+      <p>Obviously this command is fake, since no file exist in the
+            temporary directory we have just created. The
+      <tt>protocol-level</tt>
+       referenced in this command is described
+            in the standard macro <tt>$(cmt_cvs_protocol_level)</tt>
+    .</p>
+  </li>
+    <li>This action actually triggers the CVS pluggin installed in the
+    <tt>loginfo</tt>
+     CVS metafile. A default pluggin is provided by
+        CMT implemented as a shell script,
+    <tt>cmt_buildcvsinfos2.sh</tt>
+    , which simply receives in its
+          argument the module name onto which we need information. This
+          information is obtained by scanning the files into the
+          repository, and an answer is built with the following syntax:
+<pre>
+[error=<i>error-text</i>]            (1)
+tags=<i>tag</i> ...                  (2)
+branches=<i>branch</i> ...           (3)
+subpackages=<i>sub-package</i> ...   (4)</pre>
+      <ol>
+        <li>In case of error (typically when the requested module is
+                not found in the repository) a text explaining the error
+              condition is returned</li>
+      <li>The list of tags found on the requirements file</li>
+        <li>The list of branches defined in this packages (ie
+              subdirectories not containing a requirements file)</li>
+        <li>The list of subpackages (ie subdirectories containing a
+              requirements files)</li>
+    </ol>
+  </li>
+    <li>
+          Another version of this pluggin is also available as a C++
+          application. This application is available for download at the
+    <a href="http://www.cmtsite.org">CMT web site</a>
+    .
+  </li>
+</ol>
+</blockquote>
+</blockquote>
+<hr><h1><A NAME="index"></A>Contents</h1>
+<blockquote>
+<table cols="2">
+<tr>
+<td width="100"><tt>&nbsp;1</tt></td>
+<td><a href="#Presentation">Presentation</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;2</tt></td>
+<td><a href="#The conventions">The conventions</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;3</tt></td>
+<td><a href="#The architecture of the environment">The architecture of the environment</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;3.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Supported platforms">Supported platforms</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;4</tt></td>
+<td><a href="#Defining and managing projects">Defining and managing projects</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;4.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The project file">The project file</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;4.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Projects and strategies">Projects and strategies</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;4.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#CMTPROJECTPATH">CMTPROJECTPATH</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;4.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#CMTPATH">CMTPATH</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;5</tt></td>
+<td><a href="#Installing a new package">Installing a new package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;6</tt></td>
+<td><a href="#Localizing a package">Localizing a package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;7</tt></td>
+<td><a href="#Assigning semantics to packages. Common practices">Assigning semantics to packages. Common practices</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;7.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The primary package">The primary package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;7.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The policy package">The policy package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;7.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The container or management package">The container or management package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;7.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The release package">The release package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;7.&nbsp;5</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The glue or interface package">The glue or interface package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;8</tt></td>
+<td><a href="#Managing site dependent features - The CMTSITE environment variable">Managing site dependent features - The CMTSITE environment variable</a></td>
+</tr>
+<tr>
+<td width="100"><tt>&nbsp;9</tt></td>
+<td><a href="#Configuring a package">Configuring a package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>10</tt></td>
+<td><a href="#Selecting a specific configuration">Selecting a specific configuration</a></td>
+</tr>
+<tr>
+<td width="100"><tt>10.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Describing a configuration">Describing a configuration</a></td>
+</tr>
+<tr>
+<td width="100"><tt>10.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Defining the user tags">Defining the user tags</a></td>
+</tr>
+<tr>
+<td width="100"><tt>10.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Activating tags">Activating tags</a></td>
+</tr>
+<tr>
+<td width="100"><tt>11</tt></td>
+<td><a href="#Working on a package">Working on a package</a></td>
+</tr>
+<tr>
+<td width="100"><tt>11.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Working on a library">Working on a library</a></td>
+</tr>
+<tr>
+<td width="100"><tt>11.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Working on an application">Working on an application</a></td>
+</tr>
+<tr>
+<td width="100"><tt>11.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Working on a test or external application">Working on a test or external application</a></td>
+</tr>
+<tr>
+<td width="100"><tt>12</tt></td>
+<td><a href="#Defining a document generator">Defining a document generator</a></td>
+</tr>
+<tr>
+<td width="100"><tt>12.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#An example : the tex document-style">An example : the tex document-style</a></td>
+</tr>
+<tr>
+<td width="100"><tt>12.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#How to create and install a new document style">How to create and install a new document style</a></td>
+</tr>
+<tr>
+<td width="100"><tt>12.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Examples">Examples</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13</tt></td>
+<td><a href="#The tools provided by CMT">The tools provided by CMT</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The requirements file">The requirements file</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;1.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The general requirements syntax">The general requirements syntax</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The concepts handled in the requirements file">The concepts handled in the requirements file</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The package structuring style ">The package structuring style </a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Meta-information : author, manager">Meta-information : author, manager</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#package, version">package, version</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Constituents : application, library, document">Constituents : application, library, document</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;5</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Groups">Groups</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;6</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Languages">Languages</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;7</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Symbols">Symbols</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;7.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#actions">actions</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;8</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#use">use</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;9</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#patterns">patterns</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.&nbsp;9.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Applying a pattern">Applying a pattern</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.10</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmtpath_patterns">cmtpath_patterns</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.11</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#branches">branches</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.12</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Strategy specifications">Strategy specifications</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.13</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#setup_script, cleanup_script">setup_script, cleanup_script</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.14</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#include_path">include_path</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.15</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#include_dirs">include_dirs</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.16</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#make_fragment">make_fragment</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.17</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#public, private">public, private</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.17.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Scoping sections">Scoping sections</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;2.18</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#tag, apply_tag">tag, apply_tag</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The general cmt user interface">The general cmt user interface</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Global options of the cmt command">Global options of the cmt command</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt broadcast">cmt broadcast</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;2.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Specifying the shell command">Specifying the shell command</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;2.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Templates in the shell command">Templates in the shell command</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt build &lt;option&gt;">cmt build &lt;option&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt check configuration">cmt check configuration</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;5</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt check files &lt;reference-file&gt; &lt;new-file&gt;">cmt check files &lt;reference-file&gt; &lt;new-file&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;6</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt checkout ...">cmt checkout ...</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;7</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt co ...">cmt co ...</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;8</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt cleanup [-csh|-sh]">cmt cleanup [-csh|-sh]</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.&nbsp;9</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt config">cmt config</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.10</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt create &lt;package&gt; &lt;version&gt; [&lt;area&gt;]">cmt create &lt;package&gt; &lt;version&gt; [&lt;area&gt;]</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.11</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt expand model [-strict] &lt;model-string&gt;">cmt expand model [-strict] &lt;model-string&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.12</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt filter &lt;in-file&gt; &lt;out-file&gt;">cmt filter &lt;in-file&gt; &lt;out-file&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.13</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt help | --help">cmt help | --help</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.14</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt lock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]">cmt lock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.15</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt remove &lt;package&gt; &lt;version&gt; [&lt;area&gt;]">cmt remove &lt;package&gt; &lt;version&gt; [&lt;area&gt;]</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.16</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt remove library_links">cmt remove library_links</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.17</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt run [shell-command]">cmt run [shell-command]</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.18</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt set version &lt;version&gt;">cmt set version &lt;version&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.19</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt set versions">cmt set versions</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.20</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt setup [-csh|-sh|-bat]">cmt setup [-csh|-sh|-bat]</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.21</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt show &lt;option&gt;">cmt show &lt;option&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.22</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt system">cmt system</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.23</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt unlock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]">cmt unlock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.24</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt version | --version">cmt version | --version</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.25</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt cvstags &lt;module&gt;">cmt cvstags &lt;module&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.26</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt cvsbranches &lt;module&gt;">cmt cvsbranches &lt;module&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.27</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt cvssubpackages &lt;module&gt;">cmt cvssubpackages &lt;module&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;3.28</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt cvssubprojects &lt;module&gt;">cmt cvssubprojects &lt;module&gt;</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The setup and cleanup scripts">The setup and cleanup scripts</a></td>
+</tr>
+<tr>
+<td width="100"><tt>13.&nbsp;5</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#cmt build prototype">cmt build prototype</a></td>
+</tr>
+<tr>
+<td width="100"><tt>14</tt></td>
+<td><a href="#Using cvs together with CMT">Using cvs together with CMT</a></td>
+</tr>
+<tr>
+<td width="100"><tt>14.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Importing a package into a cvs repository">Importing a package into a cvs repository</a></td>
+</tr>
+<tr>
+<td width="100"><tt>14.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Checking a package out from a cvs repository">Checking a package out from a cvs repository</a></td>
+</tr>
+<tr>
+<td width="100"><tt>14.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Querying CVS about some important infos">Querying CVS about some important infos</a></td>
+</tr>
+<tr>
+<td width="100"><tt>14.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Working on a package, creating a new release">Working on a package, creating a new release</a></td>
+</tr>
+<tr>
+<td width="100"><tt>14.&nbsp;5</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Getting a particular tagged version out of CVS">Getting a particular tagged version out of CVS</a></td>
+</tr>
+<tr>
+<td width="100"><tt>15</tt></td>
+<td><a href="#Interfacing an external package with CMT">Interfacing an external package with CMT</a></td>
+</tr>
+<tr>
+<td width="100"><tt>16</tt></td>
+<td><a href="#The installation area mechanism">The installation area mechanism</a></td>
+</tr>
+<tr>
+<td width="100"><tt>16.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The default implementation">The default implementation</a></td>
+</tr>
+<tr>
+<td width="100"><tt>16.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Tuning the installation area mechanisms">Tuning the installation area mechanisms</a></td>
+</tr>
+<tr>
+<td width="100"><tt>17</tt></td>
+<td><a href="#Installing CMT for the first time">Installing CMT for the first time</a></td>
+</tr>
+<tr>
+<td width="100"><tt>17.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Installing CMT on your Unix site">Installing CMT on your Unix site</a></td>
+</tr>
+<tr>
+<td width="100"><tt>17.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Installing CMT on a Windows or Windows NT site">Installing CMT on a Windows or Windows NT site</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18</tt></td>
+<td><a href="#Appendices">Appendices</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Copyright">Copyright</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Standard make targets predefined in CMT">Standard make targets predefined in CMT</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Standard macros predefined in CMT">Standard macros predefined in CMT</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;1</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#CMT static macros">CMT static macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;2</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Structural macros">Structural macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;3</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Language related macros">Language related macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Package customizing macros">Package customizing macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;5</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Constituent specific customizing macros">Constituent specific customizing macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;6</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Source specific customizing macros">Source specific customizing macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;7</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Generated macros">Generated macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;8</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Macros related with the installation area mechanisms">Macros related with the installation area mechanisms</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;3.&nbsp;9</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Utility macros">Utility macros</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;4</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Standard tags generated by CMT">Standard tags generated by CMT</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;5</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Standard templates for makefile fragments">Standard templates for makefile fragments</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;6</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#Makefile generation sequences">Makefile generation sequences</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;7</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The complete project file syntax">The complete project file syntax</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;8</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The complete requirements syntax">The complete requirements syntax</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.&nbsp;9</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The default strategies defined in CMT">The default strategies defined in CMT</a></td>
+</tr>
+<tr>
+<td width="100"><tt>18.10</tt></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;<a href="#The internal mechanism of cmt cvs operations">The internal mechanism of cmt cvs operations</a></td>
+</tr>
+<tr><td colspan="2">&nbsp;</td></tr>
+<tr><td colspan="2"><h2>Images</h2></td></tr>
+<tr>
+<td width="100"><tt>1</tt></td>
+<td><a href="#Structuring a package - A typical example.">Structuring a package - A typical example.</a></td>
+</tr>
+<tr>
+<td width="100"><tt>2</tt></td>
+<td><a href="#Structuring a sofware base.">Structuring a sofware base.</a></td>
+</tr>
+<tr>
+<td width="100"><tt>3</tt></td>
+<td><a href="#The architecture of document generation.">The architecture of document generation.</a></td>
+</tr>
+</table>
+</blockquote>
+<address>
+<i>Christian Arnault</i>
+</address>
+</body>
+</html>
Index: /CMT/v1r20/doc/CMTDoc.xml
===================================================================
--- /CMT/v1r20/doc/CMTDoc.xml	(revision 368)
+++ /CMT/v1r20/doc/CMTDoc.xml	(revision 368)
@@ -0,0 +1,8999 @@
+<?xml version="1.0"?>
+<!DOCTYPE CMT [ 
+  <!ENTITY nbsp "&nbsp;">
+  <!ENTITY CMTrelease "19">
+  <!ENTITY CMTVersion "v1r19">
+  <!ENTITY CMTvTag "CMTv1">
+  <!ENTITY CMTrTag "CMTr19">
+  <!ENTITY CMTpTag "CMTp">
+  <!ENTITY CMTrequirements "&nbsp;<a HREF='#The requirements file'>requirements</a>&nbsp;">
+]>  
+
+<!--
+
+  <!ENTITY  SYSTEM ".xml">
+
+-->
+
+
+<cmt:book
+	  name='CMT'
+	  title='Configuration Management Tool'
+	  version='&CMTVersion;'
+	  author='Christian Arnault'
+	  email='arnault@lal.in2p3.fr'
+>	  
+<!--
+	  updated by='Vincent Garonne'
+	  email='garonne@lal.in2p3.fr'
+-->
+	  
+
+  <cmt:section title='Presentation'>
+
+    <p>This environment, based on some management conventions and
+    comprising several utilities, is an attempt to
+    formalize software production and especially configuration
+    management around a <i>package</i>-oriented principle.</p>
+
+    <p>The notion of <i>packages</i> represents hereafter a set of
+    software components (that may be applications, libraries,
+    documents, tools etc...)  that are to be used for producing a
+    <i>system</i> or a <i>framework</i>.  In such an environment,
+    several persons are assumed to participate in the development and
+    the components themselves are either independent or related to
+    each other.</p>
+
+    <p>The environment provides conventions (for <i>naming</i>
+    packages, files, directories and for <i>addressing</i> them) and
+    tools for <i>automating</i> as much as possible the implementation
+    of these conventions. It permits the <i>description</i> of the
+    configuration requirements and automatically deduce from the
+    description the effective set of configuration parameters needed
+    to operate the packages (typically for <i>building</i> them or
+    <i>using</i> them).</p>
+
+    <p><tt>CMT</tt> lays upon some organisational or managerial
+    principles or mechanisms described below. However, it permits in
+    many respects the users or the managers to <i>control</i>,
+    specialize and customize these mechanisms, through
+    parameterization, strategy control and generic specifications.
+
+      <ul>
+        <li> Many such packages are produced and maintained.  </li>
+
+        <li> Packages sets may be structured in <i>areas</i>
+        implementing a <i>project</i> oriented organization.  </li>
+
+        <li> The projects represent independent organisations of
+        packages, but may be interconnected as a <i>direct acyclic
+        graph</i> of projects</li>
+
+	<li> The packages may or not be related with each other
+	(defining also a <i>direct acyclic graph</i> of packages - not just
+	a single tree).  </li>
+
+	<li> The concept of package may be extended to implement
+	structuring or organizing patterns such as those involved in
+	project management. </li>
+
+	<li> Project management policies and behavioural patterns can
+	be easily expressed and automated by CMT. </li>
+
+	<li> Each <i>executable application</i> (from now on simply
+	named <i>applications</i>) either belongs to a particular
+	package and/or defines its own environment and then makes use
+	of some other packages.  </li>
+
+        <li> Each package can be uniquely identified within the system
+        or the framework by a <i>name</i> which is usually a short
+        <i>mnemonic</i> and which may be also used for isolating its
+        name-space (eg. by <i>prefixing</i> components of the package
+        by its mnemonic).  </li>
+
+	<li> A package installed in this environment may be
+	<i>exported</i> to a site where the architecture is
+	reproduced, and as long as the local organisation defined for
+	the package is preserved through the transport, the
+	reconstruction procedure will be preserved. Configuration
+	specifications can be easily provided to cope with machine,
+	site or system specific features.  </li>
+
+	<li> Packages are maintained consistently to their declared
+	relationships to each other through a <i>version</i>
+	identification model based on :
+
+	  <ul>
+
+	    <li> a version is defined with a mnemonic comprising one
+	    to three numbers the <i>major</i> id, the <i>minor</i> id,
+	    and the <i>patch</i> id </li>
+
+            <li> versions with different major ids are said to be
+            incompatible, </li>
+
+            <li> versions with same major ids but different minor ids
+            are said to be backward compatible with respect of the
+            minor id ordering.  </li>
+
+            <li> versions differing only by their patch id are said to
+            be fully compatible with each other. </li>
+
+          </ul> 
+        </li> 
+
+        <li>Projects are also referenced using a <i>release</i></li>
+
+        <li> Version control and management schemes (eg. by using
+        <tt>CVS</tt>) are usually consistently operated, applying the
+        conventions on organization and version identification.  </li>
+
+        <li> An application that uses one or several packages managed
+        in this environment should not itself be constrained to be
+        managed by <tt>CMT</tt>. The tools should only require a few
+        exported features (such as a few environment variables) for
+        referencing any given package.  </li>
+
+        <li> Similarly, a package maintained in this environment must
+        be able to use packages that are <i>not</i> managed in this
+        environment (which are often called <i>external</i> packages).
+        </li>
+
+      </ul>
+    </p>
+
+    <p>Following these definitions, the basic configuration management
+    operations involved here (and serviced by the <tt>CMT</tt> tools)
+    consist of :
+
+      <ul> 
+
+        <li> installing the packages in conventional locations so that
+        they can be referenced by each other, following projects or
+        teams structuring paradigms, </li>
+
+        <li> describing the configuration &CMTrequirements; for each
+        package:
+
+          <ul> 
+
+            <li> dependencies to other packages, </li>
+
+            <li> generic behavioural patterns meant to describe
+            generic configuration items or project specific policies.
+            </li>
+
+            <li> symbols to be exported to client packages
+            (environment variables, make macros, etc...)  </li>
+
+            <li> parameterized configuration activities (documentation
+            generation, deploiement, installation, etc...)</li>
+
+            <li> components (also named <i>constituents</i>) of the
+            packages (libraries, applications, generated documents) </li>
+
+            <li> parameterization of the build and test tools </li>
+
+            <li> parameterization of the deployment tools </li>
+
+            <li> strategies that <tt>CMT</tt> should follow at run time,
+            overriding its default ones.  </li>
+
+          </ul> 
+        </li> 
+
+        <li> deducing the effective configuration parameters from the
+        &CMTrequirements; so as to
+        automatize the building phases and the run-time operations and
+        connections between packages (typically for generating
+        makefiles, generating compiler and linker options, shared
+        libraries paths etc...). This construction mechanism follows
+        customizable strategies (eg. for selecting among possible
+        alternate versions of available packages).  </li>
+
+      </ul> 
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title='The conventions'>
+
+    <p>This environment relies on a set of conventions, mainly for
+    organizing the directories where projects and packages are
+    maintained and developed : </p>
+
+    <ul> 
+
+      <li> Each package is installed in a standard directory structure
+      defined at least as follows:
+
+        <cmt:code>&lt;some root&gt;/&lt;Package mnemonic&gt;/&lt;version mnemonic&gt;/cmt</cmt:code>
+
+        <p>or (<i>obsolescent convention</i>)
+
+          <cmt:code>&lt;some root&gt;/&lt;Package mnemonic&gt;/&lt;version mnemonic&gt;/mgr</cmt:code>
+
+        </p>
+
+	<p>The &lt;version mnemonic&gt; directory level may also be
+	omitted, in which case the version information will be stored
+	inside the cmt directory in a conventional file named
+	<tt>version.cmt</tt> leading to the following alternate
+	organization:</p>
+
+        <cmt:code>&lt;some root&gt;/&lt;Package mnemonic&gt;/cmt/version.cmt </cmt:code>
+
+        <p>In both cases, the <tt>cmt</tt> directory holds the main source of information
+        needed by <tt>CMT</tt>: the <i>requirements</i> file. All
+        <tt>CMT</tt>-related operations are generally executed from this
+        directory.</p>
+
+        <p>This style of organization should be considered as the
+        basic (and unique) criterion for a package to be recognized as
+        a valid <i>CMT package</i>. Any other structuring convention will
+        be supported by CMT and its operations can always be
+        customized to follow them</p>
+
+        <p>This structure is a central concept since all relationships
+        between packages relies on the package identification which
+        unambiguously and exclusively consists in the duet [
+        <i>package-name</i>, <i>package-version</i> ] (or
+        <i>package-name</i> only when the version directory level is
+        omitted).</p>
+
+      </li>
+
+      <li> Constructing the internal structure of a package.
+
+        <p>Many other parallel directory branches (similar to <tt>cmt</tt>) such
+        as <tt>src</tt>, <tt>include</tt> or <tt>test</tt> may be freely
+        added to this list according to the specific needs of each
+        package.  In particular, a set of such parallel branches are
+        expected to contain <i>binary</i> outputs (those that
+        compilers, linkers, archive managers or other kinds of code or
+        pseudo-code generators can produce). Their name always
+        corresponds to the particular <i>configuration tag</i> used to
+        produce the output (such as the machine or operating system
+        type). The <tt>CMT</tt> toolkit provides, through the <tt>cmt
+        system</tt> utility, a default value for this token. An
+        environment variable (<tt>CMTCONFIG</tt>) is also assigned to
+        this value (See the <a href="#Selecting a specific configuration">complete description</a> 
+        of configuration tags).</p>
+
+        <p>Each branch may in addition be freely structured, and there
+        is no constraint to the complexity of this organization.</p>
+
+        <cmt:image src="Images/InternalPackageStructure.jpg" caption="Structuring a package - A typical example."/>
+
+      </li> 
+
+      <p></p>
+
+      <li> Organizing a software base.
+
+        <p>A software base is generally composed of multiple coherent
+        sets of packages, each installed in its specific root
+        directory and forming different <i>package areas</i> or
+        <i>sub-projects</i></p>
+
+        <p>Package areas implement the concept of <i>projects</i> or
+        <i>sub-projects</i> which correspond to the practical
+        organization of the software base.</p>
+
+        <p>There are no constraints on the number of such sub-projects
+        or areas into which <tt>CMT</tt> packages are installed. We'll
+        see <a HREF="#Localizing a package">later</a> how the
+        different sub-projects can be declared and identified by
+        <tt>CMT</tt>.</p>
+
+        <p>examples of such organization can be : </p>
+
+        <cmt:image src="Images/PackageStructure.jpg" caption="Structuring a sofware base."></cmt:image>
+
+      </li> 
+    </ul> 
+
+  </cmt:section>
+
+  <cmt:section title="The architecture of the environment">
+
+    <p>This environment is based on the fact that one of its packages
+    (named <tt>CMT</tt>) provides the basic management
+    tools. <tt>CMT</tt>, as a package, has very little specificities
+    and as such itself obeys the general conventions.</p>
+
+    <p>Then the complete software base is organized in terms of
+    projects (or <i>sub-projects</i>), containing consistently managed
+    package sets. Projects are localized either globally or
+    individually:
+
+      <ul>
+
+        <li>globally using the environment variable
+        <tt>CMTPROJECTPATH</tt> that describes all locations where CMT
+        projects can be found</li>
+
+        <li>individually using the environment variable
+        <tt>CMTPATH</tt> that describe all package areas where
+        packages can be found</li>
+
+      </ul>
+
+    Packages are localized respectively to the projects they belong
+    to.</p>
+
+    <p>It should be noted that the choice of a location for installing
+    CMT itself is totally independent of the locations where projects
+    are installed and managed.</p>
+
+    <p><tt>CMT</tt> is operated through one main user interface : the
+    <tt>cmt</tt> command, which operates the <tt>CMT</tt> conventions
+    and which provides a set of services for : </p>
+
+    <ul> 
+
+      <li> creating a new package. This operation will create or check
+      the local package directory tree and generate several minimal
+      scripts (see the description of the <a HREF="#create">create</a>
+      command), </li>
+
+      <li> describing or monitoring :
+
+        <ul> 
+
+          <li> the relationships between the package and other
+          packages </li>
+
+          <li> the configuration features either specified in the
+          current package, or imported from related (<i>used</i>)
+          ones. (symbols, patterns, fragments) </li>
+
+          <li> the constituents of the package in terms of libraries,
+          executables, or generated documents.  </li>
+
+        </ul> 
+      </li> 
+
+      <li> automatically generating the reconstruction scripts
+      (<tt>makefiles</tt>) from this description.  </li>
+
+      <li> recursively acting upon the hierarchy of used packages.
+      </li>
+
+    </ul> 
+
+    <p>Several other utilities are also provided for some specific
+    activities (such as the automatic production of shared libraries,
+    <tt>C</tt> prototypes, management of interactions between <tt>CVS</tt>
+    and <tt>CMT</tt> itself, the management of a similar architecture
+    for <tt>Windows</tt> or <tt>OS9</tt>, setting up protections for
+    packages (through locks) etc...). </p>
+
+    <cmt:section title="Supported platforms">
+
+      <tt>CMT</tt> has been ported and tested on a wide range of
+      machines/operating systems, including :
+
+      <ul>
+
+        <li> DEC-Unix V4.0 </li>
+
+        <li> HP-UX-10 (several types of platforms) </li>
+
+        <li> AIX-4 </li>
+
+        <li> Solaris </li>
+
+        <li> IRIX </li>
+
+        <li> Several variants of LynxOS </li>
+
+        <li> All variants of Linux (RedHat, Debian, SuSe, ScientificLinux, ...) </li>
+
+        <li> Windows 95/98/NT/Windows2000 in various environments:
+
+	  <ul>
+
+	    <li> <tt>CYGWIN_NT-5.1</tt> environment </li>
+
+	    <li> <tt>nmake</tt> based environment </li>
+
+	    <li> <tt>MSDev/VisualC 6</tt> environment</li>
+
+	    <li> <tt>MSDev/VisualC 7</tt> environment</li>
+
+	  </ul>
+
+        </li>
+
+        <li> Darwin (Mac OS X) </li>
+
+      </ul> 
+
+      This in particular means that a package developped on one
+      platform may be re-configured towards any of these platforms
+      without any change to its configuration description. All
+      platform specific tools will be dynamically reconfigured and
+      parameterized transparently.
+
+    </cmt:section> 
+
+  </cmt:section> 
+
+
+  <cmt:section title="Defining and managing projects">
+
+    <p>In the CMT terminology, the complete software base is composed
+    of CMT packages. Those packages are organized into
+    sub-projects. The semantics of a sub-project is very opened since
+    it's merely an area for grouping CMT packages. Typically
+    sub-projects may correspond to</p>
+
+    <ul>
+
+      <li>a structuration in software domains, such as Reconstruction,
+      Simulation, Graphics, Core, etc.</li>
+
+      <li>how responsibilities or management policies are defined and
+      assigned </li>
+
+      <li>reusing or sharing different software products from
+      different projects</li>
+
+    </ul>
+
+    <p>Considering the simple structuring aspects of sub-projects, two
+    important configuration parameters (environment variables) handled
+    by CMT must be understood before attempting to manage
+    packages:</p>
+
+    <ul>
+
+      <li><a href="#CMTPROJECTPATH"><tt>CMTPROJECTPATH</tt></a> for a
+      global specification of where projects can be found. This
+      specification should be considered as the standard mechanism for
+      structuring the software base since from it, CMT can and will
+      deduce all other localization parameters (like
+      <tt>CMTPATH</tt>).<p></p></li>
+
+      <li><a href="#CMTPATH"><tt>CMTPATH</tt></a> offers a more
+      internal mechanism for localizing packages. It's not generally
+      meant to be defined manually since CMT will construct it from
+      <tt>CMTPROJECTPATH</tt>. However, it's important to understand
+      how this configuration parameter is used to locate
+      packages.</li>
+    </ul>
+
+    <p>Projects receive detailed descriptions or specifications in a
+    dedicated <i>project file</i>, always located in a <tt>cmt</tt>
+    directory at their top directory level, and named
+    <tt>cmt/project.cmt</tt>. It can receive the following
+    specifications:</p>
+
+    <cmt:code>
+project &lt;project-name&gt;          [1]
+<i>project-use specifications...</i>   [2]
+<i>strategy specifications...</i>      [3]</cmt:code>
+
+    <ol>
+
+      <li>The project name specified here takes precedence over the
+      project name specified in the directory structure. However when
+      <tt>CMTPROJECTPATH</tt> is not specified, this may cause
+      conflicts in the localization of projects. In this case it's
+      highly recommended to always use the same naming convention in
+      project files as in the directory hierarchy.<p></p></li>
+
+      <li>Projects are hierarchized as a directed acyclic graph. The
+      minimal hierarchy simply corresponds to the order of the
+      <tt>CMTPATH</tt> items. A more complex hierarchy can be
+      specified through use statements between sub-projects. This
+      hierarchy also defines a <i>parent/child</i> relationship between
+      projects. If a project <tt>A</tt> uses another project
+      <tt>B</tt>, <tt>A</tt> is also named the <i>parent</i> and
+      <tt>B</tt> the <i>child</i><p></p></li>
+
+      <li>CMT Strategies (for build or setup) are separately
+       collected into each project. Therefore one can apply different
+       strategies to different sub-projects. The strategy
+       specifications may appear in requirements file of any package
+       of a project or in the <tt>cmt/project.cmt</tt> project file.
+
+       <p>By default a project inherits the strategies of its
+       parents. Or if it's the top project, it follows the default
+       strategies defined by CMT (Refer to this 
+
+       <a href="#The default strategies defined in CMT">appendix</a>
+       to see the default strategies currently defined by CMT).</p>
+
+       <p></p></li>
+
+    </ol>
+
+    <cmt:section title="The project file">
+
+      <p>The project file can be created using the command:</p>
+
+      <cmt:code>
+&gt; cmt create_project &lt;project-name&gt; [&lt;release&gt;] [&lt;path&gt;]
+&gt; cmt create_project &lt;project-name&gt; [&lt;release&gt;] [&lt;path&gt;] [-use=&lt;package&gt;:&lt;version&gt;:&lt;path&gt;]...</cmt:code>
+
+      <p>This will create the complete directory hierarchy from the
+      current directory (or, when it is specified from the optional
+      project path). It will also create a project file containing the
+      project name, and optionnally will initialize it with some use
+      statements.</p>
+
+      <blockquote><i>Note that the &lt;release&gt; argument may be
+      left empty (or to an empty string). In this case, the directory
+      hierarchy will be limited to the single level of the project
+      name.</i></blockquote>
+
+      <cmt:code>
+&lt;path&gt;/&lt;project-name&gt;/&lt;release&gt;/cmt/project.cmt
+&lt;path&gt;/&lt;project-name&gt;/cmt/project.cmt</cmt:code>
+
+      <p>As an example, we create the following projects:</p>
+
+      <cmt:code>
+&gt; cmt create_project WorkArea "" /test
+&gt; cmt create_project ProjectA 1.0 /test
+&gt; cmt create_project ProjectB 1.0 /test</cmt:code>
+
+      <p>And we manually fill <tt>CMTPATH</tt> with:</p>
+
+      <cmt:code>
+/test/WorkArea:/test/ProjectA/1.0:/test/ProjectB/1.0</cmt:code>
+
+      <p>Then, when standing in the <tt>WorkArea</tt> the following
+      projects will appear displayed from bottom to top as</p>
+
+      <cmt:code>
+&gt; cd /test/WorkArea
+&gt; cmt show projects 
+<i><font face="courier new, courier" COLOR="#000077">WorkArea (in /test/WorkArea) (current)
+  ProjectA 1.0 (in /test/ProjectA/1.0)
+    ProjectB 1.0 (in /test/ProjectB/1.0)</font></i></cmt:code>
+
+      <p>Of course the preferred way to characterize this software
+      base should rather be based on specifying the relationships
+      between those three sub-projects, through the use statements in
+      the projects files.</p>
+
+      <p>For instance in our little example, we could add the
+      following statement into the project file of WorkArea:</p>
+
+      <cmt:code>
+use ProjectA 1.0</cmt:code>
+
+      <p>and the following statement into the project file of ProjectB:</p>
+
+      <cmt:code>
+use ProjectB 1.0</cmt:code>
+
+      <p>Then instead of specifying <tt>CMTPATH</tt> we'd rather
+      simply define <tt>CMTPROJECTPATH</tt> as:</p>
+
+      <cmt:code>
+/test</cmt:code>
+
+      <p>This complete sequence may also be shortened as follows:</p>
+
+      <cmt:code>
+&gt; cmt create_project ProjectB 1.0 /test
+&gt; cmt create_project ProjectA 1.0 /test -use=ProjectB:1.0
+&gt; cmt create_project WorkArea "" /test -use=ProjectA:1.0</cmt:code>
+
+    </cmt:section>
+
+    <cmt:section title="Projects and strategies">
+
+      <p>Few behaviours of the configuration management process can be
+      tailored with respect to CMT, via means of defining
+      <i>strategies</i>. Then according to these strategies, CMT will
+      behave in well defined ways.</p>
+
+      <p>Every strategy setting is a boolean value, instructing CMT to
+      activate or not a given behaviour. As such it defines two
+      mutually exclusive CMT <i>tags</i> and it activates one of
+      them.</p>
+
+      <cmt:cmtcode>
+&lt;project&gt;_&lt;have_item&gt; 
+&lt;project&gt;_&lt;have_not_item&gt; </cmt:cmtcode>
+
+      <p>Examples</p> 
+
+      <cmt:cmtcode>
+&lt;project&gt;_with_install_area
+&lt;project&gt;_without_install_area
+&lt;project&gt;_config
+&lt;project&gt;_no_config
+&lt;project&gt;_root
+&lt;project&gt;_no_root
+&lt;project&gt;_cleanup
+&lt;project&gt;_no_cleanup
+&lt;project&gt;_with_version_directory
+&lt;project&gt;_without_version_directory
+&lt;project&gt;_prototypes
+&lt;project&gt;_no_prototypes</cmt:cmtcode>
+
+      <p>In the context of a hierarchy - <i>a graph</i> - of projects,
+      strategies are transmitted along the graph, according to the use
+      relationships specified between the projects. A project
+      transmits its strategies to its clients except when one of them
+      overrides those strategies.</p>
+
+      <p>Several mechanisms help defining project specific properties,
+      and more specifically making use of the strategies:</p>
+
+      <ul>
+
+        <li>The <tt>&lt;project&gt;</tt> parameter is expanded in the
+        <tt>cmtpath_pattern</tt> construct in addition to the
+        <tt>&lt;path&gt;</tt> parameter. This parameter is assigned
+        the name of the project associated with the running
+        <tt>CMTPATH</tt> entry.  <p></p></li>
+
+        <li>The <tt>&lt;project&gt;</tt> parameter is also available
+        for normal patterns. In this case it is assigned the project
+        name associated with the cmtpath parameter for the current
+        package.<p></p></li>
+
+        <li>Every project defines a tag of the same name, and the tag
+        of the current project is active.<p></p></li>
+
+        <li>The <tt>cmt_installarea_prefix</tt> macro is specialized
+        <i>per project</i> and every project may override the
+        <tt>&lt;project&gt;_installarea_prefix</tt> macro. The default
+        value of any <tt>&lt;project&gt;_installarea_prefix</tt> is
+        <tt>${cmt_installarea_prefix}</tt> (which itself is a global
+        macro that receives a default value from CMT )<p></p></li>
+
+      </ul>
+
+    </cmt:section>
+
+    <cmt:section title="CMTPROJECTPATH">
+
+      <p>This is an environment variable containing a search list,
+      very similar to the well know Unix or Windows <tt>PATH</tt>
+      environment variable. It specifies a list of file paths where
+      CMT projects can be found. The syntax of this search list
+      follows the standard syntax of search lists, i.e. items are
+      separated using a <tt>:</tt> character on Unix and a <tt>;</tt>
+      character on Windows.</p>
+
+      <p><blockquote><i>One should understand this search list as the
+      primary mechanism to locate sub-projects in the software base,
+      and therefore packages. This in particular can completely
+      replace the <tt>CMTPATH</tt>-based search mechanism for packages
+      that was used before <tt>v1r18</tt>. However the two mechanisms
+      are still both supported and in fact interact with each
+      other.</i></blockquote></p>
+
+      <p>A sub-project in itself is a multi-level directory structure,
+      located below one of the items of this search list, and composed
+      of:</p>
+
+      <ul>
+
+        <li>the sub-project name</li>
+
+        <li>the sub-project release (which may span several directory levels)</li>
+
+      </ul>
+
+      <p>Then, below this directory structure, we find</p>
+
+      <ul>
+
+        <li>A project definition file in <tt>cmt/project.cmt</tt></li>
+
+        <li>A set of CMT packages</li>
+
+      </ul>
+
+      <p>A typical example of such a structure could be:</p>
+
+      <cmt:code>
+/project-area1/Reconstruction/1.0/cmt/project.cmt
+                                 /RecA/...
+                                 /RecB/...
+/project-area1/Reconstruction/2.0/cmt/project.cmt
+                                 /RecA/...
+                                 /RecB/...
+
+/project-area1/Simulation/1.0/cmt/project.cmt
+                             /SimA/...
+                             /SimB/...
+/project-area1/Core/1.0/cmt/project.cmt
+                       /CoreA/...
+                       /CoreB/...
+
+
+/project-area2/ProductA/1.1.2/cmt/project.cmt
+                             /PA_A/...
+                             /PA_B/...
+                             /PA_C/...
+/project-area2/ProductB/v1r8p3/cmt/project.cmt
+                              /PB_A/...
+                              /PB_B/...
+/project-area2/ProductB/v1r10/cmt/project.cmt
+                             /PB_A/...
+                             /PB_B/...   </cmt:code>
+
+      <p>In this example:</p>
+
+      <ul>
+
+        <li>there are two project areas, one for the main developments
+        (<tt>/project-area1</tt>), and another one for managing
+        external products (<tt>/project-area1</tt>)</li>
+
+        <li><tt>project-area1</tt> offers three sub-projects
+        <tt>Reconstruction</tt>, <tt>Simulation</tt> and
+        <tt>Core</tt></li>
+
+        <li><tt>project-area2</tt> offers two sub-projects
+        <tt>ProductA</tt> and <tt>ProductB</tt></li>
+
+        <li>the sub-project <tt>Reconstruction</tt> is available in two
+        releases <tt>1.0</tt> and <tt>2.0</tt></li>
+
+        <li>the sub-project <tt>Reconstruction</tt> offers two packages
+        <tt>RecA</tt> and <tt>RecB</tt></li>
+
+        <li>the sub-project <tt>ProductB</tt> is available in two
+        releases <tt>v1r8p3</tt> and <tt>v1r10</tt></li>
+
+      </ul>
+
+      <p>This search list is used to interpret the <i>use</i>
+      statements written in the project files. This project use
+      statement takes the form:</p>
+
+      <cmt:syntax name="project-use">
+        <cmt:rule name="project-use">
+          <cmt:alt>
+            <cmt:kwd name="use"/>
+            <cmt:term name="project-name"/>
+            <cmt:term name="project-release"/>
+          </cmt:alt>
+        </cmt:rule>
+      </cmt:syntax>
+
+      <p>Typically, in our example one could construct the project
+      file of the <tt>Reconstruction</tt> sub-project as follows:</p>
+
+      <cmt:code>
+use Core 1.0
+use ProductA 1.1.2</cmt:code>
+
+      <p><i>Note that sub-project release identifiers are always
+      considered using a perfect-match principle.</i></p>
+
+      <p>Structuring the set of sub-projects comprising a software
+      base is sufficient to permit CMT to find <i>all</i> sub-projects
+      and thus <i>all</i> packages in them. Defining
+      <tt>CMTPROJECTPATH</tt> <i>and</i> installing the list of use
+      statements in all appropriate project files entirely suppress
+      the need of manually defining the <tt>CMTPATH</tt> search
+      list.</p>
+
+    </cmt:section>
+
+    <cmt:section title="CMTPATH">
+
+      <p>This is an environment variable containing a search list,
+      very similar to the well know <tt>PATH</tt> environment
+      variable, containing a list of file paths where CMT packages can
+      be found. The syntax of this search list follows the standard
+      syntax of search lists, i.e. items are separated using a
+      <tt>:</tt> character on Unix and a <tt>;</tt> character on
+      Windows.</p>
+
+      <p><blockquote><i>When the software base is organized and
+      configured using the <a
+      href="#CMTPROJECTPATH"><tt>CMTPROJECTPATH</tt></a> search list
+      and project-use statements in the project files, this search
+      list is automatically and internally generated by CMT, and
+      therefore it should not be manually defined nor manipulated. If
+      this is your case, you can skip this
+      section</i></blockquote></p>
+
+      <p>It is possible to manually define this search list (when
+      <tt>CMTPROJECTPATH</tt> is not defined or when project files are
+      not provided)</p>
+
+      <p>There should be one entry per package area, and the list is
+      ordered. The order of items is used to prioritize the package
+      search.</p>
+
+      <p><tt>CMTPATH</tt> can be specified:</p>
+
+      <ul>
+
+        <li>as the environment variable named <tt>CMTPATH</tt>
+
+          <cmt:code>
+sh&gt; export CMTPATH=/home/arnault/mydev:/ProjectB </cmt:code>
+
+          <cmt:code>
+bat&gt; set CMTPATH=/home/arnault/mydev;/ProjectB </cmt:code>
+
+          or (in a <tt>requirements</tt> file) 
+
+          <cmt:cmtcode>
+path_append CMTPATH "/home/arnault/mydev"
+path_append CMTPATH "/ProjectB"</cmt:cmtcode>
+
+        </li>
+
+        <li>in <tt>.cmtrc</tt> files, which can be located either in
+        the current directory, in the <i>home</i> directory of the
+        developper or in <tt>${CMTROOT}/mgr</tt>. The syntax to use in this
+        configuration file is:
+
+          <cmt:code>
+CMTPATH=/home/arnault/mydev:/ProjectB </cmt:code>
+
+        </li>
+
+        <li>In the Windows environment, this configuration parameter
+        may also be installed as a <i>Registry</i> under the alternate
+        keys:
+
+          <ul> 
+            <li> <tt>HKEY_LOCAL_MACHINE/Software/CMT/path</tt> </li>
+            <li> <tt>HKEY_CURRENT_USER/Software/CMT/path</tt> </li>
+          </ul>
+        </li>
+      </ul>
+
+      <blockquote><i>The project file (i.e. the file
+      <tt>cmt/project.cmt</tt>), when it exists for the current
+      package (i.e. upstream in the directory hierarchy), also
+      provides an automatic value for the <tt>CMTPATH</tt> search
+      list.</i></blockquote>
+
+    </cmt:section>
+
+  </cmt:section>
+
+  <cmt:section title="Installing a new package">
+
+    <p>We consider here the installation of a user package. Installing
+    <tt>CMT</tt> itself requires special attention and is described in a 
+    dedicated <a href="#Installing CMT for the first time">section</a>
+    of this document.</p>
+
+    <p>Therefore, we assume that <tt>CMT</tt> is already installed in
+    some location in the system.  One first has to <i>setup</i>
+    <tt>CMT</tt> in order to gain access to the various management
+    utilities, using for example the shell command: </p>
+
+    <cmt:code>
+csh&gt; source /lal/CMT/&CMTVersion;/mgr/setup.csh
+
+or 
+
+ksh&gt; . /lal/CMT/&CMTVersion;/mgr/setup.sh
+
+or 
+
+dos&gt; call \lal\CMT\&CMTVersion;\mgr\setup.bat</cmt:code> 
+
+    <p>Obviously, this operation <i>must</i> be performed (once)
+    before any other <tt>CMT</tt> action. Therefore it is often
+    recommended to install this setup action straight in the
+    <i>login</i> script. </p>
+
+    <cmt:blockquote>
+      <i>
+
+        <p> The <i>setup script</i> used in this example is a constant
+        in the <tt>CMT</tt> environment : every configured package
+        will have one such setup script automatically generated and
+        installed by <tt>CMT</tt>. It is one important entry point to
+        any package (and thus to <tt>CMT</tt> itself). It provides
+        environment variable definitions for all related (<i>used</i>)
+        packages (A corresponding cleanup script is also
+        provided). This script contains a uniform mechanism for
+        <i>interpreting</i> the &CMTrequirements; file so as to
+        dynamically define environment variables, aliases for the
+        package itself and all its used packages. It is constructed
+        once per package installation by the <tt>cmt create</tt>
+        command, or restored by the <tt>cmt config</tt> command (if it
+        has been lost).</p>
+
+      </i>
+    </cmt:blockquote>        
+
+    <p>It is generally good to start by immediately defining a
+    <i>project</i>. This project is our first disk area where CMT
+    packages will be located. Remember that several such projects can
+    be set up and defined. The simplest way to do this is:</p>
+
+    <cmt:code>
+&gt; cmt create_project Dev
+<i><font face="courier new, courier" COLOR="#000077">------------------------------------------
+Configuring environment for project Dev
+CMT version &CMTVersion;.
+------------------------------------------
+Installing the cmt directory
+Creating a new project file </font></i></cmt:code>
+
+    <p>This creates a project structure
+    <tt>Dev/cmt/project.cmt</tt> from the current directory. Once
+    this project has been created we have a complete environment to
+    start creating packages below <tt>Dev</tt> and working out our software base.</p>
+
+    <p> A package is primarily defined by a <i>name</i> and a
+    <i>version</i> identifier (this duet actually forms the complete
+    <i>package identifier</i>). These two attributes will be given as
+    arguments to <tt>cmt create</tt> such as in the following example :
+    </p>
+
+    <cmt:code>
+csh&gt; cd Dev
+csh&gt; cmt create Foo v1
+<i><font face="courier new, courier" COLOR="#000077">------------------------------------------
+Configuring environment for package Foo version v1.
+CMT version &CMTVersion;.                              [1]
+Root set to /home/arnault/Dev.
+System is Linux-i686                                     [2]
+------------------------------------------
+Installing the package directory                         [3]
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts. </font></i></cmt:code>
+
+    <ol>
+
+      <li>This shows which actual CMT version you are currently using</li>
+
+      <li>This shows the current configuration tag (also available by
+      the <tt>cmt system</tt> command). In this example this is a
+      <tt>Linux</tt> machine</li>
+
+      <li>This shows the detailed construction of the complete
+      directory structure, starting from the top directory which has
+      the name of the package. Since we are creating a completely new
+      package, there will be by default only two branches below the
+      version directory : <tt>cmt</tt> and <tt>src</tt>.</li>
+
+    </ol>
+
+    <p>The package creation occured from the current directory,
+    creating from there the complete directory tree for this new
+    package.</p>
+
+    <p>In the next example, we install the package in a completely
+    different area, by explicitly specifying the path to it as a third
+    argument to <tt>cmt create</tt> : </p>
+
+    <cmt:code>
+&gt; cmt create Foo v1 /ProjectB 
+<i><font face="courier new, courier" COLOR="#007700">------------------------------------------
+Configuring environment for package Foo version v1.
+CMT version &CMTVersion;.
+Root set to /ProjectB.
+System is Linux-i686
+------------------------------------------
+Installing the path directory
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts. </font></i></cmt:code>
+
+    <p></p>        
+
+    Several file creations occurred at this level : 
+
+    <ul> 
+
+      <li> a minimal directory tree for the package, including
+      <tt>src</tt> and <tt>cmt</tt> (the other branches will be installed
+      when needed or generated at build time).  </li>
+
+      <p></p>
+
+      <li> an empty configuration specification file (named
+      <tt>requirements</tt>) installed in the <tt>cmt</tt> branch.  </li>
+
+      <p></p>
+
+      <li> A minimal <tt>Makefile</tt> (on Unix environments only),
+      containing
+
+        <cmt:code>
+include $(CMTROOT)/src/Makefile.header 
+
+include $(CMTROOT)/src/constituents.make </cmt:code>
+
+        <p></p>
+
+        This <tt>Makefile</tt> does not need any further modification to
+        build any of the constituents managed by <tt>CMT</tt>. The
+        intermediate makefile fragments will always be re-generated
+        transparently and automatically at build time. However (and
+        thanks to this feature), this file will not be modified
+        <i>anymore</i> by <tt>CMT</tt> itself. Thus you may insert any
+        particular make statement you would feel appropriate,
+        typically when you ask for operations that cannot be taken
+        - if any - into account by <tt>CMT</tt>.
+
+      </li> 
+
+      <p></p>
+
+      <li> A similar minimal <tt>NMake</tt> file (on Windows
+      environments only), containing
+
+        <cmt:code>
+!include $(CMTROOT)\src\NMakefile.header 
+
+!include $(CMTROOT)\src\constituents.nmake </cmt:code>
+
+      </li>
+
+      <p></p>
+
+      <li> the setup and cleanup scripts (one flavour for each shell
+      family).  </li>
+
+    </ul> 
+
+    One <i>may</i> then setup this new package by running the setup
+    script (which will not have much effect yet since the requirements
+    file is empty) :
+
+    <cmt:code>
+sh&gt; cd ~/mydev/Foo/v1/cmt 
+sh&gt; . setup.sh </cmt:code>
+
+or 
+
+    <cmt:code>
+csh&gt; cd ~/mydev/Foo/v1/cmt 
+csh&gt; source setup.csh </cmt:code>
+
+or 
+
+    <cmt:code>
+dos&gt; cd \mydev\Foo\v1\cmt 
+dos&gt; call setup.bat</cmt:code>
+
+    <p>The <tt>FOOROOT</tt> and <tt>FOOCONFIG</tt> environment variables
+    are defined automatically by this operation. </p>
+
+    <p>It should be noted that running the setup script of a package
+    is not always necessary for building operations. The only
+    situation where running this script <i>may</i> become useful, is
+    when an application is to be run, while requiring domain specific
+    environment variables defined in one of the used packages. Besides
+    this particular situation, running the setup scripts may not be
+    needed at all. </p>
+
+    <p>Lastly, this newly created package may be removed by the quite
+    similar remove command, using exactly the same arguments as those
+    used for creating the package.</p>
+
+    <cmt:code>csh&gt; cd mydev
+csh&gt; cmt remove Foo v1 
+<i><font face="courier new, courier" COLOR="#000077">------------------------------------------
+Removing package Foo version v1.
+CMT version &CMTVersion;.
+Root set to /home/arnault/mydev.
+System is Linux-i686
+------------------------------------------
+Version v1 has been removed from /home/arnault/mydev/Foo
+Package Foo has no more versions. Thus it has been removed.</font></i></cmt:code>
+
+    or:
+
+    <cmt:code>csh&gt; cmt remove Foo v1 /ProjectB
+<i><font face="courier new, courier" COLOR="#000077">------------------------------------------
+Removing package Foo version v1.
+CMT version &CMTVersion;.
+Root set to /ProjectB.
+System is Linux-i686
+------------------------------------------
+Version v1 has been removed from /ProjectB/Foo
+Package Foo has no more versions. Thus it has been removed.</font></i></cmt:code>
+
+    <p>So far our package is not very useful since no constituent
+    (application or library) is installed yet. You can jump to the
+    section showing how to work on an <a href="#Working on an application">application</a> 
+    or on a <a href="#Working on a library">library</a> 
+    for details on these operations or we can
+    roughly draw the sequence used to specify and build the simplest
+    application we can think of as follows:</p>
+
+    <cmt:code>
+csh&gt; cd ~/mydev/Foo/v1/cmt
+csh&gt; cat &gt;../src/FooTest.c 
+#include &lt;stdio.h&gt;
+
+int main ()
+{
+  printf ("Hello Foo\n");
+  return (0);
+}
+
+csh&gt; vi requirements 
+... 
+application FooTest FooTest.c 
+csh&gt; gmake
+csh&gt; source setup.csh
+csh&gt; FooTest.exe
+<i><font face="courier new, courier" COLOR="#007700">Hello Foo</font></i></cmt:code>
+
+    <p>Directly running the application is possible since the
+    application has been installed after being built in
+    an automatic <i>installation area</i> reachable through the
+    standard <tt>PATH</tt> environment variable</p>
+
+    <p>This can also be integrated in the build process by providing
+    the -check option to the application definition:</p>
+
+    <cmt:code>
+csh&gt; cd ../cmt 
+csh&gt; vi requirements 
+... 
+application FooTest -check FooTest.c 
+csh&gt; gmake check
+<i><font face="courier new, courier" COLOR="#000077">Hello Foo</font></i></cmt:code>
+
+  </cmt:section>
+
+  <cmt:section title="Localizing a package">
+
+    <p>In the next sections, we'll see that packages <i>reference</i>
+    each other by means of <i>use</i> relationships. Generally
+    packages are found in different locations, according to the
+    project - or sub-project - they belong to.  <tt>CMT</tt> provides a
+    quite flexible mechanism for <i>localizing</i> the referenced
+    packages. </p>
+
+    <p>The first ingredient we need at this level is to understand how
+    projects themselves are localized, since packages will be found
+    inside project areas. You should therefore refer to the 
+
+    <a href="#Defining and managing projects">section on projects</a>
+    where the complete mechanism based on <a
+    href="#CMTPROJECTPATH"><tt>CMTPROJECTPATH</tt></a> or <a
+    href="#CMTPATH"><tt>CMTPATH</tt></a> is described.</p>
+
+    <p>However, there is one special case where this path list can be
+    avoided, i.e. when only one project is considered. In this case,
+    the knowledge of this single project area can simply be deduced
+    from the detection of the project file, created at the top of its
+    disk space.</p>
+
+    <p>A given version of a given package is always referred to by
+    using a <i>use</i> statement within its <tt>&CMTrequirements;</tt>
+    file. This statement should specify the package through three
+    <i>keys</i> :</p>
+
+    <ul> 
+
+      <li> its name (such as <tt>Bar</tt>) </li>
+
+      <li> its version (such as <tt>v7r5</tt>) </li>
+
+      <li> optionally its expected absolute location or relative
+      offset
+      </li>
+
+    </ul> 
+
+    <cmt:cmtcode>
+use Bar v7r5                    [1]</cmt:cmtcode>
+
+    <i>or</i>
+
+    <cmt:cmtcode>
+use Bar v7r5 A                  [2]</cmt:cmtcode>
+
+    <i>or</i>
+
+    <cmt:cmtcode>
+use Bar v7r5 /ProjectB/A        [3]</cmt:cmtcode>
+
+    <p>Given these keys, the referenced package is looked for
+    according to a prioritized search list which is (in decreasing
+    priority order) : </p>
+
+    <ol> 
+
+      <li> the absolute access path, if the <i>use path</i> is
+      absolute (case #3), </li>
+
+      <li> the access paths registered in the configuration parameter
+      <a href="#CMTPATH"><tt>CMTPATH</tt></a> (and in decreasing
+      priority, the first element being searched for first).</li>
+
+    </ol> 
+
+    <p>If the <i>path</i> argument is specified as a relative path
+    (case #2 above) (ie. there is no leading <i>slash</i> character or
+    it's not a <i>disk</i> on windows machines), it will be used as an
+    <i>offset</i> to each search case. The search is done starting
+    from the list specified in the <tt>CMTPATH</tt> configuration
+    parameter; and the offset is appended at each searched
+    location.</p>
+
+    <p>As an example, if the <tt>CMTPATH</tt> parameter contains: </p>
+
+    <cmt:code>
+/home/arnault/mydev:/ProjectB </cmt:code>
+
+    <p>Then a <i>use</i> statement (defined within a given package)
+    containing : </p>
+
+    <cmt:cmtcode>
+... 
+use Bar v7r5
+use BarA v1 A</cmt:cmtcode>
+
+    would look for the package <tt>Bar</tt> from :
+
+    <ol> 
+
+      <li> <tt>/home/arnault/mydev/Bar/v7r5/cmt</tt> </li>
+
+      <li> <tt>/ProjectB/Bar/v7r5/cmt</tt> </li>
+
+    </ol> 
+
+    Whereas the package <tt>BarA</tt> would be searched from : 
+
+    <ol> 
+
+      <li> <tt>/home/arnault/mydev/A/BarA/v1/cmt</tt> </li>
+
+      <li> <tt>/ProjectB/A/BarA/v1/cmt</tt> </li>
+
+    </ol> 
+
+    The packages are searched assuming that the directory hierarchy
+    below the access paths always follow the convention :
+
+    <ol> 
+
+      <li> there is a first directory level exactly named according to
+      the package name (this is case sensitive), </li>
+
+      <li> then (optionally) the next directory level is named
+      according to the version tag, </li>
+
+      <li> then there is a branch named <tt>cmt</tt>, </li>
+
+      <li> lastly there is a <i>requirements</i> file within this
+      <tt>cmt</tt> branch.  </li>
+
+    </ol> 
+
+    Thus the list of access paths is searched for until these
+    conditions are properly met.
+
+    <p> The actual complete search list can always be visualized by
+    the command:
+
+
+      <cmt:code>
+&gt; cmt show path
+<i><font face="courier new, courier" COLOR="#000077"># Add path /home/arnault/dev from CMTPATH
+# Add path /ProjectB from CMTPATH
+#
+/home/arnault/dev:/ProjectB</font></i></cmt:code>
+
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title="Assigning semantics to packages. Common practices">
+
+    Generally speaking, CMT makes no assumption on how or why is used
+    a package. However past experience has shown that packages can be
+    categorized according to their purpose or their type of contents.
+
+    <cmt:section title="The primary package">
+
+      This is the most general and basic pakage type, which provides
+      actual pieces of software, such as libraries or
+      applications. Generally the main activities performed by such a
+      package include building the software (compiling, linking),
+      testing, generating the documentation, installing, ...
+
+      <p>A typical package of that kind will contain:</p>
+
+      <ul>
+
+        <li>a <tt>../src</tt> directory containing the sources of the package</li>
+
+	<li>a directory for the include files, with a name that will
+	depend on the structuring policies defined for the
+	project. Tyical examples are
+
+	  <cmt:code>
+../include/
+../&lt;packagename&gt;/</cmt:code>
+
+	</li>
+
+	<li>a <tt>../doc</tt> directory for the documentation</li>
+
+	<li>a <tt>../test</tt> directory for the test programs.</li>
+
+      </ul>
+
+      <p>The requirements file will generally contain at least
+      <tt>library</tt> and <tt>application</tt> statements.</p>
+
+    </cmt:section>
+
+    <cmt:section title="The policy package">
+
+      This kind of package only provides conventions, working methods,
+      general purpose shell scripts but generally provides no software
+      per se. It is designed to gather all policies and management
+      conventions for a project or a sub project.
+
+      <p>The basic contents of such a package is the requirements file
+      including</p>
+
+      <ul>
+
+        <li>strategy definitions</li>
+        <li>pattern definitions</li>
+        <li>general purpose symbol definitions</li>
+
+      </ul>
+
+      <p>In principle the idea when such a policy package is defined,
+      is that all packages of the project or of the sub-project will
+      use it</p>
+
+      <p>Global patterns may be specified so as to automate the
+      applying of basic policies and conventions.</p>
+
+      <p>Typical examples of policies that are profitably specified in
+      such a package are:</p>
+
+      <ul>
+
+        <li>include search path convention (using a global pattern
+        with the <tt>include_dir</tt> statement)</li>
+
+        <li>build or setup strategies</li>
+
+        <li>compiler or linker generic options</li>
+
+        <li>defining the project-wide production tools (compiler,
+        documentation generator, etc...)</li>
+
+        <li>tag associations need to describe the binary tag
+        convention in the project</li>
+
+      </ul>
+
+      <p>In large projects, it is even often desirable to split the
+      policies into a set of specialized policies and to associate one
+      dedicated policy package with each of those.</p>
+
+      <ul>
+
+        <li>policies for the test</li>
+
+        <li>policies for each programming language</li>
+
+        <li>policies for documentation management</li>
+
+        <li>policies for installation and deployment</li>
+
+        <li>policies for external software organisation</li>
+
+      </ul>
+
+      Then the global policy package will use them
+
+    </cmt:section>
+
+    <cmt:section title="The container or management package">
+
+      In large projects, it's often useful to decompose the software
+      base into specialized domains (Core software, Graphics,
+      Database, Online, etc...) or subsets of the software (eg per
+      detector in a physics experiment). Then a container package
+      consists in constructing a simple package with only one
+      requirements file in it and only containing a set of use
+      statements.
+
+      <p>Management activities directly related with the associated
+      sub-domain can then be undertaken through this special
+      package:</p>
+
+      <ul>
+
+        <li>version management (such as CVS tagging) of packages
+        belonging to the domain</li>
+
+	<li>consistently building the domain</li>
+
+	<li>Generally the <tt>cmt broadcast</tt> command is widely exploited
+	to perform those management activities.</li>
+
+      </ul>
+
+      <p> Generally the use statements installed in a container
+      package make use of explicit version specification (and prohibit
+      wild carding) since each version of this container package acts
+      as a reference of the set of version tags validated for the
+      packages of the domain.</p>
+
+    </cmt:section>
+
+    <cmt:section title="The release package">
+
+      This package is one particular example of the container concept,
+      but dedicated to manage the project-wide activities. This
+      release package is the primary target of the project manager. It
+      will generally receive as its version tags the version tags
+      assigned to the project releases themselves.
+
+    </cmt:section>
+
+    <cmt:section title="The glue or interface package">
+
+      This kind of package defines an interface to an existing
+      software product not managed in the context of the project
+      itself. Typical examples concern:
+
+      <ul>
+
+        <li>packages shared from external projects that don't use CMT
+        as their configuration tool</li>
+
+	<li>third party software (free software, commercial products,
+	...)  locally installed on the development platform.</li>
+
+      </ul>
+
+      <p>The primary goal fo such a glue package is to convert the
+      management conventions and policies expected by the referenced
+      product to the ones appropriate for the current project.</p>
+
+      <ul>
+
+        <li>compiler and linker options</li>
+
+	<li>run time settings such as environment variable definitions
+	(<tt>PATH</tt>, <tt>LD_LIBRARY_PATH</tt>, etc..)</li>
+
+	<li>data file access</li>
+
+	<li>specification of local installation according to the
+	project strategy</li>
+
+      </ul>
+
+      <p>Generally this kind of package only provides a requirements
+      file, or make fragments used to automate some actions (typically
+      when document generation is expected from thie interfaced
+      product)</p>
+
+    </cmt:section>
+
+  </cmt:section>
+
+  <cmt:section title="Managing site dependent features - The CMTSITE environment variable">
+
+    <p>Software bases managed by <tt>CMT</tt> are often replicated to
+    multiple geographically distant sites (as opposed to machines
+    connected through AFS-like WAN). In this kind of situation, some
+    of the configuration parameters (generally those used for instance
+    to reference local installations of <i>external</i> software) take
+    different values. </p>
+
+    <p>The <tt>CMTSITE</tt> environment variable or <i>registry</i> in
+    Windows environments, is entirely under the control of the
+    <i>site</i> manager and can be set with a value representing
+    the site (typical values may be <tt>LAL</tt>, <tt>Virgo</tt>,
+    <tt>Atlas</tt>, <tt>LHCb</tt>, <tt>CERN</tt>, etc.). </p>
+
+    <p>This variable, when set, corresponds to a <i>tag</i> which can
+    be used to select different values for make macros or environment
+    variables. </p>
+
+    <p>A typical use for this tag is to build up actual values for the
+    location path of an external software package. Here we take the
+    example of the Anaphe utility: </p>
+
+    <cmt:cmtcode>
+macro AnapheTOP "" \
+      CERN  "/afs/cern.ch/sw/lhcxx" \
+      BNL   "/afs/rhic/usatlas/offline/external/lhcxx" \
+      LBNL  "/auto/atlas/sw/lhcxx"</cmt:cmtcode>
+
+  </cmt:section>
+
+  <cmt:section title="Configuring a package">
+
+    <p>The first ingredient of a proper package configuration is the
+    set of configuration parameters which has to be specified in a
+    text file uniquely named <tt>&CMTrequirements;</tt> and necessarily
+    installed in the <tt>cmt</tt> branch of the package directory tree. </p>
+
+    <p>An empty version of this file is automatically created the
+    first time the package is installed, and the package manager is
+    expected to augment it with configuration specifications. </p>
+
+    <p>The primary goal of this configuration file is to specify
+    <i>any</i> configuration information for this package. There is
+    virtually no limit to what could be specified there. And we can
+    expect to find exhaustive information about:
+
+    <ul>
+
+      <li>the primary constituents of the package</li>
+
+      <li>how to rebuild the software</li>
+
+      <li>how to setup and use the software</li>
+
+      <li>how to transport and deploy the package</li>
+
+    </ul>
+
+    </p>
+
+    <p>Many configuration parameters are supposed to be described into
+    this &CMTrequirements; file - see the <a href="#The requirements file">detailed</a>
+    syntax specifications here - namely :</p>
+
+    <ul> 
+
+      <li> the package information about its author(s) and manager(s) </li>
+
+      <li> the relationships with other packages </li>
+
+      <li> the package constituents (libraries, applications,
+      documents, etc.) </li>
+
+      <li> the policy patterns to be applied by clients of this
+      package </li>
+
+      <li> the parameterization of the tools used in the build process
+      (eg. make macros) </li>
+
+      <li> the parameterization of the run-time activity
+      (eg. environment variables, search paths, etc.) </li>
+
+    </ul> 
+
+    <p>Generally, every such appropriate parameter will be deduced on
+    demand from the &CMTrequirements; file(s) through the various
+    query functions available from the <tt>cmt</tt> main
+    driver. Therefore there is no systematic package re-configuration
+    per se, besides the very first time a package is newly installed
+    in its location (using the <tt>cmt create</tt> action). </p>
+
+    <p>Query actions (generally provided using the <tt>cmt show ...</tt>
+    <a HREF="#show">family</a> of commands) are to be embedded in the
+    various productivity tools, such as the setup shell scripts, or
+    makefile fragment generators. </p>
+
+    <p>These query actions always interpret the set of
+    &CMTrequirements; files obtained from the current package
+    <i>and</i> from the packages in the effective <i>used</i>
+    chain. Symbols, tags and other definitions are then computed and
+    built up according to inheritance-like mechanisms set up between
+    used packages. </p>
+
+    <p>Conversely one may say that parameters defined in a
+    &CMTrequirements; file are meant to be exported to the clients of
+    the package.</p>
+
+    <p>Other configuration parameters are also optionally inserted
+    from the <tt>HOME</tt> and <tt>USER</tt> <a href=""><i>context</i></a>
+    requirements files</p>
+
+    <p>Typical examples of these query functions are: </p>
+
+    <ul> 
+
+      <li><tt>cmt setup</tt> builds a shell command line for setting up
+      environment variables </li>
+
+      <li><tt>cmt show projects</tt> gives the ordered sequence of
+      sub-projects comprising the complete software base </li>
+
+      <li><tt>cmt show macros</tt> construct the effective set of
+      inherited make macros </li>
+
+      <li><tt>cmt show uses</tt> gives the ordered and flattened set of
+      used packages </li>
+
+      <li><tt>cmt show constituents</tt> lists the package's
+      constituents </li>
+
+      <li><tt>cmt show path</tt> lists the effective search path for
+      packages. </li>
+
+      <li><tt>cmt show strategies</tt> shows the current setup of
+      various functional <tt>CMT</tt> strategies. </li>
+
+      <li><tt>cmt show setup</tt> combines in one display the result
+      of <tt>uses</tt>, <tt>tags</tt> and <tt>path</tt> </li>
+
+    </ul> 
+
+  </cmt:section>
+
+  <cmt:section title="Selecting a specific configuration">
+
+    A configuration describes the conditions in which the package has
+    to be built (ie. compiled and linked) or applications can be
+    run. This configuration can depend on :
+
+    <ul> 
+
+      <li> the operating system (such as <i>Linux</i>, <i>Windows</i>,
+      ...)  </li>
+
+      <li> the platform (such as <i>Intel</i>, <i>Compaq</i>,
+      <i>Sun</i>, etc...)  </li>
+
+      <li> the sub-project into which a package is inserted </li>
+
+      <li> the choice of the compiler (such as <i>g++</i>,
+      <i>egcs</i>, <i>CC</i>, etc...)  </li>
+
+      <li> options used for compiling (such as <i>optimizer</i>,
+      <i>debugger</i>, etc...)  or linking </li>
+
+      <li> the context specifications (selecting a particular version
+      of a firmware, selecting a database server, ...)  </li>
+
+      <li> the site itself</li>
+
+      <li> the context of a constituent during its rebuild operation</li>
+
+    </ul> 
+
+    Carefully describing this configuration is essential both for
+    maintenance operations (so as to remember the precise conditions
+    in which the package was built) and when the development area is
+    <i>shared</i> between machines running different operating
+    systems, or when a project has to be deployed on several sites.
+
+    <cmt:section title="Describing a configuration">
+
+      <p> <tt>CMT</tt> relies on several complementary conventions or
+      mechanisms for this description and the associated
+      management. All these conventions rely on the concept of
+      <i>configuration tags</i>.</p>
+
+      <ul>
+
+        <li>A tag is a symbol that describes one aspect of the
+        configuration.</li>
+
+	<li>A tag can be <i>active</i> when the corresponding aspect
+	of the configuration is true or <i>inactive</i> otherwise</li>
+
+	<li>The set of active tags represents the complete
+	configuration known by CMT, and can be visualized with the
+	<tt>cmt show tags</tt> command</li>
+
+        <li>Tags can be combined using logical expressions to form tag
+        associations</li>
+
+      </ul>
+
+      <ol>
+
+      <li>Some aspects of the configuration - and their associated tags -
+      are automatically deduced from some standard environment
+      variables that the user is expected to specify (typically using
+      shell commands):<p></p>
+
+      <p></p>
+      <ul>
+
+        <li><tt>CMTCONFIG</tt> describes the current settings for producing
+        binary objects. One default value is provided automatically by
+        CMT, but generally project will override it to apply specific
+        conventions.
+
+	<cmt:blockquote>The default value is computed by CMT in the
+	${CMTROOT}/mgr/cmt_system.sh shell script.
+
+          <p>This script automatically builds a value characterizing
+          both the machine type and the opebrating system type (using a
+          mixing of the <tt>uname</tt> standard <tt>UNIX</tt> command with
+          various operating system specific definitions such as the
+          <tt>AFS</tt> based <tt>fs sysname</tt> command)</p>
+	</cmt:blockquote><p></p></li>
+
+        <li><tt>CMTSITE</tt> characterizes the current site. Its syntax is
+        completely free<p></p></li>
+
+	<li><tt>CMTEXTRATAGS</tt> may contain a space-separated list of
+	additional tags to systematically activate</li>
+
+      </ul>
+      <p></p>
+
+      <cmt:blockquote><i>Note that the <tt>CMTBIN</tt> variable which
+      represents the current binary installation of CMT itself does
+      NOT correspond to any tag.</i></cmt:blockquote>
+
+      <p></p>
+      </li>
+
+      <li>
+      Some aspects of the configuration represents the implicit
+      knowledge CMT gets of the current context:
+
+      <p></p>
+      <ul>
+
+        <li>The value given by the <i>uname</i> standard Unix facility
+        is always a valid configuration tag. (eg. <tt>Linux</tt>)</li>
+
+	<li>The current major version id of CMT is a valid tag and
+	takes the form <tt>CMTv&lt;n&gt;</tt> (eg. <tt>&CMTvTag;</tt>)</li>
+
+	<li>The current minor version id of CMT is a valid tag and
+	takes the form <tt>CMTr&lt;n&gt;</tt> (eg. <tt>&CMTrTag;</tt>)</li>
+
+	<li>The current patch id of CMT is a valid tag and takes the
+	form <tt>CMTp&lt;n&gt;</tt> (eg. <tt>CMTp20030616</tt>)</li>
+
+        <li> The current sub-project to which the current package
+        belongs, and the various tags automatically generated by CMT
+        to qualify the strategy options.</li>
+
+        <li> The current hardware understood as filled in the
+        <tt>cmt_hardware</tt> macro</li>
+
+        <li> The current OS understood as filled in the
+        <tt>cmt_system_version</tt> macro</li>
+
+        <li> The version of the C++ compiler understood as filled in
+        the <tt>cmt_compiler_version</tt> macro</li>
+
+      </ul>
+
+      <p></p>
+      </li>
+
+      <li>
+        During a <tt>make</tt> session, each individual target being
+        rebuilt may define its own context, when the
+        <tt>-target_tag</tt> is set to the associated constituent, and
+        this is materialized with a dedicated tag named
+        <tt>target_&lt;constituent&gt;</tt>.
+
+        <p>For instance, a package defines a library <tt>A</tt> and an
+        application <tt>P</tt>, both in the default group. Both
+        constituents have their <tt>-target_tag</tt> option set. Thus,
+        when the standard <tt>make</tt> command is run, then those two
+        targets will be rebuilt successively (eg <tt>A</tt> then
+        <tt>B</tt>). Then, during the build of <tt>A</tt> (and only
+        then) the tag named <tt>target_A</tt> will be active and
+        during the build of <tt>B</tt>, the tag named
+        <tt>target_B</tt>will in turn be active.</p>
+
+        <cmt:cmtcode>
+library A -target_tag A.cxx
+application P -target_tag P.cxx
+
+macro_append cppflags "" target_A "-DA" target_P "-DP"</cmt:cmtcode>
+
+      <p></p>
+      </li>
+
+      <li>
+        During the execution of an 
+        <a href="#actions"><tt>action</tt></a>, a specific context is
+        created, which is materialized with a dedicated tag named
+        <tt>target_&lt;action&gt;</tt>, very similarly to the target
+        tags for constituents.
+
+      <p></p>
+      </li>
+
+      <li>
+      User defined tags can be explicitly or implicitly activated:
+
+      <p></p>
+      <ul>
+
+        <li>explicitly from the <tt>cmt</tt> command line, using the
+        <tt>-tag=&lt;tag-list&gt;</tt> option </li>
+
+	<li>explictly from requirements files using the <tt>apply_tag
+	&lt;tag&gt;</tt> syntax</li>
+
+	<li> implicitly from requirements files using the tag
+	association syntax, when a tag is associated with an otherwise
+	activated tag. One example is the <tt>Unix</tt> tag associated
+	by CMT itself with most Unix variants </li>
+
+      </ul>
+      </li>
+
+      </ol>
+
+      The minimal tag set available from CMT can be visualized as
+      follows (note that the exact output will obviously not
+      necessarily be the one presented in this document according to
+      the context effectively used):
+
+      <cmt:code>
+&gt; cd ${CMTROOT}
+&gt; cmt show tags
+<i><font face="courier new, courier" COLOR="#000077">&CMTvTag; (from CMTVERSION)                                                   [1]
+&CMTrTag; (from CMTVERSION) package CMT implies [CMTr14]                     [1]
+CMTp20040701 (from CMTVERSION)                                            [1]
+Linux (from uname) package CMT implies [Unix]                             [2]
+i686-rh73-gcc32-opt (from CMTCONFIG)                                      [3]
+CERN (from CMTSITE)                                                       [4]
+CMT_prototypes (from PROJECT) excludes [CMT_no_prototypes]                [5]
+CMT_with_installarea (from PROJECT) excludes [CMT_without_installarea]
+CMT_setup_config (from PROJECT) excludes [CMT_setup_no_config]
+CMT_setup_root (from PROJECT) excludes [CMT_setup_no_root]
+CMT_setup_cleanup (from PROJECT) excludes [CMT_setup_no_cleanup]
+CMTr14 (from package CMT)
+i686 (from package CMT)                                                   [6]
+rh73 (from package CMT)                                                   [7]
+gcc32 (from package CMT)                                                  [8]
+Unix (from package CMT) excludes [WIN32 Win32]                            [9]</font></i></cmt:code>
+
+
+      <ol>
+
+        <li>Implicit tags deduced from the current version of CMT</li>
+        <li>Implicit tag obtained from the uname command (note that there is an associated tag defined here)</li>
+        <li>The current value of CMTCONFIG</li>
+        <li>The current value of CMTSITE</li>
+        <li>The strategy tags</li>
+        <li>Automatic detection of the hardware</li>
+        <li>Automatic detection of the current OS</li>
+        <li>Automatic detection of the C++ compiler version</li>
+        <li>A indirectly activated tag (associated with another active tag)</li>
+
+      </ol>
+
+    </cmt:section>
+
+    <cmt:section title="Defining the user tags">
+
+      <p>The user configuration tags can generally be specified though
+      various complementary mechanisms:</p>
+
+      <ul>
+
+        <li>CMTSITE and CMTCONFIG can be specified using standard
+        shell commands (setenv, export, set)</li>
+
+        <cmt:code>
+sh&gt; export CMTSITE=CERN</cmt:code>
+
+        <p></p>
+
+        <li>CMTSITE and CMTCONFIG can alternatively be specified using
+        the <tt>set</tt> statement in a requirements file</li>
+
+        <cmt:cmtcode>
+set CMTSITE "CERN"
+set CMTCONFIG "${CMTBIN}" sun "Solaris-CC-dbg"</cmt:cmtcode>
+
+        <p></p>
+
+        <li> Additional tags may also be associated with other tags,
+        using the <tt>tag</tt> statement (in a requirements file):
+
+          <cmt:cmtcode>
+tag newtag tag1 tag2 tag3</cmt:cmtcode>
+
+          which means that:
+
+          <ul>
+
+            <li><tt>newtag</tt> defines a tag (inactive by default)</li>
+
+            <li>when <tt>newtag</tt> is active, then both tag1, tag2 and
+            tag3 are simultaneously active</li>
+
+          </ul>
+        </li>
+
+        <p></p>
+
+        <li>
+	Tags may be declared as <i>exclusive</i> using the <tt>tag_exclude</tt> syntax.
+
+          <cmt:cmtcode>
+tag_exclude debug optimized</cmt:cmtcode>
+
+	  This example implies that the two tags <tt>debug</tt> and
+	  <tt>optimized</tt> should never become active simultaneously.
+
+	</li>
+
+        <p></p>
+
+        <li>
+	Tags are assigned priorities according to the way they have
+	been defined. The priority is particularly useful for
+	specifying exclusion. The tag association promotes the
+	priority of the associated tags to the priority of the
+	defining tag.
+
+	The following decreasing priorities are currently defined by
+	CMT:
+
+	<p></p>
+
+	<ol>
+
+	  <li>tag specified in the command line using the -tag=&lt;tag-list&gt; option</li>
+	  <li>tag deduced from CMTCONFIG</li>
+	  <li>tag defined in a requirements file using the <tt>tag</tt> syntax</li>
+	  <li>tag deduced from CMTSITE</li>
+	  <li>tag deduced from <i>uname</i></li>
+	  <li>tags deduced from the version of CMT</li>
+
+	</ol>
+
+	</li>
+
+      </ul>
+
+    </cmt:section>
+
+    <cmt:section title="Activating tags">
+
+      By default, <tt>CMTCONFIG</tt>, <tt><i>uname</i></tt> and
+      <tt>CMTSITE</tt> (also named system tags) are always active.
+
+      <p>The tag associated with the current project name as well as
+      those describing the strategy properties of all projects are
+      also always active.</p>
+
+      <p>The target tags associated with constituents (when the
+      <tt>-target_tag</tt> option was set on them) or with actions are
+      automatically activated during the build of the constituent or
+      during the execution of the action.</p>
+
+      <p>It is possible to <i>activate</i> other tags through the
+      following arguments to <i>any</i> cmt command:</p>
+
+      <ul>
+
+        <li>
+          <tt>-tag=&lt;tag-list&gt;</tt>
+
+          <p> will cleanup the complete current tag set, and
+          activate the new tags (the system tags are restored).
+          </p>
+
+        </li>
+
+        <li>
+          <tt>-tag_add=&lt;tag-list&gt;</tt>
+
+          <p> will add to the current tag set the tags
+          specified in the comma separated list </p>
+
+        </li>
+
+        <li>
+          <tt>-tag_remove=&lt;tag-list&gt;</tt>
+
+          <p>will remove from the current tag set the tags specified
+            in the comma separated list</p>
+
+        </li>
+      </ul>
+
+      <cmt:blockquote>
+
+      Beware that giving these arguments generally make the selected
+      tag set active only during the selected command. Therefore two
+      different CMT commands run with different tag sets will
+      generally yield different results.
+
+      </cmt:blockquote>
+
+      <p>However it's often useful to state that a given tag or tag
+      set should be active. This can be obtained by the following
+      mechanisms:</p>
+
+      <ol>
+
+        <li>
+	  <i>Forcing a tag in a requirements file using the <tt>apply_tag</tt> &nbsp;syntax</i>
+
+	  <p></p>
+
+	  Eg the following syntax installed in a requirements file
+	  will force the tag <tt>foo</tt>:
+
+	  <cmt:cmtcode>
+tag_apply foo</cmt:cmtcode>
+
+	  <cmt:code>
+&gt; cmt show tags
+<i><font face="courier new, courier" COLOR="#000077">&CMTvTag; (from CMTVERSION)
+&CMTrTag; (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+Default (from Default)
+foo (from package Foo)</font></i></cmt:code>
+
+	</li>
+
+	<li>
+	  <i>Implying a tag from another one using the tag association syntax</i>
+
+	  <cmt:cmtcode>
+tag Linux foo</cmt:cmtcode>
+
+	  <cmt:code>
+&gt; cmt show tags
+<i><font face="courier new, courier" COLOR="#000077">&CMTvTag; (from CMTVERSION)
+&CMTrTag; (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname) package Foo implies [foo]
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+Default (from Default)
+foo (from package Foo)</font></i></cmt:code>
+
+	</li>
+
+	<li>
+	  <i>Through conventionally encoded values of <tt>CMTCONFIG</tt></i>
+
+	  <cmt:cmtcode>
+tag Linux-foo Linux foo</cmt:cmtcode>
+
+	  <cmt:code>
+&gt; export CMTCONFIG=Linux-foo
+&gt; cmt show tags
+<i><font face="courier new, courier" COLOR="#000077">&CMTvTag; (from CMTVERSION)
+&CMTrTag; (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-foo (from CMTCONFIG) package Foo implies [Linux foo]
+A (From PROJECT)
+Default (from Default)
+Linux-i686 (from package CMT) package CMT implies [Linux]
+foo (from package Foo)</font></i></cmt:code>
+
+	</li> 
+
+      </ol>
+
+      <p>The current active tag set can always be visualized using the
+      <tt>cmt show tags</tt> command.</p>
+
+      <cmt:code>
+&gt; cmt show tags
+<i><font face="courier new, courier" COLOR="#000077">&CMTvTag; (from CMTVERSION)
+&CMTrTag; (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+Default (from Default)
+</font></i>
+&gt; cmt -tag_add=tag1,tag2,tag3 show tags
+<i><font face="courier new, courier" COLOR="#000077">&CMTvTag; (from CMTVERSION)
+&CMTrTag; (from CMTVERSION)
+CMTp0 (from CMTVERSION)
+Linux (from uname)
+Linux-i686 (from CMTCONFIG) package CMT implies [Linux]
+A (From PROJECT)
+tag1 (from arguments)
+tag2 (from arguments)
+tag3 (from arguments)
+Default (from Default)</font></i></cmt:code>
+
+      <p>Typical usages of those extra tags are:</p>
+
+      <ul> 
+
+        <li> when using special compiler options (e.g. optimization,
+        debugging, ...)  </li>
+
+        <li> for switching to different compilers (e.g. <tt>gcc</tt>
+        versus the native compiler) </li>
+
+        <li> when one uses a special debugging environment such as
+        <tt>Insure</tt> or <tt>Purify</tt> </li>
+
+        <li> when using special system specific features (such as
+        whether one uses thread-safe algorithms or not) </li>
+
+      </ul> 
+
+      <p>All symbol definitions providing specific values triggered by
+      the active selectors will be selected, such as in:</p>
+
+      <cmt:cmtcode>
+macro_append cppflags "" \
+             debug    " -g "</cmt:cmtcode>
+
+    </cmt:section> 
+
+  </cmt:section> 
+
+  <cmt:section title="Working on a package">
+
+    <p>In this section, we'll see, through a quite simple scenario,
+    the typical operations generally needed for installing, defining
+    and building a package.  We are continuing the <a
+    href="#Installing a new package">example</a> of the <tt>Foo</tt>
+    package already used in this document. </p>
+
+    <cmt:section title="Working on a library">
+
+      <p>Let's assume, as a first example, that the <tt>Foo</tt> package
+      <i>is</i> originally composed of one library <tt>libFoo.a</tt>
+      itself made from two sources : <tt>FooA.c</tt> and
+      <tt>FooB.c</tt>. A shared flavour of the library <tt>libFoo.so</tt>
+      or <tt>libFoo.sl</tt> or <tt>libFoo.dll</tt>) is also foreseen.</p>
+
+      <p> The minimal set of branches provided by <tt>CMT</tt> (once the
+      <tt>cmt create</tt> operation has been performed) for a package
+      includes <tt>src</tt> for the sources and <tt>cmt</tt> for the
+      <i>Makefiles</i> and other scripts.</p>
+
+      <p> The various tools <tt>CMT</tt> provide will be fully exploited
+      if one respects the roles these branches have to play. However
+      it is always possible to extend the default understanding
+      <tt>CMT</tt> gets on the package by appropriate modifiers
+      (typically by overriding <a href="#Standard macros predefined in CMT">standard</a> macros). </p>
+
+      <p> Assuming the conventional usage is selected, the steps
+      described in this section can be undertaken in order to actually
+      develop a software package. </p>
+
+      <p> We first have to create the two source files into the
+      <tt>src</tt> branch (typically using our favourite text
+      editor). Then a description of the expected library (ie. built
+      from these two source files) will be entered into the
+      <tt>requirements</tt> file. The minimal syntax required in our
+      example will be :</p>
+
+      <cmt:code>
+csh&gt; cd ../cmt
+csh&gt; vi requirements             (1)
+library Foo FooA.cxx FooB.cxx</cmt:code>
+
+      <ol> 
+
+        <li> the <tt>&CMTrequirements;</tt> 
+        file located in the <tt>cmt</tt>
+        branch of the package receives the description of this
+        <i>library</i> component. This is done using one
+        <tt>library</tt> statement.  </li>
+
+      </ol> 
+
+      <p>The <tt>cmt create</tt> command had generated a simple
+      <i>Makefile</i> (or <tt>NMake</tt> file) which is generaly
+      sufficient for all standard operations, since <tt>CMT</tt>
+      continuously and transparently manages the automatic
+      reconstruction of all intermediate makefile fragments. We
+      therefore simply and immediately execute gmake as follows:</p>
+
+      <cmt:code>
+...v1/cmt&gt; gmake QUIET=1
+<i><font face="courier new, courier" COLOR="#000077">------> (Makefile.header) Rebuilding constituents.make
+------> (constituents.make) Rebuilding setup.make Linux-i686.make         [1]
+setup.make ok
+------> (constituents.make) Rebuilding library links
+------> (constituents.make) all done
+------> (constituents.make) Building Foo.make                             [2]
+Library Foo
+------> (constituents.make) Starting Foo
+------> (Foo.make) Rebuilding ../Linux-i686/Foo_dependencies.make         [3]
+rebuilding ../Linux-i686/FooA.o
+rebuilding ../Linux-i686/FooB.o
+rebuilding library
+------> Foo : library ok
+------> Foo ok
+Installing library libFoo.so into /home/arnault/mydev/InstallArea/Linux-i686/lib
+installation done                                                         [4]
+------> (constituents.make) Foo done
+ all ok.
+Linux-i686.make ok
+gmake[2]: `config' is up to date.
+gmake[2]: `all' is up to date.</font></i></cmt:code>
+
+      <ol> 
+
+        <li> Some intermediate makefile fragments are automatically
+        built to reflect the current effective set of Makefile macros
+        deduced from the configuration (read from the <tt>
+        &CMTrequirements;</tt> file). These fragments are automatically
+        rebuilt (if needed) each time one of the
+        <tt>&CMTrequirements;</tt> file changes.  </li>
+
+        <li> Each component of the package (be it a particular
+        <i>library</i> or a particular <i>executable</i>) will have
+        its own <i>makefile</i> fragment (named
+        <tt>../${CMTCONFIG}/&lt;name&gt;.[n]mak[e]</tt>). This dedicated
+        <i>makefile</i> takes care of filling up the library and
+        creating the shared library (on the systems where this is
+        possible).  </li>
+
+        <li> The directory which is used for the binaries (i.e. the
+        results of compilation or the libraries) has been
+        automatically created by a generic target (<tt>dirs</tt>)
+        which is defined within <tt>[N]Makefile.header</tt>. A new
+        binary directory will be created each time a new value of the
+        <tt>CMTCONFIG</tt> environment variable is defined or a
+        <i>tag</i> is provided on the command line to <tt>make</tt>.
+        </li>
+
+        <li> An automatic installation mechanism is applied for all
+        successfully built binaries. </li>
+
+      </ol>
+
+      or, for nmake:
+
+      <cmt:code>
+...v1/cmt&gt; nmake /f nmake </cmt:code>
+
+      <p>This mechanism relies on some conventional <i>macros</i> and
+      incremental <i>targets</i> used within the specific
+      makefiles. Some are automatically generated, some have to be
+      specified in user packages. It's quite important to understand
+      the list of possible customization macros, since this is the
+      main communication medium between <tt>CMT</tt> and the package
+      manager. See the complete 
+      <a href="#Standard macros predefined in CMT">table</a> 
+      of those conventional macro when you want to
+      interact with the standard CMT behaviour.  </p>
+
+      <p>However, it is also possibble to use a simplified and
+      platform independent form to build a constituent</p>
+
+      <cmt:code>
+...v1/cmt&gt; cmt make </cmt:code>
+
+      <p>This syntax is identical on all platforms, and also does not
+      require any <tt>cmt config</tt> nor <tt>source setup</tt>
+      operation</p>
+
+    </cmt:section> 
+
+    <cmt:section title="Working on an application">
+
+      <p>Assume we now want to add a test program to our
+      development. Then we create a <tt>FooTest.cxx</tt> source, and
+      generate the associated makefile (specifying that it will be an
+      executable instead of a library) : </p>
+
+      <cmt:code>
+csh&gt; cd ../src 
+csh&gt; emacs FooTest.cxx
+... 
+csh&gt; cd ../cmt 
+csh&gt; vi requirements 
+... 
+application FooTest FooTest.cxx</cmt:code>
+
+      So that we may simply build the complete stuff by running : 
+
+      <cmt:code>
+&gt; cmt make QUIET=1
+<i><font face="courier new, courier" COLOR="#000077">------> (Makefile.header) Rebuilding constituents.make
+------> (constituents.make) Rebuilding setup.make Linux-i686.make
+setup.make ok
+------> (constituents.make) Rebuilding library links
+------> (constituents.make) all done
+------> (constituents.make) Building Foo.make
+Library Foo
+------> (constituents.make) Starting Foo
+------> Foo : library ok
+------> Foo ok
+installation done
+------> (constituents.make) Foo done
+------> (constituents.make) Building FooTest.make
+Application FooTest
+------> (constituents.make) Starting FooTest
+------> (FooTest.make) Rebuilding ../Linux-i686/FooTest_dependencies.make
+rebuilding ../Linux-i686/FooTest.o
+rebuilding ../Linux-i686/FooTest.exe
+------> FooTest ok
+Installing application FooTest.exe into /home/arnault/mydev/InstallArea/Linux-i686/bin
+installation done
+------> (constituents.make) FooTest done
+ all ok.
+Linux-i686.make ok
+gmake[2]: `config' is up to date.
+gmake[2]: `all' is up to date.</font></i></cmt:code>
+
+      Which shows that a program <tt>FooTest.exe</tt> has been built
+      from our sources. Assuming now that this program needs to access
+      the <tt>Foo</tt> library, we'll just add the following definition
+      in the <tt>&CMTrequirements;</tt>
+      file :
+
+      <cmt:cmtcode>
+... 
+macro Foo_linkopts " -lFoo " \
+      WIN32        " $(FOOROOT)/$(Foo_tag)/Foo.lib "
+... </cmt:cmtcode>
+
+      <p>The <tt>Foo_linkopts</tt> conventional macro will be automatically
+      inserted within the <tt>use_linkopts</tt> macro. And the shared
+      library location will be automatically set to the installation
+      areas.</p>
+
+      <p>It is also possible to select extra tag sets when running
+      gmake as follows (in this example we first cleanup the previous
+      build and rebuild with debug options added to the compiler and
+      linker commands) :</p>
+
+      <cmt:code>
+&gt; cmt make clean
+&gt; cmt make CMTEXTRATAGS=debug</cmt:code>
+
+      <p> Like all other make macros used to build a component, the
+      <tt>Foo_linkopts</tt> will be specified within the
+      <tt>&CMTrequirements;</tt> which gives several benefits: </p>
+
+      <ul> 
+
+        <li> variants of the macro definition can be provided </li>
+
+        <li> monitoring features of <tt>CMT</tt> such as the <tt>cmt show
+        macro Foo_linkopts</tt> command can be used later on </li>
+
+        <li> macros defined this way may be later on inherited by
+        client packages which will <i>use</i> our package.  </li>
+
+      </ul> 
+
+    </cmt:section> 
+
+    <cmt:section title="Working on a test or external application">
+
+      It is also possible to work on a <i>test</i> or <i>external</i>
+      application, ie. when one does not wish to configure the
+      development for this application using <tt>CMT</tt>. Even in this
+      case, it is possible to benefit from the packages configured
+      using <tt>CMT</tt> by partially using <tt>CMT</tt>, just for
+      <i>used</i> relationships.
+
+      <p> Here, no special convention is assumed on the location of
+      the sources, the binaries, the management scripts,
+      etc... However, it is possible to describe in a <tt>
+      &CMTrequirements;</tt> file the <i>use</i> relationships, as well
+      as the <tt>make</tt> macro definitions, quite similarly to the
+      package entirely configured using <tt>CMT</tt>. </p>
+
+      <p> Most of the options provided by the <tt>cmt</tt> user
+      interface are still available in these conditions. </p>
+
+    </cmt:section> 
+
+  </cmt:section>
+
+  <cmt:section title="Defining a document generator">
+
+    <p> In a Unix environment, documents are built using <tt>make</tt>
+    (well generally its <i>gnu</i> flavour) or <tt>nmake</tt> in Windows
+    environments. The basic mechanism provided in <tt>CMT</tt> relies on
+    <i>make fragment patterns</i> containing instructions on how to
+    rebuild document pieces. Many such generators are provided by
+    <tt>CMT</tt> itself so as to take care of of the most usual cases
+    (e.g. compilations, link operations, archive manipulations,
+    etc...). In addition to those, any package has to possibility to
+    provide a new generator for its own purpose, i.e. either for
+    providing rules for a special kind of document, or even to
+    override the default ones provided by <tt>CMT</tt>. This mechanism
+    is very similar to the definition or re-definition of
+    <i>macros</i> or environment variables in that every new generator
+    has to be first declared in a <tt> &CMTrequirements;</tt> file
+    belonging to a package (<tt>CMT</tt> actually declares all its
+    default generators within its <tt>&CMTrequirements;</tt> file),
+    allowing all its client packages to transparently acquire the
+    capacity to generate documents of that sort.  </p>
+
+    <p> <tt>CMT</tt> manages two categories of constituents:
+
+      <ol>
+
+        <li><i>Applications</i> and <i>Libraries</i> are handled using
+        pre-defined make fragments (mainly related with languages) and
+        behaviour.  </li>
+
+        <li><i>Documents</i> offer a quite general framework for
+        introducing completely new behaviours through user-defined
+        make fragments. This includes actually generating documents,
+        but also simply performing an operation (in which case
+        sometimes no real <i>document</i> is produced).  </li>
+
+      </ol>
+    </p>
+
+    <p> In this section we only discuss the latter category and the
+    following paragraphs explain the framework used for defining new
+    document types.  </p>
+
+    <p>The main concept of this framework is that each document to be
+    generated or manipulated must be associated with a "document-type"
+    (also sometimes named "document-style"), which corresponds to a
+    dedicated make fragment of that name. Then, when specified in a
+    <tt>document</tt> statement, this make fragment will be
+    <i>instanciated</i> once or several times (typically once per
+    source file) to construct a complete and functional make fragment,
+    containing one main target. Both the resulting make fragment and
+    the make target will have the name of the constituent.</p>
+
+    <cmt:section title="An example : the tex document-style">
+
+      <p>
+
+        <cmt:blockquote> <i>This section discusses one simple example (the
+        production of postscript from latex files) available in the
+        standard <tt>CMT</tt> distribution kit.  </i> </cmt:blockquote>
+
+      </p>
+
+      <p>Converting a latex source file into a postcript output
+      implies to chain two text processors, with an intermediate dvi
+      format.</p>
+
+      <p>The fragment described here exactly performs this sequence,
+      taking care of intermediate file deletion. The document style is
+      named "tex" (the associated fragment shown here and named "tex"
+      is actually provided by <tt>CMT</tt> itself, and can be looked at
+      in <tt>${CMTROOT}/fragments/tex</tt>.) :</p>
+
+      <cmt:cmtcode>
+============ tex ===================================== 
+${CONSTITUENT} :: ${FILEPATH}/${NAME}.ps
+
+${FILEPATH}/${NAME}.dvi : ${FULLNAME} 
+	cd ${doc}; latex ${FULLNAME} 
+
+${FILEPATH}/${NAME}.ps : ${FILEPATH}/${NAME}.dvi 
+	cd ${doc}; dvips ${FILEPATH}/${NAME}.dvi 
+
+${CONSTITUENT}clean ::
+	cd $(doc); /bin/rm -f ${FILEPATH}/${NAME}.ps ${FILEPATH}/${NAME}.dvi
+
+====================================================== </cmt:cmtcode>
+
+      <ul> 
+
+        <li> They are declared in the <tt>CMT</tt>'s <a HREF="#The
+        requirements file">requirements</a> file as follows :
+
+          <cmt:cmtcode>
+make_fragment tex -header=tex_header</cmt:cmtcode>
+
+          where: 
+
+          <ol> 
+
+            <p></p>
+
+            <li> "tex" represents both the fragment name and the document style. </li>
+
+            <p></p>
+
+            <li>the <tt>-header=tex_header</tt> option indicates that
+            the generated makefile fragment will first include this
+            header (which is actually an empty file in this case)</li>
+
+            <p></p>
+
+          </ol> 
+
+        </li>
+
+        <li> A user package willing to apply this behaviour will have
+        to include in its &CMTrequirements; file a statement similar
+        to the following:
+
+          <cmt:cmtcode>
+document tex MyDoc -s=../doc doc1.tex doc2.tex </cmt:cmtcode>
+
+          where: 
+
+          <ol> 
+
+            <li> The first parameter "tex" is the document-style </li>
+
+            <li> The second parameter "MyDoc" is used for building the
+            constituent's makefile (under the name MyDoc.make) and for
+            providing the make target "MyDoc". </li>
+
+            <li> The other parameters (doc1.tex and doc2.tex) are the
+            sources of the document. Explicit location is required
+            (since default is currently defined to be ../src) </li>
+
+            <li> The constituent's makefile MyDoc.make is built as
+            follows :
+
+              <ol> 
+
+                <li> Install a copy of the
+                <tt>$CMTROOT/fragments/make_header</tt> generic fragment
+                </li>
+
+                <li> Install a copy of the <tt>$CMTROOT/fragments/tex_header</tt> fragment </li>
+
+                <li> For each of the sources, install a copy of the fragment "tex"</li> 
+
+                <li> Install a copy of the <tt>$CMTROOT/fragments/cleanup_header</tt> fragment </li>
+
+              </ol> 
+
+            </li>            
+
+          </ol> 
+
+          <p>The result for our example is: </p>
+
+          <cmt:cmtcode>
+=========== MyDoc.make =============================== 
+
+#==================================== 
+#  Document MyDoc 
+# 
+#   Generated   by  
+# 
+#==================================== 
+
+help :: 
+@echo 'MyDoc' 
+
+doc1_dependencies = ../doc/doc1.tex 
+doc2_dependencies = ../doc/doc2.tex 
+
+MyDoc :: ../doc/doc1.ps 
+
+../doc/doc1.dvi : $(doc)doc1.tex 
+	cd ${doc}; latex $(doc)doc1.tex 
+
+../doc/doc1.ps : ../doc/doc1.dvi 
+	cd ${doc}; dvips ../doc/doc1.dvi 
+
+MyDocclean ::
+	cd $(doc); /bin/rm -f ../doc/doc1.ps ../doc/doc1.dvi
+
+MyDoc :: ../doc/doc2.ps 
+
+../doc/doc2.dvi : $(doc)doc2.tex 
+	cd ${doc}; latex $(doc)doc2.tex 
+
+../doc/doc2.ps : ../doc/doc2.dvi 
+	cd ${doc}; dvips ../doc/doc2.dvi 
+
+MyDocclean ::
+	cd $(doc); /bin/rm -f ../doc/doc2.ps ../doc/doc2.dvi
+
+clean :: MyDocclean 
+	cd . 
+
+MyDocclean :: 
+====================================================== </cmt:cmtcode>
+        </li>
+      </ul> 
+
+    </cmt:section> 
+
+    <cmt:section title="How to create and install a new document style">
+
+      <p><cmt:blockquote><i>This section presents the general framework
+      for designing a document generator.</i></cmt:blockquote></p>
+
+      <ol> 
+
+        <li> Select a name for the document style. It should not clash
+        with existing ones (use the <tt>cmt show fragments</tt> for a
+        complete list of document types currently defined).</li>
+
+        <p></p>
+
+        <li> A fragment exactly named after the document style name
+        must be installed into a subdirectory named <tt>fragments</tt>
+        below the <tt>cmt</tt> branch of a given package (which becomes
+        the <i>provider</i> package).</li>
+
+        <p></p>
+
+        <li> Optionally, two other fragments may be installed into the
+        same subdirectory, one of them will be the <i>header</i> of
+        the generated complete fragment, the other will be its
+        <i>trailer</i></li>
+
+        <p></p>
+
+        <li> Those fragments <i>must</i> be declared in the
+        &CMTrequirements; file of the provider package as follows:
+
+          <cmt:cmtcode>
+make_fragment &lt;fragment-name&gt; [ options... ] </cmt:cmtcode>
+
+          where options may be : 
+
+          <p>
+
+            <table BORDER='1' COLS='2' cellspacing='0'> 
+                  <tr> 
+                    <td><tt>-suffix=&lt;suffix&gt;</tt></td> 
+                    <td width="500">provide the suffix of the output files (without the dot)</td> 
+                  </tr> 
+                  <tr> 
+                    <td><tt>-header=&lt;header&gt;</tt></td> 
+                    <td>provide another make fragment meant to be prepended to 
+                      the constituent's make fragment.</td> 
+                  </tr> 
+                  <tr> 
+                    <td><tt>-trailer=&lt;trailer&gt;</tt></td> 
+                    <td>provide another make fragment meant to be
+                      appended to the constituent's make fragment.</td> 
+                  </tr> 
+                  <tr> 
+                    <td><tt>-dependencies</tt></td> 
+                    <td>install the automatic generation of dependencies into the 
+                      constituent's make fragment</td> 
+                  </tr> 
+            </table> 
+          </p>
+        </li>
+      </ol> 
+
+      <p>Once a fragment is installed and declared, it may be used by
+      any <i>client</i> package (ie a package <i>using</i> the
+      provider), and queried upon using the command</p>
+
+      <cmt:code>
+&gt; cmt show fragment &lt;fragment name&gt; </cmt:code>
+
+      <p>which will show where this fragment is defined (ie. in which
+      of the used packages).</p>
+
+      <p>The <tt>cmt show fragments</tt> commands lists all declared
+      fragments. </p>
+
+      <p>If a package re-defines an already declared make fragment, ie
+      it provides a new copy of the fragment (possibly with new copies
+      of the header and the trailer), and declares it inside its
+      requirements file, then this package becomes the new provider
+      for the document style.</p>
+
+      <p>For building a fragment, one may use pre-defined generic
+      "templates" (which will be substituted when a fragment is copied
+      into the final constituent's makefile).</p>
+
+      <p>
+        <center> 
+          <table BORDER='1' COLS='2' cellspacing='0'> 
+
+                <tr>
+                  <td width="100"><tt>CONSTITUENT</tt></td>
+                  <td width="400">the constituent name</td>
+                </tr> 
+                <tr>
+                  <td><tt>CONSTITUENTSUFFIX</tt></td>
+                  <td>the optional constituent's output suffix</td>
+                </tr>              
+                <tr>
+                  <td><tt>FULLNAME</tt></td>
+                  <td>the full source path name (including directory and suffix)</td>
+                </tr> 
+                <tr>
+                  <td><tt>FILENAME</tt></td>
+                  <td>the complete source file name (only including the suffix)</td>
+                </tr> 
+                <tr>
+                  <td><tt>NAME</tt></td>
+                  <td>the short source file name (without directory and suffix)</td>
+                </tr> 
+                <tr>
+                  <td><tt>FILEPATH</tt></td>
+                  <td>the source directory</td>
+                </tr> 
+
+                <tr>
+                  <td><tt>SUFFIX</tt></td>
+                  <td>the suffix provided in the -suffix option</td>
+                </tr> 
+
+                <tr>
+                  <td><tt>OBJS</tt></td>
+                  <td>(only available in headers) the list of
+                    outputs, formed by a set of expressions :
+
+		    <cmt:code>
+$(${CONSTITUENT}_output)${NAME}${SUFFIX} </cmt:code>
+
+                  </td>
+                </tr> 
+
+          </table> 
+        </center> 
+      </p>
+
+      <p>Templates must be enclosed between <tt>${</tt> and <tt>}</tt> or between <tt>$(</tt> and
+      <tt>)</tt> and will be substituted at the generation time. Thus, if a
+      fragment contains the following text : </p>
+
+      <cmt:code>
+$(${CONSTITUENT}_output)${NAME}${SUFFIX}</cmt:code>
+
+      <p>then, the expanded constituent's makefile will contain
+      (refering to the "tex" example)</p>
+
+      <cmt:code>
+$(MyDoc_output)doc1.ps </cmt:code>
+
+      <p>Which shows that make macros may be dynamically generated. </p>
+
+      <cmt:image src="Images/DocumentGenerator.jpg" 
+                 caption="The architecture of document generation."/>
+
+    </cmt:section> 
+
+    <cmt:section title="Examples">
+
+      <ol> 
+
+        <li> rootcint 
+
+          <p>It generates C++ hubs for the Cint interpreter in Root. </p>
+
+          <cmt:cmtcode>
+========= rootcint ========================================= 
+$(src)${NAME}.cc :: ${FULLNAME}   
+	${rootcint} -f $(src)${NAME}.cc -c ${FULLNAME} 
+============================================================ </cmt:cmtcode>
+        </li>
+
+        <li> agetocxx and agetocxx_header. 
+
+          <p>It generates C++ source files (xxx.g files) from Atlas' AGE 
+            description files. </p>
+
+          <cmt:cmtcode>
+========= agetocxx ========================================= 
+output=$(${CONSTITUENT}_output) 
+
+$(output)${NAME}.cxx : $(${NAME}_cxx_dependencies) 
+	(echo '#line 1 "${FULLNAME}"'; cat ${FULLNAME}) > /tmp/${NAME}.gh.c 
+	gcc -E -I$(output) $(use_includes) -D_GNU_SOURCE \ 
+	  cd ${output}; $(agetocxx) -o ${NAME} -ohd ${FILEPATH} \
+	  -ohp ${FILEPATH} /tmp/${NAME}.gh 
+	rm -f /tmp/${NAME}.gh /tmp/${NAME}.gh.c 
+	cd $(bin); $(cppcomp) $(use_cppflags) $(${CONSTITUENT}_cppflags) \
+	  $(${NAME}_cppflags) ${ADDINCLUDE} $(output)${NAME}.cxx 
+	cd $(bin); $(ar) $(${CONSTITUENT}lib) ${NAME}.o; /bin/rm -f ${NAME}.o 
+============================================================ </cmt:cmtcode>
+
+          <cmt:cmtcode>
+========= agetocxx_header ================================== 
+${CONSTITUENT}lib       = $(bin)lib${CONSTITUENT}.a 
+${CONSTITUENT}stamp     = $(bin)${CONSTITUENT}.stamp 
+${CONSTITUENT}shstamp   = $(bin)${CONSTITUENT}.shstamp 
+
+${CONSTITUENT} :: dirs ${CONSTITUENT}LIB 
+	@/bin/echo ${CONSTITUENT} ok 
+
+${CONSTITUENT}LIB :: $(${CONSTITUENT}lib) $(${CONSTITUENT}shstamp) 
+	@/bin/echo ${CONSTITUENT} : library ok 
+
+$(${CONSTITUENT}lib) $(${CONSTITUENT}stamp) :: ${OBJS} 
+	$(ranlib) $(${CONSTITUENT}lib) 
+	cat /dev/null &gt;$(${CONSTITUENT}stamp) 
+
+$(${CONSTITUENT}shstamp) :: $(${CONSTITUENT}stamp) 
+	cd $(bin); $(make_shlib) $(tag) ${CONSTITUENT} \
+	  $(${CONSTITUENT}shlibflags); \
+	  cat /dev/null &gt;$(${CONSTITUENT}shstamp) 
+
+============================================================ </cmt:cmtcode>
+
+          It must be declared as follows : 
+
+          <cmt:cmtcode>
+make_fragment agetocxx -suffix=cxx -dependencies -header=agetocxx_header </cmt:cmtcode>
+
+        </li>
+      </ol> 
+
+    </cmt:section> 
+
+  </cmt:section>
+
+  <cmt:section title="The tools provided by CMT">
+
+
+        The set of conventions and tools provided by <tt>CMT</tt> is 
+        mainly composed of : 
+
+        <ul> 
+          <li> 
+            the syntax of the <tt>&CMTrequirements;</tt> file, 
+          </li> 
+          <li> 
+            and the general <tt>cmt</tt> user interface, available in 
+            the <tt>mgr</tt> branch of the <tt>CMT</tt> package. 
+          </li> 
+        </ul> 
+
+        The <i>setup</i> script found in the <tt>CMT</tt> installation
+        directory actually adds its location to the definition of the
+        standard <tt>UNIX</tt> <tt>PATH</tt> environment variable in order to
+        give direct access to the main <tt>cmt</tt> user interface.
+
+        <p> 
+          The sections below will detail the complete syntax of the 
+          <tt>&CMTrequirements;</tt> file since it is the basis of most 
+          information required to run the tools as well as the main 
+          commands available through the <tt>cmt</tt> user interface. </p>
+
+        <cmt:section title="The requirements file">
+
+          <cmt:section title="The general requirements syntax">
+
+            <ul>
+              <li>
+                A requirements file is made of <i>statements</i>, each describing
+                one named configuration parameter.
+
+                <p>Statements generally occupy one single line, but may be
+                  split into several lines using the reverse-slash character
+                  (in this case the reverse-slash character <i>must</i> be
+                  the last character on the line or must be only followed
+                  by space characters).</p>
+
+                <p>Each statement is composed of words separated with spaces
+                  or tabulations.</p>
+
+                <p>The first word of a statement is the name of the
+                  configuration parameter.</p>
+
+                <p>The rest of the statement provides the value assigned
+                  to the configuration parameter.</p>
+
+              </li>
+
+              <li>
+                <p>Words composing a statement are separated with space or
+                  tab characters. They may also be enclosed in quotes when
+                  they have to include space or tab characters. Single or
+                  double quotes may be freely used, as long as the same type
+                  of quote is used on both sides of the word.</p>
+
+                  <p>Special characters (tabs, carriage-return and
+                    line-feed) may be inserted into the statements using an
+                    XML-based convention:</p>
+
+                    <center>
+                      <table cols='2'>
+
+                        <tr>
+                          <td>
+                            <tt>tabulation</tt>
+                          </td>
+                          <td>
+                            <tt><tt>&lt;cmt:tab/&gt;</tt></tt>
+                          </td>
+                        </tr>
+
+                        <tr>
+                          <td>
+                            <tt>carriage-return</tt>
+                          </td>
+                          <td>
+                            <tt><tt>&lt;cmt:cr/&gt;</tt></tt>
+                          </td>
+                        </tr>
+
+                        <tr>
+                          <td>
+                            <tt>line-feed</tt>
+                          </td>
+                          <td>
+                            <tt><tt>&lt;cmt:lf/&gt;</tt></tt>
+                          </td>
+                        </tr>
+
+                      </table>
+                    </center>
+                    <p></p>
+              </li>
+
+              <li> 
+                <p>Comments : they start with the <tt>#</tt> character and 
+                  extend up to the end of the current line. 
+                  </p> 
+              </li>
+
+            </ul>
+
+	    The complete  syntax specification is available in <a href="#The complete requirements syntax">Appendix</a>.
+
+          </cmt:section> 
+
+        </cmt:section>
+
+        <cmt:section title="The concepts handled in the requirements file">
+
+          <cmt:section title="The package structuring style ">
+
+            <p>Packages are installed in a directory structure that
+            can optionnally include a version directory (just after
+            the top directory of the package name). This is controlled
+            through the <i>structuring style</i> or <i>structuring
+            strategy</i> parameters specified using one of the
+            following means:</p>
+
+            <ol>
+
+              <li>Through the environment variable
+              <tt>CMTSTRUCTURINGSTYLE</tt> taking one of the
+              alternate values:
+<cmt:code>
+with_version_directory
+without_version_directory</cmt:code>
+              <p></p></li>
+
+              <li>Through the command line options
+              <tt>-with_version_directory</tt> or
+              <tt>-without_version_directory</tt><p></p></li>
+
+              <li>Through the <tt>structure_strategy</tt> specification entered into the project file of the current project, using the alternate values:
+<cmt:code>
+with_version_directory
+without_version_directory</cmt:code>
+              <p></p></li>
+
+            </ol>
+
+            <p>It should be noted that the command line option will
+            take precedence over the strategy specification, in case
+            of conflict.</p>
+
+          </cmt:section>
+
+          <cmt:section title="Meta-information : author, manager">
+
+            The author and manager names 
+
+          </cmt:section>
+
+          <cmt:section title="package, version">
+
+            The package name and version. These statements are purely
+            informational.
+
+          </cmt:section>
+
+          <cmt:section title="Constituents : application, library, document">
+
+            <p>Describe the composition of a constituent. Application
+            and library correspond to the standard meaning of an
+            application (an executable) and a library, while document
+            provides for a quite generic and open mechanism for
+            describing any type of document that can be generated from
+            sources.</p>
+
+            <p>Applications and libraries are assigned a name (which
+            will correspond to a generated make fragment, and a
+            dedicated make target).</p>
+
+            <p>A document is first associated with a document type
+            (which must correspond to a previously declared make
+            fragment). The document name is then used to name a
+            dedicated make fragment and a make target.</p>
+
+            <p>Various options can be used when declaring a
+            constituent:</p>
+
+            <center>
+              <table border='1' cellspacing='0' cols='3'>
+
+                <tr>
+                  <td width="250"><center><i>option</i></center></td>
+                  <td width="150"><center><i>validity</i></center></td>
+                  <td width="300"><center><i>usage</i></center></td>
+                </tr>
+
+                <tr>
+                  <td><tt>-s=<i>directory</i></tt></td>
+                  <td>any</td>
+                  <td>switch to a new default directory <a href="#source selection and exclusion"><tt>(1)</tt></a></td>
+                </tr>
+
+                <tr>
+                  <td><tt>-x=<i>regexp</i></tt></td>
+                  <td>any</td>
+                  <td>specify an exclusion regular expression to be applied to the sources <a href="#source selection and exclusion"><tt>(1)</tt></a></td>
+                </tr>
+
+                <tr>
+                  <td><tt>-k=<i>regexp</i></tt></td>
+                  <td>any</td>
+                  <td>specify a finer selection regular expression to be applied to the sources <a href="#source selection and exclusion"><tt>(1)</tt></a></td>
+                </tr>
+
+                <tr>
+                  <td><tt>-no_share</tt></td>
+                  <td>libraries</td>
+                  <td>do not generate the shared library</td>
+                </tr>
+
+                <tr>
+                  <td><tt>-no_static</tt></td>
+                  <td>libraries</td>
+                  <td>do not generate the static library (<i>not yet implemented</i>)</td>
+                </tr>
+
+                <tr>
+                  <td><tt>-prototypes</tt></td>
+                  <td>applications, libraries</td>
+                  <td>do generate the prototype header files</td>
+                </tr>
+
+                <tr>
+                  <td><tt>-no_prototypes</tt></td>
+                  <td>applications, libraries</td>
+                  <td>do not generate the prototype header files</td>
+                </tr>
+
+                <tr>
+                  <td><tt>-check</tt></td>
+                  <td>applications</td>
+                  <td>generate a check target meant to execute the rebuilt application</td>
+                </tr>
+
+                <tr>
+                  <td><tt>-group=&lt;group-name&gt;</tt></td>
+                  <td>any</td>
+                  <td>install the constituent within this group target</td>
+                </tr>
+
+                <tr>
+                  <td><tt>-suffix=&lt;suffix&gt;</tt></td>
+                  <td>applications, libraries</td>
+                  <td>provide a suffix to names of all object files generated for this constituent <a href="#suffix option"><tt>(2)</tt></a></td>
+                </tr>
+
+                <tr>
+                  <td><tt>-import=&lt;package&gt;</tt></td>
+                  <td>applications, libraries</td>
+                  <td>explicitly import for this constituent the standard macros from a package that has the <tt>-no_auto_imports</tt> option set</td>
+                </tr>
+
+                <tr>
+                  <td><tt>-target_tag</tt></td>
+                  <td>any</td>
+                  <td>construct a specific tag named
+                  <tt>target_&lt;constituent&gt;</tt>. This tag will
+                  only be active during the make session for this
+                  constituent. <a href="#the target tag option"><tt>(4)</tt></a></td>
+                </tr>
+
+                <tr>
+                  <td><tt>-windows</tt></td>
+                  <td>applications</td>
+                  <td>When used in a Windows environment, generates a GUI-based application (rather than a console application) </td>
+                </tr>
+
+                <tr>
+                  <td><tt>&lt;var-name&gt;=&lt;var-value&gt;</tt></td>
+                  <td>any</td>
+                  <td>define a variable and its value to be given to the make fragment <a href="#variable-name option"><tt>(3)</tt></a></td>
+                </tr>
+
+              </table>
+            </center>
+
+            <ol>
+
+              <li><a name="source selection and exclusion"></a>
+
+                <p>The sources of the constituents are generally
+                specified as a set of file names with their suffixes,
+                and are by default expected from the <tt>../src</tt>
+                directory</p>
+
+                <cmt:cmtcode>
+library A A.cxx B.cxx</cmt:cmtcode>
+
+                <p>Then it is possible to change the default search
+                location as well as to use a simplified wildcarding
+                syntax:</p>
+
+                <cmt:cmtcode>
+library A -s=A *.cxx -s=B *.cxx</cmt:cmtcode>
+
+                <ul>
+
+                  <li><tt>-s=A</tt> means that next source files
+                  should be taken searched from <tt>../src/A</tt></li>
+
+                  <li><tt>-s=B</tt> means that next source files
+                  should be taken searched from
+                  <tt>../src/B</tt>. Note that this new specification
+                  is <i>not</i> relative to the previous <tt>-s=A</tt>
+                  but relative to the default search path
+                  <tt>../src</tt></li>
+
+                  <li><tt>*.cxx</tt> indicates that all files with a
+                  <tt>.cxx</tt> suffix in the current search path
+                  should be considered
+                  </li>
+
+                </ul>
+
+                <p>It's also possible to select or exclude files using
+                regular expressions from general wildcarding
+                techniques:</p>
+
+                <cmt:cmtcode>
+library A -s=A -x=[0-9] *.cxx -s=B -k=^B *.cxx</cmt:cmtcode>
+
+                <ul>
+
+                  <li>The exclusion specification <tt>-x=[0-9]</tt>
+                  added to the statement will exclude all files
+                  from <tt>../src/A</tt> containing a <i>number</i> in their name.</li>
+
+                  <li>The selection specification <tt>-k=^B</tt> added
+                  to the statement will select files from
+                  <tt>../src/B</tt> strictly starting with the
+                  <tt>B</tt> letter.</li>
+
+                </ul>
+
+              <p></p></li>
+
+              <li><a name="suffix option"></a>
+
+                <p>When several constituents need to share source
+                files, (a typical example is for building different
+                libraries from the same sources but with different
+                compiler options), it is possible to specify an
+                optional output suffix with the
+                <tt>-suffix=&lt;suffix&gt;</tt> option. With this
+                option, every object file name will be automatically
+                suffixed by the character string
+                "<tt>&lt;suffix&gt;</tt>", avoiding name conflicts
+                between the different targets, as in the following
+                example:</p>
+
+		<cmt:cmtcode>
+library AXt  -suffix=Xt  *.cxx
+library AXaw -suffix=Xaw *.cxx</cmt:cmtcode>
+
+              </li>
+
+              <li><a name="variable-name option"></a>
+
+                <p>It's possible to specify in the list of parameters
+                one or more pairs of
+                <tt>variable-name</tt>=<tt>variable-value</tt> (without
+                any space characters around the <tt><tt>"="</tt></tt>
+                character), such as in the next example:</p>
+
+		<cmt:cmtcode>
+make_fragment doc_to_html                             (1)
+
+document doc_to_html Foo output=FooA.html FooA.doc    (2) (3)</cmt:cmtcode>
+
+
+                <ol>
+
+                  <li>This makefile fragment is meant to contain some text
+                  conversion actions and defines a <a href="#Defining a
+                  document generator"> document type</a> named
+                  <tt>doc_to_html</tt>.</li>
+
+                  <li>This constituent exploits the document type
+                  <tt>doc_to_html</tt> to convert the source <tt>FooA.doc</tt>
+                  into an html file.</li>
+
+                  <li>The user defined template variable named <tt>output</tt>
+                  is specified and assigned the value <tt>FooA.html</tt>. If the
+                  fragment <tt>doc_to_html</tt> contains the string
+                  <tt>${output}</tt>, then it will be substituted to
+                  this value.</li>
+
+                </ol>
+
+              <p></p></li>
+
+              <li><a name="the target tag option"></a>
+
+                <p>For any constituent that has the
+                <tt>-target_tag</tt> option set, a dedicated
+                <i>tag</i> named <tt>target_&lt;constituent&gt;</tt>
+                is automatically constructed by CMT. This tag becomes
+                active during the construction of this constituent
+                when using <tt>make</tt>, and therefore can be used as
+                any other tag to select symbol values, or other
+                configuration parameters.</p>
+
+              </li>
+
+            </ol>
+
+          </cmt:section>
+
+          <cmt:section title="Groups">
+
+            Groups permit the organization of the constituents that must
+            be consistently built at the same development phases or with similar
+            constraints.
+
+            <p>Each group is associated with a make target (of the same
+              name) which, when used in the make command, selectively
+              rebuilds all constituents of this group.</p>
+
+            <p>The default group (into which all constituents are
+              installed by default) is named <tt>all</tt>, therefore,
+              running make without argument, activates the default target
+              (ie. <tt>all</tt>).</p>
+
+            <p>As a typical usage of this mechanism, one may examplify the
+              case in which one or several constituents are making use of
+              one special facility (such as a database service, real-time
+              features, graphical libraries) and therefore might require a
+              controled re-build. This is especially useful for having these
+              constituents only rebuilt on demand rather than rebuilt
+              automatically when the default make command is run.</p>
+
+            <p>One could, for instance specify within the requirements file :</p>
+
+	    <cmt:cmtcode>
+# Constituents belonging to the default <i>all</i> group
+
+<i>... constituents without group specification ...</i>
+library Foo *.cxx
+
+# Constituents belonging to specific groups
+
+library Foo-objy -group=objy &lt;<i>sources making use of Objectivity</i>&gt;
+
+application FooGUI -group=graphics &lt;<i>sources making use of Qt</i>&gt;
+application BarGUI -group=graphics &lt;<i>sources making use of Qt</i>&gt;
+</cmt:cmtcode>
+
+            <i>(Beware of the position of the -group option which must be
+              located after the constituent name. Any other position will be
+              misunderstood by CMT)</i>
+
+            <p>Then, running <tt>gmake all</tt> would only rebuild the un-grouped
+              constituents, whereas running</p>
+
+	      <cmt:code>
+&gt; gmake objy
+&gt; gmake graphics</cmt:code>
+
+            <p>in the context of the <tt>Foo</tt> package would rebuild <i>objy</i>
+              related or <i>graphics</i> related constituents.</p>
+
+          </cmt:section>
+
+          <cmt:section title="Languages">
+
+            Some computer languages are known by default by <tt>CMT</tt>
+            (<tt>C</tt>, <tt>C</tt>++, <tt>Fortran77</tt>, <tt>Java</tt>,
+            <tt>lex</tt>, <tt>yacc</tt>). However it is possible to extend
+            this knowledge to any other langage.
+
+            <p>We consider here languages that are able to produce object
+              files from sources.</p>
+
+            <p>Let's take an example. We would like to install support for
+              Fortran90. We first have to <i>declare</i> this new language
+              support to <tt>CMT</tt> within the <tt>requirements</tt> file of
+              one of our packages (Notice that it's not at all required to
+              modify <tt>CMT</tt> itself since all clients of the selected
+              package will inherit the knowledge of this language).</p>
+
+            <p>The language support is simply named <tt>fortran90</tt> and is
+              declared by the following statement:</p>
+
+	      <cmt:cmtcode>
+language fortran90 \
+  -suffix=f90 -suffix=F90 \             [1]
+  -linker=$(f90link) \                  [2]
+  -preprocessor_command=$(ppcmd)</cmt:cmtcode>
+
+            <ol>
+
+              <li>The recognized suffixes for source files will be <tt>f90</tt> and <tt>F90</tt></li>
+
+              <li>The linker command used to build a Fortran90 application
+              is described inside the macro named <tt>f90link</tt> (which
+              must defined in this requirements file but which can also be
+              overridden by clients)</li>
+
+            </ol>
+
+            <p>The language support being named <tt>fortran90</tt>, two
+            associated make fragments are expected, one under the name
+            <tt>fortran90</tt> (for building application modules), the
+            other with the name <tt>fortran90_library</tt> (for modules
+            meant to be archived), both without extension.</p>
+
+            <p>These two fragments should be installed in the
+            <tt>fragments</tt> sub-directory of the cmt branch of our
+            package.</p>
+
+            <p>Due to the similarity of the example to fortran77, we
+            may easily provide the expected fragments simply by
+            copying the f77 fragments found in <tt>CMT</tt> (thus the
+            fragments <tt>${CMTROOT}/fragments/fortran</tt> and
+            <tt>${CMTROOT}/fragments/fortran_library</tt></p>
+
+            <p>These fragments make use of the <tt>fcomp</tt> macro,
+            which holds the fortran77 compiler command (through the
+            <tt>for</tt> macro).</p>
+
+	    <cmt:cmtcode>
+macro for             "f77" \
+...
+macro fcomp           "$(for) -c $(fincludes) $(fflags) $(pp_fflags)"</cmt:cmtcode>
+
+            <p>We therefore simply replace these macros by new macros
+            named <tt>f90comp</tt> and <tt>f90</tt>, defined as
+            follows:</p>
+
+	    <cmt:cmtcode>
+macro f90             "f90"
+...
+macro f90comp         "$(f90) -c $(fincludes) $(fflags) $(pp_fflags)"</cmt:cmtcode>
+
+            <p>Some languages (this has been seen for example in the
+            IDL generators in Corba environments) do provide several
+            object files from one unique source file. It is possible
+            to specify this feature through the (repetitive)
+            <tt>-extra_output_suffix</tt> option like in:</p>
+
+	    <cmt:cmtcode>
+language idl -suffix=idl -fragment=idl -extra_output_suffix=_skel</cmt:cmtcode>
+
+            where, in this case, two object files are produced for each
+            IDL source file, one named <tt>&lt;<i>name</i>&gt;.o</tt> the
+            other named <tt>&lt;<i>name</i>&gt;_skel.o</tt>.
+
+          </cmt:section>
+
+          <cmt:section title="Symbols">
+
+            <p>This is a generic concept supporting the notion of
+            valued symbols. Several alternate semantics are
+            implemented by these symbols, all specified using the
+            same syntactic schema, but leading to different behaviours
+            or interpretations by CMT:</p>
+
+            <ul>
+
+              <li>The <tt>set</tt> keyword is translated into an environment
+              variable definition.</li>
+
+              <li>The <tt>macro</tt> keyword is translated into a
+              <tt>make</tt>'s macro definition.</li>
+
+              <li>The <tt>path</tt> keyword is translated into a
+              prioritized <i>path</i>-like environment variable, which
+              is supposed to be composed of search paths separated
+              with colon characters <tt>':'</tt> (on Unix) or semi-colon
+              characters <tt>';'</tt> (on Windows). It is generally
+              recommended to construct such a variable by iteratively
+              concatenating individual items one by one using
+              <tt>path_append</tt> or <tt>path_prepend</tt></li>
+
+              <li>The <tt>action</tt> keyword is translated into a shell
+              command definition, that can be activated using the
+              <tt>cmt do &lt;action&gt;</tt> command or the associated
+              <tt>make</tt> target.</li>
+
+              <li>The <tt>alias</tt> keyword is translated into a shell alias
+              definition, </li>
+
+            </ul>
+
+            <p>Variants of these keywords are also provided for
+            modifying already defined symbols. This generally happens
+            when a package needs to modify (append, prepend or
+            subtract) an inherited symbol (ie. which has been already
+            defined by a used package).</p>
+
+            <p>The translations occur while running either the setup
+              scripts (for alias, set or path) or the make command (for
+              macro and actions).</p>
+
+            <p>All these definitions follow the same pattern:</p>
+
+	    <cmt:syntax name="symbol">
+	      <cmt:rule name="symbol">
+	        <cmt:alt>
+		  <cmt:term name="symbol-type"/>
+		  <cmt:term name="symbol-name"/>
+		  <cmt:term name="default-value"/>
+		  <cmt:optionseq>
+		    <cmt:term name="tag-expr"/>
+		    <cmt:term name="value"/>
+		  </cmt:optionseq>
+	        </cmt:alt>
+	      </cmt:rule>
+              <cmt:rule name="symbol-type">
+                <cmt:alt><cmt:term name="definition"/></cmt:alt>
+                <cmt:alt><cmt:term name="modification"/></cmt:alt>
+              </cmt:rule>
+              <cmt:rule name="definition">
+                <cmt:alt><cmt:kwd name="macro"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="set"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="path"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="action"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="alias"/></cmt:alt>
+              </cmt:rule>
+              <cmt:rule name="modification">
+                <cmt:alt><cmt:kwd name="macro_prepend"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="macro_append"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="macro_remove"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="macro_remove_regexp"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="macro_remove_all"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="macro_remove_all_regexp"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="set_prepend"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="set_append"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="set_remove"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="set_remove_regexp"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="path_prepend"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="path_append"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="path_remove"/></cmt:alt>
+                <cmt:alt><cmt:kwd name="path_remove_regexp"/></cmt:alt>
+              </cmt:rule>
+              <cmt:rule name="tag-expr">
+                <cmt:alt>
+                  <cmt:term name="tag"/>
+                  <cmt:optionseq>
+		    <cmt:kwd name="&amp;"/>
+		    <cmt:term name="tag"/>
+		  </cmt:optionseq>
+                </cmt:alt>
+              </cmt:rule>
+	    </cmt:syntax>
+
+	    <p></p>
+
+            <ul>
+
+              <li>The symbol-name identifies the symbol.<p></p></li>
+
+              <li>Values are generally quoted strings (using either
+              simple or double quotes). They may be unquoted only if
+              they are composed of one single non-empty word, since
+              the general syntax parsing relies on space separated
+              words.<p></p></li>
+
+              <li> The default-value is mandatory (although it can be
+              an empty string) optionally followed by a set of
+              tag/value pairs, each representing an alternate value
+              for this symbol.<p></p></li>
+
+              <li>Each tag-value pair describes an alternate value to
+              be used when the corresponding tag or tag-expression is
+              active.<p></p></li>
+
+              <li>When several alternate values are specified through
+              several tag-value pairs the <i>first</i> matching
+              condition is selected. Therefore one should always
+              specify the most contraining condition first.<p></p></li>
+
+              <li>The removal operations can be specified using either
+              plain sub-strings or regular rexpressions. One should
+              notice that even for the <tt>path_remove_regexp</tt>
+              operation, full regular expression are expected rather
+              than file-system wild carding syntaxes.<p></p></li>
+
+              <li>The <tt>path_remove</tt> keyword is slightly
+              specialized since it removes all individual search paths
+              that <i>contain</i> the specified sub-string.<p></p></li>
+
+            </ul>
+
+            <p>Be aware that there is only one name space for
+            all kinds of symbols. Therefore, if a symbol was originally
+            defined using a <tt>macro</tt> statement, using
+            <tt>set_append</tt> to modify it will produce an undefined
+            result (and a warning message).</p>
+
+            <p>The <a href="#tag, apply_tag">tag</a> expression is
+            used to select one alternate value to replace the default
+            value, using the following matching rule:</p>
+
+            <ul>
+
+              <li>The first matching condition in the ordered list of
+              alternate values is selected, ignoring the following
+              ones</li>
+
+              <li>A tag expression matches when all tags in the
+              expression are active.</li>
+
+            </ul>
+
+            <p>Examples of such definition are : </p>
+
+	    <cmt:cmtcode>
+package CMT 
+
+macro cflags          "" \
+      LynxOS-VGPW2    "-X" \
+      insure          "-std1" \
+      HP-UX           "+Z" \
+      hp700_ux101     "-fpic -ansi" \
+      alpha           "-std1" \
+      alphat          "-std1" \
+      SunOS           "-KPIC" \
+      WIN32           '/nologo /DWIN32 /MD /W3 $(includes) /c'
+
+macro pp_cflags       "" \
+      LynxOS-VGPW2    "-DVGPW2" \
+      HP-UX           "-D_HPUX_SOURCE" \
+      alphat          "-DCTHREADS" \
+      AIX             "-D_ALL_SOURCE -D_BSD" \
+      Linux           "-Di586"
+
+macro ccomp           "$(cc) -c $(includes) $(cdebugflags) $(cflags) $(pp_cflags)" \
+      VisualC         "cl.exe $(cdebugflags) $(cflags) $(pp_cflags)"
+
+macro clinkflags      ""
+
+macro clink           "$(cc) $(clinkflags)" \
+      VisualC         "link.exe /nologo /machine:IX86 "
+</cmt:cmtcode>
+
+            <cmt:section  title="actions">
+
+              Actions are one of the possible symbols. Their
+              definition as said previously follow the generic
+              conventions for any symbol type, and they implement the
+              concept of a generic shell command.
+
+              <p>An example of a symple action:</p>
+
+              <cmt:cmtcode>
+action directory "ls $(dir_options)" WIN32 "dir $(dir_options)"</cmt:cmtcode>
+
+              <p>Like other symbols, actions can be visualized using
+              the <tt>cmt show actions</tt> or the <tt>cmt show action
+              &lt;name&gt;</tt> command.</p>
+
+              <p>Some specialized mechanims are available on actions,
+              in order to execute in various ways the corresponding
+              shell commands.</p>
+
+              <p>Actually two operating modes are supported:</p>
+
+              <ol>
+
+                <li>Immediate mode
+
+                  <p>This can be done via the <tt>cmt do</tt> command:</p>
+
+                  <cmt:code>&gt; cmt &lt;action-name&gt;</cmt:code>
+
+                  <p>or, when the action name conflicts with a native CMT keyword, </p>
+
+                  <cmt:code>&gt; cmt do &lt;action-name&gt;</cmt:code>
+
+                  <p>This mode immediately executes the specified
+                  command, after locally setting all environment
+                  variables known from the current package.</p>
+
+                </li>
+
+                <li>Through <tt>make</tt>
+
+                  <cmt:code>
+&gt; cmt make &lt;action-name&gt;</cmt:code>
+
+                  <ul>
+
+                    <li>Actions are always associated with a make
+                    target of the same name</li>
+
+                    <li>Action are always defined under a constituent
+                    <a href="#Groups">group</a> named
+                    <tt>cmt_actions</tt>. This means that action
+                    targets are never activated by default. Instead
+                    they must be explicitly called.
+                    </li>
+
+                    <li>Action targets can be made dependent to other
+                    make targets (or vice versa), similarly to other
+                    constituents (libraries, applications, documents),
+                    using the <tt>&lt;name&gt;_dependencies</tt>
+                    macro.
+
+                    <p>Example 1</p>
+
+                    <cmt:cmtcode>
+library A ...
+action B ...
+macro B_dependencies " A "</cmt:cmtcode>
+
+                    In this example when doing <tt>gmake B</tt>, the
+                    library <tt>A</tt> will be rebuilt first.
+
+                    <p>Example 2</p>
+
+                    <cmt:cmtcode>
+library A ...
+action B ...
+macro A_dependencies " B "</cmt:cmtcode>
+
+                    In this example when doing <tt>gmake A</tt> (or
+                    simply <tt>gmake</tt>), the action <tt>B</tt> will
+                    be executed first.
+
+                    </li>
+                  </ul>
+
+                </li>
+
+              </ol>
+
+            </cmt:section>
+
+          </cmt:section>
+
+          <cmt:section  title="use">
+
+            <p>Describe the relationships with other packages; the
+            generic syntax is :</p>
+
+	    <cmt:cmtcode>
+use &lt;package&gt; [ &lt;version&gt; [ &lt;offset&gt; ] ] [ -no_auto_imports=&lt;package&gt; ... ]</cmt:cmtcode>
+
+            <p>Omitting the version specification means that the most
+            recent version (ie. the one with highest ids) that can be
+            found from the search path list will be automatically
+            selected.</p>
+
+            <p> The <i>offset</i> specification can be relative
+            (i.e. on Unix it does not contain a leading '/'
+            character). In this case, this offset is systematically
+            considered when the package is looked for in the search
+            path list. But it can also be absolute (ie. with a leading
+            '/' character on Unix), in which case this path takes
+            precedence over the standard search path list (see
+            CMTPATH).</p>
+
+            <p>The additional <tt>-no_auto_imports</tt> options
+            suppress the automatic inheritance of some standard
+            parameters from the specified used packages, such as
+            include paths, compiler flags, ... </p>
+
+            <p> Examples of such relationships are :</p>
+
+	    <cmt:cmtcode>
+use OnX v5r2 
+use CSet v2r3 
+use Gb v2r1 
+
+# A package installed in a sub-directory one step below the root : 
+use CS v3r1 virgo 
+
+# Back to the default root : 
+use Cm v7r3 
+
+# Get the most recent version of CERNLIB
+use CERNLIB</cmt:cmtcode>
+
+            <p>By default, a set of standard macros, which are
+            expected to be specified by used packages, is
+            automatically imported from them (see the <A
+            HREF="#Package customizing macros">detailed list</A> of
+            these macros). This automatic feature can be discarded
+            using the <tt>-no_auto_imports</tt> option to the use
+            statement, or re-activated using the
+            <tt>-auto_imports</tt>. When it is discarded, the macros
+            will not be transparently inherited, but rather, each
+            individual constituent willing to make use of them will
+            have to explicitly import them using the
+            <tt>-import=&lt;<i>package</i>&gt;</tt> <a
+            href="#constituents">option</a>.</p>
+
+            <p>When a <tt>use</tt> statement is in a <a href="#public, private"><tt>private</tt></a>
+            section, the corresponding used package will only be
+            reached if when <tt>CMT</tt> operations occur in the context
+            of the holder package. Otherwise (ie if the operation
+            occurs in some upper level client package), then this
+            <i>privately</i> used package will be entirely
+            hidden. (<i>This behaviour follows a very similar pattern
+            to the private or public inheritance of C++</i>). Suppose
+            we have the following organization:</p>
+
+	    <cmt:cmtcode>
+----------------
+package A
+
+use B v1
+use D v1
+----------------
+
+----------------
+package B
+
+private
+use C v1
+use D v1
+----------------
+</cmt:cmtcode>
+
+            <ul>
+              <li> all operations done in the context of package B will <i>see</i> both packages C and D</li>
+              <li> all operations done in the context of package A will <i>see</i> both packages B and D, but not package C</li>
+            </ul>
+
+          </cmt:section>
+
+          <cmt:section title="patterns">
+
+            <p>Often, similar configuration items are needed over a
+            set of packages (sometimes over all packages of a
+            project). This reflects either similarities between
+            packages or generic conventions established by a project
+            or a team.</p>
+
+            <p>Typical examples are the definition of the search path
+            for shared libraries (through the <tt>LD_LIBRARY_PATH</tt>
+            environment variable), the systematic production of test
+            applications, etc.</p>
+
+            <p>The concept of pattern proposed here implements this
+            genericity. Patterns may be either <i>global</i>, in which
+            case they will be systematically applied onto every
+            package, or <i>local</i> (the default) in which case they
+            will be applied on demand only by each package.</p>
+
+            <p>The general principle of a pattern is to associate a
+            templated (set of) <tt>cmt</tt> statement(s) with the
+            pattern name. Then every time the pattern is applied, its
+            associated statements are applied as if they were directly
+            specified in the requirements file, replacing the template
+            with its current value. If several statements are to be
+            associated with a given pattern, they will be separated
+            with the <tt>" ; "</tt> separator pattern (beware of really
+            enclosing the <tt>;</tt> character between two space
+            characters).</p>
+
+	    <p>The general syntax for defining a pattern in a
+	    requirements file is:</p>
+
+	    <cmt:syntax name="pattern">
+	      <cmt:rule name="pattern">
+                <cmt:alt>
+	          <cmt:kwd/>
+                  <cmt:option><cmt:kwd name="-global"/></cmt:option>
+                  <cmt:term name="pattern-name"/>
+                  <cmt:ruleref name="cmt-statement"/>
+                </cmt:alt>
+                <cmt:continuation>
+                  <cmt:optionseq>
+                  <cmt:kwd name=" ; "/>
+                  <cmt:ruleref name="cmt-statement"/>
+                  </cmt:optionseq>
+                </cmt:continuation>
+              </cmt:rule>
+            </cmt:syntax>
+
+            <p>Pattern templates are names enclosed between the
+            <tt>&lt;</tt> and <tt>&gt;</tt> characters. A set of
+            predefined templates are automatically provided by
+            <tt>CMT</tt>:</p>
+
+            <p>
+              <center>
+                <table BORDER='1' cellspacing='0' COLS='2'> 
+                  <tr> 
+                    <td width="80"><tt>package</tt></td> 
+                    <td width="300">the name of the current package</td> 
+                  </tr> 
+                  <tr> 
+                    <td><tt>PACKAGE</tt></td> 
+                    <td>the name of the current package in upper case</td> 
+                  </tr> 
+                  <tr> 
+                    <td><tt>version</tt></td> 
+                    <td>the version tag of the current package</td> 
+                  </tr> 
+                  <tr> 
+                    <td><tt>path</tt></td> 
+                    <td>the access path of the current package</td> 
+                  </tr> 
+                  <tr> 
+                    <td><tt>project</tt></td> 
+                    <td>the project name of the current package</td> 
+                  </tr> 
+                </table>
+              </center>
+            </p>
+
+            <p>Then, in addition, user defined templates can be installed
+              within the pattern definitions. Their actual value will be
+              provided as arguments to the apply_pattern statement.</p>
+
+            <p>User defined templates that have not been assigned a
+            value when the pattern is applied are simply ignored
+            (ie. replaced with an empty string).</p>
+
+            <p>Some examples:</p>
+
+            <ol>
+              <li>
+                <p>Changing the standard include search path.</p>
+
+                <p>The standard include path is set by default to
+                  <tt>${&lt;package&gt;_root}/src</tt>. However, often projects
+                  need to override this default convention, and typical
+                  example is to set it to a branch named with the package
+                  name. This convention is easily applied by defining a
+                  pattern which will apply the include_path statement as
+                  follows:</p>
+
+		<cmt:cmtcode>
+pattern -global include_path include_path ${&lt;package&gt;_root}/&lt;package&gt;/</cmt:cmtcode>
+
+                <p>For instance, a package named <tt>PackA</tt> will expand this
+                  pattern as follows:</p>
+
+		<cmt:cmtcode>
+include_path ${PackA_root}/PackA/</cmt:cmtcode>
+              </li>
+              <li>
+                <p>Providing a value to the <tt>LD_LIBRARY_PATH</tt> environment variable</p>
+
+                <p>On some operating systems (eg. Linux), shared library
+                  paths must be explicited, through an environment
+                  variable. The following pattern can automate this operation:</p>
+
+		<cmt:cmtcode>
+pattern ld_library_path \
+  path_remove LD_LIBRARY_PATH "/&lt;package&gt;/" ; \
+  path_append LD_LIBRARY_PATH ${&lt;PACKAGE&gt;ROOT}/${CMTCONFIG}</cmt:cmtcode>
+
+                <p>In this example, the pattern was not set global, so
+                  that only packages actually providing shared libraries
+                  would be concerned. These packages will simply have to
+                  apply the pattern as follows:</p>
+
+		<cmt:cmtcode>
+apply_pattern ld_library_path</cmt:cmtcode>
+
+                <p>The schema installed by this pattern provides first a
+                  cleanup of the <tt>LD_LIBRARY_PATH</tt> environment variable
+                  and then the new assignment. This choice is useful in this
+                  case to avoid conflicting definitions from two different
+                  versions of the same package.</p>
+
+              </li>
+
+              <li>
+                <p>Installing a systematic test application in all packages</p>
+
+                <p>Quality assurance requirements might specify that every
+                  package should provide a test program. One way to enforce
+                  this is to build a global pattern declaring this
+                  application. Then every make command would naturally
+                  ensure its actual presence.</p>
+
+		<cmt:cmtcode>
+pattern quality_test application &lt;package&gt;test &lt;package&gt;test.cxx &lt;other_sources&gt;</cmt:cmtcode>
+
+                <p>In this example, an additional pattern
+                  (&lt;other_sources&gt;) permits the package to specify
+                  extra source files to the test application (the pattern
+                  assumes at least one source file &lt;package&gt;test.cxx).</p>
+
+              </li>
+            </ol>
+
+            <cmt:section title="Applying a pattern">
+
+              According to whether the <tt>-global</tt> qualifier was
+              used in the pattern definition, the aplication mode will
+              be completely different.
+
+              <ol>
+
+                <li><i>Normal patterns</i>
+
+                  <p>Such patterns must be applied explicitly using
+                  the <tt>apply_pattern</tt> construct</p>
+
+                  <p>Doing so, it is possible to specify custmization
+                  values for user defined template parameters</p>
+
+                  <cmt:cmtcode>
+pattern TA macro &lt;base&gt;AAA "AAA"
+
+apply_pattern TA base=abc
+apply_pattern TA base=def</cmt:cmtcode>
+
+                  <p>In the <tt>apply_pattern</tt> syntax, it is even
+                  possible to simply <i>ommit</i> the keyword itself,
+                  and thus using the pattern name as a plain CMT
+                  keyword. The previous example becomes: </p>
+
+                  <cmt:cmtcode>
+TA base=abc
+TA base=def</cmt:cmtcode>
+
+                  <p>This can be seen as a way to <i>extend</i> the
+                  CMT language. Notice that there is a risk of a
+                  conflict between the primary CMT keywords and
+                  pattern names then. Suppose that a pattern name is
+                  defined to be exactly a primary CMT keyword. In this
+                  case, the syntax parser will always understand this
+                  name as the CMT primary keyword, and thus won't
+                  override the original syntax. When this (not
+                  recommended) situation occurs, it is therefore
+                  required to use the full notation with an explicit
+                  <tt>apply_pattern</tt> keyword, so as to avoid any
+                  possible ambiguity.</p>
+
+                </li>
+
+                <li><i>Global patterns</i> (ie when the <tt>-global</tt> qualifier is used
+
+                  <p>In this case, the pattern is automatically applied
+                  to <i>all</i> packages that effectively see the
+                  pattern definition, which includes all clients of
+                  the package defining the pattern.</p>
+
+                  <p>Another consequence of the automatic application
+                  of the pattern, is that it is not possible to give
+                  values to parameters. Therefore it is not
+                  recommended to design global patterns with user
+                  defined parameters.</p>
+
+                  <p>Conversely it is possible to inhibit the
+                  automatic application of a global pattern in a
+                  particular package by using the following
+                  statement:</p>
+
+                  <cmt:cmtcode>
+ignore_pattern &lt;name&gt;</cmt:cmtcode>
+
+                </li>
+
+              </ol>
+
+            </cmt:section>
+
+          </cmt:section> 
+
+          <cmt:section title="cmtpath_patterns">
+
+	    <p>These patterns act quite similarly to the <i>global</i>
+	    patterns previously described, ie they defines a set of
+	    CMT statements to be applied in a generic way. The
+	    difference is that instead of being applied to
+	    <i>packages</i>, they are automatically applied to all
+	    entries in the <tt>CMTPATH</tt> list.</p>
+
+	    <p>Only few system parameters can be used here:
+
+              <ul>
+
+                <li><tt>&lt;path&gt;</tt> which stands for any entry
+                in the CMTPATH list.</li>
+
+                <li><tt>&lt;project&gt;</tt> which stands for the
+                project name associated with an entry in the CMTPATH
+                list.</li>
+
+              </ul>
+
+            </p>
+
+	    <p>As an example suppose we define</p>
+
+	    <cmt:cmtcode>
+path        CMTPATH "/ProjectA"
+path_append CMTPATH "/ProjectB"
+
+cmtpath_pattern \
+  macro_prepend pp_cppflags " -I&lt;path&gt;/InstallArea/include "</cmt:cmtcode>
+
+	    <p>this will assemble one <tt>-I</tt> option (towards the
+	    preprocessor) per entry in CMTPATH, implementing a
+	    mechanism for a multiple installation area for header
+	    files. In the example above the resulting macro will
+	    be</p>
+
+	    <cmt:code>
+ -I/ProjectA/InstallArea/include -I/ProjectB/InstallArea/include </cmt:code>
+
+	    <p>
+	    This can be combined with the standard and 
+	    <a href="#Generated macros">automatic macros</a>
+	    (automatically setup for all used packages)
+
+	    <cmt:cmtcode>
+&lt;package&gt;_cmtpath
+&lt;package&gt;_offset</cmt:cmtcode>
+
+	    which provide the CMTPATH entry and the directory offset
+	    in this CMTPATH for all used packages.
+
+	    </p>
+
+          </cmt:section>
+
+          <cmt:section title="branches">
+
+            <p>Describe the specific directory branches to be added while
+              configuring the package.</p>
+
+	    <cmt:cmtcode>
+branches &lt;branch-name&gt; ... </cmt:cmtcode>
+
+            <p> These branches will be created (if needed) at the same
+              level as the <tt>cmt</tt> branch. Typical examples of such
+              required branches may be <tt>include</tt>, <tt>test</tt> or
+              <tt>data</tt>.</p>
+
+          </cmt:section> 
+
+           <cmt:section title="Strategy specifications">
+ 
+            <p>Users can control the behaviour of <tt>CMT</tt> through a
+            set of strategy specifications. The current implementation
+            provides such control over several aspects :</p>
+ 
+            <ol>
+
+              <li>
+
+	        <p>The build strategy</p>
+
+                <p>This controls some aspects of the building
+                process. </p>
+
+                <p>The following keywords are available:</p>
+
+                <p>
+                  <center>
+                    <table BORDER='1' cellspacing='0' COLS='2'> 
+                      <tr> 
+                        <td width="80"><tt>prototypes</tt></td> 
+
+                        <td width="500">C source files will
+                        automatically produce a header file containing
+                        a prototype of all global entry points</td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>no_prototypes</tt></td> 
+
+                        <td width="500">No production of automatic
+                        prototype header files for C sources</td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>with_installarea</tt></td> 
+
+                        <td width="500">The installation area
+                        mechanisms are activated. This implies
+                        applying the cmtpath_patterns that may be
+                        defined (eg in CMT itself)</td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>without_installarea</tt></td> 
+
+                        <td width="500">The installation area
+                        mechanisms are inhibited</td>
+
+                      </tr> 
+
+                    </table>
+                  </center>
+                </p>
+
+              </li>
+
+              <li>
+	        <p>The setup strategy</p>
+
+		<p>This controls various actions that may be performed
+		during the sourcing of the setup scripts.</p>
+
+                <p>The following keywords are available:</p>
+
+                <p>
+                  <center>
+                    <table BORDER='1' cellspacing='0' COLS='2'> 
+
+                      <tr> 
+                        <td width="80"><tt>config</tt></td> 
+
+                        <td width="500">An environment variable
+                        &lt;PACKAGE&gt;CONFIG will be generated for all
+                        packages in the dependency chain</td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>no_config</tt></td> 
+
+                        <td width="500">The &lt;PACKAGE&gt;CONFIG
+                        environment variable is not generated </td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>root</tt></td> 
+
+                        <td width="500">An environment variable
+                        &lt;PACKAGE&gt;ROOT will be generated for all
+                        packages in the dependency chain</td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>no_root</tt></td> 
+
+                        <td width="500">The &lt;PACKAGE&gt;ROOT
+                        environment variable is not generated </td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>cleanup</tt></td> 
+
+                        <td width="500">The automatic cleanup
+                        operation to the current installation
+                        area is launched</td>
+
+                      </tr> 
+
+                      <tr> 
+                        <td width="80"><tt>no_cleanup</tt></td> 
+
+                        <td width="500">The automatic cleanup
+                        operation to the current installation
+                        area is not launched</td>
+
+                      </tr> 
+
+                    </table>
+                  </center>
+                </p>
+
+	      </li>
+
+            </ol>
+
+            <p>The strategy specifications are setup on a per-project
+            basis. This means that they are generally applicable to
+            all packages of a given sub-project, and can be oerridden
+            in other sub-projecs of the same software base.</p>
+
+            <p>Every strategy setting defines two mutually exclusive
+            tags and activates one of them.</p>
+
+              <cmt:cmtcode>
+&lt;project&gt;_&lt;have_item&gt; 
+&lt;project&gt;_&lt;have_not_item&gt; </cmt:cmtcode>
+
+            Examples 
+
+            <cmt:cmtcode>
+&lt;project&gt;_prototypes
+&lt;project&gt;_no_prototypes
+&lt;project&gt;_with_install_area
+&lt;project&gt;_without_install_area
+&lt;project&gt;_config
+&lt;project&gt;_no_config
+&lt;project&gt;_root
+&lt;project&gt;_no_root
+&lt;project&gt;_cleanup
+&lt;project&gt;_no_cleanup</cmt:cmtcode>
+
+          </cmt:section> 
+
+          <cmt:section title="setup_script, cleanup_script">
+
+            <p>Specify user defined configuration scripts, which will be
+              activated together with the execution of the main
+              <tt>setup</tt> and <tt>cleanup</tt> scripts.</p>
+
+            <p> The script names may be specified without any access path
+              specification, in this case, they are looked for in the
+              <tt>cmt</tt> or <tt>mgr</tt> branch of the package
+              itself. They may also be specified without any <tt>.csh</tt>
+              or <tt>.sh</tt> suffix, the appropriate suffix will be
+              appended accordingly when needed. Therefore, when such a user
+              configuration script is specified, <tt>CMT</tt> expects that
+              the corresponding shell scripts actually exist in the
+              appropriate directory (the <tt>cmt</tt> branch by default) and
+              is provided in whatever format is appropriate (thus suffixed
+              by <tt>.csh</tt> and/or <tt>.sh</tt>).</p>
+
+          </cmt:section> 
+
+          <cmt:section title="include_path">
+
+            <p>Override the specification for the default include search
+              path, which is internally set to<br />
+              <tt>${&lt;<i>package</i>&gt;_root}/src</tt>.</p>
+
+            <p>Specifying the value <tt><i>none</i></tt> (a reserved
+            CMT keyword) means that no default include search path is
+            expected from CMT, and thus no <tt>-I</tt> compiler option
+            will be generated by default (generally this means that
+            user include search paths should be specified via explicit
+            <tt>include_dirs</tt> instead).</p>
+
+            <blockquote><i>
+              <p>Note that this behaviour is expected to become
+              obsolete in some next release of CMT. The default
+              include search path of <tt>../src</tt> will then simply
+              disappear, and the <tt>include_path</tt> statement will
+              become meaningless. When this happens, include search
+              paths will always have to be explicitly specified using the
+              <tt>include_dirs</tt> statement. In order to anticipate
+              this evolution, it is suggested to always use
+              <tt>include_path none</tt> and add all include search
+              directories using the <tt>include_dirs</tt>
+              statement.</p>
+            </i></blockquote>
+
+          </cmt:section> 
+
+          <cmt:section title="include_dirs">
+
+            <p>Add explicit specifications for include access
+            paths. The value may be provided through a macro
+            reference.</p>
+
+            <p>The statement is sensitive to private scoping.</p>
+
+          </cmt:section> 
+
+          <cmt:section title="make_fragment">
+
+            <p>This statement specifies a specialized makefile fragment,
+              used as a building brick to construct the final makefile
+              fragment dedicated to build the constituents.</p>
+
+            <p>There are basically three categories of such fragments :
+              <ol>
+                <li>some are provided by <tt>CMT</tt> itself (they
+                  correspond to its        internal behaviour)</li> 
+                <li>others handle the language support</li>
+                <li>and the        last serve as specialized document generators.</li>
+              </ol>
+            </p>
+
+            <p>The fragments defined in <tt>CMT</tt> can be:</p>
+
+            <ul>
+
+              <li> those used to construct the application or library
+                constituents. Their semantic is 
+                standardized (they are all associated with a
+                <tt>language</tt> statement in the CMT requirements
+                file).
+
+                <cmt:blockquote>
+                  <i>
+                    c c_library cpp cpp_library lex lex_library fortran
+                    fortran_library yacc yacc_library jar jar_header
+                    java java_copy java_header check_java cleanup_java
+                  </i>
+                </cmt:blockquote>
+
+              </li>
+
+              <li> those used internally by CMT as primary building
+                blocks for assembling the makefile. (Generally developers
+                should not see them). 
+
+                <cmt:blockquote>
+                  <i>
+                    cleanup_objects application
+                    constituent application_header constituents_header
+                    buildproto protos_header os9_header dependencies
+                    check_application dependencies_and_triggers
+                    check_application_header document_header library
+                    cleanup library_header cleanup_application
+                    library_no_share cleanup_header make_header
+                    cleanup_library
+                  </i>
+                </cmt:blockquote>
+
+              </li>
+
+              <li> some document generators which <i>may</i> be used if
+                needed, but are not mandatory:
+                <cmt:blockquote>
+                  <i>
+                    installer installer_header readme readme_header
+                    readme_trailer readme_use dvi tex generator
+                    generator_header
+                  </i>
+                </cmt:blockquote>
+
+              </li>
+
+              <li> those used to generate configuration files for MSVisualC++:
+                <cmt:blockquote>
+                  <i>
+                    dsp_windows_header dsw_all_project
+                    dsw_all_project_dependency dsw_all_project_header
+                    dsw_all_project_trailer dsw_header dsw_project
+                    dsw_trailer dsp_all dsp_application_header
+                    dsp_contents dsp_library_header
+                    dsp_shared_library_header dsp_trailer
+                  </i>
+                </cmt:blockquote>
+
+              </li>
+
+            </ul>
+
+            <p>Language fragments should provide two forms, one for the
+              applications (in which case they are named exactly after the
+              language name eg c, cpp, fortran) and the other for the
+              libraries (in which case they have the <tt>_library</tt>
+              suffix (eg. c_library, cpp_library, fortran_library). A set
+              of language definitions (C, C++, Fortran, Java, Lex, Yacc)
+              is provided by CMT itself but it is expected that projects
+              add new languages according to their needs. Event if the
+              make fragment meant to be the implementation of a language
+              support is declared, the language support itself must be
+              declared too, using the <tt>language statement</tt> </p>
+
+            <p>All make fragments are provided as (suffixless) files
+              which must be located in the <tt>fragments</tt>
+              sub-directory inside the cmt/mgr branch of one
+              package. They must also be declared in the requirements
+              file (through the <tt>make_fragment</tt> statement) so as to
+              be visible.</p>
+
+            <p>A package declaring, and implementing a make fragment may
+              override a fragment of the same name when it is already
+              declared by a used package. This implies in particular that
+              any package <tt>may</tt> freely override any make fragment
+              provided by <tt>CMT</tt> itself (although in this case a deep
+              understanding of what the original fragment does is
+              recommended).</p>
+
+            <p>Makefile fragments may take any form convenient to the
+              document style, and some special pre-built templates (see
+              the <A HREF="#Standard templates for makefile
+                     fragments">appendix</A>) can be used in their body to
+              represent running values, meant to be
+              properly expanded at actual generation time :</p>
+
+            <p><table BORDER='1' cellspacing='0' COLS='2'> 
+                 <tr> 
+                   <td width="150"><tt>CONSTITUENT</tt></td> 
+                   <td width="400">the constituent name</td> 
+                 </tr> 
+                 <tr> 
+                   <td><tt>FULLNAME</tt></td> 
+                   <td>the full source path</td> 
+                 </tr> 
+                 <tr> 
+                   <td><tt>FILENAME</tt></td> 
+                   <td>the source file name without its path</td> 
+                 </tr> 
+                 <tr> 
+                   <td><tt>NAME</tt></td> 
+                   <td>the source file name without its path and suffix</td> 
+                 </tr> 
+                 <tr> 
+                   <td><tt>FILESUFFIX</tt></td> 
+                   <td>the dotted file suffix</td> 
+                 </tr> 
+                 <tr> 
+                   <td><tt>FILEPATH</tt></td> 
+                   <td>the output path</td> 
+                 </tr> 
+                 <tr> 
+                   <td><tt>SUFFIX</tt></td> 
+                   <td>the default suffix for output files</td> 
+                 </tr> 
+               </table>
+            </p>
+
+          </cmt:section>
+
+          <cmt:section title="public, private">
+
+            <p>The <tt>public</tt> or <tt>private</tt> keywords
+            introduce sections containing <i>public</i> or
+            <i>private</i> statements. This concerns:</p>
+
+            <ul>
+
+              <li>the definition of symbols</li>
+
+              <li>the specification of use relationships</li>
+
+              <li>the declaration of make fragments</li>
+
+              <li>the declaration of patterns</li>
+
+              <li>the declaration of include search paths (via the
+              <tt>include_dirs</tt> statement)</li>
+
+            </ul>
+
+	    <p>Public definitions are meant to be exported to any
+	    client of the package whereas private ones are only
+	    available for the package <i>developper</i> ie. when the
+	    current directory is within the package itself.</p>
+
+	    <p>Public use relationships expose the complete sub-tree
+	    to the package clients, whereas private ones entirely hide
+	    the sub-tree, expanding it only when the operator really
+	    acts from within the context of the package. It should be
+	    noticed that private use relationships are completely
+	    unvisible from clients, which implies that none of the
+	    definitions (not only symbols) will be set.</p>
+
+	    <p>However, the <tt>cmt broadcast</tt> and <tt>cmt show
+	    uses</tt> commands are configured to always ignore the
+	    private specification and therefore will always traverse
+	    the sub-trees whether they are public or private (in order
+	    to ensure the hierarchy dependencies)</p>
+
+            <cmt:section title="Scoping sections">
+
+              By using the <tt>public</tt> or <tt>private</tt> keywords,
+              one defines <i>scoping</i> sections. This sections
+              continues until:
+
+              <ul>
+
+                <li>another scoping statement is found, which simply
+                switch to this new mode <p></p></li>
+
+                <li>an <tt>end_private</tt> or <tt>end_public</tt>
+                keyword is found, in which case the scoping mode is
+                reset to the state prior to the previous matching
+                <tt>private</tt> or <tt>public</tt> statement. This
+                latter mechanisms permits in particular to define
+                autonomous scoping sections within <a
+                href="#patterns"><tt>pattern</tt>s</a>.  <p></p></li>
+
+              </ul>
+
+              <p>By default <tt>cmt</tt> commands operate according to
+              the scoping specifications found in the requirements
+              files of the reachable packages. Ie. in the current
+              package all statements are considered whether being
+              prublic or private, while in used packages, only public
+              statements are considered.</p>
+
+              <p>This standard behaviour though is not applied when
+              running <tt>cmt broadcast</tt> or <tt>cmt show
+              uses</tt>, and in this case all statements public or
+              private, are always considered, even in used
+              packages.</p>
+
+              <p>However it is always possible to override the default
+              behaviours by using the <tt>-private</tt> or
+              <tt>-public</tt> modifier to the <tt>cmt</tt>
+              command:</p>
+
+              <ul>
+
+                <li><tt>-private</tt><p>Force the command to consider
+                all definitions even those installed in private
+                sections</p><p></p></li>
+
+                <li><tt>-public</tt><p>Force the command to really
+                mask the private sections</p><p></p></li>
+
+              </ul>
+
+            </cmt:section>
+
+          </cmt:section>
+
+          <cmt:section title="tag, apply_tag">
+
+            <p>The <tt>tag</tt> keyword provides tag definitions,
+            while the <tt>apply_tag</tt> keyword <i>activates</i> a tag.</p>
+
+            <p> A tag is a token which can be used to select
+            particular values of symbols.</p>
+
+            <p> Some tags are automatically constructed by CMT
+            according to its knowledge of the context (see this <a
+            href="#Selecting a specific configuration">section</a> for
+            more details), but they may be also defined within a <a
+            HREF="#The requirements file">requirements</a> file as
+            follows :</p>
+
+<cmt:cmtcode>
+tag Foo                [1]
+tag Bar Foo FooA FooB  [2]
+apply_tag Bar          [3]</cmt:cmtcode>
+
+            <ol>
+
+              <li>This simply declares a tag. This does not
+              activate it by default<p></p></li>
+
+              <li>This construct declares that the tags <tt>Foo</tt>,
+              <tt>FooA</tt> and <tt>FooB</tt> will become active if
+              <tt>Bar</tt> becomes active. Note that this statement
+              implicitly <i>declares</i> <tt>FooA</tt> and
+              <tt>FooB</tt><p></p></li>
+
+              <li>This activates the <tt>Bar</tt> tag. Tags that have
+              been associated with it (in [2]), will all become active
+              as well.<p></p></li>
+
+            </ol>
+
+            <p>Running the setup script (through the <i>source
+            setup.[c]sh</i> or <i>call setup.bat</i> command ) can
+            also receive tag specifications using the
+            <i>-tag=tag-list</i> options.</p>
+
+          </cmt:section>
+
+        </cmt:section>
+
+        <cmt:section title="The general cmt user interface">
+
+          This utility (a shell script combined with a <tt>C++</tt> 
+          application) provides a centralised access to various commands 
+          to the <tt>CMT</tt> system. The first way to use <tt>cmt</tt> is 
+          to run it without argument, this will print a minimal help text 
+          showing the basic commands and their syntax : 
+
+<cmt:code>
+&amp;gt; cmt command [option...]
+<i><font face="courier new, courier" COLOR="#000077"> command :
+   none
+   awk
+   broadcast [-select=list] [-exclude=list] [-local] [-global] [-begin=pattern] [-depth=n] &amp;lt;command&gt; : 
+        apply a command to [some of] the used packages
+   build &amp;lt;option&gt;          : build actions. (Try cmt help build)
+   build constituent_makefile &amp;lt;constituent&gt;  : generate constituent Makefile fragment
+   build constituents_makefile : generate constituents.make
+   build dependencies      : generate dependencies
+   build library_links     : build symbolic links towards all imported libraries
+   build make_setup        : build a compiled version of setup scripts
+   build msdev             : generate MSDEV files
+   build CMT_pacman        : generate PACMAN manifest file for CMT
+   build vsnet             : generate VS.NET files
+   build os9_makefile      : generate Makefile for OS9
+   build prototype         : generate prototype file
+   build readme            : generate README.html
+   build tag_makefile      : generate tag specific Makefile
+   build temporary_name    : generate a name for a temprary file
+   build triggers &amp;lt;constituent&gt; : generate library trigger file
+   build windefs &amp;lt;library_name&gt; : generate def file for Windows shared libraries
+   check &amp;lt;option&gt;          : check actions. (Try cmt help check)
+   check configuration     : check configuration
+   check files &amp;lt;old&gt; &lt;new&gt; : compare two files and overrides &lt;old&gt; by &lt;new&gt; if different
+   check version &amp;lt;name&gt;    : check if a name follows a version tag syntax 
+   co | checkout           : perform a cvs checkout over a CMT package
+   cleanup [-csh|-sh|-bat] : generate a cleanup script
+   config                  : generate setup and cleanup scripts
+   create &amp;lt;package&gt; &lt;version&gt; [&lt;path&gt;] : create and configure a new package
+   create_project &amp;lt;project&gt; &lt;name&gt; [&lt;path&gt;] : create and configure a new project
+   cvsbranches &amp;lt;module&gt;      : display the subdirectories for a module
+   cvssubpackages &amp;lt;module&gt;  : display the subpackages for a module
+   cvssubprojects &amp;lt;module&gt;  : display the subprojects for a module
+   cvstags &amp;lt;module&gt;          : display the CVS tags for a module
+   do &amp;lt;action&gt; [&lt;param&gt;=&lt;value&gt;] ... : Execute an action
+   expand model &amp;lt;model&gt;    : 
+   filter &amp;lt;in&gt; &lt;out&gt;       : filter a file against CMT macros and env. variables
+   help | -help | --help   : display this help
+   load
+   lock [&amp;lt;p&gt; &lt;v&gt; [&lt;path&gt;]] : lock a package
+   relocate                  : generate setup and cleanup scripts (without makefiles)
+   remove &amp;lt;package&gt; &lt;version&gt; [&lt;path&gt;] : remove a package version
+   remove library_links    : remove symbolic links towards all imported libraries
+   run '&amp;lt;command&gt;'         : apply a command
+   run_sequence &amp;lt;sequence file&gt; : execute a cmt equence file
+   set version &amp;lt;version&gt;   : generate a version file in the current package
+   set versions            : generate version files into packages
+   setup [-csh|-sh|-bat]   : generate a setup script
+   show &amp;lt;option&gt;           : query actions. (Try cmt help show)
+   show  action &amp;lt;name&gt;     :  a formatted action definition
+   show  action_value &amp;lt;name&gt; :  a raw action definition
+   show  action_names      :  all action names
+   show  actions           :  all action definitions
+   show  all_tags          :  all defined tags
+   show  applied_patterns  :  all patterns actually applied
+   show  author            :  package author
+   show  branches          :  added branches
+   show  clients           :  package clients
+   show  cmtpath_patterns  :  cmtpath_patterns
+   show  constituent &amp;lt;name&gt;:  constituent definition
+   show  constituent_names :  constituent names
+   show  constituents      :  constituent definitions
+   show  cycles            :  cycles in the use graph
+   show  fragment &amp;lt;name&gt;   :  one fragment definition
+   show  fragments         :  fragment definitions
+   show  groups            :  group definitions
+   show  include_dirs      :  
+   show  language &amp;lt;name&gt;   :  language definition
+   show  languages         :  language definitions
+   show  macro &amp;lt;name&gt;      :  a formatted macro definition
+   show  macro_value &amp;lt;name&gt;  :  a raw macro definition
+   show  macro_names       :  all macro names
+   show  macros            :  all macro definitions
+   show  manager           :  package manager
+   show  packages          :  packages reachable from the current context
+   show  path              :  the package search list
+   show  pattern &amp;lt;name&gt;    :  the pattern definition and usages
+   show  pattern_names     :  pattern names
+   show  patterns          :  the pattern definitions
+   show  projects          :  project definitions
+   show  setup             :  setup definitions
+   show  pwd               :  filtered current directory
+   show  set &amp;lt;name&gt;        :  a formatted set definition
+   show  set_names         :  set names
+   show  set_value &amp;lt;name&gt;  :  a raw set definition
+   show  sets              :  set definitions
+   show  strategies        :  all strategies (build &amp; version)
+   show  tags              :  all currently active tags
+   show  use_paths &amp;lt;pack&gt;  :  all paths to the used package
+   show  uses              :  used packages
+   show  version           :  version of the current package
+   show  versions &amp;lt;name&gt;   :  visible versions of the selected package
+   system                  : display the system tag
+   unlock [&amp;lt;p&gt; &lt;v&gt; [&lt;path&gt;]] : unlock a package
+   version                 : version of CMT
+ global options :
+   -quiet                  : don't print errors
+   -use=&amp;lt;p&gt;:&lt;v&gt;:&lt;path&gt;     : set package version path
+   -pack=&amp;lt;package&gt;         : set package
+   -version=&amp;lt;version&gt;      : set version
+   -path=&amp;lt;path&gt;            : set root path
+   -f=&amp;lt;requirement-file&gt;   : set input file
+   -e=&amp;lt;statement&gt;          : add a one line statement
+   -tag=&amp;lt;tag-list&gt;         : select a new tag-set
+   -tag_add=&amp;lt;tag-list&gt;     : add specific comma-separated tag(s)
+   -tag_remove=&amp;lt;tag-list&gt;  : remove specific comma-separated tag(s)
+   -warnings               : display various warnings
+   -with_version_directory : reset to default structuring style
+   -without_version_directory : switch structuring style</font></i></cmt:code>
+
+<!--
+   -cleanup                : activate install area cleanup
+   -no_cleanup             : inhibit install area cleanup
+-->
+
+          <p>The following sections present the detail of each available command. </p>
+
+
+          <cmt:section title="Global options of the cmt command">
+
+            <p>These options of the general form
+            <tt>-&lt;option&gt;</tt> or
+            <tt>-&lt;option&gt;=&lt;value&gt;</tt> should be provided
+            <i>before</i> the command itself. They give special hints
+            to cmt onto how to perform the command.</p>
+
+            <p>Some options have meaning over all commands (such as
+            the <tt>-quiet</tt> option) while some others only have a
+            meaning in the context of some specialized commands (such
+            as the <tt>-with_version_directory</tt> option which is
+            only useful for the <tt>create</tt> or <tt>co</tt>
+            commands)</p>
+
+            <p>The following table describes the various global
+            options of the <tt>cmt</tt> tool:</p>
+
+            <table BORDER='1' cellspacing='0' COLS='3'>
+
+              <tr>
+                <td><center><i>option</i></center></td>
+                <td><center><i>effect</i></center></td>
+                <td><center><i>commands</i></center></td>
+              </tr>
+
+              <tr>
+                <td><tt>-quiet</tt></td>
+                <td>don't print errors</td>
+                <td><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-use=&amp;lt;p&gt;:&lt;v&gt;:&lt;path&gt;</tt></td>
+                <td>set current package version and path in one option</td>
+                <td><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-pack=&amp;lt;package&gt;</tt></td>
+                <td rowspan='3'>set current package, version and root path</td>
+                <td rowspan='3'><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-version=&amp;lt;version&gt;</tt></td>
+              </tr>
+              <tr>
+                <td><tt>-path=&amp;lt;path&gt;</tt></td>
+              </tr>
+              <tr>
+                <td><tt>-f=&amp;lt;requirement-file&gt;</tt></td>
+                <td>override input file</td>
+                <td><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-e=&amp;lt;statement&gt;</tt></td>
+                <td>add a one line statement</td>
+                <td><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-tag=&amp;lt;tag-list&gt;</tt></td>
+                <td>select a new tag-set</td>
+                <td><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-tag_add=&amp;lt;tag-list&gt;</tt></td>
+                <td>add specific comma-separated tag(s)</td>
+                <td><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-tag_remove=&amp;lt;tag-list&gt;</tt></td>
+                <td>remove specific comma-separated tag(s)</td>
+                <td><i>all</i></td>
+              </tr>
+              <tr>
+                <td><tt>-warnings</tt></td>
+                <td>displays various warnings, such as invalid PATH items</td>
+                <td><table><tr><td><tt>broadcast</tt></td></tr><tr><td><tt>run</tt></td></tr><tr><td><tt>setup</tt></td></tr></table></td>
+              </tr>
+              <tr>
+                <td><tt>-with_version_directory</tt></td>
+                <td>reset to default structuring style</td>
+                <td><table><tr><td><tt>create</tt></td></tr><tr><td><tt>co</tt></td></tr></table></td>
+              </tr>
+              <tr>
+                <td><tt>-without_version_directory</tt></td>
+                <td>switch structuring style</td>
+                <td><table><tr><td><tt>create</tt></td></tr><tr><td><tt>co</tt></td></tr></table></td>
+              </tr>
+              <!--
+              <tr>
+                <td><tt>-cleanup</tt></td>
+                <td>activate install area cleanup</td>
+                <td><tt>setup</tt></td>
+              </tr>
+              <tr>
+                <td><tt>-no_cleanup</tt></td>
+                <td>inhibit install area cleanup</td>
+                <td><tt>setup</tt></td>
+              </tr>
+              -->
+            </table>
+
+          </cmt:section>
+
+          <cmt:section title="cmt broadcast">
+
+            This command tries to repeatedly execute a shell command in the 
+            context of each of the used package of the current package. The 
+            used packages are listed using the <tt>cmt show uses</tt> 
+            command, which also indicates in which order the broadcast is 
+            performed. When the <tt>all_packages</tt> option, the set of
+            packages reached by the broadcast is rather the same as the one shown
+            by the <tt>cmt show packages</tt> command, ie all <tt>CMT</tt> packages
+            and versions available through the current <tt>CMTPATH</tt> list.
+
+            <p>Typical uses of this <i>broadcast</i> operation could be:</p>
+
+<cmt:code>
+csh&gt; cmt broadcast cmt config
+csh&gt; cmt broadcast - gmake 
+csh&gt; cmt broadcast '(cd ../; cvs -n update)' </cmt:code>
+
+            <p>The loop over used packages will stop at the first error
+              occurence in the application of the command, except if the
+              command was preceded by a '-' (minus) sign (similarly to the
+              make convention).</p>
+
+            <p>It is possible to specify a list of selection or
+              exclusion criteria set onto the package path, using the
+              following options, right after the <tt>broadcast</tt>
+              keyword. These selection criteria may be combined (eg one
+              may combine the <i>begin</i> and <i>select</i>
+              modifiers)</p>
+
+<cmt:code>
+sh&gt; cmt broadcast -begin=Cm gmake                 (1)
+sh&gt; cmt broadcast -select=Cm gmake                (2)
+sh&gt; cmt broadcast -select='/Cm/ /CSet/' gmake     (3)
+sh&gt; cmt broadcast -select=Cm -exclude=Cmo gmake   (4)
+sh&gt; cmt broadcast -local gmake                    (5)
+sh&gt; cmt broadcast -depth=&lt;n&gt; gmake                (6)
+sh&gt; cmt broadcast -global gmake                   (7)
+sh&gt; cmt broadcast -all_packages gmake             (8)</cmt:code>
+
+            <p>According to the option, the loop will only operate onto:</p>
+
+            <ol>
+              <li>the first package which path contains the string
+              <tt>"Cm"</tt>, and then all other reachable packages (in
+              case other specifiers are used)</li>
+
+              <li>the packages which path contains the string <tt>"Cm"</tt></li>
+
+              <li>the packages which path contains either the string
+              <tt>"/Cm/"</tt> or the string <tt>"/CSet/"</tt></li>
+
+              <li>the packages which path contains the string <tt>"Cm"</tt>,
+              but which does not contain the string <tt>"Cmo"</tt></li>
+
+              <li>the packages at the same level as the current package</li>
+
+              <li>the packages at the same level as the current package or
+              among the &lt;n&gt; first entries in the <tt>CMTPATH</tt> list</li>
+
+              <li>the packages at any level of the CMTPATH search list</li>
+
+              <li>all the packages and versions currently available
+              through the <tt>CMTPATH</tt> list</li>
+            </ol>
+
+            <p>The environment variables as specified in the
+            requirements files of the use graph are internally pre-set
+            before running the specified shell command. Thus it's not
+            required to <i>source</i> the setup scripts before using
+            the <tt>broadcast</tt> command
+            </p>
+
+	    <cmt:section title="Specifying the shell command">
+
+	    <p>A priori any Unix or DOS shell command can be specified
+	    in a boadcast command. However, it's important to
+	    understand the order of the various parsing actions:</p>
+
+	    <ol>
+	      <li>The current shell first parses the complete command line</li>
+	      <li>CMT catches all possible options given to the broadcast command itself</li>
+	      <li>CMT then gets the rest of the command line and makes it the shell command to be executed during the broadcast scan.</li>
+	      <li>This command line may be subject to template substitution (see below) by CMT</li>
+	      <li>Eventually the command line is passed to the local shell (which may then perform additional parsing actions)</li>
+	    </ol>
+
+	    <p>Considering this complex sequence of parsing, it may be
+	    appropriate to selectively enclose the shell command
+	    passed to the broadcast action into quotes. It may even be
+	    sometimes useful to have two levels of quotes</p>
+
+	    </cmt:section>
+
+	    <cmt:section title="Templates in the shell command">
+
+	    <p>Similarly to what exists in the <a
+	    href="#patterns">pattern</a> mechanism, some standard
+	    <i>templated</i> values can be embedded inside the
+	    command to be executed by the broadcast action. They take
+	    a standard form of
+	    <i><tt>&lt;template-name&gt;</tt></i>. These templates acquire
+	    their value on each package effectively reached during the
+	    broadcast scan, and the effective value is substituted
+	    before launching the command. The possible templates are:</p>
+
+	    <table>
+
+	      <tr>
+	        <td><tt>&lt;package_cmtpath&gt;</tt></td>
+	        <td>The element in the CMTPATH search list where the package has been found</td>
+	      </tr>
+
+	      <tr>
+	        <td><tt>&lt;package_offset&gt;</tt></td>
+	        <td>The directory offset to cmtpath</td>
+	      </tr>
+
+	      <tr>
+	        <td><tt>&lt;package&gt;</tt></td>
+	        <td>The package name</td>
+	      </tr>
+
+	      <tr>
+	        <td><tt>&lt;version&gt;</tt></td>
+	        <td>The version of the package</td>
+	      </tr>
+
+	    </table>
+
+	    <p>The next example shows a typical broadcast command listing the
+	    header files as expected in the conventional location
+	    <tt>../&lt;package&gt;</tt> :</p>
+
+	    <cmt:code>
+&gt; cmt broadcast 'ls ../&lt;package&gt;'
+<i><font face="courier new, courier" COLOR="#000077">[...]
+#--------------------------------------------------------------
+# Now trying [ ls ../GenzModuleEvent] in /.../GenzModuleEvent/.../cmt (149/609)
+#--------------------------------------------------------------
+CVS  KineHepMcmap.h
+#--------------------------------------------------------------
+# Now trying [ ls ../Tauola_i] in /.../Tauola_i/.../cmt (150/609)
+#--------------------------------------------------------------
+CVS     Jaki.icc        Tauola_i.h    Taurad.h    config.h    rn_tau.h
+Jaki.h  ReadPDGtable.h  Tauola_i.icc  Taurad.icc  polhep.inc  tauola_cblk.inc
+#--------------------------------------------------------------
+# Now trying [ ls ../NavigationEvent] in /.../NavigationEvent/.../cmt (151/609)
+#--------------------------------------------------------------
+CVS  INavigable.h  INavigationCondition.h  INavigationSelector.h
+INavigationToken.h  NavigationToken.h
+[...]</font></i></cmt:code>
+
+	    <cmt:blockquote>
+	    One should note that when templates are used in a
+	    broadcast command, it's important to enclose the command
+	    in quotes so as to inhibit any possible parsing of the
+	    <tt>&lt; &gt;</tt> syntax by the shell.
+	    </cmt:blockquote>
+
+	    </cmt:section>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt build &lt;option&gt;">
+
+	    <p>The actions associated with the build options are
+            generally meant for internal use only, and users will
+            rarely (if ever!) apply them manually</p>
+
+	    <p>All build commands are generally meant to change the
+            current package (some file or set of files is
+            generated). Therefore a check against conflicting locks
+            (ie. a lock owned by another user) is performed by all
+            these commands prior to execute it.</p>
+
+            <ul> 
+              <li><tt>[-nmake] constituent_makefile &lt;<i>constituent-name</i>&gt;</tt> 
+ 
+                <p>This command is internally used by <tt>CMT</tt> in the standard 
+                  Makefile.header fragment. It generates a specific makefile 
+                  fragment (named &lt;<i>constituent-name</i>&gt;.make) 
+                  which is used to re-build this fragment. </p>
+
+                <p>All such constituent fragments are automatically 
+                  included from the main Makefile. </p>
+
+                <p>Although this command is meant to be used internally 
+                  (and transparently) by <tt>CMT</tt> when the make command is run, a 
+                  developer may find useful in very rare cases to manually 
+                  re-generate the constituent fragment, using this command.</p>
+
+                <p>The <tt>-nmake</tt> option (which must precede the
+                  command) provides exactly the same features but in a
+                  Windows/nmake context. In this case, all generated
+                  makefiles are suffixed by <tt>.nmake</tt> instead of
+                  <tt>.make</tt> for Unix environments. The main makefile is
+                  expected to be named <tt>NMake</tt> and the standard header
+                  is named <tt>NMakefile.header</tt></p>
+
+              </li> 
+
+              <li><tt>[-nmake] constituents_makefile</tt>
+
+                <p>This command is internally (and transparently) used by 
+                  <tt>CMT</tt> in the standard Makefile.header fragment, and when the 
+                  make command is run, to generate a specialized make 
+                  fragment containing all "cmt build constituent_makefile" 
+                  commands for a given package. </p>
+
+                <p>The <tt>-nmake</tt> option (which must precede the
+                  command) provides exactly the same feature but in a
+                  Windows/nmake context. In this case, all generated
+                  makefiles are suffixed by <tt>.nmake</tt> instead of
+                  <tt>.make</tt> for Unix environments. The main makefile is
+                  expected to be named <tt>NMake</tt> and the standard header
+                  is named <tt>NMakefile.header</tt></p>
+
+              </li>
+
+              <li><tt>dependencies</tt>
+
+                <p>This command is internally (and transparently) used by 
+                  <tt>CMT</tt> from the constituent specific fragment, and when the 
+                  make command is run, to generate a fragment containing the 
+                  dependencies required by a source file. </p>
+
+                <p>This fragment contains a set of macro definitions (one 
+                  per constituent source file), each containing the set of 
+                  found dependencies. </p>
+
+                <p>CMT is able to recursively compute the dependencies
+                implied by the <tt>include</tt> statements found in
+                the source files. However it's also possible to make
+                plain use of the standard mechanisms provided by some
+                standard tools like <tt>cpp -M</tt>. In this case, it
+                will be required to <i>format</i> the output produced
+                by the selected tool so as to let CMT parse it and
+                properly deduce the dependencies. Formatting the
+                output of external tools may require to interface the
+                tool itself e.g. using a shell script.</p>
+
+                <p>The standard CMT macro
+                <tt>$(build_dependencies)</tt> must be used to specify
+                an alternate dependency builder. The default value is:</p>
+
+                <cmt:code>$(cmtexe) -quiet -tag=$(tags) build dependencies</cmt:code>
+
+                <p>The expected output format from any dependency builder is as follows:</p>
+
+                <ul>
+                  <li>Each file corresponds to one single dependency line in the output</li>
+                  <li>A dependency line should be formatted as follows:
+                    <cmt:code>&lt;file-name&gt;_&lt;file_suffix&gt;_dependencies = &lt;source&gt; &lt;file&gt; ... </cmt:code>
+                    <p>Where:</p>
+                    <ul>
+                      <li><tt>&lt;file-name&gt;</tt> is given without the file suffix</li>
+                      <li><tt>&lt;file_suffix&gt;</tt> is given without the dot</li>
+                      <li><tt>&lt;source&gt;</tt> is the path to the source file</li>
+                      <li>the list of <tt>&lt;file&gt;</tt> paths corresponds to the effective list of dependent files. This is a list of reative or absolute file paths.</li>
+                    </ul>
+                  </li>
+                </ul>
+
+
+                <p>A Unix shell script in
+                <tt>${CMTROOT}/mgr/cmt_build_deps.sh</tt> is offered
+                as an example of how to interface the standard <tt>cpp
+                -M</tt> command with CMT. It can be declared as a
+                substitute to the internal mechanism as follows:</p>
+
+                <cmt:code>macro build_dependencies "${CMTROOT}/mgr/cmt_build_deps.sh"</cmt:code>
+
+                <p>Of course this shell script should be considered as
+                an example and might have to be adapted for other
+                dependency builders, or for Windows.</p>
+
+              </li> 
+
+              <li><tt>library_links</tt>
+
+                <p>This command builds a local symbolic link towards all
+                  exported libraries from the used packages. A package
+                  exports its libraries through the
+                  <tt>&lt;<i>package</i>&gt;_libraries</tt> macro which should
+                  contain the list of constituent names corresponding to
+                  libraries that must be exported.</p>
+
+<cmt:cmtcode>
+library Foo ...
+library Foo-utils ...
+...
+macro Foo_libraries "Foo Foo-utils"</cmt:cmtcode>
+
+                The corresponding <tt>cmt remove library_links</tt> command
+                will remove all these links.
+
+              </li>
+
+              <li><tt>msdev</tt> 
+
+                <p>This command generates workspace (.dsw) and project 
+                  (.dsp) files required for the MSDev tool. </p>
+
+              </li>
+
+              <li><tt>vsnet</tt> 
+
+                <p>This command generates workspace and project files
+                required for the Visual.net tool. </p>
+
+              </li>
+
+              <li><tt>os9_makefile</tt>
+
+                <p>This command generates external dedicated
+                  <i>makefile</i> fragments for each individual component of
+                  the package (ie. libraries or executable applications) to
+                  be used in OS9 context. It generates specific syntaxes for
+                  the <tt>OS9</tt> operating systems.</p>
+
+                <p>The output of this tool is a set of files (named with
+                  the components' name and suffixed by <tt>.os9make</tt>) that
+                  are meant to be <i>included</i> within the main
+                  <tt>Makefile</tt> that the developer has to write anyhow.</p>
+
+                <p>The syntax of the <tt>cmt build os9_makefile</tt> utility 
+                  is as follows : </p>
+
+<cmt:code>
+sh&gt; cmt build os9_makefile &lt;package&gt; </cmt:code>
+
+              </li>
+
+              <li><tt>prototype &lt;source-file-name&gt;</tt> 
+
+                <p>This command is internally (and transparently) used by 
+                  <tt>CMT</tt> from the constituent specific fragment, and when the 
+                  make command is run, to generate prototype header files 
+                  from C source files. </p>
+
+                <p>The prototype header files (named &lt;file-name&gt;.ph) 
+                  will contain prototype definitions for every global entry 
+                  point defined in the corresponding C source file. </p>
+
+                <p>The effective activation of this feature is controled 
+                  by the build strategy of <tt>CMT</tt>. The build strategy may be 
+                  freely and globally overridden from any &CMTrequirements; file, 
+                  using the <tt>build_strategy</tt> cmt statement, providing 
+                  either the "prototypes" or the "no_prototypes" values. </p>
+
+                <p>In addition, any constituent may locally override this 
+                  strategy using the "-prototypes" or "-no_prototypes" 
+                  modifiers. </p>
+
+              </li>
+
+              <li><tt>readme</tt> 
+
+                <p>This command generates a README.html file into the cmt 
+                  branch of the referenced package. This html file will 
+                  include  </p>
+
+                <ul> 
+
+                  <li>a table containing URLs to equivalent pages for 
+                    all used packages,  </li>
+
+                  <li>a copy of the local README file (if it exists). </li>
+
+                </ul> 
+
+              </li>
+
+              <li><tt>tag_makefile</tt> 
+
+                <p> This command produces onto the standard output, the
+                  exhaustive list of all macros controled by <tt>CMT</tt>,
+                  ie. those defined in the requirements files as well as the
+                  standard macros internally built by <tt>CMT</tt>, taking
+                  into account all used packages.</p>
+
+              </li>
+
+            </ul> 
+
+          </cmt:section> 
+
+          <cmt:section title="cmt check configuration">
+
+            This command reads the hierarchy of requirements files 
+            referenced by a package, check them, and signals syntax 
+            errors, version conflicts or other configuration problems. 
+
+            <p>An empty output means that everything is fine. </p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt check files &lt;reference-file&gt; &lt;new-file&gt;">
+
+            This command compares the reference file to the new file, and 
+            substitues the reference file by the new one if they are 
+            different. 
+
+            <p>If substitution is performed, a copy (with additional 
+              extension <tt>sav</tt>) is produced. </p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt checkout ...">
+
+            See the <a href="#Using cvs together with CMT">paragraph</a>
+            on how to use cvs together with <tt>CMT</tt>, and more specifically the
+            details on <a href="#Checking a package out from a cvs repository">checkout oprations</a>.
+
+          </cmt:section> 
+
+          <cmt:section title="cmt co ...">
+
+            This is simply a short cut to the <tt>cmt checkout</tt> command. 
+
+          </cmt:section> 
+
+          <cmt:section title="cmt cleanup [-csh|-sh]">
+
+            This command generates (to the standard output) a set of shell 
+            commands (either for csh or sh shell families) meant to unset 
+            all environment variables specified in the &CMTrequirements; files 
+            of the used packages. 
+
+            <p>This command is internally used in the cleanup.[c]sh shell 
+              script, itself generated by the <tt>cmt config</tt> command. </p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt config">
+
+            <p>This command (re-)generates the setup scripts and the
+              manimal Makefile (when it does not exist yet or have been lost).</p>
+
+<cmt:code>
+csh&gt; cd ~/Packages/Foo/v1/cmt 
+csh&gt; cmt config </cmt:code>
+
+            <p>To be properly operated, one must <i>already</i> be in
+              the <tt>cmt</tt> or <tt>mgr</tt> branch of a package (where the
+              &CMTrequirements; file can
+              be found).</p>
+
+            <p>This command also performs some cleanup operations
+              (eg. removing all makefile fragments previously
+              generated). Generally speaking, one may say that this
+              command restores the CMT-related files to their original state (ie
+              before any document generation) </p>
+
+            <p>The situations in which it is useful to run this command are:</p>
+
+            <ul>
+
+              <li>When the setup or cleanup scripts have been lost</li>
+
+              <li>When the minimal Makefile have been lost</li>
+
+              <li>When the version of <tt>CMT</tt> is changed</li>
+
+              <li>After restoring a package from CVS</li>
+
+              <li>After having manually changed the directory structure
+                of a package (using a manual copy operation, or renaming
+                one of its parent directory, such as the version
+                directory)</li>
+
+            </ul>
+
+            <p>It should be noted however that when using
+            <i>actions</i>, such as the one defined by default to
+            launch <tt>make</tt> tools neither <tt>cmt config</tt> nor
+            <tt>source setup</tt> are required any longer.</p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt create &lt;package&gt; &lt;version&gt; [&lt;area&gt;]">
+
+            <p>
+              This command creates a new package or a new version of a package</p>
+
+<cmt:code>
+csh&gt; cmt create Foo v1 </cmt:code>
+
+            or:
+
+<cmt:code>
+csh&gt; cmt create Foo v1 ~/dev</cmt:code>
+
+            <p>In the first mode (ie. without the <i>area</i> argument)
+              the package will be created in the default path.</p>
+
+            <p>The second mode explicitly provides an alternate path.</p>
+
+            <p>A minimal configuration is installed for this new package:</p>
+
+            <ul>
+
+              <li>A <tt>src</tt> and a <tt>cmt</tt> branch</li>
+
+              <li>A very minimal requirements file</li>
+
+              <li>The setup and cleanup shell scripts</li>
+
+              <li>The minimal Makefile</li>
+
+            </ul>
+
+            <p>A version directory may be created according to the
+            structuring style or structuring strategy parameters
+            specified using one of the following means:</p>
+
+            <ol>
+
+              <li>Through the environment variable
+              <tt>CMTSTRUCTURINGSTYLE</tt> taking one of the
+              alternate values:
+<cmt:code>
+with_version_directory
+without_version_directory</cmt:code>
+              <p></p></li>
+
+              <li>Through the command line options
+              <tt>-with_version_directory</tt> or
+              <tt>-without_version_directory</tt><p></p></li>
+
+              <li>Through the <tt>structure_strategy</tt> specification entered into the project file of the current project, using the alternate values:
+<cmt:code>
+with_version_directory
+without_version_directory</cmt:code>
+              <p></p></li>
+
+            </ol>
+
+            <p>It should be noted that the command line option will
+            take precedence over the strategy specification, in case
+            of conflict.</p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt expand model [-strict] &lt;model-string&gt;">
+
+            This command produces on the standard output an
+            <i>expansion</i> of the model string given in the
+            argument.
+
+            <p>The expansion consists in:</p>
+
+            <ul>
+
+              <li>Expanding macros referenced in the model string
+              using the standard notations <tt>$()</tt> or
+              <tt>${}</tt> or <tt>%%</tt>
+
+                <cmt:code>
+&gt; cmt expand model "abcd $(CMTVERSION) efgh"
+<i><font face="courier new, courier" COLOR="#000077">abcd &CMTVersion; efgh</font></i></cmt:code>
+              </li>
+
+              <li><i>Recursively</i> expanding text files with
+              parameters. The model string must then take a
+              conventional XML-based syntax:
+
+                <cmt:code>
+&gt; cmt expand model "<i>text</i> &lt;<i>file-name</i> <i>parameter</i>=<i>value</i> ... /&gt; <i>text</i> ..."</cmt:code>
+
+                or
+
+                <cmt:code>
+&gt; cmt expand model -strict "<i>text</i> &lt;cmts:<i>file-name</i> <i>parameter</i>='<i>value</i>' ... /&gt; <i>text</i> ..."</cmt:code>
+
+                or
+
+                <cmt:code>
+&gt; cmt expand model -strict "<i>text</i> &lt;cmtv:<i>file-name</i> <i>parameter</i>='<i>v1 v2 v3 ...</i>' ... /&gt; <i>text</i> ..."</cmt:code>
+
+                Where:
+
+                <ul>
+                  <li><i>file-name</i> is the name of a file declared
+                  using the <tt>make_fragment</tt> statement</li>
+
+                  <li><tt><i>parameter</i>=<i>value</i></tt> specifies
+                  the value of a parameter that will be substituted in
+                  the file when referenced using the
+                  <tt>$(<i>parameter</i>)</tt> notation. Several such
+                  values may be specified in one model string</li>
+
+                  <li>the <tt>-strict</tt> form is useful to handle
+                  XML files, and file names must be prefixed
+                  (<i>namespaced</i>) by a special keyword
+                  <tt>cmts:</tt> or <tt>cmtv:</tt> . 
+
+                  <table>
+                    <tr><td><tt>cmts:</tt></td><td>Perform a unique substitution over one copy of the file</td></tr>
+                    <tr><td><tt>cmtv:</tt></td><td>Perform a multiple substitution over N copies of the file, taking the N space-separated values specified for the parameters</td></tr>
+                  </table>
+
+                  </li>
+
+                </ul>
+
+                The following examples will explain some of the mechanisms.
+
+                <p>We consider <tt>A</tt> containing:</p>
+
+                <cmt:code>
+A$(P1)B$(P2)C</cmt:code>
+
+                <p>And <tt>B</tt> containing:</p>
+
+                <cmt:code>
+i&lt;cmts:A P1='j' P2='${P2}'/&gt;k</cmt:code>
+
+
+                <cmt:code>
+&gt; cmt expand model "abcd &lt;A P1=XXX/&gt; efgh"                                      [1]
+<i><font face="courier new, courier" COLOR="#000077">abcd AXXXBC efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmts:A P1='XXX' P2='YYY'/&gt; efgh"              [2]
+<i><font face="courier new, courier" COLOR="#000077">abcd AXXXBYYYC efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmts:A P1='XXX'/&gt; &lt;cmts:B P2='YYY'/&gt; efgh"    [3]
+<i><font face="courier new, courier" COLOR="#000077">abcd AXXXBC iAjBYYYCk efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmtv:A P1='X Y Z' P2='YYY'/&gt; efgh"            [4]
+<i><font face="courier new, courier" COLOR="#000077">abcd AXBYYYCAYBCAZBC efgh</font></i>
+&gt; cmt expand model -strict "abcd &lt;cmtv:A P1='X Y Z' P2='\"\" &lt;cmt:null/&gt; ZZZ'/&gt; efgh"  [5]
+<i><font face="courier new, courier" COLOR="#000077">abcd AXBCAYBCAZBZZZC efgh</font></i>
+...</cmt:code>
+
+                <ol>
+
+                  <li>A simple expansion using the non-strict model
+                  syntax. <tt>P1</tt> is substituted, but
+                  <tt>$(P2)</tt> becomes empty
+                  </li>
+
+                  <li> The same using the strict model. Here P2 is valued.
+                  </li>
+
+                  <li>A more complex model, using a recursive
+                  expansion described in <tt>B</tt> showing how
+                  parameter values are transmitted</li>
+
+                  <li>A model showing the multiple expansion. Here
+                  <tt>P1</tt> receives 3 values. <tt>P2</tt> has only
+                  one value. The largest vector (3 values) dictates
+                  the number of copies. smaller vectors are completed
+                  by empty values.</li>
+
+                  <li>A model showing the multiple expansion with
+                  empty values in a vector. Here <tt>P1</tt> receives
+                  3 values. <tt>P2</tt> has also 3 values, but only
+                  one non-empty. This examples show the two possible
+                  means of specifying empty vector values: using
+                  either <tt>\"\"</tt> or the reserved keyword
+                  <tt>&lt;cmt:null/&gt;</tt>.</li>
+
+                </ol>
+
+                <p></p>
+              </li>
+
+              <li>The file expansion is recursive. This means that
+              files specified in model elements will themselves be
+              considered as model texts (ie following the same
+              syntax), and be expanded in turn. This processus is
+              entirely recursive, with no limit to the depth. The
+              <i>-strict</i> option, when selected is propagated
+              during the recursion.</li>
+
+            </ul>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt filter &lt;in-file&gt; &lt;out-file&gt;">
+
+            This command reads &lt;in-file&gt;, substitutes all occurences 
+            of macro references (taking either the form 
+            <tt>$(<i>macro-name</i>)</tt> or <tt>${<i>macro-name</i>}</tt> 
+            ) by values deduced from corresponding macro specifications 
+            found in the &CMTrequirements; files, and writes the result into 
+            &lt;out-file&gt;. 
+
+            <p>This mechanism is widely internally used by <tt>CMT</tt>, especially 
+              for instanciating make fragments. Then, users may use it for 
+              any kind of document, including maual generation of MSDev 
+              configuration files, etc... </p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt help | --help">
+
+            This command shows the list of options of the <tt>cmt</tt> driver. 
+
+          </cmt:section> 
+
+          <cmt:section title="cmt lock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]">
+
+            This command tries to set a lock onto the current package (or onto the
+            specified package). This consists in the following operations:
+
+            <p></p>
+
+            <ol>
+
+              <li>Check if a conflicting lock is already set onto this
+                package (ie. a lock owned by another user).</li>
+
+              <p></p>
+
+              <li>If not, then install a small text file named <tt>lock.cmt</tt> into the
+                <tt>cmt/mgr</tt> branch of the package, containing the following text: 
+
+<cmt:code>
+locked by &lt;user-name&gt; date &lt;now&gt;</cmt:code>
+
+                <p></p>
+              </li>
+
+              <li>Run a shell command described in the macro named <tt>lock_command</tt> meant to install physical locks onto all files for this version of this package. A typical definition for this macro could be:
+
+<cmt:cmtcode>
+macro lock_command   "chmod -R a-w ../*" \
+      WIN32          "attrib /S /D +R ../*"</cmt:cmtcode>
+
+              </li>
+
+            </ol>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt remove &lt;package&gt; &lt;version&gt; [&lt;area&gt;]">
+
+            This command removes one version of the specified package. If
+            the package does not contain a conflicting lock, and if the user is
+            granted enough access rights to remove files, <i>all</i> files below
+            the version directory will be definitively removed. Therefore
+            this command should be used with as much care as possible.
+
+            <p>The arguments needed to reach the package version to be
+              removed are the same as the ones whic had been used to create it.</p>
+
+            <p>If the removed version is the last version of this package,
+              (and only if its directory is really empty) the package directory itself
+              will be deleted.</p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt remove library_links">
+
+            This command removes symbolic links towards all imported
+            libraries which had been installed using the <tt>
+            <a href="#build">cmt build library_links</a></tt>
+            command. This command is generally transparently executed
+            when one runs <tt>gmake clean</tt>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt run [shell-command]">
+
+            This command runs any shell command, in the context of the 
+            <i>current</i> package.  
+
+            <p>In particular all environment variables defined in
+            requirements file are first set before running the
+            command. This may be seen as a generic <i>application
+            launcher</i>.</p>
+
+	    <p>This may be combined with the global options
+	    <tt>-pack=<i>package</i></tt>,
+	    <tt>-version=<i>version</i></tt>,
+	    <tt>-path=<i>access-path</i></tt>, to give a direct access
+	    to any package context. </p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt set version &lt;version&gt;">
+
+            This command creates and/or fills in the
+            <tt>version.cmt</tt> file for a package structured without
+            the version directory.
+
+	    <p>This command has no effect when run in the context of a
+	    package structured <i>with</i> the version directory</p>
+
+	    <p>This command must be run while being in the context of
+	    one CMT package.</p>
+
+          </cmt:section>
+
+          <cmt:section title="cmt set versions">
+
+            This command applies recursively the <tt>cmt set version
+            ...</tt> command onto all used packages using a broadcast operation.
+
+	    <p>Packages reached during the broadcast scan acquire
+	    their version from the original use statement. This is
+	    this specified version which will be stored inside the
+	    <tt>version.cmt</tt> files</p>
+
+          </cmt:section>
+
+          <cmt:section title="cmt setup [-csh|-sh|-bat]">
+
+            This command generates (to the standard output) a set of shell
+            commands (either for csh, sh or bat shell families) meant to
+            set all environment variables specified in the 
+            <a HREF="#The requirements file">requirements</a> files of the used
+            packages.
+
+            <p>This command is internally used in the
+            <tt>setup.[c]sh</tt> or <tt>setup.bat</tt> shell script,
+            itself generated by the <tt>cmt config</tt> command.</p>
+
+          </cmt:section> 
+
+          <cmt:section title="cmt show &lt;option&gt;">
+
+            <ul> 
+              <li><tt>all_tags</tt> </li>
+
+                <p>This command displays all currently defined tags,
+		  even when not currenty active</p>
+
+              <li><tt>applied_patterns</tt> </li>
+
+                <p>This command displays all patterns actually applied
+                in the current package</p>
+
+              <li><tt>author</tt> <p></p></li>
+
+              <li><tt>branches</tt> <p></p></li>
+
+              <li><tt>clients &lt;package&gt; [ &lt;version&gt; ]</tt> 
+
+                <p>This command displays all packages that express an
+                  explicit <strong>use</strong> statement onto the specified
+                  package. If no version is specified on the argument list,
+                  then all uses of that package are displayed.</p>
+
+                <p>Note that the search on clients is <i>not</i>
+                performed recusively. Thus only clients explicitly
+                using the specified package will be displayed.</p>
+
+                <p></p>
+              </li>
+
+              <li><tt>constituent_names</tt> <p></p></li>
+
+              <li><tt>constituents</tt> <p></p></li>
+
+              <li><tt>cycles</tt>
+
+                <p>This command displays all cycles in the use graph
+                of the current package. Although CMT smoothly accepts
+                such cycles, it is generally a bad practice to have
+                cycles in a use graph, because CMT can never decide on
+                the prefered entry point in the cycle, leading to
+                somewhat unpredictable results, eg in constructing the
+                <tt>use_linkopts</tt> macro.</p>
+
+              <p></p></li>
+
+              <li><tt>fragment &lt;name&gt;</tt> 
+
+                <p>This command displays the actual location where the
+                  specified make fragment is currently found by <tt>CMT</tt>,
+                  taking into account possible overridden definitions.</p>
+
+              <li><tt>fragments</tt> 
+                <p>Display the effective location of all declared make fragments </p>
+                <p></p>
+              </li>
+
+              <li><tt>groups</tt> 
+
+                <p>This command displays all groups possibly defined
+                in constituents of the current package (using the
+                <tt>-group=&lt;<i>group-name</i>&gt;</tt> option).</p>
+
+                <p></p>
+              </li>
+
+              <li><tt>languages</tt>
+                <p>Display al languages declared using the <tt>language</tt> keyword</p>
+                <p></p>
+              </li>
+
+              <li><tt>macro &lt;name&gt;</tt> <br /> <tt>set &lt;name&gt;</tt> <br /> <tt>action &lt;name&gt;</tt>
+
+                <p>This set of commands displays a quite detailed
+                explanation on the value assigned to the symbol
+                (macro, set or action) specified as the additional
+                argument. It presents in particular each intermediate
+                assignments made to this symbol by the hierarchy of
+                used statements, as well as the final result of these
+                assignment operations. </p>
+
+                <p>By adding a <tt>-tag=&lt;tag&gt;</tt> option to this
+                command, it is possible to simulate the behaviour of
+                this command in another context, without actually
+                going to a machine or an operating system where this
+                configuration is defined. </p>
+
+                <p></p>
+              </li>
+
+              <li><tt>macro_value &lt;name&gt;</tt> <br /> <tt>set_value &lt;name&gt;</tt> <br /> <tt>action_value &lt;name&gt;</tt> 
+
+                <p>This set of commands displays the raw value
+                assigned to the symbol (macro, set or action)
+                specified as the additional argument. It only presents
+                the final result of the assignment operations
+                performed by used packages. </p>
+
+                <p>By adding a <tt>-tag=&lt;tag></tt> option to this
+                command, it is possible to simulate the behaviour of
+                this command in another context, without actually
+                going to a machine or an operating system where this
+                configuration is defined.</p>
+
+                <p>The typical usage of the <tt>show macro_value</tt>
+                command is to get at the shell level (rather than
+                within a <tt>Makefile</tt>) the value of a macro
+                definition, providing means of accessing them (quite
+                similarly to an environment variable) : </p>
+
+                <cmt:code>
+csh&gt; set compiler=`cmt show macro_value cppcomp` 
+csh&gt; ${compiler} .... </cmt:code>
+
+              </li>
+
+              <li><tt>macros</tt> <br /> <tt>sets</tt> <br /> <tt>actions</tt>
+
+                <p>This set of commands extracts from the
+                <tt>&CMTrequirements;</tt> file(s) the complete set of
+                symbol (macro, set or action) definitions, selects the
+                appropriate <i>tag</i> definition (or uses the one
+                provided in the <tt>-tag=&lt;tag&gt;</tt> option) and
+                displays the effective symbol values corresponding to
+                this tag. </p>
+
+                <p>This command is typically used to show the
+                effective list of macros used when running make and
+                can be also used to build, as an argument list, the
+                make command as follows : </p>
+
+                <cmt:code>
+csh&gt; eval make `cmt show macros` </cmt:code>
+
+                <p>This use of <tt>cmt show macros</tt> is directly
+                installed within the default target provided in the
+                standard <tt>Makefile.header</tt> file.  Therefore if
+                this file is included into the package's
+                <tt>Makefile</tt>, macro definitions provided in the
+                &CMTrequirements; files (the one of the currently
+                built package as well as the ones of the used
+                packages) will be expanded and provided as arguments
+                to make. </p>
+
+                <p>By adding a <tt>-tag=&lt;tag&gt;</tt> option to this
+                command, it is possible to simulate the behaviour of
+                this command in another context, without atcually
+                going to a machine or an operating system where this
+                configuration is defined. </p>
+
+              </li>
+
+              <li><tt>manager</tt> <p></p></li>
+
+              <li><tt>packages</tt> 
+
+                <p>This command displays all packages (and all
+                versions of them) currently reachable through the
+                current <a href="#Localizing a package">access
+                path</a> definition (which can be displayed using the
+                <tt>cmt show path</tt> command).</p> <p></p>
+
+              </li>
+
+              <li><tt>path</tt> 
+
+                <p>This command displays the complete and effective <a
+                href="#Localizing a package">access path</a> currently
+                defined using any possible alternate way.</p>
+
+              </li>
+
+              <li><tt>pattern &lt;name&gt;</tt> 
+
+                <p>This command displays how and where the specified
+                pattern is defined, and which packages do apply
+                it.</p></li>
+
+              </li>
+
+              <li><tt>patterns</tt> 
+
+                <p>This command displays all pattern definitions.</p>
+
+              </li>
+
+              <li><tt>projects</tt>
+
+                <p>This command displays the current knowledge of
+                sub-project definitions and settings. It shows the
+                project names and their location (ie the corresponding
+                item in <tt>CMTPATH</tt></p>
+
+                <cmt:code>
+&gt; cmt show projects
+<i><font face="courier new, courier" COLOR="#000077">PA (in C:\Arnault\test\tprojects\PC) (current)
+Project1 (in C:\Arnault\test\tprojects\PB)
+PA (in C:\Arnault\test\tprojects\PA\1.1)
+Project2 (in C:\Arnault\test\tprojects\P0)
+CMT (in C:\Arnault)</font></i></cmt:code>
+
+                <p></p>
+              </li>
+
+              <li><tt>pwd</tt> 
+
+                <p>This command displays a filtered version of the
+                  standard <tt>pwd</tt> unix command. The applied filter takes
+                  into account the set of aliases installed in the standard
+                  configuration file located in
+                  <tt>${CMTROOT}/mgr/cmt_mount_filter</tt>.</p>
+
+                <p>This configuration file contains a set of path aliases
+                  (one per line) each proposing a translation for
+                  non-portable file paths (imposed by mount constraints on
+                  some contexts).</p>
+
+              </li>
+
+              <li><tt>setup</tt> 
+                <p>This command combines in one go the output of:</p>
+
+                <cmt:code>
+&gt; cmt show uses
+&gt; cmt show tags
+&gt; cmt show path</cmt:code>
+
+              <p></p></li>
+
+              <li><tt>strategies</tt> <p></p></li>
+
+              <li><tt>tags</tt> </li>
+
+	        <p>This command displays all currently <i>active</i>
+		  tags, and what part of the configuration actually
+		  activates them</p>
+
+              <li><tt>uses</tt>
+
+                 <p>This command displays the use graph fo the current
+                 package. Private sections of used packages are
+                 reached and considered. This behavior can be changed
+                 to effectively hide the private sections in used
+                 packages by using the <tt>-public</tt> modifier</p>
+
+                 <cmt:code>
+&gt; cmt -public show uses</cmt:code>
+
+                 <p>A typical output produced by this command is:</p>
+
+                 <cmt:code>
+&gt; cmt show uses 
+<i><font face="courier new, courier" COLOR="#000077"># use GaudiPolicy v*                             [1]
+# use GaudiKernel v* 
+#   use GaudiPolicy v5r*                         [2]
+# use CLHEP v*  (native_version=1.8.2.0)         [3]
+#   use ExternalLibs v4r* 
+#
+# Selection :                                    [4]
+use CMT &CMTVersion; (/afs/cern.ch/sw/contrib)
+use ExternalLibs v4r2p0  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)    [5]
+use CLHEP v2r1820p0  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)
+use GaudiPolicy v5r11p2  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)
+use GaudiKernel v13r5p1  (/afs/cern.ch/atlas/offline/external/Gaudi/0.12.1.5)</font></i></cmt:code>
+
+                 <ol>
+
+                   <li>The first section of the display (up to the
+                   <tt>Selection</tt> keyword) displays the
+                   hierarchical use graph.
+
+                   <p>Use statements as specified in the requirements
+                   files are displayed, rather than the result of the
+                   effective selection performed by CMT</p>
+                   <p></p></li>
+
+                   <li>Sub-uses are expanded only once and indented
+                   according to the depth in the graph<p></p></li>
+
+                   <li>Various precisions on the use statements are
+                   shown in the first section, such as the scoping
+                   section, the <tt>-no_auto_imports</tt> modifier,
+                   and the <i>native version</i> of this package, (when
+                   a <tt>&lt;package&gt;_native_version</tt> macro has
+                   been defined)<p></p></li>
+
+                   <li>The second section shows the effective ordered
+                   set of use statements resolved by CMT according to
+                   the combined use specifications.<p></p></li>
+
+                   <li>On every line the effective location of the
+                   found package is displayed.<p></p></li>
+
+                 </ol>
+
+                <p>The <tt>-quiet</tt> option may be used to remove the
+                first section from the output so as to only display a
+                simple list of used packages, starting from the
+                deepest uses.</p>
+
+              <p></p></li>
+
+              <li><tt>use_paths &lt;target-package&gt;</tt> </li>
+
+                <p>This command displays all possible paths between
+                the current package and the specified used target
+                package.</p>
+
+                <p>In particular this will detect if a package has no
+                access to another one, due to private use
+                statements</p>
+
+
+              <li><tt>version</tt> 
+
+                <p>This command displays the version tag of the current package.</p>
+
+              </li>
+
+              <li><tt>versions &lt;name&gt;</tt> 
+
+                <p>This command displays the reachable versions of the
+                  specified package, looking at the current access paths.</p>
+
+              </li>
+
+            </ul> 
+
+          </cmt:section>
+
+          <cmt:section title="cmt system">
+
+            This command displays the current value assigned by default to 
+            the <tt>CMTCONFIG</tt> environment variable. 
+
+          </cmt:section>
+
+          <cmt:section title="cmt unlock [ &lt;package&gt; &lt;version&gt; [&lt;area&gt;] ]">
+
+            This command tries to remove a lock from the current package (or from the
+            specified package). This consists in the following operations:
+
+            <p>
+              <ol>
+
+                <li>Check if a conflicting lock is already set onto this
+                  package (ie. a lock owned by another user).
+                </li>
+
+                <li>If not, then remove the text file named <tt>lock.cmt</tt> from the
+                  <tt>cmt/mgr</tt> branch of the package.
+
+                </li>
+
+                <li>Run a shell command described in the macro named <tt>unlock_command</tt> meant to remove physical locks from all files for this version of this package. A typical definition for this macro could be:
+
+<cmt:cmtcode>
+macro unlock_command "chmod -R g+w ../*" \
+      WIN32          "attrib /S /D -R ../*"</cmt:cmtcode>
+                </li>
+              </ol>
+            </p>
+
+          </cmt:section>
+
+          <cmt:section title="cmt version | --version">
+
+            This command shows the current verion of <tt>CMT</tt>, including (if 
+            applicable) the actual patch level. This always corresponds to 
+            the corresponding CVS tag assigned to <tt>CMT</tt> sources. 
+
+          </cmt:section>
+
+          <cmt:section title="cmt cvstags &lt;module&gt;">
+
+            (see the section on <i>how tu use </i><tt>CVS</tt><i>together 
+                                                              with CMT</i> for more details on this command) 
+
+          </cmt:section>
+
+          <cmt:section title="cmt cvsbranches &lt;module&gt;">
+
+          </cmt:section>
+
+          <cmt:section title="cmt cvssubpackages &lt;module&gt;">
+
+          </cmt:section>
+
+          <cmt:section title="cmt cvssubprojects &lt;module&gt;">
+
+          </cmt:section>
+
+        </cmt:section> 
+
+        <cmt:section title="The setup and cleanup scripts">
+
+          They are produced by the <tt>cmt config</tt> command and their 
+          contents is built according to the specifications stored in the 
+          <tt>&CMTrequirements;</tt> file. 
+
+          <p>One flavour of these scripts is generated per shell family
+            (<tt>csh</tt>, <tt>sh</tt> and <tt>bat</tt>), yielding the following
+            scripts :</p>
+
+          <cmt:code>
+setup.csh 
+setup.sh 
+setup.bat
+cleanup.csh 
+cleanup.sh </cmt:code>
+
+          <p>The main sections installed within a setup script are : </p>
+
+          <ol> 
+            <li> 
+              Connection to the current version of the <tt>CMT</tt> package. 
+            </li> 
+
+            <li> Setting the set of user defined public variables
+            specified in the &CMTrequirements; file (including those
+            defined by all used packages). This is achieved by running
+            the <tt>cmt setup</tt> utility into a temporary file and
+            running this temporary file.  </li>
+
+            <li> 
+              Activation of the user defined setup and cleanup scripts 
+              (those specified using the <tt>setup_script</tt> and 
+              <tt>cleanup_script</tt> statements). 
+            </li> 
+          </ol> 
+
+          It should be noted that these setup scripts do <i>not</i> 
+          contain machine specific information (due to the online use of 
+          the <tt>cmt setup</tt> command).  Therefore, it is perfectly 
+          possible to use the same setup script on various platforms (as 
+          soon as they share the directories) and this also shows that the 
+          configuration operation (the <tt>cmt config</tt> command) is 
+          required only once for a set of multiple platforms sharing a 
+          development area. 
+
+        </cmt:section> 
+
+        <cmt:section title="cmt build prototype">
+
+          This command is only provided for development of <tt>C</tt> 
+          modules. It generates a <tt>C</tt> header file containing the 
+          set of prototype statements for all public functions of a given 
+          module. Its output is a file with the same name as the input 
+          source (given as the argument) and suffixed with <tt>.ph</tt>. 
+
+          <p>The generated prototype header file is meant to be included 
+            whereever it is needed (in the module file itself for instance). </p>
+
+          <p>A typical example of the use of <tt>cmt build prototype</tt> 
+            could be : </p>
+
+<cmt:code>
+csh&gt; cd ../src 
+csh&gt; cmt build prototype FooA.c 
+<i><font face="courier new, courier" COLOR="#000077">Building FooA.ph </font></i></cmt:code>
+
+          <p>Running <tt>cmt build prototype</tt> will only produce a new 
+            prototype header file if the output is actually different from 
+            the existing one (if it exists) in order to avoid confusing 
+            <i>make</i> checks. </p>
+
+          <p>The effective use of this facility (which may not be
+            appropriate in all projects) is controlled by one option of the
+            build strategy, which can take one of the two values:</p>
+
+<cmt:cmtcode>
+build_strategy prototypes
+build_strategy no_prototypes</cmt:cmtcode>
+
+          <p>In addition to this global strategy specification, each
+            application or library may individually override it using the
+            <tt>-prototypes</tt> or <tt>-no_prototypes</tt> options.</p>
+
+          <p>Lastly, the actual behaviour of the prototype generator is
+            defined in the standard make macro <tt>build_prototype</tt> (which
+            default to call the <tt>cmt build prototype</tt> command, allowing
+            a user defined behavious to this feature)</p>
+
+        </cmt:section> 
+</cmt:section> 
+
+<cmt:section title="Using cvs together with CMT">
+
+  <p>Nothing special is apriori required by <tt>CMT</tt> with respect to
+  the use of <tt>CVS</tt>.  Nevertheless, one may advertize some well
+  tested conventions and practices which turned out to ensure a good
+  level of consistency between the two utilities.</p>
+
+  <p>Although none of these are required, the <tt>cmt</tt> general
+  command provides a few utilities so as to simplify the use of these
+  practices. It should be noted that the added features provided by
+  cmt rely on the possibility to <i>query</i> CVS about the existing
+  <tt>CMT</tt> packages and the possible tags setup for these
+  packages. CVS does not by default permit such query operations
+  (since they require to scan the physical CVS repository). Therefore
+  <tt>CMT</tt> provides a hook to CVS (based upon standard CVS features
+  - not patches) for this. This hook can be installed following a
+  recipe explained in the dedicated 
+  <a href="#The internal mechanism of cmt cvs operations">appendix</a>.</p>
+
+  <cmt:section title="Importing a package into a cvs repository">
+
+    <p>Generally, everything composing a package (below the
+    <i>version</i> directory and besides the <i>binary</i>
+    directories) is relevant to be imported.  Then choosing a
+    <tt>cvs</tt> <i>module</i> name is generally done on the basis of
+    the package name. Taking the previous examples, one could import
+    the <tt>Foo</tt> package as follows :</p>
+          
+    <cmt:code>
+csh&gt; cd ...../Foo/v1 
+csh&gt; cvs import -m "First import" -I alpha -I hp9000s700 Foo LAL v1 </cmt:code>
+          
+    <p>In this example, </p>
+
+    <ul> 
+      <li> 
+        we have ignored the currently existing binary directories 
+        (here <tt>alpha</tt> and <tt>hp9000s700</tt>) 
+      </li> 
+      <li> 
+        the <tt>cvs</tt> module name is identical to the package 
+        name (<tt>Foo</tt>) 
+      </li> 
+      <li> 
+        the original symbolic insertion tag is identical to the 
+        version identifier (<tt>v1</tt>) 
+      </li> 
+    </ul> 
+          
+    <p>The choice of the module name can generally be identical to the
+    package name. However, some site specific management issues may
+    lead to different choices (typically, a top directory where groups
+    of packages are gathered may be inserted).</p>
+          
+    <p>Conversely, using symbolic tags identical to version
+    identifiers appears to be a very good practice. The only
+    constraint induced by <tt>cvs</tt> is that the symbolic tags may not
+    contain <i>dot</i> characters (<tt>'.'</tt>), whereas no restriction
+    exist from <tt>CMT</tt> itself. Thus version identifiers like
+    <tt>v3r2</tt> will be preferred to the <tt>v3.2</tt> form. </p>
+
+  </cmt:section>
+
+  <cmt:section title="Checking a package out from a cvs repository">
+
+    <p>Assuming the previous conventions on module name and version
+    identifier have been selected when importing a package, the
+    following operations will naturally intervene when one need to
+    check a package out (typically to work on it or to install it on
+    some platform) : </p>
+          
+    <cmt:code>
+csh&gt; cd &lt;some root&gt;            (1) 
+csh&gt; mkdir Foo                 (2) 
+csh&gt; cd Foo 
+csh&gt; cvs checkout -d v1 Foo    (3) 
+csh&gt; cd v1/cmt 
+csh&gt; cmt config                (4) 
+csh&gt; source setup.csh          (5) 
+csh&gt; [g]make                   (6) </cmt:code>
+                                                        
+    <ol> 
+      <li> 
+        one always have to select a root directory where to settle 
+        down this copy of the extracted package. This may either be 
+        the so-called <i>default root</i> or any other appropriate 
+        directory. In both cases, the next <tt>cmt config</tt> 
+        operation will automatically take care of this effective 
+        location. 
+      </li> 
+      <li> 
+        creating a base directory with the package name is mandatory 
+        here, and is <i>not</i> taken into account by <tt>cvs</tt> 
+        during the <i>chaeckout</i> operation since one wants to 
+        insert the <i>version</i> branch in between. 
+      </li> 
+      <li> 
+        the package is checked out into a directory named with the 
+        expected version identifier exactly corresponding to the 
+        version currently stored in the <tt>cvs</tt> 
+        repository. 
+      </li> 
+      <li> 
+        then using the <tt>cmt config</tt> command (from the 
+        <tt>cmt</tt> branch) will update the setup scripts against 
+        the <tt><a HREF="#The requirements file">requirements</a></tt> file and the effective current 
+        package location. 
+      </li> 
+      <li> 
+        using this updated version of the setup script provides the 
+        appropriate set of environment variables 
+      </li> 
+      <li> lastly, rebuilding the entire package is possible simply
+        using the <tt>[g]make</tt> command.
+      </li>
+
+    </ol> 
+
+          
+    <p>The actions decribed just above (from number 2 to number 4
+    included) can also be performed using the <tt>cmt checkout</tt>
+    command. </p>
+          
+    <cmt:code>
+&gt; cd &lt;some work area&gt; 
+&gt; cmt checkout [modifier ...] &lt;package&gt; ... 
+<i><font face="courier new, courier" COLOR="#000077">                  
+modifier :
+-l        Do not process used packages (default).
+-R        Process used packages recursively.
+-r rev    Check out version tag. (is sticky)
+-d dir    Check out into dir instead of module name.
+-o offset Offset in the CVS repository
+-n        Simulation mode on
+-v        Verbose mode on
+-help     Print this help</font></i></cmt:code>
+          
+    Thus the previous example would become:
+          
+    <cmt:code>
+csh&gt; cd &lt;some root&gt;
+csh&gt; cmt checkout Foo
+csh&gt; cd Foo/v1/cmt 
+csh&gt; source setup.csh
+csh&gt; [g]make</cmt:code>
+          
+  </cmt:section>
+
+  <cmt:section title="Querying CVS about some important infos">
+
+    It is possible, using the commands :
+          
+    <ul> 
+      <li> 
+        <tt>cmt cvstags &lt;module&gt;</tt> 
+      </li> 
+      <li> 
+        <tt>cmt cvsbranches &lt;module&gt;</tt> 
+      </li> 
+      <li> 
+        <tt>cmt cvssubpackages &lt;module&gt;</tt> 
+      </li> 
+      <li> 
+        <tt>cmt cvssubprojects &lt;module&gt;</tt> 
+      </li> 
+    </ul> 
+          
+    <p> to query the <tt>CVS</tt> repository about the existing tags
+    installed onto a given <tt>CVS</tt> module, the subdirectories and
+    the subpackages (in the <tt>CMT</tt> meaning, i.e. when a <tt><a
+    HREF="#The requirements file">requirements</a></tt> file
+    exists). </p>
+          
+    <cmt:code>
+&gt; cmt cvstags Cm 
+<i><font face="courier new, courier" COLOR="#000077">v7r6 v7r5 v7r4 v7r3 v7r1 v7 </font></i>
+&gt; cmt cvstags Co 
+<i><font face="courier new, courier" COLOR="#000077">v3r7 v3r6 v3 </font></i></cmt:code>
+          
+    <p>One should notice here that the <tt>cvstags</tt> command can give
+    informations about any type of module, even if it is not managed
+    in the <tt>CMT</tt> environment. </p>
+          
+    <p>However, in order to let this mechanism operate, it is required
+    to install some elements into the physical <tt>CVS</tt> repository
+    (<i> which may require some access rights into it</i>). This
+    installation procedure (to be done only once in the life of the
+    repositiory) can be achieved through the following command:</p>
+          
+    <cmt:code>
+sh&gt; (cd ${CMTROOT}/mgr; gmake installcvs)</cmt:code>
+          
+    <p>However, the details of the procedure is listed below (this
+    section is preferably reserved for system managers and can easily
+    be skipped by standard users):</p>
+          
+    <ol> 
+
+      <li> copy the <tt>cmt_buildcvsinfos2.sh</tt> shell script into the
+      management directory <tt>${CVSROOT}/CVSROOT</tt> as follows :
+
+        <cmt:code>
+sh&gt; cp ${CMTROOT}/mgr/cmt_buildcvsinfos2.sh ${CVSROOT}/CVSROOT </cmt:code>
+      </li> 
+            
+      <li> install one special statement in the <tt>loginfo</tt>
+      administrative file as follows :
+              
+        <cmt:code>
+sh&gt; cd ... 
+sh&gt; cvs checkout CVSROOT 
+sh&gt; cd CVSROOT 
+sh&gt; vi loginfo 
+... 
+.cmtcvsinfos $CVSROOT/CVSROOT/cmt_buildcvsinfos2.sh 
+sh&gt; cvs commit -m "set up commitinfo for CMT" </cmt:code>
+      </li> 
+    </ol> 
+          
+  </cmt:section>
+
+  <cmt:section title="Working on a package, creating a new release">
+        
+    <p>This section presents the way to instanciate a new release of
+    a given package, which happens when the foreseen modifications
+    will yield additions or changes to the application programming
+    interface of the package. </p>
+          
+    <p>Then the version tag is supposed to be moved forward, either
+    increasing its minor identifier (in case of simple additions) or
+    its major identifier (in case of changes). </p>
+          
+    <p>The following actions should be undertaken then : </p>
+          
+    <ol> 
+      <li> 
+        understand what is the latest version tag (typically by 
+        using the <tt>cmt cvstags</tt> command). Let's call it 
+        <tt>old-tag</tt>. 
+        <p></p>
+      </li> 
+      <li> 
+        select (according to the foreseen amount of changes) what 
+        will be the next version tag. Let's call it 
+        <tt>new-tag</tt>. 
+        <p></p>
+      </li> 
+      <li> 
+        check the most recent version of the package in your 
+        development area : 
+            
+        <cmt:code>
+sh&gt; cd &lt;development area&gt; 
+sh&gt; cvs checkout -d &lt;new-tag&gt; &lt;package&gt; </cmt:code>
+      </li> 
+      <li> 
+        configure this new release, and rebuild it : 
+              
+        <cmt:code>
+sh&gt; cd &lt;new-tag&gt;/cmt 
+sh&gt; cmt config 
+sh&gt; source setup.csh 
+sh&gt; [g]make </cmt:code>
+      </li> 
+    </ol> 
+          
+  </cmt:section>
+
+  <cmt:section title="Getting a particular tagged version out of CVS">
+        
+    <p>The previous example presented the standard case where one gets
+      the <i>most recent</i> version of a given package. The procedure
+      is only slightly modified when one wants to extract a previously
+      tagged version. Let's imagine that the <tt>Foo</tt> package has
+      evolved by several iterations, leading to several tagged
+      releases in the <tt>cvs</tt> repository (say <tt>v2</tt> and
+      <tt>v3</tt>). If the <tt>v2</tt> release is to be used (e.g. for
+      understanding and fixing a problem discovered in the running
+      version) one will operate as follows :</p>
+          
+    <cmt:code>
+csh&gt; cd &lt;some root&gt; 
+csh&gt; mkdir Foo 
+csh&gt; cd Foo 
+csh&gt; cvs checkout -d v2 -r v2 Foo
+csh&gt; cd v2/cmt 
+csh&gt; cmt config 
+csh&gt; source setup.csh 
+csh&gt; make </cmt:code>
+
+  </cmt:section>
+
+</cmt:section>
+
+<cmt:section title="Interfacing an external package with CMT">
+
+  <p>Very often, external packages (typically commercial products, or
+  third party software) are to be used by packages developped in the
+  context of the <tt>CMT</tt> environment. Although this can obviously
+  done simply by specifying compiler or linker options internally to
+  the client packages, it can be quite powerful to interface these
+  so-called <i>external</i> packages to <tt>CMT</tt> by defining a
+  <i>glue</i> package, where configuration specifications for this
+  external package are detailed.</p>
+
+  <p>Using this approach, one may : </p>
+
+        <ul> 
+          <li> 
+            provide a <i>nickname</i> for this external package, 
+          </li> 
+          <li> 
+            adapt the version tag convention consistently to the
+            project, hiding the version tag specificities of
+            eg. commercial packages.
+          </li> 
+          <li> 
+            provide compiler options using the the standard make macros 
+            <tt>&lt;package>_cflags</tt>, <tt>&lt;package>_cppflags</tt> 
+            or <tt>&lt;package>_fflags</tt>, 
+          </li> 
+          <li> 
+            specify a set of search paths for the include files, using 
+            the <tt>include_dirs</tt> statement, 
+          </li> 
+          <li> 
+            provide linker options using the the standard make macros 
+            <tt>&lt;package>_linkopts</tt> 
+          </li> 
+        </ul> 
+
+        Let's consider the example of the <tt>OPACS</tt> package. This 
+        package is provided outside of the <tt>CMT</tt> 
+        environment. Providing a directory tree following the 
+        <tt>CMT</tt> conventions (ie. a branch named after the version 
+        identifier, then an <tt>cmt</tt> branch) then a 
+        <tt>&CMTrequirements;</tt> file, containing (among other statements 
+        not shown for the sake of clarity) : 
+
+<cmt:cmtcode>
+package OPACS 
+
+include_dirs ${Wo_root}/include ${Co_root}/include ${Xx_root}/include \
+${Ho_root}/include ${Go_root}/include ${Xo_root}/include 
+
+public 
+macro OPACS_cflags      "-DHAS_XO -DHAS_XM" 
+macro OPACS_cppflags    " $(OPACS_cflags) " 
+
+macro OPACS_linkopts    "$(Wo_linkopts) $(Xo_linkopts) $(Go_linkopts) \
+$(Glo_linkopts) $(Xx_linkopts) $(Ho_linkopts) $(Htmlo_linkopts) \
+$(W3o_linkopts) $(Co_linkopts) $(X_linkopts)" </cmt:cmtcode>
+
+        <p>Then every package or application, client of this 
+          <tt>OPACS</tt> package would have just to provide a use 
+          statement like : </p>
+
+<cmt:cmtcode>
+use OPACS v3 </cmt:cmtcode>
+
+        <p>This procedure gives the complete benefit of the use 
+          relationships between packages (a client application 
+          transparently inherits all configuration specifications) while 
+          keeping unchanged the original referenced package, allowing to 
+          apply this approach even to commercial products so that they 
+          may be integrated in resource usage surveys similarly to local 
+          packages. </p>
+
+</cmt:section> 
+
+<cmt:section title="The installation area mechanism">
+
+  <p>CMT proposes and implements a flexible architecture for
+  installation areas, meant to group the results of the build process
+  or any other information belonging to packages into shared disk
+  spaces. The typical usage of such installation areas is classical
+  and expect to make only visible to the clients of a given
+  (sub-)project the results of the build process while hiding the
+  details of the package sources.</p>
+
+  <p>the basics of the mechanisms supported by CMT are the following:</p>
+      
+  <ol>
+
+    <li>The installation area mechanism is activated on demand via a
+    dedicated strategy specification, that can be written either in a
+    requirements file or in a project file. By default the mechanism
+    is <i>not</i> active.<p></p></li>
+
+    <li>All mechanisms are customizable on a per-project basis,
+    so as to easily follow the project specific conventions<p></p></li>
+
+    <li>However CMT proposes a minimal default behaviour based on the
+    concrete experience in large projects, as well as frequently met
+    practices<p></p></li>
+
+    <li>A typical well supported convention is to map the set of
+    installation areas onto the set of CMTPATH entries, associating the
+    concept of CMTPATH splitting with the sub-project
+    organization<p></p></li>
+
+    <li>A typical consequence of this approach is that many
+    configuration parameters need to be set according to the list of
+    CMTPATH items. Eg on a Unix system, if one expects to find shared
+    libraries in every installation area, each of them being created
+    in a corresponding CMTPATH entry, one also expects to have
+    LD_LIBRARY_PATH entries accordingly. The mechanism of
+    <tt>cmtpath_pattern</tt> is exactly designed for that.<p></p></li>
+
+    <li>The mechanism easily supports the extension for installing
+    binary files (libraries, applications, java classes), runtime
+    files, documentation and header files.<p></p></li>
+        
+  </ol>
+
+  <cmt:section title="The default implementation"> 
+
+    <p>It is provided in terms of</p>
+
+    <ol>
+
+      <li>
+
+        A set of <tt>cmtpath_pattern</tt>s defined in the CMT requirements
+        file. This can be displayed using the command
+
+	<cmt:code>
+&gt; cmt show cmtpath_patterns</cmt:code>
+
+        <p></p>
+      </li>
+
+      <li>
+
+        A consistent set of actions added to the following make_fragments
+
+	<table>
+	  <tr><td><tt>application</tt></td><td>applications</td></tr>
+	  <tr><td><tt>library</tt></td><td>shared libraries</td></tr>
+	  <tr><td><tt>library_no_share</tt></td><td>static libraries</td></tr>
+	  <tr><td><tt>java_header</tt></td><td>Java applications</td></tr>
+	  <tr><td><tt>jar</tt></td><td>Java libraries</td></tr>
+	</table>
+
+        <p></p>
+      </li>
+
+      <li>
+        <p>One shell script for installing or uninstalling files or directories</p>
+
+	<cmt:code>
+${CMTROOT}/mgr/cmt_install_action.sh
+${CMTROOT}/mgr/cmt_uninstall_action.sh
+${CMTROOT}/mgr/cmt_install_action.bat
+${CMTROOT}/mgr/cmt_uninstall_action.bat</cmt:code>
+
+        <p></p>
+      </li>
+
+      <li>
+
+      <p>The default architecture of this installation scheme is by
+      default set for each CMTPATH entry to:</p>
+
+      <cmt:code>
+&lt;path&gt;/$(&lt;project&gt;_installarea_prefix)/$(tag)/bin/...                [1]
+                                      /$(tag)/lib/...                [2]
+                                      /include/&lt;package&gt;/...         [3]
+                                      /share/bin/...                 [4]
+                                      /share/lib/...                 [5]
+                                            /...                     [6]
+                                      /doc/&lt;package&gt;/...             [7]
+                                          /...                       [8]</cmt:code>
+
+      <ol>
+        <li>Platform dependent executables</li>
+        <li>Platform dependent libraries</li>
+        <li>Public header files </li>
+        <li>Platform independent applications (eg Java applications)</li>
+        <li>Platform independent libraries (eg Java libraries)</li>
+        <li>other platform independent files</li>
+        <li>package specific documentations</li>
+        <li>project-wide documentation</li>
+      </ol>
+
+      <p>The <tt>&lt;project&gt;_installarea_prefix</tt> takes the
+      default value of <tt>$(cmt_installarea_prefix)</tt> for all
+      projects, which itself takes the default value of
+      <tt>InstallArea</tt>. Of course it can be overridden to other
+      values in each project</p>
+
+      </li>
+
+    </ol>
+
+    <p>The <tt>cmtpath_patterns</tt> are designed in this
+    implementation for constructing a proper and consistent sequence
+    of system specific environment variables (eg <tt>PATH</tt>,
+    <tt>LD_LIBRARY_PATH</tt>, <tt>CLASSPATH</tt>) as well as compiler
+    or linker options so as to transparently refer to the installation
+    area only when it is appropriate to ovverride the local
+    patterns.</p>
+
+  </cmt:section> 
+     
+  <cmt:section title="Tuning the installation area mechanisms">
+
+    <p>First of all every individual sub-project may activate or
+    inhibit the installation area mechanisms using the
+    <tt>build_strategy</tt> statement, with either
+    <tt>with_installarea</tt> or <tt>without_installarea</tt>
+    option.</p>
+
+    <p>Then a dedicated tag materializes the selected strategy:
+    <tt>&lt;project&gt;_with_installarea</tt> or
+    <tt>&lt;project&gt;_without_installarea</tt></p>
+
+    <p>This tag set will be used in various macro or set definitions
+    to produce or not the appropriate values</p>
+
+    <p>CMT manipulate some standard macros or environment variables
+    according to the effective strategy:</p>
+
+    <table border="1" cellspacing='0'>
+      <tr>
+        <td><center><i>name</i></center></td>
+        <td><center><i>purpose</i></center></td>
+        <td><center><i>default</i></center></td>
+      </tr>
+
+      <tr>
+        <td><tt>cmt_installarea_prefix</tt></td>
+        <td>The default prefix for all projects</td>
+        <td><tt>InstallArea</tt></td>
+      </tr>
+
+      <tr>
+        <td><tt>&lt;project&gt;_installarea_prefix</tt></td>
+        <td>The prefix for a given sub-project</td>
+        <td><tt>$(cmt_installarea_prefix)</tt></td>
+      </tr>
+
+      <tr>
+        <td><tt>&lt;project&gt;_installarea_prefix_remove</tt></td>
+        <td>The regexp pattern to cleanup symbols</td>
+        <td><tt>$(&lt;project&gt;_installarea_prefix)</tt></td>
+      </tr>
+
+      <tr>
+        <td><tt>cmt_installarea_linkopts</tt></td>
+        <td>Implicit linker options due to the installation area</td>
+        <td>...</td>
+      </tr>
+
+      <tr>
+        <td><tt>PATH</tt></td>
+        <td>Accessing the executables in the installation area</td>
+        <td>...</td>
+      </tr>
+
+      <tr>
+        <td><tt>LD_LIBRARY_PATH</tt></td>
+        <td>Accessing the shared libraries in the installation area</td>
+        <td>...</td>
+      </tr>
+
+      <tr>
+        <td><tt>CLASSPATH</tt></td>
+        <td>Accessing the jar files in the installation area</td>
+        <td>...</td>
+      </tr>
+
+<!--
+      <tr>
+        <td><tt></tt></td>
+        <td></td>
+        <td></td>
+      </tr>
+-->
+
+    </table>
+
+    <p></p>
+
+  </cmt:section> 
+
+</cmt:section>
+
+<cmt:section title="Installing CMT for the first time">
+
+        <P>These sections are of interest only if <tt>CMT</tt> is not yet 
+          installed on your site, of if you need a private 
+          installation. </P> 
+
+        <P>The first question you need to answer is the location where 
+          to install <tt>CMT</tt>. This location is typically a disk area where 
+          most of packages managed in your project will be located. </P> 
+
+        <P>Then, you have to fetch the distribution kit from the Web at 
+	  <A HREF="http://www.cmtsite.org">http://www.cmtsite.org</A>. You 
+          must get at least the primary distribution kit containing the 
+          basic configuration information and the <tt>CMT</tt> sources. This 
+          operation results in a set of directories hanging below the <tt>CMT</tt> 
+          root and the version directory. The src branch contains the 
+          sources of <tt>CMT</tt>, the fragments branch contains the makefile 
+          fragments and the mgr branch contains the scripts needed to build 
+          or operate <tt>CMT</tt>. </P> 
+
+        <cmt:section title="Installing CMT on your Unix site">
+
+          <P>The very first operation after dowloading <tt>CMT</tt>
+          consists in running the <tt>INSTALL</tt> shell script. This
+          will build the setup scripts required by any <tt>CMT</tt>
+          user. </P>
+            <P>Then you may either decide to build <tt>CMT</tt> by yourself or fetch 
+            a pre-built binary from the same Web location. The prebuilt 
+            binary versions may not exist for the actual platform you are 
+            working on. You will see on the distribution page the precise 
+            configurations used for building those binaries. </P> 
+
+          <P>In case you have to build <tt>CMT</tt> yourself, you need a C++ 
+            compiler capable of handling templates (although the support for 
+            STL is not required). There is a Makefile provided in the 
+            distribution kit which takes g++ by default as the compiler. If 
+            you need a specific C++ compiler you will override the cpp macro 
+            as follows: </P> 
+
+<cmt:code>
+sh&gt; gmake cpp=CC </cmt:code>
+
+          <P>The <tt>cppflags</tt> macro can also be used to override the
+            behaviour of the compilation. </P>
+
+          <P>Another important concern is the way <tt>CMT</tt> will identify the 
+            platform. <tt>CMT</tt> builds a configuration tag per each type of 
+            platform, and uses this tag for naming the directory where all 
+            binary files will be stored. As such this tag has to be defined 
+            prior to even build <tt>CMT</tt> itself. </P> 
+
+          <P><tt>CMT</tt> builds the default configuration by running the 
+            cmt_system.sh script found in the mgr branch of <tt>CMT</tt>. Run it 
+            manually to see what is the default value provided by this 
+            script. You might consider changing its algorithm for your own 
+            convenience. </P> 
+
+          <p>A distribution kit may be obtained at the following URL : </p>
+
+<cmt:code>
+http://www.cmtsite.org</cmt:code>
+
+          <p>Once the <tt>tar</tt> file has been downloaded, the 
+            following operations must be achieved : </p>
+
+          <ol> 
+            <li> 
+              Select a root directory where to install 
+              <tt>CMT</tt>. Typically this will correspond to a 
+              development area or a public distribution area. 
+            </li> 
+            <li> 
+              Import the distribution kit mentioned above. 
+            </li> 
+            <li> 
+              Uncompress and untar it. 
+            </li> 
+            <li> 
+              Configure <tt>CMT</tt>. 
+            </li> 
+            <li> 
+              CMT is ready to be used for developing packages. 
+            </li> 
+          </ol> 
+
+          <p>A typical corresponding session could look like : </p>
+
+<cmt:code>
+csh&gt; cd /Packages 
+csh&gt; &lt;get the tar file from the Web&gt; 
+csh&gt; tar xzf CMT&CMTVersion;.tar.gz 
+csh&gt; cd CMT/&CMTVersion;/mgr 
+csh&gt; ./INSTALL 
+csh&gt; source setup.csh 
+csh&gt; gmake</cmt:code>
+
+        </cmt:section> 
+
+        <cmt:section title="Installing CMT on a Windows or Windows NT site">
+
+          <p>You first have to fetch the distribution kit from the Web at 
+            <A 
+              HREF="http://www.cmtsite.org">http://www.cmtsite.org</A>. You 
+            must get at least the primary distribution kit containing the 
+            basic configuration information and the <tt>CMT</tt> sources. This 
+            operation results in a set of directories hanging below the <tt>CMT</tt> 
+            root and the version directory. The binary kit provided for 
+            Windows environments will generally fit your needs. </p> 
+
+          <p>You should consider getting the pre-compiled (for a Windows
+            environment) applications, and especially the
+            <tt>..\VisualC\install.exe</tt> application, which interactively
+            configures the registry entries as described in the
+            next paragraph.</p>
+
+          <p>The next operation consists in defining a few registries
+            (typically using the standard RegEdit facility or the
+            <tt>install.exe</tt> special application): </p>
+
+          <UL> 
+
+            <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/root</tt> will
+            contain the root directory where <tt>CMT</tt> is installed
+            (eg. <tt>"e:"</tt>). </li>
+
+            <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/version</tt> will
+            contain the current version tag of <tt>CMT</tt>
+            (<tt>"&CMTVersion;"</tt> for this version). </li>
+
+            <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/path/</tt> may
+            optionally contain a set of text values corresponding to
+            the different package global access paths. </li>
+
+            <li><tt>HKEY_LOCAL_MACHINE/Software/CMT/site</tt> will
+            contain the conventional site name. </li>
+
+            <li><tt>HKEY_CURRENT_USER/Software/CMT/path/</tt> may
+            contain a set of text of text values corresponding to the
+            different package private access paths. </li> </UL>
+
+          <p>CMT can also be configured to run on DOS-based environments
+            using the <tt>nmake</tt> facility. In this case, the installation
+            procedure is very similar to the Unix one:</p>
+
+          <p>A typical corresponding session could look like : 
+
+<cmt:code>
+dos&gt; cd Packages 
+dos&gt; &lt;get the tar file from the Web&gt; 
+dos&gt; cd CMT\&CMTVersion;\mgr 
+dos&gt; call INSTALL 
+dos&gt; call setup.bat
+dos&gt; nmake /f nmake</cmt:code>
+
+          </p>
+
+        </cmt:section> 
+
+</cmt:section> 
+
+<cmt:section title="Appendices">
+
+<cmt:section title='Copyright'>
+
+<center><b>Copyright LAL and Christian Arnault LAL-Orsay CNRS</b></center>
+
+<center><tt>arnault@lal.in2p3.fr</tt></center>
+
+<p>This software is a computer program whose purpose is to describe and
+manage software configuration activities.</p>
+
+<p>This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use, 
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+<center><a href="http://www.cecill.info"><cmt:code>http://www.cecill.info</cmt:code></a></center> </p>
+
+<p>As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability. </p>
+
+<p>In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or 
+data to be ensured and,  more generally, to use and operate it in the 
+same conditions as regards security. </p>
+
+<p>The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.</p>
+
+
+</cmt:section>
+
+<cmt:section title="Standard make targets predefined in CMT">
+
+  <p>These targets can always be listed through the following command : </p>
+
+  <cmt:code>
+sh&gt; gmake help </cmt:code>
+
+  <p> 
+    <table BORDER='1' cellspacing='0' COLS='2'> 
+      <tr> 
+        <td width="200"> 
+          <center><i>target</i></center> 
+        </td> 
+        <td width="500"> 
+          <center><i>usage</i></center> 
+        </td> 
+      </tr> 
+      <tr> 
+        <td><tt>help</tt></td> 
+        <td >Get the list of possible make target for this package.</td> 
+      </tr> 
+      <tr> 
+        <td><tt>all</tt></td> 
+        <td >build all components of this package.</td> 
+      </tr> 
+      <tr> 
+        <td><tt>clean</tt></td> 
+        <td>remove everything that can be rebuilt by make</td> 
+      </tr> 
+      <tr> 
+        <td><tt>binclean</tt></td> 
+        <td>completely remove the <tt>../$(tag)</tt> binary directory</td> 
+      </tr> 
+      <tr> 
+        <td><tt>configclean</tt></td> 
+        <td>remove all intermediate makefile fragments</td> 
+      </tr> 
+      <tr> 
+        <td><tt>install</tt></td> 
+        <td>install binaries of this package to the current installation area</td> 
+      </tr> 
+      <tr> 
+        <td><tt>uninstall</tt></td> 
+        <td>uninstall binaries of this package from the current installation area</td> 
+      </tr> 
+      <tr> 
+        <td><tt>check</tt></td> 
+        <td>run all applications defined with the -check option</td> 
+      </tr> 
+      <tr> 
+        <td><i>component-name</i></td>
+        <td>only build this 
+          particular component (as opposed to the <tt>all</tt> 
+          target that tries to build all components of this 
+          package)</td> 
+      </tr> 
+      <tr>
+        <td><i>group-name</i></td>
+        <td>build all constituents
+                belonging to this group (ie. those defined using the same
+                -group=&lt;group-name&gt; option)</td>
+      </tr>
+    </table> 
+  </p>
+  <p>These targets have to be specified as follows : </p>
+
+  <cmt:code>
+sh&gt; gmake clean 
+sh&gt; gmake Foo </cmt:code>
+
+</cmt:section> 
+
+<cmt:section title="Standard macros predefined in CMT">
+
+  <cmt:section title="CMT static macros">
+
+    These macros provide static data about CMT itself. They cannot be
+    modified by the user.
+
+    <p>
+      <table BORDER='1' cellspacing='0' COLS='3'> 
+        <tr> 
+          <td width="150"> 
+            <center><i>macro</i></center> 
+          </td> 
+          <td width="300"> 
+            <center><i>usage</i></center> 
+          </td> 
+          <td width="200"> 
+            <center><i>default value</i></center> 
+          </td> 
+        </tr> 
+        <tr> 
+          <td><tt>CMTrelease</tt></td> 
+          <td>gives the current release number of CMT</td> 
+          <td><tt>&CMTrelease;</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>CMTVERSION</tt></td> 
+          <td>gives the current complete version tag of CMT</td> 
+          <td><tt>&CMTVersion;</tt></td> 
+        </tr> 
+      </table> 
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title="Structural macros">
+
+    These macros describe the structural conventions followed by
+    <tt>CMT</tt>. They receive a conventional default value from the
+    <tt>CMT</tt> requirements file. However, they can be overridden in
+    any package for its own needs.
+
+    <p>
+      <table BORDER='1' cellspacing='0' COLS='3'> 
+        <tr> 
+          <td width="150"> 
+            <center><i>macro</i></center> 
+          </td> 
+          <td width="300"> 
+            <center><i>usage</i></center> 
+          </td> 
+          <td width="200"> 
+            <center><i>default value</i></center> 
+          </td> 
+        </tr> 
+        <tr> 
+          <td><tt>tag</tt></td> 
+          <td>gives the binary tag</td> 
+          <td><tt>${CMTCONFIG}</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>src</tt></td>
+          <td>the src branch</td> 
+          <td><tt>../src/</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>inc</tt></td> 
+          <td>the include branch</td> 
+          <td><tt>../src/</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>mgr</tt></td> 
+          <td>the cmt or mgr branch</td> 
+          <td><tt>../cmt/</tt> or <tt>../mgr/</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>bin</tt></td> 
+          <td>the branch for binaries</td> 
+          <td><tt>../$(&lt;package&gt;_tag)/</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>javabin</tt></td> 
+          <td>the branch for java classes</td> 
+          <td><tt>../classes/</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>doc</tt></td> 
+          <td>the doc branch</td> 
+          <td><tt>../doc/</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cmt_hardware</tt></td> 
+          <td>the description of the current hardware</td> 
+          <td><tt>&lt;none&gt;</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cmt_system_version</tt></td> 
+          <td>the version of the current OS</td> 
+          <td><tt>&lt;none&gt;</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cmt_compiler_version</tt></td> 
+          <td>the version of the currently visible C++ compiler </td> 
+          <td><tt>&lt;none&gt;</tt></td> 
+        </tr> 
+      </table> 
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title="Language related macros">
+
+    These macros are purely conventional. They are expected in the
+    various make fragments available from <tt>CMT</tt> itself for
+    providing the various building actions.
+
+    <p>During the mechanism of new language declaration and definition
+    available in the <tt>CMT</tt> syntax, developers are expected to
+    define similar conventions for corresponding actions.</p>
+
+    <p> Their default values are originally defined inside the
+    &CMTrequirements; file of the <tt>CMT</tt> package itself but can be
+    <i>redefined</i> by providing a new definition in the package's
+    requirements file using the <tt>macro</tt> statement. The original
+    definition can be <i>completed</i> using the <tt>macro_append</tt>
+    or <tt>macro_prepend</tt> statements.</p>
+
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='3'> 
+        <tr> 
+          <td width="150"> 
+            <center><i>macro</i></center> 
+          </td> 
+          <td width="300"> 
+            <center><i>usage</i></center> 
+          </td> 
+          <td width="200"> 
+            <center><i>default value</i></center> 
+          </td> 
+        </tr> 
+        <tr> 
+          <td><tt>cc</tt></td> 
+          <td>The C compiler</td> 
+          <td><tt>cc</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>ccomp</tt></td> 
+          <td>The C compiling command</td> 
+          <td><tt>$(cc) -c -I$(inc) $(includes) $(cflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>clink</tt></td> 
+          <td>The C linking command</td> 
+          <td><tt>$(cc) $(clinkflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cflags</tt></td> 
+          <td>The C compilation flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>pp_cflags</tt></td> 
+          <td>The preprocessor flags for C</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>clinkflags</tt></td> 
+          <td>The C link flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+      </table> 
+    </p>
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='3'> 
+        <tr> 
+          <td width="150"><tt>cpp</tt></td> 
+          <td width="300">The C++ compiler</td> 
+          <td width="200"><tt>g++</tt></td> 
+        </tr> 
+        <tr> 
+          <td width="150"><tt>preproc</tt></td> 
+          <td width="300">The C++ preprocessor</td> 
+          <td width="200"><tt>g++ -MD -c </tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cppcomp</tt></td> 
+          <td>The C++ compiling command</td> 
+          <td><tt>$(cpp) -c -I$(inc) $(includes) $(cppflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cpplink</tt></td> 
+          <td>The C++ linking command</td> 
+          <td><tt>$(cpp) $(cpplinkflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cppflags</tt></td> 
+          <td>The C++ compilation flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>pp_cppflags</tt></td> 
+          <td>The preprocessor flags for C++</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>cpplinkflags</tt></td> 
+          <td>The C++ link flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+      </table> 
+    </p>
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='3'> 
+        <tr> 
+          <td width="150"><tt>for</tt></td> 
+          <td width="300">The Fortran compiler</td> 
+          <td width="200"><tt>f77</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>fcomp</tt></td> 
+          <td>The Fortran compiling command</td> 
+          <td><tt>$(for) -c -I$(inc) $(includes) $(fflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>flink</tt></td> 
+          <td>The Fortran linking command</td> 
+          <td><tt>$(for) $(clinkflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>fflags</tt></td> 
+          <td>The Fortran compilation flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>pp_fflags</tt></td> 
+          <td>The preprocessor flags for fortran</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>flinkflags</tt></td> 
+          <td>The Fortran link flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>ppcmd</tt></td> 
+          <td>The include file command for Fortran</td> 
+          <td><tt>-I</tt></td> 
+        </tr> 
+      </table> 
+    </p>
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='3'> 
+        <tr> 
+          <td width="150"><tt>javacomp</tt></td> 
+          <td width="300">The java compiling command</td> 
+          <td width="200"><tt>javac</tt></td> 
+        </tr> 
+        <tr> 
+          <td width="150"><tt>jar</tt></td> 
+          <td>The java archiver command</td> 
+          <td><tt>jar</tt></td> 
+        </tr> 
+      </table> 
+    </p>
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='3'> 
+        <tr> 
+          <td width="150"><tt>lex</tt></td> 
+          <td width="300">The Lex command</td> 
+          <td width="200"><tt>lex $(lexflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>lexflags</tt></td> 
+          <td>The Lex flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>yacc</tt></td> 
+          <td>The Yacc command</td> 
+          <td><tt>yacc $(yaccflags)</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>yaccflags</tt></td> 
+          <td>The Yacc flags</td> 
+          <td><i>none</i> </td> 
+        </tr> 
+        <tr> 
+          <td><tt>ar</tt></td> 
+          <td>The archive command</td> 
+          <td><tt>ar -clr</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>ranlib</tt></td> 
+          <td>The ranlib command</td> 
+          <td>r<tt>anlib</tt></td> 
+        </tr> 
+      </table> 
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title="Package customizing macros">
+
+    These macros do not receive default values. They are all prefixed
+    by the package name. They are meant to provide specific variant to
+    the corresponding generic language related macros.
+
+    <p>They are automatically and by default concatenated by
+    <tt>CMT</tt> to fill in the corresponding global <i>use</i> macros
+    (see appendix on <A HREF="#Generated macros">generated
+    macros</A>). However, this concatenation mechanism is discarded
+    when the <tt>-no_auto_imports</tt> option is specified in the
+    corresponding use statement.</p>
+
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td width="250"> 
+            <center><i>macro</i></center> 
+          </td> 
+          <td width="400"> 
+            <center><i>usage</i></center> 
+          </td> 
+        </tr>
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_cflags</tt></td> 
+          <td>specific C flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_pp_cflags</tt></td> 
+          <td>specific C preprocessor flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_cppflags</tt></td> 
+          <td>specific C++ flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_pp_cppflags</tt></td> 
+          <td>specific C++ preprocessor flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_fflags</tt></td> 
+          <td>specific Fortran flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_pp_fflags</tt></td> 
+          <td>specific Fortran preprocessor flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_libraries</tt></td> 
+          <td>
+            gives the (space separated) list of library names exported by this
+            package. This list is typically used in the 
+            <tt>cmt build library_links</tt> command.
+          </td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_linkopts</tt></td> 
+          <td>
+            provide the linker options required by any application willing to 
+            access the different libraries offered by the 
+            package. This may include support for several libraries 
+            per package. 
+
+            <p> 
+              A typical example of how to define such a macro could be : </p>
+
+            <cmt:cmtcode>
+macro Cm_linkopts "-L$(CMROOT)/$(Cm_tag) -lCm -lm" </cmt:cmtcode>
+
+          </td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_stamps</tt></td> 
+          <td>
+
+            may contain a list of <i>stamp</i> file names (or make
+            targets). Whenever a library is modified, one dedicated
+            stamp file is re-created, simply to mark the
+            reconstruction date. The name of this stamp file is
+            conventionally <tt>&lt;<i>library</i>&gt;.stamp</tt>.  Thus,
+            a typical definition for this macro could be :
+
+            <cmt:cmtcode>
+macro Cm_stamps "$(Cm_root)/$(Cm_tag)/Cm.stamp" </cmt:cmtcode>
+
+            <p>Then, these stamp file references are accumulated
+              into the standard macro named <tt>use_stamps</tt> which is
+              always installed within the dependency list for
+              applications, so that whenever one of the libraries used
+              from the hierarchy of used packages changes, the
+              application will be automatically rebuilt.</p>
+           </td>
+        </tr> 
+      </table>
+    </p>
+
+    <p>The following macros are not subject to automatic concatenation
+    (and therefore are not hidden by the <tt>-no_auto_imports</tt>
+    modifier).</p>
+
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td width="250"> 
+            <center><i>macro</i></center> 
+          </td> 
+          <td width="400"> 
+            <center><i>usage</i></center> 
+          </td> 
+        </tr>
+
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_native_version</tt></td> 
+
+          <td>specifies the native version of the external package
+          referenced by this <i>interface</i> package.<br/>When this
+          macro is provided, its value is displayed by the <tt>cmt show
+          uses</tt> command</td>
+
+        </tr>
+
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_export_paths</tt></td> 
+          <td>specifies the list of files or directories that
+          should be exported during the deployment process for
+          this package. Generally this is only useful for glue
+          packages refering to external software</td>
+
+        </tr>
+        <tr> 
+
+          <td><tt>&lt;<i>package</i>&gt;_home</tt></td> 
+
+          <td>specifies the base location for external software
+          described in glue packages. This macro is generally used to
+          specify the previous one</td>
+
+        </tr>
+      </table>
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title="Constituent specific customizing macros">
+
+    These macros do not receive any default values (ie they are empty
+    by default). They are meant to provide for each constituent,
+    specific variants to the corresponding generic language related
+    macros.
+
+    <p>By convention, they are all prefixed by the constituent
+    name. But macros used for defining compiler options are in
+    addition prefixed by the constituent type (either <tt>lib_</tt>,
+    <tt>app_</tt> or <tt>doc_</tt>).</p>
+
+    <p>They are used in the various make fragments for fine
+    customization of the build command parameters.</p>
+
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td><tt>&lt;<i>type</i>&gt;_&lt;<i>constituent</i>&gt;_cflags</tt></td> 
+          <td WIDTH="400">specific C flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>type</i>&gt;_&lt;<i>constituent</i>&gt;_pp_cflags</tt></td> 
+          <td>specific C preprocessor flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>type</i>&gt;_&lt;<i>constituent</i>&gt;_cppflags</tt></td> 
+          <td>specific C++ flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>type</i>&gt;_&lt;<i>constituent</i>&gt;_pp_cppflags</tt></td> 
+          <td>specific C++ preprocessor flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>type</i>&gt;_&lt;<i>constituent</i>&gt;_fflags</tt></td> 
+          <td>specific Fortran flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>type</i>&gt;_&lt;<i>constituent</i>&gt;_pp_fflags</tt></td> 
+          <td>specific Fortran preprocessor flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>constituent</i>&gt;linkopts</tt></td> 
+          <td>
+            provides additional linker options to the application. It is
+            complementary to - and should not be confused with - the
+            <tt>&lt;<i>package</i>&gt;_linkopts</tt> macro, which
+            provides exported linker options required by clients
+            packages to use the package libraries.
+          </td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>constituent</i>&gt;_shlibflags</tt></td> 
+          <td>
+            provides additional linker options used when building a
+            shared library. Generally, a simple shared library does
+            not need any external reference to be resolved at build
+            time (it is in this case supposed to get its unresolved
+            references from other shared libraries). However,
+            (typically when one builds a dynamic loading capable
+            component) it might be desired to statically link it
+            with other libraries (making them somewhat private).
+          </td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>constituent</i>&gt;_dependencies</tt></td> 
+          <td>
+            provides user defined dependency specifications for each
+            constituent. The typical use of this macro is fill it
+            with the name of the list of some other constituents
+            which <i>have</i> to be rebuilt first (since each
+            constituent is associated with a target with the same
+            name). This is especially needed when one want to use
+            the parallel gmake (ie. the -j option of gmake).
+          </td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>group</i>&gt;_dependencies</tt></td> 
+          <td>
+            provides user defined dependency specifications for each
+            group. The typical use of this macro is fill it
+            with the name of the list of some other constituents
+            which <i>have</i> to be rebuilt first (since each
+            constituent is associated with a target with the same
+            name). This is especially needed when one want to use
+            the parallel gmake (ie. the -j option of gmake).
+          </td>
+        </tr> 
+      </table> 
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title="Source specific customizing macros">
+
+    These macros do not receive any default values (ie they are empty
+    by default). They are meant to provide for each source file,
+    specific variants to the corresponding generic language related
+    macros.
+
+    <p>By convention, they are all prefixed by the source file name
+    followed by the source file suffix (either <tt>_c</tt>, <tt>_cxx</tt>,
+    <tt>_f</tt>, etc.)</p>
+
+    <p>They are used in the various make fragments for fine
+    customization of the build command parameters.</p>
+
+    <p> 
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td WIDTH="300"><tt>&lt;<i>constituent</i>&gt;_&lt;<i>suffix</i>&gt;_cflags</tt></td> 
+          <td WIDTH="300">specific C flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>constituent</i>&gt;_&lt;<i>suffix</i>&gt;_cppflags</tt></td> 
+          <td>specific C++ flags</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>constituent</i>&gt;_&lt;<i>suffix</i>&gt;_fflags</tt></td> 
+          <td>specific Fortran flags</td>
+        </tr> 
+      </table> 
+    </p>
+
+  </cmt:section>
+
+  <cmt:section title="Generated macros">
+
+    <p> These macros are automatically <i>generated</i> when any cmt
+    connand is run (and thus when <tt>make</tt> is run).</p>
+
+    <p>The first set of them provide constant values corresponding to
+    <tt>CMT</tt> based information. They are not meant to be overridden
+    by the user, since they serve as a communication mean between
+    <tt>CMT</tt> and the user.</p>
+
+    <p>
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td width="200"><tt>&lt;<i>PACKAGE</i>&gt;ROOT</tt></td> 
+          <td width="400">The access path of the package (including
+          the version branch). This is controlled by the
+          <tt>setup_strategy [no_]root</tt> statement.</td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_root</tt></td> 
+
+          <td>The access path of the package (including the
+          version branch). This macro is very similar to the
+          <tt>&lt;<i>PACKAGE</i>&gt;ROOT</tt> macro except that
+          it tries to use a relative path instead of an
+          absolute one. </td>
+         </tr> 
+        <tr> 
+          <td><tt>&lt;<i>PACKAGE</i>&gt;VERSION</tt></td>
+          <td>The used version of the package.</td> 
+        </tr> 
+        <tr> 
+          <td><tt>PACKAGE_ROOT</tt></td> 
+          <td>The access path of the current package (including the version branch)</td> 
+        </tr> 
+        <tr> 
+          <td><tt>package</tt></td> 
+          <td>The name of the current package</td> 
+        </tr> 
+        <tr> 
+          <td><tt>version</tt></td> 
+          <td>The version tag of the current package</td> 
+        </tr> 
+        <tr> 
+          <td><tt>package_offset</tt></td> 
+          <td>The directory offset of the current package</td> 
+        </tr> 
+        <tr> 
+          <td><tt>package_cmtpath</tt></td> 
+          <td>The package area where the current package has been found</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_project</tt></td> 
+          <td>The project name to which the corresponding package belongs</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_cmtpath</tt></td> 
+          <td>The package area where the corresponding package has been found</td> 
+        </tr> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_offset</tt></td> 
+          <td>The directory offset of the corresponding package</td> 
+        </tr> 
+      </table> 
+    </p>
+    <p>The second set is deduced from the context and from the
+      requirements file of the package. They can be overridden by
+      the user so as to customize the <tt>CMT</tt> behaviour.</p>
+    <p>
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td><tt>&lt;<i>package</i>&gt;_tag</tt></td> 
+          <td width="400">The specific configuration tag for the package. By default it is set to $(tag) but can be freely overridden</td> 
+        </tr> 
+        <tr> 
+          <td><tt>constituents</tt></td> 
+          <td>The ordered set of constituents declared without any group option</td> 
+        </tr> 
+        <tr> 
+          <td><tt><i>&lt;group-name&gt;</i>_constituents</tt></td> 
+          <td>The ordered set of all constituents declared using a group=&lt;group-name&gt; option</td> 
+        </tr> 
+      </table> 
+    </p>
+
+    <p>The third set of generated macros are the <i>global use
+    macros</i>.  They correspond to the concatenation of the
+    corresponding package specific customizing options that can be
+    deduced from the ordered set of <i>use</i> statements found in the
+    requirements file (taking into account the complete hierarchy of
+    used packages with the exception of those specified with the
+    <br/><tt>-no_auto_imports</tt> option in their use statement) :</p>
+
+    <p>
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td width="150"><tt>use_cflags</tt></td> 
+          <td width="400">C compiler flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_pp_cflags</tt></td> 
+          <td>Preprocessor flags for the C language</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_cppflags</tt></td> 
+          <td>C++ compiler flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_pp_cppflags</tt></td> 
+          <td>Preprocessor flags for the C++ language</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_fflags</tt></td> 
+          <td>Fortran compiler flags</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_pp_fflags</tt></td> 
+          <td>Preprocessor flags for the Fortran language</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_libraries</tt></td> 
+          <td>List of library names</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_linkopts</tt></td> 
+          <td>Linker options</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_stamps</tt></td> 
+          <td>Dependency stamps</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_requirements</tt></td> 
+          <td>The set of used requirements</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_includes</tt></td> 
+          <td>The set of include search paths options for the preprocessor from the used packages</td> 
+        </tr> 
+        <tr> 
+          <td><tt>use_fincludes</tt></td> 
+          <td>The set of include search paths options for the fortran preprocessor from the used packages</td> 
+        </tr> 
+        <tr> 
+          <td><tt>includes</tt></td> 
+          <td>The overall set of include search paths for the preprocessor</td> 
+        </tr> 
+        <tr> 
+          <td><tt>fincludes</tt></td> 
+          <td>The overall set of include search paths options for the fortran preprocessor</td> 
+        </tr> 
+      </table> 
+    </p>
+
+  </cmt:section> 
+
+  <cmt:section title="Macros related with the installation area mechanisms">
+
+    These macros contain the parameterisation of the installation area
+    mechanisms.
+
+    <p><font size="-10">
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td width="250"> 
+            <center><i>macro</i></center> 
+          </td> 
+          <td width="20"> 
+            <center><i>usage</i></center> 
+          </td> 
+          <td width="300"> 
+            <center><i>default value</i></center> 
+          </td> 
+        </tr>
+         <tr> 
+          <td><tt>cmt_installarea_command</tt></td> 
+          <td>&nbsp;</td> 
+          <td>&nbsp;</td> 
+        </tr> 
+        <tr> 
+          <td><tt>cmt_uninstallarea_command</tt></td> 
+          <td>&nbsp;</td> 
+          <td>&nbsp;</td> 
+        </tr> 
+        <tr> 
+          <td><tt>cmt_install_action</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>$(CMTROOT)\mgr\cmt_install_action.bat</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cmt_installdir_action</tt></td> 
+          <td>&nbsp;</td>
+          <td><tt>$(CMTROOT)\mgr\cmt_installdir_action.bat</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>cmt_uninstall_action</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>$(CMTROOT)\mgr\cmt_uninstall_action.bat</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>cmt_uninstalldir_action</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>$(CMTROOT)\mgr\cmt_uninstalldir_action.bat</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>cmt_installdir_excludes</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>$(CMTROOT)\mgr\cmt_installdir_excludes.txt</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>cmt_installarea_prefix</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>InstallArea</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>&lt;project&gt;_installarea_prefix</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>$(cmt_installarea_prefix)</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>CMTINSTALLAREA</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>C:\Arnault\test\tprojects\PC\InstallArea</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>cmt_installarea_paths</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>&nbsp;</tt></td> 
+        </tr> 
+        <tr> 
+          <td><tt>cmt_installarea_linkopts</tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>&nbsp;</tt></td> 
+        </tr> 
+
+<!--
+
+        <tr> 
+          <td><tt></tt></td> 
+          <td>&nbsp;</td> 
+          <td><tt>&nbsp;</tt></td> 
+        </tr> 
+-->
+
+      </table> 
+    </font></p>
+
+  </cmt:section> 
+
+  <cmt:section title="Utility macros">
+
+    These macros are used to specify the behaviour of various actions
+    in CMT.
+
+    <p>
+      <table BORDER='1' cellspacing='0' COLS='2'> 
+        <tr> 
+          <td width="150"><center><i>macro</i></center></td> 
+          <td width="250"><center><i>usage</i></center></td> 
+          <td width="200"><center><i>default on Unix</i></center></td> 
+        </tr> 
+        <tr> 
+          <td><tt>X11_cflags</tt></td> 
+          <td>compilation flags for X11</td> 
+          <td><tt>-I/usr/include</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>Xm_cflags</tt></td> 
+          <td>compilation flags for Motif</td> 
+          <td><tt>-I/usr/include</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>X_linkopts</tt></td> 
+          <td>Link options for XWindows (and Motif)</td> 
+          <td>&nbsp;</td>
+        </tr> 
+        <tr> 
+          <td><tt>make_shlib</tt></td> 
+          <td>The command used to generate the shared library from the static one</td> 
+          <td><tt>${CMTROOT}/mgr/cmt_make_shlib_common.sh extract</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>shlibsuffix</tt></td> 
+          <td>The system dependent suffix for shared libraries</td> 
+          <td><tt>so</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>shlibbuilder</tt></td> 
+          <td>The loader used to build the shared library</td> 
+          <td><tt>g++</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>shlibflags</tt></td> 
+          <td>The additional options given to the shared library builder</td> 
+          <td><tt>-shared</tt></td>
+        </tr> 
+
+        <tr> 
+          <td><tt>application_suffix</tt></td> 
+          <td>The default extension for applications</td>
+          <td><tt>.exe</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>library_prefix</tt></td> 
+          <td>The default name prefix of libraries</td> 
+          <td><tt>lib</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>library_suffix</tt></td> 
+          <td>The default name suffix of libraries</td> 
+          <td>&nbsp;</td>
+        </tr> 
+        <tr> 
+          <td><tt>symlink</tt></td> 
+          <td>The command used to install a symbolic link</td> 
+          <td><tt>/bin/ln -fs</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt></tt></td> 
+          <td>The command used to remove a symbolic link</td> 
+          <td><tt>/bin/rm -f </tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>build_prototype</tt></td> 
+          <td>The command used to generate the C prototype header file (default to the internal cmt dedicated command)</td> 
+          <td><tt>$(cmtexe) build prototype</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>build_dependencies</tt></td> 
+          <td>The command used to generate dependencies (default to the internal cmt dedicated command)</td> 
+          <td><tt>$(cmtexe) -quiet -tag=$(tags) build dependencies</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>lock_command</tt></td> 
+          <td>The command used to physically lock a package</td> 
+          <td><tt>chmod -R a-w ../*</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>unlock_command</tt></td> 
+          <td>The command used to physically unlock a package</td> 
+          <td><tt>chmod -R g+w ../*</tt></td>
+        </tr> 
+        <tr> 
+          <td><tt>make_hosts</tt></td> 
+          <td>The list of remote host names which exactly require the <tt>make</tt> command</td> 
+          <td>&nbsp;</td>
+        </tr> 
+        <tr> 
+          <td><tt>gmake_hosts</tt></td> 
+          <td>The list of remote host names which exactly require the <tt>gmake</tt> command</td> 
+          <td>&nbsp;</td>
+        </tr> 
+
+<!--
+        <tr> 
+          <td><tt></tt></td> 
+          <td></td> 
+          <td>&nbsp;</td>
+        </tr> 
+-->
+
+      </table> 
+    </p>
+
+  </cmt:section> 
+
+</cmt:section> 
+
+<cmt:section title="Standard tags generated by CMT">
+
+  <p>
+    <table BORDER='1' cellspacing='0' COLS='3'> 
+      <tr>
+        <td width="150"><center><i>tag name</i></center></td>
+        <td width="400"><center><i>usage</i></center></td>
+      </tr>
+
+      <tr>
+        <td><tt>CMTv&lt;n&gt;</tt></td>
+        <td>Primary version id of CMT</td>
+      </tr>
+      <tr>
+        <td><tt>CMTr&lt;n&gt;</tt></td>
+        <td>Secondary version id of CMT</td>
+      </tr>
+      <tr>
+        <td><tt>CMTp&lt;n&gt;</tt></td>
+        <td>Patch id of CMT</td>
+      </tr>
+      <tr>
+        <td><tt>`uname`</tt></td>
+        <td>The basic platform id</td>
+      </tr>
+      <tr>
+        <td><tt>&lt;project-name&gt;</tt></td>
+        <td>The current project name</td>
+      </tr>
+      <tr>
+        <td>
+          <table>
+            <tr><td><tt>&lt;project&gt;_prototypes</tt></td></tr>
+            <tr><td><tt>&lt;project&gt;_no_prototypes</tt></td></tr>
+          </table>
+        </td>
+        <td>The prototypes strategy for each project</td>
+      </tr>
+      <tr>
+        <td>
+          <table>
+            <tr><td><tt>&lt;project&gt;_with_installarea</tt></td></tr>
+            <tr><td><tt>&lt;project&gt;_without_installarea</tt></td></tr>
+          </table>
+        </td>
+        <td>The installation area strategy for each project</td>
+      </tr>
+      <tr>
+        <td>
+          <table>
+            <tr><td><tt>&lt;project&gt;_setup_config</tt></td></tr>
+            <tr><td><tt>&lt;project&gt;_setup_no_config</tt></td></tr>
+          </table>
+        </td>
+        <td>The strategy for generating <tt>&lt;P&gt;CONFIG</tt> for each project</td>
+      </tr>
+      <tr>
+        <td>
+          <table>
+            <tr><td><tt>&lt;project&gt;_setup_root</tt></td></tr>
+            <tr><td><tt>&lt;project&gt;_setup_no_root</tt></td></tr>
+          </table>
+        </td>
+        <td>The strategy for generating <tt>&lt;P&gt;ROOT</tt> for each project</td>
+      </tr>
+      <tr>
+        <td>
+          <table>
+            <tr><td><tt>&lt;project&gt;_setup_cleanup</tt></td></tr>
+            <tr><td><tt>&lt;project&gt;_setup_no_cleanup</tt></td></tr>
+          </table>
+        </td>
+        <td>The installation area cleanup strategy for each project</td>
+      </tr>
+
+
+<!--
+
+      <tr>
+        <td><tt>&nbsp;</tt></td>
+        <td>&nbsp;</td>
+      </tr>
+
+-->
+
+    </table> 
+  </p>
+
+</cmt:section> 
+
+<cmt:section title="Standard templates for makefile fragments">
+
+  <p>
+    <table BORDER='1' cellspacing='0' COLS='3'> 
+      <tr>
+        <td width="150"><center><i>template name</i></center></td>
+        <td width="200"><center><i>usage</i></center></td>
+        <td width="400"><center><i>used in fragment</i></center></td>
+      </tr>
+      <tr>
+        <td><tt>ADDINCLUDE</tt></td>
+        <td>additional include path</td>
+        <td>&lt;<i>language</i>&gt; java</td>
+      </tr>
+      <tr>
+        <td><tt>CONSTITUENT</tt></td>
+        <td>name of the constituent</td>
+        <td>&lt;<i>language</i>&gt; java jar make_header jar_header java_header library_header application_header protos_header library_no_share library application dependencies cleanup_header cleanup_library cleanup_application check_application document_header &lt;document&gt; trailer dsw_all_project_dependency dsw_project dsp_library_header dsp_shared_library_header dsp_windows_header dsp_application_header dsp_trailer constituent check_application_header</td>
+      </tr>
+      <tr>
+        <td><tt>DATE</tt></td>
+        <td>now</td>
+        <td>make_header</td>
+      </tr>
+      <tr>
+        <td><tt>FILENAME</tt></td>
+        <td>file name without path</td>
+        <td>buildproto &lt;<i>language</i>&gt; &lt;<i>document</i>&gt;</td>
+      </tr>
+      <tr>
+        <td><tt>FILEPATH</tt></td>
+        <td>file path</td>
+        <td>buildproto &lt;<i>language</i>&gt; &lt;<i>document</i>&gt;</td>
+      </tr>
+      <tr>
+        <td><tt>FILESUFFIX</tt></td>
+        <td>file suffix (without dot)</td>
+        <td>&lt;<i>language</i>&gt;</td>
+      </tr>
+      <tr>
+        <td><tt>FILESUFFIX</tt></td>
+        <td>file suffix (with dot)</td>
+        <td>&lt;<i>document</i>&gt;</td>
+      </tr>
+      <tr>
+        <td><tt>FULLNAME</tt></td>
+        <td>complete file path and name</td>
+        <td>&lt;<i>language</i>&gt; cleanup &lt;<i>document</i>&gt; dsp_contents</td>
+      </tr>
+      <tr>
+        <td><tt>GROUP</tt></td>
+        <td>group name</td>
+        <td>constituents_header</td>
+      </tr>
+      <tr>
+        <td><tt>LINE</tt></td>
+        <td>source files</td>
+        <td>&lt;<i>language</i>&gt; dependencies constituent</td>
+      </tr>
+      <tr>
+        <td><tt>LINKMACRO</tt></td>
+        <td>link macro</td>
+        <td>application</td>
+      </tr>
+      <tr>
+        <td><tt>NAME</tt></td>
+        <td>file name without path and suffix</td>
+        <td>buildproto &lt;<i>language</i>&gt; java &lt;<i>document</i>&gt;</td>
+      </tr>
+      <tr>
+        <td><tt>OBJS</tt></td>
+        <td>object files</td>
+        <td>jar_header java_header jar library_no_share library application cleanup_java document_header trailer</td>
+      </tr>
+      <tr>
+        <td><tt>OUTPUTNAME</tt></td>
+        <td>output file name</td>
+        <td>java</td>
+      </tr>
+      <tr>
+        <td><tt>PACKAGE</tt></td>
+        <td>current package name</td>
+        <td>&lt;<i>language</i>&gt; dsw_header dsw_all_project dsw_all_project_trailer dsw_trailer dsp_all readme_header readme readme_use readme_trailer</td>
+      </tr>
+      <tr> 
+        <td><tt>PACKAGEPATH</tt></td>
+        <td>current package location</td>
+        <td>readme_use</td>
+      </tr>
+      <tr>
+        <td><tt>PROTOSTAMPS</tt></td>
+        <td>prototype stamp files</td>
+        <td>protos_header</td>
+      </tr>
+      <tr>
+        <td><tt>PROTOTARGET</tt></td>
+        <td>prototype target name</td>
+        <td>library_header application_header</td>
+      </tr>
+      <tr>
+        <td><tt>SUFFIX</tt></td>
+        <td>document suffix</td>
+        <td>&lt;<i>document</i>&gt;</td>
+      </tr>
+      <tr>
+        <td><tt>TITLE</tt></td>
+        <td>title for make header</td>
+        <td>make_header</td>
+      </tr>
+      <tr>
+        <td><tt>USER</tt></td>
+        <td>user name</td>
+        <td>make_header</td>
+      </tr>
+      <tr>
+        <td><tt>VERSION</tt></td>
+        <td>current package version tag</td>
+        <td>readme_header readme readme_use</td>
+      </tr>
+    </table>
+  </p>
+
+</cmt:section>
+
+<cmt:section title="Makefile generation sequences">
+
+  <cmt:blockquote> 
+
+    This section describes the various makefile generation sequences
+    provided by <tt>CMT</tt>. Each sequence description shows the
+    precise set of <a href="#make_fragment">make fragments</a> used
+    during the operation.
+
+  </cmt:blockquote> 
+
+  <p>
+    <table border='1' cellspacing='0' cols='3'>
+
+      <tr>
+        <td width="200"><center><i>Generated makefile</i></center></td>
+        <td width="250"><center><i>description</i></center></td>
+        <td width="350"><center><i>used make fragments</i></center></td> 
+      </tr>
+       <tr>
+        <td><tt>constituents.make</tt></td>
+        <td>the main entry point point for all constituent targets</td>
+        <td>
+          <ol>
+            <li>constituents_header</li>
+            <li>constituent</li>
+            <li>check_application_header</li>
+          </ol>
+        </td>
+      </tr>
+       <tr>
+        <td><tt>&lt;<i>constituent</i>&gt;.make</tt></td>
+        <td>application or library specific make fragment</td>
+        <td>
+          <ol>
+            <li>make_header</li>
+            <li>java_header | jar_header | library_header | application_header</li>
+            <li>protos_header</li>
+            <li>buildproto</li>
+            <li>jar | library | library_no_share | application</li>
+            <li>dependencies</li>
+            <li>&lt;language&gt; | &lt;language&gt;_library | java</li>
+            <li>cleanup_header</li>
+            <li>cleanup</li>
+            <li>cleanup_application</li>
+            <li>cleanup_objects</li>
+            <li>cleanup_java</li>
+            <li>cleanup_library</li>
+            <li>check_application</li>
+          </ol>
+        </td>
+      </tr>
+       <tr>
+        <td><tt>&lt;<i>constituent</i>&gt;.make</tt></td>
+        <td>document specific make fragment</td>
+        <td>
+          <ol>
+            <li>make_header</li>
+            <li>document_header</li>
+            <li>dependencies</li>
+            <li>&lt;document&gt;</li>
+            <li>&lt;document-trailer&gt;</li>
+            <li>cleanup_header</li>
+          </ol>
+        </td>
+      </tr>
+        <tr>
+        <td><tt>&lt;package&gt;.dsw</tt></td>
+        <td>Visual workspace configuration files</td>
+        <td>
+          <ol>
+            <li>dsw_header</li>
+            <li>dsw_all_project_header</li>
+            <li>dsw_all_project_dependency</li>
+            <li>dsw_all_project_trailer</li>
+            <li>dsw_project</li>
+            <li>dsw_trailer</li>
+            <li>dsp_all</li>
+          </ol>
+        </td>
+      </tr>
+        <tr>
+        <td><tt>&lt;constituent&gt;.dsp</tt></td>
+        <td>Visual project configuration files</td>
+        <td>
+          <ol>
+            <li>dsp_library_header | dsp_shared_library_header | dsp_windows_header | dsp_application_header</li>
+            <li>dsp_contents</li>
+            <li>dsp_trailer</li>
+          </ol>
+        </td>
+      </tr>
+        <tr>
+        <td><tt>README</tt></td>
+        <td>.</td>
+        <td>
+          <ol>
+            <li>readme_header</li>
+            <li>readme</li>
+            <li>readme_use</li>
+            <li>readme_trailer</li>
+          </ol>
+        </td>
+      </tr>
+    </table>
+  </p>
+
+</cmt:section>
+
+<cmt:section title="The complete project file syntax">
+
+  The syntax of specification statements that can be installed in a
+  <tt>project.cmt</tt> file are :
+
+<cmt:syntax rule-width="220" name="CMTProject">
+  <cmt:rule name="cmt-statement">
+    <cmt:alt><cmt:ruleref name="build_strategy"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="container"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="project"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="setup_strategy"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="structure_strategy"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="use"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="build_strategy">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="build-strategy-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="build-strategy-name">
+    <cmt:alt><cmt:kwd name="prototypes"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_prototypes"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="with_installarea"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="without_installarea"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="container">
+    <cmt:alt>
+      <cmt:kwd/> <cmt:term name="container-name"/>
+      <cmt:option>
+        <cmt:ruleref name="version-tag"/>
+	<cmt:option>
+	  <cmt:term name="access-path"/>
+	</cmt:option>
+      </cmt:option>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="project">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="project-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="setup_strategy">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="setup-strategy-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="setup-strategy-name">
+    <cmt:alt><cmt:kwd name="config"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_config"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="root"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_root"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="cleanup"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_cleanup"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="structure_strategy">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="structure-strategy-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="structure-strategy-name">
+    <cmt:alt><cmt:kwd name="with_version_directory"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="without_version_directory"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="use">
+    <cmt:alt>
+      <cmt:kwd/> <cmt:term name="project-name"/>
+      <cmt:option>
+        <cmt:ruleref name="release-tag"/>
+	<cmt:option>
+	  <cmt:term name="access-path"/>
+	</cmt:option>
+      </cmt:option>
+    </cmt:alt>
+  </cmt:rule>
+</cmt:syntax>
+
+</cmt:section> 
+
+<cmt:section title="The complete requirements syntax">
+
+  The syntax of specification statements that can be installed in a
+  <tt>requirements</tt> file are :
+
+<cmt:syntax rule-width="220" name="CMT">
+  <cmt:rule name="cmt-statement">
+    <cmt:alt><cmt:ruleref name="application"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="apply_pattern"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="apply_tag"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="author"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="branches"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="build_strategy"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="cleanup_script"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="cmtpath_pattern"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="document"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="ignore_pattern"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="include_dirs"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="include_path"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="language"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="library"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="make_fragment"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="manager"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="package"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="pattern"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="private"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="public"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="setup_script"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="setup_strategy"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="structure_strategy"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="symbol"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="tag"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="tag_exclude"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="use"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="version"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="alias">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="alias-name"/>
+      <cmt:term name="default-value"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="application">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="application-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="constituent-option"/>
+      </cmt:optionseq>
+    </cmt:alt>
+    <cmt:continuation>
+      <cmt:optionseq>
+        <cmt:ruleref name="source"/>
+      </cmt:optionseq>
+    </cmt:continuation>
+  </cmt:rule>
+  <cmt:rule name="constituent-option">
+    <cmt:alt><cmt:kwd name="-no_share"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-no_static"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-prototypes"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-no_prototypes"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-check"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-target_tag"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-group" value="group-name"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-suffix" value="output-suffix"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-import" value="package-name"/></cmt:alt>
+    <cmt:alt>
+      <cmt:term name="variable-name"/>
+      <cmt:kwd name="="/>
+      <cmt:term name="variable-value"/>
+    </cmt:alt>
+    <cmt:alt><cmt:kwd name="-OS9"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-windows"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="source">
+    <cmt:alt><cmt:term name="name.suffix"/></cmt:alt>
+    <cmt:alt><cmt:term name="*.suffix"/></cmt:alt>
+    <cmt:alt><cmt:term name="*.*"/></cmt:alt>
+    <cmt:alt>
+      <cmt:kwd name="-s" value="new-search-path"/>
+    </cmt:alt>
+    <cmt:alt>
+      <cmt:kwd name="-k" value="selection-regexp"/>
+    </cmt:alt>
+    <cmt:alt>
+      <cmt:kwd name="-x" value="exclusion-regexp"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="apply_pattern">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="pattern-name"/>
+      <cmt:optionseq>
+        <cmt:term name="template-name"/>
+	<cmt:kwd name="="/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="apply_tag">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="tag-name"/>
+      <cmt:optionseq>
+        <cmt:term name="tag-name"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="author">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="author-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="branches">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:seq><cmt:term name="branch-name"/></cmt:seq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="build_strategy">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="build-strategy-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="build-strategy-name">
+    <cmt:alt><cmt:kwd name="prototypes"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_prototypes"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="with_installarea"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="without_installarea"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="cleanup_script">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="script-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="cmtpath_pattern">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:ruleref name="cmt-statement"/>
+    </cmt:alt>
+    <cmt:continuation>
+      <cmt:optionseq>
+        <cmt:kwd name=" ; "/>
+        <cmt:ruleref name="cmt-statement"/>
+      </cmt:optionseq>
+    </cmt:continuation>
+  </cmt:rule>
+  <cmt:rule name="document">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="document-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="constituent-option"/>
+      </cmt:optionseq>
+    </cmt:alt>
+    <cmt:continuation>
+      <cmt:optionseq>
+        <cmt:ruleref name="source"/>
+      </cmt:optionseq>
+    </cmt:continuation>
+  </cmt:rule>
+  <cmt:rule name="ignore_pattern">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="pattern-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="include_dirs">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="search-path"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="include_path">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="search-path"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="language">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="language-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="language-option"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="language-option">
+    <cmt:alt><cmt:kwd name="-suffix" value="suffix"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-linker" value="linker-command"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-prototypes"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-preprocessor_command" value="preprocessor_command"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-fragment" value="fragment"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-output_suffix" value="output-suffix"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-extra_output_suffix" value="extra-output-suffix"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="library">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="library-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="constituent-option"/>
+      </cmt:optionseq>
+    </cmt:alt>
+    <cmt:continuation>
+      <cmt:optionseq>
+        <cmt:ruleref name="source"/>
+      </cmt:optionseq>
+    </cmt:continuation>
+  </cmt:rule>
+  <cmt:rule name="action">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="action-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="macro">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="macro-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="macro_append">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="macro-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="macro_prepend">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="macro-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="macro_remove">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="macro-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="macro_remove_regexp">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="macro-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="macro_remove_all">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="macro-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="macro_remove_all_regexp">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="macro-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="make_fragment">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="fragment-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="fragment-option"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="fragment-option">
+    <cmt:alt><cmt:kwd name="-suffix" value="suffix"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-dependencies"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-header" value="fragment"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-trailer" value="fragment"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="manager">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="manager-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="package">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="package-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="path">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="path-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="path_append">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="path-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="path_prepend">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="path-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="path_remove">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="path-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="path_remove_regexp">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="path-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="pattern">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:option><cmt:kwd name="-global"/></cmt:option>
+      <cmt:term name="pattern-name"/>
+      <cmt:ruleref name="cmt-statement"/>
+    </cmt:alt>
+    <cmt:continuation>
+      <cmt:optionseq>
+        <cmt:kwd name=" ; "/>
+        <cmt:ruleref name="cmt-statement"/>
+      </cmt:optionseq>
+    </cmt:continuation>
+  </cmt:rule>
+  <cmt:rule name="private">
+    <cmt:alt><cmt:kwd/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="public">
+    <cmt:alt><cmt:kwd/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="set">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="set-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="set_append">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="set-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="set_prepend">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="set-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="set_remove">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="set-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="set_remove_regexp">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="set-name"/>
+      <cmt:optionseq>
+        <cmt:ruleref name="tag-expr"/>
+        <cmt:term name="value"/>
+      </cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="setup_script">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="script-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="setup_strategy">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="setup-strategy-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="setup-strategy-name">
+    <cmt:alt><cmt:kwd name="config"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_config"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="root"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_root"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="cleanup"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="no_cleanup"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="structure_strategy">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="structure-strategy-name"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="structure-strategy-name">
+    <cmt:alt><cmt:kwd name="with_version_directory"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="without_version_directory"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="symbol">
+    <cmt:alt><cmt:ruleref name="alias"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="action"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="macro"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="macro_append"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="macro_prepend"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="macro_remove"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="macro_remove_regexp"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="macro_remove_all"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="macro_remove_all_regexp"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="path"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="path_append"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="path_prepend"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="path_remove"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="path_remove_regexp"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="set"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="set_append"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="set_prepend"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="set_remove"/></cmt:alt>
+    <cmt:alt><cmt:ruleref name="set_remove_regexp"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="tag">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="tag-name"/>
+      <cmt:optionseq><cmt:term name="tag-name"/></cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="tag_exclude">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="tag-name"/>
+      <cmt:optionseq><cmt:term name="tag-name"/></cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="tag-expr">
+    <cmt:alt>
+      <cmt:term name="tag-name"/>
+      <cmt:optionseq><cmt:kwd name="&amp;"/><cmt:term name="tag-name"/></cmt:optionseq>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="use">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:term name="package-name"/>
+      <cmt:option>
+        <cmt:ruleref name="version-tag"/>
+	<cmt:option>
+	  <cmt:term name="access-path"/>
+	</cmt:option>
+      </cmt:option>
+    </cmt:alt>
+    <cmt:continuation>
+      <cmt:option>
+        <cmt:ruleref name="use-option"/>
+      </cmt:option>
+    </cmt:continuation>
+  </cmt:rule>
+  <cmt:rule name="version">
+    <cmt:alt>
+      <cmt:kwd/>
+      <cmt:ruleref name="version-tag"/>
+    </cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="version-tag">
+    <cmt:alt>
+      <cmt:ruleref name="key"/>
+      <cmt:term name="version-number"/>
+    </cmt:alt>
+    <cmt:continuation>
+      <cmt:option>
+        <cmt:ruleref name="key"/>
+	<cmt:term name="release-number"/>
+        <cmt:option>
+          <cmt:ruleref name="key"/>
+	  <cmt:term name="patch-number"/>
+        </cmt:option>
+      </cmt:option>
+    </cmt:continuation>
+  </cmt:rule>
+  <cmt:rule name="use-option">
+    <cmt:alt><cmt:kwd name="-no_auto_imports"/></cmt:alt>
+    <cmt:alt><cmt:kwd name="-auto_imports"/></cmt:alt>
+  </cmt:rule>
+  <cmt:rule name="key">
+    <cmt:alt><cmt:seq><cmt:term name="letter"/></cmt:seq></cmt:alt>
+  </cmt:rule>
+</cmt:syntax>
+
+</cmt:section> 
+
+<cmt:section title="The default strategies defined in CMT">
+
+  <cmt:cmtcode>
+  build_strategy prototypes | without_installarea
+  setup_strategy config | root
+  structure_strategy with_version_directory</cmt:cmtcode>
+
+</cmt:section> 
+
+<cmt:section title="The internal mechanism of cmt cvs operations">
+
+  Generally, CVS does not handle queries upon the repository (such as
+  knowing all installed modules, all tags of the modules
+  etc..). Various tools such as CVSWeb, LXR etc. provide very powerful
+  answers to this question, but all through a Web browser.
+
+  <p><tt>CMT</tt> provides a hook that can be installed within a CVS
+  repository, based on a helper script that will be activated upon a
+  particular CVS command, and that is able to perform some level of
+  scan within this repository and return filtered information. </p>
+
+  <p>More precisely, this helper script (found in
+  <tt>${CMTROOT}/mgr/cmt_buildcvsinfos2.sh</tt>) is meant to be declared
+  within the <tt>loginfo</tt> management file (see the <a
+  href="http://www.cvshome.org/docs/manual/index.html">CVS manual</a>
+  for more details) as one entry named <tt>.cmtcvsinfos</tt>, able to
+  launch the helper script. This installation can be operated at once
+  using the following sequence:</p>
+
+  <cmt:code>
+sh&gt; cd ${CMTROOT}/mgr
+sh&gt; gmake installcvs</cmt:code> 
+
+  <p>This mechanism is thus fully compatible with standard remote
+  access to the repository.</p>
+
+  <p>Once the helper script is installed, the mechanism operates as
+  follows (this actually describes the algorithms installed in the
+  <tt>CvsImplementation::show_cvs_infos</tt> method available in
+  <tt>cmt_cvs.cxx</tt> and is transparently run when one uses the <tt>cmt
+  cvs<i>xxx</i> commands</tt>):</p>
+
+  <ol>
+
+    <li>Find a location for working with temporary files. This is
+    generally deduced from the <tt>${TMPDIR}</tt> environment variable
+    or in <tt>/tmp</tt> (or in the current directory if none of these
+    methods apply).</li>
+
+    <li>There, install a directory named
+    <tt>cmtcvs/&lt;<i>unique-name</i>&gt;/.cmtcvsinfos</tt></li>
+
+    <li>Then, from this directory, try to run a fake import command
+    built as follows:
+
+      <cmt:code>
+cvs -Q import -m cmt .cmtcvsinfos/&lt;protocol-level&gt;/&lt;<i>package-name</i>&gt; CMT v1 </cmt:code> 
+
+      <p>Obviously this command is fake, since no file exist in the
+      temporary directory we have just created. The
+      <tt>protocol-level</tt> referenced in this command is described
+      in the standard macro <tt>$(cmt_cvs_protocol_level)</tt>.</p>
+
+    </li>
+
+    <li>This action actually triggers the CVS pluggin installed in the
+    <tt>loginfo</tt> CVS metafile. A default pluggin is provided by
+    CMT implemented as a shell script,
+
+      <tt>cmt_buildcvsinfos2.sh</tt>, which simply receives in its
+      argument the module name onto which we need information. This
+      information is obtained by scanning the files into the
+      repository, and an answer is built with the following syntax:
+
+      <cmt:code>
+[error=<i>error-text</i>]            (1)
+tags=<i>tag</i> ...                  (2)
+branches=<i>branch</i> ...           (3)
+subpackages=<i>sub-package</i> ...   (4)</cmt:code>
+
+      <ol>
+
+        <li>In case of error (typically when the requested module is
+        not found in the repository) a text explaining the error
+        condition is returned</li>
+
+        <li>The list of tags found on the requirements file</li>
+
+        <li>The list of branches defined in this packages (ie
+        subdirectories not containing a requirements file)</li>
+
+        <li>The list of subpackages (ie subdirectories containing a
+        requirements files)</li>
+
+      </ol>
+    </li>
+
+    <li>
+      Another version of this pluggin is also available as a C++
+      application. This application is available for download at the
+      <a href="http://www.cmtsite.org">CMT web site</a>.
+    </li>
+  </ol>
+
+</cmt:section>
+
+</cmt:section>
+
+</cmt:book>
Index: /CMT/v1r20/doc/CMTDownload.html
===================================================================
--- /CMT/v1r20/doc/CMTDownload.html	(revision 368)
+++ /CMT/v1r20/doc/CMTDownload.html	(revision 368)
@@ -0,0 +1,78 @@
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html><head><!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+--><title>CMTDownload</title><!-- Changed by: Christian Arnault, 10-Apr-2002 --><!-- phpmyvisites -->
+        
+
+<script type="text/javascript">
+<!--
+var a_vars = Array();
+var pagename='';
+
+var phpmyvisitesSite = 1;
+var phpmyvisitesURL = "http://www.cmtsite.org/phpmv2/phpmyvisites.php";
+//-->
+</script><script language="javascript" src="CMTDownload_fichiers/phpmyvisites.js" type="text/javascript"></script></head><body alink="#007777" bgcolor="#ffffff" link="#550088"><a href="http://www.phpmyvisites.net/" title="phpMyVisites | Open source web analytics" onclick="window.open(this.href);return(false);">
+
+<img src="CMTDownload_fichiers/phpmyvisites.gif" alt="phpMyVisites" style="border: 0pt none ;">
+
+<noscript>
+<p>phpMyVisites | Open source web analytics
+<img src="http://www.cmtsite.org/phpmv2/phpmyvisites.php" alt="phpMyVisites" style="border:0" />
+</p>
+</noscript>
+</a>
+<!-- /phpmyvisites -->
+
+  
+    <h1>CMTDownload</h1>
+
+      <blockquote>
+
+        <i>You should first download the source kit of CMT, and this kit is
+      complete for a local rebuild. In addition, it is optionally
+      possible to obtain some prebuilt binaries for some platforms
+      (note that any binary kit also requires to first download the
+      source kit for a proper installation of CMT):
+        </i>
+      </blockquote>
+
+      <center>
+	<table border="1" cols="1">
+
+<tbody><tr><td><a href="http://www.cmtsite.org/phpmv2/phpmyvisites.php?url=http://www.cmtsite.org/v1r19/CMTv1r19.tar.gz&amp;id=1&amp;pagename=FILE:CMTv1r19.tar.gz">Source kit</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/phpmv2/phpmyvisites.php?url=http://www.cmtsite.org/v1r19/CMTv1r19OSF1-alpha.tar.gz&amp;id=1&amp;pagename=FILE:CMTv1r19OSF1-alpha.tar.gz">OSF1-alpha</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/phpmv2/phpmyvisites.php?url=http://www.cmtsite.org/v1r19/CMTv1r19Linux-i686.tar.gz&amp;id=1&amp;pagename=FILE:CMTv1r19Linux-i686.tar.gz">Linux-i686</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/phpmv2/phpmyvisites.php?url=http://www.cmtsite.org/v1r19/CMTv1r19Linux-x86_64.tar.gz&amp;id=1&amp;pagename=FILE:CMTv1r19Linux-x86_64.tar.gz">Linux-x86_64</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/phpmv2/phpmyvisites.php?url=http://www.cmtsite.org/v1r19/CMTv1r19Linux-ia64.tar.gz&amp;id=1&amp;pagename=FILE:CMTv1r19Linux-ia64.tar.gz">Linux-ia64</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/v1r19/CMTv1r19SunOS-sun4u.tar.gz">SunOS-sun4u</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/v1r19/CMTv1r19AIX-002064874C00.tar.gz">AIX-002064874C00</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/phpmv2/phpmyvisites.php?url=http://www.cmtsite.org/v1r19/CMTv1r19VisualC.tar.gz&amp;id=1&amp;pagename=FILE:CMTv1r19VisualC.tar.gz">VisualC</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/v1r19/CMTv1r19CYGWIN_NT-5.1-i686.tar.gz">CYGWIN_NT-5.1-i686</a> </td></tr>
+<tr><td><a href="http://www.cmtsite.org/phpmv2/phpmyvisites.php?url=http://www.cmtsite.org/v1r19/CMTv1r19Darwin-PowerMacintosh.tar.gz&amp;id=1&amp;pagename=FILE:CMTv1r19Darwin-PowerMacintosh.tar.gz">Darwin-PowerMacintosh</a> </td></tr>
+
+
+<!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+-->
+
+
+	</tbody></table>
+      </center>
+
+
+    <hr>
+    <address><a href="mailto:garonne@lal.in2p3.fr">vincent Garonne</a></address>
+    <!-- Created: Thu Feb  3 15:55:09 MET 2000 -->
+    <!-- hhmts start -->
+Last modified: Wed Nov 22 15:55:11 CEST 2006
+<!-- hhmts end -->
+  </body></html>
Index: /CMT/v1r20/doc/CMTDownload1.html
===================================================================
--- /CMT/v1r20/doc/CMTDownload1.html	(revision 368)
+++ /CMT/v1r20/doc/CMTDownload1.html	(revision 368)
@@ -0,0 +1,30 @@
+<!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+-->
+
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+  <head>
+    <title>CMTDownload</title>
+    <!-- Changed by: Christian Arnault, 10-Apr-2002 -->
+  </head>
+  
+  <body BGCOLOR="#FFFFFF" link="#550088" alink="#007777" alink="#007777">
+    <h1>CMTDownload</h1>
+
+      <blockquote>
+
+        <i>You should first download the source kit of CMT, and this kit is
+      complete for a local rebuild. In addition, it is optionally
+      possible to obtain some prebuilt binaries for some platforms
+      (note that any binary kit also requires to first download the
+      source kit for a proper installation of CMT):
+        </i>
+      </blockquote>
+
+      <center>
+	<table BORDER COLS=1 >
Index: /CMT/v1r20/doc/CMTDownload2.html
===================================================================
--- /CMT/v1r20/doc/CMTDownload2.html	(revision 368)
+++ /CMT/v1r20/doc/CMTDownload2.html	(revision 368)
@@ -0,0 +1,21 @@
+<!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+-->
+
+
+	</table>
+      </center>
+
+
+    <hr>
+    <address><a href="mailto:arnault@lal.in2p3.fr">Christian Arnault</a></address>
+    <!-- Created: Thu Feb  3 15:55:09 MET 2000 -->
+    <!-- hhmts start -->
+Last modified: Wed May 22 15:55:11 CEST 2002
+<!-- hhmts end -->
+  </body>
+</html>
Index: /CMT/v1r20/doc/CMTFAQ.html
===================================================================
--- /CMT/v1r20/doc/CMTFAQ.html	(revision 368)
+++ /CMT/v1r20/doc/CMTFAQ.html	(revision 368)
@@ -0,0 +1,232 @@
+<!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+-->
+
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+  <head>
+    <title>FAQ on CMT</title>
+  </head>
+
+  <body>
+    <center><h1>FAQ on CMT</h1></center>
+    <h1>Index</h1>
+
+    <ol>
+      <li><a href="#Providing sourceless documents">Providing sourceless documents</a>
+      <li><a href="#Accessing packages in a sub-directory">Accessing packages in a sub-directory</a>
+    </ol>
+
+    <hr>
+    <h1><a name="Providing sourceless documents"/>Providing sourceless documents</h1>
+
+    <blockquote>
+      <i>
+	I'm always trying to use CMT together with java and I now have
+	problems with the documentation.
+ 
+      <p> What I'd like to do is just generating automatically my
+	documentation using javadoc. Since it is not done in cmt, I tried to
+	write a new fragment to define a new document type : javadoc.
+ 
+      <p>The problem is that the process of generating the doc is not a
+	file to file process : it does not take a .java file to write a
+	.html. It takes a java package name (which has no associated file)
+	and returns many files.  This is not possible with the current
+	implementation of document. It seems that adding this feature would
+	lead to write some code into cmt_generator.
+	
+      <p>Does anyone see another method to generate my documentation ?
+	
+      <p>Sebastien
+      </i>
+    </blockquote>
+    
+    <p>In fact what you ask for is already available in CMT, it is
+      documented (although likely crypticly ;-) ) as follows :
+      
+    <p>Since your "document generator" does not make use of any source
+      file per se, it's likely that you will provide as the fragments the
+      following files (I use as an example the name "javadoc" for your
+      document type):
+      
+      <font face="courier new, courier" COLOR="#770077"> 
+	<b> 
+	<pre>
+...
+make_fragment javadoc_header
+make_fragment javadoc -header=javadoc_header
+...
+	</pre>    
+      </b> 
+      </font> 
+      
+    <p>  where javadoc is simply ... empty.
+      
+    <p>I remind you that here :
+      
+    <ul>
+      <li> javadoc_header will be instanciated once per document
+      <li> javadoc will be instanciated once per source file (thus never if 
+	no source file is specified)
+    </ul>
+    
+    <p>Then a document associated with the javadoc type could be specified 
+      as follows, using the <i>unusual</i> feature I mentioned above
+      
+      <font face="courier new, courier" COLOR="#770077"> 
+	<b> 
+	<pre>
+document javadoc MyDoc JAVAPACKAGE=MyPackage
+	</pre>    
+      </b> 
+      </font> 
+      
+    <p>Here the syntax <b>JAVAPACKAGE=MyPackage</b> corresponds to
+      providing user-defined templates in the document's fragments
+      
+      (see the general <a href="CMTDoc.html#kw-constituent-option">syntax</a>)
+      
+      every variable name should then correspond within the fragment to
+      constructs like (appearing anywhere in the fragment)
+      
+      <font face="courier new, courier" COLOR="#770077"> 
+	<b> 
+	<pre>
+...
+... ${JAVAPACKAGE} ...
+...
+	</pre>    
+      </b> 
+      </font> 
+      
+    <blockquote>
+      <i>
+	(please note the <b>${..}</b> syntax with required braces around the 
+	variable name)
+      </i>
+    </blockquote>
+	
+    <p>You have probably already understood that CMT provides internal 
+      predefined similar <a href="CMTDoc.html#Standard templates for makefile fragments">variable names</a>
+      
+    <p>the typical example being <b>CONSTITUENT</b> which is replaced by the 
+      constituent name when the fragment is instanciated.
+      
+    <p>What I'm talking about here consists in adding any number of 
+      user-defined variables which value will be specified on the <b>document</b> 
+      statement line using any number of <b>&lt;variable-name&gt;=&lt;value&gt;</b> constructs.
+      
+    <p>You will notice that the all-uppercase convention has been selected 
+      for CMT-internal variables (eg. <b>CONSTITUENT</b>). This is why I have used 
+      this convention for this example. This is only a convention, any form 
+      is possible here. The only constraint being that it should not overlap
+      with a macro name or an env. var name.
+      
+    <hr>
+    <h1><a name="Accessing packages in a sub-directory"/>Accessing packages in a sub-directory</h1>
+
+    <blockquote><i>
+      <p>I tried to use CMT with sub-packages. How does this work? If I
+	have on cvs a structure like
+      
+	<font face="courier new, courier" COLOR="#770077"> 
+	  <b> 
+	  <pre>
+ Velo/VeloEvent/..
+     /VSicbCnv/..
+	  </pre>    
+	</b> 
+	</font>
+	
+      <p>and on disk:
+	
+	<font face="courier new, courier" COLOR="#770077"> 
+	  <b> 
+	  <pre>
+ Velo/VeloEvent/v3/..
+     /VSicbCnv/v3/..
+	  </pre>    
+	</b> 
+	</font>
+	
+      <p> it recognizes the stuff in the use statement, but when I say
+      <b>cmt show packages</b> they are not there...  Hence, the
+      add-in for devstudio fails.
+      </i></blockquote>
+
+    <p>Well this is just a subtle effect :
+
+    <ul>
+      <li> when you are in the context of say <b>VeloEvent/v3</b>,
+      then the path of the current package is implicitly added to the
+      search path, all the used packages that reside in this same root
+      are visible (which explains that the <b>cmt show uses</b>
+      works).
+
+      <li> but, when you ask for <b>cmt show packages</b>, this is
+      performed outside of any context (mainly because it can be done
+      from any location). Then only packages reachable in the search
+      path (ie. <b>CMTPATH</b> or in the <b>CMT\path</b> registry set)
+      are visible.
+    </ul>
+
+    <p>Then in your precise case, you can do one of the following :
+
+    <ol>
+      
+      <li>If you strictly have (as you explained)
+	
+	<font face="courier new, courier" COLOR="#770077"> 
+	  <b> 
+	  <pre>
+ xxx/Velo/VeloEvent/v3/..
+         /VSicbCnv/v3/..
+	  </pre>    
+	</b> 
+	</font>
+	
+	<p>then the <b>CMTPATH</b> should include <b>xxx/Velo</b> in
+	order to make both <b>VeloEvent</b> and <b>VSicbCnv</b>
+	visible.
+	  
+      <li> If <b>Velo</b> is itself a package :
+
+	<font face="courier new, courier" COLOR="#770077"> 
+	  <b> 
+	  <pre>
+ xxx/Velo/VeloEvent/v3/..
+         /VSicbCnv/v3/..
+         /v1/...
+	  </pre>    
+	</b> 
+	</font>
+	
+	<p>then the <b>CMTPATH</b> may simply include <b>xxx</b>
+	(although <b>xxx/Velo</b> is possible too but in this case, it
+	is redundent). This makes all packages below <b>Velo</b>
+	visible.
+
+    </ol>
+
+    <p>The difference between 1) and 2) is really the fact that in 2)
+    <b>Velo</b> IS a true <b>CMT</b> package, whereas, in 1)
+    <b>Velo</b> is just a prefix.
+
+    <p>For simple efficiency reasons, <b>CMT</b> does not scan any
+    arbitrary directory tree depth when it looks for all packages, but
+    only the tree of true <b>CMT</b> packages + one level below each
+    package.
+
+    <hr>
+    <address><a href="mailto:arnault@lal.in2p3.fr">Christian Arnault</a></address>
+<!-- Created: Thu Oct 26 09:09:01 MET DST 2000 -->
+<!-- hhmts start -->
+Last modified: Thu Nov  9 15:16:35 MET 2000
+<!-- hhmts end -->
+  </body>
+</html>
Index: /CMT/v1r20/doc/ChangeLog.html
===================================================================
--- /CMT/v1r20/doc/ChangeLog.html	(revision 368)
+++ /CMT/v1r20/doc/ChangeLog.html	(revision 368)
@@ -0,0 +1,6306 @@
+<html>
+<body bgcolor="white">
+<table border>
+  <tr>
+    <td width="80"><i><center>date</center></i></td>
+    <td><i><center>file</center></i></td>
+    <td><i><center>comment</center></i></td>
+  </tr>
+<tr>
+  <td> <font color="blue">2002-05-29</font></td>
+  <td><tt>src/cmt_database.cxx
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_database.h
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_project.h 
+<br><font color="green">class Project</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_project.cxx 
+<br><font color="green">Project</font>
+</tt></td>
+  <td>
+Introduce Project management
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Define the default project CMT
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">select</font>
+</tt></td>
+  <td>
+&nbsp;
+Introduce apply_tag statements
+Introduce first iteration on project management
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+replace direct access to member of
+tag objects by accessor functions.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.h 
+<br><font color="green">class Tag</font>
+</tt></td>
+  <td>
+&nbsp;
+Clean up the for private members only
+introduce action_apply to activate a tag from a requirements file
+introduce tag expressions -> this defines primary tags versus
+computed ones. Selection is either obtained from m_selected for
+primary tags or computed from operands otherwise.
+so far only AND expressions are available.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-05-28</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">select_last</font>
+</tt></td>
+  <td>
+Make use of Tag::is_selected 
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">is_selected</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.h 
+<br><font color="green">class Tag</font>
+</tt></td>
+  <td>
+Add and_operands for defining tags
+from a bool expression of primary tags. Move selected to private
+area to ensure usage of is_selected which may compute the
+selection state from operands. The embedded state is now reserved
+to primary tags.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_awk.cxx 
+<br><font color="green">class Parser</font>
+</tt></td>
+  <td>
+Replace the basic parsing engine
+by the local Parser class. It takes care of both EOL styles (Unix
+and Win) and of trailing backslashes for continuations.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_awk.h 
+<br><font color="green">class Awk</font>
+</tt></td>
+  <td>
+Added a function inc_line_number to
+increment the line number from the external text parser.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">filter</font>
+</tt></td>
+  <td>
+Added debug messages
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_awk</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+Added action_awk
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Added do_awk function for testing the Awk operator.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-05-27</font></td>
+  <td><tt>doc/todo.html
+</tt></td>
+  <td>
+Adding entries
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-05-24</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+fix few problems with
+no_version_directory.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-05-23</font></td>
+  <td><tt>src/demo/scenario.awk
+</tt></td>
+  <td>
+Adapt to handle without_version_directory style
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/demo/demo1.cmt
+</tt></td>
+  <td>
+fix a typo 
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_requirements</font>
+</tt></td>
+  <td>
+Fixing bug on private
+macros for without_version_directory style
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/Makefile 
+<br><font color="green">demo</font>
+</tt></td>
+  <td>
+Improving the demo scenario manager
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-05-22</font></td>
+  <td><tt>doc/download.html
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>doc/CMTDownload.html
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_version.h 
+<br><font color="green">CMTVERSION</font>
+</tt></td>
+  <td>
+preparing tagging for v1r13...
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.h 
+<br><font color="green">class Use</font>
+</tt></td>
+  <td>
+new helpers
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+re-design the scope
+hiding for private uses (was buggy for first level private uses)
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">reach_package</font>
+</tt></td>
+  <td>
+structuring style
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">get_full_path</font>
+</tt></td>
+  <td>
+new helper for centralizing the full package path
+computation
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">reduce_path</font>
+</tt></td>
+  <td>
+new helper to normal form with $<PACKAGE>ROOT
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">get_paths</font>
+</tt></td>
+  <td>
+add debug prints
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">show_sub_uses</font>
+</tt></td>
+  <td>
+structuring style
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.h 
+<br><font color="green">class CmtSystem</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">reduce_file_separators</font>
+</tt></td>
+  <td>
+helper to reduce
+multiple file separators into one
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">is_package_directory</font>
+</tt></td>
+  <td>
+structuring style
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx 
+<br><font color="green">apply</font>
+</tt></td>
+  <td>
+add debug prints
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+Add CmtStructuringStyle options
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+</tt></td>
+  <td>
+&nbsp;
+Introducing support for structuring style. 
+m_current_structuring_style global variable
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">scan_path</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">scan_package</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">run</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">PackageCollector::run</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure</font>
+</tt></td>
+  <td>
+calling configure_current_structuring_style
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_current_package</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_current_structuring_style</font>
+</tt></td>
+  <td>
+new method
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+use Use::get_full_path
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_config</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_create</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_help</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_lock</font>
+</tt></td>
+  <td>
+suppress unused local variable
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_remove</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_show_macros</font>
+</tt></td>
+  <td>
+add pattern for selection instead of default '*'
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_show_sets</font>
+</tt></td>
+  <td>
+idem
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">do_unlock</font>
+</tt></td>
+  <td>
+suppress unused local variable
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">get_current_strategy</font>
+</tt></td>
+  <td>
+new method
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">install_cleanup_scripts</font>
+</tt></td>
+  <td>
+install cleanup scripts on windows
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">load</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+re-number argument array
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+support arguments for cmt show macros
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+support arguments for cmt show sets
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+-with_version_directory option
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+-without_version_directory option
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parse_requirements</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+support arguments for cmt show macros
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+support arguments for cmt show sets
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">print_context</font>
+</tt></td>
+  <td>
+use Use::get_full_path
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">print_macros</font>
+</tt></td>
+  <td>
+selection pattern (reg. expression) on symbols
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">reach_current_package</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+add getting pwd
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+structuring style
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">SourceFile::set</font>
+</tt></td>
+  <td>
+use CmtSystem::reduce_file_separators 
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">prepare_use_context</font>
+</tt></td>
+  <td>
+idem
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">prepare_use_context</font>
+</tt></td>
+  <td>
+use Use::get_full_path
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">set_full_name</font>
+</tt></td>
+  <td>
+idem
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_make_setup</font>
+</tt></td>
+  <td>
+idem
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_fragment.cxx
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_fragment.cxx
+<br><font color="green">print</font>
+</tt></td>
+  <td>
+use Use::reduce_path factorization
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_fragment.cxx
+<br><font color="green">locate</font>
+</tt></td>
+  <td>
+use Use::get_full_path factorization
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_fragment.cxx
+<br><font color="green">locate</font>
+</tt></td>
+  <td>
+Support structuring style options
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx
+</tt></td>
+  <td>
+&nbsp;
++ need cmt.h for accessing structuring style
++ support for structuring style
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+&nbsp;
+Adding support for structuring style
+do_show_macros now accepts arguments
+do_show_sets now accepts arguments
+print_macros now accepts a pattern for selecting symbols
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/demo/tprivate.cmt
+</tt></td>
+  <td>
+Scenario for testing private uses and
+-no_auto_imports
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/demo/demo1.cmt
+</tt></td>
+  <td>
+Scenario for the general test/demo sequence. 
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/demo/scenario.awk
+</tt></td>
+  <td>
+Add a script for installing
+scenarios. This script can
+- create packages
+- install text files relatively to the packages.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/Makefile 
+<br><font color="green">demo</font>
+</tt></td>
+  <td>
+Replace the copy operations for the demo
+targets by an awk-based mechanism (only for Unix -> keep old
+mechanism for Windows). The scenario.awk script is able to create
+packages and install text files into the newly created packages.
+&nbsp;
+<br>
+Add a target (a scenario) for testing private uses and
+-no_auto_imports
+&nbsp;
+<br>
+Add an help target describing all special targets.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituents_header 
+<br><font color="green">first</font>
+</tt></td>
+  <td>
+Differentiate setup.make
+with the package name when $(bin) is common.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-05-17</font></td>
+  <td><tt>doc/todo.html
+</tt></td>
+  <td>
+Adding a web page for ToDo list, and bug reports.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_test_setup_scripts</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_test_cleanup_scripts</font>
+</tt></td>
+  <td>
+Fix the bug
+to "source setup" standalone with a current directory outside the
+package itself.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-05-15</font></td>
+  <td><tt>src/cmt_version.h 
+<br><font color="green">CMTVERSION</font>
+</tt></td>
+  <td>
+Preparing the new tag v1r12p20020515
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>doc/CMTDoc.html
+</tt></td>
+  <td>
+Upgrade the documentation.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.tcsh
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.zsh
+</tt></td>
+  <td>
+Add all_tags to the list of know show options
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">show_definition</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.h 
+<br><font color="green">class Tag</font>
+</tt></td>
+  <td>
+Added Tag::show_definition
+(unfiltered show method wrt the selected state)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_help</font>
+</tt></td>
+  <td>
+Implement the new cmt show all_tags command.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Added Cmt::do_show_all_tags ()
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+Added action_show_all_tags
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+remove -I$(inc) from default value of ccomp
+macro (no longer needed and has side effects)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+Protect against null use pointer when not found.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+do increase the tag ref list when
+overridden. It used to be un-overridden...
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituents_trailer 
+<br><font color="green">clean</font>
+</tt></td>
+  <td>
+add a semi-colon between the two shell commands.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">create_symlink</font>
+</tt></td>
+  <td>
+Explicit .c_str() in system calls.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>doc/table.html
+</tt></td>
+  <td>
+setup a direct URL to CVSWeb rather than through
+an intermediate page
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-04-12</font></td>
+  <td><tt>doc/CMTDoc.html
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.zsh
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.tcsh
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_help</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+introduce action_show_all_tags do
+display all defined tags (while action_show_tags only shows all
+active tags)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituents_trailer 
+<br><font color="green">clean</font>
+</tt></td>
+  <td>
+typo in the clean target.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-04-11</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print_clean</font>
+</tt></td>
+  <td>
+Suppress the unset of CMTCONFIG
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-04-10</font></td>
+  <td><tt>fragments/library
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/library_no_share
+</tt></td>
+  <td>
+Suppress the experimental change for 
+erasing the object files after filling the library
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_version.h
+</tt></td>
+  <td>
+preparing tagging for v1r12
+&nbsp;
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Adapt to Darwin
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.h 
+<br><font color="green">class Use</font>
+</tt></td>
+  <td>
+Introduce m_has_native_version
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Add standard $(library_prefix) and $(library_suffix) macros
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_make_shlib_common.sh 
+<br><font color="green">temp_shlib</font>
+</tt></td>
+  <td>
+Set verbose mode to
+the linker command and control it through the QUIET macro. Fix the
+temporary expansion directory
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_make_shlib_common.sh 
+<br><font color="green">temp_shlib</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/library_header
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/cleanup_library
+</tt></td>
+  <td>
+Add standard $(library_prefix) and $(library_suffix) macros
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituents_trailer 
+<br><font color="green">makefilesclean</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituent
+</tt></td>
+  <td>
+remove specific makefile fragments for
+the constituents (instead of *.make)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/library_no_share
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/library
+</tt></td>
+  <td>
+erase *.o files after filling the library
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.h 
+<br><font color="green">class Use</font>
+</tt></td>
+  <td>
+Add use::sub_use_auto_imports to save
+specifications on sub uses. Add Use::set_auto_imports to possibly
+promote auto_imports to sub uses when it is changed from Off to
+On.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx 
+<br><font color="green">show_all_applied_patterns</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.h 
+<br><font color="green">class Pattern</font>
+</tt></td>
+  <td>
+adding Pattern::show_all_applied_patterns ()
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.tcsh
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.zsh
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_help</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Adding Cmt::do_show_applied_patterns for
+the new command "cmt show applied_patterns"
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-04-04</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+Protect against duplicated registration of
+current_use.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_setup_scripts</font>
+</tt></td>
+  <td>
+Append an empty line
+at the end of the generated setup script (problem on some shells)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_create</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Change the signature of the do_create
+function to receive its arguments from the "arguments" list rather
+than changing current_package etc...
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+Add a systematic config target (for backward compatibility)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituents_trailer 
+<br><font color="green">binclean</font>
+</tt></td>
+  <td>
+added the binclean
+target to completely remove the binary directory at once.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/make_header
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituents_header
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/make_header 
+<br><font color="green">CMTEXTRATAGS</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/constituents_header 
+<br><font color="green">CMTEXTRATAGS</font>
+</tt></td>
+  <td>
+Remove the settings of CMTCONFIG
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-03-22</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">suppress_OS_delimiters</font>
+</tt></td>
+  <td>
+operate on %...%
+patterns only on Windows machines.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-03-20</font></td>
+  <td><tt>mgr/Makefile 
+<br><font color="green">Atlas</font>
+</tt></td>
+  <td>
+Suppress HP rebuild for Atlas group
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">filter</font>
+</tt></td>
+  <td>
+Improve the recursive passes and
+handle the new qualifiers of the use statements.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/cleanup_header 
+<br><font color="green">clean</font>
+</tt></td>
+  <td>
+Fix bad insertion of the .DEFAULT target
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">suppress_OS_delimiters</font>
+</tt></td>
+  <td>
+Introduce this new
+function to ensure that only $() syntax is used in tag makefiles
+(ie suppress ${} and %% syntaxes)
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">show_macro</font>
+</tt></td>
+  <td>
+apply this new function for action_build_tag_makefile
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">reset</font>
+</tt></td>
+  <td>
+Do not generate the Visual
+directory on non-windows machines
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/group 
+<br><font color="green">clean</font>
+</tt></td>
+  <td>
+Suppress one echo on gmake clean
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-03-14</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Cleanup management of m_current_tag
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-03-07</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print_context</font>
+</tt></td>
+  <td>
+Suppress the automatic
+settings of CMTEXTRATAGS
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+Do not change CMTCONFIG
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/NMakefile.header
+</tt></td>
+  <td>
+Do not change CMTCONFIG
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-02-27</font></td>
+  <td><tt>fragments/jar
+</tt></td>
+  <td>
+Adding removal of jar file for clean target
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">show_sub_uses</font>
+</tt></td>
+  <td>
+show no_auto_imports status
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">reach_current_package</font>
+</tt></td>
+  <td>
+reapply global
+pattern at once until side effects are solved in user projects.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/jar
+</tt></td>
+  <td>
+Apply an old fix to Unix fragments (was applied
+to Windows only)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-02-26</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">move_to</font>
+</tt></td>
+  <td>
+select_alternate must be applied
+after reach_package for searches against an absolute path or
+against the current directory.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-02-25</font></td>
+  <td><tt>fragments/cleanup_header 
+<br><font color="green">clean</font>
+</tt></td>
+  <td>
+Add default action
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header 
+<br><font color="green">common_target</font>
+</tt></td>
+  <td>
+Remove debug print
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_requirements</font>
+</tt></td>
+  <td>
+Apply global patterns
+right after parsing a requirements file, and only considering the
+Use context, one at a time (rather than applying all global
+patterns to all Uses at once after reading all requirements file)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx 
+<br><font color="green">apply_all_globals</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.h 
+<br><font color="green">class Pattern</font>
+</tt></td>
+  <td>
+Add a method to apply all
+global patterns in the context of only one Use object.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-02-24</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">command_separator</font>
+</tt></td>
+  <td>
+New method for getting
+the shell command separator (& or ;)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Add
+CmtSystem::command_separator() between cvs co of each branch
+(instead of newlines).
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">has_device</font>
+</tt></td>
+  <td>
+Accepts the \\xxx\ syntax as a
+device name in file paths on windows.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">configure_cmt_path</font>
+</tt></td>
+  <td>
+Hide show_set action
+when recursive definition of CMTCONFIG
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">need_new</font>
+</tt></td>
+  <td>
+Some optimizations
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">move_to</font>
+</tt></td>
+  <td>
+Exchange the priority of CMTPATH
+versus version when selecting the best version.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">use_cmt</font>
+</tt></td>
+  <td>
+Hide CMTDEBUG while parsing the
+requirements of CMT itself
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-02-20</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+Fix a bug for setting the
+style the the Current use. This effect was induced by the new
+mechanism for constructing the Current Use object, now a singleton
+of the Use class.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-02-07</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">change_path</font>
+</tt></td>
+  <td>
+Add a m_located flag in Use class
+to record the success of the package localization. Test against
+this info instead of real_path to allow for package found in
+current directory (where real_path stays empty)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">configure</font>
+</tt></td>
+  <td>
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">show_sub_uses</font>
+</tt></td>
+  <td>
+Ensure that the cmt show uses
+displays the correct scoping information for uses and
+sub-uses. cmt show uses also displays the full tree even when it
+contains private uses.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-02-06</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+Install UseContext
+to manage proper propagation of -no_auto_imports
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-01-30</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+Fix the bug of private
+environment variables which could not be set even within the
+package (bug in the management of the -pack= -version= -path=
+options).
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+</tt></td>
+  <td>
+Install all attributes of the Cmt class as private
+attributes, and make them follow the convention : m_xxx. This
+implies to install few accessor methods.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-01-29</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+The private uses
+are accessed for 
+- broadcast operations
+- show uses operations
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+Expands the specified script name
+for the setup_script and cleanup_script statement.
+Protect against empty script names.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-01-11</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+Reorganize basic Makefile fragment
+generation to permit better support for parallel & concurrent
+builds. Mimize also the number of makefile fragments generated
+and kept : only $(tag).make remains in ../cmt . All other are
+thrown away after use.
+&nbsp;
+<br>
+Make those changes a branch "parallelbuilds"
+&nbsp;
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-01-09</font></td>
+  <td><tt>src/NMakefile.header 
+<br><font color="green">tags</font>
+</tt></td>
+  <td>
+Apply the fix for tags onto
+NMakefile.header
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2002-01-07</font></td>
+  <td><tt>src/Makefile.header 
+<br><font color="green">tags</font>
+</tt></td>
+  <td>
+Attempt to fix the continuity break
+between v1r9 and v1r10, by re-installing the possibility to use
+gmake tag=<...> rather than having to use source setup.[c]sh
+-tag=<...>
+&nbsp;
+<br>
+(This fix has to be tested before any validation)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-26</font></td>
+  <td><tt>Tagging v1r10p20011126
+</tt></td>
+  <td>
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+tag is now ${CMTCONFIG} and tags ${CMTEXTRATAGS}
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Provide the macro tags as ${CMTEXTRATAGS}
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx
+</tt></td>
+  <td>
+Various changes in strategy for tags:
+- tag inclusion (defined by the "tag" statement) transmits the priority.
+- tag selection can be discarded by exclusion specifications. Exclusion 
+qualifies a set of contradictory tags. Contradictory tags will be selected
+according to their priority or to their declaration order in case of
+equal priority.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum Priority</font>
+</tt></td>
+  <td>
+Change the priority list:
+Arguments get highest priority
+then CMTCONFIG
+then user tags (those defined in requirements)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/make_setup
+</tt></td>
+  <td>
+produce uses.make and tags.make
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Suppress the mechanism of
+primary_tag. CMTCONFIG is enough.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-21</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">add_value_to_list</font>
+</tt></td>
+  <td>
+fix protection on
+value_list.size () to start at 1 (not at 2)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">build</font>
+</tt></td>
+  <td>
+Reflective values of Sets should
+consider previous setenv settings.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_dependencies</font>
+</tt></td>
+  <td>
+Using ../$(tag) for
+output base of the dependencies fragment rather then
+Cmt::current_tag
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header 
+<br><font color="green">CMTPRIMARYTAG</font>
+</tt></td>
+  <td>
+tag=... argument of gmake
+will override CMTPRIMARYTAG. However internal tag macro is only
+replaced with ${CMTCONFIG}
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/make_setup 
+<br><font color="green">config</font>
+</tt></td>
+  <td>
+create a tags.log (for cmt show
+tags)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_make_shlib_common.sh
+</tt></td>
+  <td>
+Add the ${lib} prefix to the
+temporary expansion directory. Fix a bug in sed filter for all
+module files.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">configure_tags</font>
+</tt></td>
+  <td>
+Add a protection against
+absence of CMTPRIMARYTAG
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">create_symlink</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.h 
+<br><font color="green">class CmtSystem</font>
+</tt></td>
+  <td>
+Adding the create_symlink
+function.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_build_library_links</font>
+</tt></td>
+  <td>
+Using direct system
+calls to create symlinks.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-13</font></td>
+  <td><tt>Tagging v1r10p20011113
+</tt></td>
+  <td>
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/constituents.make 
+<br><font color="green">build_library_links</font>
+</tt></td>
+  <td>
+Define macros for
+build_library_links and remove_library_links
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/make_setup 
+<br><font color="green">config</font>
+</tt></td>
+  <td>
+Add build_library_links target
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Fix bad production of
+use_includes when private is used.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+Fix -begin=<pattern> error
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-08</font></td>
+  <td><tt>src/cmt_version.h
+</tt></td>
+  <td>
+tagging v1r10
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">add_cmt_path</font>
+</tt></td>
+  <td>
+Get cwd alias to each selected path.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Add cmt_path_cwd vector of all CMTPATH
+entries normalized to getcwd.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">java_file_action</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">proto_file_action</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">module_file_action</font>
+</tt></td>
+  <td>
+Pass reference to the constituent in order
+to transmit constituent variables to the fragment.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Insert a space
+character for all generated macro_append operations.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_fragment.cxx 
+<br><font color="green">xxxcopy</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_fragment.h 
+<br><font color="green">class Variable</font>
+</tt></td>
+  <td>
+Adding the expansion of
+fragments variables using both the ${} syntax AND the $() syntax.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.h 
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">is_selected</font>
+</tt></td>
+  <td>
+Change the Tag::selected attribute to bool.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-07</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">build</font>
+</tt></td>
+  <td>
+Implement the possibilty to have
+reflexive asignment to symbols: when a symbol value is exactly
+specified (from set, macro or path statements) using $(<name>) or
+${<name>} or %<name>% then the old value is preserved for all
+corresponding selectors.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Re-activate -import
+options (that had been discarded!)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+Generate an error when a package is not
+found (the error was only generated at "cmt show uses")
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_constituent.cxx 
+<br><font color="green">show</font>
+</tt></td>
+  <td>
+Display -import options
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/dependencies
+</tt></td>
+  <td>
+Force checking $(bin) 
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituent
+</tt></td>
+  <td>
+Adding some printout to display when
+constituent fragment is rebuilt
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Re-validate
+-no_auto_imports option for use and -import options for
+constituents.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-06</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_document_makefile</font>
+</tt></td>
+  <td>
+protect against
+missing files (causing infinite loops in Make)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-05</font></td>
+  <td><tt>mgr/Makefile 
+<br><font color="green">application_suffix</font>
+</tt></td>
+  <td>
+Define application_suffix in
+the CMT's Makefile
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print_context</font>
+</tt></td>
+  <td>
+Do not generate ROOT and
+CONFIG for cmt_standalone packages.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Reomving the cmt_selector.cxx source file.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/constituents.make
+</tt></td>
+  <td>
+Force the dirs target for
+build_library_links
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">restore_all_tags</font>
+</tt></td>
+  <td>
+Get the value of
+CMTPRIMARYTAG to configure Cmt::primary_tag.
+&nbsp;
+<br>
+Leave unchanged the primary_tag and the extra_tags except if
+overridden through the -tagxxx= options
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+Add PrioritySite in the list of
+possible priorities.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Add the restore_all_tags function. Add
+the extra_tags attribute . Change the strategy of tag persistency:
+&nbsp;
+<br>
+o CMTPRIMARYTAG always contains what had been specified using
+the -tag= option,
+&nbsp;
+<br>
+o CMTEXTRATAGS contains what had been manipulated by -tag_add=
+and -tag_remove= options.
+&nbsp;
+<br>
+o CMTCONFIG is setup independently of the primary tag.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header 
+<br><font color="green">primary_tag</font>
+</tt></td>
+  <td>
+Propagate tags using
+CMTPRIMARYTAG instead of CMTCONFIG (except when CMTPRIMARYtAG is
+not yet defined)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_constituent.cxx 
+<br><font color="green">parse</font>
+</tt></td>
+  <td>
+Fix the word parsing for
+constituent specification...
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-11-02</font></td>
+  <td><tt>src/cmt.h
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_database.cxx
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_database.h
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_selector.cxx
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_selector.h
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.h
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx
+</tt></td>
+  <td>
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.h
+</tt></td>
+  <td>
+&nbsp;
+Suppressing cmt_selector objects (only tags are needed!!)
+Add tag_exclude keyword for building tag-exclusions.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-31</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Don't need to explicitly declare make_fragment
+headers (automatically declared in the -header= option)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">print_clean</font>
+</tt></td>
+  <td>
+Cleaning up path variables may
+be either unsetenv when the result is empty or setenv if not.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/application_launcher
+</tt></td>
+  <td>
+evolution
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">configure_tags</font>
+</tt></td>
+  <td>
+protect against empty
+declaration of CMTCONFIG : by default will take uname...
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-30</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">clean</font>
+</tt></td>
+  <td>
+Implement the cleanup correctly,
+with in particular the cleanup of the path variables.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print_context</font>
+</tt></td>
+  <td>
+improve output of cmt show tags
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.h 
+<br><font color="green">class Symbol</font>
+</tt></td>
+  <td>
+Add clean_macro_value for
+building the result of the clean operations induced by this symbol
+(only implemented for path_xxx)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+</tt></td>
+  <td>
+New post-context requirements file :
+user_context in addition to home package. Added Use* use
+arguments to configure_xxx functions to transfer.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_cmt_path</font>
+</tt></td>
+  <td>
+Attempt to make use of
+CMTPATH definitions from requirements files.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_config_selector</font>
+</tt></td>
+  <td>
+Install context
+information for tag creation
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_home</font>
+</tt></td>
+  <td>
+Attempt to make use of
+CMTHOME definitions from requirements files.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_user_context</font>
+</tt></td>
+  <td>
+Install user_context
+management
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_site_selector</font>
+</tt></td>
+  <td>
+Get CMTSITE from
+requirements as well
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">configure_tags</font>
+</tt></td>
+  <td>
+Add a configure_tags
+finction to retreive tags from all possible sources: CMTCONFIG
+(from req) then CMTPRIMARYTAG then CMTCONFIG then CMTBIN then
+append all CMTEXTRATAGS.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+fix parsing bug for the
+-home= argument
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+Set action_show_path to be recursive
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+Call the HOME package just after
+using CMT. Call the use_context package just after reaching the
+current package.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">print_clean</font>
+</tt></td>
+  <td>
+reformat the output (with
+newlines). Clear CMTPRIMARYTAG CMTEXTRATAGS and CMTCONFIG.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">print_context</font>
+</tt></td>
+  <td>
+set CMTPRIMARYTAG
+CMTEXTRATAGS and CMTCONFIG from the current definitions.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Rationalize the
+production of current_tag
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+<br><font color="green">use_user_context_requirements</font>
+</tt></td>
+  <td>
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">show_all</font>
+</tt></td>
+  <td>
+Display new user_context package
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+query function ok()
+includes both home_package and user_context_package
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">reach_package</font>
+</tt></td>
+  <td>
+special treatment for
+home_package and user_context_package since they do not follow the
+standard location scheme.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+Improve the detection of packages not found.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">unmark</font>
+</tt></td>
+  <td>
+Reset the use pointer
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+Install the use origin.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+Install the use origin and the context
+information. It will be reset to the new context in case of
+re-definition. Suppress various excessive debug printouts.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">clear</font>
+</tt></td>
+  <td>
+clear use and context new information
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">show</font>
+</tt></td>
+  <td>
+Improve the display of tags with
+hierarchical display of subtags and context information.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_tag.h 
+<br><font color="green">class Tag</font>
+</tt></td>
+  <td>
+Added Use* use parameter to action
+and add methods. Store a pointer to the package (Use*) who
+originated the definition, and a context string to qualify the
+definition.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.h 
+<br><font color="green">class CmtSystem</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">add_cmt_paths_from_text</font>
+</tt></td>
+  <td>
+Factor out the
+code to register a set of CMTPATH entries, with the context
+information.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">is_home_package</font>
+</tt></td>
+  <td>
+Add is_home_package and
+is_user_context_package query functions.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">get_cmt_site</font>
+</tt></td>
+  <td>
+Default site is empty
+(instead of LAL)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">print_clean</font>
+</tt></td>
+  <td>
+Suppress some obsolete
+print_tabs () formattings. Apply unset instead of unset for
+aliases as well.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+Add special treatment for CMTXXX
+environment variables : the new setting has to be taken into
+account as soon as it is parsed.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_selector.cxx 
+<br><font color="green">create</font>
+</tt></td>
+  <td>
+remove some debug code.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_default_makefile</font>
+</tt></td>
+  <td>
+Produce only
+Makefile on Unix and only NMake on Windows.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Renaming new script_launcher fragments into
+application_launcher
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Added Use* use arguments to configure_xxx
+functions to transfer.
+&nbsp;
+<br>
+Added use_user_context_requirements () to include post-context
+requirements file.
+&nbsp;
+<br>
+Added the static value primary_tag to store the primary tag.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_default_makefile</font>
+</tt></td>
+  <td>
+Create Makefile
+only un Unix and NMake only on WIN32
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-24</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+add the recursive property to
+action_show_path.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.h 
+<br><font color="green">class CmtSystem</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">get_user_context_package</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">is_user_context_package</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">show_all</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">reach_package</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">configure</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">configure_user_context</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+&nbsp;
+&nbsp;
+Adding user_context equivalent of CMTHOME support for post
+requirements file. The corresponding env. var. is CMTUSERCONTEXT.
+The complete scheme for supporting PRE-parsed HOME requirements
+file is exactly copied to those POST-parsed files.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/script_launcher_header
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/script_launcher
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/script_launcher_trailer
+</tt></td>
+  <td>
+Introduce a new document
+generator for launching scripts. The same convention as the
+check_application is reused, for pre-action, argument passing and
+post-action. Several scripts (specified in the source list of the
+document) can be executed in sequence.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">is_home_package</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.h 
+<br><font color="green">class CmtSystem</font>
+</tt></td>
+  <td>
+Add the is_home_package
+function to encapsulate the syntax of a HOME package (and apply it
+in Use::use_action_iterator)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+Prepare specific actions when the
+parsed symbol is one of the CMTXXX standard symbols. So far
+CMTHOME -> re-configure home.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+apply use_home_requirements right
+after reading CMT requirements file (ie. before reading current
+package)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">configure_home</font>
+</tt></td>
+  <td>
+understand the possible
+"set CMTHOME" declarations (but keep $CMTHOME)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">reach_current_package</font>
+</tt></td>
+  <td>
+* src/cmt_system.cxx
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">get_cmt_paths</font>
+</tt></td>
+  <td>
+Restore the automatic addition of "current
+package" in the CMTPATH list.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+bad parsing of the
+-home=xxx argument
+&nbsp;
+&nbsp;
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-23</font></td>
+  <td><tt>mgr/Makefile 
+<br><font color="green">demo</font>
+</tt></td>
+  <td>
+Need to add CMTPATH towards ${CMTROOT}/demo
+since CMTPATH to current package is no longer supported !!!
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/check_application 
+<br><font color="green">check</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/cleanup_application
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/application_header
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/application
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/application
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/application_header
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/cleanup_application
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/check_application 
+<br><font color="green">check</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Create a new standard macro
+"application_suffix" for making possible to change the .exe
+default suffix of applications
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-22</font></td>
+  <td><tt>src/cmt_parser.cxx 
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+</tt></td>
+  <td>
+Suppress the automatic addition of current 
+package's path into CMTPATH.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/Makefile
+</tt></td>
+  <td>
+Change the method to rebuild
+cmt_dependencies by copying what is obtained from CVS. Rebuild it
+manually when needed.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-19</font></td>
+  <td><tt>fragments/make_setup 
+<br><font color="green">config</font>
+</tt></td>
+  <td>
+Creating uses.log needs to use an
+intermediate temporary file
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.[c]sh 
+</tt></td>
+  <td>
+Avoid re-definition of CMTCONFIG
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+temporarily discard the mecanism by which
+uses.log files are read before the requirements files.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">is_version_directory</font>
+</tt></td>
+  <td>
+returns -1 for fields
+that were wildcarded
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">need_new</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">BestFitSelector::operate</font>
+</tt></td>
+  <td>
+Start the
+implementation of priority control between explicit use
+specification over wildcarded ..
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">reach_current_package</font>
+</tt></td>
+  <td>
+Change the value of
+the CMTPATH for the current package once it has been reached (but
+before reading its requirements file)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_setup_scripts</font>
+</tt></td>
+  <td>
+(improvement) Add the transfer of
+arguments towards cmt.exe into setup.bat
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">get_cmt_paths</font>
+</tt></td>
+  <td>
+(bug fix) path_sources was
+not cleared as paths.
+Prepend "current path" to the path list under "current package".
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+(bug fix) Suppress
+enclosing quotes around cmt.exe arguments so that setup.bat can
+transmit arguments properly
+&nbsp;
+<br>
+call setup.bat "-tag_add=a,b,c"
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-18</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Set current_tag to
+CMTBIN when in CMT itself (not complete yet)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_dependencies</font>
+</tt></td>
+  <td>
+Use CMTBIN for CMT
+itself (instead of current_tag) well this should be cured later on
+to ensure that current_tag is always set to CMTBIN for CMT itself
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_version.h 
+<br><font color="green">CMTVERSION</font>
+</tt></td>
+  <td>
+install v1r10 (not tagged yet)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_system.sh
+</tt></td>
+  <td>
+Do not try to use AFS on Darwin and LynxOS.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.[c]sh
+</tt></td>
+  <td>
+Define CMTBIN as `uname` on Unix and CMTCONFIG
+as `cmt_system.sh`
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">show_macro</font>
+</tt></td>
+  <td>
+the trailing space must be
+added only for WIN32 !!
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-17</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">show_macro</font>
+</tt></td>
+  <td>
+add a trailing space on all
+macro definitions (to avoid problem of trailing backslash)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macro</font>
+</tt></td>
+  <td>
+remove the insertion of
+trailing spaces after the last backslash for WIN32/NMake
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/constituents.make 
+<br><font color="green">all</font>
+</tt></td>
+  <td>
+(bug fix) re-install the
+build_library_links action for the all target
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-11</font></td>
+  <td><tt>src/cmt_version.h
+</tt></td>
+  <td>
+Tagging for v1r9p20011011
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/library
+</tt></td>
+  <td>
+(bug fix) transmit both -tag=<tag> and
+-tag_add=<tag_list> to cmt_make_shlib_common.sh
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+</tt></td>
+  <td>
+remove debug print options
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-10</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+fix problems in multiple
+tag management.
+&nbsp;
+<br>
+converge in the question of HOME requirements file to support
+- no default
+- define the path to the HOME requirements file in ${CMTHOME}
+&nbsp;
+<br>
+converge in the arguments for manipulating the extra tags
+-tag=<tag>
+-tag_add=<tag-list>
+-tag_remove=<tag-list>
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-03</font></td>
+  <td><tt>src/constituents.make 
+<br><font color="green">makefilesclean</font>
+</tt></td>
+  <td>
+Make all action lists
+run in one single shell (ie. use ;\ everywhere)
+&nbsp;
+<br>
+Make an explicit target for build_library_links
+Make it called before any group
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-02</font></td>
+  <td><tt>src/cmt_awk.h 
+<br><font color="green">class Awk</font>
+</tt></td>
+  <td>
+add a state variable
+(m_continuation_allowed) which when true, take into account the
+trailing backslashes, so as to first accumulate continued lines
+into one. Add the allow_continuation method to base Awk class.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-10-01</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Bug in
+checkout_from_requirements. Did not accept leading spaces on use
+statements.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-09-27</font></td>
+  <td><tt>src/cmt_version.h
+</tt></td>
+  <td>
+Tagging for v1r9p20010927
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.zsh
+</tt></td>
+  <td>
+add the -begin option to the auto-expansion.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">show_all</font>
+</tt></td>
+  <td>
+Visualize the HOME package when
+applicable.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">get_home_package</font>
+</tt></td>
+  <td>
+(also do some formatting
+cleanup)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.h 
+<br><font color="green">class CmtSystem</font>
+</tt></td>
+  <td>
+Adding get_home_package
+function to build the name given to the HOME package (provides the
+HOME requirements file)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-09-26</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_show_macro</font>
+</tt></td>
+  <td>
+Improving error detection on
+cmt show macro/set
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>doc/CMTDoc.html
+</tt></td>
+  <td>
+Improve the doc.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print</font>
+</tt></td>
+  <td>
+produce the CMTEXTRATAGS environment
+variable, at setup time.
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+take into account this new 
+env.var. to retreive previous extra tags.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+Add the CMTEXTRATAGS environment variable
+to propagate additional tags to Make.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/make_setup
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituent
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/constituents.make
+</tt></td>
+  <td>
+Adding -tag=$(tags) to all calls to cmtexe
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.h 
+<br><font color="green">class CmtSystem</font>
+</tt></td>
+  <td>
+Adding the bool testenv
+(name) function to test if an environment variable is defined or
+not.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">use_home_requirements</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Adding support of CMTHOME environment
+variable for specifying home requirements file. Default value will
+be ${HOME}. And can be overridden through the -home=<directory>
+global option. An explicit empty value (or set to eg. NONE) will
+discard the feature
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+Implement the tag list
+(comma separated list of extra tags) option -tag=<tag-list> to
+specify a list of tags to validate.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-09-25</font></td>
+  <td><tt>src/setup.csh
+</tt></td>
+  <td>
+fixed PATH settings (may accept a path with space
+characters eg. for Darwin)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_system.sh
+</tt></td>
+  <td>
+Insert the knowledge of Darwin OS (Mac OS
+X). The default CMTCONFIG will be Darwin.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/constituents.make 
+<br><font color="green">makefilesclean</font>
+</tt></td>
+  <td>
+Ensure that removal of
+makefile fragments is performed AFTER all cleanup uperations.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">use_home_requirements</font>
+</tt></td>
+  <td>
+Add the systematic
+search for a requirements file located in ${HOME}. This
+requirements file when found, is systematically parsed AFTER the
+requirements file of the current package has been parsed (so as to
+give the highest precedence to its statements)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_remove_library_links</font>
+</tt></td>
+  <td>
+Upgrade "remove library_links" to make
+it compliant to the algorithm used in "build library_links"
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-09-24</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+* src/cmt_parser.cxx (configure): Add a
+global configure_error variable to store the possible error
+produced during the configuration.
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">install_test_setup_scripts</font>
+</tt></td>
+  <td>
+Add the -quiet option to the build
+temporary_name command used in setup script generation.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.cxx 
+<br><font color="green">get_last_error</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.h 
+<br><font color="green">class CmtError</font>
+</tt></td>
+  <td>
+Add get_last_error to retrieve
+the formatted text of the last error.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">create</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">all_print</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">print</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">build</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">select</font>
+</tt></td>
+  <td>
+Understand the "path" statement as
+a complete re-definition of a path-like variable.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">add_cmt_path</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.cxx 
+<br><font color="green">class Error</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.h 
+<br><font color="green">class CmtError</font>
+</tt></td>
+  <td>
+Adding "path not found" error
+code, for CMTPATH checking.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx 
+<br><font color="green">const cmt_string& name</font>
+</tt></td>
+  <td>
+Return a warning
+for pattern not found.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.h 
+<br><font color="green">class CmtError</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.cxx 
+<br><font color="green">class Error</font>
+</tt></td>
+  <td>
+Adding "pattern not found" error
+code, for showing diagnostics in "cmt show pattern"
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_show_macro</font>
+</tt></td>
+  <td>
+Return a warning for symbol
+not found.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.h 
+<br><font color="green">class CmtError</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_error.cxx 
+<br><font color="green">class Error</font>
+</tt></td>
+  <td>
+Adding "symbol not found" error
+code, for showing diagnostics in "cmt show macro/set"
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-09-19</font></td>
+  <td><tt>mgr/cmt_make_shlib_common.sh 
+</tt></td>
+  <td>
+return a status value which
+reflects the success or failure of the shared library build
+command.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Discard the versions
+specified with wild cards in the recursive checkout.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_triggers.cxx
+</tt></td>
+  <td>
+Protect the error messages in the trigger
+facility by Cmt::quiet.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_constituent.cxx 
+<br><font color="green">class constituents_action_iterator</font>
+</tt></td>
+  <td>
+&nbsp;
+temporarily discard the -triggers option.
+&nbsp;
+&nbsp;
+<br>
+Tagging v1r9p2001p0824
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_system.sh
+</tt></td>
+  <td>
+Improve the reliability of the cmt_system.sh
+script against variants of "fs sysname"
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-08-23</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Since the tag filter
+is back to cmtcvs.cxx, the temporary forced tag filter in CMT is
+removed.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.zsh
+</tt></td>
+  <td>
+upgrade the completion for the broadcast command.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+Make the -select independent
+of the -local or -global options. This is achieved by adding a
+"path_selections" list only managed by the -depth, -local -global
+modifiers while the "selections" list is managed by the -select
+modifier. The -exclude is left unchanged.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-08-22</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Add the possibility
+to transmit a flag to the CVS pluggin, by inserting a /cmtcvstest
+in the module name to import. This will have to be decoded by the
+CVS pluggin itself !!
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-08-21</font></td>
+  <td><tt>src/setup.tcsh
+</tt></td>
+  <td>
+Improving the tcsh completion mechanism (for cmt co).
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/setup.zsh
+</tt></td>
+  <td>
+Improving the zsh completion mechanism (for cmt co).
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Converging on HEAD
+management strategy...
+&nbsp;
+<br>
+Starting implementation of the Atlas filter for CVS tags right
+into cmt_cvs.cxx rather than inside the CVS pluggin...
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-08-20</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Improving the
+recursive checkout process
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Reorganizing some CVS operations:
+- Apply the CMTCVSOFFSET env. variable to all actions (tags, branches, subpackages)
+- cleanup checkout algorithms (remove some obsolete variables)
+- add the -requirements <requirements-file-path> option to checkout according to
+a set of use statements.
+- remove the inheritance to Awk of CvsImplementation to split the filter into 2
+phases (implemented as 2 separated Awk derived classes) RecursivePass1 and
+RecursivePass2.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-08-16</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">print</font>
+</tt></td>
+  <td>
+Bug in path_remove when the
+specified path variable only contained one item : the remove
+operation was not applied.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-07-20</font></td>
+  <td><tt>src/cmt_version.h
+</tt></td>
+  <td>
+setting the patch v1r9p20010720
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_regexp.h 
+<br><font color="green">cmt_regexp::begin</font>
+</tt></td>
+  <td>
+Add an optional pos
+argument to the begin method.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>doc/CMTDoc.html
+</tt></td>
+  <td>
+Improvements, English cleanup...
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-07-18</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">CvsImplementation::checkout_package</font>
+</tt></td>
+  <td>
+Change
+the mechanism to get top files, since the " -d . " does not work
+anymore when CVSROOT is set to kserver!!!!
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-07-16</font></td>
+  <td><tt>doc/CMTDoc.html
+</tt></td>
+  <td>
+Old PREFIX fragment variable has been replaced
+by FILEPATH long ago. This was not upgraded in the doc.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituent
+</tt></td>
+  <td>
+The -f <file> MUST be specified BEFORE
+other Make flags!!
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/dependencies
+</tt></td>
+  <td>
+Tried to comment out the dependencies to
+cmt_path.make etc... but it confused the dependencies fragment
+production. Uncomment it but need to understand the side effect.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-07-09</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_readme</font>
+</tt></td>
+  <td>
+Bug: the VERSION variable
+was not used for installing the readme_trailer (although the
+documentation was mentioning it)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-07-04</font></td>
+  <td><tt>src/cmt_version.h
+</tt></td>
+  <td>
+setting the patch v1r9p20010704
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-07-02</font></td>
+  <td><tt>fragments/dependencies
+</tt></td>
+  <td>
+Cleaning some old debug printouts.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Bug in replacing the
+wild card expression. v5r* has to be replaced by v5r0 while v5*
+has to be replaced by v5 in case no matching tag exists in the CVS
+repository. Other bug : All split operations should be performed
+against " \t" (include tab character)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-06-29</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Final Validation of
+the change in the implementation of the m_installed stack used to
+avoid recursion due to dependency cycles.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-06-22</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+doing some
+optimizations for the big checkout operations.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_config</font>
+</tt></td>
+  <td>
+Remove .[n]make files also from
+the binary directory.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Always fetch the cmt
+branch at HEAD even if the checkout operation is applied to a
+required tag (temporary feature).
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-06-18</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+insert a space
+between top tags and other tags.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_make_shlib.bat
+</tt></td>
+  <td>
+Write extra options received through
+arguments into a temporary option file, used by @<optionfile> to
+resolve line-too-long prolems.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/cpp_library
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/cpp
+</tt></td>
+  <td>
+&nbsp;
+Add the /Tp qualifier for allowing non-standard file suffixes.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-06-05</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+Default to the
+-no_auto_import was to keep the most recent specification. Change
+this to always request auto_import by default, (unless otherwise
+specified)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-06-01</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+Bug fix in do_broadcast: the
+-begin option wrongly implied the -global option.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-06-13</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Improving the
+strategy for getting version tags from the repository:
+o If a request specifies a tag which is not applied to the 
+requirements file, the specified tag is used to create the
+version directory but the HEAD is used in the repository.
+o CvsImplementation::show_cvs_infos () :
+stores all received infos into xxx_info corresponding
+local properties. Thus this method is only called once per
+package.
+o Error messages are really obtained from the error_info field.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-30</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_document_makefile</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">get_dot_suffix</font>
+</tt></td>
+  <td>
+fix bug for file_names
+without any suffix
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h & src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Add a
+state standard_macros_done to protect against multiple calls to
+set_standard_macros.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-28</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+display the tags in a
+one-per-line basis instead of space separated when doing cmt
+cvstags.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">operate</font>
+</tt></td>
+  <td>
+Make the version selector operator a
+little bit more quiet...
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-25</font></td>
+  <td><tt>mgr/Makefile 
+<br><font color="green">demo</font>
+</tt></td>
+  <td>
+improve the gmake check action in the demo
+target.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">fill_macro_all</font>
+</tt></td>
+  <td>
+build use_xxx standard macros
+using macro_append instead of macro.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-22</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+Fix the default (-local)
+option to act as -depth=1.
+Improve some error messages.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-21</font></td>
+  <td><tt>src/setup.bat
+</tt></td>
+  <td>
+Improved skeleton for setup.bat. Base it on
+CMTBIN rather than on CMTCONFIG. Do not override CMTCONFIG if
+defined by the user. Do not care about PATH for Visual tools.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/install.mak
+</tt></td>
+  <td>
+change the strategy for building the setup.bat
+script for CMT itself at INSTALL time. Now copy ..\src\setup.bat
+skeleton.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Fix WIN32/VisualC tag definitions and PATH
+settings for cleaner handling of default tag overriding.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">operate</font>
+</tt></td>
+  <td>
+Implement the algorithm for using
+aliases to alternate version specification in uses.
+&nbsp;
+&nbsp;
+<br>
+-> Tag CMTv1r9p20010521
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-18</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">show_sub_uses</font>
+</tt></td>
+  <td>
+Start the implementation of
+version_alias and path_alias for equivalencing two version naming
+policies.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Adding the -o offset
+option to cmt checkout for specifying a global offset to the base
+CVS repository. This offset will be prepended to all modules
+during the various CVS operations.
+&nbsp;
+<br>
+the m_offset attribute is added to the CvsImplementation class.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Improve protection against CVS modules
+not found.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Added the --help option the cmt checkout.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-07-10</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+add the -tag=$(tag) option to the
+build_dependencies macro.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/dependencies
+</tt></td>
+  <td>
+take the improvements into account.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_dependencies</font>
+</tt></td>
+  <td>
+Improve the
+dependency builder: re-generate all entries of the
+<constituent>_dependencies.make that are missing from the complete
+source list (thus regenerate it when it is empty).
+Optimize the file scan for getting the new source list.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_build_dependencies</font>
+</tt></td>
+  <td>
+Dynamically shifts
+arguments of the build dependencies command to keep only the
+new-source-list. The complete command being 
+"cmt <args> build dependencies <constituent-name> <new-source-list>"
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_config</font>
+</tt></td>
+  <td>
+drop all makefile fragments from the mgr/cmt
+directory AND from the binary directory.
+&nbsp;
+&nbsp;
+<br>
+Moving to v1r8
+&nbsp;
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_deps_builder.cxx istream& input,
+</tt></td>
+  <td>
+&nbsp;
+const cmt_string& dir_name,
+int current_path_index,
+const CmtSystem::cmt_string_vector& include_paths,
+const CmtSystem::cmt_string_vector& substitutions,
+CmtSystem::cmt_string_vector& all_deps,
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>CmtSystemcmt_string_vector& deps
+</tt></td>
+  <td>
+Augmented local internal
+line buffer (from 1024 to 16384).
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>doc/CMTDoc.html
+</tt></td>
+  <td>
+document the new <package>_root macro
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros get_best_form</font>
+</tt></td>
+  <td>
+Define
+a new set of standard macros using the pattern <package>_root
+similar to <PACKAGE>ROOT except that this new definition uses the
+get_best_form, with a relative path to the package. The
+<PACKAGE>ROOT macro is restored to the previous convention, that
+it uses the absolute path.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">fill_includes_macro</font>
+</tt></td>
+  <td>
+Adapt the
+fill_includes_macro to use the new <package>_root standard macro
+&nbsp;
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-10</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+Add the -begin=<pattern>
+option to start the broadcast loop from a given package. This
+option can be combined with other options such as -select or
+-exclude.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">filter_paths</font>
+</tt></td>
+  <td>
+Suppress two unused
+variables.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+Bug fixing: during the discovery of
+versions requested for a given package, the discarded versions
+were not correctly replaced by the finally selected version,
+especially in the Use::get_paths method. The
+Use::get_selected_version has been added to obtain the effective
+replacement for a discarded version.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/check_application
+</tt></td>
+  <td>
+suppress the ". setup.sh" before
+application run.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-04</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+The production of all
+use_xxx standard macros now is based on a "macro_append" keyword
+instead of "macro", since "macro" resets all previous
+definitions. Therefore if the user's requirements did augment
+those use_xxx macros, these specifications would be ignored.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_broadcast</font>
+</tt></td>
+  <td>
+Set the -local option to broadcast the
+default. Add the -global option to revert to the old default (with
+no selection and to any depth)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-05-03</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">add_value_to_list</font>
+</tt></td>
+  <td>
+A new macro or set
+keyword resets (discards) all previous definitions for the
+corresponding symbol.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.h 
+<br><font color="green">class SymbolValueList</font>
+</tt></td>
+  <td>
+Added an attribute
+discarded for symbol resetting.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print_macros</font>
+</tt></td>
+  <td>
+Exclude scripts from macros
+defined in the $(tag).make file.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-27</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">get_best_form</font>
+</tt></td>
+  <td>
+Validate the compression
+algorithm for paths to packages (only for the macro <PACKAGE>ROOT
+- this is still not true for the <PACKAGE>ROOT environment
+variable) into a relative form when it is shorter than the
+absolute form.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_system.cxx 
+<br><font color="green">compress_path</font>
+</tt></td>
+  <td>
+Fix the algorithm for
+compressing the patterns "aaaa/xxxx/../bbbb" into aaaa/bbbb.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">filter_paths</font>
+</tt></td>
+  <td>
+use
+CmtSystem::compress_path instead of duplicating its algorithm for
+erasing "/aaa/.." patterns
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-25</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Prepare the production
+of <PACKAGE>ROOT macros as relative paths rather than absolute
+ones, when the relative expression is shorter than the absolute
+one. Temporarily, trigger that feature by setting the
+CMTTESTPREFIX environment variable until absence of side effects
+is confirmed.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-18</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_readme</font>
+</tt></td>
+  <td>
+bug when generating the
+readme_trailer fragment : the PACKAGE variable should be reset to
+current.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-11</font></td>
+  <td><tt>src/cmt_generator.h 
+<br><font color="green">class Generator</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_build_readme</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+do_build_readme now propagates argument list
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/readme_trailer
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_readme</font>
+</tt></td>
+  <td>
+Added DATE and USER information when building the README.html file. readme_trailer fragment updated accordingly.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_readme</font>
+</tt></td>
+  <td>
+Add the -url=<url> argument to the cmt build
+readme command. The specified URL will be used in place of the
+package path when generating the URL for used packages.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-18</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">build</font>
+</tt></td>
+  <td>
+In all builder objects, symbol value
+lists registered by discarded Uses are now ignored.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.h 
+<br><font color="green">class SymbolValue</font>
+</tt></td>
+  <td>
+cleanup a comment.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">print</font>
+</tt></td>
+  <td>
+protect setup script execution
+against missing files.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-10</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_readme</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/readme_use
+</tt></td>
+  <td>
+building readme.html requires to know the
+mgr/cmt style of each used package. This fragment now requires a
+fourth variable MGRSTYLE which reflects the use->mgr_style
+attribute. Generator::build_readme fills in this new variable.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-06</font></td>
+  <td><tt>src/cmt_parser.cxx 
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">reach_current_package</font>
+</tt></td>
+  <td>
+Use CmtSystem::getenv instead of base getenv
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">action</font>
+</tt></td>
+  <td>
+Now really private stuff is
+selected when access is at UserMode and scope is Private.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">add</font>
+</tt></td>
+  <td>
+This method does not need to maintain
+current scope and access mode any longer.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_requirements</font>
+</tt></td>
+  <td>
+Cmt::parse_requirements
+now manages the AccessMode and Scope when recursing into
+requirements files of used packages.
+&nbsp;
+<br>
+Cmt::scope handles the sticky state provided by private/public statements
+Cmt::current_access handles the access mode that reflects the situation of the user
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.h 
+<br><font color="green">enum</font>
+</tt></td>
+  <td>
+introduce the AccessMode to distinguish
+between DeveloperMode (when pwd is in the current package
+directory) and UserMode (otherwise).
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt.h 
+<br><font color="green">class Cmt</font>
+</tt></td>
+  <td>
+Cmt::current_mode is now current_access
+and is of type AccessMode
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">reach_current_package</font>
+</tt></td>
+  <td>
+Use
+CmtSystem::getenv instead of base getenv
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">Use::get_paths</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx Pattern
+</tt></td>
+  <td>
+:apply ()) : bug in computing the
+path between two Uses. The result now includes the current Use.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-05</font></td>
+  <td><tt>src/cmt_tag.cxx 
+<br><font color="green">Tag::addconst cmt_string& name, int priority</font>
+</tt></td>
+  <td>
+&nbsp;
+clear a newly created Tag object (to deal with the reuse of old
+objects)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx Pattern
+</tt></td>
+  <td>
+:add) : clear a newly created
+pattern object (to deal with the reuse of old objects)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.h 
+<br><font color="green">class Use</font>
+</tt></td>
+  <td>
+Add Use::author_action and
+Use::manager_action to fill in the author and manager information.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">select</font>
+</tt></td>
+  <td>
+fill in author and manager values
+with the complete line. When several author and manager statements
+are provided, fill in as several lines (separated with a new-line).
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx analyze_file const Constituent&
+</tt></td>
+  <td>
+&nbsp;
+constituent, const cmt_string& file) : production of objects for
+libraries and applications is strictly identical.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-03</font></td>
+  <td><tt>src/cmt_constituent.cxx 
+<br><font color="green">clear</font>
+</tt></td>
+  <td>
+constituent.parameters was not
+cleared in Constituent::clear
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">build</font>
+</tt></td>
+  <td>
+add cleanup ValueList objects after
+their addition for ensuring a really new value (due to cmt_string
+optimizing)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/Makefile
+</tt></td>
+  <td>
+Operate the demo targets on different make action
+lines
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+Added -tag=$(tag) to cmt actions
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/generator_header
+</tt></td>
+  <td>
+create the output directory if
+needed
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-04-02</font></td>
+  <td><tt>fragments/nmake/constituent
+</tt></td>
+  <td>
+added the -tag=$(tag) option to cmt
+build actions
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parser</font>
+</tt></td>
+  <td>
+show_constituentxxx recursively
+reads used requirements files
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx 
+<br><font color="green">Pattern::apply  const</font>
+</tt></td>
+  <td>
+protection added
+for the case where the pattern is applied to the package that
+defines it.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-29</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">get_paths</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.h 
+<br><font color="green">class Use</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.h 
+<br><font color="green">class IgnorePattern</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_pattern.cxx 
+<br><font color="green">const apply</font>
+</tt></td>
+  <td>
+Bug in apply global patterns
+: a pattern defined in one package should only be applied to the
+Uses that are on one of the paths between the current Use and the
+one wher the pattern is defined (and not to the Uses that never
+pretend to inherit that pattern!!!)
+&nbsp;
+<br>
+This required to implement the Use::get_paths which fills in the
+inclusive list of all Uses that are between two Uses.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-27</font></td>
+  <td><tt>fragments/dependencies
+</tt></td>
+  <td>
+protection against missing dependency
+make fragment during clean operations.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_constituent.cxx 
+<br><font color="green">class constituents_action_iterator</font>
+</tt></td>
+  <td>
+&nbsp;
+the -suffix= option was hidden by the user variable specification
+while parsing the constituent parameters.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-23</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+clean up WIN32 tag variants definitions
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header 
+<br><font color="green">setup.make</font>
+</tt></td>
+  <td>
+Display of the target in case
+of target not found (.DEFAULT)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/make_setup 
+<br><font color="green">csh</font>
+</tt></td>
+  <td>
+few checks
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/installer
+</tt></td>
+  <td>
+add the creation of $(install_dir) if
+needed
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-21</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_arguments</font>
+</tt></td>
+  <td>
+When the tag specified in
+the command line arguments (using -tag=<tag>) is the same as
+CMTCONFIG, then still validate the tag given by uname
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/dependencies
+</tt></td>
+  <td>
+generate
+${CONSTITUENT}_dependencies.make into $(bin)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/constituent
+</tt></td>
+  <td>
+generate ${CONSTITUENT}.make into $(bin)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_constituent.cxx 
+<br><font color="green">parse</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_constituent.h 
+<br><font color="green">class Constituent</font>
+</tt></td>
+  <td>
+Added the two-step
+parsing of the constituents specifications : first stage during
+parsing of the requirements file, parameters are simply stored in
+the constituent object and not interpreted. Second stage : after
+building the standard macros (once requirements files have
+entirely been read) then constituent objects are parsed.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx
+</tt></td>
+  <td>
+Add Constituent::parse_all in
+Cmt::set_standard_macros to finalize the constituent
+parsing. Install set_standard_macros in several additional actions
+&nbsp;
+&nbsp;
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-16</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Get the files at the
+top directory when doing a cmt checkout. 
+&nbsp;
+<br>
+Only checkout at head for the top package (ie do not recurse at
+head) and when -r is not specified.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">resolve_value_for_macros</font>
+</tt></td>
+  <td>
+Perform the
+substitution of ${} to %% (or reverse) even if the env. var. is
+not defined in CMT.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_setup_scripts</font>
+</tt></td>
+  <td>
+Setup scripts on
+Windows generate the temporary expansion script in
+%HOMEDRIVE%%HOMEPATH%.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+clean up variants for VisualC and
+VisualC/debug
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-15</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class use_action_iterator</font>
+</tt></td>
+  <td>
+Strange name
+conflict: the use_action_iterator::set method is in conflict with
+something else when the class is named "action_iterator" (is it a
+conflict with the same private class defined in Symbol.cxx ??)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/NMakefile.header 
+<br><font color="green">cmtexe</font>
+</tt></td>
+  <td>
+Fix for re-building cmt when
+cmt.exe does not exist.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-13</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">class action_iterator</font>
+</tt></td>
+  <td>
+Introducing the
+action_iterator class for managing the local expansion of macros
+in the syntax parser (similart to what was done in Symbol::action)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx Generator
+</tt></td>
+  <td>
+:build_make_setup) when
+generating setup.make, the default value for constituents is
+extracted from the constituents macro.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-06</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Show both top tags
+and non-top tags in cmt cvstags.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>doc/CMT.htm
+</tt></td>
+  <td>
+Addition of several slide shows (from Atlas)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_buildcvsinfos2.sh 
+<br><font color="green">error</font>
+</tt></td>
+  <td>
+The awk script had to be
+protected against multiple ocurrences of the /symbols/,/locks/
+pattern.
+&nbsp;
+<br>
+Implement both in python and in shell script the differntiated
+production of top tags and non-top tags. Top tags are the set of
+tags sharing the most recent CVS tagged version id (ie. the HEAD
+may be more recent)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-05</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_build_library_links</font>
+</tt></td>
+  <td>
+Handle libraries
+specified as a full path in <package>_libraries
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print_context</font>
+</tt></td>
+  <td>
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">all_print</font>
+</tt></td>
+  <td>
+Use one line per
+env. var. assignment when generating setup scripts (instead of ;
+separated instructions) . The latter style should be no longer
+needed since we use temporary files.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Add CMTCONFIG to the
+standard sets, so as to let it known as a plain "symbol"
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-03-02</font></td>
+  <td><tt>src/cmt_system.h
+</tt></td>
+  <td>
+introduce the CmtSystem::ev_open () and
+CmtSystem::ev_close () to get the OS-dependent pattern for
+environment variable definition.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_symbol.cxx 
+<br><font color="green">resolve_value_for_macros</font>
+</tt></td>
+  <td>
+Substitute
+patterns ${xxx} or %xxx% to the appropriate OS-dependent pattern
+when producing "set" values only (this is only done when the
+pattern is not already the good one)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_setup_scripts</font>
+</tt></td>
+  <td>
+Changed
+>>${tempfile} into >${tempfile} in setup scripts (fix a constraint
+in csh)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-02-26</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_build_temporary_name</font>
+</tt></td>
+  <td>
+Add the build
+temporary_name command to supply that missing function on various
+shells.
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_test_setup_scripts</font>
+</tt></td>
+  <td>
+Apply this new build service to
+setup scripts generation.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/Makefile.header
+</tt></td>
+  <td>
+Needed a trailing end-of-line
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-02-15</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Fix misuse of
+checkout_package arguments (confusion between package path and
+checkout directory)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-02-26</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">install_test_setup_scripts</font>
+</tt></td>
+  <td>
+use mktemp for
+setup scripts.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Suppress local private configuration of
+MSVC++. It has to be done previously to operate on CMT (even
+before making the INSTALL.bat)
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_deps_builder.cxx char* ptr,
+</tt></td>
+  <td>
+&nbsp;
+state_def& state,
+const cmt_string& dir_name,
+int current_path_index,
+const CmtSystem::cmt_string_vector& include_paths,
+const CmtSystem::cmt_string_vector& substitutions,
+CmtSystem::cmt_string_vector& all_deps,
+CmtSystem::cmt_string_vector& deps)
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">const cmt_string& file_name</font>
+</tt></td>
+  <td>
+&nbsp;
+&nbsp;
+Rollback recent change to work on cmt_strings rather than char* to
+restore speed.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-02-15</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_dependencies</font>
+</tt></td>
+  <td>
+Restore the
+mechanism that takes into account the arguments, and the source
+list when -all_sources option is provided.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+change /machine:I386 into /machine:IX86 as
+link option for VisualC
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-02-13</font></td>
+  <td><tt>src/cmt_generator.cxx 
+<br><font color="green">build_dependencies</font>
+</tt></td>
+  <td>
+Do not require the
+source list from the arguments. Instead, get the sources directly
+from the constituents definition.
+&nbsp;
+<br>
+The "cmt build dependencies" now only requires the constituent name. 
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_deps_builder.cxx
+</tt></td>
+  <td>
+Read files at once into a cmt_string
+and work from the text instead of reainf line by line from the file.
+&nbsp;
+<br>
+Install the detection of fortran include statements
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-02-06</font></td>
+  <td><tt>src/cmt_use.cxx
+</tt></td>
+  <td>
+clean up space & tabs
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">parse_requirements_text</font>
+</tt></td>
+  <td>
+Abort the parser in
+case of error, but only for check configuration command.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>arc/NMakefile.header 
+<br><font color="green">lex_echo</font>
+</tt></td>
+  <td>
+Add -quiet option to cmt command
+except cmt check configuration
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>fragments/nmake/constituents.nmake
+</tt></td>
+  <td>
+Add -quiet option to cmt command
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2001-01-30</font></td>
+  <td><tt>all dsp fragments 
+</tt></td>
+  <td>
+suppress the Win32 Release
+configuration. Only keep the Win32 Debug. This makes possible the
+generation of msdev using the syntax cmt build msdev
+-tag=VisualCdbg
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/cmt_buildcvsinfos.py first attempt to make the cvs script
+</tt></td>
+  <td>
+&nbsp;
+written in Python
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>mgr/requirements
+</tt></td>
+  <td>
+Consistently base Windows tag on VisualC rather
+than WIN32
+&nbsp;
+<br>
+upgraded setup.tcsh setup.zsh
+&nbsp;
+<br>
+introduced cmt show include_dirs
+&nbsp;
+<br>
+introduced cmt show constituent <name>
+&nbsp;
+<br>
+bug in Pattern::add : overridden patterns were not cleared.
+&nbsp;
+<br>
+cmt config must recursively get used packages (at least to get patterns)
+&nbsp;
+<br>
+introduced cmt show pattern_names (at least for completion mechanisms) 
+new action : action_show_pattern_names
+&nbsp;
+<br>
+experimental work started on build triggers
+&nbsp;
+<br>
+macro build_triggers
+implied_library_prefix
+implied_library_sufffix
+&nbsp;
+<br>
+new library option -triggers
+new constituent attribute build_triggers
+new fragment dependencies_and_triggers for libraries
+&nbsp;
+<br>
+bug in cmt_system.cxx::scan_dir
+&nbsp;
+<br>
+Recursively get all requirements file in cmt config action
+&nbsp;
+&nbsp;
+<br>
+Changed strategy for argument parsing error detection
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_use.cxx 
+<br><font color="green">const cmt_string& from_path </font>
+</tt></td>
+  <td>
+bug in
+detection of "use pack " without version specification at all (ie
+equiv. to *). We needed to check we are on a real CMT package.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_constituent.cxx 
+<br><font color="green">class action_iterator</font>
+</tt></td>
+  <td>
+Expand the macros
+before acting upon a constituent specification. Each expanded word
+may then result in several words. Thus the line parser is
+re-implemented through a local operator class "action_iterator",
+in charge of filling up a new constituent object from the expanded
+statement. (Note that this mechanism could perfectly be reused for
+other statements eg "use" !!!)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">set_standard_macros</font>
+</tt></td>
+  <td>
+Implement all_constituents
+and all_constituentsclean unconditionally.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/NMakefile.header 
+<br><font color="green">checkuses</font>
+</tt></td>
+  <td>
+if defined statements require that
+the macro to test is provided without quotes.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_generator.cxx
+</tt></td>
+  <td>
+Apply the new convention of installing object
+files into $(bin)${CONSTITUENTS} also for applications (was only
+done for libraries)
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">print_context</font>
+</tt></td>
+  <td>
+Take the current CONFIG name
+from CmtSystem::get_cmt_config rather than recursively calling
+"cmt system", when generating setup scripts.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_cvs.cxx 
+<br><font color="green">class CvsImplementation</font>
+</tt></td>
+  <td>
+Use '/' ínstead of
+CmtSystem::file_separator for CVS-only file specs.
+&nbsp;
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">2000-12-26</font></td>
+  <td><tt>src/cmt_fragment.h 
+<br><font color="green">class Fragment and FragmentHandle</font>
+</tt></td>
+  <td>
+Install all
+variants of (win)copy methods that act upon a cmt_string instead
+of a FILE*.
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_model.cxx
+</tt></td>
+  <td>
+Create the implementation file for CmtModel 
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_model.h 
+<br><font color="green">class CmtModel</font>
+</tt></td>
+  <td>
+Create the CmtModel class
+&nbsp;
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_expand_model</font>
+</tt></td>
+  <td>
+Add the new command verb :
+'expand model' and all associated features
+  </td>
+</tr>
+<tr>
+  <td> <font color="blue">&nbsp;</font></td>
+  <td><tt>src/cmt_parser.cxx 
+<br><font color="green">do_expand_model</font>
+</tt></td>
+  <td>
+call the CmtModel::expand
+&nbsp;
+</table>
+</body>
+</html>
Index: /CMT/v1r20/doc/Design.txt
===================================================================
--- /CMT/v1r20/doc/Design.txt	(revision 368)
+++ /CMT/v1r20/doc/Design.txt	(revision 368)
@@ -0,0 +1,189 @@
+
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+==========================================================================
+Flow in cmt_parser
+
+--------------------------------------
+Cmt::parser (command_line)
+  split command line into a vector of args
+  call parser (args)
+
+--------------------------------------
+Cmt::parser (args)
+  init ArgParser
+  call clear
+  call configure
+  set m_current_access to user or developer mode
+  parse_arguments
+  handle extra lines or extra requirements
+
+  call use_cmt and use_home is needed
+  select recursive
+  reach current package and call use_user_context if needed
+
+  detect error if needed
+
+  execute action
+
+
+--------------------------------------
+
+
+
+==========================================================================
+Gestionnaire de messages de log dans CMT
+----------------------------------------
+
+cmt_log (...)
+
+will
+
+o display or not according to the level of output
+
+   [default] quiet
+   verbose = <n>
+   debug
+
+o pour le mode debug on devrait rajouter la fonction??
+
+A terme doit remplacer tous les outputs de CMT !!!
+
+
+==========================================================================
+1) actions in CMT [DONE]
+-----------------
+Principle:
+  define an "action" concept similar to constituents (or macro????)
+
+  - it has a name
+
+  - its name corresponds to a make target
+
+  - it receives in its value a shell command (subject to macro
+  expansion before activation)
+
+  - can be run out of the make context through the "cmt do <action>" command.
+
+  - in the context of gmake a temporary make fragment will be
+  generated, holding the associated shell command.
+
+
+examples
+
+action A "xxx" WIN32 "yyy"
+
+=> the syntax is like macros but the execution phase is close to constituents.
+
+One may either do 
+
+> cmt do A
+
+or
+
+gmake A
+
+Question : do we need parameters
+
+action A "xxx<p>" WIN32 "yyy<p>"
+action A "xxx$(p)" WIN32 "yyy$(p)"
+
+so that 
+
+> cmt do A p=z
+> gmake A p=z
+
+Question : can action replace setup_script ?
+
+Implementation : reuse the symbol code.
+
+Cmt::do_do (...)
+  o at least first argument should be the action name
+  o optional param-value pairs will assign value to macros
+
+     cmt do A p=y
+
+    equivalent to [macro p "y"]
+
+cmt show constituents should show actions as well
+
+when generating the constituent make files we also have to generate
+makefiles for actions.
+=> name space for actions share the name space for constituents
+=> there is a target_<action> tag [see next design]
+
+Actually, doing
+
+action A "cmd"
+
+is equivalent to doing:
+
+document cmt_action_runner A action_value='cmd'
+
+==========================================================================
+2) target tags DONE
+--------------
+Principle:
+
+  - Each constituent (or action) is associated with a make target
+
+  - let's also generate a "tag" associated with the make target.
+
+  - the tag format is target_<name>
+
+  - the group tags are also defined as tag associations
+
+      tag target_all target_A target_B
+
+==========================================================================
+3) A pattern also defines a dynamic CMT keyword.[DONE]
+
+ => at the end of the parser if the word did not match any standard
+ CMT keyword, then we look into the pattern name space.
+
+ex. 
+
+pattern A ...
+
+apply_pattern A p=x
+
+is equivalent to 
+
+A p=x
+
+==========================================================================
+4) Revival of the concept of Project[DONE]
+
+o One project is associated with every CMTPATH
+
+o Strategies are stored into project objects
+
+o project objects are ordered like CMTPATHs
+
+o Each CMTPATH entry does generate one Project
+
+o unnamed projects receive a default name [TBD]
+
+o Projects can be named:
+
+   project abcd
+
+   Will name the project associated with the cmtpath of the package where this is defined.
+
+o By default Projects inherit properties of the previous project
+
+o Any package has a corresponding project which is the project
+associated with the CMTPATH entry of this package.
+
+o CMT itself defines the "base" project (named CMT)
+
+
+
+
+
+
+
Index: /CMT/v1r20/doc/Doxyfile
===================================================================
--- /CMT/v1r20/doc/Doxyfile	(revision 368)
+++ /CMT/v1r20/doc/Doxyfile	(revision 368)
@@ -0,0 +1,716 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+# Doxyfile 1.2.2
+
+# This file describes the settings to be used by doxygen for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# General configuration options
+#---------------------------------------------------------------------------
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project. 
+
+PROJECT_NAME           = "CMT"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = 
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = Doxygen
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Dutch, French, Italian, Czech, Swedish, German, Finnish, Japanese, 
+# Korean, Hungarian, Spanish, Romanian, Russian, Croatian, Polish, and 
+# Portuguese.
+
+OUTPUT_LANGUAGE        = English
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES 
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation. 
+
+EXTRACT_PRIVATE        = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation. 
+
+EXTRACT_STATIC         = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled. 
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these class will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled. 
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this. 
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed. 
+
+REPEAT_BRIEF           = YES
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description. 
+
+ALWAYS_DETAILED_SEC    = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used. 
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. It is allowed to use relative paths in the argument list.
+
+STRIP_FROM_PATH        = 
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation. 
+
+INTERNAL_DOCS          = NO
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a class diagram (in Html and LaTeX) for classes with base or 
+# super classes. Setting the tag to NO turns the diagrams off. 
+
+CLASS_DIAGRAMS         = YES
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation. 
+
+INLINE_SOURCES         = YES
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible. 
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower case letters. If set to YES upper case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# users are adviced to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden. 
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this. 
+
+VERBATIM_HEADERS       = YES
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put list of the files that are included by a file in the documentation 
+# of that file. 
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES (the default) then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the Javadoc-style will 
+# behave just like the Qt-style comments. 
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# reimplements. 
+
+INHERIT_DOCS           = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members. 
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order. 
+
+SORT_MEMBER_DOCS       = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments. 
+
+TAB_SIZE               = 8
+
+# The ENABLE_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif. 
+
+ENABLED_SECTIONS       = 
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines. 
+
+ALIASES                = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used. 
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used. 
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled. 
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. 
+
+WARN_FORMAT            = "$file:$line: $text"
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces. 
+
+INPUT                  = ../source
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included. 
+
+FILE_PATTERNS          = cmt*.cxx cmt*.h
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used. 
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag. 
+
+EXCLUDE                = 
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. 
+
+EXCLUDE_PATTERNS       = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command). 
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included. 
+
+EXAMPLE_PATTERNS       = 
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command). 
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output. 
+
+INPUT_FILTER           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces. 
+
+ALPHABETICAL_INDEX     = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20]) 
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers. 
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output. 
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path. 
+
+HTML_OUTPUT            = html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet 
+
+HTML_STYLESHEET        = 
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used. 
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) 
+# of the generated HTML documentation. 
+
+GENERATE_HTMLHELP      = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it. 
+
+DISABLE_INDEX          = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output. 
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path. 
+
+LATEX_OUTPUT           = latex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general. 
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used. 
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output. 
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing! 
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer. 
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation. 
+
+USE_PDFLATEX           = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML. 
+
+LATEX_BATCHMODE        = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimised for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path. 
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general. 
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using a WORD or other. 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links. 
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assigments. You only have to provide 
+# replacements, missing definitions are set to their default value. 
+
+RTF_STYLESHEET_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages 
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path. 
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3) 
+
+MAN_EXTENSION          = .3
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation. Warning: This feature 
+# is still experimental and very incomplete.
+
+GENERATE_XML           = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files. 
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES. 
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_PREDEFINED tags. 
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found. 
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor. 
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used. 
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. 
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition. 
+
+EXPAND_AS_DEFINED      = 
+
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tagfiles. 
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads. 
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed. 
+
+ALLEXTERNALS           = NO
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl'). 
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default) 
+
+HAVE_DOT               = YES
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes. 
+
+COLLABORATION_GRAPH    = YES
+
+# If the ENABLE_PREPROCESSING, INCLUDE_GRAPH, and HAVE_DOT tags are set to 
+# YES then doxygen will generate a graph for each documented file showing 
+# the direct and indirect include dependencies of the file with other 
+# documented files. 
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, INCLUDED_BY_GRAPH, and HAVE_DOT tags are set to 
+# YES then doxygen will generate a graph for each documented header file showing 
+# the documented files that directly or indirectly include this file 
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one. 
+
+GRAPHICAL_HIERARCHY    = YES
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found on the path. 
+
+DOT_PATH               = 
+
+# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images. 
+
+MAX_DOT_GRAPH_WIDTH    = 1024
+
+# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height 
+# (in pixels) of the graphs generated by dot. If a graph becomes larger than 
+# this value, doxygen will try to truncate the graph, so that it fits within 
+# the specified constraint. Beware that most browsers cannot cope with very 
+# large images. 
+
+MAX_DOT_GRAPH_HEIGHT   = 1024
+
+DOT_IMAGE_FORMAT       = gif
+
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be 
+# used. If set to NO the values of all tags below this one will be ignored. 
+
+SEARCHENGINE           = NO
+
+# The CGI_NAME tag should be the name of the CGI script that 
+# starts the search engine (doxysearch) with the correct parameters. 
+# A script with this name will be generated by doxygen. 
+
+CGI_NAME               = search.cgi
+
+# The CGI_URL tag should be the absolute URL to the directory where the 
+# cgi binaries are located. See the documentation of your http daemon for 
+# details. 
+
+CGI_URL                = 
+
+# The DOC_URL tag should be the absolute URL to the directory where the 
+# documentation is located. If left blank the absolute path to the 
+# documentation, with file:// prepended to it, will be used. 
+
+DOC_URL                = 
+
+# The DOC_ABSPATH tag should be the absolute path to the directory where the 
+# documentation is located. If left blank the directory on the local machine 
+# will be used. 
+
+DOC_ABSPATH            = 
+
+# The BIN_ABSPATH tag must point to the directory where the doxysearch binary 
+# is installed. 
+
+BIN_ABSPATH            = /usr/local/bin/
+
+# The EXT_DOC_PATHS tag can be used to specify one or more paths to 
+# documentation generated for other projects. This allows doxysearch to search 
+# the documentation for these projects as well. 
+
+EXT_DOC_PATHS          = 
Index: /CMT/v1r20/doc/Makefile
===================================================================
--- /CMT/v1r20/doc/Makefile	(revision 368)
+++ /CMT/v1r20/doc/Makefile	(revision 368)
@@ -0,0 +1,14 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+pack = CMT
+wwwdir = /lal/www/Public/SI/
+
+install :
+	cp ${pack}Doc.html ${wwwdir}/${pack}
+	cp ${pack}Doc.ps.Z ${wwwdir}/${pack}
+	cp $(pack).htm  $(wwwdir)/$(pack)
+
Index: /CMT/v1r20/doc/ReleaseNotes.html
===================================================================
--- /CMT/v1r20/doc/ReleaseNotes.html	(revision 368)
+++ /CMT/v1r20/doc/ReleaseNotes.html	(revision 368)
@@ -0,0 +1,758 @@
+<!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+-->
+
+<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
+<html>
+  <head>
+    <title>Release notes</title>
+
+    <style type='text/css'>
+li.bug
+{
+  color:#FF0000;
+}
+li.new
+{
+  color:#0000FF;
+  font-weight:bold;
+}
+li.int
+{
+  color:#00FF00;
+}
+<!--  font-style:italic; -->
+    </style>
+  </head>
+  
+  <body BGCOLOR="#FFFFFF" link="#550088" alink="#007777" alink="#007777">
+    <h1>Release notes</h1>
+
+    <blockquote>
+      <center><i>Notation</i></center>
+      <ul>
+	<li class="new">New features</li>
+	<li class="bug">Bug fixes</li>
+	<li class="int">Internal management</li>
+      </ul>
+    </blockquote>
+
+    <ul>
+
+ <li>
+        <b>v1r19</b>
+	<ul>    
+    <li class="new">Add support for wildcarded project dependencies which Allow CMTPROJECTPATH overrides, e.g.: use project v*.</li>
+    <li class="new">Support for the author keyword at the project level and the corresponding command is <tt>cmt show project_author</tt>
+    to obtain it from command line.</li>
+    <li class="new">Extend the strategy syntax for supporting variable, e.g.:
+    <pre>
+        macro use_strategy "without_installarea" \
+                   ATLAS "with_installarea"
+
+        build_strategy $(use_strategy)
+    </pre>
+    </li>
+    <li class="new">Add a option to bypass the <tt>cmt config</tt> step after the cvs checkout: <tt>cmt co -no_config ...</tt>.</li>
+	<li class="new">Add a new traversal mode for the cmtpath_pattern: <tt>cmtpath_pattern_revert</tt>. This is for constructing macro from current 
+	project to projects used (Atlas's request).</li>	
+	<li class="bug">Disable warning about tags,e.g. CMTSITE. To re-enable them you should use cmt with the <tt>-warnings</tt> option.</li>	
+	<li class="int">Introduce the pre-compiler __APPLE__ macro for removing compilation warnings.</li>
+  
+	</ul>
+ </li>
+ 
+<li>
+        <b>v1r18p20061003</b>
+	<ul>
+        <li class="bug">Correct problem with long word during compilation which reach make limit(Atlas's request).</li>
+	</ul>
+ </li>
+	
+ <li>
+        <b>v1r18p20060606</b>
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">
+	  Add a touch functionnality, e.g. <tt>cvs co -t package</tt>, during cvs checkout, this is mainly due that cvs keeps the file 
+	  timestamps so that build tools, i.d. make, can not recognize it as "new". The "best" default behaviour is for it to set the filestamp 
+	  to the checkout time.</li>
+
+      <li class="new"> Add the support on Linux/make for creating separate directory for libraries/constituents.
+      To be Atlas compliant, this strategy is not built by default you should called explicitely the STRUCTURED_OUTPUT option, e.g. 
+      <tt>make STRUCTURED_OUTPUT=1</tt>. For more informations see the following <a href="http://trac.lal.in2p3.fr/CMT/ticket/10">Bug 
+      report</a>.</li>
+
+	  <li class="new"> Supress the n repeated entries in the CMTPATH after the first found occurence.</li>
+
+	  <li class="int"> Add the cvs <tt>"-f"</tt> option which force cvs to ignore the user .cvsrc file during cvs 
+	  command execution. It appears to create problem with the cmtcvs plugin and empty directories
+	  within cvs.</li>
+
+      <li class="int">Translate symlinks for the <tt>cmt show packages</tt> command.<li>
+
+	  <li class="bug"> Bring a better support for the cmt checkout operation to bypass cvs weird behaviours, e.g. chekout 
+	  localy a directory whithout any files inside creates nothing.</li>
+
+      <li class="bug"> Correct problems when checkouting successively the same package with a different tag in the
+       <tt>without version directory</tt>mode.</li>
+
+      <li class="bug">Compute the project of the package when expanding the <project> template to fix packages with offset .</li>
+	  	  	  
+	</ul>
+
+ </li>
+
+      <li>
+        <b>v1r18p20051101</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">Add a new standard macro definition
+	  <tt>$(q)</tt> to hold a double quote. This is useful to
+	  define symbol values that contin doublequotes so as they are
+	  not filtered out by CMT. Typical usage is to cope with paths
+	  containing spaces on Windows. Various fixes have been done
+	  to improve the support of spaces in paths</li>
+
+	  <li class="new">The <tt>pacman</tt> source file for CMT now
+	  includes a constraint on the version of Pacman.</li>
+
+	  <li class="bug">Added a mechanism to filter out bad items in
+	  a PATH symbol. This was causing troubles at <tt>source
+	  setup</tt> time</li>
+
+	  <li class="bug">Added a protection against old protocols in
+	  the CVS pluggin</li>
+
+	  <li class="bug">Better support of release-less projects on
+	  Windows</li>
+
+	  <li class="bug">Added a protection against single level
+	  directories in CMTPATH</li>
+
+	  <li class="bug">Added a protection against unexisting
+	  makefile fragments when running the <tt>clean</tt> target.</li>
+
+	  <li class="bug">The definition of standard macros was not
+	  properly set when using the <tt>cmt broadcast</tt>
+	  command. Thus environment variables where badly preset.</li>
+
+	  <li class="int">Improve the automatic preparation of CMT releases</li>
+
+	  <li class="int">The internal <tt>Makefile</tt> structure has
+	  been cleaned up to remove obsolete internal targets (leading
+	  to confusing behavours in some cases)</li>
+
+        </ul>
+
+      </li>
+
+      <li>
+        <b>v1r18p20050901</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">Package creation (either from the <tt>cmt
+	  create</tt> or the <tt>cmt co</tt> commands is affected by
+	  the specification of the structuring style or of the
+	  structuring strategy.</li>
+
+	  <li class="new">Introduce a new strategy structure_strategy
+	  with only one value with/out_version_directory. This is
+	  mostly useful when installed in a project file to condition
+	  the behaviour of package creation afterwards</li>
+
+	  <li class="new">Support dependency building using external
+	  tools such as cpp -M. Fix the cmt_build_des.sh wrapper
+	  script to properly format the command output.</li>
+
+	  <li class="new">Perform the cmt checkout onto a project even
+	  if the basic directory structure of the project is already
+	  in place.</li>
+
+	  <li class="new">When no current project is defined the
+	  strategies are taken from the top project (eg obtained from
+	  the CMTPATH)</li>
+
+	  <li class="new">The include_dirs statement can now be hidden
+	  in a private section.</li>
+
+	  <li class="new">The include_dirs statement now accepts a
+	  macro reference as its value</li>
+
+
+
+	  <li class="bug">Fix incorrect generation of XXXROOT and
+	  XXXCONFIG environment variables according to strategies</li>
+
+	  <li class="bug">Protect against missing un/install targets</li>
+
+	  <li class="bug">Fix a typo in cmt_uninstall_action.bat
+	  resulting in bad management of make cleanup on Windows</li>
+
+	  <li class="bug">When creating a parent-less project, link it
+	  to exisiting top project(s) and upgrade strategies
+	  accordingly. Avoid confusions when mixing explicit CMTPATH,
+	  CMTPROJECTPATH and project files </li>
+
+	  <li class="bug">Don't apply include_dirs when their expanded
+	  value is empty (avoid killing -I"")</li>
+
+	  <li class="bug">Reset CMTPATH to empty when filling in
+	  CMTPATH from projects (avoid confusions and
+	  dupplications)</li>
+
+	  <li class="bug">Fix a bug in dependency builder that missed
+	  some statements after a single line C++ comment</li>
+
+	  <li class="bug">Cleanup unneeded duplicate path
+	  separators</li>
+
+	  <li class="bug">Fix a bug in standard macro generation for
+	  projects</li>
+
+        </ul>
+
+      </li>
+
+      <li>
+        <b>v1r18p20050501</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">Fill in a pacman cache for CMT using pacman3
+	  syntax. The Pacman package name is CMT.</li>
+
+	  <li class="new">Extend the recursive checkout mechanism to
+	  projects. The recursivity covers the use relationships
+	  between projects and propagates to packges of a project when
+	  the container package is specified in the project file.</li>
+
+	  <li class="new">Add the cvssubprojects query command to
+	  retrieve subprojects at a CVS repository level</li>
+
+	  <li class="new">Add a container statement in project
+	  file. The syntax is like use statements. It indicates that a
+	  container-like package exists in the project. This is useful
+	  for recursive checkout operations.</li>
+
+	  <li class="int">Migrate to a new version of the CVS
+	  pluggin. Now the protocol level is explicitly referenced
+	  when sending CVS requests via the pluggin. The new protocol
+	  gives the nature of the CVS module: is it a project or a
+	  package. The protocol level is specified in a dedicated
+	  macro in the CMT requirements file.</li>
+
+	  <li class="bug">Fix the production of shared libraries on CYGWIN</li>
+
+	  <li class="bug">Fix ambiguities between physical paths and
+	  logical paths in PATH variables management</li>
+
+	  <li class="bug">Fix arg counting bugs in cvstags and cvssubpackages commands</li>
+
+	</ul>
+
+      </li>
+
+      <li>
+        <b>v1r18p20050401</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">Introduce a new bug reporting system: Trac</li>
+
+	  <li class="new">Accept HEAD or head as a valid version tag for packages</li>
+
+	  <li class="new">The path of CMT is removed from
+	  CMTPATH. Packages aside CMT are no longer reachable by
+	  default</li>
+
+	  <li class="new">Major restructuring of the project
+	  management and package localisation. The most important
+	  parameter becomes the search path CMTPROJECTPATH for
+	  projects. Then CMTPATH is deduced from the effective list of
+	  used projects. Project files and the dependency graph
+	  described by the project use statement becomes a central
+	  mechanism.</li>
+
+	  <li class="new">Introduce the management of releases for
+	  projects. Release must exactly match</li>
+
+	  <li class="new">Install a mechanism to detect unused tags
+	  from arguments or CMTSITE. This is performed during the
+	  setup generation</li>
+
+	  <li class="int">Source code management tansfered to SVN</li>
+
+	  <li class="int">Restructure the strategy management to make
+	  it fully generic.</li>
+
+	  <li class="bug">Fix poor management of unknown commands </li>
+
+	  <li class="bug">Suppress the export action for alias in setup.sh</li>
+
+	  <li class="bug">Fix a problem in TMPDIR management with
+	  multi directory level</li>
+
+	  <li class="bug">Fix a problem in cmt show packages</li>
+
+	  <li class="bug">Fix bad parsing of various cmt commands</li>
+
+	  <li class="bug">Fix an internal bug causing misfunction in
+	  the -import parameter of constituents.</li>
+
+	  <li class="bug">Fix fragment for action to improve argument transmission</li>
+
+	  <li class="bug">Fix pdb files for Visual about debug mode</li>
+
+        </ul>
+
+      </li>
+
+      <li>
+        <b>v1r18p20041201</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="int">Suppress the completely unused makefile strategy</li>
+
+	  <li class="bug">Really apply the project specific setup
+	  strategy to control the generation of ROOT or CONFIG
+	  env. variables.</li>
+
+	  <li class="new">Change default build strategy to <tt>without_installarea</tt></li>
+
+	  <li class="new">${CMTROOT} is no longer an automatic part of
+	  the CMTPATH. Nor the current package automatically defines
+	  an entry in the CMTPATH search list. However a feature
+	  partly compensates this evolution: the current project
+	  (i.e. the current package area, where the developer stands)
+	  is autmatically detected when its project file exists
+	  (i.e. when its cmt/project.cmt file exists). For instance,
+	  this suppresses the need to set CMTPATH when working in one
+	  single project.</li>
+
+	  <li class="new">The general cmt command parsing mechanism
+	  has been revisited and now "actions" are considered as
+	  extended cmt commands and no longer need the "cmt do
+	  &lt;action&gt;" syntax. One can directly use "cmt
+	  &lt;action&gt;" when the action does not conflict with
+	  internal cmt commands.</li>
+
+	  <li class="new">Command line arguments are transmitted to
+	  "actions" now through the new standard "cmt_args" macro</li>
+
+	  <li class="bug">Really force the settings of all
+	  Env. variables before running internal cmmands through
+	  broadcast, run or do commands.</li>
+
+	  <li class="new">The "cmt run" command transmits all its
+	  arguments to the launched action</li>
+
+	  <li class="new">Revisit the production of dependency files,
+	  to consider the changes made to the configuration in general
+	  in addition to the usual source changes. This consists in
+	  generating one stamp file per source, touched when its
+	  contents change rather than when recomputing the
+	  dependencies.</li>
+
+	  <li class="bug">Better protections for CMTPATH entries</li>
+
+	  <li class="int">Major internal restructuring of the CMT
+	  package. Internal sources are now in ../source, ../src only
+	  contains publicly exported configuration files, fragments
+	  are in ../mgr/fragments. This is for constructing a really
+	  autonomous binary kit for CMT (eg for Fink) (without needing
+	  to export two kits)</li>
+
+	  <li class="bug">Now produce the last revision date of the
+	  CMT documentation. Insert the complete version tag rather
+	  than just the base version tag.</li>
+
+	  <li class="new">Suppress the systematic production of
+	  bundles on Darwin machines. This must now be done
+	  explicitly.</li>
+
+	  <li class="bug">The algorithm for commpressing paths with
+	  ../ patterns now takes into account the presence of ${xxx}
+	  expressions that cannot be reduced. It also better handle
+	  various patterns that used to produce failures.</li>
+
+	  <li class="bug">A global checking of the configuration is
+	  performed first when running Make</li>
+
+	  <li class="new">Incompatible major ids in the version
+	  numbers are now managed like the minor id, ie. the decision
+	  is taken in a similar way. The usual error message is
+	  displayed but this is no longer fatal, and a decision is
+	  taken</li>
+
+        </ul>
+
+      </li>
+
+      <li>
+        <b>v1r16p20040901</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">Introduce the support of SLC3 (Scientific
+	  Linux) platforms</li>
+
+	  <li class="new">Trigger the reconstruction of the dependency
+	  makefile fragment from a change in the
+	  &lt;package&gt;_setup.make, ie from any change in tags, uses
+	  or CMTPATHs</li>
+
+	  <li class="new"><tt>CMTBIN</tt> now follows a new convention
+	  on Unix `uname`-`uname -m` to differentiate among Linux
+	  platforms.</li>
+
+	  <li class="new">Introduce a new -strict option to the cmt
+	  expand model to support model files freely formatted. This
+	  implied securing the user defined model elements by the
+	  <tt>cmts</tt> or <tt>cmtv</tt> name space
+	  keywords. <tt>cmts:xxx</tt> indicates a scalar modelling
+	  element <tt>xxx</tt> meant to be expanded only
+	  once. <tt>cmtv:yyy</tt> indicates a vector modelling element
+	  <tt>yyy</tt> meant to be expanded once per item in the
+	  vector of values.</li>
+
+	  <li class="new">Better management of temporary file
+	  generation. Now support the standard TMPDIR environment
+	  variable to redirect temporary locations.</li>
+
+	  <li class="int">Apply the new GPL-like licence officially
+	  provided by CNRS-CEA-INRIA</li>
+
+	  <li class="int">Use stderr instead of stdout to display
+	  error and warning messages. Mainly to better expose messages in
+	  the source setup operations</li>
+
+	  <li class="bug">Protect against source files not found (avoid infinite loops in make)</li>
+
+	  <li class="bug">Better management of the build strategy on
+	  installation area to generate various automatic macros or
+	  sets (installarea_linkopts, PATH, LD_LIBRARY_PATH,
+	  etc...)</li>
+
+	  <li class="bug">Revisit the package scan algorithm to
+	  improve the detection of directory structure of packages as
+	  well as their version tags.</li>
+
+	  <li class="bug">Compress the path definitions (ie compress
+	  the ../xxx patterns) and use the compressed paths
+	  everywhere</li>
+
+	</ul>
+
+      </li>
+
+      <li>
+        <b>v1r16p20040701</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="bug">Better generation of .def files for DATA</li>
+
+	  <li class="bug">fix a bug that impacted on the order of
+	  compatible use requests with different wilcarded specifications</li>
+
+	</ul>
+
+      </li>
+
+      <li>
+        <b>v1r16p20040527</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">Generate the <tt>target_${CONSTITUENT}</tt>
+	  tag to trigger configuration control per target. This
+	  feature is only activated when the new <tt>-target_tag</tt>
+	  option is specified to a constituent. Specific tag makefiles
+	  are then generated for those targets. This tag is activated
+	  either when <tt>make &lt;target&gt;</tt> or <tt>cmt do
+	  &lt;action&gt;</tt> is run.</li>
+
+	  <li class="new">Add a section on package semantics in the documentation</li>
+
+	  <li class="new">The <tt>apply_tag</tt> keyword now accepts macro expansion for its argument.</li>
+
+	  <li class="new">Add the support for Enterprise Linux</li>
+
+	  <li class="new">Create automatic tags from
+	  <tt>cmt_hardware</tt> <tt>cmt_system_version</tt> and
+	  <tt>cmt_compiler_version</tt></li>
+
+	  <li class="new">Add a filtering script to keep 3 digits instead of 2</li>
+
+	  <li class="int">Start the implementation of a centralized log message facility</li>
+
+	  <li class="int">Implement a <tt>READONLY</tt> mode to
+	  Makefiles to generate all intermediate files in
+	  <tt>/tmp/CMT_*</tt> rather than in <tt>../cmt</tt></li>
+
+	  <li class="int">Associate a dedicated project with CMTHOME and CMTUSERCONTEXT to manage strategies</li>
+
+	  <li class="bug">Set the macro <tt>shlibsuffix</tt> for Win32</li>
+	  <li class="bug">Use /bin/pwd instead of the raw pwd in various CMT scripts for Unix</li>
+	  <li class="bug">Fix misunderstanding of of version specification of the form v1r2p (ie without a trailing number)</li>
+	  <li class="bug">Explicitly close the scope sections at the end of requirements files</li>
+
+	</ul>
+
+      </li>
+
+      <li>
+        <b>v1r16</b>
+
+	<ul>
+
+	  <!--
+	  <li class="new"></li>
+	  <li class="bug"></li>
+	  <li class="int"></li>
+	  -->
+
+	  <li class="new">Offer an [x]emacs mode for editing requirements files</li>
+
+	  <li class="new">Permit macro expressions in the <tt>tag</tt> statement</li>
+
+	  <li class="new">Possibility to specify additional
+	  <tt>mount_filters</tt> in <tt>.cmtrc</tt></li>
+
+	  <li class="new">Introduce new regexp-based remove operations
+	  for symbols <tt>macro_remove_regexp</tt>,
+	  <tt>set_remove_regexp</tt> and
+	  <tt>path_remove_regexp</tt></li>
+
+	  <li class="new">Add <tt>-n</tt> and <tt>-v</tt> options to
+	  <tt>cmt cvs</tt> commands to support simulation and verbose
+	  modes</li>
+
+	  <li class="new">Ensure that the <tt>constituents</tt> macro is always private</li>
+
+	  <li class="new">Introduce support for <i>projects</i>
+	  associated with package areas, i.e. one project per item in
+	  <tt>CMTPATH</tt>. Possibility to setup strategies per
+	  project. Project definitions stored in a new
+	  <tt>cmt/project.cmt</tt> top level file. New
+	  <tt>&lt;package&gt;_project</tt> standard macro. And
+	  associated pattern templates.</li>
+
+	  <li class="new">Make <tt>CMTINSTALLAREA</tt> a macro instead of a set</li>
+
+	  <li class="new">Suppress dependency computation when the
+	  <tt>make QUICK=1</tt> option is used</li>
+
+	  <li class="new">New <i>action</i> concept to support
+	  simplified shell action definition. Action is an extension
+	  of the generic symbol mechanism (like macros), thus defining
+	  an action uses the same syntax as macros. Actions are
+	  triggered with <tt>make</tt> or <tt>cmt do</tt></li>
+
+	  <li class="new"><i>public</i> and <i>private</i> section can be ended by a
+	  new keyword <tt>end_public</tt> <tt>end_private</tt>. Ending
+	  keywords switch back to the previous scope active before the
+	  most recent opening keyword</li>
+
+	  <li class="new">Can use a pattern name as a plain CMT
+	  keyword. I.e. the <tt>apply_pattern</tt> keyword is optional
+	  except to resolve ambiguities</li>
+
+	  <li class="int">Generate part of the standard macros before
+	  reading the requirements file</li>
+
+	  <li class="int">Lots of internal optimisations checked with
+	  <tt>valgrind</tt> and <tt>gprof</tt></li>
+
+	  <li class="bug">Only set non empty environment variables</li>
+
+	  <li class="bug">Fix bad definition of <tt>&lt;PACKAGE&gt;VERSION</tt></li>
+
+	  <li class="bug">Add dependency to all stamps file to trigger rebuild of shared libraries</li>
+
+	  <li class="bug">Add dependency to all requirements file to trigger rebuild of applications</li>
+
+	  <li class="bug">Suppress install area cleanup action from
+	  cmt config and cmt setup</li>
+
+	  <li class="bug">Improved syntax checking on constituents</li>
+
+	  <li class="bug">Fix construction of paths when symlinks
+	  exist along pwd</li>
+
+	  <li class="bug">Added various protections for bad pattern
+	  syntaxes</li>
+
+	</ul>
+
+      </li>
+      <li>
+        <b>v1r14p20031120</b>
+	<ul>
+	  <li class="new">Add a new standard macro $(&lt;group&gt;_dependencies)to specify global dependencies for a group</li>
+	  <li class="new">Add support for bundles on Darwin platforms</li>
+	  <li class="bug">Consider symlinked paths in CMTPATH entries</li>
+	  <li class="bug">Always setup cmtpath patterns even if the current installation area is undefined</li>
+
+	  <li class="new">Provide a generic pacman manifest file for
+	    CMT. All instances of the "&lt;version&gt;" pattern need to be
+	    substituted by the effective version of CMT to make it a
+	    real pacman file as follows:
+	    <pre>sed -e 's#[&lt;]version[&gt;]#'`cmt -quiet version`'#g' $CMTROOT/mgr/CMT.pacman</pre>
+	  </li>
+
+	</ul>
+      </li>
+
+      <li>
+        <b>v1r14p20031027</b>
+	<ul>
+	  <li class="bug">Fix a bug in the bootstrap mechanism to define CMTINSTALLAREA</li>
+	</ul>
+      </li>
+
+      <li>
+        <b>v1r14p20031022</b>
+	<ul>
+	  <li class="new">Add the possibility to specify exclusion files when installing directories in Installation Area (on windows only)</li>
+	  <li class="bug">Fix a bug : CMTINSTALLAREA symbol has to be defined before all other symbols in set_standard_macros</li>
+	  <li class="bug">Few fixes on nmake flavour of install area mechanisms</li>
+	  <li class="new">Generate &lt;package&gt;_cmtpath and &lt;package&gt;_offset also for current package</li>
+	  <li class="bug">Fix warning messages that confuse csh when environment variables are not defined</li>
+	</ul>
+      </li>
+
+      <li>
+        <b>v1r14p20031014</b>
+	<ul>
+	  <li class="bug">Fix a problem in broadcast operation for handling return status 2 (caused to unexpectedly break the loop in some cases)</li>
+	  <li class="bug">Force auto_imports to On when context is unspecified (internal)</li>
+	  <li class="bug">Stop trying to make use of PWD</li>
+	  <li class="bug">Fix a bug in internal incomplete expansion of macros</li>
+	  <li class="bug">Fix a bug in consistency checks of PWD vs CMTINSTALLAREA</li>
+	  <li class="new">Convert $(cmtpath) and $(offset) macros to $(package_cmtpath) and $(package_offset)</li>
+	  <li class="new">Add dependency list for constituent makefile similar to the constituent target (force the same build order)</li>
+	  <li class="bug">Fix a bug in use graph internal management</li>
+	  <li class="bug">Fix setup script calling mechanism in no_version style</li>
+	  <li class="new">Add a -k=&lt;regexp&gt; argument for selection patterns of constituent sources.</li>
+	  <li class="new">Support wildcarded suffixes (*.*) in constituent sources</li>
+	  <li class="new">Standardize the output format of show uses (make it reliable for user scripts)</li>
+	</ul>
+      </li>
+
+      <li>
+        <b>v1r14p20030811</b>
+	<ul>
+	  <li class="bug">Trailing slashes on offset specification in use statement were causing troubles. Now they are properly handled.</li>
+	  <li class="new">The broadcast pattern as well as the standard macro &lt;cmtpath&gt; is now renamed &lt;package_cmtpath&gt; to avoid confusion with the CMTPATH variable on Windows.</li>
+	  <li class="int">Make use of ${PWD} when available to acquire the value for "cmt show pwd"</li>
+	  <li class="bug">Add or refresh tuning for CYGWIN and for LynxOS</li>
+	  <li class="bug">Work around a limitation of some old version of the C++ compiler on LynxOS</li>
+	  <li class="new">Improve the display of incompatible use specifications.</li>
+	  <li class="int">Dynamically create the CMTDownload.html web page to really reflect what is available when installing the CMT release on the primary CMT web site.</li>
+	  <li class="bug">Setup.bat scripts on DOS are now relocatable wrt heterogeneous file systems (AFS, DFS, etc...)</li>
+	</ul>
+      </li>
+
+      <li>
+        <b>v1r14p20030620</b>
+	<ul>
+	  <li class="new">introduce a generic "Unix" tag for all Unix platforms. Both Linux, HP-UX, LynxOS, alpha, ... do validate Unix</li>
+	  <li class="new">hide the make_fragments declaration in private sections. This was not true previously. A make_fragment declaration installed in a private section will now be hidden to clients.</li>
+	  <li class="bug">convert ${} into $() syntax for tag makefiles on Windows. This actually reverts to a feature of an old CMT version which had disappeared. This was causing a problem since the ${} syntax is not understood by nmake</li>
+	  <li class="new">add a command "cmt show use_paths &lt;target&gt;" to display all possible paths to the target package. This is useful to understand how a given package is reached, for instance when it is desired to cut the use relationship and make it private somewhere in the graph.</li>
+	  <li class="new">add a command "cmt show cycles" to display circular dependencies in the use graph.</li>
+	  <li class="new">provide a binary RPM for CMT itself (only for redhat 7.2 distribution). It is downloadable from the usual Download page and provide a complete installation of CMT (including make fragments, binary, etc..). It is a relocatable RPM (install it using the --relocate option). (See the install WEB page for complete notice)</li>
+	  <li class="new">Add an extended script to retrieve information about Linux version (cmt_linux_version.sh). It supports Redhat, Debian, Suse. It is used to compute the cmt_system_version macro (contributions from Clark McGrew and Wim Lavrijsen)</li>
+	  <li class="bug">The setup scripts for Windows now use %TEMP% instead of %HOMEDRIVE%%HOMEPATH% to store temporary files (contributions from Pere Mato and Florence Ranjard)</li>
+	  <li class="new">Add the --public and --private global options for cmt commands, to control whether the use graph traverses or not the private sections:
+<pre>
+&gt; cmt --public ...
+</pre>
+       only sees public uses (default behavior for most commands but not for cmt broadcast and cmt show uses which traverse the private sub graphs)
+<pre>
+&gt; cmt --private ...
+</pre>   
+       forces the traversal of private subgraphs. This is already the default behavior for cmt show uses and for cmt broadcast, but can now be applied to any CMT command.</li>
+	  <li class="bug">A global pattern specifying private sections did not really generate private definitions</li>
+	</ul>
+      </li>
+
+<!--
+      <li>
+        <b></b>
+	<ul>
+	  <li class=""></li>
+	</ul>
+      </li>
+-->
+
+    </ul>
+
+
+    <hr>
+    <address><a href="mailto:arnault@lal.in2p3.fr">Christian Arnault</a></address>
+  </body>
+</html>
Index: /CMT/v1r20/doc/cmt-mode.el
===================================================================
--- /CMT/v1r20/doc/cmt-mode.el	(revision 368)
+++ /CMT/v1r20/doc/cmt-mode.el	(revision 368)
@@ -0,0 +1,418 @@
+
+;;-----------------------------------------------------------
+;; Copyright Christian Arnault LAL-Orsay CNRS
+;; arnault@lal.in2p3.fr
+;; See the complete license in cmt_license.txt "http://www.cecill.info". 
+;;-----------------------------------------------------------
+
+;;; @(#) cmt-mode.el --- a major mode for editing CMT configuration files
+
+;; $Id: cmt-mode.el,v 1.3 2004/08/25 09:04:27 arnault Exp $
+
+;; Copyright (C) 2004 by Antoine Pérus
+
+;; Author: Antoine Pérus <perus@lal.in2p3.fr>
+;; Created: 29 Feb 2004
+;; Keywords: local, languages, tools
+
+;; This file is not part of XEmacs
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+;;
+;; This mode adds some services editing the CMT requirements file.
+;; See <http://www.cmtsite.org> for a CMT description.
+;; This is a hack initialy started from apache.el and css-mode.el
+;; The list of keywords was derived from the documentation for CMT;
+;; there is lot of omissions.
+;;
+;; To enable automatic selection of this mode :
+;;
+;;   (autoload 'cmt-mode "cmt-mode" "autoloaded" t)
+;;   (add-to-list 'auto-mode-alist '("requirements"   . cmt-mode))
+;;
+
+;;; Change Log:
+;;
+;;   13/03/04 - New way in definition of cmt-font-lock-keywords with a more
+;;   modular definition of keyword groups. Should help too for the next step :
+;;   a completion mechanism.
+
+;;; Code:
+
+;; Requires modules
+(eval-when-compile
+  (defvar byte-compile-dynamic nil)	;silence old Emacs's ByteCompiler
+  (set (make-local-variable 'byte-compile-dynamic) t))
+
+(require 'font-lock)
+(require 'custom)
+
+;; Variables
+
+;;;###autoload
+(defgroup cmt nil
+  "Major mode for editing CMT configuration files."
+  :prefix "cmt-"
+  :group 'languages)
+
+(defcustom cmt-manual-url "http://www.cmtsite.org/CMTDoc.html"
+  "*URL at which to find the CMT manual."
+  :type 'string
+  :group 'cmt)
+
+;;;###autoload
+(defcustom cmt-file-patterns
+  (list "requirements")
+  "*List of file patterns for which to automatically invoke `cmt-mode'."
+  :type '(repeat (regexp :tag "Pattern"))
+  :group 'cmt)
+
+(defcustom cmt-mode-hook nil
+  "*List of hook functions run by `cmt-mode' (see `run-hooks')."
+  :type 'hook
+  :group 'cmt)
+
+(defvar cmt-mode-version-id
+  "$Id: cmt-mode.el,v 1.3 2004/08/25 09:04:27 arnault Exp $"
+  "Latest modification time and version number.")
+
+(defconst cmt-mode-version "0.4"
+  "Cmt-mode official version.")
+
+;;; --- end of up-to-date-overview configuration ------------------
+
+(defvar cmt-mode-syntax-table nil
+  "Syntax table for `cmt-mode'.")
+
+;; Make cmt-mode the default mode for cmt config buffers.
+;;;###autoload
+(let ((cmt-file-patterns-temp cmt-file-patterns))
+  (while cmt-file-patterns-temp
+    (add-to-list 'auto-mode-alist
+		  (cons (car cmt-file-patterns-temp) 'cmt-mode))
+    (setq cmt-file-patterns-temp (cdr cmt-file-patterns-temp))))
+
+
+
+(defconst cmt-symbols
+  '(
+    "alias" "action"
+    ;; environment directives
+    "set" "set_append" "set_prepend" "set_remove"
+    ;; path directives
+    "path" "path_append" "path_prepend" "path_remove"
+    ;; macro directives
+    "macro" "macro_append" "macro_prepend" "macro_remove"
+    ;; setup directives
+    "setup_script" "cleanup_script"
+    "setup_strategy"
+    )
+  "A list of CMT symbol keywords.")
+
+(defconst cmt-patterns
+  '(
+    ;; Pattern directives
+    "pattern" "apply_pattern" "ignore_pattern" "cmtpath_pattern"
+    )
+  "A list of CMT pattern keywords.")
+
+(defconst cmt-tags
+  '(
+    "tag" "apply_tag" "ignore_tag" "tag_exclude"
+    )
+  "A list of CMT tags relative keywords.")
+
+(defconst cmt-features
+  '(
+    ;; core directives
+    "package" "version" "project"
+    "author" "manager"
+    ;;
+    "use"
+    ;;
+    "branches"
+    ;;
+    "public" "end_public" "private" "end_private"
+    ;;
+    "application" "library" "document"
+    "make_fragment"
+    ;;
+    "include_dirs" "include_path"
+    )
+  "A list of CMT feature keywords.")
+
+(defconst cmt-options
+  '(
+    "-no_share" "-no_static"
+    "-prototypes" "-no_prototypes" "-check"
+    "-group" "-suffix"
+    "-import" "-no_auto_imports"
+    "-header" "-global"
+    )
+  "A list of CMT options.")
+
+
+(defconst cmt-keywords-alist
+  (append
+   (mapcar (lambda(prop)
+	     (cons (concat prop " ") nil)) cmt-symbols)
+   (mapcar (lambda(prop)
+	     (cons (concat prop " ") nil)) cmt-patterns)
+   (mapcar (lambda(prop)
+	     (cons (concat prop " ") nil)) cmt-tags)
+   (mapcar (lambda(prop)
+	     (cons (concat prop " ") nil)) cmt-features)
+   (mapcar (lambda(prop)
+	     (cons (concat prop "=") nil)) cmt-options)
+   )
+  "An association list of the CMT keywords for completion use.")
+
+
+(defun cmt-list-2-regexp-at-beginning-of-line(altlist)
+  "Takes a list and returns the regexp ^\\s-*\\(elem1\\|elem2\\|...\\)\\s-"
+  (let ((regexp "^\\s-*\\("))
+    (mapcar (lambda(elem)
+              (setq regexp (concat regexp elem "\\|")))
+            altlist)
+    (concat (substring regexp 0 -2) ; cutting the last "\\|"
+            "\\)\\s-")
+    ))
+
+(defun cmt-list-2-regexp(altlist)
+  "Takes a list and returns the regexp \\(elem1\\|elem2\\|...\\)"
+  (let ((regexp "\\("))
+    (mapcar (lambda(elem)
+              (setq regexp (concat regexp elem "\\|")))
+            altlist)
+    (concat (substring regexp 0 -2) ; cutting the last "\\|"
+            "\\)")
+    ))
+
+;; Font lock
+(defconst cmt-font-lock-keywords
+  (purecopy
+   (list
+    (list "^\\s-*#.*$" 0 'font-lock-comment-face t)
+
+    (cons (cmt-list-2-regexp-at-beginning-of-line cmt-symbols)
+	  font-lock-function-name-face)
+
+    (cons (cmt-list-2-regexp-at-beginning-of-line cmt-patterns)
+	  font-lock-function-name-face)
+
+    (cons (cmt-list-2-regexp-at-beginning-of-line cmt-tags)
+	  font-lock-type-face)
+
+    (cons (cmt-list-2-regexp-at-beginning-of-line cmt-features)
+	  font-lock-keyword-face)
+
+    (cons (cmt-list-2-regexp cmt-options) font-lock-type-face)
+
+    ))
+  "Expressions to highlight in `cmt-mode' buffers.")
+
+
+
+
+;; Motion code.
+
+(defconst cmt-pattern-regex
+  (eval-when-compile
+   (concat
+    "^"
+    "\\("
+    "pattern"
+   "\\)"))
+  "Regex used to find patterns.")
+
+(defun cmt-next-pattern ()
+  "Move point to the beginning of the next pattern definition."
+  (interactive)
+  (let ((here (point)))
+    (end-of-line)
+    (if (re-search-forward cmt-pattern-regex (point-max) t)
+	(progn (beginning-of-line) t)	; indicate success
+      (goto-char here) nil)))
+
+(defun cmt-previous-pattern ()
+  "Move point to the beginning of the previous pattern definition."
+  (interactive)
+  (let ((here (point)))
+    (beginning-of-line)
+    (if (re-search-backward cmt-pattern-regex (point-min) t)
+	(progn (beginning-of-line) t)	; indicate success
+      (goto-char here) nil)))
+
+
+(defun cmt-next-feature ()
+  "Move point to the beginning of the next feature."
+  (interactive)
+  (let ((here (point)))
+    (end-of-line)
+    (if (re-search-forward
+	 (cmt-list-2-regexp-at-beginning-of-line cmt-features)
+	 (point-max) t)
+	(progn (beginning-of-line) t)	; indicate success
+      (goto-char here) nil)))
+
+(defun cmt-previous-feature ()
+  "Move point to the beginning of the previous feature."
+  (interactive)
+  (let ((here (point)))
+    (beginning-of-line)
+    (if (re-search-backward
+	 (cmt-list-2-regexp-at-beginning-of-line cmt-features)
+	 (point-min) t)
+	(progn (beginning-of-line) t)	; indicate success
+      (goto-char here) nil)))
+
+
+(defconst cmt-menubar-menu
+    '("Cmt"
+      ["Move to Next Pattern" cmt-next-pattern t]
+      ["Move to Previous Pattern" cmt-previous-pattern t]
+      "---"
+      ["Move to Next Feature" cmt-next-feature t]
+      ["Move to Previous Feature" cmt-previous-feature t]
+    ))
+
+(defconst cmt-popup-menu
+    (cons "CMT Mode Commands"
+	  (cdr cmt-menubar-menu)))
+
+
+
+
+
+;;===============
+
+;;; Property completion
+; This code is stolen from ans1-mode.el.
+
+(defun cmt-completion ()
+  "Do a completion with `cmt-keywords-alist'."
+  (interactive)
+  (let* ((end (point))
+	 (buffer-syntax (syntax-table))
+	 (beg (unwind-protect
+		  (save-excursion
+		    (set-syntax-table cmt-mode-syntax-table)
+		    (skip-syntax-backward "\\w")
+		    (point))
+		(set-syntax-table buffer-syntax)))
+	 (pattern (buffer-substring beg end))
+	 (completion (try-completion pattern cmt-keywords-alist)))
+    (cond ((eq completion t))
+	  ((null completion)
+	   (message "Can't find completion for %s " pattern)
+	   (ding))
+	  ((not (string= pattern completion))
+	   (delete-region beg end)
+	   (insert completion))
+	  (t
+	   (with-output-to-temp-buffer "*Completions*"
+	     (display-completion-list
+	      (sort (all-completions pattern
+				     cmt-keywords-alist)
+		    'string<))))
+	  )
+    )
+  )
+
+
+
+
+
+;;===============
+
+
+;; Syntax table
+(if cmt-mode-syntax-table
+    nil
+  (setq cmt-mode-syntax-table (copy-syntax-table nil))
+  ;; underscore considered part of word
+  (modify-syntax-entry ?_    "w"    cmt-mode-syntax-table)
+  (modify-syntax-entry ?\-   "w"    cmt-mode-syntax-table)
+  (modify-syntax-entry ?\"   "\""   cmt-mode-syntax-table))
+
+
+;; Keymap for cmt-mode.
+(defvar cmt-mode-map nil
+  "Keymap used in `cmt-mode' buffers.")
+
+(if cmt-mode-map
+    nil
+  (setq cmt-mode-map (make-sparse-keymap))
+  ;; Set up the keymap
+  (define-key cmt-mode-map "\M-\t" 'cmt-completion)
+  (define-key cmt-mode-map "\M-p"  'cmt-previous-pattern)
+  (define-key cmt-mode-map "\M-n"  'cmt-next-pattern)
+  (define-key cmt-mode-map "\M-f"  'cmt-next-feature)
+  (define-key cmt-mode-map "\M-b"  'cmt-previous-feature)
+)
+
+
+;;;###autoload
+(defun cmt-mode ()
+  "Major mode for editing CMT requirements files.
+See <http://www.cmtsite.org/CMTDoc.html>.
+
+\\{cmt-mode-map}"
+
+  (interactive)
+
+  ; Initializing
+  (kill-all-local-variables)
+
+  (use-local-map cmt-mode-map)
+  (set-syntax-table cmt-mode-syntax-table)
+
+  ; Setting up font-locking
+  (make-local-variable 'font-lock-defaults)
+  (setq font-lock-defaults '(cmt-font-lock-keywords nil t nil nil))
+
+  ; Comment stuff.
+  (make-local-variable 'comment-start)
+  (make-local-variable 'comment-end)
+  (make-local-variable 'comment-start-skip)
+  (make-local-variable 'comment-column)
+
+  (setq comment-start "#"
+	comment-end ""
+	comment-start-skip "#\\W*"
+	comment-column 48)
+
+  ;; Set menu
+  ;; XEmacs addition
+  (setq mode-popup-menu cmt-popup-menu)
+  (if (featurep 'menubar)
+      (progn
+	;; make a local copy of the menubar, so our mode doesn't
+	;; change the global menubar
+	(set-buffer-menubar current-menubar)
+	(add-submenu nil cmt-menubar-menu)))
+  
+  (setq mode-name "CMT"
+	major-mode 'cmt-mode)
+  (run-hooks 'cmt-mode-hook))
+
+
+;; Provides
+(provide 'cmt-mode)
+
+;;; cmt-mode.el ends here
Index: /CMT/v1r20/doc/gendoc.py
===================================================================
--- /CMT/v1r20/doc/gendoc.py	(revision 368)
+++ /CMT/v1r20/doc/gendoc.py	(revision 368)
@@ -0,0 +1,655 @@
+#!/usr/bin/env python
+
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# author: arnault@lal.in2p3.fr
+# modified by: garonne@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+import sys, os, string, getopt, types
+import xml.parsers.expat
+import commands, glob
+from   datetime import date
+
+
+#------------------------------------------------------------
+def checkPythonVersion (major=1,minor=5):    
+    version      = float(str(major) +'.'+ str(minor))
+    thisversion  = float(str(sys.version_info[0]) + '.' + str(sys.version_info[1]))
+    if    version > thisversion:
+    # try to find the good python version >= 2.3
+        paths = string.split(os.environ['PATH'],':')
+        print 'hmmm look for the appropriate python version, this one is',\
+        thisversion,'and the required version is python >=', version    
+        pythons = list()      
+        for path in paths:
+            pythons = glob.glob1(path, 'python*')
+            for python in pythons:
+                cmd = python +' -c "import sys; print sys.version_info"'
+                status, thisversion = commands.getstatusoutput(cmd)
+                thisversion         = eval (thisversion)
+                thisversion         = float(str(thisversion[0]) +'.'+ str(thisversion[1]))
+                if (thisversion >= version):
+                    print 'found and load', python
+                    sys.argv.insert (0, python)
+                    os.execvp       (python, sys.argv)  
+        print 'The appropriate version of python >=' + version + ' is not here, check your PATH variable or install it'
+        sys.exit(-1)
+
+
+#------------------------------------------------------------
+# A Section holds
+#   an  id     of the form n.m.p
+#   a   title
+#   the level
+#
+class Section :
+  def __init__ (self, id, title, level) :
+    self.id = id
+    self.title = title
+    self.level = level
+  # end def
+
+  # Format the index entry for this section
+  def show_index_entry (self) :
+    tab = string.rjust ("", 4*self.level)
+    tab = tab.replace (" ", "&nbsp;")
+    print '<tr>'
+    print '<td width="100">' + self.id + '</td>'
+    print '<td>' + tab + '<a href="#' + self.title + '">' + self.title + '</a></td>'
+    print '</tr>'
+  # end def
+
+#------------------------------------------------------------
+# A Book
+#  It holds the history of sections and the definitions of internal entities
+#
+class Book :
+  # Format one level of a section id as %2.2d
+  def format_id (self, id) :
+    r = repr (id)
+    if id < 10 :
+      r = '&nbsp;' + r
+    return r
+  # end def
+
+  # Format a complete section id, with all individual level ids
+  #  Currently the implementation is somewhat ugly. This is due
+  #  to the strange behaviour of the ideal form (using a for-loop
+  #  over the elements of self.level_ids). Once we can understand
+  #  the reason of this unexpected behaviour we can improve it.
+  def build_id (self) :
+    id = '<tt>'
+    n = len (self.level_ids)
+    if n >= 1 :
+      id += self.format_id (self.level_ids[0])
+    if n >= 2 :
+      id += '.' + self.format_id (self.level_ids[1])
+    if n >= 3 :
+      id += '.' + self.format_id (self.level_ids[2])
+    if n >= 4 :
+      id += '.' + self.format_id (self.level_ids[3])
+    id += '</tt>'
+    return id
+  # end def
+
+  # Create a new Section object
+  #  Register the history of sections (with level hierarchy) 
+  def open_section (self, name) :
+    self.level_ids [self.level] += 1
+    i = self.level_ids [self.level]
+    id = self.build_id ()
+    self.sections.append (Section (id, name, self.level))
+    self.level += 1
+    self.level_ids.append (0)
+    return id
+  # end def
+
+  # Pop one level in the level hierarchy
+  def close_section (self) :
+    self.level_ids.pop ()
+    self.level -= 1
+  # end def
+
+  # Register the definition of an internal entity in the entity dictionary
+  def entity_decl (self, name, is_parameter, value, base, systemId, publicId, notation) :
+    if value :
+      self.entities['&' + name + ';'] = value
+  # end def
+
+  # Generic parser
+  def generic_parse (self, p, name) :
+    p.StartElementHandler = self.start_element
+    p.EndElementHandler = self.end_element
+    p.CharacterDataHandler = self.char_data
+    p.ExternalEntityRefHandler = self.external_entity
+    p.DefaultHandler = self.dummy
+    p.EntityDeclHandler = self.entity_decl
+    #file_name = os.path.join (sys.path[0], name)
+    f = open (name)
+    p.ParseFile (f)
+    f.close ()
+  # end def
+
+  # Top level parser
+  def parse (self, name) :
+    self.p = xml.parsers.expat.ParserCreate ()
+    self.generic_parse (self.p, name)
+  # end def
+
+  # Sub-parser for external entities
+  def external_entity (self, context, base, system_id, public_id):
+    #print "external entity " + repr(context) + " " + repr(system_id) + ' ' + sys.path[0]
+    ep = self.p.ExternalEntityParserCreate (context)
+    self.generic_parse (ep, system_id)
+  # end def
+
+  # Format a tabulation according to the stored tabulation level
+  def tab (self) :
+    return (string.rjust ("", self.tabulation))
+  # end def
+
+  # Flush the internal line buffer and display it using the tabulation
+  def purge (self) :
+    if self.line != '':
+      if self.in_code == 0 :
+        print self.tab () + self.line
+        self.line = ''
+  # end def
+
+
+  #----------------------------------------------------------
+  #
+  #  All XML element handlers
+  #
+  #----------------------------------------------------------
+
+
+  # any element : simply reproduce the element with its attributes
+  #  (ie assume it is a true HTML element)
+  def default_start (self, name, attrs) :
+    self.line += '<' + name
+    if len (attrs) > 0 :
+      i = len (attrs)
+      for k, v in attrs.items() :
+        self.line += ' ' + k + '="' + v + '"'
+        i -= 1
+        if i <= 0 : break
+    self.line += '>'
+    #####  self.purge ()
+    self.tabulation += 2
+  # end def
+
+
+  def default_end (self, name) :
+    self.tabulation -= 2
+    self.line += '</' + name + '>'
+    self.purge ()
+  # end def
+
+
+  # <book>
+  def book_start (self, attrs) :
+    self.name = attrs['name']
+    self.title = attrs['title']
+    self.version = attrs['version']
+    self.author = attrs['author']
+    print '<!doctype html public "-//w3c//dtd html 4.0 transitional//en"> '
+    print '<html>'
+    print '<title>' + self.name + '</title>'
+    print '<head>'
+    print ' <style type="text/css">'
+    print '   body {font-face: Arial, Helvetica, Comic Sans MS, Times; color: #000000}'
+    ##print '   tt {color:#006600; font-weight: normal; background-color: #eeffee}'
+    print '   tt {color:#00AA00; font-weight: normal; background-color: #eeeeee}'
+    print '   pre {color:#FF0000; background-color: #eeeeee; border-style: solid; border-width: 1; border-color: black; padding: 4}'
+    print '   pre.cmt {font-family: courier; color:#00AA00; background-color: #eeeeee; border-style: solid; border-width: 1; border-color: black; padding: 4}'
+    print '   h2 {color:#0000FF}'
+    print '   h3 {color:#00AA00}'
+    print '   h4 {color:#997700}'
+    print '   a {color:#0000FF; background-color: LightGoldenRodYellow; text-decoration: none}'
+    print '   b {font-family: courier; color:#006600; font-weight: normal; %background-color: #eeffee}'
+    print '   td.rule {padding-top: 10}'
+    print ' </style>'
+    print '</head>'
+    print '<body bgcolor="#ffffff" link="#550088" alink="#007777" alink="#007777">'
+    ##print '<font face="Arial, Helvetica" color="#000000">'
+    ##print '<font face="Arial, Helvetica, Comic Sans MS, Times" color="#000000">'
+    print '<h1><center>' + self.name + '</center>'
+    print '<center>' + self.title + '</center></h1>'
+    print '<h2><center>Version ' + self.version + '</center>'
+    print '<center>' + self.author + '</center>'
+    print '<center><tt>' + attrs['email'] + '</tt></center></h2>'
+    self.line += '<center><i>Document revision date : ' + date.today().isoformat() + '</i></center>'
+    self.line += '<hr><h2>'
+    self.line += '<a href="#index">General index</a>'
+    self.line += '</h2>'
+    self.purge ()
+  # end def
+
+  def book_end (self) :
+    print '<hr><h1><A NAME="index"></A>Contents</h1>'
+    print '<blockquote>'
+    print '<table cols="2">'
+    for k in range (len (self.sections)) :
+      self.sections[k].show_index_entry ()
+    print '<tr><td colspan="2">&nbsp;</td></tr>'
+    print '<tr><td colspan="2"><h2>Images</h2></td></tr>'
+    for k in range (len (self.images)) :
+      print '<tr>'
+      print '<td width="100"><tt>' + repr(k+1) + '</tt></td>'
+      print '<td><a href="#' + self.images[k] + '">' + self.images[k] + '</a></td>'
+      print '</tr>'
+    print '</table>'
+    print '</blockquote>'
+    ##print '</font>'
+    print '<address>'
+    print '<i>' + self.author + '</i>'
+    print '</address>'
+    print '</body>'
+    print '</html>'
+  # end def
+
+
+  # <section>
+  def section_start (self, attrs) :
+    title = attrs['title']
+    title = title.replace ('>', '&gt;')
+    title = title.replace ('<', '&lt;')
+    id = self.open_section (title)
+    h_level = repr(self.level+1)
+    self.line += '<hr><h' + h_level + '>'
+    self.line += '<a name="' + title + '"></a>'
+    self.line += '<a href="#index">' + id + '</a> - ' + title
+    self.line += '</h' + h_level + '>'
+    self.purge ()
+    self.line = '<blockquote>'
+    self.purge ()
+  # end def
+
+  def section_end (self) :
+    self.purge ()
+    self.line = '</blockquote>'
+    self.purge ()
+    self.close_section ()
+  # end def
+
+
+  # <code>
+  def code_start (self, attrs) :
+    self.purge ()
+    self.in_code += 1
+    self.line = '<pre>'
+  # end def
+
+  def code_end (self) :
+    self.in_code -= 1
+    print self.line + '</pre>'
+    self.line = ''
+  # end def
+
+
+  # <cmtcode>
+  def cmtcode_start (self, attrs) :
+    self.purge ()
+    self.in_code += 1
+    self.line = '<pre class="cmt">'
+  # end def
+
+  def cmtcode_end (self) :
+    self.in_code -= 1
+    print self.line + '</pre>'
+    self.line = ''
+  # end def
+
+
+  # <syntax>
+  def syntax_start (self, attrs) :
+    print '<center>'
+    print '<table cols="3">'
+    print '<tr>'
+    if 'rule-width' in attrs :
+      print '<td width="' + attrs['rule-width'] + '"></td>'
+    else :
+      print '<td></td>'
+    if 'name' in attrs :
+      self.ruleref_prefix = 'kw' + attrs['name'] + '-'
+    else :
+      self.ruleref_prefix = 'kw-'
+    print '<td width="10"></td>'
+    print '<td></td>'
+    print '</tr>' 
+  # end def
+
+  def syntax_end (self) :
+    print '</table>'
+    print '</center>'
+  # end def
+
+
+  # <rule>
+  def rule_start (self, attrs) :
+    self.rule_name = attrs['name']
+    self.rule_started = 0
+  # end def
+
+  def rule_end (self) :
+    self.rule_name = ''
+    self.rule_started = 0
+  # end def
+
+
+  # <alt>
+  def alt_start (self, attrs) :
+    print '<tr>'
+    if self.rule_started == 0 :
+      self.rule_started = 1
+      print '<td class="rule"><font face="courier new, courier" COLOR="#770000"><i><a name="' + self.ruleref_prefix + self.rule_name + '"></a>' + self.rule_name + '</i></font></td>'
+      print '<td class="rule">:</td>'
+      print '<td class="rule">'
+    else :
+      print '<td></td>'
+      print '<td>|</td>'
+      print '<td>'
+  # end def
+      
+  def alt_end (self) :
+    print '</td>'
+    print '</tr>'
+  # end def
+
+
+  # <continuation>
+  def continuation_start (self, attrs) :
+    print '<tr>'
+    print '<td></td>'
+    print '<td></td>'
+    print '<td>&nbsp;&nbsp;&nbsp;'
+  # end def
+      
+  def continuation_end (self) :
+    print '</td>'
+    print '</tr>'
+  # end def
+
+
+  # <kwd>
+  def kwd_start (self, attrs) :
+    print '<font face="courier new, courier" COLOR="#FF0000">'
+    if 'name' in attrs :
+      name = attrs['name']
+    else :
+      name = self.rule_name
+    if 'value' in attrs :
+      name += '='
+      value = '<font face="courier new, courier" COLOR="#770000"><i>'
+      value += attrs['value']
+      value += '</i></font>'
+    else :
+      value = ''
+    print name + value
+  # end def
+
+  def kwd_end (self) :
+    print '</font>'
+  # end def
+
+
+
+  # <term>
+  def term_start (self, attrs) :
+    print '<font face="courier new, courier" COLOR="#770000"><i>'
+    print attrs['name']
+  # end def
+
+  def term_end (self) :
+    print '</i></font>'
+  # end def
+
+
+
+  # <ruleref>
+  def ruleref_start (self, attrs) :
+    print '<font face="courier new, courier" COLOR="#770000"><i>'
+    print '<a href="#' + self.ruleref_prefix + attrs['name'] + '">' + attrs['name'] + '</a>'
+  # end def
+
+  def ruleref_end (self) :
+    print '</i></font>'
+  # end def
+
+
+  # <option>
+  def option_start (self, attrs) :
+    print '[&nbsp;'
+  # end def
+
+  def option_end (self) :
+    print '&nbsp;]&nbsp;'
+  # end def
+
+
+  # <seq>
+  def seq_start (self, attrs) :
+    i=0
+  # end def
+
+  def seq_end (self) :
+    print '&nbsp;...&nbsp;'
+  # end def
+
+
+  # <optionseq>
+  def optionseq_start (self, attrs) :
+    print '[&nbsp;'
+  # end def
+
+  def optionseq_end (self) :
+    print '&nbsp;...&nbsp;'
+    print '&nbsp;]&nbsp;'
+  # end def
+
+
+
+  # <image>
+  def image_start (self, attrs) :
+    caption = attrs['caption']
+    self.images.append (caption)
+    n = len (self.images)
+    print '<center>'
+    print '<a name="' + caption + '"></a>'
+    print '<img src="' + attrs['src'] + '"/>'
+    print '</center>'
+    print '<center>'
+    print '<tt>' + repr(n) + '</tt> - <i>' + caption + '</i>'
+  # end def
+
+  def image_end (self) :
+    print '</center>'
+  # end def
+
+  def blockquote_start (self, attrs) :
+    print '<blockquote><hr>'
+  # end def
+
+  def blockquote_end (self) :
+    print '<hr></blockquote>'
+  # end def
+
+
+  # Basic element parsing handler
+  def start_element (self, name, attrs):
+    #print 'start_element: name=' + repr(name)
+    try :
+      if self.start_handlers.has_key (name) :
+        self.start_handlers [name] (attrs)
+      else :
+        self.default_start (name, attrs)
+    except TypeError:
+      print 'start_element: (error) name=' + repr(name)
+      self.default_start (name, attrs)
+  # end def
+
+  def end_element (self, name) :
+    #print 'end_element: name=' + repr(name)
+    try :
+      if self.end_handlers.has_key (name) :
+        self.end_handlers [name] ()
+      else :
+        self.default_end (name)
+    except TypeError:
+      #print 'end_element: (error) name=' + repr(name)
+      if name == u'cmt:book' :
+        self.book_end ()
+      else :
+        self.default_end (name)
+  # end def
+
+  # Unhandled elements will be trapped here
+  def dummy (self, data) :
+    if self.entities.has_key (data) :
+      self.char_data (self.entities[data])
+    #print "dummy:[" + repr (data) + "]" + repr (type(data))
+  # end def
+
+  # CDATA handling inside code sections
+  def code_char_data (self, data) :
+    if data == u'\n' :
+      self.line += data
+    else :
+      n = len (data)
+      #
+      if n > 0 :
+        if data == u'<':
+          self.line += '&lt;'
+        elif data == u'>' :
+          self.line += '&gt;'
+        else :
+          self.line += data
+  # end def
+
+  # CDATA handling outside code sections
+  def plain_char_data (self, data) :
+    if data == u'\n' :
+      self.purge ()
+    else :
+      n = len (string.strip (data))
+      #
+      if n > 0 :
+        if data == u'<':
+          self.line += '&lt;'
+        elif data == u'>' :
+          self.line += '&gt;'
+        else :
+  #        self.line += string.strip (data)
+          self.line += data
+  # end def
+
+  # CDATA handling
+  def char_data (self, data) :
+    #print '[' + repr(data) + ']' + repr (type (data)) + ' ' + repr(len (string.strip (data)))
+    if self.in_code > 0 :
+      self.code_char_data (data)
+    else :
+      self.plain_char_data (data)
+  # end def
+
+  def __init__ (self) :
+    self.line = ''
+    self.tabulation = 0
+    self.in_code = 0
+    self.sections = []
+    self.level_ids = [0]
+    self.level = 0
+    self.images = []
+    self.entities = {}
+    #
+    self.start_handlers = {}
+    self.start_handlers['cmt:code'] = self.code_start
+    self.start_handlers['cmt:cmtcode'] = self.cmtcode_start
+    self.start_handlers['cmt:section'] = self.section_start
+    self.start_handlers['cmt:book'] = self.book_start
+    self.start_handlers['cmt:syntax'] = self.syntax_start
+    self.start_handlers['cmt:rule'] = self.rule_start
+    self.start_handlers['cmt:alt'] = self.alt_start
+    self.start_handlers['cmt:continuation'] = self.continuation_start
+    self.start_handlers['cmt:kwd'] = self.kwd_start
+    self.start_handlers['cmt:term'] = self.term_start
+    self.start_handlers['cmt:ruleref'] = self.ruleref_start
+    self.start_handlers['cmt:option'] = self.option_start
+    self.start_handlers['cmt:seq'] = self.seq_start
+    self.start_handlers['cmt:optionseq'] = self.optionseq_start
+    self.start_handlers['cmt:image'] = self.image_start
+    self.start_handlers['cmt:blockquote'] = self.blockquote_start
+    #
+    self.end_handlers = {}
+    self.end_handlers['cmt:code'] = self.code_end
+    self.end_handlers['cmt:cmtcode'] = self.cmtcode_end
+    self.end_handlers['cmt:section'] = self.section_end
+    self.end_handlers['cmt:book'] = self.book_end
+    self.end_handlers['cmt:syntax'] = self.syntax_end
+    self.end_handlers['cmt:rule'] = self.rule_end
+    self.end_handlers['cmt:alt'] = self.alt_end
+    self.end_handlers['cmt:continuation'] = self.continuation_end
+    self.end_handlers['cmt:kwd'] = self.kwd_end
+    self.end_handlers['cmt:term'] = self.term_end
+    self.end_handlers['cmt:ruleref'] = self.ruleref_end
+    self.end_handlers['cmt:option'] = self.option_end
+    self.end_handlers['cmt:seq'] = self.seq_end
+    self.end_handlers['cmt:optionseq'] = self.optionseq_end
+    self.end_handlers['cmt:image'] = self.image_end
+    self.end_handlers['cmt:blockquote'] = self.blockquote_end
+  # end def
+
+
+
+#----------------------------------------------------------------------------------
+
+#----------------------------------------------------------------------------------
+#
+#  Various top level functions
+#
+#----------------------------------------------------------------------------------
+def usage() :
+  print 'Usage:'
+  print '  gendoc'
+  print 'Try "gendoc --help" for more information.'
+  sys.exit()
+# end def
+
+#----------------------------------------------------------------------------------
+def help() :
+  print "Generates the HTML documentation from Xml"
+# end def
+
+#----------------------------------------------------------------------------------
+def main() :
+  file_name = ''
+  options = []
+  for a in sys.argv[1:] :
+    if a[0] == '-' :
+      options = sys.argv[sys.argv.index(a):]
+      break
+    else :
+      file_name = a
+  try:
+    opts, args = getopt.getopt(options, 'h', ['help'])
+  except getopt.GetoptError:
+    usage()
+    sys.exit(2)
+  for o, a in opts:
+    if o in ('-h', '--help'):
+      help()
+      sys.exit()
+  book = Book ()
+  book.parse (file_name)
+# end def
+
+#---------------------------------------------------------------------
+#print '__name__ = ' + __name__
+if __name__ == "__main__":
+  checkPythonVersion (major=2, minor=3)
+  main()
+# end def
+
Index: /CMT/v1r20/doc/init.el
===================================================================
--- /CMT/v1r20/doc/init.el	(revision 368)
+++ /CMT/v1r20/doc/init.el	(revision 368)
@@ -0,0 +1,82 @@
+
+;;-----------------------------------------------------------
+;; Copyright Christian Arnault LAL-Orsay CNRS
+;; arnault@lal.in2p3.fr
+;; See the complete license in cmt_license.txt "http://www.cecill.info". 
+;;-----------------------------------------------------------
+
+;;----------------------------------
+;; Local organization
+;;
+(defvar my-xemacs-dir
+  (expand-file-name "~/.xemacs")
+"The directory where all the XEmacs configuration (and more) goes."
+  )
+
+(setq load-path
+      (append
+       (list my-xemacs-dir)
+       load-path
+       ))
+
+
+;;----------------------------------
+;; Local key binding
+;;
+;; The local prefix for globally available commands: C-b
+;; (just like C-x and C-c for xemacs' defaults)
+(global-unset-key '[(control b)])
+
+(defun my-coding-keys (map)
+  "Sets the key bindings which shall be available in all programming
+languages. Argument MAP is the local keymap (e.g. cmt-mode-map)."
+  (define-key map '[(control b) (\;)]         'my-comment-region-or-line)
+  (define-key map '[(control b) (\:)]         'my-uncomment-region-or-line)
+  )
+
+;;----------------------------------
+;; Comment in and out
+;;
+(defun my-comment-region-or-line ()
+  (interactive)
+  (let ((beg 0)
+	(end 0))
+    (if (region-exists-p)
+	(setq beg (region-beginning)
+	      end (region-end))
+      (save-excursion
+	(beginning-of-line)
+	(setq beg (point))
+	(forward-line)
+	(setq end (point))))
+    (comment-region beg end)))
+
+(defun my-uncomment-region-or-line ()
+  (interactive)
+  (let ((beg 0)
+	(end 0))
+    (if (region-exists-p)
+	(setq beg (region-beginning)
+	      end (region-end))
+      (save-excursion
+	(beginning-of-line)
+	(setq beg (point))
+	(forward-line)
+	(setq end (point))))
+    (comment-region beg end -1)))
+
+
+;;----------------------------------
+;; Load CMT mode
+;;
+(autoload 'cmt-mode "cmt-mode" "CMT requirements file editing mode." t)
+
+(setq auto-mode-alist
+      (append (list (cons "requirements$" 'cmt-mode))
+	  auto-mode-alist))
+
+(add-hook 'cmt-mode-hook
+          '(lambda ()
+	     (turn-on-font-lock)
+	     (my-coding-keys cmt-mode-map)
+	     ))
Index: /CMT/v1r20/doc/make_sequence.txt
===================================================================
--- /CMT/v1r20/doc/make_sequence.txt	(revision 368)
+++ /CMT/v1r20/doc/make_sequence.txt	(revision 368)
@@ -0,0 +1,83 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+
+------------------------------------
+1) Makefile
+
+  1.1) Makefile.header
+
+    1.1.1) Makefile.core
+           tag settings
+
+    1.1.2) cmt check configuration
+           clean $(tag).make
+           recurse on common_target with targets="first config all"
+
+     or
+
+           cmt check configuration
+           recurse on common_target with targets="config <target>"
+
+    1.1.3)
+      1.1.3.1) get cmt_lock_pid
+      1.1.3.2) cmt build constituents_makefile
+            constituents_header
+            constituent
+            constituent
+            constituent
+            constituents_trailer
+      1.1.3.3) recurse using constituents.make onto targets
+
+------------------------------------
+2) constituents.make
+
+   2.1) Makefile.core
+        tag settings
+
+   2.2) <first> (only for creating $(tag).make)
+     2.2.1) cmt build tag_makefile
+            mkdir $(bin)
+            cmt show setup
+
+   2.3) <config>
+     2.3.1) checkuses
+
+   2.4) <constituent>
+     2.4.1) build <constituent>.make
+              1) make_header
+
+              2)   |library_header
+                   |application_header
+                   |document_header
+
+              3)   |library
+                   |application
+
+              4) dependency
+
+              5) s
+                 s
+                 s...
+
+              4) cleanup_header
+
+              5)   |cleanup_library
+                   |cleanup_application
+
+
+     2.4.2) recurse with <constituent>.make on <constituent>
+
+------------------------------------
+3) <constituent>.make
+
+   3.1) Makefile.core
+        tag settings
+
+   3.2) $(build_dependencies)
+
+   3.3)...
+
Index: /CMT/v1r20/doc/todo.html
===================================================================
--- /CMT/v1r20/doc/todo.html	(revision 368)
+++ /CMT/v1r20/doc/todo.html	(revision 368)
@@ -0,0 +1,468 @@
+<!--
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+-->
+
+    <center><h1><b>ToDo list</b></h1></center>
+    
+    <blockquote>
+
+      <center><i>Users are welcome to contribute to this list, by sending
+      proposals to the <a href="discussion.html">discussion list</a>
+      </i></center>
+
+    </blockquote>
+    <br>
+    <hr>
+
+    <blockquote>
+
+      <center><table border>
+        <tr>
+          <td><center><i>Type</i></center></td>
+          <td><center><i>Feature</i></center></td>
+          <td><center><i>Status</i></center></td>
+        </tr>
+
+        <tr>
+          <td>Implemented</td>
+          <td><a href="#Support for unstructured directory organization">Support for unstructured directory organization</a></td>
+          <td>Implemented in v1r14 serie</td>
+        </tr>
+
+        <tr>
+          <td>Implemented</td>
+          <td><a href="#Management of versions of external software in Interface packages">Management of versions of external software in Interface packages</a></td>
+          <td>Implemented in v1r12p20020515</td>
+        </tr>
+
+        <tr>
+          <td>Bug</td>
+          <td><a href="#Calling source setup onto a standalone package">Calling "source setup" onto a standalone package</a></td>
+          <td>Fixed in v1r12p20020515</td>
+        </tr>
+
+        <tr>
+          <td>Implemented</td>
+          <td><a href="#Advanced tag management in the requirements file">Advanced tag management in the requirements file</a></td>
+          <td>Implemented in v1r14 serie</td>
+        </tr>
+
+        <tr>
+          <td>Implemented</td>
+          <td><a href="#Advanced tag management (2)">Advanced tag management (2)</a></td>
+          <td>Implemented in v1r14 serie</td>
+        </tr>
+
+        <tr>
+          <td>Proposed</td>
+          <td><a href="#A new concept for binary tag management">A new concept for binary tag management : the <b>project</b></a></td>
+          <td>No longer envisaged</td>
+        </tr>
+
+<!--
+        <tr>
+          <td>Foreseen|Bug|Proposed</td>
+          <td><a href="#">-</a></td>
+          <td>-</td>
+        </tr>
+-->
+
+      </table></center>
+
+    </blockquote>
+    <br>
+    <hr>
+    <h2>Foreseen</h2>
+    <blockquote>
+      <ol>
+	<li><i><a name="Support for unstructured directory organization"></a>Support for unstructured directory organization.</i>
+
+	  <p>
+	    It has been decided during the <a
+	      href="workshop/minutes.html#structure">first CMT workshop</a> to study
+	    the possibility to support, in addition to the conventional
+	    directory structure, an alternate convention (with limited
+	    control power) where the version directory would be absent.</p>
+	  
+	  <p>
+	    In this scheme, the following package organization would
+	    be permitted, in addition to the existing one:
+	    
+	  <blockquote>
+	    <pre>
+&lt;package&gt;/cmt
+         /src
+         /...
+	    </pre>
+	  </blockquote>
+	</p>
+	  
+	  <p>
+	    The version specification for this package could then be
+	    optionally located inside the file
+	    <tt>cmt/version.cmt</tt>. When found, this specification
+	    would be used for version checks.
+	  </p>
+
+	  <p>
+	    Each package would then individually select one or the
+	    other structuring style. This selection being done in the
+	    "cmt create" or the "cmt checkout" commands through either
+	    
+	  <ul>
+	    
+	    <li>one environment variable CMTSTRUCTURINGSTYLE,
+	      taking the possible values:
+	      
+	      <ul>
+		<li>with_version_directory (<i>default value</i>)</li>
+		<li>without_version_directory</li>
+	      </ul>
+	    </li>
+
+	    <li>or the new following options to the cmt command:
+	      <ul>
+		<li>-with_version_directory (<i>default value</i>)</li>
+		<li>-without_version_directory</li>
+	      </ul>
+	    </li>
+	  </ul>
+	</p>
+	  
+	  <p>The known drawbacks and limitations of this new structuring style are:
+	  <ul>
+
+	    <li>lack of systematic version checking possibilities
+	    (since the version file is optional)</li>
+
+	    <li>only one version of a given package is possible in the
+	    context of a given CMT path</li>
+
+	    <li>CVS actions may not be restricted to only one package
+	    when sub-packages exist</li>
+
+	  </ul>
+	</p>
+
+	  <p>Strict backward compatibility is expected (implying that
+	  the two structuring styles can always coexist)</p>
+
+	  <p>A temptative implementation is currently achieved and
+	  will be made visible after stabilization of the v1r12.</p>
+
+	</li>
+
+      <br>
+      <hr>
+      <li><i><a name="Management of versions of external software in Interface packages"></a>Management of versions of external software in Interface packages</i></li>
+
+      <p>As a follow up of discussions in the <a
+      href="workshop/minutes.html#last minute">CMT workshop</a>, it is
+      foreseen to support the new conventional macro
+      <i>&lt;package&gt;_native_version</i>. This macro will be
+      available to specify the exact value of the native version of
+      the associated package.</p>
+
+      <blockquote>
+	<pre>
+macro CLHEP_native_version "1.7.0.1"
+	</pre>
+      </blockquote>
+
+      <p>When specified, this native version will appear in the "cmt
+      show uses" output</p>
+
+      <blockquote>
+	<pre>
+...
+#   use CLHEP CLHEP-00-00-01 External (native_version=1.7.0.1)
+...
+	</pre>
+      </blockquote>
+
+<!-- Next item:
+
+      <br>
+      <hr>
+      <li><i><a name=""></a></i>
+
+-->
+
+    </ol>
+    </blockquote>
+    
+    <br>
+    <hr>
+    <h2>Known bugs</h2>
+    <blockquote>
+      <ol>
+	<li><i><a name="Calling source setup onto a standalone package"></a>Calling "source setup" onto a standalone package</i>
+
+	  <p>When this operation is <i>not</i> done right in the
+	  package directory this produces an error:</p>
+
+	  <blockquote>
+	    <pre>
+&gt; cd &lt;<i>somewhere</i>&gt;
+&gt; source setup.sh
+	    </pre>
+	  </blockquote>
+
+	  works well, whereas:
+
+	  <blockquote>
+	    <pre>
+&gt; source &lt;<i>somewhere</i>&gt;/setup.sh
+	    </pre>
+	  </blockquote>
+
+	  produces an error.
+
+	  <p><i>(Note that this works well for a conventional package,
+	  after a bug fix in v1r12)</i></p>
+
+	  <p><b>Solution:</b></p>
+
+	  <blockquote>
+	    <i>
+	      The setup.[c]sh and cleanup.[c]sh files are badly generated. The "cmt setup"
+	      command requires an option "-pack=cmt_standalone"
+	    </i>
+	  <blockquote>
+
+	</li>
+
+<!-- Next item:
+
+      <br>
+      <hr>
+      <li><i><a name=""></a></i>
+-->
+
+      </ol>
+    </blockquote>
+    
+    <br>
+    <hr>
+    <h2>Possible improvements (to be discussed)</h2>
+    <blockquote>
+      <ol>
+	<li><i><a name="Advanced tag management in the requirements file"></a>Advanced tag management in the requirements file.</i>
+
+	  <p>This concerns the possibility to manipulate the tag
+	  associations, to add, remove association-tags or to clear
+	  the association-tags</p>
+
+	  <p>So far tags are defined in a requirements file by declaring associations with other tags</p>
+
+	  <blockquote>
+	    <pre>
+tag A B C
+	    </pre>
+	  </blockquote>
+
+	  <p>The last revision of v1r12 (ie. v1r12p20020515)
+	  introduced the iterative accumulation of those
+	  associations. Therefore what is missing now is the
+	  possibility to manage this list of associations, such as
+	  with:</p>
+
+	  <ul>
+	    <li>tag_remove A B</li>
+	    <li>tag_clear A</li>
+	    <li>tag_apply A (<i>or apply_tag A ?</i>)</li>
+	  </ul>
+	</li>
+
+	<br>
+        <hr>
+	<li><i><a name="Advanced tag management (2)"></a>Advanced tag management (2).</i>
+
+	  <p>Another syntax evolution of the requirements file dealing
+	  with tag associations is the possibility to use <i>tag
+	  expressions</i> when specifying alternate symbol values.</p>
+
+	  <blockquote>
+	    <pre>
+macro_append cppflags "" \
+             Linux&debug " -g " \
+             WIN32&debug " /G "
+	    </pre>
+	  </blockquote>
+
+	<p>This would avoid the need to construct explicit tag mixture
+	associated with new tags.</p>
+
+	<p>Since tags are boolean values (a tag is active or inactive)
+	one considers <i>and</i> and <i>or</i> operations, with the
+	<b>&amp;</b> and <b>|</b> operators, with the obvious meaning
+	that "A&B" is true when both A and B are true.</p>
+
+      <br>
+      <hr>
+      <li><i><a name="A new concept for binary tag management"></a>A new concept for binary tag management : the <b>project</b></i></li>
+
+        <p>Binary tags can follow different conventions according to the
+        <i>sub-projects</i> where packages are defined. Currently,
+        <i>policy</i> packages are the preferred location where these
+        conventions are defined. However, policy packages are
+        submitted to the usual dependency relationship, and tag
+        associations are therefore freely transmitted across multiple
+        policy packages, leading to conflicts and ambiguities,
+        especially when packages from multiple and independent
+        sub-projects are simultaneously used.</p>
+
+        <p>
+          The concept of <b>project</b> is proposed to solve this
+          question, by making explicit the <i>context</i> for all
+          definitions that only belong to a given project, . The
+          following definitions and characteristics are proposed:
+        </p>
+
+        <ul>
+
+          <li>CMT defines one global project by default</li>
+
+          <li>
+            So far two CMT features are candidates for being scoped by the projects:
+            <ul><li>tags</li><li>patterns</li></ul>
+
+            <p>Other features (eg. macros, sets,...) will still be
+            normally transmitted in the use relationship</p>
+
+          </li>
+
+          <li>
+            A project is specified using the following new CMT statement:
+	  <blockquote>
+	    <pre>
+project &lt;project name&gt;
+	    </pre>
+	  </blockquote>
+          </li>
+
+          <li>
+            Once defined in a given package, a project becomes
+            <i>the</i> context project, and cannot be overridden by
+            used packages (which will specify their own context project).
+
+            <p>
+              The context project is persistent in the subsequent use
+              graph, unless another context project was specified
+              before
+            </p>
+
+            <p>
+              In the following example:
+            </p>
+
+            <img src="Images/Projects.jpg">
+
+            <p>
+              <ol>
+                <li>A is in the default project (ie CMT)</li>
+                <li>P1 defines the project P1</li>
+                <li>P2 defines the project P2</li>
+                <li>B and F directly and respectively connect to one project</li>
+                <li>C, D and E transitively connect to project P1</li>
+                <li>G is inside project P1 (rather than P2) since it is the <i>first</i> definition</li>
+              </ol>
+            </p>
+          </li>
+
+          <li>When one enters the requirements of a package, the
+          context project is always empty (ie. reset to the default
+          project)</li>
+
+          <li>The first "project" statement met along the use chain
+          defines the context project</li>
+
+          <li>When leaving a requirements, the context project is
+          persistent unless another one was already specified</li>
+
+          <li>Tags and patterns defined in the default project (ie. in
+          CMT) are visible in all projects</li>
+
+          <li>A package gets its tag associations and patterns from
+          its context project (and from the default project too)</li>
+
+          <li>Tag associations and patterns from other projects are
+          not visible nor active <i>by default</i></li>
+
+          <li>
+            A pattern or a tag defined in a project may be applied
+            even is the context project is different through the
+            following syntax:
+	  <blockquote>
+	    <pre>
+apply_pattern &lt;project name&gt;.&lt;pattern name&gt;
+apply_tag &lt;project name&gt;.&lt;tag name&gt;
+	    </pre>
+	  </blockquote>
+          </li>
+
+          <li>Every project is associated with a new standard tag macro
+
+	  <blockquote>
+	    <pre>
+&lt;project&gt;tag
+	    </pre>
+	  </blockquote>
+
+             And a new environment variable (with the same semantics as CMTCONFIG)
+
+	  <blockquote>
+	    <pre>
+&lt;PROJECT&gt;CONFIG
+	    </pre>
+	  </blockquote>
+
+             The project macro acts as the default value for all
+             $(&lt;package&gt;_tag) macros, and the project
+             configuration variable is the default for the project
+             macro. Ie. the following <i>defaults</i> settings are
+             considered (for any project and package) unless
+             explicitly specified through usual environment variables
+             or macro settings:
+
+	  <blockquote>
+	    <pre>
+&lt;PROJECT&gt;CONFIG=${CMTCONFIG}
+&lt;project&gt;tag=${&lt;PROJECT&gt;CONFIG}
+&lt;package&gt;_tag=$(&lt;project&gt;tag)
+	    </pre>
+	  </blockquote>
+
+          </li>
+
+          <li>
+             Primary tags are defined by CMT:
+
+             <ol>
+               <li>All values of <i>uname</i></li>
+               <li>Compilers (gcc, egcs, CC, cxx, KAI, VC, ...)</li>
+               <li>Compiler versions</li>
+               <li>Main build options (debug, optimized, profiled, ...)</li>
+             </ol>
+
+             Therefore all projects can be affected when a primary tag is activated.
+          </li>
+
+        </ul>
+
+<!-- Next item:
+
+      <br>
+      <hr>
+      <li><i><a name=""></a></i></li>
+
+-->
+
+      </ol>
+    </blockquote>
+
+    <hr>
Index: /CMT/v1r20/java/cmt_parser.make
===================================================================
--- /CMT/v1r20/java/cmt_parser.make	(revision 368)
+++ /CMT/v1r20/java/cmt_parser.make	(revision 368)
@@ -0,0 +1,88 @@
+
+include $(CMTROOT)/src/Makefile.header
+
+#====================================
+#  Application cmt_parser
+#
+#   Generated Thu Aug 17 14:27:01 2000  by carnault
+#
+#====================================
+
+help ::
+	@echo 'cmt_parser'
+
+cmt_parser :: dirs $(javabin)cmt_package.class $(javabin)cmt_parser.class $(javabin)customizer.class $(javabin)error_listener.class $(javabin)general_editor.class $(javabin)requirements_editor.class $(javabin)submit_listener.class $(javabin)use.class $(javabin)cmt_list.class $(javabin)DynamicTree.class
+	@/bin/echo "------> cmt_parser ok"
+
+
+cmt_parser_dependencies.make : ./cmt_package.java ./cmt_parser.java ./customizer.java ./error_listener.java ./general_editor.java ./requirements_editor.java ./submit_listener.java ./use.java ./cmt_list.java ./DynamicTree.java  cmt_path.make requirements $(use_requirements)
+	@echo "Rebuilding $@"; $(build_dependencies) cmt_parser $?
+
+-include cmt_parser_dependencies.make
+
+
+$(javabin)cmt_package.class : cmt_package.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(cmt_package_javaflags) cmt_package.java
+
+
+
+$(javabin)cmt_parser.class : cmt_parser.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(cmt_parser_javaflags) cmt_parser.java
+
+
+
+$(javabin)customizer.class : customizer.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(customizer_javaflags) customizer.java
+
+
+
+$(javabin)error_listener.class : error_listener.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(error_listener_javaflags) error_listener.java
+
+
+
+$(javabin)general_editor.class : general_editor.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(general_editor_javaflags) general_editor.java
+
+
+
+$(javabin)requirements_editor.class : requirements_editor.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(requirements_editor_javaflags) requirements_editor.java
+
+
+
+$(javabin)submit_listener.class : submit_listener.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(submit_listener_javaflags) submit_listener.java
+
+
+
+$(javabin)use.class : use.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(use_javaflags) use.java
+
+
+
+$(javabin)cmt_list.class : cmt_list.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(cmt_list_javaflags) cmt_list.java
+
+
+
+$(javabin)DynamicTree.class : DynamicTree.java
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin) $(use_javaflags) $(cmt_parser_javaflags) $(DynamicTree_javaflags) DynamicTree.java
+
+
+clean :: cmt_parserclean
+	@cd .
+
+cmt_parserclean ::
+	-$(cleanup_echo) $(javabin)cmt_package.class $(javabin)cmt_parser.class $(javabin)customizer.class $(javabin)error_listener.class $(javabin)general_editor.class $(javabin)requirements_editor.class $(javabin)submit_listener.class $(javabin)use.class $(javabin)cmt_list.class $(javabin)DynamicTree.class
+	-$(cleanup_silent) cd $(javabin); /bin/rm -f $(javabin)cmt_package.class $(javabin)cmt_parser.class $(javabin)customizer.class $(javabin)error_listener.class $(javabin)general_editor.class $(javabin)requirements_editor.class $(javabin)submit_listener.class $(javabin)use.class $(javabin)cmt_list.class $(javabin)DynamicTree.class
Index: /CMT/v1r20/java/constituents.make
===================================================================
--- /CMT/v1r20/java/constituents.make	(revision 368)
+++ /CMT/v1r20/java/constituents.make	(revision 368)
@@ -0,0 +1,16 @@
+all_groups :: all
+all :: $(all_constituents)
+	@/bin/echo "$(arrow) all ok."
+
+cmt_parser :: $(cmt_parser_dependencies)
+	@echo "$(arrow) starting cmt_parser"
+	@$(cmtexe) build constituent_makefile cmt_parser; $(MAKE) -f cmt_parser.make build_strategy=keep_makefiles cmt_parser
+
+clean :: cmt_parserclean
+	@echo "$(arrow) cmt_parserclean ok"
+
+cmt_parserclean ::
+	@echo "$(arrow) starting cmt_parserclean"
+	@$(cmtexe) build constituent_makefile cmt_parser; $(MAKE) -f cmt_parser.make build_strategy=keep_makefiles cmt_parserclean
+
+
Index: /CMT/v1r20/mgr/CMT.pacman
===================================================================
--- /CMT/v1r20/mgr/CMT.pacman	(revision 368)
+++ /CMT/v1r20/mgr/CMT.pacman	(revision 368)
@@ -0,0 +1,29 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+description ('CMT <version>')
+packageName ('CMT')
+version ('<version>')
+
+pacmanVersionGE('3.13')
+
+{
+    platformGE ('Linux') ; downloadUntar ('http://www.cmtsite.org/<version>/CMT<version>Linux-i686.tar.gz', 'CMTBASE')
+  OR 
+    platformGE ('Cygwin') ; downloadUntar ('http://www.cmtsite.org/<version>/CMT<version>CYGWIN_NT-5.1-i686', 'CMTBASE')
+  OR
+    downloadUntar ('http://www.cmtsite.org/<version>/CMT<version>.tar.gz', 'CMTBASE')
+}
+
+cd ('$CMTBASE/<version>/mgr')
+shellOutputContains ('./INSTALL', 'CMT installation terminated')
+{
+  shellOutputContains ('. setup.sh; cmt version', '<version>') 
+    OR shell ('. setup.sh; gmake') 
+}
+shellOutputContains ('. setup.sh; cmt version', '<version>')
+cd ()
+
Index: /CMT/v1r20/mgr/CMT.spec
===================================================================
--- /CMT/v1r20/mgr/CMT.spec	(revision 368)
+++ /CMT/v1r20/mgr/CMT.spec	(revision 368)
@@ -0,0 +1,281 @@
+Summary: Software Package CMT
+Name: CMT
+Version: %{_version}
+Release: 1
+Source: %{name}%{version}.tar.gz
+Buildroot: %{_topdir}/BUILD
+URL: http://www.cmtsite.org/
+Copyright: LAL
+Group: Applications
+Packager: CMT
+Prefix: /CMT
+
+%description
+CMT.
+
+%prep
+echo doing prep
+%setup -c -n %{name}/%{version}
+
+%build
+CMTROOT=`(cd ../; pwd)`; export CMTROOT
+cd ${RPM_BUILD_DIR}/%{name}/%{version}/mgr
+gmake CMTBIN=Linux
+
+%install
+cd ${RPM_BUILD_DIR}/%{name}/%{version}/mgr
+./INSTALL
+
+%post
+echo doing post at ${RPM_INSTALL_PREFIX}
+cd ${RPM_INSTALL_PREFIX}/%{version}/mgr
+./INSTALL
+
+
+%files
+%defattr(-,root,root)
+%{prefix}/%{version}/fragments/application
+%{prefix}/%{version}/fragments/application_header
+%{prefix}/%{version}/fragments/application_launcher
+%{prefix}/%{version}/fragments/application_launcher_header
+%{prefix}/%{version}/fragments/application_launcher_trailer
+%{prefix}/%{version}/fragments/buildproto
+%{prefix}/%{version}/fragments/c
+%{prefix}/%{version}/fragments/c_library
+%{prefix}/%{version}/fragments/check_application
+%{prefix}/%{version}/fragments/check_application_header
+%{prefix}/%{version}/fragments/check_java
+%{prefix}/%{version}/fragments/cleanup
+%{prefix}/%{version}/fragments/cleanup_application
+%{prefix}/%{version}/fragments/cleanup_header
+%{prefix}/%{version}/fragments/cleanup_java
+%{prefix}/%{version}/fragments/cleanup_library
+%{prefix}/%{version}/fragments/cleanup_objects
+%{prefix}/%{version}/fragments/cmt_action_runner
+%{prefix}/%{version}/fragments/cmt_action_runner_header
+%{prefix}/%{version}/fragments/constituent
+%{prefix}/%{version}/fragments/constituents_header
+%{prefix}/%{version}/fragments/constituents_trailer
+%{prefix}/%{version}/fragments/cpp
+%{prefix}/%{version}/fragments/cpp_library
+%{prefix}/%{version}/fragments/dependencies
+%{prefix}/%{version}/fragments/dependencies_and_triggers
+%{prefix}/%{version}/fragments/document_header
+%{prefix}/%{version}/fragments/dsp_all
+%{prefix}/%{version}/fragments/dvi
+%{prefix}/%{version}/fragments/dsp_application_header
+%{prefix}/%{version}/fragments/dsp_contents
+%{prefix}/%{version}/fragments/dsp_library_header
+%{prefix}/%{version}/fragments/dsp_shared_library_header
+%{prefix}/%{version}/fragments/dsp_trailer
+%{prefix}/%{version}/fragments/dsp_windows_header
+%{prefix}/%{version}/fragments/dsw_all_project
+%{prefix}/%{version}/fragments/dsw_all_project_dependency
+%{prefix}/%{version}/fragments/dsw_all_project_header
+%{prefix}/%{version}/fragments/dsw_all_project_trailer
+%{prefix}/%{version}/fragments/dsw_header
+%{prefix}/%{version}/fragments/dsw_project
+%{prefix}/%{version}/fragments/dsw_trailer
+%{prefix}/%{version}/fragments/fortran
+%{prefix}/%{version}/fragments/fortran_library
+%{prefix}/%{version}/fragments/generator
+%{prefix}/%{version}/fragments/generator_header
+%{prefix}/%{version}/fragments/group
+%{prefix}/%{version}/fragments/install_includes
+%{prefix}/%{version}/fragments/install_includes_header
+%{prefix}/%{version}/fragments/installer
+%{prefix}/%{version}/fragments/installer_header
+%{prefix}/%{version}/fragments/jar
+%{prefix}/%{version}/fragments/jar_header
+%{prefix}/%{version}/fragments/java
+%{prefix}/%{version}/fragments/java_copy
+%{prefix}/%{version}/fragments/java_header
+%{prefix}/%{version}/fragments/lex
+%{prefix}/%{version}/fragments/lex_library
+%{prefix}/%{version}/fragments/library
+%{prefix}/%{version}/fragments/library_header
+%{prefix}/%{version}/fragments/library_no_share
+%{prefix}/%{version}/fragments/make_header
+%{prefix}/%{version}/fragments/make_setup
+%{prefix}/%{version}/fragments/make_setup_header
+%{prefix}/%{version}/fragments/make_setup_nmake
+%{prefix}/%{version}/fragments/os9
+%{prefix}/%{version}/fragments/os9_header
+%{prefix}/%{version}/fragments/protos_header
+%{prefix}/%{version}/fragments/readme
+%{prefix}/%{version}/fragments/readme_header
+%{prefix}/%{version}/fragments/readme_trailer
+%{prefix}/%{version}/fragments/readme_use
+%{prefix}/%{version}/fragments/sln_dependency_header
+%{prefix}/%{version}/fragments/sln_dependency_project
+%{prefix}/%{version}/fragments/sln_dependency_trailer
+%{prefix}/%{version}/fragments/sln_header
+%{prefix}/%{version}/fragments/sln_project
+%{prefix}/%{version}/fragments/sln_project_config
+%{prefix}/%{version}/fragments/sln_trailer
+%{prefix}/%{version}/fragments/tex
+%{prefix}/%{version}/fragments/tex_header
+%{prefix}/%{version}/fragments/vcproj_all
+%{prefix}/%{version}/fragments/vcproj_application_header
+%{prefix}/%{version}/fragments/vcproj_contents
+%{prefix}/%{version}/fragments/vcproj_directory_header
+%{prefix}/%{version}/fragments/vcproj_directory_trailer
+%{prefix}/%{version}/fragments/vcproj_library_header
+%{prefix}/%{version}/fragments/vcproj_trailer
+%{prefix}/%{version}/fragments/yacc
+%{prefix}/%{version}/fragments/yacc_library
+%{prefix}/%{version}/fragments/nmake/application
+%{prefix}/%{version}/fragments/nmake/application_header
+%{prefix}/%{version}/fragments/nmake/c
+%{prefix}/%{version}/fragments/nmake/c_library
+%{prefix}/%{version}/fragments/nmake/check_application
+%{prefix}/%{version}/fragments/nmake/check_application_header
+%{prefix}/%{version}/fragments/nmake/check_java
+%{prefix}/%{version}/fragments/nmake/cleanup
+%{prefix}/%{version}/fragments/nmake/cleanup_application
+%{prefix}/%{version}/fragments/nmake/cleanup_header
+%{prefix}/%{version}/fragments/nmake/cleanup_java
+%{prefix}/%{version}/fragments/nmake/cleanup_library
+%{prefix}/%{version}/fragments/nmake/cleanup_objects
+%{prefix}/%{version}/fragments/nmake/cmt_action_runner_header
+%{prefix}/%{version}/fragments/nmake/constituent
+%{prefix}/%{version}/fragments/nmake/constituents_header
+%{prefix}/%{version}/fragments/nmake/constituents_trailer
+%{prefix}/%{version}/fragments/nmake/cpp
+%{prefix}/%{version}/fragments/nmake/cpp_library
+%{prefix}/%{version}/fragments/nmake/dependencies
+%{prefix}/%{version}/fragments/nmake/dependencies_and_triggers
+%{prefix}/%{version}/fragments/nmake/fortran
+%{prefix}/%{version}/fragments/nmake/fortran_library
+%{prefix}/%{version}/fragments/nmake/generator_header
+%{prefix}/%{version}/fragments/nmake/group
+%{prefix}/%{version}/fragments/nmake/install_includes_header
+%{prefix}/%{version}/fragments/nmake/installer
+%{prefix}/%{version}/fragments/nmake/installer_header
+%{prefix}/%{version}/fragments/nmake/jar
+%{prefix}/%{version}/fragments/nmake/jar_header
+%{prefix}/%{version}/fragments/nmake/java
+%{prefix}/%{version}/fragments/nmake/java_copy
+%{prefix}/%{version}/fragments/nmake/java_header
+%{prefix}/%{version}/fragments/nmake/lex
+%{prefix}/%{version}/fragments/nmake/lex_library
+%{prefix}/%{version}/fragments/nmake/library
+%{prefix}/%{version}/fragments/nmake/library_header
+%{prefix}/%{version}/fragments/nmake/library_no_share
+%{prefix}/%{version}/fragments/nmake/make_header
+%{prefix}/%{version}/fragments/nmake/protos_header
+%{prefix}/%{version}/fragments/nmake/yacc
+%{prefix}/%{version}/fragments/nmake/yacc_library
+%{prefix}/%{version}/mgr/CMT.pacman
+%{prefix}/%{version}/mgr/CMT.spec
+%{prefix}/%{version}/mgr/ChangeLog.php
+%{prefix}/%{version}/mgr/INSTALL
+%{prefix}/%{version}/mgr/INSTALL.bat
+%{prefix}/%{version}/mgr/Makefile
+%{prefix}/%{version}/mgr/NMake
+%{prefix}/%{version}/mgr/README
+%{prefix}/%{version}/mgr/README.html
+%{prefix}/%{version}/mgr/cmt.make
+%{prefix}/%{version}/mgr/afs_set_acls.sh
+%{prefix}/%{version}/mgr/build_from_rpm.sh
+%{prefix}/%{version}/mgr/cmt
+%{prefix}/%{version}/mgr/cmt.nmake
+%{prefix}/%{version}/mgr/cmt_export.sh
+%{prefix}/%{version}/mgr/cmt_CC_version.sh
+%{prefix}/%{version}/mgr/cmt_algorithms.cxx
+%{prefix}/%{version}/mgr/cmt_build_deps.sh
+%{prefix}/%{version}/mgr/cmt_build_release.sh
+%{prefix}/%{version}/mgr/cmt_buildcvsinfos.bat
+%{prefix}/%{version}/mgr/cmt_buildcvsinfos.py
+%{prefix}/%{version}/mgr/cmt_buildcvsinfos.sh
+%{prefix}/%{version}/mgr/cmt_buildcvsinfos2.sh
+%{prefix}/%{version}/mgr/cmt_cxx_version.sh
+%{prefix}/%{version}/mgr/cmt_dcc_version.sh
+%{prefix}/%{version}/mgr/cmt_dependencies.make
+%{prefix}/%{version}/mgr/cmt_dependencies.nmake
+%{prefix}/%{version}/mgr/cmt_filter_version.sh
+%{prefix}/%{version}/mgr/cmt_gcc_version.sh
+%{prefix}/%{version}/mgr/cmt_genmakeos9.sh
+%{prefix}/%{version}/mgr/cmt_install_action.bat
+%{prefix}/%{version}/mgr/cmt_install_action.sh
+%{prefix}/%{version}/mgr/cmt_installdir_action.bat
+%{prefix}/%{version}/mgr/cmt_installdir_excludes.txt
+%{prefix}/%{version}/mgr/cmt_linux_version.sh
+%{prefix}/%{version}/mgr/cmt_make_cpp_shlib.sh
+%{prefix}/%{version}/mgr/cmt_make_shlib.bat
+%{prefix}/%{version}/mgr/cmt_make_shlib.sh
+%{prefix}/%{version}/mgr/cmt_make_shlib_common.sh
+%{prefix}/%{version}/mgr/cmt_mount_filter
+%{prefix}/%{version}/mgr/cmt_os9tounix.sh
+%{prefix}/%{version}/mgr/cmt_remote
+%{prefix}/%{version}/mgr/cmt_system.sh
+%{prefix}/%{version}/mgr/cmt_tar_export.sh
+%{prefix}/%{version}/mgr/cmt_uninstall_action.bat
+%{prefix}/%{version}/mgr/cmt_uninstall_action.sh
+%{prefix}/%{version}/mgr/cmt_uninstalldir_action.bat
+%{prefix}/%{version}/mgr/cmt_unixtoos9.sh
+%{prefix}/%{version}/mgr/cmt_unixtowin.sh
+%{prefix}/%{version}/mgr/cmt_which.sh
+%{prefix}/%{version}/mgr/cmt_wintounix.sh
+%{prefix}/%{version}/mgr/cmtsh.sh
+%{prefix}/%{version}/mgr/install.mak
+%{prefix}/%{version}/mgr/install_from_rpm.sh
+%{prefix}/%{version}/mgr/package.nmake
+%{prefix}/%{version}/mgr/requirements
+%{prefix}/%{version}/mgr/srt2cmt.sh
+%{prefix}/%{version}/mgr/tag.nmake
+%{prefix}/%{version}/mgr/setup.csh
+%{prefix}/%{version}/mgr/setup.sh
+%{prefix}/%{version}/mgr/cleanup.csh
+%{prefix}/%{version}/mgr/cleanup.sh
+%{prefix}/%{version}/mgr/cmt_path.make
+%{prefix}/%{version}/mgr/VisualC_cmt.nmake
+%{prefix}/%{version}/mgr/cmt_filter3_version.sh
+%{prefix}/%{version}/src/Makefile
+%{prefix}/%{version}/src/Makefile.core
+%{prefix}/%{version}/src/Makefile.header
+%{prefix}/%{version}/src/NMake
+%{prefix}/%{version}/src/NMakefile.core
+%{prefix}/%{version}/src/NMakefile.header
+%{prefix}/%{version}/src/cleanup.csh
+%{prefix}/%{version}/src/cleanup.sh
+%{prefix}/%{version}/src/demo/demo1.cmt
+%{prefix}/%{version}/src/demo/scenario.awk
+%{prefix}/%{version}/src/demo/tprivate.cmt
+%{prefix}/%{version}/src/demo/tprivate.out
+%{prefix}/%{version}/src/demo/tproject.cmt
+%{prefix}/%{version}/src/demo/demoA/A.java
+%{prefix}/%{version}/src/demo/demoA/demoA.cxx
+%{prefix}/%{version}/src/demo/demoA/demoA.h
+%{prefix}/%{version}/src/demo/demoA/init.bat
+%{prefix}/%{version}/src/demo/demoA/init.csh
+%{prefix}/%{version}/src/demo/demoA/init.sh
+%{prefix}/%{version}/src/demo/demoA/requirements
+%{prefix}/%{version}/src/demo/demoA/fragments/rename
+%{prefix}/%{version}/src/demo/demoA/fragments/rename_header
+%{prefix}/%{version}/src/demo/demoA/fragments/nmake/rename
+%{prefix}/%{version}/src/demo/demoA/fragments/nmake/rename_header
+%{prefix}/%{version}/src/demo/demoB/B.java
+%{prefix}/%{version}/src/demo/demoB/demoB.cxx
+%{prefix}/%{version}/src/demo/demoB/init.bat
+%{prefix}/%{version}/src/demo/demoB/init.csh
+%{prefix}/%{version}/src/demo/demoB/init.sh
+%{prefix}/%{version}/src/demo/demoB/requirements
+%{prefix}/%{version}/src/demo/demoC/C1.cxx
+%{prefix}/%{version}/src/demo/demoC/C2.cxx
+%{prefix}/%{version}/src/demo/demoC/C3.cxx
+%{prefix}/%{version}/src/demo/demoC/demoC.cxx
+%{prefix}/%{version}/src/demo/demoC/requirements
+%{prefix}/%{version}/src/constituents.make
+%{prefix}/%{version}/src/constituents.nmake
+%{prefix}/%{version}/src/lex.make
+%{prefix}/%{version}/src/os9make.header
+%{prefix}/%{version}/src/setup.bat
+%{prefix}/%{version}/src/setup.csh
+%{prefix}/%{version}/src/setup.sh
+%{prefix}/%{version}/src/setup.tcsh
+%{prefix}/%{version}/src/setup.zsh
+%{prefix}/%{version}/src/yacc.make
+%{prefix}/%{version}/Linux/cmt
+%{prefix}/%{version}/Linux/cmt.exe
+
Index: /CMT/v1r20/mgr/ChangeLog.php
===================================================================
--- /CMT/v1r20/mgr/ChangeLog.php	(revision 368)
+++ /CMT/v1r20/mgr/ChangeLog.php	(revision 368)
@@ -0,0 +1,294 @@
+<?php
+
+$with_tables = TRUE;
+//$with_tables = FALSE;
+
+echo "
+<html>
+<body bgcolor='white'>";
+
+echo "
+<STYLE TYPE='text/css'>
+BODY 
+{scrollbar-face-color: #0069B3; 
+ scrollbar-shadow-color: #000000;
+ scrollbar-highlight-color: #FFFFFF;
+ scrollbar-3dlight-color: #000000; 
+ scrollbar-darkshadow-color: #000000; 
+ scrollbar-track-color: #0069B3; 
+ scrollbar-arrow-color: #FFCC00;}
+TD.a {color:blue;
+       background-color:#FFFFFF;
+       font-color:blue;
+       font-size:11px;
+       font-family:verdana;}
+A.a {color:#FFCC00;
+       background-color:#000000;
+       foreground-color:#ffcc00;
+       font-color:#FFCC00;
+       font-size:11px;
+       font-family:verdana;}
+A.b {color:#FFCC00;
+       background-color:#0069b3;
+       foreground-color:#ffcc00;
+       text-decoration:none;
+       font-color:#FFCC00;
+       font-size:11px;
+       font-family:verdana;}
+A {
+color:#FFFFFF;
+text-decoration:none;
+}
+A:hover {
+color:#FFCC00;
+text-decoration:underline;
+}
+A.menu {
+color:#000000; 
+text-decoration:underline;
+}
+A:hover.menu {
+color:#FFFF00;
+text-decoration:underline;
+}
+A.esp {
+color:#FF3333; 
+text-decoration:underline;
+}
+A:hover.esp {
+color:#33FFFF;
+text-decoration:none;
+}
+
+A.div {
+color:#FFCC00; 
+text-decoration:none;
+}
+A:hover.div {
+color:#FF3333;
+text-decoration:none;
+}
+TD.b {color:black;
+       background-color:white;
+       font-size:11px;
+       font-family:verdana;}
+TD.c {color:red;
+       background-color:white;
+       font-size:11px;
+       font-family:verdana;}
+P.a {
+       background-color:$res_couleur_fond_entête;
+       color:$res_couleur_texte_entête;}
+P.c {color:#FFCC00;
+       background-color:#000000;
+       font-size:11px;
+       font-family:verdana;
+}
+INPUT {color:#FFCC00;
+       background-color:#0069B3;
+       font-size:11px;
+       font-family:verdana;}
+SELECT {color:#FFCC00;background-color:#0069D2;font-size:12px;font-family:verdana;}
+TEXTAREA {color:#FFCC00;background-color:#0069B3;font-size:11px;font-family:verdana;}
+</STYLE>";
+
+if (with_tables)
+{
+  echo "
+<table border width=100%>
+  <tr>
+    <td width=70 nowrap class='a'><i><center>date</center></i></td>
+    <td width=50% class='b'><i><center>file</center></i></td>
+    <td class='c'><i><center>comment</center></i></td>
+  </tr>";
+}
+
+$started = FALSE;
+
+$fcontents = file ('ChangeLog');
+
+$date = "";
+
+while (list ($n, $line) = each ($fcontents))
+{
+  $line = str_replace ("\t", " ", $line);
+  $c = substr ($line, 0, 1);
+
+  $line = trim ($line);
+  if ($line == "") continue;
+  
+  $words = explode (" ", $line);
+  $NF = count ($words) - 1;
+
+  //echo "|<font color=red>$line</font>|". $words[0] . "|". $words[1] . "|". $words[2] . "|<br>";
+
+  $marker = strpos ("." . $line, "):");
+  if ($marker >= 1)
+    {
+    }
+  else
+    {
+      $marker = 0;
+    }
+
+  //echo "<br>date: $date<br> ladate: $ladate<br>";
+
+  if ($c != " ")
+    {
+      // <date> <who> <number>
+
+      $has_number = (strcspn ($words[$NF], "0123456789") == 0);
+
+      if ($has_number)
+        {
+          $last = $NF - 1;
+          $number = $words[$NF];
+        }
+      else
+        {
+          $last = $NF;
+          $number = "";
+        }
+
+      $who = "";
+
+      for ($i = 1; $i <= $last; $i++)
+        {
+          $who .= " ";
+          $who .= $words[$i];
+        }
+
+
+      $date = $words[0];
+      if ($date != $ladate)
+        {
+          $ladate = $date;
+        }
+      else
+        {
+          $date = "&nbsp;";
+        }
+
+      //echo "date:[" . $date . "] ladate:[" . $ladate . "] who:" . $who . " #:" . $number . " [$line]<br>" ;
+
+    }
+  else if (($words[0] == "*") || ($marker >= 1))
+    {
+      if ($started)
+        {
+          if ($with_tables) echo "</td></tr>";
+
+          $started = FALSE;
+        }
+
+      if ($marker == 0)
+        {
+          $marker = strpos ("." . $line, ":");
+        }
+      else
+        {
+          $marker++;
+        }
+
+      //echo "  ...Starting an entry... marker=$marker date=$date<br>";
+
+      if ($marker > 0)
+        {
+          $head = substr ($line, 0, $marker);
+          $line = substr ($line, $marker);
+        }
+      else
+        {
+          $head = $line;
+          $line = "";
+        }
+
+      $head = trim ($head);
+      $line = trim ($line);
+
+      //echo "[$head] [$line]<br>";
+
+      $par = strpos ("." . $head, "(");
+      if ($par > 0)
+        {
+          if ($par > 1) $file = substr ($head, 0, $par-1);
+          $info = substr ($head, $par);
+          $info = str_replace ("(", "", $info);
+          $info = str_replace (")", "", $info);
+          $info = str_replace (":", "", $info);
+        }
+      else
+        {
+          $file = $head;
+          $info = "";
+        }
+
+      $file = str_replace ("*", "", $file);
+      $file = str_replace ("(", "", $file);
+      $file = str_replace (")", "", $file);
+      $file = str_replace (":", "", $file);
+      $file = str_replace ("\\", "/", $file);
+
+      if ($with_tables) echo "<tr><td class='a' valign='top'> ";
+
+      echo "$date";
+
+      if ($with_tables) echo "</td><td class='b' valign='top'>";
+
+      echo "$file";
+
+      if (!empty ($info)) echo " (<font color='green'>$info</font>)";
+
+      //echo "</tt>";
+
+      if ($with_tables) echo "</td><td class='c' valign='top'>";
+
+      $date = "&nbsp;";
+
+      $line = trim ($line);
+
+      if (empty ($line)) $line="&nbsp;";
+
+      echo "$line";
+      if (!$with_tables) echo "<br>";
+
+      $started = TRUE;
+      $was_empty = FALSE;
+      $was_not_empty = FALSE;
+
+    }
+  else if ($started)
+    {
+      $line = trim ($line);
+      if (empty ($line))
+        {
+          if ($was_not_empty) 
+            {
+              $was_not_empty = FALSE;
+              $was_empty = TRUE;
+            }
+          $line = "&nbsp;";
+        }
+      else
+        {
+          if ($was_empty)
+            {
+              $was_empty = TRUE;
+              echo "<br>";
+            }
+          $was_not_empty = TRUE;
+        }
+      echo "$line";
+      if (!$with_tables) echo "<br>";
+    }
+}
+
+if ($with_tables) echo "</table>";
+
+echo "
+</body>
+</html>";
+
+
+?>
+
Index: /CMT/v1r20/mgr/INSTALL
===================================================================
--- /CMT/v1r20/mgr/INSTALL	(revision 368)
+++ /CMT/v1r20/mgr/INSTALL	(revision 368)
@@ -0,0 +1,132 @@
+#!/bin/sh
+
+#--------------------------------------------------
+# main ()
+#--------------------------------------------------
+
+#--------------------------------------------------
+#
+#  First try to figure out where we are now.
+#
+#--------------------------------------------------
+
+##set -v
+
+here=`pwd`                #should be .../CMT/vxxx/mgr
+here=`dirname ${here}`    #should be .../CMT/vxxx
+here=`dirname ${here}`    #should be .../CMT
+here=`basename ${here}`   #should be CMT
+
+if test ! "${here}" = "CMT" ; then  # Are we outside of CMT ?
+  echo " INSTALL should be run from within the mgr branch of the CMT package"
+  echo " Please go there first and restart this script"
+  echo "  > cd <...>/CMT/v.../mgr"
+  echo "  > ./INSTALL"
+  exit 1
+fi
+
+p=`pwd`
+CMTROOT=`dirname $p`
+
+version=`basename ${CMTROOT}`
+p=`dirname ${CMTROOT}`
+ppath=`dirname ${p}`
+
+#--------------------------------------------------
+#
+#   On some sites, it is convenient to reformat the
+# dir. name obtained by pwd (eg. for removing the /tmp_mnt prefixes)
+#   Some of these replacements are available in 
+# the ${CMTROOT}/mgr/cmt_mount_filter file.
+#
+#   You may add new substitutions in this file, according to your
+# specific file system configuration.
+#
+#   Each entry takes the form :
+#
+#dir-name      replacement-name
+#
+#   (with space[s] as separator)
+#
+#--------------------------------------------------
+
+if test -r cmt_mount_filter ; then
+  e=`sed -e 's/[ ][ ]*/#/' -e 's/^[ ]*/s#/' -e 's/[ ]*$/#/' -e 's/^s##$//' cmt_mount_filter`
+  ppath=`echo ${ppath} | sed -e "$e"`
+fi
+
+#--------------------------------------------------
+#
+#   Building the setup.csh script
+#
+#--------------------------------------------------
+
+cat <<END >setup.csh
+# echo "Setting CMT ${version} in ${ppath}"
+    
+setenv CMTROOT ${ppath}/CMT/${version}
+
+END
+
+cat ../src/setup.csh >>setup.csh
+
+#--------------------------------------------------
+#
+#   Building the setup.sh script
+#
+#--------------------------------------------------
+
+cat <<END >setup.sh
+# echo "Setting CMT ${version} in ${ppath}"
+    
+CMTROOT=${ppath}/CMT/${version}; export CMTROOT
+
+END
+
+cat ../src/setup.sh >>setup.sh
+
+#--------------------------------------------------
+#
+#   Building the cleanup.csh script
+#
+#--------------------------------------------------
+
+cp ../src/cleanup.csh ./cleanup.csh
+
+#--------------------------------------------------
+#
+#   Building the cleanup.sh script
+#
+#--------------------------------------------------
+
+cp ../src/cleanup.sh ./cleanup.sh
+
+#--------------------------------------------------
+#
+#  In case one needs to re-build cmt from the sources
+#  it's likely that cmt.exe does not exist yet thus
+#  we cannot expect that dependencies are re-built.
+#
+#  rather, we expect they have been downloaded from 
+#  the distribution kit and thus we just have to 
+#  touch them.
+#
+#--------------------------------------------------
+
+touch ../src/*.make ../mgr/*.make ../mgr/cmt_path.make
+
+exes=`ls ../*/cmt.exe | sed -e 's#\.\./#    #g' -e 's#/cmt.exe##g'`
+
+echo "============================================"
+echo "       CMT installation terminated.         "
+echo "           --------------------             "
+if test "${exes}" = "" ; then
+  echo " cmt.exe is not built on this site"
+  echo " you might need to build it as follows:"
+  echo " > source setup.csh"
+  echo " > [g]make"
+else
+  echo " cmt.exe is available on this site for:"
+    echo "${exes}"
+fi
+echo "============================================"
Index: /CMT/v1r20/mgr/INSTALL.bat
===================================================================
--- /CMT/v1r20/mgr/INSTALL.bat	(revision 368)
+++ /CMT/v1r20/mgr/INSTALL.bat	(revision 368)
@@ -0,0 +1,13 @@
+
+@echo off
+
+copy ..\src\setup.bat ..\mgr\setup.bat
+
+echo ============================================
+echo        CMT installation terminated.         
+echo            --------------------             
+
+echo  you might need to build it as follows:
+echo " > setup.bat"
+echo " > nmake /f nmake"
+echo ============================================
Index: /CMT/v1r20/mgr/Makefile
===================================================================
--- /CMT/v1r20/mgr/Makefile	(revision 368)
+++ /CMT/v1r20/mgr/Makefile	(revision 368)
@@ -0,0 +1,383 @@
+
+cppflags  = $(CFLAGS)
+
+
+cpp = g++ -O2
+
+ifeq ($(CMTBIN),LinuxDebug)
+cpp = g++ -g
+endif
+
+ifeq ($(CMTBIN),Linux-i686Debug)
+cpp = g++ -g
+endif
+
+ifeq ($(CMTBIN),LinuxProf)
+cpp = g++ -g -pg
+endif
+
+ifeq ($(CMTBIN),Linux-i686Prof)
+cpp = g++ -g -pg
+endif
+
+
+ifeq ($(CMTBIN),LinuxInsure)
+cpp = insure -g
+endif
+
+ifeq ($(CMTBIN),OSF1DEB)
+cpp           = cxx -g3 -pg
+endif
+
+ifeq ($(CMTBIN),OSF1-alpha)
+cpp           = cxx
+endif
+
+ifeq ($(CMTBIN),SunOS-sun4u)
+cpp       = CC
+endif
+
+ifeq ($(CMTBIN),HP-UX)
+cpp       = aCC
+endif
+
+ifeq ($(CMTBIN),Darwin)
+cpp       = c++ -O2
+endif
+
+#ifeq ($(CMTBIN),OSF1)
+#remote_launch = rsh
+#else
+remote_launch = ssh
+#endif
+
+ifeq ($(CMTBIN),CYGWIN_NT-5.1-i686)
+cpp = g++ -O2 -Wno-deprecated
+cpp = g++ -g -Wno-deprecated
+endif
+
+ifeq ($(CMTBIN),LynxOS-PowerPC)
+cpp = g++
+endif
+
+ifeq ($(CMTBIN),AIX-002065204C00)
+cpp = g++ -O2 -Wno-deprecated
+endif
+
+cppcomp   = $(cpp) -c -I${inc} $(cppflags)
+
+ifeq ($(STATIC),1)
+    cpplink   = $(cpp) -static
+else
+    cpplink   = $(cpp)
+endif
+
+src       = ../src/
+inc       = ../src/
+mgr       = ../mgr/
+bin       = ../${CMTBIN}/
+binshort  = ../${CMTBIN}
+
+cpp_silent =
+cpp_echo = @--->
+link_silent =
+link_echo = @--->
+
+SHELL     = /bin/sh
+
+tag       = 
+
+application_suffix = .exe
+cmtexe    = $(CMTROOT)/$(CMTBIN)/cmt.exe
+
+build_dependencies = test -d $(bin) || mkdir -p $(binshort); test -f $(cmtexe) || cp ../mgr/cmt_dependencies.make $(bin); test -f $(bin)CMT_setup.make || touch $(bin)CMT_setup.make ; echo 
+
+PACKAGE_ROOT = ${CMTROOT}
+
+all :: dirs
+	-@cd $(bin); /bin/rm -f last-rebuild; date >last-rebuild
+
+dirs ::
+	@if test ! -d $(bin) ; then mkdir -p $(binshort) ; fi
+
+#---------------------------------------------------------
+#
+# Re-building CMT
+#
+#---------------------------------------------------------
+
+done : cmt post_build 
+	@echo "CMT has been succesfully rebuilt."
+
+CFLAGS = 
+clinkflags = 
+
+#---------------------------------------------------------
+all :: cmt post_build done
+	@cd $(bin); /bin/rm -f cmt; cp cmt.exe cmt
+	@echo all ok
+
+cmt_install_action = echo
+cmt_uninstall_action = echo
+CMTINSTALLAREA = 
+
+
+include cmt.make
+
+post_build :: cmt cmt_dependencies.make $(bin)/cmt_dependencies.make 
+	echo post_build done
+
+cmt_dependencies.make $(bin)/cmt_dependencies.make : $(cmtexe)
+	$(cmtexe) -quiet build dependencies cmt -all_sources -no_stamps
+	cp $(bin)/cmt_dependencies.make ../mgr
+	$(cmtexe) -quiet build dependencies cmt -all_sources
+
+#---------------------------------------------------------
+
+#---------------------------------------------------------
+# This procedure installs a hook into the commitinfo management file.
+# then the 
+#---------------------------------------------------------
+installcvs :
+	cd `echo ${CVSROOT} | cut -f4 -d':'`/CVSROOT;\
+	if [ "`grep cmt_buildcvsinfos loginfo`" = "" ] ; then \
+	  echo "======== Configuring loginfo in `pwd`>>>>>> "; \
+	  chmod u+w loginfo; \
+	  echo '.cmtcvsinfos $${CVSROOT}/CVSROOT/cmt_buildcvsinfos2.sh' >> loginfo; \
+	  chmod u-w loginfo; \
+	else \
+	  echo "======== loginfo already configured in `pwd` >>>>>> "; \
+	fi; \
+	cp ${CMTROOT}/mgr/cmt_buildcvsinfos2.sh .; \
+	/bin/rm -rf ../.cmtcvsinfos/*
+
+#---------------------------------------------------------
+
+#---------------------------------------------------------
+###binaries = Linux OSF1 HP-UX VisualC
+##binaries = $(shell '/usr/bin/find ../ -name cmt.exe')
+
+
+#---------------------------------------------------------
+# Regenerates the Doxygen documentation of CMT
+# A priori as it is written it works at LAL only
+# The result is also transported to the Web site
+#---------------------------------------------------------
+doxygen ::
+	. /lal/Doxygen/Linux/setup.sh; cd ../doc; /bin/rm -Rf Doxygen; doxygen
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/Doxygen
+
+#---------------------------------------------------------
+# Converts CMTDoc.html CMTFAQ.html into pdf and ps
+#---------------------------------------------------------
+pdf ::
+	html2ps -nu -o ../doc/CMTDoc.ps ../doc/CMTDoc.html
+	ps2pdf ../doc/CMTDoc.ps ../doc/CMTDoc.pdf
+	html2ps -nu -o ../doc/CMTFAQ.ps ../doc/CMTFAQ.html
+	ps2pdf ../doc/CMTFAQ.ps ../doc/CMTFAQ.pdf
+
+#python = python
+python = /afs/cern.ch/sw/lcg/external/Python/2.3.4/rh73_gcc323/bin/python
+#python = /cygdrive/c/Arnault/Python23/python.exe
+
+#---------------------------------------------------------
+# Generates the html form of the doc from the XML form
+#---------------------------------------------------------
+gendoc ::
+	@cd ../doc; python gendoc.py CMTDoc.xml > CMTDoc.html
+	@echo "CMTDoc.html generated from CMTDoc.xml"
+
+
+#---------------------------------------------------------
+# Transfer the docs into the Web site.
+#---------------------------------------------------------
+docs ::
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/CMTDoc.html
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/CMTDoc.ps
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/CMTDoc.pdf
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/CMTFAQ.html
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/ReleaseNotes.html
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/ChangeLog
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/mgr/ChangeLog.php
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/CMTFAQ.ps
+	${CMTROOT}/mgr/cmt_export.sh CMT/ ${CMTROOT}/doc/CMTFAQ.pdf
+
+#        echo '  <tr><td><a href="CMT-'$${version}'-1.i386.rpm">RPM for redhat 7.2</a></td></tr>' >>doc/CMTDownload.html;
+
+#---------------------------------------------------------
+# Construct the pacman file from the generic form
+#---------------------------------------------------------
+pacman ::
+	version=`cmt version`; \
+	sed -e 's#<version>#'"$${version}"'#g' CMT.pacman >CMT-$${version}.pacman
+
+#---------------------------------------------------------
+# Construct the tar balls for the binary kits for all
+# existing binaries available in ../*.cmt.exe
+# Binary kits are now autonomous (ie they don't require
+# the source kit)
+#---------------------------------------------------------
+bintar ::
+	cd ..; root=`pwd`; \
+	tag=`cmt version`; \
+	version=`basename $${root}`; \
+	tag=$${version} ; \
+	cat doc/CMTDownload1.html >| doc/CMTDownload.html; \
+        echo '  <tr><td><a href="CMT'$${version}'.tar.gz">Source kit</a> </td></tr>' >> doc/CMTDownload.html; \
+	binaries=`/usr/bin/find ./ -name cmt.exe | sed -e 's#[.]/##' -e 's#/.*##'`; \
+        for f in `echo $${binaries}`; do \
+          echo '  <tr><td><a href="CMT'$${version}$${f}'.tar.gz">'$${f}'</a> </td></tr>' >> doc/CMTDownload.html; \
+        done; \
+	cat doc/CMTDownload2.html >> doc/CMTDownload.html; \
+	${CMTROOT}/mgr/cmt_export.sh CMT/ $${root}/doc/CMTDownload.html $${tag}; \
+	if test -d rpm; then \
+	  ${CMTROOT}/mgr/cmt_export.sh CMT/ $${root}/rpm/CMT-$${version}-1.i386.rpm $${tag}; \
+	fi; \
+	cd ../../; \
+	for branch in `echo $${binaries}` ; \
+	do \
+	  if test $${branch} = VisualC; then \
+	    /bin/rm -rf CMT/$${version}/$${branch}/cmt ; \
+	  else \
+	    /bin/rm -rf CMT/$${version}/$${branch}/*.o ; \
+	    ln -s cmt.exe CMT/$${version}/$${branch}/cmt ; \
+	  fi ; \
+	  echo $${branch} ; \
+	  tarfile=CMT/CMT$${version}$${branch}.tar; \
+	  tar cf $${tarfile} CMT/$${version}/mgr CMT/$${version}/src CMT/$${version}/$${branch} ; \
+	  gzip $${tarfile}; \
+	  ${CMTROOT}/mgr/cmt_export.sh CMT/ $${tarfile}.gz $${tag} ; \
+	done
+
+
+#----------------------------------------------------------
+#
+#  Building an RPM for CMT.
+#
+#   reinstallation is done by:
+#
+#  rpm -Uvh --relocate /CMT=/newdir/CMT CMT-${version}-1.i386.rpm
+#
+#----------------------------------------------------------
+rpm ::
+	version=`$(cmtexe) -quiet version`; \
+	tempdir=/tmp/CMT; \
+	rm -rf $${tempdir}; \
+	for f in BUILD RPMS SOURCES SPECS SRPMS ; do \
+	  mkdir -p $${tempdir}/$${f}; \
+	done; \
+	(cd ../; tar cf $${tempdir}/SOURCES/CMT$${version}.tar --exclude mgr src source); \
+	gzip $${tempdir}/SOURCES/CMT$${version}.tar; \
+	if test ! -d ../rpm; then mkdir -p ../rpm; fi; \
+	rpmbuild -ba --define "_topdir $${tempdir}" --define "_version $${version}" CMT.spec; \
+	cp $${tempdir}/RPMS/i386/CMT-$${version}-1.i386.rpm ../rpm ; \
+	cp $${tempdir}/SRPMS/CMT-$${version}-1.src.rpm ../rpm ; \
+	rm -r $${tempdir}
+
+#
+#        cp CMT.spec $${tempdir}; \
+#        find ../fragments ../mgr ../src ! -path '*/CVS*' ! -name '*~' ! -type d | \
+#          sed -e 's#[.][.]#%{prefix}/%{version}#' >>$${tempdir}/CMT.spec ; \
+#
+
+
+#----------------------------------------------------------
+# Construct a source kit
+#----------------------------------------------------------
+srctar ::
+	${CMTROOT}/mgr/cmt_tar_export.sh source mgr src Visual java doc
+
+
+#----------------------------------------------------------
+# Construct the kits
+#----------------------------------------------------------
+Export :: docs srctar bintar
+	@echo Export done
+
+democlean ::
+	/bin/rm -rf ../demo/*
+
+demo_location = ../demo
+demo_sequence = demo1
+
+#----------------------------------------------------------
+# Run the autotest sequence
+#----------------------------------------------------------
+demo :: democlean
+	@echo "------------------------------------------"
+	@echo "Starting general auto test sequence"
+	@echo "  Creating $(demo_location) work area..."
+	@mkdir -p $(demo_location)
+	@echo "  Creating all $(demo_sequence) packages..."
+	cd $(demo_location); \
+	version=`$(cmtexe) -quiet version`; \
+	($(cmtexe) -quiet run_sequence ${CMTROOT}/src/demo/$(demo_sequence).cmt | \
+	  sed -e "s#$${CMTROOT}#"'$${CMTROOT}'"#" \
+	      -e "s#$${version}#"'$${version}'"#" \
+	      -e "s#$${CMTCONFIG}#"'$${CMTCONFIG}'"#"; \
+	  ) >$(demo_sequence).txt
+	@echo "  Comparing results with reference output (${CMTROOT}/src/demo/$(demo_sequence).out) ..."
+	@cd $(demo_location); \
+	diff $(demo_sequence).txt ${CMTROOT}/src/demo/$(demo_sequence).out; s=$$?; \
+	if test $${s} = 0; then \
+	  echo "    => no differences"; \
+	else \
+	  echo "    => errors?"; \
+	  cp $(demo_sequence).txt ${CMTROOT}/src/demo/$(demo_sequence).out; \
+	fi
+
+#---------------------------------------------------------
+
+
+tprivate :: democlean
+	@echo "------------------------------------------"; \
+	sequence=tprivate; \
+	location=../demo; \
+	echo "Starting auto test sequence on private uses"; \
+	echo "  Creating $${location} work area..."; \
+	mkdir -p $${location}; \
+	cd $${location}; \
+	version=`$(cmtexe) -quiet version`; \
+	echo "  Creating all $${sequence} packages..."; \
+	($(cmtexe) -quiet run_sequence ${CMTROOT}/src/demo/$${sequence}.cmt | \
+	  sed -e "s#$${CMTROOT}#"'$${CMTROOT}'"#" \
+	      -e "s#$${version}#"'$${version}'"#" \
+	      -e "s#$${CMTCONFIG}#"'$${CMTCONFIG}'"#"; \
+	  ) >$${sequence}.txt; \
+	echo "  Comparing results with reference output (${CMTROOT}/src/demo/$${sequence}.out) ..."; \
+	diff $${sequence}.txt ${CMTROOT}/src/demo/$${sequence}.out; s=$$?; \
+	if test $${s} = 0; then \
+	  echo "    => no differences"; \
+	else \
+	  echo "    => errors?"; \
+	  cp $${sequence}.txt ${CMTROOT}/src/demo/$${sequence}.out; \
+	fi
+
+
+
+#---------------------------------------------------------
+
+help ::
+	@echo "------------------------------------------------------------"
+	@echo "  [all]      : Default target"
+	@echo "  "
+	@echo "  installcvs : "
+	@echo "  doxygen    : Documentation generation"
+	@echo "  docs       : Documentation production and installation"
+	@echo "  pdf        : Convert html docs into pdf and ps"
+	@echo "  gendoc     : Convert xml doc into html"
+	@echo "  srctar     : Production and installation of source tar-ball"
+	@echo "                (include Linux binary directory)"
+	@echo "  bintar     : Production and installation of binary tar-balls"
+	@echo "  rpm        : Production of the RPM"
+	@echo "  Export     : Installation in the web site"
+	@echo "  democlean  : Cleaning the demo area"
+	@echo "  demo       : Run the demo sequence on private uses"
+	@echo "      (Site-specific targets for building CMT)"
+	@echo "  LAL        : asc lx1 papou1-fe hp2 #virgo-control1"
+	@echo "  LHCB       : lxtest hpplus dxplus rsplus"
+	@echo "  Atlas      : atlinux atlas50"
+	@echo "  Virgo      : ax7 vmpc13a rio0a"
+	@echo "  CCIN2P3    : ccars ccahp ccali ccasn"
+	@echo "------------------------------------------------------------"
+
Index: /CMT/v1r20/mgr/NMake
===================================================================
--- /CMT/v1r20/mgr/NMake	(revision 368)
+++ /CMT/v1r20/mgr/NMake	(revision 368)
@@ -0,0 +1,89 @@
+
+cmtexe = ..\$(CMTBIN)\cmt.exe
+bin = ..\VisualC
+
+!if exist ("$(bin)") == 0
+!if [mkdir $(bin)] == 0
+!endif
+!endif
+
+!if [copy cmt_dependencies.nmake $(bin)] == 0
+!endif
+
+!if exist ("$(cmtexe)")
+!if [$(cmtexe) -quiet build constituent_makefile cmt] == 0
+!endif
+!else
+!if [echo no cmt] == 0
+!endif
+!endif
+
+cmt_install_action = echo
+cmt_uninstall_action = echo
+CMTINSTALLAREA = 
+
+#all ::
+#	set include=$(include)
+#	set lib=$(lib)
+
+all :: cmt post_build cmttag
+	@echo all ok
+
+post_build :: cmt_dependencies.nmake
+
+cmt_dependencies.nmake :: $(cmtexe)
+	@echo Rebuilding dependencies.nmake without stamps
+	@$(cmtexe) build dependencies cmt -all_sources -no_stamps
+	@copy $(bin)\cmt_dependencies.nmake ..\mgr
+	@$(cmtexe) build dependencies cmt -all_sources
+
+!include cmt.nmake
+
+
+cmttag ::
+	@echo Rebuilding VisualC.nmake
+	@$(cmtexe) build tag_makefile | find /I /V "Arnault" | find /I /V "include=" | find /I /V "lib=" | find /I /V "PATH=" | find /I /V "CMTROOT=" >VisualC.nmake
+
+democlean ::
+	-rmdir /Q /S ..\demo
+
+demo :: democlean
+	cd ..
+	$(cmtexe) create_project demo
+	cd demo
+	$(cmtexe) create demoA v1
+	$(cmtexe) create demoB v1
+	$(cmtexe) create demoC v1
+	mkdir demoA\v1\demoA
+	mkdir demoA\v1\cmt\fragments
+	mkdir demoA\v1\cmt\fragments\nmake
+	copy ..\src\demo\demoA\requirements demoA\v1\cmt
+	copy ..\src\demo\demoA\init.bat demoA\v1\cmt
+	copy ..\src\demo\demoA\*.cxx demoA\v1\src
+	copy ..\src\demo\demoA\demoA.h demoA\v1\demoA
+	copy ..\src\demo\demoA\*.java demoA\v1\src
+	copy ..\src\demo\demoA\fragments\rename* demoA\v1\cmt\fragments
+	copy ..\src\demo\demoA\fragments\nmake\rename* demoA\v1\cmt\fragments\nmake
+	copy ..\src\demo\demoB\requirements demoB\v1\cmt
+	copy ..\src\demo\demoB\init.bat demoB\v1\cmt
+	copy ..\src\demo\demoB\*.cxx demoB\v1\src
+	copy ..\src\demo\demoB\*.java demoB\v1\src
+	copy ..\src\demo\demoC\requirements demoC\v1\cmt
+	copy ..\src\demo\demoC\*.cxx demoC\v1\src
+	set CMTPATH=$(CMTROOT)\demo
+	cd demoA\v1\cmt
+        call setup.bat
+	nmake /f nmake all_groups check
+	cd ..\..\..\demoB\v1\cmt
+        call setup.bat
+	nmake /f nmake all check
+	cd ..\..\..\demoC\v1\cmt
+        call setup.bat
+	$(cmtexe) config
+	nmake /f nmake all check
+
+
+gendoc :
+	@cd ../doc
+	@\Arnault\Python23\python.exe gendoc.py CMTDoc.xml >CMTDoc.html
+
Index: /CMT/v1r20/mgr/README
===================================================================
--- /CMT/v1r20/mgr/README	(revision 368)
+++ /CMT/v1r20/mgr/README	(revision 368)
@@ -0,0 +1,34 @@
+
+
+How to rebuild a complete exportable CMT release.
+
+1) run gmake on the following machines for creating binaries:
+
+asc.lal.in2p3.fr                   -> OSF1
+atlas.in2p3.fr                     -> Linux
+ccasn.in2p3.fr                     -> SunOS
+ccars.in2p3.fr                     -> AIX
+PC                                 -> VisualC
+Cygwin                             -> CYGWIN_NT-5.1
+macls3                             -> Darwin
+ax12.virgo.infn.it then rsh rio36a -> LynxOS
+
+then transfer binaries to /lal/CMT/v1rXXX/...
+
+2) To generate the doc run :
+
+gmake gendoc
+gmake pdf
+
+on lxplus.cern.ch
+
+Then when it's done, do cvs ci to check in the upgraded docs
+
+3) On atlas.lal.in2p3.fr
+
+> cvs update (to get docs)
+> gmake doxygen
+> gmake rpm
+> gmake Export
+
+
Index: /CMT/v1r20/mgr/README.html
===================================================================
--- /CMT/v1r20/mgr/README.html	(revision 368)
+++ /CMT/v1r20/mgr/README.html	(revision 368)
@@ -0,0 +1,19 @@
+<html>
+  <head>
+    <title>CMT v1r4</title>
+  </head>
+  <body>
+
+      <h1>CMT v1r4</h1>
+
+      <p>
+
+
+      <p>
+
+      <center>
+      <table BORDER COLS=4 WIDTH="400" NOSAVE >
+      </table>
+    </center>
+</body>
+</html>
Index: /CMT/v1r20/mgr/VisualC.nmake
===================================================================
--- /CMT/v1r20/mgr/VisualC.nmake	(revision 368)
+++ /CMT/v1r20/mgr/VisualC.nmake	(revision 368)
@@ -0,0 +1,87 @@
+CMT_tag=$(tag) 
+CMTVERSION=HEAD 
+cmt_hardware_query_command=uname -m 
+cmt_hardware=WIN32 
+cmt_system_version_query_command=uname -r  
+cmt_system_version=XP 
+cmt_compiler_version_query_command=$(CMTROOT)/mgr/cmt_gcc_version.sh | grep '^gcc' 
+cmt_compiler_version=cl 
+debug_option=/G 
+cc=cl.exe 
+cflags=/nologo /DWIN32 /MD /W3 $(includes) /c 
+ccomp=cl.exe $(cdebugflags) $(cflags) $(pp_cflags) 
+clink=link.exe /nologo /machine:IX86  
+msdevdll=/dll 
+msdevdllflags=/MT /D "_USRDLL" /D "WDLL_EXPORTS" 
+ppcmd=/I  
+preproc=cl.exe 
+cpp=cl.exe 
+cppflags=/nologo /DWIN32 /MD /W3 $(includes) /c /EHsc 
+cppcomp=cl.exe $(cppdebugflags) $(cppflags) $(pp_cppflags) 
+cpplink=link.exe /nologo /machine:I386 advapi32.lib  
+for=f77 
+flink=$(for) $(flinkflags) 
+javacomp=javac -classpath $(src):$(CLASSPATH)  
+javacopy=copy 
+jar=jar 
+lex=lex $(lexflags) 
+yacc=yacc $(yaccflags) 
+ar=lib.exe /nologo  
+shlibsuffix=dll 
+shlibbuilder= $(cmt_installarea_linkopts)  
+library_install_command=copy  
+build_library_links=$(cmtexe) build library_links -quiet -tag=$(tags) 
+remove_library_links=$(cmtexe) remove library_links -quiet -tag=$(tags) 
+cmtexe=$(CMTROOT)\$(CMTBIN)\cmt.exe 
+build_prototype=$(cmtexe) build prototype 
+build_dependencies=$(cmtexe) -quiet -tag=$(tags) build dependencies 
+build_triggers=$(cmtexe) build triggers 
+implied_library_prefix=-l 
+implied_library_suffix=.lib 
+SHELL=cmd 
+q=" 
+src=..\src\ 
+doc=..\doc\ 
+inc=..\src\ 
+mgr=..\mgr\ 
+application_suffix=.exe 
+lock_command=attrib /S /D +R ..\* 
+unlock_command=attrib /S /D -R ..\* 
+MAKEFLAGS= --no-print-directory  
+gmake_hosts=lx1 rsplus lxtest as7 dxplus ax7 hp2 aleph hp1 hpplus papou1-fe atlas 
+make_hosts=virgo-control1 rio0a vmpc38a 
+everywhere=hosts 
+install_command=xcopy /S /E /Y  
+uninstall_command=del  
+cmt_installarea_command=xcopy /S /E /Y  
+cmt_uninstallarea_command=del  
+cmt_install_area_command=$(cmt_installarea_command) 
+cmt_uninstall_area_command=$(cmt_uninstallarea_command) 
+cmt_install_action=$(CMTROOT)\mgr\cmt_install_action.bat 
+cmt_installdir_action=$(CMTROOT)\mgr\cmt_installdir_action.bat 
+cmt_uninstall_action=$(CMTROOT)\mgr\cmt_uninstall_action.bat 
+cmt_uninstalldir_action=$(CMTROOT)\mgr\cmt_uninstalldir_action.bat 
+cmt_installdir_excludes=$(CMTROOT)\mgr\cmt_installdir_excludes.txt 
+mkdir=mkdir 
+cmt_cvs_protocol_level=v1r1 
+cmt_installarea_prefix=InstallArea 
+CMT_PATH_remove_regexp=\\[^\\]*\\ 
+CMT_PATH_remove_share_regexp=\\share\\ 
+NEWCMTCONFIG=WIN32-XP-cl 
+all_constituents=cmt $(constituents) 
+tag=VisualC 
+package=CMT 
+version=HEAD 
+PACKAGE_ROOT=$(CMTROOT) 
+srcdir=..\src 
+bin=..\$(CMT_tag)\ 
+javabin=..\classes\ 
+mgrdir=mgr 
+cmt_installarea_paths=$(cmt_installarea_prefix)/$(tag)/bin $(cmt_installarea_prefix)/$(tag)/lib $(cmt_installarea_prefix)/share/lib $(cmt_installarea_prefix)/share/bin 
+use_linkopts= $(cmt_installarea_linkopts)  
+cmt_use_linkopts=  $(CMT_linkopts)  
+constituents= cmt  
+constituentsclean= cmtclean  
+all_constituentsclean= $(constituentsclean) 
+cmt_actions_constituents= make  
+cmt_actions_constituentsclean= makeclean  
Index: /CMT/v1r20/mgr/afs_set_acls.sh
===================================================================
--- /CMT/v1r20/mgr/afs_set_acls.sh	(revision 368)
+++ /CMT/v1r20/mgr/afs_set_acls.sh	(revision 368)
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+if test "$#" = 0; then
+  echo "> afs_set_acls.sh <directory> <group id> <access rights>"
+  exit 0
+fi
+
+where=$1
+shift
+acl=$*
+
+for file in `find ${where} -type d -print`
+do
+  echo ${file}
+  fs sa -dir ${file} -acl ${acl}
+done
Index: /CMT/v1r20/mgr/build_from_rpm.sh
===================================================================
--- /CMT/v1r20/mgr/build_from_rpm.sh	(revision 368)
+++ /CMT/v1r20/mgr/build_from_rpm.sh	(revision 368)
@@ -0,0 +1,45 @@
+
+
+set -x
+
+version=v1r14
+
+#-------------------------------------------------------------
+# Install a local RPM database
+#-------------------------------------------------------------
+
+tempdir=/tmp/CMT
+
+rm -rf ${tempdir}
+
+database=${tempdir}/rpm-database
+
+mkdir -p ${database}
+
+rpm --dbpath ${database} --initdb
+rpm --dbpath ${database} -Uvh virtual.rpm
+
+rpm --dbpath ${database} -e CMT
+
+#-------------------------------------------------------------
+# Now Install from the source RPM
+#-------------------------------------------------------------
+
+tempdir1=$1
+
+if test "${tempdir1}" = ""; then
+  tempdir1=/tmp/CMT1
+  rm -rf ${tempdir1}
+  mkdir -p ${tempdir1}
+fi
+
+rm -rf ${tempdir1}
+mkdir -p ${tempdir1}
+
+rpm --dbpath ${database} -Uvh --relocate /CMT=${tempdir1}/CMT \
+  --define "_topdir ${tempdir1}" \
+  ../rpm/CMT-${version}-1.src.rpm
+
+
+
+
Index: /CMT/v1r20/mgr/cmt
===================================================================
--- /CMT/v1r20/mgr/cmt	(revision 368)
+++ /CMT/v1r20/mgr/cmt	(revision 368)
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+set -f
+
+if test ! "${CMTDEBUG}" = "" ; then
+  set -x
+fi
+
+#--------------------------------------------------
+# main ()
+#--------------------------------------------------
+
+cmtexe=${CMTROOT}/${CMTBIN}/cmt.exe
+
+${cmtexe} "$@"
+
+
+
+
+
Index: /CMT/v1r20/mgr/cmt.make
===================================================================
--- /CMT/v1r20/mgr/cmt.make	(revision 368)
+++ /CMT/v1r20/mgr/cmt.make	(revision 368)
@@ -0,0 +1,435 @@
+#-- start of make_header -----------------
+
+#====================================
+#  Application cmt
+#
+#   Generated Sun Oct 24 19:06:09 2004  by ARNAULT
+#
+#====================================
+
+#include ${CMTROOT}/src/Makefile.core
+
+ifdef tag
+CMTEXTRATAGS = $(tag)
+else
+tag       = $(CMTCONFIG)
+endif
+
+cmt_cmt_has_no_target_tag = 1
+
+#--------------------------------------------------------
+
+ifdef cmt_cmt_has_target_tag
+
+tags      = $(tag),$(CMTEXTRATAGS),target_cmt
+
+CMT_tag = $(tag)
+
+ifdef READONLY
+cmt_local_tagfile_cmt = /tmp/CMT_$(CMT_tag)_cmt.make$(cmt_lock_pid)
+else
+cmt_local_tagfile_cmt = $(CMT_tag)_cmt.make
+endif
+
+else
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+CMT_tag = $(tag)
+
+ifdef READONLY
+cmt_local_tagfile_cmt = /tmp/CMT_$(CMT_tag).make$(cmt_lock_pid)
+else
+cmt_local_tagfile_cmt = $(CMT_tag).make
+endif
+
+endif
+
+#-include $(cmt_local_tagfile_cmt)
+
+ifdef cmt_cmt_has_target_tag
+
+ifdef READONLY
+cmt_final_setup_cmt = /tmp/CMT_CMT_cmt_setup.make
+cmt_local_cmt_makefile = /tmp/CMT_cmt$(cmt_lock_pid).make
+else
+cmt_final_setup_cmt = $(bin)CMT_cmt_setup.make
+cmt_local_cmt_makefile = $(bin)cmt.make
+endif
+
+else
+
+ifdef READONLY
+cmt_final_setup_cmt = /tmp/CMT_CMT_setup.make
+cmt_local_cmt_makefile = /tmp/CMT_cmt$(cmt_lock_pid).make
+else
+cmt_final_setup_cmt = $(bin)CMT_setup.make
+cmt_local_cmt_makefile = $(bin)cmt.make
+endif
+
+endif
+
+ifdef READONLY
+cmt_final_setup = /tmp/CMT_CMT_setup.make
+else
+cmt_final_setup = $(bin)CMT_setup.make
+endif
+
+cmt ::
+
+
+ifdef READONLY
+cmt ::
+	@echo tags=$(tags)
+	@echo cmt_local_tagfile=$(cmt_local_tagfile)
+endif
+
+
+dirs ::
+	@if test ! -r requirements ; then echo "No requirements file" ; fi; \
+	  if test ! -d $(bin) ; then $(mkdir) -p $(bin) ; fi; \
+	  /bin/rm -f checkuses
+
+javadirs ::
+	@if test ! -d $(javabin) ; then $(mkdir) -p $(javabin) ; fi
+
+srcdirs ::
+	@if test ! -d $(src) ; then $(mkdir) -p $(src) ; fi
+
+help ::
+	@echo 'cmt'
+
+#-- end of make_header ------------------
+#-- start of application_header
+
+cmt :: dirs  $(bin)cmt${application_suffix}
+	@/bin/echo "------> cmt ok"
+
+#-- end of application_header
+#-- start of application
+
+$(bin)cmt${application_suffix} :: $(bin)cmt.o $(bin)cmt_awk.o $(bin)cmt_branch.o $(bin)cmt_constituent.o $(bin)cmt_deps_builder.o $(bin)cmt_fragment.o $(bin)cmt_generator.o $(bin)cmt_include.o $(bin)cmt_parser.o $(bin)cmt_script.o $(bin)cmt_string.o $(bin)cmt_system.o $(bin)cmt_tag.o $(bin)cmt_use.o $(bin)cmt_symbol.o $(bin)cmt_error.o $(bin)cmt_pattern.o $(bin)cmt_language.o $(bin)cmt_cvs.o $(bin)cmt_group.o $(bin)cmt_database.o $(bin)cmt_lock.o $(bin)cmt_triggers.o $(bin)cmt_regexp.o $(bin)cmt_model.o $(bin)cmt_project.o $(bin)cmt_syntax.o $(bin)cmt_install_area.o $(bin)cmt_cmtpath_pattern.o $(bin)cmt_sequence.o $(bin)cmt_generators.o $(bin)cmt_scope_section.o $(bin)cmt_log.o $(bin)cmt_commands.o $(use_stamps) $(cmtstamps) requirements $(use_requirements)
+	$(link_echo) $@
+	$(link_silent) cd $(bin); $(cpplink) -o cmt.exe.new $(bin)cmt.o $(bin)cmt_awk.o $(bin)cmt_branch.o $(bin)cmt_constituent.o $(bin)cmt_deps_builder.o $(bin)cmt_fragment.o $(bin)cmt_generator.o $(bin)cmt_include.o $(bin)cmt_parser.o $(bin)cmt_script.o $(bin)cmt_string.o $(bin)cmt_system.o $(bin)cmt_tag.o $(bin)cmt_use.o $(bin)cmt_symbol.o $(bin)cmt_error.o $(bin)cmt_pattern.o $(bin)cmt_language.o $(bin)cmt_cvs.o $(bin)cmt_group.o $(bin)cmt_database.o $(bin)cmt_lock.o $(bin)cmt_triggers.o $(bin)cmt_regexp.o $(bin)cmt_model.o $(bin)cmt_project.o $(bin)cmt_syntax.o $(bin)cmt_install_area.o $(bin)cmt_cmtpath_pattern.o $(bin)cmt_sequence.o $(bin)cmt_generators.o $(bin)cmt_scope_section.o $(bin)cmt_log.o $(bin)cmt_commands.o $(use_linkopts) $(cmtlinkopts); mv -f cmt.exe.new cmt${application_suffix}
+
+###
+### Preparing for next management of use_linkopts and auto_imports :
+###  will use  <constituent>_use_linkopts instead of use_linkopts
+###
+###    $(link_silent) cd $(bin); \
+###      $(cpplink) -o cmt.exe.new $(bin)cmt.o $(bin)cmt_awk.o $(bin)cmt_branch.o $(bin)cmt_constituent.o $(bin)cmt_deps_builder.o $(bin)cmt_fragment.o $(bin)cmt_generator.o $(bin)cmt_include.o $(bin)cmt_parser.o $(bin)cmt_script.o $(bin)cmt_string.o $(bin)cmt_system.o $(bin)cmt_tag.o $(bin)cmt_use.o $(bin)cmt_symbol.o $(bin)cmt_error.o $(bin)cmt_pattern.o $(bin)cmt_language.o $(bin)cmt_cvs.o $(bin)cmt_group.o $(bin)cmt_database.o $(bin)cmt_lock.o $(bin)cmt_triggers.o $(bin)cmt_regexp.o $(bin)cmt_model.o $(bin)cmt_project.o $(bin)cmt_syntax.o $(bin)cmt_install_area.o $(bin)cmt_cmtpath_pattern.o $(bin)cmt_sequence.o $(bin)cmt_generators.o $(bin)cmt_scope_section.o $(bin)cmt_log.o $(bin)cmt_commands.o \
+###      $(cmt_use_linkopts) $(cmtlinkopts); \
+###      mv -f cmt.exe.new cmt${application_suffix}
+###	 $(link_silent) cd $(bin); $(cpplink) -o cmt.exe.new $(bin)cmt.o $(bin)cmt_awk.o $(bin)cmt_branch.o $(bin)cmt_constituent.o $(bin)cmt_deps_builder.o $(bin)cmt_fragment.o $(bin)cmt_generator.o $(bin)cmt_include.o $(bin)cmt_parser.o $(bin)cmt_script.o $(bin)cmt_string.o $(bin)cmt_system.o $(bin)cmt_tag.o $(bin)cmt_use.o $(bin)cmt_symbol.o $(bin)cmt_error.o $(bin)cmt_pattern.o $(bin)cmt_language.o $(bin)cmt_cvs.o $(bin)cmt_group.o $(bin)cmt_database.o $(bin)cmt_lock.o $(bin)cmt_triggers.o $(bin)cmt_regexp.o $(bin)cmt_model.o $(bin)cmt_project.o $(bin)cmt_syntax.o $(bin)cmt_install_area.o $(bin)cmt_cmtpath_pattern.o $(bin)cmt_sequence.o $(bin)cmt_generators.o $(bin)cmt_scope_section.o $(bin)cmt_log.o $(bin)cmt_commands.o $(cmt_use_linkopts) $(cmtlinkopts); mv -f cmt.exe.new cmt${application_suffix}
+
+
+
+#-----------------------------------------------------------------
+#
+#  New section for automatic installation
+#
+#-----------------------------------------------------------------
+
+install_dir = ${CMTINSTALLAREA}/$(tag)/bin
+cmtinstallname = cmt${application_suffix}
+
+cmt :: cmtinstall
+
+install :: cmtinstall
+
+cmtinstall :: $(install_dir)/$(cmtinstallname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then\
+	  echo "installation done"; \
+	fi
+
+$(install_dir)/$(cmtinstallname) :: $(bin)$(cmtinstallname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  CMTINSTALLAREA=${CMTINSTALLAREA}; export CMTINSTALLAREA; \
+	  $(cmt_install_action) "`(cd $(bin); pwd)`" "$(cmtinstallname)" "$(install_dir)" "$(cmt_installarea_command)" ; \
+	fi
+
+cmtclean :: cmtuninstall
+
+uninstall :: cmtuninstall
+
+cmtuninstall ::
+	@echo "------> (cmt.make) Removing installed files"
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  CMTINSTALLAREA=${CMTINSTALLAREA}; export CMTINSTALLAREA; \
+	  $(cmt_uninstall_action) "$(PACKAGE_ROOT)/$(tag)" "$(cmtinstallname)" "$(install_dir)" ; \
+	fi
+
+#-- end of application
+#-- start of dependency ------------------
+
+$(bin)cmt_dependencies.make :: dirs
+
+ifndef QUICK
+$(bin)cmt_dependencies.make :: ../source/cmt.cxx ../source/cmt_awk.cxx ../source/cmt_branch.cxx ../source/cmt_constituent.cxx ../source/cmt_deps_builder.cxx ../source/cmt_fragment.cxx ../source/cmt_generator.cxx ../source/cmt_include.cxx ../source/cmt_parser.cxx ../source/cmt_script.cxx ../source/cmt_string.cxx ../source/cmt_system.cxx ../source/cmt_tag.cxx ../source/cmt_use.cxx ../source/cmt_symbol.cxx ../source/cmt_error.cxx ../source/cmt_pattern.cxx ../source/cmt_language.cxx ../source/cmt_cvs.cxx ../source/cmt_group.cxx ../source/cmt_database.cxx ../source/cmt_lock.cxx ../source/cmt_triggers.cxx ../source/cmt_regexp.cxx ../source/cmt_model.cxx ../source/cmt_project.cxx ../source/cmt_syntax.cxx ../source/cmt_install_area.cxx ../source/cmt_cmtpath_pattern.cxx ../source/cmt_sequence.cxx ../source/cmt_generators.cxx ../source/cmt_scope_section.cxx ../source/cmt_log.cxx ../source/cmt_commands.cxx  requirements $(use_requirements) $(cmt_final_setup_cmt)
+	@echo "------> (cmt.make) Rebuilding $@"; \
+	  args=`echo $? | sed -e "s#requirements.*##"`; \
+	  $(build_dependencies) cmt $${args}
+endif
+
+#$(cmt_dependencies)
+
+-include $(bin)cmt_dependencies.make
+
+#-- end of dependency -------------------
+#-- start of cpp ------
+
+$(bin)cmt.o : $(cmt_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_cppflags) $(cmt_cxx_cppflags) -I../source ../source/cmt.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_awk.o : $(cmt_awk_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_awk.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_awk_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_awk_cppflags) $(cmt_awk_cxx_cppflags) -I../source ../source/cmt_awk.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_branch.o : $(cmt_branch_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_branch.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_branch_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_branch_cppflags) $(cmt_branch_cxx_cppflags) -I../source ../source/cmt_branch.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_constituent.o : $(cmt_constituent_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_constituent.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_constituent_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_constituent_cppflags) $(cmt_constituent_cxx_cppflags) -I../source ../source/cmt_constituent.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_deps_builder.o : $(cmt_deps_builder_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_deps_builder.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_deps_builder_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_deps_builder_cppflags) $(cmt_deps_builder_cxx_cppflags) -I../source ../source/cmt_deps_builder.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_fragment.o : $(cmt_fragment_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_fragment.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_fragment_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_fragment_cppflags) $(cmt_fragment_cxx_cppflags) -I../source ../source/cmt_fragment.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_generator.o : $(cmt_generator_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_generator.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_generator_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_generator_cppflags) $(cmt_generator_cxx_cppflags) -I../source ../source/cmt_generator.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_include.o : $(cmt_include_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_include.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_include_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_include_cppflags) $(cmt_include_cxx_cppflags) -I../source ../source/cmt_include.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_parser.o : $(cmt_parser_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_parser.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_parser_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_parser_cppflags) $(cmt_parser_cxx_cppflags) -I../source ../source/cmt_parser.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_script.o : $(cmt_script_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_script.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_script_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_script_cppflags) $(cmt_script_cxx_cppflags) -I../source ../source/cmt_script.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_string.o : $(cmt_string_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_string.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_string_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_string_cppflags) $(cmt_string_cxx_cppflags) -I../source ../source/cmt_string.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_system.o : $(cmt_system_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_system.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_system_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_system_cppflags) $(cmt_system_cxx_cppflags) -I../source ../source/cmt_system.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_tag.o : $(cmt_tag_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_tag.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_tag_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_tag_cppflags) $(cmt_tag_cxx_cppflags) -I../source ../source/cmt_tag.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_use.o : $(cmt_use_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_use.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_use_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_use_cppflags) $(cmt_use_cxx_cppflags) -I../source ../source/cmt_use.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_symbol.o : $(cmt_symbol_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_symbol.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_symbol_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_symbol_cppflags) $(cmt_symbol_cxx_cppflags) -I../source ../source/cmt_symbol.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_error.o : $(cmt_error_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_error.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_error_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_error_cppflags) $(cmt_error_cxx_cppflags) -I../source ../source/cmt_error.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_pattern.o : $(cmt_pattern_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_pattern.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_pattern_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_pattern_cppflags) $(cmt_pattern_cxx_cppflags) -I../source ../source/cmt_pattern.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_language.o : $(cmt_language_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_language.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_language_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_language_cppflags) $(cmt_language_cxx_cppflags) -I../source ../source/cmt_language.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_cvs.o : $(cmt_cvs_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_cvs.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_cvs_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_cvs_cppflags) $(cmt_cvs_cxx_cppflags) -I../source ../source/cmt_cvs.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_group.o : $(cmt_group_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_group.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_group_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_group_cppflags) $(cmt_group_cxx_cppflags) -I../source ../source/cmt_group.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_database.o : $(cmt_database_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_database.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_database_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_database_cppflags) $(cmt_database_cxx_cppflags) -I../source ../source/cmt_database.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_lock.o : $(cmt_lock_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_lock.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_lock_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_lock_cppflags) $(cmt_lock_cxx_cppflags) -I../source ../source/cmt_lock.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_triggers.o : $(cmt_triggers_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_triggers.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_triggers_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_triggers_cppflags) $(cmt_triggers_cxx_cppflags) -I../source ../source/cmt_triggers.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_regexp.o : $(cmt_regexp_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_regexp.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_regexp_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_regexp_cppflags) $(cmt_regexp_cxx_cppflags) -I../source ../source/cmt_regexp.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_model.o : $(cmt_model_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_model.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_model_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_model_cppflags) $(cmt_model_cxx_cppflags) -I../source ../source/cmt_model.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_project.o : $(cmt_project_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_project.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_project_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_project_cppflags) $(cmt_project_cxx_cppflags) -I../source ../source/cmt_project.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_syntax.o : $(cmt_syntax_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_syntax.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_syntax_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_syntax_cppflags) $(cmt_syntax_cxx_cppflags) -I../source ../source/cmt_syntax.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_install_area.o : $(cmt_install_area_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_install_area.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_install_area_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_install_area_cppflags) $(cmt_install_area_cxx_cppflags) -I../source ../source/cmt_install_area.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_cmtpath_pattern.o : $(cmt_cmtpath_pattern_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_cmtpath_pattern.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_cmtpath_pattern_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_cmtpath_pattern_cppflags) $(cmt_cmtpath_pattern_cxx_cppflags) -I../source ../source/cmt_cmtpath_pattern.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_sequence.o : $(cmt_sequence_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_sequence.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_sequence_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_sequence_cppflags) $(cmt_sequence_cxx_cppflags) -I../source ../source/cmt_sequence.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_generators.o : $(cmt_generators_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_generators.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_generators_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_generators_cppflags) $(cmt_generators_cxx_cppflags) -I../source ../source/cmt_generators.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_scope_section.o : $(cmt_scope_section_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_scope_section.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_scope_section_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_scope_section_cppflags) $(cmt_scope_section_cxx_cppflags) -I../source ../source/cmt_scope_section.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_log.o : $(cmt_log_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_log.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_log_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_log_cppflags) $(cmt_log_cxx_cppflags) -I../source ../source/cmt_log.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt_commands.o : $(cmt_commands_cxx_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o cmt_commands.o $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_commands_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_commands_cppflags) $(cmt_commands_cxx_cppflags) -I../source ../source/cmt_commands.cxx
+
+#-- end of cpp ------
+#-- start of cleanup_header --------------
+
+clean :: cmtclean
+	@cd .
+
+.DEFAULT::
+	@echo Using default action for $@
+
+cmtclean ::
+#-- end of cleanup_header ---------------
+#-- start of cleanup_application ------
+	@echo "------> (cmt.make) Removing application files"
+	-$(cleanup_echo) cmt${application_suffix}
+	-@cd $(bin); /bin/rm -f cmt${application_suffix}
+#-- end of cleanup_application ------
+#-- start of cleanup_objects ------
+	$(cleanup_echo) objects
+	-$(cleanup_silent) cd $(bin); /bin/rm -f $(bin)cmt.o $(bin)cmt_awk.o $(bin)cmt_branch.o $(bin)cmt_constituent.o $(bin)cmt_deps_builder.o $(bin)cmt_fragment.o $(bin)cmt_generator.o $(bin)cmt_include.o $(bin)cmt_parser.o $(bin)cmt_script.o $(bin)cmt_string.o $(bin)cmt_system.o $(bin)cmt_tag.o $(bin)cmt_use.o $(bin)cmt_symbol.o $(bin)cmt_error.o $(bin)cmt_pattern.o $(bin)cmt_language.o $(bin)cmt_cvs.o $(bin)cmt_group.o $(bin)cmt_database.o $(bin)cmt_lock.o $(bin)cmt_triggers.o $(bin)cmt_regexp.o $(bin)cmt_model.o $(bin)cmt_project.o $(bin)cmt_syntax.o $(bin)cmt_install_area.o $(bin)cmt_cmtpath_pattern.o $(bin)cmt_sequence.o $(bin)cmt_generators.o $(bin)cmt_scope_section.o $(bin)cmt_log.o $(bin)cmt_commands.o
+#-- end of cleanup_objects ------
Index: /CMT/v1r20/mgr/cmt.nmake
===================================================================
--- /CMT/v1r20/mgr/cmt.nmake	(revision 368)
+++ /CMT/v1r20/mgr/cmt.nmake	(revision 368)
@@ -0,0 +1,387 @@
+
+#====================================
+#  Application cmt
+#
+#   Generated Tue Jan 31 17:10:47 2006  by arnault
+#
+#====================================
+
+!include $(CMTROOT)/src/NMakefile.core
+
+!if defined (tag)
+CMTEXTRATAGS = $(tag)
+!else
+!if defined (CMTCONFIG)
+tag = $(CMTCONFIG) 
+!else
+tag = VisualC
+!endif
+!endif
+
+cmt_cmt_has_no_target_tag = 1
+
+#--------------------------------------------------------
+
+!if defined (cmt_cmt_has_target_tag)
+
+tags      = $(tag),$(CMTEXTRATAGS),target_cmt
+
+CMT_tag = $(tag)
+
+cmt_local_tagfile = $(CMT_tag)_cmt.nmake
+
+!else
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+CMT_tag = $(tag)
+
+cmt_local_tagfile = $(CMT_tag).nmake
+
+!endif
+
+!include $(cmt_local_tagfile)
+
+cmt ::
+
+javadirs ::
+	@if not exist $(javabin) mkdir $(javabin)
+
+srcdirs ::
+	@if not exist $(src) mkdir $(src)
+
+dirs ::
+	@if not exist requirements echo "No requirements file"
+	@if not exist $(bin) mkdir $(bin)
+
+help ::
+	@echo 'cmt'
+
+cmt :: dirs  $(bin)cmt$(application_suffix)
+	@echo "------> cmt ok"
+
+
+
+$(bin)cmt$(application_suffix) :: $(bin)cmt\cmt.obj $(bin)cmt\cmt_awk.obj $(bin)cmt\cmt_branch.obj $(bin)cmt\cmt_constituent.obj $(bin)cmt\cmt_deps_builder.obj $(bin)cmt\cmt_fragment.obj $(bin)cmt\cmt_generator.obj $(bin)cmt\cmt_include.obj $(bin)cmt\cmt_parser.obj $(bin)cmt\cmt_script.obj $(bin)cmt\cmt_string.obj $(bin)cmt\cmt_system.obj $(bin)cmt\cmt_tag.obj $(bin)cmt\cmt_use.obj $(bin)cmt\cmt_symbol.obj $(bin)cmt\cmt_error.obj $(bin)cmt\cmt_pattern.obj $(bin)cmt\cmt_language.obj $(bin)cmt\cmt_cvs.obj $(bin)cmt\cmt_group.obj $(bin)cmt\cmt_database.obj $(bin)cmt\cmt_lock.obj $(bin)cmt\cmt_triggers.obj $(bin)cmt\cmt_regexp.obj $(bin)cmt\cmt_model.obj $(bin)cmt\cmt_project.obj $(bin)cmt\cmt_syntax.obj $(bin)cmt\cmt_install_area.obj $(bin)cmt\cmt_cmtpath_pattern.obj $(bin)cmt\cmt_sequence.obj $(bin)cmt\cmt_generators.obj $(bin)cmt\cmt_scope_section.obj $(bin)cmt\cmt_log.obj $(bin)cmt\cmt_commands.obj $(use_stamps) $(cmtstamps) requirements $(use_requirements)
+	$(link_echo) $@
+	$(link_silent) $(cpplink) /out:$(bin)cmt$(application_suffix) @<<
+$(bin)cmt\cmt.obj $(bin)cmt\cmt_awk.obj $(bin)cmt\cmt_branch.obj $(bin)cmt\cmt_constituent.obj $(bin)cmt\cmt_deps_builder.obj $(bin)cmt\cmt_fragment.obj $(bin)cmt\cmt_generator.obj $(bin)cmt\cmt_include.obj $(bin)cmt\cmt_parser.obj $(bin)cmt\cmt_script.obj $(bin)cmt\cmt_string.obj $(bin)cmt\cmt_system.obj $(bin)cmt\cmt_tag.obj $(bin)cmt\cmt_use.obj $(bin)cmt\cmt_symbol.obj $(bin)cmt\cmt_error.obj $(bin)cmt\cmt_pattern.obj $(bin)cmt\cmt_language.obj $(bin)cmt\cmt_cvs.obj $(bin)cmt\cmt_group.obj $(bin)cmt\cmt_database.obj $(bin)cmt\cmt_lock.obj $(bin)cmt\cmt_triggers.obj $(bin)cmt\cmt_regexp.obj $(bin)cmt\cmt_model.obj $(bin)cmt\cmt_project.obj $(bin)cmt\cmt_syntax.obj $(bin)cmt\cmt_install_area.obj $(bin)cmt\cmt_cmtpath_pattern.obj $(bin)cmt\cmt_sequence.obj $(bin)cmt\cmt_generators.obj $(bin)cmt\cmt_scope_section.obj $(bin)cmt\cmt_log.obj $(bin)cmt\cmt_commands.obj
+$(use_linkopts)
+$(cmtlinkopts)
+<<
+
+install_dir = $(CMTINSTALLAREA)\$(tag)\bin
+cmtinstallname = cmt$(application_suffix)
+
+cmt :: cmtinstall
+
+install :: cmtinstall
+
+cmtinstall :: $(install_dir)\$(cmtinstallname)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+
+$(install_dir)\$(cmtinstallname) :: $(bin)$(cmtinstallname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\$(tag)" "$(cmtinstallname)" "$(install_dir)"
+
+cmtclean :: cmtuninstall
+
+uninstall :: cmtuninstall
+
+cmtuninstall ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstall_action) "$(PACKAGE_ROOT)\$(tag)" "$(cmtinstallname)" "$(install_dir)"
+
+#-- start of dependency ------------------
+
+!if defined (QUICK)
+!else
+!if exist ("$(CMTROOT)/$(CMTBIN)/cmt.exe")
+!if [$(build_dependencies) cmt -all_sources] == 0
+!endif
+!else
+!if [echo no cmt $(CMTROOT)/$(CMTBIN)/cmt.exe] == 0
+!endif
+!endif
+!endif
+
+!include $(bin)cmt_dependencies.nmake
+
+#-- end of dependency ------------------
+#-- start of cpp ------
+
+$(bin)cmt/cmt.obj : $(cmt_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_cppflags) $(cmt_cxx_cppflags) -I..\source /Tp..\source\cmt.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_awk.obj : $(cmt_awk_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_awk.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_awk_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_awk_cppflags) $(cmt_awk_cxx_cppflags) -I..\source /Tp..\source\cmt_awk.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_branch.obj : $(cmt_branch_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_branch.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_branch_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_branch_cppflags) $(cmt_branch_cxx_cppflags) -I..\source /Tp..\source\cmt_branch.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_constituent.obj : $(cmt_constituent_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_constituent.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_constituent_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_constituent_cppflags) $(cmt_constituent_cxx_cppflags) -I..\source /Tp..\source\cmt_constituent.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_deps_builder.obj : $(cmt_deps_builder_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_deps_builder.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_deps_builder_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_deps_builder_cppflags) $(cmt_deps_builder_cxx_cppflags) -I..\source /Tp..\source\cmt_deps_builder.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_fragment.obj : $(cmt_fragment_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_fragment.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_fragment_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_fragment_cppflags) $(cmt_fragment_cxx_cppflags) -I..\source /Tp..\source\cmt_fragment.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_generator.obj : $(cmt_generator_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_generator.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_generator_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_generator_cppflags) $(cmt_generator_cxx_cppflags) -I..\source /Tp..\source\cmt_generator.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_include.obj : $(cmt_include_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_include.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_include_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_include_cppflags) $(cmt_include_cxx_cppflags) -I..\source /Tp..\source\cmt_include.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_parser.obj : $(cmt_parser_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_parser.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_parser_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_parser_cppflags) $(cmt_parser_cxx_cppflags) -I..\source /Tp..\source\cmt_parser.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_script.obj : $(cmt_script_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_script.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_script_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_script_cppflags) $(cmt_script_cxx_cppflags) -I..\source /Tp..\source\cmt_script.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_string.obj : $(cmt_string_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_string.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_string_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_string_cppflags) $(cmt_string_cxx_cppflags) -I..\source /Tp..\source\cmt_string.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_system.obj : $(cmt_system_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_system.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_system_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_system_cppflags) $(cmt_system_cxx_cppflags) -I..\source /Tp..\source\cmt_system.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_tag.obj : $(cmt_tag_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_tag.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_tag_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_tag_cppflags) $(cmt_tag_cxx_cppflags) -I..\source /Tp..\source\cmt_tag.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_use.obj : $(cmt_use_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_use.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_use_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_use_cppflags) $(cmt_use_cxx_cppflags) -I..\source /Tp..\source\cmt_use.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_symbol.obj : $(cmt_symbol_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_symbol.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_symbol_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_symbol_cppflags) $(cmt_symbol_cxx_cppflags) -I..\source /Tp..\source\cmt_symbol.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_error.obj : $(cmt_error_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_error.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_error_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_error_cppflags) $(cmt_error_cxx_cppflags) -I..\source /Tp..\source\cmt_error.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_pattern.obj : $(cmt_pattern_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_pattern.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_pattern_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_pattern_cppflags) $(cmt_pattern_cxx_cppflags) -I..\source /Tp..\source\cmt_pattern.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_language.obj : $(cmt_language_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_language.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_language_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_language_cppflags) $(cmt_language_cxx_cppflags) -I..\source /Tp..\source\cmt_language.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_cvs.obj : $(cmt_cvs_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_cvs.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_cvs_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_cvs_cppflags) $(cmt_cvs_cxx_cppflags) -I..\source /Tp..\source\cmt_cvs.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_group.obj : $(cmt_group_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_group.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_group_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_group_cppflags) $(cmt_group_cxx_cppflags) -I..\source /Tp..\source\cmt_group.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_database.obj : $(cmt_database_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_database.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_database_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_database_cppflags) $(cmt_database_cxx_cppflags) -I..\source /Tp..\source\cmt_database.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_lock.obj : $(cmt_lock_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_lock.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_lock_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_lock_cppflags) $(cmt_lock_cxx_cppflags) -I..\source /Tp..\source\cmt_lock.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_triggers.obj : $(cmt_triggers_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_triggers.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_triggers_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_triggers_cppflags) $(cmt_triggers_cxx_cppflags) -I..\source /Tp..\source\cmt_triggers.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_regexp.obj : $(cmt_regexp_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_regexp.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_regexp_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_regexp_cppflags) $(cmt_regexp_cxx_cppflags) -I..\source /Tp..\source\cmt_regexp.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_model.obj : $(cmt_model_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_model.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_model_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_model_cppflags) $(cmt_model_cxx_cppflags) -I..\source /Tp..\source\cmt_model.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_project.obj : $(cmt_project_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_project.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_project_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_project_cppflags) $(cmt_project_cxx_cppflags) -I..\source /Tp..\source\cmt_project.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_syntax.obj : $(cmt_syntax_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_syntax.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_syntax_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_syntax_cppflags) $(cmt_syntax_cxx_cppflags) -I..\source /Tp..\source\cmt_syntax.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_install_area.obj : $(cmt_install_area_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_install_area.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_install_area_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_install_area_cppflags) $(cmt_install_area_cxx_cppflags) -I..\source /Tp..\source\cmt_install_area.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_cmtpath_pattern.obj : $(cmt_cmtpath_pattern_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_cmtpath_pattern.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_cmtpath_pattern_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_cmtpath_pattern_cppflags) $(cmt_cmtpath_pattern_cxx_cppflags) -I..\source /Tp..\source\cmt_cmtpath_pattern.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_sequence.obj : $(cmt_sequence_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_sequence.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_sequence_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_sequence_cppflags) $(cmt_sequence_cxx_cppflags) -I..\source /Tp..\source\cmt_sequence.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_generators.obj : $(cmt_generators_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_generators.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_generators_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_generators_cppflags) $(cmt_generators_cxx_cppflags) -I..\source /Tp..\source\cmt_generators.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_scope_section.obj : $(cmt_scope_section_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_scope_section.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_scope_section_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_scope_section_cppflags) $(cmt_scope_section_cxx_cppflags) -I..\source /Tp..\source\cmt_scope_section.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_log.obj : $(cmt_log_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_log.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_log_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_log_cppflags) $(cmt_log_cxx_cppflags) -I..\source /Tp..\source\cmt_log.cxx
+
+#-- end of cpp ------
+#-- start of cpp ------
+
+$(bin)cmt/cmt_commands.obj : $(cmt_commands_cxx_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)cmt mkdir $(bin)cmt
+	$(cpp_silent) $(cppcomp) /Fo$(bin)cmt\cmt_commands.obj  /Fd$(bin)cmt\ $(use_pp_cppflags) $(cmt_pp_cppflags) $(app_cmt_pp_cppflags) $(cmt_commands_pp_cppflags) $(use_cppflags) $(cmt_cppflags) $(app_cmt_cppflags) $(cmt_commands_cppflags) $(cmt_commands_cxx_cppflags) -I..\source /Tp..\source\cmt_commands.cxx
+
+#-- end of cpp ------
+
+cmtclean ::
+	-$(cleanup_echo) cmt$(application_suffix)
+	-$(cleanup_silent) if exist $(bin)cmt$(application_suffix) del $(bin)cmt$(application_suffix)
+	$(cleanup_echo) objects
+	$(cleanup_silent) if exist $(bin)cmt rmdir /S /Q $(bin)cmt
+
Index: /CMT/v1r20/mgr/cmt_CC_version.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_CC_version.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_CC_version.sh	(revision 368)
@@ -0,0 +1,4 @@
+
+CC -V 2>&1 |\
+ cut -d ' ' -f7 |\
+ sed -e 's#^[0-9]#CC-&#'
Index: /CMT/v1r20/mgr/cmt_algorithms.cxx
===================================================================
--- /CMT/v1r20/mgr/cmt_algorithms.cxx	(revision 368)
+++ /CMT/v1r20/mgr/cmt_algorithms.cxx	(revision 368)
@@ -0,0 +1,161 @@
+typedef cmt_string T;
+
+typedef T* RandomAccessIterator;
+typedef T* BidirectionalIterator1;
+typedef T* BidirectionalIterator2;
+typedef T* ForwardIterator1;
+typedef T* ForwardIterator2;
+
+//template <class ForwardIterator1, class ForwardIterator2, class T>
+void iter_swap (ForwardIterator1 a, ForwardIterator2 b, T*)
+{
+  T tmp = *a;
+  *a = *b;
+  *b = tmp;
+}
+
+//template <class RandomAccessIterator, class T>
+RandomAccessIterator unguarded_partition (RandomAccessIterator first,
+                                          RandomAccessIterator last,
+                                          T pivot)
+{
+  while (true)
+    {
+      while (*first < pivot) ++first;
+      --last;
+      while (pivot < *last) --last;
+
+      if (!(first < last)) return first;
+
+      iter_swap (first, last, first);
+
+      ++first;
+    }
+}
+
+//template <class T>
+const T& median (const T& a, const T& b, const T& c)
+{
+  if (a < b)
+    if (b < c)
+      return b;
+    else if (a < c)
+      return c;
+    else
+      return a;
+  else if (a < c)
+    return a;
+  else if (b < c)
+    return c;
+  else
+    return b;
+}
+
+const int threshold = 16;
+
+//template <class RandomAccessIterator, class T>
+void quick_sort_loop (RandomAccessIterator first,
+                      RandomAccessIterator last, T* t)
+{
+  while ((last - first) > threshold)
+    {
+      RandomAccessIterator cut = unguarded_partition
+          (first,
+           last,
+           T (median(*first,
+                     *(first + (last - first)/2),
+                     *(last - 1))));
+
+      T pivot = median(*first,
+                       *(first + (last - first)/2),
+                       *(last - 1));
+
+      if (cut - first >= last - cut)
+        {
+          quick_sort_loop (cut, last, t);
+          last = cut;
+        }
+      else
+        {
+          quick_sort_loop (first, cut, t);
+          first = cut;
+        }
+    }
+}
+
+//template <class RandomAccessIterator, class T>
+void unguarded_linear_insert (RandomAccessIterator last, T value)
+{
+  RandomAccessIterator next = last;
+  --next;
+  while (value < *next)
+    {
+      *last = *next;
+      last = next--;
+    }
+  *last = value;
+}
+
+//template <class BidirectionalIterator1, class BidirectionalIterator2>
+BidirectionalIterator2 copy_backward (BidirectionalIterator1 first,
+                                      BidirectionalIterator1 last,
+                                      BidirectionalIterator2 result)
+{
+    while (first != last) *--result = *--last;
+    return result;
+}
+
+//template <class RandomAccessIterator, class T>
+void linear_insert (RandomAccessIterator first,
+                    RandomAccessIterator last, T*)
+{
+  T value = *last;
+  if (value < *first)
+    {
+      copy_backward(first, last, last + 1);
+      *first = value;
+    }
+  else
+    unguarded_linear_insert (last, value);
+}
+
+//template <class RandomAccessIterator>
+void insertion_sort (RandomAccessIterator first, RandomAccessIterator last)
+{
+  if (!(first == last))
+    for (RandomAccessIterator i = first + 1; i != last; ++i)
+      linear_insert(first, i, first);
+}
+
+//template <class RandomAccessIterator, class T>
+void unguarded_insertion_sort (RandomAccessIterator first,
+                               RandomAccessIterator last, T*)
+{
+  for (RandomAccessIterator i = first; i != last; ++i)
+    unguarded_linear_insert (i, T(*i));
+}
+
+//template <class RandomAccessIterator>
+void final_insertion_sort (RandomAccessIterator first,
+                           RandomAccessIterator last)
+{
+  if (last - first > threshold)
+    {
+      insertion_sort (first, first + threshold);
+      unguarded_insertion_sort (first + threshold, last, first);
+    }
+  else
+    insertion_sort (first, last);
+}
+
+//template <class RandomAccessIterator>
+void sort (RandomAccessIterator first,
+           RandomAccessIterator last)
+{
+  if (!(first == last))
+    {
+      quick_sort_loop (first, last, first);
+      final_insertion_sort (first, last);
+    }
+}
+
Index: /CMT/v1r20/mgr/cmt_build_deps.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_build_deps.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_build_deps.sh	(revision 368)
@@ -0,0 +1,150 @@
+
+#===============================================================
+#
+# This shell script emulates the behaviour of the 'cmt buid dependencies' operation
+# but using cpp -M instead
+#
+#===============================================================
+
+function compute_dependencies ()
+{
+  file=$1
+
+  # Generate the expected format:
+  #  one single line
+  #  prefix is a make macro
+  #  ends with a dependency to the stamp file
+
+  a=`eval cpp -M ${allflags} ${file} | \
+    sed -e 's#[.]o:#_'"${suffix}"'_dependencies = #' -e 's#[\\]$##'`
+
+  if test ! `echo ${a} | wc -w` = "0"; then
+    echo -n ${a}
+  else
+    echo -n "${file_name}_${suffix}_dependencies = ${file}"
+  fi
+
+  echo " \$(bin)${constituent}_deps/${file_name}_${suffix}.stamp"
+
+  # create or update the stamp file
+
+  touch ${bin}/${constituent}_deps/${file_name}_${suffix}.stamp
+}
+
+#--------------------------------------------
+macro_value ()
+{
+  name=$1
+  shift
+
+  grep "^${name}=" ${tempmacros} | sed -e "s#^${name}=##"
+}
+
+#-----------------------------------------------------
+# Pre-compute all configuration parameters from CMT queries
+#-----------------------------------------------------
+function prepare_context ()
+{
+  /bin/rm -f ${tempmacros}
+  cmt -quiet build tag_makefile > ${tempmacros}
+  cmt -quiet filter ${tempmacros} ${tempmacros}A; mv ${tempmacros}A ${tempmacros}
+
+  # /bin/rm -f ${tempconstituents}
+  # cmt -quiet show constituents > ${tempconstituents}
+  # cmt -quiet filter ${tempconstituents} ${tempconstituents}A; mv ${tempconstituents}A ${tempconstituents}
+}
+
+#------------------------------------------------------------------------------------------
+# Main
+#
+#  Expected arguments:
+#    1    : <constituent name>
+#    2    : -all_sources
+#    3... : <source file list>
+#
+#------------------------------------------------------------------------------------------
+
+constituent=$1
+shift
+
+all_sources=$1
+shift
+
+files=$*
+
+#---------------
+# Prepare temporary file management
+#
+tempprefix=/tmp/CMT$$
+if test ! "${TMP}" = ""; then
+  tempprefix=${TMP}/CMT$$
+fi
+
+tempmacros=${tempprefix}/macros$$
+tempconstituents=${tempprefix}/constituents$$
+
+trap "if test -d ${tempprefix} ; then chmod -R +w ${tempprefix}; fi; /bin/rm -rf ${tempprefix}" 0 1 2 15
+
+if test -d ${tempprefix} ; then chmod -R +w ${tempprefix}; fi
+/bin/rm -rf ${tempprefix}
+mkdir -p ${tempprefix}
+#---------------
+
+#---------------
+# prepare the context from CMT
+#
+prepare_context
+
+incl=`macro_value includes`
+
+cflags=`macro_value cflags`
+const_cflags=`macro_value ${constituent}_cflags`
+const_pp_cflags=`macro_value ${constituent}_pp_cflags`
+
+cppflags=`macro_value cppflags`
+const_cppflags=`macro_value ${constituent}_cppflags`
+const_pp_cppflags=`macro_value ${constituent}_pp_cppflags`
+
+bin=`macro_value bin`
+#--------------
+
+#--------------
+# Prepare the directory for the stamp files
+#
+mkdir -p ${bin}/${constituent}_deps
+#--------------
+
+#--------------
+# Prepare the dependency file
+#
+output=${bin}${constituent}_dependencies.make
+#--------------
+
+#--------------
+# Loop over source files (if any)
+#
+for f in `echo ${files}`; do
+  suffix=`echo ${f} | sed -e 's#.*[.]##'`
+  file_name=`basename ${f} .${suffix}`
+
+  # First remove the old dependency line from the output
+
+  if test -f ${output}; then
+    grep -v "${file_name}_${suffix}_dependencies" ${output} >t$$; mv t$$ ${output}
+  fi
+
+  echo "computing dependencies for ${file_name}.${suffix}"
+
+  case ${suffix} in
+    c ) allflags="${incl} ${cflags} ${const_cflags} ${const_cpp_cflags}";;
+    C|cc|cxx|cpp ) allflags="${incl} ${cppflags} ${const_cppflags} ${const_cpp_cppflags}";;
+  esac
+
+  echo "cpp -M ${allflags} ${f}"
+
+  compute_dependencies ${f} >>${output}
+done
+#--------------
+
+
+
Index: /CMT/v1r20/mgr/cmt_build_release.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_build_release.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_build_release.sh	(revision 368)
@@ -0,0 +1,171 @@
+
+
+#------------------------------------------------------------------
+# This script tries to rebuild various elements of one CMT release
+#
+# The binaries on:
+#   Linux (atlas.lal.in2p3.fr)
+#   OSF1  (asc)
+#   SunOS (ccasn)
+#   AIX   (ccars)
+#   Darwin (mac-ls3)
+#   LynxOS (ax12+rio36a)
+#
+# RPM and doxygen (lx1)
+#
+# gendoc + pdf (lxplus)
+#
+# What is NOT automatic is the build on VisualC and CYGWIN
+# For this we still need to 
+#   1) log onto Vmware
+#   2) checkout
+#   3) rebuild on VisualC 
+#        nmake /f nmake
+#        nmake /f nmake cmttag
+#   4) rebuild on CYGWIN
+#        make
+#   5) check in the result of the rebuild VisualC 
+#   6) transfer the result to /lal/CMT/...
+#
+# At the end, the ast operations are:
+#
+#  1) cvs tag ${version}
+#  2) gmake Export
+#
+#------------------------------------------------------------------
+
+##set -x
+
+version=`pwd`
+version=`dirname ${version}`
+version=`basename ${version}`
+
+CVSROOT=:pserver:anonymous@cvsserver.lal.in2p3.fr:/projects/cvs
+rwCVSROOT=:pserver:arnault@cvsserver.lal.in2p3.fr:/projects/cvs
+
+at_lal=/lal
+at_tmp=/tmp/tmpcmt
+at_virgo=/virgoDev
+at_lyon=/afs/in2p3.fr/home/throng/lalorsay
+at_cern=/afs/cern.ch/sw/contrib
+
+# For LAL machines
+
+cmd_lal="(cd ${at_lal}/CMT; \
+ cd ${version}/mgr; \
+ ./INSTALL; \
+ source setup.csh; \
+ gmake)"
+
+# For sh machines anywhere
+
+shcmd1="(rm -rf ${at_tmp}/CMT; \
+ mkdir -p ${at_tmp}/CMT; \
+ cd ${at_tmp}/CMT; \
+ cvs -d ${CVSROOT} co -d ${version} CMT; \
+ cd ${version}/mgr; \
+ ./INSTALL; \
+ source setup.sh; \
+ make)"
+
+# For csh machines anywhere
+
+cshcmd1="(rm -rf ${at_tmp}/CMT; \
+ mkdir -p ${at_tmp}/CMT; \
+ cd ${at_tmp}/CMT; \
+ cvs -d ${CVSROOT} co -d ${version} CMT; \
+ cd ${version}/mgr; \
+ ./INSTALL; \
+ source setup.csh; \
+ make)"
+
+# For Virgo machines
+
+cmd_virgo="(cd ${at_virgo}/CMT; \
+ cvs -d ${CVSROOT} co -d ${version} CMT; \
+ cd ${version}/mgr; \
+ ./INSTALL; \
+ source setup.csh; \
+ gmake; \
+ rsh rio36a \"(cd ${at_virgo}/CMT/${version}/mgr; source setup.csh; make)\")"
+
+# For csh machines anywhere
+
+cmd_lyon="(mkdir -p ${at_lyon}/CMT; \
+ cd ${at_lyon}/CMT; \
+ cvs -d ${CVSROOT} co -d ${version} CMT; \
+ cd ${version}/mgr; \
+ ./INSTALL; \
+ source setup.csh; \
+ make)"
+
+# For creating rpm and doxygen LAL machines
+
+cmd_rpm="(cd ${at_lal}/CMT; \
+ cd ${version}/mgr; \
+ ./INSTALL; \
+ source setup.csh; \
+ gmake doxygen; \
+ gmake rpm)"
+
+# For sh machines at CERN
+
+cmd_cern="(cd ${at_cern}/CMT; \
+ cvs -d ${rwCVSROOT} co -d ${version} CMT; \
+ cd ${version}/mgr; \
+ ./INSTALL; \
+ source setup.sh; \
+ gmake; \
+ cd; \
+ source setup.sh; \
+ cd ${at_cern}/CMT/${version}/mgr; \
+ gmake gendoc pdf; \
+ cd ../doc; \
+ cvs -d ${rwCVSROOT} ci -m gendoc)"
+
+
+#targets="arnault#atlas.lal.in2p3.fr#Linux#cmd_lal#${at_lal} \
+#arnault#asc.lal.in2p3.fr#OSF1#cmd_lal#${at_lal} \
+#arnault#ccasn.in2p3.fr#SunOS#cmd_lyon#${at_lyon} \
+#arnault#ccars.in2p3.fr#AIX#cmd_lyon#${at_lyon} \
+#arnault#ccali.in2p3.fr#Linux#cmd_lyon# \
+#arnault#mac-ls3.lal.in2p3.fr#Darwin#cshcmd1#${at_tmp} \
+#arnault#ax12.virgo.infn.it#LynxOS#cmd_virgo#${at_virgo} \
+#arnault#lx1.lal.in2p3.fr#Linux#cmd_rpm# \
+#carnault#lxplus.cern.ch#Linux#cmd_cern#"
+
+targets="arnault#ccasn.in2p3.fr#SunOS#cmd_lyon#${at_lyon} \
+arnault#ccars.in2p3.fr#AIX#cmd_lyon#${at_lyon} \
+arnault#ccali.in2p3.fr#Linux#cmd_lyon# \
+arnault#mac-ls3.lal.in2p3.fr#Darwin#cshcmd1#${at_tmp} \
+arnault#ax12.virgo.infn.it#LynxOS#cmd_virgo#${at_virgo}"
+
+selected=$1
+
+for t in `echo ${targets}`; do
+  user=`echo ${t} | cut -d# -f1`
+  machine=`echo ${t} | cut -d# -f2`
+  system=`echo ${t} | cut -d# -f3`
+  cmd=`echo ${t} | cut -d# -f4`
+  where=`echo ${t} | cut -d# -f5`
+
+  cmd=`eval echo '${'"${cmd}"'}'`
+
+  if test ! "${selected}" = ""; then
+    if test ! "${selected}" = "${machine}"; then
+      continue
+    fi
+  fi
+
+  echo "Trying [${cmd}] on machine ${machine} where=${where}"
+  ssh -x -l ${user} ${machine} "${cmd}" 2>&1 | cat >| build${machine}.log
+
+  if test ! "${where}" = ""; then
+    mkdir -p ../${system}
+    scp ${user}@${machine}:${where}/CMT/${version}/${system}/cmt.exe ../${system}/cmt.exe
+  fi
+
+done
+
+
+
Index: /CMT/v1r20/mgr/cmt_buildcvsinfos.bat
===================================================================
--- /CMT/v1r20/mgr/cmt_buildcvsinfos.bat	(revision 368)
+++ /CMT/v1r20/mgr/cmt_buildcvsinfos.bat	(revision 368)
@@ -0,0 +1,8 @@
+
+@echo off
+
+set ppp=%1%
+
+c:\Python20\python.exe /dev/CMT/v1r7/mgr/cmt_buildcvsinfos.py %1%
+
+
Index: /CMT/v1r20/mgr/cmt_buildcvsinfos.py
===================================================================
--- /CMT/v1r20/mgr/cmt_buildcvsinfos.py	(revision 368)
+++ /CMT/v1r20/mgr/cmt_buildcvsinfos.py	(revision 368)
@@ -0,0 +1,227 @@
+
+import os
+import string
+import sys
+
+#---------------------------------------------------------------------
+#
+# This script should be installed within the loginfo file of CVS
+# using the following line :
+#
+# ...
+#.cmtcvsinfos $CVSROOT/CVSROOT/cmt_buildcvsinfos.sh
+# ...
+#
+# and is used whenever one tries to import a module named .cmtcvsinfos/<module>
+#
+#---------------------------------------------------------------------
+
+#---------------------------------------------------------------------
+def CVSROOT () :
+    e = os.environ ['CVSROOT']
+    pos = e.find (':')
+    if pos == 0 :
+        e = e[1:]
+        pos = e.find (':')
+        e = e[pos+1:]
+
+    return (e)
+#---------------------------------------------------------------------
+    
+#------------------------------------------------------------
+def remove_dir (d):
+    if not os.path.exists (d) : return
+    
+    for f in os.listdir(d) :
+        name = d + '/' + f
+        if os.path.isdir (name) : remove_dir (name)
+        else :
+            os.chmod (name, 0777)
+            os.remove (name)
+
+    os.rmdir (d)
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def check_head (head, version) :
+    hlist = head.split ('.')
+    vlist = version.split ('.')
+    i = 0
+    for h in hlist :
+        if h != vlist[i] : return 0
+        i = i + 1
+        
+    return 1
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+#    test :  v1 newer then v2
+#
+def check_newer (v1, v2) :
+    list1 = v1.split ('.')
+    if len(list1) == 0 : return 0
+    
+    list2 = v2.split ('.')
+    i = 0
+    for h in list1 :
+        if i > len(list2) : return 1
+        if h > list2[i] : return 1
+        i = i + 1
+        
+    return 0
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def get_tags (module_file) :
+    if not os.path.isdir (module_file) : return ('')
+    
+    tags = ''
+    test_file = ''
+    if os.path.exists (module_file + '/cmt/requirements,v') :
+        test_file = module_file + '/cmt/requirements,v'
+    elif os.path.exists (module_file + '/mgr/requirements,v') :
+        test_file = module_file + '/mgr/requirements,v'
+    else :
+        for f in os.listdir (module_file) :
+            if f[-2:] == ',v' :
+                test_file = module_file + '/' + f
+                break;
+
+    if test_file == '' : return ('')
+
+    started = 0
+    finished = 0
+    top = ''
+    toptag = ''
+    cvstags = ''
+    
+    f = open (test_file, 'r')
+    while 1 :
+        line = f.readline ()
+        line = line [:-1]
+        if len (line) == 0 : break
+
+        if not started :
+            if line.find ('symbols') >= 0 :
+                started = 1
+                finished = 0
+                pos = line.find ('symbols')
+                line = line[pos+7:]
+                
+        if not finished :
+            if line.find ('locks;') >= 0 :
+                finished = 1
+                break
+            else :
+                line = line.strip ()
+                n = line.count ('.')
+                if n == 1 or n == 3 or n == 5 :
+                    pos = line.find (':')
+                    if pos >= 0 :
+                        v = line[pos+1:]
+                        tag = line[:pos]
+                        if check_newer (v, top) == 1 : top = v
+                        tags += tag + ' '
+                        cvstags += v + ' '
+    
+    taglist = tags.split ()
+    ts = cvstags.split ()
+    tags = ''
+    i = 0
+    for t in ts :
+        tags += taglist[i]
+        if top == t : tags += '(t)'
+        tags += ' '
+        i = i + 1
+
+    f.close ()
+
+    return (tags)
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def get_branches (module_file) :
+    if not os.path.isdir (module_file) : return ('')
+    branches = ''
+    for branch in os.listdir (module_file) :
+        if branch == 'Attic' : continue
+        branch_file = module_file + '/' + branch
+        if os.path.isdir (branch_file) :
+            if not os.path.exists (branch_file + '/cmt/requirements,v') :
+                if not os.path.exists (branch_file + '/mgr/requirements,v') :
+                    branches += branch + ' '
+
+    return (branches)
+#------------------------------------------------------------
+
+#------------------------------------------------------------
+def get_subpackages (module_file) :
+    if not os.path.isdir (module_file) : return ('')
+    subpackages = ''
+    for branch in os.listdir (module_file) :
+        if branch == 'Attic' : continue
+        branch_file = module_file + '/' + branch
+        if os.path.isdir (branch_file) :
+            if os.path.exists (branch_file + '/cmt/requirements,v') :
+                subpackages += branch + ' '
+            elif os.path.exists (branch_file + '/mgr/requirements,v') :
+                subpackages += branch + ' '
+                
+    return (subpackages)
+#------------------------------------------------------------
+
+if os.path.exists (CVSROOT() + '/.cmtcvsinfos') :
+    remove_dir (CVSROOT() + '/.cmtcvsinfos')
+
+a = raw_input ()
+
+root = CVSROOT ()
+
+print ('a=' + a)
+
+pos = a.find ('.cmtcvsinfos/')
+
+if pos == -1 :
+    print ('error=syntax error')
+    sys.exit (1)
+
+module = a[pos+len('.cmtcvsinfos/'):]
+
+print ('module=[' + module + ']')
+
+errormsg = ''
+
+module_file = CVSROOT () + '/' + module
+
+print ('module_file=[' + module_file + ']')
+
+if not os.path.isdir (module_file) :
+    errormsg = '### Module ' + module + ' not found.'
+    
+tags = get_tags (module_file)
+branches = get_branches (module_file)
+subpackages = get_subpackages (module_file)
+
+if errormsg != '' :
+    print ('error=' + errormsg)
+
+taglist = tags.split ()
+tags_top = ''
+tags = ''
+for t in taglist :
+    pos = t.find ('(t)')
+    if pos >= 0 :
+        tags_top += t[:pos] + ' '
+    else :
+        tags += t + ' '
+
+print ('tags_top=' + tags_top)
+print ('tags=' + tags)
+print ('branches=' + branches)
+print ('subpackages=' + subpackages)
+
+sys.exit (1)
+
+
+
+
Index: /CMT/v1r20/mgr/cmt_buildcvsinfos.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_buildcvsinfos.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_buildcvsinfos.sh	(revision 368)
@@ -0,0 +1,95 @@
+#!/bin/sh
+
+#---------------------------------------------------------------------
+#
+# This script should be installed within the commitinfo file of CVS
+# using the following line :
+#
+# ...
+#.cvsinfos $CVSROOT/CVSROOT/cmt_buildcvsinfos.sh
+# ...
+#
+# and is used whenever one tries to import a file named cmt.cvsinfos
+#
+#  This file should only contain the name of a CVS module onto which
+# queries are to be done.
+# 
+#---------------------------------------------------------------------
+
+#set -x
+
+echo $*
+
+if test "$1" = "" ; then
+  exit 1
+fi
+
+if test "$1" = "cmt.cvsinfos" ; then
+  module=`cat $1`
+elif test "$1" = "methods.cvsinfos" ; then
+  module=`cat $1`
+elif test "$2" = "cmt.cvsinfos" ; then
+  module=`cat $2`
+elif test "$2" = "methods.cvsinfos" ; then
+  module=`cat $2`
+else
+  exit 1
+fi
+
+if test "${module}" = "" ; then
+  exit 1
+fi
+
+if test -d ${CVSROOT}/${module} ; then
+  if test -r ${CVSROOT}/${module}/mgr/requirements,v ; then
+    test_file=${CVSROOT}/${module}/mgr/requirements,v
+  else
+    test_file=`find ${CVSROOT}/${module} -name '*,v' -print | head -n 1`
+  fi
+
+  tags=`tr ' ' '\n' < ${test_file} | \
+   awk '/symbols/,/locks/ {n=split($0,w,"."); if ((n == 2) || (n == 4)) print; }'  | \
+   sed -e 's#:.*##' -e 's#[ 	]*##'`
+else
+  echo # Module ${module} not found.
+fi
+
+branches=
+for branch in `ls ${CVSROOT}/${module} | grep -v Attic` ; do
+  if test -d ${CVSROOT}/${module}/${branch} ; then
+    if test ! -r ${CVSROOT}/${module}/${branch}/cmt/requirements,v ; then
+      if test ! -r ${CVSROOT}/${module}/${branch}/mgr/requirements,v ; then
+	if test "${branches}" = "" ; then
+	  branches="${branch}"
+	else
+	  branches="${branches} ${branch}"
+	fi
+      fi
+    fi
+  fi
+done
+
+subpackages=
+for branch in `ls ${CVSROOT}/${module} | grep -v Attic` ; do
+  if test -d ${CVSROOT}/${module}/${branch} ; then
+    if test -r ${CVSROOT}/${module}/${branch}/cmt/requirements,v ; then
+      if test "${subpackages}" = "" ; then
+	subpackages="${branch}"
+      else
+	subpackages="${subpackages} ${branch}"
+      fi
+    elif test -r ${CVSROOT}/${module}/${branch}/mgr/requirements,v ; then
+      if test "${subpackages}" = "" ; then
+	subpackages="${branch}"
+      else
+	subpackages="${subpackages} ${branch}"
+      fi
+    fi
+  fi
+done
+
+echo tags=${tags}
+echo branches=${branches}
+echo subpackages=${subpackages}
+
+exit 1
Index: /CMT/v1r20/mgr/cmt_buildcvsinfos2.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_buildcvsinfos2.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_buildcvsinfos2.sh	(revision 368)
@@ -0,0 +1,284 @@
+#!/bin/sh
+
+#---------------------------------------------------------------------
+#
+# This script should be installed within the loginfo file of CVS
+# using the following line :
+#
+# ...
+#.cmtcvsinfos $CVSROOT/CVSROOT/cmt_buildcvsinfos2.sh
+# ...
+#
+# and is used whenever one tries to import a module named .cmtcvsinfos/<protocol-level>/<module>
+#
+#---------------------------------------------------------------------
+
+#set -x
+
+#---------------------------------------------------------------------
+get_cvsroot ()
+{
+  echo ${CVSROOT} | sed -e 's#^:[^:]*:##'
+}
+
+#---------------------------------------------------------------------
+check_head ()
+{
+  head=$1
+  version=$2
+
+  echo "${head} ${version}" | awk '{\
+   head = $1; \
+   version = $2; \
+   nh = split (head, hlist); \
+   nv = split (version, vlist); \
+   for (i = 0; i < nh; i++) \
+   { \
+     if (hlist[i] != vlist[i]) \
+     { \
+       print "0"; \
+       next; \
+     } \
+   } \
+   print "1"; \
+}'
+}
+
+#---------------------------------------------------------------------
+check_newer ()
+{
+  v1=$1;
+  v2=$2;
+
+  #echo "check_newer v1=${v1} v2=${v2}"
+
+  if test "${v2}" = ""; then
+    echo "1"
+    return
+  fi
+
+  echo "${v1} ${v2}" | awk '{\
+   v1 = $1;\
+   v2 = $2;\
+   n1 = len (v1);\
+   if (n1 == 0) \
+   {\
+     print "0";\
+     next;\
+   }\
+   n1 = split (v1, list1);\
+   if (n1 == 0) \
+   {\
+     print "0";\
+     next;\
+   }\
+   n2 = split (v2, list2);\
+   for (i = 0; i < n1; i++)\
+   {\
+     if (i > n2)\
+     {\
+       print "1";\
+       next;
+     }\
+     if (list1[i] > list2[i])\
+     {\
+       print "1";\
+       next;
+     }\
+   }\
+   print "0";\
+}'
+}
+
+#---------------------------------------------------------------------
+get_tags ()
+{
+  module=$1
+
+  if test -r "${CVSROOT}/${module}/cmt/requirements,v" ; then
+    test_file="${CVSROOT}/${module}/cmt/requirements,v"
+  elif test -r "${CVSROOT}/${module}/mgr/requirements,v" ; then
+    test_file="${CVSROOT}/${module}/mgr/requirements,v"
+  else
+    test_file=`find "${CVSROOT}/${module}" -name '*,v' -print | head -n 1`
+  fi
+
+#  tags=`tr ' ' '\n' < "${test_file}" | \
+#   awk '/symbols/,/locks/ {n=split($0,w,"."); if ((n == 2) || (n == 4) || (n == 6)) print; }'  | \
+#   sed -e 's#:.*##' -e 's#[ 	]*##'`
+#  print "${tags}"
+
+  started=0
+  finished=0
+  top=
+  toptags=
+  cvstags=
+
+#symbols
+#	v10:1.1.1.1
+#	v2:1.1.1.1
+#	v1r2:1.1.1.1
+#	v1r1:1.1.1.1
+#	v1:1.1.1.1
+#	cmt:1.1.1;
+#locks; strict;
+  
+  alltags=`tr ' ' '\n' < "${test_file}" | \
+   awk '/symbols/,/locks/ { \
+     if (done == 1) next; \
+     n = split ($0,w,"."); \
+     if ((n != 2) && (n != 4) && (n != 6)) next; \
+     if ($1 == "symbols") \
+     { \
+       print $2; \
+     } \
+     else \
+     { \
+       print $1; \
+     } \
+     if ($1 == "locks;") done = 1; \
+   }'`
+
+  for t in ${alltags}; do
+    tag=`echo ${t} | sed -e 's#:.*##'`
+    v=`echo ${t} | sed -e 's#.*:##'`
+
+    if test `check_newer ${v} ${top}` = "1"; then
+      top=${v}
+    fi
+  done
+
+  tags=
+
+  for t in ${alltags}; do
+    tag=`echo ${t} | sed -e 's#:.*##'`
+    v=`echo ${t} | sed -e 's#.*:##'`
+
+    if test "${v}" = "${top}"; then
+      tags="${tags} ${tag}(t) "
+    else
+      tags="${tags} ${tag} "
+    fi
+
+  done
+
+  echo "${tags}"
+}
+
+#---------------------------------------------------------------------
+get_branches ()
+{
+  module=$1
+
+  branches=
+  for branch in `ls "${CVSROOT}/${module}" | grep -v Attic` ; do
+    if test -d "${CVSROOT}/${module}/${branch}" ; then
+      if test ! -r "${CVSROOT}/${module}/${branch}/cmt/requirements,v" ; then
+	if test ! -r "${CVSROOT}/${module}/${branch}/mgr/requirements,v" ; then
+	  if test "${branches}" = "" ; then
+	    branches="${branch}"
+	  else
+	    branches="${branches} ${branch}"
+	  fi
+	fi
+      fi
+    fi
+  done
+  echo "${branches}"
+}
+
+#---------------------------------------------------------------------
+get_subpackages ()
+{
+  module=$1
+
+  subpackages=
+  for branch in `ls "${CVSROOT}/${module}" | grep -v Attic` ; do
+    if test -d "${CVSROOT}/${module}/${branch}" ; then
+      if test -r "${CVSROOT}/${module}/${branch}/cmt/requirements,v" ; then
+	if test "${subpackages}" = "" ; then
+	  subpackages="${branch}"
+	else
+	  subpackages="${subpackages} ${branch}"
+	fi
+      elif test -r "${CVSROOT}/${module}/${branch}/mgr/requirements,v" ; then
+	if test "${subpackages}" = "" ; then
+	  subpackages="${branch}"
+	else
+	  subpackages="${subpackages} ${branch}"
+	fi
+      fi
+    fi
+  done
+  echo "${subpackages}"
+}
+
+#---------------------------------------------------------------------
+# main
+#---------------------------------------------------------------------
+
+rm -f -r $CVSROOT/.cmtcvsinfos/*
+
+read a
+
+root=$CVSROOT
+protocol_level=v1r1
+
+module=`echo $a | sed -e "s#.*[.]cmtcvsinfos/${protocol_level}/##"`
+error=
+
+if test "${module}" = "" ; then
+  echo "error=syntax error"
+  exit 1
+fi
+
+tags=
+tags_top=
+
+if test -d "${CVSROOT}/${module}" ; then
+  alltags=`get_tags ${module}`
+  for t in ${alltags}; do
+    a=`echo ${t} | grep '[(]t[)]$'`
+    is_top=$?
+    if test "${is_top}" = 1; then
+      if test "${tags}" = ""; then
+	tags="${t}"
+      else
+	tags="${tags} ${t}"
+      fi
+    else
+      t=`echo ${t} | sed -e 's#(t)##'`
+
+      if test "${tags_top}" = ""; then
+	tags_top="${t}"
+      else
+	tags_top="${tags_top} ${t}"
+      fi
+    fi
+  done
+else
+  error="### Module ${module} not found."
+fi
+
+branches=
+if test -d "${CVSROOT}/${module}" ; then
+  branches=`get_branches ${module}`
+fi
+
+subpackages=
+if test -d "${CVSROOT}/${module}" ; then
+  subpackages=`get_subpackages ${module}`
+fi
+
+if test ! "${error}" = ""; then
+  echo error=${error}
+fi
+
+echo tags_top=${tags_top}
+echo tags=${tags}
+echo branches=${branches}
+echo subpackages=${subpackages}
+
+exit 1
+
+
Index: /CMT/v1r20/mgr/cmt_cxx_version.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_cxx_version.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_cxx_version.sh	(revision 368)
@@ -0,0 +1,6 @@
+
+cxx -V 2>&1 |\
+ grep 'C++' |\
+ cut -d ' ' -f3  |\
+ sed -e 's#^V#cxx-#'
+
Index: /CMT/v1r20/mgr/cmt_dcc_version.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_dcc_version.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_dcc_version.sh	(revision 368)
@@ -0,0 +1,7 @@
+
+cc -v 2>&1 |\
+ grep version |\
+ cut -d ' ' -f3 |\
+ sed -e 's#^[0-9]#gcc-&#'
+
+
Index: /CMT/v1r20/mgr/cmt_dependencies.make
===================================================================
--- /CMT/v1r20/mgr/cmt_dependencies.make	(revision 368)
+++ /CMT/v1r20/mgr/cmt_dependencies.make	(revision 368)
@@ -0,0 +1,34 @@
+cmt_cxx_dependencies =  ../source/cmt.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_parser.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h 
+cmt_awk_cxx_dependencies =  ../source/cmt_awk.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_regexp.h   ../source/cmt_awk.h   ../source/cmt_vector.h   ../source/cmt_system.h 
+cmt_branch_cxx_dependencies =  ../source/cmt_branch.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h 
+cmt_constituent_cxx_dependencies =  ../source/cmt_constituent.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_awk.h   ../source/cmt_deps_builder.h   ../source/cmt_generator.h   ../source/cmt_branch.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h 
+cmt_deps_builder_cxx_dependencies =  ../source/cmt_deps_builder.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_parser.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_deps_builder.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_log.h 
+cmt_fragment_cxx_dependencies =  ../source/cmt_fragment.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_fragment.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_branch.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h 
+cmt_generator_cxx_dependencies =  ../source/cmt_generator.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_awk.h   ../source/cmt_deps_builder.h   ../source/cmt_generator.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_generators.h 
+cmt_include_cxx_dependencies =  ../source/cmt_include.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_include.h   ../source/cmt_map.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_log.h 
+cmt_parser_cxx_dependencies =  ../source/cmt_parser.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_version.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h   ../source/cmt_deps_builder.h   ../source/cmt_generator.h   ../source/cmt_error.h   ../source/cmt_cvs.h   ../source/cmt_lock.h   ../source/cmt_triggers.h   ../source/cmt_model.h   ../source/cmt_syntax.h   ../source/cmt_install_area.h   ../source/cmt_sequence.h   ../source/cmt_log.h   ../source/cmt_commands.h 
+cmt_script_cxx_dependencies =  ../source/cmt_script.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_script.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h 
+cmt_string_cxx_dependencies =  ../source/cmt_string.cxx   ../source/cmt_std.h   ../source/cmt_string.h 
+cmt_system_cxx_dependencies =  ../source/cmt_system.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt_error.h   ../source/cmt_map.h 
+cmt_tag_cxx_dependencies =  ../source/cmt_tag.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h   ../source/cmt_log.h 
+cmt_use_cxx_dependencies =  ../source/cmt_use.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_map.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_error.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h   ../source/cmt_syntax.h 
+cmt_symbol_cxx_dependencies =  ../source/cmt_symbol.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_map.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h 
+cmt_error_cxx_dependencies =  ../source/cmt_error.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_error.h   ../source/cmt_vector.h 
+cmt_pattern_cxx_dependencies =  ../source/cmt_pattern.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_parser.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h   ../source/cmt_error.h   ../source/cmt_syntax.h 
+cmt_language_cxx_dependencies =  ../source/cmt_language.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_fragment.h   ../source/cmt_language.h   ../source/cmt_branch.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h 
+cmt_cvs_cxx_dependencies =  ../source/cmt_cvs.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_parser.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_cvs.h   ../source/cmt_awk.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_project.h 
+cmt_group_cxx_dependencies =  ../source/cmt_group.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_group.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h 
+cmt_database_cxx_dependencies =  ../source/cmt_database.cxx   ../source/cmt_vector.h   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h 
+cmt_lock_cxx_dependencies =  ../source/cmt_lock.cxx   ../source/cmt_std.h   ../source/cmt_lock.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt_error.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h 
+cmt_triggers_cxx_dependencies =  ../source/cmt_triggers.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_triggers.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt_awk.h   ../source/cmt_map.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_project.h   ../source/cmt_syntax.h 
+cmt_regexp_cxx_dependencies =  ../source/cmt_regexp.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_regexp.h   ../source/cmt_vector.h   ../source/cmt_system.h 
+cmt_model_cxx_dependencies =  ../source/cmt_model.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt_model.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_fragment.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h 
+cmt_project_cxx_dependencies =  ../source/cmt_project.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h   ../source/cmt_syntax.h   ../source/cmt_error.h 
+cmt_syntax_cxx_dependencies =  ../source/cmt_syntax.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_map.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_syntax.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_error.h   ../source/cmt_branch.h   ../source/cmt_language.h   ../source/cmt_cmtpath_pattern.h 
+cmt_install_area_cxx_dependencies =  ../source/cmt_install_area.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt_parser.h   ../source/cmt.h   ../source/cmt_install_area.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_syntax.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_cmtpath_pattern.h 
+cmt_cmtpath_pattern_cxx_dependencies =  ../source/cmt_cmtpath_pattern.cxx   ../source/cmt_vector.h   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_branch.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_map.h   ../source/cmt_pattern.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h   ../source/cmt_cmtpath_pattern.h   ../source/cmt_database.h   ../source/cmt_syntax.h 
+cmt_sequence_cxx_dependencies =  ../source/cmt_sequence.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_regexp.h   ../source/cmt_awk.h   ../source/cmt_sequence.h   ../source/cmt_vector.h   ../source/cmt_system.h 
+cmt_generators_cxx_dependencies =  ../source/cmt_generators.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_fragment.h   ../source/cmt_group.h   ../source/cmt_constituent.h   ../source/cmt_language.h   ../source/cmt_awk.h   ../source/cmt_deps_builder.h   ../source/cmt_generator.h   ../source/cmt_generators.h   ../source/cmt_map.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_log.h 
+cmt_scope_section_cxx_dependencies =  ../source/cmt_scope_section.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_parser.h   ../source/cmt_scope_section.h 
+cmt_log_cxx_dependencies =  ../source/cmt_log.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_log.h   ../source/cmt_vector.h   ../source/cmt_parser.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h 
+cmt_commands_cxx_dependencies =  ../source/cmt_commands.cxx   ../source/cmt_std.h   ../source/cmt_string.h   ../source/cmt_vector.h   ../source/cmt_map.h   ../source/cmt_parser.h   ../source/cmt_regexp.h   ../source/cmt_system.h   ../source/cmt.h   ../source/cmt_commands.h   ../source/cmt_include.h   ../source/cmt_script.h   ../source/cmt_pattern.h   ../source/cmt_scope_section.h   ../source/cmt_use.h   ../source/cmt_tag.h   ../source/cmt_symbol.h   ../source/cmt_awk.h   ../source/cmt_project.h 
Index: /CMT/v1r20/mgr/cmt_dependencies.nmake
===================================================================
--- /CMT/v1r20/mgr/cmt_dependencies.nmake	(revision 368)
+++ /CMT/v1r20/mgr/cmt_dependencies.nmake	(revision 368)
@@ -0,0 +1,34 @@
+cmt_cxx_dependencies = "..\source\cmt.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_parser.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h"
+cmt_awk_cxx_dependencies = "..\source\cmt_awk.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_regexp.h" "..\source\cmt_awk.h" "..\source\cmt_vector.h" "..\source\cmt_system.h"
+cmt_branch_cxx_dependencies = "..\source\cmt_branch.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h"
+cmt_constituent_cxx_dependencies = "..\source\cmt_constituent.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_awk.h" "..\source\cmt_deps_builder.h" "..\source\cmt_generator.h" "..\source\cmt_branch.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h"
+cmt_deps_builder_cxx_dependencies = "..\source\cmt_deps_builder.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_parser.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_deps_builder.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_log.h"
+cmt_fragment_cxx_dependencies = "..\source\cmt_fragment.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_fragment.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_branch.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h"
+cmt_generator_cxx_dependencies = "..\source\cmt_generator.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_awk.h" "..\source\cmt_deps_builder.h" "..\source\cmt_generator.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_generators.h"
+cmt_include_cxx_dependencies = "..\source\cmt_include.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_include.h" "..\source\cmt_map.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_log.h"
+cmt_parser_cxx_dependencies = "..\source\cmt_parser.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_version.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h" "..\source\cmt_deps_builder.h" "..\source\cmt_generator.h" "..\source\cmt_error.h" "..\source\cmt_cvs.h" "..\source\cmt_lock.h" "..\source\cmt_triggers.h" "..\source\cmt_model.h" "..\source\cmt_syntax.h" "..\source\cmt_install_area.h" "..\source\cmt_sequence.h" "..\source\cmt_log.h" "..\source\cmt_commands.h"
+cmt_script_cxx_dependencies = "..\source\cmt_script.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_script.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h"
+cmt_string_cxx_dependencies = "..\source\cmt_string.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h"
+cmt_system_cxx_dependencies = "..\source\cmt_system.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt_error.h"
+cmt_tag_cxx_dependencies = "..\source\cmt_tag.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h" "..\source\cmt_log.h"
+cmt_use_cxx_dependencies = "..\source\cmt_use.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_map.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_error.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h" "..\source\cmt_syntax.h"
+cmt_symbol_cxx_dependencies = "..\source\cmt_symbol.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_map.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h"
+cmt_error_cxx_dependencies = "..\source\cmt_error.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_error.h" "..\source\cmt_vector.h"
+cmt_pattern_cxx_dependencies = "..\source\cmt_pattern.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_parser.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h" "..\source\cmt_error.h" "..\source\cmt_syntax.h"
+cmt_language_cxx_dependencies = "..\source\cmt_language.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_fragment.h" "..\source\cmt_language.h" "..\source\cmt_branch.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h"
+cmt_cvs_cxx_dependencies = "..\source\cmt_cvs.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_parser.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_cvs.h" "..\source\cmt_awk.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_project.h"
+cmt_group_cxx_dependencies = "..\source\cmt_group.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_group.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h"
+cmt_database_cxx_dependencies = "..\source\cmt_database.cxx" "..\source\cmt_vector.h" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h"
+cmt_lock_cxx_dependencies = "..\source\cmt_lock.cxx" "..\source\cmt_std.h" "..\source\cmt_lock.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt_error.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h"
+cmt_triggers_cxx_dependencies = "..\source\cmt_triggers.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_triggers.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt_awk.h" "..\source\cmt_map.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_project.h" "..\source\cmt_syntax.h"
+cmt_regexp_cxx_dependencies = "..\source\cmt_regexp.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_regexp.h" "..\source\cmt_vector.h" "..\source\cmt_system.h"
+cmt_model_cxx_dependencies = "..\source\cmt_model.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt_model.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_fragment.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h"
+cmt_project_cxx_dependencies = "..\source\cmt_project.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h" "..\source\cmt_syntax.h" "..\source\cmt_error.h"
+cmt_syntax_cxx_dependencies = "..\source\cmt_syntax.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_map.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_syntax.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_error.h" "..\source\cmt_branch.h" "..\source\cmt_language.h" "..\source\cmt_cmtpath_pattern.h"
+cmt_install_area_cxx_dependencies = "..\source\cmt_install_area.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt_parser.h" "..\source\cmt.h" "..\source\cmt_install_area.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_syntax.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_cmtpath_pattern.h"
+cmt_cmtpath_pattern_cxx_dependencies = "..\source\cmt_cmtpath_pattern.cxx" "..\source\cmt_vector.h" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_branch.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_map.h" "..\source\cmt_pattern.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h" "..\source\cmt_cmtpath_pattern.h" "..\source\cmt_database.h" "..\source\cmt_syntax.h"
+cmt_sequence_cxx_dependencies = "..\source\cmt_sequence.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_regexp.h" "..\source\cmt_awk.h" "..\source\cmt_sequence.h" "..\source\cmt_vector.h" "..\source\cmt_system.h"
+cmt_generators_cxx_dependencies = "..\source\cmt_generators.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_fragment.h" "..\source\cmt_group.h" "..\source\cmt_constituent.h" "..\source\cmt_language.h" "..\source\cmt_awk.h" "..\source\cmt_deps_builder.h" "..\source\cmt_generator.h" "..\source\cmt_generators.h" "..\source\cmt_map.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_log.h"
+cmt_scope_section_cxx_dependencies = "..\source\cmt_scope_section.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_parser.h" "..\source\cmt_scope_section.h"
+cmt_log_cxx_dependencies = "..\source\cmt_log.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_log.h" "..\source\cmt_vector.h" "..\source\cmt_parser.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h"
+cmt_commands_cxx_dependencies = "..\source\cmt_commands.cxx" "..\source\cmt_std.h" "..\source\cmt_string.h" "..\source\cmt_vector.h" "..\source\cmt_map.h" "..\source\cmt_parser.h" "..\source\cmt_regexp.h" "..\source\cmt_system.h" "..\source\cmt.h" "..\source\cmt_commands.h" "..\source\cmt_include.h" "..\source\cmt_script.h" "..\source\cmt_pattern.h" "..\source\cmt_scope_section.h" "..\source\cmt_use.h" "..\source\cmt_tag.h" "..\source\cmt_symbol.h" "..\source\cmt_awk.h" "..\source\cmt_project.h"
Index: /CMT/v1r20/mgr/cmt_export.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_export.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_export.sh	(revision 368)
@@ -0,0 +1,46 @@
+#!/bin/sh -f
+
+if test $# -lt 2 ; then
+  echo "Usage : " 1>&2
+  echo "> cmt_export.sh <Package> <file> [<prefix>]" 1>&2
+  exit 1
+fi
+
+package=$1
+file=$2
+
+if test $# = 3 ; then
+  prefix=$3
+else
+  prefix=
+fi
+
+echo "> cmt_export.sh ${package} ${file} ${prefix}"
+
+if test ${package} = "CMT/"; then
+  website=/www/Web/htdocs/cmtsite
+elif test ${package} = "CMT"; then
+  website=/www/Web/htdocs/cmtsite
+else
+  website=/www/Web/htdocs/html/SI/${package}
+fi
+
+if test "${FTPPATH}" = "" ; then
+  dest=${website}/${prefix}
+else
+  dest="${FTPPATH}"
+fi
+
+if test ! -d ${dest} ; then
+  mkdir -p ${dest}
+fi
+
+unset noclobber
+
+echo "> cp ${file} ${dest}"
+cp -R ${file} ${dest}
+##if test ! `pwd` = `(cd ${dest}; pwd)` ; then
+##  /bin/rm -f ${file}
+##fi
+
+
Index: /CMT/v1r20/mgr/cmt_filter3_version.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_filter3_version.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_filter3_version.sh	(revision 368)
@@ -0,0 +1,28 @@
+
+#--------------------------------------------------
+# Procedure to filter system version specifications
+#
+#   Input is received from stdin
+#   Output wll be sent to stdout
+#
+#   Input format
+#    <some letters>[-]<dot separated numeric fields>
+#
+#   Output format
+#    <some letters><field1><field2>
+#
+#   o only the first two numeric fields are kept
+#   o separators ('-' or '.') are all filtered out
+#
+#--------------------------------------------------
+
+read value
+
+c=`echo $value | sed -e 's#[-.0-9]##g'`
+v=`echo $value | \
+   sed -e 's#[^-.0-9]##g' -e 's#^[^0-9]##' -e 's#[-]#.#g' | \
+   cut -d '.' -f1-3 | \
+   sed -e 's#[-.]##g'`
+
+echo ${c}${v}
+
Index: /CMT/v1r20/mgr/cmt_filter_version.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_filter_version.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_filter_version.sh	(revision 368)
@@ -0,0 +1,28 @@
+
+#--------------------------------------------------
+# Procedure to filter system version specifications
+#
+#   Input is received from stdin
+#   Output wll be sent to stdout
+#
+#   Input format
+#    <some letters>[-]<dot separated numeric fields>
+#
+#   Output format
+#    <some letters><field1><field2>
+#
+#   o only the first two numeric fields are kept
+#   o separators ('-' or '.') are all filtered out
+#
+#--------------------------------------------------
+
+read value
+
+c=`echo $value | sed -e 's#[-.0-9]##g'`
+v=`echo $value | \
+   sed -e 's#[^-.0-9]##g' -e 's#^[^0-9]##' -e 's#[-]#.#g' | \
+   cut -d '.' -f1,2 | \
+   sed -e 's#[-.]##g'`
+
+echo ${c}${v}
+
Index: /CMT/v1r20/mgr/cmt_gcc_version.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_gcc_version.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_gcc_version.sh	(revision 368)
@@ -0,0 +1,6 @@
+
+gcc -v 2>&1 |\
+ grep version |\
+ cut -d ' ' -f3 |\
+ sed -e 's#^[0-9]#gcc-&#'
+
Index: /CMT/v1r20/mgr/cmt_genmakeos9.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_genmakeos9.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_genmakeos9.sh	(revision 368)
@@ -0,0 +1,433 @@
+
+#set -x
+#set -v
+#echo $*
+
+#--------------------------------------------------
+build_deps ()
+#--------------------------------------------------
+#  Build the dependency line.
+#
+#  Globals :
+#
+#    includes         list of -I<path> preprocessor options
+#    format_filter    sed commands for cleaning up the cpp output
+#    include_filter   sed commands for formatting include statements
+#
+#  Inputs :
+#
+#    file       Source file to apply
+#
+#  Output :
+#
+#    $(src)source $(inc)dep1 ...
+#
+#--------------------------------------------------
+{
+#
+#  $1 = source file
+#
+
+  if test -d ../src ; then
+    srcdir=../src
+  else
+    srcdir=./
+  fi
+
+  file=$1
+  shift
+
+  # echo "makedepend ${includes} ${srcdir}/${file}" >x$$
+
+  touch t$$
+  eval makedepend ${includes} ${srcdir}/${file} -ft$$
+
+  line=`cat t$$ | egrep -v '^#' | sed -e "$format_filter" -e "$include_filter"`
+
+  /bin/rm -f t$$*
+
+  line=`echo '$(src)'${file}; echo ${line}`
+
+  line=`echo ${line} | sed 's#$(inc)#$(src)#'`
+
+  echo $line
+}
+
+#--------------------------------------------------
+genmake_package ()
+#--------------------------------------------------
+{
+
+  if test -d ../src ; then
+    srcdir=../src
+  else
+    srcdir=./
+  fi
+
+  if test -d ../mgr ; then
+    mgrdir=../mgr/
+  else
+    mgrdir=`pwd`/
+  fi
+
+  if test -d ../include ; then
+    incdir=../include
+  else
+    if test -d ../src ; then
+      incdir=../src
+    else
+      incdir=./
+    fi
+  fi
+
+  if test "$is_executable" = 1 ; then
+    title='Executable'
+  else
+    title='Package'
+  fi
+
+  #---- Define output file. -----------------------------------------
+
+  package=$1
+  shift
+
+  if test "$#" = 0 ; then
+    sources=`(cd ../src; ls ${PACKTARGET}*.c)`
+  else
+    sources="$*"
+  fi
+
+  echo $title $PACKTARGET
+
+  #---- Prepare the use context. ------------------------------------
+
+  uses=`${CMTROOT}/mgr/cmt includes`
+
+  includes="-I${incdir} ${uses} ${PACKINCLUDES}"
+
+  # echo "includes = [" ${includes} "]"
+
+  #  Remove trailing back-slashes
+  #  Remove target
+  #  Substitute ../src/ and ../include/ by $(inc)
+
+  format_filter='s#\\##g
+s#[^:]*:##
+s#/usr/local/[^ ]*[ ]##g
+s#/usr/local/.*$##g
+s#/usr/include/[^ ]*[ ]##g
+s#/usr/include/.*$##g
+s#\.\./src/#$(inc)#g
+s#/src/#/OS9/#g'
+
+  # Substitute all "<path>/<package>/<version>/"
+  # by "$(<PACKAGE>ROOT)/"
+
+  include_filter=`${CMTROOT}/mgr/cmt filter_includes -quiet | sed 's#//#/#g'`
+
+  #
+  # Other initializations.
+  #
+
+  src='$(src)'
+  inc='$(inc)'
+  bin='$(bin)'
+  rels='$(rels)'
+  mgr='$(mgr)'
+
+  if test "$is_library" = 1 ; then
+    lib='$(lib)lib'${PACKTARGET}'.l'
+    libstamp='$('${PACKTARGET}'stamp)'
+    shlibstamp='$('${PACKTARGET}'shstamp)'
+  else
+    linkopts='$('${PACKTARGET}'linkopts)'
+    stamps='$('${PACKTARGET}'stamps)'
+  fi
+
+  unset ccs
+  unset CCs
+  unset yaccs
+  unset lexs
+  unset objs
+  unset protos
+  unset protonames
+  unset protostamps
+  unset cyaccs
+  unset clexs
+  unset os9sources
+  unset linkmacro
+  unset subdir
+
+  #
+  # Scan the sources.
+  #
+  
+  for file in $sources ; do
+    echo $file | grep '^-s='
+    if test "$?" = "0" ; then
+      subdir=`echo $file | sed -e 's#^-s=##' -e 's#[/]*$#/#'`
+    else
+      suffix=`echo $file | sed 's/^.*\.//'`
+      name=`echo $file | sed 's/\..*//'`
+      oname="$name"
+      
+      if test "$linkmacro" = "" ; then
+	if test "$suffix" = "f" ; then
+	  linkmacro='$(flink)'
+	elif test "$suffix" = "F" ; then
+	  linkmacro='$(flink)'
+	elif test "$suffix" = "c" ; then
+	  linkmacro='$(clink)'
+	elif test "$suffix" = "C" ; then
+	  linkmacro='$(cpplink)'
+	elif test "$suffix" = "cc" ; then
+	  linkmacro='$(cpplink)'
+	elif test "$suffix" = "cxx" ; then
+	  linkmacro='$(cpplink)'
+	else
+	  linkmacro='none'
+	fi
+      fi
+      
+      if test "$suffix" = "f" ; then
+	fs="$fs ${subdir}$file"
+      elif test "$suffix" = "F" ; then
+	fs="$fs ${subdir}$file"
+      elif test "$suffix" = "c" ; then
+	ccs="$ccs ${subdir}$file"
+      elif test "$suffix" = "C" ; then
+	CCs="$CCs ${subdir}$file"
+      elif test "$suffix" = "cc" ; then
+	CCs="$CCs ${subdir}$file"
+      elif test "$suffix" = "cxx" ; then
+	CCs="$CCs ${subdir}$file"
+      elif test "$suffix" = "y" ; then
+	yaccs="$yaccs ${subdir}$file"
+	name=`echo $name | sed 's/Parse$//'`
+	ccs="$ccs ${subdir}${name}Parse.c"
+	oname="${name}Parse"
+      elif test "$suffix" = "l" ; then
+	lexs="$lexs ${subdir}$file"
+	name=`echo $name | sed 's/Lex$//'`
+	ccs="$ccs ${subdir}${name}Lex.c"
+	oname="${name}Lex"
+      fi
+    
+      obj="${rels}${oname}.r"
+      
+      objs="$objs $obj"
+    fi
+
+  done
+
+  #-------------------------------------------
+  #
+  # Start the output.
+  #
+  #-------------------------------------------
+
+  d=`date`
+
+  cat <<END >$output
+
+#====================================
+#  $title $PACKTARGET
+#
+#   Generated $d  by $USER
+#
+#====================================
+  
+END
+
+  pobjs='$('${PACKTARGET}'OBJS)'
+
+  if test "$is_library" = 1 ; then
+
+    cat <<END >>${output}
+
+${PACKTARGET}OBJS = ${objs}
+
+${lib}: ${pobjs}
+ libgen -c -o=${lib} ${pobjs}
+ @echo ${PACKTARGET} : library ok
+
+END
+
+  else
+    
+    cat <<END >>${output}
+
+${PACKTARGET}OBJS = ${objs}
+
+\$(bin)${PACKTARGET}: ${pobjs}
+ cc \$(LINKFLAGS) -olM=8 \$(CFLAGS) -fd=\$@ \$?
+
+END
+
+  fi
+
+  if test ! "$ccs" = "" ; then                           # C targets
+    for file in $ccs ; do
+      if test -f ${srcdir}/${file} ; then
+	echo Source file $file
+	
+	line=`build_deps $file`
+
+	if test "$line" != "" ; then
+	  source=`echo $line | sed 's/[ ].*//'`
+	  suffix=`echo ${file} | sed 's/^.*\.//'`
+	  target=`basename $source ".${suffix}" | sed 's#$(src)##'`
+
+	  cat <<END >>$output
+
+\$(rels)${target}.r : ${line}
+ cc \$(CFLAGS) -e=as -fd=\$@ ${src}\$*.c
+
+END
+
+	fi
+
+	cat <<END >>$output
+
+END
+
+      else
+	echo "Warning : cannot build dependancies for file $file (not found)"
+      fi
+    done
+  fi
+
+  cat <<END >>$output
+
+END
+
+}
+
+#--------------------------------------------------
+usage ()
+#--------------------------------------------------
+{
+  echo "Usage :"
+  echo "> genmakeos9.sh <Package> [ options ] <source files> "
+  echo "     options : -I <include-path>"
+  echo "               -L <Library>"
+  echo "               -E <Executable>"
+}
+
+#--------------------------------------------------
+#main ()
+#--------------------------------------------------
+
+argcount=$# #
+
+if test $argcount = 0 ; then
+  usage
+  exit 0
+fi
+
+package=$1
+shift
+
+c=`echo "$package" | grep '^[-]'`
+
+if test "$c" = "$package" ; then
+  usage
+  exit 0
+fi
+
+unset PACKINCLUDES
+unset is_executable
+unset PACKOS9
+PACKTARGET=$package
+
+while test "$#" -gt 0 ; do
+
+  command=$1
+  c=`echo "$command" | grep '^[-]'`
+
+  if test "$c" = "$command" ; then
+    #
+    # Here we have a command (starting with -)
+    #
+    shift
+  else
+    #
+    # The first non-command argument terminates the parsing.
+    #
+    break
+  fi
+
+  if test "$command" = "-I" ; then
+    #
+    #   The include path is defined in the next argument.
+    #
+    include=$1
+    shift
+
+    PACKINCLUDES="$PACKINCLUDES -I$include"
+
+    unset include
+
+  elif test "$command" = "-L" ; then
+    is_library=1
+    is_executable=0
+    PACKTARGET=$1
+    shift
+  elif test "$command" = "-E" ; then
+    is_library=0
+    is_executable=1
+    PACKTARGET=$1
+    shift
+  elif test "$command" = "-OS9" ; then
+    PACKOS9=1
+  else
+    echo "Usage :"
+    echo "> genmakeos9.sh <Package> [ options ] <source files> "
+    echo "     options : -I <include-path>"
+    echo "               -L <Library>"
+    echo "               -E <Executable>"
+    exit 0
+  fi
+done
+
+#
+#  To get access to cpp
+#
+
+  system=`uname`
+  if test "$system" = "HP-UX" ; then
+    v=`uname -r | cut -d. -f2`
+    if test "$v" = 10 ; then
+      PATH=$PATH:/usr/ccs/lbin
+    else
+      PATH=$PATH:/lib
+    fi
+    unset v
+  elif test "$system" = "AIX" ; then
+    PATH=$PATH:/usr/ccs/lib
+  fi
+
+#---- Define old and output files. --------------------------------
+
+  if test -d ../mgr ; then
+    mgrdir=../mgr/
+  else
+    mgrdir=`pwd`/
+  fi
+
+  old=${mgrdir}${PACKTARGET}.os9make
+  backup=${old}sav
+  output=${old}new
+  
+  genmake_package $package $*
+
+#---- Complete the operation --------------------------------------
+
+  if test -r $old ; then
+    mv $old $backup
+  fi
+
+  mv $output $old
+
+
+
Index: /CMT/v1r20/mgr/cmt_install_action.bat
===================================================================
--- /CMT/v1r20/mgr/cmt_install_action.bat	(revision 368)
+++ /CMT/v1r20/mgr/cmt_install_action.bat	(revision 368)
@@ -0,0 +1,36 @@
+
+
+@echo off
+
+rem
+rem 1  absolute source directory
+rem 2  file name
+rem 3  absolute installation directory
+rem
+
+set source_dir=%1%
+set file_name=%2%
+set install_dir=%3%
+
+if "%source_dir%"=="" exit /B 0
+if "%file_name%"=="" exit /B 0
+if "%install_dir%"=="" exit /B 0
+
+set dest_file_path=%install_dir%\%file_name%
+set ref_file=%dest_file_path%.cmtref
+set full_source_name=%source_dir%\%file_name%
+
+if %install_dir%=="" exit /B 0
+
+if NOT exist %install_dir% mkdir %install_dir%
+
+if NOT exist %install_dir% echo "Cannot install file %file_name%, no installation directory specified" & exit /B 0
+
+echo Installing file %file_name% into %install_dir%
+
+if exist %dest_file_path% del %dest_file_path%
+
+if exist %ref_file% del %ref_file%
+
+copy /Y %full_source_name% %dest_file_path%
+echo %full_source_name% >%ref_file%
Index: /CMT/v1r20/mgr/cmt_install_action.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_install_action.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_install_action.sh	(revision 368)
@@ -0,0 +1,149 @@
+#!/bin/sh -f
+
+###set -x
+
+#------------------------------------------------------------------------------
+#
+# -source=1   absolute source directory
+# -name=2     file name
+# -out=3      absolute installation directory
+# -cmd=4      installation system command
+# -cmtpath=5  cmtpath of the package
+#
+#------------------------------------------------------------------------------
+
+source_dir=""
+file_name=""
+install_dir=""
+install_command=""
+cmtpath=""
+
+#handle_args $*
+#
+#------------------------------------------------------------------------------
+#handle_args ()
+#{
+  opt="-source"
+
+  while test "$#" -gt 0; do
+    arg=$1
+    shift
+
+    val=${arg}
+    
+    case ${arg} in
+      -*)
+        if echo $arg | grep '=' 2>&1 >/dev/null; then
+          opt=`echo ${arg} | sed -e 's#=.*##'`
+	  val=`echo ${arg} | sed -e 's#[^=]*=##'`
+	else
+	  opt=${arg}
+	  val=
+	  if test "$#" -gt 0; then
+	    val=$1
+	    shift
+	  fi
+	fi
+	;;
+    esac
+    
+    case ${opt} in
+      -source)
+	source_dir=${val};
+	opt="-name";
+	;;
+      -name)
+	file_name=${val};
+	opt="-out";
+	;;
+      -out)
+	install_dir=${val};
+	opt="-cmd";
+	;;
+      -cmd)
+	install_command=${val};
+	opt="-cmtpath";
+	;;
+      -cmtpath)
+	cmtpath=${val};
+	opt="";
+	;;
+      *)
+	;;
+    esac
+    
+  done
+    
+  if test "${source_dir}" = ""; then
+    echo "cmt_install_action.sh> no source directory"
+    exit 1
+  fi
+    
+  if test "${file_name}" = ""; then
+    echo "cmt_install_action.sh> no file name"
+    exit 1
+  fi
+    
+  if test "${install_dir}" = ""; then
+    echo "cmt_install_action.sh> no install dir"
+    exit 1
+  fi
+    
+  if test "${install_command}" = ""; then
+    echo "cmt_install_action.sh> no install command"
+    exit 1
+  fi
+    
+  if test "${cmtpath}" = ""; then
+    package=`cmt show macro_value package`
+    cmtpath=`cmt show macro_value ${package}_cmtpath`
+  fi
+
+  if test "${cmtpath}" = ""; then
+    echo "cmt_install_action.sh> no cmtpath"
+    exit 1
+  fi
+#}
+
+dest_file_path=${install_dir}/${file_name}
+ref_file=${dest_file_path}.cmtref
+full_source_name=${source_dir}/${file_name}
+
+if test "${cmtpath}" = "" ; then
+  echo "No installation directory specified"
+  exit 0
+fi
+
+b=`(cd ${cmtpath}; /bin/pwd)`
+a=`/bin/pwd | grep -e "${b}"`
+if test "${a}" = ""; then
+  echo "Current directory outside of the installation area. Cannot proceed"
+  exit 0
+fi
+
+if test "${install_dir}" = "" ; then
+  exit 0
+fi
+
+if test ! -d ${install_dir}; then
+  mkdir -p ${install_dir}
+fi
+
+if test ! -d ${install_dir}; then
+  echo "Cannot install file ${file_name}, no installation directory specified"
+  exit 0
+fi
+
+echo "Installing file ${file_name} into ${install_dir}"
+if test -L ${dest_file_path}; then
+  /bin/rm -f ${dest_file_path}
+elif test -f ${dest_file_path}; then
+  /bin/rm -f ${dest_file_path}
+fi
+
+if test -f ${ref_file}; then
+  /bin/rm -f ${ref_file}
+fi
+
+${install_command} ${full_source_name} ${dest_file_path}
+echo ${full_source_name} >${ref_file}
Index: /CMT/v1r20/mgr/cmt_installdir_action.bat
===================================================================
--- /CMT/v1r20/mgr/cmt_installdir_action.bat	(revision 368)
+++ /CMT/v1r20/mgr/cmt_installdir_action.bat	(revision 368)
@@ -0,0 +1,39 @@
+
+
+@echo off
+
+rem
+rem 1  absolute source directory
+rem 2  file name (a directory)
+rem 3  absolute installation directory
+rem 4  exclusion file
+rem
+
+set source_dir=%1%
+set dir_name=%2%
+set install_dir=%3%
+set exclusion_file=%4%
+
+set dest_file_path=%install_dir%\%dir_name%
+set ref_file=%dest_file_path%.cmtref
+set full_source_name=%source_dir%\%dir_name%
+
+if "%source_dir%"=="" exit /B 0
+if "%dir_name%"=="" exit /B 0
+if "%install_dir%"=="" exit /B 0
+
+if NOT exist "%full_source_name%" exit /B 0
+
+if NOT exist %install_dir% mkdir %install_dir%
+
+if NOT exist %install_dir% echo "Cannot install directory %dir_name%, no installation directory specified" & exit /B 0
+
+echo Installing directory %dir_name% into %install_dir%
+
+if exist %dest_file_path% rmdir /S/Q %dest_file_path%
+
+if exist %ref_file% del %ref_file%
+
+mkdir %dest_file_path% 
+xcopy /S/Y/Q/EXCLUDE:%exclude_file% %full_source_name% %dest_file_path%
+echo %full_source_name% >%ref_file%
Index: /CMT/v1r20/mgr/cmt_installdir_excludes.txt
===================================================================
--- /CMT/v1r20/mgr/cmt_installdir_excludes.txt	(revision 368)
+++ /CMT/v1r20/mgr/cmt_installdir_excludes.txt	(revision 368)
@@ -0,0 +1,1 @@
+\CVS\
Index: /CMT/v1r20/mgr/cmt_linux_version.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_linux_version.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_linux_version.sh	(revision 368)
@@ -0,0 +1,60 @@
+
+# Determine the Linux distribution and version that is being run.
+#
+
+# Check for GNU/Linux distributions
+if [ -f /etc/SuSE-release ]; then
+  DISTRIBUTION="suse"
+elif [ -f /etc/UnitedLinux-release ]; then
+  DISTRIBUTION="united"
+elif [ -f /etc/debian_version ]; then
+  DISTRIBUTION="debian"
+elif [ -f /etc/redhat-release ]; then
+  a=`grep -i 'red.*hat.*enterprise.*linux' /etc/redhat-release`
+  if test $? = 0; then
+    DISTRIBUTION=rhel
+  else
+    a=`grep -i 'red.*hat.*linux' /etc/redhat-release`
+    if test $? = 0; then
+      DISTRIBUTION=rh
+    else
+      a=`grep -i 'cern.*e.*linux' /etc/redhat-release`
+      if test $? = 0; then
+        DISTRIBUTION=cel
+      else
+        a=`grep -i 'scientific.*linux' /etc/redhat-release`
+        DISTRIBUTION="slc"
+      fi
+    fi
+  fi
+else
+  DISTRIBUTION="unknown"
+fi
+
+###    VERSION=`rpm -q redhat-release | sed -e 's#redhat[-]release[-]##'`
+
+case ${DISTRIBUTION} in
+rh|cel|rhel|slc)
+    VERSION=`cat /etc/redhat-release | sed -e 's#[^0-9]##g' -e 's#7[0-2]#73#'`
+    ;;
+debian)
+    VERSION=`cat /etc/debian_version`
+    if [ ${VERSION} = "testing/unstable" ]; then
+        # The debian testing/unstable version must be translated into
+        # a numeric version number, but no number makes sense so just
+        # remove the version all together.
+        VERSION=""
+    fi
+    ;;
+suse)
+    VERSION=`cat /etc/SuSE-release | grep 'VERSION' | sed  -e 's#[^0-9]##g'`
+    ;;
+united)
+    VERSION=`cat /etc/UnitedLinux-release`
+    ;;
+*)
+    VERSION='00'
+    ;;
+esac;
+
+echo ${DISTRIBUTION}${VERSION}
Index: /CMT/v1r20/mgr/cmt_make_cpp_shlib.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_make_cpp_shlib.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_make_cpp_shlib.sh	(revision 368)
@@ -0,0 +1,35 @@
+#!/bin/sh -f
+
+#set -x
+
+lib=$1
+
+if test `uname` = "HP-UX" ; then
+  /bin/rm -f lib${lib}.sl
+  
+  objs=`ls *.o`
+  if test ! "$objs" = "" ; then
+    /bin/rm -f *.o
+  fi
+  ar x ../lib${lib}.a
+  ld -b -o lib${lib}.sl *.o $2 -lc
+  /bin/rm -f *.o
+fi
+
+if test `uname` = "OSF1" ; then
+  /bin/rm -f lib${lib}.so
+  ld -shared -o lib${lib}.so -all ../lib${lib}.a $2 -lc -rpath `dirs`
+  cxx -Wl,shared,all -o lib${lib}.so ../lib${lib}.a $2 -lc -rpath `dirs`
+fi
+
+if test `uname` = "SunOS" ; then
+#  objs=`ls *.o`
+#  if test ! "$objs" = "" ; then
+#    /bin/rm -f *.o
+#  endif
+#  ar x ../lib${lib}.a
+#  $CILINK -o lib${lib}.so *.o $2 -lc
+#  /bin/rm -f *.o
+fi
+
+
Index: /CMT/v1r20/mgr/cmt_make_shlib.bat
===================================================================
--- /CMT/v1r20/mgr/cmt_make_shlib.bat	(revision 368)
+++ /CMT/v1r20/mgr/cmt_make_shlib.bat	(revision 368)
@@ -0,0 +1,71 @@
+
+
+@echo off
+
+rem #
+set bin=..\%1%
+set name=%2%
+
+if not exist %bin%\%name%.arc exit
+
+rem # Retreive other arguments in one "tmplinkopts" file :
+
+set tmplinkopts=%bin%\%name%\tmplinkopts.dat
+
+if exist %tmplinkopts% del %tmplinkopts% 
+
+shift 
+shift
+set empty=''
+
+:next
+set x='%1'
+IF %x% EQU %empty% goto end 
+echo %1 >> %tmplinkopts%
+shift
+goto next
+
+:end
+set empty=
+set x=
+
+set indirectlinkopts=
+if exist %tmplinkopts% set indirectlinkopts=@%tmplinkopts% 
+
+rem
+rem  Different detections for "component" libraries
+rem  this is not very clean in the sense that it is linked
+rem  to project-specific implementation.
+rem   We need to define a better way to specify that option 
+rem
+
+if exist %bin%\%name%\%name%_dll.obj goto component
+if exist %bin%\%name%\%name%_entries.obj goto componentnew
+
+:linker
+
+%CMTROOT%\%CMTBIN%\cmt.exe build windefs %bin%\%name%.arc >%bin%\%name%.def
+
+lib.exe /nologo /machine:ix86 /def:%bin%\%name%.def /out:%bin%\%name%.lib
+
+if exist %bin%\%name%.dll del %bin%\%name%.dll
+
+link.exe /nologo /dll /out:%bin%\%name%.dll %bin%\%name%.exp %bin%\%name%.arc %indirectlinkopts%
+
+goto return
+
+:component
+
+link.exe /nologo /dll /out:%bin%\%name%.dll %bin%\%name%\%name%_dll.obj %bin%\%name%.arc /machine:ix86 %indirectlinkopts%
+
+goto return
+ 
+:componentnew
+ 
+echo hello
+link.exe /nologo /dll /out:%bin%\%name%.dll %bin%\%name%\%name%_load.obj %bin%\%name%.arc /machine:ix86 %indirectlinkopts%
+
+:return
+if exist %tmplinkopts% del %tmplinkopts%
+set tmplinkopts=
+
Index: /CMT/v1r20/mgr/cmt_make_shlib.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_make_shlib.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_make_shlib.sh	(revision 368)
@@ -0,0 +1,77 @@
+#!/bin/sh -f
+
+#set -x
+
+lib=$1
+
+d=`/bin/pwd`
+a=`basename $d`
+if test "${a}" = "shlib" ; then
+  cd ..
+fi
+
+if test `uname` = "HP-UX" ; then
+  mkdir -p shlib
+  /bin/rm -f shlib/*
+
+  /bin/rm -f lib${lib}.sl
+  
+  cd shlib
+  ar x ../lib${lib}.a
+#####   ld -b -a shared -o ../lib${lib}.sl `ls` $2
+  aCC -Wl,-a,shared -b +Z -q -Wl,+s -Wl,+vallcompatwarnings -o ../lib${lib}.sl `ls` $2
+
+  cd ../
+
+  /bin/rm -rf shlib
+
+fi
+
+if test `uname` = "OSF1" ; then
+  /bin/rm -f lib${lib}.so
+  ld -expect_unresolved '*' -shared -o lib${lib}.so -all lib${lib}.a \
+    $2 -rpath `/bin/pwd`
+fi
+
+if test `uname` = "Linux" ; then
+  echo "BUILDING SHARED LIBRARY ${lib}"
+# ATTEMPT 2: temp for sharedlin force
+#   cp lib${lib}.a lib${lib}.so
+
+# ATTEMPT 1:
+#  mkdir -p tmpShlib
+#  cd tmpShlib
+#  /bin/rm -f lib${lib}.so
+#
+#  ld -shared -o lib${lib}.so --whole-archive ../lib${lib}.a $2 -rpath `/bin/pwd`
+#  mv lib${lib}.so ..
+#  cd ../
+#  /bin/rm -rf tmpShlib
+
+# ATTEMPT 3: (Time consummibg but seems to work...)
+# CMT should do this differently!!!!
+  /bin/rm -f lib${lib}.so
+  mkdir -p tmpShlib
+  cd tmpShlib
+  ar x ../lib${lib}.a
+
+#  ld -shared -o lib${lib}.so `ls` $2 -rpath `/bin/pwd`
+  g++ -shared `ls` $2 -o lib${lib}.so 
+  mv lib${lib}.so ..
+  cd ../
+  /bin/rm -rf tmpShlib
+
+fi
+
+if test `uname` = "SunOS" ; then
+  echo 'not yet implemented on SunOS'
+#  objs=`ls *.o`
+#  if test ! "$objs" = "" ; then
+#    /bin/rm -f *.o
+#  endif
+#  ar x ../lib${lib}.a
+#  $CILINK -o lib${lib}.so *.o $2 -lc
+#  /bin/rm -f *.o
+fi
+
+
Index: /CMT/v1r20/mgr/cmt_make_shlib_common.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_make_shlib_common.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_make_shlib_common.sh	(revision 368)
@@ -0,0 +1,89 @@
+#!/bin/sh
+
+#set -x
+
+#------------------------------------------------------
+#
+#  Syntax :
+#
+#  cmt_make_shlib_common.sh extract-arg package extra-args
+#
+#   with :
+#
+#      extract-arg  : either "extract" or "no_extract"
+#      package      : the current package name
+#      extra-args   : extra link options
+#
+#------------------------------------------------------
+
+extract=$1
+shift
+
+tag=$1
+shift
+
+lib=$1
+shift
+
+extra=$*
+
+here=`/bin/pwd`
+
+ld=`${CMTROOT}/mgr/cmt show macro_value shlibbuilder -tag=${tag}`
+ldflags=`${CMTROOT}/mgr/cmt show macro_value shlibflags -tag=${tag}`
+suffix=`${CMTROOT}/mgr/cmt show macro_value shlibsuffix -tag=${tag}`
+libprefix=`${CMTROOT}/mgr/cmt show macro_value library_prefix -tag=${tag}`
+libsuffix=`${CMTROOT}/mgr/cmt show macro_value library_suffix -tag=${tag}`
+
+if test "${ld}" = "" ; then
+  exit 1
+fi
+
+libname=${libprefix}${lib}${libsuffix}
+/bin/rm -f ${libname}.${suffix}
+
+result=0
+
+temp_shlib=${lib}temp_shlib
+
+if test ${extract} = "extract"; then
+  trap 'cd ${here}; /bin/rm -rf ${temp_shlib}; exit ${result}' 0 1 2 15
+
+  mkdir -p ${temp_shlib}
+  /bin/rm -f ${temp_shlib}/*
+
+  (cd ${temp_shlib}; ar x ../${libname}.a)
+
+  #
+  # Build a protected list of modules just extracted from
+  # the static library
+  #  Files containing space characters are accepted
+  #
+  modules=`ls -1 ${temp_shlib} | \
+           grep '[.]o$' | \
+           sed -e 's#^#'${temp_shlib}'/#' \
+               -e 's#^#"#g' \
+               -e 's#$#"#'`
+
+  if test "${QUIET}" = ""; then set -v; fi
+  eval ${ld} ${ldflags} -o ${libname}.${suffix} ${modules} ${extra}
+  result=$?
+
+  if test "${QUIET}" = ""; then set +v; fi
+
+  /bin/rm -rf ${temp_shlib}
+
+else
+
+  if test "${QUIET}" = ""; then set -v; fi
+
+  eval ${ld} ${ldflags} -all ${libname}.a -o ${libname}.${suffix} ${extra} -rpath `/bin/pwd`
+  result=$?
+
+  if test "${QUIET}" = ""; then set +v; fi
+
+fi
+
+
+
+
Index: /CMT/v1r20/mgr/cmt_mount_filter
===================================================================
--- /CMT/v1r20/mgr/cmt_mount_filter	(revision 368)
+++ /CMT/v1r20/mgr/cmt_mount_filter	(revision 368)
@@ -0,0 +1,7 @@
+/tmp_mnt/lal_prod/common /lal
+/tmp_mnt/users           /users
+/lal_prod/common         /lal
+/tmp_mnt/project         /project
+/tmp_mnt/                /
+/virgoa1_2/virgoApp      /virgoApp
+/tmp_mnt/exp/virgo       /exp/virgo
Index: /CMT/v1r20/mgr/cmt_os9tounix.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_os9tounix.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_os9tounix.sh	(revision 368)
@@ -0,0 +1,8 @@
+#!/bin/sh -f
+
+for f in $* ; do
+  name=`basename $f`
+  echo "Convert $f to $name" 1>&2
+  tr '\r' '\n' <$f >t$$; mv t$$ $name
+done
+
Index: /CMT/v1r20/mgr/cmt_remote
===================================================================
--- /CMT/v1r20/mgr/cmt_remote	(revision 368)
+++ /CMT/v1r20/mgr/cmt_remote	(revision 368)
@@ -0,0 +1,138 @@
+#!/bin/sh -f
+
+#-------------------------------------------------
+help ()
+#-------------------------------------------------
+{
+  echo "$1 [make | update] <package> <version> [<root>]"
+  echo ""
+  echo "    make   : rebuild the package"
+  echo "    update : cvs-update the package"
+}
+
+#--------------------------------------------------
+configure_which ()
+#--------------------------------------------------
+{
+  if test ! "${CMT_WHICH}" = "" ; then
+    which_cmd=${CMT_WHICH}; export which_cmd
+  else
+    which_cmd=`${CMTROOT}/mgr/cmt_which.sh; export which_cmd`
+    CMT_WHICH=${which_cmd}; export CMT_WHICH
+  fi
+}
+
+#--------------------------------------------------
+which_file ()
+#--------------------------------------------------
+{
+  ${which_cmd} $1 1>/dev/null 2>/dev/null
+  return $?
+}
+
+#-------------------------------------------------
+#  main ()
+#-------------------------------------------------
+
+p=`dirname $0`
+p=`dirname $p`
+
+if test "${p}" = "." ; then  # When $0 does not work
+  p=`find_file cmt`
+  p=`dirname $p`
+  p=`dirname $p`
+fi
+
+if test "${p}" = "." ; then  # When we are inside cmt
+  p=`pwd`
+  p=`dirname $p`
+fi
+
+CMTROOT=${p}; export CMTROOT
+
+configure_which
+
+test $# -lt 1
+if test "$?" = 0 ; then
+  help $0
+  exit 1
+fi
+
+command=$1
+shift
+
+root=`dirname $0`
+root=`dirname $root`
+cmtroot=$root
+
+if test ${cmtroot} = "." ; then
+  root=`pwd | sed 's#/tmp_mnt/lal_prod/common#/lal#'`
+  root=`dirname $root`
+  cmtroot=$root
+fi
+
+root=`dirname $root`
+root=`dirname $root`
+
+if test -d "/virgoApp" ; then
+  root=/virgoApp
+fi
+
+PATH=${PATH}:/usr/local1/bin
+
+package=$1
+version=$2
+ppath=$3
+
+if test "$ppath" = "" ; then
+  p=${root}/${package}/${version}/mgr
+else
+  c=`echo ${ppath} | sed 's#^[/].*#/#'`
+  if test "$c" = "/" ; then
+    p=${ppath}/${package}/${version}/mgr
+  else
+    p=${root}/${ppath}/${package}/${version}/mgr
+  fi
+fi
+
+cd $p
+
+if test "$?" = 1 ; then
+  echo "Bad path specification $p"
+  exit 1
+fi
+
+if test ! -f setup.csh ; then
+  ${cmtroot}/mgr/cmt config
+fi
+
+
+if test ${command} = "make" ; then
+
+  extra=
+  if test ${package} = "cmt" ; then
+    which_file gcc
+    if test "$?" = 1 ; then
+      extra="cc=cc"
+    fi
+  fi
+ 
+  csh -c "(source setup.csh; make ${extra})"
+
+else
+
+  if test ${command} = "update" ; then
+
+    cd ../
+    cvs update
+
+  else
+
+    help $0
+
+  fi
+
+fi
+
+
+
Index: /CMT/v1r20/mgr/cmt_system.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_system.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_system.sh	(revision 368)
@@ -0,0 +1,77 @@
+#!/bin/sh
+
+#--------------------------------------------------
+select_system ()
+#--------------------------------------------------
+{
+  if test ! "${UNAME}" = "" ; then
+    echo ${UNAME}
+    return 0
+  else
+    UNAME=`uname`
+  fi
+
+  may_use_afs=1
+
+  case ${UNAME} in
+    Darwin)
+      may_use_afs=0
+      ;;
+  esac
+
+  if test "${may_use_afs}" = 1; then
+    a=`fs sysname 2>/dev/null`
+    if test $? = 0 ; then
+      echo $a | \
+        sed -e "s#[ :]##g" \
+            -e "s#'# #g" \
+            -e "s#Currentsysnameis##" \
+            -e "s#Currentsysnamelistis##" | awk '{print $1}'
+          
+      return 0
+    fi
+  fi
+
+  case ${UNAME} in
+    LynxOS)
+	    echo `uname`-`uname -m`
+	    return 0
+	    ;;
+    Linux)
+	   echo `uname`-`uname -m`
+	   return 0
+	   ;;
+    Darwin)
+	   echo `uname`
+	   return 0
+	   ;;
+    CYGWIN*)
+	   echo `uname`
+	   return 0
+	   ;;
+    OSF1)
+	  if test `uname -r` = "V3.2" ; then
+	    echo alpha_v3
+	    return 0
+	  fi
+	  ;;
+    HP-UX)
+	   if test `uname -m` = "9000/780" ; then
+	     echo hp9000s780
+	     return 0
+	   elif test `uname -m` = "9000/735" ; then
+	     echo hp9000s735
+	     return 0
+	   fi
+	   ;;
+  esac
+
+  echo `uname -m`
+  return 0
+}
+
+#--------------------------------------------------
+# main ()
+#--------------------------------------------------
+
+select_system
Index: /CMT/v1r20/mgr/cmt_tar_export.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_tar_export.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_tar_export.sh	(revision 368)
@@ -0,0 +1,23 @@
+
+branches=$*
+
+if test "${branches}" = "" ; then
+  echo "No branch are specified to export"
+else
+  cd ..
+  root=`pwd`
+  version=`basename ${root}`
+  package=`dirname ${root}`
+  package=`basename ${package}`
+
+  if test ${package} = "CMT" ; then
+    prefix=`cmt version`/
+  fi
+
+  cd ../../
+  branches=`echo " "${branches} | sed -e "s%[ ]% ${package}/${version}/%g"`
+  tar cf ${package}/${package}${version}.tar ${branches}
+  gzip ${package}/${package}${version}.tar
+  ${CMTROOT}/mgr/cmt_export.sh ${package} ${package}/${package}${version}.tar.gz ${prefix}
+fi
+
Index: /CMT/v1r20/mgr/cmt_uninstall_action.bat
===================================================================
--- /CMT/v1r20/mgr/cmt_uninstall_action.bat	(revision 368)
+++ /CMT/v1r20/mgr/cmt_uninstall_action.bat	(revision 368)
@@ -0,0 +1,31 @@
+
+@echo off
+
+rem
+rem 1  absolute source directory
+rem 2  file name
+rem 3  absolute installation directory
+rem
+
+set source_dir=%1%
+set file_name=%2%
+set install_dir=%3%
+
+if "%source_dir%"=="" exit /B 0
+if "%file_name%"=="" exit /B 0
+if "%install_dir%"=="" exit /B 0
+
+set dest_file_path=%install_dir%\%file_name%
+set ref_file=%dest_file_path%.cmtref
+set full_source_name=%source_dir%\%file_name%
+
+cd %source_dir%
+
+if %install_dir%=="" exit /B 0
+
+if NOT exist %install_dir% echo "Cannot uninstall file %file_name%, no installation directory" & exit /B 0
+
+echo Removing file %file_name% from %install_dir%
+
+if exist %dest_file_path% del %dest_file_path%
+if exist %ref_file% del %ref_file%
Index: /CMT/v1r20/mgr/cmt_uninstall_action.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_uninstall_action.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_uninstall_action.sh	(revision 368)
@@ -0,0 +1,133 @@
+#!/bin/sh -f
+
+###set -x
+
+#------------------------------------------------------------------------------
+#
+# -source=1   absolute source directory
+# -name=2     file name
+# -out=3      absolute installation directory
+# -cmtpath=4  cmtpath of the package
+#
+#------------------------------------------------------------------------------
+
+source_dir=""
+file_name=""
+install_dir=""
+install_command=""
+cmtpath=""
+
+#handle_args $*
+#
+#------------------------------------------------------------------------------
+#handle_args ()
+#{
+  opt="-source"
+
+  while test "$#" -gt 0; do
+    arg=$1
+    shift
+
+    val=${arg}
+    
+    case ${arg} in
+      -*)
+        if echo $arg | grep '=' 2>&1 >/dev/null; then
+          opt=`echo ${arg} | sed -e 's#=.*##'`
+	  val=`echo ${arg} | sed -e 's#[^=]*=##'`
+	else
+	  opt=${arg}
+	  val=
+	  if test "$#" -gt 0; then
+	    val=$1
+	    shift
+	  fi
+	fi
+	;;
+    esac
+    
+    case ${opt} in
+      -source)
+	source_dir=${val};
+	opt="-name";
+	;;
+      -name)
+	file_name=${val};
+	opt="-out";
+	;;
+      -out)
+	install_dir=${val};
+	opt="-cmd";
+	;;
+      -cmd)
+	install_command=${val};
+	opt="-cmtpath";
+	;;
+      -cmtpath)
+	cmtpath=${val};
+	opt="";
+	;;
+      *)
+	;;
+    esac
+    
+  done
+    
+  if test "${source_dir}" = ""; then
+    echo "cmt_uninstall_action.sh> no source directory"
+    exit 1
+  fi
+    
+  if test "${file_name}" = ""; then
+    echo "cmt_uninstall_action.sh> no file name"
+    exit 1
+  fi
+    
+  if test "${install_dir}" = ""; then
+    echo "cmt_uninstall_action.sh> no install dir"
+    exit 1
+  fi
+
+  if test "${cmtpath}" = ""; then
+    package=`cmt show macro_value package`
+    cmtpath=`cmt show macro_value ${package}_cmtpath`
+  fi
+
+  if test "${cmtpath}" = ""; then
+    echo "cmt_uninstall_action.sh> no cmtpath"
+    exit 1
+  fi
+#}
+
+dest_file_path=${install_dir}/${file_name}
+ref_file=${dest_file_path}.cmtref
+full_source_name=${source_dir}/${file_name}
+
+b=`(cd ${cmtpath}; /bin/pwd)`
+a=`/bin/pwd | grep -e "${b}"`
+if test "${a}" = ""; then
+  echo "Current directory outside of the installation area. Cannot proceed"
+  exit 0
+fi
+
+if test "${install_dir}" = "" ; then
+  exit 0
+fi
+
+if test ! -d ${install_dir}; then
+  echo "Cannot uninstall file ${file_name}, no installation directory specified"
+  exit 0
+fi
+
+if test -d ${dest_file_path}; then
+  echo Removing directory ${file_name} from ${install_dir}
+  /bin/rm -rf ${dest_file_path}
+elif test -f ${dest_file_path}; then
+  echo Removing file ${file_name} from ${install_dir}
+  /bin/rm -f ${dest_file_path}
+fi
+
+if test -f ${ref_file}; then
+  /bin/rm -f ${ref_file}
+fi
+
Index: /CMT/v1r20/mgr/cmt_uninstalldir_action.bat
===================================================================
--- /CMT/v1r20/mgr/cmt_uninstalldir_action.bat	(revision 368)
+++ /CMT/v1r20/mgr/cmt_uninstalldir_action.bat	(revision 368)
@@ -0,0 +1,31 @@
+
+@echo off
+
+rem
+rem 1  absolute source directory
+rem 2  file name (a directory)
+rem 3  absolute installation directory
+rem
+
+set source_dir=%1%
+set dir_name=%2%
+set install_dir=%3%
+
+if "%source_dir%"=="" exit /B 0
+if "%dir_name%"=="" exit /B 0
+if "%install_dir%"=="" exit /B 0
+
+set dest_file_path=%install_dir%\%dir_name%
+set ref_file=%dest_file_path%.cmtref
+set full_source_name=%source_dir%\%dir_name%
+
+cd %source_dir%
+
+if %install_dir%=="" exit /B 0
+
+if NOT exist %install_dir% echo "Cannot uninstall directory %dir_name%, no installation directory" & exit /B 0
+
+echo Removing directory %dir_name% from %install_dir%
+
+if exist %dest_file_path% rmdir /S/Q %dest_file_path%
+if exist %ref_file% del %ref_file%
Index: /CMT/v1r20/mgr/cmt_unixtoos9.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_unixtoos9.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_unixtoos9.sh	(revision 368)
@@ -0,0 +1,21 @@
+#!/bin/sh -f
+
+for f in $* ; do
+  name=`basename $f`
+
+  tr '\n' '\r' <$f >t$$
+
+  if test -r $name ; then
+    diff t$$ $name >/dev/null 2>/dev/null
+    s=$?
+  else
+    s=1
+  fi
+
+  if test $s = "0" ; then
+    /bin/rm -f t$$
+  else
+    echo "Convert $f to $name"
+    mv t$$ $name
+  fi
+done
Index: /CMT/v1r20/mgr/cmt_unixtowin.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_unixtowin.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_unixtowin.sh	(revision 368)
@@ -0,0 +1,8 @@
+#!/bin/sh -f
+
+for f in $* ; do
+  name=`basename $f`
+  echo "Convert $f" 1>&2
+  awk '{ print $0"\015"; }' $f >t$$; mv t$$ $f
+done
+
Index: /CMT/v1r20/mgr/cmt_which.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_which.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_which.sh	(revision 368)
@@ -0,0 +1,34 @@
+#!/bin/sh
+
+if test ! "${CMT_WHICH}" = "" ; then
+  echo ${CMT_WHICH}
+  exit 0
+fi
+
+which cat 1>/dev/null 2>/dev/null
+yes="$?"
+which abcdefghijklmnopqrstuvwxyz 1>/dev/null 2>/dev/null
+no="$?"
+if test "${yes}" = 0 -a "${no}" = 0 ; then
+  type cat 1>/dev/null 2>/dev/null
+  yes="$?"
+  type abcdefghijklmnopqrstuvwxyz 1>/dev/null 2>/dev/null
+  no="$?"
+  if test "${yes}" = 0 -a "${no}" = 0 ; then
+    /usr/bin/type cat 1>/dev/null 2>/dev/null
+    yes="$?"
+    /usr/bin/type abcdefghijklmnopqrstuvwxyz 1>/dev/null 2>/dev/null
+    no="$?"
+    if test "${yes}" = 0 -a "${no}" = 0 ; then
+      exit 1
+    else
+      echo "/usr/bin/type"
+    fi
+  else
+    echo "type"
+  fi
+else
+  echo "which"
+fi
+
+exit 0
Index: /CMT/v1r20/mgr/cmt_wintounix.sh
===================================================================
--- /CMT/v1r20/mgr/cmt_wintounix.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmt_wintounix.sh	(revision 368)
@@ -0,0 +1,10 @@
+#!/bin/sh -f
+
+for f in $* ; do
+  echo "Convert $f" 1>&2
+  cat $f | \
+    sed -e 's#[ ]$#'__$$$$__'#' | \
+    tr '\r' ' ' | \
+    sed -e 's#[ ]$##' -e 's#'__$$$$__'$# #' >t$$; mv t$$ $f
+done
+
Index: /CMT/v1r20/mgr/cmtsh.sh
===================================================================
--- /CMT/v1r20/mgr/cmtsh.sh	(revision 368)
+++ /CMT/v1r20/mgr/cmtsh.sh	(revision 368)
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+. /lal/CMT/v1r4p20000328/mgr/setup.sh
+
+echo $CLASSPATH
+
+J2SDKBIN=/usr/opt/java122/bin; export J2SDKBIN
+
+PATH=${J2SDKBIN}:${PATH}; export PATH
+
+java cmt_parser
+
+trap "break" 0 1 2 15
+
+while test 1 ; do
+  read a
+  echo $a
+done
+
+
Index: /CMT/v1r20/mgr/fragments/application
===================================================================
--- /CMT/v1r20/mgr/fragments/application	(revision 368)
+++ /CMT/v1r20/mgr/fragments/application	(revision 368)
@@ -0,0 +1,49 @@
+#-- start of application
+
+$(bin)${CONSTITUENT}${application_suffix} :: ${OBJS} $(use_stamps) $(${CONSTITUENT}stamps) requirements $(use_requirements)
+	$(link_echo) $@
+	$(link_silent) cd $(bin); ${LINKMACRO} -o ${CONSTITUENT}.exe.new ${OBJS} $(use_linkopts) $(${CONSTITUENT}linkopts); mv -f ${CONSTITUENT}.exe.new ${CONSTITUENT}${application_suffix}
+
+#-----------------------------------------------------------------
+#
+#  New section for automatic installation
+#
+#-----------------------------------------------------------------
+
+install_dir = ${CMTINSTALLAREA}/$(tag)/bin
+${CONSTITUENT}installname = ${CONSTITUENT}${application_suffix}
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then\
+	  echo "installation done"; \
+	fi
+
+$(install_dir)/$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_install_action) \
+	    -source "`(cd $(bin); pwd)`" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmd "$(cmt_installarea_command)" \
+	    -cmtpath "$($(package)_cmtpath)"; \
+	fi
+
+##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@echo "------> (${CONSTITUENT}.make) Removing installed files"
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_uninstall_action) \
+	    -source "`(cd $(bin); pwd)`" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmtpath "$($(package)_cmtpath)"; \
+	fi
+
+#-- end of application
Index: /CMT/v1r20/mgr/fragments/application_header
===================================================================
--- /CMT/v1r20/mgr/fragments/application_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/application_header	(revision 368)
@@ -0,0 +1,6 @@
+#-- start of application_header
+
+${CONSTITUENT} :: dirs ${PROTOTARGET} $(bin)${CONSTITUENT}${application_suffix}
+	@/bin/echo "------> ${CONSTITUENT} ok"
+
+#-- end of application_header
Index: /CMT/v1r20/mgr/fragments/application_launcher
===================================================================
--- /CMT/v1r20/mgr/fragments/application_launcher	(revision 368)
+++ /CMT/v1r20/mgr/fragments/application_launcher	(revision 368)
@@ -0,0 +1,10 @@
+#-- start of application_launcher
+
+${CONSTITUENT} ::
+	cd $(bin); \
+	  ${${CONSTITUENT}_pre_check}; \
+	  ${FULLNAME} ${${CONSTITUENT}_check_args}; \
+	  ${${CONSTITUENT}_post_check}
+
+
+#-- end of application_launcher
Index: /CMT/v1r20/mgr/fragments/application_launcher_header
===================================================================
--- /CMT/v1r20/mgr/fragments/application_launcher_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/application_launcher_header	(revision 368)
@@ -0,0 +1,1 @@
+
Index: /CMT/v1r20/mgr/fragments/application_launcher_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/application_launcher_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/application_launcher_trailer	(revision 368)
@@ -0,0 +1,1 @@
+
Index: /CMT/v1r20/mgr/fragments/buildproto
===================================================================
--- /CMT/v1r20/mgr/fragments/buildproto	(revision 368)
+++ /CMT/v1r20/mgr/fragments/buildproto	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of buildproto
+
+$(inc)${NAME}.pp : ${FILEPATH}${FILENAME}
+	@echo "Now rebuilding $@"
+	@cd $(inc); $(build_prototype) ${FILEPATH}${FILENAME} >/dev/null
+	@cat /dev/null >$(inc)${NAME}.pp
+
+#-- end of buildproto
Index: /CMT/v1r20/mgr/fragments/c
===================================================================
--- /CMT/v1r20/mgr/fragments/c	(revision 368)
+++ /CMT/v1r20/mgr/fragments/c	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of c ------
+
+$(bin)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(c_echo) $@
+	$(c_silent) cd $(bin); $(ccomp) -o ${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(app_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(app_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of c ------
Index: /CMT/v1r20/mgr/fragments/c_library
===================================================================
--- /CMT/v1r20/mgr/fragments/c_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/c_library	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of c_library ------
+
+$(bin)$(binobj)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(c_echo) $@
+	$(c_silent) cd $(bin); $(ccomp) -o $(binobj)${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(lib_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(lib_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of c_library ------
Index: /CMT/v1r20/mgr/fragments/check_application
===================================================================
--- /CMT/v1r20/mgr/fragments/check_application	(revision 368)
+++ /CMT/v1r20/mgr/fragments/check_application	(revision 368)
@@ -0,0 +1,9 @@
+#-- start of check_application ------
+
+check :: ${CONSTITUENT}check
+
+${CONSTITUENT}check :: ${CONSTITUENT}
+	cd $(bin); $(${CONSTITUENT}_pre_check)
+	cd $(bin); ${CONSTITUENT}${application_suffix} $(${CONSTITUENT}_check_args)
+	cd $(bin); $(${CONSTITUENT}_post_check)
+#-- end of check_application ------
Index: /CMT/v1r20/mgr/fragments/check_application_header
===================================================================
--- /CMT/v1r20/mgr/fragments/check_application_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/check_application_header	(revision 368)
@@ -0,0 +1,10 @@
+#-- start of check_application_header ------
+
+check :: ${CONSTITUENT}check
+	@echo "------> ${CONSTITUENT}check ok"
+
+${CONSTITUENT}check ::
+	@echo "------> starting ${CONSTITUENT}check"
+	@$(cmtexe) -quiet build constituent_makefile ${CONSTITUENT}; $(MAKE) -f ${CONSTITUENT}.make build_strategy=keep_makefiles ${CONSTITUENT}check
+
+#-- end of check_application_header ------
Index: /CMT/v1r20/mgr/fragments/check_java
===================================================================
--- /CMT/v1r20/mgr/fragments/check_java	(revision 368)
+++ /CMT/v1r20/mgr/fragments/check_java	(revision 368)
@@ -0,0 +1,9 @@
+#-- start of check_java ------
+
+check :: ${CONSTITUENT}check
+
+${CONSTITUENT}check :: ${CONSTITUENT}
+	cd $(bin); $(${CONSTITUENT}_pre_check)
+	cd $(bin); java $(java_run_options) $(${CONSTITUENT}_run_options) ${CONSTITUENT} $(${CONSTITUENT}_check_args)
+	cd $(bin); $(${CONSTITUENT}_post_check)
+#-- end of check_java ------
Index: /CMT/v1r20/mgr/fragments/cleanup
===================================================================
--- /CMT/v1r20/mgr/fragments/cleanup	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cleanup	(revision 368)
@@ -0,0 +1,4 @@
+#-- start of cleanup ------
+	-$(cleanup_echo) ${FULLNAME}
+	-$(cleanup_silent) cd $(src); /bin/rm -f ${FULLNAME}
+#-- end of cleanup ------
Index: /CMT/v1r20/mgr/fragments/cleanup_application
===================================================================
--- /CMT/v1r20/mgr/fragments/cleanup_application	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cleanup_application	(revision 368)
@@ -0,0 +1,5 @@
+#-- start of cleanup_application ------
+	@echo "------> (${CONSTITUENT}.make) Removing application files"
+	-$(cleanup_echo) ${CONSTITUENT}${application_suffix}
+	-@cd $(bin); /bin/rm -f ${CONSTITUENT}${application_suffix}
+#-- end of cleanup_application ------
Index: /CMT/v1r20/mgr/fragments/cleanup_header
===================================================================
--- /CMT/v1r20/mgr/fragments/cleanup_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cleanup_header	(revision 368)
@@ -0,0 +1,18 @@
+#-- start of cleanup_header --------------
+
+clean :: ${CONSTITUENT}clean
+	@cd .
+
+ifndef PEDANTIC
+.DEFAULT::
+	@echo "WARNING >> You should provide a target for $@"
+else
+.DEFAULT::
+	@echo "PEDANTIC MODE >> You should provide a target for $@"
+	@if test `expr index $@ '.'` != 0 ; \
+	then  echo "PEDANTIC MODE >> This target seems to be a missing file, please check"; exit -1 ;\
+	else echo "PEDANTIC MODE >> Just ignore it ; as it seems to be just a fake target due to some pattern" ; exit 0; fi; 		
+endif
+
+${CONSTITUENT}clean ::
+#-- end of cleanup_header ---------------
Index: /CMT/v1r20/mgr/fragments/cleanup_java
===================================================================
--- /CMT/v1r20/mgr/fragments/cleanup_java	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cleanup_java	(revision 368)
@@ -0,0 +1,4 @@
+#-- start of cleanup_java ------
+	-$(cleanup_echo) ${OBJS}
+	-$(cleanup_silent) cd $(javabin); /bin/rm -f ${OBJS}
+#-- end of cleanup_java ------
Index: /CMT/v1r20/mgr/fragments/cleanup_library
===================================================================
--- /CMT/v1r20/mgr/fragments/cleanup_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cleanup_library	(revision 368)
@@ -0,0 +1,5 @@
+#-- start of cleanup_library -------------
+	$(cleanup_echo) library
+	-$(cleanup_silent) cd $(bin); /bin/rm -f $(binobj)$(library_prefix)${CONSTITUENT}$(library_suffix).a $(binobj)$(library_prefix)${CONSTITUENT}$(library_suffix).s? $(binobj)${CONSTITUENT}.stamp $(binobj)${CONSTITUENT}.shstamp
+#-- end of cleanup_library ---------------
+
Index: /CMT/v1r20/mgr/fragments/cleanup_objects
===================================================================
--- /CMT/v1r20/mgr/fragments/cleanup_objects	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cleanup_objects	(revision 368)
@@ -0,0 +1,5 @@
+#-- start of cleanup_objects ------
+	$(cleanup_echo) objects
+	-$(cleanup_silent) cd $(bin); /bin/rm -f ${OBJS}
+	-$(cleanup_silent) cd $(bin); /bin/rm -rf ${CONSTITUENT}_deps ${CONSTITUENT}_dependencies.make
+#-- end of cleanup_objects ------
Index: /CMT/v1r20/mgr/fragments/cmt_action_runner
===================================================================
--- /CMT/v1r20/mgr/fragments/cmt_action_runner	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cmt_action_runner	(revision 368)
@@ -0,0 +1,2 @@
+#-- start of cmt_action_runner ----------------------
+#-- end of cmt_action_runner ------------------------
Index: /CMT/v1r20/mgr/fragments/cmt_action_runner_header
===================================================================
--- /CMT/v1r20/mgr/fragments/cmt_action_runner_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cmt_action_runner_header	(revision 368)
@@ -0,0 +1,31 @@
+#-- start of cmt_action_runner_header ---------------
+
+ifdef ONCE
+${CONSTITUENT}_once = 1
+endif
+
+ifdef ${CONSTITUENT}_once
+
+${CONSTITUENT}actionstamp = ${CONSTITUENT}.actionstamp
+
+${CONSTITUENT} :: $(${CONSTITUENT}actionstamp)
+	@echo ${CONSTITUENT} ok
+
+$(${CONSTITUENT}actionstamp) :: $(${CONSTITUENT}_dependencies)
+	$(silent) ${action_value}
+	@echo ok > $(${CONSTITUENT}actionstamp)
+
+${CONSTITUENT}clean ::
+	@/bin/rm -f $(${CONSTITUENT}actionstamp)
+
+else
+
+${CONSTITUENT} :: $(${CONSTITUENT}_dependencies)
+	$(silent) $(action_value)
+
+endif
+
+install ::
+uninstall ::
+
+#-- end of cmt_action_runner_header -----------------
Index: /CMT/v1r20/mgr/fragments/constituent
===================================================================
--- /CMT/v1r20/mgr/fragments/constituent	(revision 368)
+++ /CMT/v1r20/mgr/fragments/constituent	(revision 368)
@@ -0,0 +1,85 @@
+#-- start of constituent ------
+
+cmt_${CONSTITUENT}_${HASTARGETTAG} = 1
+
+#--------------------------------------------------------
+
+ifdef cmt_${CONSTITUENT}_has_target_tag
+
+ifdef READONLY
+cmt_local_tagfile_${CONSTITUENT} = /tmp/CMT_$(${PACKAGE}_tag)_${CONSTITUENT}.make$(cmt_lock_pid)
+cmt_final_setup_${CONSTITUENT} = /tmp/CMT_${PACKAGE}_${CONSTITUENT}setup.make
+cmt_local_${CONSTITUENT}_makefile = /tmp/CMT_${CONSTITUENT}$(cmt_lock_pid).make
+else
+cmt_local_tagfile_${CONSTITUENT} = $(${PACKAGE}_tag)_${CONSTITUENT}.make
+cmt_final_setup_${CONSTITUENT} = $(bin)${PACKAGE}_${CONSTITUENT}setup.make
+cmt_local_${CONSTITUENT}_makefile = $(bin)${CONSTITUENT}.make
+endif
+
+${CONSTITUENT}_extratags = -tag_add=target_${CONSTITUENT}
+
+$(cmt_local_tagfile_${CONSTITUENT}) : $(cmt_lock_setup)
+	@/bin/echo "------> (constituents.make) Rebuilding setup.make $(cmt_local_tagfile_${CONSTITUENT})"
+	@if test -f $(cmt_local_tagfile_${CONSTITUENT}); then /bin/rm -f $(cmt_local_tagfile_${CONSTITUENT}); fi ; \
+	  $(cmtexe) -quiet -tag=$(tags) $(${CONSTITUENT}_extratags) build tag_makefile >>$(cmt_local_tagfile_${CONSTITUENT}); \
+	  if test -f $(cmt_final_setup_${CONSTITUENT}); then /bin/rm -f $(cmt_final_setup_${CONSTITUENT}); fi; \
+	  $(cmtexe) -quiet -tag=$(tags) $(${CONSTITUENT}_extratags) show setup >>$(cmt_final_setup_${CONSTITUENT})
+	@/bin/echo setup.make ok
+
+else
+
+ifdef READONLY
+cmt_local_tagfile_${CONSTITUENT} = /tmp/CMT_$(${PACKAGE}_tag).make$(cmt_lock_pid)
+cmt_final_setup_${CONSTITUENT} = /tmp/CMT_${PACKAGE}setup.make
+cmt_local_${CONSTITUENT}_makefile = /tmp/CMT_${CONSTITUENT}$(cmt_lock_pid).make
+else
+cmt_local_tagfile_${CONSTITUENT} = $(${PACKAGE}_tag).make
+cmt_final_setup_${CONSTITUENT} = $(bin)${PACKAGE}setup.make
+cmt_local_${CONSTITUENT}_makefile = $(bin)${CONSTITUENT}.make
+endif
+
+endif
+
+$(cmt_local_${CONSTITUENT}_makefile) :: $(${CONSTITUENT}_dependencies) $(cmt_local_tagfile_${CONSTITUENT}) build_library_links dirs
+	@echo "------> (constituents.make) Building ${CONSTITUENT}.make"; \
+	  $(cmtexe) -quiet -tag=$(tags) $(${CONSTITUENT}_extratags) build constituent_makefile ${CONSTITUENT} ; \
+	  if test ! "$(bin)" = "./"; then /bin/mv -f ${CONSTITUENT}.make $(cmt_local_${CONSTITUENT}_makefile); fi
+
+${CONSTITUENT} :: $(${CONSTITUENT}_dependencies) $(cmt_local_${CONSTITUENT}_makefile)
+	@echo "------> (constituents.make) Starting ${CONSTITUENT}"
+	@$(MAKE) -f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) cmt_lock_pid=$${cmt_lock_pid} ${CONSTITUENT}
+	@echo "------> (constituents.make) ${CONSTITUENT} done"
+
+clean :: ${CONSTITUENT}clean
+
+${CONSTITUENT}clean :: $(${CONSTITUENT}clean_dependencies) ##$(cmt_local_${CONSTITUENT}_makefile)
+	@-if test -f $(cmt_local_${CONSTITUENT}_makefile); then \
+	  echo "------> (constituents.make) Starting ${CONSTITUENT}clean"; \
+	  $(MAKE) -f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) cmt_lock_pid=$${cmt_lock_pid} ${CONSTITUENT}clean; \
+	fi
+
+##	  /bin/rm -f $(cmt_local_${CONSTITUENT}_makefile) $(bin)${CONSTITUENT}_dependencies.make
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(${CONSTITUENT}_dependencies) $(cmt_local_${CONSTITUENT}_makefile)
+	@echo "------> (constituents.make) Starting install ${CONSTITUENT}"
+	@-$(MAKE) -f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) cmt_lock_pid=$${cmt_lock_pid} install
+	@echo "------> (constituents.make) install ${CONSTITUENT} done"
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall :: $(cmt_local_${CONSTITUENT}_makefile)
+	@echo "------> (constituents.make) Starting uninstall ${CONSTITUENT}"
+	@-$(MAKE) -f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) cmt_lock_pid=$${cmt_lock_pid} uninstall
+	@echo "------> (constituents.make) uninstall ${CONSTITUENT} done"
+
+ifndef PEDANTIC
+.DEFAULT::
+	@echo "------> (constituents.make) Starting $@ ${CONSTITUENT}"
+	@echo Using default action for $@
+	@echo "------> (constituents.make) $@ ${CONSTITUENT} done"
+endif
+
+
+#-- end of constituent ------
Index: /CMT/v1r20/mgr/fragments/constituents_header
===================================================================
--- /CMT/v1r20/mgr/fragments/constituents_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/constituents_header	(revision 368)
@@ -0,0 +1,95 @@
+
+#-- start of constituents_header ------
+
+include ${CMTROOT}/src/Makefile.core
+
+ifdef tag
+CMTEXTRATAGS = $(tag)
+else
+tag       = $(CMTCONFIG)
+endif
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+${PACKAGE}_tag = $(tag)
+
+ifdef READONLY
+cmt_local_tagfile = /tmp/CMT_$(${PACKAGE}_tag).make$(cmt_lock_pid)
+else
+cmt_local_tagfile = $(${PACKAGE}_tag).make
+endif
+
+-include $(cmt_local_tagfile)
+
+ifdef READONLY
+cmt_local_setup = /tmp/CMT_${PACKAGE}setup$(cmt_lock_pid).make
+cmt_final_setup = /tmp/CMT_${PACKAGE}setup.make
+else
+cmt_local_setup = $(bin)${PACKAGE}setup$(cmt_lock_pid).make
+cmt_final_setup = $(bin)${PACKAGE}setup.make
+endif
+
+#--------------------------------------------------------
+
+cmt_lock_setup = /tmp/lock$(cmt_lock_pid).make
+cmt_temp_tag = /tmp/tag$(cmt_lock_pid).make
+
+first :: $(cmt_local_tagfile)
+	@echo $(cmt_local_tagfile) ok
+
+##	@bin=`$(cmtexe) -quiet show macro_value bin`
+
+$(cmt_local_tagfile) : $(cmt_lock_setup)
+	@/bin/echo "------> (constituents.make) Rebuilding setup.make $(cmt_local_tagfile)"
+	@if test -f $(cmt_local_tagfile); then /bin/rm -f $(cmt_local_tagfile); fi
+	@$(cmtexe) -quiet -tag=$(tags) build tag_makefile >$(cmt_temp_tag)
+	@mv $(cmt_temp_tag) $(cmt_local_tagfile)
+	@bin=$(bin); \
+	  if test ! -d $${bin} ; then $(mkdir) -p $${bin} ; fi; \
+	  echo CMTCONFIG=$(CMTCONFIG); \
+	  if test -f $(cmt_local_setup); then /bin/rm -f $(cmt_local_setup); fi; \
+	  cmt_local_setup=$${bin}${PACKAGE}setup$(cmt_lock_pid).make; \
+	  cmt_final_setup=$${bin}${PACKAGE}setup.make; \
+	  trap '/bin/rm -f $${cmt_local_setup}' 0 1 2 15; \
+	  $(cmtexe) -quiet -tag=$(tags) show setup >>$${cmt_local_setup}; \
+	  if test ! -f $${cmt_final_setup}; then \
+	    mv $${cmt_local_setup} $${cmt_final_setup}; \
+	  else \
+	    if /usr/bin/diff $${cmt_local_setup} $${cmt_final_setup} >/dev/null ; then \
+	      echo "$${cmt_final_setup} untouched "; \
+	    else \
+	      mv $${cmt_local_setup} $${cmt_final_setup}; \
+	    fi; \
+	  fi
+	@/bin/echo setup.make ok   
+config :: checkuses
+	@exit 0
+
+env.make ::
+	printenv >env.make.tmp; $(cmtexe) -quiet check files env.make.tmp env.make
+
+all :: build_library_links
+	@echo "------> (constituents.make) all done"
+
+javadirs ::
+	@if test ! -d $(javabin) ; then $(mkdir) -p $(javabin) ; fi
+
+srcdirs ::
+	@if test ! -d $(src) ; then $(mkdir) -p $(src) ; fi
+
+dirs ::
+	@if test ! -r requirements ; then echo "No requirements file" ; fi; \
+	  if test ! -d $(bin) ; then $(mkdir) -p $(bin) ; fi
+
+build_library_links : dirs requirements
+	@echo "------> (constituents.make) Rebuilding library links"; \
+	if test ! -d $(bin) ; then $(mkdir) -p $(bin) ; fi; \
+	$(build_library_links)
+
+.DEFAULT ::
+	@if test "$@" = "$(cmt_lock_setup)"; then \
+	  /bin/rm -f $(cmt_lock_setup); \
+	  touch $(cmt_lock_setup); \
+	fi
+
+#-- end of constituents_header ------
Index: /CMT/v1r20/mgr/fragments/constituents_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/constituents_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/constituents_trailer	(revision 368)
@@ -0,0 +1,23 @@
+#-- start of constituents_trailer ------
+
+clean :: remove_library_links
+
+remove_library_links ::
+	@echo "Removing library links"; \
+	  $(remove_library_links); \
+
+makefilesclean ::
+
+###	@/bin/rm -f checkuses
+
+###	/bin/rm -f *.make*
+
+clean :: makefilesclean
+
+binclean :: clean
+	@if test ! "$(bin)" = "./"; then \
+	  echo "Removing binary directory $(bin)"
+	  /bin/rm -rf $(bin); \
+	fi
+
+#-- end of constituents_trailer ------
Index: /CMT/v1r20/mgr/fragments/cpp
===================================================================
--- /CMT/v1r20/mgr/fragments/cpp	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cpp	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of cpp ------
+
+$(bin)$(binobj)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o $(binobj)${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cppflags) $(${CONSTITUENT}_pp_cppflags) $(app_${CONSTITUENT}_pp_cppflags) $(${NAME}_pp_cppflags) $(use_cppflags) $(${CONSTITUENT}_cppflags) $(app_${CONSTITUENT}_cppflags) $(${NAME}_cppflags) $(${NAME}_${FILESUFFIX}_cppflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of cpp ------
Index: /CMT/v1r20/mgr/fragments/cpp_library
===================================================================
--- /CMT/v1r20/mgr/fragments/cpp_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/cpp_library	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of cpp_library -----------------
+#
+$(bin)$(binobj)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(cpp_echo) $@
+	$(cpp_silent) cd $(bin); $(cppcomp) -o $(binobj)${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cppflags) $(${CONSTITUENT}_pp_cppflags) $(lib_${CONSTITUENT}_pp_cppflags) $(${NAME}_pp_cppflags) $(use_cppflags) $(${CONSTITUENT}_cppflags) $(lib_${CONSTITUENT}_cppflags) $(${NAME}_cppflags) $(${NAME}_${FILESUFFIX}_cppflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of cpp_library ------------------
Index: /CMT/v1r20/mgr/fragments/dependencies
===================================================================
--- /CMT/v1r20/mgr/fragments/dependencies	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dependencies	(revision 368)
@@ -0,0 +1,16 @@
+#-- start of dependency ------------------
+
+$(bin)${CONSTITUENT}_dependencies.make :: dirs
+
+ifndef QUICK
+$(bin)${CONSTITUENT}_dependencies.make :: ${LINE} requirements $(use_requirements) $(cmt_final_setup_${CONSTITUENT})
+	@echo "------> (${CONSTITUENT}.make) Rebuilding $@"; \
+	  args=`echo $? | sed -e "s#requirements.*##"`; \
+	  $(build_dependencies) ${CONSTITUENT} -all_sources $${args}
+endif
+
+#$(${CONSTITUENT}_dependencies)
+
+-include $(bin)${CONSTITUENT}_dependencies.make
+
+#-- end of dependency -------------------
Index: /CMT/v1r20/mgr/fragments/dependencies_and_triggers
===================================================================
--- /CMT/v1r20/mgr/fragments/dependencies_and_triggers	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dependencies_and_triggers	(revision 368)
@@ -0,0 +1,12 @@
+#-- start of dependencies_and_triggers ------
+
+${CONSTITUENT}_dependencies.make : ${LINE} cmt_path.make requirements $(use_requirements)
+	@echo "Rebuilding $@"
+	@$(build_dependencies) ${CONSTITUENT} $?
+	@echo "Rebuilding trigger file"
+	@$(build_triggers) ${CONSTITUENT} >${CONSTITUENT}.triggers
+
+-include ${CONSTITUENT}_dependencies.make
+
+
+#-- end of dependencies_and_triggers ------
Index: /CMT/v1r20/mgr/fragments/document_header
===================================================================
--- /CMT/v1r20/mgr/fragments/document_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/document_header	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of document_header ------
+
+${CONSTITUENT}_output = $(doc)
+
+${CONSTITUENT} :: ${OBJS}
+	@/bin/echo "------> ${CONSTITUENT} ok"
+
+#-- end of document_header ------
Index: /CMT/v1r20/mgr/fragments/dsp_all
===================================================================
--- /CMT/v1r20/mgr/fragments/dsp_all	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsp_all	(revision 368)
@@ -0,0 +1,52 @@
+# Microsoft Developer Studio Project File - Name="all" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Generic Project" 0x010a
+
+CFG=all - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "all.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "all.mak" CFG="all - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "all - Win32 Debug" (based on "Win32 (x86) Generic Project")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+MTL=midl.exe
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "..\$(tag)"
+# PROP BASE Intermediate_Dir "..\$(tag)"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\$(tag)"
+# PROP Intermediate_Dir "..\$(tag)"
+# PROP Target_Dir ""
+
+# Begin Target
+
+# Name "all - Win32 Debug"
+# Begin Group "cmt"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\$(mgrdir)\requirements
+# End Source File
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/mgr/fragments/dsp_application_header
===================================================================
--- /CMT/v1r20/mgr/fragments/dsp_application_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsp_application_header	(revision 368)
@@ -0,0 +1,62 @@
+# Microsoft Developer Studio Project File - Name="${CONSTITUENT}" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=${CONSTITUENT} - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "${CONSTITUENT}.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "${CONSTITUENT}.mak" CFG="${CONSTITUENT} - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "${CONSTITUENT} - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+F90=df.exe
+MTL=midl.exe
+RSC=rc.exe
+
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Intermediate_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP Intermediate_Dir "..\$(${PACKAGE}_tag)\${CONSTITUENT}"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE F90 $(${CONSTITUENT}_fflags) $(fflags) /nopdbfile /debug:full /optimize:0
+# ADD F90 $(${CONSTITUENT}_fflags) $(fflags)  /nopdbfile /debug:full /optimize:0
+# ADD BASE CPP $(${CONSTITUENT}_cppflags) $(cppflags) /Od /Z7 /D "_DEBUG" /D "_CONSOLE" $(includes) $(use_cppflags)
+# ADD CPP $(${CONSTITUENT}_cppflags) $(cppflags) /Od /Z7 /D "_DEBUG" /D "_CONSOLE" $(includes) $(use_cppflags)
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 $(cpplinkflags) $(use_linkopts) $(${CONSTITUENT}linkopts) /subsystem:console /debug /pdbtype:sept
+# ADD LINK32 $(cpplinkflags) $(use_linkopts) $(${CONSTITUENT}linkopts) /subsystem:console /debug /pdbtype:sept
+
+
+# Begin Target
+
+# Name "${CONSTITUENT} - Win32 Debug"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
Index: /CMT/v1r20/mgr/fragments/dsp_contents
===================================================================
--- /CMT/v1r20/mgr/fragments/dsp_contents	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsp_contents	(revision 368)
@@ -0,0 +1,4 @@
+# Begin Source File
+
+SOURCE=${FULLNAME}
+# End Source File
Index: /CMT/v1r20/mgr/fragments/dsp_library_header
===================================================================
--- /CMT/v1r20/mgr/fragments/dsp_library_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsp_library_header	(revision 368)
@@ -0,0 +1,74 @@
+# Microsoft Developer Studio Project File - Name="${CONSTITUENT}" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=${CONSTITUENT} - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "${CONSTITUENT}.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "${CONSTITUENT}.mak" CFG="${CONSTITUENT} - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "${CONSTITUENT} - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+F90=df.exe
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Intermediate_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP Intermediate_Dir "..\$(${PACKAGE}_tag)\${CONSTITUENT}"
+# PROP Target_Dir ""
+# ADD BASE F90 $(${CONSTITUENT}_fflags) $(fflags) /nopdbfile /debug:full /optimize:0 /fpp:"/I.."
+# ADD F90 $(${CONSTITUENT}_fflags) $(fflags)  /nopdbfile /debug:full /optimize:0 /fpp:"/I.."
+# ADD BASE CPP $(${CONSTITUENT}_cppflags) $(cppflags) /Od /Z7 /D "_DEBUG" $(includes) $(use_cppflags)
+# ADD CPP $(${CONSTITUENT}_cppflags) $(cppflags) /Od /Z7 /D "_DEBUG" $(includes) $(use_cppflags)
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:..\$(${PACKAGE}_tag)\${CONSTITUENT}.${LIBRARYSUFFIX}
+
+# Begin Custom Build
+!IF  "${LIBRARYSUFFIX}" == "arc"
+..\$(${PACKAGE}_tag)\${CONSTITUENT}.dll :
+        set CMTROOT=$(CMTROOT)
+        $(make_shlib) $(${PACKAGE}_tag) ${CONSTITUENT} /debug $(cpplinkflags) $(${CONSTITUENT}_shlibflags)
+!ENDIF 
+        $(${CONSTITUENT}_customBuild)
+        $(${CONSTITUENT}_customBuild1)
+        $(${CONSTITUENT}_customBuild2)
+        $(${CONSTITUENT}_customBuild3)
+# End Custom Build
+
+# Begin Special Build Tool
+SOURCE=$(InputPath)
+PreLink_Cmds=$(${CONSTITUENT}_preLink)  $(${CONSTITUENT}_preLink1)      $(${CONSTITUENT}_preLink2)
+PostBuild_Cmds=$(${CONSTITUENT}_postBuild)      $(${CONSTITUENT}_postBuild1)    $(${CONSTITUENT}_postBuild2)
+# End Special Build Tool
+
+# Begin Target
+
+# Name "${CONSTITUENT} - Win32 Debug"
Index: /CMT/v1r20/mgr/fragments/dsp_shared_library_header
===================================================================
--- /CMT/v1r20/mgr/fragments/dsp_shared_library_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsp_shared_library_header	(revision 368)
@@ -0,0 +1,66 @@
+# Microsoft Developer Studio Project File - Name="${CONSTITUENT}shr" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=${CONSTITUENT}shr - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "${CONSTITUENT}shr.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "${CONSTITUENT}shr.mak" CFG="${CONSTITUENT}shr - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "${CONSTITUENT}shr - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Intermediate_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP Intermediate_Dir "..\$(${PACKAGE}_tag)"
+# PROP Target_Dir ""
+# ADD BASE CPP $(cppflags) /Gm /Od /D "_DEBUG" /D "_USRDLL" /D "${CONSTITUENT}_EXPORTS" /Yu"${CONSTITUENT}afx.h" /GZ
+# ADD CPP $(cppflags) /Gm /Od /D "_DEBUG" /D "_USRDLL" /D "${CONSTITUENT}_EXPORTS" /Yu"${CONSTITUENT}afx.h" /GZ
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+
+# Begin Target
+
+# Name "${CONSTITUENT}shr - Win32 Release"
+# Name "${CONSTITUENT}shr - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=../src/${CONSTITUENT}Afx.cpp
+# ADD CPP /Yc"${CONSTITUENT}afx.h"
+# End Source File
Index: /CMT/v1r20/mgr/fragments/dsp_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/dsp_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsp_trailer	(revision 368)
@@ -0,0 +1,7 @@
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# End Target
+# End Project
Index: /CMT/v1r20/mgr/fragments/dsp_windows_header
===================================================================
--- /CMT/v1r20/mgr/fragments/dsp_windows_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsp_windows_header	(revision 368)
@@ -0,0 +1,62 @@
+# Microsoft Developer Studio Project File - Name="${CONSTITUENT}" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=${CONSTITUENT} - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "${CONSTITUENT}.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "${CONSTITUENT}.mak" CFG="${CONSTITUENT} - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "${CONSTITUENT} - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Intermediate_Dir "..\$(${PACKAGE}_tag)"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\$(${PACKAGE}_tag)"
+# PROP Intermediate_Dir "..\$(${PACKAGE}_tag)"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP $(cppflags) /Gm /Od /ZI /D "_DEBUG" /GZ /D "_WINDOWS"
+# ADD CPP $(cppflags) /Gm /Od /ZI /D "_DEBUG" /GZ /D "_WINDOWS"
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x40c /d "_DEBUG"
+# ADD RSC /l 0x40c /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /debug /pdbtype:sept 
+# ADD LINK32 ${use_linkopts} kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /debug /pdbtype:sept
+
+# Begin Target
+
+# Name "${CONSTITUENT} - Win32 Release"
+# Name "${CONSTITUENT} - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
Index: /CMT/v1r20/mgr/fragments/dsw_all_project
===================================================================
--- /CMT/v1r20/mgr/fragments/dsw_all_project	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsw_all_project	(revision 368)
@@ -0,0 +1,15 @@
+###############################################################################
+
+Project: "all"=.\all.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name ${CONSTITUENT}
+    End Project Dependency
+}}}
+
Index: /CMT/v1r20/mgr/fragments/dsw_all_project_dependency
===================================================================
--- /CMT/v1r20/mgr/fragments/dsw_all_project_dependency	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsw_all_project_dependency	(revision 368)
@@ -0,0 +1,3 @@
+    Begin Project Dependency
+    Project_Dep_Name ${CONSTITUENT}
+    End Project Dependency
Index: /CMT/v1r20/mgr/fragments/dsw_all_project_header
===================================================================
--- /CMT/v1r20/mgr/fragments/dsw_all_project_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsw_all_project_header	(revision 368)
@@ -0,0 +1,11 @@
+###############################################################################
+
+Project: "all"=.\all.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+
Index: /CMT/v1r20/mgr/fragments/dsw_all_project_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/dsw_all_project_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsw_all_project_trailer	(revision 368)
@@ -0,0 +1,2 @@
+}}}
+
Index: /CMT/v1r20/mgr/fragments/dsw_header
===================================================================
--- /CMT/v1r20/mgr/fragments/dsw_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsw_header	(revision 368)
@@ -0,0 +1,2 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
Index: /CMT/v1r20/mgr/fragments/dsw_project
===================================================================
--- /CMT/v1r20/mgr/fragments/dsw_project	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsw_project	(revision 368)
@@ -0,0 +1,12 @@
+###############################################################################
+
+Project: "${CONSTITUENT}"=.\${CONSTITUENT}.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
Index: /CMT/v1r20/mgr/fragments/dsw_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/dsw_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dsw_trailer	(revision 368)
@@ -0,0 +1,13 @@
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
Index: /CMT/v1r20/mgr/fragments/dvi
===================================================================
--- /CMT/v1r20/mgr/fragments/dvi	(revision 368)
+++ /CMT/v1r20/mgr/fragments/dvi	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of dvi ------
+
+${FILEPATH}/${NAME}.dvi : ${FULLNAME}
+	cd ${doc}; latex ${FULLNAME}
+
+${FILEPATH}/${NAME}.ps : ${FILEPATH}/${NAME}.dvi
+	cd ${doc}; dvips ${FILEPATH}/${NAME}.dvi
+#-- end of dvi ------
Index: /CMT/v1r20/mgr/fragments/fortran
===================================================================
--- /CMT/v1r20/mgr/fragments/fortran	(revision 368)
+++ /CMT/v1r20/mgr/fragments/fortran	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of fortran ------
+ 
+$(bin)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(fortran_echo) $@
+	$(fortran_silent)cd $(bin); $(fcomp) -o ${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_fflags) $(${CONSTITUENT}_pp_fflags) $(app_${CONSTITUENT}_pp_fflags) $(${NAME}_pp_fflags) $(use_fflags) $(${CONSTITUENT}_fflags) $(app_${CONSTITUENT}_fflags) $(${NAME}_fflags) $(${NAME}_${FILESUFFIX}_fflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of fortran ------
Index: /CMT/v1r20/mgr/fragments/fortran_library
===================================================================
--- /CMT/v1r20/mgr/fragments/fortran_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/fortran_library	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of fortran_library ------
+ 
+$(bin)$(binobj)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(fortran_echo) $@
+	$(fortran_silent)cd $(bin); $(fcomp) -o $(binobj)${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_fflags) $(${CONSTITUENT}_pp_fflags) $(lib_${CONSTITUENT}_pp_fflags) $(${NAME}_pp_fflags) $(use_fflags) $(${CONSTITUENT}_fflags) $(lib_${CONSTITUENT}_fflags) $(${NAME}_fflags) $(${NAME}_${FILESUFFIX}_fflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of fortran_library ------
Index: /CMT/v1r20/mgr/fragments/generator
===================================================================
--- /CMT/v1r20/mgr/fragments/generator	(revision 368)
+++ /CMT/v1r20/mgr/fragments/generator	(revision 368)
@@ -0,0 +1,3 @@
+#-- start of generator ------
+
+#-- end of generator ------
Index: /CMT/v1r20/mgr/fragments/generator_header
===================================================================
--- /CMT/v1r20/mgr/fragments/generator_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/generator_header	(revision 368)
@@ -0,0 +1,22 @@
+#-- start of generator_header ------
+
+
+
+##dir=.
+
+${CONSTITUENT} :: ${CONSTITUENT}_dir ${dir}${out}_stamp
+
+${CONSTITUENT}_dir :: 
+	@if test ! -d ${dir} ; then mkdir -p ${dir} ; fi
+
+${dir}${out}_stamp ::
+	@echo ${out}
+	$(cmtexe) -quiet expand model "${model}" > ${dir}${out}_temp
+	$(cmtexe) -quiet check files ${dir}${out}_temp ${dir}${out}
+	@echo ${CONSTITUENT} >${dir}${out}_stamp
+
+${CONSTITUENT}clean ::
+	if test -f ${dir}${out}_stamp ; then /bin/rm ${dir}${out}_stamp; fi
+	if test -f ${dir}${out} ; then /bin/rm ${dir}${out}; fi
+
+#-- end of generator_header ------
Index: /CMT/v1r20/mgr/fragments/group
===================================================================
--- /CMT/v1r20/mgr/fragments/group	(revision 368)
+++ /CMT/v1r20/mgr/fragments/group	(revision 368)
@@ -0,0 +1,16 @@
+#-- start of group ------
+
+all_groups :: ${GROUP}
+
+${GROUP} :: $(${GROUP}_dependencies)  $(${GROUP}_pre_constituents) $(${GROUP}_constituents)  $(${GROUP}_post_constituents)
+	@/bin/echo " ${GROUP} ok."
+
+clean :: allclean
+
+${GROUP}clean ::  $(${GROUP}_constituentsclean)
+	@echo $(${GROUP}_constituentsclean)
+	@/bin/echo " ${GROUP}clean ok."
+
+${GROUP}clean :: makefilesclean
+
+#-- end of group ------
Index: /CMT/v1r20/mgr/fragments/install_includes
===================================================================
--- /CMT/v1r20/mgr/fragments/install_includes	(revision 368)
+++ /CMT/v1r20/mgr/fragments/install_includes	(revision 368)
@@ -0,0 +1,3 @@
+#-- start of install_includes ------
+
+#-- end of install_includes ------
Index: /CMT/v1r20/mgr/fragments/install_includes_header
===================================================================
--- /CMT/v1r20/mgr/fragments/install_includes_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/install_includes_header	(revision 368)
@@ -0,0 +1,65 @@
+#-- start of install_includes_header ------
+
+#
+#  We want to install all header files that follow the standard convention
+#
+#    ../<package>
+#
+#  This document generator needs no parameterization, since it simply expects
+#  the standard convention.
+#
+
+installarea = ${CMTINSTALLAREA}
+install_include_dir = $(installarea)/include
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_include_dir)
+	@if test ! "$(installarea)" = ""; then\
+	  echo "installation done"; \
+	fi
+
+$(install_include_dir) ::
+	@if test "$(installarea)" = ""; then \
+	  echo "Cannot install header files, no installation directory specified"; \
+	else \
+	  if test -d ../${package}; then \
+	    echo "Installing files from standard ../${package} to $(install_include_dir)"; \
+	    if test ! -d $(install_include_dir) ; then mkdir -p $(install_include_dir); fi; \
+	    if test ! -L $(install_include_dir)/$(package); then \
+	      (cd ../${package}; \
+	       here=`/bin/pwd`; \
+               eval ln -s $${here} $(install_include_dir)/$(package); \
+	       /bin/rm -f $(install_include_dir)/$(package).cmtref; \
+               echo $${here} >$(install_include_dir)/$(package).cmtref); \
+            fi; \
+	  else \
+	    echo "No standard include file area"; \
+	  fi; \
+	fi
+
+##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if test "$(installarea)" = ""; then \
+	  echo "Cannot uninstall header files, no installation directory specified"; \
+	else \
+	  if test -d $(install_include_dir)/$(package) ; then \
+	    echo "Uninstalling files from $(install_include_dir)/$(package)"; \
+	    eval rm -Rf $(install_include_dir)/$(package) ; \
+	  elif test -L $(install_include_dir)/$(package) ; then \
+	    echo "Uninstalling files from $(install_include_dir)/$(package)"; \
+	    eval rm -f $(install_include_dir)/$(package) ; \
+	  fi ; \
+	  if test -f $(install_include_dir)/$(package).cmtref ; then \
+	    echo "Uninstalling files from $(install_include_dir)/$(package).cmtref"; \
+	    eval rm -f $(install_include_dir)/$(package).cmtref ; \
+	  fi; \
+	fi
+
+
+#-- end of install_includes_header ------
Index: /CMT/v1r20/mgr/fragments/installer
===================================================================
--- /CMT/v1r20/mgr/fragments/installer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/installer	(revision 368)
@@ -0,0 +1,12 @@
+#-- start of installer ------
+
+${CONSTITUENT} :: ${install_dir}/${NAME}${FILESUFFIX}
+
+${install_dir}/${NAME}${FILESUFFIX} : ${FULLNAME}
+	@if test ! -d "${install_dir}" ; then mkdir -p ${install_dir}; fi
+	${install_command} ${FULLNAME} ${install_dir}/${NAME}${FILESUFFIX}
+
+${CONSTITUENT}clean ::
+	${uninstall_command} ${install_dir}/${NAME}${FILESUFFIX}
+
+#-- end of installer ------
Index: /CMT/v1r20/mgr/fragments/installer_header
===================================================================
--- /CMT/v1r20/mgr/fragments/installer_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/installer_header	(revision 368)
@@ -0,0 +1,4 @@
+#-- start of installer_header ------
+
+
+#-- end of installer_header ------
Index: /CMT/v1r20/mgr/fragments/jar
===================================================================
--- /CMT/v1r20/mgr/fragments/jar	(revision 368)
+++ /CMT/v1r20/mgr/fragments/jar	(revision 368)
@@ -0,0 +1,46 @@
+#-- start of jar ------
+
+$(javabin)${CONSTITUENT}.jar :: ${OBJS}
+	$(java_echo) $@
+	$(java_silent)cd $(javabin)${CONSTITUENT}; $(jar) cvf ../${CONSTITUENT}.jar *
+
+install_dir = ${CMTINSTALLAREA}/share/lib
+${CONSTITUENT}installname = ${CONSTITUENT}.jar
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then\
+	  echo "installation done"; \
+	fi
+
+$(install_dir)/$(${CONSTITUENT}installname) :: $(javabin)$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_install_action) \
+	    -source "$(PACKAGE_ROOT)/classes" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmd "$(cmt_installarea_command)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_uninstall_action) \
+	    -source "$(PACKAGE_ROOT)/classes" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+${CONSTITUENT}clean ::
+	/bin/rm -rf $(javabin)/${CONSTITUENT}
+	/bin/rm -f $(javabin)/${CONSTITUENT}.jar
+
+#-- end of jar ------
Index: /CMT/v1r20/mgr/fragments/jar_header
===================================================================
--- /CMT/v1r20/mgr/fragments/jar_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/jar_header	(revision 368)
@@ -0,0 +1,10 @@
+#-- start of jar_header ------
+
+${CONSTITUENT}javadirs ::
+	@if test ! -d $(javabin)/${CONSTITUENT} ; then $(mkdir) -p $(javabin)${CONSTITUENT} ; fi
+
+${CONSTITUENT} :: ${CONSTITUENT}javadirs $(javabin)${CONSTITUENT}.jar
+	@/bin/echo ${CONSTITUENT} ok
+
+
+#-- end of jar_header ------
Index: /CMT/v1r20/mgr/fragments/java
===================================================================
--- /CMT/v1r20/mgr/fragments/java	(revision 368)
+++ /CMT/v1r20/mgr/fragments/java	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of java ------
+
+${OUTPUTNAME} : ${FULLNAME}
+	$(java_echo) $@
+	$(java_silent)cd $(src); $(javacomp) -d $(javabin)/${CONSTITUENT} $(use_javaflags) $(${CONSTITUENT}_javaflags) $(${NAME}_javaflags) ${FULLNAME}
+
+#-- end of java ------
Index: /CMT/v1r20/mgr/fragments/java_copy
===================================================================
--- /CMT/v1r20/mgr/fragments/java_copy	(revision 368)
+++ /CMT/v1r20/mgr/fragments/java_copy	(revision 368)
@@ -0,0 +1,9 @@
+#-- start of java_copy ------
+
+${OUTPUTNAME} : ${FULLNAME}
+	$(java_echo) $@
+	$(java_silent) mkdir -p ${FILEPATH}
+	$(java_silent)cd $(src); $(javacopy) ${FULLNAME} ${OUTPUTNAME}
+
+
+#-- end of java_copy ------
Index: /CMT/v1r20/mgr/fragments/java_header
===================================================================
--- /CMT/v1r20/mgr/fragments/java_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/java_header	(revision 368)
@@ -0,0 +1,54 @@
+#-- start of java_header ------
+
+${CONSTITUENT}javadirs ::
+	@if test ! -d $(javabin)/${CONSTITUENT} ; then $(mkdir) -p $(javabin)${CONSTITUENT} ; fi
+
+${CONSTITUENT} :: ${CONSTITUENT}javadirs $(javabin)${CONSTITUENT}.jar
+	@/bin/echo "------> ${CONSTITUENT} ok"
+
+$(javabin)${CONSTITUENT}.jar :: ${OBJS}
+	$(java_echo) $@
+	$(java_silent)cd $(javabin)${CONSTITUENT}; \
+	  echo "Main-Class: ${CONSTITUENT}" >| ${CONSTITUENT}.jmf; \
+	  jar -cmvf ${CONSTITUENT}.jmf ../${CONSTITUENT}.jar *
+
+install_dir = ${CMTINSTALLAREA}/share/bin
+${CONSTITUENT}installname = ${CONSTITUENT}.jar
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then\
+	  echo "installation done"; \
+	fi
+
+$(install_dir)/$(${CONSTITUENT}installname) :: $(javabin)$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_install_action) \
+	    -source "$(PACKAGE_ROOT)/classes" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmd "$(cmt_installarea_command)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_uninstall_action) \
+	    -source "$(PACKAGE_ROOT)/classes" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+${CONSTITUENT}clean ::
+	/bin/rm -rf $(javabin)/${CONSTITUENT}
+	/bin/rm -f $(javabin)/${CONSTITUENT}.jar
+
+#-- end of java_header ------
Index: /CMT/v1r20/mgr/fragments/lex
===================================================================
--- /CMT/v1r20/mgr/fragments/lex	(revision 368)
+++ /CMT/v1r20/mgr/fragments/lex	(revision 368)
@@ -0,0 +1,14 @@
+#-- start of lex ------
+
+$(bin)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(lex_echo) $@
+	$(lex_silent) cd $(src); \
+	 $(lex) ${FILENAME}; \
+	 sed -e 's/yy/${NAME}YY/g' \
+	     -e 's/LexYY/YY/g' \
+	     -e 's/ = {stdin}//' \
+	     -e 's/ = {stdout}//' lex.yy.c > lex.yy.c.tmp; \
+	 $(cmtexe) check_files lex.yy.c.tmp ${NAME}.c; /bin/rm -f lex.yy.c
+	$(lex_silent) cd $(bin); $(ccomp) -o ${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(app_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(app_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of lex ------
Index: /CMT/v1r20/mgr/fragments/lex_library
===================================================================
--- /CMT/v1r20/mgr/fragments/lex_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/lex_library	(revision 368)
@@ -0,0 +1,14 @@
+#-- start of lex_library ------
+
+$(bin)$(binobj)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(lex_echo) $@
+	$(lex_silent) cd $(src); \
+	  $(lex) ${FILENAME}; \
+	  sed -e 's/yy/${NAME}YY/g' \
+	      -e 's/LexYY/YY/g' \
+	      -e 's/ = {stdin}//' \
+	      -e 's/ = {stdout}//' lex.yy.c > lex.yy.c.tmp; \
+	  $(cmtexe) check_files lex.yy.c.tmp ${NAME}.c; /bin/rm -f lex.yy.c
+	$(lex_silent) cd $(bin); $(ccomp) -o $(binobj)${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(lib_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(lib_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of lex_library ------
Index: /CMT/v1r20/mgr/fragments/library
===================================================================
--- /CMT/v1r20/mgr/fragments/library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/library	(revision 368)
@@ -0,0 +1,82 @@
+#-- start of libary ----------------------
+
+${CONSTITUENT}LIB :: $(${CONSTITUENT}lib) $(${CONSTITUENT}shstamp)
+	@/bin/echo "------> ${CONSTITUENT} : library ok"
+
+$(${CONSTITUENT}lib) :: ${OBJS}
+	$(lib_echo) library
+	$(lib_silent) cd $(bin); \
+	  $(ar) $(${CONSTITUENT}lib) $?
+	$(lib_silent) $(ranlib) $(${CONSTITUENT}lib)
+	$(lib_silent) cat /dev/null >$(${CONSTITUENT}stamp)
+
+#------------------------------------------------------------------
+#  Future improvement? to empty the object files after
+#  storing in the library
+#
+##	  for f in $?; do \
+##	    rm $${f}; touch $${f}; \
+##	  done
+#------------------------------------------------------------------
+
+#
+# We add one level of dependency upon the true shared library 
+# (rather than simply upon the stamp file)
+# this is for cases where the shared library has not been built
+# while the stamp was created (error??) 
+#
+
+$(${CONSTITUENT}libname).$(shlibsuffix) :: $(${CONSTITUENT}lib) requirements $(use_requirements) $(${CONSTITUENT}stamps)
+	$(lib_silent) cd $(bin); QUIET=$(QUIET); $(make_shlib) "$(tags)" ${CONSTITUENT} $(${CONSTITUENT}_shlibflags)
+
+$(${CONSTITUENT}shstamp) :: $(${CONSTITUENT}libname).$(shlibsuffix)
+	@if test -f $(${CONSTITUENT}libname).$(shlibsuffix) ; then cat /dev/null >$(${CONSTITUENT}shstamp) ; fi
+
+${CONSTITUENT}clean ::
+	$(cleanup_echo) objects
+	$(cleanup_silent) cd $(bin); /bin/rm -f ${OBJS}
+	$(cleanup_silent) cd $(bin); /bin/rm -rf ${CONSTITUENT}_deps ${CONSTITUENT}_dependencies.make
+
+#-----------------------------------------------------------------
+#
+#  New section for automatic installation
+#
+#-----------------------------------------------------------------
+
+install_dir = ${CMTINSTALLAREA}/$(tag)/lib
+${CONSTITUENT}installname = $(library_prefix)${CONSTITUENT}$(library_suffix).$(shlibsuffix)
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then\
+	  echo "installation done"; \
+	fi
+
+$(install_dir)/$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_install_action) \
+	    -source "`(cd $(bin); pwd)`" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmd "$(cmt_installarea_command)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_uninstall_action) \
+	    -source "`(cd $(bin); pwd)`" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+
+#-- end of libary -----------------------
Index: /CMT/v1r20/mgr/fragments/library_header
===================================================================
--- /CMT/v1r20/mgr/fragments/library_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/library_header	(revision 368)
@@ -0,0 +1,11 @@
+#-- start of libary_header ---------------
+
+${CONSTITUENT}libname   = $(bin)$(library_prefix)${CONSTITUENT}$(library_suffix)
+${CONSTITUENT}lib       = $(${CONSTITUENT}libname).a
+${CONSTITUENT}stamp     = $(bin)${CONSTITUENT}.stamp
+${CONSTITUENT}shstamp   = $(bin)${CONSTITUENT}.shstamp
+
+${CONSTITUENT} :: dirs ${PROTOTARGET} ${CONSTITUENT}LIB
+	@/bin/echo "------> ${CONSTITUENT} ok"
+
+#-- end of libary_header ----------------
Index: /CMT/v1r20/mgr/fragments/library_no_share
===================================================================
--- /CMT/v1r20/mgr/fragments/library_no_share	(revision 368)
+++ /CMT/v1r20/mgr/fragments/library_no_share	(revision 368)
@@ -0,0 +1,67 @@
+#-- start of library_no_share ------
+
+${CONSTITUENT}LIB :: $(${CONSTITUENT}lib)
+	@/bin/echo ${CONSTITUENT} : library ok
+
+$(${CONSTITUENT}lib) :: ${OBJS}
+	$(lib_echo) library
+	$(lib_silent) cd $(bin); \
+	  $(ar) $(${CONSTITUENT}lib) $?
+	$(lib_silent) $(ranlib) $(${CONSTITUENT}lib)
+	$(lib_silent) cat /dev/null >$(${CONSTITUENT}stamp)
+
+#------------------------------------------------------------------
+#  Future improvement? to empty the object files after
+#  storing in the library
+#
+##	  for f in $?; do \
+##	    rm $${f}; touch $${f}; \
+##	  done
+#------------------------------------------------------------------
+
+#-----------------------------------------------------------------
+#
+#  New section for automatic installation
+#
+#-----------------------------------------------------------------
+
+install_dir = ${CMTINSTALLAREA}/$(tag)/lib
+${CONSTITUENT}installname = $(library_prefix)${CONSTITUENT}$(library_suffix).a
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then\
+	  echo "installation done"; \
+	fi
+
+$(install_dir)/$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_install_action) \
+	    -source "`(cd $(bin); pwd)`" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmd "$(cmt_installarea_command)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if test ! "${CMTINSTALLAREA}" = ""; then \
+	  $(cmt_uninstall_action) \
+	    -source "`(cd $(bin); pwd)`" \
+	    -name "$(${CONSTITUENT}installname)" \
+	    -out "$(install_dir)" \
+	    -cmtpath "$($(package)_cmtpath)" ; \
+	fi
+
+${CONSTITUENT}clean ::
+	$(cleanup_echo) ${OBJS}
+	$(cleanup_silent) cd $(bin); /bin/rm -f ${OBJS}
+
+#-- end of library_no_share ------
Index: /CMT/v1r20/mgr/fragments/make_header
===================================================================
--- /CMT/v1r20/mgr/fragments/make_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/make_header	(revision 368)
@@ -0,0 +1,110 @@
+#-- start of make_header -----------------
+
+#====================================
+#  ${TITLE} ${CONSTITUENT}
+#
+#   Generated ${DATE}  by ${USER}
+#
+#====================================
+
+include ${CMTROOT}/src/Makefile.core
+
+ifdef tag
+CMTEXTRATAGS = $(tag)
+else
+tag       = $(CMTCONFIG)
+endif
+
+cmt_${CONSTITUENT}_${HASTARGETTAG} = 1
+
+#--------------------------------------------------------
+
+ifdef cmt_${CONSTITUENT}_has_target_tag
+
+tags      = $(tag),$(CMTEXTRATAGS),target_${CONSTITUENT}
+
+${PACKAGE}_tag = $(tag)
+
+ifdef READONLY
+cmt_local_tagfile_${CONSTITUENT} = /tmp/CMT_$(${PACKAGE}_tag)_${CONSTITUENT}.make$(cmt_lock_pid)
+else
+cmt_local_tagfile_${CONSTITUENT} = $(${PACKAGE}_tag)_${CONSTITUENT}.make
+endif
+
+else
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+${PACKAGE}_tag = $(tag)
+
+ifdef READONLY
+cmt_local_tagfile_${CONSTITUENT} = /tmp/CMT_$(${PACKAGE}_tag).make$(cmt_lock_pid)
+else
+cmt_local_tagfile_${CONSTITUENT} = $(${PACKAGE}_tag).make
+endif
+
+endif
+
+-include $(cmt_local_tagfile_${CONSTITUENT})
+
+ifdef cmt_${CONSTITUENT}_has_target_tag
+
+ifdef READONLY
+cmt_final_setup_${CONSTITUENT} = /tmp/CMT_${PACKAGE}_${CONSTITUENT}setup.make
+cmt_local_${CONSTITUENT}_makefile = /tmp/CMT_${CONSTITUENT}$(cmt_lock_pid).make
+else
+cmt_final_setup_${CONSTITUENT} = $(bin)${PACKAGE}_${CONSTITUENT}setup.make
+cmt_local_${CONSTITUENT}_makefile = $(bin)${CONSTITUENT}.make
+endif
+
+else
+
+ifdef READONLY
+cmt_final_setup_${CONSTITUENT} = /tmp/CMT_${PACKAGE}setup.make
+cmt_local_${CONSTITUENT}_makefile = /tmp/CMT_${CONSTITUENT}$(cmt_lock_pid).make
+else
+cmt_final_setup_${CONSTITUENT} = $(bin)${PACKAGE}setup.make
+cmt_local_${CONSTITUENT}_makefile = $(bin)${CONSTITUENT}.make
+endif
+
+endif
+
+ifdef READONLY
+cmt_final_setup = /tmp/CMT_${PACKAGE}setup.make
+else
+cmt_final_setup = $(bin)${PACKAGE}setup.make
+endif
+
+${CONSTITUENT} ::
+
+
+ifdef READONLY
+${CONSTITUENT} ::
+	@echo tags=$(tags)
+	@echo cmt_local_tagfile=$(cmt_local_tagfile)
+endif
+
+
+dirs ::
+	@if test ! -r requirements ; then echo "No requirements file" ; fi; \
+	  if test ! -d $(bin) ; then $(mkdir) -p $(bin) ; fi
+
+javadirs ::
+	@if test ! -d $(javabin) ; then $(mkdir) -p $(javabin) ; fi
+
+srcdirs ::
+	@if test ! -d $(src) ; then $(mkdir) -p $(src) ; fi
+
+help ::
+	@echo '${CONSTITUENT}'
+
+binobj = 
+ifdef STRUCTURED_OUTPUT
+binobj = ${CONSTITUENT}/
+${CONSTITUENT}::
+	@if test ! -d $(bin)$(binobj) ; then $(mkdir) -p $(bin)$(binobj) ; fi
+	@echo "STRUCTURED_OUTPUT="$(bin)$(binobj)
+endif
+
+#-- end of make_header ------------------
+
Index: /CMT/v1r20/mgr/fragments/make_setup
===================================================================
--- /CMT/v1r20/mgr/fragments/make_setup	(revision 368)
+++ /CMT/v1r20/mgr/fragments/make_setup	(revision 368)
@@ -0,0 +1,43 @@
+#-- start of make_setup ------
+
+${PACKAGE}_tag = $(tag)
+
+all :: config
+
+csh :: $(${PACKAGE}_tag).csh
+	@/bin/echo $(${PACKAGE}_tag).csh ok
+
+$(${PACKAGE}_tag).csh : cmt_path.make requirements ${use_requirements}
+	@if test "$(nocheck)" = ""; then \
+	  /bin/echo "Rebuilding $@"; \
+	  $(cmtexe) setup -quiet -tag=$(tags) | sed -e 's#`${CMTROOT}/mgr/cmt system`#$(${PACKAGE}_tag)#' >$(${PACKAGE}_tag).csh; \
+	fi
+
+sh :: $(${PACKAGE}_tag).sh
+	@/bin/echo $(${PACKAGE}_tag).sh ok
+
+$(${PACKAGE}_tag).sh : cmt_path.make requirements ${use_requirements}
+	@if test "$(nocheck)" = ""; then \
+	  /bin/echo "Rebuilding $@"; \
+	  $(cmtexe) setup -quiet -sh -tag=$(tags) | sed -e 's#`${CMTROOT}/mgr/cmt system`#$(${PACKAGE}_tag)#' >$(${PACKAGE}_tag).csh; \
+	fi
+
+config :: ## checkuses $(${PACKAGE}_tag).make
+	@/bin/echo $(${PACKAGE}_tag).make ok
+
+env.make ::
+	@printenv >env.make.tmp; $(cmtexe) -quiet check files env.make.tmp env.make
+
+$(${PACKAGE}_tag).make : requirements $(use_requirements)
+	@if test ! -d $(bin) ; then $(mkdir) -p $(bin); fi; \
+	  if test -f $(${PACKAGE}_tag).make; then /bin/rm -f $(${PACKAGE}_tag).make; fi; \
+	  $(cmtexe) -quiet -tag=$(tags) build tag_makefile >t$$$$; mv t$$$$ $(${PACKAGE}_tag).make ; \
+	  $(cmtexe) -quiet -tag=$(tags) show uses >t$$$$; mv t$$$$ uses.make ; \
+	  $(cmtexe) -tag=$(tags) show tags >t$$$$; mv t$$$$ tags.make
+
+-include $(${PACKAGE}_tag).make
+
+all :: build_library_links
+
+
+#-- end of make_setup ------
Index: /CMT/v1r20/mgr/fragments/make_setup_header
===================================================================
--- /CMT/v1r20/mgr/fragments/make_setup_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/make_setup_header	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of make_setup_header ------
+#
+# File generated ${now}
+#
+
+
+
+#-- end of make_setup_header ------
Index: /CMT/v1r20/mgr/fragments/make_setup_nmake
===================================================================
--- /CMT/v1r20/mgr/fragments/make_setup_nmake	(revision 368)
+++ /CMT/v1r20/mgr/fragments/make_setup_nmake	(revision 368)
@@ -0,0 +1,29 @@
+#-- start of make_setup_nmake ------
+
+${PACKAGE}_tag = $(tag)
+
+all :: config
+
+bat : $(${PACKAGE}_tag).bat
+	@/bin/echo $(${PACKAGE}_tag).bat ok
+  
+###$(${PACKAGE}_tag).bat : cmt_path.make requirements ${use_requirements}
+$(${PACKAGE}_tag).bat : requirements ${use_requirements}
+	@/bin/echo Rebuilding setup and config. One requirements file has changed.
+	$(cmt) build setup -bat -tag=$(${PACKAGE}_tag)
+
+config : checkuses $(${PACKAGE}_tag).make
+	@/bin/echo $(${PACKAGE}_tag).make ok
+
+##$(${PACKAGE}_tag).make : cmt_path.make requirements ${use_requirements}
+$(${PACKAGE}_tag).make : requirements ${use_requirements}
+	@echo "Now rebuilding $@"
+###	@mkdir -p $(bin); touch $(${PACKAGE}_tag).make; ${CMTROOT}/mgr/cmt -quiet build tag_makefile -tag=$(${PACKAGE}_tag) >t$$$$; mv t$$$$ $(${PACKAGE}_tag).make
+
+-include $(${PACKAGE}_tag).make
+
+##configclean :
+##	/bin/rm -f *.make*
+
+
+#-- end of make_setup_nmake ------
Index: /CMT/v1r20/mgr/fragments/nmake/application
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/application	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/application	(revision 368)
@@ -0,0 +1,31 @@
+
+$(bin)${CONSTITUENT}$(application_suffix) :: ${OBJS} $(use_stamps) $(${CONSTITUENT}stamps) requirements $(use_requirements)
+	$(link_echo) $@
+	$(link_silent) ${LINKMACRO} /out:$(bin)${CONSTITUENT}$(application_suffix) @<<
+${OBJS}
+$(use_linkopts)
+$(${CONSTITUENT}linkopts)
+<<
+
+
+
+install_dir = $(CMTINSTALLAREA)\$(tag)\bin
+${CONSTITUENT}installname = ${CONSTITUENT}$(application_suffix)
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)\$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+
+$(install_dir)\$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
+${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstall_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
Index: /CMT/v1r20/mgr/fragments/nmake/application_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/application_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/application_header	(revision 368)
@@ -0,0 +1,5 @@
+
+${CONSTITUENT} :: dirs ${PROTOTARGET} $(bin)${CONSTITUENT}$(application_suffix)
+	@echo "------> ${CONSTITUENT} ok"
+
+
Index: /CMT/v1r20/mgr/fragments/nmake/c
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/c	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/c	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of c ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(c_echo) $@
+	@if not exist $(bin)${CONSTITUENT} mkdir $(bin)${CONSTITUENT}
+	$(c_silent) $(ccomp) /Fo$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj  /Fd$(bin)${CONSTITUENT}\ $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(app_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(app_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of c ------
Index: /CMT/v1r20/mgr/fragments/nmake/c_library
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/c_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/c_library	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of c_library ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(c_echo) $@
+	@if not exist $(bin)${CONSTITUENT} mkdir $(bin)${CONSTITUENT}
+	$(c_silent) $(ccomp) /Fo$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj  /Fd$(bin)${CONSTITUENT}\ $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(lib_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(lib_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of c_library ------
Index: /CMT/v1r20/mgr/fragments/nmake/check_application
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/check_application	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/check_application	(revision 368)
@@ -0,0 +1,7 @@
+
+check :: ${CONSTITUENT}check
+
+${CONSTITUENT}check :: ${CONSTITUENT}
+	$(${CONSTITUENT}_pre_check)
+	$(bin)${CONSTITUENT}$(application_suffix) $(${CONSTITUENT}_check_args)
+	$(${CONSTITUENT}_post_check)
Index: /CMT/v1r20/mgr/fragments/nmake/check_application_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/check_application_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/check_application_header	(revision 368)
@@ -0,0 +1,9 @@
+
+check :: ${CONSTITUENT}check
+	@echo "------> ${CONSTITUENT}check ok"
+
+${CONSTITUENT}check ::
+	@echo "------> starting ${CONSTITUENT}check"
+	@$(cmtexe) -quiet build -nmake constituent_makefile ${CONSTITUENT}
+	$(MAKE) /f ${CONSTITUENT}.nmake build_strategy=keep_makefiles ${CONSTITUENT}check
+
Index: /CMT/v1r20/mgr/fragments/nmake/check_java
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/check_java	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/check_java	(revision 368)
@@ -0,0 +1,7 @@
+
+check :: ${CONSTITUENT}check
+
+${CONSTITUENT}check :: ${CONSTITUENT}
+	$(${CONSTITUENT}_pre_check)
+	java ${CONSTITUENT} $(${CONSTITUENT}_check_args)
+	$(${CONSTITUENT}_post_check)
Index: /CMT/v1r20/mgr/fragments/nmake/cleanup
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cleanup	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cleanup	(revision 368)
@@ -0,0 +1,3 @@
+	-$(cleanup_echo) ${FULLNAME}
+	$(cleanup_silent) if exist ${FULLNAME} del ${FULLNAME}
+
Index: /CMT/v1r20/mgr/fragments/nmake/cleanup_application
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cleanup_application	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cleanup_application	(revision 368)
@@ -0,0 +1,2 @@
+	-$(cleanup_echo) ${CONSTITUENT}$(application_suffix)
+	-$(cleanup_silent) if exist $(bin)${CONSTITUENT}$(application_suffix) del $(bin)${CONSTITUENT}$(application_suffix)
Index: /CMT/v1r20/mgr/fragments/nmake/cleanup_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cleanup_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cleanup_header	(revision 368)
@@ -0,0 +1,2 @@
+
+${CONSTITUENT}clean ::
Index: /CMT/v1r20/mgr/fragments/nmake/cleanup_java
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cleanup_java	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cleanup_java	(revision 368)
@@ -0,0 +1,2 @@
+	-$(cleanup_echo) ${OBJS}
+	-$(cleanup_silent) del ${OBJS}
Index: /CMT/v1r20/mgr/fragments/nmake/cleanup_library
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cleanup_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cleanup_library	(revision 368)
@@ -0,0 +1,4 @@
+	$(cleanup_echo) library
+	-$(cleanup_silent) if exist $(bin)${CONSTITUENT}.lib del $(bin)${CONSTITUENT}.lib
+	-$(cleanup_silent) if exist $(bin)${CONSTITUENT}.stamp del $(bin)${CONSTITUENT}.stamp
+	-$(cleanup_silent) if exist $(bin)${CONSTITUENT}.shstamp del $(bin)${CONSTITUENT}.shstamp
Index: /CMT/v1r20/mgr/fragments/nmake/cleanup_objects
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cleanup_objects	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cleanup_objects	(revision 368)
@@ -0,0 +1,3 @@
+	$(cleanup_echo) objects
+	$(cleanup_silent) if exist $(bin)${CONSTITUENT} rmdir /S /Q $(bin)${CONSTITUENT}
+
Index: /CMT/v1r20/mgr/fragments/nmake/cmt_action_runner_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cmt_action_runner_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cmt_action_runner_header	(revision 368)
@@ -0,0 +1,33 @@
+#-- start of cmt_action_runner_header ---------------
+
+!if defined (ONCE)
+${CONSTITUENT}_once = 1
+!endif
+
+!if defined (${CONSTITUENT}_once)
+
+${CONSTITUENT}actionstamp = ${CONSTITUENT}.actionstamp
+
+${CONSTITUENT} :: $(${CONSTITUENT}actionstamp)
+	@echo ${CONSTITUENT} ok
+
+#-- $(${CONSTITUENT}_dependencies)
+$(${CONSTITUENT}actionstamp) :: 
+	$(silent) ${action_value}
+	@echo ok > $(${CONSTITUENT}actionstamp)
+
+${CONSTITUENT}clean ::
+	@if exist $(${CONSTITUENT}actionstamp) del $(${CONSTITUENT}actionstamp)
+
+!else
+
+#-- $(${CONSTITUENT}_dependencies) --
+${CONSTITUENT} :: 
+	$(silent) ${action_value}
+
+!endif
+
+install ::
+uninstall ::
+
+#-- end of cmt_action_runner_header -----------------
Index: /CMT/v1r20/mgr/fragments/nmake/constituent
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/constituent	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/constituent	(revision 368)
@@ -0,0 +1,74 @@
+#-- start of constituent ------
+
+cmt_${CONSTITUENT}_${HASTARGETTAG} = 1
+
+#--------------------------------------------------------
+
+!if defined (cmt_${CONSTITUENT}_has_target_tag)
+
+cmt_local_tagfile_${CONSTITUENT} = $(${PACKAGE}_tag)_${CONSTITUENT}.nmake
+cmt_final_setup_${CONSTITUENT} = $(bin)${PACKAGE}_${CONSTITUENT}_setup.nmake
+cmt_local_${CONSTITUENT}_makefile = $(bin)${CONSTITUENT}.nmake
+
+${CONSTITUENT}_extratags = -tag_add=target_${CONSTITUENT}
+
+!if [if not exist $(bin) mkdir $(bin)] == 0
+!endif
+
+!if [cmt -quiet -tag=$(tags) $(${CONSTITUENT}_extratags) build tag_makefile >$(cmt_local_tagfile_${CONSTITUENT})] == 0
+!endif
+
+!if [$(cmtexe) -quiet -tag=$(tags) $(${CONSTITUENT}_extratags) show setup >$(cmt_final_setup_${CONSTITUENT})] == 0
+!endif
+
+!else
+
+cmt_local_tagfile_${CONSTITUENT} = $(${PACKAGE}_tag).nmake
+cmt_final_setup_${CONSTITUENT} = $(bin)${PACKAGE}_setup.nmake
+cmt_local_${CONSTITUENT}_makefile = $(bin)${CONSTITUENT}.nmake
+
+!endif
+
+$(cmt_local_${CONSTITUENT}_makefile) :: $(${CONSTITUENT}_dependencies) $(cmt_local_tagfile_${CONSTITUENT}) dirs
+	@echo (constituents.nmake) Building ${CONSTITUENT}.nmake
+	@set include=$(include)
+	@set lib=$(lib)
+	@$(cmtexe) -quiet -tag=$(tags) $(${CONSTITUENT}_extratags) build -nmake constituent_makefile ${CONSTITUENT}
+	@move ${CONSTITUENT}.nmake $(bin)
+	@echo (constituents.nmake) ${CONSTITUENT}.nmake done
+
+${CONSTITUENT} :: $(${CONSTITUENT}_dependencies) $(cmt_local_${CONSTITUENT}_makefile)
+	@echo (constituents.nmake) Starting ${CONSTITUENT}
+	@set include=$(include)
+	@set lib=$(lib)
+	@$(MAKE) /nologo /f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) build_strategy=keep_makefiles ${CONSTITUENT} tag=$(tag)
+	@echo (constituents.nmake) ${CONSTITUENT} done
+
+clean :: ${CONSTITUENT}clean
+
+${CONSTITUENT}clean :: $(${CONSTITUENT}clean_dependencies) ##$(cmt_local_${CONSTITUENT}_makefile)
+	@echo (constituents.nmake) Starting ${CONSTITUENT}clean
+	@set include=$(include)
+	@set lib=$(lib)
+	@-if exist $(cmt_local_${CONSTITUENT}_makefile) $(MAKE) /nologo /f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) build_strategy=keep_makefiles ${CONSTITUENT}clean tag=$(tag)
+	@echo (constituents.nmake) ${CONSTITUENT}clean done
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(${CONSTITUENT}_dependencies) $(cmt_local_${CONSTITUENT}_makefile)
+	@echo (constituents.nmake) Starting install ${CONSTITUENT}
+	@set include=$(include)
+	@set lib=$(lib)
+	@-$(MAKE) /nologo /f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) build_strategy=keep_makefiles install tag=$(tag)
+	@echo (constituents.nmake) install ${CONSTITUENT} done
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall :: $(cmt_local_${CONSTITUENT}_makefile)
+	@echo (constituents.nmake) Starting uninstall ${CONSTITUENT}"
+	@set include=$(include)
+	@set lib=$(lib)
+	@-$(MAKE) /nologo /f $(cmt_local_${CONSTITUENT}_makefile) $(MAKEFLAGS) build_strategy=keep_makefiles uninstall tag=$(tag)
+	@echo (constituents.nmake) uninstall ${CONSTITUENT} done
+
+#-- end of constituent ------
Index: /CMT/v1r20/mgr/fragments/nmake/constituents_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/constituents_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/constituents_header	(revision 368)
@@ -0,0 +1,51 @@
+
+!include $(CMTROOT)/src/NMakefile.core
+
+!if defined (tag)
+CMTEXTRATAGS = $(tag)
+!else
+tag       = $(CMTCONFIG)
+!endif
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+${PACKAGE}_tag = $(tag)
+
+!if [echo (constituents.nmake) Rebuilding $(${PACKAGE}_tag).nmake] == 0
+!endif
+
+!if [cmt -quiet build tag_makefile -tag_add=$(tags) >$(${PACKAGE}_tag).nmake] == 0
+!endif
+
+!include $(${PACKAGE}_tag).nmake
+
+all ::
+
+#--------------------------------------------------------
+
+cmt_lock_setup = lock$(cmt_lock_pid).nmake
+cmt_setup_pid  = $(bin)setup.nmake
+
+config ::  ##$(${PACKAGE}_tag).nmake
+
+env.nmake ::
+	@set >env.nmake.tmp; $(cmtexe) -quiet check files env.nmake.tmp env.nmake
+
+all ::
+
+javadirs ::
+	@if not exist $(javabin) mkdir $(javabin)
+
+srcdirs ::
+	@if not exist $(src) mkdir $(src)
+
+dirs ::
+	@if not exist requirements echo "No requirements file"
+	@echo (constituents.nmake) Rebuilding setup.nmake
+	@if not exist $(bin) mkdir $(bin)
+	@$(cmtexe) -quiet -tag=$(tags) show setup   >$(cmt_setup_pid)
+	@echo setup.nmake ok
+
+.DEFAULT :
+        @echo "???"
+
Index: /CMT/v1r20/mgr/fragments/nmake/constituents_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/constituents_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/constituents_trailer	(revision 368)
@@ -0,0 +1,17 @@
+
+clean :: remove_library_links
+
+remove_library_links ::
+	@echo "Removing library links"
+	@$(remove_library_links)
+
+makefilesclean ::
+	@if exist *.make.* del *.make*
+
+###	@if exist checkuses del checkuses
+
+clean :: makefilesclean
+
+binclean :: clean
+	@del /Q $(bin)\*
+
Index: /CMT/v1r20/mgr/fragments/nmake/cpp
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cpp	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cpp	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of cpp ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)${CONSTITUENT} mkdir $(bin)${CONSTITUENT}
+	$(cpp_silent) $(cppcomp) /Fo$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj  /Fd$(bin)${CONSTITUENT}\ $(use_pp_cppflags) $(${CONSTITUENT}_pp_cppflags) $(app_${CONSTITUENT}_pp_cppflags) $(${NAME}_pp_cppflags) $(use_cppflags) $(${CONSTITUENT}_cppflags) $(app_${CONSTITUENT}_cppflags) $(${NAME}_cppflags) $(${NAME}_${FILESUFFIX}_cppflags) ${ADDINCLUDE} /Tp${FULLNAME}
+
+#-- end of cpp ------
Index: /CMT/v1r20/mgr/fragments/nmake/cpp_library
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/cpp_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/cpp_library	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of cpp_library ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(cpp_echo) $@
+	@if not exist $(bin)${CONSTITUENT} mkdir $(bin)${CONSTITUENT}
+	$(cpp_silent) $(cppcomp) /Fo$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj  /Fd$(bin)${CONSTITUENT}\ $(use_pp_cppflags) $(${CONSTITUENT}_pp_cppflags) $(lib_${CONSTITUENT}_pp_cppflags) $(${NAME}_pp_cppflags) $(use_cppflags) $(${CONSTITUENT}_cppflags) $(lib_${CONSTITUENT}_cppflags) $(${NAME}_cppflags) $(${NAME}_${FILESUFFIX}_cppflags) ${ADDINCLUDE} /Tp${FULLNAME}
+
+#-- end of cpp_library ------
Index: /CMT/v1r20/mgr/fragments/nmake/dependencies
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/dependencies	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/dependencies	(revision 368)
@@ -0,0 +1,16 @@
+#-- start of dependency ------------------
+
+!if defined (QUICK)
+!else
+!if exist ("$(CMTROOT)/$(CMTBIN)/cmt.exe")
+!if [$(build_dependencies) ${CONSTITUENT} -all_sources] == 0
+!endif
+!else
+!if [echo no cmt $(CMTROOT)/$(CMTBIN)/cmt.exe] == 0
+!endif
+!endif
+!endif
+
+!include $(bin)${CONSTITUENT}_dependencies.nmake
+
+#-- end of dependency ------------------
Index: /CMT/v1r20/mgr/fragments/nmake/dependencies_and_triggers
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/dependencies_and_triggers	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/dependencies_and_triggers	(revision 368)
@@ -0,0 +1,11 @@
+
+!if exist ("$(cmtexe)")
+!if [$(build_dependencies) ${CONSTITUENT} ${LINE}] == 0
+!endif
+!if [$(build_triggers) ${CONSTITUENT} >${CONSTITUENT}.triggers] == 0
+!endif
+!endif
+
+!include ${CONSTITUENT}_dependencies.nmake
+
+
Index: /CMT/v1r20/mgr/fragments/nmake/fortran
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/fortran	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/fortran	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of fortran ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies) 
+	$(fortran_echo) $@
+	@if not exist $(bin)${CONSTITUENT} mkdir $(bin)${CONSTITUENT}
+	$(fortran_silent) $(fcomp) /object:"$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj" $(use_pp_fflags) $(${CONSTITUENT}_pp_fflags) $(app_${CONSTITUENT}_pp_fflags) $(${NAME}_pp_fflags) $(use_fflags) $(${CONSTITUENT}_fflags) $(app_${CONSTITUENT}_fflags) $(${NAME}_fflags) $(${NAME}_${FILESUFFIX}_fflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of fortran ------
Index: /CMT/v1r20/mgr/fragments/nmake/fortran_library
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/fortran_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/fortran_library	(revision 368)
@@ -0,0 +1,8 @@
+#-- start of fortran_library ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies) 
+	$(fortran_echo) $@
+	@if not exist $(bin)${CONSTITUENT} mkdir $(bin)${CONSTITUENT}
+	$(fortran_silent) $(fcomp) /object:"$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj" $(use_pp_fflags) $(${CONSTITUENT}_pp_fflags) $(lib_${CONSTITUENT}_pp_fflags) $(${NAME}_pp_fflags) $(use_fflags) $(${CONSTITUENT}_fflags) $(lib_${CONSTITUENT}_fflags) $(${NAME}_fflags) $(${NAME}_${FILESUFFIX}_fflags) ${ADDINCLUDE} ${FULLNAME}
+
+#-- end of fortran_library ------
Index: /CMT/v1r20/mgr/fragments/nmake/generator_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/generator_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/generator_header	(revision 368)
@@ -0,0 +1,18 @@
+
+dir=.
+
+${CONSTITUENT} :: ${CONSTITUENT}_dir ${dir}${out}_stamp
+
+${CONSTITUENT}_dir :: 
+	@if not exist ${dir} mkdir ${dir}
+
+${dir}${out}_stamp ::
+        @echo ${out}
+        $(cmtexe) -quiet expand model "${model}" > ${dir}${out}_temp
+        $(cmtexe) -quiet check files ${dir}${out}_temp ${dir}${out}
+        @echo ${CONSTITUENT} >${dir}${out}_stamp
+
+${CONSTITUENT}clean ::
+        if exist ${dir}${out}_stamp del ${dir}${out}_stamp
+        if exist ${dir}${out} del ${dir}${out}
+
Index: /CMT/v1r20/mgr/fragments/nmake/group
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/group	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/group	(revision 368)
@@ -0,0 +1,14 @@
+
+all_groups :: ${GROUP}
+
+${GROUP} ::  $(${GROUP}_pre_constituents)  $(${GROUP}_constituents)  $(${GROUP}_post_constituents)
+	@echo " ${GROUP} ok."
+
+clean :: allclean
+
+${GROUP}clean ::  $(${GROUP}_constituentsclean)
+	@echo $(${GROUP}_constituentsclean)
+	@echo " ${GROUP}clean ok."
+
+${GROUP}clean :: makefilesclean
+
Index: /CMT/v1r20/mgr/fragments/nmake/install_includes_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/install_includes_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/install_includes_header	(revision 368)
@@ -0,0 +1,27 @@
+
+#
+#  We want to install all header files that follow the standard convention
+#
+#    ../<package>
+#
+
+install_dir = $(CMTINSTALLAREA)\include
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+
+$(install_dir) ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_installdir_action) "$(PACKAGE_ROOT)" "$(package)" "$(install_dir)" "$(cmt_installdir_excludes)"
+
+${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstalldir_action) "$(PACKAGE_ROOT)" "$(package)" "$(install_dir)"
+
+
Index: /CMT/v1r20/mgr/fragments/nmake/installer
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/installer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/installer	(revision 368)
@@ -0,0 +1,11 @@
+
+
+${CONSTITUENT} :: $(install_dir)${NAME}${FILESUFFIX}
+
+$(install_dir)${NAME}${FILESUFFIX} : ${FULLNAME}
+	@if NOT exist $(install_dir) mkdir $(install_dir) 
+	@$(install_command) ${FULLNAME} $(install_dir) 
+
+${CONSTITUENT}clean ::
+	@if exist $(install_dir)\${NAME}${FILESUFFIX} $(uninstall_command) $(install_dir)\${NAME}${FILESUFFIX}
+
Index: /CMT/v1r20/mgr/fragments/nmake/installer_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/installer_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/installer_header	(revision 368)
@@ -0,0 +1,2 @@
+
+
Index: /CMT/v1r20/mgr/fragments/nmake/jar
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/jar	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/jar	(revision 368)
@@ -0,0 +1,32 @@
+
+$(javabin)${CONSTITUENT}.jar :: ${OBJS}
+	$(java_echo) $@
+	cd $(javabin)${CONSTITUENT}
+	$(jar) cvf ..\${CONSTITUENT}.jar *
+
+install_dir = $(CMTINSTALLAREA)\share\lib
+${CONSTITUENT}installname = ${CONSTITUENT}.jar
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)\$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+
+$(install_dir)\$(${CONSTITUENT}installname) :: $(javabin)$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\classes" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
+${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstall_action) "$(PACKAGE_ROOT)\classes" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
+${CONSTITUENT}clean ::
+	if exist $(javabin)\${CONSTITUENT} rmdir /Q /S $(javabin)\${CONSTITUENT}
+	if exist $(javabin)\${CONSTITUENT}.jar del $(javabin)\${CONSTITUENT}.jar
+
+
+
Index: /CMT/v1r20/mgr/fragments/nmake/jar_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/jar_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/jar_header	(revision 368)
@@ -0,0 +1,7 @@
+
+${CONSTITUENT}javadirs ::
+	@if test ! -d $(javabin)/${CONSTITUENT} ; then $(mkdir) -p $(javabin)${CONSTITUENT} ; fi
+
+${CONSTITUENT} :: ${CONSTITUENT}javadirs $(javabin)${CONSTITUENT}.jar
+	@echo ${CONSTITUENT} ok
+
Index: /CMT/v1r20/mgr/fragments/nmake/java
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/java	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/java	(revision 368)
@@ -0,0 +1,6 @@
+
+${OUTPUTNAME} : ${FULLNAME}
+	$(java_echo) $@
+	@cd $(src)
+	$(javacomp) -d $(javabin)/${CONSTITUENT} $(use_javaflags) $(${CONSTITUENT}_javaflags) $(${NAME}_javaflags) ${FULLNAME}
+
Index: /CMT/v1r20/mgr/fragments/nmake/java_copy
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/java_copy	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/java_copy	(revision 368)
@@ -0,0 +1,5 @@
+
+${OUTPUTNAME} : ${FULLNAME}
+	$(java_echo) $@
+	$(javacopy) ${FULLNAME} ${OUTPUTNAME}
+
Index: /CMT/v1r20/mgr/fragments/nmake/java_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/java_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/java_header	(revision 368)
@@ -0,0 +1,37 @@
+
+${CONSTITUENT}javadirs ::
+	@if not exist $(javabin)${CONSTITUENT} mkdir $(javabin)${CONSTITUENT}
+
+${CONSTITUENT} :: ${CONSTITUENT}javadirs $(javabin)${CONSTITUENT}.jar
+	@echo "------> ${CONSTITUENT} ok"
+
+$(javabin)${CONSTITUENT}.jar :: ${OBJS}
+	$(java_echo) $@
+	$(java_silent)cd $(javabin)${CONSTITUENT}
+	$(java_silent)echo Main-Class: ${CONSTITUENT} > ${CONSTITUENT}.jmf
+	$(java_silent)jar -cmvf ${CONSTITUENT}.jmf ../${CONSTITUENT}.jar *
+
+install_dir = $(CMTINSTALLAREA)\share\bin
+${CONSTITUENT}installname = ${CONSTITUENT}.jar
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)\$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+
+$(install_dir)\$(${CONSTITUENT}installname) :: $(javabin)$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\classes" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
+${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstall_action) "$(PACKAGE_ROOT)\classes" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
+
+${CONSTITUENT}clean ::
+	if exist $(javabin)\${CONSTITUENT} rmdir /Q /S $(javabin)\${CONSTITUENT}
+	if exist $(javabin)\${CONSTITUENT}.jar del $(javabin)\${CONSTITUENT}.jar
Index: /CMT/v1r20/mgr/fragments/nmake/lex
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/lex	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/lex	(revision 368)
@@ -0,0 +1,11 @@
+#-- start of lex ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(lex_echo) $@
+	$(lex_silent) $(lex) ${FILENAME}
+	sed -e 's/yy/${NAME}YY/g' -e 's/LexYY/YY/g' -e 's/ = {stdin}//' -e 's/ = {stdout}//' lex.yy.c > lex.yy.c.tmp
+	$(cmtexe) -quiet check_files lex.yy.c.tmp ${NAME}.c
+	del lex.yy.c
+	$(lex_silent) $(ccomp) /Fo"$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj" $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(app_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(app_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of lex ------
Index: /CMT/v1r20/mgr/fragments/nmake/lex_library
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/lex_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/lex_library	(revision 368)
@@ -0,0 +1,11 @@
+#-- start of lex_library ------
+
+$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(lex_echo) $@
+	$(lex_silent) $(lex) ${FILENAME}
+	sed -e 's/yy/${NAME}YY/g' -e 's/LexYY/YY/g' -e 's/ = {stdin}//' -e 's/ = {stdout}//' lex.yy.c > lex.yy.c.tmp
+	$(cmtexe) -quiet check_files lex.yy.c.tmp ${NAME}.c
+	del lex.yy.c
+	$(lex_silent) $(ccomp) /Fo"$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj" $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(lib_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(lib_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of lex_library ------
Index: /CMT/v1r20/mgr/fragments/nmake/library
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/library	(revision 368)
@@ -0,0 +1,65 @@
+
+${CONSTITUENT}LIB :: $(${CONSTITUENT}shstamp)
+	@echo "------> ${CONSTITUENT} : library ok"
+
+$(${CONSTITUENT}arc) :: ${OBJS}
+	$(lib_echo) library
+	$(lib_silent) $(ar) /out:$(bin)${CONSTITUENT}.arc @<<
+${OBJS}
+<<
+	echo "" >$(${CONSTITUENT}stamp)
+
+$(${CONSTITUENT}shstamp) :: $(${CONSTITUENT}arc) requirements $(use_requirements) $(${CONSTITUENT}stamps)
+	$(make_shlib) $(tag) ${CONSTITUENT} $(cpplinkflags) $(${CONSTITUENT}_shlibflags)
+	if exist $(bin)${CONSTITUENT}.dll echo "" >$(${CONSTITUENT}shstamp)
+
+${CONSTITUENT}clean ::
+	$(cleanup_echo) #objects
+	$(cleanup_silent) for %f in (${OBJS}) do if exist %f del %f
+	$(cleanup_silent) if exist $(bin)${CONSTITUENT}.arc del $(bin)${CONSTITUENT}.arc
+	$(cleanup_silent) if exist $(bin)${CONSTITUENT}.lib del $(bin)${CONSTITUENT}.lib
+	$(cleanup_silent) if exist $(bin)${CONSTITUENT}.def del $(bin)${CONSTITUENT}.def
+	$(cleanup_silent) if exist $(bin)${CONSTITUENT}.exp del $(bin)${CONSTITUENT}.exp
+	$(cleanup_silent) if exist $(bin)${CONSTITUENT}.dll del $(bin)${CONSTITUENT}.dll
+	$(cleanup_silent) if exist $(bin)${CONSTITUENT}.pdb del $(bin)${CONSTITUENT}.pdb
+
+
+install_dir = $(CMTINSTALLAREA)\$(tag)\lib
+${CONSTITUENT}installlibname = $(library_prefix)${CONSTITUENT}$(library_suffix).lib
+${CONSTITUENT}installdllname = $(library_prefix)${CONSTITUENT}$(library_suffix).dll
+${CONSTITUENT}installpdbname = $(library_prefix)${CONSTITUENT}$(library_suffix).pdb
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+!IF "$(vsCONFIG)" == "Debug" 
+${CONSTITUENT}install :: $(${CONSTITUENT}shstamp) $(install_dir)\$(${CONSTITUENT}installlibname) $(install_dir)\$(${CONSTITUENT}installdllname) $(install_dir)\$(${CONSTITUENT}installpdbname)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+
+!ELSE
+
+${CONSTITUENT}install :: $(${CONSTITUENT}shstamp) $(install_dir)\$(${CONSTITUENT}installlibname) $(install_dir)\$(${CONSTITUENT}installdllname)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+!ENDIF
+
+$(install_dir)\$(${CONSTITUENT}installlibname) :: $(bin)$(${CONSTITUENT}installlibname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installlibname)" "$(install_dir)"
+
+$(install_dir)\$(${CONSTITUENT}installdllname) :: $(bin)$(${CONSTITUENT}installdllname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installdllname)" "$(install_dir)"
+
+$(install_dir)\$(${CONSTITUENT}installpdbname) :: $(bin)$(${CONSTITUENT}installpdbname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installpdbname)" "$(install_dir)"
+
+${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstall_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installlibname)" "$(install_dir)"
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstall_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installdllname)" "$(install_dir)"
+
+
+
+
Index: /CMT/v1r20/mgr/fragments/nmake/library_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/library_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/library_header	(revision 368)
@@ -0,0 +1,9 @@
+
+${CONSTITUENT}lib       = $(bin)${CONSTITUENT}.lib
+${CONSTITUENT}arc       = $(bin)${CONSTITUENT}.arc
+${CONSTITUENT}stamp     = $(bin)${CONSTITUENT}.stamp
+${CONSTITUENT}shstamp   = $(bin)${CONSTITUENT}.shstamp
+
+${CONSTITUENT} :: dirs ${PROTOTARGET} ${CONSTITUENT}LIB
+	@echo "------> ${CONSTITUENT} ok"
+
Index: /CMT/v1r20/mgr/fragments/nmake/library_no_share
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/library_no_share	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/library_no_share	(revision 368)
@@ -0,0 +1,39 @@
+
+${CONSTITUENT}LIB :: $(${CONSTITUENT}lib)
+	@echo "------> ${CONSTITUENT} : library ok"
+
+$(${CONSTITUENT}lib) :: ${OBJS}
+	$(lib_echo) library
+	$(lib_silent) $(ar) /out:$(${CONSTITUENT}lib) @<<
+${OBJS}
+<<
+	@echo "" >$(${CONSTITUENT}stamp)
+
+${CONSTITUENT}clean ::
+	$(cleanup_echo) #objects
+	$(cleanup_silent) for %f in (${OBJS}) do if exist %f del %f
+	$(cleanup_silent) if exist $(${CONSTITUENT}lib) del $(${CONSTITUENT}lib)
+
+install_dir = $(CMTINSTALLAREA)\$(tag)\lib
+${CONSTITUENT}installname = $(library_prefix)${CONSTITUENT}$(library_suffix).lib
+
+${CONSTITUENT} :: ${CONSTITUENT}install
+
+install :: ${CONSTITUENT}install
+
+${CONSTITUENT}install :: $(install_dir)\$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" echo "installation done"
+
+$(install_dir)\$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_install_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
+${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
+
+uninstall :: ${CONSTITUENT}uninstall
+
+${CONSTITUENT}uninstall ::
+	@if NOT "$(CMTINSTALLAREA)"=="" $(cmt_uninstall_action) "$(PACKAGE_ROOT)\$(tag)" "$(${CONSTITUENT}installname)" "$(install_dir)"
+
+
+
+
Index: /CMT/v1r20/mgr/fragments/nmake/make_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/make_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/make_header	(revision 368)
@@ -0,0 +1,58 @@
+
+#====================================
+#  ${TITLE} ${CONSTITUENT}
+#
+#   Generated ${DATE}  by ${USER}
+#
+#====================================
+
+!include $(CMTROOT)/src/NMakefile.core
+
+!if defined (tag)
+CMTEXTRATAGS = $(tag)
+!else
+!if defined (CMTCONFIG)
+tag = $(CMTCONFIG) 
+!else
+tag = VisualC
+!endif
+!endif
+
+cmt_${CONSTITUENT}_$(HASTARGETTAG) = 1
+
+#--------------------------------------------------------
+
+!if defined (cmt_${CONSTITUENT}_has_target_tag)
+
+tags      = $(tag),$(CMTEXTRATAGS),target_${CONSTITUENT}
+
+${PACKAGE}_tag = $(tag)
+
+cmt_local_tagfile = $(${PACKAGE}_tag)_${CONSTITUENT}.nmake
+
+!else
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+${PACKAGE}_tag = $(tag)
+
+cmt_local_tagfile = $(${PACKAGE}_tag).nmake
+
+!endif
+
+!include $(cmt_local_tagfile)
+
+${CONSTITUENT} ::
+
+javadirs ::
+	@if not exist $(javabin) mkdir $(javabin)
+
+srcdirs ::
+	@if not exist $(src) mkdir $(src)
+
+dirs ::
+	@if not exist requirements echo "No requirements file"
+	@if not exist $(bin) mkdir $(bin)
+
+help ::
+	@echo '${CONSTITUENT}'
Index: /CMT/v1r20/mgr/fragments/nmake/protos_header
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/protos_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/protos_header	(revision 368)
@@ -0,0 +1,4 @@
+    
+${CONSTITUENT}PROTOS :: ${PROTOSTAMPS}
+	@echo ${CONSTITUENT} : Protos ok
+
Index: /CMT/v1r20/mgr/fragments/nmake/yacc
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/yacc	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/yacc	(revision 368)
@@ -0,0 +1,13 @@
+#-- start of yacc ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(yacc_echo) $@
+	$(yacc_silent) $(yacc) ${FILENAME}
+	sed -e 's/yy/${NAME}YY/g' -e 's/ParseYY/YY/g' y.tab.c > y.tab.c.tmp
+	$(cmtexe) -quiet check_files y.tab.c.tmp ${NAME}.c
+	sed -e 's/yy/${NAME}YY/g' -e 's/ParseYY/YY/g' y.tab.h > y.tab.h.tmp
+	$(cmtexe) -quiet check_files y.tab.h.tmp ${NAME}.h
+	del y.tab.[ch]
+	$(yacc_silent) $(ccomp) /Fo"$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj" $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(app_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(app_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of yacc ------
Index: /CMT/v1r20/mgr/fragments/nmake/yacc_library
===================================================================
--- /CMT/v1r20/mgr/fragments/nmake/yacc_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/nmake/yacc_library	(revision 368)
@@ -0,0 +1,13 @@
+#-- start of yacc_library ------
+
+$(bin)${CONSTITUENT}/${NAME}${CONSTITUENTSUFFIX}.obj : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(yacc_echo) $@
+	$(yacc_silent) $(yacc) ${FILENAME}
+	sed -e 's/yy/${NAME}YY/g' -e 's/ParseYY/YY/g' y.tab.c > y.tab.c.tmp
+	$(cmtexe) -quiet check_files y.tab.c.tmp ${NAME}.c
+	sed -e 's/yy/${NAME}YY/g' -e 's/ParseYY/YY/g' y.tab.h > y.tab.h.tmp
+	$(cmtexe) -quiet check_files y.tab.h.tmp ${NAME}.h
+	del y.tab.[ch]
+	$(yacc_silent) $(ccomp) /Fo"$(bin)${CONSTITUENT}\${NAME}${CONSTITUENTSUFFIX}.obj" $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(lib_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(lib_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of yacc_library ------
Index: /CMT/v1r20/mgr/fragments/os9
===================================================================
--- /CMT/v1r20/mgr/fragments/os9	(revision 368)
+++ /CMT/v1r20/mgr/fragments/os9	(revision 368)
@@ -0,0 +1,7 @@
+#-- start of os9 ------
+
+../OS9/${NAME} :: ${FILE}
+	@cd ../OS9/; unixtoos9.csh ${FILE}
+
+
+#-- end of os9 ------
Index: /CMT/v1r20/mgr/fragments/os9_header
===================================================================
--- /CMT/v1r20/mgr/fragments/os9_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/os9_header	(revision 368)
@@ -0,0 +1,6 @@
+#-- start of os9_header ------
+      
+OS9 :: ${ALLOS9SOURCES}
+	@cd .
+
+#-- end of os9_header ------
Index: /CMT/v1r20/mgr/fragments/protos_header
===================================================================
--- /CMT/v1r20/mgr/fragments/protos_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/protos_header	(revision 368)
@@ -0,0 +1,6 @@
+#-- start of protos_header ------
+    
+${CONSTITUENT}PROTOS :: ${PROTOSTAMPS}
+	@/bin/echo ${CONSTITUENT} : Protos ok
+
+#-- end of protos_header ------
Index: /CMT/v1r20/mgr/fragments/readme
===================================================================
--- /CMT/v1r20/mgr/fragments/readme	(revision 368)
+++ /CMT/v1r20/mgr/fragments/readme	(revision 368)
@@ -0,0 +1,12 @@
+    <hr>
+    <center>
+      <table BORDER COLS=4 WIDTH="400" NOSAVE >
+
+	<h3>Used packages</h3>
+	
+        <tr>
+          <td><center><i>package name</i></center></td>
+          <td><center><i>version tag</i></center></td>
+          <td><center><i>path</i></center></td>
+        </tr>
+
Index: /CMT/v1r20/mgr/fragments/readme_header
===================================================================
--- /CMT/v1r20/mgr/fragments/readme_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/readme_header	(revision 368)
@@ -0,0 +1,11 @@
+<html>
+  <head>
+    <title>${PACKAGE} ${VERSION}</title>
+  </head>
+  <body>
+
+      <h1>${PACKAGE} ${VERSION}</h1>
+
+      <p>
+
+
Index: /CMT/v1r20/mgr/fragments/readme_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/readme_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/readme_trailer	(revision 368)
@@ -0,0 +1,12 @@
+      </table>
+
+      <p>See also the <a href="requirements">Requirements</a> file.</p>
+    </center>
+
+<hr>
+<i>
+   Last update ${DATE} by ${USER}
+</i>
+
+</body>
+</html>
Index: /CMT/v1r20/mgr/fragments/readme_use
===================================================================
--- /CMT/v1r20/mgr/fragments/readme_use	(revision 368)
+++ /CMT/v1r20/mgr/fragments/readme_use	(revision 368)
@@ -0,0 +1,6 @@
+        <tr>
+          <td><a href="${PACKAGEPATH}${PACKAGEPREFIX}/${PACKAGE}/${VERSION}/${MGRSTYLE}/README.html">${PACKAGE}</a></td>
+          <td>${VERSION}</td>
+          <td>${PACKAGEPREFIX}</td>
+        </tr>
+
Index: /CMT/v1r20/mgr/fragments/sln_dependency_header
===================================================================
--- /CMT/v1r20/mgr/fragments/sln_dependency_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/sln_dependency_header	(revision 368)
@@ -0,0 +1,5 @@
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		ConfigName.0 = $(vsCONFIG)
+	EndGlobalSection
+	GlobalSection(ProjectDependencies) = postSolution
Index: /CMT/v1r20/mgr/fragments/sln_dependency_project
===================================================================
--- /CMT/v1r20/mgr/fragments/sln_dependency_project	(revision 368)
+++ /CMT/v1r20/mgr/fragments/sln_dependency_project	(revision 368)
@@ -0,0 +1,1 @@
+		$(GUID_all).${NUMBER} = ${CONSTITUENT_GUID}
Index: /CMT/v1r20/mgr/fragments/sln_dependency_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/sln_dependency_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/sln_dependency_trailer	(revision 368)
@@ -0,0 +1,2 @@
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
Index: /CMT/v1r20/mgr/fragments/sln_header
===================================================================
--- /CMT/v1r20/mgr/fragments/sln_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/sln_header	(revision 368)
@@ -0,0 +1,3 @@
+Microsoft Visual Studio Solution File, Format Version 7.00
+Project("$(package_GUID)") = "all", "all.vcproj", "$(GUID_all)"
+EndProject
Index: /CMT/v1r20/mgr/fragments/sln_project
===================================================================
--- /CMT/v1r20/mgr/fragments/sln_project	(revision 368)
+++ /CMT/v1r20/mgr/fragments/sln_project	(revision 368)
@@ -0,0 +1,2 @@
+Project("$(package_GUID)") = "${CONSTITUENT}", "${CONSTITUENT}.vcproj", "${CONSTITUENT_GUID}"
+EndProject
Index: /CMT/v1r20/mgr/fragments/sln_project_config
===================================================================
--- /CMT/v1r20/mgr/fragments/sln_project_config	(revision 368)
+++ /CMT/v1r20/mgr/fragments/sln_project_config	(revision 368)
@@ -0,0 +1,2 @@
+		${CONSTITUENT_GUID}.$(vsCONFIG).ActiveCfg = $(vsCONFIG)|Win32
+		${CONSTITUENT_GUID}.$(vsCONFIG).Build.0 = $(vsCONFIG)|Win32
Index: /CMT/v1r20/mgr/fragments/sln_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/sln_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/sln_trailer	(revision 368)
@@ -0,0 +1,6 @@
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal
Index: /CMT/v1r20/mgr/fragments/tex
===================================================================
--- /CMT/v1r20/mgr/fragments/tex	(revision 368)
+++ /CMT/v1r20/mgr/fragments/tex	(revision 368)
@@ -0,0 +1,16 @@
+#-- start of tex ------
+
+${CONSTITUENT} :: ${FILEPATH}${NAME}.ps
+
+${FILEPATH}${NAME}.dvi : ${NAME}${FILESUFFIX}
+	cd ${doc}; latex ${NAME}${FILESUFFIX}
+
+${FILEPATH}${NAME}.ps : ${FILEPATH}${NAME}.dvi
+	cd ${doc}; dvips -o ${NAME}.ps ${NAME}.dvi
+
+${CONSTITUENT}clean ::
+	$(cleanup_echo) ${doc}/${NAME}.ps
+	$(cleanup_silent) cd ${doc}; /bin/rm -f ${NAME}.ps ${NAME}.dvi
+	$(cleanup_silent) cd ${doc}; /bin/rm -f ${NAME}.aux ${NAME}.log ${NAME}.toc
+
+#-- end of tex ------
Index: /CMT/v1r20/mgr/fragments/tex_header
===================================================================
--- /CMT/v1r20/mgr/fragments/tex_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/tex_header	(revision 368)
@@ -0,0 +1,3 @@
+#-- start of tex_header ------
+
+#-- end of tex_header ------
Index: /CMT/v1r20/mgr/fragments/vcproj_all
===================================================================
--- /CMT/v1r20/mgr/fragments/vcproj_all	(revision 368)
+++ /CMT/v1r20/mgr/fragments/vcproj_all	(revision 368)
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<!-- GLAST fragment $Header: /projects/cvs/CMT/mgr/fragments/vcproj_all,v 1.1 2004/09/30 16:20:09 arnault Exp $ -->
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="all"
+	ProjectGUID="$(GUID_all)"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="$(vsCONFIG)|Win32"
+			OutputDirectory="..\$(${PACKAGE}_tag)"
+			IntermediateDirectory="..\$(${PACKAGE}_tag)\${CONSTITUENT}"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<File
+			RelativePath="..\src\mainpage.h">
+		</File>
+		<File
+			RelativePath="..\doc\release.notes">
+		</File>
+		<File
+			RelativePath="..\cmt\requirements">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
Index: /CMT/v1r20/mgr/fragments/vcproj_application_header
===================================================================
--- /CMT/v1r20/mgr/fragments/vcproj_application_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/vcproj_application_header	(revision 368)
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<!-- generated by CMT for package/constituent ${PACKAGE}/${CONSTITUENT} 
+     from fragment: $Header: /projects/cvs/CMT/mgr/fragments/vcproj_application_header,v 1.1 2004/09/30 16:20:09 arnault Exp $ 
+     GUID=${GUID}
+  -->
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="${CONSTITUENT}"
+	ProjectGUID="${GUID}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="$(vsCONFIG)|Win32"
+			OutputDirectory="..\$(${PACKAGE}_tag)"
+			IntermediateDirectory="..\$(${PACKAGE}_tag)\${CONSTITUENT}"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions='$(cppflags) $(use_cppflags)  $(${CONSTITUENT}_cppflags)'
+				Optimization="$(vsOptimize)"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions='$(cpplinkflags) $(use_linkopts) $(${CONSTITUENT}linkopts)  $(${CONSTITUENT}_use_linkopts)'
+				OutputFile="..\$(${PACKAGE}_tag)\${CONSTITUENT}.exe"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(vsPDF)"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
Index: /CMT/v1r20/mgr/fragments/vcproj_contents
===================================================================
--- /CMT/v1r20/mgr/fragments/vcproj_contents	(revision 368)
+++ /CMT/v1r20/mgr/fragments/vcproj_contents	(revision 368)
@@ -0,0 +1,3 @@
+			<File
+				RelativePath="${FULLNAME}">
+			</File>
Index: /CMT/v1r20/mgr/fragments/vcproj_directory_header
===================================================================
--- /CMT/v1r20/mgr/fragments/vcproj_directory_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/vcproj_directory_header	(revision 368)
@@ -0,0 +1,1 @@
+		<Filter Name="$(DIRNAME)" Filter="">
Index: /CMT/v1r20/mgr/fragments/vcproj_directory_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/vcproj_directory_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/vcproj_directory_trailer	(revision 368)
@@ -0,0 +1,1 @@
+		</Filter>
Index: /CMT/v1r20/mgr/fragments/vcproj_library_header
===================================================================
--- /CMT/v1r20/mgr/fragments/vcproj_library_header	(revision 368)
+++ /CMT/v1r20/mgr/fragments/vcproj_library_header	(revision 368)
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<!-- GLAST fragment $Header: /projects/cvs/CMT/mgr/fragments/vcproj_library_header,v 1.1 2004/09/30 16:20:09 arnault Exp $
+   Build by CMT for package/project: ${PACKAGE}/${CONSTITUENT}
+   Generated GUID:  ${GUID}
+  -->
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="${CONSTITUENT}"
+	ProjectGUID="${GUID}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="$(vsCONFIG)|Win32"
+			OutputDirectory="..\$(${PACKAGE}_tag)"
+			IntermediateDirectory="..\$(${PACKAGE}_tag)\${CONSTITUENT}"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions='$(cppflags) $(use_cppflags) $(lib_${CONSTITUENT}_cppflags)'
+				Optimization="$(vsOptimize)"
+				PreprocessorDefinitions="_USRDLL;${PACKAGE}_EXPORTS"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"/>
+			<Tool
+				Name="VCCustomBuildTool"
+				CommandLine='type NUL > ..\$(tag)\${CONSTITUENT}.stamp
+   set CMTROOT=$(CMTROOT)
+   $(${CONSTITUENT}_customBuild)
+   call $(make_shlib) $(tag) ${CONSTITUENT} $(cpplinkflags) $(${CONSTITUENT}_shlibflags) 
+   if exist ..\$(tag)\${CONSTITUENT}.dll type NUL > ..\$(tag)\${CONSTITUENT}.shstamp
+   $(${CONSTITUENT}_customBuild1)
+   $(${CONSTITUENT}_customBuild2)
+   $(${CONSTITUENT}_customBuild3)'
+			Outputs="..\$(tag)\${CONSTITUENT}.stamp; ..\$(tag)\${CONSTITUENT}.shstamp; ..\$(tag)\${CONSTITUENT}.dll "/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\$(${PACKAGE}_tag)\${CONSTITUENT}.${LIBRARYSUFFIX}"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
Index: /CMT/v1r20/mgr/fragments/vcproj_trailer
===================================================================
--- /CMT/v1r20/mgr/fragments/vcproj_trailer	(revision 368)
+++ /CMT/v1r20/mgr/fragments/vcproj_trailer	(revision 368)
@@ -0,0 +1,4 @@
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
Index: /CMT/v1r20/mgr/fragments/yacc
===================================================================
--- /CMT/v1r20/mgr/fragments/yacc	(revision 368)
+++ /CMT/v1r20/mgr/fragments/yacc	(revision 368)
@@ -0,0 +1,14 @@
+#-- start of yacc ------
+
+$(bin)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(yacc_echo) $@
+	$(yacc_silent) cd $(src); \
+	  $(yacc) ${FILENAME}; \
+	  sed -e 's/yy/${NAME}YY/g' \
+	    -e 's/ParseYY/YY/g' y.tab.c > y.tab.c.tmp; \
+	  $(cmtexe) check_files y.tab.c.tmp ${NAME}.c; \
+	  sed -e 's/yy/${NAME}YY/g' -e 's/ParseYY/YY/g' y.tab.h > y.tab.h.tmp; \
+	  $(cmtexe) check_files y.tab.h.tmp ${NAME}.h; /bin/rm -f y.tab.[ch]
+	$(yacc_silent) cd $(bin); $(ccomp) -o ${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(app_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(app_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of yacc ------
Index: /CMT/v1r20/mgr/fragments/yacc_library
===================================================================
--- /CMT/v1r20/mgr/fragments/yacc_library	(revision 368)
+++ /CMT/v1r20/mgr/fragments/yacc_library	(revision 368)
@@ -0,0 +1,13 @@
+#-- start of yacc_library ------
+
+$(bin)$(binobj)${NAME}${CONSTITUENTSUFFIX}.o : $(${NAME}_${FILESUFFIX}_dependencies)
+	$(yacc_echo) $@
+	$(yacc_silent) cd $(src); \
+	  $(yacc) ${FILENAME}; \
+	  sed -e 's/yy/${NAME}YY/g' -e 's/ParseYY/YY/g' y.tab.c > y.tab.c.tmp; \
+	  $(cmtexe) check_files y.tab.c.tmp ${NAME}.c; \
+	  sed -e 's/yy/${NAME}YY/g' -e 's/ParseYY/YY/g' y.tab.h > y.tab.h.tmp; \
+	  $(cmtexe) check_files y.tab.h.tmp ${NAME}.h; /bin/rm -f y.tab.[ch]
+	$(yacc_silent) cd $(bin); $(ccomp) -o $(binobj)${NAME}${CONSTITUENTSUFFIX}.o $(use_pp_cflags) $(${CONSTITUENT}_pp_cflags) $(lib_${CONSTITUENT}_pp_cflags) $(${NAME}_pp_cflags) $(use_cflags) $(${CONSTITUENT}_cflags) $(lib_${CONSTITUENT}_cflags) $(${NAME}_cflags) $(${NAME}_${FILESUFFIX}_cflags) ${ADDINCLUDE} $(src)${NAME}.c
+
+#-- end of yacc_library ------
Index: /CMT/v1r20/mgr/install.mak
===================================================================
--- /CMT/v1r20/mgr/install.mak	(revision 368)
+++ /CMT/v1r20/mgr/install.mak	(revision 368)
@@ -0,0 +1,5 @@
+
+all ::
+	@echo set CMTROOT=$(MAKEDIR)
+	@type src\setup.bat
+
Index: /CMT/v1r20/mgr/install_from_rpm.sh
===================================================================
--- /CMT/v1r20/mgr/install_from_rpm.sh	(revision 368)
+++ /CMT/v1r20/mgr/install_from_rpm.sh	(revision 368)
@@ -0,0 +1,49 @@
+
+
+set -x
+
+version=v1r14
+
+#-------------------------------------------------------------
+# Setup a temporary directory
+#-------------------------------------------------------------
+
+#-------------------------------------------------------------
+# Install a local RPM database
+#-------------------------------------------------------------
+
+tempdir=/tmp/CMT
+
+rm -rf ${tempdir}
+
+database=${tempdir}/rpm-database
+
+mkdir -p ${database}
+
+rpm --dbpath ${database} --initdb
+rpm --dbpath ${database} -Uvh virtual.rpm
+
+rpm --dbpath ${database} -e CMT
+
+#-------------------------------------------------------------
+# Install from the bin RPM
+#-------------------------------------------------------------
+
+tempdir1=$1
+
+if test "${tempdir1}" = ""; then
+  tempdir1=/tmp/CMT1
+  rm -rf ${tempdir1}
+  mkdir -p ${tempdir1}
+fi
+
+rpm --quiet --dbpath ${database} -Uvh --relocate /CMT=${tempdir1}/CMT \
+  ../rpm/CMT-${version}-1.i386.rpm
+
+source ${tempdir1}/CMT/${version}/mgr/setup.sh
+
+cmt version
+
+
+
+
Index: /CMT/v1r20/mgr/package.nmake
===================================================================
--- /CMT/v1r20/mgr/package.nmake	(revision 368)
+++ /CMT/v1r20/mgr/package.nmake	(revision 368)
@@ -0,0 +1,2 @@
+# Package CMT v1r11 defines macro package as 'CMT' for default tag
+package='CMT'
Index: /CMT/v1r20/mgr/requirements
===================================================================
--- /CMT/v1r20/mgr/requirements	(revision 368)
+++ /CMT/v1r20/mgr/requirements	(revision 368)
@@ -0,0 +1,736 @@
+package CMT
+
+author arnault@lal.in2p3.fr
+
+tag CMTr15 CMTr14
+tag CMTr16 CMTr14
+tag CMTr18 CMTr16
+tag CMTr0  CMTr18
+
+#
+#  Automatic detection of some system features.
+#
+
+
+# Getting info on the hardware
+macro cmt_hardware_query_command "uname -m" \
+      Darwin "uname -p" \
+      SunOS "uname -p" \
+      HP-UX "uname -m | sed -e 's#/##g'" 
+
+macro cmt_hardware `$(cmt_hardware_query_command)` WIN32 "WIN32"
+
+apply_tag $(cmt_hardware)
+
+
+# Getting info about the OS
+macro cmt_system_version_query_command "uname -r " \
+      Linux "${CMTROOT}/mgr/cmt_linux_version.sh" \
+      SunOS "uname -r | sed -e 's#^#sunos#'" \
+      OSF1  "uname -r | sed -e 's#^#OSF#'" \
+      Darwin "system_profiler -detailLevel -2 | grep 'System Version' | sed -e 's#[^.0-9 ]##g' -e 's#  *# #g' | cut -d ' ' -f2 | sed -e 's#^#mac#' " \
+      HP-UX "uname -r | sed -e 's#^#hpux#'" \
+      CYGWIN "uname -r | sed -e 's#[(].*##' -e 's#^#Cygwin#'" \
+      LynxOS "uname -r | sed -e 's#^#LynxOS#'"
+
+macro_append cmt_system_version_query_command " | ${CMTROOT}/mgr/cmt_filter_version.sh" \
+             WIN32 ""
+
+macro cmt_system_version   `$(cmt_system_version_query_command)`   WIN32 "XP"
+
+apply_tag $(cmt_system_version)
+
+
+# Getting info about the C++ compiler
+macro cmt_compiler_version_query_command "${CMTROOT}/mgr/cmt_gcc_version.sh | grep '^gcc'" \
+      Linux "${CMTROOT}/mgr/cmt_gcc_version.sh" \
+      SunOS "${CMTROOT}/mgr/cmt_CC_version.sh" \
+      OSF1  "${CMTROOT}/mgr/cmt_cxx_version.sh" \
+      Darwin "${CMTROOT}/mgr/cmt_dcc_version.sh" \
+      HP-UX "echo aCC" \
+      LynxOS "${CMTROOT}/mgr/cmt_gcc_version.sh"
+
+macro_append cmt_compiler_version_query_command " | ${CMTROOT}/mgr/cmt_filter3_version.sh" \
+             rhel3 " | ${CMTROOT}/mgr/cmt_filter3_version.sh" \
+             cel3  " | ${CMTROOT}/mgr/cmt_filter3_version.sh" \
+             WIN32 ""
+
+macro cmt_compiler_version `$(cmt_compiler_version_query_command)` WIN32 "cl"
+
+apply_tag $(cmt_compiler_version)
+
+tag OSF1           Unix
+tag Linux          Unix
+tag HP-UX          Unix
+tag Darwin         Unix
+tag LynxOS         Unix
+tag AIX            Unix
+tag SunOS          Unix
+
+tag CYGWIN_NT-5.1  Unix CYGWIN
+
+tag alpha          OSF1
+tag alpha_dux40    alpha
+tag alpha-debug    alpha debug
+
+tag LynxOS-VGPW2   LynxOS
+tag LynxOS-PowerPC LynxOS
+tag RIO806X        LynxOS
+tag VMTR2X         LynxOS
+
+tag hp9000s780     HP-UX
+tag hp9000s700     HP-UX
+tag hp700_ux101    HP-UX
+tag hp_ux102       HP-UX
+
+tag Linux-i686     Linux
+tag i386_redhat51  Linux
+tag i386_linux22   Linux
+
+tag rs_aix42       AIX
+
+tag sun4u          SunOS
+tag sun4x_57       SunOS
+
+tag rhel3          Linux
+tag cel3           Linux
+tag slc3           Linux
+
+# Alternate possible tags for VisualC
+tag VisualC        WIN32
+tag VisualC        Win32
+tag WIN32          VisualC
+
+# Some alternate definitions for debug on VisualC
+tag VisualCdbg     WIN32 windebug
+tag VisualD        WIN32 windebug
+tag VisualDbg      WIN32 windebug
+tag VisualDebug    WIN32 windebug
+tag VisualD        VisualC windebug
+tag VisualDbg      VisualC windebug
+tag Win32Debug     VisualC windebug
+
+# VSNET tags #
+tag VC7            vsnet
+tag VC7debug       vsnet windebug
+
+tag_exclude WIN32 Unix
+tag_exclude Win32 Unix
+
+#
+#  Global PATH variables management
+#
+
+path_remove  PATH      "CMT/v" \
+             WIN32     "CMT\v"
+
+path_prepend PATH      "${CMTROOT}/${CMTBIN}" \
+             WIN32     "%CMTROOT%\%CMTBIN%"
+
+path_remove  CLASSPATH  "CMT"
+path_append  CLASSPATH  "${CMTROOT}/java" \
+             WIN32      "%CMTROOT%\java"
+
+path_append include    ""
+path_append lib        ""
+
+macro debug_option "-g" \
+      SunOS        "-G" \
+      WIN32        "/G"
+
+#
+#  C environment
+#
+
+macro cc              "gcc" \
+      insure          "insure" \
+      alpha           "cc" \
+      alphat          "cc" \
+      HP-UX           "aCC" \
+      hp700_ux101     "gcc" \
+      AIX             "xlc" \
+      SunOS           "cc" \
+      VisualC         "cl.exe" \
+      Darwin          "cc"
+
+macro cdebugflags     "" \
+      debug           "$(debug_option)"
+
+macro cflags          "" \
+      LynxOS-VGPW2    "-X" \
+      insure          "-std1" \
+      HP-UX           "+Z" \
+      hp700_ux101     "-fpic -ansi" \
+      alpha           "-std1" \
+      alphat          "-std1" \
+      SunOS           "-KPIC" \
+      VisualC         '/nologo /DWIN32 /MD /W3 $(includes) /c'
+
+macro pp_cflags       "" \
+      LynxOS-VGPW2    "-DVGPW2" \
+      HP-UX           "-D_HPUX_SOURCE" \
+      alphat          "-DCTHREADS" \
+      AIX             "-D_ALL_SOURCE -D_BSD"
+
+macro ccomp           "$(cc) -c $(includes) $(cdebugflags) $(cflags) $(pp_cflags)" \
+      VisualC         "cl.exe $(cdebugflags) $(cflags) $(pp_cflags)"
+
+macro clinkflags      ""
+
+macro clink           "$(cc) $(clinkflags) $(cdebugflags)" \
+      VisualC         "link.exe /nologo /machine:IX86 "
+
+
+#
+#  Developper Studio environment
+#
+
+macro msdevdll          "" \
+      VisualC           "/dll"
+
+macro msdevdllflags   "" \
+      VisualC         '/MT /D "_USRDLL" /D "WDLL_EXPORTS"' \
+      VisualD         '/MTd /D "_USRDLL" /D "WDLL_EXPORTS"'
+
+macro vsCONFIG        "" \
+      VC7             "Release" \
+      VC7debug        "Debug"
+
+macro vsOptimize      "" \
+      VC7             "2" \
+      VC7debug        "0"
+
+
+#
+#  C++ environment
+#
+
+macro ppcmd           "-I" \
+      rs_aix41        "-WF,-I" \
+      VisualC         "/I "
+
+macro preproc         "g++ -MD -c " \
+      insure          "insure" \
+      alpha           "cxx" \
+      OSF1            "g++" \
+      HP-UX           "aCC" \
+      hp700_ux101     "g++" \
+      hp_ux102        "aCC" \
+      AIX             "xlC" \
+      Linux           "c++ -MD -c " \
+      SunOS           "CC" \
+      VisualC         "cl.exe" \
+      Darwin          "c++"
+
+macro cpp             "g++" \
+      insure          "insure" \
+      alpha           "cxx" \
+      OSF1            "g++" \
+      HP-UX           "aCC" \
+      hp700_ux101     "g++" \
+      hp_ux102        "aCC" \
+      AIX             "xlC" \
+      Linux           "c++" \
+      SunOS           "CC" \
+      VisualC         "cl.exe" \
+      Darwin          "c++"
+
+macro cppdebugflags   "" \
+      debug           "$(debug_option)"
+
+macro cppflags        "" \
+      alpha           "-nocompress -std arm -msg_quiet" \
+      OSF1            "-fpic" \
+      hp9000s780      "+Z" \
+      hp700_ux101     "-fpic" \
+      HP-UX           "+Z -Wc,-ansi_for_scope,on" \
+      hp_ux102        "-z +p -Wc,-ansi_for_scope,on +O2 +Onoinitcheck" \
+      Linux           "-pipe -ansi -pedantic -W -Wall -Wwrite-strings -Wpointer-arith -Woverloaded-virtual " \
+      SunOS           "-KPIC" \
+      VisualC         '/nologo /DWIN32 /MD /W3 $(includes) /c /EHsc'
+
+macro pp_cppflags     "" \
+      HP-UX           "-D_HPUX_SOURCE" \
+      Linux           "-D_GNU_SOURCE"
+
+macro cppcomp         "$(cpp) -c $(includes) $(cppdebugflags) $(cppflags) $(pp_cppflags)" \
+      VisualC         "cl.exe $(cppdebugflags) $(cppflags) $(pp_cppflags)"
+
+macro cpplinkflags    ""
+
+macro cpplink         "$(cpp) $(cpplinkflags) $(cppdebugflags)" \
+      VisualC         "link.exe /nologo /machine:I386"
+
+macro cpp_linkopts    "" \
+      OSF1            " -lstdc++ " \
+      alpha           " /usr/lib/cmplrs/cxx/libcxx.a -lcxxstd -lexc -lm " \
+      alphat          " /usr/lib/cmplrs/cxx/libcxx.a -lcxxstd -lexc -lm "
+
+#
+#  Fortran environment
+#
+
+macro for             "f77" \
+      HP-UX           "fort77" \
+      rs_aix41        "xlf" \
+      Linux           "g77"
+
+macro fflags          "$(debug_option)" \
+      VisualC         ""
+
+macro fcomp           "$(for) -c $(fincludes) $(fflags) $(pp_fflags)" \
+      VisualC         ""
+
+macro flink           "$(for) $(flinkflags)"
+
+#
+#  Java environment
+#
+
+macro javacomp        "javac -classpath $(src):$(CLASSPATH) "
+macro javacopy        "cp"    VisualC "copy"
+macro jar             "jar"
+
+#
+#  X11 environment
+#
+
+macro X11_cflags      "-I/usr/include" \
+      HP-UX           "-I/usr/include/X11R5" \
+      SunOS           "-I/usr/motif/usr/include" \
+      VisualC         ""
+
+macro Xm_cflags       "-I/usr/include" \
+      HP-UX           "-I/usr/include/Motif1.2" \
+      SunOS           "-I/usr/motif/usr/include" \
+      VisualC         ""
+
+####      hp9000s700      "/usr/lib/Motif1.2/libXm.sl /usr/lib/X11R5/libXt.sl /usr/lib/X11R5/libX11.sl"
+
+macro X_linkopts      ""\
+      alpha           "-lXm -lXmu -lXt -lXext -lX11 -ldnet_stub -lm -lots"\
+      OSF1            "-lXm -lXmu -lXt -lXext -lX11 -ldnet_stub -lm -lots"\
+      insure          "-lXm -lXmu -lXt -lXext -lX11 -ldnet_stub -lm -lots"\
+      HP-UX           "-L/usr/lib -lXm -L/usr/contrib/X11R6/lib -lXmu -lXt -lXext -lX11" \
+      SunOS           "-L/usr/motif/usr/lib -lXm -lXt -lX11 -lm"\
+      LynxOS          "-lXt -lX11 -lm"\
+      Linux           "-L/usr/X11R6/lib -lXm -lXt -lXext -lX11 -lm"\
+      RIO806X         "-lXm -lXt -lXext -lX11 -lm"\
+      VGPW2           "-lXm -lXt -lXext -lX11 -lm"\
+      m68k            "-lXm -lXt -lXext -lX11 -lm"\
+      IRIX            "/usr/lib/libXm.so /usr/lib/libXt.so /usr/lib/libX11.so -lm -lPW"\
+      AIX             "/usr/lib/libXm.a /usr/lib/libXt.a /usr/lib/libX11.a -lm" \
+      VisualC         ""
+
+#
+# Lex environment
+#
+
+macro lexflags        ""
+macro lex             "lex $(lexflags)" \
+      i686            "flex $(lexflags)"
+
+#
+# Yacc environment
+#
+
+macro yaccflags       " -l -d " \
+      VisualC         ""
+
+macro yacc            "yacc $(yaccflags)"
+
+#
+#  Archive environment
+#
+
+macro ar              "ar -clr" \
+      SunOS           "ar clr" \
+      VGPW2           "ar clr" \
+      m68k            "ar clr" \
+      LynxOS          "ar clr" \
+      RIO806X         "ar clr" \
+      Linux           "ar r" \
+      VisualC         "lib.exe /nologo "
+
+macro ranlib          "ranlib" \
+      SunOS           "ar ts" \
+      VGPW2           "ar ts" \
+      m68k            "ranlib" \
+      RIO806X         "ranlib" \
+      LynxOS          "ar ts" \
+      IRIX            "ar ts"
+
+macro make_shlib    "echo" \
+      HP-UX         "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
+      OSF1          "${CMTROOT}/mgr/cmt_make_shlib_common.sh noextract" \
+      Linux         "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
+      CYGWIN        "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
+      SunOS         "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
+      Darwin        "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
+      VisualC       "%CMTROOT%\mgr\cmt_make_shlib.bat"
+
+macro shlibsuffix   "" \
+      HP-UX         "sl" \
+      OSF1          "so" \
+      SunOS         "so" \
+      Linux         "so" \
+      CYGWIN        "dll" \
+      Darwin        "dylib" \
+      WIN32         "dll"
+
+macro shlibbuilder  "" \
+      HP-UX         "aCC" \
+      OSF1          "ld" \
+      SunOS         "CC" \
+      Linux         "g++" \
+      CYGWIN        "g++" \
+      Darwin        "c++"
+
+macro shlibflags    "" \
+      HP-UX         "-Wl,-a,shared -b +Z -q -Wl,+s -Wl,+vallcompatwarnings" \
+      OSF1          "-shared -expect_unresolved '*'" \
+      Linux         "-shared" \
+      CYGWIN        "-shared" \
+      SunOS         "$(debug_option)" \
+      VisualC       "" \
+      Darwin        "-dynamiclib -flat_namespace -undefined suppress "
+
+macro symlink       "/bin/ln -fs " \
+      VisualC       ""
+
+macro symunlink     "/bin/rm -f " \
+      VisualC       ""
+
+macro library_install_command "${symlink}" \
+      VisualC                 "copy "
+
+macro build_library_links  "$(cmtexe) build library_links -quiet -tag=$(tags)"
+macro remove_library_links "$(cmtexe) remove library_links -quiet -tag=$(tags)"
+
+#
+# Prototype and dependency generation
+#
+
+macro cmtexe             "${CMTROOT}/${CMTBIN}/cmt.exe" \
+      WIN32              "%CMTROOT%\%CMTBIN%\cmt.exe" 
+
+##macro tags               "$(CMTEXTRATAGS)"
+
+macro build_prototype    "$(cmtexe) build prototype"
+macro build_dependencies "$(cmtexe) -quiet -tag=$(tags) build dependencies"
+macro build_triggers     "$(cmtexe) build triggers"
+
+macro implied_library_prefix "-l" \
+      LynxOS                 "$(<PACKAGE>ROOT)/$(bin)/lib"
+
+macro implied_library_suffix "" \
+      VisualC                ".lib" \
+      LynxOS                 ".a"
+
+#
+# Generic environments
+#
+
+macro SHELL           "/bin/sh" WIN32 "cmd"
+
+macro q               '"'
+macro src             "../src/" WIN32 "..\src\"
+macro doc             "../doc/" WIN32 "..\doc\"
+macro inc             "../src/" WIN32 "..\src\"
+macro mgr             "../mgr/" WIN32 "..\mgr\"
+##macro javabin         "../classes/"
+
+macro application_suffix ".exe"
+macro library_prefix "lib" WIN32 "" CYGWIN ""
+macro library_suffix ""
+
+macro lock_command "chmod -R a-w ../*" \   
+      VisualC      "attrib /S /D +R ..\*"
+
+macro unlock_command "chmod -R g+w ../*" \   
+      VisualC      "attrib /S /D -R ..\*"
+
+macro preprocessor_command "" \
+      VisualC              ""
+
+macro_append MAKEFLAGS " --no-print-directory "
+
+#macro_prepend constituents " configclean "
+
+#
+# Remote definitions
+#
+
+macro gmake_hosts "lx1 rsplus lxtest as7 dxplus ax7 hp2 aleph hp1 hpplus papou1-fe atlas"
+
+macro make_hosts  "virgo-control1 rio0a vmpc38a"
+
+macro everywhere  "hosts" \
+      LAL         "as7 lx1 virgo-control1 papou1-fe hp2 aleph hp1" \
+      LHCb        "lxtest hpplus dxplus rsplus" \
+      Atlas       "lxplus sundev" \
+      Cascina     "ax7 vmpc38a rio0a"
+
+
+#
+#  Fragments
+#
+
+make_fragment make_header
+make_fragment library_header
+make_fragment application_header
+make_fragment document_header
+make_fragment java_header
+make_fragment jar_header
+make_fragment protos_header
+make_fragment buildproto
+make_fragment library
+make_fragment library_no_share
+make_fragment application
+make_fragment jar
+make_fragment java
+make_fragment java_copy
+make_fragment cleanup_header
+make_fragment cleanup
+make_fragment cleanup_library
+make_fragment cleanup_application
+make_fragment cleanup_java
+make_fragment cleanup_objects
+
+make_fragment fortran
+make_fragment c
+make_fragment cpp
+make_fragment lex
+make_fragment yacc
+
+make_fragment fortran_library
+make_fragment c_library
+make_fragment cpp_library
+make_fragment lex_library
+make_fragment yacc_library
+
+make_fragment dsw_header
+make_fragment dsw_project
+make_fragment dsw_trailer
+make_fragment dsw_all_project_header
+make_fragment dsw_all_project_dependency
+make_fragment dsw_all_project_trailer
+
+make_fragment dsp_library_header
+make_fragment dsp_shared_library_header
+make_fragment dsp_application_header
+make_fragment dsp_windows_header
+make_fragment dsp_contents
+make_fragment dsp_trailer
+make_fragment dsp_all
+
+# vsnet fragments
+make_fragment vcproj_library_header
+make_fragment vcproj_application_header
+make_fragment vcproj_all
+make_fragment vcproj_trailer
+make_fragment vcproj_contents
+make_fragment vcproj_directory_header
+make_fragment vcproj_directory_trailer
+
+make_fragment sln_header
+make_fragment sln_project
+make_fragment sln_trailer
+make_fragment sln_project_config
+make_fragment sln_dependency_project
+
+make_fragment sln_dependency_header
+make_fragment sln_dependency_trailer
+
+#### all packages have same GUID, and the "all" project as well
+
+macro GUID_all     "" vsnet {DD1EDB1B-B098-44F8-8012-3039B5A56FEF}
+macro package_GUID "" vsnet {8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}
+
+make_fragment make_setup
+make_fragment make_setup_header
+
+make_fragment constituents_header
+make_fragment group
+make_fragment constituent
+make_fragment constituents_trailer
+
+make_fragment dependencies
+make_fragment dependencies_and_triggers
+
+make_fragment readme_header
+make_fragment readme
+make_fragment readme_doc
+make_fragment readme_use
+make_fragment readme_trailer
+
+make_fragment tex -header=tex_header -suffix=ps
+
+make_fragment check_application
+make_fragment check_java
+make_fragment check_application_header
+
+make_fragment application_launcher -header=application_launcher_header
+
+make_fragment install_includes -header=install_includes_header
+
+macro install_command "cp " \
+      WIN32           "xcopy /S /E /Y " 
+
+macro uninstall_command "/bin/rm -f " \
+      WIN32             "del "
+
+macro cmt_installarea_command "ln -fs " \
+      WIN32                   "xcopy /S /E /Y "
+
+macro cmt_uninstallarea_command "/bin/rm -f " \
+      WIN32                     "del "
+
+macro cmt_install_area_command "$(cmt_installarea_command)"
+macro cmt_uninstall_area_command "$(cmt_uninstallarea_command)"
+
+macro cmt_install_action       "$(CMTROOT)/mgr/cmt_install_action.sh" \
+      WIN32                    "$(CMTROOT)\mgr\cmt_install_action.bat"
+
+macro cmt_installdir_action    "$(CMTROOT)/mgr/cmt_installdir_action.sh" \
+      WIN32                    "$(CMTROOT)\mgr\cmt_installdir_action.bat"
+
+macro cmt_uninstall_action     "$(CMTROOT)/mgr/cmt_uninstall_action.sh" \
+      WIN32                    "$(CMTROOT)\mgr\cmt_uninstall_action.bat"
+
+macro cmt_uninstalldir_action  "$(CMTROOT)/mgr/cmt_uninstalldir_action.sh" \
+      WIN32                    "$(CMTROOT)\mgr\cmt_uninstalldir_action.bat"
+
+macro cmt_installdir_excludes  "" WIN32 "$(CMTROOT)\mgr\cmt_installdir_excludes.txt"
+
+action make "gmake $(cmt_args)" Darwin "make $(cmt_args)" CYGWIN "make $(cmt_args)" WIN32 "nmake /f nmake $(cmt_args)"
+
+macro mkdir  "mkdir" \
+      LynxOS "mkdir -f"
+
+#-----------------------------------------------------------------
+# Generic copy facility
+#   It is customized through the parameter:
+#     install_dir="<path where to install the sources>"
+#
+make_fragment installer -header=installer_header
+
+
+#-----------------------------------------------------------------
+# Generic usage of the cmt expand model facility
+#   the fragment is customized through the following parameters:
+#    model="<model text string>"
+#    out="<output file name>"
+#
+make_fragment generator -header=generator_header
+
+#-----------------------------------------------------------------
+# Generic action runner
+#
+make_fragment cmt_action_runner -header=cmt_action_runner_header
+
+#
+# The supported languages
+#
+
+language fortran -suffix=f -suffix=F -preprocessor_command=$(ppcmd) -linker=$(flink)
+language c       -suffix=c -prototypes -linker=$(clink)
+language c++     -suffix=C -suffix=cc -suffix=cxx -suffix=cpp -fragment=cpp -linker=$(cpplink)
+language java    -suffix=java -linker=java
+language yacc    -suffix=y -prototypes -linker=$(clink)
+language lex     -suffix=l -prototypes -linker=$(clink)
+
+#
+# Protocol level for the CVS pluggin
+#
+
+macro cmt_cvs_protocol_level "v1r1"
+
+#
+# The CMTPATH patterns for installation areas
+#
+
+macro cmt_installarea_prefix "InstallArea"
+
+cmtpath_pattern \
+  macro cmt_installarea_paths        " $(cmt_installarea_prefix)/$(CMTCONFIG)/bin" ; \
+  macro_prepend use_linkopts         " $(cmt_installarea_linkopts) " ; \
+  macro_append shlibbuilder          " $(cmt_installarea_linkopts) "
+
+cmtpath_pattern \
+  macro_append cmt_installarea_paths "" <project>_with_installarea " $(<project>_installarea_prefix)/$(CMTCONFIG)/lib" ; \
+  macro_append cmt_installarea_paths "" <project>_with_installarea " $(<project>_installarea_prefix)/share/lib" ; \
+  macro_append cmt_installarea_paths "" <project>_with_installarea " $(<project>_installarea_prefix)/share/bin"
+  
+macro CMT_PATH_remove_regexp "/[^/]*/" WIN32 "\\[^\\]*\\"
+macro CMT_PATH_remove_share_regexp "/share/" WIN32 "\\share\\"
+
+cmtpath_pattern \
+  macro <project>_installarea_prefix "$(cmt_installarea_prefix)" ; \
+  macro <project>_installarea_prefix_remove "$(<project>_installarea_prefix)" ; \
+  path_remove_regexp PATH "" <project>_with_installarea "$(<project>_installarea_prefix_remove)$(CMT_PATH_remove_regexp)bin$" ; \
+  path_remove_regexp PATH "" <project>_with_installarea "$(<project>_installarea_prefix_remove)$(CMT_PATH_remove_regexp)lib$" ; \
+  path_remove_regexp LD_LIBRARY_PATH "" <project>_with_installarea "$(<project>_installarea_prefix_remove)/[^/]*/lib$"  ; \
+  path_remove_regexp CLASSPATH "" <project>_with_installarea "$(<project>_installarea_prefix_remove)$(CMT_PATH_remove_share_regexp)lib$" ; \
+  path_remove_regexp CLASSPATH "" <project>_with_installarea "$(<project>_installarea_prefix_remove)$(CMT_PATH_remove_share_regexp)bin$"
+
+cmtpath_pattern \
+  path_prepend PATH "" \
+               <project>_with_installarea&WIN32 "<path>/$(<project>_installarea_prefix)/${CMTCONFIG}/bin" \
+               <project>_with_installarea&Unix "<path>/$(<project>_installarea_prefix)/${CMTCONFIG}/bin" ; \
+  path_prepend PATH "" \
+               <project>_with_installarea&WIN32 "<path>/$(<project>_installarea_prefix)/${CMTCONFIG}/lib" \
+               <project>_with_installarea&CYGWIN "<path>/$(<project>_installarea_prefix)/${CMTCONFIG}/lib" ; \
+  path_prepend LD_LIBRARY_PATH "" \
+               <project>_with_installarea&Unix "<path>/$(<project>_installarea_prefix)/${CMTCONFIG}/lib" ; \
+  macro_prepend cmt_installarea_linkopts "" \
+                <project>_without_installarea "" \
+                <project>_with_installarea&Unix " -L<path>/$(<project>_installarea_prefix)/$(CMTCONFIG)/lib " \
+                <project>_with_installarea&WIN32 " /LIBPATH:<path>\$(<project>_installarea_prefix)\$(CMTCONFIG)\lib "                 
+    
+set NEWCMTCONFIG "${cmt_hardware}-${cmt_system_version}-${cmt_compiler_version}"
+
+#
+# The cmt constituent
+#
+
+application cmt -s=../source cmt.cxx \
+cmt_awk.cxx \
+cmt_branch.cxx \
+cmt_constituent.cxx \
+cmt_deps_builder.cxx \
+cmt_fragment.cxx \
+cmt_generator.cxx \
+cmt_include.cxx \
+cmt_parser.cxx \
+cmt_script.cxx \
+cmt_string.cxx \
+cmt_system.cxx \
+cmt_tag.cxx \
+cmt_use.cxx \
+cmt_symbol.cxx \
+cmt_error.cxx \
+cmt_pattern.cxx \
+cmt_language.cxx \
+cmt_cvs.cxx \
+cmt_group.cxx \
+cmt_database.cxx \
+cmt_lock.cxx \
+cmt_triggers.cxx \
+cmt_regexp.cxx \
+cmt_model.cxx \
+cmt_project.cxx \
+cmt_syntax.cxx \
+cmt_install_area.cxx \
+cmt_cmtpath_pattern.cxx \
+cmt_sequence.cxx \
+cmt_generators.cxx \
+cmt_scope_section.cxx \
+cmt_log.cxx \
+cmt_commands.cxx
+
+private
+
+macro all_constituents cmt
+
+macro_append cpplink "" VisualC " advapi32.lib "
Index: /CMT/v1r20/mgr/srt2cmt.sh
===================================================================
--- /CMT/v1r20/mgr/srt2cmt.sh	(revision 368)
+++ /CMT/v1r20/mgr/srt2cmt.sh	(revision 368)
@@ -0,0 +1,161 @@
+#!/bin/sh -f
+
+set -x
+
+#----------------------------------------------------------
+build_version ()
+#----------------------------------------------------------
+{
+  #
+  # arg1 = "version"
+  # arg2 = DetectorDescription-00-00-11:19990122114459 
+  #
+  #   Convert a-b-c into v<b>r<c>
+  #
+  #   (might be v<a>r<b>p<c> instead)
+  #
+
+  #tag=`echo $2 | cut -d':' -f1 | cut -d'-' -f3-4`
+  #version=`echo $tag | cut -d'-' -f1 | sed 's#^0##'`
+  #release=`echo $tag | cut -d'-' -f2 | sed 's#^0##'`
+  #echo v${version}r${release}
+
+  echo "v2r1"
+}
+
+#----------------------------------------------------------
+install_cvs ()
+#----------------------------------------------------------
+{
+  #
+  # Install all required management files for a directory.
+  #
+  #   CVS/Entries     (empty)
+  #   CVS/Root        (filled in with current $CVSROOT)
+  #   CVS/Repository  (filled in with current $CVSROOT/$1)
+  #
+  repository=$1
+
+  if test ! -d CVS ; then
+    mkdir CVS
+  fi
+
+  if test ! -d CVS/Entries ; then
+    cat <<END >CVS/entries
+END
+  fi
+
+  if test ! -d CVS/Root ; then
+    cat <<END >CVS/Root
+${CVSROOT}
+END
+  fi
+
+  if test ! -d CVS/Repository ; then
+    cat <<END >CVS/Repository
+${CVSROOT}/${repository}
+END
+  fi
+
+}
+
+#----------------------------------------------------------
+install_cvs_branch ()
+#----------------------------------------------------------
+{
+  #
+  #  Manually add a branch entry in the CVS/Entries file
+  #  (avoid duplications)
+  #
+  branch=$1
+
+  a=`egrep -e "/${branch}/" CVS/Entries`
+
+  if test "${a}" = "" ; then
+    cat <<END >>CVS/Entries
+D/${branch}////
+END
+  fi
+}
+
+#----------------------------------------------------------
+do_help ()
+#----------------------------------------------------------
+{
+  cat <<END
+ > srt2cmt.sh <package> <package> ...
+
+ Checkout packages (commited using the SRT organisation) from CVS,
+ and install them using the cmt organisation.
+
+ The following conventions are used :
+
+ files from :           go to :
+ <package>/             <package>/<version>/cmt/
+ <package>/<branch>/    <package>/<version>/<branch>/
+
+END
+}
+
+#----------------------------------------------------------
+work ()
+#----------------------------------------------------------
+{
+  target=$1
+
+  echo "================= working in target ${target}"
+
+  for package_file in `find ${root}/${target} -name PACKAGE,v -print` ; do
+
+    echo "================= working on package_file ${package_file}"
+
+    package=`dirname ${package_file} | sed -e "s#${root}/##"`
+
+    echo "================= package is ${package}"
+
+    cd ${home_dir}
+
+    #
+    #  First of all export the PACKAGE file to get basic infos (version)
+    # about the package.
+    #
+    mkdir -p ${package}
+    cvs export -r HEAD -d ${package} offline/${package}/PACKAGE
+
+    tag=`grep version ${package}/PACKAGE` 
+    title=`grep title ${package}/PACKAGE` 
+    author=`grep author ${package}/PACKAGE` 
+
+    echo ${tag} ${title} ${author}
+
+    /bin/rm -f ${package}/PACKAGE
+
+  done
+}
+
+#----------------------------------------------------------
+# main ()
+#----------------------------------------------------------
+
+#if test "$#" = "0" ; then
+#  do_help
+#  exit 1
+#fi
+
+case "$1" in
+  --help)
+	  do_help
+	  exit 1
+	  ;;
+esac
+
+home_dir=`pwd`
+
+root=$CVSROOT/offline
+
+#for target in $* ; do
+#done
+
+work
+
+
Index: /CMT/v1r20/mgr/tag.nmake
===================================================================
--- /CMT/v1r20/mgr/tag.nmake	(revision 368)
+++ /CMT/v1r20/mgr/tag.nmake	(revision 368)
@@ -0,0 +1,65 @@
+PATH=C:\dev\CMT\v1r11\%CMTBIN%;C:\W2000\system32;C:\W2000;C:\W2000\System32\Wbem;C:\Program Files\IBM\AFS\Common;C:\Program Files\IBM\AFS\Client\Program;C:\Program Files\Microsoft Visual Studio\Common\Tools\WinNT;C:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin;C:\Program Files\Microsoft Visual Studio\Common\Tools;C:\Program Files\Microsoft Visual Studio\VC98\bin;C:\jdk1.3\bin;C:\Program Files\graphviz\bin; 
+CLASSPATH=C:\dev\CMT\v1r11\java 
+include=C:\Program Files\Microsoft Visual Studio\VC98\atl\include;C:\Program Files\Microsoft Visual Studio\VC98\mfc\include;C:\Program Files\Microsoft Visual Studio\VC98\include 
+lib=C:\Program Files\Microsoft Visual Studio\VC98\mfc\lib;C:\Program Files\Microsoft Visual Studio\VC98\lib 
+cc=cl.exe 
+cflags=/nologo /DWIN32 /MD /W3 $(includes) /c 
+ccomp=cl.exe $(cdebugflags) $(cflags) $(pp_cflags) 
+clink=link.exe /nologo /machine:IX86  
+msdevdll=/dll 
+msdevdllflags=/MT /D "_USRDLL" /D "WDLL_EXPORTS" 
+ppcmd=/I  
+cpp=cl.exe 
+cppflags=/nologo /DWIN32 /MD /W3 $(includes) /c 
+cppcomp=cl.exe $(cppdebugflags) $(cppflags) $(pp_cppflags) 
+cpplink=link.exe /nologo /machine:I386 advapi32.lib  
+for=f77 
+flink=$(for) $(flinkflags) 
+javacomp=javac 
+javacopy=copy 
+jar=jar 
+lex=lex $(lexflags) 
+yacc=yacc $(yaccflags) 
+ar=lib.exe /nologo  
+ranlib=ranlib 
+make_shlib=%CMTROOT%\mgr\cmt_make_shlib.bat 
+build_library_links=$(cmtexe) build library_links -quiet -tag=$(tags) 
+remove_library_links=$(cmtexe) remove library_links -quiet -tag=$(tags) 
+cmtexe=%CMTROOT%\%CMTBIN%\cmt.exe 
+tags=${CMTEXTRATAGS} 
+build_prototype=$(cmtexe) build prototype 
+build_dependencies=$(cmtexe) -quiet -tag=$(tags) build dependencies 
+build_triggers=$(cmtexe) build triggers 
+implied_library_prefix=$(<PACKAGE>ROOT)/$(bin)/ 
+implied_library_suffix=.lib 
+SHELL=/bin/sh 
+src=..\src\ 
+doc=..\doc\ 
+inc=..\src\ 
+mgr=../mgr/ 
+application_suffix=.exe 
+lock_command=attrib /S /D +R ..\* 
+unlock_command=attrib /S /D -R ..\* 
+MAKEFLAGS= --no-print-directory  
+gmake_hosts=lx1 rsplus lxtest as7 dxplus ax7 hp2 aleph hp1 hpplus papou1-fe atlas 
+make_hosts=virgo-control1 rio0a vmpc38a 
+everywhere=hosts 
+install_command=copy /Y  
+uninstall_command=del  
+mkdir=mkdir 
+all_constituents=cmt $(constituents) 
+tag=VisualC 
+CMT_tag=$(tag) 
+CMTROOT=C:\dev\CMT\v1r11 
+CMT_root=C:\dev\CMT\v1r11 
+CMTVERSION=v1r11 
+PACKAGE_ROOT=$(CMTROOT) 
+srcdir=..\src 
+bin=..\$(CMT_tag)\ 
+javabin=..\classes\ 
+mgrdir=mgr 
+version=v1r11 
+package=CMT 
+constituents= cmt  
+constituentsclean= cmtclean  
+all_constituentsclean= $(constituentsclean) 
Index: /CMT/v1r20/source/cmt.cxx
===================================================================
--- /CMT/v1r20/source/cmt.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt.cxx	(revision 368)
@@ -0,0 +1,21 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt.h"
+
+#include <stdlib.h>
+
+/*----------------------------------------------------------*/
+int main (int argc, char* argv[])
+/*----------------------------------------------------------*/
+{
+   //cout << "argc=" << argc << endl;
+  int status = Cmt::parser (argc, argv);
+  if (status !=0) return -1;
+  return (status);
+}
+
Index: /CMT/v1r20/source/cmt.h
===================================================================
--- /CMT/v1r20/source/cmt.h	(revision 368)
+++ /CMT/v1r20/source/cmt.h	(revision 368)
@@ -0,0 +1,262 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_h__
+#define __cmt_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+
+class ArgParser;
+class Symbol;
+class Tag;
+
+class CmtContext
+{
+public:
+
+  CmtContext ();
+  ~CmtContext ();
+
+  void clear ();
+
+  ActionType m_action;
+  bool m_build_nmake;
+  cmt_string m_cmt_config;
+  cmt_string m_cmt_root;
+  cmt_string m_cmt_home;
+  cmt_string m_cmt_user_context;
+  cmt_string m_cmt_site;
+  cmt_string m_cmt_version;
+  
+  cmt_string m_current_dir;
+  cmt_string m_current_package;
+  cmt_string m_current_config;
+  cmt_string m_current_path;
+  cmt_string m_current_prefix;
+  cmt_string m_current_cmtpath;
+  cmt_string m_current_offset;
+  
+  AccessMode m_current_access;
+  CmtDirStyle m_current_style;
+  CmtStructuringStyle m_current_structuring_style;
+  
+  cmt_string m_current_tag;
+  cmt_string m_current_target;
+  cmt_string m_current_version;
+  
+  cmt_string m_extra_tags;
+  cmt_string m_configure_error;
+  
+  bool m_debug;
+  
+  cmt_string m_default_path;
+  bool m_quiet;
+  bool m_disable_warnings;
+  bool m_warnings;
+  bool m_recursive;
+  CmtScopeFilteringMode m_scope_filtering_mode;
+  bool m_simulation;
+  bool m_standard_macros_done;
+  bool m_all_sets_done;
+
+  bool m_autoconfigure_cmtpath;
+};
+
+class Cmt
+{
+public:
+  static void build_config (const cmt_string& prefix, cmt_string& config);
+  static void build_makefile (const cmt_string& target);
+  static void build_msdev_file (const cmt_string& target);
+  // Visual Studio.Net Support                            
+  static void build_vsnet_file (const cmt_string& target);
+
+  static bool build_nmake ();
+  static void build_OS9_makefile (const cmt_string& target);
+  static void build_prefix (const cmt_string& package, cmt_string& prefix);
+  static void clear ();
+
+  static void configure ();
+  static void configure_cmt_path (Use* use);
+  static void configure_config_tag ();
+  static void configure_current_cmtpath ();
+  static void configure_current_dir ();
+  static void configure_current_package ();
+  static void configure_current_structuring_style ();
+  static void configure_default_path ();
+  static void configure_home (Use* use);
+  static void configure_user_context (Use* use);
+  static void configure_hosttype_tag ();
+  static void configure_site_tag (Use* use);
+  static void configure_tags (Use* use);
+  static void configure_uname_tag ();
+  static void configure_version_tag ();
+
+  static void do_awk (const ArgParser& ap);
+  static void do_broadcast (const ArgParser& ap);
+  static void do_build_constituent_makefile (const ArgParser& ap);
+  static void do_build_constituents_makefile (const ArgParser& ap);
+  static void do_build_dependencies (const ArgParser& ap,
+                                     int argc,
+                                     char* argv[]);
+  static void do_build_library_links (const ArgParser& ap);
+  static void do_build_make_setup (const ArgParser& ap);
+  static void do_build_msdev (const ArgParser& ap);
+  static void do_build_CMT_pacman (const ArgParser& ap);
+  // Visual Studio.Net Support                                               
+  static void do_build_vsnet (const ArgParser& ap);
+
+  static void do_build_os9_makefile (const ArgParser& ap);
+  static void do_build_prototype (const ArgParser& ap);
+  static void do_build_readme (const ArgParser& ap);
+  static void do_build_tag_makefile (const ArgParser& ap);
+  static void do_build_temporary_name (const ArgParser& ap);
+  static void do_build_triggers (const ArgParser& ap);
+  static void do_build_windefs (const ArgParser& ap);
+  static void do_check_configuration (const ArgParser& ap);
+  static void do_check_files (const ArgParser& ap);
+  static void do_check_version (const ArgParser& ap);
+  static void do_checkout (const ArgParser& ap);
+  static void do_cleanup (const ArgParser& ap);
+  static void do_config (const ArgParser& ap);
+  static void do_create (const ArgParser& ap);
+  static void do_create_project (const ArgParser& ap);
+  static void do_cvsbranches (const ArgParser& ap);
+  static void do_cvssubpackages (const ArgParser& ap);
+  static void do_cvssubprojects (const ArgParser& ap);
+  static void do_cvstags (const ArgParser& ap);
+  static void do_do (const ArgParser& ap);
+  static void do_expand_model (const ArgParser& ap);
+  static void do_filter       (const ArgParser& ap);
+  static void do_help         (const ArgParser& ap);
+  static void do_lock         (const ArgParser& ap);
+  static void do_relocate     (const ArgParser& ap);
+  static void do_remove       (const ArgParser& ap);
+  static void do_remove_library_links (const ArgParser& ap);
+  static void do_run (const ArgParser& ap);
+  static void do_run_sequence (const ArgParser& ap);
+
+  static void do_set_version (const ArgParser& ap);
+  static void do_set_versions (const ArgParser& ap);
+
+  static void do_setup (const ArgParser& ap);
+  static void do_show_action (const ArgParser& ap);
+  static void do_show_action_names (const ArgParser& ap);
+  static void do_show_action_value (const ArgParser& ap);
+  static void do_show_actions (const ArgParser& ap);
+  static void do_show_all_tags (const ArgParser& ap);
+  static void do_show_applied_patterns (const ArgParser& ap);
+  static void do_show_author (const ArgParser& ap);
+  static void do_show_branches (const ArgParser& ap);
+  static void do_show_clients (const ArgParser& ap);
+  static void do_show_cmtpath_patterns (const ArgParser& ap);
+  static void do_show_constituent (const ArgParser& ap);
+  static void do_show_constituent_names (const ArgParser& ap);
+  static void do_show_constituents (const ArgParser& ap);
+  static void do_show_cycles (const ArgParser& ap);
+  static void do_show_fragment (const ArgParser& ap);
+  static void do_show_fragments (const ArgParser& ap);
+  static void do_show_groups (const ArgParser& ap);
+  static void do_show_include_dirs (const ArgParser& ap);
+  static void do_show_language (const ArgParser& ap);
+  static void do_show_languages (const ArgParser& ap);
+  static void do_show_macro (const ArgParser& ap);
+  static void do_show_macro_names (const ArgParser& ap);
+  static void do_show_macro_value (const ArgParser& ap);
+  static void do_show_macros (const ArgParser& ap);
+  static void do_show_manager (const ArgParser& ap);
+  static void do_show_packages (const ArgParser& ap);
+  static void do_show_path (const ArgParser& ap);
+  static void do_show_pattern (const ArgParser& ap);
+  static void do_show_pattern_names (const ArgParser& ap);
+  static void do_show_patterns (const ArgParser& ap);
+  static void do_show_projects (const ArgParser& ap);
+  static void do_show_project_author (const ArgParser& ap);  
+  static void do_show_pwd (const ArgParser& ap);
+  static void do_show_setup (const ArgParser& ap);
+  static void do_show_set (const ArgParser& ap);
+  static void do_show_set_names (const ArgParser& ap);
+  static void do_show_set_value (const ArgParser& ap);
+  static void do_show_sets (const ArgParser& ap);
+  static void do_show_strategies (const ArgParser& ap);
+  static void do_show_tags (const ArgParser& ap);
+  static void do_show_use_paths (const ArgParser& ap);
+  static void do_show_uses (const ArgParser& ap);
+  static void do_show_version (const ArgParser& ap);
+  static void do_show_versions (const ArgParser& ap);
+  static void do_show_system (const ArgParser& ap);
+  static void do_unlock (const ArgParser& ap);
+  static void do_version (const ArgParser& ap);
+
+
+  static const cmt_string& filter_dir (const cmt_string& dir);
+
+  static ActionType get_action ();
+
+  static const cmt_string& get_cmt_home ();
+  static const cmt_string& get_cmt_user_context ();
+  static const cmt_string& get_cmt_version ();
+  static const cmt_string& get_current_dir ();
+  static const cmt_string& get_current_package ();
+  static const cmt_string& get_current_cmtpath ();
+  static const cmt_string& get_current_offset ();
+  static AccessMode get_current_access ();
+  static CmtStructuringStyle get_current_structuring_style ();
+  static CmtDirStyle get_current_style ();
+  static const cmt_string& get_current_version ();
+  static const cmt_string& get_current_target ();
+  static bool get_debug ();
+  static bool get_disable_warnings ();  
+  static bool get_quiet ();
+  static bool get_warnings ();
+  static bool get_recursive ();
+  static CmtScopeFilteringMode get_scope_filtering_mode ();
+  static bool get_all_sets_done ();
+
+  /// If a project file exists above the current directory we don't need CMTPATH
+  static void guess_current_project ();
+
+  static void install_cleanup_scripts ();
+  static void install_setup_scripts ();
+  static void install_native_version_file ();
+  static void install_test_cleanup_scripts ();
+  static void install_test_setup_scripts ();
+  static bool load (const cmt_string& path,
+                    const cmt_string& package,
+                    const cmt_string& version,
+                    const cmt_string& tag_name = "");
+  static bool need_prototypes ();
+  static void parse_arguments (ArgParser& ap);
+  static int parser (const cmt_string& command_line);
+  static int parser (int argc, char* argv[]);
+  static void print (PrintMode mode);
+  static void print_clean (PrintMode mode);
+  static void print_context (Use& use, PrintMode mode, const cmt_string& tag);
+  static void print_macros (PrintMode mode, const cmt_string& pattern = "");
+  static void print_symbol_names (PrintMode mode, const cmt_string& pattern = "");
+  static void print_tabs (int tabs);
+  static int reach_current_package ();
+  static void restore_all_tags (Use* use);
+  static void set_current_access (AccessMode mode);
+  static void set_scope_filtering_mode (CmtScopeFilteringMode mode);
+  static void set_standard_macros ();
+  static void set_all_sets_done ();
+  static void reset_all_sets_done ();
+  static void use_cmt ();
+  static void use_home_requirements ();
+  static void use_user_context_requirements ();
+  static void use_special_requirements (const cmt_string& path, 
+					const cmt_string& name, 
+					const cmt_string& file_name);
+  static cmt_string vector_to_string (const CmtSystem::cmt_string_vector& v);
+  static void vector_to_string (const CmtSystem::cmt_string_vector& v,
+                                const cmt_string& separator,
+                                cmt_string& result);
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_awk.cxx
===================================================================
--- /CMT/v1r20/source/cmt_awk.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_awk.cxx	(revision 368)
@@ -0,0 +1,987 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifdef WIN32
+#include <direct.h>
+#define popen _popen
+#define pclose _pclose
+#endif
+
+#include "cmt_awk.h"
+#include "cmt_system.h"
+
+class Parser
+{
+public:
+  Parser (Awk* awk, const cmt_string pattern, const cmt_regexp* expression) :
+          m_pattern (pattern), m_expression (expression), m_awk(awk)
+      {
+      }
+
+    /** 
+     *  this first level parsing function extracts individual lines
+     *  from the text, taking care of both Unix and Windows EOL styles.
+     *
+     *   Then the second level parsing function parse_line is called.
+     */
+  Awk::condition parse (const cmt_string& text)
+      {
+        Awk::condition result = Awk::ok;
+
+        cmt_string line;
+        int pos;
+        int max_pos;
+
+        pos = 0;
+        max_pos = text.size ();
+
+        m_accumulator.erase (0);
+
+        for (pos = 0; pos < max_pos;)
+          {
+            int eol = text.find (pos, '\n');
+            
+            if (eol == cmt_string::npos)
+              {
+                  // Last line, since there is no eol at all
+                text.substr (pos, line);
+                pos = max_pos;
+              }
+            else
+              {
+                int length = 1;
+
+                int cr = text.find (pos, "\r\n");
+
+                if (cr == (eol-1))
+                  {
+                    eol = cr;
+                    length = 2;
+                  }
+
+                if (eol == pos)
+                  {
+                      // this is an empty line
+                    line = "";
+                    pos += length;
+                  }
+                else
+                  {
+                      // The eol was found beyond the current position
+                      // (ie. this is a non empty line)
+                    text.substr (pos, eol - pos, line);
+                    pos = eol + length;
+                  }
+              }
+
+            if (m_awk != 0) m_awk->inc_line_number ();
+
+              //cout << "parse> line=[" << line << "]" << endl;
+
+            result = parse_line (line);
+            if (result != Awk::ok) break;
+          }
+
+        return (result);
+      }
+
+    /**
+     *   This second level parsing function accumulates individual lines
+     *   with real trailing back slashes.
+     *    Eventually the possible text pattern or regular expression is
+     *   checked and the Awk::filter function is called in case of
+     *   succesful match onto the accumulated line.
+     */
+  Awk::condition parse_line (const cmt_string& line)
+      {
+        Awk::condition result = Awk::ok;
+        int length;
+        cmt_string temp_line = line;
+
+          //
+          // We scan the line for handling backslashes.
+          //
+          // Really terminating backslashes (ie those only followed by spaces/tabs
+          // mean continued line
+          //
+          //
+
+        bool finished = true;
+
+        length = temp_line.size ();
+
+        if (length == 0)
+          {
+              // An empty line following a backslash terminates the continuation.
+            finished = true;
+          }
+        else
+          {
+            int back_slash = temp_line.find_last_of ('\\');
+        
+            if (back_slash != cmt_string::npos)
+              {
+                  //
+                  // This is the last backslash
+                  // check if there are only space chars after it
+                  //
+            
+                bool at_end = true;
+            
+                for (int i = (back_slash + 1); i < length; i++)
+                  {
+                    char c = temp_line[i];
+                    if ((c != ' ') && (c != '\t'))
+                      {
+                        at_end = false;
+                        break;
+                      }
+                  }
+                
+                if (at_end)
+                  {
+                    temp_line.erase (back_slash);
+                    finished = false;
+                  }
+                else
+                  {
+                      // This was not a trailing backslash.
+                    finished = true;
+                  }
+              }
+        
+            m_accumulator += temp_line;
+          }
+
+          //cout << "parse_line1> accumulator=[" << m_accumulator << "]" << endl;
+          //cout << "parse_line1> finished=[" << finished << "]" << endl;
+
+        if (!finished)
+          {
+              // We still need to accumulate forthcoming lines
+              // before parsing the resulting text.
+            return (Awk::ok);
+          }
+
+          // now filter the complete accumulated line (if non empty)
+
+        if (m_accumulator != "")
+          {
+            bool ok = false;
+            
+            if (m_expression != 0)
+              {
+                if (m_expression->match (m_accumulator))
+                  {
+                    ok = true;
+                  }
+              }
+            else
+              {
+                if ((m_pattern == "") ||
+                    (m_accumulator.find (m_pattern) != cmt_string::npos))
+                  {
+                    ok = true;
+                  }
+              }
+            
+            if (ok && (m_awk != 0))
+              {
+                  //cout << "parse_line> accumulator=[" << m_accumulator << "]" << endl;
+
+                m_awk->filter (m_accumulator);
+                result = m_awk->get_last_condition ();
+              }
+
+            m_accumulator.erase (0);
+          }
+        
+        return (result);
+      }
+
+private:
+
+  cmt_string m_accumulator;
+  cmt_string m_pattern;
+  const cmt_regexp* m_expression;
+  Awk* m_awk;
+};
+
+//------------------------------------------------
+Awk::Awk ()
+{
+  m_condition = ok;
+}
+
+//------------------------------------------------
+Awk::~Awk ()
+{
+}
+
+//------------------------------------------------
+Awk::condition Awk::run (const cmt_string& text,
+                         const cmt_string& pattern)
+{
+  m_line_number = 0;
+  m_condition = ok;
+
+  begin ();
+  if (m_condition != ok) return (m_condition);
+
+  if (CmtSystem::testenv ("CMTTESTAWK"))
+    {
+      Parser p (this, pattern, 0);
+
+      m_condition = p.parse (text);
+      if (m_condition != ok) return (m_condition);
+    }
+  else
+    {
+      cmt_string line;
+      int pos = 0;
+      int max_pos;
+
+      max_pos = text.size ();
+
+      for (pos = 0; pos < max_pos;)
+        {
+          int cr = text.find (pos, "\r\n");
+          int nl = text.find (pos, '\n');
+          
+            // Get the first end-of-line (either lf or cr-lf)
+
+            //--------------------
+            //
+            //     cr    1    0
+            //   nl
+            //
+            //    1      a    b
+            //
+            //    0      c    d
+            //
+            //--------------------
+          
+          int first = nl;
+          
+          if (cr != cmt_string::npos)
+            {
+                // cases a or c
+
+              if (nl == cmt_string::npos)
+                {
+                    // case a
+                  first = cr;
+                }
+              else
+                {
+                    // case c
+                  first = (nl < cr) ? nl : cr;
+                }
+            }
+          
+          if (first == cmt_string::npos)
+            {
+                // This is likely the last line since there is no end-of-line
+              text.substr (pos, line);
+              pos = max_pos;
+            }
+          else if (first > pos)
+            {
+                // The eol was found beyond the current position
+                // (ie. this is a non empty line)
+              text.substr (pos, first - pos, line);
+              pos = first + 1;
+            }
+          else
+            {
+                // an empty line
+              line = "";
+              pos++;
+            }
+          
+          m_line_number++;
+          
+          if (line != "")
+            {
+              if ((pattern == "") ||
+                  (line.find (pattern) != cmt_string::npos))
+                {
+                  filter (line);
+                  if (m_condition != ok) return (m_condition);
+                }
+            }
+        }
+    }
+
+  end ();
+
+  return (m_condition);
+}
+
+//------------------------------------------------
+Awk::condition Awk::run (const cmt_string& text,
+                         const cmt_regexp& expression)
+{
+  m_line_number = 0;
+  m_condition = ok;
+
+  begin ();
+  if (m_condition != ok) return (m_condition);
+
+  Parser p (this, "", &expression);
+
+  m_condition = p.parse (text);
+  if (m_condition != ok) return (m_condition);
+
+    /*
+  if (CmtSystem::testenv ("CMTTESTAWK"))
+    {
+    }
+  else
+    {
+      cmt_string line;
+      int pos = 0;
+      int max_pos;
+
+      max_pos = text.size ();
+
+      for (pos = 0; pos < max_pos;)
+        {
+          int cr = text.find (pos, "\r\n");
+          int nl = text.find (pos, '\n');
+          
+            // Get the first end-of-line (either lf or cr-lf)
+          
+          int first = nl;
+          
+          if (cr != cmt_string::npos)
+            {
+              if (nl == cmt_string::npos)
+                {
+                  first = cr;
+                }
+              else
+                {
+                  first = (nl < cr) ? nl : cr;
+                }
+            }
+          
+          if (first == cmt_string::npos)
+            {
+                // This is likely the last line since there is no end-of-line
+              text.substr (pos, line);
+              pos = max_pos;
+            }
+          else if (first > pos)
+            {
+                // The eol was found beyond the current position
+                // (ie. this is a non empty line)
+              text.substr (pos, first - pos, line);
+              pos = first + 1;
+            }
+          else
+            {
+                // an empty line
+              line = "";
+              pos++;
+            }
+          
+          m_line_number++;
+          
+          if (line != "")
+            {
+              if (expression.match (line))
+                {
+                  filter (line);
+                  if (m_condition != ok) return (m_condition);
+                }
+            }
+        }
+    }
+    */
+
+  end ();
+
+  return (m_condition);
+}
+
+//------------------------------------------------
+void Awk::stop ()
+{
+  m_condition = stopped;
+}
+
+//------------------------------------------------
+void Awk::abort ()
+{
+  m_condition = failed;
+}
+
+//------------------------------------------------
+void Awk::allow_continuation ()
+{
+  m_continuation_allowed = true;
+}
+
+//------------------------------------------------
+Awk::condition Awk::get_last_condition () const
+{
+  return (m_condition);
+}
+
+//------------------------------------------------
+void Awk::begin ()
+{
+}
+
+//------------------------------------------------
+void Awk::filter (const cmt_string& /*line*/)
+{
+    //cout << "awk> " << line << endl;
+}
+
+//------------------------------------------------
+void Awk::end ()
+{
+}
+
+//------------------------------------------------
+void Awk::inc_line_number ()
+{
+  m_line_number++;
+}
+
+//------------------------------------------------
+Awk::condition FAwk::run (const cmt_string& file_name,
+                          const cmt_string& pattern)
+{
+  if (!CmtSystem::test_file (file_name)) return (failed);
+
+  CmtSystem::basename (file_name, m_file_name);
+  CmtSystem::dirname (file_name, m_dir_name);
+
+  cmt_string text;
+
+  text.read (file_name);
+
+  return (Awk::run (text, pattern));
+}
+
+//------------------------------------------------
+Awk::condition FAwk::run (const cmt_string& file_name,
+                          const cmt_regexp& expression)
+{
+  if (!CmtSystem::test_file (file_name)) return (failed);
+
+  CmtSystem::basename (file_name, m_file_name);
+  CmtSystem::dirname (file_name, m_dir_name);
+
+  cmt_string text;
+
+  text.read (file_name);
+
+  return (Awk::run (text, expression));
+}
+
+//------------------------------------------------
+Awk::condition PAwk::run (const cmt_string& command, 
+                          const cmt_string& pattern)
+{
+  cmt_string line;
+
+  m_line_number = 0;
+  m_condition = ok;
+
+  begin ();
+  if (m_condition != ok) return (m_condition);
+
+  FILE* f = popen (command.c_str (), "r"); 
+  
+  if (f == 0) return (failed);
+
+  char buffer[8192]; 
+  char* ptr;
+
+  while ((ptr = fgets (buffer, sizeof (buffer), f)) != NULL) 
+    {
+      line = ptr;
+
+      if (line.find ("\n") == cmt_string::npos)
+        {
+          cerr << "#CMT> Warning: Line too long and truncated in PAwk::run for command " << command << endl;
+        }
+
+      line.replace ("\n", "");
+
+      m_line_number++;
+
+      if (line != "")
+        {
+          if ((pattern == "") ||
+              (line.find (pattern) != cmt_string::npos))
+            {
+              filter (line);
+              if (m_condition != ok) return (m_condition);
+            }
+        }
+    }
+
+  pclose (f);
+
+  end ();
+
+  return (m_condition);
+}
+
+//------------------------------------------------
+Awk::condition PAwk::run (const cmt_string& command, 
+                          const cmt_regexp& expression)
+{
+  cmt_string line;
+
+  m_line_number = 0;
+  m_condition = ok;
+
+  begin ();
+  if (m_condition != ok) return (m_condition);
+
+  FILE* f = popen (command.c_str (), "r"); 
+  
+  if (f == 0) return (failed);
+
+  char buffer[256]; 
+  char* ptr;
+
+  while ((ptr = fgets (buffer, sizeof (buffer), f)) != NULL) 
+    {
+      line = ptr;
+
+      line.replace ("\n", "");
+
+      m_line_number++;
+
+      if (line != "")
+        {
+          if (expression.match (line))
+            {
+              filter (line);
+              if (m_condition != ok) return (m_condition);
+            }
+        }
+    }
+
+  pclose (f);
+
+  end ();
+
+  return (m_condition);
+}
+
+//----------------------------------------------------------
+PathScanner::PathScanner ()
+{
+  _running = false;
+  _level = 0;
+}
+
+//----------------------------------------------------------
+bool PathScanner::scan_path (const cmt_string& path, actor& a)
+{
+  if (_running) return (false);
+
+  _level = 0;
+  _running = true;
+
+  cmt_string compressed_path = path;
+  CmtSystem::compress_path (compressed_path);
+  CmtSystem::realpath      (compressed_path, compressed_path);  
+  scan_path                (compressed_path, 0, a);
+
+  _running = false;
+  _level = 0;
+
+  return (true);
+}
+
+//----------------------------------------------------------
+void PathScanner::scan_path (const cmt_string& path, int level, actor& a)
+{
+  if (level > 10)
+    {
+      //cout << "#PathScanner::scan_path> too deep search path=" << path << endl;
+      return;
+    }
+
+  //
+  // Only do something if it is a directory.
+  //
+  if (!CmtSystem::test_directory (path)) return;
+  
+
+  CmtSystem::cmt_string_vector list;
+  CmtSystem::cmt_string_vector entrylist;
+
+  CmtSystem::scan_dir (path, list);
+
+  if (list.size () == 0) return;
+
+  _level++;
+
+  // Will be set if at least one directory is a version directory
+  bool has_package = false;
+
+  cmt_string name;
+  cmt_string version;
+  cmt_string where;
+
+  int i;
+
+  for (i = 0; i < list.size (); i++)
+    {
+      const cmt_string& here = list[i];
+
+      if (!CmtSystem::test_directory (here)) continue;
+
+      name    = "";
+      version = "";
+
+      cmt_string entry;
+      CmtSystem::basename (here, entry);
+      CmtSystem::dirname (path, where);
+
+      //cout << "## here=" << here << " entry=" << entry << " where=" << where << endl;
+
+      if ((level == 0) && (entry == "InstallArea")) continue;
+      if (entry == "CVS") continue;
+
+      cmt_string req;
+
+      req = here;
+      req += CmtSystem::file_separator ();
+      req += "mgr";
+      req += CmtSystem::file_separator ();
+      req += "requirements";
+      
+      if (CmtSystem::test_file (req))
+	{
+	  // We have found <path>/mgr/requirements
+	  // this is an old directory convention. 
+	  // The version directory is the directory above
+
+	  version = entry;
+	  CmtSystem::basename (path, name);
+
+	  //cout << "#1" << endl;
+
+	  a.run (name, version, where);
+	  has_package = true;
+
+	  // We don't keep on looking in this directory since the versioned structure
+	  // does not expect subpackages there
+	  continue;
+	}
+
+      req = here;
+      req += CmtSystem::file_separator ();
+      req += "cmt";
+      req += CmtSystem::file_separator ();
+      req += "requirements";
+
+      if (CmtSystem::test_file (req))
+	{
+	  // We have found <path>/cmt/requirements
+	  // Question now is to detect the directory structure:
+	  //
+	  // if cmt/version.cmt exists it's a non-version-directory structure
+	  // else
+	  //   if there is a package statement in the requirements file we find it upward
+	  //   else
+	  //     if up is a version directory
+	  //     else
+	  //
+
+	  cmt_string vreq;
+	  vreq = here;
+	  vreq += CmtSystem::file_separator ();
+	  vreq += "cmt";
+	  vreq += CmtSystem::file_separator ();
+	  vreq += "version.cmt";
+
+	  if (CmtSystem::test_file (vreq))
+	    {
+	      version.read (vreq);
+	      int pos;
+	      pos = version.find ('\n');
+	      if (pos != cmt_string::npos) version.erase (pos);
+	      pos = version.find ('\r');
+	      if (pos != cmt_string::npos) version.erase (pos);
+
+	      //cout << "#2" << endl;
+
+	      a.run (entry, version, path, true);
+	      has_package = true;
+
+	      // We scan further down
+	      scan_path (here, 1, a);
+	      continue;
+	    }
+
+	  cmt_string p;
+	  
+	  p.read (req);
+	  int pos;
+	  pos = p.find ("package");
+	  if (pos != cmt_string::npos)
+	    {
+	      p.erase (0, pos+8);
+	      pos = p.find ('\n');
+	      if (pos != cmt_string::npos) p.erase (pos);
+	      pos = p.find ('\r');
+	      if (pos != cmt_string::npos) p.erase (pos);
+	      p.replace_all (" ", "");
+	      p.replace_all ("\t", "");
+	      if (p != "") name = p;
+	    }
+	  
+	  if (name != "")
+	    {
+	      // The package name was specified in the requirements file
+	      
+	      if (entry == name)
+		{
+		  // The structure is without the version directory.
+		  
+		  //cout << "#3" << endl;
+		  
+		  a.run (name, "v1", path);
+		  has_package = true;
+		  
+		  // We scan further down
+		  scan_path (here, 1, a);
+		  continue;
+		}
+	      
+	      version = entry;
+	      CmtSystem::basename (path, entry);
+	      
+	      if (entry == name)
+		{
+		  // The structure is with the version directory.
+		  
+		  //cout << "#4" << endl;
+		  
+		  a.run (name, version, where);
+		  has_package = true;
+		  
+		  continue;
+		}
+	      
+	      // No directory structure matches the package name
+	      // Is it a typo in the requirements file ?
+	      // probably we should display it and quit...
+	    }
+	  else
+	    {
+	      version = entry;
+	      CmtSystem::basename (path, entry);
+	    }
+	  
+	  // The package name is not specified in the requirements file
+	  // or did not match the directory structure
+	  // We'll have to guess it from the structure
+	  
+	  if (CmtSystem::is_version_directory (version))
+	    {
+	      //cout << "#5" << endl;
+	      
+	      a.run (entry, version, where);
+	      has_package = true;
+	      
+	      continue;
+	    }
+
+	  // Here we suppose that the directory up is the package name
+	  // although no specification of the version has been found
+	  // So we decide that
+	  // - it's a non-versioned structure
+	  // - the version is set by default to v1
+	  name = version;
+	  
+	  where += CmtSystem::file_separator ();
+	  where += entry;
+	  
+	  //cout << "#6" << endl;
+	  
+	  a.run (name, "v1", where);
+	  has_package = true;
+	  
+	  // We scan further down
+	  scan_path (here, 1, a);
+	  continue;
+	}
+
+      //
+      // Here this is a non-package directory. Let's search further down
+      //cout << "#7" << endl;
+
+      scan_path (here, level + 1, a);
+    }
+
+  if (has_package)
+    {
+      //
+      // At least one version was found here. Thus we want to scan further down.
+      //
+
+      for (i = 0; i < entrylist.size (); i++)
+	{
+	  const cmt_string& e = entrylist[i];
+
+	  cmt_string p = path;
+	  p += CmtSystem::file_separator ();
+	  p += e;
+
+
+	  /*
+	  for (int j = 1; j < _level; j++) cout << "  ";
+	  cout << "Restarting scan_path on p=" << p << endl;
+            
+
+	  cout << "#PathScanner::scan_path> Restarting scan_path on p=" << p << endl;
+	  */
+
+	  scan_path (p, 1, a);
+	}
+    }
+
+  _level--;
+}
+
+
+//----------------------------------------------------------
+bool PathScanner::scan_package (const cmt_string& path,
+                                const cmt_string& package)
+{
+  //
+  // Only do something if it is a directory.
+  //
+
+  if (!CmtSystem::test_directory (path)) return (false);
+
+  cmt_string pattern = path;
+  pattern += CmtSystem::file_separator ();
+  pattern += package;
+
+  if (!CmtSystem::test_directory (pattern)) return (false);
+
+  CmtSystem::cmt_string_vector list;
+
+  CmtSystem::scan_dir (pattern, list);
+
+  if (list.size () == 0) 
+    {
+      return (false);
+    }
+
+  bool result = false;
+
+  int i;
+  for (i = 0; i < list.size (); i++)
+    {
+      const cmt_string& name = list[i];
+
+      cmt_string version;
+      CmtSystem::basename (name, version);
+
+      if (version == "cmt")
+        {
+          cmt_string req;
+
+          req = name;
+          req += CmtSystem::file_separator ();
+          req += "requirements";
+
+          if (CmtSystem::test_file (req))
+            {
+              //cout << " -> no version" << endl;
+
+	      cmt_string req;
+	      
+	      req = name;
+	      req += CmtSystem::file_separator ();
+	      req += "version.cmt";
+
+	      cmt_string version;
+	      if (CmtSystem::test_file (req))
+		{
+		  version.read (req);
+		  int pos;
+		  pos = version.find ('\n');
+		  if (pos != cmt_string::npos) version.erase (pos);
+		  pos = version.find ('\r');
+		  if (pos != cmt_string::npos) version.erase (pos);
+		}
+	      else
+		{
+		  version = "v*";
+		}
+
+              cout << package << " " << version << " " << path << endl;
+
+              result = true;
+            }
+        }
+      else if (CmtSystem::is_version_directory (version))
+        {
+          cmt_string req;
+
+          req = name;
+          req += CmtSystem::file_separator ();
+          req += "cmt";
+          req += CmtSystem::file_separator ();
+          req += "requirements";
+
+          if (CmtSystem::test_file (req))
+            {
+              //cout << " -> cmt" << endl;
+
+              cout << package << " " << version << " " << path << endl;
+
+              result = true;
+            }
+          else
+            {
+              //cout << " -> no cmt" << endl;
+
+              req = name;
+              req += CmtSystem::file_separator ();
+              req += "mgr";
+              req += CmtSystem::file_separator ();
+              req += "requirements";
+
+              if (CmtSystem::test_file (req))
+                {
+                  //cout << " -> mgr" << endl;
+
+                  cout << package << " " << version << " " << path << endl;
+
+                  result = true;
+                }
+              else
+                {
+                  //cout << " -> no mgr" << endl;
+                }
+            }
+        }
+      else
+        {
+          //cout << " -> stop" << endl;
+        }
+    }
+
+  return (result);
+}
+
Index: /CMT/v1r20/source/cmt_awk.h
===================================================================
--- /CMT/v1r20/source/cmt_awk.h	(revision 368)
+++ /CMT/v1r20/source/cmt_awk.h	(revision 368)
@@ -0,0 +1,131 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_awk_h__
+#define __cmt_awk_h__
+
+#include "cmt_std.h"
+#include "cmt_string.h"
+#include "cmt_regexp.h"
+
+//------------------------------------------------
+//
+//  Emulation of the awk program.
+//
+//  The run method reads the specified file, and applies the
+// <filter> virtual method onto each selected line. It returns
+// a condition (see below)
+//
+//  o empty lines are ignored
+//  o when the optional pattern is specified, only lines matching it
+//    are considered.
+//
+//  The virtual <begin> method is applied before any filter
+//  The virtual <filter> method is applied onto each line
+//  The virtual <end> method is applied after all filters
+//
+//  The condition (one of "ok", "stopped" or "failed") will be
+//  generated if :
+//    o everything run well (ok)
+//    o the <stop> method is called (stopped)
+//    o an error occurred or the <abort> method is called (failed)
+//
+//  State variables are maintained for derived awk filters
+//
+//    m_line_number  the current line number (empty lines
+//                   are counted)
+//
+//    m_continuation_allowed when true, take into account the
+//                           trailing backslashes, so as to
+//                           first accumulate continued lines 
+//                           into one
+//
+//  Derived classes:
+//  ----------------
+//
+//  FAwk : scans a file
+//
+//    State variables:
+//
+//    m_dir_name     the path of the currently read file
+//    m_file_name    the name of the currently read file
+//
+//  PAwk : execute a command and scans its output
+//
+//------------------------------------------------
+class Awk
+{
+public:
+  typedef enum {ok, stopped, failed} condition;
+  Awk ();
+  virtual ~Awk ();
+  condition run (const cmt_string& text, const cmt_string& pattern = "");
+  condition run (const cmt_string& text, const cmt_regexp& expression);
+  void stop ();
+  void abort ();
+  void allow_continuation ();
+  condition get_last_condition () const;
+
+  virtual void begin ();
+  virtual void filter (const cmt_string& line);
+  virtual void end ();
+
+  void inc_line_number ();
+  
+protected:
+  int m_line_number;
+  condition m_condition;
+  bool m_continuation_allowed;
+};
+
+class FAwk : public Awk
+{
+public:
+  condition run (const cmt_string& file_name, const cmt_string& pattern = "");
+  condition run (const cmt_string& text, const cmt_regexp& expression);
+protected:
+  cmt_string m_dir_name;
+  cmt_string m_file_name;
+};
+
+class PAwk : public Awk
+{
+public:
+  condition run (const cmt_string& command, const cmt_string& pattern = "");
+  condition run (const cmt_string& text, const cmt_regexp& expression);
+};
+
+/**
+ *  This scans a path and looks for CMT packages.
+ *  Whenever it finds one, it applies the specified actor to it.
+ */
+class PathScanner
+{
+public:
+  class actor
+  {
+  public:
+    virtual void run (const cmt_string& package,
+                      const cmt_string& version,
+                      const cmt_string& path,
+                      const bool without_version_directory=false)
+    {
+    }
+  };
+  
+  PathScanner ();
+  bool scan_path (const cmt_string& path, actor& a);
+  bool scan_package (const cmt_string& path, const cmt_string& package);
+  
+private:
+  void scan_path (const cmt_string& path, int level, actor& a);
+  
+  bool _running;
+  int _level;
+};
+
+
+#endif
Index: /CMT/v1r20/source/cmt_branch.cxx
===================================================================
--- /CMT/v1r20/source/cmt_branch.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_branch.cxx	(revision 368)
@@ -0,0 +1,146 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_branch.h"
+#include "cmt_database.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Branches                                  */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+/*----------------------------------------------------------*/
+void Branch::action (const CmtSystem::cmt_string_vector& words)
+/*----------------------------------------------------------*/
+{
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& name = words[i];
+      if (name == "") return;
+
+      add (name);
+    }
+}
+
+/*----------------------------------------------------------*/
+Branch* Branch::find (const cmt_string& name)
+/*----------------------------------------------------------*/
+{
+  static BranchVector& Branches = branches ();
+
+  int branch_index;
+
+  if (Branches.size () == 0) return (0);
+
+  for (branch_index = 0;
+       branch_index < Branches.size ();
+       branch_index++)
+    {
+      Branch& branch = Branches[branch_index];
+
+      if (branch.name () == name)
+        {
+          return (&branch);
+        }
+    }
+
+  return (0);
+}
+
+/*----------------------------------------------------------*/
+void Branch::add (const cmt_string& name)
+/*----------------------------------------------------------*/
+{
+  static BranchVector& Branches = branches ();
+
+  {
+    Branch* branch;
+
+    branch = find (name);
+    if (branch != 0) return;
+  }
+
+  Branch& branch = Branches.add ();
+
+  branch.m_name = name;
+}
+
+/*----------------------------------------------------------*/
+void Branch::print_all (PrintMode mode)
+/*----------------------------------------------------------*/
+{
+  static BranchVector& Branches = branches ();
+
+  int number;
+
+  for (number = 0; number < Branches.size (); number++)
+    {
+      if (number > 0) cout << " ";
+      Branches[number].print (mode);
+    }
+  if (number > 0) cout << endl;
+}
+
+/*----------------------------------------------------------*/
+void Branch::clear_all ()
+/*----------------------------------------------------------*/
+{
+  static BranchVector& Branches = branches ();
+
+  int number;
+
+  for (number = 0; number < Branches.size (); number++)
+    {
+      Branch& b = Branches[number];
+
+      b.m_name = "";
+    }
+
+  Branches.clear ();
+}
+
+/*----------------------------------------------------------*/
+Branch::BranchVector& Branch::branches ()
+/*----------------------------------------------------------*/
+{
+  static Database& db = Database::instance ();
+  static BranchVector& Branches = db.branches ();
+
+  return (Branches);
+}
+
+/*----------------------------------------------------------*/
+Branch::Branch ()
+/*----------------------------------------------------------*/
+{
+}
+
+/*----------------------------------------------------------*/
+Branch::~Branch ()
+/*----------------------------------------------------------*/
+{
+}
+
+/*----------------------------------------------------------*/
+const cmt_string& Branch::name () const
+/*----------------------------------------------------------*/
+{
+  return (m_name);
+}
+
+/*----------------------------------------------------------*/
+void Branch::print (PrintMode mode) const
+/*----------------------------------------------------------*/
+{
+  cout << m_name;
+}
+
Index: /CMT/v1r20/source/cmt_branch.h
===================================================================
--- /CMT/v1r20/source/cmt_branch.h	(revision 368)
+++ /CMT/v1r20/source/cmt_branch.h	(revision 368)
@@ -0,0 +1,35 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_branch_h__
+#define __cmt_branch_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+
+class Branch
+{
+public:
+  typedef cmt_vector<Branch> BranchVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words);
+  static Branch* find (const cmt_string& name);
+  static void add (const cmt_string& name);
+  static void print_all (PrintMode mode);
+  static void clear_all ();
+  static BranchVector& branches ();
+
+public:
+  Branch ();
+  ~Branch ();
+  const cmt_string& name () const;
+  void print (PrintMode mode) const;
+
+private:
+  cmt_string m_name;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_cmtpath_pattern.cxx
===================================================================
--- /CMT/v1r20/source/cmt_cmtpath_pattern.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_cmtpath_pattern.cxx	(revision 368)
@@ -0,0 +1,279 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_database.h"
+#include "cmt_cmtpath_pattern.h"
+#include "cmt_syntax.h"
+
+//----------------------------------------------------------
+//
+//  Operations on CmtPathPatterns
+//
+//----------------------------------------------------------
+
+void CmtPathPattern::action (const CmtSystem::cmt_string_vector& words, Use* use, bool revert)
+{
+  if (words.size () < 1) return;
+
+    //
+    // expected syntax is:
+    //
+    //  cmtpath_pattern any-cmt-statement
+    //
+    // where any-cmt-statement may contain the "template"
+    //
+    //      <path>
+    //      <project>
+    //
+
+  add (words, use, revert);
+
+  if (Cmt::get_debug ())
+    {
+      cout << "CmtPathPattern::action> add " << endl;
+    }
+}
+
+void CmtPathPattern::add (const CmtSystem::cmt_string_vector& words, Use* use, bool revert)
+{
+  static CmtPathPatternVector& CmtPathPatterns = patterns ();
+
+  CmtPathPattern& p = CmtPathPatterns.add ();
+
+  p.clear ();
+
+  p.use  = use;
+  p.revert  = revert;
+
+  int first_word = 1;
+
+    //
+    // Install the cmt-statement as a vector of words.
+    //
+  for (int i = first_word; i < words.size (); i++)
+    {
+      bool need_quotes = (i > (first_word + 1));
+
+      cmt_string& s = words[i];
+
+      if (i > first_word) p.line += " ";
+
+      if (s == ";") first_word = i+1;
+
+      if ((s == "\n") | (s == ";"))
+        {
+          p.line += "\n  ";
+        }
+      else
+        {
+	  cmt_string sep = "\"";
+
+	  if (s.find (sep) != cmt_string::npos)
+	    {
+	      sep = "\'";
+	    }
+
+	  if (!need_quotes) sep = "";
+
+          p.line += sep;
+          p.line += s;
+          p.line += sep;
+        }
+    }
+}
+
+/**
+ * Get the number of registered patterns
+ */
+int CmtPathPattern::pattern_number ()
+{
+  static CmtPathPatternVector& CmtPathPatterns = patterns ();
+
+  return (CmtPathPatterns.size ());
+}
+
+/**
+ * Get the index'th pattern in the database
+ */
+CmtPathPattern& CmtPathPattern::pattern (int index)
+{
+  static CmtPathPatternVector& CmtPathPatterns = patterns ();
+
+  return (CmtPathPatterns[index]);
+}
+
+void CmtPathPattern::clear_all ()
+{
+  static CmtPathPatternVector& CmtPathPatterns = patterns ();
+
+  for (int i = 0; i < CmtPathPatterns.size (); i++)
+    {
+      CmtPathPattern& p = CmtPathPatterns[i];
+      p.clear ();
+    }
+
+  CmtPathPatterns.clear ();
+}
+
+CmtPathPattern::CmtPathPatternVector& CmtPathPattern::patterns ()
+{
+  static Database& db = Database::instance ();
+  static CmtPathPatternVector& CmtPathPatterns = db.cmtpath_patterns ();
+
+  return (CmtPathPatterns);
+}
+
+/**
+ * Applies all patterns to all CMTPATH item
+ */
+void CmtPathPattern::apply_all ()
+{
+  static CmtPathPatternVector& CmtPathPatterns = patterns ();
+
+  int i;
+
+  for (i = 0; i < CmtPathPatterns.size (); i++)
+    {
+      CmtPathPattern& p = CmtPathPatterns[i];
+
+      p.apply ();
+    }
+}
+
+/**
+ * this is the cmt show cmtpath_patterns command
+ * It just shows the cmtpath_pattern declarations.
+ */
+void CmtPathPattern::show_all ()
+{
+  static CmtPathPatternVector& CmtPathPatterns = patterns ();
+
+  int i;
+
+  for (i = 0; i < CmtPathPatterns.size (); i++)
+    {
+      CmtPathPattern& p = CmtPathPatterns[i];
+
+      cout << "# " << p.use->get_package_name () << " " << p.use->version 
+	   << " adds a cmtpath_pattern as " << endl;
+      cout << "  " << p.line << endl;
+    }
+}
+
+//----------------------------------------------------------
+CmtPathPattern::CmtPathPattern ()
+{
+}
+
+//----------------------------------------------------------
+CmtPathPattern::~CmtPathPattern ()
+
+{
+}
+
+//----------------------------------------------------------
+void CmtPathPattern::clear ()
+{
+  use = 0;
+  line = "";
+}
+
+class CmtPathPatternProjectAction : public IProjectAction
+{
+public:
+  CmtPathPatternProjectAction (const CmtPathPattern& pattern, Use& use) : 
+    m_pattern (pattern), 
+    m_current (use)
+  {
+  }
+
+  bool run (const Project& project)
+  {
+    const cmt_string& pname = project.get_name ();
+    const cmt_string& p = project.get_cmtpath ();
+    const cmt_string& s = project.get_cmtpath_source ();
+
+    if (s == "default path") return (true);
+
+    m_pattern.expand (m_buffer, p, pname);
+
+    if (Cmt::get_debug ())
+      {
+	cout << "CmtPathPattern::apply> text=[" << m_buffer << "]" << endl;
+      }
+
+    SyntaxParser::parse_requirements_text (m_buffer, "", &m_current);
+    m_buffer = "";
+
+    return (true);
+  }
+
+private:
+
+  const CmtPathPattern& m_pattern;
+  Use& m_current;
+  cmt_string m_buffer;
+};
+
+
+/**
+ *   Applies a pattern to all CMTPATH entries.
+ */
+void CmtPathPattern::apply () const
+{
+  if (Cmt::get_debug ())
+    {
+      cout << "CmtPathPattern::apply> cmtpath_pattern defined in " << use->get_package_name () << endl;
+    }
+
+  Use& current_use = Use::current ();
+
+  bool is_constant = ((line.find ("<path>") == cmt_string::npos) &&
+		      (line.find ("<project>") == cmt_string::npos));
+
+  if (is_constant)
+    {
+      cmt_string buffer;
+
+      expand (buffer, "", "");
+
+      if (Cmt::get_debug ())
+	{
+	  cout << "CmtPathPattern::apply> text=[" << buffer << "]" << endl;
+	}
+
+      SyntaxParser::parse_requirements_text (buffer, "", &current_use);
+      buffer = "";
+    }
+  else
+    {
+      CmtPathPatternProjectAction pa (*this, current_use);
+
+      if (revert)
+	{
+	  Project::broadcast (pa);
+	}
+      else
+	{
+	  Project::reverse_broadcast (pa);
+	}
+    }
+}
+
+void CmtPathPattern::expand (cmt_string& replacement, 
+			     const cmt_string& path, 
+			     const cmt_string& project) const
+{
+  replacement = line;
+
+  if (replacement != "")
+    {
+      // Substitute <path> template from the cmt statement
+      replacement.replace_all ("<path>", path.c_str ());
+      replacement.replace_all ("<project>", project.c_str ());
+    }
+}
+
Index: /CMT/v1r20/source/cmt_cmtpath_pattern.h
===================================================================
--- /CMT/v1r20/source/cmt_cmtpath_pattern.h	(revision 368)
+++ /CMT/v1r20/source/cmt_cmtpath_pattern.h	(revision 368)
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_cmtpath_pattern_h__
+#define __cmt_cmtpath_pattern_h__
+
+#include "cmt_pattern.h"
+
+class CmtPathPattern
+{
+public:
+  typedef cmt_vector<CmtPathPattern> CmtPathPatternVector;
+  typedef cmt_vector<CmtPathPattern*> CmtPathPatternPtrVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words, Use* use, bool revert = false);
+
+  static void add (const CmtSystem::cmt_string_vector& words, Use* use, bool revert);
+
+  static int pattern_number ();
+  static CmtPathPattern& pattern (int index);
+  static void clear_all ();
+  static CmtPathPatternVector& patterns ();
+
+  static void apply_all ();
+  static void show_all ();
+
+public:
+  CmtPathPattern ();
+  ~CmtPathPattern ();
+
+  void clear ();
+  void apply () const;
+  void expand (cmt_string& line, const cmt_string& path, const cmt_string& project) const;
+
+  cmt_string line;
+  Use* use;
+  bool revert;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_commands.cxx
===================================================================
--- /CMT/v1r20/source/cmt_commands.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_commands.cxx	(revision 368)
@@ -0,0 +1,2308 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_commands.h"
+#include "cmt_tag.h"
+#include "cmt_symbol.h"
+#include "cmt_project.h"
+
+ArgParser::ArgParser (CmtContext& context) : cmt(context), argc(0), argv(0), mode(Csh)
+{
+  arguments.clear ();
+
+  int i = 0;
+
+  parsers.add ("awk", i);
+  pv.push_back (&ArgParser::do_awk); i++;
+
+  parsers.add ("br", i);
+  parsers.add ("bro", i);
+  parsers.add ("broa", i);
+  parsers.add ("broad", i);
+  parsers.add ("broadc", i);
+  parsers.add ("broadca", i);
+  parsers.add ("broadcas", i);
+  parsers.add ("broadcast", i);
+  pv.push_back (&ArgParser::do_broadcast); i++;
+
+  parsers.add ("bu", i);
+  parsers.add ("bui", i);
+  parsers.add ("buil", i);
+  parsers.add ("build", i);
+  pv.push_back (&ArgParser::do_build); i++;
+
+  parsers.add ("check", i);
+  pv.push_back (&ArgParser::do_check); i++;
+
+  parsers.add ("check_f", i);
+  parsers.add ("check_fi", i);
+  parsers.add ("check_fil", i);
+  parsers.add ("check_file", i);
+  parsers.add ("check_files", i);
+  pv.push_back (&ArgParser::do_check_files); i++;
+
+  parsers.add ("co", i);
+  parsers.add ("checkout", i);
+  pv.push_back (&ArgParser::do_checkout); i++;
+
+  parsers.add ("cl", i);
+  parsers.add ("cle", i);
+  parsers.add ("clea", i);
+  parsers.add ("clean", i);
+  parsers.add ("cleanu", i);
+  parsers.add ("cleanup", i);
+  pv.push_back (&ArgParser::do_cleanup); i++;
+
+  parsers.add ("con", i);
+  parsers.add ("conf", i);
+  parsers.add ("confi", i);
+  parsers.add ("config", i);
+  pv.push_back (&ArgParser::do_config); i++;
+
+  parsers.add ("create", i);
+  pv.push_back (&ArgParser::do_create); i++;
+
+  parsers.add ("create_project", i);
+  pv.push_back (&ArgParser::do_create_project); i++;
+
+  parsers.add ("cvsb", i);
+  parsers.add ("cvsbr", i);
+  parsers.add ("cvsbra", i);
+  parsers.add ("cvsbran", i);
+  parsers.add ("cvsbranc", i);
+  parsers.add ("cvsbranch", i);
+  parsers.add ("cvsbranche", i);
+  parsers.add ("cvsbranches", i);
+  pv.push_back (&ArgParser::do_cvsbranches); i++;
+
+  parsers.add ("cvssubpa", i);
+  parsers.add ("cvssubpac", i);
+  parsers.add ("cvssubpack", i);
+  parsers.add ("cvssubpacka", i);
+  parsers.add ("cvssubpackag", i);
+  parsers.add ("cvssubpackage", i);
+  parsers.add ("cvssubpackages", i);
+  pv.push_back (&ArgParser::do_cvssubpackages); i++;
+
+  parsers.add ("cvssubpr", i);
+  parsers.add ("cvssubpro", i);
+  parsers.add ("cvssubproj", i);
+  parsers.add ("cvssubproje", i);
+  parsers.add ("cvssubprojec", i);
+  parsers.add ("cvssubproject", i);
+  parsers.add ("cvssubprojects", i);
+  pv.push_back (&ArgParser::do_cvssubprojects); i++;
+
+  parsers.add ("cvst", i);
+  parsers.add ("cvsta", i);
+  parsers.add ("cvstag", i);
+  parsers.add ("cvstags", i);
+  pv.push_back (&ArgParser::do_cvstags); i++;
+
+  parsers.add ("d", i);
+  parsers.add ("do", i);
+  pv.push_back (&ArgParser::do_do); i++;
+
+  parsers.add ("e", i);
+  parsers.add ("ex", i);
+  parsers.add ("exp", i);
+  parsers.add ("expa", i);
+  parsers.add ("expan", i);
+  parsers.add ("expand", i);
+  pv.push_back (&ArgParser::do_expand); i++;
+
+  parsers.add ("f", i);
+  parsers.add ("fi", i);
+  parsers.add ("fil", i);
+  parsers.add ("filt", i);
+  parsers.add ("filte", i);
+  parsers.add ("filter", i);
+  pv.push_back (&ArgParser::do_filter); i++;
+
+  parsers.add ("h", i);
+  parsers.add ("he", i);
+  parsers.add ("hel", i);
+  parsers.add ("help", i);
+  pv.push_back (&ArgParser::do_help); i++;
+
+  parsers.add ("l", i);
+  parsers.add ("lo", i);
+  parsers.add ("loc", i);
+  parsers.add ("lock", i);
+  pv.push_back (&ArgParser::do_lock); i++;
+
+  parsers.add ("rel", i);
+  parsers.add ("relo", i);
+  parsers.add ("reloc", i);
+  parsers.add ("reloca", i);
+  parsers.add ("relocat", i);
+  parsers.add ("relocate", i);
+  pv.push_back (&ArgParser::do_relocate); i++;
+
+  parsers.add ("rem", i);
+  parsers.add ("remo", i);
+  parsers.add ("remov", i);
+  parsers.add ("remove", i);
+  pv.push_back (&ArgParser::do_remove); i++;
+
+  parsers.add ("run", i);
+  pv.push_back (&ArgParser::do_run); i++;
+
+  parsers.add ("run_sequence", i);
+  pv.push_back (&ArgParser::do_run_sequence); i++;
+
+  parsers.add ("set", i);
+  pv.push_back (&ArgParser::do_set); i++;
+
+  parsers.add ("setup", i);
+  pv.push_back (&ArgParser::do_setup); i++;
+
+  parsers.add ("sh", i);
+  parsers.add ("sho", i);
+  parsers.add ("show", i);
+  pv.push_back (&ArgParser::do_show); i++;
+
+  parsers.add ("sy", i);
+  parsers.add ("sys", i);
+  parsers.add ("syst", i);
+  parsers.add ("syste", i);
+  parsers.add ("system", i);
+  pv.push_back (&ArgParser::do_system); i++;
+
+  parsers.add ("u", i);
+  parsers.add ("un", i);
+  parsers.add ("unl", i);
+  parsers.add ("unlo", i);
+  parsers.add ("unloc", i);
+  parsers.add ("unlock", i);
+  pv.push_back (&ArgParser::do_unlock); i++;
+
+  parsers.add ("v", i);
+  parsers.add ("ve", i);
+  parsers.add ("ver", i);
+  parsers.add ("vers", i);
+  parsers.add ("versi", i);
+  parsers.add ("versio", i);
+  parsers.add ("version", i);
+  parsers.add ("--version", i);
+  pv.push_back (&ArgParser::do_version); i++;
+
+  parsers.add ("-b", i);
+  parsers.add ("-ba", i);
+  parsers.add ("-bat", i);
+  pv.push_back (&ArgParser::option_bat); i++;
+
+  parsers.add ("-c", i);
+  parsers.add ("-cs", i);
+  parsers.add ("-csh", i);
+  pv.push_back (&ArgParser::option_csh); i++;
+
+  parsers.add ("-d", i);
+  parsers.add ("-di", i);
+  parsers.add ("-dis", i);
+  parsers.add ("-disa", i);
+  parsers.add ("-disab", i);
+  parsers.add ("-disabl", i);
+  parsers.add ("-disable", i);
+  parsers.add ("-disable_", i);
+  parsers.add ("-disable_w", i);
+  parsers.add ("-disable_wa", i);
+  parsers.add ("-disable_war", i);
+  parsers.add ("-disable_warn", i);
+  parsers.add ("-disable_warni", i);
+  parsers.add ("-disable_warnin", i);
+  parsers.add ("-disable_warning", i);
+  parsers.add ("-disable_warnings", i);
+  pv.push_back (&ArgParser::option_disable_warnings); i++;
+//Cmt::get_quiet ()
+
+  parsers.add ("-e", i);
+  pv.push_back (&ArgParser::option_e); i++;
+
+  parsers.add ("-f", i);
+  pv.push_back (&ArgParser::option_f); i++;
+
+  parsers.add ("-h", i);
+  parsers.add ("-he", i);
+  parsers.add ("-hel", i);
+  parsers.add ("-help", i);
+  parsers.add ("--h", i);
+  parsers.add ("--he", i);
+  parsers.add ("--hel", i);
+  parsers.add ("--help", i);
+  pv.push_back (&ArgParser::option_help); i++;
+
+  parsers.add ("-ho", i);
+  parsers.add ("-hom", i);
+  parsers.add ("-home", i);
+  pv.push_back (&ArgParser::option_home); i++;
+
+  parsers.add ("-n", i);
+  pv.push_back (&ArgParser::option_n); i++;
+
+  parsers.add ("-no_c", i);
+  parsers.add ("-no_cl", i);
+  parsers.add ("-no_cle", i);
+  parsers.add ("-no_clea", i);
+  parsers.add ("-no_clean", i);
+  parsers.add ("-no_cleanu", i);
+  parsers.add ("-no_cleanup", i);
+  pv.push_back (&ArgParser::option_no_cleanup); i++;
+
+  parsers.add ("-pac", i);
+  parsers.add ("-pack", i);
+  pv.push_back (&ArgParser::option_pack); i++;
+
+  parsers.add ("-pat", i);
+  parsers.add ("-path", i);
+  pv.push_back (&ArgParser::option_path); i++;
+
+  parsers.add ("-pr", i);
+  parsers.add ("-pri", i);
+  parsers.add ("-priv", i);
+  parsers.add ("-priva", i);
+  parsers.add ("-privat", i);
+  parsers.add ("-private", i);
+  pv.push_back (&ArgParser::option_private); i++;
+
+  parsers.add ("-pu", i);
+  parsers.add ("-pub", i);
+  parsers.add ("-publ", i);
+  parsers.add ("-publi", i);
+  parsers.add ("-public", i);
+  pv.push_back (&ArgParser::option_public); i++;
+
+  parsers.add ("-s", i);
+  parsers.add ("-sh", i);
+  pv.push_back (&ArgParser::option_sh); i++;
+
+  parsers.add ("-q", i);
+  parsers.add ("-qu", i);
+  parsers.add ("-qui", i);
+  parsers.add ("-quie", i);
+  parsers.add ("-quiet", i);
+  pv.push_back (&ArgParser::option_quiet); i++;
+
+  parsers.add ("-tag", i);
+  pv.push_back (&ArgParser::option_tag); i++;
+
+  parsers.add ("-tag_add", i);
+  pv.push_back (&ArgParser::option_tag_add); i++;
+
+  parsers.add ("-tag_remove", i);
+  pv.push_back (&ArgParser::option_tag_remove); i++;
+
+  parsers.add ("-u", i);
+  parsers.add ("-us", i);
+  parsers.add ("-use", i);
+  pv.push_back (&ArgParser::option_use); i++;
+
+  parsers.add ("-user", i);
+  parsers.add ("-user_", i);
+  parsers.add ("-user_c", i);
+  parsers.add ("-user_co", i);
+  parsers.add ("-user_con", i);
+  parsers.add ("-user_cont", i);
+  parsers.add ("-user_conte", i);
+  parsers.add ("-user_contex", i);
+  parsers.add ("-user_context", i);
+  pv.push_back (&ArgParser::option_user_context); i++;
+
+  parsers.add ("-v", i);
+  parsers.add ("-ve", i);
+  parsers.add ("-ver", i);
+  parsers.add ("-vers", i);
+  parsers.add ("-versi", i);
+  parsers.add ("-versio", i);
+  parsers.add ("-version", i);
+  pv.push_back (&ArgParser::option_version); i++;
+
+  parsers.add ("-warn", i);
+  parsers.add ("-warni", i);
+  parsers.add ("-warnin", i);
+  parsers.add ("-warning", i);
+  parsers.add ("-warnings", i);
+  pv.push_back (&ArgParser::option_warnings); i++;
+
+  parsers.add ("-with_v", i);
+  parsers.add ("-with_ve", i);
+  parsers.add ("-with_ver", i);
+  parsers.add ("-with_vers", i);
+  parsers.add ("-with_versi", i);
+  parsers.add ("-with_versio", i);
+  parsers.add ("-with_version", i);
+  parsers.add ("-with_version_", i);
+  parsers.add ("-with_version_d", i);
+  parsers.add ("-with_version_di", i);
+  parsers.add ("-with_version_dir", i);
+  parsers.add ("-with_version_dire", i);
+  parsers.add ("-with_version_direc", i);
+  parsers.add ("-with_version_direct", i);
+  parsers.add ("-with_version_directo", i);
+  parsers.add ("-with_version_director", i);
+  parsers.add ("-with_version_directory", i);
+  pv.push_back (&ArgParser::option_with_version_directory); i++;
+
+  parsers.add ("-without_v", i);
+  parsers.add ("-without_ve", i);
+  parsers.add ("-without_ver", i);
+  parsers.add ("-without_vers", i);
+  parsers.add ("-without_versi", i);
+  parsers.add ("-without_versio", i);
+  parsers.add ("-without_version", i);
+  parsers.add ("-without_version_", i);
+  parsers.add ("-without_version_d", i);
+  parsers.add ("-without_version_di", i);
+  parsers.add ("-without_version_dir", i);
+  parsers.add ("-without_version_dire", i);
+  parsers.add ("-without_version_direc", i);
+  parsers.add ("-without_version_direct", i);
+  parsers.add ("-without_version_directo", i);
+  parsers.add ("-without_version_director", i);
+  parsers.add ("-without_version_directory", i);
+  pv.push_back (&ArgParser::option_without_version_directory); i++;
+
+}
+
+void ArgParser::shift ()
+{
+  if (argc > 0)
+    {
+      argc--;
+      argv++;
+    }
+}
+
+void ArgParser::unshift ()
+{
+  argc++;
+  argv--;
+}
+
+void ArgParser::fill_arguments ()
+{
+  while (argc > 0)
+    {
+      cmt_string& s = arguments.add ();
+      s = argv[0];
+
+      //cerr << "Getting arg[" << s << "] " << endl;
+
+      shift ();
+    }  
+}
+
+cmt_string& ArgParser::fill_one_argument ()
+{
+  if (argc > 0)
+    {
+      cmt_string& s = arguments.add ();
+      s = argv[0];
+
+      //cerr << "Getting arg[" << s << "] " << endl;
+
+      shift ();
+
+      return (s);
+    }
+  else
+    {
+      static cmt_string empty = "";
+      return (empty);
+    }
+}
+
+cmt_string& ArgParser::fill_one_argument_filtered ()
+{
+  if (argc > 0)
+    {
+      cmt_string& s = arguments.add ();
+      s = argv[0];
+
+      if (s[0] == '-')
+	{
+	  s = "";
+	}
+
+      //cerr << "Getting arg[" << s << "] " << endl;
+
+      shift ();
+
+      return (s);
+    }
+  else
+    {
+      static cmt_string empty = "";
+      return (empty);
+    }
+}
+
+void ArgParser::parse ()
+{
+  ArgParser& me = *this;
+
+  help_action = action_none;
+  arguments.clear ();
+  extra_line.erase (0);
+  extra_file.erase (0);
+  mode = Csh;
+
+  /// Skip first argument ("cmt")
+  shift ();
+
+  cmt.m_action = action_none;
+
+  while (argc > 0)
+    {
+      arg = argv[0];
+
+      shift ();
+
+      /// Suppress trailing carriage-return
+      int cr = arg.find ('\r');
+      if (cr != cmt_string::npos) arg.erase (cr);
+
+      /// Suppress enclosing quotes
+      if ((arg[0] == '\"') && (arg[arg.size () - 1] == '\"'))
+	{
+	  arg.erase (0, 1);
+	  arg.erase (arg.size () - 1, 1);
+	}
+
+      /// Detect and split arguments of the form a=b
+      /// left and right part of this argument
+      cmt_string reduced_arg = arg;
+      int pos = reduced_arg.find ('=');
+      if (pos != cmt_string::npos)
+	{
+	  reduced_arg.erase (pos);
+	  arg.erase (0, pos+1);
+	}
+      else
+	{
+	  arg = "";
+	}
+
+      // cerr << "argc=" << argc << " reduced_arg=[" << reduced_arg << "] arg=[" << arg << "]" << endl;
+
+      if (parsers.has (reduced_arg))
+	{
+	  // This argument corresponds to a known command
+
+	  int i = (*parsers.find (reduced_arg));
+
+	  parser p = pv[i];
+	  (me.*p) ();
+	}
+      else if (cmt.m_action != action_none)
+	{
+	  // We have unexpected arguments (not handled by the command handler). This may sign 
+	  // an unprotected handler implementation.
+	  if (!cmt.m_quiet) cerr << "#CMT> warning : unexpected parameter " << reduced_arg << endl;
+	}
+      else
+	{
+	  // This argument does not correspond to a known command. We expect then an action
+	  // to be executed with that name
+
+	  unshift ();
+	  do_do ();
+
+	  /*
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : bad command parameter " << arg << endl;
+	      help_action = action_none;
+	  */
+	}
+    }
+}
+
+void ArgParser::do_awk ()
+{
+  fill_arguments ();
+  cmt.m_action = action_awk;
+}
+
+void ArgParser::do_broadcast ()
+{
+  fill_arguments ();
+  cmt.m_action = action_broadcast;
+  
+  if (cmt.m_scope_filtering_mode == default_filtering_mode)
+    {
+      cmt.m_scope_filtering_mode = reach_private_uses;
+    }
+}
+
+void ArgParser::do_build ()
+{
+  if (argc > 0)
+    {
+      arg = argv[0];
+
+      if (arg == "-nmake")
+	{
+	  cmt.m_build_nmake = true;
+	  shift ();
+	}
+    }
+
+  if (argc > 0)
+    {
+      arg = argv[0];
+
+      shift ();
+
+      if (arg == "constituent_makefile")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	      cmt.m_action = action_build_constituent_makefile;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : constituent name missing" << endl;
+	      cmt.m_action = action_build_constituent_makefile;
+	      help_action = action_help;
+	    }
+	}
+      else if (arg == "constituents_makefile")
+	{
+	  fill_arguments ();
+	  cmt.m_action = action_build_constituents_makefile;
+	}
+      else if (arg == "dependencies")
+	{
+	  if (argc > 0)
+	    {
+	      fill_arguments ();
+	      cmt.m_action = action_build_dependencies;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : arguments missing " << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_build_dependencies;
+	    }
+	}
+      else if (arg == "library_links")
+	{
+	  cmt.m_action = action_build_library_links;
+	}
+      else if (arg == "make_setup")
+	{
+	  cmt.m_action = action_build_make_setup;
+	}
+      else if (arg == "msdev")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument_filtered ();
+	    }
+
+	  cmt.m_action = action_build_msdev;
+	}
+      else if (arg == "CMT_pacman")
+	{
+	  cmt.m_action = action_build_CMT_pacman;
+	}
+      else if (arg == "vsnet") 
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument_filtered ();
+	    }
+                                                                    
+	  cmt.m_action = action_build_vsnet;                 
+	}                                              
+      else if (arg == "os9_makefile")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	      cmt.m_action = action_build_os9_makefile;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : arguments missing " << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_build_os9_makefile;
+	    }
+	}
+      else if (arg == "prototype")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	      cmt.m_action = action_build_prototype;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : arguments missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_build_prototype;
+	    }
+	}
+      else if (arg == "readme")
+	{
+	  cmt.m_action = action_build_readme;
+
+	  fill_arguments ();
+	}
+      else if (arg == "tag_makefile")
+	{
+	  cmt.m_action = action_build_tag_makefile;
+	}
+      else if (arg == "temporary_name")
+	{
+	  cmt.m_action = action_build_temporary_name;
+	}
+      else if (arg == "triggers")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	      cmt.m_action = action_build_triggers;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : arguments missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_build_triggers;
+	    }
+	}
+      else if (arg == "windefs")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	      cmt.m_action = action_build_windefs;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : arguments missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_build_windefs;
+	    }
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : wrong build argument" << endl;
+	  help_action = action_help;
+	  cmt.m_action = action_build;
+	}
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : don't know what to build" << endl;
+      help_action = action_help;
+      cmt.m_action = action_build;
+    }
+}
+
+void ArgParser::do_check ()
+{
+  if (argc > 0)
+    {
+      arg = argv[0];
+
+      shift ();
+
+      if (arg == "configuration")
+	{
+	  cmt.m_action = action_check_configuration;
+	  //cmt.m_warnings = true;
+	}
+      else if (arg == "files")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	      if (argc > 0)
+		{
+		  fill_one_argument ();
+		  cmt.m_action = action_check_files;
+		}
+	      else
+		{
+		  if (!cmt.m_quiet) cerr << "#CMT> syntax error : reference file name missing" 
+					 << endl;
+		  help_action = action_help;
+		  cmt.m_action = action_check_files;
+		}
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : file name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_check_files;
+	    }
+	}
+      else if (arg == "version")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	      cmt.m_action = action_check_version;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_check_version;
+	    }
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : bad check option" << endl;
+	  help_action = action_help;
+	  cmt.m_action = action_check;
+	}
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : don't know what to check" << endl;
+      help_action = action_help;
+      cmt.m_action = action_check;
+    }
+}
+
+void ArgParser::do_check_files ()
+{
+  if (argc > 0)
+    {
+      fill_one_argument ();
+      if (argc > 0)
+	{
+	  fill_one_argument ();
+	  cmt.m_action = action_check_files;
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : reference file missing" << endl;
+	  help_action = action_help;
+	  cmt.m_action = action_check_files;
+	}
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : file name missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_check_files;
+    }
+}
+
+void ArgParser::do_checkout ()
+{
+  if (argc > 0)
+    {
+      fill_arguments ();
+      cmt.m_action = action_checkout;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : checkout arguments missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_checkout;
+    }
+}
+
+void ArgParser::do_cleanup ()
+{
+  cmt.m_action = action_cleanup;
+}
+
+void ArgParser::do_config ()
+{
+  cmt.m_action = action_config;
+}
+
+void ArgParser::do_create ()
+{
+  if (argc > 0)
+    {
+      fill_arguments ();
+      cmt.m_action = action_create;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : create arguments missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_create;
+    }
+}
+
+void ArgParser::do_create_project ()
+{
+  if (argc > 0)
+    {
+      fill_arguments ();
+      cmt.m_action = action_create_project;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : create_project arguments missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_create_project;
+    }
+}
+
+void ArgParser::do_cvsbranches ()
+{
+  if (argc > 0)
+    {
+      fill_one_argument ();
+      cmt.m_action = action_cvsbranches;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : cvsbranches arguments missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_cvsbranches;
+    }
+}
+
+void ArgParser::do_cvssubpackages ()
+{
+  if (argc > 0)
+    {
+      fill_one_argument ();
+    }
+
+  cmt.m_action = action_cvssubpackages;
+}
+
+void ArgParser::do_cvssubprojects ()
+{
+  if (argc > 0)
+    {
+      fill_one_argument ();
+    }
+
+  cmt.m_action = action_cvssubprojects;
+}
+
+void ArgParser::do_cvstags ()
+{
+  if (argc > 0)
+    {
+      fill_arguments ();
+      cmt.m_action = action_cvstags;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_cvstags;
+    }
+}
+
+void ArgParser::do_do ()
+{
+  if (argc > 0)
+    {
+      fill_arguments ();
+		  
+      {
+	cmt_string tag_name = "target_";
+	tag_name += arguments[0];
+
+	Tag* tag;
+	tag = Tag::add (tag_name, PriorityUserTag, "action", 0);                      
+	tag->mark ();
+      }
+
+      cmt.m_action = action_do;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : action not specified" << endl;
+      help_action = action_help;
+      cmt.m_action = action_do;
+    }
+}
+
+void ArgParser::do_expand ()
+{
+  if (argc > 0)
+    {
+      arg = argv[0];
+
+      shift ();
+      if (arg == "model")
+	{
+	  if (argc > 0)
+	    {
+	      fill_arguments ();
+	      cmt.m_action = action_expand_model;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : model not specified" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_expand_model;
+	    }
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : bad expand option" << endl;
+	  help_action = action_help;
+	  cmt.m_action = action_expand_model;
+	}
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : don't know what to expand" << endl;
+      help_action = action_help;
+      cmt.m_action = action_expand_model;
+    }
+}
+
+void ArgParser::do_filter ()
+{
+  if (argc > 0)
+    {
+      fill_arguments ();
+      cmt.m_action = action_filter;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : file to filter not specified" << endl;
+      help_action = action_help;
+      cmt.m_action = action_filter;
+    }
+}
+
+void ArgParser::do_help ()
+{
+  help_action = action_help;
+}
+
+void ArgParser::do_lock ()
+{
+  if (argc > 0)
+    {
+      cmt.m_current_package = fill_one_argument ();
+      cmt.m_current_version.erase (0);
+      cmt.m_current_path.erase (0);
+
+      if (argc > 0)
+	{
+	  cmt.m_current_version = fill_one_argument ();
+	  cmt.m_action = action_lock;
+
+	  if (argc > 0)
+	    {
+	      cmt.m_current_path = fill_one_argument_filtered ();
+	    }
+
+	  cmt.m_current_access = UserMode;
+	  (Use::current()).set (cmt.m_current_package, 
+				cmt.m_current_version, 
+				cmt.m_current_path);
+
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : version missing" << endl;
+	  help_action = action_help;
+	  cmt.m_action = action_lock;
+	}
+    }
+  else
+    {
+      cmt.m_action = action_lock;
+    }
+}
+
+
+void ArgParser::do_relocate ()
+{
+  cmt.m_action = action_relocate;
+}
+
+
+void ArgParser::do_remove ()
+{
+  if (argc > 0)
+    {
+      arg = argv[0];
+
+      if (arg == "library_links")
+	{
+	  shift ();
+	  cmt.m_action = action_remove_library_links;
+	}
+      else
+	{
+	  cmt.m_current_package = fill_one_argument ();
+	  cmt.m_current_version.erase (0);
+	  cmt.m_current_path.erase (0);
+                      
+	  if (argc > 0)
+	    {
+	      cmt.m_current_version = fill_one_argument ();
+
+	      if (argc > 0)
+		{
+		  cmt.m_current_path = fill_one_argument_filtered ();
+		}
+                            
+	      cmt.m_action = action_remove;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : version missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_remove;
+	    }
+	}
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : don't know what to remove" << endl;
+      help_action = action_help;
+      cmt.m_action = action_remove;
+    }
+}
+
+void ArgParser::do_run ()
+{
+  if (argc > 0)
+    {
+      fill_arguments ();
+      cmt.m_action = action_run;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : run arguments missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_run;
+    }
+}
+
+void ArgParser::do_run_sequence ()
+{
+  if (argc > 0)
+    {
+      fill_one_argument ();
+      cmt.m_action = action_run_sequence;
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : run_sequence arguments missing" << endl;
+      help_action = action_help;
+      cmt.m_action = action_run_sequence;
+    }
+}
+
+void ArgParser::do_set ()
+{
+  if (argc > 0)
+    {
+      arg = argv[0];
+
+      shift ();
+
+      if (arg == "version")
+	{
+	  fill_arguments ();
+	  cmt.m_action = action_set_version;
+	}
+      else if (arg == "versions")
+	{
+	  fill_arguments ();
+
+	  cmt.m_action = action_set_versions;
+
+	  if (cmt.m_scope_filtering_mode == default_filtering_mode)
+	    {
+	      cmt.m_scope_filtering_mode = reach_private_uses;
+	    }
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : bad set argument" << endl;
+	  help_action = action_help;
+	  //cmt.m_action = action_set;
+	}
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : don't know what to set" << endl;
+      help_action = action_help;
+      //cmt.m_action = action_set;
+    }
+}
+
+void ArgParser::do_setup ()
+{
+  cmt.m_action = action_setup;
+  //cmt.m_warnings = true;
+}
+
+void ArgParser::do_show ()
+{
+  if (argc > 0)
+    {
+      arg = argv[0];
+
+      //cerr << "Running show arg=" << arg << endl;
+
+      shift ();
+
+      if (arg == "action")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_action;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : action name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_action;
+	    }
+	}
+      else if (arg == "action_names")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	    }
+
+	  cmt.m_action = action_show_action_names;
+	}
+      else if (arg == "action_value")
+	{
+	  cmt.m_quiet = true;
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_action_value;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : action name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_action_value;
+	    }
+	}
+      else if (arg == "actions")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	    }
+
+	  cmt.m_action = action_show_actions;
+	}
+      else if (arg == "all_tags")
+	{
+	  cmt.m_action = action_show_all_tags;
+	}
+      else if (arg == "applied_patterns")
+	{
+	  cmt.m_action = action_show_applied_patterns;
+	}
+      else if (arg == "author")
+	{
+	  cmt.m_action = action_show_author;
+	}
+      else if (arg == "branches")
+	{
+	  cmt.m_action = action_show_branches;
+	}
+      else if (arg == "clients")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+
+	      cmt.m_action = action_show_clients;
+
+	      if (argc > 0)
+		{
+		  fill_one_argument ();
+		  if (argc > 0)
+		    {
+		      fill_one_argument ();
+		    }
+		}
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_clients;
+	    }
+	}
+      else if (arg == "cmtpath_patterns")
+	{
+	  cmt.m_action = action_show_cmtpath_patterns;
+	}
+      else if (arg == "constituent")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_constituent;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : constituent name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_constituent;
+	    }
+	}
+      else if (arg == "constituent_names")
+	{
+	  cmt.m_action = action_show_constituent_names;
+	}
+      else if (arg == "constituents")
+	{
+	  cmt.m_action = action_show_constituents;
+	}
+      else if (arg == "cycles")
+	{
+	  cmt.m_action = action_show_cycles;
+	}
+      else if (arg == "fragment")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_fragment;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : fragment name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_fragment;
+	    }
+	}
+      else if (arg == "fragments")
+	{
+	  cmt.m_action = action_show_fragments;
+	}
+      else if (arg == "groups")
+	{
+	  cmt.m_action = action_show_groups;
+	}
+      else if (arg == "include_dirs")
+	{
+	  cmt.m_action = action_show_include_dirs;
+	}
+      else if (arg == "language")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_language;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : language name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_language;
+	    }
+	}
+      else if (arg == "languages")
+	{
+	  cmt.m_action = action_show_languages;
+	}
+      else if (arg == "macro")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_macro;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : macro name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_macro;
+	    }
+	}
+      else if (arg == "macro_names")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	    }
+
+	  cmt.m_action = action_show_macro_names;
+	}
+      else if (arg == "macro_value")
+	{
+	  cmt.m_quiet = true;
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_macro_value;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : macro name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_macro_value;
+	    }
+	}
+      else if (arg == "macros")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	    }
+
+	  cmt.m_action = action_show_macros;
+	}
+      else if (arg == "manager")
+	{
+	  cmt.m_action = action_show_manager;
+	}
+      else if (arg == "packages")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	    }
+
+	  cmt.m_action = action_show_packages;
+	}
+      else if (arg == "path")
+	{
+	  cmt.m_action = action_show_path;
+	}
+      else if (arg == "pattern")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_pattern;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : pattern name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_pattern;
+	    }
+	}
+      else if (arg == "pattern_names")
+	{
+	  cmt.m_action = action_show_pattern_names;
+	}
+      else if (arg == "patterns")
+	{
+	  cmt.m_action = action_show_patterns;
+	}
+      else if (arg == "projects")
+	{
+	  cmt.m_action = action_show_projects;
+	}
+	else if (arg == "project_author")
+	{
+	  cmt.m_action = action_show_project_author;
+	}
+
+      else if (arg == "pwd")
+	{
+	  cmt.m_action = action_show_pwd;
+	}
+      else if (arg == "setup")
+	{
+	  cmt.m_action = action_show_setup;
+
+	  if (cmt.m_scope_filtering_mode == default_filtering_mode)
+	    {
+	      cmt.m_scope_filtering_mode = reach_private_uses;
+	    }
+	}
+      else if (arg == "set_names")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	    }
+
+	  cmt.m_action = action_show_set_names;
+	}
+      else if (arg == "set_value")
+	{
+	  cmt.m_quiet = true;
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_set_value;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : set name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_set_value;
+	    }
+	}
+      else if (arg == "set")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_set;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : set name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_set;
+	    }
+	}
+      else if (arg == "sets")
+	{
+	  if (argc > 0)
+	    {
+	      fill_one_argument ();
+	    }
+
+	  cmt.m_action = action_show_sets;
+	}
+      else if (arg == "strategies")
+	{
+	  cmt.m_action = action_show_strategies;
+	}
+      else if (arg == "tags")
+	{
+	  cmt.m_action = action_show_tags;
+	}
+      else if (arg == "use_paths")
+	{
+	  if (argc > 0)
+	    {
+	      while (argc > 0)
+		{
+		  if (strcmp (argv[0], "-private") == 0)
+		    {
+		      cmt.m_scope_filtering_mode = reach_private_uses;
+		    }
+		  else if (strcmp (argv[0], "--private") == 0)
+		    {
+		      cmt.m_scope_filtering_mode = reach_private_uses;
+		    }
+		  else
+		    {
+		      cmt_string& s = arguments.add ();
+		      s = argv[0];
+		    }
+
+		  shift ();
+		}
+
+	      cmt.m_action = action_show_use_paths;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_use_paths;
+	    }
+	}
+      else if ((arg == "u") ||
+	       (arg == "us") ||
+	       (arg == "use") ||
+	       (arg == "uses"))
+	{
+	  cmt.m_action = action_show_uses;
+
+	  if (cmt.m_scope_filtering_mode == default_filtering_mode)
+	    {
+	      cmt.m_scope_filtering_mode = reach_private_uses;
+	    }
+	}
+      else if (arg == "version")
+	{
+	  cmt.m_action = action_show_version;
+	}
+      else if (arg == "versions")
+	{
+	  if (argc > 0)
+	    {
+	      cmt.m_current_target = fill_one_argument ();
+	      cmt.m_action = action_show_versions;
+	    }
+	  else
+	    {
+	      if (!cmt.m_quiet) cerr << "#CMT> syntax error : package name missing" << endl;
+	      help_action = action_help;
+	      cmt.m_action = action_show_versions;
+	    }
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : bad show argument" << endl;
+	  help_action = action_help;
+	  cmt.m_action = action_show;
+	}
+    }
+  else
+    {
+      if (!cmt.m_quiet) cerr << "#CMT> syntax error : don't know what to show" << endl;
+      help_action = action_help;
+      cmt.m_action = action_show;
+    }
+}
+
+void ArgParser::do_system ()
+{
+  cmt.m_action = action_system;
+}
+
+void ArgParser::do_unlock ()
+{
+  if (argc > 0)
+    {
+      cmt.m_current_package = fill_one_argument ();
+      cmt.m_current_version.erase (0);
+      cmt.m_current_path.erase (0);
+                                        
+      if (argc > 0)
+	{
+	  cmt.m_current_version = fill_one_argument ();
+	  cmt.m_action = action_unlock;
+
+	  if (argc > 0)
+	    {
+	      cmt.m_current_path = fill_one_argument_filtered ();
+	    }
+                                                
+	  cmt.m_current_access = UserMode;
+	  (Use::current()).set (cmt.m_current_package, 
+				cmt.m_current_version, 
+				cmt.m_current_path);
+
+	}
+      else
+	{
+	  if (!cmt.m_quiet) cerr << "#CMT> syntax error : version missing" << endl;
+	  help_action = action_help;
+	  cmt.m_action = action_unlock;
+	}
+    }
+  else
+    {
+      cmt.m_action = action_unlock;
+    }
+}
+
+void ArgParser::do_version ()
+{
+  cmt.m_action = action_version;
+}
+
+void ArgParser::option_help ()
+{
+  help_action = action_help;
+}
+
+void ArgParser::option_n ()
+{
+  cmt.m_simulation = true;
+}
+
+
+void ArgParser::option_disable_warnings ()
+{
+  cmt.m_disable_warnings = true;
+}
+
+void ArgParser::option_quiet ()
+{
+  cmt.m_quiet = true;
+}
+
+
+void ArgParser::option_warnings ()
+{
+  cmt.m_warnings = true;
+}
+
+void ArgParser::option_csh ()
+{
+  mode = Csh;
+}
+
+void ArgParser::option_sh ()
+{
+  mode = Sh;
+}
+
+void ArgParser::option_bat ()
+{
+  mode = Bat;
+}
+
+void ArgParser::option_use ()
+{
+  if (cmt.m_action != action_create)
+    {
+      CmtSystem::cmt_string_vector words;
+
+      CmtSystem::split (arg, ":", words);
+
+      cmt.m_current_access = UserMode;
+
+      if (words.size () > 0) cmt.m_current_package = words[0];
+      if (words.size () > 1) cmt.m_current_version = words[1];
+      if (words.size () > 2) cmt.m_current_path    = words[2];
+      (Use::current()).set (cmt.m_current_package, 
+			    cmt.m_current_version, 
+			    cmt.m_current_path);
+    }
+}
+
+void ArgParser::option_pack ()
+{
+  if ((cmt.m_action != action_create) && (cmt.m_current_package != arg))
+    {
+      //CmtSystem::cd (cmt.m_default_path);
+
+      cmt.m_current_access = UserMode;
+
+      cmt.m_current_package = arg;
+      cmt.m_current_version = "";
+
+      /*
+      cerr << "ArgParser::option_pack> "
+	   << " cp=" << cmt.m_current_package
+	   << " cv=" << cmt.m_current_version
+	   << " cp=" << cmt.m_current_path << endl;
+      */
+
+      (Use::current()).set (cmt.m_current_package, 
+			    cmt.m_current_version, 
+			    cmt.m_current_path);
+    }
+}
+
+void ArgParser::option_version ()
+{
+  if ((cmt.m_action != action_create) && (cmt.m_current_version != arg))
+    {
+      cmt.m_current_access = UserMode;
+      cmt.m_current_version = arg;
+
+      /*
+      cerr << "ArgParser::option_version> "
+	   << " cp=" << cmt.m_current_package
+	   << " cv=" << cmt.m_current_version
+	   << " cp=" << cmt.m_current_path << endl;
+      */
+
+      (Use::current()).set (cmt.m_current_package, 
+			    cmt.m_current_version, 
+			    cmt.m_current_path);
+    }
+}
+
+void ArgParser::option_path ()
+{
+  if ((cmt.m_action != action_create) && (cmt.m_current_path != arg))
+    {
+      cmt.m_current_access = UserMode;
+      cmt.m_current_path = arg;
+
+      /*
+      cerr << "ArgParser::option_path> "
+	   << " cp=" << cmt.m_current_package
+	   << " cv=" << cmt.m_current_version
+	   << " cp=" << cmt.m_current_path << endl;
+      */
+
+      (Use::current()).set (cmt.m_current_package, 
+			    cmt.m_current_version, 
+			    cmt.m_current_path);
+
+      //IProjectFactory& factory = ProjectFactory::instance ();
+      //CmtSystem::add_cmt_path (cmt.m_current_path, "argument", factory);
+    }
+}
+
+void ArgParser::option_f ()
+{
+  extra_file = arg;
+}
+
+void ArgParser::option_e ()
+{
+  cerr << "#CMT> Warning: extra statement = " << arg << endl;
+  extra_line = arg;
+}
+
+void ArgParser::option_home ()
+{
+  if (CmtSystem::test_directory (arg))
+    {
+      cmt.m_cmt_home = arg;
+    }
+}
+
+void ArgParser::option_tag ()
+{
+  /*
+    Here we are going to change the complete tag set
+  */
+  if (arg != "")
+    {
+      Tag* tag;
+      CmtSystem::cmt_string_vector words;
+
+      // First reset selection of all existing tags
+      //Tag::clear_all ();
+      Tag::unmark_all ();
+      cmt.m_extra_tags = ",";
+		    
+      // Then restore CMTSITE
+      Cmt::configure_version_tag ();
+      Cmt::configure_site_tag (0);
+      Cmt::configure_uname_tag ();
+      Cmt::configure_hosttype_tag ();
+      Cmt::configure_config_tag ();
+      Cmt::configure_home (0);
+      Cmt::guess_current_project ();
+
+      CmtSystem::split (arg, " \t,", words);
+		  
+      for (int i = 0; i < words.size (); i++)
+	{
+	  const cmt_string& a = words[i];
+      //if (!cmt.m_quiet) cout	<< "parse_argument(tag_add)> current_tag=" << a << endl;  		      
+	  cmt_string s = ",";
+	  s += a;
+	  s += ",";
+		      
+	  if (i == 0)
+	    {
+	      cmt.m_current_tag = a;
+			  
+	      if (CmtSystem::testenv ("TAGDEBUG")) 
+	      cerr << "parse_argument(tag_add)> current_tag=" << cmt.m_current_tag << endl;
+	    }
+		      
+	  if (cmt.m_extra_tags.find (s) == cmt_string::npos)
+	    {
+	      //if (!cmt.m_quiet) cerr << "  a=[" << a << "]" << endl;
+			  
+	      // Then restore uname if the specified tag is CMTCONFIG
+	      if (a == CmtSystem::get_cmt_config ())
+		{
+		  Cmt::configure_uname_tag ();
+		}
+			  
+	      tag = Tag::add (a, PriorityArgument, "arguments", 0);
+	      tag->mark ();
+	      cmt.m_extra_tags += a;
+	      cmt.m_extra_tags += ",";
+	    }
+	}
+	// To be sure that a tag
+	Cmt::guess_current_project ();
+    }
+}
+
+void ArgParser::option_tag_add ()
+{
+  Tag* tag;
+  CmtSystem::cmt_string_vector words;
+  
+  if (!cmt.m_quiet) cout << "-tag_add=" << arg << endl;
+
+  CmtSystem::split (arg, " \t,", words);
+
+  for (int i = 0; i < words.size (); i++)
+    {
+      const cmt_string& a = words[i];
+
+      cmt_string s = ",";
+      s += a;
+      s += ",";
+
+      if (cmt.m_extra_tags.find (s) == cmt_string::npos)
+	{
+	  //if (!cmt.m_quiet) cerr << "  a=[" << a << "]" << endl;
+
+	  /// Then restore uname if the specified tag is CMTCONFIG
+	  if (a == CmtSystem::get_cmt_config ())
+	    {
+	      Cmt::configure_uname_tag ();
+	    }
+                      
+	  tag = Tag::add (a, PriorityUserTag, "arguments", 0);
+                      
+	  tag->mark ();
+
+	  cmt.m_extra_tags += a;
+	  cmt.m_extra_tags += ",";
+	}
+    }
+}
+
+void ArgParser::option_tag_remove ()
+{
+  Tag::TagPtrVector tags = Tag::tags ();
+  int i;
+  Tag* tag;
+
+  /*
+    for (i = 0; i < tags.size (); i++)
+    {
+    tag = tags[i];
+    if ((tag != 0) &&
+    (tag->selected))
+    {
+    if (!cmt.m_quiet) cerr << "  original tag_list=" << tag->name << tag->priority << endl;
+    }
+    }
+  */
+
+  CmtSystem::cmt_string_vector words;
+
+  //if (!cmt.m_quiet) cerr << "-arg_remove=" << arg << endl;
+
+  CmtSystem::split (arg, " \t,", words);
+
+  //
+  // Now erase all entries in the old list that match
+  // the specified tags 
+  //
+
+  for (i = 0; i < words.size (); i++)
+    {
+      const cmt_string& a = words[i];
+
+      cmt_string s = ",";
+      s += a;
+      s += ",";
+
+      int pos;
+
+      pos = cmt.m_extra_tags.find (s);
+
+      if (pos != cmt_string::npos)
+	{
+	  cmt.m_extra_tags.erase (pos, s.size () - 1);
+	}
+
+      //if (!cmt.m_quiet) cerr << "  tag_list=[" << tag_list << "]" << endl;
+    }
+
+  //
+  // Now reinject the purged list of tags into the database
+  // exactly as when using -tag=<tag-list>
+  //
+
+  /// First forget about all existing tags
+      Tag::unmark_all ();
+
+      /// Then restore CMTSITE
+	Cmt::configure_version_tag ();
+	Cmt::configure_site_tag (0);
+	Cmt::configure_uname_tag ();
+	Cmt::configure_hosttype_tag ();
+              
+	CmtSystem::split (cmt.m_extra_tags, " \t,", words);
+
+	for (i = 0; i < words.size (); i++)
+	  {
+	    const cmt_string& a = words[i];
+
+	    //fprintf (stderr, "  a=[%s]\n", a.c_str ());
+
+	    /// Then restore uname if the specified tag is CMTCONFIG
+	      if (a == CmtSystem::get_cmt_config ())
+		{
+		  Cmt::configure_uname_tag ();
+		}
+
+	      if (i == 0)
+		{
+		  cmt.m_current_tag = a;
+
+		  //if (!cmt.m_quiet) cerr << "parse_argument(tag_remove)> current_tag=" 
+		  //<< cmt.m_current_tag << endl;
+
+		  tag = Tag::add (a, PriorityTag, "restore configuration", 0);
+		}
+	      else
+		{
+		  tag = Tag::add (a, PriorityUserTag, "restore configuration", 0);
+		}
+
+	      tag->mark ();
+	  }
+}
+
+void ArgParser::option_user_context ()
+{
+  if (CmtSystem::test_directory (arg))
+    {
+      cmt.m_cmt_user_context = arg;
+    }
+}
+
+void ArgParser::option_with_version_directory ()
+{
+  cmt.m_current_structuring_style = with_version_directory;
+
+  StrategyDef* def = StrategyMgr::find_strategy ("VersionDirectory");
+  if (def != 0)
+    {
+      def->m_default_value = true;
+      def->m_priority_value = false;
+    }
+}
+
+void ArgParser::option_without_version_directory ()
+{
+  cmt.m_current_structuring_style = without_version_directory;
+
+  StrategyDef* def = StrategyMgr::find_strategy ("VersionDirectory");
+  if (def != 0)
+    {
+      def->m_default_value = false;
+      def->m_priority_value = true;
+    }
+}
+
+void ArgParser::option_no_cleanup ()
+{
+  //cmt.m_current_setup_strategy |= SetupNoCleanup;
+}
+
+void ArgParser::option_private ()
+{
+  cmt.m_scope_filtering_mode = reach_private_uses;
+}
+
+void ArgParser::option_public ()
+{
+  cmt.m_scope_filtering_mode = block_private_uses;
+}
+
+
+
+
+
+
+CommandHelp::HelpMap& CommandHelp::get_help ()
+{
+  static CommandHelp& me = instance ();
+
+  return (me.m_help);
+}
+
+CommandHelp::HelpTexts& CommandHelp::get_help_texts ()
+{
+  static CommandHelp& me = instance ();
+
+  return (me.m_help_texts);
+}
+
+const cmt_string& CommandHelp::get_help_text (ActionType key)
+{
+  static const HelpTexts& help = get_help_texts ();
+
+  const cmt_string& h = help[key];
+  return (h);
+}
+
+void CommandHelp::show_all ()
+{
+  static HelpTexts& help_texts = get_help_texts ();
+
+  cerr << "#> cmt command [option...]" << endl;
+  cerr << "# command :" << endl;
+
+  int i;
+
+  for (i = 0; ; i++)
+    {
+      const cmt_string& s = help_texts[i];
+      if (s == "") break;
+      cerr << "#   " << s << endl;
+    }
+
+  cerr << "# global options :" << endl;
+
+  cerr << "#   -disable_warnings       : don't print warnings" << endl;
+  cerr << "#   -quiet                  : don't print errors" << endl;
+  cerr << "#   -use=<p>:<v>:<path>     : set package version path" << endl;
+  cerr << "#   -pack=<package>         : set package" << endl;
+  cerr << "#   -version=<version>      : set version" << endl;
+  cerr << "#   -path=<path>            : set root path" << endl;
+  cerr << "#   -f=<requirement-file>   : set input file" << endl;
+  cerr << "#   -e=<statement>          : add a one line statement" << endl;
+  cerr << "#   -tag=<tag-list>         : select a new tag-set" << endl;
+  cerr << "#   -tag_add=<tag-list>     : add specific comma-separated tag(s)" << endl;
+  cerr << "#   -tag_remove=<tag-list>  : remove specific comma-separated tag(s)" << endl;
+  cerr << "#   -warnings               : display various warnings" << endl;
+  cerr << "#   -with_version_directory : reset to default structuring style" << endl;
+  cerr << "#   -without_version_directory : switch structuring style" << endl;
+  cerr << "#   -cleanup                : activate install area cleanup" << endl;
+  cerr << "#   -no_cleanup             : inhibit install area cleanup" << endl;
+}
+
+void CommandHelp::show (ActionType action)
+{
+  //cerr << "CommandHelp::show> action = " << action << endl;
+
+  static HelpTexts& help_texts = get_help_texts ();
+
+  if (action == action_build)
+    {
+      int i;
+
+      for (i = action_build_constituent_makefile; i <= action_build_windefs; i++)
+	{
+	  const cmt_string& s = help_texts[i];
+	  cerr << "#   " << s << endl;
+	}
+    }
+  if (action == action_check)
+    {
+      int i;
+
+      for (i = action_check_configuration; i <= action_check_version; i++)
+	{
+	  const cmt_string& s = help_texts[i];
+	  cerr << "#   " << s << endl;
+	}
+    }
+  else if (action == action_show)
+    {
+      int i;
+
+      for (i = (action_show + 1); i <= action_show_versions; i++)
+	{
+	  const cmt_string& s = help_texts[i];
+	  cerr << "#   " << s << endl;
+	}
+    }
+  else
+    {
+      const cmt_string& s = get_help_text (action);
+      cerr << "#" << s << endl;
+    }
+}
+
+CommandHelp& CommandHelp::instance ()
+{
+  static CommandHelp me;
+  return (me);
+}
+
+CommandHelp::CommandHelp ()
+{
+  static HelpMap& help = m_help;
+
+  static HelpTexts& help_texts = m_help_texts;
+
+  help_texts.clear ();
+
+  help_texts.add () =  "none";
+  help_texts.add () =  "awk";
+  help_texts.add () =  "broadcast [-select=list] [-exclude=list] [-local] [-global] [-begin=pattern] [-depth=n] <command> : apply a command to [some of] the used packages";
+  help_texts.add () =  "build <option>          : build actions. (Try cmt help build)";
+  help_texts.add () =  "build constituent_makefile <constituent>  : generate constituent Makefile fragment";
+  help_texts.add () =  "build constituents_makefile : generate constituents.make";
+  help_texts.add () =  "build dependencies      : generate dependencies";
+  help_texts.add () =  "build library_links     : build symbolic links towards all imported libraries";
+  help_texts.add () =  "build make_setup        : build a compiled version of setup scripts";
+  help_texts.add () =  "build msdev             : generate MSDEV files";
+  help_texts.add () =  "build CMT_pacman        : generate PACMAN manifest file for CMT";
+  help_texts.add () =  "build vsnet             : generate VS.NET files";
+  help_texts.add () =  "build os9_makefile      : generate Makefile for OS9";
+  help_texts.add () =  "build prototype         : generate prototype file";
+  help_texts.add () =  "build readme            : generate README.html";
+  help_texts.add () =  "build tag_makefile      : generate tag specific Makefile";
+  help_texts.add () =  "build temporary_name    : generate a name for a temprary file";
+  help_texts.add () =  "build triggers <constituent> : generate library trigger file";
+  help_texts.add () =  "build windefs <library_name> : generate def file for Windows shared libraries";
+  help_texts.add () =  "check <option>          : check actions. (Try cmt help check)";
+  help_texts.add () =  "check configuration     : check configuration";
+  help_texts.add () =  "check files <old> <new> : compare two files and overrides <old> by <new> if different";
+  help_texts.add () =  "check version <name>    : check if a name follows a version tag syntax ";
+  help_texts.add () =  "co | checkout           : perform a cvs checkout over a CMT package";
+  help_texts.add () =  "cleanup [-csh|-sh|-bat] : generate a cleanup script";
+  help_texts.add () =  "config                  : generate setup and cleanup scripts";
+  help_texts.add () =  "create <package> <version> [<path>] : create and configure a new package";
+  help_texts.add () =  "create_project <project> <name> [<path>] : create and configure a new project";
+  help_texts.add () =  "cvsbranches <module>      : display the subdirectories for a module";
+  help_texts.add () =  "cvssubpackages <module>   : display the subpackages for a module";
+  help_texts.add () =  "cvssubprojects <module>   : display the subprojects for a module";
+  help_texts.add () =  "cvstags <module>          : display the CVS tags for a module";
+  help_texts.add () =  "do <action> [<param>=<value>] ... : Execute an action";
+  help_texts.add () =  "expand model <model>    : ";
+  help_texts.add () =  "filter <in> <out>       : filter a file against CMT macros and env. variables";
+  help_texts.add () =  "help | -help | --help   : display this help";
+  help_texts.add () =  "load";
+  help_texts.add () =  "lock [<p> <v> [<path>]] : lock a package";
+  help_texts.add () =  "relocate                : generate only setup scripts";
+  help_texts.add () =  "remove <package> <version> [<path>] : remove a package version";
+  help_texts.add () =  "remove library_links    : remove symbolic links towards all imported libraries";
+  help_texts.add () =  "run '<command>'         : apply a command";
+  help_texts.add () =  "run_sequence <sequence file> : execute a cmt equence file";
+  help_texts.add () =  "set version <version>   : generate a version file in the current package";
+  help_texts.add () =  "set versions            : generate version files into packages";
+  help_texts.add () =  "setup [-csh|-sh|-bat]   : generate a setup script";
+  help_texts.add () =  "show <option>           : query actions. (Try cmt help show)";
+  help_texts.add () =  "show  action <name>     :  a formatted action definition";
+  help_texts.add () =  "show  action_value <name> :  a raw action definition";
+  help_texts.add () =  "show  action_names      :  all action names";
+  help_texts.add () =  "show  actions           :  all action definitions";
+  help_texts.add () =  "show  all_tags          :  all defined tags";
+  help_texts.add () =  "show  applied_patterns  :  all patterns actually applied";
+  help_texts.add () =  "show  author            :  package author";
+  help_texts.add () =  "show  branches          :  added branches";
+  help_texts.add () =  "show  clients           :  package clients";
+  help_texts.add () =  "show  cmtpath_patterns  :  cmtpath_patterns";
+  help_texts.add () =  "show  constituent <name>:  constituent definition";
+  help_texts.add () =  "show  constituent_names :  constituent names";
+  help_texts.add () =  "show  constituents      :  constituent definitions";
+  help_texts.add () =  "show  cycles            :  cycles in the use graph";
+  help_texts.add () =  "show  fragment <name>   :  one fragment definition";
+  help_texts.add () =  "show  fragments         :  fragment definitions";
+  help_texts.add () =  "show  groups            :  group definitions";
+  help_texts.add () =  "show  include_dirs      :  ";
+  help_texts.add () =  "show  language <name>   :  language definition";
+  help_texts.add () =  "show  languages         :  language definitions";
+  help_texts.add () =  "show  macro <name>      :  a formatted macro definition";
+  help_texts.add () =  "show  macro_value <name>  :  a raw macro definition";
+  help_texts.add () =  "show  macro_names       :  all macro names";
+  help_texts.add () =  "show  macros            :  all macro definitions";
+  help_texts.add () =  "show  manager           :  package manager";
+  help_texts.add () =  "show  packages          :  packages reachable from the current context";
+  help_texts.add () =  "show  path              :  the package search list";
+  help_texts.add () =  "show  pattern <name>    :  the pattern definition and usages";
+  help_texts.add () =  "show  pattern_names     :  pattern names";
+  help_texts.add () =  "show  patterns          :  the pattern definitions";
+  help_texts.add () =  "show  projects          :  project definitions";
+  help_texts.add () =  "show  project author    :  project author";
+  help_texts.add () =  "show  setup             :  setup definitions";
+  help_texts.add () =  "show  pwd               :  filtered current directory";
+  help_texts.add () =  "show  set <name>        :  a formatted set definition";
+  help_texts.add () =  "show  set_names         :  set names";
+  help_texts.add () =  "show  set_value <name>  :  a raw set definition";
+  help_texts.add () =  "show  sets              :  set definitions";
+  help_texts.add () =  "show  strategies        :  all strategies (build & version)";
+  help_texts.add () =  "show  tags              :  all currently active tags";
+  help_texts.add () =  "show  use_paths <pack>  :  all paths to the used package";
+  help_texts.add () =  "show  uses              :  used packages";
+  help_texts.add () =  "show  version           :  version of the current package";
+  help_texts.add () =  "show  versions <name>   :  visible versions of the selected package";
+  help_texts.add () =  "system                  : display the system tag";
+  help_texts.add () =  "unlock [<p> <v> [<path>]] : unlock a package";
+  help_texts.add () =  "version                 : version of CMT";
+  help_texts.add () =  "";
+
+  //"build <key>             : build various components :"
+  //"show <key>              : display various infos on :"
+
+  help.add (action_none, help_texts[action_none]);
+  help.add (action_awk, help_texts[action_awk]);
+  help.add (action_broadcast, help_texts[action_broadcast]);
+  help.add (action_build, help_texts[action_build]);
+  help.add (action_build_constituent_makefile, help_texts[action_build_constituent_makefile]);
+  help.add (action_build_constituents_makefile, help_texts[action_build_constituents_makefile]);
+  help.add (action_build_dependencies, help_texts[action_build_dependencies]);
+  help.add (action_build_library_links, help_texts[action_build_library_links]);
+  help.add (action_build_make_setup, help_texts[action_build_make_setup]);
+  help.add (action_build_msdev, help_texts[action_build_msdev]);
+  help.add (action_build_CMT_pacman, help_texts[action_build_CMT_pacman]);
+  help.add (action_build_vsnet, help_texts[action_build_vsnet]);
+  help.add (action_build_os9_makefile, help_texts[action_build_os9_makefile]);
+  help.add (action_build_prototype, help_texts[action_build_prototype]);
+  help.add (action_build_readme, help_texts[action_build_readme]);
+  help.add (action_build_tag_makefile, help_texts[action_build_tag_makefile]);
+  help.add (action_build_temporary_name, help_texts[action_build_temporary_name]);
+  help.add (action_build_triggers, help_texts[action_build_triggers]);
+  help.add (action_build_windefs, help_texts[action_build_windefs]);
+  help.add (action_check_configuration, help_texts[action_check_configuration]);
+  help.add (action_check_files, help_texts[action_check_files]);
+  help.add (action_check_version, help_texts[action_check_version]);
+  help.add (action_checkout, help_texts[action_checkout]);
+  help.add (action_cleanup, help_texts[action_cleanup]);
+  help.add (action_config, help_texts[action_config]);
+  help.add (action_create, help_texts[action_create]);
+  help.add (action_create_project, help_texts[action_create_project]);
+  help.add (action_cvsbranches, help_texts[action_cvsbranches]);
+  help.add (action_cvssubpackages, help_texts[action_cvssubpackages]);
+  help.add (action_cvssubprojects, help_texts[action_cvssubprojects]);
+  help.add (action_cvstags, help_texts[action_cvstags]);
+  help.add (action_do, help_texts[action_do]);
+  help.add (action_expand_model, help_texts[action_expand_model]);
+  help.add (action_filter, help_texts[action_filter]);
+  help.add (action_help, help_texts[action_help]);
+  help.add (action_load, help_texts[action_load]);
+  help.add (action_lock, help_texts[action_lock]);
+  help.add (action_relocate, help_texts[action_relocate]);
+  help.add (action_remove, help_texts[action_remove]);
+  help.add (action_remove_library_links, help_texts[action_remove_library_links]);
+  help.add (action_run, help_texts[action_run]);
+  help.add (action_run_sequence, help_texts[action_run_sequence]);
+  help.add (action_set_version, help_texts[action_set_version]);
+  help.add (action_set_versions, help_texts[action_set_versions]);
+  help.add (action_setup, help_texts[action_setup]);
+  help.add (action_show, help_texts[action_show]);
+  help.add (action_show_action, help_texts[action_show_action]);
+  help.add (action_show_action_value, help_texts[action_show_action_value]);
+  help.add (action_show_action_names, help_texts[action_show_action_names]);
+  help.add (action_show_actions, help_texts[action_show_actions]);
+  help.add (action_show_all_tags, help_texts[action_show_all_tags]);
+  help.add (action_show_applied_patterns, help_texts[action_show_applied_patterns]);
+  help.add (action_show_author, help_texts[action_show_author]);
+  help.add (action_show_branches, help_texts[action_show_branches]);
+  help.add (action_show_clients, help_texts[action_show_clients]);
+  help.add (action_show_cmtpath_patterns, help_texts[action_show_cmtpath_patterns]);
+  help.add (action_show_constituent, help_texts[action_show_constituent]);
+  help.add (action_show_constituent_names, help_texts[action_show_constituent_names]);
+  help.add (action_show_constituents, help_texts[action_show_constituents]);
+  help.add (action_show_cycles, help_texts[action_show_cycles]);
+  help.add (action_show_fragment, help_texts[action_show_fragment]);
+  help.add (action_show_fragments, help_texts[action_show_fragments]);
+  help.add (action_show_groups, help_texts[action_show_groups]);
+  help.add (action_show_include_dirs, help_texts[action_show_include_dirs]);
+  help.add (action_show_language, help_texts[action_show_language]);
+  help.add (action_show_languages, help_texts[action_show_languages]);
+  help.add (action_show_macro, help_texts[action_show_macro]);
+  help.add (action_show_macro_value, help_texts[action_show_macro_value]);
+  help.add (action_show_macro_names, help_texts[action_show_macro_names]);
+  help.add (action_show_macros, help_texts[action_show_macros]);
+  help.add (action_show_manager, help_texts[action_show_manager]);
+  help.add (action_show_packages, help_texts[action_show_packages]);
+  help.add (action_show_path, help_texts[action_show_path]);
+  help.add (action_show_pattern, help_texts[action_show_pattern]);
+  help.add (action_show_pattern_names, help_texts[action_show_pattern_names]);
+  help.add (action_show_patterns, help_texts[action_show_patterns]);
+  help.add (action_show_projects, help_texts[action_show_projects]);
+  help.add (action_show_project_author, help_texts[action_show_project_author]);
+  help.add (action_show_setup, help_texts[action_show_setup]);
+  help.add (action_show_pwd, help_texts[action_show_pwd]);
+  help.add (action_show_set, help_texts[action_show_set]);
+  help.add (action_show_set_names, help_texts[action_show_set_names]);
+  help.add (action_show_set_value, help_texts[action_show_set_value]);
+  help.add (action_show_sets, help_texts[action_show_sets]);
+  help.add (action_show_strategies, help_texts[action_show_strategies]);
+  help.add (action_show_tags, help_texts[action_show_tags]);
+  help.add (action_show_use_paths, help_texts[action_show_use_paths]);
+  help.add (action_show_uses, help_texts[action_show_uses]);
+  help.add (action_show_version, help_texts[action_show_version]);
+  help.add (action_show_versions, help_texts[action_show_versions]);
+  help.add (action_system, help_texts[action_system]);
+  help.add (action_unlock, help_texts[action_unlock]);
+  help.add (action_version, help_texts[action_version]);
+}
+
Index: /CMT/v1r20/source/cmt_commands.h
===================================================================
--- /CMT/v1r20/source/cmt_commands.h	(revision 368)
+++ /CMT/v1r20/source/cmt_commands.h	(revision 368)
@@ -0,0 +1,121 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_commands_h__
+#define __cmt_commands_h__
+
+#include "cmt_map.h"
+#include "cmt.h"
+
+class ArgParser
+{
+public:
+  typedef void (ArgParser::* parser) (void);
+
+  ArgParser (CmtContext& context);
+
+  void parse ();
+
+  int argc;
+  char** argv;
+  cmt_string arg;
+  CmtSystem::cmt_string_vector arguments;
+  cmt_string extra_line;
+  cmt_string extra_file;
+  PrintMode mode;
+  ActionType help_action;
+
+private:
+  void do_awk ();
+  void do_broadcast ();
+  void do_build ();
+  void do_check ();
+  void do_check_files ();
+  void do_checkout ();
+  void do_cleanup ();
+  void do_config ();
+  void do_create ();
+  void do_create_project ();
+  void do_cvsbranches ();
+  void do_cvssubpackages ();
+  void do_cvssubprojects ();
+  void do_cvstags  ();
+  void do_do       ();
+  void do_expand   ();
+  void do_filter   ();
+  void do_help     ();
+  void do_lock     ();
+  void do_relocate ();
+  void do_remove   ();
+  void do_run      ();
+  void do_run_sequence ();
+  void do_set ();
+  void do_setup ();
+  void do_show ();
+  void do_system ();
+  void do_unlock ();
+  void do_version ();
+  void option_disable_warnings();
+  void option_help ();
+  void option_n ();
+  void option_quiet ();
+  void option_warnings ();
+  void option_csh ();
+  void option_sh ();
+  void option_bat ();
+  void option_use ();
+  void option_pack ();
+  void option_version ();
+  void option_path ();
+  void option_f ();
+  void option_e ();
+  void option_home ();
+  void option_tag ();
+  void option_tag_add ();
+  void option_tag_remove ();
+  void option_user_context ();
+  void option_with_version_directory ();
+  void option_without_version_directory ();
+  void option_no_cleanup ();
+  void option_private ();
+  void option_public ();
+
+  void shift ();
+  void unshift ();
+  void fill_arguments ();
+  cmt_string& fill_one_argument ();
+  cmt_string& fill_one_argument_filtered ();
+
+  CmtContext& cmt;
+
+  cmt_vmap <cmt_string, int> parsers;
+  cmt_vector <parser> pv;
+
+};
+
+class CommandHelp
+{
+public:
+  typedef cmt_map <ActionType, cmt_string> HelpMap;
+  typedef cmt_vector <cmt_string> HelpTexts;
+
+  static HelpMap& get_help ();
+  static HelpTexts& get_help_texts ();
+  static const cmt_string& get_help_text (ActionType key);
+  static void show_all ();
+  static void show (ActionType action);
+
+private:
+  static CommandHelp& instance ();
+
+  CommandHelp ();
+
+  HelpMap m_help;
+  HelpTexts m_help_texts;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_constituent.cxx
===================================================================
--- /CMT/v1r20/source/cmt_constituent.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_constituent.cxx	(revision 368)
@@ -0,0 +1,662 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_constituent.h"
+#include "cmt_generator.h"
+#include "cmt_system.h"
+#include "cmt_database.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Constituent                               */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+//----------------------------------------------------------
+void Constituent::show (const cmt_string& name)
+{
+  Constituent* cptr = find (name);
+  if (cptr == 0) return;
+
+  const Constituent& constituent = *cptr;
+
+  constituent.show ();
+}
+
+//----------------------------------------------------------
+void Constituent::parse_all ()
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  int number;
+
+  for (number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      if (symbol.type != Symbol::SymbolAction) continue;
+
+      if (symbol.value_lists.size () < 1) continue;
+
+      cmt_string value = symbol.build_macro_value ();
+
+      if (value != "")
+	{
+	  add_for_action (symbol.name);
+	}
+    }
+
+  for (number = 0; number < Constituents.size (); number++)
+    {
+      Constituent& constituent = Constituents[number];
+
+      constituent.parse ();
+    }
+}
+
+//----------------------------------------------------------
+void Constituent::show_all ()
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  int number;
+
+  for (number = 0; number < Constituents.size (); number++)
+    {
+      const Constituent& constituent = Constituents[number];
+
+      constituent.show ();
+    }
+}
+
+//----------------------------------------------------------
+void Constituent::show_names ()
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  int number;
+
+  for (number = 0; number < Constituents.size (); number++)
+    {
+      Constituent& constituent = Constituents[number];
+      cout << constituent.name << endl;
+    }
+}
+
+//----------------------------------------------------------
+Constituent* Constituent::find (const cmt_string& name)
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  int constituent_index;
+
+  if (Constituents.size () == 0) return (0);
+
+  for (constituent_index = 0;
+       constituent_index < Constituents.size ();
+       constituent_index++)
+    {
+      Constituent& constituent = Constituents[constituent_index];
+
+      if (constituent.name == name)
+        {
+          return (&constituent);
+        }
+    }
+
+  return (0);
+}
+
+class constituents_action_iterator
+{
+public:
+  typedef enum
+  {
+    ready,
+    need_include
+  } states;
+
+  constituents_action_iterator (Constituent& c) : m_constituent (c)
+  {
+    m_state = ready;
+  }
+
+  void set (const cmt_string& w)
+  {
+    int equal;
+
+    if (w == "") return;
+
+    if (m_state == need_include)
+      {
+        m_state = ready;
+
+        cmt_string& include = m_constituent.includes.add ();
+        include = w;
+      }
+
+    if (w == "-OS9")
+      {
+        m_constituent.need_OS9 = true;
+      }
+    else if ((w == "-Windows") ||
+             (w == "-windows"))
+      {
+        m_constituent.windows = true;
+      }
+    else if (w == "-no_share")
+      {
+        m_constituent.no_share = true;
+      }
+    else if (w == "-no_static")
+      {
+        m_constituent.no_static = true;
+      }
+    else if (w == "-prototypes")
+      {
+        m_constituent.need_prototypes = true;
+      }
+    else if (w == "-no_prototypes")
+      {
+        m_constituent.need_prototypes = false;
+      }
+    else if (w == "-check")
+      {
+        m_constituent.need_check = true;
+      }
+    else if (w == "-triggers")
+      {
+        if (m_constituent.type == Library)
+          {
+              //m_constituent.build_triggers = true;
+          }
+      }
+    else if (w == "-no_triggers")
+      {
+        if (m_constituent.type == Library)
+          {
+            m_constituent.build_triggers = false;
+          }
+      }
+    else if (w == "-I")
+      {
+        m_state = need_include;
+      }
+    else if (w.substr (0, 3) == "-s=")
+      {
+        w.substr (3, m_subdir);
+      }
+    else if (w.substr (0, 3) == "-x=")
+      {
+        cmt_string& exclude = m_constituent.excludes.add ();
+        w.substr (3, exclude);
+        cmt_regexp& exp = m_constituent.exclude_exprs.add ();
+	exp.set (exclude);
+      }
+    else if (w.substr (0, 3) == "-k=")
+      {
+        cmt_string& select = m_constituent.selects.add ();
+        w.substr (3, select);
+        cmt_regexp& exp = m_constituent.select_exprs.add ();
+	exp.set (select);
+      }
+    else if (w.substr (0, 8) == "-import=")
+      {        
+            cmt_string text_imports;
+            w.substr (8, text_imports);
+
+            CmtSystem::cmt_string_vector imports;
+
+            CmtSystem::split (text_imports, ',', imports);
+
+            for (int i = 0; i < imports.size (); i++)
+            {
+                cmt_string& import = m_constituent.imports.add ();
+                import             = imports[i] ; 
+            }        
+      }
+    else if (w.substr (0, 7) == "-group=")
+      {
+        cmt_string group_name = "";
+
+        w.substr (7, group_name);
+        
+	if (group_name != "")
+	  {
+	    m_constituent.group = Group::add (group_name);
+	  }
+      }
+    else if (w.substr (0, 8) == "-suffix=")
+      {
+        w.substr (8, m_constituent.suffix);
+      }
+    else if (w == "-target_tag")
+      {
+	m_constituent.has_target_tag = true;
+      }
+    else if (w.substr (0, 1) == "-")
+      {
+	   //if (!Cmt::get_quiet ())
+	   //{
+	    cerr << "#CMT> Warning: bad option " 
+		 << w << " in constituent " << m_constituent.name << endl;
+	    //CmtError::set (CmtError::execution_error, cmd);
+	   //}
+      }
+    else if ((equal = w.find ("=")) != cmt_string::npos)
+      {
+        cmt_string variable_name;
+        cmt_string variable_value;
+        
+        w.substr (0, equal, variable_name);
+        w.substr (equal + 1, variable_value);
+        
+        Variable* v = Variable::find (m_constituent.variables, variable_name);
+        if (v == 0)
+          {
+            v = &(m_constituent.variables.add ());
+            v->set (variable_name);
+          }
+
+        (*v) = variable_value;
+      }
+    else
+      {
+        // We have a normal source module
+ 
+        cmt_string& module = m_constituent.modules.add ();
+        
+        module.erase (0);
+          
+        //
+        // The prefix explicitly provided in (w) has priority
+        // over the currently specified (m_subdir) when it is an
+        // absolute path
+        //
+        if (CmtSystem::absolute_path (w))
+          {
+            module += w;
+          }
+        else
+          {
+            cmt_string prefix;
+            cmt_string name = w;
+
+            CmtSystem::dirname (name, prefix);
+            if (prefix == "../src") CmtSystem::basename (name, name);
+
+            module += m_subdir;
+
+            if (module != "")
+              {
+                module += CmtSystem::file_separator ();
+              }
+
+            module += name;
+          }
+      }
+  }
+
+  Constituent& m_constituent;
+  cmt_string m_subdir;
+  states m_state;
+};
+
+//----------------------------------------------------------
+void Constituent::action (ConstituentType type,
+                          const CmtSystem::cmt_string_vector& words)
+{
+  cmt_string generator;
+  cmt_string name;
+  Constituent* constituent;
+
+  int i = 1;
+
+  if (type == Document)
+    {
+      generator = words[i];
+      if (generator == "") return;
+      i++;
+    }
+
+  name = words[i];
+  if (name == "") return;
+  i++;
+
+  constituent = add (type, name, generator);
+
+  for (;i < words.size (); i++)
+    {
+      const cmt_string& w = words[i];
+      cmt_string& parameter = constituent->parameters.add ();
+      parameter = w;
+    }
+}
+
+//----------------------------------------------------------
+void Constituent::parse ()
+{
+  if (parameters.size () == 0) return;
+
+  Constituent& me = *this;
+
+  modules.clear ();
+
+  constituents_action_iterator it (me);
+
+  for (int i = 0; i < parameters.size (); i++)
+    {
+      const cmt_string& w = parameters[i];
+      cmt_string ew = w;
+
+      Symbol::expand (ew);
+
+      CmtSystem::cmt_string_vector ws;
+
+      //cerr << "Constituent " << name << " Analyzing module " << ew << endl;
+
+      if (ew.substr (0, 13) == "action_value=")
+	{
+          it.set (ew);
+	}
+      else
+	{
+	  CmtSystem::split (ew, " \t", ws);
+
+	  for (int j = 0; j < ws.size (); ++j)
+	    {
+	      const cmt_string& w = ws[j];
+          
+	      //cerr << "Constituent " << name << " Setting module " << w << endl;
+	      it.set (w);
+	    }
+	}
+    }
+
+  parameters.clear ();
+}
+
+//----------------------------------------------------------
+Constituent* Constituent::add (ConstituentType type,
+                               const cmt_string& name,
+                               const cmt_string& generator)
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  {
+    Constituent* constituent;
+
+    if (name == "") return (0);
+
+    constituent = find (name);
+    if (constituent != 0) return (constituent);
+  }
+
+  Constituent& constituent = Constituents.add ();
+  constituent.clear ();
+
+  constituent.name      = name;
+  constituent.generator = generator;
+  constituent.type      = type;
+  constituent.need_prototypes = Cmt::need_prototypes ();
+
+  return (&constituent);
+}
+
+//----------------------------------------------------------
+Constituent* Constituent::add_for_action (const cmt_string& name)
+{
+  Constituent* constituent;
+
+  constituent = add (Document, name, "cmt_action_runner");
+
+  constituent->group = Group::add ("cmt_actions");
+  constituent->has_target_tag = true;
+
+  cmt_string& p1 = constituent->parameters.add ();
+  p1 = "action_value=";
+  p1 += "$(";
+  p1 += name;
+  p1 += ")";
+
+  return (constituent);
+}
+
+//----------------------------------------------------------
+void Constituent::clear_all ()
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  for (int i = 0; i < Constituents.size (); i++)
+    {
+      Constituent& c = Constituents[i];
+      c.clear ();
+    }
+  Constituents.clear ();
+}
+
+//----------------------------------------------------------
+Constituent::ConstituentVector& Constituent::constituents ()
+{
+  static Database& db = Database::instance ();
+  static ConstituentVector& Constituents = db.constituents ();
+
+  return (Constituents);
+}
+
+//----------------------------------------------------------
+Constituent::Constituent ()
+{
+  clear ();
+}
+
+//----------------------------------------------------------
+Constituent::~Constituent ()
+{
+}
+
+//----------------------------------------------------------
+void Constituent::clear ()
+{
+  name      = "";
+  generator = "";
+  type = Document;
+  group     = 0;
+  modules.clear ();
+  parameters.clear ();
+  need_OS9        = false;
+  windows         = false;
+  no_static       = false;
+  no_share        = false;
+  need_prototypes = false;
+  need_check      = false;
+  build_triggers  = false;
+  has_target_tag  = false;
+  excludes.clear ();
+  exclude_exprs.clear ();
+  selects.clear ();
+  select_exprs.clear ();
+  includes.clear ();
+  imports.clear ();
+  variables.clear ();
+}
+
+//----------------------------------------------------------
+void Constituent::build_all_makefiles (bool simulation)
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  int i;
+
+  for (i = 0; i < Constituents.size (); i++)
+    {
+      Constituent& constituent = Constituents[i];
+
+      constituent.build_makefile (simulation);
+    }
+}
+
+//----------------------------------------------------------
+void Constituent::build_all_msdev_files (bool simulation)
+{
+  static ConstituentVector& Constituents = constituents ();
+
+  int i;
+
+  Generator::build_msdev_workspace (Constituents);
+
+  for (i = 0; i < Constituents.size (); i++)
+    {
+      Constituent& constituent = Constituents[i];
+
+      constituent.build_msdev_file (simulation);
+    }
+}
+
+// Visual Studio.Net Support                                     
+//----------------------------------------------------------     
+void Constituent::build_all_vsnet_files (bool simulation)        
+{                                                                
+  static ConstituentVector& Constituents = constituents ();      
+                                                                 
+  int i;                                                         
+                                                                 
+  Generator::build_vsnet_workspace (Constituents);               
+                                                                 
+  for (i = 0; i < Constituents.size (); i++)                     
+    {                                                            
+      Constituent& constituent = Constituents[i];                
+                                                                 
+      constituent.build_vsnet_file (simulation);                 
+    }                                                            
+}                                                                
+                                                                 
+//----------------------------------------------------------
+void Constituent::build_makefile (bool simulation) const
+{
+  if (!simulation)
+    {
+      Generator::build_constituent_makefile (*this);
+    }
+}
+
+//----------------------------------------------------------
+void Constituent::build_msdev_file (bool simulation) const
+{
+  if (!simulation)
+    {
+      Generator::build_msdev (*this);
+    }
+}
+
+// Visual Studio.net Support                                  
+//----------------------------------------------------------  
+void Constituent::build_vsnet_file (bool simulation) const    
+{                                                             
+  if (!simulation)                                            
+    {                                                         
+      Generator::build_vsnet (*this);                         
+    }
+}
+
+//----------------------------------------------------------
+void Constituent::show () const
+{
+  int i;
+
+  switch (type)
+    {
+      case Library:
+        cout << "library";
+        break;
+      case Application:
+        cout << "application";
+        break;
+      case Document:
+        cout << "document " << generator;
+        break;
+    }
+  
+  cout << " " << name;
+  
+  if (group != 0)
+    {
+      cout << " -group=" << group->name ();
+    }
+  
+  if (suffix != 0)
+    {
+      cout << " -suffix=" << suffix;
+    }
+  
+  if ((type == Application) && need_check)
+    {
+      cout << " -check";
+    }
+  
+  if ((type == Library) && no_share)
+    {
+      cout << " -no_share";
+    }
+  
+  if ((type == Library) && no_static)
+    {
+      cout << " -no_static";
+    }
+  
+  if ((type == Library) && build_triggers)
+    {
+      cout << " -triggers";
+    }
+  
+  if (has_target_tag)
+    {
+      cout << " -target_tag";
+    }
+  
+  for (i = 0; i < (imports.size ()); i++)
+    {
+      const cmt_string& import_name = imports[i];
+      
+      cout << " -import=" << import_name;
+    }
+  
+  for (i = 0; i < (excludes.size ()); i++)
+    {
+      const cmt_string& exclude = excludes[i];
+      
+      cout << " -x=" << exclude;
+    }
+  
+  for (i = 0; i < (selects.size ()); i++)
+    {
+      const cmt_string& select = selects[i];
+      
+      cout << " -k=" << select;
+    }
+  
+  for (i = 0; i < (modules.size ()); i++)
+    {
+      const cmt_string& module_name = modules[i];
+      
+      cout << " " << module_name;
+    }
+  
+  for (i = 0; i < (variables.size ()); i++)
+    {
+      const Variable& v = variables[i];
+      
+      cout << " " << v.name << "=" << v.value;
+    }
+  
+  cout << endl;
+}
Index: /CMT/v1r20/source/cmt_constituent.h
===================================================================
--- /CMT/v1r20/source/cmt_constituent.h	(revision 368)
+++ /CMT/v1r20/source/cmt_constituent.h	(revision 368)
@@ -0,0 +1,76 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_constituent_h__
+#define __cmt_constituent_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+#include "cmt_fragment.h"
+#include "cmt_group.h"
+
+class Constituent
+{
+public:
+  typedef cmt_vector<Constituent> ConstituentVector;
+  static void action (ConstituentType type,
+                      const CmtSystem::cmt_string_vector& words);
+  static Constituent* find (const cmt_string& name);
+  static Constituent* add (ConstituentType type,
+                           const cmt_string& name,
+                           const cmt_string& generator);
+  static Constituent* add_for_action (const cmt_string& name);
+  static void show (const cmt_string& name);
+  static void parse_all ();
+  static void show_all ();
+  static void show_names ();
+  static void build_all_makefiles (bool simulation);
+  static void build_all_msdev_files (bool simulation);
+  static void build_all_vsnet_files (bool simulation); 
+  static void clear_all ();
+  static ConstituentVector& constituents ();
+
+public:
+  Constituent ();
+  ~Constituent ();
+  void parse ();
+
+  virtual void clear ();
+  virtual void build_makefile (bool simulation) const;
+  virtual void build_msdev_file (bool simulation) const;
+  virtual void build_vsnet_file (bool simulation) const;
+  virtual void show () const;
+
+  cmt_string name;
+  cmt_string generator;
+  ConstituentType type;
+  Group* group;
+  cmt_string suffix;
+  CmtSystem::cmt_string_vector modules;
+  bool need_OS9;
+  bool windows;
+  bool no_static;
+  bool no_share;
+  bool need_prototypes;
+  bool need_check;
+  bool build_triggers;
+  bool has_target_tag;
+  CmtSystem::cmt_string_vector excludes;
+  cmt_vector<cmt_regexp> exclude_exprs;
+
+  CmtSystem::cmt_string_vector selects;
+  cmt_vector<cmt_regexp> select_exprs;
+
+  CmtSystem::cmt_string_vector includes;
+  CmtSystem::cmt_string_vector imports;
+  Variable::VariableVector variables;
+
+private:
+  CmtSystem::cmt_string_vector parameters;
+
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_cvs.cxx
===================================================================
--- /CMT/v1r20/source/cmt_cvs.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_cvs.cxx	(revision 368)
@@ -0,0 +1,2896 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by: garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "cmt.h"
+#include "cmt_cvs.h"
+#include "cmt_awk.h"
+#include "cmt_symbol.h"
+#include "cmt_project.h"
+
+/**
+
+    Grep : perform a grep like operation onto a cmt_string
+
+    o All lines of the input string are collected when they contain
+      the specified pattern.
+    o The input string and the selector pattern are specified in
+      the constructor:
+
+         Grep (input_string, pattern)
+
+    o All selected lines are accumulated (appended) into the internal
+      variable m_result . 'space' is the separator.
+
+    o The accumulator is retrieved by the result () method.
+
+ */
+class Grep : public Awk
+{
+public:
+
+  void begin ();
+  void filter (const cmt_string& line);
+  const cmt_string& result () const;
+
+private:
+  cmt_string m_result;
+};
+
+/**
+
+     Cut : perform a cut-like operation :
+
+     o collect the <field>'th field of every line into the m_result 
+       internal variable
+
+     o the field number is given in the constructor and starts at zero.
+
+     o selected fields are accumulated with a space as separator.
+
+ */
+class Cut : public Awk
+{
+public:
+  Cut (int field);
+  void begin ();
+  void filter (const cmt_string& line);
+  const cmt_string& result () const;
+
+private:
+  cmt_string m_result;
+  int m_field;
+};
+
+/**
+
+      History : maintains the history of checkouts during a 
+                recursive checkout, so as to avoid double checkouts.
+
+ */
+class History
+{
+public:
+  static History& instance ();
+  void clear ();
+  void install (const cmt_string& line);
+  bool is_installed (const cmt_string& line);
+
+private:
+  History ();
+
+  cmt_string m_installed;
+};
+
+/**
+
+     RecursivePass1 : simply validate use statements in a requirements file
+                      and echo those that really need to be handled.
+
+ */
+class RecursivePass1 : public Awk
+{
+public:
+
+  void begin ();
+  void filter (const cmt_string& line);
+  const cmt_string& result () const;
+
+private:
+  cmt_string m_result;
+  bool m_first;
+};
+
+/**
+
+     RecursivePass2 : after filtering the use statements really perform the
+                      checkouts.
+
+ */
+class CvsImplementation;
+class RecursivePass2 : public Awk
+{
+public:
+  RecursivePass2 (CvsImplementation& cvs);
+  void begin ();
+  void filter (const cmt_string& line);
+
+private:
+  CvsImplementation& m_cvs;
+};
+
+/**
+
+     RecursivePass3 : simply validate use statements in a project file
+                      and echo those that really need to be handled.
+
+ */
+class RecursivePass3 : public Awk
+{
+public:
+
+  void begin ();
+  void filter (const cmt_string& line);
+  const cmt_string& result () const;
+
+private:
+  cmt_string m_result;
+  bool m_first;
+};
+
+/**
+
+     RecursivePass4 : after filtering the use statements really perform the
+                      project checkouts.
+
+ */
+class CvsImplementation;
+class RecursivePass4 : public Awk
+{
+public:
+  RecursivePass4 (CvsImplementation& cvs);
+  void begin ();
+  void filter (const cmt_string& line);
+
+private:
+  CvsImplementation& m_cvs;
+};
+
+/**
+
+   Internal implementation of CVS to CMT operations.
+   The Cvs class only provides abstract interface.
+
+ */
+class CvsImplementation
+{
+public:
+
+  CvsImplementation ()
+  {
+    clear ();
+  }
+
+  void clear ()
+  {
+    m_recursive  = false;
+    m_head       = false;
+    m_verbose    = false;
+    m_simulation = false;
+    no_config    = false;
+
+    m_home_dir     = "";
+    m_checkout_dir = "";
+    m_version_dir  = "";
+    m_cvs_offset   = "";
+
+    m_last_module        = "";
+    m_last_cvs_infos     = "";
+    structure_info       = "";
+    error_info           = "";
+    tags_top_info        = "";
+    tags_info            = "";
+    cvsversions_top_info = "";
+    cvsversions_info     = "";
+    branches_info        = "";
+    subpackages_info     = "";
+    subprojects_info     = "";
+
+    m_protocol_level     = "";
+
+    Symbol* symbol = Symbol::find ("cmt_cvs_protocol_level");
+    if (symbol != 0)
+      {
+	m_protocol_level = symbol->build_macro_value ();
+	Symbol::expand (m_protocol_level);
+      }
+  }
+
+  CvsImplementation& operator = (const CvsImplementation& other)
+  {
+    m_recursive  = other.m_recursive;
+    m_head       = other.m_head;
+    m_verbose    = other.m_verbose;
+    m_simulation = other.m_simulation;
+    no_config    = other.no_config;
+
+    m_home_dir       = other.m_home_dir;
+    m_checkout_dir   = other.m_checkout_dir;
+    m_version_dir    = other.m_version_dir;
+    m_cvs_offset     = other.m_cvs_offset;
+    m_protocol_level = other.m_protocol_level;
+    m_last_module    = other.m_last_module;
+    m_last_cvs_infos = other.m_last_cvs_infos;
+
+    structure_info       = other.structure_info;
+    error_info           = other.error_info;
+    tags_top_info        = other.tags_top_info;
+    tags_info            = other.tags_info;
+    cvsversions_top_info = other.cvsversions_top_info;
+    cvsversions_info     = other.cvsversions_info;
+    branches_info        = other.branches_info;
+    subpackages_info     = other.subpackages_info;
+    subprojects_info     = other.subprojects_info;
+
+    return (*this);
+  }
+
+  /**
+     Filter out the space-separated words of a text that don't match a regexp.
+   */
+  void filter_list (cmt_string& text, const cmt_regexp& exp)
+  {
+    CmtSystem::cmt_string_vector list;
+
+    CmtSystem::split (text, " ", list);
+
+    int i;
+
+    text = "";
+
+    for (i = 0; i < list.size (); i++)
+      {
+	const cmt_string& s = list[i];
+	if (exp.match (s))
+	  {
+	    if (i > 0) text += " ";
+	    text += s;
+	  }
+      }
+  }
+
+  int execute (const cmt_string& command)
+  {
+    int status = 0;
+
+    if (m_verbose || m_simulation)
+      {
+	cout << "#CMT> Executing [" << command << "]" << endl;
+      }
+    
+    if (!m_simulation)
+      {
+	status = CmtSystem::execute (command);
+      }
+
+    return (status);
+  }
+
+  void execute_and_retry (const cmt_string& command, const cmt_string& message)
+  {
+    int status;
+    int retry = 0;
+
+    for (;;)
+      {
+	status = execute (command);
+        
+	if (status != 0)
+	  {
+	    retry++;
+	    
+	    cout << "# " << message << ": status=" << status << endl;
+	    cout << "#---------------------------------------------------------" << endl;
+	    
+	    if (retry > 5) exit(0);
+	  }
+	else
+	  {
+	    break;
+	  }
+      }
+  }
+
+  int execute (const cmt_string& command, cmt_string& out)
+  {
+    int status = 0;
+
+    if (m_verbose || m_simulation)
+      {
+	cout << "#CMT> Executing [" << command << "]" << endl;
+      }
+    
+    if (!m_simulation)
+      {
+	status = CmtSystem::execute (command, out);
+	
+      }
+      
+    //if (m_verbose || m_simulation)
+    //  {
+    //       cout << out << endl;
+    //  }
+    return (status);
+  }
+
+
+  /**
+     This function will check the protocol level with the CVS pluggin.
+     The expected level is defined in a macro (in the requirements file of CMT)
+     The protocol level characterizes the structure of the message received from the CVS pluggin
+     and depends on its version.
+
+     In order to know if the pluggin is installed AND if the support for this version is
+     installed, we checkout CVSROOT/loginfo which should contain entries with selection patterns
+
+     .cmtcvsinfos/<protocol_level>
+
+     However old versions only offer as pattern:
+
+     .cmtcvsinfos
+
+     In this function we'll detect if the effective protocol level satisifies the 
+     level expected for this release of CMT
+
+     In simulation mode we suppose the expected protocol has been found.
+   */
+  bool check_protocol ()
+  {
+    static bool done = false;
+    static bool found = true;
+
+    if (done) return (found);
+    done = true;
+
+    cmt_string cvsroot;
+	
+    CmtSystem::get_cvsroot (cvsroot);
+	
+    cmt_string command;
+	
+    command = "cvs";
+    if (cvsroot != "") 
+      {
+	command += " -d ";
+	command += cvsroot;
+      }
+    command += " -Q co -p CVSROOT/loginfo ";
+
+    found = false;
+
+    cmt_string pattern = ".cmtcvsinfos";
+
+    if (m_protocol_level != "")
+      {
+	pattern += "/";
+    	pattern += m_protocol_level;
+      }
+
+    cmt_string loginfo;
+
+    if (m_simulation)
+      {
+	loginfo = pattern;
+      }
+
+    execute (command, loginfo);
+
+    int pos = loginfo.find (pattern);
+
+    if (pos != cmt_string::npos)
+      {
+	found = true;
+      }
+
+    if (m_verbose)
+      {
+	if (found)
+	  {
+	    cout << "#CMT> Protocol level " << m_protocol_level << endl;
+	  }
+	else
+	  {
+	    cout << "#CMT> The CVS pluggin is not installed or is not at protocol level " << m_protocol_level << endl;
+	  }
+      }
+    
+    return (found);
+  }
+
+  /**
+     Execute the CVS command that activates the CVS pluggin, ie this is a cvs import 
+     using the conventional module .cmtcvsinfos/<protocol-level>/<module>
+
+     We create a temporary directory just to lauch the command. However nothing
+     should change in this temporary directory since the pluggin returns an error status.
+   */
+  void retreive_cvs_infos (const cmt_string& module)
+  {
+    static const cmt_string cmtcvsinfos = ".cmtcvsinfos";
+
+    cmt_string home_dir = CmtSystem::pwd ();
+	
+    //
+    // Activities related with .cmtcvsinfos will occur in a temporary directory
+    //
+    cmt_string tmp_dir = CmtSystem::getenv ("TMPDIR");
+    if (tmp_dir == "")
+      {
+	tmp_dir = CmtSystem::file_separator ();
+	tmp_dir += "tmp";
+      }
+    
+    if (!CmtSystem::cd (tmp_dir))
+      {
+	tmp_dir = home_dir;
+      }
+    
+    tmp_dir += CmtSystem::file_separator ();
+    tmp_dir += "cmtcvs";
+    {
+      cmt_string temp = CmtSystem::get_temporary_name ();
+      CmtSystem::basename (temp, temp);
+      // Suppress dots for Windows
+      temp.replace_all (".", "");
+      tmp_dir += temp;
+    }
+    
+    if (!CmtSystem::test_directory (tmp_dir))
+      {
+	if (!CmtSystem::mkdir (tmp_dir))
+	  {
+	    cout << "#CMT> Cannot create the temporary directory [" << tmp_dir << "]" << endl;
+	    return;
+	  }
+      }
+    
+    //trap "rm -rf ${tmp_dir}" 0 1 2 15
+    
+    if (!CmtSystem::cd (tmp_dir))
+      {
+	cout << "#CMT> Cannot move to the temporary directory " << tmp_dir << endl;
+	
+	if (m_verbose)
+	  {
+	    cout << "#CMT> now removing tmp_dir " << tmp_dir << " home=" << home_dir << endl;
+	  }
+	
+	CmtSystem::remove_directory (tmp_dir);
+	
+	return;
+      }
+    
+    if (m_verbose)
+      {
+	cout << "#CMT> cvs infos are now obtained from the temporary directory " << CmtSystem::pwd () << endl;  
+      }
+    
+    /**
+       The script associated to such entries is supposed to :
+        1) extract the set of <infos> from ${module}/cmt/requirements
+                                        or ${module}/cmt/project.cmt
+        2) build an output of the form :
+            <infos>=info1 info2 info3 ...
+      
+       Currently this script can be found in
+      
+       ${CMTROOT}/cmt/cmt_buildcvsinfos2.sh
+       %CMTROOT%/cmt/cmt_buildcvsinfos.py
+       There is a C++ implementation as cmtcvs.exe
+      
+    */
+    
+    if (!CmtSystem::test_directory (cmtcvsinfos))
+      {
+	CmtSystem::mkdir (cmtcvsinfos);
+      }
+    
+    CmtSystem::cd (cmtcvsinfos);
+    
+    cmt_string cvsroot;
+    
+    CmtSystem::get_cvsroot (cvsroot);
+    
+    cmt_string command;
+    
+    command = "cvs";
+    if (cvsroot != "") 
+      {
+	command += " -d ";
+	command += cvsroot;
+      }
+    command += " -Q import -m cmt ";
+    
+    command += cmtcvsinfos;
+    
+    if (m_protocol_level != "")
+      {
+	command += "/";
+	command += m_protocol_level;
+      }
+    command += "/";
+    command += module;
+    command += " CMT v1";
+    
+    m_last_cvs_infos = "";
+
+    execute (command, m_last_cvs_infos);
+    
+    if (m_verbose)
+      {
+	cout << "#CMT> now removing tmp_dir " << tmp_dir << " home=" << home_dir << endl;
+      }
+    
+    CmtSystem::cd (home_dir);
+    CmtSystem::remove_directory (tmp_dir);	
+  }
+
+  /**
+     This method exploits the hook installed into the loginfo script.
+     A communication is setup with a dummy CVS module named .cmtcvsinfos/<module>
+    
+     At import time, the contents of the file will be used to parameterize
+     the script named cmt_buildcvsinfos2.sh (referenced in the loginfo script)
+    
+      This script performs a scan in the CVS repository for the following types of
+     information :
+    
+       the recognized structure below this module (none, project, package)
+       all top symbolic tags installed for the module
+       all symbolic tags installed for the module
+       all branches available below this module
+       all subpackages installed below the module.
+       all subprojects installed below the module.
+    
+        In principle, only modules corresponding to true CMT products (packages or projects) are considered.
+          o tags are obtained from the requirements or the project file
+          o branches are sub-directories which are not themselves packages
+          o subpackages are sub-directories which are CMT packages
+            (a subdirectory is always either a branch or a subpackage)
+  */
+  void get_cvs_infos_with_offset (const cmt_string& module)
+  {
+    if (!check_protocol ())
+      {
+	cout << "#CMT> The CVS pluggin is not installed or is not at protocol level " << m_protocol_level << endl;
+	return;
+      }
+
+    if (module == "")
+      {
+	cout << "#CMT> cmt cvs needs a module name" << endl;
+	return;
+      }
+
+    if (module == m_last_module)
+      {
+	if (m_verbose)
+	  {
+	    cout << "#CMT> cvs infos for module " << module << " already there" << endl;
+	  }
+      }
+    else
+      {
+	m_last_module = module;
+        
+	retreive_cvs_infos (module);
+      }
+    
+    /**
+       Now retrieve all info fields :
+    */
+
+    Grep grep;
+
+    grep.run (m_last_cvs_infos, "structure=");
+    
+    if (grep.result () != "")
+      {
+	structure_info = grep.result ();
+	structure_info.replace ("structure=", "");
+      }
+    else
+      {
+	// This may happen for old protocol level < v1r1
+	structure_info = "package";
+      }
+    
+    grep.run (m_last_cvs_infos, "error=");
+    
+    if (grep.result () != "")
+      {
+	error_info = grep.result ();
+	error_info.replace ("error=", "");
+      }
+    else
+      {
+	error_info = "";
+      }
+    
+    grep.run (m_last_cvs_infos, "tags_top=");
+    
+    if (grep.result () != "")
+      {
+	tags_top_info = grep.result ();
+	tags_top_info.replace ("tags_top=", "");
+      }
+    else
+      {
+	tags_top_info = "";
+      }
+    
+    grep.run (m_last_cvs_infos, "tags=");
+    
+    if (grep.result () != "")
+      {
+	tags_info = grep.result ();
+	tags_info.replace ("tags=", "");
+      }
+    else
+      {
+	tags_info = "";
+      }
+    
+    grep.run (m_last_cvs_infos, "cvsversions_top=");
+    
+    if (grep.result () != "")
+      {
+	cvsversions_top_info = grep.result ();
+	cvsversions_top_info.replace ("cvsversions_top=", "");
+      }
+    else
+      {
+	cvsversions_top_info = "";
+      }
+    
+    grep.run (m_last_cvs_infos, "cvsversions=");
+    
+    if (grep.result () != "")
+      {
+	cvsversions_info = grep.result ();
+	cvsversions_info.replace ("cvsversions=", "");
+      }
+    else
+      {
+	cvsversions_info = "";
+      }
+    
+    grep.run (m_last_cvs_infos, "branches=");
+    
+    if (grep.result () != "")
+      {
+	branches_info = grep.result ();
+	branches_info.replace ("branches=", "");
+      }
+    else
+      {
+	branches_info = "";
+      }
+    
+    grep.run (m_last_cvs_infos, "subpackages=");
+    
+    if (grep.result () != "")
+      {
+	subpackages_info = grep.result ();
+	subpackages_info.replace ("subpackages=", "");
+      }
+    else
+      {
+	subpackages_info = "";
+      }
+    
+    grep.run (m_last_cvs_infos, "subprojects=");
+
+    if (grep.result () != "")
+      {
+	subprojects_info = grep.result ();
+	subprojects_info.replace ("subprojects=", "");
+      }
+    else
+      {
+	subprojects_info = "";
+      }
+
+    /**
+       The CMTCVSTAGFILTER env. var. may contain a regexp that will exclude some tags
+       from the answr of the CVS pluggin.
+       The pattern is a regexp but it may also contain the <package> template
+     */
+    cmt_string tag_filter = CmtSystem::getenv ("CMTCVSTAGFILTER");
+    
+    if (tag_filter != "")
+      {
+	cmt_string package;
+	CmtSystem::basename (module, package);
+	
+	cmt_string pattern = "<package>";
+	
+	tag_filter.replace_all (pattern, package);
+	
+	cmt_regexp exp (tag_filter);
+	
+	cmt_string text;
+	
+	filter_list (tags_top_info, exp);
+	filter_list (tags_info, exp);
+	filter_list (cvsversions_top_info, exp);
+	filter_list (cvsversions_info, exp);
+      }
+  }
+  
+  void get_cvs_infos (const cmt_string& cvs_offset, const cmt_string& module)
+  {
+    cmt_string full_name;
+
+    if (cvs_offset != "") 
+      {
+	full_name = cvs_offset;
+	full_name += "/";
+	while (full_name.find ("//") != cmt_string::npos)
+	  {
+	    full_name.replace_all ("//", "/");
+	  }
+      }
+
+    full_name += module;
+
+    get_cvs_infos_with_offset (full_name);
+  }
+
+  /**
+     From a space-separated list of version tags, try to find one tag
+     matching a given regular expression.
+
+       o The first matching tag is returned into 'version'
+       o Success is returned as function value.
+
+   */
+  bool match_version_request (const cmt_string& text, 
+                              const cmt_regexp& version_exp,
+                              cmt_string& version)
+  {
+    CmtSystem::cmt_string_vector vs;
+      
+    CmtSystem::split (text, " \t", vs);
+
+    version = "";
+
+    for (int i = 0; i < vs.size (); i++)
+      {
+	const cmt_string& vv = "^"+ vs[i] + "$";
+        
+	if (version_exp.match (vv))
+	  {
+	    version = vv;
+	    return (true);
+	  }
+      }
+
+    return (false);
+  }
+
+  void get_module (const cmt_string& offset,
+		   const cmt_string& product,
+		   cmt_string& module)
+  {
+    module = "";
+
+    if (offset != "")
+      {
+	module = offset;
+	module += "/"; // This is for CVS only thus we don't use the real separator.
+	while (module.find ("//") != cmt_string::npos)
+	  {
+	    module.replace_all ("//", "/");
+	  }
+      }
+
+    module += product;
+  }
+
+  bool get_version (const cmt_string& offset,
+                    const cmt_string& product,
+                    const cmt_string& version_request,
+                    const cmt_string& module,
+                    cmt_string& version,
+                    bool& at_head)
+  {
+    Grep grep;
+    cmt_string topversions;
+    cmt_string versions;
+    cmt_string requested_version = version_request;
+    
+    at_head = false;
+            
+    /**
+     *   Try to figure out what is the effective version tag available
+     *   for the requested version expressions (which may contain
+     *   wild card)
+     *
+     *     the requested version may either be in the top tags (ie those
+     *     corresponding to the same most recent CVS version number before
+     *     the HEAD) or not. The returned at_head flag will show this.
+     *
+     *     then the requested product may either be located in the CVS repository
+     *     under the offset or not, the returned module will contain the effective
+     *     location where the requested version has been found.
+     */
+    
+    if (m_verbose)
+      {
+	     cout << "#CMT> requesting cvs infos onto module " << module << endl;
+      }
+    
+    get_cvs_infos_with_offset (module);
+    
+    if (error_info != "")
+      {
+	versions = "";
+	cout << "#CMT> Product " << product << " not found in ${CVSROOT}" << endl;
+	return (false);
+      }
+
+    versions = tags_top_info;
+
+    cmt_string v = version_request;
+    
+    if (version_request.find ("*") != cmt_string::npos)
+      {
+	v.replace_all ("*", ".*");
+      }
+    else
+      {
+	// this is an exact match to the end of the word since there is no wild card
+	v += "$";
+      }
+    
+    cmt_regexp version_exp (v);
+    
+    if (!match_version_request (versions, version_exp, version))
+      {
+	// We try on non-top versions
+
+	versions = tags_info;
+
+	if (!match_version_request (versions, version_exp, version))
+	  {
+	    version = requested_version;
+	    int pos = 0;
+	    if ((pos = version.find ("*")) != cmt_string::npos)
+	      {
+		//
+		//  There was a wild card but the expression does not match
+		// any of the existing tags in CVS.
+		//  Things will be retreived from HEAD but we have to build
+		// a reasonable version tag from the wild card expression.
+		//  If the letter before the * was a digit, then simply remove
+		// the * (v5* -> v5) otherwise add a zero (v5r* -> v5r0)
+		//
+		if (pos > 0)
+		  {
+		    char letter = version[pos-1];
+		    
+		    static const cmt_string digits = "0123456789";
+		    
+		    if (digits.find (letter) == cmt_string::npos)
+		      {
+			// "v5r*" -> "v5r0"
+			version.replace ("*", "0");
+		      }
+		    else
+		      {
+			// "v5*" -> "v5"
+			version.replace ("*", "");
+		      }
+		  }
+		else
+		  {
+		    // The expression was simply "*" !!!
+		    version = "v0";
+		  }
+	      }
+	    at_head = true;
+	  }
+	else
+	  {
+	    at_head = false;
+	  }
+      }
+    else
+      {
+	at_head = true;
+      }
+    
+    /**
+     *   Here we have at least one version matching the requested expression.
+     */
+    
+    return (true);
+  }
+
+  bool do_need_version ()
+  {
+     bool need_version = false;
+
+    if (structure_info == "project")
+    {
+  	     need_version = true;
+  	     //CmtStructuringStyle style = Cmt::get_current_structuring_style ();
+         //if (style == default_structuring_style)
+	     //{
+	     //   Use& current_use = Use::current ();
+	     //   if (current_use.get_strategy ("VersionDirectory"))
+	     //      need_version = true;
+	     //}
+	     //else if (style == with_version_directory)
+	     //    need_version = true;	  	       
+  	     // cout<<"need version"<<need_version<<endl;
+  	}
+    else
+      {
+	     CmtStructuringStyle style = Cmt::get_current_structuring_style ();
+         if (style == default_structuring_style)
+	     {
+	        Use& current_use = Use::current ();
+	        if (current_use.get_strategy ("VersionDirectory"))
+	           need_version = true;
+	     }
+	     else if (style == with_version_directory)
+	         need_version = true;	        
+      }
+
+    return (need_version);
+  }
+
+  /**
+     Take care of structuring style for packages and of project vs package conventions
+   */
+  cmt_string build_version_directory (const cmt_string& offset,
+                                      const cmt_string& product,
+                                      const cmt_string& version)
+  {
+    cmt_string dir = m_home_dir;
+    
+    if (m_checkout_dir != "")
+      {
+	// consider the usual -d option 
+ 
+	dir += CmtSystem::file_separator ();
+	dir += m_checkout_dir;
+      }
+    
+    dir += CmtSystem::file_separator ();
+    dir += offset;
+    dir += CmtSystem::file_separator ();
+    dir += product;
+
+    if (do_need_version ())
+      {
+	dir += CmtSystem::file_separator ();
+	dir += version;
+      }
+    
+    CmtSystem::reduce_file_separators (dir);
+    
+    return (dir);
+  }
+
+  /**
+     Wrapper to mkdir handling simulation and verbose options.
+   */
+  bool mkdir (const cmt_string& dir)
+  {
+    if (m_simulation)
+      {
+	cout << "#CMT> Would create the " << dir << " directory" << endl;
+      }
+    else
+      {
+	if (!CmtSystem::cd (dir))
+	  {
+	    if (m_verbose)
+	      {
+		cout << "#CMT> About to mkdir " << dir << endl;
+	      }
+
+	    CmtSystem::mkdir (dir);
+	    if (!CmtSystem::cd (dir))
+	      {
+		cout << "# Error creating the directory :" << dir << endl;
+		cout << "#---------------------------------------------------------" << endl;
+		return (false);
+	      }
+	  }
+      }
+    return (true);
+  }
+
+  /**
+     When running cmt cvs commands, we stand by definition outside of any existing 
+     package context. Thus it's likely that CMTPATH are not completely defined.
+     This function manually prepends CMTPATH entries to the environment variable.
+   */
+  void add_cmtpath (const cmt_string& dir)
+  {
+    static cmt_string CMTPATH;
+
+    cmt_string cmtpath = Symbol::get_env_value ("CMTPATH");
+
+    if (cmtpath.find (dir) == cmt_string::npos)
+      {
+	CMTPATH = dir;
+	CMTPATH += ":";
+	CMTPATH += cmtpath;
+
+	CmtSystem::putenv ("CMTPATH", CMTPATH);
+      }
+
+    if (m_verbose)
+      {
+	cout << "#CMT> CMTPATH=" << CmtSystem::getenv ("CMTPATH") << endl;
+      }
+  }
+
+  /**
+     Specific checkout of one project
+   */
+  bool really_checkout_project_contents (const cmt_string& offset,
+					 const cmt_string& project,
+					 const cmt_string& version,
+					 const cmt_string& tag,
+					 const cmt_string& module,
+					 const cmt_string& basedir,
+					 bool at_head,
+					 const cmt_string& currentdir)
+  {
+    cmt_string dir = currentdir;
+
+    cout << "  # get project files into " << dir << endl;
+
+
+    cmt_string version_dir = version;
+    if (!mkdir (version_dir)) return (false);
+
+    dir += CmtSystem::file_separator ();
+    dir += version_dir;
+    
+    cmt_string command = "cvs -f -Q co -P ";
+    if (!at_head)
+      {
+	command += "-r ";
+	command += (tag != "") ? tag : version;
+      }
+
+    command += " -d cmt ";
+
+    command += " ";
+    command += module;
+    command += "/cmt";
+
+    command += CmtSystem::command_separator ();
+
+    command += " cvs -f update -l .";
+
+    execute_and_retry (command, "Error getting project CMT contents");
+
+    return (true);
+  }
+  /**
+     Construct CVS management files in the top directory. This is needed
+     if the top directory of a product is empty. (In this case the
+     co -l results in nothing)
+   */
+  void make_management_files (const cmt_string& module,
+			      const cmt_string& entries_text)
+  {
+    if (!CmtSystem::test_directory ("CVS"))
+      {
+	/**
+	 * The CVS repository had not been created (this is generally
+	 * due to the lack of top files)
+	 */
+
+	if (!mkdir ("CVS")) return;
+
+	CmtSystem::cd ("..");
+
+	cmt_string s;
+	
+	// Let's create first the CVS/Root file.
+	
+	CmtSystem::get_cvsroot (s);
+	s += "\n";
+	
+	cmt_string f;
+	
+	f = "CVS";
+	f += CmtSystem::file_separator ();
+	f += "Root";
+	
+	if (m_simulation)
+	  {
+	    cout << "#CMT> Would fill in the CVS/Root file with " << endl;
+	    cout << s << endl;
+	  }
+	else
+	  {
+	    if (m_verbose)
+	      {
+		cout << "#CMT> Fill in the CVS/Root file with " << endl;
+		cout << s << endl;
+	      }
+	    s.write (f);
+	  }
+	
+	// Now we create the CVS/Repository file
+	
+	f = "CVS";
+	f += CmtSystem::file_separator ();
+	f += "Repository";
+	
+	CmtSystem::get_cvsroot (s);
+	if (s[0] == ':')
+	  {
+	    int pos = s.find (1, ":");
+	    s.erase (0, pos+1);
+	    pos = s.find (0, ":");
+	    s.erase (0, pos+1);
+	  }
+	s += "/";
+	s += module;
+	s += "\n";
+	
+	if (m_simulation)
+	  {
+	    cout << "#CMT> Would fill in the CVS/Repository file with " << endl;
+	    cout << s << endl;
+	  }
+	else
+	  {
+	    if (m_verbose)
+	      {
+		cout << "#CMT> Fill in the CVS/Repository file with " << endl;
+		cout << s << endl;
+	      }
+	    s.write (f);
+	  }
+      }
+    
+    if (m_simulation)
+      {
+	cout << "#CMT> Would write the top CVS/Entries file with " << endl;
+	cout << entries_text << endl;
+      }
+    else
+      {
+	cmt_string entries_file_name;
+
+	entries_file_name = "CVS";
+	entries_file_name += CmtSystem::file_separator ();
+	entries_file_name += "Entries";
+    
+	cmt_string text;
+
+	if (!text.read (entries_file_name))
+	  {
+	    // This happens when there were no top files
+	  }
+
+	text += entries_text;
+
+	// Now the CVS/Entries is ready to be created.
+	if (m_verbose)
+	  {
+	    cout << "#CMT> Fill in the top CVS/Entries file with " << endl;
+	    cout << text << endl;
+	  }
+
+	text.write (entries_file_name);
+      }
+  }
+
+
+  /**
+     Specific checkout of one package
+
+     1) get top files (no directories)
+     2) construct the directory structure (with or without version directory)
+     3) build the CVS/Entries file for subdirs and co individual subdirs
+     4) write the CVS management files if CVS did not do it.
+   */
+  bool really_checkout_package_contents (const cmt_string& offset,
+					 const cmt_string& package,
+					 const cmt_string& version,
+					 const cmt_string& module,
+					 const cmt_string& basedir,
+					 bool at_head,
+					 const cmt_string& currentdir)
+  {
+    cmt_string dir = currentdir;
+
+    cout << "  # get top files " << endl;
+            
+    cmt_string command = "cvs -f -Q co -l ";
+    if (!at_head)
+      {
+	command += "-r ";
+	command += version;
+      }
+
+    bool need_version = do_need_version ();
+
+    if (need_version)
+      {
+	command += " -d ";
+	command += version;
+      }
+    else
+      {
+	command += " -d ";
+	command += package;
+
+	// Must stand just above the package directory
+	CmtSystem::cd ("..");
+	CmtSystem::dirname (dir, dir);
+      }
+    
+    command += " ";
+    command += module;
+    
+    execute_and_retry (command, "Error getting package CMT contents");
+
+    if (need_version)
+      {
+	       if (!mkdir (version)) return (false);	
+	       dir += CmtSystem::file_separator ();
+	       dir += version;
+      }
+    else
+      {
+	if (!mkdir (package)) return (false);
+	
+	dir += CmtSystem::file_separator ();
+	dir += package;
+      }
+    
+    if (m_verbose)
+      {
+	cout << "#CMT> Now getting subdirectories pwd=" << CmtSystem::pwd () << " dir=" << dir << endl;
+      }
+    
+    cmt_string branches = CmtSystem::getenv ("CMTCVSBRANCHES");
+    
+    if (branches == "")
+      {
+	    branches = branches_info;
+      }
+    
+    CmtSystem::cmt_string_vector branch_vector;
+    
+    CmtSystem::split (branches, " \t", branch_vector);
+      
+    cmt_string text = "";
+    
+    command = "";
+
+    if (!CmtSystem::test_directory ("CVS"))
+      {
+          int i;
+          for (i = 0; i < branch_vector.size (); i++)
+            {
+	       cmt_string& branch = branch_vector[i];	
+	       if (i > 0)
+	           {
+	              command += CmtSystem::command_separator ();
+	           }
+	
+	       command += "cvs -f -Q co ";
+	
+	       if (!at_head)
+	          {
+	             command += "-r ";
+	             command += version;
+	          }
+	
+	       command += " -d ";
+	       command += branch;
+	       command += " ";
+	       command += module;
+	       command += "/";    // CVS uses the '/' notation on all platforms!!
+	       command += branch;
+	
+	       text += "D/";
+	       text += branch;
+	       text += "////\n";
+            } 
+        execute_and_retry (command, "Error getting package contents");
+
+        make_management_files (module, text);
+
+        if (need_touch_files)
+        {  
+    
+            cout << "# --> udapte the file timestamps" << endl;                 
+            for (i = 0; i < branch_vector.size (); i++)
+            {	
+	            cmt_string& branch = branch_vector[i];    
+                CmtSystem::cmt_string_vector& list = CmtSystem::scan_dir (branch);
+                int j;
+                for (j = 0; j < list.size (); j++)
+                    if (CmtSystem::test_file(list[j]))                
+                        CmtSystem::touch_file (list[j]);
+            }
+        }        
+        return (true);   
+      }
+ 
+    command += "cvs -Q update -d ";
+
+    if (!at_head)
+      {
+        command += "-r ";
+        command += version;
+      }
+
+    int i;
+    
+    for (i = 0; i < branch_vector.size (); i++)
+      {
+	    cmt_string& branch = branch_vector[i];
+            if (branch != "CVS")
+            {   
+                command += " ";
+	        command += branch;
+             }
+      }
+
+    command += CmtSystem::command_separator ();
+
+    command += "cvs update -l .";
+    
+    execute_and_retry (command, "Error getting package contents");
+
+    if (need_touch_files)
+    {  
+    
+        cout << "# --> udapte the file timestamps" << endl;                 
+        for (i = 0; i < branch_vector.size (); i++)
+        {	
+	        cmt_string& branch = branch_vector[i];    
+            CmtSystem::cmt_string_vector& list = CmtSystem::scan_dir (branch);
+            int j;
+            for (j = 0; j < list.size (); j++)
+                if (CmtSystem::test_file(list[j]))                
+                    CmtSystem::touch_file (list[j]);
+        }
+    }        
+    return (true);
+  }
+
+  /**
+     Effective checkout of a package or a project
+   */
+  bool really_checkout (const cmt_string& offset,
+			const cmt_string& product,
+			const cmt_string& version,
+			const cmt_string& tag,
+			const cmt_string& module,
+			const cmt_string& basedir,
+			bool at_head)
+  {
+    cmt_string dir = basedir;
+    cmt_string out;
+    
+    cout << "# ================= working on " << structure_info << " " << product 
+	 << " version " << version;
+
+    if (at_head) cout << " (At head) ";
+
+    cmt_string full_offset;
+
+    full_offset = m_cvs_offset;
+    full_offset += offset;
+
+    cmt_string echo_ppath;
+        
+    if (offset != "")
+      {
+	echo_ppath = " path ";
+	echo_ppath += offset;
+      }
+    
+    cout << echo_ppath << " in " << dir << endl;
+
+    if (do_need_version ())
+      {
+	// Move back to the product name.
+	CmtSystem::dirname (dir, dir);
+      }
+
+    if (!mkdir (dir)) return (false);
+	
+    if (structure_info == "package")
+      {
+	really_checkout_package_contents (offset,
+					  product,
+					  version,
+					  module,
+					  basedir,
+					  at_head,
+					  dir);
+      }
+    else if (structure_info == "project")
+      {
+	really_checkout_project_contents (offset,
+					  product,
+					  version,
+					  tag,
+					  module,
+					  basedir,
+					  at_head,
+					  dir);
+      }
+
+    return (true);
+  }
+
+  /**
+     Find the most appropriate effective version directory corresponding to the 
+     specified version expression.
+     The specified expression may contain wildcards (in the file manager sense). This
+     FME is first converted into a RE then a directory search is performed.
+     An empty string is returned if no match is found.
+   */
+  cmt_string find_matching_version (const cmt_string& expression)
+  {
+      
+    cmt_string result;     
+    
+    //
+    // Here expression takes the form
+    //   <some path>/<expression with wild-card>
+    //
+
+    cmt_string dir;
+    CmtSystem::dirname (expression, dir);
+    dir += CmtSystem::file_separator ();
+    
+    cmt_string version;
+    CmtSystem::basename (expression, version);
+
+    if (version.find ("*") == cmt_string::npos)
+      {
+	// there is no wildcarding here. A simple test is enough.
+	if (CmtSystem::test_directory (expression))
+	  {
+	    result = version;
+	  }
+      }
+    else
+      {
+	version.replace ("*", ".*");
+	
+	cmt_regexp exp (version);
+	
+	CmtSystem::cmt_string_vector list;
+	
+	CmtSystem::scan_dir (dir, exp, list);
+	
+	if (list.size () > 0)
+	  {
+	    result = list[0];
+	    
+	    CmtSystem::basename (result, result);
+	  }
+      }
+    
+    return (result);
+  }
+  
+  /**
+   *   We provide a path to a requirements file. From it we read the use 
+   *  statements, and we try to checkout the corresponding packages.
+   *
+   *   A boolean return tells if any recursion occurred.
+   */
+  bool checkout_from_requirements (const cmt_string& requirements_path)
+  {
+    static cmt_regexp expression ("^[ \t]*use[ \t]");
+
+    cmt_string text;
+
+    text.read (requirements_path);
+
+    RecursivePass1 p1;
+    p1.run (text, expression);
+
+    bool result = (p1.result () != "");
+    RecursivePass2 p2 (*this);
+    p2.run (p1.result ());
+
+    return (result);
+  }
+
+  /**
+   *   We provide a path to a project file. From it we read the use 
+   *  statements, and we try to checkout the corresponding projects.
+   */
+  void checkout_from_project_file (const cmt_string& file_name)
+  {
+    static cmt_regexp expression ("^[ \t]*use[ \t]");
+
+    cmt_string text;
+
+    text.read (file_name);
+
+    CvsImplementation& me = *this;
+    CvsImplementation saved;
+    saved = me;
+    cmt_string here = CmtSystem::pwd ();
+
+    RecursivePass3 p3;
+    p3.run (text, expression);
+
+    RecursivePass4 p4 (*this);
+    p4.run (p3.result ());
+
+    Grep grep;
+
+    grep.run (text, "container");
+    cmt_string container = grep.result ();
+
+    if (container != "")
+      {
+	static cmt_regexp container_expression ("^[ \t]*container[ \t]");
+
+	add_cmtpath (here);
+
+	cout << "  # --> now getting project packages from the " << container << " " << here << endl;
+
+	CmtSystem::cd (here);
+
+	RecursivePass1 p1;
+	p1.run (text, container_expression);
+
+	RecursivePass2 p2 (*this);
+
+	m_home_dir = CmtSystem::pwd ();
+	p2.run (p1.result ());
+      }
+
+    CmtSystem::cd (here);
+    me = saved;
+  }
+
+  /**
+     Check whether a given directory structure matches an expected product structure
+     given by the structure info obtained from the most recent request to the CVS pluggin
+   */
+  bool check_structure (const cmt_string& dir, const cmt_string& version)
+  {
+    bool result = false;
+    if (!CmtSystem::test_directory (dir))
+      {
+	       return (false);
+      }
+
+    if (structure_info == "package")
+      {
+	// Check if it is a true CMT package.	
+	cmt_string file_name;
+	
+	file_name = dir;
+	file_name += CmtSystem::file_separator ();
+	file_name += "cmt";
+	file_name += CmtSystem::file_separator ();
+	file_name += "requirements";
+	
+	if (CmtSystem::test_file (file_name))
+	  {	  
+	       if (!do_need_version ())
+	       {
+	           // open the version.cmt file and compare the version
+                 cmt_string current_version;
+                 cmt_string version_file = dir;
+                 version_file += CmtSystem::file_separator ();
+                 version_file += "CVS";
+                 version_file += CmtSystem::file_separator ();
+                 version_file += "Tag"; 
+                 current_version.read (version_file);               
+                 //cout <<version_file<<", "<<current_version<<", "<<"N"+version+"\n"<<endl;
+                 return current_version=="N"+version+"\n";	            
+	        }   
+	       	else
+		       result = true;
+	  }
+	else
+	  {
+
+	    file_name = dir;
+	    file_name += CmtSystem::file_separator ();
+	    file_name += "mgr";
+	    file_name += CmtSystem::file_separator ();
+	    file_name += "requirements";
+	    
+	    if (CmtSystem::test_file (file_name))
+	      {
+	       if (!do_need_version ())
+	       {
+	           // open the version.cmt file and compare the version
+                 cmt_string current_version;
+                 cmt_string version_file = dir;
+                 version_file += CmtSystem::file_separator ();
+                 version_file += "CVS";
+                 version_file += CmtSystem::file_separator ();
+                 version_file += "Tag"; 
+                 current_version.read (version_file);               
+                 //cout <<version_file<<", "<<current_version<<", "<<"N"+version+"\n"<<endl;
+                 return current_version=="N"+version+"\n";	            
+	        }   
+	       	else
+		       result = true;
+	      }
+	  }
+      }
+    else if (structure_info == "project")
+      {
+	cmt_string file_name;
+	
+	file_name = dir;
+	file_name += CmtSystem::file_separator ();
+	file_name += "cmt";
+	file_name += CmtSystem::file_separator ();
+	file_name += "project.cmt";
+	
+	if (CmtSystem::test_file (file_name))
+	  {
+	    result = true;
+	  }
+    }
+
+    return (result);
+  }
+
+  /**
+     Internal call from the initial do_checkout or from recursive passes
+     Prepare the directory structure for the checkout
+     Do the checkout
+     Check if everything was done properly, if a package or a project has been created
+     If needed recurse from the requirements or project file
+
+     For projects there may be two different specifications for
+     - the version directory
+     - the CVS tag
+   */
+  void do_checkout_phase2 (const cmt_string& offset,
+			   const cmt_string& product,
+			   const cmt_string& specified_version,
+			   const cmt_string& tag)
+  {
+    if (m_verbose)
+      {
+	cout << "#CMT> do_checkout_phase2> offset=" << offset
+	     << " " << structure_info << "=" << product
+	     << " specified_version=" << specified_version
+	     << " tag=" << tag
+	     << " pwd=" << CmtSystem::pwd ()
+	     << endl;
+      }
+    
+    cmt_string version = specified_version;
+    cmt_string empty;
+    cmt_string full_offset;
+
+    full_offset = m_cvs_offset;
+    full_offset += offset;
+    
+    cmt_string echo_ppath;
+    
+    if (offset != "")
+      {
+	echo_ppath = " path ";
+	echo_ppath += offset;
+      }
+    
+    if (version == "")
+      {
+	cout << "# ================= No version specified for " << structure_info << " " << product << endl;
+	return;
+      }
+    
+    //
+    //  First make an attempt to locate the specified version of
+    //  this product "as-it-is" in the work area.
+    //   Since 'version' may contain wild-card, it's likely that
+    //  we should not simply use CmtSystem::test_directory but
+    //  use the wild-card search.
+    //
+    
+    cmt_string dir;
+    
+    dir = build_version_directory (offset, product, version);
+    
+    bool recursive = m_recursive;
+    
+    cmt_string effective_version = "";
+    if (do_need_version ())
+    {
+    /* Important this part should be enhanced ASAP 
+       and deal with many other cases.... arghhhh !!
+    */    
+        effective_version = find_matching_version (dir);         
+    }
+
+
+         
+    cmt_string module;
+    get_module (full_offset, product, module);
+
+    cmt_string cvs_tag = (tag != "") ? tag : version;
+    bool at_head = false;
+
+    if (effective_version != "")
+      {
+	version = effective_version;
+      }
+    else
+      {
+	//
+	// get_version attempts to find the most appropriate version
+	// tag matching the specification FROM the repository. However,
+	// we should take into account situations where some versions have
+	// already been checked out, in which case they might be sufficient
+	// (or preferred?)
+	//
+	
+	if (cvs_tag.find ("*") != cmt_string::npos)
+	  {
+	    cout << "# ================= " << structure_info << " " << product 
+		 << " version " << cvs_tag << echo_ppath 
+		 << " has wild cards and will not be considered." << endl;
+	    return;
+	  }
+	
+	if (!get_version (full_offset, product, cvs_tag, module,
+			  cvs_tag, at_head))
+	  {
+	    return;
+	  }
+	
+	if (m_head)
+	  {
+	    m_head = false;
+	    
+	    at_head = true;
+	  }
+	else
+	  {
+	    at_head = false;
+	  }
+	
+	//
+	// Make a second try after having selected a CVS tag from all the
+	// available tags compatible with the specified version
+	//
+
+	if (tag == "")
+	  {
+	    // If tag was not specified, then the version directory has to match the CVS tag
+	    // Otherwise the original version specification is kept for the directory.
+	    version = cvs_tag;
+	    dir = build_version_directory (offset, product, version);
+	  }
+      }
+    
+    if (check_structure (dir, version))
+      {
+	     cout << "# ================= " << structure_info << " " << product 
+	          << " version "            << version        << echo_ppath 
+	          << " already installed."  << endl;	
+	     recursive = false;
+      }
+    else
+      {
+	//
+	// Now we can say that we have to perform the real checkout.
+	// 
+	
+	if (!really_checkout (offset, product, version, cvs_tag, module, dir, at_head))
+	  {
+	    cout << "# bad return from really_checkout_product" << endl;
+	    return;
+	  }
+      }
+
+    //
+    //  Now reach the newly checked out product.
+    //
+    
+    if (m_simulation)
+      {
+	cout << "#CMT> " << structure_info << " directory not really created " << dir << endl;
+      }
+    else if (structure_info == "package")
+      {
+	if (!CmtSystem::cd (dir))
+	  {
+	    cout << "#CMT> Package directory not created " << dir << endl;
+	    return;
+	  }
+	
+	// Check if it is a true CMT package.
+	
+	cmt_string file_name;
+	
+	file_name = "cmt";
+	file_name += CmtSystem::file_separator ();
+	file_name += "requirements";
+	
+	if (CmtSystem::test_file (file_name))
+	  {
+	    dir += CmtSystem::file_separator ();
+	    dir += "cmt";
+	    CmtSystem::cd ("cmt");
+	    
+	    if (!do_need_version ())
+	      {
+		cmt_string text = version;
+		text += "\n";
+		text.write ("version.cmt");
+	      }
+	  }
+	else
+	  {
+	    file_name = "mgr";
+	    file_name += CmtSystem::file_separator ();
+	    file_name += "requirements";
+	    
+	    if (CmtSystem::test_file (file_name))
+	      {
+		dir += CmtSystem::file_separator ();
+		dir += "mgr";
+		CmtSystem::cd ("mgr");
+	      }
+	    else
+	      {
+		cout << "# " << product << " not a CMT package" << endl;
+		return;
+	      }
+	  }
+	
+	if (recursive)
+	  {
+	    cmt_string here = CmtSystem::pwd ();
+
+	    bool did_recurse = checkout_from_requirements ("requirements");
+
+	    CmtSystem::cd (here);
+
+	    if (did_recurse) 
+	      {
+	          if (no_config==false)	          
+		        execute ("cmt -quiet broadcast cmt -quiet config");
+	      
+	      }
+	    else
+	      {
+	          if (no_config==false)
+		        execute ("cmt -quiet config");
+	      }
+	  }
+	else
+	  {
+	    if (no_config==false)
+    	    execute ("cmt -quiet config");
+	  }
+      }
+    else if (structure_info == "project")
+      {
+	
+	if (m_verbose)
+	  {
+	    cout << "#CMT> dir=" << dir << endl;
+	  }
+	
+	if (!CmtSystem::cd (dir))
+	  {
+	    cout << "#CMT> Project directory not created " << dir << endl;
+	    return;
+	  }
+	
+	cmt_string file_name;
+	
+	file_name = "cmt";
+	file_name += CmtSystem::file_separator ();
+	file_name += "project.cmt";
+	
+	if (!CmtSystem::test_file (file_name))
+	  {
+	    cout << "# " << product << " not a CMT project" << endl;
+	    return;
+	  }
+	
+	if (recursive)
+	  {
+	    checkout_from_project_file (file_name);
+	  }
+
+	cout << "# ================= Project " << product << " completed" << endl;
+
+      }
+  }
+  
+  /**
+     Top level of the checkout operation, initiated from the command line arguments
+
+     Construct an history of the checkouts to avoid duplicating the
+     checkouts during the recursivity
+
+     Eventually 
+     o perform the cmt config for packages.
+
+   */
+  void do_checkout_phase1 (const cmt_string& module, 
+			   const cmt_string& version_dir, 
+			   const cmt_string& version_tag)
+  {
+    add_cmtpath (m_home_dir);
+
+    History& h = History::instance ();
+
+    h.clear ();
+
+    if (module == "")
+      {
+	if (m_verbose)
+	  {
+	    cout << "#CMT> Missing module name" << endl;
+	  }
+	return;
+      }
+
+    cmt_string offset;
+    cmt_string product;
+    cmt_string version;
+    cmt_string tag;
+    
+    {
+      cmt_string m;
+      m = m_cvs_offset;
+      m += module;
+        
+      get_cvs_infos_with_offset (m);
+        
+      if (error_info != "")
+	{
+	  cout << error_info << endl;
+	  return;
+	}
+    }
+
+    if (version_tag == "")
+      {
+        Cut cut (0);
+        
+        if (tags_top_info != "") tag = tags_top_info;
+        else tag = tags_info;
+        
+        cut.run (tag);
+        
+        tag = cut.result ();
+      }
+    else
+      {
+	tag = version_tag;
+      }
+
+    version = (version_dir == "") ? tag : version_dir;
+
+    CmtSystem::dirname (module, offset);
+    CmtSystem::basename (module, product);
+    
+    cmt_string top_dir;
+        
+    top_dir = m_home_dir;
+    top_dir += CmtSystem::file_separator ();
+    top_dir += m_checkout_dir;
+    top_dir += CmtSystem::file_separator ();
+    top_dir += offset;
+    top_dir += CmtSystem::file_separator ();
+    top_dir += product;
+    top_dir += CmtSystem::file_separator ();
+    top_dir += version;
+
+    CmtSystem::reduce_file_separators (top_dir);
+
+    if (m_verbose)
+      {
+	cout << "#CMT> about to checkout " << structure_info
+	     << " " << product << " version " << version << " into " << top_dir << endl;
+      }
+
+    static const cmt_string empty;
+    do_checkout_phase2 (offset, product, version, tag);
+
+    if (m_simulation) return;
+
+    if (!CmtSystem::cd (top_dir)) return;
+
+    if (structure_info == "project")
+      {
+	cmt_string file_name;
+    
+	file_name = "cmt";
+	file_name += CmtSystem::file_separator ();
+	file_name += "project.cmt";
+	
+	if (!CmtSystem::test_file (file_name))
+	  {
+	    cout << "# " << product << " was not properly checked out and is missing its cmt/project.cmt file" << endl;
+	    return;
+	  }
+      }
+    else
+      {
+	cmt_string file_name;
+    
+	file_name = "cmt";
+	file_name += CmtSystem::file_separator ();
+	file_name += "requirements";
+	
+	if (CmtSystem::test_file (file_name))
+	  {
+	    top_dir += CmtSystem::file_separator ();
+	    top_dir += "cmt";
+	    CmtSystem::cd ("cmt");
+	  }
+	else
+	  {
+	    file_name = "mgr";
+	    file_name += CmtSystem::file_separator ();
+	    file_name += "requirements";
+	    
+	    if (CmtSystem::test_file (file_name))
+	      {
+		top_dir += CmtSystem::file_separator ();
+		top_dir += "mgr";
+		CmtSystem::cd ("mgr");
+	      }
+	    else
+	      {
+		cout << "# " << product << " was not properly checked out and is missing its cmt/requirements file" << endl;
+		return;
+	      }
+	  }
+	
+	if (m_verbose)
+	  {
+	    cout << "#CMT> product " << product << " has been checked out" << endl;
+	  }
+	
+	if (!m_recursive)
+	  {
+	      if (no_config==false)
+	        execute ("cmt -quiet config");
+	  }
+      }
+  }
+
+  void help ()
+  {
+    cout << "> cd <some work area>" << endl;
+    cout << "> cmt checkout [modifier ...] <package|project>" << endl;
+    cout << "" << endl;
+    cout << "   modifier :" << endl;
+    cout << "   -l        Do not process used packages (default)." << endl;
+    cout << "   -R        Process used products recursively." << endl;
+    cout << "   -r rev    Check out version tag. (is sticky)" << endl;
+    cout << "   -vd dir   Use this version directory instead of CVS tag." << endl;
+    cout << "   -d dir    Check out into dir instead of module name." << endl;
+    cout << "   -o offset Offset in the CVS repository" << endl;
+    cout << "   -requirements <requirements file path>  Check out packages referenced in this requirements file" << endl;
+    cout << "   -t  Change file timestamps to the date of checkout" << endl;
+    cout << "   -n        simulation mode on" << endl;
+    cout << "   -no_config  Disable config step after checkout" << endl;    
+    cout << "   -v        verbose mode on" << endl;
+    cout << "   --help    print this help" << endl;
+    cout << "" << endl;
+    cout << "> cmt cvstags <package|project>" << endl;
+    cout << "> cmt cvssubpackages <directory>" << endl;
+    cout << "> cmt cvssubprojects <directory>" << endl;
+    cout << "" << endl;
+  }
+
+  /**
+     Implementation of the cmt cvstags
+     Get the CVS tags of a module
+   */
+  void tags (const CmtSystem::cmt_string_vector& arguments)
+  {
+    if (arguments.size () < 1)
+      {
+	help ();
+	return;
+      }
+    
+    if (CmtSystem::getenv ("CVSROOT") == "")
+      {
+	cout << "# Please set CVSROOT first !" << endl;
+	return;
+      }
+    
+    m_cvs_offset = CmtSystem::getenv ("CMTCVSOFFSET");
+    if (m_cvs_offset != "") 
+      {
+	m_cvs_offset += "/";
+	m_cvs_offset.replace_all ("//", "/");
+      }
+    
+    bool all = false;
+    
+    for (int arg = 0; arg < arguments.size (); arg++)
+      {
+	const cmt_string& option = arguments[arg];
+	
+	if (option == "-all")
+	  {
+	    all = true;
+	  }
+	else
+	  {
+	    get_cvs_infos (CmtSystem::getenv ("CMTCVSOFFSET"), option);
+	    
+	    if (error_info != "")
+	      {
+		cout << error_info << endl;
+	      }
+	    else
+	      {
+		cmt_string tags;
+		
+		if (all)
+		  {
+		    tags = cvsversions_top_info;
+		    tags += " ";
+		    tags += cvsversions_info;
+		  }
+		else
+		  {
+		    tags = tags_top_info;
+		    tags += " ";
+		    tags += tags_info;
+		  }
+		
+		CmtSystem::cmt_string_vector v;
+		
+		CmtSystem::split (tags, " \t", v);
+		for (int i = 0; i < v.size (); i++)
+		  {
+		    const cmt_string& s = v[i];
+		    cout << s << endl;
+		  }
+	      }
+	  }
+      }
+  }
+
+  /**
+     Implementation of the cmt cvsbranches
+     Get the subdirs of a module that are not subackages
+   */
+  void branches (const cmt_string& module)
+  {
+    cmt_string out;
+    
+    get_cvs_infos (CmtSystem::getenv ("CMTCVSOFFSET"), module);
+    
+    if (error_info != "")
+      {
+	cout << error_info << endl;
+      }
+    else
+      {
+	cout << branches_info << endl;
+      }
+  }
+
+  /**
+     Implementation of the cmt cvssubpackages
+     Get the subdirs of a module that ARE CMT subpackages
+   */
+  void subpackages (const cmt_string& module)
+  {
+    cmt_string out;
+    
+    get_cvs_infos (CmtSystem::getenv ("CMTCVSOFFSET"), (module == "") ? "." : module);
+    
+    if (error_info != "")
+      {
+	cout << error_info << endl;
+      }
+    else
+      {
+	cout << subpackages_info << endl;
+      }
+  }
+  
+  /**
+     Implementation of the cmt cvssubrojects
+     Get the subdirs of a module that ARE CMT projects
+   */
+  void subprojects (const cmt_string& module)
+  {
+    cmt_string out;
+    
+    get_cvs_infos (CmtSystem::getenv ("CMTCVSOFFSET"), (module == "") ? "." : module);
+    
+    if (error_info != "")
+      {
+	cout << error_info << endl;
+      }
+    else
+      {
+	cout << subprojects_info << endl;
+      }
+  }
+
+  /**
+     Implementation of the cmt checkout
+     Parse the arguments
+     Then call do_checkout for each argument
+   */
+  void checkout (const CmtSystem::cmt_string_vector& arguments)
+  {
+    if (arguments.size () < 1)
+      {
+	help ();
+	return;
+      }
+    
+    if (CmtSystem::getenv ("CVSROOT") == "")
+      {
+	cout << "# Please set CVSROOT first !" << endl;
+	return;
+      }
+    
+    m_home_dir = CmtSystem::pwd ();
+    m_checkout_dir = "";
+    m_version_dir = "";
+    m_cvs_offset = "";
+
+    cmt_string module;
+    
+    m_recursive      = false;
+    need_touch_files = false;
+    no_config        = false;
+    
+    bool need_version_tag = false;
+    cmt_string version_tag;
+    
+    
+    bool need_checkout_dir = false;
+    bool need_cvs_offset = false;
+    bool need_requirements_file = false;
+    bool need_version_dir = false;
+    
+    m_simulation = false;
+    //m_verbose = true;
+    m_verbose = false;
+    
+    m_head = true;
+    
+    m_cvs_offset = CmtSystem::getenv ("CMTCVSOFFSET");
+    if (m_cvs_offset != "") 
+      {
+	m_cvs_offset += "/";
+	m_cvs_offset.replace_all ("//", "/");
+      }
+    
+    for (int arg = 0; arg < arguments.size (); arg++)
+      {
+	const cmt_string& option = arguments[arg];
+	
+	if (need_version_tag)
+	  {
+	    need_version_tag = false;
+	    
+	    if (option == "HEAD")
+	      {
+		m_head = true;
+	      }
+	    else
+	      {
+		version_tag = option;
+	      }
+	  }
+	else if (need_checkout_dir)
+	  {
+	    need_checkout_dir = false;
+	    m_checkout_dir = option;
+	  }
+	else if (need_version_dir)
+	  {
+	    need_version_dir = false;
+	    m_version_dir = option;
+	  }
+	else if (need_cvs_offset)
+	  {
+	    need_cvs_offset = false;
+	    m_cvs_offset = option;
+	    m_cvs_offset += '/';
+	    m_cvs_offset.replace_all ("//", "/");
+	  }
+	else if (need_requirements_file)
+	  {
+	    need_requirements_file = false;
+	    m_head = false;
+	    checkout_from_requirements (option);
+	  }
+	else
+	  {
+	    if (option == "-R")
+	      {
+		m_recursive = true;
+	      }
+	    else if (option == "-t")
+	    {   
+	       need_touch_files = true;
+	    }  
+	    else if (option == "-l")
+	      {
+		m_recursive = false;
+	      }
+	    else if (option == "-r")
+	      {
+		need_version_tag = true;
+		m_head = false;
+	      }
+	    else if (option == "-d")
+	      {
+		need_checkout_dir = true;
+	      }
+	    else if (option == "-o")
+	      {
+		need_cvs_offset = true;
+	      }
+	    else if (option == "-n")
+	      {
+		m_simulation = true;
+	      }
+	    else if (option == "-no_config")
+	      {
+		    no_config = true;
+	      }	      
+	    else if (option == "-v")
+	      {
+		m_verbose = true;
+	      }
+	    else if (option == "-vd")
+	      {
+		need_version_dir = true;
+	      }
+	    else if (option == "-requirements")
+	      {
+		need_requirements_file = true;
+	      }
+	    else if (option == "--help")
+	      {
+		help ();
+		return;
+	      }
+	    else if (option[0] == '-')
+	      {
+		help ();
+		return;
+	      }
+	    else
+	      {
+		do_checkout_phase1 (option, m_version_dir, version_tag);
+	      }
+	  }
+      }
+  }
+
+private:
+
+  bool m_recursive;
+  bool need_touch_files;
+  bool m_head;
+  bool m_verbose;
+  bool m_simulation;
+  bool no_config;
+
+  cmt_string m_home_dir;
+  cmt_string m_checkout_dir;
+  cmt_string m_version_dir;
+  cmt_string m_cvs_offset;
+
+  cmt_string m_protocol_level;
+  cmt_string m_last_module;
+  cmt_string m_last_cvs_infos;
+  cmt_string structure_info;
+  cmt_string error_info;
+  cmt_string tags_top_info;
+  cmt_string tags_info;
+  cmt_string cvsversions_top_info;
+  cmt_string cvsversions_info;
+  cmt_string branches_info;
+  cmt_string subpackages_info;
+  cmt_string subprojects_info;
+};
+
+//--------------------------------------------------------------------
+
+void Grep::begin ()
+{
+  m_result = "";
+}
+
+void Grep::filter (const cmt_string& line)
+{
+    //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "Grep::filter" << endl;
+
+  if (m_result != "") m_result += " ";
+  m_result += line;
+}
+
+const cmt_string& Grep::result () const
+{
+  return (m_result);
+}
+
+//--------------------------------------------------------------------
+
+Cut::Cut (int field)
+{
+  m_field = field;
+}
+
+void Cut::begin ()
+{
+    //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "Cut::begin" << endl;
+  m_result = "";
+}
+
+void Cut::filter (const cmt_string& line)
+{
+    //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "Cut::filter" << endl;
+
+  static CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " \t", words);
+  
+  if (words.size () <= m_field) return;
+  
+  if (m_result != "") m_result += " ";
+  m_result += words[m_field];
+}
+
+const cmt_string& Cut::result () const
+{
+  return (m_result);
+}
+
+//--------------------------------------------------------------------
+//--------------------------------------------------------------------
+
+History& History::instance ()
+{
+  static History h;
+  return (h);
+}
+
+void History::clear ()
+{
+  m_installed = "";
+}
+
+void History::install (const cmt_string& line)
+{
+  m_installed += "|";
+  m_installed += line;
+  m_installed += "|";
+}
+
+bool History::is_installed (const cmt_string& line)
+{
+  if (m_installed.find (line) != cmt_string::npos)
+    {
+      return (true);
+    }
+  
+  return (false);
+}
+
+History::History ()
+{
+}
+
+
+//--------------------------------------------------------------------
+
+void RecursivePass1::begin ()
+{
+  m_first = true;
+  m_result = "";
+}
+
+void RecursivePass1::filter (const cmt_string& line)
+{
+    //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "RecursivePass1::filter> " 
+    //                                          << "line=[" << line << "]" << endl;
+
+  if (line.find ("use CMT") != cmt_string::npos) return;
+  if (line.find ("use cmt") != cmt_string::npos) return;
+  
+  History& h = History::instance ();
+  
+  if (h.is_installed (line)) return;
+  
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " \t", words);
+
+  enum
+  {
+    need_package,
+    need_version,
+    need_path,
+    no_need
+  } state = need_package;
+
+  cmt_string package;
+  cmt_string version;
+  cmt_string path;
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& s = words[i];
+
+      if (s[0] == '-') continue;
+
+      switch (state)
+        {
+          case need_package:
+            package = s;
+            state = need_version;
+            break;
+          case need_version:
+            version = s;
+            state = need_path;
+            break;
+          case need_path:
+            path = s;
+            state = no_need;
+            break;
+        }
+    }
+  
+  if (version.find ("*") != cmt_string::npos)
+    {
+        /*
+      cout << "# ================= Package " << package 
+           << " version " << version << " " << path 
+           << " has wild cards and will not be considered." << endl;
+        */
+      return;
+    }
+
+  /**
+   *  At the first pass, we simply accumulate the not-yet handled
+   *  use statements.
+   */
+  
+  m_result += line;
+  m_result += "\n";
+  
+  if (m_first)
+    {
+      m_first = false;
+      cout << "  # --> now propagate cmt checkout to :" << endl;
+    }
+  
+  cout << "  #     " << package << " " << version << " " << path << endl;
+}
+
+const cmt_string& RecursivePass1::result () const
+{
+  return (m_result);
+}
+
+//--------------------------------------------------------------------
+
+RecursivePass2::RecursivePass2 (CvsImplementation& cvs) : m_cvs (cvs)
+{
+}
+
+void RecursivePass2::begin ()
+{
+}
+
+void RecursivePass2::filter (const cmt_string& line)
+{
+    //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "RecursivePass2::filter> " 
+    //                                          << "line=[" << line << "]" << endl;
+
+  /**
+   *   At the second pass, the lines are really handled. Thus
+   *   the lines are stored into m_installed so as to avoid
+   *   later on re-installation.
+   */
+  
+  History& h = History::instance ();
+  
+  if (h.is_installed (line)) return;
+  
+  h.install (line);
+  
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " \t", words);
+
+  enum
+  {
+    need_package,
+    need_version,
+    need_path,
+    no_need
+  } state = need_package;
+
+  cmt_string package;
+  cmt_string version;
+  cmt_string path;
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& s = words[i];
+
+      if (s[0] == '-') continue;
+
+      switch (state)
+        {
+          case need_package:
+            package = s;
+            state = need_version;
+            break;
+          case need_version:
+            version = s;
+            state = need_path;
+            break;
+          case need_path:
+            path = s;
+            state = no_need;
+            break;
+        }
+    }
+
+  if (version.find ("*") != cmt_string::npos)
+    {
+        /*
+      cout << "# ================= Package " << package 
+           << " version " << version << " " << path 
+           << " has wild cards and will not be considered." << endl;
+        */
+    }
+  else
+    {
+      static const cmt_string empty;
+      m_cvs.do_checkout_phase2 (path, package, version, empty);
+    }
+}
+
+//--------------------------------------------------------------------
+
+void RecursivePass3::begin ()
+{
+  m_first = true;
+  m_result = "";
+}
+
+void RecursivePass3::filter (const cmt_string& line)
+{
+  History& h = History::instance ();
+  
+  if (h.is_installed (line)) return;
+  
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " \t", words);
+
+  enum
+  {
+    need_project,
+    need_version,
+    need_tag,
+    no_need
+  } state = need_project;
+
+  cmt_string project;
+  cmt_string version;
+  cmt_string tag;
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& s = words[i];
+
+      switch (state)
+        {
+          case need_project:
+            project = s;
+            state = need_version;
+            break;
+          case need_version:
+            version = s;
+            state = need_tag;
+            break;
+          case need_tag:
+            tag = s;
+            state = no_need;
+            break;
+        }
+    }
+  
+  if (version.find ("*") != cmt_string::npos)
+    {
+        /*
+      cout << "# ================= Project " << project 
+           << " version " << version << " " << path 
+           << " has wild cards and will not be considered." << endl;
+        */
+      return;
+    }
+
+  /**
+   *  At the first pass, we simply accumulate the not-yet handled
+   *  use statements.
+   */
+  
+  m_result += line;
+  m_result += "\n";
+  
+  if (m_first)
+    {
+      m_first = false;
+      cout << "  # --> now propagate cmt checkout to :" << endl;
+    }
+  
+  cout << "  #     " << project << " " << version << " " << tag << endl;
+}
+
+const cmt_string& RecursivePass3::result () const
+{
+  return (m_result);
+}
+
+//--------------------------------------------------------------------
+
+RecursivePass4::RecursivePass4 (CvsImplementation& cvs) : m_cvs (cvs)
+{
+}
+
+void RecursivePass4::begin ()
+{
+}
+
+void RecursivePass4::filter (const cmt_string& line)
+{
+    //if (CmtSystem::testenv ("CMTTESTAWK")) cout << "RecursivePass4::filter> " 
+    //                                          << "line=[" << line << "]" << endl;
+
+  /**
+   *   At the second pass, the lines are really handled. Thus
+   *   the lines are stored into m_installed so as to avoid
+   *   later on re-installation.
+   */
+  
+  History& h = History::instance ();
+  
+  if (h.is_installed (line)) return;
+  
+  h.install (line);
+  
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " \t", words);
+
+  enum
+  {
+    need_project,
+    need_version,
+    need_tag,
+    no_need
+  } state = need_project;
+
+  cmt_string project;
+  cmt_string version;
+  cmt_string tag;
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& s = words[i];
+
+      switch (state)
+        {
+          case need_project:
+            project = s;
+            state = need_version;
+            break;
+          case need_version:
+            version = s;
+            state = need_tag;
+            break;
+          case need_tag:
+            tag = s;
+            state = no_need;
+            break;
+        }
+    }
+
+  if (version.find ("*") != cmt_string::npos)
+    {
+        /*
+      cout << "# ================= Project " << project 
+           << " version " << version
+           << " has wild cards and will not be considered." << endl;
+        */
+    }
+  else
+    {
+      static const cmt_string empty;
+      m_cvs.do_checkout_phase2 (empty, project, version, tag);
+    }
+}
+
+//--------------------------------------------------------------------
+
+void Cvs::tags (const CmtSystem::cmt_string_vector& arguments)
+{
+  CvsImplementation cvs;
+
+  cvs.tags (arguments);
+}
+
+void Cvs::branches (const cmt_string& module)
+{
+  CvsImplementation cvs;
+
+  cvs.branches (module);
+}
+
+void Cvs::subpackages (const cmt_string& module)
+{
+  CvsImplementation cvs;
+
+  cvs.subpackages (module);
+}
+
+void Cvs::subprojects (const cmt_string& module)
+{
+  CvsImplementation cvs;
+
+  cvs.subprojects (module);
+}
+
+void Cvs::checkout (const CmtSystem::cmt_string_vector& arguments)
+{
+  CvsImplementation cvs;
+
+  cvs.checkout (arguments);
+}
+
Index: /CMT/v1r20/source/cmt_cvs.h
===================================================================
--- /CMT/v1r20/source/cmt_cvs.h	(revision 368)
+++ /CMT/v1r20/source/cmt_cvs.h	(revision 368)
@@ -0,0 +1,24 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_cvs_h__
+#define __cmt_cvs_h__
+
+#include "cmt_system.h"
+
+class Cvs
+{
+public:
+  
+  static void tags (const CmtSystem::cmt_string_vector& arguments);
+  static void branches (const cmt_string& module);
+  static void subpackages (const cmt_string& module);
+  static void subprojects (const cmt_string& module);
+  static void checkout (const CmtSystem::cmt_string_vector& arguments);
+
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_database.cxx
===================================================================
--- /CMT/v1r20/source/cmt_database.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_database.cxx	(revision 368)
@@ -0,0 +1,170 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_database.h"
+#include "cmt_vector.h"
+
+Database& Database::instance ()
+{
+  static Database db;
+
+  return (db);
+}
+
+void Database::clear ()
+{
+  Branch::clear_all ();
+  Constituent::clear_all ();
+  Fragment::clear_all ();
+  Group::clear_all ();
+  Language::clear_all ();
+  Package::clear_all ();
+  Pattern::clear_all ();
+  PatternList::clear_all ();
+  Use::clear_all ();
+  Symbol::clear_all ();
+  Tag::clear_all ();
+  Project::clear_all ();
+  CmtPathPattern::clear_all ();
+}
+
+Branch::BranchVector& Database::branches ()
+{
+  static Database& db = instance ();
+
+  return (db.m_branches);
+}
+
+Constituent::ConstituentVector& Database::constituents ()
+{
+  static Database& db = instance ();
+
+  return (db.m_constituents);
+}
+
+Fragment::FragmentVector& Database::fragments ()
+{
+  static Database& db = instance ();
+
+  return (db.m_fragments);
+}
+
+Group::GroupVector& Database::groups ()
+{
+  static Database& db = instance ();
+
+  return (db.m_groups);
+}
+
+Language::LanguageVector& Database::languages ()
+{
+  static Database& db = instance ();
+
+  return (db.m_languages);
+}
+
+Package::PackageVector& Database::packages ()
+{
+  static Database& db = instance ();
+
+  return (db.m_packages);
+}
+
+Package::PackageMap& Database::package_map ()
+{
+  static Database& db = instance ();
+
+  return (db.m_package_map);
+}
+
+Pattern::PatternVector& Database::patterns ()
+{
+  static Database& db = instance ();
+
+  return (db.m_patterns);
+}
+
+PatternList::PatternListMap& Database::pattern_list_map ()
+{
+  static Database& db = instance ();
+
+  return (db.m_pattern_list_map);
+}
+
+PatternList::PatternListVector& Database::pattern_lists ()
+{
+  static Database& db = instance ();
+
+  return (db.m_pattern_lists);
+}
+
+Use::UseVector& Database::all_uses ()
+{
+  static Database& db = instance ();
+
+  return (db.m_all_uses);
+}
+
+Use::UsePtrVector& Database::uses ()
+{
+  static Database& db = instance ();
+
+  return (db.m_uses);
+}
+
+Symbol::SymbolVector& Database::symbols ()
+{
+  static Database& db = instance ();
+
+  return (db.m_symbols);
+}
+
+Symbol::SymbolMap& Database::symbol_map ()
+{
+  static Database& db = instance ();
+
+  return (db.m_symbol_map);
+}
+
+Tag::TagVector& Database::all_tags ()
+{
+  static Database& db = instance ();
+
+  return (db.m_all_tags);
+}
+
+Tag::TagPtrVector& Database::tags ()
+{
+  static Database& db = instance ();
+
+  return (db.m_tags);
+}
+
+Tag::TagMap& Database::tag_map ()
+{
+  static Database& db = instance ();
+
+  return (db.m_tag_map);
+}
+
+Project::ProjectVector& Database::projects ()
+{
+  static Database& db = instance ();
+
+  return (db.m_projects);
+}
+
+CmtPathPattern::CmtPathPatternVector& Database::cmtpath_patterns ()
+{
+  static Database& db = instance ();
+
+  return (db.m_cmtpath_patterns);
+}
+
+Database::Database ()
+{
+}
+
Index: /CMT/v1r20/source/cmt_database.h
===================================================================
--- /CMT/v1r20/source/cmt_database.h	(revision 368)
+++ /CMT/v1r20/source/cmt_database.h	(revision 368)
@@ -0,0 +1,90 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_database_h__
+#define __cmt_database_h__
+
+#include "cmt_vector.h"
+
+#include "cmt_branch.h"
+#include "cmt_constituent.h"
+#include "cmt_fragment.h"
+#include "cmt_group.h"
+#include "cmt_language.h"
+#include "cmt_pattern.h"
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+#include "cmt_project.h"
+#include "cmt_cmtpath_pattern.h"
+
+class Database
+{
+public:
+
+  static Database& instance ();
+
+  static void clear ();
+
+  static Branch::BranchVector& branches ();
+  static Constituent::ConstituentVector& constituents ();
+  static Fragment::FragmentVector& fragments ();
+  static Group::GroupVector& groups ();
+  static Language::LanguageVector& languages ();
+
+  static Package::PackageVector& packages ();
+  static Package::PackageMap& package_map ();
+
+  static Pattern::PatternVector& patterns ();
+
+  static PatternList::PatternListMap& pattern_list_map ();
+  static PatternList::PatternListVector& pattern_lists ();
+
+  static Use::UseVector& all_uses ();
+  static Use::UsePtrVector& uses ();
+
+  static Symbol::SymbolVector& symbols ();
+  static Symbol::SymbolMap& symbol_map ();
+
+  static Tag::TagVector& all_tags ();
+  static Tag::TagPtrVector& tags ();
+  static Tag::TagMap& tag_map ();
+
+  static Project::ProjectVector& projects ();
+
+  static CmtPathPattern::CmtPathPatternVector& cmtpath_patterns ();
+
+private:
+
+  Database ();
+
+  Branch::BranchVector m_branches;
+  Constituent::ConstituentVector m_constituents;
+  Fragment::FragmentVector m_fragments;
+  Group::GroupVector m_groups;
+  Language::LanguageVector m_languages;
+
+  Package::PackageVector m_packages;
+  Package::PackageMap m_package_map;
+
+  Pattern::PatternVector m_patterns;
+
+  PatternList::PatternListMap m_pattern_list_map;
+  PatternList::PatternListVector m_pattern_lists;
+
+  Use::UseVector m_all_uses;
+  Use::UsePtrVector m_uses;
+  Symbol::SymbolVector m_symbols;
+  Symbol::SymbolMap m_symbol_map;
+  Tag::TagVector m_all_tags;
+  Tag::TagPtrVector m_tags;
+  Tag::TagMap m_tag_map;
+  Project::ProjectVector m_projects;
+
+  CmtPathPattern::CmtPathPatternVector m_cmtpath_patterns;
+
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_deps_builder.cxx
===================================================================
--- /CMT/v1r20/source/cmt_deps_builder.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_deps_builder.cxx	(revision 368)
@@ -0,0 +1,965 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_deps_builder.h"
+#include "cmt_system.h"
+#include "cmt_use.h"
+#include "cmt_include.h"
+#include "cmt_symbol.h"
+#include "cmt_log.h"
+
+//
+//  While parsing a C++ file, these are the possible usefull
+// states we can reach.
+//  Each state correspond to a specific state action function.
+//
+enum state_def
+{
+  at_start,                                // beginning of the file
+  in_line,                                // along a line
+  in_string,                        // inside a quoted string
+  in_char,                                // inside a quoted char
+  in_comment,                        // inside a multi-line comment
+  in_string_comment,        // inside a quoted string in a comment
+  in_char_comment,                // inside a quoted char in a comment
+  in_line_comment                // inside a single-line comment
+};
+
+//--------------------------------------------------
+static int build_deps (const cmt_string& name,
+                       const cmt_string& dir_name,
+                       int current_path_index,
+                       const CmtSystem::cmt_string_vector& include_paths,
+                       const CmtSystem::cmt_string_vector& substitutions,
+                       CmtSystem::cmt_string_vector& all_deps,
+                       CmtSystem::cmt_string_vector& deps);
+
+
+//--------------------------------------------------
+static void header_file_action (const char* header_file,
+                                const cmt_string& dir_name,
+                                int current_path_index,
+                                const CmtSystem::cmt_string_vector& include_paths,
+                                const CmtSystem::cmt_string_vector& substitutions,
+                                CmtSystem::cmt_string_vector& all_deps,
+                                CmtSystem::cmt_string_vector& deps)
+{
+  Log;
+
+  bool found = false;
+
+  for (int i = 0; i < all_deps.size (); i++)
+    {
+      const cmt_string& n = all_deps[i];
+
+      log << "CMT> check old header file name=" << n << " against " << header_file << log_endl;
+
+      if (n == header_file)
+        {
+          found = true;
+          break;
+        }
+    }
+  
+  if (!found)
+    {
+      log << "CMT> parsing new header file name=" << header_file << log_endl;
+
+      all_deps.push_back (header_file);
+      
+      int path_index = build_deps (header_file,
+                                   dir_name,
+                                   current_path_index,
+                                   include_paths,
+                                   substitutions,
+                                   all_deps,
+                                   deps);
+      
+      if (path_index >= 0)
+        {
+          cmt_string full_name;
+          
+          if (path_index == 1)
+            {
+              full_name = dir_name;
+              full_name += CmtSystem::file_separator ();
+              
+              if (current_path_index >= 2)
+                {
+                  full_name.replace (include_paths[current_path_index - 2],
+                                     substitutions[current_path_index - 2]);
+                }
+            }
+          else if (path_index > 1)
+            {
+              full_name  = substitutions[path_index - 2];
+              full_name += CmtSystem::file_separator ();
+            }
+          
+          full_name += header_file;
+          
+          deps.push_back (full_name);
+        }
+    }
+}
+
+
+//--------------------------------------------------
+static char* at_start_action (char* ptr,
+                              state_def& state,
+                              const cmt_string& dir_name,
+                              int current_path_index,
+                              const CmtSystem::cmt_string_vector& include_paths,
+                              const CmtSystem::cmt_string_vector& substitutions,
+                              CmtSystem::cmt_string_vector& all_deps,
+                              CmtSystem::cmt_string_vector& deps)
+{
+
+  char term = 0;
+  // To ignore leading spaces and tabs 
+  while ( (*ptr == ' ') or (*ptr == '\t'))
+  {
+    ptr++;
+  }
+
+  if (*ptr == '#')
+    {
+      ptr++;
+
+      // skip spaces 
+      while ((*ptr == ' ') || (*ptr == '\t')) ptr++;
+
+      if (!strncmp (ptr, "include", 7))
+        {
+	  // We have a #include statement
+
+          ptr += 7;
+
+          while ((*ptr == ' ') or (*ptr == '\t')) ptr++;
+          
+          if (*ptr == '<')
+            {
+              term = '>';
+              ptr++;
+            }
+          else if (*ptr == '"')
+            {
+              term = '"';
+              ptr++;
+            }
+          else
+            {
+	      // empty #include statement??
+              state = in_line;
+              ptr += strlen (ptr);
+              return (ptr);
+            }
+        }
+      else
+        {
+	  // ignore other pre-processor statements
+
+          state = in_line;
+          ptr += strlen (ptr);
+          return (ptr);
+        }
+    }
+  else if (!strncmp (ptr, "      include", 13))
+    {
+      // fortran include statement
+
+      ptr += 13;
+
+      while ((*ptr == ' ') || (*ptr == '\t')) ptr++;
+
+      if (*ptr == '\'')
+        {
+          term = '\'';
+          ptr++;
+        }
+      else
+        {
+          state = in_line;
+          return (ptr);
+        }
+    }
+  else if (!strncmp (ptr, "\tinclude", 8))
+    {
+      // fortran include statement
+
+      ptr += 8;
+
+      while ((*ptr == ' ') || (*ptr == '\t')) ptr++;
+
+      if (*ptr == '\'')
+        {
+          term = '\'';
+          ptr++;
+        }
+      else
+        {
+          state = in_line;
+          return (ptr);
+        }
+    }
+  else
+    {
+      state = in_line;
+      return (ptr);
+    }
+
+  // At this point we do have to include a header file.
+
+  char* end;
+
+  end = strchr (ptr, term);
+  if (end != 0)
+    {
+      *end = 0;
+    }
+  
+  const char* header_file = ptr;
+  
+  header_file_action (header_file,
+                      dir_name,
+                      current_path_index,
+                      include_paths,
+                      substitutions,
+                      all_deps,
+                      deps);
+  
+  if (end != 0)
+    {
+      *end = term;
+    }
+
+  state = in_line;
+  ptr += strlen (ptr);
+  
+  return (ptr);
+}
+
+/**
+   Any line with no header inclusion
+   step through comments and strings
+ */
+static char* in_line_action (char* ptr, state_def& state)
+{
+  char* pattern = ptr + strlen (ptr);
+  int length = 0;
+
+  /*
+    search for the first occurrence of 
+    {single-quote double-quote open-comment open-line-comment}
+
+    Must exclude escaped quotes \' and \"
+  */
+
+  char* pos = strchr (ptr, '"');
+  if ((pos != 0) && (pos < pattern) && (pos > ptr) && (*(pos-1) != '\\'))
+    {
+      state = in_string;
+      pattern = pos;
+      length = 1;
+    }
+
+  pos = strchr (ptr, '\'');
+  if ((pos != 0) && (pos < pattern) && (pos > ptr) && (*(pos-1) != '\\'))
+    {
+      state = in_char;
+      pattern = pos;
+      length = 1;
+    }
+
+  pos = strstr (ptr, "/*");   //*/
+  if ((pos != 0) && (pos < pattern))
+    {
+      state = in_comment;
+      pattern = pos;
+      length = 2;
+    }
+
+  pos = strstr (ptr, "//");
+  if ((pos != 0) && (pos < pattern))
+    {
+      state = in_line_comment;
+      pattern = pos;
+      length = 2;
+    }
+
+  ptr = pattern + length;
+
+  return (ptr);
+}
+
+//--------------------------------------------------
+static char* in_string_action (char* ptr, state_def& state)
+{
+  // we exclusively look for a double quote
+
+  char* pos = strchr (ptr, '"');
+  if (pos == 0)
+    {
+        // This string is not finished till the end of the line..
+        // we expect it to continue to the next line...
+        // thus we leave the state as it is
+      ptr += strlen (ptr);
+    }
+  else
+    {
+      if ((pos > ptr) && (*(pos - 1) == '\\'))
+        {
+          ptr = pos + 1;
+        }
+      else
+        {
+          ptr = pos + 1;
+          state = in_line;
+        }
+    }
+
+  return (ptr);
+}
+
+//--------------------------------------------------
+static char* in_char_action (char* ptr, state_def& state)
+{
+  // we exclusively look for a single quote
+
+  char* pos = strchr (ptr, '\'');
+  if (pos == 0)
+    {
+        // This string is not finished till the end of the line..
+        // we expect it continues to the nex line...
+        // thus we leave the state as it is
+      ptr += strlen (ptr);
+    }
+  else
+    {
+      if ((pos > ptr) && (*(pos - 1) == '\\'))
+        {
+          ptr = pos + 1;
+        }
+      else
+        {
+          ptr = pos + 1;
+          state = in_line;
+        }
+    }
+
+  return (ptr);
+}
+
+//--------------------------------------------------
+static char* in_comment_action (char* ptr, state_def& state)
+{
+  char* pattern = ptr + strlen (ptr);
+  int length    = 0;
+  char* pos;
+  
+
+    /*
+    Even if we are inside a comment, we must detect strings since comment markers may 
+    be written inside them.
+  
+  pos = strchr (ptr, '"');
+  
+  if ((pos != 0) && (pos < pattern) && (pos > ptr) && (*(pos-1) != '\\'))
+    {
+      state = in_string_comment;
+      pattern = pos;
+      length = 1;
+    }
+
+  pos = strchr (ptr, '\'');
+  if ((pos != 0) && (pos < pattern) && (pos > ptr) && (*(pos-1) != '\\'))
+    {
+      state = in_char_comment;
+      pattern = pos;
+      length = 1;
+    }
+ */
+  pos = strstr (ptr, "*/");
+  if ((pos != 0) && (pos < pattern))
+    {
+      state   = in_line;
+      pattern = pos;
+      length  = 2;
+    }
+
+  ptr = pattern + length;
+
+  return (ptr);
+}
+
+//--------------------------------------------------
+static char* in_string_comment_action (char* ptr, state_def& state)
+{
+  char* pos = strchr (ptr, '"');
+  if (pos == 0)
+    {
+        // This string is not finished till the end of the line..
+        // we expect it continues to the nex line...
+      ptr += strlen (ptr);
+    }
+  else
+    {
+      if ((pos > ptr) && (*(pos - 1) == '\\'))
+        {
+          ptr = pos + 1;
+        }
+      else
+        {
+          ptr = pos + 1;
+          state = in_comment;
+        }
+    }
+
+  return (ptr);
+}
+
+//--------------------------------------------------
+static char* in_char_comment_action (char* ptr, state_def& state)
+{
+  char* pos = strchr (ptr, '\'');
+  if (pos == 0)
+    {
+        // This string is not finished till the end of the line..
+        // we expect it continues to the nex line...
+      ptr += strlen (ptr);
+    }
+  else
+    {
+      if ((pos > ptr) && (*(pos - 1) == '\\'))
+        {
+          ptr = pos + 1;
+        }
+      else
+        {
+          ptr = pos + 1;
+          state = in_comment;
+        }
+      pos--;
+    }
+
+  return (ptr);
+}
+
+//--------------------------------------------------
+static char* in_line_comment_action (char* ptr, state_def& state)
+{
+  char * pos = strchr (ptr, '\\');  
+ /* Extend this part to deal with continuation character */  
+  if ( (pos == NULL) || ( (ptr + strlen(ptr)-1)!=pos ))
+  {
+      state = in_line;
+  }
+  
+  ptr    += strlen (ptr);
+  
+  return (ptr);
+}
+
+//--------------------------------------------------
+static void build_deps_text (char* text,
+			     const cmt_string& dir_name,
+			     int current_path_index,
+			     const CmtSystem::cmt_string_vector& include_paths,
+			     const CmtSystem::cmt_string_vector& substitutions,
+			     CmtSystem::cmt_string_vector& all_deps,
+			     CmtSystem::cmt_string_vector& deps)
+{
+  Log;
+
+  int pos;
+  int max_pos;
+  int line_number = 1;
+
+  log << "CMT> build_deps_text dir_name="
+      << dir_name << log_endl;
+
+
+  // erase of continuation character
+  pos = 0;
+  max_pos = strlen (text);
+  char* current = text;
+  char* last = text + max_pos;
+  while (current < last)
+  {
+   
+      char* crnl = strstr (current, "\\\r\n");
+      char* nl   = strstr (current, "\\\n");
+      
+      if ( (crnl==0) && (nl ==0)) break;
+      
+      int length = 0;
+            
+      char * ptr = 0;
+      if (nl==0)  //crnl > 0
+      {
+        length = 3;
+        ptr    = crnl; 
+      }      
+      else if (crnl==0) //nl > 0
+      {
+        length = 2;                        
+        ptr    = nl; 
+      }     
+      else if (crnl < nl)
+      {
+        length = 3;
+        ptr    = crnl;                 
+      }
+      else // (crnl > nl)
+      {
+        length = 2;                        
+        ptr    = nl;         
+      }
+      strcpy (ptr, ptr+length);
+      current = ptr;
+      last -= length;
+  } 
+  
+  pos = 0;
+  max_pos = strlen (text);
+  current = text;
+  last = text + max_pos;
+
+  state_def state = at_start;
+  
+
+  while (current < last)
+    {
+             
+      char marker;
+      char* marker_pos = 0;
+
+      char* crnl = strstr (current, "\r\n");
+      char* nl = strchr (current, '\n');
+
+      char* first = nl;
+      int length = 1;
+
+      char* ptr = 0;
+
+      if (crnl != 0)
+        {
+	  // cr+nl has been found
+
+          if (nl == 0)
+            {
+	      // cr but no nl ??
+              first = crnl;
+              length = 2;
+            }
+          else
+            {
+	      // both cr+nl and nl found
+              first = (nl < crnl) ? nl : crnl;
+              length = (nl < crnl) ? 1 : 2;
+            }
+        }
+      else
+	{
+	  // no cr+nl but nl alone found
+	  first = nl;
+	  length = 1;
+	}
+
+      ptr = current;
+
+      if (first == 0)
+        {
+    	  // neither nl nor cr+nl found => this is the last line
+	       marker_pos = 0;
+        }
+      else
+        {
+    	  marker_pos = first;
+	      marker = *marker_pos;
+	      *marker_pos = 0;
+        }
+
+      log << "CMT> build_deps_text2 line=[" 
+	  << current << "]" << log_endl;
+      
+      while (strlen (ptr) > 0)
+	{
+	  switch (state)
+	    {
+	    case at_start:
+	      ptr = at_start_action (ptr,
+				     state,
+				     dir_name,
+				     current_path_index,
+				     include_paths,
+				     substitutions,
+				     all_deps,
+				     deps);
+	      break;
+	    case in_line:
+	      ptr = in_line_action (ptr, state);
+	      break;
+	    case in_string:
+	      ptr = in_string_action (ptr, state);
+	      break;
+	    case in_char:
+	      ptr = in_char_action (ptr, state);
+	      break;
+	    case in_comment:
+	      ptr = in_comment_action (ptr, state);
+	      break;
+	    case in_string_comment:
+	      ptr = in_string_comment_action (ptr, state);
+	      break;
+	    case in_char_comment:
+	      ptr = in_char_comment_action (ptr, state);
+	      break;
+	    case in_line_comment:
+	      ptr = in_line_comment_action (ptr, state);
+	      break;
+	    }
+	}
+
+      if (state == in_line) state = at_start;
+      line_number++;
+
+      if (marker_pos != 0)
+	{
+	  *marker_pos = marker;
+	  current = marker_pos + length;
+	}
+      else
+	{
+	  break;
+	}
+    }
+            
+}
+
+//--------------------------------------------------
+static int build_deps (const cmt_string& name,
+                       const cmt_string& dir_name,
+                       int current_path_index,
+                       const CmtSystem::cmt_string_vector& include_paths,
+                       const CmtSystem::cmt_string_vector& substitutions,
+                       CmtSystem::cmt_string_vector& all_deps,
+                       CmtSystem::cmt_string_vector& deps)
+{
+  Log;
+
+  int result = -1;
+  cmt_string new_dir;
+
+  log << "CMT> build_deps name=" << name << " dir_name=" 
+      << dir_name << log_endl;
+
+    //
+    // Return 0 when the file is found in the current directory
+    //
+  if (CmtSystem::test_file (name))
+    {
+      cmt_string text;
+
+      text.read (name);
+
+      char* ptr = &text[0];
+      CmtSystem::dirname (name, new_dir);
+
+      build_deps_text (ptr, new_dir, current_path_index,
+		       include_paths, substitutions,
+		       all_deps, deps);
+      return (0);
+    }
+
+  cmt_string full_name;
+
+  full_name = dir_name;
+  full_name += CmtSystem::file_separator ();
+  full_name += name;
+
+    //
+    // Return 1 when the file is found in the directory of the
+    // upper level source file
+    //
+  if (CmtSystem::test_file (full_name))
+    {
+      cmt_string text;
+
+      text.read (full_name);
+
+      char* ptr = &text[0];
+      CmtSystem::dirname (full_name, new_dir);
+
+      build_deps_text (ptr, new_dir, current_path_index,
+		       include_paths, substitutions,
+		       all_deps, deps);
+      return (1);
+    }
+
+  int path_index = -1;
+
+    //
+    // Return [path_index + 2] when the include file is found at one of
+    // the include_paths
+    //
+  for (path_index = 0; path_index < include_paths.size (); path_index++)
+    {
+      full_name  = include_paths[path_index];
+      full_name += CmtSystem::file_separator ();
+      full_name += name;
+
+      log << "CMT> build_deps2 full_name=" << full_name << log_endl;
+
+      if (CmtSystem::test_file (full_name))
+        {
+	  cmt_string text;
+
+	  text.read (full_name);
+
+	  char* ptr = &text[0];
+	  CmtSystem::dirname (full_name, new_dir);
+
+	  log << "CMT> build_deps3 new_dir=" << new_dir << log_endl;
+
+	  build_deps_text (ptr,
+			   new_dir,
+			   path_index + 2,
+			   include_paths,
+			   substitutions,
+			   all_deps,
+			   deps);
+
+	  return (path_index + 2);
+        }
+    }
+
+  log << "CMT> build_deps3" << log_endl;
+
+  return (-1);
+}
+
+//--------------------------------------------------------------------------
+void DepsBuilder::clear ()
+{
+  m_include_paths.clear ();
+  m_substitutions.clear ();
+}
+
+//--------------------------------------------------------------------------
+void DepsBuilder::add (const cmt_string& path, const cmt_string& substitution)
+{
+  if (path[path.size () - 1] == CmtSystem::file_separator ())
+    {
+      cmt_string p = path;
+      p.erase (path.size () - 1);
+      m_include_paths.push_back (p);
+    }
+  else
+    {
+      m_include_paths.push_back (path);
+    }
+
+  m_substitutions.push_back (substitution);
+}
+
+//--------------------------------------------------------------------------
+void DepsBuilder::add_includes (const Use& use)
+{
+  Log;
+
+  const Include::IncludeVector& includes = use.includes;
+  int include_number;
+
+  for (include_number = 0;
+       include_number < includes.size ();
+       include_number++)
+    {
+      const Include& include = includes[include_number];
+
+      cmt_string temp = include.name;
+      cmt_string pattern;
+      cmt_string name;
+      char end_pattern;
+
+      int start = 0;
+
+      for (;;)
+        {
+          int begin;
+
+          begin = temp.find (start, "${");
+          if (begin != cmt_string::npos)
+            {
+              end_pattern = '}';
+            }
+          else
+            {
+              begin = temp.find (start, "$(");
+              if (begin != cmt_string::npos)
+                {
+                  end_pattern = ')';
+                }
+              else
+                {
+                  break;
+                }
+            }
+
+          start = begin + 2;
+
+          int end;
+          end = temp.find (start, end_pattern);
+          if (end == cmt_string::npos) break;
+          if (end < begin) break;
+          start = end + 1;
+
+          temp.substr (begin, end - begin + 1, pattern);
+          temp.substr (begin + 2, end - begin - 2, name);
+
+          Symbol* macro = Symbol::find (name);
+          if (macro != 0)
+            {
+              cmt_string value = macro->resolve_macro_value ();
+              value += CmtSystem::file_separator ();
+              temp.replace_all (pattern, value);
+            }
+          else
+            {
+              cmt_string value = CmtSystem::getenv (name);
+              value += CmtSystem::file_separator ();
+              temp.replace_all (pattern, value);
+            }
+        }
+
+      log << "include = " << temp << log_endl;
+
+      add (temp, include.name);
+    }
+}
+
+//--------------------------------------------------------------------------
+CmtSystem::cmt_string_vector& DepsBuilder::run (const cmt_string& file_name)
+{
+  Log;
+
+  log << "Starting deps builder on " << file_name << log_endl;
+
+
+  m_deps.clear ();
+  m_all_deps.clear ();
+
+  cmt_string preprocessor;
+  Symbol* macro = Symbol::find ("preprocessor_command");
+  if (macro != 0)
+    {
+      preprocessor = macro->resolve_macro_value ();
+    }
+
+  if (preprocessor == "")
+    {
+        //
+        //   Since no preprocessor command is defined,
+        // we use the internal mechanism provided here.
+        //
+      cmt_string new_dir;
+
+      CmtSystem::dirname (file_name, new_dir);
+
+      build_deps (file_name,
+                  new_dir,
+                  0,
+                  m_include_paths,
+                  m_substitutions,
+                  m_all_deps,
+                  m_deps);
+    }
+  else
+    {
+        //
+        //  An external preprocessor command is defined. We expect it
+        // to follow a "standard" syntax for its output, ie:
+        //   o It starts with:
+        //       <module>.o: ...
+        //   o There may be many lines with trailing back-slashes
+        //   o All entries are space-separated
+        //   o One of the entries is the source file name itself
+        //
+        //  The preprocessor command expects the list of -I options
+        // (resolved from the "includes" macro) and the list of 
+        // -D/-U options (resolved from the "*_pp_*flags" macros)
+        //
+
+        //
+        // Building the complete command (still the pp_*flags are
+        // missing)
+        //
+      preprocessor += " ";
+      macro = Symbol::find ("includes");
+      preprocessor += macro->resolve_macro_value ();
+      preprocessor += " ";
+      preprocessor += file_name;
+      
+      cmt_string output;
+      
+      CmtSystem::execute (preprocessor, output);
+
+        //
+        // Make the output as one single big line.
+        //
+
+      output.replace_all ("\n", " ");
+      output.replace_all ("\\ ", " ");
+      
+      CmtSystem::cmt_string_vector files;
+      
+      CmtSystem::split (output, " \t", files);
+
+        //
+        // Analyze each entry
+        //
+      
+      for (int i = 1; i < files.size (); i++)
+        {
+          const cmt_string& file = files[i];
+          if (file == file_name) continue;
+          
+          cmt_string dir;
+          cmt_string name;
+          cmt_string full_name;
+          
+          CmtSystem::dirname (file, dir);
+
+            //
+            // Only declared include_paths will be taken into account
+            // Others are considered as system include paths.
+            //
+          
+          for (int j = 0; j < m_include_paths.size (); j++)
+            {
+              const cmt_string& p = m_include_paths[j];
+              if (dir == p)
+                {
+                  CmtSystem::basename (file, name);
+                  full_name = m_substitutions[j];
+                  full_name += name;
+
+                    //
+                    // We add in the "m_deps" list the symbolic form
+                    // of the path rather that the expanded one.
+                    //
+                  
+                  m_deps.push_back (full_name);
+                  
+                  break;
+                }
+            }
+        }
+    }
+
+  return (m_deps);
+}
+
Index: /CMT/v1r20/source/cmt_deps_builder.h
===================================================================
--- /CMT/v1r20/source/cmt_deps_builder.h	(revision 368)
+++ /CMT/v1r20/source/cmt_deps_builder.h	(revision 368)
@@ -0,0 +1,32 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_deps_builder_h__
+#define __cmt_deps_builder_h__
+
+#include "cmt.h"
+#include "cmt_system.h"
+
+class DepsBuilder
+{
+public:
+
+  void clear ();
+  void add (const cmt_string& path, const cmt_string& substitution);
+  void add_includes (const Use& use);
+  CmtSystem::cmt_string_vector& run (const cmt_string& file_name);
+
+private:
+
+  CmtSystem::cmt_string_vector m_include_paths;
+  CmtSystem::cmt_string_vector m_substitutions;
+
+  CmtSystem::cmt_string_vector m_deps;
+  CmtSystem::cmt_string_vector m_all_deps;
+
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_error.cxx
===================================================================
--- /CMT/v1r20/source/cmt_error.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_error.cxx	(revision 368)
@@ -0,0 +1,167 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_error.h"
+#include "cmt_vector.h"
+
+class Error
+{
+public:
+  static Error& instance ();
+
+  Error ()
+  {
+    error_names.add() = "ok";
+    error_names.add() = "Warning";
+    error_names.add() = "symbol not found";
+    error_names.add() = "pattern not found";
+    error_names.add() = "syntax error";
+    error_names.add() = "command_not_implemented";
+    error_names.add() = "package_not_found";
+    error_names.add() = "path_not_found";
+    error_names.add() = "version_conflict";
+    error_names.add() = "file_access_error";
+    error_names.add() = "execution_error";
+    error_names.add() = "cannot_lock";
+    error_names.add() = "cannot_write_lock";
+    error_names.add() = "cannot_run_lock_command";
+    error_names.add() = "cannot_unlock";
+    error_names.add() = "cannot_run_unlock_command";
+    error_names.add() = "cannot_remove_lock";
+    error_names.add() = "conflicting_lock";
+    error_names.add() = "unknown_command";
+    error_names.add() = "project_release_conflict";
+    error_names.add() = "execution_failed";
+    m_execution_error = 0;
+  }
+
+  ~Error ()
+  {
+  }
+
+  void clear ()
+  {
+    m_code = CmtError::ok;
+    m_text = "";
+    m_execution_error = 0 ;
+  }
+
+  void set (CmtError::code code, const cmt_string& text, const int execution_error)
+  {
+    m_code = code;
+    m_text = text;
+    m_execution_error = execution_error;
+  }
+
+  CmtError::code get_code () const
+  {
+    return (m_code);
+  }
+
+  int get_last_execution_error ()
+  {
+      return m_execution_error;
+  }
+
+  const cmt_string& get_text () const
+  {
+    return (m_text);
+  }
+
+  const cmt_string& get_name (CmtError::code error) const
+  {
+    const cmt_string& s = error_names[error];
+
+    return (s);
+  }
+
+private:
+  CmtError::code m_code;
+  cmt_string m_text;
+  cmt_vector<cmt_string> error_names;
+  int m_execution_error;
+};
+
+//---------------------------------------------------------------
+Error& Error::instance ()
+{
+  static Error e;
+  
+  return (e);
+}
+
+//---------------------------------------------------------------
+void CmtError::clear ()
+{
+  Error& e = Error::instance ();
+
+  e.clear ();
+}
+
+//---------------------------------------------------------------
+bool CmtError::has_pending_error ()
+{
+  Error& e = Error::instance ();
+
+  if (e.get_code () == ok) return (false);
+  else return (true);
+}
+
+//---------------------------------------------------------------
+CmtError::code CmtError::get_last_error_code ()
+{
+  Error& e = Error::instance ();
+
+  return (e.get_code ());
+}
+
+//---------------------------------------------------------------
+int CmtError::get_last_execution_error ()
+{
+  Error& e = Error::instance ();
+
+  return (e.get_last_execution_error ());
+}
+
+//---------------------------------------------------------------
+const cmt_string& CmtError::get_error_name (code error)
+{
+  Error& e = Error::instance ();
+
+  return (e.get_name (error));
+}
+
+//---------------------------------------------------------------
+void CmtError::set (code error, const cmt_string& text, const int execution_error)
+{
+  Error& e = Error::instance ();
+
+  e.set (error, text, execution_error);
+}
+
+//---------------------------------------------------------------
+cmt_string CmtError::get_last_error ()
+{
+  Error& e = Error::instance ();
+
+  cmt_string result;
+
+  result = get_error_name (e.get_code ());
+  result += " : ";
+  result += e.get_text ();
+
+  return (result);
+}
+
+//---------------------------------------------------------------
+void CmtError::print ()
+{
+  Error& e = Error::instance ();
+
+  cerr << "CMT> Error: " << get_error_name (e.get_code ()) << " : " << e.get_text () << endl;
+}
+
Index: /CMT/v1r20/source/cmt_error.h
===================================================================
--- /CMT/v1r20/source/cmt_error.h	(revision 368)
+++ /CMT/v1r20/source/cmt_error.h	(revision 368)
@@ -0,0 +1,57 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_error_h__
+#define __cmt_error_h__
+
+#include "cmt_std.h"
+#include "cmt_string.h"
+
+class CmtError
+{
+public:
+
+  typedef enum
+  {
+    ok,
+    warning,
+    symbol_not_found,
+    pattern_not_found,
+    syntax_error,
+    command_not_implemented,
+    package_not_found,
+    path_not_found,
+    version_conflict,
+    file_access_error,
+    execution_error,
+    cannot_lock,
+    cannot_write_lock,
+    cannot_run_lock_command,
+    cannot_unlock,
+    cannot_run_unlock_command,
+    cannot_remove_lock,
+    conflicting_lock,
+    unknown_command,    
+    project_release_conflict,
+    execution_failed
+  } code;
+ 
+  
+  static void clear ();
+  static code get_last_error_code ();
+  static bool has_pending_error ();
+  static const cmt_string& get_error_name (code error);
+  static void set (code error, const cmt_string& text, const int execution_error=0);
+
+  static int get_last_execution_error ();
+
+  static cmt_string get_last_error ();
+  static void print ();
+    
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_fragment.cxx
===================================================================
--- /CMT/v1r20/source/cmt_fragment.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_fragment.cxx	(revision 368)
@@ -0,0 +1,1288 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_fragment.h"
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+#include "cmt_system.h"
+#include "cmt_database.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Variables                                 */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+//----------------------------------------------------------
+Variable* Variable::find (VariableVector& vector, 
+                          const cmt_string& name)
+{
+  for (int i = 0; i < vector.size (); i++)
+    {
+      Variable& v = vector[i];
+
+      if (v.name == name) return (&v);
+    }
+
+  return (0);
+}
+
+//----------------------------------------------------------
+Variable::Variable ()
+{
+}
+
+//----------------------------------------------------------
+Variable::Variable (const cmt_string& n) : name (n)
+{
+  m_macro_braces = "${";
+  m_macro_braces += name;
+  m_macro_braces += "}";
+
+  m_macro_pars = "$(";
+  m_macro_pars += name;
+  m_macro_pars += ")";
+}
+
+//----------------------------------------------------------
+const cmt_string& Variable::macro_braces () const
+{
+  return (m_macro_braces);
+}
+
+//----------------------------------------------------------
+const cmt_string& Variable::macro_pars () const
+{
+  return (m_macro_pars);
+}
+
+//----------------------------------------------------------
+void Variable::set (const cmt_string& new_name,
+                    const cmt_string& new_value)
+{
+  name = new_name;
+  value = new_value;
+
+  m_macro_braces = "${";
+  m_macro_braces += name;
+  m_macro_braces += "}";
+
+  m_macro_pars = "$(";
+  m_macro_pars += name;
+  m_macro_pars += ")";
+}
+
+//----------------------------------------------------------
+Variable& Variable::operator = (const Variable& other)
+{
+  value = other.value;
+  return (*this);
+}
+
+//----------------------------------------------------------
+Variable& Variable::operator = (const cmt_string& v)
+{
+  value = v;
+  return (*this);
+}
+
+//----------------------------------------------------------
+void Variable::operator += (const cmt_string& v)
+{
+  value += v;
+}
+
+//----------------------------------------------------------
+cmt_string Variable::operator + (const cmt_string& v) const
+{
+  return (value + v);
+}
+
+//----------------------------------------------------------
+Variable::operator const cmt_string& () const
+{
+  return (value);
+}
+
+//----------------------------------------------------------
+bool Variable::operator == (const cmt_string& v) const
+{
+  return ((value == v));
+}
+
+//----------------------------------------------------------
+bool Variable::operator != (const cmt_string& v) const
+{
+  return ((value != v));
+}
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Fragments                                 */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+/*----------------------------------------------------------*/
+void Fragment::show (const cmt_string& name)
+{
+  Fragment* fragment = Fragment::find (name);
+  if (fragment == 0)
+    {
+      cout << "Fragment " << name << " not found" << endl;
+    }
+  else
+    {
+      fragment->print ();
+    }
+}
+
+/*----------------------------------------------------------*/
+void Fragment::show_all ()
+{
+  static FragmentVector& Fragments = fragments ();
+
+  int number;
+
+  for (number = 0; number < Fragments.size (); number++)
+    {
+      Fragment& fragment = Fragments[number];
+
+      fragment.print ();
+    }
+}
+
+class fragment_action_iterator
+{
+public:
+
+  fragment_action_iterator (Use* use) :
+    m_need_dependencies (false),
+    m_state (need_name),
+    m_use (use)
+  {
+  }
+
+  void add_word (const cmt_string& w)
+  {
+    switch (m_state)
+      {
+      case need_name:
+	m_name = w;
+	m_state = need_options;
+	break;
+      case need_options:
+	if (w.find ("-suffix=") != cmt_string::npos)
+	  {
+	    m_suffix = w;
+	    m_suffix.replace ("-suffix=", "");
+	  }
+	else if (w.find ("-dependencies") != cmt_string::npos)
+	  {
+	    m_need_dependencies = true;
+	  }
+	else if (w.find ("-header=") != cmt_string::npos)
+	  {
+	    m_header = w;
+	    m_header.replace ("-header=", "");
+
+	    if (Fragment::find (m_header) == 0)
+	      {
+		Fragment::add (m_header, "", "", "", false, m_use);
+	      }
+	  }
+	else if (w.find ("-trailer=") != cmt_string::npos)
+	  {
+	    m_trailer = w;
+	    m_trailer.replace ("-trailer=", "");
+	    
+	    if (Fragment::find (m_trailer) == 0)
+	      {
+		Fragment::add (m_trailer, "", "", "", false, m_use);
+	      }
+	  }
+	break;
+      }
+  }
+
+  void commit ()
+  {
+    Fragment::add (m_name, m_suffix, m_header, m_trailer, m_need_dependencies, m_use);
+  }
+
+private:
+
+  enum
+    {
+      need_name,
+      need_options
+    } m_state;
+
+  cmt_string m_name;
+  cmt_string m_suffix;
+  cmt_string m_header;
+  cmt_string m_trailer;
+  bool m_need_dependencies;
+  Use* m_use;
+};
+
+
+/*----------------------------------------------------------*/
+void Fragment::action (const CmtSystem::cmt_string_vector& words,
+                       Use* use)
+{
+  if ((Cmt::get_current_access () == UserMode) &&
+      (use->get_current_scope () == ScopePrivate)) return;
+
+  if (words.size () <= 1) return;
+
+  fragment_action_iterator it (use);
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& w = words[i];
+      cmt_string ew = w;
+
+      Symbol::expand (ew);
+      if (ew != w)
+        {
+          CmtSystem::cmt_string_vector ws;
+
+          CmtSystem::split (ew, " ", ws);
+
+          for (int j = 0; j < ws.size (); ++j)
+            {
+              const cmt_string& ww = ws[j];
+              it.add_word (ww);
+            }
+        }
+      else
+        {
+          it.add_word (ew);
+        }
+    }
+
+  it.commit ();
+}
+
+/*----------------------------------------------------------*/
+Fragment* Fragment::find (const cmt_string& name)
+{
+  static FragmentVector& Fragments = fragments ();
+
+  int fragment_index;
+
+  if (Fragments.size () == 0) return (0);
+
+  for (fragment_index = 0;
+       fragment_index < Fragments.size ();
+       fragment_index++)
+    {
+      Fragment& fragment = Fragments[fragment_index];
+
+      if (fragment.name == name)
+        {
+          return (&fragment);
+        }
+    }
+
+  return (0);
+}
+
+/*----------------------------------------------------------*/
+void Fragment::add (const cmt_string& name,
+                    const cmt_string& suffix,
+                    const cmt_string& header,
+                    const cmt_string& trailer,
+                    bool need_dependencies,
+                    Use* use)
+{
+  static FragmentVector& Fragments = fragments ();
+
+  {
+    Fragment* fragment;
+
+    if (name == "") return;
+
+    fragment = find (name);
+    if (fragment != 0)
+      {
+        if (suffix != "")
+          {
+            fragment->suffix = suffix;
+          }
+
+        if (header != "")
+          {
+            fragment->header = header;
+          }
+
+        if (trailer != "")
+          {
+            fragment->trailer = trailer;
+          }
+
+        fragment->need_dependencies = need_dependencies;
+
+        fragment->use = use;
+        return;
+      }
+  }
+
+  Fragment& fragment = Fragments.add ();
+
+  fragment.name              = name;
+  fragment.suffix            = suffix;
+  fragment.header            = header;
+  fragment.trailer           = trailer;
+  fragment.need_dependencies = need_dependencies;
+  fragment.use               = use;
+}
+
+/*----------------------------------------------------------*/
+void Fragment::clear_all ()
+{
+  static FragmentVector& Fragments = fragments ();
+
+  for (int i = 0; i < Fragments.size (); i++)
+    {
+      Fragment& f = Fragments[i];
+      f.clear ();
+    }
+
+  Fragments.clear ();
+}
+
+/*----------------------------------------------------------*/
+Fragment::FragmentVector& Fragment::fragments ()
+{
+  static Database& db = Database::instance ();
+  static FragmentVector& Fragments = db.fragments ();
+
+  return (Fragments);
+}
+
+/*----------------------------------------------------------*/
+Fragment::Fragment ()
+{
+  use = 0;
+}
+
+/*----------------------------------------------------------*/
+Fragment::Fragment (const cmt_string& fragment_name)
+{
+  name = fragment_name;
+  use = 0;
+  path = "";
+}
+
+/*----------------------------------------------------------*/
+Fragment::~Fragment ()
+{
+  use = 0;
+}
+
+/*----------------------------------------------------------*/
+void Fragment::clear ()
+{
+  name    = "";
+  suffix  = "";
+  header  = "";
+  trailer = "";
+  need_dependencies = false;
+  path = "";
+  use  = 0;
+}
+
+/*----------------------------------------------------------*/
+int Fragment::print ()
+{
+  int result = 1;
+
+  if (name == "") return (0);
+  
+  locate ();
+
+  if (use == 0)
+    {
+      Use& u = Use::current();
+      use = &u;
+    }
+  
+  cmt_string the_path = path;
+
+  use->reduce_path (the_path);
+
+  cout << the_path;
+
+  if (suffix != "")
+    {
+      cout << "->" << suffix;
+    }
+
+  cout << endl;
+
+  return (result);
+}
+
+/*----------------------------------------------------------*/
+bool Fragment::locate ()
+{
+  cmt_string root_path;
+
+  if (use == 0)
+    {
+      // Assume CMT
+      use = Use::find ("CMT");
+    }
+
+  use->get_full_path (root_path);
+
+  if (path != "") return (true);
+
+  // First try <root>/fragments/<name> or <root>/fragments/nmake/<name>
+
+  path = root_path;
+  path += CmtSystem::file_separator ();
+  path += "fragments";
+  path += CmtSystem::file_separator ();
+  
+  if (Cmt::build_nmake ())
+    {
+      path += "nmake";
+      path += CmtSystem::file_separator ();
+    }
+  
+  path += name;
+
+  if (CmtSystem::test_file (path)) return (true);
+
+  // Then try <root>/fragments/<name> for both Win and Unix
+
+  path = root_path;
+  path += CmtSystem::file_separator ();
+  path += "fragments";
+  path += CmtSystem::file_separator ();
+  path += name;
+
+  if (CmtSystem::test_file (path)) return (true);
+
+  // Then try <root>/cmt/fragments/<name> or <root>/cmt/fragments/nmake/<name>
+
+  root_path += CmtSystem::file_separator ();
+
+  if (use->style == mgr_style) root_path += "mgr";
+  else root_path += "cmt";
+  
+  root_path += CmtSystem::file_separator ();
+  root_path += "fragments";
+  root_path += CmtSystem::file_separator ();
+  
+  path = root_path;
+  
+  if (Cmt::build_nmake ())
+    {
+      path += "nmake";
+      path += CmtSystem::file_separator ();
+    }
+  
+  path += name;
+  
+  if (CmtSystem::test_file (path)) return (true);
+
+  // Then try <root>/cmt/fragments/<name> for both Win and Unix
+
+  path = root_path;
+  
+  path += name;
+
+  if (CmtSystem::test_file (path)) return (true);
+
+  return (false);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (FILE* out,
+                     const cmt_string& name,
+                     int variables, ...)
+{
+  va_list ids;
+
+  Fragment* fragment = Fragment::find (name);
+  if (fragment == 0) return (false);
+
+  va_start (ids, variables);
+  bool result = fragment->copy (out, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (cmt_string& out,
+                     const cmt_string& name,
+                     int variables, ...)
+{
+  va_list ids;
+
+  Fragment* fragment = Fragment::find (name);
+  if (fragment == 0) return (false);
+
+  va_start (ids, variables);
+  bool result = fragment->copy (out, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (FILE* out, int variables, ...)
+{
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = copy (out, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (cmt_string& out, int variables, ...)
+{
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = copy (out, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (FILE* out, int variables, va_list ids)
+{
+  static cmt_string cline;
+
+  bool result = copy (cline, variables, ids);
+  if (result)
+    {
+      cline.write (out);
+      return (true);
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+bool Fragment::copy (cmt_string& out, int variables, va_list ids)
+{
+  int i;
+
+  if (!locate ()) return (false);
+
+  out.read (path);
+
+  Variable* var = 0;
+  for (i = 0; i < variables; i++)
+    {
+      var = va_arg (ids, Variable*);
+      out.replace_all (var->macro_braces (), var->value);
+      out.replace_all (var->macro_pars (), var->value);
+    }
+
+  return (true);
+}
+
+//--------------------------------------------------
+bool Fragment::wincopy (FILE* out, int variables, va_list ids)
+{
+  static cmt_string cline;
+
+  bool result = wincopy (cline, variables, ids);
+
+  if (result)
+    {
+      cline.write (out);
+      return (true);
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+bool Fragment::wincopy (cmt_string& out, int variables, va_list ids)
+{
+  int i;
+
+  if (!locate ()) return (false);
+
+  out.read (path);
+
+  Variable* var = 0;
+  for (i = 0; i < variables; i++)
+    {
+      var = va_arg (ids, Variable*);
+      out.replace_all (var->macro_braces (), var->value);
+      out.replace_all (var->macro_pars (), var->value);
+    }
+
+  cmt_string pattern;
+  cmt_string macro_name;
+  char end_pattern;
+
+  int start = 0;
+
+  for (;;)
+    {
+      //
+      // Try and substitute all ${xxx} or $(xxx) patterns
+      // using symbol values.
+      //
+      int par;
+      int brace;
+      int begin;
+
+      par = out.find (start, "$(");
+      brace = out.find (start, "${");
+
+      if (par == cmt_string::npos)
+        {
+	  // No parentheses. Look for brace
+          if (brace == cmt_string::npos)
+            {
+	      // No pattern, finish the scan.
+              break;
+            }
+
+	  // Brace found
+          end_pattern = '}';
+          begin = brace;
+        }
+      else
+        {
+	  // Parenthese found. Look for closest from {par, brace}
+          if ((brace == cmt_string::npos) ||
+              (brace > par))
+            {
+              end_pattern = ')';
+              begin = par;
+            }
+          else
+            {
+              end_pattern = '}';
+              begin = brace;
+            }
+        }
+
+      // Skip the pattern intro.
+      start = begin + 2;
+
+      int end;
+      end = out.find (start, end_pattern);
+      if (end == cmt_string::npos)
+        {
+	  // The pattern is a fake one (no ending!)
+          break;
+        }
+
+      // This should never happen...
+      if (end < begin) break;
+
+      // Extract the complete pattern
+      out.substr (begin, end - begin + 1, pattern);
+
+      // Then only the macro name
+      out.substr (begin + 2, end - begin - 2, macro_name);
+
+      if (macro_name == "CFG")
+        {
+	  // This is a Windows reserved keyword...
+          start = end + 1;
+        }
+      else
+        {
+          Symbol* macro = Symbol::find (macro_name);
+          if (macro != 0)
+            {
+	      // Macro found
+              cmt_string value = macro->resolve_macro_value ();
+	      //cout << "resolve_macro_value2> value=" << value << endl;
+              out.replace_all (pattern, value);
+
+	      // The substitution will restart from the same place
+	      // allowing for recursive replacements
+              start = begin;
+            }
+          else
+            {
+	      // Macro not found. Look for env. variable
+              cmt_string value = CmtSystem::getenv (macro_name);
+	      //cout << "resolve_macro_value3> " << macro_name << "=" << value << endl;
+              out.replace_all (pattern, value);
+
+	      // The substitution will restart from the same place
+	      // allowing for recursive replacements
+              start = begin;
+            }
+        }
+    }
+
+  // Uniformly install CR-LF doublets.
+
+  out.replace_all ("\r\n", "\n");
+  out.replace_all ("\n", "\r\n");
+
+  return (true);
+}
+
+
+
+
+
+
+
+
+//--------------------------------------------------
+bool Fragment::copy (FILE* out,
+                     const cmt_string& name,
+                     const Variable::VariableVector& vector, 
+                     int variables, ...)
+{
+  va_list ids;
+
+  Fragment* fragment = Fragment::find (name);
+  if (fragment == 0) return (false);
+
+  va_start (ids, variables);
+  bool result = fragment->copy (out, vector, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (cmt_string& out,
+                     const cmt_string& name,
+                     const Variable::VariableVector& vector, 
+                     int variables, ...)
+{
+  va_list ids;
+
+  Fragment* fragment = Fragment::find (name);
+  if (fragment == 0) return (false);
+
+  va_start (ids, variables);
+  bool result = fragment->copy (out, vector, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (FILE* out, const Variable::VariableVector& vector, int variables, ...)
+{
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = copy (out, vector, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (cmt_string& out, const Variable::VariableVector& vector, int variables, ...)
+{
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = copy (out, vector, variables, ids);
+  va_end (ids);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool Fragment::copy (FILE* out, const Variable::VariableVector& vector, int variables, va_list ids)
+{
+  static cmt_string cline;
+
+  bool result = copy (cline, vector, variables, ids);
+  if (result)
+    {
+      cline.write (out);
+      return (true);
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+bool Fragment::copy (cmt_string& out, const Variable::VariableVector& vector, int variables, va_list ids)
+{
+  int i;
+
+  if (!locate ()) return (false);
+
+  out.read (path);
+
+  Variable* var = 0;
+
+  for (i = 0; i < vector.size (); i++)
+    {
+      var = &(vector[i]);
+      out.replace_all (var->macro_braces (), var->value);
+      out.replace_all (var->macro_pars (), var->value);
+    }
+
+  for (i = 0; i < variables; i++)
+    {
+      var = va_arg (ids, Variable*);
+      out.replace_all (var->macro_braces (), var->value);
+      out.replace_all (var->macro_pars (), var->value);
+    }
+
+  return (true);
+}
+
+//--------------------------------------------------
+bool Fragment::wincopy (FILE* out, const Variable::VariableVector& vector, int variables, va_list ids)
+{
+  static cmt_string cline;
+
+  bool result = wincopy (cline, vector, variables, ids);
+  if (result)
+    {
+      cline.write (out);
+      return (true);
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+bool Fragment::wincopy (cmt_string& out, const Variable::VariableVector& vector, 
+                        int variables, va_list ids)
+{
+  int i;
+
+  if (!locate ()) return (false);
+
+  out.read (path);
+
+  Variable* var = 0;
+
+  for (i = 0; i < vector.size (); i++)
+    {
+      var = &(vector[i]);
+      out.replace_all (var->macro_braces (), var->value);
+      out.replace_all (var->macro_pars (), var->value);
+    }
+
+  for (i = 0; i < variables; i++)
+    {
+      var = va_arg (ids, Variable*);
+      out.replace_all (var->macro_braces (), var->value);
+      out.replace_all (var->macro_pars (), var->value);
+    }
+
+  cmt_string pattern;
+  cmt_string macro_name;
+  char end_pattern;
+
+  int start = 0;
+
+  for (;;)
+    {
+      //
+      // Try and substitute all ${xxx} or $(xxx) patterns
+      // using symbol values.
+      //
+      int par;
+      int brace;
+      int begin;
+
+      par = out.find (start, "$(");
+      brace = out.find (start, "${");
+
+      if (par == cmt_string::npos)
+        {
+	  // No parentheses. Look for brace
+          if (brace == cmt_string::npos)
+            {
+	      // No pattern, finish the scan.
+              break;
+            }
+
+	  // Brace found
+          end_pattern = '}';
+          begin = brace;
+        }
+      else
+        {
+	  // Parenthese found. Look for closest from {par, brace}
+          if ((brace == cmt_string::npos) ||
+              (brace > par))
+            {
+              end_pattern = ')';
+              begin = par;
+            }
+          else
+            {
+              end_pattern = '}';
+              begin = brace;
+            }
+        }
+
+      // Skip the pattern intro.
+      start = begin + 2;
+
+      int end;
+      end = out.find (start, end_pattern);
+      if (end == cmt_string::npos)
+        {
+	  // The pattern is a fake one (no ending!)
+          break;
+        }
+
+      // This should never happen...
+      if (end < begin) break;
+
+      // Extract the complete pattern
+      out.substr (begin, end - begin + 1, pattern);
+
+      // Then only the macro name
+      out.substr (begin + 2, end - begin - 2, macro_name);
+
+      if (macro_name == "CFG")
+        {
+	  // This is a Windows reserved keyword...
+          start = end + 1;
+        }
+      else
+        {
+          Symbol* macro = Symbol::find (macro_name);
+          if (macro != 0)
+            {
+	      // Macro found
+              cmt_string value = macro->resolve_macro_value ();
+	      //cout << "resolve_macro_value2> value=" << value << endl;
+              out.replace_all (pattern, value);
+
+	      // The substitution will restart from the same place
+	      // allowing for recursive replacements
+              start = begin;
+            }
+          else
+            {
+	      // Macro not found. Look for env. variable
+              cmt_string value = CmtSystem::getenv (macro_name);
+	      //cout << "resolve_macro_value3> " << macro_name << "=" << value << endl;
+              out.replace_all (pattern, value);
+
+	      // The substitution will restart from the same place
+	      // allowing for recursive replacements
+              start = begin;
+            }
+        }
+    }
+
+  // Uniformly install CR-LF doublets.
+
+  out.replace_all ("\r\n", "\n");
+  out.replace_all ("\n", "\r\n");
+
+  return (true);
+}
+
+//--------------------------------------------------
+FragmentHandle::FragmentHandle ()
+{
+  _fragment = 0;
+  _initialized = false;
+}
+
+//--------------------------------------------------
+FragmentHandle::FragmentHandle (const cmt_string name) : _name(name)
+{
+  _fragment = 0;
+  _initialized = false;
+}
+
+//--------------------------------------------------
+FragmentHandle& FragmentHandle::operator = (const FragmentHandle& other)
+{
+  _name = other._name;
+  _fragment = 0;
+  _initialized = false;
+
+  return (*this);
+}
+
+//--------------------------------------------------
+void FragmentHandle::reset ()
+{
+  _fragment = 0;
+  _initialized = false;
+}
+
+//--------------------------------------------------
+void FragmentHandle::set (const cmt_string name)
+{
+  _name = name;
+  _fragment = 0;
+  _initialized = false;
+}
+
+//--------------------------------------------------
+cmt_string& FragmentHandle::name ()
+{
+  static cmt_string null_string;
+
+  if (!setup ()) return (null_string);
+
+  return (_fragment->name);
+}
+
+//--------------------------------------------------
+cmt_string& FragmentHandle::suffix ()
+{
+  static cmt_string null_string;
+
+  if (!setup ()) return (null_string);
+
+  return (_fragment->suffix);
+}
+
+//--------------------------------------------------
+cmt_string& FragmentHandle::header ()
+{
+  static cmt_string null_string;
+
+  if (!setup ()) return (null_string);
+
+  return (_fragment->header);
+}
+
+//--------------------------------------------------
+cmt_string& FragmentHandle::trailer ()
+{
+  static cmt_string null_string;
+
+  if (!setup ()) return (null_string);
+
+  return (_fragment->trailer);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::need_dependencies ()
+{
+  if (!setup ()) return (false);
+
+  return (_fragment->need_dependencies);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::copy (FILE* out, int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->copy (out, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::copy (cmt_string& out, int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->copy (out, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::wincopy (FILE* out, int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->wincopy (out, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::wincopy (cmt_string& out, int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->wincopy (out, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+
+
+
+//--------------------------------------------------
+bool FragmentHandle::copy (FILE* out, const Variable::VariableVector& vector, int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->copy (out, vector, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::copy (cmt_string& out, const Variable::VariableVector& vector, int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->copy (out, vector, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::wincopy (FILE* out, const Variable::VariableVector& vector, int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->wincopy (out, vector, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::wincopy (cmt_string& out, 
+                              const Variable::VariableVector& vector, 
+                              int variables, ...)
+{
+  if (!setup ()) return (false);
+
+  va_list ids;
+
+  va_start (ids, variables);
+  bool result = _fragment->wincopy (out, vector, variables, ids);
+  va_end (ids);
+
+  if (!result)
+    {
+      cerr << "#CMT> Fragment " << _name << " not found" << endl;
+      _fragment = 0;
+    }
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool FragmentHandle::setup ()
+{
+  if (!_initialized)
+    {
+      _initialized = true;
+
+      _fragment = Fragment::find (_name);
+      if (_fragment == 0)
+        {
+          cerr << "#CMT> Fragment " << _name << " not found" << endl;
+        }
+    }
+
+  if (_fragment == 0)
+    {
+      return (false);
+    }
+  else
+    {
+      return (true);
+    }
+}
Index: /CMT/v1r20/source/cmt_fragment.h
===================================================================
--- /CMT/v1r20/source/cmt_fragment.h	(revision 368)
+++ /CMT/v1r20/source/cmt_fragment.h	(revision 368)
@@ -0,0 +1,140 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_fragment_h__
+#define __cmt_fragment_h__
+
+#include <stdarg.h>
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+
+class Variable
+{
+public:
+
+  typedef cmt_vector<Variable> VariableVector;
+
+  static Variable* find (VariableVector& vector, 
+                         const cmt_string& name);
+
+public:
+
+  Variable ();
+  Variable (const cmt_string& n);
+
+  const cmt_string& macro_braces () const;
+  const cmt_string& macro_pars () const;
+
+  void set (const cmt_string& new_name,
+            const cmt_string& new_value = "");
+
+  Variable& operator = (const Variable& other);
+  Variable& operator = (const cmt_string& v);
+  void operator += (const cmt_string& v);
+  cmt_string operator + (const cmt_string& v) const;
+  operator const cmt_string& () const;
+  bool operator == (const cmt_string& v) const;
+  bool operator != (const cmt_string& v) const;
+  cmt_string name;
+  cmt_string value;
+
+private:
+  cmt_string m_macro_braces;
+  cmt_string m_macro_pars;
+};
+
+class Fragment
+{
+public:
+  typedef cmt_vector<Fragment> FragmentVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words,
+                      Use* use);
+  static Fragment* find (const cmt_string& name);
+  static void add (const cmt_string& name,
+                   const cmt_string& suffix,
+                   const cmt_string& header,
+                   const cmt_string& trailer,
+                   bool need_dependencies,
+                   Use* use);
+  static void show (const cmt_string& name);
+  static void show_all ();
+  static void clear_all ();
+  static bool copy (FILE* out, const cmt_string& name, int variables, ...);
+  static bool copy (cmt_string& out, const cmt_string& name, int variables, ...);
+  static bool copy (FILE* out, const cmt_string& name, 
+                    const Variable::VariableVector& vector, int variables, ...);
+  static bool copy (cmt_string& out, const cmt_string& name, 
+                    const Variable::VariableVector& vector, int variables, ...);
+
+  static FragmentVector& fragments ();
+
+public:
+  Fragment ();
+  Fragment (const cmt_string& fragment_name);
+  ~Fragment ();
+  void clear ();
+  int print ();
+  bool locate ();
+
+  bool copy (FILE* out, int variables, ...);
+  bool copy (cmt_string& out, int variables, ...);
+  bool copy (FILE* out, int variables, va_list ids);
+  bool copy (cmt_string& out, int variables, va_list ids);
+  bool wincopy (FILE* out, int variables, va_list ids);
+  bool wincopy (cmt_string& out, int variables, va_list ids);
+
+  bool copy (FILE* out, const Variable::VariableVector& vector, int variables, ...);
+  bool copy (cmt_string& out, const Variable::VariableVector& vector, int variables, ...);
+  bool copy (FILE* out, const Variable::VariableVector& vector, int variables, va_list ids);
+  bool copy (cmt_string& out, const Variable::VariableVector& vector, int variables, va_list ids);
+  bool wincopy (FILE* out, const Variable::VariableVector& vector, int variables, va_list ids);
+  bool wincopy (cmt_string& out, const Variable::VariableVector& vector, int variables, va_list ids);
+
+  cmt_string name;
+  cmt_string suffix;
+  cmt_string header;
+  cmt_string trailer;
+  bool need_dependencies;
+  cmt_string path;
+  UseRef use;
+};
+
+class FragmentHandle
+{
+public:
+  FragmentHandle ();
+  FragmentHandle (const cmt_string name);
+
+  FragmentHandle& operator = (const FragmentHandle& other);
+  void reset ();
+  void set (const cmt_string name);
+  cmt_string& name ();
+  cmt_string& suffix ();
+  cmt_string& header ();
+  cmt_string& trailer ();
+  bool need_dependencies ();
+
+  bool copy (FILE* out, int variables, ...);
+  bool copy (cmt_string& out, int variables, ...);
+  bool wincopy (FILE* out, int variables, ...);
+  bool wincopy (cmt_string& out, int variables, ...);
+
+  bool copy (FILE* out, const Variable::VariableVector& vector, int variables, ...);
+  bool copy (cmt_string& out, const Variable::VariableVector& vector, int variables, ...);
+  bool wincopy (FILE* out, const Variable::VariableVector& vector, int variables, ...);
+  bool wincopy (cmt_string& out, const Variable::VariableVector& vector, int variables, ...);
+
+private:
+  bool setup ();
+
+  Fragment* _fragment;
+  cmt_string _name;
+  bool _initialized;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_generator.cxx
===================================================================
--- /CMT/v1r20/source/cmt_generator.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_generator.cxx	(revision 368)
@@ -0,0 +1,867 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <errno.h>
+#include <stdio.h>
+
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
+#include "cmt_generator.h"
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+
+#include "cmt_generators.h"
+
+//------------------------------------------------------------------------
+void SourceFile::set (const cmt_string name, Language& language, const cmt_string output)
+{
+  m_name = name;
+  m_language = &language;
+  m_output = output;
+  
+  CmtSystem::reduce_file_separators (m_name);
+}
+
+cmt_string SourceFile::name () const
+{
+  return (m_name);
+}
+
+Language& SourceFile::language () const
+{
+  return (*m_language);
+}
+
+cmt_string SourceFile::output () const
+{
+  return (m_output);
+}
+//------------------------------------------------------------------------
+
+//--------------------------------------------------
+CmtGenerator::CmtGenerator ()
+{
+  m_CONSTITUENT.set ("CONSTITUENT");
+  m_LINKMACRO.set ("LINKMACRO");
+  m_DOCPATH.set ("DOCPATH");
+  m_PACKAGEPATH.set ("PACKAGEPATH");
+  m_PACKAGEPREFIX.set ("PACKAGEPREFIX");
+  m_PACKAGE.set ("PACKAGE");
+  m_VERSION.set ("VERSION");
+  m_MGRSTYLE.set ("MGRSTYLE");
+  m_TITLE.set ("TITLE");
+  m_GROUP.set ("GROUP");
+  m_CONSTITUENT.set ("CONSTITUENT");
+  m_CONSTITUENTSUFFIX.set ("CONSTITUENTSUFFIX");
+  m_LIBRARYSUFFIX.set ("LIBRARYSUFFIX");
+  m_USER.set ("USER");
+  m_DATE.set ("DATE");
+  m_PROTOTARGET.set ("PROTOTARGET");
+  m_OBJS.set ("OBJS");
+  m_CLASSES.set ("CLASSES");
+  m_PROTOSTAMPS.set ("PROTOSTAMPS");
+  m_NAME.set ("NAME");
+  m_FILEPATH.set ("FILEPATH");
+  m_FILESUFFIX.set ("FILESUFFIX");
+  m_SUFFIX.set ("SUFFIX");
+  m_FILENAME.set ("FILENAME");
+  m_LINKMACRO.set ("LINKMACRO");
+  m_LINE.set ("LINE");
+  m_ADDINCLUDE.set ("ADDINCLUDE");
+  m_FULLNAME.set ("FULLNAME");
+  m_DIRNAME.set ("DIRNAME");
+  m_OUTPUTNAME.set ("OUTPUTNAME");
+  m_ALLOS9SOURCES.set ("ALLOS9SOURCES");
+  m_NODEBUGUSELINKOPTS.set ("NODEBUGUSELINKOPTS");
+  m_DEBUGUSELINKOPTS.set ("DEBUGUSELINKOPTS");
+  m_USEINCLUDES.set ("USEINCLUDES");
+  m_HASTARGETTAG.set ("HASTARGETTAG");
+}
+
+//--------------------------------------------------
+void CmtGenerator::reset ()
+{
+  m_CONSTITUENT = "";
+  m_LINKMACRO = "";
+  m_DOCPATH = "";
+  m_PACKAGEPATH = "";
+  m_PACKAGEPREFIX = "";
+  m_PACKAGE = "";
+  m_VERSION = "";
+  m_MGRSTYLE = "";
+  m_TITLE = "";
+  m_GROUP = "";
+  m_CONSTITUENTSUFFIX = "";
+  m_LIBRARYSUFFIX = "";
+  m_USER = "";
+  m_DATE = "";
+  m_PROTOTARGET = "";
+  m_OBJS = "";
+  m_CLASSES = "";
+  m_PROTOSTAMPS = "";
+  m_NAME = "";
+  m_FILEPATH = "";
+  m_FILESUFFIX = "";
+  m_SUFFIX = "";
+  m_FILENAME = "";
+  m_LINE = "";
+  m_ADDINCLUDE = "";
+  m_FULLNAME = "";
+  m_OUTPUTNAME = "";
+  m_ALLOS9SOURCES = "";
+  m_NODEBUGUSELINKOPTS = "";
+  m_DEBUGUSELINKOPTS = "";
+  m_USEINCLUDES = "";
+  m_HASTARGETTAG = "";
+  m_PACKINCLUDES = "";
+  m_PACKOS9      = false;
+  m_GENERATOR    = "";
+
+  is_library     = false;
+  is_application = false;
+  srcdir       = "";
+  docdir       = "";
+  cmtdir       = "";
+  incdir       = "";
+  src          = "$(src)";
+  doc          = "$(doc)";
+  inc          = "$(inc)";
+  mgr          = "$(mgr)";
+  cmt          = "$(cmt)";
+  protos       = "";
+  protonames   = "";
+  os9sources   = "";
+
+  m_source_files.clear ();
+
+  Language::setup_all_fragments ();
+
+  CmtSystem::cd (Cmt::get_current_dir ());
+
+  cmt_string branch = CmtSystem::current_branch ();
+
+  if ((branch == "mgr") || (branch == "cmt"))
+    {
+      if (CmtSystem::test_directory ("../src"))
+        {
+          srcdir = "..";
+	  srcdir += CmtSystem::file_separator ();
+          srcdir += "src";
+	  srcdir += CmtSystem::file_separator ();
+        }
+      else
+        {
+          srcdir = "";
+        }
+
+      if (CmtSystem::test_directory ("../doc"))
+        {
+          docdir = "..";
+	  docdir += CmtSystem::file_separator ();
+          docdir += "doc";
+	  docdir += CmtSystem::file_separator ();
+        }
+      else
+        {
+          docdir = "";
+        }
+
+      if (CmtSystem::test_directory ("../cmt"))
+        {
+          cmtdir = "..";
+	  cmtdir += CmtSystem::file_separator ();
+          cmtdir += "cmt";
+	  cmtdir += CmtSystem::file_separator ();
+        }
+      else if (CmtSystem::test_directory ("../mgr"))
+        {
+          cmtdir = "..";
+	  cmtdir += CmtSystem::file_separator ();
+          cmtdir += "mgr";
+	  cmtdir += CmtSystem::file_separator ();
+        }
+      else
+        {
+          cmtdir = CmtSystem::pwd ();
+          cmtdir += CmtSystem::file_separator ();
+        }
+
+      if (CmtSystem::test_directory ("../src"))
+        {
+          incdir = "..";
+	  incdir += CmtSystem::file_separator ();
+          incdir += "src";
+	  incdir += CmtSystem::file_separator ();
+        }
+      else
+        {
+          incdir = "";
+        }
+    }
+  else
+    {
+      srcdir = ".";
+      srcdir += CmtSystem::file_separator ();
+      docdir = ".";
+      docdir += CmtSystem::file_separator ();
+      cmtdir = CmtSystem::pwd ();
+      cmtdir += CmtSystem::file_separator ();
+      incdir = ".";
+      incdir += CmtSystem::file_separator ();
+    }
+}
+
+//--------------------------------------------------
+bool CmtGenerator::prepare_output (const cmt_string& package,
+                                   const Constituent& constituent)
+{
+  m_PACKAGE = package;
+  m_CONSTITUENT = constituent.name;
+  m_CONSTITUENTSUFFIX = constituent.suffix;
+
+  m_PACKOS9 = constituent.need_OS9;
+
+  m_output_file_name = cmtdir + m_CONSTITUENT + ".";
+
+  if (Cmt::build_nmake ())
+    {
+      m_output_file_name += "nmake";
+    }
+  else
+    {
+      m_output_file_name += "make";
+    }
+  
+  m_output_file_name += "new";
+
+
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+  if (m_output_file != NULL)
+    {
+      return (true);
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+void CmtGenerator::check (const cmt_string& name)
+{
+  static cmt_string old;
+  static cmt_string backup;
+
+  old = name;
+
+  int pos = old.find_last_of ("new");
+  old.erase (pos);
+
+  if (!CmtSystem::compare_files (old, name))
+    {
+      backup = old;
+      backup += "sav";
+
+      unlink (backup.c_str ());
+      rename (old.c_str (), backup.c_str ());
+      rename (name.c_str (), old.c_str ());
+    }
+  else
+    {
+      unlink (name);
+    }
+}
+
+//--------------------------------------------------
+void CmtGenerator::commit (const cmt_string& name)
+{
+  static cmt_string old;
+  static cmt_string backup;
+
+  old = name;
+
+  int pos = old.find_last_of ("new");
+  old.erase (pos);
+
+  if (CmtSystem::test_file (old))
+    {
+      backup = old;
+      backup += "sav";
+
+      unlink (backup.c_str ());
+      rename (old.c_str (), backup.c_str ());
+    }
+
+  rename (name.c_str (), old.c_str ());
+}
+
+//--------------------------------------------------
+void CmtGenerator::terminate ()
+{
+  fclose (m_output_file);
+
+    //--- Complete the operation --------------
+
+  commit (m_output_file_name);
+}
+
+//--------------------------------------------------
+void CmtGenerator::fill_outputs ()
+{
+  bool first = true;
+
+  m_OBJS = "";
+
+  for (int i = 0; i < m_source_files.size (); i++)
+    {
+      const SourceFile& file = m_source_files[i];
+      const cmt_string output = file.output ();
+
+      if (output != "")
+        {
+          if (first)
+            {
+              first = false;
+            }
+          else
+            {
+              m_OBJS += " ";
+            }
+
+          m_OBJS += output;
+        }
+
+      if (Cmt::get_debug ())
+        {
+          cout << "CmtGenerator::fill_outputs> output=" << output << " OBJS=" << m_OBJS << endl;
+        }
+
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "CmtGenerator::fill_outputs> OBJS=" << m_OBJS << endl;
+    }
+
+}
+
+//--------------------------------------------------
+void CmtGenerator::prepare_use_context ()
+{
+  cmt_string path;
+  cmt_string substitution;
+
+  Use* use = &Use::current ();
+
+  m_deps_builder.clear ();
+
+  if (use->include_path != "none")
+    {
+      if (use->include_path == "")
+	{
+	  m_deps_builder.add (incdir, "$(src)");
+	}
+      else
+	{
+	  substitution = use->include_path;
+	  
+	  path = substitution;
+	  Symbol::expand (path);
+	  
+	  CmtSystem::reduce_file_separators (path);
+
+          m_deps_builder.add (path, substitution);
+	}
+    }
+
+  m_deps_builder.add_includes (*use);
+
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  if (uses.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < uses.size (); number++)
+        {
+          use = uses[number];
+          if (use->discarded) continue;
+
+          if (use->real_path != "")
+            {
+	      if (use->include_path != "none")
+		{
+		  if (use->include_path == "")
+		    {
+		      use->get_full_path (path);
+                      path += CmtSystem::file_separator ();
+		      path += "src";
+
+		      substitution = "$(";
+		      substitution += use->prefix;
+		      substitution += "ROOT)";
+		      substitution += CmtSystem::file_separator ();
+		      substitution += "src";
+		      substitution += CmtSystem::file_separator ();
+		    }
+		  else
+		    {
+		      substitution = use->include_path;
+
+		      path = substitution;
+		      Symbol::expand (path);
+
+                      CmtSystem::reduce_file_separators (path);
+		    }
+
+		  m_deps_builder.add (path, substitution);
+		}
+
+              m_deps_builder.add_includes (*use);
+            }
+        }
+    }
+}
+
+//--------------------------------------------------
+void CmtGenerator::filter_path (cmt_string& text)
+{
+  CmtSystem::compress_path (text);
+
+  text.replace_all ("./../src/../", "../");
+  text.replace_all ("./../src/", "$(src)");
+
+  text.replace_all (".\\..\\src\\..\\", "..\\");
+  text.replace_all (".\\..\\src\\", "$(src)");
+
+  text.replace_all ("../src/../", "../");
+  text.replace_all ("../src/", "$(src)");
+
+  text.replace_all ("..\\src\\..\\", "..\\");
+  text.replace_all ("..\\src\\", "$(src)");
+
+  text.replace_all ("../doc/../", "../");
+  text.replace_all ("../doc/", "$(doc)");
+
+  text.replace_all ("..\\doc\\..\\", "..\\");
+  text.replace_all ("..\\doc\\", "$(doc)");
+
+  text.replace_all ("$(src)$(src)", "$(src)");
+}
+
+/**
+   Scan a complete file spec (with possibly wild cards and directory)
+   given in full_name ad fill in a vector of found file names.
+
+   Result of the scan is filtered against matching suffixes
+
+   Returns the count of non empty file names really found.
+
+*/
+int CmtGenerator::get_all_files (const cmt_string& full_name,
+				 const cmt_vector<cmt_regexp>& exclude_exprs,
+				 const cmt_vector<cmt_regexp>& select_exprs,
+				 CmtSystem::cmt_string_vector& files)
+{
+  static cmt_string suffix;
+  static cmt_string name;
+
+  bool has_excludes = false;
+  bool has_selects = false;
+
+  suffix = "";
+  name = "";
+
+  files.clear ();
+
+  has_excludes = (exclude_exprs.size () > 0);
+  has_selects = (select_exprs.size () > 0);
+
+  CmtSystem::get_dot_suffix (full_name, suffix);
+
+  bool wilcarded_suffix = false;
+
+  if (suffix == ".*") wilcarded_suffix = true;
+
+  int count = 0;
+
+  if (full_name.find ('*') != cmt_string::npos)
+    {
+      CmtSystem::scan_dir (full_name, files);
+
+      if (Cmt::get_debug ())
+        {
+          cout << "CMT::get_all_files> full_name=" << full_name <<
+	    " pwd=" << CmtSystem::pwd () << endl;
+          cout << "CMT::get_all_files> files.size=" <<  files.size () << endl;
+        }
+
+        /**
+
+           We have to treat patterns of the form *.xxx (ie with a
+           suffix) thus we filter out everything that could have been
+           collected with a different suffix because the
+           CmtSystem::scan_dir function only handles patterns of the
+           form xxx* (ie with trailing *)
+
+           [If the original suffix was empty (ie files specified using
+           xx*) this means getting files without any dot-suffix. This
+           may be incorrect??]
+
+        */
+
+      for (int j = 0; j < files.size (); j++)
+        {
+          cmt_string& n = files[j];
+
+	  bool rejected = false;
+
+          if (n == "")
+            {
+	      rejected = true;
+	    }
+
+	  if (!rejected && has_selects)
+	    {
+	      rejected = true;
+
+	      for (int k = 0; k < select_exprs.size (); k++)
+		{
+		  const cmt_regexp& exp = select_exprs[k];
+		  if (exp.match (n))
+		    {
+		      rejected = false;
+		      break;
+		    }
+		}
+	    }
+
+	  if (!rejected && has_excludes)
+	    {
+	      for (int k = 0; k < exclude_exprs.size (); k++)
+		{
+		  const cmt_regexp& exp = exclude_exprs[k];
+		  if (exp.match (n))
+		    {
+		      rejected = true;
+		      break;
+		    }
+		}
+	    }
+
+	  if (!rejected)
+	    {
+              static cmt_string s;
+
+              CmtSystem::get_dot_suffix (n, s);
+              if (!wilcarded_suffix && (s != suffix)) 
+                {
+		  rejected = true;
+                }
+              else
+                {
+                  count++;
+                }
+            }
+
+	  if (Cmt::get_debug ())
+	    {
+	      if (rejected)
+		{
+		  cout << "CMT::get_all_files> reject " <<  n << endl;
+		}
+	      else
+		{
+		  cout << "CMT::get_all_files> keep " <<  n << endl;
+		}
+	    }
+
+	  if (rejected)
+	    {
+	      n = "";
+	    }
+        }
+    }
+  else
+    {
+      if (full_name != "")
+        {
+	  bool rejected = false;
+
+	  if (has_excludes)
+	    {
+	      for (int k = 0; k < exclude_exprs.size (); k++)
+		{
+		  const cmt_regexp& exp = exclude_exprs[k];
+		  if (exp.match (full_name))
+		    {
+		      rejected = true;
+		      break;
+		    }
+		}
+	    }
+
+	  if (!rejected)
+	    {
+	      cmt_string& n = files.add ();
+
+	      n = full_name;
+
+	      count++;
+	    }
+        }
+    }
+
+  return (count);
+}
+
+//--------------------------------------------------
+void CmtGenerator::set_full_name (cmt_string& full_name, cmt_string& file)
+{
+  full_name = "";
+
+  Symbol::expand (file);
+
+  if (file == "") return;
+  
+  if (!CmtSystem::absolute_path (file))
+    {
+      full_name = srcdir;
+      if (full_name != "") full_name += CmtSystem::file_separator ();
+    }
+  
+  full_name += file;
+
+  CmtSystem::reduce_file_separators (full_name);
+}
+
+//------------------------------------------------------------------------
+static ApplicationGenerator ApplicationContext;
+static LibraryGenerator LibraryContext;
+static DocumentGenerator DocumentContext;
+static ReadmeGenerator ReadmeContext;
+static PrototypeGenerator PrototypeContext;
+static DefaultMakefileGenerator DefaultMakefileContext;
+static MSDEVGenerator MSDEVContext;
+static VSNETGenerator VSNETContext;
+static MakeSetupGenerator MakeSetupContext;
+static ConstituentsMakefileGenerator ConstituentsMakefileContext;
+static DependencyGenerator DependencyContext;
+
+//--------------------------------------------------
+int Generator::build_msdev_workspace (const Constituent::ConstituentVector& constituents)
+{
+  return (MSDEVContext.build_workspace (constituents));
+}
+
+//--------------------------------------------------
+int Generator::build_msdev (const Constituent& constituent)
+{
+  return (MSDEVContext.build_project (constituent));
+}
+
+//--------------------------------------------------
+int Generator::build_vsnet_workspace (const Constituent::ConstituentVector& constituents)
+{
+  return (VSNETContext.build_workspace (constituents));
+}
+
+//--------------------------------------------------   
+int Generator::build_vsnet (const Constituent& constituent)
+{
+  return (VSNETContext.build_project (constituent));
+}
+
+//--------------------------------------------------
+void Generator::build_make_setup (const cmt_string& package)
+{
+  MakeSetupContext.build (package);
+}
+
+//--------------------------------------------------
+void Generator::build_constituents_makefile (const cmt_string& package,
+					     const CmtSystem::cmt_string_vector& arguments)
+{
+  ConstituentsMakefileContext.build (package, arguments);
+}
+
+//--------------------------------------------------
+int Generator::build_constituent_makefile (const Constituent& constituent)
+{
+  const cmt_string& package = Cmt::get_current_package ();
+
+  switch (constituent.type)
+    {
+    case Application:
+      ApplicationContext.build (package, constituent);
+      break;
+    case Library:
+      LibraryContext.build (package, constituent);
+      break;
+    case Document:
+      DocumentContext.build (package, constituent);
+      break;
+    }
+
+  return (0);
+}
+
+//--------------------------------------------------
+void Generator::build_constituent_makefile (const cmt_string& name)
+{
+  const Constituent* constituent = Constituent::find (name);
+  if (constituent != 0) build_constituent_makefile (*constituent);
+}
+
+//--------------------------------------------------
+void Generator::build_default_makefile ()
+{
+  DefaultMakefileContext.build ();
+}
+
+//--------------------------------------------------
+void Generator::build_dependencies (const CmtSystem::cmt_string_vector& arguments)
+{
+  DependencyContext.build (arguments);
+}
+
+//--------------------------------------------------
+void Generator::build_prototype (const cmt_string& file_name)
+{
+  PrototypeContext.build (file_name);
+}
+
+//--------------------------------------------------
+void Generator::build_readme (const CmtSystem::cmt_string_vector& arguments)
+{
+  ReadmeContext.build (arguments);
+}
+
+class WinDefAwk : public PAwk
+{
+public :
+   WinDefAwk (const cmt_string& library_name)
+    {
+      m_name = library_name;
+    }
+
+  void begin ()
+    {
+      cout << "LIBRARY " << m_name << endl;
+      cout << "EXPORTS" << endl;
+    }
+
+  void filter (const cmt_string& line)
+    {
+      if (line.find ("External") == cmt_string::npos) return;
+      if (line.find ("??_") != cmt_string::npos)
+	{
+	  if (line.find ("operator/=") == cmt_string::npos) return;
+	  // Keep operator /= .
+	}
+
+      CmtSystem::cmt_string_vector words;
+      CmtSystem::split (line, " \t", words);
+      if (words.size () >= 7)
+        {
+          int pos = 7;
+
+          cmt_string& fifth_word = words[4];
+          if (fifth_word == "()") pos = 7;
+          else if (fifth_word == "External") pos = 6;
+          else return;
+
+          cmt_string& symbol = words[pos];
+          if (symbol[0] == '_') symbol.erase (0, 1);
+          symbol.replace_all ("\r", "");
+          symbol.replace_all ("\n", "");
+
+          if ((pos == 6) && 
+              ((line.find(": static") != cmt_string::npos) ||
+               (line.find("(class") != cmt_string::npos)) )
+	    {
+	      // static data members are not DATA :
+	      // extern objects are not DATA :
+	      cout << " " << symbol << " " << endl;
+	    } 
+	  else if (pos == 6)
+	    {
+	      // DATA :
+	      cout << " " << symbol << "\tDATA" << endl;
+	    } 
+	  else
+	    {
+	      // code :
+	      cout << " " << symbol << " " << endl;
+	    } 
+        }
+    }
+
+  void end ()
+    {
+    }
+
+private:
+  cmt_string m_name;
+};
+
+//--------------------------------------------------
+void Generator::build_windefs (const cmt_string& library_name)
+{
+  cmt_string bin;
+  cmt_string name;
+  cmt_string suffix;
+
+  CmtSystem::dirname (library_name, bin);
+  CmtSystem::get_dot_suffix (library_name, suffix);
+  CmtSystem::basename (library_name, suffix, name);
+  
+  if (!CmtSystem::cd (bin)) return;
+  
+  cmt_string text;
+  cmt_string command;
+  
+  command = "dumpbin /symbols ";
+  command += library_name;
+	
+  WinDefAwk filter (name);
+  
+  filter.run (command, "SECT");
+}
+
+//--------------------------------------------------
+void Packager::begin ()
+{
+  m_package_name = "";
+}
+
+void Packager::filter (const cmt_string& line)
+{
+  CmtSystem::cmt_string_vector words;
+
+  CmtSystem::split (line, " ", words);
+  if (words.size () > 1)
+    {
+      cmt_string& w = words[0];
+
+      if (w == "package")
+        {
+          m_package_name = words[1];
+
+	  int pos = m_package_name.find (";");
+          if (pos != cmt_string::npos) m_package_name.erase (pos);
+          m_package_name.replace_all (".", CmtSystem::file_separator ());
+        }
+    }
+}
+
+cmt_string& Packager::package_name ()
+{
+  return (m_package_name);
+}
+
Index: /CMT/v1r20/source/cmt_generator.h
===================================================================
--- /CMT/v1r20/source/cmt_generator.h	(revision 368)
+++ /CMT/v1r20/source/cmt_generator.h	(revision 368)
@@ -0,0 +1,180 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_generator_h__
+#define __cmt_generator_h__
+
+#include "cmt_parser.h"
+#include "cmt_constituent.h"
+#include "cmt_language.h"
+#include "cmt_awk.h"
+#include "cmt_deps_builder.h"
+
+class Packager : public FAwk
+{
+public:
+  void begin ();
+  void filter (const cmt_string& line);
+  cmt_string& package_name ();
+private:
+  cmt_string m_package_name;
+};
+
+class SourceFile
+{
+public:
+  void set (const cmt_string name, Language& language, const cmt_string output);
+  cmt_string name () const;
+  Language& language () const;
+  cmt_string output () const;
+
+private:
+  cmt_string m_name;
+  Language* m_language;
+  cmt_string m_output;
+};
+
+/**
+   Base class for all specific generators.
+   The Generator command driver will operate on specialized classes of CmtGenerator
+*/
+class CmtGenerator
+{
+public:
+
+  CmtGenerator ();
+
+  void reset ();
+  bool prepare_output (const cmt_string& package,
+                       const Constituent& constituent);
+  void commit (const cmt_string& name);
+  static void check (const cmt_string& name);
+  void terminate ();
+
+  void fill_outputs ();
+
+  void prepare_use_context ();
+
+  void set_full_name (cmt_string& full_name, cmt_string& file);
+  void filter_path (cmt_string& text);
+  int get_all_files (const cmt_string& full_name,
+		     const cmt_vector<cmt_regexp>& exclude_exprs, 
+		     const cmt_vector<cmt_regexp>& select_exprs, 
+		     CmtSystem::cmt_string_vector& files);
+
+
+public:
+  cmt_string m_PACKINCLUDES;
+  bool m_PACKOS9;
+
+  cmt_string m_GENERATOR;
+
+  bool is_library;
+  bool is_application;
+
+  cmt_string srcdir;
+  cmt_string docdir;
+  cmt_string cmtdir;
+  cmt_string incdir;
+  cmt_string src;
+  cmt_string doc;
+  cmt_string inc;
+  cmt_string mgr;
+  cmt_string cmt;
+  cmt_string protos;
+  cmt_string protonames;
+  cmt_string os9sources;
+
+  cmt_vector<SourceFile> m_source_files;
+
+  cmt_string m_bin;
+  cmt_string m_output_file_name;
+  FILE* m_output_file;
+
+  DepsBuilder m_deps_builder;
+
+  Constituent* m_constituent;
+
+  Variable m_CONSTITUENT;
+  Variable m_LINKMACRO;
+  Variable m_DOCPATH;
+  Variable m_PACKAGEPATH;
+  Variable m_PACKAGEPREFIX;
+  Variable m_PACKAGE;
+  Variable m_VERSION;
+  Variable m_MGRSTYLE;
+  Variable m_TITLE;
+  Variable m_GROUP;
+  Variable m_CONSTITUENTSUFFIX;
+  Variable m_LIBRARYSUFFIX;
+  Variable m_USER;
+  Variable m_DATE;
+  Variable m_PROTOTARGET;
+  Variable m_OBJS;
+  Variable m_CLASSES;
+  Variable m_PROTOSTAMPS;
+  Variable m_NAME;
+  Variable m_FILEPATH;
+  Variable m_FILESUFFIX;
+  Variable m_SUFFIX;
+  Variable m_FILENAME;
+  Variable m_LINE;
+  Variable m_ADDINCLUDE;
+  Variable m_FULLNAME;
+  Variable m_DIRNAME;
+  Variable m_OUTPUTNAME;
+  Variable m_ALLOS9SOURCES;
+  Variable m_NODEBUGUSELINKOPTS;
+  Variable m_DEBUGUSELINKOPTS;
+  Variable m_USEINCLUDES;
+  Variable m_HASTARGETTAG;
+};
+
+/**
+   Generic command interface to be used by the cmt command driver.
+ */
+class Generator
+{
+public:
+    // Build the MSDEV workspace file
+  static int build_msdev_workspace (const Constituent::ConstituentVector& constituents);
+
+    // Build the MSDEV project file (one per constituent)
+  static int build_msdev (const Constituent& constituent);
+
+    // Build the VSNET workspace file
+  static int build_vsnet_workspace (const Constituent::ConstituentVector& constituents);
+
+    // Build the VSNET project file (one per constituent)
+  static int build_vsnet (const Constituent& constituent);
+
+     // Build the Make setup file
+  static void build_make_setup (const cmt_string& package);
+
+    // Build the constituents.make file
+  static void build_constituents_makefile (const cmt_string& package,
+					   const CmtSystem::cmt_string_vector& arguments);
+
+    // Build the makefile fragment for one constituent
+  static int build_constituent_makefile (const Constituent& constituent);
+  static void build_constituent_makefile (const cmt_string& name);
+
+  static void build_default_makefile ();
+
+    // Build the dependencies for one module
+  static void build_dependencies (const CmtSystem::cmt_string_vector& arguments);
+
+    // Build prototype file for one module
+  static void build_prototype (const cmt_string& file_name);
+
+    // Build README.html file
+  static void build_readme (const CmtSystem::cmt_string_vector& arguments);
+
+    // Build def files for Windows shared libraries
+  static void build_windefs (const cmt_string& library_name);
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_generators.cxx
===================================================================
--- /CMT/v1r20/source/cmt_generators.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_generators.cxx	(revision 368)
@@ -0,0 +1,3010 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_generators.h"
+#include "cmt_awk.h"
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+#include "cmt_log.h"
+
+//--------------------------------------------------
+AnyDocumentGenerator::AnyDocumentGenerator ()
+{
+  m_TITLE.set ("TITLE");
+  m_STRUCTURED_OUTPUT.set ("STRUCTURED_OUTPUT");
+
+  make_header_fragment.set ("make_header");
+  cleanup_header_fragment.set ("cleanup_header");
+  cleanup_fragment.set ("cleanup");
+  dependencies_fragment.set ("dependencies");
+  dependencies_and_triggers_fragment.set ("dependencies_and_triggers");
+}
+
+void AnyDocumentGenerator::reset ()
+{
+  CmtGenerator::reset ();
+  m_TITLE = "";
+
+  make_header_fragment.reset ();
+  cleanup_header_fragment.reset ();
+  cleanup_fragment.reset ();
+  dependencies_fragment.reset ();
+  dependencies_and_triggers_fragment.reset ();
+}
+
+//--------------------------------------------------
+LibraryGenerator::LibraryGenerator ()
+{
+  library_header_fragment.set ("library_header");
+  application_header_fragment.set ("application_header");
+  java_header_fragment.set ("java_header");
+  jar_header_fragment.set ("jar_header");
+  protos_header_fragment.set ("protos_header");
+  library_fragment.set ("library");
+  library_no_share_fragment.set ("library_no_share");
+  application_fragment.set ("application");
+  jar_fragment.set ("jar");
+  java_fragment.set ("java");
+  java_copy_fragment.set ("java_copy");
+  cleanup_library_fragment.set ("cleanup_library");
+  cleanup_application_fragment.set ("cleanup_application");
+  cleanup_java_fragment.set ("cleanup_java");
+  cleanup_objects_fragment.set ("cleanup_objects");
+  buildproto_fragment.set ("buildproto");
+  check_application_fragment.set ("check_application");
+  check_java_fragment.set ("check_java");
+}
+
+//--------------------------------------------------
+void LibraryGenerator::reset ()
+{
+  AnyDocumentGenerator::reset ();
+  library_header_fragment.reset ();
+  application_header_fragment.reset ();
+  java_header_fragment.reset ();
+  jar_header_fragment.reset ();
+  protos_header_fragment.reset ();
+  library_fragment.reset ();
+  library_no_share_fragment.reset ();
+  jar_fragment.reset ();
+  application_fragment.reset ();
+  java_fragment.reset ();
+  java_copy_fragment.reset ();
+  cleanup_library_fragment.reset ();
+  cleanup_application_fragment.reset ();
+  cleanup_java_fragment.reset ();
+  cleanup_objects_fragment.reset ();
+  buildproto_fragment.reset ();
+  check_application_fragment.reset ();
+  check_java_fragment.reset ();
+}
+
+//--------------------------------------------------
+bool LibraryGenerator::analyze_file (const Constituent& constituent,
+				     const cmt_string& file)
+{
+  static cmt_string suffix;
+  static cmt_string name;
+  static cmt_string obj;
+
+  bool file_not_found = false;
+  bool can_build = true;
+
+  obj = file;
+
+  if (Cmt::get_debug ())
+    {
+      cout << "CmtGenerator::analyze_file> constituent=" << 
+          constituent.name <<
+          " file=" << file << endl;
+    }
+
+  if (!CmtSystem::test_file (file) && !CmtSystem::test_directory (file))
+    {
+      file_not_found = true;
+      cerr << "#CMT> Warning: Source file " << file << " not found" << endl;
+    }
+
+  CmtSystem::get_suffix (file, suffix);
+  CmtSystem::basename (file, suffix, name);
+
+  Language& language = Language::find_with_suffix (suffix);
+
+  if (m_LINKMACRO == "")
+    {
+      m_LINKMACRO = language.linker;
+    }
+
+  if (language == "java")
+    {
+      static Packager packager;
+      
+      obj  = "$(javabin)";
+      obj +=  m_CONSTITUENT;
+      obj +=  CmtSystem::file_separator ();
+
+      cmt_regexp exp ("^package[ \t][ \t]*[a-zA-Z0-9_.][a-zA-Z0-9_.][ \t]*;");
+      
+      packager.run (file, exp);
+      if (packager.package_name () != "")
+        {
+          obj += packager.package_name ();
+          obj += CmtSystem::file_separator ();
+        }
+      
+      obj += name;
+      obj += ".class";
+    }
+  else if (language != Language::null ())
+    {
+      obj  = "$(bin)";      
+
+      if (CmtSystem::getenv("STRUCTURED_OUTPUT")!="" || Cmt::build_nmake ())
+      {
+          obj +=  m_CONSTITUENT;
+          obj +=  CmtSystem::file_separator ();
+      }
+
+      obj += name;
+      obj += language.output_suffix;
+      obj += constituent.suffix;
+      if (Cmt::build_nmake ()) obj += ".obj";
+      else obj += ".o";
+ 
+      for (int i = 0; i < language.extra_output_suffixes.size (); i++)
+        {
+          cmt_string& extra_suffix = language.extra_output_suffixes[i];
+
+          obj += " $(bin)";
+          obj += name;
+          obj += extra_suffix;
+          obj += language.output_suffix;
+          obj += constituent.suffix;
+          if (Cmt::build_nmake ()) obj += ".obj";
+          else obj += ".o";
+        }
+    }
+  else
+    {
+        //cout << "#CMT> analyze_file file=" << file << " no language" << endl;
+
+      if (m_LINKMACRO == "java")
+        {
+          obj  = "$(javabin)";
+          obj +=  m_CONSTITUENT;
+          obj +=  CmtSystem::file_separator ();
+          obj += file;
+          
+          obj.replace ("../src/", "");
+          obj.replace ("..\\src\\", "");
+        }
+      else if (file_not_found)
+        {
+	  can_build = false;
+          obj  = "";
+	  cerr << "#CMT> Warning: Source file " << name << " cannot be rebuilt" << endl;
+        }
+      else
+        {
+          obj  = "";
+        }
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "CmtGenerator::analyze_file> constituent=" << 
+          constituent.name <<
+          " obj=" << obj << endl;
+    }
+
+  if (can_build)
+    {
+      SourceFile& source = m_source_files.add ();
+      source.set (file, language, obj);
+      return (true);
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+void LibraryGenerator::java_file_action (SourceFile& file, const Constituent& constituent)
+{
+  static cmt_string suffix;
+
+  m_FULLNAME = file.name ();
+  m_OUTPUTNAME = file.output ();
+
+  CmtSystem::get_dot_suffix (m_FULLNAME, suffix);
+  
+  CmtSystem::basename (m_FULLNAME, suffix, m_NAME.value);
+  CmtSystem::basename (m_FULLNAME, m_FILENAME.value);
+  
+  if (CmtSystem::test_file (m_FULLNAME))
+    {
+      java_fragment.copy (m_output_file, constituent.variables, 5,
+                          &m_NAME,
+                          &m_FULLNAME,
+                          &m_OUTPUTNAME,
+                          &m_CONSTITUENT, 
+                          &m_CONSTITUENTSUFFIX);
+    }
+  else
+    {
+      cerr << "#CMT> Warning: file " << m_FULLNAME << " not found" << endl;
+    }
+}
+
+//--------------------------------------------------
+void LibraryGenerator::proto_file_action (const cmt_string& file, const Constituent& constituent)
+{
+  static cmt_string suffix;
+
+  CmtSystem::dirname (file, m_FILEPATH.value);
+  if (m_FILEPATH.value != "") m_FILEPATH.value += CmtSystem::file_separator ();
+
+  filter_path (m_FILEPATH.value);
+
+  CmtSystem::basename (file, m_FILENAME.value);
+  CmtSystem::get_dot_suffix (m_FILENAME, suffix);
+
+  CmtSystem::basename (m_FILENAME, suffix, m_NAME.value);
+
+  buildproto_fragment.copy (m_output_file, constituent.variables, 3, 
+                            &m_NAME, 
+                            &m_FILEPATH, 
+                            &m_FILENAME);
+}
+
+//--------------------------------------------------
+void LibraryGenerator::prepare_proto_file (const cmt_string& file)
+{
+  static cmt_string name;
+  static cmt_string pp;
+
+  CmtSystem::name (file, name);
+
+  if (CmtSystem::test_file (file))
+    {
+      pp  = incdir;
+      pp += name;
+      pp += ".pp";
+
+      if (!CmtSystem::test_file (pp))
+        {
+	  //Generator::build_prototype (file);
+        }
+    }
+
+  protos += " ";
+  protos += inc;
+  protos += name;
+  protos += ".ph";
+
+  protonames += " ";
+  protonames += name;
+  protonames += ".ph";
+
+  m_PROTOSTAMPS += " ";
+  m_PROTOSTAMPS += inc;
+  m_PROTOSTAMPS += name;
+  m_PROTOSTAMPS += ".pp";
+}
+
+//--------------------------------------------------
+void LibraryGenerator::module_file_action (SourceFile& file, const Constituent& constituent)
+{
+  cmt_string name = file.name ();
+  Language& language = file.language ();
+
+  static cmt_string suffix;
+  static cmt_string prefix;
+  static cmt_string preproc;
+
+  m_FULLNAME = name;
+
+  CmtSystem::get_dot_suffix (name, suffix);
+
+  CmtSystem::basename (name, suffix, m_NAME.value);
+
+  CmtSystem::dirname (name, prefix);
+  CmtSystem::basename (name, m_FILENAME.value);
+
+  FragmentHandle* fragment;
+
+  if (language != Language::null ())
+    {
+      preproc = language.preprocessor_command;
+      fragment = (is_library) ? &(language.library) : &(language.application);
+    }
+  else
+    {
+      //
+      // What happens when the language is not known???
+      // 
+      //
+      preproc = "-I";
+      fragment = 0;
+    }
+
+  if ((prefix == "../src") || (prefix == "..\\src"))
+    {
+      m_ADDINCLUDE = "";
+    }
+  else if (prefix != "")
+    {
+      m_ADDINCLUDE  = preproc;
+      m_ADDINCLUDE += prefix;
+    }
+
+  m_FILEPATH = prefix;
+  if (m_FILEPATH.value != "") m_FILEPATH.value += CmtSystem::file_separator ();
+  filter_path (m_FILEPATH.value);
+
+  m_LINE = m_FULLNAME.value;
+  m_LINE += " ";
+
+  filter_path (m_FULLNAME.value);
+  filter_path (m_LINE.value);
+
+  CmtSystem::get_suffix (name, m_FILESUFFIX.value);
+
+  if (fragment != 0)
+    {
+      fragment->copy (m_output_file, constituent.variables, 10,
+                      &m_CONSTITUENT, 
+                      &m_CONSTITUENTSUFFIX, 
+                      &m_FILENAME, 
+                      &m_NAME, 
+                      &m_LINE,
+                      &m_ADDINCLUDE, 
+                      &m_FULLNAME, 
+                      &m_FILEPATH, 
+                      &m_FILESUFFIX, 
+                      &m_PACKAGE);
+    }
+  else if (file.output () != "")
+    {
+      m_OUTPUTNAME = file.output ();
+      CmtSystem::dirname (m_OUTPUTNAME.value, m_FILEPATH.value);
+
+      java_copy_fragment.copy (m_output_file, constituent.variables, 11,
+                               &m_CONSTITUENT, 
+                               &m_CONSTITUENTSUFFIX, 
+                               &m_FILENAME, 
+                               &m_NAME, 
+                               &m_LINE,
+                               &m_ADDINCLUDE, 
+                               &m_FULLNAME, 
+                               &m_FILEPATH, 
+                               &m_FILESUFFIX, 
+                               &m_PACKAGE, 
+                               &m_OUTPUTNAME);
+    }
+
+  if (m_PACKOS9)
+    {
+      os9sources += m_LINE;
+      os9sources += " ";
+    }
+}
+
+//--------------------------------------------------
+void LibraryGenerator::build (const cmt_string& package,
+                              const Constituent& constituent)
+{
+  static cmt_string lib;
+  static cmt_string allsources;
+  static cmt_string file;
+  static cmt_string full_name;
+  static cmt_string compressed_name;
+  static cmt_string suffix;
+  int i;
+  bool need_prototypes;
+
+  reset ();
+
+  if (!prepare_output (package, constituent)) return;
+
+  switch (constituent.type)
+    {
+    case Application:
+      is_library = false;
+      is_application = true;
+      m_TITLE = "Application";
+      break;
+    case Library:
+      is_library = true;
+      is_application = false;
+      m_TITLE = "Library";
+      break;
+    }
+
+  m_source_files.clear ();
+
+  need_prototypes = constituent.need_prototypes;
+
+  cout << m_TITLE << " " << m_CONSTITUENT << endl;
+
+  lib  = "$(";
+  lib += m_CONSTITUENT;
+  lib += "lib)";
+
+  //
+  // Prepare the include paths
+  //
+
+  const CmtSystem::cmt_string_vector& includes = constituent.includes;
+
+  for (i = 0; i < includes.size (); i++)
+    {
+      const cmt_string& subdir = includes[i];
+
+      m_PACKINCLUDES += " -I";
+      m_PACKINCLUDES += subdir;
+    }
+
+  //
+  // Scan the sources.
+  //
+
+  const CmtSystem::cmt_string_vector& sources = constituent.modules;
+  const cmt_vector<cmt_regexp>& excludes = constituent.exclude_exprs;
+  const cmt_vector<cmt_regexp>& selects = constituent.select_exprs;
+
+  m_LINE = "";
+
+  for (i = 0; i < sources.size (); i++)
+    {
+      file = sources[i];
+
+      set_full_name (full_name, file);
+      if (full_name == "") continue;
+
+      CmtSystem::compress_path (full_name, compressed_name);
+      full_name = compressed_name;
+
+      static CmtSystem::cmt_string_vector files;
+
+      int count = get_all_files (full_name, excludes, selects, files);
+
+      filter_path (full_name);
+
+      for (int j = 0; j < files.size (); j++)
+        {
+          const cmt_string& name = files[j];
+
+          if (name != "") 
+            {
+              if (!analyze_file (constituent, name)) 
+		{
+		  count = 0;
+		  break;
+		}
+            }
+        }
+
+      if (count > 0)
+        {
+          m_LINE += full_name;
+          m_LINE += " ";
+        }
+    }
+
+  fill_outputs ();
+
+  prepare_use_context ();
+
+  m_DATE = CmtSystem::now ();
+  m_USER = CmtSystem::user ();
+  m_PACKAGE = package;
+
+  if (constituent.has_target_tag)
+    {
+      m_HASTARGETTAG = "has_target_tag";
+    }
+  else
+    {
+      m_HASTARGETTAG = "has_no_target_tag";
+    }
+    
+  m_STRUCTURED_OUTPUT = "STRUCTURED_OUTPUT";
+
+  make_header_fragment.copy (m_output_file, constituent.variables, 8, 
+			                 &m_TITLE,
+                             &m_CONSTITUENT,
+                             &m_CONSTITUENTSUFFIX,
+			                 &m_USER,
+                             &m_DATE,
+                             &m_PACKAGE,
+			                 &m_HASTARGETTAG,
+			                 &m_STRUCTURED_OUTPUT
+			     );
+
+  if (need_prototypes)
+    {
+      need_prototypes = false;
+
+      for (i = 0; i < m_source_files.size (); i++)
+        {
+          const SourceFile& file = m_source_files[i];
+          Language& language = file.language ();
+          if (language.prototypes)
+            {
+              need_prototypes = true;
+              break;
+            }
+        }
+    }
+
+  //-------------------------------------------
+  //
+  // Specific targets (application, library or java)
+  // Prepare in case prototype files are needed
+  //
+  //-------------------------------------------
+
+  m_PROTOTARGET = "";
+
+  //if ((Cmt::current_build_strategy & PrototypesMask) == Prototypes)
+  if (need_prototypes)
+    {
+      m_PROTOTARGET = m_CONSTITUENT;
+      m_PROTOTARGET += "PROTOS";
+    }
+
+  if (m_LINKMACRO == "java")
+    {
+      if (is_library)
+        {
+          jar_header_fragment.copy (m_output_file, constituent.variables, 3, 
+				    &m_CONSTITUENT, 
+                                    &m_CONSTITUENTSUFFIX,
+                                    &m_OBJS);
+        }
+      else
+        {
+          java_header_fragment.copy (m_output_file, constituent.variables, 3, 
+				     &m_CONSTITUENT,
+                                     &m_CONSTITUENTSUFFIX,
+                                     &m_OBJS);
+        }
+    }
+  else
+    {
+      if (is_library)
+        {
+          library_header_fragment.copy (m_output_file, constituent.variables, 3,
+                                        &m_CONSTITUENT,
+                                        &m_CONSTITUENTSUFFIX,
+                                        &m_PROTOTARGET);
+        }
+      else
+        {
+          application_header_fragment.copy (m_output_file, constituent.variables, 3,
+                                            &m_CONSTITUENT, 
+                                            &m_CONSTITUENTSUFFIX, 
+					    &m_PROTOTARGET);
+        }
+    }
+
+
+  //----------------------------------------------------
+  //
+  // Preparing prototype files.
+  //
+  //----------------------------------------------------
+
+  //if ((Cmt::current_build_strategy & PrototypesMask) == Prototypes)
+  if (need_prototypes)
+    {
+      for (i = 0; i < m_source_files.size (); i++)
+        {
+          const SourceFile& file = m_source_files[i];
+          Language& language = file.language ();
+          if (language.prototypes)
+            {
+              prepare_proto_file (file.name ());
+            }
+        }
+
+      if (m_PROTOSTAMPS != "")
+        {
+          protos_header_fragment.copy (m_output_file, constituent.variables, 3, 
+				       &m_CONSTITUENT,
+                                       &m_CONSTITUENTSUFFIX,
+                                       &m_PROTOSTAMPS);
+        }
+
+      if (protonames != "")
+        {
+          for (i = 0; i < m_source_files.size (); i++)
+            {
+              const SourceFile& file = m_source_files[i];
+              Language& language = file.language ();
+              if (language.prototypes)
+                {
+                  proto_file_action (file.name (), constituent);
+                }
+            }
+        }
+    }
+
+  //----------------------------------------------------
+  //
+  // Preparing the library.
+  //
+  //----------------------------------------------------
+
+  if (m_OBJS != "")
+    {
+      if (m_LINKMACRO == "java")
+        {
+          if (is_library)
+            {
+	      cmt_string classes = m_OBJS.value;
+
+	      classes.replace_all ("$(javabin)", "");
+	      classes.replace_all (srcdir.c_str (), "");
+
+	      m_CLASSES = classes;
+
+              jar_fragment.copy (m_output_file, constituent.variables, 4, 
+				 &m_CONSTITUENT,
+                                 &m_CONSTITUENTSUFFIX,
+                                 &m_OBJS,
+                                 &m_CLASSES);
+            }
+        }
+      else
+        {
+          if (is_library)
+            {
+              if (constituent.no_share)
+                {
+                  library_no_share_fragment.copy (m_output_file, constituent.variables, 3, 
+						  &m_CONSTITUENT,
+                                                  &m_CONSTITUENTSUFFIX,
+                                                  &m_OBJS);
+                }
+              else
+                {
+                  library_fragment.copy (m_output_file, constituent.variables, 3, 
+					 &m_CONSTITUENT,
+                                         &m_CONSTITUENTSUFFIX,
+                                         &m_OBJS);
+                }
+            }
+          else
+            {
+              application_fragment.copy (m_output_file, constituent.variables, 4,
+                                         &m_CONSTITUENT,
+                                         &m_CONSTITUENTSUFFIX, 
+					 &m_OBJS,
+                                         &m_LINKMACRO);
+            }
+        }
+    }
+
+  if (constituent.build_triggers)
+    {
+      dependencies_and_triggers_fragment.copy (m_output_file, 
+                                               constituent.variables, 3,
+                                               &m_CONSTITUENT, 
+                                               &m_CONSTITUENTSUFFIX, 
+                                               &m_LINE);
+    }
+  else
+    {
+      dependencies_fragment.copy (m_output_file, 
+                                  constituent.variables, 3,
+                                  &m_CONSTITUENT, 
+                                  &m_CONSTITUENTSUFFIX, 
+                                  &m_LINE);
+    }
+
+  //----------------------------------------------------
+  //
+  // Building actual individual targets.
+  //
+  //----------------------------------------------------
+
+  for (i = 0; i < m_source_files.size (); i++)
+    {
+      SourceFile& file = m_source_files[i];
+      Language& language = file.language ();
+
+      if (language == "java")
+        {
+          java_file_action (file, constituent);
+        }
+      else
+        {
+          module_file_action (file, constituent);
+        }
+    }
+
+  if (m_PACKOS9)
+    {
+      if (os9sources != "")
+        {
+	  //
+	  // Generate transfers to the OS9 area.
+	  //
+
+          m_ALLOS9SOURCES = "";
+          allsources = "";
+        }
+    }
+
+  /*
+    for file in `cmt_sort_line.csh ${os9sources}` ; do
+    if test `echo ${file} | grep '$(src)'` ; then
+    name=`echo ${file} | sed 's#$(src)##'`
+    ALLOS9SOURCES="${ALLOS9SOURCES} ../OS9/${name}"
+    allsources="${allsources} ${file}"
+    elif test `echo ${file} | grep '$(inc)'` ; then
+    name=`echo ${file} | sed 's#$(inc)##'`
+    ALLOS9SOURCES="${ALLOS9SOURCES} ../OS9/${name}"
+    allsources="${allsources} ${file}"
+    fi
+    done
+
+    if test ! "${ALLOS9SOURCES}" = "" ; then
+
+    sed -e "`subs_vars ALLOS9SOURCES`" \
+    ${os9_header_fragment} \
+    >>${output}
+
+    for FULLNAME in ${allsources} ; do
+
+    NAME=`echo ${FULLNAME} | sed -e 's#$(src)##' -e 's#$(inc)##'`
+
+    sed -e "`subs_vars NAME FULLNAME`" \
+    ${os9_fragment} \
+    >>${output}
+
+    done
+    fi
+    fi
+    fi
+  */
+
+  //
+  //  Generate package cleanup operations.
+  //
+
+  cleanup_header_fragment.copy (m_output_file, constituent.variables, 2, 
+				&m_CONSTITUENT,
+                                &m_CONSTITUENTSUFFIX);
+
+  //if ((Cmt::current_build_strategy & PrototypesMask) == Prototypes)
+  if (need_prototypes)
+    {
+      if (protos != "")
+        {
+          m_FULLNAME = protos;
+          cleanup_fragment.copy (m_output_file, constituent.variables, 1, &m_FULLNAME);
+          m_FULLNAME = m_PROTOSTAMPS;
+          cleanup_fragment.copy (m_output_file, constituent.variables, 1, &m_FULLNAME);
+        }
+    }
+
+  if (m_LINKMACRO == "java")
+    {
+      cleanup_java_fragment.copy (m_output_file, constituent.variables, 1, &m_OBJS);
+
+      if (!is_library)
+	{
+          if (constituent.need_check)
+            {
+              check_java_fragment.copy (m_output_file, constituent.variables, 2, 
+					&m_CONSTITUENT,
+                                        &m_CONSTITUENTSUFFIX);
+            }
+	}
+    }
+  else
+    {
+      if (is_library)
+        {
+          cleanup_library_fragment.copy (m_output_file, constituent.variables, 2, 
+					 &m_CONSTITUENT,
+                                         &m_CONSTITUENTSUFFIX);
+        }
+      else
+        {
+          cleanup_application_fragment.copy (m_output_file, constituent.variables, 2, 
+					     &m_CONSTITUENT,
+                                             &m_CONSTITUENTSUFFIX);
+          if (m_OBJS != "")
+            {
+              cleanup_objects_fragment.copy (m_output_file, constituent.variables, 3, 
+					     &m_OBJS,
+                                             &m_CONSTITUENT,
+                                             &m_CONSTITUENTSUFFIX);
+            }
+
+          if (constituent.need_check)
+            {
+              check_application_fragment.copy (m_output_file, constituent.variables, 2, 
+					       &m_CONSTITUENT,
+                                               &m_CONSTITUENTSUFFIX);
+            }
+        }
+    }
+
+  terminate ();
+}
+
+//--------------------------------------------------
+DocumentGenerator::DocumentGenerator ()
+{
+  document_header_fragment.set ("document_header");
+}
+
+//--------------------------------------------------
+void DocumentGenerator::reset ()
+{
+  AnyDocumentGenerator::reset ();
+  document_header_fragment.reset ();
+}
+
+//--------------------------------------------------
+void DocumentGenerator::build (const cmt_string& package,
+                               const Constituent& constituent)
+{
+  static cmt_string names;
+  static cmt_string output_dir;
+  static cmt_string name;
+  static cmt_string full_name;
+  static cmt_string compressed_name;
+  static cmt_string suffix;
+  static cmt_string output_suffix;
+  static cmt_string fragment_suffix;
+
+  reset ();
+
+  if (!prepare_output (package, constituent)) return;
+
+  is_library = false;
+  is_application = false;
+  m_GENERATOR = constituent.generator;
+  m_TITLE = "Document";
+
+  int i;
+
+  cout << m_TITLE << " " << m_CONSTITUENT << endl;
+
+  //
+  // Prepare the include paths.
+  //
+
+  const CmtSystem::cmt_string_vector& includes = constituent.includes;
+
+  for (i = 0; i < includes.size (); i++)
+    {
+      const cmt_string& subdir = includes[i];
+
+      m_PACKINCLUDES += " -I";
+      m_PACKINCLUDES += subdir;
+    }
+
+  //
+  // Get the fragment associated with the document style
+  //
+
+  FragmentHandle fragment (m_GENERATOR);
+
+  fragment_suffix = fragment.suffix ();
+
+  output_suffix = ".";
+
+  if (fragment_suffix == "")
+    {
+      output_suffix += fragment.name ();
+    }
+  else
+    {
+      output_suffix += fragment_suffix;
+    }
+
+  //
+  // Scan the sources.
+  //
+
+  const CmtSystem::cmt_string_vector& sources = constituent.modules;
+  const cmt_vector<cmt_regexp>& excludes = constituent.exclude_exprs;
+  const cmt_vector<cmt_regexp>& selects = constituent.select_exprs;
+
+  m_LINE = "";
+
+  for (i = 0; i < sources.size (); i++)
+    {
+      cmt_string& file = sources[i];
+
+      set_full_name (full_name, file);
+      if (full_name == "") continue;
+
+      CmtSystem::compress_path (full_name, compressed_name);
+      full_name = compressed_name;
+
+      static CmtSystem::cmt_string_vector files;
+
+      int count = get_all_files (full_name, excludes, selects, files);
+
+      filter_path (full_name);
+
+      if (count > 0)
+        {
+          m_LINE += full_name;
+          m_LINE += " ";
+        }
+
+      for (int j = 0; j < files.size (); j++)
+        {
+          const cmt_string& name = files[j];
+
+          if (name != "") 
+            {
+              analyze_file (name, constituent.name, output_suffix);
+            }
+        }
+    }
+
+  fill_outputs ();
+
+  prepare_use_context ();
+
+  m_DATE = CmtSystem::now ();
+  m_USER = CmtSystem::user ();
+  m_PACKAGE = package;
+
+  if (constituent.has_target_tag)
+    {
+      m_HASTARGETTAG = "has_target_tag";
+    }
+  else
+    {
+      m_HASTARGETTAG = "has_no_target_tag";
+    }
+
+  make_header_fragment.copy (m_output_file, constituent.variables, 7,
+			     &m_TITLE, 
+                             &m_CONSTITUENT,
+                             &m_CONSTITUENTSUFFIX,
+			     &m_USER,
+                             &m_DATE,
+                             &m_PACKAGE,
+			     &m_HASTARGETTAG);
+
+  const cmt_string& header = fragment.header ();
+
+  //
+  // If the document type specifies a header, use it . 
+  // otherwise, use the default document header fragment.
+  //
+  if (header != "")
+    {
+      FragmentHandle header_fragment (header);
+      header_fragment.copy (m_output_file, constituent.variables, 3, 
+			    &m_CONSTITUENT,
+                            &m_CONSTITUENTSUFFIX,
+                            &m_OBJS);
+    }
+  else
+    {
+      document_header_fragment.copy (m_output_file, constituent.variables, 3, 
+				     &m_CONSTITUENT,
+                                     &m_CONSTITUENTSUFFIX,
+                                     &m_OBJS);
+    }
+
+  if (fragment.need_dependencies ())
+    {
+      dependencies_fragment.copy (m_output_file, constituent.variables, 3, 
+				  &m_CONSTITUENT,
+                                  &m_CONSTITUENTSUFFIX,
+                                  &m_LINE);
+    }
+  else
+    {
+      for (i = 0; i < sources.size (); i++)
+        {
+          cmt_string& file = sources[i];
+          
+          set_full_name (full_name, file);
+	  if (full_name == "") continue;
+          
+	  CmtSystem::compress_path (full_name, compressed_name);
+	  full_name = compressed_name;
+
+          static CmtSystem::cmt_string_vector files;
+          
+          get_all_files (full_name, excludes, selects, files);
+          
+          for (int j = 0; j < files.size (); j++)
+            {
+              const cmt_string& name = files[j];
+              
+              if (name != "") 
+                {
+                  static cmt_string s;
+                  static cmt_string n;
+                  
+                  CmtSystem::get_dot_suffix (name, s);
+                  CmtSystem::basename (name, s, n);
+                  CmtSystem::get_suffix (name, s);
+                  
+                  fprintf (m_output_file, "%s_%s_dependencies = %s\n",
+                           n.c_str (),
+                           s.c_str (),
+                           name.c_str ());
+                }
+            }
+        }
+    }
+  
+  m_SUFFIX = fragment_suffix;
+  for (i = 0; i < m_source_files.size (); i++)
+    {
+      SourceFile& file = m_source_files[i];
+      const cmt_string& file_name = file.name ();
+      m_FULLNAME = file_name;
+      CmtSystem::get_dot_suffix (file_name, suffix);
+      CmtSystem::basename (file_name, suffix, m_NAME.value);
+      CmtSystem::dirname (file_name, m_FILEPATH.value);
+      if (m_FILEPATH.value != "") m_FILEPATH.value += CmtSystem::file_separator ();
+      filter_path (m_FILEPATH.value);
+      CmtSystem::basename (file_name, m_FILENAME.value);
+      CmtSystem::get_dot_suffix (m_FILENAME.value, m_FILESUFFIX.value);
+
+      if (!CmtSystem::test_file (file_name) && !CmtSystem::test_directory (file_name))
+        {
+          cerr << "#CMT> Warning: Source file " << file_name << " not found" << endl;
+        }
+
+      filter_path (m_FULLNAME.value);
+
+      fragment.copy (m_output_file, constituent.variables, 8,
+                     &m_FILEPATH,
+                     &m_SUFFIX,
+                     &m_CONSTITUENT,
+                     &m_CONSTITUENTSUFFIX,
+                     &m_FILENAME,
+                     &m_NAME,
+                     &m_FULLNAME,
+                     &m_FILESUFFIX);
+    }
+
+  const cmt_string& trailer = fragment.trailer ();
+  if (trailer != "")
+    {
+      FragmentHandle trailer_fragment (trailer);
+      trailer_fragment.copy (m_output_file, constituent.variables, 3, 
+			     &m_CONSTITUENT,
+                             &m_CONSTITUENTSUFFIX,
+                             &m_OBJS);
+    }
+
+  //
+  //  Generate package cleanup operations.
+  //
+
+  cleanup_header_fragment.copy (m_output_file, constituent.variables, 2, 
+				&m_CONSTITUENT,
+                                &m_CONSTITUENTSUFFIX);
+
+  terminate ();
+}
+
+//--------------------------------------------------
+bool DocumentGenerator::analyze_file (const cmt_string& file,
+				      const cmt_string& constituent_name,
+				      const cmt_string& output_suffix)
+{
+  static cmt_string output_dir;
+  static cmt_string suffix;
+  static cmt_string name;
+  static cmt_string obj;
+
+  if (!CmtSystem::test_file (file) && !CmtSystem::test_directory (file))
+    {
+      cerr << "#CMT> Warning: Source file " << file << " not found" << endl;
+    }
+
+  CmtSystem::dirname (file, output_dir);
+  output_dir += CmtSystem::file_separator ();
+
+  filter_path (output_dir);
+
+  CmtSystem::get_suffix (file, suffix);
+  CmtSystem::basename (file, suffix, name);
+
+  //obj = output_dir;
+  obj = "$(";
+  obj += constituent_name;
+  obj += "_output)";
+  obj += name;
+  obj += output_suffix;
+
+  SourceFile& source = m_source_files.add ();
+  source.set (file, Language::null (), obj);
+
+  return (true);
+}
+
+ReadmeGenerator::ReadmeGenerator ()
+{
+  readme_header_fragment.set ("readme_header");
+  readme_fragment.set ("readme");
+  readme_doc_fragment.set ("readme_doc");
+  readme_use_fragment.set ("readme_use");
+  readme_trailer_fragment.set ("readme_trailer");
+}
+
+void ReadmeGenerator::reset ()
+{
+  CmtGenerator::reset ();
+
+  readme_header_fragment.reset ();
+  readme_fragment.reset ();
+  readme_doc_fragment.reset ();
+  readme_use_fragment.reset ();
+  readme_trailer_fragment.reset ();
+}
+
+//--------------------------------------------------
+void ReadmeGenerator::build (const CmtSystem::cmt_string_vector& arguments)
+{
+  reset ();
+
+  m_PACKAGE = Cmt::get_current_package ();
+  m_VERSION = Cmt::get_current_version ();
+  m_DATE = CmtSystem::now ();
+  m_USER = CmtSystem::user ();
+
+  cmt_string url;
+  cmt_string doc;
+
+  for (int i = 0; i < arguments.size (); i++)
+    {
+      cmt_string arg = arguments[i];
+
+      if (arg.substr (0, 5) == "-url=")
+        {
+          arg.substr (5, url);
+        }
+      else if (arg.substr (0, 5) == "-doc=")
+        {
+          arg.substr (5, doc);
+        }
+    }
+
+  m_output_file_name = cmtdir + "README.html";
+
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+  if (m_output_file != NULL)
+    {
+      readme_header_fragment.copy (m_output_file, 2, 
+                                   &m_PACKAGE, &m_VERSION);
+
+      if (doc != "")
+        {
+          m_DOCPATH = doc;
+          readme_doc_fragment.copy (m_output_file, 3,
+                                    &m_PACKAGE,
+                                    &m_VERSION,
+                                    &m_DOCPATH);
+        }
+
+      readme_fragment.copy (m_output_file, 2,
+                            &m_PACKAGE,
+                            &m_VERSION);
+
+      int number;
+      const Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+      for (number = 0; number < uses.size (); number++)
+        {
+          const Use* use = uses[number];
+
+	  if (use == 0) continue;
+          if (use->discarded) continue;
+
+	  Package* p = use->get_package ();
+	  if (p->is_cmt ()) continue;
+
+	  cmt_string selected_path;
+
+	  if (url == "")
+	    {
+	      selected_path = use->real_path;
+	      
+	      if (use->specified_path != "")
+		{
+		  int pos = selected_path.find_last_of (use->specified_path);
+		  if (pos != cmt_string::npos)
+		    {
+		      selected_path.erase (pos);
+		    }
+		}
+	    }
+	  else
+	    {
+	      selected_path = url;
+	      
+	      if (use->specified_path != "")
+		{
+		  selected_path += CmtSystem::file_separator ();
+		}
+	    }
+	  
+	  m_PACKAGEPATH = selected_path;
+	  m_PACKAGEPREFIX = use->specified_path;
+	  m_PACKAGE = use->get_package_name ();
+	  m_VERSION = use->version;
+	  m_MGRSTYLE = (use->style == mgr_style) ? "mgr" : "cmt";
+	  readme_use_fragment.copy (m_output_file, 5,
+				    &m_PACKAGEPATH,
+				    &m_PACKAGEPREFIX,
+				    &m_PACKAGE,
+				    &m_VERSION,
+				    &m_MGRSTYLE);
+        }
+
+      m_PACKAGE = Cmt::get_current_package ();
+      m_VERSION = Cmt::get_current_version ();
+      readme_trailer_fragment.copy (m_output_file, 4, 
+                                    &m_PACKAGE, 
+                                    &m_VERSION, 
+                                    &m_DATE, 
+                                    &m_USER);
+
+      terminate ();
+    }
+}
+
+//--------------------------------------------------
+class Prototyper : public FAwk
+{
+public:
+  Prototyper (bool static_functions = false) :
+    m_static_functions(static_functions)
+  {
+    if (m_static_functions)
+      {
+	m_suffix = "_static.phnew";
+	m_define_suffix = "_static_ph";
+      }
+    else
+      {
+	m_suffix = ".phnew";
+	m_define_suffix = "_ph";
+      }
+  }
+
+  void begin ()
+  {
+    m_running = false;
+
+    static cmt_string suffix;
+    static cmt_string name;
+
+    CmtSystem::get_dot_suffix (m_file_name, suffix);
+    CmtSystem::basename (m_file_name, suffix, name);
+
+    m_out_file_name  = "";
+
+    if (m_dir_name != "")
+      {
+	m_out_file_name  = m_dir_name;
+	m_out_file_name += CmtSystem::file_separator ();
+      }
+
+    m_out_file_name += name;
+    m_out_file_name += m_suffix;
+
+    CmtSystem::basename (m_file_name, suffix, m_file_name);
+
+    m_output = fopen (m_out_file_name.c_str (), "wb");
+
+    if (m_output != 0)
+      {
+	fprintf (m_output, "#ifndef __%s%s__\n", m_file_name.c_str (),
+		 m_define_suffix.c_str ());
+	fprintf (m_output, "#define __%s%s__\n", m_file_name.c_str (),
+		 m_define_suffix.c_str ());
+
+	fprintf (m_output, "\n");
+	fprintf (m_output, "#ifdef __cplusplus\n");
+	fprintf (m_output, "extern \"C\" {\n");
+	fprintf (m_output, "#endif\n");
+	fprintf (m_output, "\n");
+      }
+    else
+      {
+	stop ();
+      }
+  }
+
+  void filter (const cmt_string& line)
+  {
+    char c = line[0];
+
+    if (!m_running)
+      {
+	if ((c == ' ') ||
+	    (c == '/') ||
+	    (c == '|') ||
+	    (c == '\t') ||
+	    (c == '#')) return;
+	if (line.find ('(') == cmt_string::npos)
+	  {
+	    m_prev_line = line;
+	    return;
+	  }
+
+	m_running = true;
+	m_full_line = line;
+	m_full_line.replace ("(", " (");
+
+	static CmtSystem::cmt_string_vector words;
+
+	CmtSystem::split (m_full_line, " \t", words);
+
+	const cmt_string& second = words[1];
+	if (second[0] == '(')
+	  {
+	    m_full_line = m_prev_line;
+	    m_full_line += " ";
+	    m_full_line += line;
+
+	    m_prev_line = "";
+	  }
+      }
+    else
+      {
+	m_full_line += line;
+      }
+    if (line.find (')') == cmt_string::npos) return;
+    m_running = false;
+
+    if (m_full_line.find (';') != cmt_string::npos) return;
+    if (m_full_line.find ("::") != cmt_string::npos) return;
+    if (m_full_line.find ('<') != cmt_string::npos) return;
+    if (m_full_line.find ('>') != cmt_string::npos) return;
+    if (m_full_line.find ('{') != cmt_string::npos) return;
+    if (m_full_line.find ('}') != cmt_string::npos) return;
+    if (m_full_line.find ("typedef") != cmt_string::npos) return;
+    if (m_full_line.find ("yy") != cmt_string::npos) return;
+    if (m_full_line.find ("YY") != cmt_string::npos) return;
+    if (m_static_functions)
+      {
+	if (m_full_line.find ("static") == cmt_string::npos) return;
+      }
+    else
+      {
+	if (m_full_line.find ("static") != cmt_string::npos) return;
+      }
+
+    m_full_line += ";";
+
+    if (m_output != 0)
+      {
+	fprintf (m_output, "%s\n", m_full_line.c_str ());
+      }
+  }
+
+  void end ()
+  {
+    if (m_output != 0)
+      {
+	fprintf (m_output, "\n");
+	fprintf (m_output, "#ifdef __cplusplus\n");
+	fprintf (m_output, "}\n");
+	fprintf (m_output, "#endif\n");
+	fprintf (m_output, "\n");
+	fprintf (m_output, "#endif\n");
+	fprintf (m_output, "\n");
+
+	fclose (m_output);
+      }
+
+    CmtGenerator::check (m_out_file_name);
+  }
+
+private:
+  bool m_running;
+  cmt_string m_out_file_name;
+  FILE* m_output;
+  bool m_static_functions;
+  cmt_string m_full_line;
+  cmt_string m_prev_line;
+  cmt_string m_suffix;
+  cmt_string m_define_suffix;
+};
+//--------------------------------------------------
+
+//--------------------------------------------------
+void PrototypeGenerator::build (const cmt_string& file_name)
+{
+  Prototyper prototyper;
+
+  reset ();
+
+  prototyper.run (file_name);
+}
+
+//--------------------------------------------------
+void DefaultMakefileGenerator::build ()
+{
+  cmt_string makefile;
+
+  //reset ();
+
+  //--- Build a simple Makefile if none is installed
+
+#ifndef WIN32
+
+  bool need_makefile = false;
+
+  makefile = cmtdir + "Makefile";
+
+  if (!CmtSystem::test_file (makefile))
+    {
+      need_makefile = true;
+    }
+  else
+    {
+      static cmt_string s;
+
+      s.read (makefile);
+      if ((s.find ("METHODSROOT") != cmt_string::npos) ||
+          (s.find ("$(CMTROOT)/src/constituents.make") == cmt_string::npos))
+        {
+          static cmt_string backup = makefile;
+          backup += "_backup";
+
+          makefile += ".cmt";
+
+          if (!CmtSystem::test_file (makefile))
+            {
+              FILE* file = fopen (backup.c_str (), "wb");
+              if (file != NULL)
+                {
+                  cerr << "# " << endl;
+                  cerr << "#CMT> Warning: " << endl;
+                  cerr << "# A Makefile already exists "
+		    "but it does not provides " << endl;
+                  cerr << "# the recommended features "
+		    "for a full benefit of CMT" << endl;
+                  cerr << "# " << endl;
+                  cerr << "# CMT is now building "
+		    "a new 'Makefile.cmt' which you can use" << endl;
+                  cerr << "# to upgrade your current one." << endl;
+                  cerr << "# " << endl;
+
+                  s.write (file);
+                  fclose (file);
+
+                  need_makefile = true;
+                }
+            }
+        }
+    }
+
+  if (need_makefile)
+    {
+      FILE* file = fopen (makefile.c_str (), "wb");
+      if (file != NULL)
+        {
+          fprintf (file, "include $(CMTROOT)/src/Makefile.header\n");
+          fprintf (file, "\n");
+          fprintf (file, "include $(CMTROOT)/src/constituents.make\n");
+          fprintf (file, "\n");
+          fclose (file);
+        }
+    }
+
+#endif
+
+#ifdef WIN32
+
+  makefile = cmtdir + "NMake";
+
+  if (Cmt::get_debug ())
+    {
+      cout << "DefaultMakefileGenerator::build> pwd=" << CmtSystem::pwd () << " cmtdir=" << cmtdir << endl;
+    }
+
+  if (!CmtSystem::test_file (makefile))
+    {
+      FILE* file = fopen (makefile.c_str (), "wb");
+      if (file != NULL)
+        {
+          fprintf (file, "!include $(CMTROOT)\\src\\NMakefile.header\n");
+          fprintf (file, "\n");
+          fprintf (file, "!include $(CMTROOT)\\src\\constituents.nmake\n");
+          fprintf (file, "\n");
+          fclose (file);
+        }
+    }
+
+#endif
+
+}
+
+MSDEVGenerator::MSDEVGenerator ()
+{
+  dsw_header_fragment.set ("dsw_header");
+  dsw_project_fragment.set ("dsw_project");
+  dsw_all_project_header_fragment.set ("dsw_all_project_header");
+  dsw_all_project_dependency_fragment.set ("dsw_all_project_dependency");
+  dsw_all_project_trailer_fragment.set ("dsw_all_project_trailer");
+  dsw_trailer_fragment.set ("dsw_trailer");
+
+  dsp_all_fragment.set ("dsp_all");
+  dsp_library_header_fragment.set ("dsp_library_header");
+  dsp_application_header_fragment.set ("dsp_application_header");
+  dsp_windows_header_fragment.set ("dsp_windows_header");
+  dsp_contents_fragment.set ("dsp_contents");
+  dsp_trailer_fragment.set ("dsp_trailer");
+}
+
+void MSDEVGenerator::reset ()
+{
+  CmtGenerator::reset ();
+
+  dsw_header_fragment.reset ();
+  dsw_project_fragment.reset ();
+  dsw_all_project_header_fragment.reset ();
+  dsw_all_project_dependency_fragment.reset ();
+  dsw_all_project_trailer_fragment.reset ();
+  dsw_trailer_fragment.reset ();
+
+  dsp_all_fragment.reset ();
+  dsp_library_header_fragment.reset ();
+  dsp_application_header_fragment.reset ();
+  dsp_windows_header_fragment.reset ();
+  dsp_contents_fragment.reset ();
+  dsp_trailer_fragment.reset ();
+
+  CmtSystem::cd (Cmt::get_current_dir ());
+
+  cmt_string branch = CmtSystem::current_branch ();
+
+  if ((branch == "mgr") || (branch == "cmt"))
+    {
+#ifdef WIN32
+      msdevdir = "..";
+      msdevdir += CmtSystem::file_separator ();
+      msdevdir += "Visual";
+      
+      if (!CmtSystem::test_directory (msdevdir))
+        {
+          CmtSystem::mkdir (msdevdir);
+        }
+      
+      msdevdir += CmtSystem::file_separator ();
+#endif
+    }
+  else
+    {
+#ifdef WIN32
+      msdevdir = ".";
+      msdevdir += CmtSystem::file_separator ();
+#endif
+    }
+
+}
+
+int MSDEVGenerator::build_workspace (const Constituent::ConstituentVector& constituents)
+{
+  reset ();
+
+  const cmt_string& package = Cmt::get_current_package ();
+
+  m_output_file_name = msdevdir + package + ".dswnew";
+
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+  if (m_output_file != NULL)
+    {
+      m_PACKAGE = package;
+      dsw_header_fragment.wincopy (m_output_file, 1,
+                                   &m_PACKAGE);
+
+      int i;
+
+      dsw_all_project_header_fragment.wincopy (m_output_file, 1, 
+                                               &m_PACKAGE);
+
+      for (i = 0; i < constituents.size (); i++)
+        {
+          const Constituent& constituent = constituents[i];
+
+          if (constituent.type == Library)
+            {
+              m_CONSTITUENT = constituent.name;
+              m_CONSTITUENTSUFFIX = constituent.suffix;
+              dsw_all_project_dependency_fragment.wincopy (m_output_file, constituent.variables, 3,
+                                                           &m_PACKAGE,
+                                                           &m_CONSTITUENT, 
+                                                           &m_CONSTITUENTSUFFIX);
+            }
+	  else
+	    {
+	      m_CONSTITUENT = constituent.name;
+	      m_CONSTITUENTSUFFIX = constituent.suffix;
+	      dsw_all_project_dependency_fragment.wincopy (m_output_file, constituent.variables, 3,
+                                                           &m_PACKAGE,
+							   &m_CONSTITUENT, 
+                                                           &m_CONSTITUENTSUFFIX);
+	    }
+
+        }
+
+      dsw_all_project_trailer_fragment.wincopy (m_output_file,
+                                                1, &m_PACKAGE);
+
+      for (i = 0; i < constituents.size (); i++)
+        {
+          const Constituent& constituent = constituents[i];
+
+          if (constituent.type == Library)
+            {
+              m_CONSTITUENT = constituent.name;
+              m_CONSTITUENTSUFFIX = constituent.suffix;
+              dsw_project_fragment.wincopy (m_output_file,
+                                            constituent.variables, 3,
+                                            &m_PACKAGE,
+                                            &m_CONSTITUENT, 
+                                            &m_CONSTITUENTSUFFIX);
+            }
+          else
+            {
+              m_CONSTITUENT = constituent.name;
+              m_CONSTITUENTSUFFIX = constituent.suffix;
+              dsw_project_fragment.wincopy (m_output_file, constituent.variables, 3, 
+                                            &m_PACKAGE,
+                                            &m_CONSTITUENT, 
+                                            &m_CONSTITUENTSUFFIX);
+            }
+        }
+
+      dsw_trailer_fragment.wincopy (m_output_file, 1, &m_PACKAGE);
+
+      terminate ();
+    }
+
+  m_output_file_name = msdevdir + "all.dspnew";
+
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+  if (m_output_file != NULL)
+    {
+      dsp_all_fragment.wincopy (m_output_file, 1, &m_PACKAGE);
+      terminate ();
+    }
+
+  return (0);
+}
+
+//--------------------------------------------------
+int MSDEVGenerator::build_project (const Constituent& constituent)
+{
+  reset ();
+
+  const cmt_string& package = Cmt::get_current_package ();
+  static cmt_string file;
+  static cmt_string full_name;
+  static cmt_string suffix;
+
+  int i;
+
+  m_CONSTITUENT = constituent.name;
+  m_CONSTITUENTSUFFIX = constituent.suffix;
+
+  for (i = 0; i < constituent.includes.size (); i++)
+    {
+      const cmt_string& include = constituent.includes[i];
+      m_PACKINCLUDES += " -I" + include;
+    }
+
+  switch (constituent.type)
+    {
+    case Application:
+      is_application = true;
+      m_TITLE = "Application";
+      break;
+    case Library:
+      is_library = true;
+      m_TITLE = "Library";
+      break;
+    case Document:
+      m_GENERATOR = constituent.generator;
+      m_TITLE = "Document";
+      break;
+    }
+
+  m_PACKOS9 = constituent.need_OS9;
+
+  const CmtSystem::cmt_string_vector& sources = constituent.modules;
+  const cmt_vector<cmt_regexp>& excludes = constituent.exclude_exprs;
+  const cmt_vector<cmt_regexp>& selects = constituent.select_exprs;
+
+  //--- Build the constituents fragment -----
+
+  m_output_file_name = msdevdir + m_CONSTITUENT + ".dspnew";
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+
+  if (m_output_file == NULL) return (0);
+
+  m_PACKAGE = package;
+
+  if (is_library)
+    {
+      if (constituent.no_share)
+        {
+          m_LIBRARYSUFFIX = "lib";
+        }
+      else
+        {
+          m_LIBRARYSUFFIX = "arc";
+        }
+
+      dsp_library_header_fragment.wincopy (m_output_file, constituent.variables, 4,
+                                           &m_PACKAGE,
+                                           &m_CONSTITUENT, 
+                                           &m_CONSTITUENTSUFFIX, 
+                                           &m_LIBRARYSUFFIX);
+    }
+  else
+    {
+      if (constituent.windows)
+        {
+          dsp_windows_header_fragment.wincopy (m_output_file, constituent.variables, 3,
+                                               &m_PACKAGE,
+                                               &m_CONSTITUENT, 
+                                               &m_CONSTITUENTSUFFIX);
+        }
+      else
+        {
+          dsp_application_header_fragment.wincopy (m_output_file, constituent.variables, 3,
+                                                   &m_PACKAGE,
+                                                   &m_CONSTITUENT, 
+                                                   &m_CONSTITUENTSUFFIX);
+        }
+    }
+
+  for (i = 0; i < sources.size (); i++)
+    {
+      file = sources[i];
+
+      set_full_name (full_name, file);
+      if (full_name == "") continue;
+
+      static CmtSystem::cmt_string_vector files;
+
+      get_all_files (full_name, excludes, selects, files);
+
+      for (int j = 0; j < files.size (); j++)
+        {
+          const cmt_string& name = files[j];
+
+          if (name != "") 
+            {
+              m_FULLNAME = name;
+
+              if (m_output_file != NULL)
+                {
+                  dsp_contents_fragment.wincopy (m_output_file, constituent.variables, 2, 
+                                                 &m_PACKAGE, 
+                                                 &m_FULLNAME);
+                }
+            }
+        }
+    }
+
+  if (m_output_file != NULL)
+    {
+      dsp_trailer_fragment.wincopy (m_output_file, constituent.variables, 3,
+                                    &m_PACKAGE,
+				    &m_CONSTITUENT, 
+                                    &m_CONSTITUENTSUFFIX);
+
+      terminate ();
+    }
+
+  return (0);
+}
+
+
+VSNETGenerator::VSNETGenerator ()
+{
+  sln_header_fragment.set ("sln_header");
+  sln_project_fragment.set ("sln_project");
+  sln_dependency_header_fragment.set ("sln_dependency_header");
+  sln_dependency_project_fragment.set ("sln_dependency_project");
+  sln_dependency_trailer_fragment.set ("sln_dependency_trailer");
+  sln_project_config_fragment.set ("sln_project_config");
+  sln_trailer_fragment.set ("sln_trailer");
+
+  vcproj_all_fragment.set ("vcproj_all");
+  vcproj_library_header_fragment.set ("vcproj_library_header");
+  vcproj_application_header_fragment.set ("vcproj_application_header");
+  vcproj_windows_header_fragment.set ("vcproj_windows_header");
+  vcproj_contents_fragment.set ("vcproj_contents");
+  vcproj_directory_header_fragment.set ("vcproj_directory_header");
+  vcproj_directory_trailer_fragment.set ("vcproj_directory_trailer");
+  vcproj_trailer_fragment.set ("vcproj_trailer");
+}
+
+void VSNETGenerator::reset ()
+{
+  CmtGenerator::reset ();
+
+  CmtSystem::cd (Cmt::get_current_dir ());
+
+  cmt_string branch = CmtSystem::current_branch ();
+
+  if ((branch == "mgr") || (branch == "cmt"))
+    {
+#ifdef WIN32
+      vsnetdir = "..";
+      vsnetdir += CmtSystem::file_separator ();
+      vsnetdir += "Visual";
+      
+      if (!CmtSystem::test_directory (vsnetdir))
+        {
+          CmtSystem::mkdir (vsnetdir);
+        }
+      
+      vsnetdir += CmtSystem::file_separator ();
+#endif
+    }
+  else
+    {
+#ifdef WIN32
+      vsnetdir = ".";
+      vsnetdir += CmtSystem::file_separator ();
+#endif
+    }
+}
+
+void VSNETGenerator::pseudoGUID (const cmt_string& a, 
+                                 const cmt_string& b, 
+                                 const cmt_string& c, 
+                                 cmt_string& d)
+{
+  char buf[64]; // make the guid in here
+  static char hex[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+  int k = 0;
+  int i;
+
+  for (i = 0; (i < c.size()) && (k < sizeof(buf)); ++i, ++k) buf[k] = c[i];
+  for (i = 0; (i < a.size()) && (k < sizeof(buf)); ++i, ++k) buf[k] = a[i];
+  for (i = 0; (i < b.size()) && (k < sizeof(buf)); ++i, ++k) buf[k] = b[i];
+  for (; k < sizeof(buf); ++k) buf[k] = 0;
+
+  // now use the buffer to format the output string
+  // example: {3FE091FC-3738-4F2E-9723-E846B43F77AB}
+  d = '{';
+  k = 0;
+
+  for (i = 0; i < 4; ++i, ++k) { d += hex[buf[k]&15]; d += hex[buf[k] >> 4]; } d += '-';
+  for (i = 0; i < 2; ++i, ++k) { d += hex[buf[k]&15]; d += hex[buf[k] >> 4]; } d += '-';
+  for (i = 0; i < 2; ++i, ++k) { d += hex[buf[k]&15]; d += hex[buf[k] >> 4]; } d += '-';
+  for (i = 0; i < 2; ++i, ++k) { d += hex[buf[k]&15]; d += hex[buf[k] >> 4]; } d += '-';
+  for (i = 0; i < 6; ++i, ++k) { d += hex[buf[k]&15]; d += hex[buf[k] >> 4]; } d += '}';
+}
+
+int VSNETGenerator::build_workspace (const Constituent::ConstituentVector& constituents)
+{
+  reset ();
+
+  const cmt_string& package = Cmt::get_current_package ();
+  
+  m_output_file_name = vsnetdir + package + ".slnnew";
+  
+  Variable PACKAGE_GUID ("PACKAGE_GUID");
+  Variable CONSTITUENT_GUID ("CONSTITUENT_GUID");
+  Variable NUMBER ("NUMBER");
+  
+  cmt_string guid;
+  pseudoGUID (package, Cmt::get_current_version(), "", guid);
+  PACKAGE_GUID = guid;
+  
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+  
+  if (m_output_file != NULL)
+    {
+      m_PACKAGE = package;
+      sln_header_fragment.wincopy (m_output_file, 2, 
+                                   &m_PACKAGE,
+                                   &PACKAGE_GUID);
+      
+      int i;
+      
+      for (i = 0; i < constituents.size (); i++)
+	{
+	  const Constituent& constituent = constituents[i];
+	  
+	  pseudoGUID (package, Cmt::get_current_version(), constituent.name, guid);
+	  CONSTITUENT_GUID = guid;
+	  
+	  if (constituent.type == Library)
+	    {
+	      m_CONSTITUENT = constituent.name;
+	      m_CONSTITUENTSUFFIX = constituent.suffix;
+	      sln_project_fragment.wincopy (m_output_file,
+					    constituent.variables, 4,
+					    &m_PACKAGE,
+					    &m_CONSTITUENT,
+					    &PACKAGE_GUID,
+					    &CONSTITUENT_GUID);
+	    }
+	  else
+	    {
+	      m_CONSTITUENT = constituent.name;
+	      m_CONSTITUENTSUFFIX = constituent.suffix;
+	      sln_project_fragment.wincopy (m_output_file, constituent.variables, 4,
+					    &m_PACKAGE,
+					    &m_CONSTITUENT,
+					    &PACKAGE_GUID,
+					    &CONSTITUENT_GUID);
+	    }
+	}
+      
+      sln_dependency_header_fragment.wincopy (m_output_file,
+					      1, &m_PACKAGE);
+      
+      for (i = 0; i < constituents.size (); i++)
+	{
+	  const Constituent& constituent = constituents[i];
+	  pseudoGUID (package, Cmt::get_current_version(), constituent.name, guid);
+	  CONSTITUENT_GUID = guid;
+	  
+	  cmt_string num;
+	  num = (char)('0' + i);
+	  NUMBER = num;
+	  if (constituent.type == Library)
+	    {
+	      m_CONSTITUENT = constituent.name;
+	      m_CONSTITUENTSUFFIX = constituent.suffix;
+	      
+	      sln_dependency_project_fragment.wincopy (m_output_file, constituent.variables, 5,
+						       &m_PACKAGE,
+						       &m_CONSTITUENT,
+						       &PACKAGE_GUID,
+						       &CONSTITUENT_GUID,
+						       &NUMBER);
+	    }
+ 	  else
+ 	    {
+ 	      m_CONSTITUENT = constituent.name;
+ 	      m_CONSTITUENTSUFFIX = constituent.suffix;
+ 	      sln_dependency_project_fragment.wincopy (m_output_file, constituent.variables, 5,
+						       &m_PACKAGE,
+						       &m_CONSTITUENT,
+						       &PACKAGE_GUID,
+						       &CONSTITUENT_GUID, 
+                                                       &NUMBER);
+ 	    }
+	}
+      
+      sln_dependency_trailer_fragment.wincopy (m_output_file,
+					       1, &m_PACKAGE);
+      
+      for (i = 0; i < constituents.size (); i++)
+	{
+	  const Constituent& constituent = constituents[i];
+	  pseudoGUID (package, Cmt::get_current_version(), constituent.name, guid);
+	  CONSTITUENT_GUID = guid;
+	  
+	  if (constituent.type == Library)
+	    {
+	      m_CONSTITUENT = constituent.name;
+	      m_CONSTITUENTSUFFIX = constituent.suffix;
+	      sln_project_config_fragment.wincopy (m_output_file,
+						   constituent.variables, 3,
+						   &m_PACKAGE,
+						   &m_CONSTITUENT,
+						   &CONSTITUENT_GUID);
+	    }
+	  else
+	    {
+	      m_CONSTITUENT = constituent.name;
+	      m_CONSTITUENTSUFFIX = constituent.suffix;
+	      sln_project_config_fragment.wincopy (m_output_file, constituent.variables, 3,
+						   &m_PACKAGE,
+						   &m_CONSTITUENT,
+						   &CONSTITUENT_GUID);
+	    }
+	}
+      
+      sln_trailer_fragment.wincopy (m_output_file, 1, &m_PACKAGE);
+
+      terminate ();
+    }
+  
+  m_output_file_name = vsnetdir + "all.vcprojnew";
+  
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+  if (m_output_file != NULL)
+    {
+      vcproj_all_fragment.wincopy (m_output_file, 1, &m_PACKAGE);
+
+      terminate ();
+    }
+  
+  return (0);
+}
+
+int VSNETGenerator::build_project (const Constituent& constituent)
+{
+  reset ();
+  
+  const cmt_string& package = Cmt::get_current_package();
+  static cmt_string file;
+  static cmt_string full_name;
+  static cmt_string suffix;
+  
+  static Variable GUID("GUID");
+  int i;
+  
+  // Directory Support
+  int dir_pos;
+  int file_pos;
+  int src_pos;
+  int iSFFilter = 0;
+  cmt_string directory;
+  cmt_string new_dir;
+  bool need_trailer = false;
+
+  m_CONSTITUENT = constituent.name;
+  // make up a pseudo-GUID from the constituent-pacakge-version combination
+  
+  cmt_string guid;
+  pseudoGUID (package, Cmt::get_current_version(), constituent.name, guid);
+  
+  GUID = guid;
+  
+  for (i = 0; i < constituent.includes.size (); i++)
+    {
+      const cmt_string& include = constituent.includes[i];
+      m_PACKINCLUDES += " -I" + include;
+    }
+  
+  switch (constituent.type)
+    {
+    case Application:
+      is_application = true;
+      m_TITLE = "Application";
+      break;
+    case Library:
+      is_library = true;
+      m_TITLE = "Library";
+      break;
+    case Document:
+      m_GENERATOR = constituent.generator;
+      m_TITLE = "Document";
+      break;
+    }
+  
+  m_PACKOS9 = constituent.need_OS9;
+  
+  const CmtSystem::cmt_string_vector& sources = constituent.modules;
+  const cmt_vector<cmt_regexp>& excludes = constituent.exclude_exprs;
+  const cmt_vector<cmt_regexp>& selects = constituent.select_exprs;
+  
+  //--- Build the constituents fragment -----
+  cmt_string output;
+  
+  m_output_file_name = vsnetdir + m_CONSTITUENT + ".vcprojnew";
+  m_output_file = fopen (m_output_file_name.c_str (), "wb");
+  
+  if (m_output_file == NULL) return (0);
+  
+  m_PACKAGE = package;
+  
+  if (is_library)
+    {
+      if (constituent.no_share)
+	{
+	  m_LIBRARYSUFFIX = "lib";
+	}
+      else
+	{
+	  m_LIBRARYSUFFIX = "arc";
+	}
+      
+      vcproj_library_header_fragment.wincopy (m_output_file, constituent.variables, 4,
+					      &m_PACKAGE,
+					      &m_CONSTITUENT,
+					      &GUID,
+					      &m_LIBRARYSUFFIX);
+    }
+  else
+    {
+      if (constituent.windows)
+	{
+	  vcproj_windows_header_fragment.wincopy (m_output_file, constituent.variables, 3,
+						  &m_PACKAGE,
+						  &m_CONSTITUENT,
+						  &GUID);
+	}
+      else
+	{
+	  vcproj_application_header_fragment.wincopy (m_output_file, constituent.variables, 3,
+						      &m_PACKAGE,
+						      &m_CONSTITUENT,
+						      &GUID);
+	}
+    }
+  
+  for (i = 0; i < sources.size (); i++)
+    {
+      file = sources[i];
+      
+      set_full_name (full_name, file);
+      if (full_name == "") continue;
+      
+      static CmtSystem::cmt_string_vector files;
+      
+      get_all_files (full_name, excludes, selects, files);
+      
+      for (int j = 0; j < files.size (); j++)
+	{
+	  const cmt_string& name = files[j];
+	  
+	  if (name != "")
+	    {
+	      m_FULLNAME = name;
+
+	      // Add Directory Support here
+	      // Step 1: Parse into "..\src\" "directory" "\filename.cxx"
+
+	      // find ..\ ;
+	      src_pos = name.find('\\');
+	      // Finds ..\src\ ;
+	      dir_pos = name.find(src_pos+1, '\\') + 1;
+	      // Finds ..\src\..\astro\ ;
+	      file_pos = name.find_last_of('\\');
+	      
+	      // Debug only
+	      //printf("%40s, %i, %i, %i;\n", name src_pos, dir_pos, file_pos);
+	      // If dir_pos == file_pos, then we have ../src/filename.cxx
+	      // If dir_pos >  file_pos, then we have ../filename.cxx or something odd.
+			   
+	      // Step 2: see if it is or is not a ../src/ directory.
+	      if ((dir_pos < file_pos) && (dir_pos > src_pos))
+		{
+		  new_dir = name.substr (dir_pos, file_pos-dir_pos);
+		  new_dir.replace( "..\\", ""); // All names are relative to package/Visual,
+		                                // so we want to ditch the prevailing ..\ ;
+                                                // which all of them have.
+		}
+	      else
+		{
+		  new_dir = "Source Files NN";
+		}
+
+	      // Step 3: Add directory structure to vcproj file.
+	      if (new_dir != directory) // Detects a change in directory
+		{
+		  directory = new_dir;
+		  // Step 3a: Add a </Filter> when neccessary.
+		  if (need_trailer == false)
+		    {
+		      // Ensure that no trailing </Filter> is placed incorrectly.
+		      need_trailer = true;
+		    }
+		  else
+		    {
+		      vcproj_directory_trailer_fragment.wincopy (m_output_file,
+								 constituent.variables, 1,
+								 &m_PACKAGE);
+		    }
+
+		  // Step 3b: Add a <Filter> when neccessary.
+		  if ((dir_pos < file_pos) && (dir_pos > src_pos))
+		    {
+		      // Add <Filter Name="directory">
+		      m_DIRNAME = new_dir;
+		      vcproj_directory_header_fragment.wincopy (m_output_file, constituent.variables, 2,
+								&m_PACKAGE,
+								&m_DIRNAME);
+		    }
+		  else
+		    {
+		      // Ensure that no </Filter> is placed incorrectly.
+		      // This is the case of the file being in ../src 
+		      // which requires no directory. Thus no filter start or end tag is needed.
+
+		      need_trailer = false;
+		    }
+		}
+
+	      if (m_output_file != NULL)
+		{
+		  vcproj_contents_fragment.wincopy (m_output_file, constituent.variables, 2,
+						    &m_PACKAGE,
+						    &m_FULLNAME);
+		}
+	    }
+	}
+    }
+
+  if (need_trailer == true)
+    {
+      // Add a trailing </Filter> for directory support.
+      vcproj_directory_trailer_fragment.wincopy (m_output_file, constituent.variables, 1,
+						 &m_PACKAGE);
+    }
+
+  if (m_output_file != NULL)
+    {
+      vcproj_trailer_fragment.wincopy (m_output_file, constituent.variables, 3,
+				       &m_PACKAGE,
+				       &m_CONSTITUENT,
+				       &m_CONSTITUENTSUFFIX);
+
+      terminate ();
+    }
+
+  return (0);
+}
+
+MakeSetupGenerator::MakeSetupGenerator ()
+{
+  make_setup_header_fragment.set ("make_setup_header");
+  make_setup_fragment.set ("make_setup");
+}
+
+void MakeSetupGenerator::reset ()
+{
+  CmtGenerator::reset ();
+
+  make_setup_header_fragment.reset ();
+  make_setup_fragment.reset ();
+}
+
+void MakeSetupGenerator::build (const cmt_string& package)
+{
+  reset ();
+
+  m_PACKAGE = package;
+
+  cmt_string file_name = "setup.";
+
+  if (Cmt::build_nmake ())
+    {
+      file_name += "nmake";
+    }
+  else
+    {
+      file_name += "make";
+    }
+  
+  cmt_string new_file_name = file_name;
+  new_file_name += "new";
+
+  m_output_file = fopen (new_file_name, "wb");
+
+  if (m_output_file != NULL)
+    {
+      int number;
+
+      const Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+      const Constituent::ConstituentVector& constituents =
+	Constituent::constituents ();
+
+      cmt_string temp;
+
+      make_setup_header_fragment.copy (m_output_file, 1, &m_PACKAGE);
+
+      for (number = 0; number < uses.size (); number++)
+        {
+          const Use* use = uses[number];
+
+          if (use->discarded) continue;
+
+          if (use->real_path != "")
+            {
+              temp  = use->prefix;
+              temp += "ROOT = ";
+              temp += use->get_full_path ();
+
+              fprintf (m_output_file, "%s\n", temp.c_str());
+            }
+        }
+
+      temp  = "use_requirements = ";
+      temp += "requirements ";
+
+      for (number = 0; number < uses.size (); number++)
+        {
+          const Use* use = uses[number];
+
+          if (use->discarded) continue;
+
+          if (use->real_path != "")
+            {
+              temp += "$(";
+              temp += use->prefix;
+              temp += "ROOT)";
+              temp += CmtSystem::file_separator ();
+              switch (use->style)
+                {
+		case cmt_style:
+		  temp += "cmt";
+		  break;
+		case mgr_style:
+		  temp += "mgr";
+		  break;
+                }
+              temp += CmtSystem::file_separator ();
+              temp += "requirements ";
+            }
+        }
+
+      fprintf (m_output_file, "%s\n", temp.c_str());
+
+      temp  = "constituents = $(constituents)";
+      Symbol::expand (temp);
+
+      fprintf (m_output_file, "%s\n", temp.c_str());
+
+      make_setup_fragment.copy (m_output_file, 1, &m_PACKAGE);
+
+      fclose (m_output_file);
+
+      //--- Complete the operation --------------
+
+      commit (new_file_name);
+    }
+
+  /*
+    for option in $*
+    do
+    case ${option} in
+    args-tag=*)
+    tag=${option}
+    tag=`echo "${tag}" | sed -e 's/args.tag=//'`
+    ;;
+    -tag=*)
+    tag=args${option}
+    tag=`echo "${tag}" | sed -e 's/args.tag=//'`
+    ;;
+    esac
+    done
+
+    if test "${tag}" = "" ; then
+    tag=${CMTCONFIG}
+    fi
+
+    build_shell_setup_files ${tag}
+
+    now=`date`
+
+  */
+}
+
+ConstituentsMakefileGenerator::ConstituentsMakefileGenerator ()
+{
+  constituents_header_fragment.set ("constituents_header");
+  constituents_trailer_fragment.set ("constituents_trailer");
+  group_fragment.set ("group");
+  constituent_fragment.set ("constituent");
+  check_application_header_fragment.set ("check_application_header");
+}
+
+void ConstituentsMakefileGenerator::reset ()
+{
+  CmtGenerator::reset ();
+  constituents_header_fragment.reset ();
+  constituents_trailer_fragment.reset ();
+  group_fragment.reset ();
+  constituent_fragment.reset ();
+  check_application_header_fragment.reset ();
+}
+
+//--------------------------------------------------
+void ConstituentsMakefileGenerator::build (const cmt_string& package,
+					   const CmtSystem::cmt_string_vector& arguments)
+{
+  reset ();
+
+  cmt_string file_name;
+
+  if (arguments.size () > 0)
+    {
+      cmt_string arg = arguments[0];
+      if (arg.substr (0, 5) == "-out=")
+	{
+	  arg.erase (0, 5);
+	  file_name = arg;
+	}
+    }
+
+  if (file_name == "")
+    {
+      file_name = "constituents.";
+
+      //--- Build the constituents fragment -----
+
+      if (Cmt::build_nmake ())
+	{
+	  file_name += "nmake";
+	}
+      else
+	{
+	  file_name += "make";
+	}
+    }
+
+  cmt_string save_file_name = file_name;
+  save_file_name += "sav";
+
+  if (CmtSystem::test_file (file_name))
+    {
+      rename (file_name, save_file_name);
+    }
+
+  cmt_string new_file_name = file_name;
+  new_file_name += "new";
+
+  m_output_file = fopen (new_file_name, "wb");
+  if (m_output_file != NULL)
+    {
+      int number;
+      const Constituent::ConstituentVector&
+	constituents = Constituent::constituents ();
+
+      m_PACKAGE = package;
+
+      constituents_header_fragment.copy (m_output_file, 1, &m_PACKAGE);
+
+      m_GROUP = "all";
+      group_fragment.copy (m_output_file, 1, &m_GROUP);
+
+      const Group::GroupVector& groups = Group::groups ();
+
+      for (number = 0; number < groups.size (); number++)
+        {
+          const Group& group = groups[number];
+
+          m_GROUP = group.name ();
+
+          group_fragment.copy (m_output_file, 1, &m_GROUP);
+        }
+      
+      for (number = 0; number < constituents.size (); number++)
+        {
+          const Constituent& constituent = constituents[number];
+
+          m_CONSTITUENT = constituent.name;
+          m_CONSTITUENTSUFFIX = constituent.suffix;
+
+          m_LINE = "";
+
+	  if (constituent.has_target_tag)
+	    {
+	      m_HASTARGETTAG = "has_target_tag";
+	    }
+	  else
+	    {
+	      m_HASTARGETTAG = "has_no_target_tag";
+	    }
+
+          constituent_fragment.copy (m_output_file, constituent.variables, 5, 
+				     &m_PACKAGE,
+				     &m_CONSTITUENT, 
+                                     &m_CONSTITUENTSUFFIX,
+                                     &m_LINE,
+				     &m_HASTARGETTAG);
+
+          if (constituent.need_check)
+            {
+              check_application_header_fragment.copy (m_output_file, 
+						      constituent.variables, 3,
+						      &m_PACKAGE,
+						      &m_CONSTITUENT,
+                                                      &m_CONSTITUENTSUFFIX);
+            }
+        }
+
+      constituents_trailer_fragment.copy (m_output_file, 0);
+
+      fclose (m_output_file);
+
+      commit (new_file_name);
+    }
+}
+
+
+
+
+/**
+   With this Awk filter, we analyze an existing dependency file.
+   We get the source name in each line
+   The list of sources is maintained in m_sources
+   A source is stored in the form <name>_<suffix> (instead of <name>.<suffix>)
+*/
+class DependencyFilter : public Awk
+{
+public:
+  DependencyFilter ()
+      {
+      }
+
+  void begin ()
+      {
+        m_sources = "";
+      }
+
+  void filter (const cmt_string& line)
+      {
+        int pos = line.find ("_dependencies = ");
+        if (pos == cmt_string::npos) return;
+
+        cmt_string s = line;
+        s.erase (pos);
+
+        m_sources += " ";
+        m_sources += s;
+        m_sources += " ";
+
+          //pos = s.find_last_of ("_");
+          //if (pos != cmt_string::npos) s[pos] = "."
+      }
+
+  void add_source (const cmt_string& file_name)
+      {
+        static cmt_string suffix;
+        static cmt_string name;
+
+        CmtSystem::get_dot_suffix (file_name, suffix);
+        CmtSystem::basename (file_name, suffix, name);
+        CmtSystem::get_suffix (file_name, suffix);
+
+        cmt_string s = " ";
+        s += name;
+        s += "_";
+        s += suffix;
+        s += " ";
+
+        if (m_sources.find (s) == cmt_string::npos)
+          {
+            m_sources += s;
+          }        
+      }
+
+  bool has_source (const cmt_string& file_name) const
+      {
+        static cmt_string suffix;
+        static cmt_string name;
+
+        CmtSystem::get_dot_suffix (file_name, suffix);
+        CmtSystem::basename (file_name, suffix, name);
+        CmtSystem::get_suffix (file_name, suffix);
+
+        cmt_string s = " ";
+        s += name;
+        s += "_";
+        s += suffix;
+        s += " ";
+
+        if (m_sources.find (s) == cmt_string::npos)
+          {
+            return (false);
+          }
+        else
+          {
+            return (true);
+          }
+      }
+
+  cmt_string& get_sources ()
+      {
+        return (m_sources);
+      }
+
+private:
+  cmt_string m_sources;
+};
+
+
+void DependencyGenerator::build (const CmtSystem::cmt_string_vector& arguments)
+{
+  reset ();
+  prepare_use_context ();
+
+  m_stamps = true;
+
+  const cmt_string& name = arguments[0];
+
+  //cerr << "name=" << name << endl;
+
+  m_constituent = Constituent::find (name);
+  if (m_constituent == 0)
+    {
+      // Error : wrong constituent name...
+      
+      return;
+    }
+
+  const Constituent& constituent = *m_constituent;
+
+  cmt_string file_name;
+  cmt_string full_name;
+  cmt_string compressed_name;
+  cmt_string suffix;
+  cmt_string dependencies;
+
+  //
+  // Now prepare the output file names
+  //
+  cmt_string branch = CmtSystem::current_branch ();
+
+  if ((branch == "mgr") || (branch == "cmt"))
+    {
+      Use& current_use = Use::current ();
+
+      Package* p = current_use.get_package ();
+
+      if (p->is_cmt ())
+        {
+          m_bin = "../";
+          m_bin += CmtSystem::getenv ("CMTBIN");
+          m_bin += CmtSystem::file_separator ();
+        }
+      else
+        {
+          m_bin = "${bin}";
+        }
+
+      Symbol::expand (m_bin);
+
+      //cerr << "m_output_file_name=" << m_output_file_name << endl;
+      //cerr << "current_tag=" << Cmt::current_tag << endl;
+    }
+  else
+    {
+      m_bin = ".";
+      m_bin += CmtSystem::file_separator ();
+    }
+
+  m_output_file_name = m_bin;
+  m_output_file_name += name;
+  m_output_file_name += "_";
+  m_output_file_name += "dependencies.";
+  if (Cmt::build_nmake ())
+    {
+      m_output_file_name += "nmake";
+    }
+  else
+    {
+      m_output_file_name += "make";
+    }
+
+  //
+  // New read the existing dependency file if any and filter it to
+  // extract the source names
+  //
+  static DependencyFilter filter;
+
+  dependencies.read (m_output_file_name);
+
+  filter.run (dependencies);
+
+  //
+  // Scan the sources.
+  //
+
+  //
+  //  We have to rebuild the dependencies for :
+  //
+  //   o all sources if the parameter -all_sources has been received
+  //   o otherwise,
+  //      + all source names provided in the argument list (if any)
+  //      + all source names missing from the existing dependency file (if any)
+  //
+
+  const CmtSystem::cmt_string_vector& sources = constituent.modules;
+  const cmt_vector<cmt_regexp>& excludes = constituent.exclude_exprs;
+  const cmt_vector<cmt_regexp>& selects = constituent.select_exprs;
+
+  bool all_sources = false;
+
+  int source_number = arguments.size ();
+  int i;
+
+  //cerr << "source_number=" << source_number << endl;
+
+  for (i = source_number-1; i >= 0; i--)
+    {
+      file_name = arguments[i];
+
+      //cerr << "file_name=" << file_name << endl;
+
+        // Get rid of files that may come from the makefile fragment
+      if (file_name.find ("requirements") != cmt_string::npos) source_number--;
+      else if (file_name.find (".make") != cmt_string::npos) source_number--;
+      else if (file_name == "-all_sources") 
+        {
+          source_number = sources.size ();
+          all_sources = true;
+        }
+      else if (file_name == "-no_stamps") 
+        {
+          source_number--;
+	  m_stamps = false;
+        }
+    }
+
+
+  if (all_sources)
+    {
+      for (i = 0; i < sources.size (); i++)
+        {
+          file_name = sources[i];
+          
+          set_full_name (full_name, file_name);
+          if (full_name == "") continue;
+
+          CmtSystem::compress_path (full_name, compressed_name);
+          full_name = compressed_name;
+          
+          static CmtSystem::cmt_string_vector files;
+
+          get_all_files (full_name, excludes, selects, files);
+
+          for (int j = 0; j < files.size (); j++)
+            {
+              const cmt_string& name = files[j];
+              
+              if (name != "") 
+                {
+                  const cmt_string& line = build (name);
+                  
+		  //cout << ">>> line=[" << line << "]" << endl;
+                  
+                  add_line_to_text (line, dependencies);
+                }
+            }
+        }
+    }
+  else
+    {
+      for (i = 1; i < source_number; i++)
+        {
+          file_name = arguments[i];
+
+          set_full_name (full_name, file_name);
+          if (full_name == "") continue;
+
+          CmtSystem::compress_path (full_name, compressed_name);
+          full_name = compressed_name;
+          
+          const cmt_string& line = build (full_name);
+                  
+            //cout << ">>> name2=" << full_name << endl;
+                  
+          add_line_to_text (line, dependencies);
+
+            //cout << ">>from deps : " << filter.get_sources () << endl;
+          filter.add_source (full_name);
+
+        }
+
+        //cout << ">>from deps : " << filter.get_sources () << endl;
+
+        // Now : are there still any missing source file in dependencies??
+
+      for (i = 0; i < sources.size (); i++)
+        {
+          file_name = sources[i];
+          
+          set_full_name (full_name, file_name);
+          if (full_name == "") continue;
+          
+          CmtSystem::compress_path (full_name, compressed_name);
+          full_name = compressed_name;
+          
+          static CmtSystem::cmt_string_vector files;
+          
+          get_all_files (full_name, excludes, selects, files);
+
+          for (int j = 0; j < files.size (); j++)
+            {
+              const cmt_string& name = files[j];
+              if (name != "") 
+                {
+                  if (!filter.has_source (name))
+                    {
+                      const cmt_string& line = build (name);
+                  
+                        //cout << ">>> name3=" << name << endl;
+                  
+                      add_line_to_text (line, dependencies);
+                    }
+                }
+            }
+        }
+    }
+
+  FILE* f = fopen (m_output_file_name.c_str (), "wb");
+
+  if (f == 0)
+    {
+      cerr << "Cannot open " << m_output_file_name << " for write" << endl;
+    }
+  else
+    {
+      dependencies.write (f);
+      fclose (f);
+    }
+}
+
+//--------------------------------------------------
+//  o text contains lines with a pattern like :
+//      key = xxxxx
+//
+//  o line follows the same pattern
+//
+//   This function appends <line> to <text> only if the key found in
+//  <line> is not found in <text>
+//--------------------------------------------------
+void DependencyGenerator::add_line_to_text (const cmt_string& line, cmt_string& text)
+{
+  static const cmt_string empty;
+
+  int pos = line.find (" = ");
+  if (pos != cmt_string::npos)
+    {
+      static cmt_string key;
+      line.substr (0, pos + 3, key);
+      pos = text.find (key);
+      if (pos != cmt_string::npos)
+        {
+	  // The key in line exists in text.
+	  // Now check if the key is exactly the same.
+
+          if ((pos == 0) || (text[pos -1] == '\n'))
+            {
+	      // The key is either in the first line or
+	      // exactly matches '^key = ...'
+
+              int nl = text.find (pos, "\n");
+              if (nl != cmt_string::npos)
+                {
+                  static cmt_string old;
+                  text.substr (pos, nl - pos + 1, old);
+                  text.replace (old, empty);
+                }
+              else
+                {
+                  text.erase (pos);
+                }
+            }
+        }
+    }
+  if (line != "")
+    {
+      text += line;
+      text += "\n";
+    }
+}
+
+cmt_string DependencyGenerator::build (const cmt_string& file_name)
+{
+  Log;
+
+  const Constituent& constituent = *m_constituent;
+
+  static cmt_string full_name;
+  static cmt_string suffix;
+  static cmt_string name;
+  static cmt_string line;
+
+  full_name = "";
+  line = "";
+
+  if (!CmtSystem::absolute_path (file_name))
+    {
+      full_name = srcdir;
+    }
+
+  full_name += file_name;
+
+  CmtSystem::get_dot_suffix (full_name, suffix);
+  CmtSystem::basename (full_name, suffix, name);
+  CmtSystem::get_suffix (full_name, suffix);
+
+  if (name == "requirements") return (line);
+
+  const CmtSystem::cmt_string_vector& deps = m_deps_builder.run (full_name);
+
+  line  = name;
+  line += "_";
+  line += suffix;
+  line += "_dependencies = ";
+
+  filter_path (full_name);
+
+#ifdef WIN32
+  static const char quote = '\"';
+#else
+  static const char quote = ' ';
+#endif
+
+  line += quote;
+  line += full_name;
+  line += quote;
+
+  for (int j = 0; j < deps.size (); j++)
+    {
+      cmt_string d = deps[j];
+
+      log << "dep line = " << d << log_endl;
+
+      filter_path (d);
+
+      log << "filtered dep line = " << d << log_endl;
+
+      line += " ";
+      line += quote;
+      line += d;
+      line += quote;
+    }
+
+  Symbol::expand (line);
+
+  if (m_stamps)
+    {
+      cmt_string stamp_output_base = constituent.name;
+      stamp_output_base += "_deps";
+
+      cmt_string stamp_output = m_bin;
+      stamp_output += stamp_output_base;
+
+      if (!CmtSystem::mkdir (stamp_output))
+	{
+	  cerr << "Cannot create the binary output directory for this constituent" << endl;
+	}
+
+      stamp_output_base += CmtSystem::file_separator ();
+      stamp_output_base += name;
+      stamp_output_base += "_";
+      stamp_output_base += suffix;
+      stamp_output_base += ".stamp";
+
+      stamp_output = m_bin;
+      stamp_output += stamp_output_base;
+      
+      line += " $(bin)";
+      line += stamp_output_base;
+      
+      cmt_string old_stamp;
+      
+      if (CmtSystem::test_file (stamp_output))
+	{
+	  old_stamp.read (stamp_output);
+	}
+
+      if (line != old_stamp)
+	{
+	  line.write (stamp_output);
+	}
+    }
+
+  return (line);
+}
+
Index: /CMT/v1r20/source/cmt_generators.h
===================================================================
--- /CMT/v1r20/source/cmt_generators.h	(revision 368)
+++ /CMT/v1r20/source/cmt_generators.h	(revision 368)
@@ -0,0 +1,222 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_generators_h__
+#define __cmt_generators_h__
+
+#include "cmt_constituent.h"
+#include "cmt_fragment.h"
+#include "cmt_generator.h"
+
+class AnyDocumentGenerator : public CmtGenerator
+{
+public:
+  AnyDocumentGenerator ();
+
+protected:
+  void reset ();
+
+  Variable m_TITLE;
+  Variable m_STRUCTURED_OUTPUT;
+
+  FragmentHandle make_header_fragment;
+  FragmentHandle cleanup_header_fragment;
+  FragmentHandle cleanup_fragment;
+  FragmentHandle dependencies_fragment;
+  FragmentHandle dependencies_and_triggers_fragment;
+};
+
+class DocumentGenerator : public AnyDocumentGenerator
+{
+public:
+  DocumentGenerator ();
+  void build (const cmt_string& package,
+              const Constituent& constituent);
+
+private:
+  void reset ();
+  bool analyze_file (const cmt_string& file,
+		     const cmt_string& constituent_name,
+		     const cmt_string& output_suffix);
+
+  FragmentHandle document_header_fragment;
+};
+
+class LibraryGenerator : public AnyDocumentGenerator
+{
+public:
+  LibraryGenerator ();
+  void build (const cmt_string& package,
+              const Constituent& constituent);
+
+protected:
+  void reset ();
+  bool analyze_file (const Constituent& constituent,
+		     const cmt_string& file);
+  void java_file_action (SourceFile& file, const Constituent& constituent);
+  void proto_file_action (const cmt_string& file, const Constituent& constituent);
+  void prepare_proto_file (const cmt_string& file);
+  void module_file_action (SourceFile& file, const Constituent& constituent);
+
+  FragmentHandle library_header_fragment;
+  FragmentHandle application_header_fragment;
+  FragmentHandle java_header_fragment;
+  FragmentHandle jar_header_fragment;
+  FragmentHandle library_fragment;
+  FragmentHandle library_no_share_fragment;
+  FragmentHandle application_fragment;
+  FragmentHandle jar_fragment;
+  FragmentHandle java_fragment;
+  FragmentHandle java_copy_fragment;
+  FragmentHandle cleanup_library_fragment;
+  FragmentHandle cleanup_application_fragment;
+  FragmentHandle cleanup_java_fragment;
+  FragmentHandle cleanup_objects_fragment;
+  FragmentHandle buildproto_fragment;
+  FragmentHandle check_application_fragment;
+  FragmentHandle check_java_fragment;
+  FragmentHandle protos_header_fragment;
+};
+
+class ApplicationGenerator : public LibraryGenerator
+{
+public:
+};
+
+class ReadmeGenerator : public CmtGenerator
+{
+public:
+  ReadmeGenerator ();
+  void build (const CmtSystem::cmt_string_vector& arguments);
+
+private:
+  void reset ();
+
+  FragmentHandle readme_header_fragment;
+  FragmentHandle readme_fragment;
+  FragmentHandle readme_doc_fragment;
+  FragmentHandle readme_use_fragment;
+  FragmentHandle readme_trailer_fragment;
+};
+
+class PrototypeGenerator : public CmtGenerator
+{
+public:
+  void build (const cmt_string& file_name);
+};
+
+class DefaultMakefileGenerator : public CmtGenerator
+{
+public:
+  void build ();
+};
+
+class MSDEVGenerator : public CmtGenerator
+{
+public:
+  MSDEVGenerator ();
+  int build_workspace (const Constituent::ConstituentVector& constituents);
+  int build_project (const Constituent& constituent);
+
+private:
+  void reset ();
+
+  cmt_string msdevdir;
+
+  FragmentHandle dsw_header_fragment;
+  FragmentHandle dsw_project_fragment;
+  FragmentHandle dsw_all_project_header_fragment;
+  FragmentHandle dsw_all_project_dependency_fragment;
+  FragmentHandle dsw_all_project_trailer_fragment;
+  FragmentHandle dsw_trailer_fragment;
+
+  FragmentHandle dsp_all_fragment;
+  FragmentHandle dsp_library_header_fragment;
+  FragmentHandle dsp_application_header_fragment;
+  FragmentHandle dsp_windows_header_fragment;
+  FragmentHandle dsp_contents_fragment;
+  FragmentHandle dsp_trailer_fragment;
+
+};
+
+class VSNETGenerator : public CmtGenerator
+{
+public:
+  VSNETGenerator ();
+  int build_workspace (const Constituent::ConstituentVector& constituents);
+  int build_project (const Constituent& constituent);
+
+private:
+  void reset ();
+
+  void pseudoGUID (const cmt_string& a, 
+                   const cmt_string& b, 
+                   const cmt_string& c, 
+                   cmt_string& d);
+
+  cmt_string vsnetdir;
+
+    //Visual Studio.net Support
+  FragmentHandle sln_header_fragment;
+  FragmentHandle sln_project_fragment;
+  FragmentHandle sln_dependency_header_fragment;
+  FragmentHandle sln_dependency_project_fragment;
+  FragmentHandle sln_dependency_trailer_fragment;
+  FragmentHandle sln_project_config_fragment;
+  FragmentHandle sln_trailer_fragment;
+
+  FragmentHandle vcproj_all_fragment;
+  FragmentHandle vcproj_library_header_fragment;
+  FragmentHandle vcproj_application_header_fragment;
+  FragmentHandle vcproj_windows_header_fragment;
+  FragmentHandle vcproj_contents_fragment;
+  FragmentHandle vcproj_directory_header_fragment;
+  FragmentHandle vcproj_directory_trailer_fragment;
+  FragmentHandle vcproj_trailer_fragment;
+};
+
+class MakeSetupGenerator : public CmtGenerator
+{
+public:
+  MakeSetupGenerator ();
+  void build (const cmt_string& package);
+
+private:
+  void reset ();
+
+  FragmentHandle make_setup_header_fragment;
+  FragmentHandle make_setup_fragment;
+};
+
+class ConstituentsMakefileGenerator : public CmtGenerator
+{
+public:
+  ConstituentsMakefileGenerator ();
+  void build (const cmt_string& package,
+	      const CmtSystem::cmt_string_vector& arguments);
+
+private:
+  void reset ();
+
+  FragmentHandle constituents_header_fragment;
+  FragmentHandle constituents_trailer_fragment;
+  FragmentHandle group_fragment;
+  FragmentHandle constituent_fragment;
+  FragmentHandle check_application_header_fragment;
+};
+
+class DependencyGenerator : public CmtGenerator
+{
+public:
+  void build (const CmtSystem::cmt_string_vector& arguments);
+
+private:
+  void add_line_to_text (const cmt_string& line, cmt_string& text);
+  cmt_string build (const cmt_string& file_name);
+  bool m_stamps;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_group.cxx
===================================================================
--- /CMT/v1r20/source/cmt_group.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_group.cxx	(revision 368)
@@ -0,0 +1,149 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_group.h"
+#include "cmt_database.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Groups                                    */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+//----------------------------------------------------------
+Group* Group::find (const cmt_string& name)
+//----------------------------------------------------------
+{
+  static GroupVector& Groups = groups ();
+
+  for (int i = 0; i < Groups.size (); i++)
+    {
+      Group& v = Groups[i];
+
+      if (v.m_name == name) return (&v);
+    }
+
+  return (0);
+}
+
+//----------------------------------------------------------
+Group* Group::add (const cmt_string& name)
+//----------------------------------------------------------
+{
+  static GroupVector& Groups = groups ();
+
+  {
+    Group* group;
+
+    group = find (name);
+    if (group != 0) return (group);
+  }
+
+  Group& group = Groups.add ();
+  group.set (name);
+
+  return (&group);
+}
+
+//----------------------------------------------------------
+Group::GroupVector& Group::groups ()
+//----------------------------------------------------------
+{
+  static Database& db = Database::instance ();
+  static GroupVector& Groups = db.groups ();
+
+  return (Groups);
+}
+
+/*----------------------------------------------------------*/
+void Group::clear_all ()
+/*----------------------------------------------------------*/
+{
+  static GroupVector& Groups = groups ();
+
+  for (int i = 0; i < Groups.size (); i++)
+    {
+      Group& group = Groups[i];
+      group.clear ();
+    }
+
+  Groups.clear ();
+}
+
+/*----------------------------------------------------------*/
+void Group::show_all ()
+/*----------------------------------------------------------*/
+{
+  static GroupVector& Groups = groups ();
+
+  for (int i = 0; i < Groups.size (); i++)
+    {
+      Group& group = Groups[i];
+      cout << group.m_name << endl;
+    }
+}
+
+//----------------------------------------------------------
+Group::Group ()
+//----------------------------------------------------------
+{
+}
+
+//----------------------------------------------------------
+Group::Group (const cmt_string& name) : m_name (name)
+//----------------------------------------------------------
+{
+}
+
+//----------------------------------------------------------
+const cmt_string& Group::name () const
+//----------------------------------------------------------
+{
+  return (m_name);
+}
+
+//----------------------------------------------------------
+void Group::set (const cmt_string& name)
+//----------------------------------------------------------
+{
+  m_name = name;
+}
+
+//----------------------------------------------------------
+void Group::clear ()
+//----------------------------------------------------------
+{
+  m_name = "";
+}
+
+//----------------------------------------------------------
+Group& Group::operator = (const Group& other)
+//----------------------------------------------------------
+{
+  m_name = other.m_name;
+
+  return (*this);
+}
+
+//----------------------------------------------------------
+bool Group::operator == (const cmt_string& name) const
+//----------------------------------------------------------
+{
+  return ((m_name == name));
+}
+
+//----------------------------------------------------------
+bool Group::operator != (const cmt_string& name) const
+//----------------------------------------------------------
+{
+  return ((m_name != name));
+}
+
Index: /CMT/v1r20/source/cmt_group.h
===================================================================
--- /CMT/v1r20/source/cmt_group.h	(revision 368)
+++ /CMT/v1r20/source/cmt_group.h	(revision 368)
@@ -0,0 +1,44 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_group_h__
+#define __cmt_group_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+
+class Group
+{
+public:
+
+  typedef cmt_vector<Group> GroupVector;
+
+  static Group* find (const cmt_string& name);
+  static Group* add (const cmt_string& name);
+
+  static GroupVector& groups ();
+  static void clear_all ();
+  static void show_all ();
+
+public:
+
+  Group ();
+  Group (const cmt_string& name);
+
+  const cmt_string& name () const;
+  void set (const cmt_string& new_name);
+  void clear ();
+
+  Group& operator = (const Group& other);
+  bool operator == (const cmt_string& name) const;
+  bool operator != (const cmt_string& name) const;
+
+private:
+  cmt_string m_name;
+  cmt_string m_macro;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_include.cxx
===================================================================
--- /CMT/v1r20/source/cmt_include.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_include.cxx	(revision 368)
@@ -0,0 +1,195 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_include.h"
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+#include "cmt_log.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Include                                   */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+/**
+   Executed to parse an include_dirs statement
+   It postpones the macro expansion to the post-processing stage
+   (during set_standard_macros) 
+ */
+void Include::action (const CmtSystem::cmt_string_vector& words, Use* use)
+{
+  cmt_string name;
+
+  if (use == 0) use = &(Use::current());
+
+  if (Cmt::get_current_access () == UserMode)
+    {
+      if (use->get_current_scope () == ScopePrivate) return;
+    }
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      /*
+	statement words may contain macro references at that level
+	they are stored as they are.
+	They will be expanded later on using the parse_all method
+
+	(called from set_standard_macros)
+
+       */
+      name = words[i];
+      if (name == "") return;
+
+      add (name, use);
+    }
+}
+
+/**
+   Search a database entry for this include_dirs matching the
+   duet {name, use}
+ */
+Include* Include::find (const cmt_string& name, Use* use)
+{
+  int include_index;
+
+  if (use == 0) use = &(Use::current());
+
+  if (use->includes.size () == 0) return (0);
+
+  for (include_index = 0;
+       include_index < use->includes.size ();
+       include_index++)
+    {
+      Include& incl = use->includes[include_index];
+
+      if (incl.use != use) continue;
+
+      if (incl.name == name)
+        {
+          return (&incl);
+        }
+    }
+
+  return (0);
+}
+
+/**
+   Add a unique entry for this include_dirs specification given by the duet {name, use}
+ */
+Include* Include::add (const cmt_string& name, Use* use)
+{
+  if (name == "") return (0);
+
+  if (use == 0) use = &(Use::current());
+
+  {
+    Include* incl;
+
+    incl = find (name, use);
+    if (incl != 0) return (incl);
+  }
+
+  Include& incl = use->includes.add ();
+
+  incl.name = name;
+  incl.use = use;
+
+  return (&incl);
+}
+
+/*----------------------------------------------------------*/
+void Include::clear_all ()
+{
+  for (int include_number = 0;
+       include_number < (Use::current()).includes.size ();
+       include_number++)
+    {
+      Include& incl = (Use::current()).includes[include_number];
+
+      incl.clear ();
+    }
+}
+
+/**
+   Post processing of the include_dirs statements of a Use object.
+   This is meant to expand all macro references used in the
+   include_dirs statements
+
+   Note that this may create new Include objects. Thus the loop is
+   only performed onto the existing objects before the post-processing step
+ */
+void Include::parse_all (Use* use)
+{
+  int size;
+  int i;
+
+  size = use->includes.size ();
+  for (i = 0; i < size; i++)
+    {
+      Include& incl = use->includes[i];
+
+      incl.parse ();
+    }
+}
+
+/*----------------------------------------------------------*/
+void Include::clear ()
+{
+  use = 0;
+}
+
+/**
+   Post processing of an include_dirs statement.
+
+   The name field is expanded for its macro references
+   and split into individual words.
+   Each word in turn generates a new Include object
+   The old Include object is inactivated by setting an empty name
+ */
+void Include::parse ()
+{
+  cmt_string new_name = name;
+
+  Symbol::expand (new_name);
+
+  if (new_name == name) return;
+
+  CmtSystem::cmt_string_vector ws;
+
+  ws.clear ();
+
+  CmtSystem::split (new_name, " ", ws);
+
+  name = "";
+
+  for (int j = 0; j < ws.size (); j++)
+    {
+      const cmt_string& w = ws[j];
+
+      add (w, use);
+    }
+
+  use = 0;
+}
+
+/*----------------------------------------------------------*/
+Include::Include ()
+{
+  clear ();
+}
+
+/*----------------------------------------------------------*/
+Include::~Include ()
+{
+  use = 0;
+}
+
Index: /CMT/v1r20/source/cmt_include.h
===================================================================
--- /CMT/v1r20/source/cmt_include.h	(revision 368)
+++ /CMT/v1r20/source/cmt_include.h	(revision 368)
@@ -0,0 +1,34 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_include_h__
+#define __cmt_include_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+
+class Include
+{
+public:
+  typedef cmt_vector<Include> IncludeVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words, Use* use);
+  static Include* find (const cmt_string& name, Use* use);
+  static Include* add (const cmt_string& name, Use* use);
+  static void parse_all (Use* use);
+  static void clear_all ();
+
+public:
+  Include ();
+  ~Include ();
+  void parse ();
+  void clear ();
+
+  cmt_string name;
+  Use* use;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_install_area.cxx
===================================================================
--- /CMT/v1r20/source/cmt_install_area.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_install_area.cxx	(revision 368)
@@ -0,0 +1,201 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_system.h"
+#include "cmt.h"
+#include "cmt_install_area.h"
+#include "cmt_syntax.h"
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+#include "cmt_cmtpath_pattern.h"
+#include "cmt_project.h"
+
+CmtInstallAreaMgr& CmtInstallAreaMgr::instance ()
+{
+  static CmtInstallAreaMgr me;
+
+  return (me);
+}
+
+void CmtInstallAreaMgr::setup_current_installarea ()
+{
+  m_installarea = build_current_installarea ();
+
+  if (m_installarea == "") return;
+
+  cmt_string macro_name;
+
+  Project* project = Project::find_by_cmtpath (m_installarea);
+
+  if (project != 0)
+    {
+      macro_name = project->get_name ();
+    }
+  else
+    {
+      macro_name = "cmt";
+    }
+
+  macro_name += "_installarea_prefix";
+
+  Symbol* macro = Symbol::find (macro_name);
+
+  cmt_string installarea_prefix;
+
+  if (macro != 0)
+    {
+      installarea_prefix = macro->build_macro_value ();
+    }
+
+  if (installarea_prefix != "")
+    {
+      m_installarea += CmtSystem::file_separator ();
+      m_installarea += installarea_prefix;
+    }
+
+  Use& current_use = Use::current ();
+  cmt_string buffer;
+
+  if (!Symbol::is_selected ("CMTINSTALLAREA"))
+    {
+      buffer = "macro CMTINSTALLAREA \"";
+      buffer += m_installarea;
+      buffer += "\"";
+      
+      SyntaxParser::parse_requirements_line (buffer, &current_use);
+      buffer = "";
+    }
+}
+
+void CmtInstallAreaMgr::setup ()
+{
+  m_installarea = build_current_installarea ();
+
+  setup_current_installarea ();
+}
+
+void CmtInstallAreaMgr::config () const
+{
+  cmt_string installarea = build_current_installarea ();
+
+  CmtPathPattern::apply_all ();
+
+  if (installarea == "") return;
+
+  // cout << "InstallArea installed in " << installarea << endl;
+
+  if (!Cmt::get_quiet ())
+    {
+      cerr << "#CMT> Warning: Doing cleanup in the installation area " << installarea << endl;
+    }
+
+  Symbol* macro = Symbol::find ("cmt_installarea_paths");
+  if (macro == 0) return;
+  cmt_string installarea_paths = macro->build_macro_value ();
+
+  CmtSystem::cmt_string_vector areapaths;
+  CmtSystem::split (installarea_paths, " \t", areapaths);
+
+    // Try a cleanup only in this selected install area
+
+  for (int i = 0; i < areapaths.size (); i++)
+    {
+      const cmt_string& p = areapaths[i];
+      
+      cmt_string path = installarea;
+      path += CmtSystem::file_separator ();
+      path += p;
+      
+      Symbol::expand (path);
+
+      path.replace_all ("/", CmtSystem::file_separator ());
+      path.replace_all ("\\", CmtSystem::file_separator ());
+      
+      CmtSystem::cmt_string_vector refs;
+      cmt_regexp expression (".*[.]cmtref$");
+
+        // Look for all cmtref files in this PATH pattern
+
+      CmtSystem::scan_dir (path, expression, refs);
+      
+      for (int j = 0; j < refs.size (); j++)
+        {
+          const cmt_string& ref_file = refs[j];
+
+            // We get the absolute location of the installed file
+
+          cmt_string ref;
+          ref.read (ref_file);
+          int pos;
+
+	  ref.replace_all ("\"", "");
+
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "CmtInstallAreaMgr::config> " << ref_file << " " << ref << endl;
+	    }
+
+	  pos = ref.find ("\r\n");
+          if (pos != cmt_string::npos) ref.erase (pos);
+	  pos = ref.find ('\n');
+          if (pos != cmt_string::npos) ref.erase (pos);
+	  pos = ref.find ('\r');
+          if (pos != cmt_string::npos) ref.erase (pos);
+	  pos = ref.find (' ');
+          if (pos != cmt_string::npos) ref.erase (pos);
+
+            //  If the referenced file cannot be reached we remove the 
+            // corresponding installation
+            //  (this happens if the referenced file has be removed, or 
+            //   moved away)
+          
+          if (!CmtSystem::test_file (ref))
+            {
+              cmt_string ref_name;
+
+                // Get the name of the referenced file
+              CmtSystem::basename (ref, ref_name);
+
+                // Get the installation directory
+              CmtSystem::dirname (ref_file, ref);
+
+              ref += CmtSystem::file_separator ();
+              ref += ref_name;
+              
+                // Remove both the installed file
+                // and the reference file
+
+	      if (!Cmt::get_quiet ())
+		{
+		  cout << "# Removing obsolete installed file ["  << ref << "]";
+		  cout << "  (and " << ref_file << ")" << endl;
+		}
+
+              CmtSystem::remove_file (ref);
+              CmtSystem::remove_file (ref_file);
+            }
+        }
+    }
+}
+
+const cmt_string& CmtInstallAreaMgr::get_installarea () const
+{
+  return (m_installarea);
+}
+
+cmt_string CmtInstallAreaMgr::build_current_installarea () const
+{
+  cmt_string installarea;
+
+  const cmt_string pwd = CmtSystem::pwd ();
+
+  installarea = Project::find_in_cmt_paths (pwd);
+
+  return (installarea);
+}
+
+
+
Index: /CMT/v1r20/source/cmt_install_area.h
===================================================================
--- /CMT/v1r20/source/cmt_install_area.h	(revision 368)
+++ /CMT/v1r20/source/cmt_install_area.h	(revision 368)
@@ -0,0 +1,35 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_install_area_h__
+#define __cmt_install_area_h__
+
+class CmtInstallPathPattern
+{
+public:
+  cmt_string m_name;
+  cmt_string m_definition;
+};
+
+class CmtInstallAreaMgr
+{
+public:
+  static CmtInstallAreaMgr& instance ();
+
+public:
+  void setup_current_installarea ();
+  void setup ();
+  void config () const;
+  const cmt_string& get_installarea () const;
+
+private:
+  cmt_string build_current_installarea () const;
+  
+  cmt_vector <CmtInstallPathPattern> m_patterns;
+  cmt_string m_installarea;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_language.cxx
===================================================================
--- /CMT/v1r20/source/cmt_language.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_language.cxx	(revision 368)
@@ -0,0 +1,362 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_language.h"
+#include "cmt_system.h"
+#include "cmt_database.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Language                                  */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+/*----------------------------------------------------------*/
+void Language::show (const cmt_string& name)
+/*----------------------------------------------------------*/
+{
+  Language& language = find (name);
+
+  if (language == null ()) return;
+
+  language.show ();
+}
+
+/*----------------------------------------------------------*/
+void Language::show_all ()
+/*----------------------------------------------------------*/
+{
+  static LanguageVector& Languages = languages ();
+
+  int number;
+
+  for (number = 0; number < Languages.size (); number++)
+    {
+      Language& language = Languages[number];
+
+      language.show ();
+    }
+}
+
+/*----------------------------------------------------------*/
+void Language::show_names ()
+/*----------------------------------------------------------*/
+{
+  static LanguageVector& Languages = languages ();
+
+  int number;
+
+  for (number = 0; number < Languages.size (); number++)
+    {
+      Language& language = Languages[number];
+      cout << language.m_name << endl;
+    }
+}
+
+/*----------------------------------------------------------*/
+void Language::setup_all_fragments ()
+/*----------------------------------------------------------*/
+{
+  static LanguageVector& Languages = languages ();
+
+  int language_index;
+
+  if (Languages.size () == 0) return;
+
+  for (language_index = 0;
+       language_index < Languages.size ();
+       language_index++)
+    {
+      Language& language = Languages[language_index];
+
+      language.setup_fragments ();
+    }
+}
+
+/*----------------------------------------------------------*/
+Language& Language::find (const cmt_string& name)
+/*----------------------------------------------------------*/
+{
+  static LanguageVector& Languages = languages ();
+
+  int language_index;
+
+  if (Languages.size () == 0) return (null ());
+
+  for (language_index = 0;
+       language_index < Languages.size ();
+       language_index++)
+    {
+      Language& language = Languages[language_index];
+
+      if (language.m_name == name)
+        {
+          return (language);
+        }
+    }
+
+  return (null ());
+}
+
+/*----------------------------------------------------------*/
+Language& Language::find_with_suffix (const cmt_string& suffix)
+/*----------------------------------------------------------*/
+{
+  static LanguageVector& Languages = languages ();
+
+  int language_index;
+
+  if (Languages.size () == 0) return (null ());
+
+  for (language_index = 0;
+       language_index < Languages.size ();
+       language_index++)
+    {
+      Language& language = Languages[language_index];
+
+      for (int suffix_index = 0;
+           suffix_index < language.suffixes.size ();
+           suffix_index++)
+        {
+          cmt_string& s = language.suffixes[suffix_index];
+
+          if (s == suffix) return (language);
+        }
+    }
+
+  return (null ());
+}
+
+/*----------------------------------------------------------*/
+void Language::action (const CmtSystem::cmt_string_vector& words)
+/*----------------------------------------------------------*/
+{
+  cmt_string name;
+
+  int i = 1;
+
+  name = words[i];
+  if (name == "") return;
+  i++;
+
+  Language& language = add (name);
+
+  for (;i < words.size (); i++)
+    {
+      cmt_string& w = words[i];
+      if (w == "") break;
+
+      if (w.substr (0, 8) == "-suffix=")
+        {
+          cmt_string& suffix = language.suffixes.add ();
+
+          suffix.erase (0);
+          w.substr (8, suffix);
+        }
+      else if (w.substr (0, 8) == "-linker=")
+        {
+          w.substr (8, language.linker);
+        }
+      else if (w.substr (0, 11) == "-prototypes")
+        {
+          language.prototypes = true;
+        }
+      else if (w.substr (0, 22) == "-preprocessor_command=")
+        {
+          w.substr (22, language.preprocessor_command);
+        }
+      else if (w.substr (0, 10) == "-fragment=")
+        {
+          w.substr (10, language.fragment_name);
+        }
+      else if (w.substr (0, 15) == "-output_suffix=")
+        {
+          w.substr (15, language.output_suffix);
+        }
+      else if (w.substr (0, 21) == "-extra_output_suffix=")
+        {
+          cmt_string& suffix = language.extra_output_suffixes.add ();
+
+          suffix.erase (0);
+          w.substr (21, suffix);
+        }
+    }
+}
+
+/*----------------------------------------------------------*/
+Language& Language::add (const cmt_string& name)
+/*----------------------------------------------------------*/
+{
+  static LanguageVector& Languages = languages ();
+
+  if (name == "") return (null ());
+
+  {
+    Language& language = find (name);
+    if (language != null ()) return (language);
+  }
+
+  Language& language = Languages.add ();
+
+  language.clear ();
+  language.m_name = name;
+  language.fragment_name = name;
+
+  return (language);
+}
+
+
+/*----------------------------------------------------------*/
+void Language::clear_all ()
+/*----------------------------------------------------------*/
+{
+  static LanguageVector& Languages = languages ();
+
+  for (int i = 0; i < Languages.size (); i++)
+    {
+      Language& c = Languages[i];
+      c.clear ();
+    }
+  Languages.clear ();
+}
+
+/*----------------------------------------------------------*/
+Language::LanguageVector& Language::languages ()
+/*----------------------------------------------------------*/
+{
+  static Database& db = Database::instance ();
+  static LanguageVector& Languages = db.languages ();
+
+  return (Languages);
+}
+
+/*----------------------------------------------------------*/
+Language& Language::null ()
+/*----------------------------------------------------------*/
+{
+  static Language null_instance;
+
+  return (null_instance);
+}
+
+/*----------------------------------------------------------*/
+Language::Language ()
+/*----------------------------------------------------------*/
+{
+  clear ();
+}
+
+/*----------------------------------------------------------*/
+Language::~Language ()
+/*----------------------------------------------------------*/
+{
+}
+
+/*----------------------------------------------------------*/
+void Language::clear ()
+/*----------------------------------------------------------*/
+{
+  m_name = "";
+  linker = "none";
+  prototypes = false;
+  preprocessor_command = "-I";
+  fragment_name = "";
+  output_suffix = "";
+  suffixes.clear ();
+  extra_output_suffixes.clear ();
+}
+
+/*----------------------------------------------------------*/
+void Language::show ()
+/*----------------------------------------------------------*/
+{
+  cout << "language " << m_name;
+
+  int i;
+
+  for (i = 0; i < (suffixes.size ()); i++)
+    {
+      cmt_string& suffix = suffixes[i];
+      
+      cout << " -suffix=" << suffix;
+    }
+
+  if (linker != "")
+    {
+      cout << " -linker=" << linker;
+    }
+
+  if (prototypes)
+    {
+      cout << " -prototypes";
+    }
+
+  if (preprocessor_command != "-I")
+    {
+      cout << " -preprocessor_command=" << preprocessor_command;
+    }
+
+  if (fragment_name != m_name)
+    {
+      cout << " -fragment=" << fragment_name;
+    }
+
+  if (output_suffix != "")
+    {
+      cout << " -output_suffix=" << output_suffix;
+    }
+
+  for (i = 0; i < extra_output_suffixes.size (); i++)
+    {
+      cmt_string& suffix = extra_output_suffixes[i];
+      
+      cout << " -extra_output_suffix=" << suffix;
+    }
+
+  cout << endl;
+}
+
+/*----------------------------------------------------------*/
+void Language::setup_fragments ()
+/*----------------------------------------------------------*/
+{
+  cmt_string n = fragment_name;
+
+  application.set (n);
+
+  n += "_library";
+
+  library.set (n);
+}
+
+/*----------------------------------------------------------*/
+bool Language::operator == (const cmt_string& name) const
+/*----------------------------------------------------------*/
+{
+  if (m_name == name) return (true);
+  return (false);
+}
+
+/*----------------------------------------------------------*/
+bool Language::operator == (const Language& other) const
+/*----------------------------------------------------------*/
+{
+  if (this == &other) return (true);
+  return (false);
+}
+
+/*----------------------------------------------------------*/
+bool Language::operator != (const Language& other) const
+/*----------------------------------------------------------*/
+{
+  if (this != &other) return (true);
+  return (false);
+}
Index: /CMT/v1r20/source/cmt_language.h
===================================================================
--- /CMT/v1r20/source/cmt_language.h	(revision 368)
+++ /CMT/v1r20/source/cmt_language.h	(revision 368)
@@ -0,0 +1,52 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_language_h__
+#define __cmt_language_h__
+
+#include "cmt_parser.h"
+#include "cmt_fragment.h"
+
+class Language
+{
+public:
+  typedef cmt_vector<Language> LanguageVector;
+  static void action (const CmtSystem::cmt_string_vector& words);
+  static Language& find (const cmt_string& name);
+  static Language& find_with_suffix (const cmt_string& suffix);
+  static Language& add (const cmt_string& name);
+  static void show (const cmt_string& name);
+  static void show_all ();
+  static void show_names ();
+  static void setup_all_fragments ();
+  static void clear_all ();
+  static LanguageVector& languages ();
+  static Language& null ();
+
+public:
+  Language ();
+  ~Language ();
+  void clear ();
+  void show ();
+  void setup_fragments ();
+  bool operator == (const cmt_string& name) const;
+  bool operator == (const Language& other) const;
+  bool operator != (const Language& other) const;
+
+  cmt_string m_name;
+  cmt_string fragment_name;
+  cmt_string linker;
+  cmt_string output_suffix;
+  bool prototypes;
+  cmt_string preprocessor_command;
+  CmtSystem::cmt_string_vector suffixes;
+  CmtSystem::cmt_string_vector extra_output_suffixes;
+
+  FragmentHandle application;
+  FragmentHandle library;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_license.h
===================================================================
--- /CMT/v1r20/source/cmt_license.h	(revision 368)
+++ /CMT/v1r20/source/cmt_license.h	(revision 368)
@@ -0,0 +1,5 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
Index: /CMT/v1r20/source/cmt_license.sh
===================================================================
--- /CMT/v1r20/source/cmt_license.sh	(revision 368)
+++ /CMT/v1r20/source/cmt_license.sh	(revision 368)
@@ -0,0 +1,5 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
Index: /CMT/v1r20/source/cmt_license.txt
===================================================================
--- /CMT/v1r20/source/cmt_license.txt	(revision 368)
+++ /CMT/v1r20/source/cmt_license.txt	(revision 368)
@@ -0,0 +1,34 @@
+
+Copyright Christian Arnault LAL-Orsay CNRS 2004
+
+arnault@lal.in2p3.fr
+
+This software is a computer program whose purpose is to describe and
+manage software configuration activities.
+
+This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use, 
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info". 
+
+As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability. 
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or 
+data to be ensured and,  more generally, to use and operate it in the 
+same conditions as regards security. 
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
Index: /CMT/v1r20/source/cmt_list.h
===================================================================
--- /CMT/v1r20/source/cmt_list.h	(revision 368)
+++ /CMT/v1r20/source/cmt_list.h	(revision 368)
@@ -0,0 +1,550 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_list_h__
+#define __cmt_list_h__
+
+#include <iostream>
+
+template <class T>
+class cmt_list_node
+{
+public:
+  cmt_list_node (const T& t) : m_left(0), m_t(t), m_right(0)
+  {
+  }
+
+  ~cmt_list_node ()
+  {
+  }
+
+  cmt_list_node<T>* m_left;
+  T m_t;
+  cmt_list_node<T>* m_right;
+};
+
+template <class T>
+class cmt_list
+{
+public:
+  typedef cmt_list_node<T> NodeV;
+  typedef NodeV* Node;
+
+  class iterator
+  {
+  public:
+    iterator () : m_node (0)
+    {
+    }
+
+    iterator (Node node) : m_node (node)
+    {
+    }
+
+    iterator& operator ++ ()
+    {
+      if (m_node == 0) return (*this);
+      m_node = m_node->m_right;
+      return (*this);
+    }
+
+    iterator& operator -- ()
+    {
+      if (m_node == 0) return (*this);
+      m_node = m_node->m_left;
+      return (*this);
+    }
+
+    int operator == (const iterator& other) const
+    {
+      return (m_node == other.m_node);
+    }
+
+    int operator != (const iterator& other) const
+    {
+      const iterator& me = *this;
+      return (! (me == other));
+    }
+
+    T& operator * () const
+    {
+      if (m_node == 0)
+	{
+	  static T t;
+
+	  return (t);
+	}
+      else
+	{
+	  return (m_node->m_t);
+	}
+    }
+
+    Node get_node () const
+    {
+      return (m_node);
+    }
+
+  private:
+    Node m_node;
+  };
+
+  class const_iterator
+  {
+  public:
+    const_iterator () : m_node (0)
+    {
+    }
+
+    const_iterator (const Node node) : m_node (node)
+    {
+    }
+
+    const_iterator& operator ++ ()
+    {
+      if (m_node == 0) return (*this);
+      m_node = m_node->m_right;
+      return (*this);
+    }
+
+    const_iterator& operator -- ()
+    {
+      if (m_node == 0) return (*this);
+      m_node = m_node->m_left;
+      return (*this);
+    }
+
+    int operator == (const const_iterator& other) const
+    {
+      return (m_node == other.m_node);
+    }
+
+    int operator != (const const_iterator& other) const
+    {
+      const iterator& me = *this;
+      return (! (me == other));
+    }
+
+    const T& operator * () const
+    {
+      if (m_node == 0)
+	{
+	  static const T t;
+	  return (t);
+	}
+      else
+	{
+	  return (m_node->m_t);
+	}
+    }
+
+    const Node get_node () const
+    {
+      return (m_node);
+    }
+
+  private:
+    const Node m_node;
+  };
+
+  cmt_list ()
+  {
+    m_first = 0;
+    m_last = 0;
+  }
+
+  ~cmt_list ()
+  {
+    while (m_last != 0)
+      {
+	remove (m_last);
+      }
+  }
+
+  void push_front (const T& t)
+  {
+    Node node = new NodeV (t);
+
+    if (m_first == 0)
+      {
+	m_last = node;
+      }
+    else
+      {
+	m_first->m_left = node;
+	node->m_right = m_first;
+      }
+    m_first = node;
+  }
+
+  void push_back (const T& t)
+  {
+    Node node = new NodeV (t);
+
+    if (m_last == 0)
+      {
+	m_first = node;
+      }
+    else
+      {
+	m_last->m_right = node;
+	node->m_left = m_last;
+      }
+    m_last = node;
+  }
+
+  void pop_front ()
+  {
+    remove (m_first);
+  }
+
+  void pop_back ()
+  {
+    remove (m_last);
+  }
+
+  void erase (iterator it)
+  {
+    remove (it.get_node ());
+  }
+
+  void erase (const_iterator it)
+  {
+    remove (it.get_node ());
+  }
+
+  int size ()
+  {
+    int count = 0;
+    Node node = m_first;
+    while (node != 0)
+      {
+	node = node->m_right;
+	count++;
+      }
+
+    return (count);
+  }
+
+  iterator begin ()
+  {
+    return (iterator (m_first));
+  }
+
+  iterator last ()
+  {
+    return (iterator (m_last));
+  }
+
+  iterator end ()
+  {
+    iterator it;
+    return (it);
+  }
+
+  const_iterator begin () const
+  {
+    return (const_iterator (m_first));
+  }
+
+  const_iterator last () const
+  {
+    return (const_iterator (m_last));
+  }
+
+  const_iterator end () const
+  {
+    const_iterator it;
+    return (it);
+  }
+
+  void exchange (iterator it1, iterator it2)
+  {
+    if (it1 == it2) return;
+
+    Node node1 = it1.get_node ();
+    if (node1 == 0) return;
+    Node node2 = it2.get_node ();
+    if (node2 == 0) return;
+
+    Node l1 = node1->m_left;
+    Node r1 = node1->m_right;
+    Node l2 = node2->m_left;
+    Node r2 = node2->m_right;
+
+    Node f = m_first;
+    Node l = m_last;
+
+    if ((l2 != 0) && (l2 != node1)) l2->m_right = node1;
+    if ((r2 != 0) && (r2 != node1)) r2->m_left = node1;
+    if ((l1 != 0) && (l1 != node2)) r1->m_right = node2;
+    if ((r1 != 0) && (r1 != node2)) r1->m_left = node2;
+
+    node1->m_left  = l2;
+    node1->m_right = r2;
+    node2->m_left  = l1;
+    node2->m_right = r1;
+
+    if (node1 == f)
+      {
+	m_first = node2;
+      }
+
+    if (node1 == l)
+      {
+	m_last = node2;
+      }
+
+    if (node2 == f)
+      {
+	m_first = node1;
+      }
+
+    if (node2 == l)
+      {
+	m_last = node1;
+      }
+  }
+
+  void insert_before (iterator it, const T& t)
+  {
+    Node node = it.get_node ();
+
+    if (node == 0)
+      {
+	push_front (t);
+      }
+    else
+      {
+	Node new_node = new NodeV (t);
+
+	new_node->m_right = node;
+	new_node->m_left = node->m_left;
+
+	if (node->m_left != 0)
+	  {
+	    node->m_left->m_right = new_node;
+	  }
+
+	node->m_left = new_node;
+
+	if (node == m_first)
+	  {
+	    m_first = new_node;
+	  }
+      }
+  }
+
+  void insert_after (iterator it, const T& t)
+  {
+    Node node = it.get_node ();
+
+    if (node == 0)
+      {
+	push_back (t);
+      }
+    else
+      {
+	Node new_node = new NodeV (t);
+
+	new_node->m_left = node;
+	new_node->m_right = node->m_right;
+
+	if (node->m_right != 0)
+	  {
+	    node->m_right->m_left = new_node;
+	  }
+
+	node->m_right = new_node;
+
+	if (node == m_last)
+	  {
+	    m_last = new_node;
+	  }
+      }
+  }
+
+  void move_to_front (iterator source_it)
+  {
+    move_before (source_it, begin ());
+  }
+
+  void move_to_back (iterator source_it)
+  {
+    move_before (source_it, end ());
+  }
+
+  void move_before (iterator source_it, iterator dest_it)
+  {
+    if (source_it == dest_it) return;
+
+    Node source = source_it.get_node ();
+    if (source == 0) return;
+
+    Node dest = dest_it.get_node ();
+
+    // First remove the source
+
+    if (source == m_first)
+      {
+	m_first = source->m_right;
+      }
+
+    if (source == m_last)
+      {
+	m_last = source->m_left;
+      }
+
+    if (source->m_right != 0) source->m_right->m_left = source->m_left;
+    if (source->m_left != 0) source->m_left->m_right = source->m_right;
+
+    source->m_right = 0;
+    source->m_left = 0;
+
+    if (dest == 0)
+      {
+	// = move_to_back
+	
+	source->m_right = 0;
+	source->m_left = m_last;
+
+	if (m_last != 0)
+	  {
+	    m_last->m_right = source;
+	  }
+
+	m_last = source;
+
+	if (m_first == 0) m_first = source;
+      }
+    else
+      {
+	source->m_right = dest;
+	source->m_left = dest->m_left;
+
+	if (dest->m_left != 0)
+	  {
+	    dest->m_left->m_right = source;
+	  }
+
+	dest->m_left = source;
+
+	if (dest == m_first)
+	  {
+	    m_first = source;
+	  }
+      }
+  }
+
+  void move_after (iterator source_it, iterator dest_it)
+  {
+    if (source_it == dest_it) return;
+
+    Node source = source_it.get_node ();
+    if (source == 0) return;
+
+    Node dest = dest_it.get_node ();
+
+    // First remove the source
+
+    if (source == m_first)
+      {
+	m_first = source->m_right;
+      }
+
+    if (source == m_last)
+      {
+	m_last = source->m_left;
+      }
+
+    if (source->m_right != 0) source->m_right->m_left = source->m_left;
+    if (source->m_left != 0) source->m_left->m_right = source->m_right;
+
+    source->m_right = 0;
+    source->m_left = 0;
+
+    if (dest == 0)
+      {
+	// = move_to_front
+
+	source->m_left = 0;
+	source->m_right = m_first;
+
+	if (m_first != 0)
+	  {
+	    m_first->m_left = source;
+	  }
+
+	m_first = source;
+
+	if (m_last == 0) m_last = source;
+      }
+    else
+      {
+	source->m_left = dest;
+	source->m_right = dest->m_right;
+
+	if (dest->m_right != 0)
+	  {
+	    dest->m_right->m_left = source;
+	  }
+
+	dest->m_right = source;
+
+	if (dest == m_last)
+	  {
+	    m_last = source;
+	  }
+      }
+  }
+
+private:
+  void remove (Node node)
+  {
+    if (node == 0) return;
+
+    if (node == m_first)
+      {
+	m_first = node->m_right;
+      }
+
+    if (node == m_last)
+      {
+	m_last = node->m_left;
+      }
+
+    if (node->m_right != 0) node->m_right->m_left = node->m_left;
+    if (node->m_left != 0) node->m_left->m_right = node->m_right;
+
+    node->m_right = 0;
+    node->m_left = 0;
+
+    delete node;
+  }
+
+  Node m_first;
+  Node m_last;
+};
+
+class A
+{
+public:
+  A ()
+  {
+    static int id = 0;
+    i = id;
+    id++;
+  }
+
+  ~A ()
+  {
+    std::cout << "kill A i=" << i << std::endl;
+  }
+
+  int i;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_lock.cxx
===================================================================
--- /CMT/v1r20/source/cmt_lock.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_lock.cxx	(revision 368)
@@ -0,0 +1,130 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_std.h"
+#include "cmt_lock.h"
+#include "cmt_system.h"
+#include "cmt_error.h"
+#include "cmt_symbol.h"
+
+//----------------------------------------------------------
+CmtLock::status CmtLock::lock ()
+{
+  status s = check ();
+
+  switch (s)
+    {
+    case locked_by_user:
+      cout << "Package already locked by you" << endl;
+      return (s);
+    case locked_by_another_user:
+      CmtError::set (CmtError::cannot_lock, "lock> Package already locked by another user");
+      return (s);
+    case not_locked:
+      break;
+    }
+
+  cmt_string text = "locked by ";
+  text += CmtSystem::user ();
+  text += " date ";
+  text += CmtSystem::now ();
+
+  if (!text.write ("lock.cmt"))
+    {
+      CmtError::set (CmtError::cannot_write_lock, "lock>");
+      return (still_unlocked);
+    }
+
+  Symbol* lock_command = Symbol::find ("lock_command");
+  if (lock_command != 0)
+    {
+      cmt_string command = lock_command->build_macro_value ();
+
+      if (command != "")
+	{
+	  if (CmtSystem::execute (command) != 0)
+	    {
+	      CmtError::set (CmtError::cannot_run_lock_command, "lock>");
+	      return (still_unlocked);
+	    }
+	}
+    }
+
+  cout << "Package now locked" << endl;
+
+  return (locked_by_user);
+}
+
+//----------------------------------------------------------
+CmtLock::status CmtLock::unlock ()
+{
+  status s = check ();
+
+  switch (s)
+    {
+    case locked_by_user:
+      break;
+    case locked_by_another_user:
+      CmtError::set (CmtError::cannot_unlock, "unlock> Package locked by another user");
+      return (s);
+    case not_locked:
+      cout << "The package was not locked" << endl;
+      return (s);
+    }
+
+  Symbol* unlock_command = Symbol::find ("unlock_command");
+  if (unlock_command != 0)
+    {
+      cmt_string command = unlock_command->build_macro_value ();
+
+      if (command != "")
+	{
+	  if (CmtSystem::execute (command) != 0)
+	    {
+	      CmtError::set (CmtError::cannot_run_unlock_command, "unlock>");
+	      return (still_locked);
+	    }
+	}
+    }
+
+  if (!CmtSystem::remove_file ("lock.cmt"))
+    {
+      CmtError::set (CmtError::cannot_remove_lock, "unlock>");
+      return (still_locked);
+    }
+
+  cout << "Package now unlocked" << endl;
+
+  return (not_locked);
+}
+
+//----------------------------------------------------------
+CmtLock::status CmtLock::check ()
+{
+  cmt_string me = CmtSystem::user ();
+  cmt_string text;
+
+  if (text.read ("lock.cmt"))
+    {
+      CmtSystem::cmt_string_vector words;
+
+      CmtSystem::split (text, " ", words);
+
+      if (words.size () >= 3)
+	{
+	  if (words[2] == me)
+	    {
+	      return (locked_by_user);
+	    }
+	  else
+	    {
+	      return (locked_by_another_user);
+	    }
+	}
+    }
+	
+  return (not_locked);
+}
Index: /CMT/v1r20/source/cmt_lock.h
===================================================================
--- /CMT/v1r20/source/cmt_lock.h	(revision 368)
+++ /CMT/v1r20/source/cmt_lock.h	(revision 368)
@@ -0,0 +1,27 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_lock_h__
+#define __cmt_lock_h__
+
+class CmtLock
+{
+public:
+	typedef enum 
+	{
+		locked_by_user, 
+		locked_by_another_user, 
+		not_locked,
+		still_locked,
+		still_unlocked
+	} status;
+
+	static status lock ();
+	static status unlock ();
+	static status check ();
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_log.cxx
===================================================================
--- /CMT/v1r20/source/cmt_log.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_log.cxx	(revision 368)
@@ -0,0 +1,85 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+//#include <stdio.h>
+//#include <stdlib.h>
+//#include <stdio.h>
+//#include <string.h>
+#include "cmt_std.h"
+//#include "cmt_string.h"
+
+#include "cmt_log.h"
+#include "cmt.h"
+
+CmtLog::CmtLog ()
+{
+}
+
+CmtLogEnd& CmtLog::end ()
+{
+  static CmtLogEnd me;
+
+  return (me);
+}
+
+bool CmtLog::check ()
+{
+  if (Cmt::get_debug ()) return (true);
+  return (false);
+}
+
+CmtLog& CmtLog::operator << (const char* c)
+{
+  if (!check ()) return (*this);
+
+  cout << c;
+  return (*this);
+}
+
+CmtLog& CmtLog::operator << (const cmt_string& s)
+{
+  if (!check ()) return (*this);
+
+  cout << s;
+  return (*this);
+}
+
+CmtLog& CmtLog::operator << (int i)
+{
+  if (!check ()) return (*this);
+
+  cout << i;
+  return (*this);
+}
+
+CmtLog& CmtLog::operator << (double d)
+{
+  if (!check ()) return (*this);
+
+  cout << d;
+  return (*this);
+}
+
+CmtLog& CmtLog::operator << (void* p)
+{
+  if (!check ()) return (*this);
+
+  cout << p;
+  return (*this);
+}
+
+CmtLog& CmtLog::operator << (CmtLogEnd& end)
+{
+  if (!check ()) return (*this);
+
+  cout << endl;
+  return (*this);
+}
+
+CmtLog& CmtLog::operator << (CmtLogDummy& end)
+{
+  return (*this);
+}
Index: /CMT/v1r20/source/cmt_log.h
===================================================================
--- /CMT/v1r20/source/cmt_log.h	(revision 368)
+++ /CMT/v1r20/source/cmt_log.h	(revision 368)
@@ -0,0 +1,45 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_log_h__
+#define __cmt_log_h__
+
+#include "cmt_string.h"
+
+class CmtLogEnd
+{
+public:
+};
+
+class CmtLogDummy
+{
+public:
+};
+
+class CmtLog
+{
+public:
+  CmtLog ();
+
+  static CmtLogEnd& end ();
+  CmtLog& operator << (const cmt_string& s);
+  CmtLog& operator << (const char* c);
+  CmtLog& operator << (int i);
+  CmtLog& operator << (double d);
+  CmtLog& operator << (void* p);
+  CmtLog& operator << (CmtLogEnd& end);
+  CmtLog& operator << (CmtLogDummy& dummy);
+
+private:
+  bool check ();
+};
+
+#define Log static CmtLog log_instance
+#define log_endl CmtLog::end ()
+#define log      if (Cmt::get_debug ()) log_instance << "#CMT> (" << __FILE__ << "-" << __LINE__ << ") "
+#define log_cont if (Cmt::get_debug ()) log_instance
+
+#endif
Index: /CMT/v1r20/source/cmt_map.h
===================================================================
--- /CMT/v1r20/source/cmt_map.h	(revision 368)
+++ /CMT/v1r20/source/cmt_map.h	(revision 368)
@@ -0,0 +1,683 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_map_h__
+#define __cmt_map_h__
+
+#include "cmt_std.h"
+#include "cmt_string.h"
+#include "cmt_vector.h"
+
+#include <stdlib.h>
+
+/**
+ *    class cmt_node
+ *
+ *   Implements a binary tree of T* keyed by the class K
+ *
+ *   The class K must have the < and > operators.
+ *
+ *   This is the basic constituent for the cmt_map class.
+ */
+template <class K, class T> class cmt_node
+{
+public:
+
+  /**
+   * Required constructor.
+   * Provides the key and the value.
+   */
+  cmt_node (const K& key, T& t) : 
+    m_left (0),
+    m_key (key),
+    m_t (&t),
+    m_right (0)
+  {
+  }
+
+  /**
+   *  Destructor
+   */
+  ~cmt_node ()
+  {
+    clear ();
+  }
+
+  /**
+   *   Recursive clear operation. 
+   *   Will delete sub-nodes
+   */
+  void clear ()
+  {
+    if (m_left == 0) return;
+
+    delete m_left;
+    m_left = 0;
+
+    m_t = 0;
+
+    if (m_right == 0) return;
+
+    delete m_right;
+    m_right = 0;
+  }
+
+  /**
+   *  Add an item.
+   */
+  void add (const K& key, T& t)
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0)
+	  {
+	    m_left = new cmt_node (key, t);
+	  }
+	else
+	  {
+	    m_left->add (key, t);
+	  }
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0)
+	  {
+	    m_right = new cmt_node (key, t);
+	  }
+	else
+	  {
+	    m_right->add (key, t);
+	  }
+      }
+    else
+      {
+	m_t = &t;
+      }
+  }
+
+  /**
+   *   Finds whether the tree starting from this node 
+   *   contains this key
+   */
+  bool has (const K& key) const
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0) return (false);
+	else return (m_left->has (key));
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0) return (false);
+	else return (m_right->has (key));
+      }
+    else
+      {
+	return (true);
+      }
+  }
+
+  /**
+   *   Finds in the tree starting from this node 
+   *   the value associated with this key
+   *   Return 0 if not found
+   */
+  T* find (const K& key) const
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0) return (0);
+	else return (m_left->find (key));
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0) return (0);
+	else return (m_right->find (key));
+      }
+    else
+      {
+	return (m_t);
+      }
+  }
+
+  /**
+   *   Finds in the tree starting from this node 
+   *   the node holding the value associated with this key
+   *   Return 0 if not found
+   */
+  const cmt_node* find_node (const K& key) const
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0) return (0);
+	else return (m_left->find_node (key));
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0) return (0);
+	else return (m_right->find_node (key));
+      }
+    else
+      {
+	return (this);
+      }
+  }
+
+protected:
+  cmt_node<K,T>* m_left;
+  K m_key;
+  T* m_t;
+  cmt_node<K,T>* m_right;
+};
+
+
+template <class K, class T> class cmt_vnode
+{
+public:
+
+  /**
+   * Required constructor.
+   * Provides the key and the value.
+   */
+  cmt_vnode (const K& key, T& t) : 
+    m_left (0),
+    m_key (key),
+    m_t (t),
+    m_right (0)
+  {
+  }
+
+  /**
+   *  Destructor
+   */
+  ~cmt_vnode ()
+  {
+    clear ();
+  }
+
+  /**
+   *   Recursive clear operation. 
+   *   Will delete sub-nodes
+   */
+  void clear ()
+  {
+    if (m_left == 0) return;
+
+    delete m_left;
+    m_left = 0;
+
+    if (m_right == 0) return;
+
+    delete m_right;
+    m_right = 0;
+  }
+
+  /**
+   *  Add an item.
+   */
+  void add (const K& key, T& t)
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0)
+	  {
+	    m_left = new cmt_vnode (key, t);
+	  }
+	else
+	  {
+	    m_left->add (key, t);
+	  }
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0)
+	  {
+	    m_right = new cmt_vnode (key, t);
+	  }
+	else
+	  {
+	    m_right->add (key, t);
+	  }
+      }
+    else
+      {
+	m_t = t;
+      }
+  }
+
+  /**
+   *   Finds whether the tree starting from this node 
+   *   contains this key
+   */
+  bool has (const K& key) const
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0) return (false);
+	else return (m_left->has (key));
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0) return (false);
+	else return (m_right->has (key));
+      }
+    else
+      {
+	return (true);
+      }
+  }
+
+  /**
+   *   Finds in the tree starting from this node 
+   *   the value associated with this key
+   *   Return 0 if not found
+   */
+  const T* find (const K& key) const
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0) return (0);
+	else return (m_left->find (key));
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0) return (0);
+	else return (m_right->find (key));
+      }
+    else
+      {
+	return (&m_t);
+      }
+  }
+
+  /**
+   *   Finds in the tree starting from this node 
+   *   the node holding the value associated with this key
+   *   Return 0 if not found
+   */
+  const cmt_vnode* find_node (const K& key) const
+  {
+    if (key < m_key)
+      {	
+	if (m_left == 0) return (0);
+	else return (m_left->find_node (key));
+      }
+    else if (key > m_key)
+      {	
+	if (m_right == 0) return (0);
+	else return (m_right->find_node (key));
+      }
+    else
+      {
+	return (this);
+      }
+  }
+
+protected:
+  cmt_vnode<K,T>* m_left;
+  K m_key;
+  T m_t;
+  cmt_vnode<K,T>* m_right;
+};
+
+
+/**
+ *   Public interface for maps.
+ *   It is implemented by one top cmt_node.
+ *
+ *   At creation the map is empty. 
+ */
+template <class K, class T> class cmt_map
+{
+public:
+
+  /**
+   *  Constructor
+   */
+  cmt_map () : m_top (0)
+  {
+  }
+
+  /**
+   *  Destructor
+   */
+  ~cmt_map ()
+  {
+    clear ();
+  }
+
+  /**
+   * clear: erase everything from this map
+   */
+  void clear ()
+  {
+    if (m_top != 0)
+      {
+	delete m_top;
+	m_top = 0;
+      }
+  }
+
+  /**
+   *  Add an entry.
+   *
+   *  Existing entries with the same key will be overridden
+   */
+  void add (const K& key, T& t)
+  {
+    if (m_top == 0)
+      {
+	m_top = new cmt_node<K, T> (key, t);
+      }
+    else
+      {
+	m_top->add (key, t);
+      }
+  }
+
+  void add (const K& key, T* t)
+  {
+    if (m_top == 0)
+      {
+	m_top = new cmt_node<K, T> (key, *t);
+      }
+    else
+      {
+	m_top->add (key, *t);
+      }
+  }
+
+  /**
+   *   Finds whether there is a node holding that key
+   */
+  bool has (const K& key) const
+  {
+    if (m_top != 0)
+      {
+	return (m_top->has (key));
+      }
+    else
+      {
+	return (false);
+      }
+  }
+
+  /**
+   *   Finds the value associated with that key.
+   *   Returns 0 if not found
+   */
+  T* find (const K& key) const
+  {
+    if (m_top != 0)
+      {
+	return (m_top->find (key));
+      }
+    else
+      {
+	return (0);
+      }
+  }
+
+  /**
+   *   Finds the node containing the value associated with that key.
+   *   Returns 0 if not found
+   */
+  const cmt_node<K, T>* find_node (const K& key) const
+  {
+    if (m_top == 0) return (0);
+
+    return (m_top->find_node (key));
+  }
+
+private:
+  cmt_node<K, T>* m_top;
+};
+
+template <class K, class T> class cmt_vmap
+{
+public:
+
+  /**
+   *  Constructor
+   */
+  cmt_vmap () : m_top (0)
+  {
+  }
+
+  /**
+   *  Destructor
+   */
+  ~cmt_vmap ()
+  {
+    clear ();
+  }
+
+  /**
+   * clear: erase everything from this map
+   */
+  void clear ()
+  {
+    if (m_top != 0)
+      {
+	delete m_top;
+	m_top = 0;
+      }
+  }
+
+  /**
+   *  Add an entry.
+   *
+   *  Existing entries with the same key will be overridden
+   */
+  void add (const K& key, T& t)
+  {
+    if (m_top == 0)
+      {
+	m_top = new cmt_vnode<K, T> (key, t);
+      }
+    else
+      {
+	m_top->add (key, t);
+      }
+  }
+
+  /**
+   *   Finds whether there is a node holding that key
+   */
+  bool has (const K& key) const
+  {
+    if (m_top != 0)
+      {
+	return (m_top->has (key));
+      }
+    else
+      {
+	return (false);
+      }
+  }
+
+  /**
+   *   Finds the value associated with that key.
+   *   Returns 0 if not found
+   */
+  const T* find (const K& key) const
+  {
+    if (m_top != 0)
+      {
+	return (m_top->find (key));
+      }
+    else
+      {
+	return (0);
+      }
+  }
+
+  /**
+   *   Finds the node containing the value associated with that key.
+   *   Returns 0 if not found
+   */
+  const cmt_vnode<K, T>* find_node (const K& key) const
+  {
+    if (m_top == 0) return (0);
+
+    return (m_top->find_node (key));
+  }
+
+private:
+  cmt_vnode<K, T>* m_top;
+};
+
+
+
+
+    /*
+  T& operator [] (const K& key)
+  {
+    T* t = find (key);
+    
+    if (t == 0)
+      {
+        static T t;
+        
+        add (key, t);
+        return ((*this)[key]);
+      }
+    else
+      {
+        return (*t);
+      }
+  }
+    */
+
+
+/* ------------------------------------------------------------
+
+   This is a future possible implementation for the remove node function
+
+  void add (cmt_node* other)
+  {
+    if (other->m_key < m_key)
+      {
+	if (m_left == 0)
+	  {
+	    m_left = other;
+	  }
+	else
+	  {
+	    m_left->add (other);
+	  }
+      }
+    else if (other->m_key > m_key)
+      {	
+	if (m_right == 0)
+	  {
+	    m_right = other;
+	  }
+	else
+	  {
+	    m_right->add (other);
+	  }
+      }
+    else
+      {
+	m_t = other->m_t;
+      }
+  }
+
+  cmt_node* remove_greatest ()
+  {
+    if (m_right == 0) return (this);
+
+    cmt_node* result = m_right->remove_greatest ();
+    if (result == m_right) m_right = 0;
+
+    return (result);
+  }
+
+  cmt_node* remove_node (const K& key)
+  {
+    if (key < m_key)
+      {	
+	if (m_left != 0)
+	  {
+	    cmt_node* node = m_left->remove_node (key);
+	    if (node != 0)
+	      {
+		delete m_left;
+		m_left = node;
+	      }
+	  }
+
+	return (0);
+      }
+    else if (key > m_key)
+      {	
+	if (m_right != 0)
+	  {
+	    cmt_node* node = m_right->remove_node (key);
+	    if (node != 0)
+	      {
+		delete m_right;
+		m_right = node;
+	      }
+	  }
+
+	return (0);
+      }
+    else
+      {
+	// This node will be removed.
+	// The replacement will be returned.
+
+	if (m_left == 0)
+	  {
+	    cmt_node* rep = m_right;
+	    m_right == 0;
+	    return (rep);
+	  }
+	else if (m_right == 0)
+	  {
+	    cmt_node* rep = m_left;
+	    m_left == 0;
+	    return (rep);
+	  }
+	else
+	  {
+	    // here both sides are busy
+
+	    cmt_node* rep = remove_greatest ();
+
+	    rep->add (this);
+
+	    return (rep);
+	  }
+
+	return (this);
+      }
+  }
+
+
+  void cmt_map::remove (const K& key)
+  {
+    if (m_top == 0) return;
+
+    cmt_node<K, T>* node = m_top->remove (key);
+    if (node == 0) return;
+
+    if (node == m_top) 
+      {
+      }
+    else
+      {
+      }
+  }
+
+
+
+ ------------------------------------------------------------ */
+
+#endif
+
Index: /CMT/v1r20/source/cmt_model.cxx
===================================================================
--- /CMT/v1r20/source/cmt_model.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_model.cxx	(revision 368)
@@ -0,0 +1,552 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_model.h"
+#include "cmt_fragment.h"
+#include "cmt_symbol.h"
+
+/**
+ *   Filters out all predefined XML constructs.
+ */
+void CmtModel::filter (cmt_string& text)
+{
+  text.replace_all ("<cmt:tab/>",  "\t");
+  text.replace_all ("<cmt:cr/>",   "\r");
+  text.replace_all ("<cmt:lf/>",   "\n");
+}
+
+void CmtModel::display (cmt_string& text)
+{
+  text.replace_all ("&lt;", "<");
+  text.replace_all ("&gt;", ">");
+  text.replace_all ("\\\"", "\"");
+  text.replace_all ("\\\'", "\'");
+  text.replace_all ("<cmt:null/>", "");
+  Symbol::expand (text);
+  cout << text;
+}
+
+void CmtModel::expand (const cmt_string& input_text)
+{
+  int openmarker;
+  int closemarker;
+
+  CmtSystem::cmt_string_vector subargs;
+
+  cmt_string text = input_text;
+  cmt_string remaining;
+
+  filter (text);
+
+  for (;;)
+    {
+      /**
+       *   Look for the next < ... /> pattern
+       *   If not found, then simply dump the text as it is.
+       */
+      
+      openmarker = text.find ("<");
+      if (openmarker == cmt_string::npos) break;
+      
+      closemarker = text.find (openmarker, "/>");
+      if (closemarker == cmt_string::npos) break;
+
+      if (CmtSystem::testenv ("CMTTESTMODEL"))
+        {
+          cerr << "text=[" << text << "]" << endl;
+        }
+          
+
+      /**
+       *  Extract the command from the pattern
+       */
+      cmt_string command;
+      text.substr (openmarker + 1, closemarker - openmarker - 1, command);
+
+      if (CmtSystem::testenv ("CMTTESTMODEL"))
+        {
+          cerr << "command=[" << command << "]" << endl;
+        }
+          
+      /**
+       *   Get what is left from the original text beyond the pattern 
+       */
+      text.substr (closemarker + 2, remaining);
+
+      /**
+       *   Cut the original text up to the pattern start
+       */
+      text.erase (openmarker);
+      
+      /**
+       *   Now display it
+       */
+      display (text);
+          
+      /**
+       * Convert the extracted command into words
+       */
+      CmtSystem::split (command, " ", subargs);
+          
+      /**
+       *  Recursively expand it
+       */
+      expand (subargs);
+      
+      /**
+       *  The next iteration will operate on the remaining text
+       */
+      text = remaining;
+    }
+  
+  if (CmtSystem::testenv ("CMTTESTMODEL"))
+    {
+      cerr << "text=[" << text << "]" << endl;
+    }
+          
+  /**
+   *   Display what is left after extracting the last pattern
+   */
+  display (text);
+  cout << endl;
+}
+
+void CmtModel::strict_expand (const cmt_string& input_text)
+{
+  CmtSystem::cmt_string_vector subargs;
+
+  cmt_string text = input_text;
+  cmt_string remaining;
+
+  // The patterns for syntax parsing
+
+  cmt_string open_element = "<cmts:";
+  cmt_string open_elements = "<cmtv:";
+  cmt_string close_element = "/>";
+
+  cmt_string skip_spaces = "[ \t]+";
+  cmt_string word = "[^ \t/>]*";
+
+  cmt_string attribute = "[^=/>]+=((\"([^\"]|\\\\\")*\")|(\'([^\']|\\\\\')*\'))";
+
+  //cout << "attribute=[" << attribute << "]" << endl;
+
+  cmt_regexp exp_open_element (open_element);
+  cmt_regexp exp_open_elements (open_elements);
+  cmt_regexp exp_close_element (close_element);
+
+  cmt_regexp exp_skip_spaces (skip_spaces);
+  cmt_regexp exp_word (word);
+
+  cmt_regexp exp_attribute (attribute);
+
+  cmt_regexp::iterator it;
+  cmt_regexp::iterator its;
+
+  static int expand_level = 0;
+
+  //cout << "Text=[" << text << "]" << endl;
+
+  filter (text);
+
+  //cout << "Text=[" << text << "]" << endl;
+
+  int pos = 0;
+
+  for (;;)
+    {
+      bool multiple = false;
+
+      it = exp_open_element.begin (text, pos);
+      its = exp_open_elements.begin (text, pos);
+
+      if ((it == exp_open_element.end ()) && ((its == exp_open_elements.end ()))) 
+	{
+	  // no more opening element
+
+	  // Display the remaining text. The parsing is now completed.
+
+	  remaining = text.substr (pos);
+	  display (remaining);
+
+	  break;
+	}
+
+      if (it == exp_open_element.end ())
+	{
+	  // no single element -> we have a multiple one
+	  it = its;
+	  multiple = true;
+	}
+      else if (its == exp_open_elements.end ())
+	{
+	  // no multiple element -> we have a single one
+	}
+      else if (it < its)
+	{
+	  // the single is before the multiple
+	}
+      else
+	{
+	  // the multiple is before the single
+	  it = its;
+	  multiple = true;
+	}
+
+      remaining = text.substr (pos, it._pos - pos);
+      display (remaining);
+
+      //cout << "pos=" << pos << " open_element -> p=" << it._pos << " l=" << it._length << endl;
+      pos = it._pos + it._length;
+
+      it = exp_word.begin (text, pos);
+      if (it._pos != pos)
+	{
+	  cerr << "Syntax error: no element name" << endl;
+	  break;
+	}
+
+      //cout << "pos=" << pos << " word -> p=" << it._pos << " l=" << it._length << endl;
+      pos += it._length;
+
+      cmt_string element = it (text);
+      //cout << "pos=" << pos << " element=" << element << endl;
+
+      subargs.clear ();
+
+      {
+	cmt_string& s = subargs.add ();
+	s = element;
+      }
+
+      for (;;)
+	{
+	  it = exp_skip_spaces.begin (text, pos);
+	  if (it._pos == pos)
+	    {
+	      //cout << "pos=" << pos << " skip_spaces -> p=" << it._pos << " l=" << it._length << endl;
+	      pos += it._length;
+	    }
+
+	  //cout << "pos=" << pos << endl;
+
+	  it = exp_close_element.begin (text, pos);
+	  if (it._pos == pos)
+	    {
+	      //cout << "Recursing to [" << element << "]" << endl;
+
+	      int i;
+
+	      Variable::VariableVector variables;
+
+	      /**
+	       *   We start by decoding all [variable=value] pairs from the arguments
+	       *   A vector of Variables is filled from them. 
+	       */
+
+	      int multiple_count = 0;
+	      CmtSystem::cmt_string_vector values;
+	      cmt_string name;
+	      cmt_string value;
+
+	      for (i = 1; i < subargs.size (); i++)
+		{
+		  const cmt_string& arg = subargs[i];
+
+		  int p = arg.find ("=");
+
+		  arg.substr (0, p, name);
+		  arg.substr (p + 1, value);
+		  if (value[0] == '"') 
+		    {
+		      value.erase (0, 1);
+		      if (value[value.size()-1] == '"') value.erase (value.size ()-1);
+		    }
+		  else if (value[0] == '\'') 
+		    {
+		      value.erase (0, 1);
+		      if (value[value.size()-1] == '\'') value.erase (value.size ()-1);
+		    }
+
+		  //cout << "+ name = [" << value << "]" << endl;
+
+		  if (multiple)
+		    {
+		      values.clear ();
+		      CmtSystem::split (value, " \t", values);
+		      int n = values.size ();
+		      if (n > multiple_count) multiple_count = n;
+		    }
+
+		  Variable* v = Variable::find (variables, name);
+		  if (v == 0)
+		    {
+		      v = &(variables.add ());
+		      v->set (name);
+		    }
+
+		  (*v) = value;
+		}
+
+	      cmt_string sub_text;
+
+	      FragmentHandle fragment (element);
+
+	      if (multiple)
+		{
+		  //cout << "+ count = " << multiple_count << endl;
+		  for (int n = 0; n < multiple_count; n++)
+		    {
+		      for (i = 1; i < subargs.size (); i++)
+			{
+			  const cmt_string& arg = subargs[i];
+
+			  int p = arg.find ("=");
+
+			  arg.substr (p + 1, value);
+			  if (value[0] == '"') 
+			    {
+			      value.erase (0, 1);
+			      if (value[value.size()-1] == '"') value.erase (value.size ()-1);
+			    }
+			  else if (value[0] == '\'') 
+			    {
+			      value.erase (0, 1);
+			      if (value[value.size()-1] == '\'') value.erase (value.size ()-1);
+			    }
+
+			  //cout << "+ values = [" << value << "]" << endl;
+
+			  values.clear ();
+			  CmtSystem::split (value, " \t", values);
+			  if (n < values.size ())
+			    {
+			      value = values[n];
+			    }
+			  else
+			    {
+			      value = "";
+			    }
+
+			  Variable& v = variables[i-1];
+
+			  //cout << "+ value = [" << value << "]" << endl;
+
+			  v = value;
+			}
+
+		      fragment.copy (sub_text, variables, 0);
+
+		      expand_level++;
+		      strict_expand (sub_text);
+		      expand_level--;
+		    }
+		}
+	      else
+		{
+		  fragment.copy (sub_text, variables, 0);
+
+		  expand_level++;
+		  strict_expand (sub_text);
+		  expand_level--;
+		}
+
+	      pos += it._length;
+	      break;
+	    }
+
+	  //cout << "Try attribute at pos=" << pos << " [" << text.substr (pos) << "]" << endl;
+
+	  it = exp_attribute.begin (text, pos);
+	  if (it._pos != pos)
+	    {
+	      cerr << "Syntax error : no attribute before closing the element [" << text.substr (pos) << "]" << endl;
+	      break;
+	    }
+
+	  //cout << "pos=" << pos << " attribute -> p=" << it._pos << " l=" << it._length << endl;
+	  //cout << "pos=" << pos << " attr=[" << it (text) << "]" << endl;
+
+	  {
+	    cmt_string& s = subargs.add ();
+	    s = it (text);
+	  }
+
+	  pos += it._length;
+	}
+    }
+
+  if (expand_level == 0) cout << endl;
+}
+
+void CmtModel::test_regexp (const cmt_string& pattern, const cmt_string& input_text)
+{
+  cout << "Testing pattern [" << pattern << "] against [" << input_text << "]" << endl;
+ 
+  cmt_regexp exp (pattern);
+
+  cmt_regexp::iterator it;
+
+  for (int pos = 0; pos < 10; pos++)
+    {
+      it = exp.begin (input_text, pos);
+
+      if (it == exp.end ())
+	{
+	  cout << "No match" << endl;
+	}
+      else
+	{
+	  cout << "p=" << it._pos << " l=" << it._length << " -> [" << it (input_text) << "]" << endl;
+	}
+    }
+}
+
+
+/**
+ *   Expands a model file
+ *   Arguments are :
+ *     model-name   : name of a model file
+ *     var=value    : variable value to be expanded 
+ *                    (will take the form ${var} )
+ */
+void CmtModel::expand (const CmtSystem::cmt_string_vector& arguments)
+{
+  int i;
+
+  Variable::VariableVector variables;
+
+  /**
+   *   We start by decoding all [variable=value] pairs from the arguments
+   *   A vector of Variables is filled from them. 
+   */
+  for (i = 0; i < arguments.size (); i++)
+    {
+      const cmt_string& arg = arguments[i];
+
+      if (arg.find ("=") != cmt_string::npos)
+        {
+          cmt_string name;
+          cmt_string value;
+          int pos = arg.find ("=");
+
+          arg.substr (0, pos, name);
+          arg.substr (pos + 1, value);
+
+          Variable* v = Variable::find (variables, name);
+          if (v == 0)
+            {
+              v = &(variables.add ());
+              v->set (name);
+            }
+
+          (*v) = value;
+        }
+    }
+
+  /**
+   *   Then model names are extracted.
+   *   Each model may contain a set of <...> patterns.
+   *   The expected syntax for each of them is :
+   *     <model-name variable-name=value ...>
+   *
+   *   Therefore the current expand function is recursively restarted.
+   *
+   *   Text around patterns is displayed after replacements of all
+   *   variable values detected by ${variable-name} patterns
+   */
+  cmt_string text;
+
+  for (i = 0; i < arguments.size (); i++)
+    {
+      const cmt_string& arg = arguments[i];
+
+      if (arg.find ("=") == cmt_string::npos)
+        {
+          FragmentHandle fragment (arg);
+          fragment.copy (text, variables, 0);
+
+          filter (text);
+
+          int openmarker;
+          int closemarker;
+
+          CmtSystem::cmt_string_vector subargs;
+
+          cmt_string remaining;
+
+          for (;;)
+            {
+              /**
+               *   Look for the next <...> pattern
+               *   If not found, then simply dump the text as it is.
+               */
+
+              openmarker = text.find ("<");
+              if (openmarker == cmt_string::npos) break;
+
+              closemarker = text.find (openmarker, "/>");
+              if (closemarker == cmt_string::npos)
+                {
+                  /**
+                   *  The opening < was in the text
+                   */
+
+                  /**
+                   *   Get what is left from the original text beyond the pattern 
+                   */
+                  text.substr (openmarker + 1, remaining);
+                  text.erase (openmarker + 1);
+                  
+                  /**
+                   *   Now display it
+                   */
+                  display (text);
+                }
+              else
+                {
+                  /**
+                   *  Extract the command from the pattern
+                   */
+                  cmt_string command;
+                  text.substr (openmarker + 1, closemarker - openmarker - 1, command);
+
+                  /**
+                   *   Get what is left from the original text beyond the pattern 
+                   */
+                  text.substr (closemarker + 2, remaining);
+                  text.erase (openmarker);
+                  
+                  /**
+                   *   Now display it
+                   */
+                  display (text);
+
+                  /**
+                   * Convert the extracted command into words
+                   */
+                  CmtSystem::split (command, " ", subargs);
+                  
+                  /**
+                   *  Recursively expand it
+                   */
+                  expand (subargs);
+                }
+
+              /**
+               *  The next iteration will operate on the remaining text
+               */
+              text = remaining;
+            }
+
+          /**
+           *   Display what is left after extracting the last pattern
+           */
+          display (text);
+        }
+    }
+}
+
Index: /CMT/v1r20/source/cmt_model.h
===================================================================
--- /CMT/v1r20/source/cmt_model.h	(revision 368)
+++ /CMT/v1r20/source/cmt_model.h	(revision 368)
@@ -0,0 +1,25 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_model_h__
+#define __cmt_model_h__
+
+#include "cmt_system.h"
+
+class CmtModel
+{
+public:
+  static void expand (const cmt_string& input_text);
+  static void strict_expand (const cmt_string& input_text);
+  static void test_regexp (const cmt_string& pattern, const cmt_string& input_text);
+
+private:
+  static void filter (cmt_string& text);
+  static void display (cmt_string& text);
+  static void expand (const CmtSystem::cmt_string_vector& arguments);
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_parser.cxx
===================================================================
--- /CMT/v1r20/source/cmt_parser.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_parser.cxx	(revision 368)
@@ -0,0 +1,7808 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+//----------------------------------------------------------
+
+#include "cmt_parser.h"
+#include "cmt_version.h"
+
+#include "cmt_database.h"
+#include "cmt_include.h"
+#include "cmt_script.h"
+#include "cmt_generator.h"
+#include "cmt_system.h"
+#include "cmt.h"
+#include "cmt_error.h"
+#include "cmt_cvs.h"
+#include "cmt_lock.h"
+#include "cmt_triggers.h"
+#include "cmt_model.h"
+#include "cmt_awk.h"
+#include "cmt_syntax.h"
+#include "cmt_install_area.h"
+#include "cmt_cmtpath_pattern.h"
+#include "cmt_sequence.h"
+#include "cmt_map.h"
+#include "cmt_project.h"
+#include "cmt_log.h"
+#include "cmt_commands.h"
+
+//----------------------------------------------------------
+//
+//  Static object definitions for the CmtContext class.
+//
+
+static CmtContext Me;
+
+CmtContext::CmtContext ()
+{
+  clear ();
+}
+
+CmtContext::~CmtContext ()
+{
+}
+
+void CmtContext::clear ()
+{
+  m_action         = action_none;
+  m_build_nmake    = false;
+  m_cmt_config     = "";
+  //m_cmt_path.clear ();
+  //m_cmt_path_pwds.clear ();
+  //m_cmt_path_sources.clear ();
+  m_cmt_root       = "";
+  m_cmt_version    = "";
+  m_current_dir     = "";
+  m_current_package = "";
+  m_current_config  = "";
+  m_current_path    = "";
+  m_current_prefix  = "";
+  m_current_cmtpath = "";
+  m_current_offset  = "";
+
+  m_current_access   = DeveloperMode;
+
+  m_current_tag      = "";
+  m_current_target   = "";
+  m_current_version  = "";
+  m_default_path     = "";
+  m_quiet            = false;
+  m_disable_warnings = false;
+  m_warnings         = false;
+  m_recursive        = false;
+
+  m_scope_filtering_mode = default_filtering_mode;
+  m_simulation       = false;
+
+  m_standard_macros_done = false;
+  m_current_access = UserMode;
+  m_current_style = cmt_style;
+  m_current_structuring_style = default_structuring_style;
+  m_all_sets_done = false;
+  m_autoconfigure_cmtpath = false;
+  m_debug = false;
+  if (getenv ("CMTDEBUG") != 0) m_debug = true;
+}
+
+//----------------------------------------------------------
+
+
+//----------------------------------------------------------
+//
+//   Utility classes
+//
+//----------------------------------------------------------
+
+/**
+ *  This PathScanner actor simply displays the package name/version/path
+ *  It is used by the cmt show packages operation
+ */
+class PackageViewer : public PathScanner::actor
+{
+public:
+  void run (const cmt_string& package,
+            const cmt_string& version,
+            const cmt_string& path,
+            const bool without_version_directory=false);
+};
+
+
+/**
+ *  This PathScanner actor accumulates all found packages into a cmt_string_vector
+ *  It is used by the broadcast operation
+ */
+class PackageSelector : public PathScanner::actor
+{
+public:
+  PackageSelector (CmtSystem::cmt_string_vector& uses);
+  void run (const cmt_string& package,
+            const cmt_string& version,
+            const cmt_string& path,
+            const bool without_version_directory=false);
+private:
+  CmtSystem::cmt_string_vector& m_uses;
+};
+
+
+
+/**
+ *  This PathScanner actor collects all packages clients of the specified one
+ *  It is used by the cmt show clients operation
+ */
+class ClientCollector : public PathScanner::actor
+{
+public:
+  ClientCollector (const cmt_string& package,
+		   const cmt_string& version);
+  void run (const cmt_string& package,
+            const cmt_string& version,
+            const cmt_string& path,
+            const bool without_version_directory=false);
+  int count ();
+
+private:
+  const cmt_string& m_package;
+  const cmt_string& m_version;
+  int m_count;
+};
+
+//----------------------------------------------------------
+void PackageViewer::run (const cmt_string& package,
+                         const cmt_string& version,
+                         const cmt_string& path,
+                         const bool without_version_directory)
+{
+  cout << package << " " << version << " " << path << endl;
+}
+
+//----------------------------------------------------------
+PackageSelector::PackageSelector (CmtSystem::cmt_string_vector& uses) : m_uses(uses)
+{
+}
+
+//----------------------------------------------------------
+void PackageSelector::run (const cmt_string& package,
+                           const cmt_string& version,
+                           const cmt_string& path,
+                           const bool without_version_directory)
+{
+  //
+  // this might be called on a package with no version directory.
+  // then simply the version argument is empty.
+  // 
+
+  cmt_string r = CmtSystem::file_separator ();
+  r += "requirements";
+
+  cmt_string temp;
+
+  if (version == "")
+    {
+      temp = path;
+      //temp += CmtSystem::file_separator ();
+      //temp += package;
+      temp += CmtSystem::file_separator ();
+      temp += "cmt";
+      temp += r;
+      
+      if (!CmtSystem::test_file (temp)) return;
+    }
+  else
+    {
+      temp = path;
+      //temp += CmtSystem::file_separator ();
+      //temp += package;
+      temp += CmtSystem::file_separator ();
+      temp += version;
+      temp += CmtSystem::file_separator ();
+      temp += "cmt";
+      temp += r;
+      
+      if (!CmtSystem::test_file (temp))
+        {
+          temp = path;
+          //temp += CmtSystem::file_separator ();
+          //temp += package;
+          temp += CmtSystem::file_separator ();
+          temp += version;
+          temp += CmtSystem::file_separator ();
+          temp += "mgr";
+          temp += r;
+          
+          if (!CmtSystem::test_file (temp))
+            {
+              return;
+            }
+        }
+    }
+
+  temp.replace (r.c_str(), "");
+  cmt_string& use = m_uses.add ();
+  use = temp;
+}
+
+//----------------------------------------------------------
+ClientCollector::ClientCollector (const cmt_string& package,
+				  const cmt_string& version) :
+  m_package (package), m_version (version), m_count (0)
+{
+}
+
+//----------------------------------------------------------
+void ClientCollector::run (const cmt_string& package,
+			   const cmt_string& version,
+			   const cmt_string& path,
+			   const bool without_version_directory)
+{
+  cmt_string dir = path;
+  dir += CmtSystem::file_separator ();
+  dir += package;
+  dir += CmtSystem::file_separator ();      
+  if (version != "" && ! without_version_directory)
+    {
+      dir += version;
+      dir += CmtSystem::file_separator ();
+    }
+
+  cmt_string req;
+ 
+  req  = dir;
+  req += "cmt";
+  req += CmtSystem::file_separator ();
+  req += "requirements";
+
+  cmt_string requirements;
+  cmt_string line;
+  CmtSystem::cmt_string_vector words;
+
+  if (CmtSystem::test_file (req))
+    {
+      requirements.read (req);
+    }
+  else
+    {
+      req = dir;
+      req += "mgr";
+      req += CmtSystem::file_separator ();
+      req += "requirements";
+      if (CmtSystem::test_file (req))
+        {
+          requirements.read (req);
+        }
+    }
+
+  if (requirements != "")
+    {
+      int pos = 0;
+      int max_pos = requirements.size ();
+
+      while (pos < max_pos)
+        {
+          int cr = requirements.find (pos, "\r\n");
+          int nl = requirements.find (pos, '\n');
+          int first = nl;
+          int length = 1;
+                
+          if (cr != cmt_string::npos)
+            {
+              if (nl == cmt_string::npos)
+                {
+                  first = cr;
+                  length = 2;
+                }
+              else
+                {
+                  first = (nl < cr) ? nl : cr;
+                  length = (nl < cr) ? 1 : 2;
+                }
+            }
+                
+          if (first == cmt_string::npos)
+            {
+              requirements.substr (pos, line);
+              pos = max_pos;
+            }
+          else if (first > pos)
+            {
+              requirements.substr (pos, first - pos, line);
+              pos = first + length;
+            }
+          else
+            {
+              line.erase (0);
+              pos += length;
+            }
+
+          CmtSystem::split (line, " \t", words);
+
+          if ((words.size () >= 2) && (words[0] == "use")) 
+            {
+              if ((words[1] == m_package) && 
+                  ( (m_version == "") || (words[2] == m_version)))
+                {
+                  cout << "# " << package << " " << version << " " << path;
+                  if (m_version == "" && words.size () > 2)
+                    {
+                      cout << " (use version " << words[2] << ")";
+                    }
+                  cout << endl;
+                  m_count++;
+                }
+            }
+        }
+    }
+}
+
+//----------------------------------------------------------
+int ClientCollector::count ()
+{
+  return (m_count);
+}
+
+
+
+
+//----------------------------------------------------------
+//
+//   The Cmt methods
+//
+//----------------------------------------------------------
+
+
+
+/**
+ *   Append "CONFIG" to the prefix
+ */
+void Cmt::build_config (const cmt_string& prefix,
+                        cmt_string& config)
+{
+  /*
+    Building the config from <prefix> 
+  */
+
+  config = prefix;
+  config += "CONFIG";
+}
+
+//----------------------------------------------------------
+void Cmt::build_makefile (const cmt_string& target)
+{
+  Constituent* constituent = 0;
+
+  if (target.size () > 0)
+    {
+      /*
+        Do genmake for one specific target.
+      */
+      constituent = Constituent::find (target);
+      if (constituent != 0)
+        {
+          constituent->build_makefile (Me.m_simulation);
+        }
+    }
+  else
+    {
+      /*
+        Do genmake for all possible targets.
+      */
+      Constituent::build_all_makefiles (Me.m_simulation);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::build_msdev_file (const cmt_string& target)
+{
+  Constituent* constituent = 0;
+
+  set_standard_macros ();
+
+  if (target != "")
+    {
+      /*
+        Do genmsdev for one specific target.
+      */
+      constituent = Constituent::find (target);
+      if (constituent != 0)
+        {
+          constituent->build_msdev_file (Me.m_simulation);
+        }
+    }
+  else
+    {
+      /*
+        Do genmsdev for all possible targets.
+      */
+      Constituent::build_all_msdev_files (Me.m_simulation);
+    }
+}
+
+/**
+   Visual Studio.net Support                                 
+*/
+void Cmt::build_vsnet_file (const cmt_string& target)        
+{                                                            
+  Constituent* constituent = 0;                              
+                                                             
+  set_standard_macros ();                                    
+                                                             
+  if (target != "")                                          
+    {                                                        
+      /*                                                     
+        Do genvsnet for one specific target.                 
+      */                                                     
+      constituent = Constituent::find (target);              
+      if (constituent != 0)                                  
+        {                                                    
+          constituent->build_vsnet_file (Me.m_simulation);        
+        }                                                    
+    }                                                        
+  else                                                       
+    {                                                        
+      /*                                                     
+        Do genvsnet for all possible targets.                
+      */                                                     
+      Constituent::build_all_vsnet_files (Me.m_simulation);       
+    }                                                        
+}                                                            
+
+//----------------------------------------------------------
+bool Cmt::build_nmake ()
+{
+  return (Me.m_build_nmake);
+}
+
+//----------------------------------------------------------
+void Cmt::build_OS9_makefile (const cmt_string& target)
+{
+  build_makefile (target);
+}
+
+/**
+ *   Convert a package name to its upper case copy
+ */
+void Cmt::build_prefix (const cmt_string& package, cmt_string& prefix)
+{
+  int pos;
+  char c;
+
+  /*
+    Building the prefix from <package> 
+  */
+
+  prefix = package;
+
+  for (pos = 0; pos < package.size (); pos++)
+    {
+      c = package[pos];
+      prefix[pos] = toupper (c);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::clear ()
+{
+  Me.clear ();
+
+  Database::clear ();
+  Include::clear_all ();
+  Script::clear_all ();
+  CmtError::clear ();
+}
+
+//----------------------------------------------------------
+void Cmt::configure ()
+{
+  Log;
+  static bool configured = false;
+
+  if (configured) return;
+
+  Me.clear ();
+
+  log << "configure_default_path" << log_endl;
+  configure_default_path ();
+  log << "configure_version_tag" << log_endl;
+  configure_version_tag ();
+  log << "configure_uname_tag" << log_endl;
+  configure_uname_tag ();
+  log << "configure_hosttype_tag" << log_endl;
+  configure_hosttype_tag ();
+  log << "configure_config_tag" << log_endl;
+  configure_config_tag ();
+  log << "configure_site_tag" << log_endl;
+  configure_site_tag (0);
+  log << "configure_home" << log_endl;
+  // CMTHOME, CMTUSERCONTEXT and CMTPATH
+  configure_home (0);
+  log << "configure_current_dir" << log_endl;
+
+
+  Me.m_autoconfigure_cmtpath = true;
+  configure_cmt_path (0);
+  Me.m_autoconfigure_cmtpath = false;
+
+
+  configure_current_dir ();
+
+  log << "configure_current_package" << log_endl;
+  configure_current_package ();
+  log << "configure_current_structuring_style" << log_endl;
+  configure_current_structuring_style ();
+
+  Use& use = Use::current();
+
+  use.set (Me.m_current_package,
+           Me.m_current_version,
+           Me.m_current_path,
+           "",
+           "");
+
+  use.style = Me.m_current_style;
+
+  use.change_path (Me.m_current_path);
+
+  guess_current_project ();
+
+  if (CmtError::has_pending_error ()) 
+    {
+      Me.m_configure_error = CmtError::get_last_error ();
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::configure_cmt_path (Use* use)
+{
+  if (!Me.m_autoconfigure_cmtpath) return;
+
+  cmt_string s;
+
+  s = Symbol::get_env_value ("CMTPATH");
+
+  {
+    bool q = Me.m_quiet;
+    Me.m_quiet = true;  
+    Symbol::filter_path_value ("CMTPATH", s);
+    Me.m_quiet = q;
+  }
+
+  IProjectFactory& factory = ProjectFactory::instance ();
+  factory.reset ();
+
+  CmtSystem::get_cmt_paths (factory, s, Me.m_cmt_user_context, Me.m_cmt_home);
+}
+
+//----------------------------------------------------------
+void Cmt::configure_config_tag ()
+{
+  Me.m_cmt_config = CmtSystem::get_cmt_config ();
+  if (Me.m_cmt_config != "")
+    {
+      Tag* tag;
+
+      tag = Tag::add (Me.m_cmt_config, PriorityConfig, "CMTCONFIG", 0);
+      tag->mark ();
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::configure_current_cmtpath ()
+{
+  Use& current_use = Use::current ();
+
+  Me.m_current_cmtpath = "";
+  Me.m_current_offset = "";
+
+  Me.m_current_cmtpath = Project::find_in_cmt_paths (current_use.path);
+
+  if (Me.m_current_cmtpath != "")
+    {
+      static const cmt_string empty_string;
+      static const cmt_string fs = CmtSystem::file_separator ();
+
+      Me.m_current_offset = current_use.path;
+
+      /**
+	 try to remove this current CMTPATH entry from path.  This
+	 has a meaning when the specified path already contains an
+	 absolute path.
+      */
+      
+      Me.m_current_offset.replace (Me.m_current_cmtpath, empty_string);
+      if (Me.m_current_offset[0] == CmtSystem::file_separator ())
+	{
+	  // Just in case there is a part left after removing the cmtpath entry
+	  
+	  Me.m_current_offset.replace (fs, empty_string);
+	}
+    }
+}
+
+class CmtMountFilterParser : public FAwk
+{
+public:
+
+  CmtMountFilterParser ()
+  {
+    reset ();
+  }
+
+  void reset ()
+  {
+    m_current_dir = CmtSystem::pwd ();
+    m_done = false;
+    m_prefix = "";
+  }
+
+  bool is_done () const
+  {
+    return (m_done);
+  }
+
+  const cmt_string& get_current_dir () const
+  {
+    return (m_current_dir);
+  }
+
+  void set_prefix (const cmt_string& prefix)
+  {
+    m_prefix = prefix;
+  }
+
+  void filter (const cmt_string& line)
+  {
+    //cout << "line=" << line << endl;
+
+    if (m_done) 
+      {
+	stop ();
+	return;
+      }
+
+    CmtSystem::cmt_string_vector words;
+
+    CmtSystem::split (line, " \t", words);
+
+    int requested = 2;
+
+    if (m_prefix != "")
+      {
+	requested++;
+      }
+
+    if (words.size () < requested) return;
+
+    int n = 0;
+
+    if (m_prefix != "")
+      {
+	if (words[n] != m_prefix) return;
+	n++;
+      }
+
+    cmt_string& path_name = words[n];
+    cmt_string& replacement = words[n+1];
+    
+    if (m_current_dir.find (path_name) != cmt_string::npos)
+      {
+	m_current_dir.replace (path_name, replacement);
+	m_done = true;
+	stop ();
+      }
+  }
+
+private:
+  bool m_done;
+  cmt_string m_prefix;
+  cmt_string m_current_dir;
+};
+
+//----------------------------------------------------------
+void Cmt::configure_current_dir ()
+{
+  cmt_string file_name;
+
+  /*
+    Building current_dir :
+
+    o we first get the physical value (using getwd)
+    o then this value is possibly filtered using the
+    cmt_mount_filter file.
+  */
+
+  CmtMountFilterParser mount_filter;
+
+  /**
+     First try with ${CMTROOT}/mgr/cmt_mount_filter
+     with no prefix on lines
+  */
+
+  file_name = Me.m_default_path;
+  if (file_name != "")
+    {
+      file_name += CmtSystem::file_separator ();
+      file_name += "CMT";
+      file_name += CmtSystem::file_separator ();
+      file_name += Me.m_cmt_version;
+      file_name += CmtSystem::file_separator ();
+      file_name += "mgr";
+      file_name += CmtSystem::file_separator ();
+    }
+
+  file_name += "cmt_mount_filter";
+
+  mount_filter.run (file_name);
+
+  /**
+     Now try with .cmtrc
+     with "mount_filter" keyword
+  */
+
+  mount_filter.set_prefix ("mount_filter");
+
+  mount_filter.run (".cmtrc");
+
+  /**
+     Now try with ${HOME}/.cmtrc
+     with "mount_filter" keyword
+  */
+
+  if (CmtSystem::get_home_directory (file_name))
+    {
+      file_name += CmtSystem::file_separator ();
+      file_name += ".cmtrc";
+      mount_filter.run (file_name);
+    }
+
+  Me.m_current_dir = mount_filter.get_current_dir ();
+}
+
+//----------------------------------------------------------
+void Cmt::configure_current_package ()
+{
+  /*
+    Build current_package and current_prefix.
+
+    This is only possible if we are within the cmt/mgr branch of a
+    standard directory tree (i.e. <package>/<version>/cmt or mgr)
+  */
+
+  cmt_string req = "..";
+  req += CmtSystem::file_separator ();
+  req += "cmt";
+  req += CmtSystem::file_separator ();
+  req += "requirements";
+
+  if (CmtSystem::test_file (req))
+    {
+      Me.m_current_style = cmt_style;
+    }
+  else
+    {
+      cmt_string req = "..";
+      req += CmtSystem::file_separator ();
+      req += "mgr";
+      req += CmtSystem::file_separator ();
+      req += "requirements";
+
+      if (CmtSystem::test_file (req))
+	{
+	  Me.m_current_style = mgr_style;
+	}
+      else
+	{
+	  // This package is probably a standalone one
+	  Me.m_current_style = none_style;
+	}
+    }
+
+
+  if (Me.m_current_style != none_style)
+    {
+      //
+      //  Here there is a ../cmt or ../mgr branch in front of us
+      //  and there is a requirements file there
+      //
+
+      cmt_string up_dir;
+      cmt_string up_branch;
+
+      CmtSystem::dirname (Me.m_current_dir, up_dir);
+      CmtSystem::basename (up_dir, up_branch);
+
+      cmt_string version_file = "..";
+      version_file += CmtSystem::file_separator ();
+      version_file += "cmt";
+      version_file += CmtSystem::file_separator ();
+      version_file += "version.cmt";
+
+      if (CmtSystem::test_file (version_file))
+	{
+	  // 
+	  // There is an explicit version descriptor. This one takes precedence
+	  // and forces the structuring style to no directory
+	  //
+
+          Me.m_current_package = up_branch;
+          CmtSystem::dirname (up_dir, Me.m_current_path);
+
+	  if (Me.m_current_version.read (version_file))
+	    {
+	      int pos;
+
+	      pos = Me.m_current_version.find ('\n');
+	      if (pos != cmt_string::npos) Me.m_current_version.erase (pos);
+	      pos = Me.m_current_version.find ('\r');
+	      if (pos != cmt_string::npos) Me.m_current_version.erase (pos);
+	    }
+	  else
+	    {
+	      Me.m_current_version = "v*";
+	    }
+
+	  if (Me.m_debug)
+	    {
+	      cout << "Cmt::configure_current_package>" << endl
+		   << " m_current_package " << Me.m_current_package << endl
+		   << " m_current_version " << Me.m_current_version << endl
+		   << " m_current_dir " << Me.m_current_dir << endl
+		   << " pwd " << CmtSystem::pwd ()
+		   << endl;
+	    }
+
+          Me.m_current_style = no_version_style;
+	}
+      else if (CmtSystem::is_version_directory (up_branch))
+        {
+	  // The up branch IS a version directory.
+
+	  Me.m_current_version = up_branch;
+          CmtSystem::dirname (up_dir, up_dir);
+          CmtSystem::basename (up_dir, Me.m_current_package);
+          CmtSystem::dirname (up_dir, Me.m_current_path);
+        }
+      else
+        {
+	  // No version descriptor
+	  // No version directory. The version is defaulted to v*
+ 
+          CmtSystem::basename (up_dir, Me.m_current_package);
+          Me.m_current_version = "v*";
+          CmtSystem::dirname (up_dir, Me.m_current_path);
+
+          Me.m_current_style = no_version_style;
+        }
+
+      build_prefix (Me.m_current_package, Me.m_current_prefix);
+      build_config (Me.m_current_prefix, Me.m_current_config);
+    }
+  else
+    {
+      Me.m_current_package = "cmt_standalone";
+      Me.m_current_version = "";
+      Me.m_current_path = Me.m_current_dir;
+      build_prefix (Me.m_current_package, Me.m_current_prefix);
+      build_config (Me.m_current_prefix, Me.m_current_config);
+      Me.m_current_style = none_style;
+    }
+
+  //cout << "configure_current_package> current style=" << Me.m_current_style << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::configure_current_structuring_style ()
+{
+  cmt_string s;
+
+  s = CmtSystem::getenv ("CMTSTRUCTURINGSTYLE");
+  if (s == "without_version_directory")
+    {
+      Me.m_current_structuring_style = without_version_directory;
+    }
+  else if (s == "with_version_directory")
+    {
+      Me.m_current_structuring_style = with_version_directory;
+    } 
+}
+
+//----------------------------------------------------------
+void Cmt::configure_default_path ()
+{
+  Me.m_default_path = CmtSystem::get_cmt_root ();
+  CmtSystem::get_cmt_version (Me.m_cmt_version);
+  Me.m_cmt_root = Me.m_default_path;
+  Me.m_cmt_root += CmtSystem::file_separator ();
+  Me.m_cmt_root += "CMT";
+  Me.m_cmt_root += CmtSystem::file_separator ();
+  Me.m_cmt_root += Me.m_cmt_version;
+}
+
+//----------------------------------------------------------
+void Cmt::configure_home (Use* use)
+{
+  Me.m_cmt_home = "";
+
+  Symbol* symbol = Symbol::find ("CMTHOME");
+  if (symbol != 0)
+    {
+      Me.m_cmt_home = symbol->build_macro_value ();
+      Symbol::expand (Me.m_cmt_home);
+    }
+  else if (CmtSystem::testenv ("CMTHOME"))
+    {
+      Me.m_cmt_home = CmtSystem::getenv ("CMTHOME");
+    }
+
+  if ((Me.m_cmt_home != "") && !CmtSystem::test_directory (Me.m_cmt_home))
+    {
+      Me.m_cmt_home = "";
+    }
+
+  configure_user_context (0);
+}
+
+//----------------------------------------------------------
+void Cmt::configure_user_context (Use* use)
+{
+  Me.m_cmt_user_context = "";
+
+  Symbol* symbol = Symbol::find ("CMTUSERCONTEXT");
+  if (symbol != 0)
+    {
+      Me.m_cmt_user_context = symbol->build_macro_value ();
+      Symbol::expand (Me.m_cmt_user_context);
+    }
+  else if (CmtSystem::testenv ("CMTUSERCONTEXT"))
+    {
+      Me.m_cmt_user_context = CmtSystem::getenv ("CMTUSERCONTEXT");
+    }
+
+  if ((Me.m_cmt_user_context != "") && !CmtSystem::test_directory (Me.m_cmt_user_context))
+    {
+      Me.m_cmt_user_context = "";
+    }
+
+  if (Me.m_debug) cout << "configure_user_context> user_context=" << Me.m_cmt_user_context << endl;
+
+  configure_cmt_path (0);
+}
+
+//----------------------------------------------------------
+void Cmt::configure_hosttype_tag ()
+{
+  cmt_string hosttype;
+
+  CmtSystem::get_hosttype (hosttype);
+
+  if (hosttype != "")
+    {
+      Tag* tag;
+
+      tag = Tag::add (hosttype, PriorityUname, "HOSTTYPE", 0);
+      tag->mark ();
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::configure_site_tag (Use* use)
+{
+  Symbol* symbol = Symbol::find ("CMTSITE");
+  if (symbol != 0)
+    {
+      Me.m_cmt_site = symbol->build_macro_value ();
+      Symbol::expand (Me.m_cmt_site);
+    }
+  else
+    {
+      Me.m_cmt_site = CmtSystem::get_cmt_site ();
+    }
+
+  if (Me.m_cmt_site != "")
+    {
+      cmt_string s = "CMTSITE";
+
+      if (use != 0)
+        {
+          s += " in ";
+        }
+
+      Tag* tag;
+
+      tag = Tag::add (Me.m_cmt_site, PrioritySite, s, use);
+      tag->mark ();
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::restore_all_tags (Use* use)
+{
+    //cerr << "restore_all_tags" << endl;
+
+  Cmt::configure_tags (use);
+
+    /*
+      Then get existing extra tags
+     */
+
+  if (CmtSystem::testenv ("CMTEXTRATAGS"))
+    {
+      cmt_string s = "CMTEXTRATAGS";
+
+      if (use != 0)
+        {
+          s += " in ";
+        }
+
+      Tag* tag;
+      CmtSystem::cmt_string_vector words;
+      
+      cmt_string tags = CmtSystem::getenv ("CMTEXTRATAGS");
+      
+      CmtSystem::split (tags, " \t,", words);
+
+      Me.m_extra_tags = ",";
+      
+      for (int i = 0; i < words.size (); i++)
+        {
+          const cmt_string& a = words[i];
+
+          Me.m_extra_tags += a;
+          Me.m_extra_tags += ",";
+          
+          tag = Tag::add (a, PriorityUserTag, s, use);
+          
+          tag->mark ();
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::configure_tags (Use* use)
+{
+  cmt_string config_tag;
+
+  Log;
+
+  //if (Me.m_debug) cout << "configure_tags0> current_tag=" << Me.m_current_tag << endl;
+
+  log << "current_tag=" << Me.m_current_tag << log_endl;
+
+  Symbol* symbol = Symbol::find ("CMTCONFIG");
+  if (symbol != 0)
+    {
+      bool show_set_hidden = false;
+
+      if (Me.m_action == action_show_set)
+        {
+          show_set_hidden = true;
+          Me.m_action = action_none;
+        }
+
+      config_tag = symbol->build_macro_value ();
+      Symbol::expand (config_tag);
+
+      if (show_set_hidden)
+        {
+          show_set_hidden = false;
+          Me.m_action = action_show_set;
+        }
+    }
+  else if (CmtSystem::testenv ("CMTCONFIG"))
+    {
+      config_tag = CmtSystem::getenv ("CMTCONFIG");
+    }
+  else if (CmtSystem::testenv ("CMTBIN"))
+    {
+      config_tag = CmtSystem::getenv ("CMTBIN");
+    }
+
+  if (config_tag == "")
+    {
+      CmtSystem::get_uname (config_tag);
+    }
+
+  //if (Me.m_debug) cout << "configure_tags> current_tag=" << Me.m_current_tag << endl;
+  log << "current_tag=" << Me.m_current_tag << log_endl;
+
+  cmt_string s = "CMTCONFIG";
+
+  if (use != 0)
+    {
+      s += " in ";
+    }
+
+  Tag* tag;
+
+  tag = Tag::add (config_tag, PriorityConfig, s, use);
+  tag->mark ();
+
+    //Me.m_current_tag = config_tag;
+}
+
+//----------------------------------------------------------
+void Cmt::configure_uname_tag ()
+{
+  cmt_string uname;
+
+  CmtSystem::get_uname (uname);
+
+  if (uname != "")
+    {
+      Tag* tag;
+
+      tag = Tag::add (uname, PriorityUname, "uname", 0);
+      tag->mark ();
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::configure_version_tag ()
+{
+  int v = 0;
+  int r = 0;
+  int p = 0;
+
+  CmtSystem::is_version_directory (CMTVERSION, v, r, p);
+
+  Tag* tag;
+
+  static char temp[80];
+
+  sprintf (temp, "CMTv%d", v);
+
+  tag = Tag::add (temp, PriorityVersion, "CMTVERSION", 0);
+  tag->mark ();
+
+  sprintf (temp, "CMTr%d", r);
+
+  tag = Tag::add (temp, PriorityVersion, "CMTVERSION", 0);
+  tag->mark ();
+
+  sprintf (temp, "CMTp%d", p);
+
+  tag = Tag::add (temp, PriorityVersion, "CMTVERSION", 0);
+  tag->mark ();
+
+}
+
+//----------------------------------------------------------
+//
+//   Actions
+//
+//----------------------------------------------------------
+
+class AwkActor : public Awk
+{
+public:
+
+  void filter (const cmt_string& line)
+      {
+        cout << line << endl;
+      }
+};
+
+//----------------------------------------------------------
+void Cmt::do_awk (const ArgParser& ap)
+{
+  if (ap.arguments.size () < 1)
+    {
+      cerr << "#CMT> cmt awk <file> <pattern>" << endl;
+      return;
+    }
+
+  const cmt_string& file = ap.arguments[0];
+  const cmt_string& pattern = ap.arguments[1];
+  cmt_string text;
+
+  text.read (file);
+
+  static AwkActor a;
+
+  cmt_regexp exp (pattern);
+
+  a.run (text, exp);
+}
+
+//----------------------------------------------------------
+void Cmt::do_broadcast (const ArgParser& ap)
+{
+  Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+  CmtSystem::cmt_string_vector uses;
+  CmtSystem::cmt_string_vector packages;
+  CmtSystem::cmt_string_vector versions;
+  CmtSystem::cmt_string_vector path_selections;
+  CmtSystem::cmt_string_vector selections;
+  CmtSystem::cmt_string_vector exclusions;
+  cmt_string begin;
+  cmt_string command;
+  bool is_cmt = false;
+  int first = 0;
+  int i;
+  bool ignore_errors = false;
+  bool all_packages = false;
+
+  bool local = true;
+
+  for (i = 0; i < ap.arguments.size (); i++)
+    {
+      const cmt_string& w = ap.arguments[i];
+
+      //cerr << "broadcast: arg=[" << w << "]" << endl;
+
+      if (command == "")
+        {
+          if (w.substr (0, 13) == "-all_packages")
+            {
+              local = false;
+              all_packages = true;
+            }
+          else if (w.substr (0, 7) == "-depth=")
+            {
+              local = false;
+
+              cmt_string depth_str;
+              int depth_value = 0;
+                          
+              w.substr (7, depth_str);
+              if ((sscanf (depth_str.c_str (), "%d", &depth_value) < 1) ||
+                  (depth_value < 1))
+                {
+                  // Syntax error
+                  //  We shall restrict to packages found within 
+                  // the <depth_value> first elements of CMTPATH.
+                  //  If CMTPATH is empty, nothing is selected.
+                  // depth=1 is equivalent to local
+                }
+
+	      Project::fill_selection (depth_value, path_selections);
+            }
+          else if (w.substr (0, 9) == "-exclude=")
+            {
+              cmt_string exclusion;
+
+              w.substr (9, exclusion);
+
+              int size = exclusion.size ();
+              
+              if (size >= 2)
+                {
+                  if (((exclusion[0] == '"') && (exclusion[size - 1] == '"')) ||
+                      ((exclusion[0] == '\'') && (exclusion[size - 1] == '\'')))
+                    {
+                      exclusion.erase (size - 1);
+                      exclusion.erase (0, 1);
+                    }
+
+                  CmtSystem::split (exclusion, " \t", exclusions);
+                }
+            }
+          else if (w.substr (0, 7) == "-global")
+            {
+              path_selections.clear ();
+
+              local = false;
+            }
+          else if (w.substr (0, 6) == "-local")
+            {
+              local = true;
+            }
+          else if (w.substr (0, 8) == "-select=")
+            {
+              cmt_string selection;
+
+              w.substr (8, selection);
+
+	      //cerr << "Select=[" << selection << "]" << endl;
+
+              int size = selection.size ();
+              
+              if (size >= 2)
+                {
+                  if (((selection[0] == '"') && (selection[size - 1] == '"')) ||
+                      ((selection[0] == '\'') && (selection[size - 1] == '\'')))
+                    {
+                      selection.erase (size - 1);
+                      selection.erase (0, 1);
+                    }
+                }
+
+	      CmtSystem::split (selection, " \t", selections);
+
+	      //cerr << "Selections.size () = " << selections.size () << endl;
+            }
+          else if (w.substr (0, 7) == "-begin=")
+            {
+              w.substr (7, begin);
+            }
+          else
+            {
+              command = w;
+            }
+        }
+      else
+        {
+          command += " ";
+          command += w;
+        }
+
+    }
+
+  if (local)
+    {
+      Project::fill_selection (1, path_selections);
+    }
+
+  if (command[0] == '-')
+    {
+      ignore_errors = true;
+      command.erase (0, 1);
+    }
+
+  //if (command.substr (0, 3) == "cmt") is_cmt = true;
+
+  if (all_packages)
+    {
+      PackageSelector selector (uses);
+      PathScanner scanner;
+      Project::scan_paths (scanner, selector);
+    }
+  else
+    {
+      for (i = Uses.size () - 1; i >= 0; i--)
+        {
+          Use* use = Uses[i];
+                  
+          if (use->discarded) continue;
+          if (use->m_hidden) continue;
+
+          if (!use->located ())
+            {
+              if (!Me.m_quiet)
+                {
+                  cerr << "#CMT> package " << use->get_package_name () <<
+                      " " << use->version << " " << use->path <<
+                      " not found" <<
+                      endl;
+                }
+            }
+          else
+            {
+              if (use->get_package_name () != "CMT")
+                {
+                  cmt_string& s = uses.add ();
+
+                  use->get_full_path (s);
+
+                  s += CmtSystem::file_separator ();
+                  if (use->style == mgr_style) s += "mgr";
+                  else s += "cmt";
+
+                  cmt_string& v = versions.add ();
+		  v = use->version;
+
+                  cmt_string& p = packages.add ();
+		  p = use->get_package_name ();
+
+                  //cout << ">>> adding " << s << " to selection" << endl;
+                }
+            }
+        }
+          
+      {
+        cmt_string& s = uses.add ();
+                  
+        Use* use = &(Use::current ());
+
+        if (use->get_package_name ().find ("cmt_standalone") != cmt_string::npos)
+          {
+            s = CmtSystem::pwd ();
+          }
+        else
+          {
+            use->get_full_path (s);
+
+            s += CmtSystem::file_separator ();
+                  
+            if (use->style == mgr_style) s += "mgr";
+            else s += "cmt";
+          }
+
+	cmt_string& v = versions.add ();
+	v = use->version;
+
+	cmt_string& p = packages.add ();
+	p = use->get_package_name ();
+
+        //cout << ">>> adding current " << s << " to selection" << endl;
+      }
+    }
+
+  bool started = false;
+
+  if (begin == "") started = true;
+
+  set_standard_macros ();
+  Cmt::reset_all_sets_done ();
+  Symbol::all_set ();
+
+  for (i = 0; i < uses.size (); i++)
+    {
+      const cmt_string& s = uses[i];
+      const cmt_string& v = versions[i];
+      const cmt_string& p = packages[i];
+      cmt_string cmtpath;
+
+      bool ok = true;
+      bool selected = true;
+      bool excluded = false;
+
+      if (path_selections.size () > 0)
+        {
+          selected = false;
+
+          for (int j = 0; j < path_selections.size (); j++)
+            {
+              const cmt_string& sel = path_selections[j];
+              
+              if (s.find (sel) != cmt_string::npos) 
+                {
+		  cmtpath = sel;
+                  selected = true;
+                  break;
+                }
+            }
+
+          ok = selected;
+        }
+
+      if (ok)
+        {
+          if (selections.size () > 0)
+            {
+              selected = false;
+              
+              for (int j = 0; j < selections.size (); j++)
+                {
+                  const cmt_string& sel = selections[j];
+                  
+                  if (s.find (sel) != cmt_string::npos) 
+                    {
+                      selected = true;
+                      break;
+                    }
+                }
+              
+              ok = selected;
+            }
+        }
+
+      if (ok && !started)
+        {
+          if (s.find (begin) != cmt_string::npos)
+            {
+              started = true;
+              ok = true;
+            }
+          else
+            {
+              ok = false;
+            }
+        }
+
+
+      if (ok)
+        {
+          excluded = false;
+
+          for (int j = 0; j < exclusions.size (); j++)
+            {
+              const cmt_string& exc = exclusions[j];
+              
+              if (s.find (exc) != cmt_string::npos) 
+                {
+                  excluded = true;
+                  break;
+                }
+            }
+
+          if (excluded) ok = false;
+        }
+
+      if (!ok) 
+        {
+          continue;
+        }
+
+
+
+      if (!CmtSystem::cd (s))
+        {
+          if (s.find ("cmt_standalone") != cmt_string::npos)
+            {
+              cerr << "#CMT> Currently not in a CMT package" << endl;
+            }
+          else
+            {
+              cerr << "#CMT> Cannot move to the package in " << s << " (" << i+1 << "/" 
+                   << uses.size () << ")"<< endl;
+            }
+
+          if (!ignore_errors) break;
+
+          continue;
+        }
+
+      if (CmtLock::check () == CmtLock::locked_by_another_user)
+        {
+          cerr << "#CMT> Ignore locked package in " << s << " (" << i+1 << "/" 
+               << uses.size () << ")" << endl;
+          continue;
+        }
+
+      if (cmtpath == "")
+        {
+	  cmt_string sel = CmtSystem::pwd ();
+	  cmtpath = Project::find_in_cmt_paths (sel);
+        }
+
+      cmt_string cmd = command;
+      static const cmt_string version_template = "<version>";
+      cmd.replace_all (version_template, v);
+
+      static const cmt_string package_template = "<package>";
+      cmd.replace_all (package_template, p);
+
+      static const cmt_string cmtpath_template = "<package_cmtpath>";
+      cmd.replace_all (cmtpath_template, cmtpath);
+
+      static const cmt_string offset_template = "<package_offset>";
+
+      static const cmt_string empty_string;
+      static const cmt_string fs = CmtSystem::file_separator ();
+      cmt_string offset = s;
+      offset.replace (cmtpath, empty_string);
+      if (offset[0] == CmtSystem::file_separator ())
+	{
+	  offset.replace (fs, empty_string);
+	}
+      CmtSystem::dirname (offset, offset);
+
+      cmt_string n;
+      CmtSystem::basename (offset, n);
+      if (n == p)
+	{
+	  CmtSystem::dirname (offset, offset);
+	}
+      else
+	{
+	  CmtSystem::dirname (offset, offset);
+	  CmtSystem::dirname (offset, offset);
+	}
+
+      cmd.replace_all (offset_template, offset);
+
+
+      cout << "#--------------------------------------------------------------" << endl;
+      cout << "# Now trying [" << cmd << "] in " << s << " (" << i+1 << "/" << uses.size () 
+           << ")" << endl;
+      cout << "#--------------------------------------------------------------" << endl;
+
+      if (is_cmt)
+        {
+          //
+          //  There is a bug in the recursive use of the parser. Macros are not set correctly.
+          //  Thus the recursive optimization is now discarded.
+          //
+          if (parser (cmd) != 0)
+            {
+              CmtError::set (CmtError::execution_error, cmd);
+              break;
+            }
+        }
+      else
+        {
+          int status = CmtSystem::execute (cmd);
+
+          //cerr << "do_broadcast> status=" << status << " ignore_errors=" << ignore_errors << endl;
+
+          if ((status != 0) && !ignore_errors)
+              //if ((status != 0) && !ignore_errors)
+            {
+              if (status != 2) CmtError::set (CmtError::execution_error, cmd);
+              break;
+            }
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_constituent_makefile (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_constituent_makefile>");
+      return;
+    }
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      Generator::build_constituent_makefile (ap.arguments[0]);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_constituents_makefile (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_constituents_makefile>");
+      return;
+    }
+  set_standard_macros ();
+
+  Generator::build_constituents_makefile (Me.m_current_package, ap.arguments);
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_dependencies (const ArgParser& ap,
+                                 int argc,
+                                 char* argv[])
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_dependencies>");
+      return;
+    }
+  if (ap.arguments.size () > 0)
+    {
+      set_standard_macros ();
+
+      Generator::build_dependencies (ap.arguments);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_library_links (const ArgParser& ap)
+{
+  cmt_string cmtinstallarea = "";
+  cmt_string tag = "";
+  cmt_string shlibsuffix;
+  cmt_string symlinkcmd;
+
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_library_links>");
+      return;
+    }
+
+  set_standard_macros ();
+
+  Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+  Use& current_use = Use::current ();
+  int i;
+
+  {
+    Symbol* macro = Symbol::find ("shlibsuffix");
+    if (macro == 0) return;
+    shlibsuffix = macro->build_macro_value ();
+    Symbol::expand (shlibsuffix);
+  }
+
+  {
+    Symbol* macro = Symbol::find ("library_install_command");
+    if (macro != 0)
+      {
+	symlinkcmd = macro->build_macro_value ();
+	Symbol::expand (symlinkcmd);
+      }
+  }
+
+  if (current_use.get_strategy ("InstallArea"))
+    {
+      const CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
+
+      //cout << "#IA2>" << endl;
+      
+      cmt_string s1 = ia_mgr.get_installarea ();
+
+      {
+        Symbol* symbol = Symbol::find ("CMTINSTALLAREA");
+        if (symbol != 0)
+          {
+            s1 = symbol->build_macro_value ();
+	    Symbol::expand (s1);
+          }
+      }
+
+      cmtinstallarea = s1;
+                  
+      cmt_string s2;
+
+      {
+        Symbol* macro = Symbol::find ("tag");
+        if (macro != 0)
+          {
+            s2 = macro->build_macro_value ();
+	    Symbol::expand (s2);
+          }
+      }
+
+      tag = s2;
+
+      cmt_string s = s1;
+      s += CmtSystem::file_separator ();
+      s += s2;
+      s += CmtSystem::file_separator ();
+      s += "lib";
+
+      CmtSystem::mkdir (s);
+    }
+
+  current_use.build_library_links (cmtinstallarea, tag, shlibsuffix, symlinkcmd);
+
+  for (i = 0; i < Uses.size (); i++)
+    {
+      Use* use = Uses[i];
+
+      if (use == 0) continue;
+      if (use->discarded) continue;
+      if (use->m_hidden) continue;
+
+      if (use->get_package_name () == "CMT") continue;
+      if (use->get_package_name () == current_use.get_package_name ()) continue;
+
+      use->build_library_links (cmtinstallarea, tag, shlibsuffix, symlinkcmd);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_make_setup (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_make_setup>");
+      return;
+    }
+  set_standard_macros ();
+  Generator::build_make_setup (Me.m_current_package);
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_msdev (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_msdev>");
+      return;
+    }
+
+  if (true)
+    {
+      set_standard_macros ();
+      if (ap.arguments.size () > 0) build_msdev_file (ap.arguments[0]);
+      else build_msdev_file ("");
+    }
+}
+
+void Cmt::do_build_CMT_pacman (const ArgParser& ap)
+{
+  cmt_string pacman_file;
+
+  pacman_file = Me.m_cmt_root;
+  pacman_file += CmtSystem::file_separator ();
+  pacman_file += "mgr";
+  pacman_file += CmtSystem::file_separator ();
+  pacman_file += "CMT.pacman";
+
+  cmt_string pacman;
+  cmt_string pattern = "<version>";
+  cmt_string replacement = CMTVERSION;
+
+  pacman.read (pacman_file);
+
+  pacman.replace_all (pattern, replacement);
+
+  cout << pacman << endl;
+}
+
+// Visual Studio.net Support                                                 
+//----------------------------------------------------------                 
+void Cmt::do_build_vsnet (const ArgParser& ap)     
+{                                                                            
+  if (CmtLock::check () == CmtLock::locked_by_another_user)                  
+    {                                                                        
+      CmtError::set (CmtError::conflicting_lock, "build_vsnet>");            
+      return;                                                                
+    }                                                                        
+                                                                             
+  if (true)                                                                  
+    {                                                                        
+      set_standard_macros ();                                                
+      if (ap.arguments.size () > 0) build_vsnet_file (ap.arguments[0]);            
+      else build_vsnet_file ("");                                            
+    }                                                                        
+}                                                                            
+
+//----------------------------------------------------------
+void Cmt::do_build_os9_makefile (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_os9_makefile>");
+      return;
+    }
+
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      build_OS9_makefile (ap.arguments[0]);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_prototype (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_prototype>");
+      return;
+    }
+
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      Generator::build_prototype (ap.arguments[0]);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_readme (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_readme>");
+      return;
+    }
+
+  set_standard_macros ();
+  Generator::build_readme (ap.arguments);
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_tag_makefile (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_tag_makefile>");
+      return;
+    }
+
+  print_macros (Make);
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_temporary_name (const ArgParser& ap)
+{
+  cmt_string name = CmtSystem::get_temporary_name ();
+  cout << name << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_triggers (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_tag_makefile>");
+      return;
+    }
+
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      TriggerGenerator::run (ap.arguments[0]);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_build_windefs (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "build_windefs>");
+      return;
+    }
+
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      Generator::build_windefs (ap.arguments[0]);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_check_configuration (const ArgParser& ap)
+{
+  cmt_string env;
+  Tag* tag;
+
+  set_standard_macros ();
+
+  static CmtSystem::cmt_string_vector tags;
+
+  CmtSystem::split (Me.m_extra_tags, " \t,", tags);
+
+  for (int i = 0; i < tags.size (); i++)
+    {
+      const cmt_string& t = tags[i];
+
+      tag = Tag::find (t);
+      if (tag == 0) continue;
+
+      if (!Tag::check_tag_used (tag) && !Symbol::check_tag_used (tag)) 
+	{
+	  cerr << "#CMT> The tag " << t << " is not used in any tag expression. Please check spelling" << endl;
+	}
+    }
+
+  Symbol::check_all_paths ();
+
+  env = CmtSystem::getenv ("CMTSITE");
+  if (env == "") 
+    {
+      return;
+    }
+
+  tag = Tag::find (env);
+  if (tag == 0) 
+    {
+      return;
+    }
+
+  if (!Tag::check_tag_used (tag) && !Symbol::check_tag_used (tag) && Cmt::get_warnings ()) 
+    {
+      cerr << "#CMT> The CMTSITE value " << env << " is not used in any tag expression. Please check spelling" << endl;
+    }
+
+}
+
+//----------------------------------------------------------
+void Cmt::do_check_files (const ArgParser& ap)
+{
+  if (ap.arguments.size () >= 2) 
+    {
+      cmt_string first_file = ap.arguments[0];
+      cmt_string second_file = ap.arguments[1];
+          
+      if (first_file == "") return;
+      if (second_file == "") return;
+          
+      CmtSystem::compare_and_update_files (first_file, second_file);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_check_version (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0)
+    {
+      cmt_string name = ap.arguments[0];
+          
+      if (name == "") return;
+      int v = 0;
+      int r = 0;
+      int p = 0;
+          
+      bool ok = CmtSystem::is_version_directory (name, v, r, p);
+          
+      if (ok)
+        {
+          cout << "# " << name << " is version " << v << " release " << r << " patch " << p << endl;
+        }
+      else
+        {
+          cout << "# " << name << " is not a version tag" << endl;
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_checkout (const ArgParser& ap)
+{
+  Cvs::checkout (ap.arguments);
+}
+
+//----------------------------------------------------------
+void Cmt::do_cleanup (const ArgParser& ap)
+{
+  print_clean (ap.mode);
+}
+
+//----------------------------------------------------------
+void Cmt::do_config (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "config>");
+      return;
+    }
+
+    //Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+  Use& current_use = Use::current ();
+
+  if (Me.m_debug)
+    {
+      cout << "Cmt::do_config> " << endl;
+      cout << "pwd " << CmtSystem::pwd () << endl;
+      cout << "current_dir " << Me.m_current_dir << endl;
+      cout << "default_path " << Me.m_default_path << endl;
+      cout << "cmt config " <<
+          Me.m_current_package << " " <<
+          Me.m_current_version << " " <<
+          Me.m_current_path << endl;
+    }
+
+  if (Me.m_current_package == "CMT") return;
+  if (Me.m_current_package == "methods") return;
+
+  cmt_string branch;
+
+  CmtSystem::basename (Me.m_current_dir, branch);
+
+  if ((branch != "mgr") && (branch != "cmt"))
+    {
+
+        //
+        // Here we are in a standalone package (ie completely unstructured)
+        //
+
+      if (CmtSystem::test_file ("requirements"))
+        {
+          cout << "------------------------------------------" << endl;
+          cout << "Configuring environment for standalone package." << endl;
+          cout << "CMT version " << Me.m_cmt_version << "." << endl;
+          cout << "System is " << Me.m_cmt_config << endl;
+          cout << "------------------------------------------" << endl;
+
+          install_test_setup_scripts ();
+          install_test_cleanup_scripts ();
+
+          Generator::build_default_makefile ();
+        }
+      else
+        {
+          cout << "==============================================" << endl;
+          cout << "cmt config must be operated either upon "
+            "an existing package" << endl;
+          cout << " (ie. when a requirements file already exists)" << endl;
+          cout << "   > cd ..." << endl;
+          cout << "   > cmt config" << endl;
+          cout << "or to create a new package" << endl;
+          cout << "   > cmt config <package> <version> [<path>]" << endl;
+          cout << "==============================================" << endl;
+        }
+
+      return;
+    }
+
+  configure_current_package ();
+
+  Generator::build_default_makefile ();
+
+  CmtSystem::cmt_string_vector makes;
+  cmt_regexp expression ("[.]n?make(sav)?$");
+
+  CmtSystem::scan_dir (".", expression, makes);
+  
+  if (makes.size () > 0)
+    {
+      cout << "Removing all previous make fragments from " << branch << endl;
+
+      for (int i = 0; i < makes.size (); i++)
+        {
+          const cmt_string& s = makes[i];
+          CmtSystem::cmt_string_vector words;
+          CmtSystem::split (s, '.', words);
+          if (words.size()>=2)
+              if (CmtSystem::get_makefile_suffix () == "nmake" && words[1] == "nmake")
+                      CmtSystem::remove_file (s);
+              else if (CmtSystem::get_makefile_suffix () == "make" && words[1] == "make")
+                      CmtSystem::remove_file (s);
+        }
+    }
+  
+
+  CmtSystem::cd ("..");
+
+  CmtSystem::scan_dir (Me.m_cmt_config, expression, makes); 
+    
+  if (makes.size () > 0) 
+    {
+      cout << "Removing all previous make fragments from "
+           << Me.m_cmt_config << endl; 
+
+      for (int i = 0; i < makes.size (); i++) 
+        { 
+          const cmt_string& s = makes[i];
+          CmtSystem::cmt_string_vector words;
+          CmtSystem::split (s, '.', words);
+          if (words.size()>=2)
+              if (CmtSystem::get_makefile_suffix () == "nmake" && words[1] == "nmake")
+                      CmtSystem::remove_file (s);
+              else if (CmtSystem::get_makefile_suffix () == "make" && words[1] == "make")
+                      CmtSystem::remove_file (s);
+        }    
+    } 
+     //exit(-1);
+
+  /*
+  // cout << "Try a cleanup of the installation area " << endl;
+
+    //
+    //  Try a cleanup of the installation area
+    //
+  if (current_use.get_strategy ("InstallArea"))
+    {
+      CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
+
+      //cout << "#IA3>" << endl;
+
+      if (current_use.get_strategy ("SetupCleanup"))
+	{
+	  ia_mgr.config ();
+	}
+    }
+  */
+
+  CmtSystem::cd (branch); 
+
+  Use& use = Use::current ();
+
+  use.set (Me.m_current_package,
+           Me.m_current_version,
+           Me.m_current_path,
+           "",
+           "");
+
+  use.change_path (Me.m_current_path);
+  use.style     = Me.m_current_style;
+
+  //cout << "do_config> current style=" << Me.m_current_style << endl;
+
+  Me.m_quiet = true;
+
+  if (!reach_current_package ())
+    {
+      cout << "Cannot read the requirements file" << endl;
+      return;
+    }
+
+  install_setup_scripts ();
+  install_cleanup_scripts ();
+  install_native_version_file ();
+
+  CmtSystem::cd ("..");
+
+  Branch::BranchVector& branches = Branch::branches ();
+
+  int i;
+
+  for (i = 0; i < branches.size (); i++)
+    {
+      const Branch& branch = branches[i];
+      const cmt_string& branch_name = branch.name ();
+
+      if (!CmtSystem::test_directory (branch_name))
+        {
+          if (!CmtSystem::mkdir (branch_name))
+            {
+              cout << "Cannot create the " << branch_name <<" branch" << endl;
+            }
+          else
+            {
+              cout << "Installing the " << branch_name << " directory" << endl;
+            }
+        }
+      else
+        {
+          cout << branch_name << " directory already installed" << endl;
+        }
+    }
+}
+
+
+//----------------------------------------------------------
+void Cmt::do_relocate (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "relocate>");
+      return;
+    }
+
+  Use& current_use = Use::current ();
+
+  if (Me.m_debug)
+    {
+      cout << "Cmt::do_relocate> " << endl;
+      cout << "pwd "          << CmtSystem::pwd () << endl;
+      cout << "current_dir "  << Me.m_current_dir << endl;
+      cout << "default_path " << Me.m_default_path << endl;
+      cout << "cmt config "   <<
+          Me.m_current_package << " " <<
+          Me.m_current_version << " " <<
+          Me.m_current_path << endl;
+    }
+
+  if (Me.m_current_package == "CMT")     return;
+  if (Me.m_current_package == "methods") return;
+
+  cmt_string branch;
+
+  CmtSystem::basename (Me.m_current_dir, branch);
+
+  if ((branch != "mgr") && (branch != "cmt"))
+    {
+
+        //
+        // Here we are in a standalone package (ie completely unstructured)
+        //
+
+      if (CmtSystem::test_file ("requirements"))
+        {
+          cout << "------------------------------------------" << endl;
+          cout << "Configuring environment for standalone package." << endl;
+          cout << "CMT version " << Me.m_cmt_version << "." << endl;
+          cout << "System is "   << Me.m_cmt_config << endl;
+          cout << "------------------------------------------" << endl;
+
+          install_test_setup_scripts ();
+          install_test_cleanup_scripts ();
+
+          Generator::build_default_makefile ();
+        }
+      else
+        {
+          cout << "==============================================" << endl;
+          cout << "cmt relocate must be operated either upon "
+            "an existing package" << endl;
+          cout << " (ie. when a requirements file already exists)" << endl;
+          cout << "   > cd ..." << endl;
+          cout << "   > cmt relocate" << endl;
+          cout << "or to create a new package" << endl;
+          cout << "   > cmt relocate <package> <version> [<path>]" << endl;
+          cout << "==============================================" << endl;
+        }
+
+      return;
+    }
+
+  configure_current_package ();
+
+  Generator::build_default_makefile ();
+  
+  CmtSystem::cd ("..");    
+  CmtSystem::cd (branch); 
+
+  Use& use = Use::current ();
+
+  use.set (Me.m_current_package,
+           Me.m_current_version,
+           Me.m_current_path,
+           "",
+           "");
+
+  use.change_path (Me.m_current_path);
+  use.style     = Me.m_current_style;
+
+  Me.m_quiet = true;
+
+  if (!reach_current_package ())
+    {
+      cout << "Cannot read the requirements file" << endl;
+      return;
+    }
+
+  install_setup_scripts ();
+  install_cleanup_scripts ();
+
+  CmtSystem::cd ("..");
+
+  Branch::BranchVector& branches = Branch::branches ();
+
+  int i;
+
+  for (i = 0; i < branches.size (); i++)
+    {
+      const Branch& branch = branches[i];
+      const cmt_string& branch_name = branch.name ();
+
+      if (!CmtSystem::test_directory (branch_name))
+        {
+          if (!CmtSystem::mkdir (branch_name))
+            {
+              cout << "Cannot create the " << branch_name <<" branch" << endl;
+            }
+          else
+            {
+              cout << "Installing the " << branch_name << " directory" << endl;
+            }
+        }
+      else
+        {
+          cout << branch_name << " directory already installed" << endl;
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_create (const ArgParser& ap)
+{
+  if (ap.arguments.size () < 2) return;
+
+  const cmt_string& package = ap.arguments[0];
+  const cmt_string& version = ap.arguments[1];
+  cmt_string offset;
+  if (ap.arguments.size () >= 3) offset = ap.arguments[2];
+
+  if (Me.m_debug)
+    {
+      cout << "do_create>Me.m_current_package=" << Me.m_current_package << endl;
+      cout << "do_create>package=" << package << endl;
+    }
+
+    //if (Me.m_current_package == "CMT") return;
+    //if (Me.m_current_package == "methods") return;
+
+  cmt_string the_path;
+
+  the_path = CmtSystem::pwd ();
+
+  if (offset != "")
+    {
+      if (!CmtSystem::absolute_path (offset))
+        {
+          // offset is really a relative offset
+          the_path += CmtSystem::file_separator ();
+          the_path += offset;
+        }
+      else // absolute path
+        {
+          the_path = offset;
+        }
+    }
+
+  CmtSystem::compress_path (the_path);
+
+  // Now 'the_path' contains the complete path where the package will be created
+
+  cout << "------------------------------------------" << endl;
+  cout << "Configuring environment for package " << package <<
+    " version " << version << "." << endl;
+  cout << "CMT version " << Me.m_cmt_version << "." << endl;
+  cout << "Root set to " << the_path << "." << endl;
+  cout << "System is " << Me.m_cmt_config << endl;
+  cout << "------------------------------------------" << endl;
+
+  if (!CmtSystem::test_directory (the_path))
+    {
+      if (!CmtSystem::mkdir (the_path))
+        {
+          cout << "Cannot create the path directory" << endl;
+          return;
+        }
+      else
+        {
+          cout << "Installing the path directory" << endl;
+        }
+    }
+
+  CmtSystem::cd (the_path);
+
+  if (!CmtSystem::test_directory (package))
+    {
+      if (!CmtSystem::mkdir (package))
+        {
+          cout << "Cannot create the package directory" << endl;
+          return;
+        }
+      else
+        {
+          cout << "Installing the package directory" << endl;
+        }
+    }
+  else
+    {
+      cout << "Package directory already installed" << endl;
+    }
+
+  CmtSystem::cd (package);
+
+  Use& current_use = Use::current ();
+
+  bool with_version_dir = current_use.get_strategy ("VersionDirectory");
+
+  CmtStructuringStyle style = get_current_structuring_style ();
+
+  if (style != default_structuring_style)
+    {
+      if (with_version_dir)
+	{
+	  if (style == without_version_directory)
+	    {
+	      with_version_dir = false;
+	    }
+	}
+      else
+	{
+	  if (style == with_version_directory)
+	    {
+	      with_version_dir = true;
+	    }
+	}
+    }
+
+  if (with_version_dir)
+    {
+      if (!CmtSystem::test_directory (version))
+        {
+          if (!CmtSystem::mkdir (version))
+            {
+              cout << "Cannot create the version directory" << endl;
+              return;
+            }
+          else
+            {
+              cout << "Installing the version directory" << endl;
+            }
+        }
+      else
+        {
+          cout << "Version directory already installed" << endl;
+        }
+
+      CmtSystem::cd (version);
+    }
+  else
+    {
+      cout << "Version directory will not be created due to structuring style" << endl;
+    }
+
+  if (!CmtSystem::test_directory ("cmt"))
+    {
+      if (!CmtSystem::test_directory ("mgr"))
+        {
+          if (!CmtSystem::mkdir ("cmt"))
+            {
+              cout << "Cannot create the cmt directory" << endl;
+              return;
+            }
+          else
+            {
+              if (with_version_dir)
+                {
+                  Me.m_current_style = cmt_style;
+                }
+              else
+                {
+                  Me.m_current_style = no_version_style;
+                }
+
+              cout << "Installing the cmt directory" << endl;
+            }
+        }
+      else
+        {
+          if (with_version_dir)
+            {
+              Me.m_current_style = mgr_style;
+            }
+          else
+            {
+              Me.m_current_style = no_version_style;
+            }
+          
+          cout << "Mgr directory already installed" << endl;
+        }
+    }
+  else
+    {
+      if (with_version_dir)
+        {
+          Me.m_current_style = cmt_style;
+        }
+      else
+        {
+          Me.m_current_style = no_version_style;
+        }
+
+      cout << "Cmt directory already installed" << endl;
+    }
+
+  if (!CmtSystem::test_directory ("src"))
+    {
+      if (!CmtSystem::mkdir ("src"))
+        {
+          cout << "Cannot create the src directory" << endl;
+          return;
+        }
+      else
+        {
+          cout << "Installing the src directory" << endl;
+        }
+    }
+  else
+    {
+      cout << "src directory already installed" << endl;
+    }
+
+  switch (Me.m_current_style)
+    {
+    case cmt_style:
+    case no_version_style:
+      CmtSystem::cd ("cmt");
+      break;
+    case mgr_style:
+      CmtSystem::cd ("mgr");
+      break;
+    }
+
+  Generator::build_default_makefile ();
+
+  if (!CmtSystem::test_file ("requirements"))
+    {
+      // create an empty requirement file.
+      ofstream f ("requirements");
+      if (f)
+        {
+          f << "package " << package << endl;
+          f << endl;
+          f.close ();
+        }
+    }
+
+  if (!with_version_dir)
+    {
+      ofstream f ("version.cmt");
+      if (f)
+        {
+          f << version << endl;
+          f.close ();
+        }
+    }
+
+  Me.m_current_package = package;
+  Me.m_current_version = version;
+  Me.m_current_path    = the_path;
+  Me.m_current_dir     = CmtSystem::pwd ();
+
+  do_config (ap);
+}
+
+//----------------------------------------------------------
+void Cmt::do_create_project (const ArgParser& ap)
+{
+  int argc = ap.arguments.size ();
+  int arg = 0;
+
+  if (argc < 1) return;
+
+  cmt_string project;
+  cmt_string release;
+  cmt_string path;
+
+  project = ap.arguments[arg]; argc--; arg++;
+
+  if (argc > 0)
+    {
+      release = ap.arguments[arg];
+
+      if (release[0] != '-')
+	{
+	  argc--; 
+	  arg++;
+	  if (argc > 0)
+	    {
+	      path = ap.arguments[arg];
+	      if (path[0] != '-')
+		{
+		  argc--; arg++;
+		}
+	      else
+		{
+		  path = "";
+		}
+	    }
+	}
+      else
+	{
+	  release = "";
+	}
+    }
+
+  if (Project::create (project, release, path))
+    {
+      while (argc > 0)
+	{
+	  const cmt_string& argument = ap.arguments[arg]; argc--; arg++;
+	  
+	  if (argument.substr (0, 5) == "-use=")
+	    {
+	      cmt_string use;
+
+	      argument.substr (5, use);
+
+	      CmtSystem::cmt_string_vector words;
+	      CmtSystem::split (use, ":", words);
+
+	      ofstream f (Project::get_project_file_name (), ios_base::app);
+	      if (f)
+		{
+		  f << "use " << words[0] << " " << words[1] << " " << words[2] << endl;
+		  f << endl;
+		  f.close ();
+		}
+	    }
+	}
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_cvsbranches (const ArgParser& ap)
+{
+  Cvs::branches (ap.arguments[0]);
+}
+
+//----------------------------------------------------------
+void Cmt::do_cvssubpackages (const ArgParser& ap)
+{
+  Cvs::subpackages (ap.arguments[0]);
+}
+
+//----------------------------------------------------------
+void Cmt::do_cvssubprojects (const ArgParser& ap)
+{
+  Cvs::subprojects (ap.arguments[0]);
+}
+
+//----------------------------------------------------------
+void Cmt::do_cvstags (const ArgParser& ap)
+{
+  Cvs::tags (ap.arguments);
+}
+
+//----------------------------------------------------------
+void Cmt::do_do (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      Cmt::reset_all_sets_done ();
+      Symbol::all_set ();
+      Generator::build_default_makefile ();
+
+      Symbol* symbol = Symbol::find (ap.arguments[0]);
+
+      if (symbol == 0)
+	{
+	  Me.m_action = action_show_action_names;
+	  /*
+	  if (!Me.m_quiet)
+	    {
+	      cerr << "Existing actions:" << endl;
+	      print_symbol_names (ap.mode);
+	    }
+	  */
+	  CmtError::set (CmtError::unknown_command, ap.arguments[0]);
+	  return;
+	}
+
+      /*
+	We convert extra arguments into the standard macro cmt_args 
+      */
+
+      cmt_string args;
+
+      for (int i = 1; i < ap.arguments.size (); i++)
+	{
+	  cmt_string s = ap.arguments[i];
+	  if (i > 1) args += " ";
+	  args += s;
+	}
+
+      cmt_string r = "macro cmt_args \"";
+      r += args;
+      r += "\"";
+
+      Use* current_use = &(Use::current ());
+      
+      SyntaxParser::parse_requirements_line (r, current_use);
+
+      cmt_string cmd = symbol->build_macro_value ();
+      Symbol::expand (cmd);
+
+      cout << "Execute action " << ap.arguments[0] << " => " << cmd << endl;
+
+      int status = CmtSystem::execute (cmd);
+      if (status != 0)
+        CmtError::set (CmtError::execution_failed, ap.arguments[0], status);
+      
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_expand_model (const ArgParser& ap)
+{
+  set_standard_macros ();
+
+  if ((ap.arguments[0] == "-strict") && (ap.arguments.size () > 1))
+    {
+      CmtModel::strict_expand (ap.arguments[1]);
+    }
+  else if ((ap.arguments[0] == "-test") && (ap.arguments.size () > 2))
+    {
+      CmtModel::test_regexp (ap.arguments[1], ap.arguments[2]);
+    }
+  else if (ap.arguments.size () > 0)
+    {
+      CmtModel::expand (ap.arguments[0]);
+    }
+}
+
+/**
+ *  Handle free filtering of text files containing $(xxx) or ${xxx} patterns
+ *
+ *  Substitution is performed against CMT macros and environment variables.
+ *
+ *  Arguments:
+ *
+ *    cmt filter input-file-name output-file-name
+ *
+ */
+void Cmt::do_filter (const ArgParser& ap)
+{
+  if (ap.arguments.size () < 2) return;
+
+  cmt_string& input = ap.arguments[0];
+  cmt_string& output = ap.arguments[1];
+
+  if (!CmtSystem::test_file (input))
+    {
+      cerr << "#CMT> File " << input << " not found" << endl;
+      return;
+    }
+
+  cmt_string text;
+
+  text.read (input);
+
+  set_standard_macros ();
+
+  Symbol::expand (text);
+
+  FILE* file = fopen (output, "wb");
+  if (file == NULL)
+    {
+      cerr << "#CMT> Cannot write filtered file " << output << endl;
+    }
+  else
+    {
+      text.write (file);
+      fclose (file);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_help (const ArgParser& ap)
+{
+  //cerr << "ap.help_action=" << ap.help_action << " Me.m_action=" << Me.m_action << endl;
+  if (Me.m_action == action_none)
+    {
+      CommandHelp::show_all ();
+    }
+  else
+    {
+      CommandHelp::show (Me.m_action);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_lock (const ArgParser& ap)
+{
+  const cmt_string& package = Me.m_current_package;
+  const cmt_string& version = Me.m_current_version;
+  const cmt_string& path    = Me.m_current_path;
+
+  //(unsused) Use& use = Use::current();
+
+  cout << "try to lock package " << package << " in " << CmtSystem::pwd () << endl;
+
+  set_standard_macros ();
+
+  CmtLock::status status = CmtLock::lock ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_remove (const ArgParser& ap)
+{
+  const cmt_string& package = Me.m_current_package;
+  const cmt_string& version = Me.m_current_version;
+  const cmt_string& path    = Me.m_current_path;
+
+    //Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+  if (Me.m_current_package == "CMT") return;
+  if (Me.m_current_package == "methods") return;
+
+  cmt_string the_path;
+
+  //the_path = Me.m_default_path;
+  the_path = CmtSystem::pwd ();
+
+  if (path != "")
+    {
+      if (!CmtSystem::absolute_path (path))
+        {
+          // path is just a suffix
+          the_path += CmtSystem::file_separator ();
+          the_path += path;
+        }
+      else // absolute path
+        {
+          the_path = path;
+        }
+    }
+
+  CmtSystem::compress_path (the_path);
+
+  cout << "------------------------------------------" << endl;
+  cout << "Removing package " << package <<
+    " version " << version << "." << endl;
+  cout << "CMT version " << Me.m_cmt_version << "." << endl;
+  cout << "Root set to " << the_path << "." << endl;
+  cout << "System is " << Me.m_cmt_config << endl;
+  cout << "------------------------------------------" << endl;
+
+  the_path += CmtSystem::file_separator ();
+  the_path += package;
+
+  if (!CmtSystem::cd (the_path))
+    {
+      cout << "Path " << the_path << " not reachable" << endl;
+      return;
+    }
+
+  if (CmtSystem::test_directory (version))
+    {
+      if (CmtSystem::remove_directory (version))
+        {
+          cout << "Version " << version << " has been removed from " << the_path << endl;
+          CmtSystem::cmt_string_vector contents;
+          CmtSystem::scan_dir (".", contents);
+          if (contents.size () == 0)
+            {
+              CmtSystem::cd ("..");
+              if (CmtSystem::remove_directory (package))
+                {
+                  cout << "Package " << package << " has no more versions. Thus it has been removed."<< endl;
+                }
+            }
+        }
+      else
+        {
+          cout << "Impossible to remove version " << version << " from " << the_path << endl;
+        }
+    }
+  else if (CmtSystem::test_directory ("cmt"))
+    {
+      CmtSystem::cd ("cmt");
+
+      cmt_string v;
+
+      v.read ("version.cmt");
+      if (v == version)
+        {
+          CmtSystem::cd ("..");
+          if (!CmtSystem::remove_directory ("cmt"))
+            {
+              cout << "Unstructured version " << version
+                   << " has been removed from " << the_path << endl;
+            }
+          else
+            {
+              cout << "Impossible to remove unstructured version " << version
+                   << " from " << the_path << endl;
+            }
+        }
+      else
+        {
+          cout << "Version " << version << " not found" << endl;
+        }
+    }
+  else
+    {
+      cout << "Version " << version << " not found" << endl;
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_remove_library_links (const ArgParser& ap)
+{
+  if (CmtLock::check () == CmtLock::locked_by_another_user)
+    {
+      CmtError::set (CmtError::conflicting_lock, "remove_library_links>");
+      return;
+    }
+
+  set_standard_macros ();
+
+  Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+  Use& current_use = Use::current ();
+  int i;
+  cmt_string shlibsuffix;
+  cmt_string symunlink;
+
+  {
+    Symbol* macro = Symbol::find ("shlibsuffix");
+    if (macro == 0) return;
+    shlibsuffix = macro->build_macro_value ();
+    Symbol::expand (shlibsuffix);
+  }
+
+  {
+    Symbol* macro = Symbol::find ("symunlink");
+    if (macro == 0) return;
+    symunlink = macro->build_macro_value ();
+    Symbol::expand (symunlink);
+  }
+
+  for (i = 0; i < Uses.size (); i++)
+    {
+      Use* use = Uses[i];
+
+      if (use->discarded) continue;
+      if (use->m_hidden) continue;
+
+      if (!use->located ())
+        {
+          if (!Me.m_quiet)
+            {
+              cerr << "#CMT> package " << use->get_package_name () <<
+                  " " << use->version << " " << use->path << 
+                  " not found" <<
+                  endl;
+            }
+        }
+      else
+        {
+          if (use->get_package_name () == "CMT") continue;
+          if (use->get_package_name () == current_use.get_package_name ()) continue;
+
+          cmt_string s;
+
+          s = use->get_package_name ();
+          s += "_libraries";
+
+          Symbol* libraries_macro = Symbol::find (s);
+
+          if (libraries_macro == 0) continue;
+
+          cmt_string libraries = libraries_macro->build_macro_value ();
+	  Symbol::expand (libraries);
+
+          static CmtSystem::cmt_string_vector values;
+
+          CmtSystem::split (libraries, " \t", values);
+
+          for (int j = 0; j < values.size (); j++)
+            {
+              const cmt_string& library = values[j];
+
+              static cmt_string libname;
+              static cmt_string name;
+
+              // Is it a simple name or a complete path?
+
+              libname = library;
+              Symbol::expand (libname);
+
+              if (CmtSystem::absolute_path (libname))
+                {
+                  /**
+                   *   We assume here that "library" contains a complete path.
+                   *   (including the complete syntax libxxx.so)
+                   */
+
+                  cmt_string suffix;
+                  CmtSystem::basename (library, name);
+                }
+              else
+                {
+                  /**
+                   *   Here we expect that only the base name of the library
+                   *   is given : ie it should not contain the "lib" prefix, 
+                   *   nor the suffix .so, nor any path prefix.
+                   *    This of course should generally correspond to a constituent name.
+                   */
+
+                  name = "lib";
+                  name += libname;
+                  name += ".";
+                  name += shlibsuffix;
+                }
+
+              Symbol::expand (libname);
+
+              if (current_use.get_strategy ("InstallArea"))
+                {
+                  const CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
+
+		  //cout << "#IA4>" << endl;
+
+                  cmt_string s1 = ia_mgr.get_installarea ();
+
+                  {
+                    Symbol* symbol = Symbol::find ("CMTINSTALLAREA");
+                    if (symbol != 0)
+                      {
+                        s1 = symbol->build_macro_value ();
+			Symbol::expand (s1);
+                      }
+                  }
+                  
+                  cmt_string s2;
+
+                  {
+                    Symbol* macro = Symbol::find ("tag");
+                    if (macro != 0)
+                      {
+                        s2 = macro->build_macro_value ();
+			Symbol::expand (s2);
+                      }
+                  }
+
+                    // Now deleting the reference file
+
+                  s = symunlink;
+                  s += " ";
+                  s += s1;
+                  s += CmtSystem::file_separator ();
+                  s += s2;
+                  s += CmtSystem::file_separator ();
+                  s += "lib";
+                  s += CmtSystem::file_separator ();
+                  s += name;
+                  s += ".cmtref";
+                  s += " ";
+                  s += s1;
+                  s += CmtSystem::file_separator ();
+                  s += s2;
+                  s += CmtSystem::file_separator ();
+                  s += "lib";
+                  s += CmtSystem::file_separator ();
+                  s += name;
+                }
+              else
+                {
+                  s = symunlink;
+                  s += " ../$(";
+                  s += current_use.get_package_name ();
+                  s += "_tag)/";
+                  s += name;
+                }
+
+              Symbol::expand (s);
+
+              if (!Me.m_quiet) cout << s << endl;
+              int status = CmtSystem::execute (s);
+
+              if (status != 0)
+                {
+                  if (status != 2) CmtError::set (CmtError::execution_error, s);
+
+                  cerr << "#CMT> Cannot remove the symbolic link " << s << endl;
+
+                  break;
+                }
+            }
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_run (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      Cmt::reset_all_sets_done ();
+      Symbol::all_set ();
+
+      cmt_string cmd;
+
+      for (int i = 0; i < ap.arguments.size (); i++)
+	{
+	  cmd += ap.arguments[i];
+	  cmd += " ";
+	}
+
+      CmtSystem::execute (cmd);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_run_sequence (const ArgParser& ap)
+{
+  if (ap.arguments.size () == 0) cerr << "#CMT> run_sequence: no sequence specified" << endl;
+
+  SequenceRunner runner;
+
+  cout << "# cmt run_sequence: sequence " << ap.arguments[0] << endl;
+
+  runner.run (ap.arguments[0]);
+}
+
+//----------------------------------------------------------
+void Cmt::do_set_version (const ArgParser& ap)
+{
+  if (ap.arguments.size () == 0) cerr << "#CMT> set version: no version specified" << endl;
+
+  const cmt_string& version = ap.arguments[0];
+
+  int v, r, p;
+
+  if (!CmtSystem::is_version_directory (version, v, r, p))
+    {
+      cerr << "#CMT> set version " << version << " is not a correct version syntax" << endl;
+      return;
+    }
+
+  if ((v == -1) || (r == -1) || (p == -1))
+    {
+      cerr << "#CMT> set version " << version
+	   << " You cannot use wild card to set a version" << endl;
+      return;
+    }
+
+  // We want to install the version.cmt file
+
+  // We first check we are in a cmt branch
+  cmt_string h = CmtSystem::pwd ();
+  cmt_string branch;
+  CmtSystem::basename (h, branch);
+
+  if (branch != "cmt")
+    {
+      cerr << "#CMT> set version " << version << " must be applied in a cmt directory" 
+	   << endl;
+      return;
+    }
+
+  CmtSystem::dirname (h, h);
+  CmtSystem::basename (h, branch);
+
+  if (branch == version)
+    {
+      cerr << "#CMT> set version " << version << " is already available as a version directory" 
+	   << endl;
+      return;
+    }
+
+  cout << "Writing version file : " << version << endl;
+
+  version.write ("version.cmt");
+}
+
+//----------------------------------------------------------
+void Cmt::do_set_versions (const ArgParser& ap)
+{
+  CmtSystem::cmt_string_vector args;
+
+  args = ap.arguments;
+  {
+    cmt_string& s = args.add ();
+    s = "cmt";
+  }
+  {
+    cmt_string& s = args.add ();
+    s = "set";
+  }
+  {
+    cmt_string& s = args.add ();
+    s = "version";
+  }
+  {
+    cmt_string& s = args.add ();
+    s = "<version>";
+  }
+
+  Me.m_action = action_broadcast;
+
+  do_broadcast (ap);
+}
+
+//----------------------------------------------------------
+void Cmt::do_setup (const ArgParser& ap)
+{
+  Use& current_use = Use::current ();
+
+  do_check_configuration (ap);
+
+  print (ap.mode);
+
+    //
+    //  Try a cleanup of the installation area
+    //
+  if (current_use.get_strategy ("InstallArea"))
+    {
+      CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
+
+      //cout << "#IA5>" << endl;
+
+      ia_mgr.setup ();
+
+      /*
+      if (current_use.get_strategy ("SetupCleanup"))
+        {
+	  const cmt_string& installarea = ia_mgr.get_installarea ();
+
+	  if (installarea != "")
+	    {
+	      cmt_string q;
+	      
+	      switch (mode)
+		{
+		case Sh :
+		case Csh :
+		  q = "\'";
+		  break;
+		default :
+		  break;
+		}
+	      
+	      if (!Me.m_quiet)
+		{
+		  cout << "echo "  << q 
+		       << "# Doing cleanup in the installation area " << installarea 
+		       << q << endl;
+		}
+	    }
+
+	  ia_mgr.config ();
+        }
+      */
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_action (const ArgParser& ap)
+{
+  cmt_string target;
+
+  if (ap.arguments.size () > 0) target = ap.arguments[0];
+
+  Symbol* symbol;
+
+  set_standard_macros ();
+
+  symbol = Symbol::find (target);
+
+  if (symbol == 0) 
+    {
+      cmt_string t = " ";
+      t += target;
+      t += " is not defined ";
+
+      CmtError::set (CmtError::symbol_not_found, t);
+
+      return;
+    }
+  else
+    {
+      cmt_string t = target;
+      t += " is a ";
+
+      if ((Me.m_action == action_show_action) ||
+          (Me.m_action == action_show_action_value))
+	{
+	  if (symbol->type != Symbol::SymbolAction)
+	    {
+	      if (symbol->type == Symbol::SymbolMacro)
+		{
+		  t += "macro";
+		}
+	      else if (symbol->type == Symbol::SymbolSet)
+		{
+		  t += "set";
+		}
+	      else if (symbol->type == Symbol::SymbolPath)
+		{
+		  t += "path";
+		}
+	      else if (symbol->type == Symbol::SymbolAlias)
+		{
+		  t += "alias";
+		}
+
+	      CmtError::set (CmtError::warning, t);
+	    }
+        }
+    }
+
+  if (symbol->value_lists.size () < 1) return;
+
+  symbol->show_macro (ap.mode);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_action_names (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0)
+    {
+      const cmt_string& pattern = ap.arguments[0];
+      print_symbol_names (ap.mode, pattern);
+    }
+  else
+    {
+      print_symbol_names (ap.mode);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_action_value (const ArgParser& ap)
+{
+  do_show_macro (ap);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_actions (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0)
+    {
+      const cmt_string& pattern = ap.arguments[0];
+      print_macros (ap.mode, pattern);
+    }
+  else
+    {
+      print_macros (ap.mode);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_all_tags (const ArgParser& /*ap*/)
+{
+  Tag::TagPtrVector tags = Tag::tags ();
+  int index;
+
+  set_standard_macros ();
+
+  for (index = 0; index < tags.size (); index++)
+    {
+      const Tag* tag = tags[index];
+      if (tag != 0)
+        {
+          tag->show_definition (true);
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_applied_patterns (const ArgParser& /*ap*/)
+{
+  Pattern::show_all_applied_patterns ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_author (const ArgParser& /*ap*/)
+{
+  Use& use = Use::current();
+
+  cout << use.author << endl;
+  
+}
+//----------------------------------------------------------
+void Cmt::do_show_project_author (const ArgParser& /*ap*/)
+{
+  cmt_string cmtpath;
+  cmt_string offset;
+  cmt_string pauthor = "";
+
+  Use& use = Use::current();    
+  use.get_cmtpath_and_offset (cmtpath, offset);
+  Project* p = Project::find_by_cmtpath (cmtpath);
+
+  cout <<p->get_author ()<<endl;
+
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_branches (const ArgParser& ap)
+{
+  Branch::print_all (ap.mode);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_clients (const ArgParser& ap)
+{
+  cmt_string package   = "";
+  cmt_string version   = "";
+  cmt_string path_name = "";
+
+  if (ap.arguments.size () >= 1) package  = ap.arguments[0];
+  if (ap.arguments.size () >= 2) version  = ap.arguments[1];
+  if (ap.arguments.size () >= 3) path_name = ap.arguments[2];
+
+  PathScanner scanner;
+  ClientCollector collector (package, version);
+
+  clear     ();
+  configure ();
+
+  cout << "# ----------- Clients of " << package <<
+    " " << version <<
+    " " << path_name <<
+    endl;
+
+  if (path_name == "")
+    {
+      Project::scan_paths (scanner, collector);
+    }
+  else
+    {
+      scanner.scan_path (path_name, collector);
+    }
+  cout << "# ----------- " << collector.count () << " clients found." << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_cmtpath_patterns (const ArgParser& /*ap*/)
+{
+  set_standard_macros ();
+  CmtPathPattern::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_constituent (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+
+      Constituent* c = Constituent::find (ap.arguments[0]);
+      if (c != 0)
+	{
+	  c->show ();
+	}
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_constituent_names (const ArgParser& /*ap*/)
+{
+  set_standard_macros ();
+  Constituent::show_names ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_constituents (const ArgParser& /*ap*/)
+{
+  set_standard_macros ();
+  Constituent::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_cycles (const ArgParser& /*ap*/)
+{
+  set_standard_macros ();
+  Use& use = Use::current();
+
+  use.show_cycles ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_fragment (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0) Fragment::show (ap.arguments[0]);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_fragments (const ArgParser& /*ap*/)
+{
+  Fragment::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_groups (const ArgParser& /*ap*/)
+{
+  Group::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_include_dirs (const ArgParser& /*ap*/)
+{
+  cmt_string temp;
+
+  Use& use = Use::current();
+
+  set_standard_macros ();
+
+  if (use.include_path == "")
+    {
+      temp += "$(src) ";
+    }
+  else if (use.include_path != "none")
+    {
+      temp += use.include_path;
+      temp += " ";
+    }
+
+  for (int include_number = 0;
+       include_number < use.includes.size ();
+       include_number++)
+    {
+      Include& incl = use.includes[include_number];
+
+      if (incl.name == "") continue;
+
+      temp += incl.name;
+      temp += " ";
+    }
+
+  cout << temp << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_language (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0) 
+    {
+      set_standard_macros ();
+      Language::show (ap.arguments[0]);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_languages (const ArgParser& /*ap*/)
+{
+  set_standard_macros ();
+  Language::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_macro (const ArgParser& ap)
+{
+  cmt_string target;
+
+  if (ap.arguments.size () > 0) target = ap.arguments[0];
+
+  Symbol* symbol;
+
+  set_standard_macros ();
+
+  symbol = Symbol::find (target);
+
+  if (symbol == 0) 
+    {
+      cmt_string t = " ";
+      t += target;
+      t += " is not defined ";
+
+      CmtError::set (CmtError::symbol_not_found, t);
+
+      return;
+    }
+  else
+    {
+      cmt_string t = target;
+      t += " is a ";
+
+      if ((Me.m_action == action_show_macro) ||
+          (Me.m_action == action_show_macro_value))
+	{
+	  if (symbol->type != Symbol::SymbolMacro)
+	    {
+	      if (symbol->type == Symbol::SymbolAction)
+		{
+		  t += "action";
+		}
+	      else if (symbol->type == Symbol::SymbolSet)
+		{
+		  t += "set";
+		}
+	      else if (symbol->type == Symbol::SymbolPath)
+		{
+		  t += "path";
+		}
+	      else if (symbol->type == Symbol::SymbolAlias)
+		{
+		  t += "alias";
+		}
+
+	      CmtError::set (CmtError::warning, t);
+	    }
+	}
+      else if ((Me.m_action == action_show_set) ||
+               (Me.m_action == action_show_set_value))
+        {
+	  if ((symbol->type != Symbol::SymbolSet) &&
+	      (symbol->type != Symbol::SymbolPath) &&
+	      (symbol->type != Symbol::SymbolAction) &&
+	      (symbol->type != Symbol::SymbolAlias))
+	    {
+	      t += "macro";
+
+	      CmtError::set (CmtError::warning, t);
+	    }
+        }
+    }
+
+  if (symbol->value_lists.size () < 1) return;
+
+  symbol->show_macro (ap.mode);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_macro_names (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0)
+    {
+      const cmt_string& pattern = ap.arguments[0];
+      print_symbol_names (ap.mode, pattern);
+    }
+  else
+    {
+      print_symbol_names (ap.mode);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_macro_value (const ArgParser& ap)
+{
+  do_show_macro (ap);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_macros (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0)
+    {
+      const cmt_string& pattern = ap.arguments[0];
+      print_macros (ap.mode, pattern);
+    }
+  else
+    {
+      print_macros (ap.mode);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_manager (const ArgParser& /*ap*/)
+{
+  Use& use = Use::current();
+
+  cout << use.manager << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_packages (const ArgParser& ap)
+{
+  cmt_string path_name;
+
+  if (ap.arguments.size () > 0) path_name = ap.arguments[0];
+
+  PathScanner   scanner;
+  PackageViewer viewer;
+
+  if (path_name == "")
+    {
+      Project::scan_paths (scanner, viewer);
+    }
+  else
+    {
+      scanner.scan_path (path_name, viewer);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_path (const ArgParser& /*ap*/)
+{
+  Project::show_paths ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_pattern (const ArgParser& ap)
+{
+  cmt_string name;
+  if (ap.arguments.size () > 0) name = ap.arguments[0];
+  Pattern::show (name);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_pattern_names (const ArgParser& /*ap*/)
+{
+  Pattern::show_all_names ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_patterns (const ArgParser& /*ap*/)
+{
+  Pattern::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_projects (const ArgParser& /*ap*/)
+{
+  Project::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_pwd (const ArgParser& /*ap*/)
+{
+  cout << Me.m_current_dir << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_setup (const ArgParser& ap)
+{
+  cout << "----------> uses" << endl;
+  do_show_uses (ap);
+
+  cout << "----------> tags" << endl;
+  do_show_tags (ap);
+
+  cout << "----------> CMTPATH" << endl;
+  do_show_path (ap);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_set (const ArgParser& ap)
+{
+  do_show_macro (ap);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_set_names (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0)
+    {
+      const cmt_string& pattern = ap.arguments[0];
+      print_symbol_names (ap.mode, pattern);
+    }
+  else
+    {
+      print_symbol_names (ap.mode);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_set_value (const ArgParser& ap)
+{
+  do_show_macro (ap);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_sets (const ArgParser& ap)
+{
+  if (ap.arguments.size () > 0)
+    {
+      const cmt_string& pattern = ap.arguments[0];
+      print_macros (ap.mode, pattern);
+    }
+  else
+    {
+      print_macros (ap.mode);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_strategies (const ArgParser& /*ap*/)
+{
+  Use& current_use = Use::current ();
+
+  Project::show_specified_strategies_for_all ();
+
+  Project* p = Project::get_current ();
+
+  /*
+    if (p != 0) p->show ();
+    else cout << "No current project" << endl;
+  */
+
+  cout << "Build strategy     : ";
+
+  if (current_use.get_strategy ("BuildPrototypes"))
+    {
+      cout << "prototypes";
+    }
+  else
+    {
+      cout << "no_prototypes";
+    }
+  
+  if (current_use.get_strategy ("InstallArea"))
+    {
+      cout << " with_installarea";
+    }
+  else
+    {
+      cout << " without_installarea";
+    }
+  
+  cout << endl;
+
+  cout << "Setup strategy     : ";
+  
+  if (current_use.get_strategy ("SetupConfig"))
+    {
+      cout << "config";
+    }
+  else
+    {
+      cout << "no_config";
+    }
+  
+  if (current_use.get_strategy ("SetupRoot"))
+    {
+      cout << " root";
+    }
+  else
+    {
+      cout << " no_root";
+    }
+  
+  if (current_use.get_strategy ("SetupCleanup"))
+    {
+      cout << " cleanup";
+    }
+  else
+    {
+      cout << " no_cleanup";
+    }
+
+  cout << endl;
+  
+  cout << "Structure strategy : ";
+  
+  if (current_use.get_strategy ("VersionDirectory"))
+    {
+      cout << "with_version_directory";
+    }
+  else
+    {
+      cout << "without_version_directory";
+    }
+  
+  cout << endl;
+
+  if (Me.m_current_structuring_style != default_structuring_style)
+    {
+      cout << "Structuring style  : ";
+
+      switch (Me.m_current_structuring_style)
+	{
+	case without_version_directory:
+	  cout << "without_version_directory";
+	  break;
+	case with_version_directory:
+	  cout << "with_version_directory";
+	  break;
+	}
+
+      cout << endl;
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_tags (const ArgParser& /*ap*/)
+{
+  Tag::TagPtrVector tags = Tag::tags ();
+  int index;
+
+  set_standard_macros ();
+
+  for (index = 0; index < tags.size (); index++)
+    {
+      const Tag* tag = tags[index];
+      if (tag != 0)
+        {
+          tag->show (Me.m_quiet);
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_use_paths (const ArgParser& ap)
+{
+  const cmt_string& to_name = ap.arguments[0];
+
+  Use* current = &(Use::current());
+
+  current->get_all_clients (to_name);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_uses (const ArgParser& /*ap*/)
+{
+  Use::show_all ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_version (const ArgParser& /*ap*/)
+{
+  cout << Me.m_current_version << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_versions (const ArgParser& ap)
+{
+  cmt_string package_name;
+
+  if (ap.arguments.size () > 0) package_name = ap.arguments[0];
+
+  PathScanner scanner;
+
+  Project::scan_paths_for_package (scanner, package_name);
+}
+
+//----------------------------------------------------------
+void Cmt::do_show_system (const ArgParser& /*ap*/)
+{
+  cout << CmtSystem::get_cmt_config () << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::do_unlock (const ArgParser& /*ap*/)
+{
+  const cmt_string& package = Me.m_current_package;
+  const cmt_string& version = Me.m_current_version;
+  const cmt_string& path    = Me.m_current_path;
+
+  // (unused??) Use& use = Use::current();
+
+  cout << "try to unlock package " << package << " in " << CmtSystem::pwd () << endl;
+
+  set_standard_macros ();
+
+  CmtLock::status status = CmtLock::unlock ();
+}
+
+//----------------------------------------------------------
+void Cmt::do_version (const ArgParser& /*ap*/)
+{
+  cout << CMTVERSION << endl;
+}
+
+
+
+//----------------------------------------------------------
+ActionType Cmt::get_action ()
+{
+  return (Me.m_action);
+}
+
+/*
+const CmtSystem::cmt_string_vector& Cmt::get_cmt_path ()
+{
+  return (Me.m_cmt_path);
+}
+
+const CmtSystem::cmt_string_vector& Cmt::get_cmt_path_pwds ()
+{
+  return (Me.m_cmt_path_pwds);
+}
+
+const CmtSystem::cmt_string_vector& Cmt::get_cmt_path_sources ()
+{
+  return (Me.m_cmt_path_sources);
+}
+*/
+
+const cmt_string& Cmt::get_cmt_home ()
+{
+  return (Me.m_cmt_home);
+}
+
+const cmt_string& Cmt::get_cmt_user_context ()
+{
+  return (Me.m_cmt_user_context);
+}
+
+const cmt_string& Cmt::get_cmt_version ()
+{
+  return (Me.m_cmt_version);
+}
+
+const cmt_string& Cmt::get_current_dir ()
+{
+  return (Me.m_current_dir);
+}
+
+const cmt_string& Cmt::get_current_package ()
+{
+  return (Me.m_current_package);
+}
+
+const cmt_string& Cmt::get_current_cmtpath ()
+{
+  return (Me.m_current_cmtpath);
+}
+
+const cmt_string& Cmt::get_current_offset ()
+{
+  return (Me.m_current_offset);
+}
+
+AccessMode Cmt::get_current_access ()
+{
+  return (Me.m_current_access);
+}
+
+CmtStructuringStyle Cmt::get_current_structuring_style ()
+{
+  return (Me.m_current_structuring_style);
+}
+
+CmtDirStyle Cmt::get_current_style ()
+{
+  return (Me.m_current_style);
+}
+
+const cmt_string& Cmt::get_current_version ()
+{
+  return (Me.m_current_version);
+}
+
+const cmt_string& Cmt::get_current_target ()
+{
+  return (Me.m_current_target);
+}
+
+bool Cmt::get_debug ()
+{
+  return (Me.m_debug);
+}
+
+bool Cmt::get_quiet ()
+{
+  return (Me.m_quiet);
+}
+
+bool Cmt::get_disable_warnings ()
+{
+  return (Me.m_disable_warnings);
+}
+
+bool Cmt::get_warnings ()
+{
+  return (Me.m_warnings);
+}
+
+bool Cmt::get_recursive ()
+{
+  return (Me.m_recursive);
+}
+
+CmtScopeFilteringMode Cmt::get_scope_filtering_mode ()
+{
+  if (Me.m_scope_filtering_mode == default_filtering_mode)
+    {
+      return (block_private_uses);
+    }
+  else
+    {
+      return (Me.m_scope_filtering_mode);
+    }
+}
+
+//----------------------------------------------------------
+bool Cmt::get_all_sets_done ()
+{
+  return (Me.m_all_sets_done);
+}
+
+/**---------------------------------------------------------
+  guess_current_project
+
+   if current directory is in one of the CMTPATHs, do nothing.
+
+  Otherwise, we want to guess the current project
+
+  move up in directories until cmt/project.cmt is found
+
+  for (;;)
+  {
+    if test -f ./cmt/project.cmt
+      ok:
+        this directory should become the first entry of the CMTPATH
+        break
+
+    if (at top) break;
+
+    move up
+  }
+  */
+void Cmt::guess_current_project ()
+{
+  Log;
+
+  log << "guess_current_project" << log_endl;
+
+  if (Project::find_in_cmt_paths (Me.m_current_dir) == "")
+    {
+      cmt_string project_file = "cmt";
+      project_file += CmtSystem::file_separator ();
+      project_file += Project::get_project_file_name ();
+
+      cmt_string pwd;
+
+      for (;;)
+	{
+	  pwd = CmtSystem::pwd ();
+	  if (CmtSystem::test_file (project_file))
+	    {
+	      //this directory should become the first entry of the CMTPATH
+
+	      IProjectFactory& factory = ProjectFactory::instance ();
+	      factory.create_project ("", pwd, "CurrentProject", 0);
+
+	      break;
+	    }
+
+	  log << "pwd=" << CmtSystem::pwd () << log_endl;
+	  
+	  if (!CmtSystem::cd (".."))
+	    {
+	      break;
+	    }
+	  if (CmtSystem::pwd () == pwd)
+	    {
+	      break;
+	    }
+	}
+      CmtSystem::cd (Me.m_current_dir);
+    }
+
+  //cmt_string buffer = "path CMTPATH \n";
+  cmt_string buffer;
+  Project::fill_cmtpaths (buffer);
+  //cerr << "buffer = " << buffer << endl;
+  Use& use = Use::current();
+  bool save_quiet = Me.m_quiet;
+  Me.m_quiet = true;
+  SyntaxParser::parse_requirements_text (buffer, "", &use);
+  Me.m_quiet = save_quiet;
+
+  Me.m_autoconfigure_cmtpath = true;
+}
+
+//----------------------------------------------------------
+const cmt_string& Cmt::filter_dir (const cmt_string& dir)
+{
+  static cmt_string newdir;
+
+  CmtSystem::compress_path (dir, newdir);
+
+  return (newdir);
+}
+
+//----------------------------------------------------------
+static void dos_script_prefix (FILE* f, 
+			       const cmt_string& cmt_root, 
+			       const cmt_string& package, 
+			       const cmt_string& version, 
+			       const cmt_string& path, 
+			       const cmt_string& action, 
+			       const cmt_string& option = "")
+{
+  cmt_string no_device = path;
+
+  if (CmtSystem::absolute_path (path)) 
+    {
+      if (path[1] == ':')
+	{
+	  no_device = path.substr (2);
+	}
+    }
+
+  if (package == "cmt_standalone")
+    {
+      no_device = "";
+    }
+  else
+    {
+      no_device = "..\\..\\..";
+      if (Cmt::get_current_style () == no_version_style)
+	{
+	  no_device = "..\\..";
+	}
+    }
+
+
+  fprintf (f, "@echo off\n");
+  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 ());
+  fprintf (f, "\n");
+  fprintf (f, "set cmttempfile=\"%%TEMP%%\\tmpsetup.bat\"\n");
+  fprintf (f, "%%CMTROOT%%\\%%CMTBIN%%\\cmt.exe %s -bat "
+	   " -pack=%s -version=%s -path=\"%%~d0%%~p0%s\" "
+	   " %s "
+	   "%%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9 >%%cmttempfile%%\n",
+	   action.c_str (),
+	   package.c_str (),
+	   version.c_str (),
+	   no_device.c_str (),
+	   option.c_str ());
+  fprintf (f, "if exist %%cmttempfile%% call %%cmttempfile%%\n");
+  fprintf (f, "if exist %%cmttempfile%% del %%cmttempfile%%\n");
+  fprintf (f, "set cmttempfile=\n");
+}
+
+//----------------------------------------------------------
+void Cmt::install_cleanup_scripts ()
+{
+#ifdef WIN32
+  static const int modes = 1;
+  static const cmt_string suffix[1]   = {"bat"};
+  static const PrintMode  mode[1]     = {Bat};
+#else
+  static const int modes = 2;
+  static const cmt_string suffix[2]   = {"csh", "sh"};
+  static const PrintMode  mode[2]     = {Csh, Sh};
+#endif
+
+  cout << "Creating cleanup scripts." << endl;
+
+  cmt_string temp;
+  int i;
+
+  cmt_string version = Me.m_current_version;
+  if (version == "v*") version = "";
+
+  for (i = 0; i < modes; i++)
+    {
+      cmt_string file_name = "cleanup";
+      file_name += ".";
+      file_name += suffix[i];
+      file_name += ".";
+      file_name += "new";
+
+      FILE* f = fopen (file_name.c_str (), "wb");
+      if (f != NULL)
+        {
+          if (mode[i] == Csh)
+            {
+              fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
+              fprintf (f, "  setenv CMTROOT %s\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "endif\n");
+              fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
+              fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if $status != 0 then\n  set tempfile=/tmp/cmt.$$\nendif\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s "
+                       "-pack=%s -version=%s -path=%s $* >${tempfile}; "
+                       "source ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_package.c_str (),
+                       version.c_str (),
+                       Me.m_current_path.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else if (mode[i] == Sh)
+            {
+              fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
+              fprintf (f, "  CMTROOT=%s; export CMTROOT\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "fi\n");
+              fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
+              fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s "
+                       "-pack=%s -version=%s -path=%s $* >${tempfile}; "
+                       ". ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_package.c_str (),
+                       version.c_str (),
+                       Me.m_current_path.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else if (mode[i] == Bat)
+            {
+	      dos_script_prefix (f, Me.m_cmt_root, 
+				 Me.m_current_package, version, Me.m_current_path,
+				 "cleanup");
+            }
+
+          fprintf (f, "\n");
+
+          fclose (f);
+
+          cmt_string old_file_name = "cleanup";
+          old_file_name += ".";
+          old_file_name += suffix[i];
+
+          CmtSystem::compare_and_update_files (file_name, old_file_name);
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::install_setup_scripts ()
+{
+#ifdef WIN32
+  static const int modes = 1;
+  static const cmt_string suffix[1]   = {"bat"};
+  static const PrintMode  mode[1]     = {Bat};
+#else
+  static const int modes = 2;
+  static const cmt_string suffix[2]   = {"csh", "sh"};
+  static const PrintMode  mode[2]     = {Csh, Sh};
+#endif
+
+  cout << "Creating setup scripts." << endl;
+
+  Use& current_use = Use::current ();
+  
+  cmt_string no_cleanup_opt;
+
+  if (current_use.get_strategy ("SetupCleanup"))
+    {
+      no_cleanup_opt = " -no_cleanup";
+    }
+
+  cmt_string temp;
+  int i;
+
+  cmt_string version = Me.m_current_version;
+  if (version == "v*") version = "";
+
+  for (i = 0; i < modes; i++)
+    {
+      cmt_string file_name = "setup";
+      file_name += ".";
+      file_name += suffix[i];
+      file_name += ".";
+      file_name += "new";
+
+      FILE* f = fopen (file_name.c_str (), "wb");
+      if (f != NULL)
+        {
+          if (mode[i] == Csh)
+            {
+              fprintf (f, "# echo \"Setting %s %s in %s\"\n",
+                       Me.m_current_package.c_str (),
+                       version.c_str (),
+                       Me.m_current_path.c_str ());
+              fprintf (f, "\n");
+
+              fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
+              fprintf (f, "  setenv CMTROOT %s\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "endif\n");
+              fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
+              fprintf (f, "\n");
+              fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if $status != 0 then\n  set tempfile=/tmp/cmt.$$\nendif\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt setup -%s "
+                       "-pack=%s -version=%s -path=%s %s $* >${tempfile}; "
+                       "source ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_package.c_str (),
+                       version.c_str (),
+                       Me.m_current_path.c_str (),
+		       no_cleanup_opt.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else if (mode[i] == Sh)
+            {
+              fprintf (f, "# echo \"Setting %s %s in %s\"\n",
+                       Me.m_current_package.c_str (),
+                       version.c_str (),
+                       Me.m_current_path.c_str ());
+              fprintf (f, "\n");
+
+              fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
+              fprintf (f, "  CMTROOT=%s; export CMTROOT\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "fi\n");
+              fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
+              fprintf (f, "\n");
+              fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt setup -%s "
+                       "-pack=%s -version=%s -path=%s %s $* >${tempfile}; "
+                       ". ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_package.c_str (),
+                       version.c_str (),
+                       Me.m_current_path.c_str (),
+		       no_cleanup_opt.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else if (mode[i] == Bat)
+            {
+              fprintf (f, "rem Setting %s %s in %%~d0%%~p0\n",
+                       Me.m_current_package.c_str (),
+                       version.c_str ());
+	      dos_script_prefix (f, Me.m_cmt_root, 
+				 Me.m_current_package, version, Me.m_current_path,
+				 "setup", no_cleanup_opt);
+            }
+
+          fprintf (f, "\n");
+
+          fclose (f);
+
+          cmt_string old_file_name = "setup";
+          old_file_name += ".";
+          old_file_name += suffix[i];
+
+          CmtSystem::compare_and_update_files (file_name, old_file_name);
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::install_test_cleanup_scripts ()
+{
+#ifdef WIN32
+  static const int modes = 1;
+  static const cmt_string suffix[1]   = {"bat"};
+  static const PrintMode  mode[1]     = {Bat};
+#else
+  static const int modes = 2;
+  static const cmt_string suffix[2]   = {"csh", "sh"};
+  static const PrintMode  mode[2]     = {Csh, Sh};
+#endif
+
+  cout << "Creating cleanup scripts." << endl;
+
+  cmt_string temp;
+  int i;
+
+  cmt_string version = Me.m_current_version;
+  if (version == "v*") version = "";
+
+  for (i = 0; i < modes; i++)
+    {
+      cmt_string file_name = "cleanup";
+      file_name += ".";
+      file_name += suffix[i];
+      file_name += ".";
+      file_name += "new";
+
+      FILE* f = fopen (file_name.c_str (), "wb");
+      if (f != NULL)
+        {
+          if (mode[i] == Csh)
+            {
+              fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
+              fprintf (f, "  setenv CMTROOT %s\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "endif\n");
+              fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
+              fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if $status != 0 then\n  set tempfile=/tmp/cmt.$$\nendif\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; "
+                       "source ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_path.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else if (mode[i] == Sh)
+            {
+              fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
+              fprintf (f, "  CMTROOT=%s; export CMTROOT\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "fi\n");
+              fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
+              fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s -pack=cmt_standalone -path=%s $* >${tempfile}; "
+                       ". ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_path.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else
+            {
+	      dos_script_prefix (f, Me.m_cmt_root, 
+				 "cmt_standalone", "", Me.m_current_path, 
+				 "cleanup");
+            }
+
+          fprintf (f, "\n");
+
+          fclose (f);
+
+          cmt_string old_file_name = "cleanup";
+          old_file_name += ".";
+          old_file_name += suffix[i];
+
+          CmtSystem::compare_and_update_files (file_name, old_file_name);
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::install_native_version_file ()
+{    
+  Use& current_use        = Use::current ();
+  cmt_string package_name = current_use.get_package_name();
+  cmt_string macro_name   = package_name + "_native_version";
+  Symbol* macro           = Symbol::find (macro_name);
+  if (macro != 0)
+  {
+      cmt_string value = macro->resolve_macro_value ();
+      if (value != "")
+      {
+        cout << "Creating native_version file." << endl;    
+        FILE* f          = fopen ("new.native_version.cmt", "wb");
+        if (f != NULL)
+        {
+            fprintf (f, "%s\n", value.c_str ());
+        }      
+        //cout<<value <<endl;
+        fclose (f);
+
+        CmtSystem::compare_and_update_files ("new.native_version.cmt", "native_version.cmt");
+      } 
+  }    
+}
+//----------------------------------------------------------
+void Cmt::install_test_setup_scripts ()
+{
+#ifdef WIN32
+  static const int modes = 1;
+  static const cmt_string suffix[1]   = {"bat"};
+  static const PrintMode  mode[1]     = {Bat};
+#else
+  static const int modes = 2;
+  static const cmt_string suffix[2]   = {"csh", "sh"};
+  static const PrintMode  mode[2]     = {Csh, Sh};
+#endif
+
+  cout << "Creating setup scripts." << endl;
+
+  Use& current_use = Use::current ();
+
+  cmt_string no_cleanup_opt;
+
+  if (current_use.get_strategy ("SetupCleanup"))
+    {
+      no_cleanup_opt = " -no_cleanup";
+    }
+
+  cmt_string temp;
+  int i;
+
+  for (i = 0; i < modes; i++)
+    {
+      cmt_string file_name = "setup";
+      file_name += ".";
+      file_name += suffix[i];
+      file_name += ".";
+      file_name += "new";
+
+      FILE* f = fopen (file_name.c_str (), "wb");
+      if (f != NULL)
+        {
+          if (mode[i] == Csh)
+            {
+              fprintf (f, "# echo \"Setting standalone package\"\n");
+              fprintf (f, "\n");
+
+              fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
+              fprintf (f, "  setenv CMTROOT %s\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "endif\n");
+              fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
+              fprintf (f, "set tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if $status != 0 then\n  set tempfile=/tmp/cmt.$$\nendif\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt setup -%s -pack=cmt_standalone -path=%s %s $* >${tempfile}; "
+                       "source ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_path.c_str (),
+		       no_cleanup_opt.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else if (mode[i] == Sh)
+            {
+              fprintf (f, "# echo \"Setting standalone package\"\n");
+              fprintf (f, "\n");
+
+              fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
+              fprintf (f, "  CMTROOT=%s; export CMTROOT\n", Me.m_cmt_root.c_str ());
+              fprintf (f, "fi\n");
+              fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
+              fprintf (f, "\n");
+              fprintf (f, "tempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n");
+              fprintf (f, "if test ! $? = 0 ; then tempfile=/tmp/cmt.$$; fi\n");
+              fprintf (f, "${CMTROOT}/mgr/cmt setup -%s -pack=cmt_standalone -path=%s %s $* >${tempfile}; "
+                       ". ${tempfile}\n",
+                       suffix[i].c_str (),
+                       Me.m_current_path.c_str (),
+		       no_cleanup_opt.c_str ());
+              fprintf (f, "/bin/rm -f ${tempfile}\n");
+            }
+          else
+            {
+              fprintf (f, "rem Setting standalone package\n");
+	      dos_script_prefix (f, Me.m_cmt_root, 
+				 "cmt_standalone", "", Me.m_current_path, 
+				 "setup", no_cleanup_opt);
+            }
+
+          fprintf (f, "\n");
+
+          fclose (f);
+
+          cmt_string old_file_name = "setup";
+          old_file_name += ".";
+          old_file_name += suffix[i];
+
+          CmtSystem::compare_and_update_files (file_name, old_file_name);
+        }
+    }
+}
+
+/**
+ *    load is only called from the Windows GUI which pretends to access directly
+ *   the internal data model.
+ *    This is considered to be rather unsafe, and should be replaced by query functions.
+ */
+bool Cmt::load (const cmt_string& path,
+                const cmt_string& package,
+                const cmt_string& version,
+                const cmt_string& tag_name)
+{
+  clear ();
+  configure ();
+
+  Me.m_action  = action_load;
+  Me.m_recursive = true;
+
+  if (((package != "") && (version != "")) || (Me.m_current_package == ""))
+    {
+      //
+      //  Here we want to connect to a new package, or to the current package
+      //  but with another tag.
+      //
+      //   the 'package' argument may include a directory offset. Thus 'path'
+      //  is only expected to hold the base directory.
+      //
+      cmt_string offset;
+      cmt_string package_name;
+      
+      CmtSystem::dirname (package, offset);
+      CmtSystem::basename (package, package_name);
+      
+      if (offset != "")
+        {
+          Me.m_current_path = path;
+          Me.m_current_path += CmtSystem::file_separator ();
+          Me.m_current_path += offset;
+        }
+      else
+        {
+          Me.m_current_path = path;
+        }
+      
+      Me.m_current_package = package_name;
+      Me.m_current_version = version;
+    }
+
+  if (tag_name != "")
+    {
+      Tag* tag;
+
+      Tag::unmark_all ();
+      configure_version_tag ();
+      configure_site_tag (0);
+      configure_uname_tag ();
+      configure_hosttype_tag ();
+
+      Me.m_current_tag = tag_name;
+
+      //if (!Me.m_quiet) cerr << "load1> current_tag=" << Me.m_current_tag << endl;
+
+      tag = Tag::add (tag_name, PriorityTag, "load", 0);
+      tag->mark ();
+    }
+
+  /*
+    Set to developer mode if positioned into the package
+    (which is detected since we were able to retreive the
+    Version, Package and Path)
+  */
+
+  if ((Me.m_current_path == "") ||
+      (Me.m_current_package == "") ||
+      (Me.m_current_version == ""))
+    {
+      Me.m_current_access = UserMode;
+    }
+  else
+    {
+      Me.m_current_access = DeveloperMode;
+    }
+
+  use_cmt ();
+
+  cmt_string dir;
+
+  /*
+    Try to access the package.
+  */
+
+  if (Me.m_current_path != "")
+    {
+      dir = Me.m_current_path;
+    }
+  else
+    {
+      dir = Me.m_default_path;
+    }
+
+  if (!CmtSystem::cd (Me.m_current_path))
+    {
+      if (!Me.m_quiet)
+        {
+          cerr << "#CMT> Cannot reach the directory " <<
+            Me.m_current_path << endl;
+        }
+      CmtError::set (CmtError::package_not_found, "Load> Cannot reach the path directory");
+      CmtSystem::cd (Me.m_current_dir);
+
+      return (false);
+    }
+
+  dir += CmtSystem::file_separator ();
+  dir += Me.m_current_package;
+
+  if (!CmtSystem::cd (Me.m_current_package))
+    {
+      if (!Me.m_quiet)
+        {
+          cerr << "#CMT::load> Cannot reach the package " <<
+            Me.m_current_package << endl;
+        }
+      CmtError::set (CmtError::package_not_found, "Load> Cannot reach the package directory");
+      CmtSystem::cd (Me.m_current_dir);
+
+      return (false);
+    }
+
+  dir += CmtSystem::file_separator ();
+  dir += Me.m_current_version;
+
+  Me.m_current_style = none_style;
+
+  if (!CmtSystem::cd (Me.m_current_version))
+    {
+      if (!CmtSystem::test_directory ("cmt"))
+        {
+          if (!Me.m_quiet)
+            {
+              cerr << "#CMT> Cannot reach the version " <<
+                Me.m_current_version << endl;
+            }
+          CmtError::set (CmtError::package_not_found, "Load> Cannot reach the version directory");
+          CmtSystem::cd (Me.m_current_dir);
+
+          return (false);
+        }
+      else
+        {
+          Me.m_current_style = no_version_style;
+        }
+    }
+
+  if (CmtSystem::cd ("cmt"))
+    {
+      dir += CmtSystem::file_separator ();
+      dir += "cmt";
+      if (Me.m_current_style == none_style) Me.m_current_style = cmt_style;
+    }
+  else
+    {
+      /*
+        if (!Me.m_quiet)
+        {
+        cerr << "Cannot reach the cmt branch" << endl;
+        }
+      */
+
+      if (CmtSystem::cd ("mgr"))
+        {
+          dir += CmtSystem::file_separator ();
+          dir += "mgr";
+          if (Me.m_current_style == none_style) Me.m_current_style = mgr_style;
+        }
+      else
+        {
+          if (!Me.m_quiet)
+            {
+              cerr << "#CMT> Cannot reach the mgr branch" << endl;
+            }
+
+          CmtError::set (CmtError::package_not_found,
+                         "Load> Cannot reach the mgr/cmt directory");
+          CmtSystem::cd (Me.m_current_dir);
+
+          return (false);
+        }
+    }
+
+  /*
+    Check Tag is always set up
+  */
+
+  if (Me.m_current_tag == "")
+    {
+      char* env;
+
+      env = getenv (Me.m_current_config.c_str ());
+      if (env != 0)
+        {
+          Tag* tag;
+
+          tag = Tag::add (env, PriorityConfig, "load", 0);
+          tag->mark ();
+          Me.m_current_tag = env;
+
+          //if (!Me.m_quiet) cerr << "load2> current_tag=" << Me.m_current_tag << endl;
+
+        }
+      else
+        {
+          Me.m_current_tag = Me.m_cmt_config;
+
+          //if (!Me.m_quiet) cerr << "load3> current_tag=" << Me.m_current_tag << endl;
+
+        }
+    }
+
+  if (Me.m_debug)
+    {
+      cout << "pwd = " << CmtSystem::pwd () << endl;
+    }
+
+  configure_current_dir ();
+  build_prefix (Me.m_current_package, Me.m_current_prefix);
+  build_config (Me.m_current_prefix, Me.m_current_config);
+
+  Use* use = &(Use::current());
+  use->path    = Me.m_current_path;
+  use->set_package_name (Me.m_current_package);
+  use->version = Me.m_current_version;
+  use->prefix  = Me.m_current_prefix;
+  use->done    = false;
+  use->style   = Me.m_current_style;
+
+  /*
+    Work on the requirements file.
+  */
+
+  dir += CmtSystem::file_separator ();
+  dir += "requirements";
+  SyntaxParser::parse_requirements (dir, use);
+
+  if (CmtError::has_pending_error ()) return (false);
+
+    /**
+     * See reach_current_package for an explanation of this call
+     */
+  Pattern::apply_all_globals ();
+
+  /*
+    Select all possible tags
+  */
+
+  Tag::restore_tree ();
+
+  return (true);
+}
+
+//----------------------------------------------------------
+bool Cmt::need_prototypes ()
+{
+  Use& current_use = Use::current ();
+
+  if (current_use.get_strategy ("BuildPrototypes")) return (true);
+  else return (false);
+}
+
+//----------------------------------------------------------
+void Cmt::parse_arguments (ArgParser& ap)
+{
+  /*
+    Decoding arguments.
+
+    While decoding all arguments, no requirements analysis should
+    occur. Every new option, or parameter should be saved and
+    used later at actual analysis time.
+  */
+
+  Me.m_action = action_none;
+
+  restore_all_tags (0);
+
+#ifdef WIN32
+  Me.m_build_nmake = true;
+#endif
+
+  ap.parse ();
+}
+
+//----------------------------------------------------------
+int Cmt::parser (const cmt_string& command_line)
+{
+  CmtSystem::cmt_string_vector v;
+
+  CmtSystem::split (command_line, " \t", v);
+
+  int argc = v.size ();
+
+  char** argv = (char**) malloc ((argc + 1) * sizeof (char*));
+
+  int i;
+  for (i = 0; i < argc; i++)
+    {
+      argv[i] = (char*) v[i].c_str ();
+    }
+  argv[argc] = 0;
+
+  int status = parser (argc, argv);
+
+  free (argv);
+
+  return (status);
+}
+
+//----------------------------------------------------------
+int Cmt::parser (int argc, char* argv[])
+{
+  ArgParser ap (Me);
+  
+  ap.argc = argc;
+  ap.argv = argv;
+
+  if (argc <= 1)
+    {
+      do_help (ap);
+      exit (0);
+    }
+
+
+  clear ();
+  configure ();
+
+  CmtError::clear ();
+
+  /*
+    Set private if positioned inside the package
+    (which is detected since we were able to retreive the
+    Version, Package and Path)
+  */
+
+  if ((Me.m_current_path.size () == 0) ||
+      (Me.m_current_package.size () == 0) ||
+      (Me.m_current_version.size () == 0))
+    {
+      Me.m_current_access = UserMode;
+    }
+  else
+    {
+      Me.m_current_access = DeveloperMode;
+    }
+  
+  parse_arguments (ap);
+  
+  if (Me.m_debug)
+    {
+      cout << "After parse_argument> pack=" << Me.m_current_package
+           << " Me.m_current_tag=" << Me.m_current_tag
+           << " cwd=" << CmtSystem::pwd () 
+	   << " mode=" << Me.m_current_access
+           << endl;
+    }
+
+  if (Me.m_configure_error != "")
+    {
+      if (!Me.m_quiet) cerr << "#CMT> Error: " << Me.m_configure_error << endl;
+      return (CmtError::execution_error);
+    }
+
+  if (CmtError::has_pending_error ())
+    {
+      int code = CmtError::get_last_error_code ();
+      if (!Me.m_quiet) CmtError::print ();
+      clear ();
+
+      return (code);
+    }
+
+  /*
+    Now actual requirements analysis can take place.
+
+    Extra lines or files are analysed first.
+  */
+
+  if (strlen (ap.extra_file.c_str ()) > 0) SyntaxParser::parse_requirements (ap.extra_file, (Use*) 0);
+  if (strlen (ap.extra_line.c_str ()) > 0) SyntaxParser::parse_requirements_line (ap.extra_line, (Use*) 0);
+
+  //
+  //  For some of the actions, the CMT package must be automatically
+  //  included
+  //
+
+  if (Me.m_debug) cout << "parser1> current_tag=" << Me.m_current_tag << endl;
+
+  if (ap.help_action == action_help)
+    {
+      do_help (ap);
+      return (0);
+    }
+
+  switch (Me.m_action)
+    {
+      // case action_none :
+    case action_awk :
+    case action_broadcast :
+    case action_build_constituent_makefile :
+    case action_build_constituents_makefile :
+    case action_build_dependencies :
+    case action_build_library_links :
+    case action_build_make_setup :
+    case action_build_msdev :
+    case action_build_CMT_pacman :
+    case action_build_vsnet :     
+    case action_build_os9_makefile :
+      // case action_build_prototype :
+    case action_build_readme :
+    case action_build_tag_makefile :
+      // case action_build_temporary_name :
+    case action_build_triggers :
+    case action_build_windefs :
+    case action_check_configuration :
+      // case action_check_files :
+      // case action_check_version :
+    case action_checkout :
+    case action_cleanup :
+    case action_config :
+    case action_create :
+      // case action_create_project :
+    case action_cvsbranches :
+    case action_cvssubpackages :
+    case action_cvssubprojects :
+    case action_cvstags :
+    case action_do :
+    case action_expand_model :
+    case action_filter :
+      // case action_help :
+    case action_load :
+    case action_lock :
+    case action_relocate:
+    case action_remove :
+    case action_remove_library_links :
+    case action_run :
+    case action_run_sequence :
+    case action_set_version :
+    case action_set_versions :
+    case action_setup :
+    case action_show_action :
+    case action_show_action_names :
+    case action_show_action_value :
+    case action_show_actions :
+    case action_show_all_tags :
+    case action_show_applied_patterns :
+      // case action_show_author :
+      // case action_show_branches :
+      // case action_show_clients :
+    case action_show_cmtpath_patterns :
+    case action_show_constituent :
+    case action_show_constituent_names :
+    case action_show_constituents :
+    case action_show_cycles :
+    case action_show_fragment :
+    case action_show_fragments :
+    case action_show_groups :
+    case action_show_include_dirs :
+    case action_show_language :
+    case action_show_languages :
+    case action_show_macro :
+    case action_show_macro_names :
+    case action_show_macro_value :
+    case action_show_macros :
+      // case action_show_manager :
+    case action_show_packages :
+    case action_show_path :
+    case action_show_pattern :
+    case action_show_pattern_names :
+    case action_show_patterns :
+    case action_show_projects :
+      // case action_show_pwd :
+    case action_show_setup :
+    case action_show_set :
+    case action_show_set_names :
+    case action_show_set_value :
+    case action_show_sets :
+    case action_show_strategies :
+    case action_show_tags :
+    case action_show_use_paths :
+    case action_show_uses :
+    case action_show_version :
+      // case action_show_versions :
+      // case action_system :
+    case action_unlock :
+    case action_version :
+      use_cmt ();
+        //
+        // Now parse the requirements file stored in ${CMTHOME}
+        //
+      
+      use_home_requirements ();
+
+      break;
+    default:
+      break;
+    }
+
+  if (Me.m_debug) cout << "parser2> current_tag=" << Me.m_current_tag << endl;
+
+  //
+  // Setting up recursive actions
+  //
+
+  switch (Me.m_action)
+    {
+      // case action_none :
+    case action_awk :
+    case action_broadcast :
+    case action_build_constituent_makefile :
+    case action_build_constituents_makefile :
+    case action_build_dependencies :
+    case action_build_library_links :
+    case action_build_make_setup :
+    case action_build_msdev :
+    case action_build_CMT_pacman :
+    case action_build_vsnet :     
+    case action_build_os9_makefile :
+      // case action_build_prototype :
+    case action_build_readme :
+    case action_build_tag_makefile :
+      // case action_build_temporary_name :
+    case action_build_triggers :
+    case action_build_windefs :
+    case action_check_configuration :
+      // case action_check_files :
+      // case action_check_version :
+      // case action_checkout :
+    case action_cleanup :
+    case action_config :
+      // case action_create :
+      // case action_create_project :
+      // case action_cvsbranches :
+      // case action_cvssubpackages :
+      // case action_cvssubprojects :
+      // case action_cvstags :
+    case action_do :
+    case action_expand_model :
+    case action_filter :
+      // case action_help :
+    case action_load :
+      // case action_lock :
+      // case action_remove :
+    case action_relocate:
+    case action_remove_library_links :
+    case action_run :
+    case action_run_sequence :
+      // case action_set_version :
+    case action_set_versions :
+    case action_setup :
+    case action_show_action :
+    case action_show_action_names :
+    case action_show_action_value :
+    case action_show_actions :
+    case action_show_all_tags :
+    case action_show_applied_patterns :
+      // case action_show_author :
+      // case action_show_branches :
+      // case action_show_clients :
+    case action_show_cmtpath_patterns :
+    case action_show_constituent :
+    case action_show_constituent_names :
+    case action_show_constituents :
+    case action_show_cycles :
+    case action_show_fragment :
+    case action_show_fragments :
+    case action_show_groups :
+    case action_show_include_dirs :
+    case action_show_language :
+    case action_show_languages :
+    case action_show_macro :
+    case action_show_macro_names :
+    case action_show_macro_value :
+    case action_show_macros :
+      // case action_show_manager :
+    case action_show_packages :
+    case action_show_path :
+    case action_show_pattern :
+    case action_show_pattern_names :
+    case action_show_patterns :
+    case action_show_projects :
+      // case action_show_pwd :
+    case action_show_setup :
+    case action_show_set :
+    case action_show_set_names :
+    case action_show_set_value :
+    case action_show_sets :
+    case action_show_strategies :
+    case action_show_tags :
+    case action_show_use_paths :
+    case action_show_uses :
+      // case action_show_version :
+      // case action_show_versions :
+      // case action_system :
+      // case action_unlock :
+      // case action_version :
+      Me.m_recursive = true;
+      break;
+    default:
+      Me.m_recursive = false;
+      break;
+    }
+
+  //
+  //  Actions for which the context of the package is checked,
+  //  and the requirements file is analysed.
+  //
+
+  switch (Me.m_action)
+    {
+    case action_none :
+    case action_awk :
+    case action_broadcast :
+    case action_build_constituent_makefile :
+    case action_build_constituents_makefile :
+    case action_build_dependencies :
+    case action_build_library_links :
+    case action_build_make_setup :
+    case action_build_msdev :
+    case action_build_CMT_pacman :
+    case action_build_vsnet :     
+    case action_build_os9_makefile :
+      // case action_build_prototype :
+    case action_build_readme :
+    case action_build_tag_makefile :
+      // case action_build_temporary_name :
+    case action_build_triggers :
+    case action_build_windefs :
+    case action_check_configuration :
+      // case action_check_files :
+      // case action_check_version :
+      // case action_checkout :
+    case action_cleanup :
+    case action_config :
+      // case action_create :
+      // case action_create_project :
+      // case action_cvsbranches :
+      // case action_cvssubpackages :
+      // case action_cvssubprojects :
+      // case action_cvstags :
+    case action_do :
+    case action_expand_model :
+    case action_filter :
+      // case action_help :
+    case action_load :
+    case action_lock :
+      // case action_remove :
+    case action_relocate :
+    case action_remove_library_links :
+    case action_run :
+      // case action_run_sequence :
+      // case action_set_version :
+    case action_set_versions :
+    case action_setup :
+    case action_show_action :
+    case action_show_action_names :
+    case action_show_action_value :
+    case action_show_actions :
+    case action_show_all_tags :
+    case action_show_applied_patterns :
+    case action_show_author :
+    case action_show_branches :
+      // case action_show_clients :
+    case action_show_cmtpath_patterns :
+    case action_show_constituent :
+    case action_show_constituent_names :
+    case action_show_constituents :
+    case action_show_cycles :
+    case action_show_fragment :
+    case action_show_fragments :
+    case action_show_groups :
+    case action_show_include_dirs :
+    case action_show_language :
+    case action_show_languages :
+    case action_show_macro :
+    case action_show_macro_names :
+    case action_show_macro_value :
+    case action_show_macros :
+    case action_show_manager :
+    case action_show_packages :
+    case action_show_path :
+    case action_show_pattern :
+    case action_show_pattern_names :
+    case action_show_patterns :
+    case action_show_projects :
+    case action_show_project_author :
+    case action_show_pwd :
+    case action_show_setup :
+    case action_show_set :
+    case action_show_set_names :
+    case action_show_set_value :
+    case action_show_sets :
+    case action_show_strategies :
+    case action_show_tags :
+    case action_show_use_paths :
+    case action_show_uses :
+    case action_show_version :
+      // case action_show_versions :
+      // case action_system :
+    case action_unlock :
+      // case action_version :
+      {
+	bool w = Me.m_warnings;
+	Me.m_warnings = false;
+	reach_current_package ();
+	use_user_context_requirements ();
+	Me.m_warnings = w;
+      }
+      break;
+    default:
+      break;
+    }
+
+  if (Me.m_debug) cout << "parser3> current_tag=" << Me.m_current_tag << endl;
+
+  //
+  // Perform some actions even if there is an error
+  //
+
+  if (CmtError::has_pending_error ())
+    {
+      int code = CmtError::get_last_error_code ();
+      if (!Me.m_quiet) CmtError::print ();
+
+      switch (Me.m_action)
+        {
+          // case action_none :
+          // case action_awk :
+          // case action_broadcast :
+        case action_build_constituent_makefile :
+        case action_build_constituents_makefile :
+        case action_build_dependencies :
+        case action_build_library_links :
+        case action_build_make_setup :
+        case action_build_msdev :
+	case action_build_CMT_pacman :
+        case action_build_vsnet :     
+        case action_build_os9_makefile :
+        case action_build_prototype :
+        case action_build_readme :
+        case action_build_tag_makefile :
+          // case action_build_temporary_name :
+        case action_build_triggers :
+        case action_build_windefs :
+        case action_check_configuration :
+          // case action_check_files :
+          // case action_check_version :
+          // case action_checkout :
+        case action_cleanup :
+          // case action_config :
+          // case action_create :
+          // case action_create_project :
+          // case action_cvsbranches :
+          // case action_cvssubpackages :
+          // case action_cvssubprojects :
+          // case action_cvstags :
+          // case action_do :
+          // case action_expand_model :
+          // case action_filter :
+          // case action_help :
+        case action_load :
+        case action_lock :
+        case action_relocate :
+        case action_remove :
+        case action_remove_library_links :
+          // case action_run :
+        case action_run_sequence :
+	  // case action_set_version :
+          // case action_set_versions :
+        case action_setup :
+          // case action_show_action :
+          // case action_show_action_names :
+          // case action_show_action_value :
+          // case action_show_actions :
+          // case action_show_all_tags :
+          // case action_show_applied_patterns :
+          // case action_show_author :
+          // case action_show_branches :
+          // case action_show_clients :
+          // case action_show_cmtpath_patterns :
+          // case action_show_constituent :
+          // case action_show_constituent_names :
+          // case action_show_constituents :
+	  // case action_show_cycles :
+          // case action_show_fragment :
+          // case action_show_fragments :
+          // case action_show_groups :
+          // case action_show_include_dirs :
+          // case action_show_language :
+          // case action_show_languages :
+          // case action_show_macro :
+          // case action_show_macro_names :
+          // case action_show_macro_value :
+          // case action_show_macros :
+          // case action_show_manager :
+          // case action_show_packages :
+          // case action_show_path :
+          // case action_show_pattern :
+          // case action_show_pattern_names :
+          // case action_show_patterns :
+          // case action_show_projects :
+          // case action_show_pwd :
+          // case action_show_setup :
+          // case action_show_set :
+          // case action_show_set_names :
+          // case action_show_set_value :
+          // case action_show_sets :
+          // case action_show_strategies :
+          // case action_show_tags :
+          // case action_show_use_paths :
+          // case action_show_uses :
+          // case action_show_version :
+          // case action_show_versions :
+          // case action_system :
+        case action_unlock :
+          // case action_version :
+          clear ();
+          return (code);
+        default:
+          CmtError::clear ();
+          break;
+        }
+    }
+
+  //
+  // Perform actions
+  //
+
+  if (!Me.m_simulation)
+    {
+      switch (Me.m_action)
+	{
+	case action_none :
+	  //CmtError::set (CmtError::syntax_error, "ParseArguments> ");
+	  break;
+	case action_awk :
+	  do_awk (ap);
+      break;
+	case action_broadcast :
+	  do_broadcast (ap);
+	  break;
+	case action_build_constituent_makefile :
+	  do_build_constituent_makefile (ap);
+	  break;
+	case action_build_constituents_makefile :
+	  do_build_constituents_makefile (ap);
+	  break;
+	case action_build_dependencies :
+	  do_build_dependencies (ap, argc, argv);
+	  break;
+	case action_build_library_links :
+	  do_build_library_links (ap);
+	  break;
+	case action_build_make_setup :
+	  do_build_make_setup (ap);
+	  break;
+	case action_build_msdev :
+	  do_build_msdev (ap);
+	  break;
+	case action_build_CMT_pacman :
+	  do_build_CMT_pacman (ap);
+	  break;
+	case action_build_vsnet :     
+	  do_build_vsnet (ap);
+	  break;
+	case action_build_os9_makefile :
+	  do_build_os9_makefile (ap);
+	  break;
+	case action_build_prototype :
+	  do_build_prototype (ap);
+	  break;
+	case action_build_readme :
+	  do_build_readme (ap);
+	  break;
+	case action_build_tag_makefile :
+	  do_build_tag_makefile (ap);
+	  break;
+	case action_build_temporary_name :
+	  do_build_temporary_name (ap);
+	  break;
+	case action_build_triggers :
+	  do_build_triggers (ap);
+	  break;
+	case action_build_windefs :
+	  do_build_windefs (ap);
+	  break;
+	case action_check_configuration :
+	  do_check_configuration (ap);
+	  break;
+	case action_check_files :
+	  do_check_files (ap);
+	  break;
+	case action_check_version :
+	  do_check_version (ap);
+	  break;
+	case action_checkout :
+	  do_checkout (ap);
+	  break;
+	case action_cleanup :
+	  do_cleanup (ap);
+	  break;
+	case action_config :
+	  do_config (ap);
+	  break;
+	case action_create :
+	  do_create (ap);
+	  break;
+	case action_create_project :
+	  do_create_project (ap);
+	  break;
+	case action_cvsbranches :
+	  do_cvsbranches (ap);
+	  break;
+	case action_cvssubpackages :
+	  do_cvssubpackages (ap);
+	  break;
+	case action_cvssubprojects :
+	  do_cvssubprojects (ap);
+	  break;
+	case action_cvstags :
+	  do_cvstags (ap);
+	  break;
+	case action_do :
+	  do_do (ap);
+	  break;
+	case action_expand_model :
+	  do_expand_model (ap);
+	  break;
+	case action_filter :
+	  do_filter (ap);
+	  break;
+	case action_help :
+	  do_help (ap);
+	  break;
+	case action_load :
+	  cerr << "#CMT> action not implemented" << endl;
+	  break;
+	case action_lock :
+	  do_lock (ap);
+	  break;
+	case action_relocate :
+	  do_relocate (ap);
+	  break;
+	case action_remove :
+	  do_remove (ap);
+	  break;
+	case action_remove_library_links :
+	  do_remove_library_links (ap);
+	  break;
+	case action_run :
+	  do_run (ap);
+	  break;
+	case action_run_sequence :
+	  do_run_sequence (ap);
+	  break;
+	case action_set_version :
+	  do_set_version (ap);
+	  break;
+	case action_set_versions :
+	  do_set_versions (ap);
+	  break;
+	case action_setup :
+	  do_setup (ap);
+	  break;
+	case action_show_action :
+	  do_show_action (ap);
+	  break;
+	case action_show_action_names :
+	  do_show_action_names (ap);
+	  break;
+	case action_show_action_value :
+	  do_show_action_value (ap);
+	  break;
+	case action_show_actions :
+	  do_show_actions (ap);
+	  break;
+	case action_show_all_tags :
+	  do_show_all_tags (ap);
+	  break;
+	case action_show_applied_patterns :
+	  do_show_applied_patterns (ap);
+	  break;
+	case action_show_author :
+	  do_show_author (ap);
+	  break;
+	case action_show_branches :
+	  do_show_branches (ap);
+	  break;
+	case action_show_clients :
+	  do_show_clients (ap);
+	  break;
+	case action_show_cmtpath_patterns :
+	  do_show_cmtpath_patterns (ap);
+	  break;
+	case action_show_constituent :
+	  do_show_constituent (ap);
+	  break;
+	case action_show_constituent_names :
+	  do_show_constituent_names (ap);
+	  break;
+	case action_show_constituents :
+	  do_show_constituents (ap);
+	  break;
+	case action_show_cycles :
+	  do_show_cycles (ap);
+	  break;
+	case action_show_fragment :
+	  do_show_fragment (ap);
+	  break;
+	case action_show_fragments :
+	  do_show_fragments (ap);
+	  break;
+	case action_show_groups :
+	  do_show_groups (ap);
+	  break;
+	case action_show_include_dirs :
+	  do_show_include_dirs (ap);
+	  break;
+	case action_show_language :
+	  do_show_language (ap);
+	  break;
+	case action_show_languages :
+	  do_show_languages (ap);
+	  break;
+	case action_show_macro :
+	  do_show_macro (ap);
+	  break;
+	case action_show_macro_names :
+	  do_show_macro_names (ap);
+	  break;
+	case action_show_macro_value :
+	  do_show_macro_value (ap);
+	  break;
+	case action_show_macros :
+	  do_show_macros (ap);
+	  break;
+	case action_show_manager :
+	  do_show_manager (ap);
+	  break;
+	case action_show_packages :
+	  do_show_packages (ap);
+	  break;
+	case action_show_path :
+	  do_show_path (ap);
+	  break;
+	case action_show_pattern :
+	  do_show_pattern (ap);
+	  break;
+	case action_show_pattern_names :
+	  do_show_pattern_names (ap);
+	  break;
+	case action_show_patterns :
+	  do_show_patterns (ap);
+	  break;
+	case action_show_projects :
+	  do_show_projects (ap);
+	  break;
+	case action_show_project_author :
+	  do_show_project_author (ap);
+	  break;
+	case action_show_pwd :
+	  do_show_pwd (ap);
+	  break;
+	case action_show_setup :
+	  do_show_setup (ap);
+	  break;
+	case action_show_set :
+	  do_show_set (ap);
+	  break;
+	case action_show_set_names :
+	  do_show_set_names (ap);
+	  break;
+	case action_show_set_value :
+	  do_show_set_value (ap);
+	  break;
+	case action_show_sets :
+	  do_show_sets (ap);
+	  break;
+	case action_show_strategies :
+	  do_show_strategies (ap);
+	  break;
+	case action_show_tags :
+	  do_show_tags (ap);
+	  break;
+	case action_show_use_paths :
+	  do_show_use_paths (ap);
+	  break;
+	case action_show_uses :
+	  do_show_uses (ap);
+	  break;
+	case action_show_version :
+	  do_show_version (ap);
+	  break;
+	case action_show_versions :
+	  do_show_versions (ap);
+	  break;
+	case action_system :
+	  do_show_system (ap);
+	  break;
+	case action_unlock :
+	  do_unlock (ap);
+	  break;
+	case action_version :
+	  do_version (ap);
+	  break;
+	default:
+	  CmtError::set (CmtError::syntax_error, "ParseArguments>");
+	  break;
+	}
+    }
+
+  if (CmtError::has_pending_error ())
+    {
+      int code = CmtError::get_last_error_code ();      
+      if (code == CmtError::execution_failed)
+      {
+          code = CmtError::get_last_execution_error();
+      }   
+      
+      if (!Me.m_quiet) CmtError::print ();
+      clear ();
+      return (code);
+    }
+  else
+    {
+      clear ();
+      return (0);
+    }
+}
+
+
+/**
+ * Format as one single line a set of 'setenv' statements
+ * joined with semi-colons to form one shell command.
+ */
+void Cmt::print (PrintMode mode)
+{
+  Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+  Use& current_use = Use::current ();
+
+  cmt_string tag;
+
+  set_standard_macros ();
+
+    //cerr << "# current_tag=" << Me.m_current_tag << endl;
+    //cerr << "# current_config=" << Me.m_current_config << endl;
+
+  if (Me.m_current_tag == "")
+    {
+      if (mode == Bat) tag = "%CMTCONFIG%";
+      else tag = "${CMTCONFIG}";
+    }
+  else
+    {
+      tag = Me.m_current_tag;
+    }
+
+    //
+    //  Now check if all extra tags are still valid. Some of them
+    //  may be discarded du to some conflict with highest priority
+    //  tags, or with exclude statements
+    //
+
+  {
+    CmtSystem::cmt_string_vector words;
+      
+    cmt_string tags;
+
+    tags = Me.m_extra_tags;
+      
+    CmtSystem::split (tags, " \t,", words);
+
+    Me.m_extra_tags = ",";
+      
+    for (int i = 0; i < words.size (); i++)
+      {
+        Tag* tag;
+        const cmt_string& a = words[i];
+
+        tag = Tag::find (a);
+
+        if ((tag != 0) && (tag->is_selected ()))
+          {
+            Me.m_extra_tags += a;
+            Me.m_extra_tags += ",";
+          }
+      }
+  }
+
+  if (Me.m_debug)
+    {
+      cout << "Before all print contexts" << endl;
+    }
+
+  if (Uses.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < Uses.size (); number++)
+        {
+          Use& use = *(Uses[number]);
+
+          if (use.discarded) continue;
+
+          print_context (use, mode, tag);
+        }
+    }
+
+  print_context (Use::current (), mode, tag);
+
+  if (Me.m_debug)
+    {
+      cout << "After all print contexts" << endl;
+    }
+
+  Symbol::all_print (mode);
+  // Script::all_print (mode);
+
+  if (Me.m_debug)
+    {
+      cout << "After all print" << endl;
+    }
+
+  cout << endl;
+}
+
+
+/**
+ * Format as one single line a set of 'unsetenv' statements
+ * joined with semi-colons to form one shell command.
+ */
+void Cmt::print_clean (PrintMode mode)
+{
+  Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+  set_standard_macros ();
+
+  Script::all_print_clean (mode);
+  Symbol::all_print_clean (mode);
+
+  switch (mode)
+    {
+    case Csh :
+      if (Me.m_current_package != "CMT")
+        {
+          cout << "unsetenv " << Me.m_current_prefix << "ROOT" << endl;
+          cout << "unsetenv " << Me.m_current_prefix << "CONFIG" << endl;
+        }
+      break;
+    case Sh :
+      if (Me.m_current_package != "CMT")
+        {
+          cout << "unset " << Me.m_current_prefix << "ROOT" << endl;
+          cout << "unset " << Me.m_current_prefix << "CONFIG" << endl;
+        }
+      break;
+    case Bat :
+      if (Me.m_current_package != "CMT")
+        {
+          cout << "set " << Me.m_current_prefix << "ROOT=" << endl;
+          cout << "set " << Me.m_current_prefix << "CONFIG=" << endl;
+        }
+      break;
+    }
+
+  if (Uses.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < Uses.size (); number++)
+        {
+          Use* use = Uses[number];
+
+          if (use->discarded) continue;
+          if (use->m_hidden) continue;
+
+	  Package* p = use->get_package ();
+	  if (p->is_cmt ()) continue;
+
+          switch (mode)
+            {
+            case Csh :
+              cout << "unsetenv " << use->prefix << "ROOT" << endl;
+              cout << "unsetenv " << use->prefix << "CONFIG" << endl;
+              break;
+            case Sh :
+              cout << "unset " << use->prefix << "ROOT" << endl;
+              cout << "unset " << use->prefix << "CONFIG" << endl;
+              break;
+            case Bat :
+              cout << "set " << use->prefix << "ROOT=" << endl;
+              cout << "set " << use->prefix << "CONFIG" << endl;
+              break;
+            }
+        }
+    }
+
+  switch (mode)
+    {
+    case Csh :
+      cout << "unsetenv CMTEXTRATAGS" << endl;
+      break;
+    case Sh :
+      cout << "unset CMTEXTRATAGS" << endl;
+      break;
+    case Bat :
+      cout << "set CMTEXTRATAGS=" << endl;
+      break;
+    }
+
+  cout << endl;
+}
+
+//----------------------------------------------------------
+void Cmt::print_context (Use& use, PrintMode mode, const cmt_string& tag)
+{
+  if (use.get_package_name () == "cmt_standalone") return;
+
+  cmt_string fs = CmtSystem::file_separator ();
+
+  use.real_path.replace_all (CmtSystem::file_separator (), fs);
+
+  cmt_string system = CmtSystem::get_cmt_config ();
+
+  bool do_config = use.get_strategy ("SetupConfig");
+  bool do_root = use.get_strategy ("SetupRoot");
+
+  switch (mode)
+    {
+    case Csh :
+      if (do_root)
+	{
+	  cout << "setenv " << use.prefix << "ROOT \"" <<
+	    use.get_full_path () << "\"" << endl;
+	}
+
+      if (use.get_package_name () == "CMT")
+        {
+          cout << "setenv CMTCONFIG " << system << endl;
+        }
+      else
+        {
+	  if (do_config)
+	    {
+	      cout << "setenv " << use.prefix << "CONFIG \"" << tag << "\"" << endl;
+	    }
+	}
+        
+      break;
+    case Sh :
+      if (do_root)
+	{
+	  cout << use.prefix << "ROOT=\"" <<
+	    use.get_full_path () << "\"; export " <<
+	    use.prefix << "ROOT" << endl;
+        }
+
+      if (use.get_package_name () == "CMT")
+        {
+          cout << "CMTCONFIG=" << system << "; export CMTCONFIG" << endl;
+        }
+      else
+        {
+	  if (do_config)
+	    {
+	      cout << use.prefix << "CONFIG=\"" <<
+		tag << "\"; export " <<
+		use.prefix << "CONFIG" << endl;
+	    }
+	}
+        
+      break;
+    case Bat :
+      if (do_root)
+	{
+	  cout << "set " << use.prefix << "ROOT=" <<
+	    use.get_full_path () << endl;
+	}
+
+      if (use.get_package_name () == "CMT")
+        {
+          cout << "set CMTCONFIG=" << system << endl;
+        }
+      else
+        {
+	  if (do_config)
+	    {
+	      cout << "set " << use.prefix << "CONFIG=" << tag << endl;
+	    }
+	}
+        
+      break;
+    }
+}
+
+/**
+ *  Format a set of make macro definitions (one per line)
+ * Each macro value is provided enclosed in single quotes
+ *
+ *  Take the macro values from the macro statements found
+ * in recursively read requirements files.
+ */
+void Cmt::print_symbol_names (PrintMode mode, const cmt_string& pattern)
+{
+  int number;
+
+  set_standard_macros ();
+
+  cmt_regexp expression (pattern);
+
+  bool has_pattern = (pattern != "");
+
+  for (number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      if (has_pattern)
+       {
+         if (!expression.match (symbol.name)) continue;
+       }
+
+      if (Me.m_action == action_show_macro_names)
+        {
+          // Only keep macros.
+          if ((symbol.type == Symbol::SymbolSet) ||
+              (symbol.type == Symbol::SymbolAlias) ||
+              (symbol.type == Symbol::SymbolPath) ||
+              (symbol.type == Symbol::SymbolAction)) continue;
+        }
+      else if (Me.m_action == action_show_set_names)
+        {
+          // Exclude macros.
+          if ((symbol.type == Symbol::SymbolMacro) ||
+              (symbol.type == Symbol::SymbolAction)) continue;
+        }
+      else if (Me.m_action == action_show_action_names)
+        {
+          // Exclude macros.
+          if (symbol.type != Symbol::SymbolAction) continue;
+        }
+
+      cout << symbol.name << endl;
+    }
+}
+
+/**
+ *  Format a set of make macro definitions (one per line)
+ * Each macro value is provided enclosed in single quotes
+ *
+ *  Take the macro values from the macro statements found
+ * in recursively read requirements files.
+ */
+void Cmt::print_macros (PrintMode mode, const cmt_string& pattern)
+{
+  int number;
+
+  set_standard_macros ();
+
+  cmt_regexp expression (pattern);
+
+  bool has_pattern = (pattern != "");
+
+  for (number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      if (has_pattern)
+	{
+	  if (!expression.match (symbol.name)) continue;
+	}
+
+      if (Me.m_action == action_show_macros)
+        {
+          // Only keep macros.
+          if ((symbol.type == Symbol::SymbolSet) ||
+              (symbol.type == Symbol::SymbolAlias) ||
+              (symbol.type == Symbol::SymbolPath) ||
+              (symbol.type == Symbol::SymbolAction)) continue;
+        }
+      else if (Me.m_action == action_show_sets)
+        {
+          // Exclude macros.
+          if ((symbol.type == Symbol::SymbolMacro) ||
+              (symbol.type == Symbol::SymbolAction)) continue;
+        }
+      else if (Me.m_action == action_build_tag_makefile)
+        {
+          // Exclude scripts and actions
+          if ((symbol.type == Symbol::SymbolSetupScript) ||
+              (symbol.type == Symbol::SymbolCleanupScript) ||
+              (symbol.type == Symbol::SymbolAction)) continue;
+        }
+      else if (Me.m_action == action_show_actions)
+        {
+          if (symbol.type != Symbol::SymbolAction) continue;
+        }
+
+      if (symbol.value_lists.size () < 1) continue;
+
+      symbol.show_macro (mode);
+    }
+}
+
+//----------------------------------------------------------
+void Cmt::print_tabs (int tabs)
+{
+  while (tabs > 0)
+    {
+      cout << "  ";
+      tabs--;
+    }
+}
+
+//----------------------------------------------------------
+int Cmt::reach_current_package ()
+{
+  Use& use = Use::current ();
+  cmt_string dir;
+
+  if (Me.m_debug)
+    {
+      cout << "Cmt::reach_current_package> pwd = " 
+	   << CmtSystem::pwd () 
+	   << " path=" << Me.m_current_path
+	   << " package=" << Me.m_current_package
+	   << endl;
+    }
+
+  /*
+    Try to access the package.
+  */
+
+  if (Me.m_current_package == "cmt_standalone")
+    {
+      if ((Me.m_current_path != "") && (Me.m_current_path != CmtSystem::pwd ()))
+        {
+          if (!CmtSystem::cd (Me.m_current_path))
+            {
+              CmtError::set (CmtError::package_not_found,
+                             "ReachCurrentPackage> Cannot reach the path directory");
+              return (0);
+            }
+        }
+
+      if (!CmtSystem::test_file ("requirements"))
+        {
+            /*
+          if (!Me.m_quiet)
+            {
+              cout << "#CMT> Cannot reach the requirements file" << endl;
+            }
+              
+          CmtError::set (CmtError::package_not_found,
+                         "ReachCurrentPackage> Cannot reach the requirements file");
+            */
+          return (0);
+        }
+    }
+  else if (Me.m_current_package != "")
+    {
+      if (!use.move_to ())
+        {
+          CmtError::set (CmtError::package_not_found,
+                         "ReachCurrentPackage> Cannot reach the path directory");
+          return (0);
+        }
+
+      Me.m_current_path = use.real_path;
+    }
+  else
+    {
+      //
+      // The cmt command has been given without explicit search for 
+      // a package. Thus it is expected that we are in the context of a
+      // true package.
+      //
+      //  This means that there should be a requirements file visible.
+      //
+      //  If this is not true, we'll make a try into ../cmt and then
+      // a last try into ../mgr
+      //
+
+      if (!CmtSystem::test_file ("requirements"))
+        {
+          if (CmtSystem::cd ("../cmt") && 
+              CmtSystem::test_file ("requirements"))
+            {
+              Me.m_current_style = cmt_style;
+            }
+          else if (CmtSystem::cd ("../mgr") && 
+                   CmtSystem::test_file ("requirements"))
+            {
+              Me.m_current_style = mgr_style;
+            }
+          else
+            {
+              if (!Me.m_quiet)
+                {
+                  cerr << "#CMT> Cannot reach the mgr branch" << endl;
+                }
+              
+              CmtError::set (CmtError::package_not_found,
+                             "ReachCurrentPackage> Cannot reach the mgr/cmt directory");
+              return (0);
+            }
+        }
+
+      dir = CmtSystem::pwd ();
+
+      CmtSystem::dirname (dir, Me.m_current_path);
+      CmtSystem::basename (Me.m_current_path, Me.m_current_version);
+
+      if (CmtSystem::is_version_directory (Me.m_current_version))
+        {
+          CmtSystem::dirname (Me.m_current_path, Me.m_current_path);
+          CmtSystem::basename (Me.m_current_path, Me.m_current_package);
+          CmtSystem::dirname (Me.m_current_path, Me.m_current_path);
+        }
+      else
+        {
+          Me.m_current_package = Me.m_current_version;
+          Me.m_current_version = "";
+          CmtSystem::dirname (Me.m_current_path, Me.m_current_path);
+
+          Me.m_current_style = no_version_style;
+        }
+
+      use.set_package_name (Me.m_current_package);
+      use.version = Me.m_current_version;
+      use.path    = Me.m_current_path;
+      use.style   = Me.m_current_style;
+    }
+
+  configure_current_dir ();
+  build_prefix (Me.m_current_package, Me.m_current_prefix);
+  build_config (Me.m_current_prefix, Me.m_current_config);
+
+  /*
+    Check Tag is always set up
+  */
+
+  if (Me.m_debug) cout << "reach_current_package0> current_tag=" << Me.m_current_tag << endl;
+
+  if (Me.m_current_tag == "")
+    {
+      cmt_string env;
+
+      env = CmtSystem::getenv (Me.m_current_config);
+      if (env != "")
+        {
+          Tag* tag;
+
+          tag = Tag::add (env, PriorityConfig, "reach current package", 0);
+          tag->mark ();
+            //Me.m_current_tag = env;
+
+          //if (!Me.m_quiet) cerr << "reach_current_package1> current_tag=" << Me.m_current_tag << endl;
+
+        }
+    }
+
+  if (Me.m_debug)
+    {
+      cout << "pwd = " << CmtSystem::pwd () << endl;
+    }
+
+  /*
+    Work on the requirements file.
+  */
+
+  if (dir != "") dir += CmtSystem::file_separator ();
+  dir += "requirements";
+  SyntaxParser::parse_requirements (dir, &use);
+
+  if (Me.m_debug) cout << "reach_current_package2> current_tag=" << Me.m_current_tag << endl;
+
+    /**
+     *   It would be useful to change this mechanism. Instead of
+     *  applying all global patterns at once to all use contexts, it
+     *  would be much better to apply it at the end of each
+     *  requirements file parsing, and only in the context the
+     *  appropriate Use.
+     *
+     *   This would avoid the current flaw which is that when a global
+     *  pattern specifies a "private" definition, it is actually
+     *  applied in the scope context of the Current Use and not in
+     *  each individual Use. Therefore the private is lost.
+     *
+     *   However, this induces problems since some pattern definitions
+     *  are done AFTER the use statements, which will NOT receive the
+     *  pattern aplications.
+     *
+     *   Therefore it is decided to leave this "bad" mechanism until
+     *  everybody is aware of this constraint.
+     *
+     * 
+     */
+  Pattern::apply_all_globals ();
+
+  /*
+    Select all possible tags
+  */
+
+  Tag::restore_tree ();
+
+  return (1);
+}
+
+static cmt_string get_best_form (const CmtSystem::cmt_string_vector& pwd,
+                                 const cmt_string& path)
+{
+  static cmt_string fs = CmtSystem::file_separator ();
+  cmt_string result;
+
+    /*
+    //if (CmtSystem::getenv ("CMTTESTPREFIX") != "")
+    {
+    */
+
+    //
+    //  If there is a common prefix between
+    //  use->real_path and pwd
+    //  we have 
+    //  use->real_path = /<prefix>/aaa
+    //  pwd            = /<prefix>/bbb
+    //
+    //  Then use->real_path may be expressed as:
+    //  ../..../../aaa
+    //   where ../..../../ moves up to /<prefix>
+    //
+    //   Then we try to find the shortest between
+    //
+    //     /<prefix> and ../..../..
+    //
+  cmt_string a = path;
+  
+  CmtSystem::cmt_string_vector va;
+  
+  va.clear ();
+  
+  CmtSystem::split (a, fs, va);
+  
+  int m = va.size ();
+  if (pwd.size () < m) m = pwd.size ();
+  
+  int i;
+  
+    //cout << "Package " << use->get_package_name () << endl;
+  
+  for (i = 0; i < m; i++)
+    {
+      const cmt_string& fa = va[i];
+      const cmt_string& fb = pwd[i];
+      
+        //cout << "  fa=" << fa << " fb=" << fb << endl;
+      
+      if (fa != fb) break;
+    }
+  
+  cmt_string ups = "";
+  
+  if (i > 0)
+    {
+        // We have the prefix.
+        // if we count what remains from pwd, then 
+        // we have the number of ../ required to 
+        // move to /<prefix>
+      int j;
+      
+      for (j = i; j < pwd.size (); j++)
+        {
+          if (j > i) ups += fs;
+          ups += "..";
+        }
+
+      for (j = i; j < va.size (); j++)
+        {
+          ups += fs;
+          ups += va[j];
+        }
+    }
+  
+    //
+    // Here ups contains the ../..../../aaa form
+    // for the use->real_path or is empty when there
+    // were no common prefix.
+    //
+  
+    //if (ups != "")
+  if ((ups != "") &&
+      (ups.size () < path.size ()))
+    {
+      result = ups;
+    }
+  else
+    {
+      result = path;
+    }
+
+  return (result);
+}
+
+/**
+ *   This completely local class holds primitive actions for building
+ *   standard macros.
+ */
+class StandardMacroBuilder
+{
+public:
+
+  /**
+   *  CMTVERSION
+   */
+  void fill_for_CMTVERSION ()
+  {
+    buffer = "macro CMTVERSION \"";
+    buffer += CMTVERSION;
+    buffer += "\"";
+    apply ();
+  }
+
+  StandardMacroBuilder (const cmt_string& tag,
+                        const cmt_string& package,
+                        const cmt_string& version,
+                        const cmt_string& prefix,
+                        CmtDirStyle style)
+  {
+    fs = CmtSystem::file_separator ();
+    buffer = "";
+    pwd = CmtSystem::pwd ();
+    CmtSystem::split (pwd, fs, vb);
+    current_use = &(Use::current ());
+    current_tag = tag;
+    current_package = package;
+    current_version = version;
+    current_prefix = prefix;
+    current_style = style;
+  }
+
+  void apply ()
+  {
+    SyntaxParser::parse_requirements_line (buffer, current_use);
+    buffer = "";
+  }
+
+  /**
+   *   tag
+   */
+  void fill_for_tag ()
+  {
+    static bool tag_debug = CmtSystem::testenv ("TAGDEBUG");
+
+    if (!Symbol::is_selected ("tag"))
+      {
+        if (tag_debug) cerr << "set_standard_macro2.1> current_tag=" << current_tag << endl;
+
+        if (current_tag == "")
+          {
+            buffer = "macro tag \"$(CMTCONFIG)\"";
+          }
+        else
+          {
+            buffer = "macro tag \"";
+            buffer += current_tag;
+            buffer += "\"";
+          }
+        
+        if (tag_debug) cerr << " define tag: " << buffer << endl;
+        
+        apply ();
+      }
+  }
+
+  /**
+   *   PACKAGE_ROOT
+   */
+  void fill_for_package (const cmt_string& current_dir)
+  {
+    buffer = "macro package \"";
+    buffer += current_package;
+    buffer += "\"";
+    apply ();
+
+    buffer = "macro version \"";
+    buffer += current_version;
+    buffer += "\"";
+    apply ();
+
+    if (!Symbol::is_selected ("PACKAGE_ROOT"))
+      {
+        buffer = "macro PACKAGE_ROOT \"$(";
+        buffer += current_prefix;
+	buffer += "ROOT";
+        buffer += ")\"";
+
+        apply ();
+      }
+  }
+
+  /**
+   *   srcdir
+   *   src       =$(srcdir)/
+   *   inc
+   *   mgrdir
+   *   mgr       =../$(mgrdir)/
+   *   bin
+   *   javabin
+   *   doc
+   *   version
+   *   package
+   *
+   *   <package>_project
+   *   <package>_cmtpath
+   *   <package>_offset
+   *   package_cmtpath
+   *   package_offset
+   *   project
+   *
+   */
+  void fill_for_branches ()
+  {
+    /**
+     *    Basic macros  (src, mgr, ...)
+     */
+    
+    if (current_style == none_style)
+      {
+        buffer = "macro srcdir \".";
+        buffer += "\"";
+        apply ();
+
+        buffer = "macro src \".";
+        buffer += fs;
+        buffer += "\"";
+        apply ();
+
+        buffer = "macro inc \".";
+        buffer += fs;
+        buffer += "\"";
+        apply ();
+
+        buffer = "macro mgr \".";
+        buffer += fs;
+        buffer += "\"";
+        apply ();
+
+        buffer = "macro bin \".";
+        buffer += fs;
+        buffer += "\"";
+        apply ();
+
+        buffer = "macro javabin \".";
+        buffer += fs;
+        buffer += "\"";
+        apply ();
+
+        buffer = "macro doc \".";
+        buffer += fs;
+        buffer += "\"";
+        apply ();
+      }
+    else
+      {
+        if (!Symbol::is_selected ("srcdir"))
+          {
+            buffer = "macro srcdir \"..";
+            buffer += fs;
+            buffer += "src";
+            buffer += "\"";
+            apply ();
+          }
+        
+        if (!Symbol::is_selected ("src"))
+          {
+            buffer = "macro src \"..";
+            buffer += fs;
+            buffer += "src";
+            buffer += fs;
+            buffer += "\"";
+            apply ();
+          }
+        
+        if (!Symbol::is_selected ("inc"))
+          {
+            buffer = "macro inc \"..";
+            buffer += fs;
+            buffer += "src";
+            buffer += fs;
+            buffer += "\"";
+            apply ();
+          }
+        
+        if (!Symbol::is_selected ("doc"))
+          {
+            buffer = "macro doc \"..";
+            buffer += fs;
+            buffer += "doc";
+            buffer += fs;
+            buffer += "\"";
+            apply ();
+          }
+        
+        if (!Symbol::is_selected ("bin"))
+          {
+            cmt_string package_tag = current_package;
+            package_tag += "_tag";
+
+            buffer = "macro bin \"..";
+            buffer += fs;
+            buffer += "$(";
+            buffer += package_tag;
+            buffer += ")";
+            buffer += fs;
+            buffer += "\"";
+            apply ();
+          }
+
+        if (!Symbol::is_selected ("javabin"))
+          {
+            buffer = "macro javabin \"..";
+            buffer += fs;
+            buffer += "classes";
+            buffer += fs;
+            buffer += "\"";
+            apply ();
+          }
+        
+        if (current_style == mgr_style)
+          {
+            buffer = "macro mgrdir \"mgr\"";
+            apply ();
+
+            buffer = "macro mgr \"..";
+            buffer += fs;
+            buffer += "mgr";
+            buffer += fs;
+            buffer += "\"";
+            apply ();
+          }
+        else
+          {
+            buffer = "macro mgrdir \"cmt\"";
+            apply ();
+
+            buffer = "macro mgr \"..";
+            buffer += fs;
+            buffer += "cmt";
+            buffer += fs;
+            buffer += "\"";
+            apply ();
+          }
+
+	Cmt::configure_current_cmtpath ();
+      }
+  }
+
+  /**
+   *   project
+   */
+  void fill_for_project ()
+  {
+    if (current_style == none_style) return;
+
+    cmt_string project_name;
+    Project* project = Project::get_current ();
+    if (project != 0)
+      {
+	project_name = project->get_name ();
+      }
+
+    buffer = "macro project \"";
+    buffer += project_name;
+    buffer += "\"";
+    apply ();
+  }
+
+  /**
+   *   use_requirements
+   */
+  void fill_for_use_requirements ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_requirements"))
+      {
+        buffer  = "macro use_requirements \"";
+        buffer += "requirements ";
+        
+        for (int number = 0; number < Uses.size (); number++)
+          {
+            Use* use = Uses[number];
+            
+            if (use->discarded) continue;
+            if (use->m_hidden) continue;
+            
+            if (use->located ())
+              {
+                buffer += "$(";
+                buffer += use->prefix;
+                buffer += "ROOT)";
+                buffer += fs;
+                
+                if (use->style == mgr_style) buffer += "mgr";
+                else buffer += "cmt";
+                
+                buffer += fs;
+                buffer += "requirements ";
+              }
+          }
+        
+        buffer += "\"";
+        
+        apply ();
+      }
+  }
+
+  /**
+   *   use_includes
+   */
+  void fill_for_use_includes ()
+  {
+    Include::parse_all (&(Use::current()));
+
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_includes"))
+      {
+        buffer = "macro_append use_includes \' ";
+        
+        for (int number = 0; number < Uses.size (); number++)
+          {
+            Use* use = Uses[number];
+            
+            if (use->discarded) continue;
+            if (use->m_hidden) continue;
+
+	    Package* p = use->get_package ();
+	    if (p->is_cmt ()) continue;
+
+            if (Cmt::get_debug ())
+              {
+                cout << "fill use_includes for " << use->get_package_name () 
+                     << " discarded=" << use->discarded
+                     << " auto_imports=" << use->auto_imports << endl;
+              }
+            
+            if (use->auto_imports == Off) continue;
+            
+	    Include::parse_all (use);
+
+            use->fill_includes_macro (buffer);
+          }
+        
+        buffer += "\'";
+        
+        apply ();
+      }
+  }
+
+  /**
+   *   use_fincludes
+   */
+  void fill_for_use_fincludes ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_fincludes"))
+      {
+        buffer = "macro_append use_fincludes \" $(use_includes)\"";
+        apply ();
+      }
+  }
+
+  /**
+   *   use_stamps
+   */
+  void fill_for_use_stamps ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_stamps"))
+      {
+        buffer = "macro use_stamps \"";
+        (Use::current()).fill_macro (buffer, "stamps");
+        
+        for (int number = 0; number < Uses.size (); number++)
+          {
+            Use* use = Uses[number];
+            
+            if (use->discarded) continue;
+            if (use->m_hidden) continue;
+
+	    Package* p = use->get_package ();
+	    if (p->is_cmt ()) continue;
+            
+            use->fill_macro (buffer, "stamps");
+          }
+        
+        buffer += "\"";
+        
+        apply ();
+      }
+  }
+
+  /**
+   *   use_cflags
+   */
+  void fill_for_use_cflags ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_cflags"))
+      {
+        Use::fill_macro_all (buffer, "cflags");
+        apply ();
+      }
+  }
+
+  /**
+   *   use_pp_cflags
+   */
+  void fill_for_use_pp_cflags ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_pp_cflags"))
+      {
+        Use::fill_macro_all (buffer, "pp_cflags");
+        apply ();
+      }
+  }
+
+  /**
+   *   use_cppflags
+   */
+  void fill_for_use_cppflags ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_cppflags"))
+      {
+        Use::fill_macro_all (buffer, "cppflags");
+        apply ();
+      }
+  }
+
+  /**
+   *   use_pp_cppflags
+   */
+  void fill_for_use_pp_cppflags ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_pp_cppflags"))
+      {
+        Use::fill_macro_all (buffer, "pp_cppflags");
+        apply ();
+      }
+  }
+
+  /**
+   *   use_fflags
+   */
+  void fill_for_use_fflags ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_fflags"))
+      {
+        Use::fill_macro_all (buffer, "fflags");
+        apply ();
+      }
+  }
+
+  /**
+   *   use_pp_fflags
+   */
+  void fill_for_use_pp_fflags ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_pp_fflags"))
+      {
+        Use::fill_macro_all (buffer, "pp_fflags");
+        apply ();
+      }
+  }
+
+  /**
+   *   use_linkopts
+   */
+  void fill_for_use_linkopts ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_linkopts"))
+      {
+        Use::fill_macro_all (buffer, "linkopts");
+        apply ();
+      }
+  }
+
+  /**
+   *   use_libraries
+   */
+  void fill_for_use_libraries ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("use_libraries"))
+      {
+        buffer  = "macro use_libraries \"";
+
+        for (int number = 0; number < Uses.size (); number++)
+          {
+            Use* use = Uses[number];
+            
+            if (use->discarded) continue;
+            if (use->m_hidden) continue;
+            
+	    Package* p = use->get_package ();
+	    if (p->is_cmt ()) continue;
+
+            use->fill_macro (buffer, "libraries");
+          }
+        
+        buffer += "\"";
+        
+        apply ();
+      }
+  }
+
+  /**
+   *   includes
+   */
+  void fill_for_includes ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("includes"))
+      {
+        buffer = "macro_append includes \' ";
+
+        Use& use = Use::current();
+
+        if (use.include_path == "")
+          {
+            buffer += "$(ppcmd)\"$(srcdir)\" ";
+          }
+        else if (use.include_path != "none")
+          {
+            buffer += "$(ppcmd)\"";
+            buffer += use.include_path;
+            buffer += "\" ";
+          }
+
+        for (int include_number = 0;
+             include_number < use.includes.size ();
+             include_number++)
+          {
+            Include& incl = use.includes[include_number];
+
+            if (incl.name == "") continue;
+
+            buffer += "$(ppcmd)\"";
+            buffer += incl.name;
+            buffer += "\" ";
+          }
+        
+        buffer += "$(use_includes)\'";
+        
+        apply ();
+      }
+  }
+
+  /**
+   *   fincludes
+   */
+  void fill_for_fincludes ()
+  {
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    if (Uses.size () == 0) return;
+
+    if (!Symbol::is_selected ("fincludes"))
+      {
+        buffer = "macro_append fincludes \" $(includes)\"";
+        apply ();
+      }
+  }
+
+  /**
+   *  Macros specific to constituents.
+   *  This includes the compiler flags
+   *  and fills in these macros from uses packages. This takes care
+   *  of -no_auto_imports and -import= directives
+   *
+   *    <constituent>_use_linkopts
+   *    <prefix>_<constituent>_cflags
+   *    <prefix>_<constituent>_pp_cflags
+   *    <prefix>_<constituent>_cppflags
+   *    <prefix>_<constituent>_pp_cppflags
+   *    <prefix>_<constituent>_fflags
+   *    <prefix>_<constituent>_pp_fflags
+   *    <constituent>linkopts
+   *    <constituent>_GUID
+   *
+   */
+  void fill_for_all_constituents ()
+  {
+    /// First, finish the parsing of constituent parameters.
+    if (Cmt::get_debug ())
+      {
+	cout << "fill_for_all_constituents>" << endl;
+      }
+    Constituent::parse_all ();
+
+    Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+    const Constituent::ConstituentVector& constituents =
+    Constituent::constituents ();
+
+  
+    /// Prepare the auto_imports states in a vector
+    cmt_vector<bool> base_auto_imports_states;
+
+    base_auto_imports_states.resize (Uses.size ());
+
+    int number;
+
+    for (number = 0; number < Uses.size (); number++)
+      {
+        Use* use = Uses[number];
+        base_auto_imports_states[number] = (use->auto_imports != Off);
+      }
+
+    /// Now scan all constituents
+
+    for (number = 0; number < constituents.size (); number++)
+      {
+        const Constituent& constituent = constituents[number];
+
+	if (Cmt::get_debug ())
+	  {
+	    cout << "Checking " << constituent.name  << " against imports requests" << endl;
+	  }
+        Use::UsePtrVector imports;
+        int i;
+
+        /**
+         *  Problem for imports in constituents.
+         *
+         *     1) use_xxx has holes due to the corresponding 
+         *         -no_auto_imports options attached to some
+         *        use statements (including the transitive ones)
+         *
+         *     2) the -import=yyy options provided to a given constituent
+         *        should restore the appropriate holes as well as
+         *        all transitive ones.
+         *
+         *     3) for use_linkopts, missing pieces must be filled at
+         *        the right position. (for others, order is not relevant
+	 *        while transitive access is required for all)
+         *
+         */
+
+        if (constituent.type == Document)
+	  { 
+	    continue;
+	  }
+
+        if (constituent.imports.size () == 0) 
+          {
+            buffer = "macro_append ";
+            buffer += constituent.name;
+            buffer += "_use_linkopts ";
+            buffer += " \" ";
+       
+            current_use->fill_macro (buffer, "linkopts");
+       
+            for (i = 0; i < Uses.size (); i++)
+              {
+                if (base_auto_imports_states[i])
+                  {
+                    Use* u = Uses[i];
+               
+                    if (u->discarded) continue;
+
+		            Package* p = u->get_package ();
+		            if (p->is_cmt ()) continue;
+                    
+                    u->fill_macro (buffer, "linkopts");
+                  }
+              }
+            buffer += "\"";
+            apply ();
+
+          /*
+            buffer = "macro_append ";
+            buffer += constituent.name;
+            buffer += "_use_linkopts ";
+
+            buffer += " \" $(use_linkopts)\"";
+            apply ();
+            */
+
+            continue;
+          }
+
+	// From here on, the constituent HAS import options. 
+
+        /**
+	 * Create a private copy of the state vector. This private copy
+	 * will be updated according to -import=xxx modifiers for the
+	 * current constituent.
+	 */
+        cmt_vector<bool> auto_imports_states (base_auto_imports_states);
+
+        for (i = 0; i < constituent.imports.size (); i++)
+          {
+            const cmt_string& import = constituent.imports[i];
+            
+            //
+            // Resolve the imported uses
+            //
+
+            int use_index = Use::find_index (import, "", "");
+
+            if (use_index >= 0)
+              {
+                Use* u = Uses[use_index];
+            
+                if (u->discarded) continue;
+                
+		if (Cmt::get_debug ())
+		  {
+		    cout << constituent.name  << " needs imports " << import << " "
+			 << use_index << " " 
+			 << u->get_package()->get_name() << " "
+			 << " u->auto_imports=" << u->auto_imports
+			 << " Off=" << Off
+			 << " On=" << On
+			 << endl;
+		  }
+
+		Package* p = u->get_package ();
+		if (p->is_cmt ()) continue;
+
+		if (u->auto_imports != Off) continue;
+
+		Use::set_auto_imports_state (use_index, auto_imports_states);
+              }
+          }
+
+        if (Cmt::get_debug ())
+          {
+            cout << constituent.name  << " has imports " << endl;
+          }
+
+
+	/**
+	 *   Find all newly exposed packages and precompute this list inside
+	 *   a vector.
+	 */
+	for (i = 0; i < base_auto_imports_states.size (); i++)
+	  {
+	    if (base_auto_imports_states[i]== On && auto_imports_states[i] == Off) continue;
+	   
+	    Use* u = Uses[i];
+
+	    if (u->discarded) continue;
+	    if (u->m_hidden)  continue;
+	    
+	    Package* p = u->get_package ();
+	    if (p->is_cmt ()) continue;
+	    
+	    if (Cmt::get_debug ())
+	      {
+		cout << constituent.name  << " has import " << p->get_name () << endl;
+	      }
+	    
+	    imports.push_back (u);
+	  }
+        
+        if (imports.size () == 0) continue;
+
+	cmt_string prefix;
+            
+	//
+	// Documents are not considered 
+	//
+	switch (constituent.type)
+	  {
+	  case Application:
+	    prefix = "app_";
+	    break;
+	  case Library:
+	    prefix = "lib_";
+	    break;
+	  }
+            
+	buffer = "macro_append ";
+	buffer += prefix;
+	buffer += constituent.name;
+	buffer += "_cflags ";
+	buffer += " \' ";
+	for (i = 0; i < imports.size (); i++)
+	  {
+	    Use* u = imports[i];
+	    
+	    u->fill_includes_macro (buffer);
+	    u->fill_macro (buffer, "cflags");
+	  }
+	buffer += "\'";
+	apply ();
+	
+	buffer = "macro_append ";
+	buffer += prefix;
+	buffer += constituent.name;
+	buffer += "_pp_cflags ";
+	buffer += " \" ";
+	for (i = 0; i < imports.size (); i++)
+	  {
+	    Use* u = imports[i];
+	    
+	    u->fill_macro (buffer, "pp_cflags");
+	  }
+	buffer += "\"";
+	apply ();
+	
+	buffer = "macro_append ";
+	buffer += prefix;
+	buffer += constituent.name;
+	buffer += "_cppflags ";
+	buffer += " \' ";
+	for (i = 0; i < imports.size (); i++)
+	  {
+	    Use* u = imports[i];
+	    
+	    u->fill_includes_macro (buffer);
+	    u->fill_macro (buffer, "cppflags");
+	  }
+	buffer += "\'";
+	apply ();
+	
+	buffer = "macro_append ";
+	buffer += prefix;
+	buffer += constituent.name;
+	buffer += "_pp_cppflags ";
+	buffer += " \" ";
+	for (i = 0; i < imports.size (); i++)
+	  {
+	    Use* u = imports[i];
+	    
+	    u->fill_macro (buffer, "pp_cppflags");
+	  }
+	buffer += "\"";
+	apply ();
+	
+	buffer = "macro_append ";
+	buffer += prefix;
+	buffer += constituent.name;
+	buffer += "_fflags ";
+	buffer += " \' ";
+	for (i = 0; i < imports.size (); i++)
+	  {
+	    Use* u = imports[i];
+	    
+	    u->fill_includes_macro (buffer);
+	    u->fill_macro (buffer, "fflags");
+	  }
+	buffer += "\'";
+	apply ();
+	
+	buffer = "macro_append ";
+	buffer += prefix;
+	buffer += constituent.name;
+	buffer += "_pp_fflags ";
+	buffer += " \" ";
+	for (i = 0; i < imports.size (); i++)
+	  {
+	    Use* u = imports[i];
+	    
+	    u->fill_macro (buffer, "pp_fflags");
+	  }
+	buffer += "\"";
+	apply ();
+	
+	/**
+           *  Setting ${CONSTITUENT}linkopts is a temporary solution
+           *  until the backward compatibility solution for a proper 
+           *  replacement of use_linkopts by ${CONSTITUENT}_use_linkopts
+           *  is acheived.
+           *
+           */
+       buffer = "macro_append ";
+       buffer += constituent.name;
+       buffer += "linkopts ";
+       buffer += " \" ";
+       for (i = 0; i < imports.size (); i++)
+         {
+           Use* u = imports[i];
+           
+           u->fill_macro (buffer, "linkopts");
+         }
+       buffer += "\"";
+       apply ();
+       
+       /**
+         *  Only for linkopts we take care of the order. This means
+        *  that ${CONSTITUENT}_use_linkopts should be used in place of use_linkopts.
+         *
+         *  (see the application fragments)
+	 *  that ${CONSTITUENT}_use_linkopts will be used in place of use_linkopts.
+	 */
+	buffer = "macro_append ";
+	buffer += constituent.name;
+	buffer += "_use_linkopts ";
+	buffer += " \" ";
+	
+	current_use->fill_macro (buffer, "linkopts");
+	
+	for (i = 0; i < Uses.size (); i++)
+	  {
+	    if (auto_imports_states[i])
+	      {
+		Use* u = Uses[i];
+		
+		if (u->discarded) continue;
+		
+		Package* p = u->get_package ();
+		if (p->is_cmt ()) continue;
+
+		u->fill_macro (buffer, "linkopts");
+	      }
+	  }
+	buffer += "\"";
+	apply ();
+
+	//==== GLAST addition for vs.net ==========
+	buffer = "macro ";
+	buffer += constituent.name;
+	buffer += "_GUID \"{88BF15AB-5A2D-4bea-B64F-02752C2A1F4F}\" ";
+	apply ();
+      }
+  }
+
+  /**
+   *   Macros implied or required to manage constituents.
+   */
+  void fill_for_constituent_macros ()
+  {
+    int number;
+    cmt_string temp;
+
+    const Constituent::ConstituentVector& constituents = Constituent::constituents ();
+  
+    if (!Symbol::is_selected ("constituents"))
+      {
+	temp = "macro_append constituents \" ";
+	
+	for (number = 0; number < constituents.size (); number++)
+	  {
+	    const Constituent& constituent = constituents[number];
+	    
+	    if (constituent.group == 0)
+	      {
+		temp += constituent.name;
+		temp += " ";
+	      }
+	  }
+	
+	temp += "\"";
+	
+	SyntaxParser::parse_requirements_line (temp, current_use);
+      }
+    
+    SyntaxParser::parse_requirements_line ("macro_append all_constituents \" $(constituents)\"", 
+					   current_use);
+    
+    if (!Symbol::is_selected ("constituentsclean"))
+      {
+	temp = "macro_append constituentsclean \" ";
+	
+	for (number = constituents.size () - 1; number >= 0 ; number--)
+	  {
+	    const Constituent& constituent = constituents[number];
+	    
+	    if (constituent.group == 0)
+	      {
+		temp += constituent.name;
+		temp += "clean ";
+	      }
+	  }
+	
+	temp += "\"";
+	
+	SyntaxParser::parse_requirements_line (temp, current_use);
+      }
+    
+    SyntaxParser::parse_requirements_line ("macro_append all_constituentsclean \" $(constituentsclean)\"", 
+					   current_use);
+    
+    const Group::GroupVector& groups = Group::groups ();
+    
+    for (number = 0; number < groups.size (); number++)
+      {
+	const Group& group = groups[number];
+	
+	temp = "macro_append ";
+	temp += group.name ();
+	temp += "_constituents \" ";
+	
+	int i;
+	
+	for (i = 0; i < constituents.size (); i++)
+	  {
+	    const Constituent& constituent = constituents[i];
+	    
+	    if ((constituent.group != 0) && 
+		(group.name () == constituent.group->name ()))
+	      {
+		temp += constituent.name;
+		temp += " ";
+	      }
+	  }
+	
+	temp += "\"";
+	
+	SyntaxParser::parse_requirements_line (temp, current_use);
+	
+	temp = "macro_append ";
+	temp += group.name ();
+	temp += "_constituentsclean \" ";
+	
+	for (i = constituents.size () - 1; i >= 0 ; i--)
+	  {
+	    const Constituent& constituent = constituents[i];
+	    
+	    if ((constituent.group != 0) && 
+		(group.name () == constituent.group->name ()))
+	      {
+		temp += constituent.name;
+		temp += "clean ";
+	      }
+	  }
+	
+	temp += "\"";
+	
+	SyntaxParser::parse_requirements_line (temp, current_use);
+    }
+  }
+
+  /**
+   *  Definitions for installation area mechanisms. Apply all cmtpath patterns
+   */
+  void fill_for_install_area ()
+  {
+    CmtPathPattern::apply_all ();
+
+    const Use& current_use = Use::current ();
+
+    if (current_use.get_strategy ("InstallArea"))
+      {
+	CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
+
+	//cout << "#IA7>" << endl;
+	
+	ia_mgr.setup ();
+      }
+  }
+
+  /**
+   * Macros to be defined once current_package is known
+   * and even before reading its requirements file.
+   */
+  void fill_for_current_package (const cmt_string& current_dir)
+  {
+    fill_for_tag ();
+    fill_for_package (current_dir);
+  }
+
+private:
+  cmt_string fs;
+  cmt_string buffer;
+  CmtSystem::cmt_string_vector vb;
+  cmt_string pwd;
+  Use* current_use;
+  cmt_string current_tag; 
+  cmt_string current_package; 
+  cmt_string current_version; 
+  cmt_string current_prefix; 
+  CmtDirStyle current_style;
+};
+
+//----------------------------------------------------------
+void Cmt::set_current_access (AccessMode mode)
+{
+  Me.m_current_access = mode;
+}
+
+//----------------------------------------------------------
+void Cmt::set_scope_filtering_mode (CmtScopeFilteringMode mode)
+{
+  Me.m_scope_filtering_mode = mode;
+}
+
+//----------------------------------------------------------
+void Cmt::set_standard_macros ()
+{
+  if (Me.m_standard_macros_done) return;
+
+  Me.m_standard_macros_done = true;
+
+  Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+  Use& current_use = Use::current ();
+
+  cmt_string fs = CmtSystem::file_separator ();
+
+  cmt_string pwd = CmtSystem::pwd ();
+
+  if (CmtSystem::test_file ("../cmt/requirements")) Me.m_current_style = cmt_style;
+  else if (CmtSystem::test_file ("../mgr/requirements")) Me.m_current_style = mgr_style;
+  else Me.m_current_style = none_style;
+
+  {
+    cmt_string v;
+    CmtSystem::dirname (pwd, v);
+    CmtSystem::basename (v, v);
+    if (!CmtSystem::is_version_directory (v))
+      {
+        Me.m_current_style = no_version_style;
+      }
+  }
+
+  // Prepare computation of the best form for relative path from current directory
+  // to package directories.
+  CmtSystem::cmt_string_vector vb;
+  CmtSystem::split (pwd, fs, vb);
+
+
+    /**
+     *    TAG management
+     */
+
+  bool tag_debug = CmtSystem::testenv ("TAGDEBUG");
+
+  if (tag_debug) cerr << "set_standard_macro0> current_tag=" << Me.m_current_tag << endl;
+
+  if (Me.m_current_tag != "")
+    {
+        // this is when some -tag= argument was used.
+      if (tag_debug) cerr << "set_standard_macro0.1> current_tag=" << Me.m_current_tag << endl;
+    }
+  else if (Symbol::is_selected ("CMTCONFIG"))
+    {
+        // This is when CMTCONFIG has been set from some requirements file
+      Symbol* macro = Symbol::find ("CMTCONFIG");
+      if (macro != 0)
+        {
+          Me.m_current_tag = macro->build_macro_value ();
+          if (tag_debug) cerr << "set_standard_macro1> current_tag=" << Me.m_current_tag << endl;
+        }
+    }
+  else
+    {
+        // this is when no -tag= argument was used.
+      if (tag_debug) cerr << "set_standard_macro(before2)> current_tag=" << Me.m_current_tag << endl;
+      if (current_use.get_package_name () == "CMT")
+        {
+          Me.m_current_tag = CmtSystem::getenv ("CMTBIN");
+        }
+      else
+        {
+          Me.m_current_tag = CmtSystem::getenv ("CMTCONFIG");
+        }
+
+      if (tag_debug) cerr << "set_standard_macro2> current_tag=" << Me.m_current_tag << endl;
+    }
+
+  if (Me.m_debug)
+    {
+      cout << "set_standard_macro3>" << endl;
+    }
+
+  StandardMacroBuilder builder (Me.m_current_tag,
+                                Me.m_current_package,
+                                Me.m_current_version,
+                                Me.m_current_prefix,
+                                Me.m_current_style);
+
+
+    //
+    //  Definitions for installation area mechanisms
+    //
+  /*
+  if (current_use.get_strategy ("InstallArea"))
+    {
+      CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
+
+      //cout << "#IA6>" << endl;
+
+      ia_mgr.setup_current_installarea ();
+    }
+  */
+
+  builder.fill_for_current_package (Me.m_current_dir);
+
+  builder.fill_for_branches ();
+  builder.fill_for_project ();
+
+  builder.fill_for_install_area ();
+
+  builder.fill_for_use_requirements ();
+  builder.fill_for_use_includes ();
+  builder.fill_for_use_fincludes ();
+  builder.fill_for_use_stamps ();
+  builder.fill_for_use_cflags ();
+  builder.fill_for_use_pp_cflags ();
+  builder.fill_for_use_cppflags ();
+  builder.fill_for_use_pp_cppflags ();
+  builder.fill_for_use_fflags ();
+  builder.fill_for_use_pp_fflags ();
+  builder.fill_for_use_linkopts ();
+  builder.fill_for_use_libraries ();
+  builder.fill_for_includes ();
+  builder.fill_for_fincludes ();
+  builder.fill_for_all_constituents ();
+  builder.fill_for_constituent_macros ();
+}
+
+void Cmt::set_all_sets_done ()
+{
+  Me.m_all_sets_done = true;
+}
+
+void Cmt::reset_all_sets_done ()
+{
+  Me.m_all_sets_done = false;
+}
+
+//----------------------------------------------------------
+void Cmt::use_cmt ()
+{
+  UseRef use;
+  bool recursive_copy = Me.m_recursive;
+  bool debug_copy = Me.m_debug;
+
+  if (Me.m_default_path.size () <= 0) return;
+  if (Me.m_current_package == "CMT") return;
+
+  Me.m_recursive = true;
+  //Me.m_debug = false;
+  use = Use::add (Me.m_default_path, "CMT", Me.m_cmt_version, "", "", "", 0);
+  Me.m_recursive = recursive_copy;
+  Me.m_debug = debug_copy;
+}
+
+//----------------------------------------------------------
+void Cmt::use_home_requirements ()
+{
+  use_special_requirements (Me.m_cmt_home, 
+			    CmtSystem::get_home_package (), 
+			    "requirements");
+}
+
+//----------------------------------------------------------
+void Cmt::use_user_context_requirements ()
+{
+  use_special_requirements (Me.m_cmt_user_context, 
+			    CmtSystem::get_user_context_package (), 
+			    "requirements");
+}
+
+//----------------------------------------------------------
+void Cmt::use_special_requirements (const cmt_string& path, 
+				    const cmt_string& name, 
+				    const cmt_string& file_name)
+{
+  if (path == "") 
+    {
+      return;
+    }
+
+  UseRef use;
+  bool recursive_copy = Me.m_recursive;
+
+  if (Me.m_default_path.size () <= 0) return;
+  if (Me.m_current_package == "CMT") return;
+
+  Me.m_recursive = true;
+
+  use = Use::add (path, name, "v0", "", "", "", 0);
+
+  cmt_string f = Me.m_cmt_user_context;
+  f += CmtSystem::file_separator ();
+  f += file_name;
+  SyntaxParser::parse_requirements (f, use);
+
+  Me.m_recursive = recursive_copy;
+}
+
+//-------------------------------------------------
+void Cmt::vector_to_string (const CmtSystem::cmt_string_vector& v,
+                            const cmt_string& separator,
+                            cmt_string& result)
+{
+  result.erase (0);
+
+  for (int i = 0; i < v.size (); i++)
+    {
+      const cmt_string& s = v[i];
+      if (s == "") continue;
+
+      if (i > 0) result += separator;
+      result += v[i];
+    }
+}
+
+//-------------------------------------------------
+cmt_string Cmt::vector_to_string (const CmtSystem::cmt_string_vector& v)
+{
+  cmt_string result;
+
+  vector_to_string (v, " ", result);
+
+  return (result);
+}
Index: /CMT/v1r20/source/cmt_parser.h
===================================================================
--- /CMT/v1r20/source/cmt_parser.h	(revision 368)
+++ /CMT/v1r20/source/cmt_parser.h	(revision 368)
@@ -0,0 +1,334 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_parser_h__
+#define __cmt_parser_h__
+
+/*
+  Generation of shell scripts :
+  We consider for the moment only csh and sh
+  */
+typedef enum
+{
+  Csh,
+  Sh,
+  Bat,
+  Make
+} PrintMode;
+
+typedef enum
+{
+  mgr_style,
+  cmt_style,
+  no_version_style,
+  none_style
+} CmtDirStyle;
+
+typedef enum
+{
+  default_structuring_style,
+  with_version_directory,
+  without_version_directory
+} CmtStructuringStyle;
+
+typedef enum
+{
+  default_filtering_mode,
+  block_private_uses,
+  reach_private_uses
+} CmtScopeFilteringMode;
+
+/*
+  Commands correspond to keywords in the requirements file.
+  */
+typedef enum
+{
+  CommandNone,
+  CommandAction,
+  CommandAlias,
+  CommandApplication,
+  CommandApplyPattern,
+  CommandApplyTag,
+  CommandAuthor,
+  CommandBranches,
+  CommandBuildStrategy,
+  CommandCleanupScript,
+  CommandCmtPathPattern,
+  CommandDocument,
+  CommandEndPrivate,
+  CommandEndPublic,
+  CommandIgnorePattern,
+  CommandIncludeDirs,
+  CommandIncludePath,
+  CommandLanguage,
+  CommandLibrary,
+  CommandMacro,
+  CommandMacroPrepend,
+  CommandMacroAppend,
+  CommandMacroRemove,
+  CommandMacroRemoveRegexp,
+  CommandMacroRemoveAll,
+  CommandMacroRemoveAllRegexp,
+  CommandMakeFragment,
+  CommandManager,
+  CommandPackage,
+  CommandPath,
+  CommandPathAppend,
+  CommandPathPrepend,
+  CommandPathRemove,
+  CommandPathRemoveRegexp,
+  CommandPattern,
+  CommandPrivate,
+  CommandProject,
+  CommandProjectAuthor,
+  CommandPublic,
+  CommandSet,
+  CommandSetAppend,
+  CommandSetPrepend,
+  CommandSetRemove,
+  CommandSetRemoveRegexp,
+  CommandSetupScript,
+  CommandSetupStrategy,
+  CommandStructureStrategy,
+  CommandTag,
+  CommandTagExclude,
+  CommandUse,
+  CommandVersion,
+  CommandVersionStrategy,
+  Commands
+} CommandType;
+
+/*
+  The scope is modified while the requirements file is read
+  when the keywords public or private are met.
+  It is also set to public when a used requirements file is read.
+  */
+
+typedef enum
+{
+  DeveloperMode,
+  UserMode
+} AccessMode;
+
+typedef enum
+{
+  ScopeUnspecified,
+  ScopePublic,
+  ScopePrivate
+} ScopeType;
+
+typedef enum
+{
+  Unspecified = -1,
+  Off = 0,
+  On = 1
+} State;
+
+typedef enum
+{
+  PriorityLowest   = 0,
+  PriorityDefault  = 1,
+  PriorityVersion  = 2,
+  PriorityUname    = 3,
+  PrioritySite     = 4,
+  PriorityUserTag  = 5,
+  PriorityTag      = 6,
+  PriorityConfig   = 7,
+  PriorityArgument = 8
+} Priority;
+
+typedef enum
+{
+  SetupScript,
+  CleanupScript
+} ScriptType;
+
+//
+// Build strategy is a mix of various options
+//  + predefined values should be multiples of 2^n
+//  + effective value is an OR of these options
+//  + all options should be specified inthis enum as pairs
+//    of <option> - no<option>. One of them being preset to zero
+//    (which represents the default) the other being set to a unique 2^n value.
+//
+typedef enum
+{
+  Prototypes     = 0x1,
+  NoPrototypes   = Prototypes << 1,
+  DefaultPrototypesStrategy = Prototypes, 
+  PrototypesMask = Prototypes | NoPrototypes,
+
+  WithInstallArea    = NoPrototypes << 1,
+  WithoutInstallArea = WithInstallArea << 1,
+  DefaultInstallAreaStrategy = WithoutInstallArea, 
+  InstallAreaMask    = WithInstallArea | WithoutInstallArea,
+
+  BuildStrategyMask  = PrototypesMask | InstallAreaMask,
+
+  DefaultBuildStrategy = DefaultPrototypesStrategy | DefaultInstallAreaStrategy
+} BuildStrategy;
+
+typedef enum
+{
+  SetupConfig = 0x1,
+  SetupNoConfig = SetupConfig << 1,
+  SetupConfigMask = SetupConfig | SetupNoConfig,
+
+  SetupRoot = SetupNoConfig << 1,
+  SetupNoRoot = SetupRoot << 1,
+  SetupRootMask = SetupRoot | SetupNoRoot,
+
+  SetupCleanup = SetupNoRoot << 1,
+  SetupNoCleanup = SetupCleanup << 1,
+  SetupCleanupMask = SetupCleanup | SetupNoCleanup,
+
+  SetupStrategyMask = SetupConfigMask | SetupRootMask | SetupCleanupMask,
+
+  DefaultSetupStrategy = SetupConfig | SetupRoot | SetupCleanup
+} SetupStrategy;
+
+typedef enum
+{
+  WithVersionDirectory = 0x1,
+  WithoutVersionDirectory   = WithVersionDirectory << 1,
+  DefaultVersionDirectoryStrategy = WithVersionDirectory, 
+  VersionDirectoryMask = WithVersionDirectory | WithoutVersionDirectory,
+
+  StructureStrategyMask  = VersionDirectoryMask,
+
+  DefaultStructureStrategy = DefaultVersionDirectoryStrategy
+} StructureStrategy;
+
+typedef enum
+{
+  Application,
+  Library,
+  Document
+} ConstituentType;
+
+/*
+  Command line action
+  */
+typedef enum
+{
+  action_none,
+  action_awk,
+  action_broadcast,
+
+  action_build,
+
+  action_build_constituent_makefile,
+  action_build_constituents_makefile,
+  action_build_dependencies,
+  action_build_library_links,
+  action_build_make_setup,
+  action_build_msdev,
+  action_build_CMT_pacman,
+  // Visual Studio.net Support                  
+  action_build_vsnet,                           
+  action_build_os9_makefile,
+  action_build_prototype,
+  action_build_readme,
+  action_build_tag_makefile,
+  action_build_temporary_name,
+  action_build_triggers,
+  action_build_windefs,
+
+  action_check,
+
+  action_check_configuration,
+  action_check_files,
+  action_check_version,
+  action_checkout,
+  action_cleanup,
+  action_config,
+  action_create,
+  action_create_project,
+  action_cvsbranches,
+  action_cvssubpackages,
+  action_cvssubprojects,
+  action_cvstags,
+  action_do,
+  action_expand_model,
+  action_filter,
+  action_help,
+  action_load,
+  action_lock,
+  action_relocate,
+  action_remove,
+  action_remove_library_links,
+  action_run,
+  action_run_sequence,
+
+  action_set_version,
+  action_set_versions,
+
+  action_setup,
+
+  action_show,
+
+  action_show_action,
+  action_show_action_value,
+  action_show_action_names,
+  action_show_actions,
+  action_show_all_tags,
+  action_show_applied_patterns,
+  action_show_author,
+  action_show_branches,
+  action_show_clients,
+  action_show_cmtpath_patterns,
+  action_show_constituent,
+  action_show_constituent_names,
+  action_show_constituents,
+  action_show_cycles,
+  action_show_fragment,
+  action_show_fragments,
+  action_show_groups,
+  action_show_include_dirs,
+  action_show_language,
+  action_show_languages,
+  action_show_macro,
+  action_show_macro_value,
+  action_show_macro_names,
+  action_show_macros,
+  action_show_manager,
+  action_show_packages,
+  action_show_path,
+  action_show_pattern,
+  action_show_pattern_names,
+  action_show_patterns,
+  action_show_projects,
+  action_show_project_author,
+  action_show_setup,
+  action_show_pwd,
+  action_show_set,
+  action_show_set_names,
+  action_show_set_value,
+  action_show_sets,
+  action_show_strategies,
+  action_show_tags,
+  action_show_use_paths,
+  action_show_uses,
+  action_show_version,
+  action_show_versions,
+
+  action_system,
+  action_unlock,
+  action_version
+} ActionType;
+
+#define SLASH '/'
+
+class Use;
+typedef Use* UseRef;
+
+#include "cmt_std.h"
+#include "cmt_string.h"
+#include "cmt_vector.h"
+#include "cmt.h"
+
+#endif
Index: /CMT/v1r20/source/cmt_pattern.cxx
===================================================================
--- /CMT/v1r20/source/cmt_pattern.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_pattern.cxx	(revision 368)
@@ -0,0 +1,1167 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt.h"
+#include "cmt_pattern.h"
+#include "cmt_use.h"
+#include "cmt_database.h"
+#include "cmt_error.h"
+#include "cmt_syntax.h"
+
+
+//----------------------------------------------------------
+
+PatternList* PatternList::find (const cmt_string& name)
+{
+  static PatternListMap& map = pattern_list_map ();
+
+  return (map.find (name));
+}
+
+
+Pattern* PatternList::find_pattern (const cmt_string& name)
+{
+  PatternList* list = find (name);
+  if (list == 0) return (0);
+
+  Pattern::PatternPtrVector& vector = list->get_patterns ();
+
+  if (vector.size () == 0) return (0);
+
+  Pattern* p = vector[vector.size () - 1];
+
+  return (p);
+}
+
+Pattern* PatternList::find (const cmt_string& name, Use* use)
+{
+  PatternList* list = find (name);
+  if (list == 0) return (0);
+
+  Pattern::PatternPtrVector& vector = list->get_patterns ();
+
+  for (int i = 0; i < vector.size (); i++)
+    {
+      Pattern* p = vector[i];
+
+      if (p->use == use) return (p);
+    }
+
+  return (0);
+}
+
+PatternList* PatternList::add (const cmt_string& name)
+{
+  PatternList* list = find (name);
+  if (list != 0) return (list);
+
+  static PatternListVector& vector = pattern_lists ();
+
+  PatternList& pl = vector.add ();
+  pl.m_name = name;
+
+  static PatternListMap& map = pattern_list_map ();
+  map.add (name, pl);
+
+  return (&pl);
+}
+
+void PatternList::clear_all ()
+{
+  static PatternListVector& vector = pattern_lists ();
+  static PatternListMap& map = pattern_list_map ();
+
+  for (int i = 0; i < vector.size (); i++)
+    {
+      PatternList& p = vector[i];
+      p.clear ();
+    }
+
+  vector.clear ();
+  map.clear ();
+}
+
+PatternList::PatternListMap& PatternList::pattern_list_map ()
+{
+  static Database& db = Database::instance ();
+  static PatternListMap& map = db.pattern_list_map ();
+
+  return (map);
+}
+
+PatternList::PatternListVector& PatternList::pattern_lists ()
+{
+  static Database& db = Database::instance ();
+  static PatternListVector& vector = db.pattern_lists ();
+
+  return (vector);
+}
+
+PatternList::PatternList ()
+{
+}
+
+PatternList::PatternList (const cmt_string& name) : m_name (name)
+{
+}
+
+PatternList::~PatternList ()
+{
+  clear ();
+}
+
+Pattern::PatternPtrVector& PatternList::get_patterns ()
+{
+  return (m_patterns);
+}
+
+void PatternList::add_pattern (Pattern* pattern)
+{
+  for (int i = 0; i < m_patterns.size (); i++)
+    {
+      Pattern* p = m_patterns[i];
+      if (p->use == pattern->use)
+	{
+	  m_patterns[i] = pattern;
+	  return;
+	}
+    }
+
+  m_patterns.push_back (pattern);
+}
+
+void PatternList::clear ()
+{
+  m_name = "";
+  m_patterns.clear ();
+}
+
+
+//----------------------------------------------------------
+//
+//  Operations on Patterns
+//
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+void Pattern::action (const CmtSystem::cmt_string_vector& words, Use* use)
+{
+  bool global = false;
+  int start_index;
+
+  if (words.size () < 2) return;
+
+    //
+    // expected syntax is:
+    //
+    //  pattern [-global] pattern-name any-cmt-statement
+    //
+    // where any-cmt-statement may contain "templates"
+    //
+    //      <package>
+    //      <PACKAGE>
+    //      <version>
+    //      <path>
+    //
+
+  cmt_string& option = words[1];
+
+  if (option == "-global")
+    {
+      global = true;
+      start_index = 2;
+    }
+  else
+    {
+      start_index = 1;
+    }
+
+  cmt_string& name = words[start_index];
+
+  start_index++;
+
+  add (name, words, start_index, global, use);
+
+  if (CmtSystem::testenv ("CMTTESTPATTERN"))
+    {
+      cout << "Pattern::action> add " << name << endl;
+    }
+}
+
+/**
+ *
+ *  Patterns are stored with two keys : <name> and <use>
+ *
+ *  thus search must done against these two keys.
+ *
+ */
+Pattern* Pattern::find (const cmt_string& name)
+{
+  Pattern* p = PatternList::find_pattern (name);
+
+  return (p);
+}
+
+//----------------------------------------------------------
+Pattern* Pattern::find (const cmt_string& name, Use* use)
+{
+  Pattern* p = PatternList::find (name, use);
+
+  return (p);
+}
+
+//----------------------------------------------------------
+void Pattern::add (const cmt_string& name,
+                   const CmtSystem::cmt_string_vector& words,
+                   int start_index,
+                   bool global,
+                   Use* use)
+{
+  static PatternVector& Patterns = patterns ();
+
+  Pattern* pattern;
+
+  pattern = find (name, use);
+
+  if (pattern == 0)
+    {
+        // No pattern for the pair <name, use> exist yet.
+        // create one.
+      Pattern& p = Patterns.add ();
+
+      p.clear ();
+
+      p.name = name;
+      p.use  = use;
+
+      PatternList* pl = PatternList::add (name);
+      pl->add_pattern (&p);
+
+      pattern = &p;
+    }
+  else
+    {
+      Pattern& p = *pattern;
+
+      p.clear ();
+
+      p.name = name;
+      p.use  = use;
+    }
+
+  pattern->line = "";
+
+  int first_word = start_index;
+
+    //
+    // Install the cmt-statement both as a vector of words and as a single line
+    //
+  for (int i = start_index; i < words.size (); i++)
+    {
+      bool need_quotes = (i > (first_word + 1));
+      //bool need_quotes = true;
+
+      cmt_string& s = words[i];
+
+      if (i > start_index) pattern->line += " ";
+
+      if (s == ";") first_word = i+1;
+
+      if ((s == "\n") | (s == ";"))
+        {
+          pattern->line += "\n  ";
+        }
+      else
+        {
+	  cmt_string sep = "\"";
+
+	  if (s.find (sep) != cmt_string::npos)
+	    {
+	      sep = "\'";
+	    }
+
+	  if (!need_quotes) sep = "";
+
+          pattern->line += sep;
+          pattern->line += s;
+          pattern->line += sep;
+        }
+    }
+
+  pattern->global = global;
+}
+
+/**
+ * Get the number of registered patterns
+ */
+int Pattern::pattern_number ()
+{
+  static PatternVector& Patterns = patterns ();
+
+  return (Patterns.size ());
+}
+
+/**
+ * Get the index'th pattern in the database
+ */
+Pattern& Pattern::pattern (int index)
+{
+  static PatternVector& Patterns = patterns ();
+
+  return (Patterns[index]);
+}
+
+//----------------------------------------------------------
+void Pattern::clear_all ()
+{
+  static PatternVector& Patterns = patterns ();
+
+  for (int i = 0; i < Patterns.size (); i++)
+    {
+      Pattern& p = Patterns[i];
+      p.clear ();
+    }
+
+  Patterns.clear ();
+}
+
+//----------------------------------------------------------
+Pattern::PatternVector& Pattern::patterns ()
+{
+  static Database& db = Database::instance ();
+  static PatternVector& Patterns = db.patterns ();
+
+  return (Patterns);
+}
+
+/**
+ * Applies all global patterns to all uses
+ */
+void PatternList::apply_all_globals ()
+{
+  static PatternListVector& PatternLists = pattern_lists ();
+
+  int i;
+
+  for (i = 0; i < PatternLists.size (); i++)
+    {
+      PatternList& pl = PatternLists[i];
+
+      int n = pl.m_patterns.size ();
+
+      if (n > 0)
+	{
+	  Pattern* p = pl.m_patterns[n-1];
+
+	  if ((p != 0) && (p->global)) p->apply ();
+	}
+    }
+}
+
+/**
+ * Applies all global patterns to a given Use
+ */
+void PatternList::apply_all_globals (Use* use)
+{
+  if (use->get_package_name () == "CMT") return;
+
+  static PatternListVector& PatternLists = pattern_lists ();
+
+  int i;
+
+  for (i = 0; i < PatternLists.size (); i++)
+    {
+      PatternList& pl = PatternLists[i];
+
+      int n = pl.m_patterns.size ();
+
+      if (n > 0)
+	{
+	  Pattern* p = pl.m_patterns[n-1];
+
+	  if ((p != 0) && (p->global)) 
+	    {
+	      if (p->global)
+		{
+		  if (IgnorePattern::find (p->name, use) == 0) p->apply (use);
+		}
+	    }
+	}
+    }
+}
+
+/**
+ * Show all patterns
+ */
+void PatternList::show_all_patterns ()
+{
+  static PatternListVector& PatternLists = pattern_lists ();
+
+  int i;
+
+  for (i = 0; i < PatternLists.size (); i++)
+    {
+      PatternList& pl = PatternLists[i];
+
+      int n = pl.m_patterns.size ();
+
+      if (n > 0)
+	{
+	  Pattern* p = pl.m_patterns[n-1];
+
+	  if (p != 0) p->show ();
+	}
+    }
+}
+/**
+ * Show all pattern names
+ */
+void PatternList::show_all_pattern_names ()
+{
+  bool empty = true;
+
+  static PatternListVector& PatternLists = pattern_lists ();
+
+  int i;
+
+  for (i = 0; i < PatternLists.size (); i++)
+    {
+      PatternList& pl = PatternLists[i];
+
+      int n = pl.m_patterns.size ();
+
+      if (n > 0)
+	{
+	  Pattern* p = pl.m_patterns[n-1];
+
+	  if (p != 0)
+	    {
+	      cout << p->name << " ";
+	      empty = false;
+	    }
+	}
+    }
+  if (!empty) cout << endl;
+}
+
+/**
+ * Applies all global patterns to all uses
+ */
+void Pattern::apply_all_globals ()
+{
+  PatternList::apply_all_globals ();
+}
+
+/**
+ * Applies all global patterns to a given Use
+ */
+void Pattern::apply_all_globals (Use* use)
+{
+  PatternList::apply_all_globals ();
+}
+
+/**
+ * this is the cmt show patterns command
+ * It just shows the pattern declarations.
+ */
+void Pattern::show_all ()
+{
+  PatternList::show_all_patterns ();
+
+  show_all_applied_patterns ();
+}
+
+/**
+ * this is the cmt show applied_patterns command
+ * It just shows the pattern applications.
+ */
+void Pattern::show_all_applied_patterns ()
+{
+  Use* use = &(Use::current ());
+  for (int i = 0; i < use->apply_patterns.size (); i++)
+    {
+      const ApplyPattern& apply_pattern = use->apply_patterns[i];
+
+      cout << "# " << use->get_package_name ()
+           << " applies pattern " << apply_pattern.name << " => " << endl;
+      apply_pattern.show ();
+      cout << endl;
+    }
+}
+
+//----------------------------------------------------------
+void Pattern::show_all_names ()
+{
+  PatternList::show_all_pattern_names ();
+}
+
+/**
+ *  This is the cmt show pattern <name> command
+ * It shows both the pattern definition(s) and the places
+ * where it is explicitly applied.
+ */
+void Pattern::show (const cmt_string& name)
+{
+  static PatternVector& Patterns = patterns ();
+
+  int i;
+  int j;
+
+  bool found = false;
+
+    // First show the definitions.
+
+  Pattern* p = Pattern::find (name);
+
+  if (p == 0)
+    {
+      CmtError::set (CmtError::pattern_not_found, name);
+      return;
+    }
+
+  p->show ();
+
+    //
+    // Then show the packages which explicitly apply the pattern.
+    //
+  Use* use;
+  ApplyPattern* apply_pattern = 0;
+
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  for (i = 0; i < uses.size (); i++)
+    {
+      use = uses[i];
+      for (j = 0; j < use->apply_patterns.size (); j++)
+        {
+          apply_pattern = &(use->apply_patterns[j]);
+            
+          if (apply_pattern->name == name)
+            {
+              cout << "# applied by " << use->get_package_name () << " => " << endl;
+              apply_pattern->show ();
+              cout << endl;
+            }
+        }
+    }
+
+  use = &(Use::current ());
+  for (j = 0; j < use->apply_patterns.size (); j++)
+    {
+      apply_pattern = &(use->apply_patterns[j]);
+	
+      if (apply_pattern->name == name)
+	{
+          cout << "# " << use->get_package_name () << " " << use->version << " applies pattern " << name;
+	  cout << " => " << endl;
+	  apply_pattern->show ();
+          cout << endl;
+	}
+    }
+}
+
+//----------------------------------------------------------
+Pattern::Pattern ()
+{
+}
+
+//----------------------------------------------------------
+Pattern::~Pattern ()
+
+{
+}
+
+//----------------------------------------------------------
+void Pattern::clear ()
+{
+  global = false;
+  name = "";
+  use = 0;
+  line = "";
+}
+
+//----------------------------------------------------------
+void Pattern::show () const
+{
+  if (use != 0) cout << "# " << use->get_package_name () << " " << use->version;
+  else cout << "# ?? ";
+
+  cout  << " defines ";
+
+  if (global) cout << "global ";
+  
+  cout << "pattern " << name << " as" << endl;
+  cout << "  " << line << endl;
+}
+
+//----------------------------------------------------------
+class PatternCache
+{
+public:
+  static PatternCache& instance ()
+  {
+    static PatternCache me;
+
+    return (me);
+  }
+
+  static bool update (Use* c, Use* t)
+  {
+    static PatternCache& me = instance ();
+
+    return (me.do_update (c, t));
+  }
+
+  static Use::UsePtrVector& get_list ()
+  {
+    static PatternCache& me = instance ();
+
+    return (me.list);
+  }
+
+private:
+
+  PatternCache () : current(0), target(0)
+  {
+    current_name = "";
+    target_name = "";
+  }
+
+  bool do_update (Use* c, Use* t)
+  {
+    cmt_string c_name = c->get_package_name ();
+    cmt_string t_name = t->get_package_name ();
+
+    if ((current_name != c_name) || (target_name != t_name))
+      {
+	if (CmtSystem::getenv ("TESTCACHE") != "")
+	  {
+	    cout << "update cache " << c->get_package_name () << "(" << c << ") " << t->get_package_name () << "(" << t << ")" << endl;
+	  }
+	
+	current = c;
+	current_name = c_name;
+
+	target = t;
+	target_name = t_name;
+
+	list.clear ();
+	  
+	if (current != target)
+	  {
+	    if (!current->get_paths (target, list)) return (false);
+	  }
+	else
+	  {
+	    list.push_back (current);
+	  }
+      }
+    else
+      {
+	if (CmtSystem::getenv ("TESTCACHE") != "")
+	  {
+	    cout << "keep cache" << endl;
+	  }
+      }
+    return (true);
+  }
+  
+  Use* current;
+  cmt_string current_name;
+  Use* target;
+  cmt_string target_name;
+  Use::UsePtrVector list;
+};
+
+/**
+ *   Applies a pattern to all uses (except CMT itself) between
+ *   current and the use that declared the pattern.
+ */
+void Pattern::apply () const
+{
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  Use* current = &(Use::current());
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Pattern(" << name << "::apply> " << " defined in " << use->get_package_name () << endl;
+    }
+
+  if (!PatternCache::update (current, use)) return;
+
+  Use::UsePtrVector& list = PatternCache::get_list ();
+
+  for (int i = 0; i < list.size (); i++)
+    {
+      Use* u = list[i];
+
+      if (Cmt::get_debug ())
+	{
+	  cout << "Pattern(" << name << "::apply> " << " to package " << u->get_package_name () << endl;
+	}
+
+      if ((u->get_package_name () != "CMT") && 
+          (IgnorePattern::find (name, u) == 0)) apply (u);
+    }
+}
+
+//----------------------------------------------------------
+void Pattern::apply (Use* context_use) const
+{
+  static Template::TemplateVector dummy_templates;
+
+  apply (context_use, dummy_templates);
+}
+
+/**
+ *  Applies a pattern to one particular use.
+ */
+void Pattern::apply (Use* context_use, 
+                     const Template::TemplateVector& templates) const
+{
+  cmt_string replacement;
+
+  expand (context_use, templates, replacement);
+
+  if (CmtSystem::testenv ("CMTTESTPATTERN"))
+    {
+      cout << "Pattern::apply> replacement=[" << replacement << "]" << endl;
+    }
+
+  if (replacement != "")
+    {
+      SyntaxParser::parse_requirements_text (replacement, "", context_use);
+    }
+}
+
+//----------------------------------------------------------
+void Pattern::expand (Use* context_use, 
+                      const Template::TemplateVector& templates, 
+                      cmt_string& replacement) const
+{
+  if (context_use == 0) context_use = &(Use::current ());
+
+  if (CmtSystem::testenv ("CMTTESTPATTERN"))
+    {
+      cout << "Pattern::expand1> line=[" << line << "]" << endl;
+    }
+
+  replacement = line;
+
+  if (replacement != "")
+    {
+        // Substitute templates from the cmt statement
+      replacement.replace_all ("<package>", context_use->get_package_name ().c_str ());
+      replacement.replace_all ("<PACKAGE>", context_use->prefix.c_str ());
+      replacement.replace_all ("<version>", context_use->version.c_str ());
+      replacement.replace_all ("<path>",    context_use->real_path.c_str ());
+
+      cmt_string cmtpath = "";
+      cmt_string offset = "";
+
+      context_use->get_cmtpath_and_offset (cmtpath, offset);
+
+      Project* p = Project::find_by_cmtpath (cmtpath);
+      if (p != 0)
+        {
+          const cmt_string& n = p->get_name ();
+          replacement.replace_all ("<project>", n.c_str ());
+        }
+
+      for (int j = 0; j < templates.size (); j++)
+        {
+          Template& t = templates[j];
+          cmt_string s;
+          s = "<";
+          s += t.name;
+          s += ">";
+          replacement.replace_all (s, t.value);
+        }
+
+      for (;;)
+        {
+          int begin = replacement.find ("<");
+          if (begin == cmt_string::npos) break;
+          int end = replacement.find (begin, ">");
+          if (end == cmt_string::npos) break;
+          // Do not erase XML constructs
+          if (replacement[end-1] == '/') break;
+          replacement.erase (begin, end - begin + 1);
+        }
+
+      if (CmtSystem::testenv ("CMTTESTPATTERN"))
+	{
+	  cout << "Pattern::expand2> repl=[" << replacement << "]" << endl;
+	}
+
+    }
+}
+
+//----------------------------------------------------------
+//
+//  Operations on ApplyPatterns
+//
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+void ApplyPattern::action (const CmtSystem::cmt_string_vector& words, Use* use)
+{
+    //
+    // Expected syntax is
+    //
+    // apply_pattern <pattern-name> [ <template>=<value> ... ]
+    //   or just
+    // <pattern-name> [ <template>=<value> ... ]
+    //
+
+  int first_word = 0;
+
+  if (words[0] == "apply_pattern") first_word = 1;
+  else first_word = 0;
+
+  if (words.size () < (first_word + 1)) return;
+
+  if (use == 0) use = &(Use::current());
+
+  cmt_string name = words[first_word];
+  Symbol::expand (name);
+
+  if (name == "") return;
+
+  Pattern* p = Pattern::find (name);
+  if (p == 0) 
+    {
+      CmtError::set (CmtError::pattern_not_found, name);
+      return;
+    }
+
+  ApplyPattern* apply_pattern = add (name, use);
+
+  /*
+    We then look for all <name>=<value> pairs
+   */
+  enum
+    {
+      need_template,
+      need_equal,
+      need_value,
+      can_add,
+      in_error
+    } state = need_template;
+
+  cmt_string tname;
+  cmt_string tvalue;
+
+  for (int i = (first_word + 1); i < words.size (); i++)
+    {
+      cmt_string s = words[i];
+
+      if (CmtSystem::testenv ("CMTTESTPATTERN"))
+	{
+	  cout << "ApplyPattern::action> " << name << " s=[" << s << "] state=" << state << endl;
+	}
+
+      int pos = cmt_string::npos;
+
+      switch (state)
+	{
+	case need_template:
+	  pos = s.find ("=");
+
+	  tname = s;
+	  tvalue = "";
+
+	  if (pos == cmt_string::npos)
+	    {
+	      state = need_equal;
+	    }
+	  else
+	    {
+	      s.substr (0, pos, tname);
+	      s.substr (pos + 1, tvalue);
+
+	      if (CmtSystem::testenv ("CMTTESTPATTERN"))
+		{
+		  cout << "ApplyPattern::action-1> n=[" << tname << "] v=[" << tvalue << "]" << endl;
+		}
+	      
+	      if (tvalue == "")
+		{
+		  state = need_value;
+		}
+	      else
+		{		  
+		  state = can_add;
+		}
+	    }
+	  break;
+	case need_equal:
+	  pos = s.find ("=");
+
+	  tvalue = "";
+
+	  if (pos != 0)
+	    {
+	      state = in_error;
+	      if (!Cmt::get_quiet ())
+		{
+		  cerr << "#CMT> Warning: bad syntax in apply_pattern " << name
+		       << " (missing '=' separator)";
+
+		  if (use != 0) cerr << " (from " << use->get_package_name () << ")";
+
+		  cerr << endl;
+		}
+	      break;
+	    }
+	  else
+	    {
+	      s.substr (pos + 1, tvalue);
+
+	      if (tvalue == "")
+		{
+		  state = need_value;
+		}
+	      else
+		{		  
+		  state = can_add;
+		}
+	    }
+	  break;
+	case need_value:
+
+	  pos = s.find ("=");
+
+	  if (pos == cmt_string::npos)
+	    {
+	      tvalue = s;
+	      state = can_add;
+	    }
+	  else
+	    {
+	      tname = s;
+	      tvalue = "";
+
+	      s.substr (0, pos, tname);
+	      s.substr (pos + 1, tvalue);
+
+	      if (CmtSystem::testenv ("CMTTESTPATTERN"))
+		{
+		  cout << "ApplyPattern::action-2> n=[" << tname << "] v=[" << tvalue << "]" << endl;
+		}
+	      
+	      if (tvalue == "")
+		{
+		  state = need_value;
+		}
+	      else
+		{		  
+		  state = can_add;
+		}
+	    }
+
+	  break;
+	}
+
+      if (state == can_add)
+	{
+	  state = need_template;
+
+	      if (CmtSystem::testenv ("CMTTESTPATTERN"))
+		{
+		  cout << "ApplyPattern::action-3> n=[" << tname << "] v=[" << tvalue << "]" << endl;
+		}
+
+	  cmt_string tsearch = "<";
+	  tsearch += tname;
+	  tsearch += ">";
+
+	  if (p->line.find (tsearch) == cmt_string::npos)
+	    {
+	      if (!Cmt::get_quiet ())
+		{
+		  cerr << "#CMT> Warning: template <" << tname << "> not expected in pattern " << name;
+		  if (use != 0) cerr << " (from " << use->get_package_name () << ")";
+		  cerr << endl;
+		}
+	    }
+
+	  Template& t = apply_pattern->replacements.add ();
+
+	  t.name = tname;
+	  t.value = tvalue;
+
+	  int size = t.value.size ();
+
+	  if (size >= 2)
+	    {
+	      if (((t.value[0] == '"') && (t.value[size - 1] == '"')) ||
+		  ((t.value[0] == '\'') && (t.value[size - 1] == '\'')))
+		{
+		  t.value.erase (size - 1);
+		  t.value.erase (0, 1);
+		}
+	    }
+	}
+    }
+
+  apply_pattern->apply ();
+}
+
+//----------------------------------------------------------
+ApplyPattern* ApplyPattern::add (const cmt_string& name, Use* use)
+{
+  ApplyPattern& a = use->apply_patterns.add ();
+
+  a.name = name;
+  a.use  = use;
+
+  return (&a);
+}
+
+//----------------------------------------------------------
+ApplyPattern::ApplyPattern ()
+{
+}
+
+//----------------------------------------------------------
+ApplyPattern::~ApplyPattern ()
+{
+}
+
+//----------------------------------------------------------
+void ApplyPattern::show () const
+{
+  cmt_string replacement = "";
+
+  Pattern* p = Pattern::find (name);
+  if (p == 0) return;
+
+  Use* u = use;
+  if (u == 0) u = &(Use::current ());
+
+  p->expand (u, replacements, replacement);
+
+  if (replacement != "")
+    {
+      replacement.replace_all ("\"", "");
+      cout << replacement;
+    }
+}
+
+//----------------------------------------------------------
+void ApplyPattern::apply () const
+{
+  if (CmtSystem::testenv ("CMTTESTPATTERN"))
+    {
+      cout << "ApplyPattern::apply> " << name << endl;
+    }
+
+  Pattern* p = Pattern::find (name);
+  if (p == 0) 
+    {
+      if (CmtSystem::testenv ("CMTTESTPATTERN"))
+        {
+          cout << "ApplyPattern::apply> " << name << " not found" << endl;
+        }
+
+      return;
+    }
+
+  if (p->global) return;
+  
+  Use* u = use;
+  if (u == 0) u = &(Use::current ());
+
+  p->apply (u, replacements);
+}
+
+
+
+//----------------------------------------------------------
+/*                                                          */
+/*  Operations on IgnorePatterns                            */
+/*                                                          */
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+void IgnorePattern::action (const CmtSystem::cmt_string_vector& words, Use* use)
+{
+    //
+    // Expected syntax is
+    //
+    // ignore_pattern <pattern-name>
+    //
+
+  if (words.size () < 2) return;
+
+  if (use == 0) use = &(Use::current());
+
+  cmt_string& name = words[1];
+
+  add (name, use);
+}
+
+//----------------------------------------------------------
+IgnorePattern* IgnorePattern::find (const cmt_string& name, Use* use)
+{
+  int ignore_pattern_index;
+
+  if (use == 0) use = &(Use::current());
+
+  if (use->ignore_patterns.size () == 0) return (0);
+
+  for (ignore_pattern_index = 0;
+       ignore_pattern_index < use->ignore_patterns.size ();
+       ignore_pattern_index++)
+    {
+      IgnorePattern& ignore_pattern = use->ignore_patterns[ignore_pattern_index];
+
+      if (ignore_pattern.name == name)
+        {
+          return (&ignore_pattern);
+        }
+    }
+
+  return (0);
+}
+
+//----------------------------------------------------------
+void IgnorePattern::add (const cmt_string& name, Use* use)
+{
+  IgnorePattern* ignore_pattern;
+
+  ignore_pattern = find (name, use);
+
+  if (ignore_pattern == 0)
+    {
+      IgnorePattern& a = use->ignore_patterns.add ();
+
+      a.name = name;
+      a.use  = use;
+    }
+}
+
+//----------------------------------------------------------
+IgnorePattern::IgnorePattern ()
+{
+}
+
+//----------------------------------------------------------
+IgnorePattern::~IgnorePattern ()
+{
+}
+
+//----------------------------------------------------------
+void IgnorePattern::show () const
+{
+}
Index: /CMT/v1r20/source/cmt_pattern.h
===================================================================
--- /CMT/v1r20/source/cmt_pattern.h	(revision 368)
+++ /CMT/v1r20/source/cmt_pattern.h	(revision 368)
@@ -0,0 +1,152 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_pattern_h__
+#define __cmt_pattern_h__
+
+#include "cmt_map.h"
+#include "cmt_parser.h"
+#include "cmt_system.h"
+
+class Use;
+
+class Template
+{
+public:
+  typedef cmt_vector<Template> TemplateVector;
+  cmt_string name;
+  cmt_string value;
+};
+
+class Pattern
+{
+public:
+  typedef cmt_vector<Pattern> PatternVector;
+  typedef cmt_vector<Pattern*> PatternPtrVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words, Use* use);
+
+  static Pattern* find (const cmt_string& name);
+  static Pattern* find (const cmt_string& name, Use* use);
+  static void add (const cmt_string& name,
+                   const CmtSystem::cmt_string_vector& words,
+                   int start_index,
+                   bool global,
+                   Use* use);
+
+  static int pattern_number ();
+  static Pattern& pattern (int index);
+  static void clear_all ();
+  static PatternVector& patterns ();
+
+  static void apply_all_globals ();
+  static void apply_all_globals (Use* use);
+  static void show_all_names ();
+  static void show_all ();
+  static void show_all_applied_patterns ();
+  static void show (const cmt_string& name);
+
+public:
+  Pattern ();
+  ~Pattern ();
+
+  void clear ();
+  void apply () const;
+  void apply (Use* constext_use) const;
+  void apply (Use* constext_use,
+              const Template::TemplateVector& templates) const;
+  void expand (Use* constext_use,
+               const Template::TemplateVector& templates,
+               cmt_string& line) const;
+  void show () const;
+
+  cmt_string name;
+  cmt_string line;
+  bool global;
+  Use* use;
+};
+
+class PatternList
+{
+public:
+
+  typedef cmt_map<cmt_string, PatternList> PatternListMap;
+  typedef cmt_vector<PatternList> PatternListVector;
+
+  static PatternList* find (const cmt_string& name);
+  static Pattern* find_pattern (const cmt_string& name);
+  static Pattern* find (const cmt_string& name, Use* use);
+
+  static PatternList* add (const cmt_string& name);
+
+  static void clear_all ();
+  static PatternListMap& pattern_list_map ();
+  static PatternListVector& pattern_lists ();
+
+  static void apply_all_globals ();
+  static void apply_all_globals (Use* use);
+  static void show_all_patterns ();
+  static void show_all_pattern_names ();
+
+public:
+  PatternList ();
+  PatternList (const cmt_string& name);
+  ~PatternList ();
+
+  Pattern::PatternPtrVector& get_patterns ();
+
+  void add_pattern (Pattern* pattern);
+
+  void clear ();
+
+  cmt_string m_name;
+  Pattern::PatternPtrVector m_patterns;
+};
+
+class ApplyPattern
+{
+public:
+  typedef cmt_vector<ApplyPattern> ApplyPatternVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words,
+                      Use* use);
+
+  static ApplyPattern* add (const cmt_string& name, Use* use);
+
+public:
+  ApplyPattern ();
+  ~ApplyPattern ();
+
+  void show () const;
+  void apply_globals () const;
+  void apply () const;
+
+  cmt_string name;
+  Use* use;
+  cmt_vector<Template> replacements;
+};
+
+class IgnorePattern
+{
+public:
+  typedef cmt_vector<IgnorePattern> IgnorePatternVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words, Use* use);
+
+  static IgnorePattern* find (const cmt_string& name, Use* use);
+  static void add (const cmt_string& name, Use* use);
+
+public:
+  IgnorePattern ();
+  ~IgnorePattern ();
+
+  void show () const;
+
+  cmt_string name;
+  Use* use;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_project.cxx
===================================================================
--- /CMT/v1r20/source/cmt_project.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_project.cxx	(revision 368)
@@ -0,0 +1,2379 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_project.h"
+#include "cmt_database.h"
+#include "cmt_system.h"
+#include "cmt_awk.h"
+#include "cmt_syntax.h"
+#include "cmt_tag.h"
+#include "cmt_error.h"
+
+class ProjectReader : public Awk
+{
+public:
+
+  ProjectReader ()
+  {
+  }
+  
+  const cmt_string& get_project_name () const
+  {
+    return (m_project);
+  }
+  
+  void filter (const cmt_string& line)
+  {
+    CmtSystem::cmt_string_vector words;
+    CmtSystem::split (line, " \t", words);
+    if (words[0] == "project")
+      {
+	m_project = words[1];
+      }
+  }
+  
+private:
+  cmt_string m_project;
+};
+
+class ProjectPatcher : public Awk
+{
+public:
+
+  ProjectPatcher (const cmt_string& p) : m_project (p)
+  {
+  }
+
+  void commit ()
+  {
+    m_output.write (Project::get_project_file_name ());
+  }
+
+  void filter (const cmt_string& line)
+  {
+    CmtSystem::cmt_string_vector words;
+    CmtSystem::split (line, " \t", words);
+    if (words[0] == "project")
+      {
+	m_output += "project ";
+	m_output += m_project;
+      }
+    else
+      {
+	m_output += line;
+      }
+
+    m_output += "\n";
+  }
+  
+private:
+  cmt_string m_output;
+  const cmt_string& m_project;
+};
+
+IProjectFactory& ProjectFactory::instance ()
+{
+  static ProjectFactory me;
+  
+  return (me);
+}
+
+void ProjectFactory::reset ()
+{
+  Project::clear_all ();
+}
+
+static bool get_release_from_path (const CmtSystem::cmt_string_vector& items, 
+				   const cmt_string& path, 
+				   const cmt_string& name, 
+				   cmt_string& real_name, 
+				   cmt_string& release)
+{
+  bool result = false;
+
+  release = "";
+  real_name = "";
+
+  cmt_string p = path;
+
+  if ((items.size () == 0) && (name == ""))
+    {
+      // There is no CMTPROJECTPATH and no expected project name.
+      // We have no way to find a project structure
+      // So we only expect a 2-level structure.
+
+      CmtSystem::basename (p, release);
+      CmtSystem::dirname (p, p);
+      CmtSystem::basename (p, real_name);
+      
+      return (false);
+    }
+
+  for (;;)
+    {
+      if (p == "")
+	{
+	  // Protection: we found no matching project name
+	  // and path was outside any CMTPROJECTPATH
+
+	  p = path;
+
+	  CmtSystem::basename (p, release);
+	  CmtSystem::dirname (p, p);
+	  CmtSystem::basename (p, real_name);
+
+	  return (false);
+	}
+
+      cmt_string n;
+
+      CmtSystem::basename (p, n);
+      CmtSystem::dirname (p, p);
+
+      if (n == name)
+	{
+	  real_name = name;
+	  result = true;
+	  break;
+	}
+
+      CmtSystem::basename (p, real_name);
+
+      for (int i = 0; i < items.size (); i++)
+	{
+	  const cmt_string& item = items[i];
+	  if (p == item)
+	    {
+	      // We have reached an item of CMTPROJECTPATH, no need to continue
+	      return (false);
+	    }
+	}
+
+      if (release == "")
+	{
+	  release = n;
+	}
+      else
+	{
+	  cmt_string r;
+
+	  r = n;
+	  r += CmtSystem::file_separator ();
+	  r += release;
+	  release = r;
+	}
+    }
+
+  //cerr << "$CMT> GRFP> path=" << path << " name=" << name << " rel=" << release << endl;
+
+  return (result);
+}
+ 
+
+/*
+  Every new CMTPATH entry becomes associated with a dedicated PROJECT
+  This function will understand this new entry to CMTPATH and understand it:
+  - it can correspond to an existing project (ie already declared)
+  - it's a new project
+     - then it tries to read and parse its project file 
+ */
+Project* ProjectFactory::create_project (const cmt_string& specified_name,
+					 const cmt_string& path,
+					 const cmt_string& source,
+					 Project* parent)
+{
+  cmt_string compressed_path = path;
+  CmtSystem::compress_path (compressed_path);
+  bool specify_name = (specified_name != "");
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Creating project " << path << " with parent " << ((parent==0)? "0" : parent->get_name ()) << endl;
+      Project::show_all ();
+    }
+
+  cmt_string sep;
+  sep = CmtSystem::path_separator ();
+
+  cmt_string cmtprojectpath = Symbol::get_env_value ("CMTPROJECTPATH"); 
+  CmtSystem::cmt_string_vector items;
+  CmtSystem::split (cmtprojectpath, sep, items);
+
+  cmt_string here = CmtSystem::pwd ();
+  if (!CmtSystem::cd (compressed_path)) return (0);
+  cmt_string pwd = CmtSystem::pwd ();
+
+  static Project::ProjectVector& Projects = Project::projects ();
+
+  int i;
+  
+  for (i = 0; i < Projects.size (); i++)
+    {
+      Project& p = Projects[i];
+      
+      if ((p.get_cmtpath () == compressed_path) ||
+	  (p.get_cmtpath_pwd () == pwd) ||
+	  (specify_name && (p.get_name () == specified_name)))
+	{
+	  cmt_string r;
+	  cmt_string n;
+
+	  get_release_from_path (items, compressed_path, p.get_name (), n, r);
+
+	  if (r != p.get_release ())
+	    {
+	      cerr << "#CMT> Project " << p.get_name ()
+		   << " requested with conflicting releases " << p.get_release () << " and " << r << endl;
+	      CmtError::set (CmtError::project_release_conflict, p.get_name ());
+	    }
+  
+	  if (parent != 0)
+	    {
+	      p.add_parent (parent);
+	      parent->add_child (&p);
+
+	      // Since p is a new parent, we should propagate the settings UP.
+
+	      parent->update_strategies_from_children ();
+	    }
+
+	  CmtSystem::cd (here);
+	  return (&p);
+	}
+    }
+
+
+  Project* project = 0;
+  Project* cmt = 0;
+  
+  bool is_current = false;
+  
+  cmt_string name = specified_name;
+  cmt_string project_name;
+  cmt_string release;
+
+  //
+  // Figure out if this is the current project
+  //
+  if (here.find (pwd) == 0) is_current = true;
+
+  cmt_string text;
+
+  /*
+    Now Figure out the project name from the project file
+       or does not specify the project name
+   */
+  bool has_project_file = false;
+
+  if (CmtSystem::cd ("cmt") && CmtSystem::test_file (Project::get_project_file_name ()))
+    {
+      has_project_file = true;
+      text.read (Project::get_project_file_name ());
+
+      ProjectReader reader;
+
+      reader.run (text);
+
+      project_name = reader.get_project_name ();
+    }
+
+  enum
+    {
+      without_project_file   = 0x01,
+      with_project_file      = 0x02,
+      without_project_name   = 0x04,
+      with_project_name      = 0x08,
+      without_specified_name = 0x10,
+      with_specified_name    = 0x20,
+      names_mismatch         = 0x40,
+      names_match            = 0x80
+    };
+
+  int status = ((has_project_file) ? with_project_file : without_project_file) |
+    ((has_project_file && (project_name != "")) ? with_project_name : without_project_name) |
+    ((specify_name) ? with_specified_name : without_specified_name) |
+    ((specify_name && has_project_file && (project_name == specified_name)) ? names_match : names_mismatch);
+
+  if (source == "default path")
+    {
+      name = "CMT";
+    }
+  else
+    {
+      cmt_string n;
+	  
+      switch (status)
+	{
+	case with_project_file | without_project_name | without_specified_name | names_mismatch:
+
+	  // The project is neither specified from the caller nor from the project file
+
+	  /*
+	    if (!Cmt::get_quiet ())
+	    {
+	    cerr << "#CMT> Warning: project name unspecified in project file." << endl;
+	    }
+	  */
+      
+	  get_release_from_path (items, compressed_path, "", name, release);
+
+	  break;
+	  
+	case with_project_file | without_project_name | with_specified_name | names_mismatch:
+	  
+	  // The name is only specified from the caller
+	  // find this specified name in the path
+	  
+	  if (get_release_from_path (items, compressed_path, specified_name, name, release))
+	    {
+	      // The specified name has been found from the path.
+	      // We believe in the release spec.
+	    }
+	  else
+	    {
+	      // The specified name is not in the path.
+	      /*
+	      if (!Cmt::get_quiet ())
+		{
+		  cerr << "#CMT> Warning: specified project name "
+		       << specified_name
+		       << " from the caller does not match path." << endl;
+		}
+	      */
+	      name = specified_name;
+	    }
+	  
+	  break;
+	  
+	case with_project_file | with_project_name | with_specified_name | names_match:
+	  
+	  // We have a double specification: from the caller and from the project file.
+	  // And both specifications are consistent.  
+	  
+	  if (get_release_from_path (items, compressed_path, specified_name, name, release))
+	    {
+	      // The specified name has been found from the path.
+	      // We believe in the release spec.
+	    }
+	  else
+	    {
+	      // The specified name is not in the path.
+	      /*
+	      if (!Cmt::get_quiet ())
+		{
+		  cerr << "#CMT> Warning: specified project name "
+		       << specified_name
+		       << " from project file and from caller does not match path." << endl;
+		}
+	      */
+	      name = specified_name;
+	    }
+	  
+	  break;
+	  
+	case with_project_file | with_project_name | with_specified_name | names_mismatch:
+	  
+	  // We have a double specification: from the caller and from the project file.
+	  // Specifications are inconsistent!!
+	  
+          /*
+	  if (!Cmt::get_quiet ())
+	    {
+	      cerr << "#CMT> Warning: specified project name "
+		   << specified_name
+		   << " inconsistent with name "
+		   << project_name
+		   << " from project file." << endl;
+	    }
+          */
+	  
+	  if (get_release_from_path (items, compressed_path, specified_name, n, release))
+	    {
+	      // name from caller wins.
+	    }
+	  else if (get_release_from_path (items, compressed_path, project_name, name, release))
+	    {
+	      // name from project file wins.
+	    }
+	  else
+	    {
+	      // The specified name is not in the path.
+	      
+	      if (!Cmt::get_quiet ())
+		{
+		  cerr << "#CMT> Warning: none of specified project names "
+		       << specified_name
+		       << " from graph and "
+		       << project_name
+		       << " from project file match path." << endl;
+		}
+
+	      name = specified_name;
+	    }
+	  
+	  break;
+	  
+	case with_project_file | with_project_name | without_specified_name | names_mismatch:
+	  
+	  // Project name is specified in the project file but not from the caller.
+	  
+	  if (get_release_from_path (items, compressed_path, project_name, name, release))
+	    {
+	      // The specified name has been found from the path.
+	      // We believe in the release spec.
+
+	    }
+	  else
+	    {
+	      // The specified name is not in the path.
+
+	      /*
+	      if (!Cmt::get_quiet ())
+		{
+		  cerr << "#CMT> Warning: specified project name "
+		       << project_name
+		       << " from project file does not match path." << endl;
+		}
+	      */
+
+	      name = project_name;
+	    }
+	  
+	  break;
+	  
+	case without_project_file | without_project_name | without_specified_name | names_mismatch:
+	  
+	  // The project is not specified from the caller and there is no project file
+	  // This corresponds to the backward compatibility
+	  // For the moment, assume /name/release/ structure where release is one level only
+	  
+	  /*
+	    if (!Cmt::get_quiet ())
+	    {
+	    cerr << "#CMT> Warning: project name is not specified "
+	    << " (no project file)." << endl;
+	    }
+	  */
+	  
+	  CmtSystem::basename (compressed_path, release);
+	  CmtSystem::dirname (compressed_path, name);
+	  CmtSystem::basename (name, name);
+
+          if (name == "")
+            {
+              name = release;
+              release = "";
+            }
+	  
+	  break;
+	  
+	case without_project_file | without_project_name | with_specified_name | names_mismatch:
+	  
+	  // The name is only specified from the caller
+	  // find this specified name in the path
+	  
+	  if (get_release_from_path (items, compressed_path, specified_name, name, release))
+	    {
+	      // The specified name has been found from the path.
+	      // We believe in the release spec.
+	    }
+	  else
+	    {
+	      // The specified name is not in the path.
+	      /*
+	      if (!Cmt::get_quiet ())
+		{
+		  cerr << "#CMT> Warning: specified project name "
+		       << specified_name
+		       << " from project graph does not match path." << endl;
+		}
+	      */
+	      name = specified_name;
+	    }
+	  
+	  break;
+	}
+    }
+
+  if (name == "")
+    {
+      name = "Project";
+    }
+
+  project = Project::add (name, release);
+      
+  if (parent != 0)
+    {
+      project->add_parent (parent);
+      parent->add_child (project);
+
+      // Since project is a new child, we should propagate the settings UP.
+
+      parent->update_strategies_from_children ();
+    }
+  else
+    {
+      // this project has no parent thus it should become the top project.
+      // Let's look for all projects without parent.
+      // they will become children of this project.
+
+      for (i = 0; i < Projects.size (); i++)
+	{
+	  Project* p = &(Projects[i]);
+	  if (p->get_name () == name) continue;
+	  if (!p->has_parents ())
+	    {
+	      project->add_child (p);
+	      p->add_parent (project);
+	    }
+	}
+
+      // Since project is a new parent, we should upgrade its settings
+
+      project->update_strategies_from_children ();
+    }
+
+  if (source == "default path")
+    {
+      cmt = project;
+      is_current = false;
+    }
+
+  project->set_cmtpath (compressed_path);
+  project->set_cmtpath_pwd (pwd);
+  project->set_cmtpath_source (source);
+
+  if (is_current)
+    {
+      //
+      // The current project defines a tag with its name
+      //
+
+      Tag* tag;
+      
+      tag = Tag::add (project->get_name (), PriorityConfig, "PROJECT", 0);
+      tag->mark ();
+    }
+
+
+
+  if (text != "")
+    {
+      // Last step is to parse the project file
+
+      if (Cmt::get_debug ())
+	{
+	  cout << "About to parse project file [" << text << "]" << endl;
+	}
+
+      // First create the Project.m_use for the policy
+	  // cout << "About to add project policy package file [" <<  project->get_name()+"_project_policy" << "]" << endl;      
+      Use* project_use = Use::create (project->get_cmtpath(), 
+                                      "package_policy_for_project_"+project->get_name(),                                       
+                                      project->get_release (), "", "");                                                         
+      project_use->done      = true; //false;
+      project_use->discarded = false;//true; //false;
+      project_use->m_hidden  = true;
+      project_use->selected  = true;
+      project_use->m_located = true;
+      project_use->set_auto_imports(Off);
+      project_use->initial_scope = ScopePublic;      
+      project->set_use(project_use);
+      
+      
+     // add at the uses level ?????
+    /*static Use::UsePtrVector& uses = Use::get_ordered_uses ();
+     bool found = false;
+     int  size  = uses.size ();
+     cerr << "\n size:"<<size<< ":" << endl;     
+     for (int n = 0; n < size; n++)
+     {
+         Use* tuse = uses[n];
+         cerr << "\tpackage file [" << tuse->get_package_name() << "]" <<project_use->get_package_name()<< endl;                    
+         if (tuse->get_package_name()==project_use->get_package_name())
+                   found=true;
+
+     }
+    
+     if (not found)
+    {
+        uses.push_back (project_use);
+        project_use->m_index = uses.size () - 1;
+    }
+      */
+
+      SyntaxParser::parse_project_file_text (text, 
+					     Project::get_project_file_name (),
+					     project);
+    }
+
+
+
+  CmtSystem::cd (here);
+
+  return (project);
+}
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Projects                                  */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+//----------------------------------------------------------
+bool Project::create (const cmt_string& name, 
+		      const cmt_string& release, 
+		      const cmt_string& path)
+{
+  cout << "------------------------------------------" << endl;
+  cout << "Configuring environment for project " << name << " " << release;
+
+  if (path != "")
+    {
+      cout << " in " << path;
+    }
+
+  cout << endl;
+  cout << "CMT version " << Cmt::get_cmt_version () << "." << endl;
+  cout << "------------------------------------------" << endl;
+
+  if (path != "")
+    {
+      if (!CmtSystem::mkdir (path))
+	{
+          cout << "Cannot create the " << path << " directory" << endl;
+          return (false);
+	}
+
+      if (!CmtSystem::cd (path))
+	{
+          cout << "Cannot access the " << path << " directory" << endl;
+          return (false);
+	}
+    }
+
+  if (!CmtSystem::mkdir (name))
+    {
+      cout << "Cannot create the " << name << " directory" << endl;
+      return (false);
+    }
+
+  if (!CmtSystem::cd (name))
+    {
+      cout << "Cannot access the " << name << " directory" << endl;
+      return (false);
+    }
+
+  if (release != "")
+    {
+      if (!CmtSystem::mkdir (release))
+	{
+	  cout << "Cannot create the " << release << " directory" << endl;
+	  return (false);
+	}
+      
+      if (!CmtSystem::cd (release))
+	{
+	  cout << "Cannot access the " << release << " directory" << endl;
+	  return (false);
+	}
+    }
+
+  if (!CmtSystem::test_directory ("cmt"))
+    {
+      if (!CmtSystem::mkdir ("cmt"))
+        {
+          cout << "Cannot create the cmt directory" << endl;
+          return (false);
+        }
+      else
+        {
+          cout << "Installing the cmt directory" << endl;
+        }
+    }
+
+  CmtSystem::cd ("cmt");
+
+  if (!CmtSystem::test_file (get_project_file_name ()))
+    {
+      cout << "Creating a new project file" << endl;
+
+      ofstream f (get_project_file_name ());
+      if (f)
+        {
+          f << "project " << name << endl;
+          f << endl;
+          f.close ();
+        }
+      else
+	{
+          cout << "Cannot create the project file" << endl;
+          return (false);
+	}
+    }
+  else
+    {
+      cmt_string text;
+      text.read (get_project_file_name ());
+
+      ProjectPatcher p (name);
+
+      p.run (text);
+      p.commit ();
+
+      cout << "project file already there" << endl;
+    }
+
+  return (true);
+}
+
+//----------------------------------------------------------
+Project* Project::find_by_name (const cmt_string& name)
+{
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      Project& p = Projects[i];
+      if (p.m_name == name) return (&p);
+      
+    }
+
+  return (0);
+}
+
+//----------------------------------------------------------
+Project* Project::find_by_cmtpath (const cmt_string& cmtpath)
+{
+  cmt_string compressed_path = cmtpath;
+  CmtSystem::compress_path (compressed_path);
+
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      Project& p = Projects[i];
+
+      if (p.m_cmtpath == compressed_path) return (&p);
+      if (p.m_cmtpath_pwd == compressed_path) return (&p);
+    }
+
+  return (0);
+}
+
+//----------------------------------------------------------
+Project* Project::get_current ()
+{
+  cmt_string here = CmtSystem::pwd ();
+
+  static ProjectVector& Projects = projects ();
+
+  Project* result = 0;
+
+  for (int i = (Projects.size () - 1); i >= 0; i--)
+    {
+      Project& p = Projects[i];
+
+      if (here.find (p.m_cmtpath_pwd) == 0) 
+	{
+	  result = &p;
+	}
+
+      if (here.find (p.m_cmtpath) == 0) 
+	{
+	  result = &p;
+	}
+    }
+
+  return (result);
+}
+
+//----------------------------------------------------------
+Project* Project::add (const cmt_string& name,
+		       const cmt_string& release)
+{
+  static ProjectVector& Projects = projects ();
+
+  //cout << "Project::add> name=" << name << endl;
+
+  {
+    Project* project;
+
+    project = find_by_name (name);
+    if (project != 0) 
+      {
+	if (!Cmt::get_quiet ())
+	  {
+	    if (release != project->get_release ())
+	      {
+		cerr << "#CMT> Project " << name << " requested with conflicting releases " << project->get_release () << " and " << release << endl;
+		CmtError::set (CmtError::project_release_conflict, name);
+	      }
+	  }
+
+	// Project objects are recreated here to follow the hierarchy
+	// This duplication is needed for properly applying the strategies
+	Project& p = Projects.add ();
+
+	p.set_name (name);
+	p.set_release (release);
+	p.configure ();
+
+	return (&p);
+
+	//return (project);
+      }
+  }
+
+  Project& project = Projects.add ();
+  project.clear ();
+  project.set_name (name);
+  project.set_release (release);
+  project.configure ();
+
+  return (&project);
+}
+
+//----------------------------------------------------------
+Project::ProjectVector& Project::projects ()
+{
+  static Database& db = Database::instance ();
+  static ProjectVector& Projects = db.projects ();
+
+  return (Projects);
+}
+
+/*----------------------------------------------------------*/
+void Project::clear_all ()
+{
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      Project& project = Projects[i];
+      project.clear ();
+    }
+
+  Projects.clear ();
+}
+
+/*----------------------------------------------------------*/
+void Project::show_all ()
+{
+  static Project::ProjectVector& Projects = Project::projects ();
+  
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      Project& p = Projects[i];
+      p.m_visited = false;
+    }
+
+  Project* p = get_current ();
+
+  if (p == 0)
+    {
+      if (Projects.size () == 0) return;
+
+      p = &(Projects[0]);
+    }
+
+  p->show ();
+}
+
+/*----------------------------------------------------------*/
+void Project::show_specified_strategies_for_all ()
+{
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      const Project& project = Projects[i];
+      project.show_specified_strategies ();
+    }
+}
+
+/*----------------------------------------------------------*/
+class VisitorForShowPaths : public IProjectVisitor
+{
+public:
+  VisitorForShowPaths ()
+  {
+  }
+
+  void pre (Project* p)
+  {
+    const cmt_string& w = p->get_cmtpath_pwd ();
+    const cmt_string& s = p->get_cmtpath_source ();
+
+    if (s == "default path") return;
+
+    if (CmtSystem::test_directory (w))
+      {
+	cout << "# Add path " << w << " from " << s << endl;
+      }
+  }
+
+  void in (Project* p)
+  {
+    const cmt_string& w = p->get_cmtpath_pwd ();
+    const cmt_string& s = p->get_cmtpath_source ();
+
+    if (s == "default path") return;
+
+    if (CmtSystem::test_directory (w))
+      {
+	cout << "# Add path " << w << " from " << s << endl;
+      }
+  }
+
+  void post (Project* p)
+  {
+  }
+};
+
+/*----------------------------------------------------------*/
+void Project::show_paths ()
+{
+  VisitorForShowPaths visitor;
+
+  start_visit (visitor);
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_project_file_name ()
+{
+  static const cmt_string name = "project.cmt";
+
+  return (name);
+}
+
+//----------------------------------------------------------
+void Project::fill_selection (int depth, CmtSystem::cmt_string_vector& path_selections)
+{
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      Project& project = Projects[i];
+
+      const cmt_string& p = project.get_cmtpath ();
+      const cmt_string& pwd = project.get_cmtpath_pwd ();
+      const cmt_string& src = project.get_cmtpath_source ();
+
+      if (src != "default path")
+	{
+	  if (depth > 0)
+	    {
+	      cmt_string& s1 = path_selections.add ();
+	      s1 = p;
+	      cmt_string& s2 = path_selections.add ();
+	      s2 = pwd;
+	      depth--;
+
+	      if (depth == 0) break;
+	    }
+	}
+    }
+}
+
+//----------------------------------------------------------
+void Project::broadcast (IProjectAction& action)
+{
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      const Project& project = Projects[i];
+
+      if (!action.run (project)) break;
+    }
+}
+
+//----------------------------------------------------------
+void Project::reverse_broadcast (IProjectAction& action)
+{
+  static ProjectVector& Projects = projects ();
+
+  for (int i = (Projects.size () - 1); i >= 0; i--)
+    {
+      const Project& project = Projects[i];
+
+      if (!action.run (project)) break;
+    }
+}
+
+//----------------------------------------------------------
+void Project::scan_paths (PathScanner& scanner, PathScanner::actor& a)
+{
+  static ProjectVector& Projects = projects ();
+
+  int i;
+
+  for (i = 0; i < Projects.size (); i++)
+    {
+      Project& p  = Projects[i];
+      p.m_visited = false;
+    }
+
+  for (i = 0; i < Projects.size (); i++)
+    {
+      const Project& project = Projects[i];
+       
+      const cmt_string& p = project.m_cmtpath;
+      scanner.scan_path (p, a);
+    }
+}
+
+//----------------------------------------------------------
+void Project::scan_paths_for_package (PathScanner& scanner, const cmt_string& name)
+{
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      const Project& project = Projects[i];
+
+      const cmt_string& p = project.m_cmtpath;
+      scanner.scan_package (p, name);
+    }
+}
+
+//----------------------------------------------------------
+cmt_string Project::find_in_cmt_paths (const cmt_string& path)
+{
+  const cmt_string pwd = CmtSystem::pwd ();
+
+  static ProjectVector& Projects = projects ();
+
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      const Project& project = Projects[i];
+
+      const cmt_string& p = project.m_cmtpath;
+      const cmt_string& w = project.m_cmtpath_pwd;
+      const cmt_string& s = project.m_cmtpath_source;
+
+      if (s == "default path") continue;
+
+      if (CmtSystem::test_directory (p))
+	{
+	  if (path.find (p) != cmt_string::npos)
+	    {
+	      return (p);
+	    }
+
+	  // To become the current area, a path must correspond to the current package
+	  if (path.find (w) != cmt_string::npos)
+	    {
+	      return (p);
+	    }
+	}
+
+      if (p == w) continue;
+
+      if (CmtSystem::test_directory (w))
+	{
+	  if (path.find (w) != cmt_string::npos)
+	    {
+	      return (w);
+	    }
+	}
+    }
+
+  return ("");
+}
+
+//----------------------------------------------------------
+void Project::visit (IProjectVisitor& visitor)
+{
+  if (m_visited) return;
+  m_visited = true;
+
+  int i;
+
+  for (i = 0; i < get_children_size (); i++)
+    {
+      Project* child = get_child (i);
+
+      if (child->visited ()) continue;
+
+      visitor.in (child);
+    }
+
+  for (i = 0; i < m_children.size (); i++)
+    {
+      Project* child = m_children[i];
+      child->visit (visitor);
+    }
+}
+
+//----------------------------------------------------------
+void Project::start_visit (IProjectVisitor& visitor)
+{
+  static Project::ProjectVector& Projects = Project::projects ();
+  
+  for (int i = 0; i < Projects.size (); i++)
+    {
+      Project& p = Projects[i];
+      p.m_visited = false;
+    }
+
+  Project* p = get_current ();
+
+  if (p == 0)
+    {
+      if (Projects.size () == 0) return;
+
+      p = &(Projects[0]);
+    }
+
+  visitor.pre (p);
+  p->visit (visitor);
+  visitor.post (p);
+}
+
+//----------------------------------------------------------
+class VisitorForFillCMTPATH : public IProjectVisitor
+{
+public:
+  VisitorForFillCMTPATH (cmt_string& buffer) : m_buffer (buffer)
+  {
+    buffer = "path CMTPATH \"\" \n";
+  }
+
+  void pre (Project* p)
+  {
+    const cmt_string& w = p->get_cmtpath_pwd ();
+    const cmt_string& s = p->get_cmtpath_source ();
+
+    if (s == "default path") return;
+
+    if (CmtSystem::test_directory (w))
+      {
+	m_buffer += "path_append CMTPATH \"";
+	m_buffer += w;
+	m_buffer += "\" \n";
+      }
+  }
+
+  void in (Project* p)
+  {
+    const cmt_string& w = p->get_cmtpath_pwd ();
+    const cmt_string& s = p->get_cmtpath_source ();
+
+    if (s == "default path") return;
+
+    if (CmtSystem::test_directory (w))
+      {
+	m_buffer += "path_append CMTPATH \"";
+	m_buffer += w;
+	m_buffer += "\" \n";
+      }
+  }
+
+  void post (Project* p)
+  {
+    //cerr << "Buffer = " << m_buffer << endl;
+  }
+
+private:
+  cmt_string& m_buffer;
+
+};
+
+//----------------------------------------------------------
+void Project::fill_cmtpaths (cmt_string& buffer)
+{
+  /*
+    Try to re-create all CMTPATH items from project definitions.
+    The goal is to generate CMTPATH even if this EV was not pre-set
+    which is the case when CMTPROJECTPATH is only used
+   */
+
+  VisitorForFillCMTPATH visitor (buffer);
+
+  start_visit (visitor);
+}
+
+//----------------------------------------------------------
+Project::Project () : m_name (""), m_author("")
+{
+  clear ();
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_name () const
+{
+  return (m_name);
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_release () const
+{
+  return (m_release);
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_container () const
+{
+  return (m_container);
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_container_version () const
+{
+  return (m_container_version);
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_cmtpath () const
+{
+  return (m_cmtpath);
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_cmtpath_pwd () const
+{
+  return (m_cmtpath_pwd);
+}
+
+//----------------------------------------------------------
+const cmt_string& Project::get_cmtpath_source () const
+{
+  return (m_cmtpath_source);
+}
+
+//----------------------------------------------------------
+int Project::get_children_size () const
+{
+  return (m_children.size ());
+}
+
+//----------------------------------------------------------
+Project* Project::get_child (int index) const
+{
+  if (index < 0) return (0);
+  if (index >= m_children.size ()) return (0);
+  return (m_children[index]);
+}
+
+//----------------------------------------------------------
+bool Project::visited () const
+{
+  return (m_visited);
+}
+
+//----------------------------------------------------------
+void Project::set_name (const cmt_string& name)
+{
+  m_name = name;
+}
+
+//----------------------------------------------------------
+void Project::set_release (const cmt_string& release)
+{
+  m_release = release;
+}
+
+//----------------------------------------------------------
+void Project::set_container (const cmt_string& container)
+{
+  m_container = container;
+}
+
+//----------------------------------------------------------
+void Project::set_container_version (const cmt_string& container_version)
+{
+  m_container_version = container_version;
+}
+
+//----------------------------------------------------------
+void Project::set_cmtpath (const cmt_string& path)
+{
+  m_cmtpath = path;
+}
+
+//----------------------------------------------------------
+void Project::set_cmtpath_pwd (const cmt_string& path)
+{
+  m_cmtpath_pwd = path;
+}
+
+//----------------------------------------------------------
+void Project::set_cmtpath_source (const cmt_string& source)
+{
+  m_cmtpath_source = source;
+}
+
+//----------------------------------------------------------
+void Project::clear ()
+{
+  m_name    = "";
+  m_release = "";
+  m_cmtpath = "";
+  m_cmtpath_pwd    = "";
+  m_cmtpath_source = "";
+  m_use            = 0;
+
+  m_parents.clear ();
+  m_children.clear ();
+
+  m_configured = false;
+
+  m_strategies.clear ();
+}
+
+//----------------------------------------------------------
+bool Project::has_parents () const
+{
+  return ((m_parents.size () > 0));
+}
+
+//----------------------------------------------------------
+bool Project::has_parent (Project* p) const
+{
+  if (p == 0) return (false);
+  if (p == this) return (false);
+
+  const cmt_string& name = p->get_name ();
+
+  int i;
+
+  for (i = 0; i < m_parents.size (); i++)
+    {
+      const Project* parent = m_parents[i];
+      if (parent == 0) continue;
+
+      if (parent->get_name () == name)
+	{
+	  // registered as a parent
+	  return (true);
+	}
+
+      if (parent->has_parent (p))
+	{
+	  // recurse
+	  return (true);
+	}
+    }
+
+  return (false);
+}
+
+//----------------------------------------------------------
+bool Project::has_child (Project* p) const
+{
+  if (p == 0) return (false);
+  if (p == this) return (false);
+
+  const cmt_string& name = p->get_name ();
+
+  int i;
+
+  for (i = 0; i < m_children.size (); i++)
+    {
+      const Project* child = m_children[i];
+      if (child == 0) continue;
+
+      if (child->get_name () == name)
+	{
+	  // registered as a child
+	  return (true);
+	}
+
+      if (child->has_child (p))
+	{
+	  // recurse
+	  return (true);
+	}
+    }
+
+  return (false);
+}
+
+//----------------------------------------------------------
+void Project::add_parent (Project* p)
+{
+  if (p == 0) return;
+  if (p == this) return;
+
+  //cerr << "Adding parent " << p->get_name () << " to " << m_name << endl;
+
+  if (has_child (p)) return;
+  if (has_parent (p)) return;
+
+  m_parents.push_back (p);
+}
+
+//----------------------------------------------------------
+void Project::add_child (Project* p)
+{
+  if (p == 0) return;
+  if (p == this) return;
+
+  if (has_child (p)) return;
+  if (has_parent (p)) return;
+
+  m_children.push_back (p);
+}
+
+//----------------------------------------------------------
+void Project::configure ()
+{
+  if (m_configured) return;
+  m_configured = true;
+
+  set_default_strategy ("SetupConfig");
+  set_default_strategy ("SetupRoot");
+  set_default_strategy ("SetupCleanup");
+  set_default_strategy ("BuildPrototypes");
+  set_default_strategy ("InstallArea");
+  set_default_strategy ("VersionDirectory");
+}
+
+/**---------------------------------------------------------
+ A container statement is met in the project file
+*/
+void Project::container_action (const cmt_string& name, const cmt_string& version)
+{
+  //cerr << "Container action " << name << " " << version << endl;
+
+  set_container (name);
+  set_container_version (version);
+}
+
+/**---------------------------------------------------------
+ A use statement is met in the project file
+*/
+void Project::use_action (const cmt_string& name, const cmt_string& release)
+{
+  if (Cmt::get_debug ())
+    {
+      cout << "Use action " << name << " " << release << endl;
+    }
+
+  // A project with its release is specified
+  //
+  // Is this project already visible?
+  // If not: look for it
+  //   + get CMTPROJECTPATH
+  //   + search from all entries of CMTPROJECTPATH : p(i)/<name>/<release>
+  //   + when found, this should become a new CMTPATH entry
+  //   +             the new project is then parsed ... etc...
+
+  // First test it wilcard is used
+  int v = -1;
+  int r = -1;
+  int p = -1;
+  cmt_string new_release = release;
+  CmtSystem::is_version_directory (new_release, v, r, p);  
+  bool use_has_wild_card = (v == -1) || (r == -1) || (p == -1);
+  if (use_has_wild_card)
+  {
+      cmt_string selected_release = "";
+      if (select_release(name, new_release,selected_release))
+      { // yes 
+          // cout <<"selected_release: "<<selected_release<<endl;    
+          new_release = selected_release;
+      }         
+   }
+
+  cmt_string cmtprojectpath = Symbol::get_env_value ("CMTPROJECTPATH");
+  cmt_string sep;
+  sep = CmtSystem::path_separator ();
+
+  //cerr << "cmtprojectpath = " << cmtprojectpath << endl;
+  CmtSystem::cmt_string_vector items;
+  CmtSystem::split (cmtprojectpath, sep, items);
+
+  bool found = false;
+
+  for (int i = 0; i < items.size (); i++)
+    {
+      const cmt_string& item = items[i];
+      cmt_string p = item;
+      p += CmtSystem::file_separator ();
+      p += name;
+      if (new_release != "")
+	{
+	  p += CmtSystem::file_separator ();
+	  p += new_release;
+	}
+
+    if (CmtSystem::test_directory (p))
+	{
+	  //cerr << "Project directory " << p << " exists " << endl;
+
+	  found = true;
+
+	  IProjectFactory& factory = ProjectFactory::instance ();
+
+	  factory.create_project (name, p, "ProjectPath", this);
+
+	  break;
+	}
+    }
+
+  if (!found)
+    {
+      Project* p = Project::find_by_name (name);
+
+      if (p != 0)
+	  {
+	      found = true;
+	      p->add_parent (this);
+	      add_child (p);
+
+	      update_strategies_from_children ();
+	    }
+    }
+    
+  if (!found && (cmtprojectpath != ""))
+    {
+      cerr << "#CMT> Project " << name << " " << release << " requested by " << m_name << " not found in CMTPROJECTPATH" << endl;
+    }
+}
+
+//---------------------------------------------------------
+bool Project::select_release(const cmt_string& name, const cmt_string& release, cmt_string& result)
+{
+    cmt_string selected_release = "";
+
+    int v = -1;
+    int r = -1;
+    int p = -1;
+    CmtSystem::is_version_directory (release, v, r, p); 
+
+    int selected_v = -1;
+    int selected_r = -1;
+    int selected_p = -1;
+    CmtSystem::cmt_string_vector releases = get_project_releases(name);
+    for (int j = 0; j < releases.size (); j++)
+    {
+         //cout <<releases[j]<<endl;  
+         int new_v = -1;
+         int new_r = -1;
+         int new_p = -1;
+         CmtSystem::is_version_directory (releases[j], new_v, new_r, new_p);
+         if (v == -1)
+         {
+             if (selected_v<new_v)
+             {
+                 selected_v       = new_v;
+                 selected_r = -1;
+                 selected_p = -1;
+                 selected_release = releases[j];
+             }
+             else if (selected_v==new_v)
+             { // We compare the r
+                 if (selected_r<new_r)
+                 {
+                     selected_r = new_r;
+                     selected_p = -1;
+                     selected_release = releases[j];                               
+                 }
+                 else if (selected_r==new_r)
+                 { // We compare the p
+                     if (selected_p<new_p)
+                     {
+                         selected_p = new_p;
+                         selected_release = releases[j];                               
+                     }
+                     // else if ? not possible                                                           
+                 }                               
+             }
+         }
+         else if (r == -1)
+         {
+             if (v==new_v)
+             { // We compare the r                                                     
+                 if (selected_r<new_r)
+                 {
+                     selected_r = new_r;
+                     selected_p = -1;
+                     selected_release = releases[j];                               
+                 }
+                 else if (selected_r==new_r)
+                 { // We compare the p
+                     if (selected_p<new_p)
+                     {
+                         selected_p = new_p;
+                         selected_release = releases[j];                               
+                     }
+                     // else if ? not possible
+                 }
+             }
+         }
+         else if (p == -1)
+         {
+             if (v==new_v && r==new_r)
+                 { // We compare the p
+                     if (selected_p<new_p)
+                     {
+                         selected_p = new_p;
+                         selected_release = releases[j];                               
+                     }
+                     // else if ? not possible
+                 }        
+         }       
+         //cerr<<"v:"<<new_v<<", r:"<<new_r<<", p:"<<new_p<<endl;             
+         //cerr<<"req v:"<<v<<", req r:"<<r<<", req p:"<<p<<endl;        
+    }
+    //cerr <<"selected release: "<<selected_release<<endl;  
+    if (selected_release == "")
+        return false;
+    result = selected_release;   
+    return true;
+}
+
+//---------------------------------------------------------
+const CmtSystem::cmt_string_vector Project::get_project_releases(const cmt_string& name) const
+{
+	CmtSystem::cmt_string_vector releases;
+    cmt_string cmtprojectpath = Symbol::get_env_value ("CMTPROJECTPATH");
+    cmt_string sep;
+    sep = CmtSystem::path_separator ();
+
+    CmtSystem::cmt_string_vector items;
+    CmtSystem::split (cmtprojectpath, sep, items);    
+    for (int i = 0; i < items.size (); i++)
+    {
+        const cmt_string& item = items[i];
+        cmt_string p = item;
+        p += CmtSystem::file_separator ();
+        p += name;
+        if (CmtSystem::test_directory (p))
+	    { 
+	        CmtSystem::cmt_string_vector directories;
+            CmtSystem::scan_dir (p, directories);
+	        for (int j = 0; j < directories.size (); j++)
+	        {
+	            if  (CmtSystem::test_directory(directories[j]))
+	            {
+	                cmt_string release;
+	                CmtSystem:: basename(directories[j], release);
+	                if (CmtSystem::is_version_directory(release))
+	                {	                           
+	                     cmt_string& name_entry = releases.add ();
+	                     name_entry = release; 
+	                     //cout << release <<endl;  
+	                }             
+	            }	                    
+	        }       	                
+	    }
+    }
+    return (releases);
+}
+
+//----------------------------------------------------------
+Project& Project::operator = (const Project& other)
+{
+  m_name = other.m_name;
+  m_cmtpath = other.m_cmtpath;
+  m_cmtpath_pwd = other.m_cmtpath_pwd;
+  m_cmtpath_source = other.m_cmtpath_source;
+
+  return (*this);
+}
+
+//----------------------------------------------------------
+bool Project::operator == (const cmt_string& name) const
+{
+  return ((m_name == name));
+}
+
+//----------------------------------------------------------
+bool Project::operator != (const cmt_string& name) const
+{
+  return ((m_name != name));
+}
+
+//----------------------------------------------------------
+void Project::show ()
+{
+  static int level = 0;
+
+  bool is_current = false;
+
+  cmt_string here = CmtSystem::pwd ();
+
+  if (here.find (m_cmtpath) == 0) 
+    {
+      if (m_cmtpath_source != "default path")
+	{
+	  is_current = true;
+	}
+    }
+
+  for (int tab = 0; tab < level; tab++) cout << "  ";
+  cout << m_name << " " << m_release << " (in " << m_cmtpath << ")";
+
+  if (is_current) cout << " (current)";
+
+  int i;
+
+  for (i = 0; i < m_parents.size (); i++)
+    {
+      Project* p = m_parents[i];
+      if (p == 0) continue;
+      cout << " P=" << p->get_name ();
+    }
+
+  for (i = 0; i < m_children.size (); i++)
+    {
+      Project* p = m_children[i];
+      if (p == 0) continue;
+      cout << " C=" << p->get_name ();
+    }
+
+  cout << endl;
+
+  if (m_visited) return;
+
+  m_visited = true;
+
+  for (i = 0; i < m_children.size (); i++)
+    {
+      Project* p = m_children[i];
+      if (p == 0) continue;
+      level++;
+      p->show ();
+      level--;
+    }
+}
+
+
+//----------------------------------------------------------
+void Project::show_specified_strategies () const
+{
+  int i;
+
+  for (i = 0; i < m_strategies.size (); i++)
+    {
+      const Strategy& s = m_strategies[i];
+      if (s.m_specified)
+	{
+	  const StrategyDef* def = s.m_definition;
+ 
+	  cout << "# Project " << m_name
+	       << " sets " << def->m_keyword
+	       << " strategy to " << ((s.m_value) ? def->m_on_value : def->m_off_value);
+
+	  if (s.m_context != "")
+	    {
+	      cout << " (from package " << s.m_context << ")";
+	    }
+
+	  cout << endl;
+	}
+    }
+}
+
+//----------------------------------------------------------
+bool Project::has_strategy (const StrategyDef* definition) const
+{
+  int i;
+
+  for (i = 0; i < m_strategies.size (); i++)
+    {
+      const Strategy& s = m_strategies[i];
+      if (s.m_definition == definition)
+	{
+	  return (true);
+	}
+    }
+
+  return (false);
+}
+
+//----------------------------------------------------------
+bool Project::get_strategy (const cmt_string& name) const
+{
+  static StrategyMgr& mgr = StrategyMgr::instance ();
+
+  StrategyDef* def = mgr.find_strategy (name);
+  if (def == 0)
+    {
+      cerr << "#CMT> strategy " << name << " undefined" << endl;
+      return (false);
+    }
+
+  return (get_strategy (def));
+}
+
+//----------------------------------------------------------
+bool Project::is_specified (const StrategyDef* definition) const
+{
+  int i;
+
+  for (i = 0; i < m_strategies.size (); i++)
+    {
+      Strategy& s = m_strategies[i];
+      if (s.m_definition == definition)
+	{
+	  // This strategy is applied in this project
+	  return (s.m_specified);
+	}
+    }
+
+  // This strategy is not applied in this project
+  return (false);
+}
+
+//----------------------------------------------------------
+bool Project::get_strategy (const StrategyDef* def) const
+{
+  int i;
+
+  for (i = 0; i < m_strategies.size (); i++)
+    {
+      Strategy& s = m_strategies[i];
+      if (s.m_definition == def)
+	{
+	  // This strategy is applied in this project
+	  if (s.m_specified)
+	    {
+	      return (s.m_specified_value);
+	    }
+	  return (s.m_value);
+	}
+    }
+
+  // This strategy is not applied in this project
+  return (def->m_default_value);
+}
+
+//----------------------------------------------------------
+void Project::set_default_strategy (const cmt_string& name)
+{
+  static StrategyMgr& mgr = StrategyMgr::instance ();
+
+  StrategyDef* def = mgr.find_strategy (name);
+  if (def == 0)
+    {
+      cerr << "#CMT> strategy " << name << " undefined" << endl;
+      return;
+    }
+
+  update_strategy (def, def->m_default_value);
+}
+
+
+//----------------------------------------------------------
+void Project::set_strategy (const cmt_string& name, const cmt_string& value, const cmt_string& context)
+{
+  static StrategyMgr& mgr = StrategyMgr::instance ();
+
+  StrategyDef* def = mgr.find_strategy (name);
+  if (def == 0)
+    {
+      cerr << "#CMT> strategy " << name << " undefined" << endl;
+      return;
+    }
+
+  bool b_value = false;
+
+  if (value == def->m_on_value)
+    {
+      b_value = true;
+    }
+  else if (value == def->m_off_value)
+    {
+      b_value = false;
+    }
+  else
+    {
+      cerr << "#CMT> requested strategy value " << value << " undefined in strategy " << name << endl;
+      return;
+    }
+
+  set_strategy (def, b_value, context);
+}
+
+//----------------------------------------------------------
+void Project::set_strategy (StrategyDef* definition, bool b_value, const cmt_string& context)
+{
+  bool need_strategy = true;
+
+  int i;
+
+  for (i = 0; i < m_strategies.size (); i++)
+    {
+      Strategy& s = m_strategies[i];
+      if (s.m_definition == definition)
+	{
+	  // This strategy is already applied in this project. Let's change it's value
+	  s.set (definition, b_value, get_name ());
+	  if (context != "")
+	    {
+	      if (s.m_context != "") s.m_context += " ";
+	      s.m_context += context;
+	    }
+	  need_strategy = false;
+	  break;
+	}
+    }
+
+  if (need_strategy)
+    {
+      // This strategy is not yet applied in this project.
+
+      Strategy& s = m_strategies.add ();
+      s.clear ();
+      s.set (definition, b_value, get_name ());
+      s.m_context = context;
+    }
+  
+  for (i = 0; i < m_parents.size (); i++)
+    {
+      Project* project = m_parents[i];
+
+      project->update_strategy (definition, b_value);
+    }
+}
+
+/**----------------------------------------------------------
+   The strategy value is changed because of indirect influences
+   - default strategy at initialization time
+   - change in the children
+   - change in the children list
+
+   (This is not a specification : see the set_strategy method)
+ */
+void Project::update_strategy (StrategyDef* definition, bool b_value)
+{
+  bool need_strategy = true;
+  bool specified = false;
+
+  int i;
+
+  for (i = 0; i < m_strategies.size (); i++)
+    {
+      Strategy& s = m_strategies[i];
+      if (s.m_definition == definition)
+	{
+	  need_strategy = false;
+
+	  if (!s.m_specified)
+	    {
+	      // This strategy is already applied in this project. Let's change it's value
+	      s.update (definition, b_value, get_name ());
+	    }
+	  else
+	    {
+	      specified = true;
+	    }
+	  break;
+	}
+    }
+
+  if (need_strategy)
+    {
+      // This strategy is not yet applied in this project.
+
+      Strategy& s = m_strategies.add ();
+      s.clear ();
+      s.update (definition, b_value, get_name ());
+    }
+
+  if (!specified)
+    {
+      for (i = 0; i < m_parents.size (); i++)
+	{
+	  Project* project = m_parents[i];
+
+	  project->update_strategy (definition, b_value);
+	}
+    }
+}
+
+/**----------------------------------------------------------
+   At least one of the children has changed this strategy
+   Or the list of children has changed.
+   We need to update the strategy value accordingly
+   This will not change the specified value for this strategy
+ */
+void Project::update_strategy_from_children (StrategyDef* definition)
+{
+  // If this strategy is specified we don't care what happens from the children
+
+  //cerr << "Updating strategy " << definition->m_name << " from children for project " << m_name << endl;
+
+  int i;
+
+  for (i = 0; i < m_strategies.size (); i++)
+    {
+      Strategy& s = m_strategies[i];
+      if (s.m_definition == definition)
+	{
+	  // This strategy is applied in this project.
+
+	  if (s.m_specified)
+	    {
+	      // There will be no impact since the strategy is specified
+
+	      //cerr << "This strategy is specified in this project" << endl;
+	      return;
+	    }
+
+	  break;
+	}
+    }
+
+  // The strategy is not specified locally so we will now figure out
+  // which strategy has to be considered from the mixture of specifications
+  // from all children.
+
+  // Algorithm:
+  // - We consider children by pairs
+  // - a child that specifies its strategy wins over a child that does not
+  // - when the two children have the same level of priority we consider the priority value
+
+  Project* selected = 0;
+  bool selected_is_specified = false;
+  bool selected_value = definition->m_default_value;
+
+  for (i = 0; i < m_children.size (); i++)
+    {
+      Project* p = m_children[i];
+
+      //cerr << "Checking strategy for child " << p->get_name () << endl;
+
+      bool is_specified = p->is_specified (definition);
+      bool value = p->get_strategy (definition);
+
+      if (selected == 0)
+	{
+	  selected = p;
+	  selected_is_specified = is_specified;
+	  selected_value = value;
+	  continue;
+	}
+
+      if (is_specified == selected_is_specified)
+	{
+	  if (selected_value != value)
+	    {
+	      // same level of priority but different values -> we must decide
+	      bool priority_value = definition->m_priority_value;
+	      if (value == priority_value)
+		{
+		  selected = p;
+		  selected_is_specified = is_specified;
+		  selected_value = value;
+		}
+	    }
+	}
+      else
+	{
+	  if (is_specified)
+	    {
+	      selected = p;
+	      selected_is_specified = is_specified;
+	      selected_value = value;
+	    }
+	}
+    }
+
+  update_strategy (definition, selected_value);  
+}
+
+/**----------------------------------------------------------
+   At least one of the children has changed its strategies
+   Or the list of children has changed.
+   We need to update the strategy values accordingly
+   This will not change the specified values
+ */
+void Project::update_strategies_from_children ()
+{
+  StrategyDef::StrategyDefs& defs = StrategyMgr::get_definitions ();
+
+  //cerr << "Updating strategies from children for project " << m_name << endl;
+
+  int i;
+
+  for (i = 0; i < defs.size (); i++)
+    {
+      StrategyDef* def = defs[i];
+      
+      update_strategy_from_children (def);
+    }
+
+  for (i = 0; i < m_parents.size (); i++)
+    {
+      Project* p = m_parents[i];
+      p->update_strategies_from_children ();
+    }
+}
+
+/**----------------------------------------------------------
+   The StrategyMgr singleton
+ */
+StrategyMgr& StrategyMgr::instance ()
+{
+  static StrategyMgr me;
+  return (me);
+}
+
+/**----------------------------------------------------------
+   The StrategyMgr constructor
+   Here are primarily constructed all strategy definitions
+ */
+StrategyMgr::StrategyMgr ()
+{
+  m_defs.clear ();
+
+  StrategyDef* s;
+
+  s = new StrategyDef;
+  s->m_keyword = "build";
+  s->m_name = "BuildPrototypes";
+  s->m_on_value = "prototypes";
+  s->m_off_value = "no_prototypes";
+  s->m_default_value = true;
+  s->m_priority_value = false;
+
+  m_defs.push_back (s);
+
+  s = new StrategyDef;
+  s->m_keyword = "build";
+  s->m_name = "InstallArea";
+  s->m_on_value = "with_installarea";
+  s->m_off_value = "without_installarea";
+  s->m_default_value = false;
+  s->m_priority_value = true;
+
+  m_defs.push_back (s);
+
+  s = new StrategyDef;
+  s->m_keyword = "setup";
+  s->m_name = "SetupConfig";
+  s->m_on_value = "config";
+  s->m_off_value = "no_config";
+  s->m_default_value = true;
+  s->m_priority_value = false;
+
+  m_defs.push_back (s);
+
+  s = new StrategyDef;
+  s->m_keyword = "setup";
+  s->m_name = "SetupRoot";
+  s->m_on_value = "root";
+  s->m_off_value = "no_root";
+  s->m_default_value = true;
+  s->m_priority_value = false;
+
+  m_defs.push_back (s);
+
+  s = new StrategyDef;
+  s->m_keyword = "setup";
+  s->m_name = "SetupCleanup";
+  s->m_on_value = "cleanup";
+  s->m_off_value = "no_cleanup";
+  s->m_default_value = true;
+  s->m_priority_value = false;
+
+  m_defs.push_back (s);
+
+  s = new StrategyDef;
+  s->m_keyword = "structure";
+  s->m_name = "VersionDirectory";
+  s->m_on_value = "with_version_directory";
+  s->m_off_value = "without_version_directory";
+  if (Cmt::get_current_structuring_style () != without_version_directory)
+    {
+      s->m_default_value = true;
+      s->m_priority_value = false;
+    }
+  else
+    {
+      s->m_default_value = false;
+      s->m_priority_value = true;
+    }
+
+  m_defs.push_back (s);
+}
+
+/**----------------------------------------------------------
+   Find a strategy definition by its name
+ */
+StrategyDef* StrategyMgr::find_strategy (const cmt_string& name)
+{
+  static StrategyMgr& me = instance ();
+
+  int i;
+
+  for (i = 0; i < me.m_defs.size (); i++)
+    {
+      StrategyDef* def = me.m_defs[i];
+      if (def->m_name == name)
+	{
+	  return (def);
+	}
+    }
+
+  return (0);
+}
+
+/**----------------------------------------------------------
+   Retreive the default value defined for a given strategy
+ */
+bool StrategyMgr::get_default_strategy (const cmt_string& name)
+{
+  StrategyDef* def = find_strategy (name);
+  if (def == 0) return (false);
+  return (def->m_default_value);
+}
+
+/**----------------------------------------------------------
+   Retreive the priority value defined for a given strategy
+   This value is used when two children of a project request two conflicting strategy values
+ */
+bool StrategyMgr::get_priority_strategy (const cmt_string& name)
+{
+  StrategyDef* def = find_strategy (name);
+  if (def == 0) return (false);
+  return (def->m_priority_value);
+}
+
+/**----------------------------------------------------------
+   Return the vector of all existing strategy definitions
+ */
+StrategyDef::StrategyDefs& StrategyMgr::get_definitions ()
+{
+  static StrategyMgr& me = instance ();
+
+  return (me.m_defs);
+}
+
+//-----------------------------------------------------------
+Strategy::Strategy ()
+{
+  clear ();
+}
+
+//-----------------------------------------------------------
+void Strategy::clear ()
+{
+  m_definition = 0;
+  m_specified = false;
+  m_specified_value = false;
+  m_value = false;
+  m_on_tag = 0;
+  m_off_tag = 0;
+}
+
+/**----------------------------------------------------------
+   Specify a new value for this strategy.
+   This only happens when a strategy statement is met in a project file or in a requirements file.
+ */
+void Strategy::set (StrategyDef* definition, bool value, const cmt_string& project_name)
+{
+  //cerr << "Setting strategy " << definition->m_name << " for project " << project_name << " to " << value << endl;
+
+  m_definition = definition;
+  m_specified = true;
+  m_specified_value = value;
+
+  update (definition, value, project_name);
+}
+
+/**----------------------------------------------------------
+   Change the effective value for this strategy.
+   This has no impact on to the specified value.
+   This will adapt the tag settings
+ */
+void Strategy::update (StrategyDef* definition, bool value, const cmt_string& project_name)
+{
+  //cerr << "Updating strategy " << definition->m_name << " for project " << project_name << " to " << value << endl;
+
+  m_value = value;
+  m_definition = definition;
+
+  cmt_string to_tag_name = project_name;
+  cmt_string to_untag_name = project_name;
+
+  to_tag_name += "_";
+  to_untag_name += "_";
+
+  if (m_value)
+    {
+      to_tag_name += m_definition->m_on_value;
+      to_untag_name += m_definition->m_off_value;
+    }
+  else
+    {
+      to_tag_name += m_definition->m_off_value;
+      to_untag_name += m_definition->m_on_value;
+    }
+
+  m_on_tag = Tag::find (to_tag_name);
+  m_off_tag = Tag::find (to_untag_name);
+
+  if (m_on_tag == 0) 
+    {
+      m_on_tag = Tag::add (to_tag_name, PriorityConfig, "PROJECT", 0);
+      m_off_tag = Tag::add (to_untag_name, PriorityConfig, "PROJECT", 0);
+
+      m_on_tag->add_tag_exclude (m_off_tag);
+      m_off_tag->add_tag_exclude (m_on_tag);
+    }
+
+  m_off_tag->unmark ();
+  m_on_tag->mark ();
+}
+//-----------------------------------------------------------
+const cmt_string& StrategyDef::get_default_value () const
+{
+  if (m_default_value)
+    {
+      return (m_on_value);
+    }
+  else
+    {
+      return (m_off_value);
+    }
+}
+//-----------------------------------------------------------
+void Project::set_author (const cmt_string& name)
+{
+  cout<<"set_author"<<name<<endl;      
+  this->m_author = name;
+}
+//-----------------------------------------------------------
+const cmt_string& Project::get_author () const
+{
+  return (m_author);
+}
+//-----------------------------------------------------------
+void Project::project_author_action (const CmtSystem::cmt_string_vector& words)
+{
+  if (m_author != "") m_author += "\n";
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& w = words[i];
+      
+      if (i > 1) m_author += " ";
+      m_author += w;  
+    }
+}
+//-----------------------------------------------------------
+Use*  Project::get_use () const
+{
+    return m_use;    
+}  
+//-----------------------------------------------------------
+void  Project::set_use (Use* use)
+{  
+    this->m_use = use;
+}
+//-----------------------------------------------------------
Index: /CMT/v1r20/source/cmt_project.h
===================================================================
--- /CMT/v1r20/source/cmt_project.h	(revision 368)
+++ /CMT/v1r20/source/cmt_project.h	(revision 368)
@@ -0,0 +1,223 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_project_h__
+#define __cmt_project_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+#include "cmt_use.h"
+#include "cmt_awk.h"
+
+class Project;
+
+class StrategyDef
+{
+public:
+  typedef cmt_vector <StrategyDef*> StrategyDefs;
+
+  cmt_string m_keyword;
+  cmt_string m_name;
+  cmt_string m_on_value;
+  cmt_string m_off_value;
+  bool m_default_value;
+  bool m_priority_value;
+
+  const cmt_string& get_default_value () const; 
+};
+
+class Strategy
+{
+public:
+  StrategyDef* m_definition;
+  bool m_specified;
+  bool m_specified_value;
+  bool m_value;
+  Tag* m_on_tag;
+  Tag* m_off_tag;
+  cmt_string m_context;
+
+  Strategy ();
+  void clear ();
+  void set (StrategyDef* definition, bool value, const cmt_string& project_name);
+  void update (StrategyDef* definition, bool value, const cmt_string& project_name);
+};
+
+class StrategyMgr
+{
+public:
+  static StrategyMgr& instance ();
+  static StrategyDef* find_strategy (const cmt_string& name);
+  static bool get_default_strategy (const cmt_string& name);
+  static bool get_priority_strategy (const cmt_string& name);
+  static StrategyDef::StrategyDefs& get_definitions ();
+
+private:
+  StrategyMgr ();
+  StrategyDef::StrategyDefs m_defs;
+};
+
+class ProjectFactory : public IProjectFactory
+{
+public:
+  static IProjectFactory& instance ();
+
+public:
+  void reset ();
+  Project* create_project (const cmt_string& name,
+			   const cmt_string& path,
+			   const cmt_string& path_source,
+			   Project* parent);
+
+};
+
+class IProjectAction
+{
+public:
+  virtual bool run (const Project& project) = 0;
+};
+
+class IProjectVisitor
+{
+public:
+  virtual void pre (Project* p) = 0;
+  virtual void in (Project* p) = 0;
+  virtual void post (Project* p) = 0;
+};
+
+class Project
+{
+public:
+
+  typedef cmt_vector<Project> ProjectVector;
+  typedef cmt_vector<Project*> ProjectPtrVector;
+
+  static bool create (const cmt_string& name, 
+		      const cmt_string& release, 
+		      const cmt_string& path);
+
+  static Project* find_by_name (const cmt_string& name);
+  static Project* find_by_cmtpath (const cmt_string& cmtpath);
+  static Project* get_current ();
+  static Project* add (const cmt_string& name,
+		       const cmt_string& release);
+
+  static ProjectVector& projects ();
+  static void clear_all ();
+  static void show_all ();
+  static void show_specified_strategies_for_all ();
+  static void show_paths ();
+  static const cmt_string& get_project_file_name ();
+
+  static void fill_selection (int depth, CmtSystem::cmt_string_vector& path_selections);
+
+  static void broadcast (IProjectAction& action);
+  static void reverse_broadcast (IProjectAction& action);
+  static void scan_paths (PathScanner& scanner, PathScanner::actor& actor);
+  static void scan_paths_for_package (PathScanner& scanner, const cmt_string& name);
+
+  static cmt_string find_in_cmt_paths (const cmt_string& path);
+
+  static void fill_cmtpaths (cmt_string& buffer);
+
+  static void start_visit (IProjectVisitor& visitor);
+
+public:
+
+  Project ();
+
+  const cmt_string& get_name () const;
+  const cmt_string& get_release () const;
+  const cmt_string& get_container () const;
+  const cmt_string& get_container_version () const;
+  const cmt_string& get_cmtpath () const;
+  const cmt_string& get_cmtpath_pwd () const;
+  const cmt_string& get_cmtpath_source () const;
+  int get_children_size () const;
+  
+  const CmtSystem::cmt_string_vector get_project_releases(const cmt_string& name) const; 
+  bool select_release(const cmt_string& name, const cmt_string& release, cmt_string& result);
+  
+  Project* get_child (int index) const;
+  bool visited () const;
+
+  void set_name (const cmt_string& name);
+  void set_release (const cmt_string& release);
+  void set_container (const cmt_string& container);
+  void set_container_version (const cmt_string& version);
+  void set_cmtpath (const cmt_string& path);
+  void set_cmtpath_pwd (const cmt_string& path);
+  void set_cmtpath_source (const cmt_string& source);
+  void clear ();
+  void configure ();
+  bool has_parents () const;
+  bool has_parent (Project* p) const;
+  bool has_child (Project* p) const;
+  void add_parent (Project* p);
+  void add_child (Project* p);
+
+  void container_action (const cmt_string& name, const cmt_string& version);
+  void use_action (const cmt_string& name, const cmt_string& release);
+
+  Project& operator = (const Project& other);
+  bool operator == (const cmt_string& name) const;
+  bool operator != (const cmt_string& name) const;
+
+  void show ();
+  void show_specified_strategies () const;
+
+  bool has_strategy (const StrategyDef* definition) const;
+  bool is_specified (const StrategyDef* definition) const;
+  bool get_strategy (const StrategyDef* definition) const;
+  bool get_strategy (const cmt_string& name) const;
+  void set_default_strategy (const cmt_string& name);
+  void set_strategy (const cmt_string& name, const cmt_string& value, const cmt_string& context);
+  void set_strategy (StrategyDef* definition, bool b_value, const cmt_string& context);
+  void update_strategy (StrategyDef* definition, bool b_value);
+  void update_strategy_from_children (StrategyDef* definition);
+  void update_strategies_from_children ();
+  void set_author (const cmt_string& name);
+  const cmt_string& get_author () const;
+  void project_author_action (const CmtSystem::cmt_string_vector& words);
+  // bool get_author (const cmt_string& name) const;
+  
+  void   visit (IProjectVisitor& visitor);
+  
+  // Use
+  Use*  get_use () const;  
+  void  set_use (Use* use);  
+  
+  cmt_vector <cmt_string> m_extra_lines;
+  
+private:
+
+  void fill_cmtpath (cmt_string& buffer);
+
+  cmt_string m_name;
+  cmt_string m_author;
+  cmt_string m_release;
+  cmt_string m_container;
+  cmt_string m_container_version;
+
+  ProjectPtrVector m_parents;
+  ProjectPtrVector m_children;
+
+  bool m_visited;
+
+  cmt_string m_cmtpath;
+  cmt_string m_cmtpath_pwd;
+  cmt_string m_cmtpath_source;
+
+  bool m_configured;
+
+  cmt_vector <Strategy> m_strategies;
+  
+  Use* m_use;
+};
+
+
+#endif
Index: /CMT/v1r20/source/cmt_regexp.cxx
===================================================================
--- /CMT/v1r20/source/cmt_regexp.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_regexp.cxx	(revision 368)
@@ -0,0 +1,1682 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_std.h"
+#include "cmt_regexp.h"
+#include "cmt_vector.h"
+#include "cmt_system.h"
+
+//----------------------------------------------------------
+//
+//  Declarations
+//
+//----------------------------------------------------------
+
+static int tab_level = 0;
+static void tab ()
+{
+  for (int i = 0; i < tab_level; i++)
+    {
+      cout << "  ";
+    }
+}
+
+//----------------------------------------------------------
+class cmt_regexp_node
+{
+public:
+  static cmt_regexp_node& null ();
+  static int node_count ();
+  
+  cmt_regexp_node ();
+  virtual ~cmt_regexp_node ();
+  
+  virtual const cmt_regexp::iterator match (const cmt_string& text, 
+                                            int pos) const;
+  virtual bool is_char () const;
+  virtual bool is_many_node () const;
+
+  virtual void dump () const;
+  
+private:
+  static int _node_count;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_char_node : public cmt_regexp_node
+{
+public:
+  cmt_char_node (char c);
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+  
+  bool is_char () const;
+  operator char ();
+
+  void dump () const;
+  
+private:
+  char _c;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_string_node : public cmt_regexp_node
+{
+public:
+  cmt_string_node (const cmt_string& s);
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+    
+private:
+  cmt_string _s;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_char_list_node : public cmt_regexp_node
+{
+public:
+  cmt_char_list_node (cmt_string list);
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+  
+protected:
+  cmt_string _list;
+  cmt_string _choices;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_not_char_list_node : public cmt_char_list_node
+{
+public:
+  cmt_not_char_list_node (cmt_string list);
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_any_node : public cmt_regexp_node
+{
+public:
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_zero_one : public cmt_regexp_node
+{
+public:
+  cmt_zero_one (cmt_regexp_node* n);
+  ~cmt_zero_one ();
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+  
+protected:
+  cmt_regexp_node* _node;
+};
+//----------------------------------------------------------
+
+
+
+//----------------------------------------------------------
+class cmt_begin_node : public cmt_regexp_node
+{
+public:
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_end_node : public cmt_regexp_node
+{
+public:
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_regexp_node_set : public cmt_regexp_node
+{
+public:
+  cmt_regexp_node_set ();
+  cmt_regexp_node_set (cmt_regexp_node_set* father);
+  ~cmt_regexp_node_set ();
+  
+  cmt_regexp_node_set* father ();
+  void clear ();
+  void push (cmt_regexp_node* n);
+  cmt_regexp_node* pop ();
+  cmt_regexp_node* top () const;
+  int nodes () const;
+  const cmt_regexp_node* nodeAt (int index) const;
+  bool parentheses () const;
+  void set_parentheses (bool value);
+  virtual void reduce ();
+
+  virtual void dump () const;
+  void dump (const cmt_string& title) const;
+  
+protected:
+  cmt_regexp_node_set* _father;
+  cmt_vector<cmt_regexp_node*> _nodes;
+  bool _parentheses;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_and_node : public cmt_regexp_node_set
+{
+public:
+  cmt_and_node ();
+  cmt_and_node (cmt_regexp_node_set* father);
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+  void reduce ();
+  void fill (cmt_and_node& other, int start_index);
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_or_node : public cmt_regexp_node_set
+{
+public:
+  cmt_or_node (cmt_regexp_node_set* father);
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_regexp_node& cmt_regexp_node::null ()
+{
+  static cmt_regexp_node null_instance;
+  
+  return (null_instance);
+}
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_many_node : public cmt_regexp_node
+{
+public:
+  bool is_many_node () const;
+  void install (cmt_and_node& other, int index);
+  void reduce ();
+
+  void dump () const;
+  
+protected:
+  cmt_many_node (cmt_regexp_node* n);
+  virtual ~cmt_many_node ();
+  cmt_regexp_node* _node;
+  cmt_and_node _follower;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_zero_more : public cmt_many_node
+{
+public:
+  cmt_zero_more (cmt_regexp_node* n);
+  
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+class cmt_one_more : public cmt_many_node
+{
+public:
+  cmt_one_more (cmt_regexp_node* n);
+
+  const cmt_regexp::iterator match (const cmt_string& text, int pos) const;
+
+  void dump () const;
+};
+//----------------------------------------------------------
+
+
+//----------------------------------------------------------
+//
+//  Implementation
+//
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_regexp_node::cmt_regexp_node ()
+{
+  _node_count++;
+}
+
+cmt_regexp_node::~cmt_regexp_node ()
+{
+  _node_count--;
+}
+
+int cmt_regexp_node::node_count ()
+{
+  return (_node_count);
+}
+
+const cmt_regexp::iterator cmt_regexp_node::match (const cmt_string& /*text*/, 
+                                            int /*pos*/) const
+{
+  return (cmt_regexp::iterator::null());
+}
+
+bool cmt_regexp_node::is_char () const
+{
+  return (false);
+}
+
+bool cmt_regexp_node::is_many_node () const
+{
+  return (false);
+}
+
+void cmt_regexp_node::dump () const
+{
+}
+
+int cmt_regexp_node::_node_count = 0;
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_char_node::cmt_char_node (char c)
+{
+  _c = c;
+}
+
+const cmt_regexp::iterator cmt_char_node::match (const cmt_string& text, 
+                                                 int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  char c = text[pos];
+
+  if (c == _c)
+    {
+      return (cmt_regexp::iterator (pos, 1));
+    }
+  
+  return (cmt_regexp::iterator::null ());
+}
+
+bool cmt_char_node::is_char () const
+{
+  return (true);
+}
+
+cmt_char_node::operator char ()
+{
+  return (_c);
+}
+
+void cmt_char_node::dump () const
+{
+  tab (); cout << "char>(" << this << ") c=" << _c << endl;
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_string_node::cmt_string_node (const cmt_string& s)
+{
+  _s = s;
+}
+
+const cmt_regexp::iterator cmt_string_node::match (const cmt_string& text, 
+                                                  int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  int length = _s.size ();
+  
+  cmt_string s = text.substr (pos, length);
+  
+  if ((length == 0) || (s == _s))
+    {
+      return (cmt_regexp::iterator (pos, length));
+    }
+  
+  return (cmt_regexp::iterator::null ());
+}
+
+void cmt_string_node::dump () const
+{
+  tab (); cout << "string (" << this << ") s=[" << _s << "]" << endl;
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_char_list_node::cmt_char_list_node (cmt_string list)
+{
+  _list = list;
+  
+  _choices = "";
+  
+  char c;
+  int i;
+  
+  for (i = 0; i < list.size (); i++)
+    {
+      c = list[i];
+      
+      switch (c)
+        {
+          case '-':
+            i++;
+            {
+              char c1 = _choices[_choices.size () - 1];
+              char c2 = list[i];
+              int j;
+              int j0 = (c1 < c2) ? c1 : c2;
+              int j1 = (c1 > c2) ? c1 : c2;
+              for (j = j0; j <= j1; j++)
+                {
+                  _choices += j;
+                }
+            }
+            break;
+          case '\\':
+            i++;
+            c = list[i];
+            switch (c)
+              {
+                case '[':
+                case ']':
+                case '(':
+                case ')':
+                case '.':
+                case '*':
+                case '?':
+                case '^':
+                case '$':
+                case '\\':
+                  c = '\\';
+                  break;
+                case 'r':
+                  c = '\r';
+                  break;
+                case 't':
+                  c = '\t';
+                  break;
+                case 'n':
+                  c = '\n';
+                  break;
+                default:
+                  break;
+              }
+          default:
+            _choices += c;
+            break;
+        }
+    }
+}
+
+const cmt_regexp::iterator cmt_char_list_node::match (const cmt_string& text, 
+                                                     int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  char c = text[pos];
+
+  int i;
+  
+  for (i = 0; i < _choices.size (); i++)
+    {
+      if (c == _choices[i]) return (cmt_regexp::iterator (pos, 1));
+    }
+  
+  return (cmt_regexp::iterator::null ());
+}
+
+void cmt_char_list_node::dump () const
+{
+  tab (); cout << "char_list (" << this << ") list=[" << _list << "] choices=[" << _choices << "]" << endl;
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_not_char_list_node::cmt_not_char_list_node (cmt_string list) : 
+        cmt_char_list_node (list)
+{
+}
+
+const cmt_regexp::iterator cmt_not_char_list_node::match (const cmt_string& text, 
+                                                      int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  char c = text[pos];
+
+  int i;
+
+  for (i = 0; i < _choices.size (); i++)
+    {
+      if (c == _choices[i]) return (cmt_regexp::iterator::null ());
+    }
+  
+  return (cmt_regexp::iterator (pos, 1));
+}
+
+void cmt_not_char_list_node::dump () const
+{
+  tab (); cout << "not_char_list (" << this << ") list=[" << _list << "] choices=[" << _choices << "]" << endl;
+}
+
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+const cmt_regexp::iterator cmt_any_node::match (const cmt_string& text, 
+                                            int pos) const
+{
+  if ((pos < 0) | (pos >= text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+  
+  return (cmt_regexp::iterator (pos, 1));
+}
+
+void cmt_any_node::dump () const
+{
+  tab (); cout << "any (" << this << ") " << endl;
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_zero_one::cmt_zero_one (cmt_regexp_node* n) : _node (n)
+{
+}
+
+cmt_zero_one::~cmt_zero_one ()
+{
+  delete _node;
+}
+
+const cmt_regexp::iterator cmt_zero_one::match (const cmt_string& text, 
+                                               int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  int total = 0;
+
+  if (pos < text.size ())
+    {
+      const cmt_regexp::iterator it = _node->match (text, pos);
+      if (it != cmt_regexp::iterator::null ())
+        {
+          total += it._length;
+          pos += it._length;
+        }
+    }
+  
+  return (cmt_regexp::iterator (pos, total));
+}
+
+void cmt_zero_one::dump () const
+{
+  tab (); cout << "zero_one (" << this << ") " << endl;
+  if (_node != 0)
+    {
+      tab_level++;
+      _node->dump ();
+      tab_level--;
+    }
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_many_node::cmt_many_node (cmt_regexp_node* n) : _node (n)
+{
+}
+
+bool cmt_many_node::is_many_node () const
+{
+  return (true);
+}
+
+cmt_many_node::~cmt_many_node ()
+{
+  delete _node;
+}
+
+void cmt_many_node::install (cmt_and_node& other, int start_index)
+{
+  _follower.fill (other, start_index);
+}
+
+void cmt_many_node::reduce ()
+{
+  _follower.reduce ();
+}
+
+void cmt_many_node::dump () const
+{
+  tab (); cout << "many (" << this << ") " << endl;
+  if (_node != 0) 
+    {
+      tab_level++;
+      _node->dump ();
+      tab_level--;
+    }
+  tab_level++;
+  _follower.dump ();
+  tab_level--;
+}
+
+//----------------------------------------------------------
+
+
+
+//----------------------------------------------------------
+cmt_zero_more::cmt_zero_more (cmt_regexp_node* n) : cmt_many_node (n)
+{
+}
+
+const cmt_regexp::iterator cmt_zero_more::match (const cmt_string& text, 
+                                             int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  int total = 0;
+
+  //
+  // we are at : x*y
+  //
+
+  int saved_pos = -1;
+  int saved_total = -1;
+
+  do
+    {
+      const cmt_regexp::iterator itx = _node->match (text, pos);
+      const cmt_regexp::iterator ity = _follower.match (text, pos);
+
+      if ((itx == cmt_regexp::iterator::null ()) &&
+          (ity == cmt_regexp::iterator::null ())) 
+        {
+          //
+          // There is neither x nor y. We move back to the last 
+          // succesful match for y.
+          //
+          if (saved_pos >= 0)
+            {
+              //
+              // We had once a y.
+              //
+              pos = saved_pos;
+              total = saved_total;
+            }
+          else
+            {
+              //
+              // We never had any y !
+              //
+              return (cmt_regexp::iterator::null ());
+            }
+
+          break;
+        }
+
+      if (itx == cmt_regexp::iterator::null ())
+        {
+          //
+          // There is a y but no x anymore, fine, we can quit.
+          //
+          total += ity._length;
+          pos += ity._length;
+          break;
+        }
+
+      if (ity != cmt_regexp::iterator::null ())
+        {
+          //
+          //  We have both x and y. We save the current pos and total,
+          // and then skip this x.
+          //
+          saved_total = total + ity._length;
+          saved_pos = pos + ity._length;
+        }
+      total += itx._length;
+      pos += itx._length;
+    } while (true);
+  
+  return (cmt_regexp::iterator (pos, total));
+}
+
+void cmt_zero_more::dump () const
+{
+  tab (); cout << "zero_more (" << this << ") " << endl;
+  if (_node != 0)
+    {
+      tab_level++;
+      _node->dump ();
+      tab_level--;
+    }
+  _follower.dump ();
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_one_more::cmt_one_more (cmt_regexp_node* n) : cmt_many_node (n)
+{
+}
+
+const cmt_regexp::iterator cmt_one_more::match (const cmt_string& text, 
+                                            int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  int total = 0;
+
+  //
+  // we are at : x+y
+  //
+
+  int saved_pos = -1;
+  int saved_total = -1;
+  bool at_least_one = false;
+
+  do
+    {
+      const cmt_regexp::iterator itx = _node->match (text, pos);
+      const cmt_regexp::iterator ity = _follower.match (text, pos);
+
+      if ((itx == cmt_regexp::iterator::null ()) &&
+          (ity == cmt_regexp::iterator::null ())) 
+        {
+          //
+          // There is neither x nor y. We move back to the last 
+          // succesful match for y.
+          //
+          if (saved_pos >= 0)
+            {
+              //
+              // We had once a y.
+              //
+              pos = saved_pos;
+              total = saved_total;
+            }
+          else
+            {
+              //
+              // We never had any y !
+              //
+              return (cmt_regexp::iterator::null ());
+            }
+
+          break;
+        }
+
+      if (itx == cmt_regexp::iterator::null ())
+        {
+          //
+          // There is a y but no x anymore, fine, we can quit.
+          //
+          total += ity._length;
+          pos += ity._length;
+          break;
+        }
+
+      if (ity != cmt_regexp::iterator::null ())
+        {
+          //
+          //  We have both x and y. We save the current pos and total,
+          // and then skip this x.
+          //
+          saved_total = total + ity._length;
+          saved_pos = pos + ity._length;
+        }
+
+      total += itx._length;
+      pos += itx._length;
+
+      at_least_one = true;
+    } while (true);
+  
+  if (!at_least_one) return (cmt_regexp::iterator::null ());
+  
+  return (cmt_regexp::iterator (pos, total));
+}
+
+void cmt_one_more::dump () const
+{
+  tab (); cout << "one_more (" << this << ") " << endl;
+  if (_node != 0)
+    {
+      tab_level++;
+      _node->dump ();
+      tab_level--;
+    }
+  tab_level++;
+  _follower.dump ();
+  tab_level--;
+}
+
+//----------------------------------------------------------
+
+
+
+//----------------------------------------------------------
+const cmt_regexp::iterator cmt_begin_node::match (const cmt_string& /*text*/, 
+                                                 int pos) const
+{
+  if (pos == 0) return (cmt_regexp::iterator (pos, 0));
+  return (cmt_regexp::iterator::null ());
+}
+
+void cmt_begin_node::dump () const
+{
+  tab (); cout << "begin (" << this << ") " << endl;
+}
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+const cmt_regexp::iterator cmt_end_node::match (const cmt_string& text,
+                                                int pos) const
+{
+  if (pos == text.size ()) return (cmt_regexp::iterator (pos, 0));
+  return (cmt_regexp::iterator::null ());
+}
+
+void cmt_end_node::dump () const
+{
+  tab (); cout << "end (" << this << ") " << endl;
+}
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_regexp_node_set::cmt_regexp_node_set () : _father (0)
+{
+  _parentheses = false;
+}
+
+cmt_regexp_node_set::cmt_regexp_node_set (cmt_regexp_node_set* father) : _father (father)
+{
+  if (father != 0) father->push (this);
+  _parentheses = false;
+}
+
+cmt_regexp_node_set::~cmt_regexp_node_set ()
+{
+  clear ();
+}
+
+cmt_regexp_node_set* cmt_regexp_node_set::father ()
+{
+  return (_father);
+}
+
+void cmt_regexp_node_set::clear ()
+{
+  int i;
+  
+  for (i = 0; i < _nodes.size (); i++)
+    {
+      cmt_regexp_node* n = _nodes[i];
+      delete n;
+    }
+  _nodes.clear ();
+}
+
+void cmt_regexp_node_set::push (cmt_regexp_node* n)
+{
+  _nodes.push_back (n);
+}
+
+cmt_regexp_node* cmt_regexp_node_set::pop ()
+{
+  if (_nodes.size () == 0) return (&cmt_regexp_node::null ());
+  
+  int index = _nodes.size () - 1;
+  
+  cmt_regexp_node* n = _nodes[index];
+  _nodes.erase (index);
+  
+  return (n);
+}
+
+cmt_regexp_node* cmt_regexp_node_set::top () const
+{
+  if (_nodes.size () == 0) return (&cmt_regexp_node::null ());
+  
+  int index = _nodes.size () - 1;
+  
+  cmt_regexp_node* n = _nodes[index];
+  
+  return (n);
+}
+
+int cmt_regexp_node_set::nodes () const
+{
+  return (_nodes.size ());
+}
+
+const cmt_regexp_node* cmt_regexp_node_set::nodeAt (int index) const
+{
+  return (_nodes[index]);
+}
+
+bool cmt_regexp_node_set::parentheses () const
+{
+  return (_parentheses);
+}
+
+void cmt_regexp_node_set::set_parentheses (bool value)
+{
+  _parentheses = value;
+}
+
+void cmt_regexp_node_set::reduce ()
+{
+}
+
+void cmt_regexp_node_set::dump () const
+{
+  tab (); cout << "regexp_node_set (" << this << ") " << endl;
+}
+
+void cmt_regexp_node_set::dump (const cmt_string& title) const
+{
+  tab (); cout << "Set (" << this << ") father=" << _father << " pars=" << _parentheses << endl;
+  for (int i = 0; i < _nodes.size (); i++)
+    {
+      cmt_regexp_node* n = _nodes[i];
+      if (n != 0)
+	{
+	  if (i > 0)
+	    {
+	      tab (); cout << title << endl;
+	    }
+	  tab_level++;
+	  n->dump ();
+	  tab_level--;
+	}
+    }
+  tab (); cout << "EndSet (" << this << ")" << endl;
+}
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_and_node::cmt_and_node () : cmt_regexp_node_set ()
+{
+}
+
+cmt_and_node::cmt_and_node (cmt_regexp_node_set* father) : cmt_regexp_node_set (father)
+{
+}
+
+const cmt_regexp::iterator cmt_and_node::match (const cmt_string& text, 
+                                                int pos) const
+{
+  if ((pos < 0) || (pos > text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  if (_nodes.size () == 0) return (cmt_regexp::iterator (pos, 0));
+
+  int i;
+  int total = 0;
+  int p = pos;
+  
+  bool dbg = CmtSystem::testenv ("CMTTESTREGEXP");
+  if (dbg) {tab (); cout << "match and (" << this << ") pos=" << pos << endl;}
+
+  for (i = 0; i < _nodes.size (); i++)
+    {
+      cmt_regexp_node* n = _nodes[i];
+
+      if (dbg) tab_level++;
+      const cmt_regexp::iterator it = n->match (text, p);
+      if (dbg) tab_level--;
+
+      if (dbg) {tab (); cout << "  -> it(" << n << ") p=" << it._pos << " l=" << it._length << endl;}
+      
+      if (it == cmt_regexp::iterator::null ()) return (it);
+      
+      total += it._length;
+      p += it._length;
+    }
+
+    // All nodes match
+  
+  return (cmt_regexp::iterator (pos, total));
+}
+
+void cmt_and_node::reduce ()
+{
+  if (_nodes.size () < 2) return;
+  
+  char c = ' ';
+  cmt_string s = "";
+  cmt_vector<cmt_regexp_node*> new_nodes;
+
+  //
+  // We loop once too much in order to finish the possibly accumulated
+  // string at the end.
+  //
+  for (int i = 0; i <= _nodes.size (); i++)
+    {
+      cmt_regexp_node* n = 0;
+
+      if (i < _nodes.size ()) n = _nodes[i];
+
+      if ((i >= _nodes.size ()) || (!n->is_char ()))
+        {
+          if (s.size () == 1)
+            {
+              //
+              // Too bad there was only one char node to consider
+              // let's put it back as a char node !
+              //
+              new_nodes.push_back (new cmt_char_node (c));
+              s = "";
+            }
+          else if (s.size () > 1)
+            {
+              //
+              // We have real reduction here sonce there was several
+              // consecutive char nodes.
+              //
+              new_nodes.push_back (new cmt_string_node (s));
+              s = "";
+            }
+
+          if (i >= _nodes.size ()) break;
+        }
+
+      if (n->is_char ())
+        {
+          //
+          // We are now trying to compact those char nodes.
+          //
+          cmt_char_node& cn = *((cmt_char_node*) n);
+          c = (char) cn;
+          s += c;
+          delete n;
+          _nodes[i] = 0;
+        }
+      else if (n->is_many_node ())
+        {
+          cmt_many_node& mn = *((cmt_many_node*) n);
+          mn.install (*this, i + 1);
+          mn.reduce ();
+          new_nodes.push_back (n);
+          break;
+        }
+      else
+        {
+          new_nodes.push_back (n);
+        }
+    }
+  
+  _nodes = new_nodes;
+}
+
+void cmt_and_node::fill (cmt_and_node& other, int start_index)
+{
+  if ((start_index < 0) || (start_index > other.nodes ())) return;
+
+  for (int i = start_index; i < other.nodes (); i++)
+    {
+      cmt_regexp_node* n = other._nodes[i];
+      push (n);
+    }
+}
+
+void cmt_and_node::dump () const
+{
+  cmt_regexp_node_set::dump ("and");
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+cmt_or_node::cmt_or_node (cmt_regexp_node_set* father) : cmt_regexp_node_set (father)
+{
+}
+
+const cmt_regexp::iterator cmt_or_node::match (const cmt_string& text, 
+                                               int pos) const
+{
+  if ((pos < 0) || (pos >= text.size ())) 
+    {
+      return (cmt_regexp::iterator::null ());
+    }
+
+  if (_nodes.size () == 0) return (cmt_regexp::iterator (pos, 0));
+  
+  bool dbg = CmtSystem::testenv ("CMTTESTREGEXP");
+  if (dbg) {tab (); cout << "match or (" << this << ") pos=" << pos << endl;}
+
+  int i;
+
+  int longest = 0;
+
+  cmt_regexp::iterator result = cmt_regexp::iterator::null ();
+  
+  for (i = 0; i < _nodes.size (); i++)
+    {
+      const cmt_regexp_node* n = _nodes[i];
+      
+      if (dbg) tab_level++;
+      const cmt_regexp::iterator it = n->match (text, pos);
+      if (dbg) tab_level--;
+
+      if (it._length > longest)
+	{
+	  longest = it._length;
+	  result = it;
+	}
+
+        //        at least one or-ed expression matches
+      // if (it != cmt_regexp::iterator::null ()) return (it);
+    }
+  
+  return (result);
+}
+
+void cmt_or_node::dump () const
+{
+  cmt_regexp_node_set::dump ("or");
+}
+
+//----------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+//----------------------------------------------------------
+cmt_regexp::cmt_regexp ()
+{
+  _root = 0;
+}
+
+//----------------------------------------------------------
+cmt_regexp::cmt_regexp (const cmt_string& expression)
+{
+  _root = 0;
+  set (expression);
+}
+
+//----------------------------------------------------------
+void cmt_regexp::set (const cmt_string& expression)
+{
+  if (_root != 0)
+    {
+      delete _root;
+      _root = 0;
+    }
+
+    //
+    // The root is the cmt_or_node which will be returned. It is
+    // the top of the hierarchy.
+    //
+    //  top is the running cmt_and_node.
+    //
+  cmt_regexp_node_set* or_root = 0;
+  cmt_regexp_node_set* top_and = 0;
+  
+    // abcd
+    // ab|cd
+    // a|b|cd
+    // a|b*|cd
+    // a|b*|cd?e
+    //
+    // exp     : and
+    //         | exp '|' and
+    //
+    // and     : unary 
+    //         | unary and
+    //
+    // unary   : primary '*'
+    //         | primary '?'
+    //
+    // primary : '[' opt_begin opt_chars opt_end ']'
+    //         | '^'
+    //         | '$'
+    //         | char
+    //         | '(' exp ')'
+    //
+  
+  {
+      //
+      // First we build an cmt_or_node (corresponding to the
+      // first grammatical rule)
+      //
+      //  Then cmt_and_nodes are pushed into it.
+      //  and standard nodes are pushed into the running (top_and) cmt_and_node
+      //
+    or_root = new cmt_or_node (0);
+    top_and = new cmt_and_node (or_root);
+  }
+  
+  int i;
+  
+  for (i = 0; i < expression.size (); i++)
+    {
+      char c = expression[i];
+      switch (c)
+        {
+          case '[':
+          {
+              //
+              // The case is 
+              //
+              //  exp   : '['     char ... ']'
+              //  exp   : '[' '^' char ... ']'
+              //
+
+            if (i >= expression.size ()) 
+              {
+                  // syntax error : unbalanced '['
+                delete or_root;
+                return;
+              }
+            i++;
+            
+            int i0 = i;
+            
+            bool done = false;
+            bool has_not = false;
+            
+            cmt_string choices = "";
+            
+            for (; i < expression.size (); i++)
+              {
+                c = expression[i];
+                switch (c)
+                  {
+                    case ']':
+                      done = true;
+                      break;
+                    case '^':
+                      if (i == i0) has_not = true;
+                      else choices += c;
+                      break;
+                    case '\\':
+                      choices += c;
+                      if (i >= expression.size ())
+                        {
+                            // syntax error : unbalanced '[' and unfinished
+                            // escape sequence
+                          delete or_root;
+                          return;
+                        }
+                      i++;
+                      c = expression[i];
+                      choices += c;
+                      break;
+                    default:
+                      choices += c;
+                      break;
+                  }
+                if (done) break;
+              }
+            
+            if (!done)
+              {
+                  // syntax error : unbalanced '['
+                delete or_root;
+                return;
+              }
+            if (has_not)
+              top_and->push (new cmt_not_char_list_node (choices));
+            else        
+              top_and->push (new cmt_char_list_node (choices));
+          }
+          break;
+          case '*':
+          {
+              //
+              //  exp : exp '*'
+              //
+            if (top_and->nodes () == 0)
+              {
+                  // Syntax error : '*' is not preceded by an expression
+                delete or_root;
+                return;
+              }
+            
+            cmt_regexp_node* n = top_and->pop ();
+            top_and->push (new cmt_zero_more (n));
+          }
+          break;
+          case '+':
+          {
+              //
+              //  exp : exp '+'
+              //
+            if (top_and->nodes () == 0)
+              {
+                  // Syntax error : '+' is not preceded by an expression
+                delete or_root;
+                return;
+              }
+            
+            cmt_regexp_node* n = top_and->pop ();
+            top_and->push (new cmt_one_more (n));
+          }
+          break;
+          case '?':
+          {
+              //
+              //  exp : exp '?'
+              //
+            if (top_and->nodes () == 0)
+              {
+                  // Syntax error : '?' is not preceded by an expression
+                delete or_root;
+                return;
+              }
+            
+            cmt_regexp_node* n = top_and->pop ();
+            top_and->push (new cmt_zero_one (n));
+          }
+          break;
+          case '.':
+              //
+              //  exp : '.'
+              //
+            top_and->push (new cmt_any_node ());
+            break;
+          case '(':
+          {
+              //
+              //  exp : '(' exp ')'
+              //
+            if (top_and->parentheses ())
+              {
+                  // This should never happen.
+                delete or_root;
+                return;
+              }
+            
+            top_and->set_parentheses (true);
+            
+              //
+              // A new complete expression is started.
+              //  -> do as for top_and parsing.
+              //
+            
+            top_and = new cmt_and_node (new cmt_or_node (top_and));
+          }
+          break;
+          case ')':
+          {
+              //
+              //  exp : '(' exp ')'
+              //
+            
+              // top_and is the cmt_and_node into which new nodes are pushed.
+            cmt_regexp_node_set* or_node = top_and->father ();
+            if (or_node == 0) 
+              {
+                  // This should never happen : top_and should always be
+                  // at least an cmt_and_node hanging at an cmt_or_node
+                delete or_root;
+                return;
+              }
+            
+              //
+              // The last cmt_and_node was empty, thus we had either '()' or '(...|)'
+              //
+            
+            if (top_and->nodes () == 0) 
+              {
+                delete (or_node->pop ());
+              }
+            else
+              {
+                top_and->reduce ();
+              }
+            
+            top_and = or_node->father ();
+            
+            if (top_and == 0)
+              {
+                  // Syntax error : too many ')'
+                delete or_root;
+                return;
+              }
+            
+              //
+              // top_and is now the previous running cmt_and_node where the '(' 
+              // was originally met its top_and node contains the parenthesized 
+              // sub expression  If this one is empty, (due to an empty '()' 
+              // expression) then it may simply be discarded.
+              //
+            
+            if (!top_and->parentheses ())
+              {
+                  // Syntax error : too many ')'
+                delete or_root;
+                return;
+              }
+            
+            top_and->set_parentheses (false);
+            
+            cmt_regexp_node* unique = 0;
+            if (or_node->nodes () == 1)
+              {
+                cmt_regexp_node_set* and_node = (cmt_regexp_node_set*) or_node->top ();
+                if (and_node->nodes () == 1)
+                  {
+                    unique = and_node->pop ();
+                    delete (or_node->pop ());
+                  }
+                else if (and_node->nodes () == 0)
+                  {
+                    delete (or_node->pop ());
+                  }
+              }
+            
+            if (or_node->nodes () == 0) delete (top_and->pop ());
+            if (unique != 0) top_and->push (unique);
+          }
+          
+          break;
+          case '|':
+          {
+              //
+              //  exp : exp '|' exp
+              //
+
+            cmt_regexp_node_set* or_node = top_and->father ();
+            
+            top_and->reduce ();
+            
+              //
+              // or is the father cmt_or_node, which only contains cmt_and_nodes
+              //
+            
+            const cmt_regexp_node_set* and_node = (cmt_regexp_node_set*) or_node->top ();
+            if (and_node->nodes () == 0)
+              {
+                  // the previous node was empty.
+                  // we may discard it
+                or_node->pop ();
+              }
+            
+            top_and = new cmt_and_node (or_node);
+          }
+          break;
+          case '^':
+              //
+              //  exp : '^'
+              //
+            top_and->push (new cmt_begin_node ());
+            break;
+          case '$':
+              //
+              //  exp : '$'
+              //
+            top_and->push (new cmt_end_node ());
+            break;
+          case '\\':
+            if (i >= expression.size ())
+              {
+                delete or_root;
+                return;
+              }
+            i++;
+            c = expression[i];
+            switch (c)
+              {
+                case '[':
+                case ']':
+                case '(':
+                case ')':
+                case '.':
+                case '*':
+                case '?':
+                case '^':
+                case '$':
+                case '\\':
+                  break;
+                case 'r':
+                  c = '\r';
+                  break;
+                case 't':
+                  c = '\t';
+                  break;
+                case 'n':
+                  c = '\n';
+                  break;
+                default:
+                  break;
+              }
+          default:
+            top_and->push (new cmt_char_node (c));
+            break;
+        }
+    }
+  
+  if (or_root != 0)
+    {
+      cmt_regexp_node_set* and_node = (cmt_regexp_node_set*) or_root->top ();
+      
+      if (or_root->nodes () == 1)
+        {
+            //
+            // Check whether there is at least one non-empty
+            // cmt_and_node
+            //
+          if (and_node->nodes () == 0)
+            {
+              delete or_root;
+              return;
+            }
+        }
+      
+      if (and_node != 0)
+        {
+          and_node->reduce ();
+          
+          if (and_node->parentheses ())
+            {
+              delete or_root;
+              return;
+            }
+        }
+    }
+  
+  _root = or_root;
+
+  bool dbg = CmtSystem::testenv ("CMTTESTREGEXP");
+
+  if (dbg)
+    {
+      if (_root != 0)
+	{
+	  _root->dump ();
+	}
+    }
+}
+
+cmt_regexp::~cmt_regexp ()
+{
+  if (_root != 0)
+    {
+      delete _root;
+    }
+}
+
+bool cmt_regexp::is_valid () const
+{
+  if (_root != 0) return (true);
+  else return (false);
+}
+
+cmt_regexp::iterator cmt_regexp::begin (const cmt_string& text, int pos)
+{
+  if (_root != 0)
+    {
+      int i;
+      
+      for (i = pos; i < text.size (); i++)
+        {
+          cmt_regexp::iterator it = _root->match (text, i);
+          if (it != end ()) return (it);
+        }
+    }
+  
+  return (end ());
+}
+
+cmt_regexp::iterator cmt_regexp::end ()
+{
+  return (cmt_regexp::iterator::null ());
+}
+
+cmt_regexp::iterator cmt_regexp::begin (const cmt_string& text, int pos) const
+{
+  if (_root != 0)
+    {
+      int i;
+      
+      for (i = pos; i < text.size (); i++)
+        {
+          cmt_regexp::iterator it = _root->match (text, i);
+          if (it != end ()) return (it);
+        }
+    }
+  
+  return (end ());
+}
+
+cmt_regexp::iterator cmt_regexp::end () const
+{
+  return (cmt_regexp::iterator::null ());
+}
+
+bool cmt_regexp::match (const cmt_string& text) const
+{
+  iterator it = begin (text);
+  if (it == end ()) return (false);
+  else return (true);
+}
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+const cmt_regexp::iterator cmt_regexp::iterator::null ()
+{
+  static const iterator null_instance (-1, -1);
+  
+  return (null_instance);
+}
+
+cmt_regexp::iterator::iterator ()
+{
+  _pos = 0;
+  _length = 0;
+}
+
+cmt_regexp::iterator::iterator (int pos, int length)
+{
+  _pos = pos;
+  _length = length;
+}
+
+cmt_regexp::iterator::iterator (const iterator& other)
+{
+  _pos = other._pos;
+  _length = other._length;
+}
+
+int cmt_regexp::iterator::operator != (const iterator& other) const
+{
+  return ((this->_pos != other._pos) ||
+          (this->_length != other._length));
+}
+
+int cmt_regexp::iterator::operator == (const iterator& other) const
+{
+  return ((this->_pos == other._pos) &&
+          (this->_length == other._length));
+}
+
+int cmt_regexp::iterator::operator < (const iterator& other) const
+{
+  if (_pos == -1) return (0);
+  if (other._pos == -1) return (0);
+
+  return (_pos < other._pos);
+}
+
+cmt_string cmt_regexp::iterator::operator () (const cmt_string& text) const
+{
+  if (_pos == -1) return ("");
+  if (_length <= 0) return ("");
+
+  return (text.substr (_pos, _length));
+}
+
+//----------------------------------------------------------
+
Index: /CMT/v1r20/source/cmt_regexp.h
===================================================================
--- /CMT/v1r20/source/cmt_regexp.h	(revision 368)
+++ /CMT/v1r20/source/cmt_regexp.h	(revision 368)
@@ -0,0 +1,59 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_regexp_h__
+#define __cmt_regexp_h__
+
+#include "cmt_string.h"
+
+class cmt_regexp_node;
+
+class cmt_regexp
+{
+public:
+  cmt_regexp ();
+  cmt_regexp (const cmt_string& expression);
+  ~cmt_regexp ();
+
+  void set (const cmt_string& expression);
+
+  bool is_valid () const;
+  
+  class iterator
+  {
+public:
+    static const iterator null ();
+    
+public:
+    iterator ();
+    iterator (int pos, int length);
+    iterator (const iterator& other);
+    
+    int operator != (const iterator& other) const;
+    int operator == (const iterator& other) const;
+    int operator < (const iterator& other) const;
+
+    cmt_string operator () (const cmt_string& text) const;
+    
+    int _pos;
+    int _length;
+  };
+  
+  iterator begin (const cmt_string& text, int pos = 0);
+  iterator end ();
+  
+  iterator begin (const cmt_string& text, int pos = 0) const;
+  iterator end () const;
+
+  bool match (const cmt_string& text) const;
+  
+private:
+  
+  cmt_regexp_node* _root;
+};
+
+#endif
+
Index: /CMT/v1r20/source/cmt_scope_section.cxx
===================================================================
--- /CMT/v1r20/source/cmt_scope_section.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_scope_section.cxx	(revision 368)
@@ -0,0 +1,25 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_scope_section.h"
+
+ScopeSection::ScopeSection () : m_scope (ScopePublic)
+{
+}
+
+ScopeSection::ScopeSection (ScopeType scope) : m_scope (scope)
+{
+}
+
+ScopeSection::~ScopeSection ()
+{
+}
+
+ScopeType ScopeSection::get_scope () const
+{
+  return (m_scope);
+}
+
Index: /CMT/v1r20/source/cmt_scope_section.h
===================================================================
--- /CMT/v1r20/source/cmt_scope_section.h	(revision 368)
+++ /CMT/v1r20/source/cmt_scope_section.h	(revision 368)
@@ -0,0 +1,25 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_scope_section_h__
+#define __cmt_scope_section_h__
+
+#include "cmt_parser.h"
+
+class ScopeSection
+{
+public:
+  ScopeSection ();
+  ScopeSection (ScopeType scope);
+  ~ScopeSection ();
+
+  ScopeType get_scope () const;
+
+private:
+  ScopeType m_scope;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_script.cxx
===================================================================
--- /CMT/v1r20/source/cmt_script.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_script.cxx	(revision 368)
@@ -0,0 +1,225 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_script.h"
+#include "cmt_use.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Scripts                                   */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+/*----------------------------------------------------------*/
+void Script::action (const CmtSystem::cmt_string_vector& words,
+                     ScriptType type,
+                     Use* use)
+{
+  cmt_string name;
+  Script* script;
+
+  if (use == 0) use = &(Use::current());
+
+  name = words[1];
+  if (name == "") return;
+
+  script = add (name, type, use);
+}
+
+/*----------------------------------------------------------*/
+Script* Script::find (const cmt_string& name, Use* use)
+{
+  int script_index;
+
+  if (use == 0) use = &(Use::current());
+
+  if (use->scripts.size () == 0) return (0);
+
+  for (script_index = 0;
+       script_index < use->scripts.size ();
+       script_index++)
+    {
+      Script& script = use->scripts[script_index];
+
+      if (script.name == name)
+        {
+          return (&script);
+        }
+    }
+
+  return (0);
+}
+
+/*----------------------------------------------------------*/
+Script* Script::add (const cmt_string& name, ScriptType type, Use* use)
+{
+  cmt_string short_name = name;
+
+  if (use == 0) use = &(Use::current());
+
+  int pos;
+
+  pos = short_name.find (".csh");
+  if (pos != cmt_string::npos)
+    {
+      short_name.erase (pos);
+    }
+
+  pos = short_name.find (".sh");
+  if (pos != cmt_string::npos)
+    {
+      short_name.erase (pos);
+    }
+
+  {
+    Script* script;
+
+    if (short_name == "") return (0);
+    script = find (short_name, use);
+    if (script != 0)
+      {
+        script->type = type;
+        return (script);
+      }
+  }
+
+  Script& script = use->scripts.add ();
+
+  script.name = short_name;
+  script.type = type;
+
+  return (&script);
+}
+
+/*----------------------------------------------------------*/
+void Script::all_print_clean (PrintMode mode)
+{
+  int number;
+  int script_number;
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  if (uses.size () > 0)
+    {
+      for (number = 0; number < uses.size (); number++)
+        {
+          const Use* use = uses[number];
+
+	  Package* p = use->get_package ();
+          if (p->is_cmt ()) continue;
+
+          for (script_number = 0;
+               script_number < use->scripts.size ();
+               script_number++)
+            {
+              Script& script = use->scripts[script_number];
+
+              if (script.type == CleanupScript)
+                {
+                  if (script.print (mode, use)) cout << "; ";
+                }
+            }
+        }
+    }
+}
+
+/*----------------------------------------------------------*/
+void Script::all_print (PrintMode mode)
+{
+  int number;
+  int script_number;
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  if (uses.size () > 0)
+    {
+      for (number = 0; number < uses.size (); number++)
+        {
+          const Use* use = uses[number];
+
+	  Package* p = use->get_package ();
+          if (p->is_cmt ()) continue;
+
+          for (script_number = 0;
+               script_number < use->scripts.size ();
+               script_number++)
+            {
+              Script& script = use->scripts[script_number];
+
+              if (script.type == SetupScript)
+                {
+                  if (script.print (mode, use)) cout << "; ";
+                }
+            }
+        }
+    }
+
+  {
+    const Use& use = Use::current ();
+
+    for (script_number = 0;
+         script_number < use.scripts.size ();
+         script_number++)
+      {
+        Script& script = use.scripts[script_number];
+
+        if (script.type == SetupScript)
+          {
+            if (script.print (mode, &use)) cout << "; ";
+          }
+      }
+  }
+}
+
+/*----------------------------------------------------------*/
+void Script::clear_all ()
+{
+}
+
+/*----------------------------------------------------------*/
+Script::Script ()
+{
+}
+
+/*----------------------------------------------------------*/
+Script::~Script ()
+{
+}
+
+/*----------------------------------------------------------*/
+int Script::print (PrintMode mode, const Use* use)
+{
+  int result = 1;
+  cmt_string suffix;
+
+  if (name == "") return (0);
+
+  switch (mode)
+    {
+      case Csh :
+        suffix = ".csh";
+        cout << "source ";
+        break;
+      case Sh :
+        suffix = ".sh";
+        cout << ". ";
+        break;
+    }
+
+  if (name.find (SLASH) == cmt_string::npos)
+    {
+      cout << "${" << use->prefix << "ROOT}/";
+      if (use->style == cmt_style) cout << "cmt/";
+      else cout << "mgr/";
+    }
+
+  cout << name << suffix;
+
+  return (result);
+}
Index: /CMT/v1r20/source/cmt_script.h
===================================================================
--- /CMT/v1r20/source/cmt_script.h	(revision 368)
+++ /CMT/v1r20/source/cmt_script.h	(revision 368)
@@ -0,0 +1,36 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_script_h__
+#define __cmt_script_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+
+class Script
+{
+public:
+  typedef cmt_vector<Script> ScriptVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words,
+                      ScriptType type,
+                      Use* use);
+  static Script* find (const cmt_string& name, Use* use);
+  static Script* add (const cmt_string& name, ScriptType type, Use* use);
+  static void all_print_clean (PrintMode mode);
+  static void all_print (PrintMode mode);
+  static void clear_all ();
+
+public:
+  Script ();
+  ~Script ();
+  int print (PrintMode mode, const Use* use);
+
+  cmt_string name;
+  ScriptType type;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_sequence.cxx
===================================================================
--- /CMT/v1r20/source/cmt_sequence.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_sequence.cxx	(revision 368)
@@ -0,0 +1,173 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_sequence.h"
+#include "cmt_system.h"
+
+SequenceRunner::SequenceRunner ()
+{
+}
+
+void SequenceRunner::begin ()
+{
+  started = false;
+  running = false;
+  if (style == CmtSystem::getenv ("CMTSTRUCTURINGSTYLE"))
+    {
+      vdir = CmtSystem::file_separator (); 
+      vdir += "v1"; 
+    } 
+  else
+    {
+      vdir = ""; 
+    }
+  package = "";
+  filename = "";
+  buffer = "";
+  pwd = "";
+}
+
+void SequenceRunner::filter (const cmt_string& line)
+{
+    //cout << "line=[" << line << "]" << endl;
+  
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " \t", words);
+  
+  cmt_string verb;
+  
+  if (words.size () > 0) verb = words[0];
+  
+  if (verb.substr (0, 2) == "%%")
+    {
+      if (verb.substr (0, 3) == "%%%") return;
+      
+      if (running)
+        {
+          buffer.write (filename);
+	  cout << "%%Writing file " << filename << endl;
+            //cout << buffer << endl;
+          buffer = "";
+          
+          running = false;
+        }
+    }
+  
+  if (verb == "%%package")
+    {
+      package = words[1];
+      version = words[2];
+      
+      if (version == "") version = "v1";
+      
+      cmt_string command = "cmt create ";
+      command += package;
+      command += " ";
+      command += version;
+      
+      CmtSystem::execute (command);
+      cout << "%% creating package " << package << " with command [" << command << "]" << endl;
+
+      if (style == CmtSystem::getenv ("CMTSTRUCTURINGSTYLE"))
+        {
+          vdir = CmtSystem::file_separator (); 
+          vdir += version; 
+        } 
+      else
+        {
+          vdir = ""; 
+        }
+      
+      filename = package;
+      filename += vdir;
+      filename += CmtSystem::file_separator ();
+      filename += "cmt";
+      filename += CmtSystem::file_separator ();
+      filename += "requirements";
+      
+      started = true;
+    }
+  else if (verb == "%%file") 
+    {
+      cmt_string file = words[1];
+      
+      cmt_string d = package;
+      d += vdir;
+      d += CmtSystem::file_separator ();
+      d += file;
+      CmtSystem::dirname (d, d);
+      
+      CmtSystem::mkdir (d);
+      cout << "%% creating directory " << d << endl;
+
+      buffer = "";
+      
+      filename = package;
+      filename += vdir;
+      filename += CmtSystem::file_separator ();
+      filename += file; 
+      started = true;
+    }
+  else if (verb == "%%cdpackage") 
+    {
+      package = words[1];
+      
+      pwd = package;
+      pwd += vdir;
+      pwd += CmtSystem::file_separator ();
+      pwd += "cmt";
+      cout << "%% moving to package " << package << endl;
+    }
+  else if (verb == "%%cmt") 
+    {
+      cmt_string command;
+      
+      if (pwd != "")
+        {
+          command = "cd ";
+          command += pwd;
+          command += " ";
+          command += CmtSystem::command_separator ();
+          command += " ";
+        }
+      
+      command += line;
+      command.replace ("%%", "");
+      
+      cout << "%% executing cmt command " << line << endl;
+
+      CmtSystem::execute (command);
+    }
+  else
+    {
+      buffer += line;
+      buffer += "\n";
+    }
+  
+  if (started)
+    {
+      started = false;
+      running = true;
+    }
+}
+
+void SequenceRunner::end ()
+{
+  if (running)
+    {
+      if (buffer != "")
+        {
+          buffer.write (filename);
+	  cout << "%%Writing file " << filename << endl;
+            //cout << buffer << endl;
+          buffer = "";
+        }
+      running = false;
+    }
+}
+
+
Index: /CMT/v1r20/source/cmt_sequence.h
===================================================================
--- /CMT/v1r20/source/cmt_sequence.h	(revision 368)
+++ /CMT/v1r20/source/cmt_sequence.h	(revision 368)
@@ -0,0 +1,84 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_sequence_h__
+#define __cmt_sequence_h__
+
+#include "cmt_awk.h"
+
+/**
+ *  This very simplified sequence interpreter is meant for 
+ *  internal use only, for driving demo or test scenarios.
+ *   This is run as follows:
+ *
+ *      > cd ../demo
+ *      > cmt run_sequence xxx.cmt
+ *
+ *   where xxx.cmt is a text file containing descriptions of sequence steps:
+ *
+ *   sequence_step :
+ *       package-creation
+ *     | file-description
+ *     | package-access
+ *     | cmt-action
+ *     | comment
+ *
+ *   package-creation :
+ *       "%%package" <package-name> requirements-file
+ *
+ *          This creates a package from the current location, at version v1
+ *         structuration style is considered.
+ *          Requirements file follows the statement.
+ *
+ *   requirements-file :
+ *       file-contents
+ *
+ *   file-description :
+ *       "%%file" <file-path> file-contents
+ *
+ *           Create a files relatively to the last created package.
+ *
+ *   package-access :
+ *       "%%cdpackage" <package-name>
+ *
+ *           Move to the cmt directory of the specified package
+ *
+ *   cmt-action :
+ *       "%%cmt" <arguments>
+ *
+ *           Perform the specified cmt action.
+ *
+ *   file-contents :
+ *       line ...
+ *
+ *   comment :
+ *       %%% ...
+ *
+ */
+class SequenceRunner : public FAwk
+{
+public:
+
+  SequenceRunner ();
+  void begin ();
+  void filter (const cmt_string& line);
+  void end ();
+
+private:
+  bool started;
+  bool running;
+  cmt_string style;
+  cmt_string vdir;
+  cmt_string package;
+  cmt_string version;
+  cmt_string filename;
+  cmt_string buffer;
+  cmt_string pwd;
+};
+
+
+#endif
+
Index: /CMT/v1r20/source/cmt_std.h
===================================================================
--- /CMT/v1r20/source/cmt_std.h	(revision 368)
+++ /CMT/v1r20/source/cmt_std.h	(revision 368)
@@ -0,0 +1,65 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_std_h__
+#define __cmt_std_h__
+
+#ifndef WIN32
+#ifndef linux
+#ifndef __CYGWIN__
+#ifndef __APPLE__
+#define OLD_HEADERS 1
+#endif
+#endif
+#endif
+#endif
+
+#ifdef OLD_HEADERS
+
+#ifdef WIN32
+#include <ios.h>
+#include <iomanip.h>
+#endif
+#include <iostream.h>
+#include <fstream.h>
+
+#define ios_base ios
+
+#define int_type int
+
+#else
+
+#include <iomanip>
+#include <iostream>
+#include <fstream>
+
+#define cout std::cout
+#define cerr std::cerr
+#define endl std::endl
+#define ofstream std::ofstream
+#define ifstream std::ifstream
+#define istream std::istream
+#define ostream std::ostream
+#define ios std::ios
+#define ios_base std::ios_base
+#define streambuf std::streambuf
+#define setw std::setw
+
+#endif
+
+#ifdef sun
+#ifndef _BOOL
+#undef NEED_BOOL
+#define NEED_BOOL
+#endif
+#endif
+
+#ifdef NEED_BOOL
+typedef enum { false, true } bool;
+#endif
+
+#endif
Index: /CMT/v1r20/source/cmt_string.cxx
===================================================================
--- /CMT/v1r20/source/cmt_string.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_string.cxx	(revision 368)
@@ -0,0 +1,779 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "cmt_std.h"
+#include "cmt_string.h"
+
+cmt_string::cmt_string ()
+{
+  _data = 0;
+  _allocated = 0;
+  _size = 0;
+}
+
+cmt_string::cmt_string (int n)
+{
+  _data = 0;
+  _allocated = 0;
+  _size = 0;
+  allocate (n + 1);
+}
+
+cmt_string::cmt_string (char c)
+{
+  _data = 0;
+  _allocated = 0;
+  _size = 0;
+
+  allocate (2);
+
+  _data[0] = c;
+  _data[1] = 0;
+  _size = 1;
+}
+
+cmt_string::cmt_string (const char* text)
+{
+  _data = 0;
+  _allocated = 0;
+  _size = 0;
+
+  if (text != 0)
+    {
+      _size = strlen (text);
+      allocate (_size + 1);
+      strcpy (_data, text);
+    }
+}
+
+cmt_string::cmt_string (const cmt_string& other)
+{
+  const char* text = other._data;
+
+  _data = 0;
+  _allocated = 0;
+  _size = 0;
+
+  if (text != 0)
+    {
+      _size = strlen (text);
+      allocate (_size + 1);
+      strcpy (_data, text);
+    }
+}
+
+cmt_string::~cmt_string ()
+{
+  if (_data != 0)
+    {
+#ifdef CMT_USE_NEW_DELETE
+      delete[] _data;
+#else
+      free (_data);
+#endif
+    }
+  _data = 0;
+  _allocated = 0;
+  _size = 0;
+}
+
+  //
+  // Operators
+  //
+cmt_string& cmt_string::operator = (char c)
+{
+  allocate (2);
+
+  _data[0] = c;
+  _data[1] = 0;
+
+  _size = 1;
+
+  return (*this);
+}
+
+cmt_string& cmt_string::operator = (const char* text)
+{
+  if (text == _data) return (*this);
+
+  if (text != 0)
+    {
+      _size = strlen (text);
+      allocate (_size + 1);
+      strcpy (_data, text);
+    }
+  else
+    {
+      _size = 0;
+
+      if (_data != 0)
+        {
+          _data[0] = 0;
+        }
+    }
+
+  return (*this);
+}
+
+cmt_string& cmt_string::operator = (const cmt_string& other)
+{
+  const char* text = other._data;
+  cmt_string& me = *this;
+  me = text;
+  return (me);
+}
+
+cmt_string::operator const char* () const
+{
+  if (_data == 0) return ("");
+  else return (_data);
+}
+
+const char* cmt_string::c_str () const
+{
+  if (_data == 0) return ("");
+  else return (_data);
+}
+
+/*
+char* cmt_string::c_str ()
+{
+  return (_data);
+}
+*/
+
+void cmt_string::operator += (char c)
+{
+  extend (2);
+
+  char temp[2] = { c, 0 };
+
+  strcat (&_data[_size], temp);
+  _size++;
+}
+
+void cmt_string::operator += (const char* text)
+{
+  if (text == 0) return;
+
+  int s = strlen (text);
+  extend (s + 1);
+
+  strcat (&_data[_size], text);
+  _size += s;
+}
+
+void cmt_string::operator += (const cmt_string& other)
+{
+  const char* text = other._data;
+  cmt_string& me = *this;
+
+  me += text;
+}
+
+cmt_string cmt_string::operator + (char c) const
+{
+  cmt_string result (_data);
+  result += c;
+
+  return (result);
+}
+
+cmt_string cmt_string::operator + (const char* text) const
+{
+  cmt_string result (_data);
+  result += text;
+
+  return (result);
+}
+
+cmt_string cmt_string::operator + (const cmt_string& other) const
+{
+  cmt_string result (_data);
+  result += other;
+
+  return (result);
+}
+
+char cmt_string::operator [] (int index) const
+{
+  if ((_data == 0) ||
+      (index < 0) ||
+      (index >= _size))
+    {
+      return (0);
+    }
+  else
+    {
+      return (_data[index]);
+    }
+}
+
+char& cmt_string::operator [] (int index)
+{
+  if ((_data == 0) ||
+      (index < 0) ||
+      (index >= _size))
+    {
+      static char temp;
+      return (temp);
+    }
+  else
+    {
+      return (_data[index]);
+    }
+}
+
+int cmt_string::size () const
+{
+  if (_data == 0) return (0);
+  return (_size);
+}
+
+int cmt_string::size ()
+{
+  if (_data == 0) return (0);
+  return (_size);
+}
+
+void cmt_string::resize (int n)
+{
+  allocate (n + 1);
+}
+
+int cmt_string::find (char c) const
+{
+  if (_data == 0) return (npos);
+
+  char* p = strchr (_data, c);
+  if (p == 0) return (npos);
+  return (p - _data);
+}
+
+int cmt_string::find (const char* text) const
+{
+  if (_data == 0) return (npos);
+  if (text == 0) return (npos);
+
+  char* p = strstr (_data, text);
+  if (p == 0) return (npos);
+  return (p - _data);
+}
+
+int cmt_string::find (const cmt_string& other) const
+{
+  const char* text = other._data;
+  return (find (text));
+}
+
+int cmt_string::find (int pos, char c) const
+{
+  if (_data == 0) return (npos);
+  if (pos < 0) return (npos);
+  if (pos >= _size) return (npos);
+
+  char* p = strchr (&_data[pos], c);
+  if (p == 0) return (npos);
+  return (p - _data);
+}
+
+int cmt_string::find (int pos, const char* text) const
+{
+  if (_data == 0) return (npos);
+  if (text == 0) return (npos);
+  if (pos < 0) return (npos);
+  if (pos >= _size) return (npos);
+
+  char* p = strstr (&_data[pos], text);
+  if (p == 0) return (npos);
+  return (p - _data);
+}
+
+int cmt_string::find (int pos, const cmt_string& other) const
+{
+  const char* text = other._data;
+  return (find (pos, text));
+}
+
+int cmt_string::find_last_of (char c) const
+{
+  if (_data == 0) return (npos);
+
+  char* p = strrchr (_data, c);
+  if (p == 0) return (npos);
+  return (p - _data);
+}
+
+int cmt_string::find_last_of (const char* text) const
+{
+  if (_data == 0) return (npos);
+  if (text == 0) return (npos);
+
+  char* ptr = _data;
+  char* last = 0;
+  char* p;
+  while ((p = strstr (ptr, text)) != 0)
+    {
+      last = p;
+      ptr = p + 1;
+    }
+  if (last == 0) return (npos);
+  return (last - _data);
+}
+
+int cmt_string::find_last_of (const cmt_string& other) const
+{
+  const char* text = other._data;
+  return (find_last_of (text));
+}
+
+void cmt_string::erase (int pos)
+{
+  if ((_data == 0) ||
+      (pos < 0) ||
+      (pos >= _size))
+    {
+      return;
+    }
+  else
+    {
+      _data[pos] = 0;
+      _size = pos;
+    }
+}
+
+void cmt_string::erase (int pos, int length)
+{
+  if ((_data == 0) ||
+      (pos < 0) ||
+      (pos >= _size))
+    {
+      return;
+    }
+  else
+    {
+      if ((pos + length) >= _size)
+        {
+          _data[pos] = 0;
+          _size = pos;
+        }
+      else if (length > 0)
+        {
+          char* d = &_data[pos];
+	  char* s = &_data[pos + length];
+	  for (;;)
+            {
+              *d = *s;
+	      if (*s == 0) break;
+	      d++;
+	      s++;
+	    }
+          _size -= length;
+        }
+    }
+}
+
+
+void cmt_string::replace (const char* pattern, const char* replacement)
+{
+  if (_data == 0) return;
+  if (_size == 0) return;
+  if (pattern == 0) return;
+
+  if (replacement == 0) replacement = "";
+
+  if (pattern[0] == 0) return;
+
+  int pattern_length = strlen (pattern);
+
+  int replacement_length = strlen (replacement);
+  int delta = replacement_length - pattern_length;
+
+  int pos;
+
+  if ((pos = find (pattern)) != npos)
+    {
+      if (delta > 0)
+        {
+            // string will be enlarged
+          extend (delta);
+
+          char* src = &_data[_size];
+          char* dest = src + delta;
+          while (src > &_data[pos])
+            {
+              *dest = *src;
+              src--;
+              dest--;
+            }
+        }
+      else if (delta < 0)
+        {
+            // string will be shortened
+
+          char* src = &_data[pos + pattern_length];
+          char* dest = src + delta;
+          while (*src != 0)
+            {
+              *dest = *src;
+              src++;
+              dest++;
+            }
+          *dest = *src;
+        }
+
+      strncpy (&_data[pos], replacement, replacement_length);
+
+      _size += delta;
+    }
+}
+
+void cmt_string::replace (const cmt_string& pattern,
+                          const cmt_string& replacement)
+{
+  const char* p_text = pattern._data;
+  const char* r_text = replacement._data;
+  cmt_string& me = *this;
+
+  me.replace (p_text, r_text);
+}
+
+void cmt_string::replace_all (const char* pattern, const char* replacement)
+{
+  if (_data == 0) return;
+  if (_size == 0) return;
+  if (pattern == 0) return;
+
+  if (replacement == 0) replacement = "";
+
+  if (pattern[0] == 0) return;
+
+  int pattern_length = strlen (pattern);
+
+  int replacement_length = strlen (replacement);
+  int delta = replacement_length - pattern_length;
+
+  int pos = 0;
+
+  while ((pos = find (pos, pattern)) != npos)
+    {
+      if (delta > 0)
+        {
+            // string will be enlarged
+          extend (delta);
+
+          char* src = &_data[_size];
+          char* dest = src + delta;
+          while (src > &_data[pos])
+            {
+              *dest = *src;
+              src--;
+              dest--;
+            }
+        }
+      else if (delta < 0)
+        {
+            // string will be shortened
+
+          char* src = &_data[pos + pattern_length];
+          char* dest = src + delta;
+          while (*src != 0)
+            {
+              *dest = *src;
+              src++;
+              dest++;
+            }
+          *dest = *src;
+        }
+
+      strncpy (&_data[pos], replacement, replacement_length);
+      pos += replacement_length;
+      _size += delta;
+    }
+}
+
+void cmt_string::replace_all (const cmt_string& pattern,
+                              const cmt_string& replacement)
+{
+  const char* p_text = pattern._data;
+  const char* r_text = replacement._data;
+  cmt_string& me = *this;
+
+  me.replace_all (p_text, r_text);
+}
+
+void cmt_string::trim ()
+{
+  if (size () == 0) return;
+
+  int i = 0;
+
+  i = strspn (_data, " \t");
+  if (i > 0) erase (0, i);
+
+  for (i = _size - 1; i >= 0; i--)
+    {
+      char c = _data[i];
+      if ((c == ' ') || (c == '\t')) continue;
+      erase (i + 1);
+      break;
+    }
+}
+
+cmt_string cmt_string::substr (int pos) const
+{
+  if ((_data == 0) ||
+      (pos < 0) ||
+      (pos >= _size))
+    {
+      return ((cmt_string) "");
+    }
+  else
+    {
+      return ((cmt_string) &_data[pos]);
+    }
+}
+
+cmt_string cmt_string::substr (int pos, int length) const
+{
+  if ((_data == 0) ||
+      (pos < 0) ||
+      (pos >= _size))
+    {
+      return ((cmt_string) "");
+    }
+  else
+    {
+      cmt_string result (&_data[pos]);
+      result.erase (length);
+      return (result);
+    }
+}
+
+void cmt_string::substr (int pos, cmt_string& dest) const
+{
+  if ((_data == 0) ||
+      (pos < 0) ||
+      (pos >= _size))
+    {
+      dest = "";
+    }
+  else
+    {
+      dest = (const char*) &_data[pos];
+    }
+}
+
+void cmt_string::substr (int pos, int length, cmt_string& dest) const
+{
+  if ((_data == 0) ||
+      (pos < 0) ||
+      (pos >= _size))
+    {
+      dest = "";
+    }
+  else
+    {
+      dest = (const char*) &_data[pos];
+      dest.erase (length);
+    }
+}
+
+bool cmt_string::operator < (const char* text) const
+{
+  if (text == 0) return (false);
+  if (_data == 0) return (false);
+
+  if (strcmp (_data, text) < 0) return (true);
+  return (false);
+}
+
+bool cmt_string::operator < (const cmt_string& other) const
+{
+  const char* text = other._data;
+  const cmt_string& me = *this;
+
+  return (me < text);
+}
+
+bool cmt_string::operator == (const char* text) const
+{
+  if (text == 0)
+    {
+      if (_data == 0) return (true);
+      if (_size == 0) return (true);
+      return (false);
+    }
+  if (_data == 0)
+    {
+      if (text == 0) return (true);
+      if (text[0] == 0) return (true);
+      return (false);
+    }
+
+  if (strcmp (_data, text) == 0) return (true);
+  return (false);
+}
+
+bool cmt_string::operator == (const cmt_string& other) const
+{
+  const char* text = other._data;
+  const cmt_string& me = *this;
+
+  return (me == text);
+}
+
+bool cmt_string::operator != (const char* text) const
+{
+  const cmt_string& me = *this;
+
+  if (!(me == text)) return (true);
+  return (false);
+}
+
+bool cmt_string::operator != (const cmt_string& other) const
+{
+  const char* text = other._data;
+  const cmt_string& me = *this;
+
+  return (me != text);
+}
+
+bool cmt_string::operator > (const char* text) const
+{
+  if (text == 0) return (false);
+  if (_data == 0) return (false);
+
+  if (strcmp (_data, text) > 0) return (true);
+  return (false);
+}
+
+bool cmt_string::operator > (const cmt_string& other) const
+{
+  const char* text = other._data;
+  const cmt_string& me = *this;
+
+  return (me > text);
+}
+
+void cmt_string::extend (int n)
+{
+  if (_data != 0) n += _size;
+  allocate (n);
+}
+
+void cmt_string::allocate (int n)
+{
+  if ((n + 1) > _allocated)
+    {
+      static const int quantum = 128;
+      int frames = ((n + 1)/quantum) + 1;
+      _allocated = frames * quantum;
+
+#ifdef CMT_USE_NEW_DELETE
+      char* new_data = new char [_allocated + 1];
+#else
+      char* new_data = (char*) malloc (_allocated + 1);
+#endif
+
+
+      if (_data != 0)
+        {
+          strcpy (new_data, _data);
+
+#ifdef CMT_USE_NEW_DELETE
+          delete[] _data;
+#else
+          free (_data);
+#endif
+
+          _data = new_data;
+        }
+      else
+        {
+          new_data[0] = 0;
+        }
+
+      _data = new_data;
+    }
+}
+
+ostream& operator << (ostream& o, const cmt_string& s)
+{
+  o << (const char*) s;
+  return (o);
+}
+
+cmt_string operator + (const char* text, const cmt_string& s)
+{
+  cmt_string result = text;
+  result += s;
+  return (result);
+}
+
+cmt_string operator + (char c, const cmt_string& s)
+{
+  cmt_string result = c;
+  result += s;
+  return (result);
+}
+
+bool cmt_string::read (const cmt_string& file_name)
+{
+  FILE* f = fopen (file_name.c_str (), "rb");
+  if (f != NULL)
+    {
+      fseek (f, 0L, SEEK_END);
+      int size = ftell (f);
+      fseek (f, 0L, SEEK_SET);
+
+      allocate (size + 1);
+
+      fread (&_data[0], size, 1, f);
+
+      _data[size] = 0;
+      _size = size;
+
+      fclose (f);
+
+      return (true);
+    }
+  else
+    {
+      cmt_string& me = *this;
+      me = "";
+
+      return (false);
+    }
+}
+
+bool cmt_string::write (const cmt_string& file_name) const
+{
+  FILE* f = fopen (file_name.c_str (), "wb");
+  if (f != NULL)
+    {
+      write (f);
+      fclose (f);
+      return (true);
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+void cmt_string::write (FILE* f) const
+{
+  fwrite (&_data[0], size (), 1, f);
+}
+
+void cmt_string::write (ostream& output)
+{
+  output.write (&_data[0], size ());
+}
+
Index: /CMT/v1r20/source/cmt_string.h
===================================================================
--- /CMT/v1r20/source/cmt_string.h	(revision 368)
+++ /CMT/v1r20/source/cmt_string.h	(revision 368)
@@ -0,0 +1,119 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_string_h__
+#define __cmt_string_h__
+
+#include <stdio.h>
+#include <string.h>
+
+class cmt_string
+{
+public:
+  typedef enum
+    {
+      npos = -1
+    } pos_type;
+
+    //
+    // Constructors
+    //
+  cmt_string ();
+  cmt_string (int n);
+  cmt_string (char c);
+  cmt_string (const char* text);
+  cmt_string (const cmt_string& other);
+  ~cmt_string ();
+
+    //
+    // Operators
+    //
+  cmt_string& operator = (char c);
+  cmt_string& operator = (const char* text);
+  cmt_string& operator = (const cmt_string& other);
+
+  bool read (const cmt_string& file_name);
+  bool write (const cmt_string& file_name) const;
+  void write (FILE* f) const;
+  void write (ostream& output);
+
+  operator const char* () const;
+
+  const char* c_str () const;
+  /*char* c_str (); */
+
+  void operator += (char c);
+  void operator += (const char* text);
+  void operator += (const cmt_string& other);
+
+  cmt_string operator + (char c) const;
+  cmt_string operator + (const char* text) const;
+  cmt_string operator + (const cmt_string& other) const;
+
+  char operator [] (int index) const;
+  char& operator [] (int index);
+
+  int size () const;
+  int size ();
+  void resize (int n);
+
+  int find (char c) const;
+  int find (const char* text) const;
+  int find (const cmt_string& other) const;
+  int find (int pos, char c) const;
+  int find (int pos, const char* text) const;
+  int find (int pos, const cmt_string& other) const;
+
+  int find_last_of (char c) const;
+  int find_last_of (const char* text) const;
+  int find_last_of (const cmt_string& other) const;
+
+  void erase (int pos);
+  void erase (int pos, int length);
+
+  void replace (const char* pattern, const char* replacement);
+  void replace (const cmt_string& pattern, const cmt_string& replacement);
+
+  void replace_all (const char* pattern, const char* replacement);
+  void replace_all (const cmt_string& pattern, const cmt_string& replacement);
+
+  void trim ();
+
+  cmt_string substr (int pos) const;
+  cmt_string substr (int pos, int length) const;
+
+  void substr (int pos, cmt_string& dest) const;
+  void substr (int pos, int length, cmt_string& dest) const;
+
+  bool operator < (const char* text) const;
+  bool operator < (const cmt_string& other) const;
+
+  bool operator == (const char* text) const;
+  bool operator == (const cmt_string& other) const;
+
+  bool compare_no_case (const char* text) const;
+  bool compare_no_case (const cmt_string& other) const;
+
+  bool operator != (const char* text) const;
+  bool operator != (const cmt_string& other) const;
+
+  bool operator > (const char* text) const;
+  bool operator > (const cmt_string& other) const;
+
+private:
+  void extend (int n);
+  void allocate (int n);
+
+  char* _data;
+  int _allocated;
+  int _size;
+};
+
+ostream& operator << (ostream& o, const cmt_string& s);
+cmt_string operator + (const char* text, const cmt_string& s);
+cmt_string operator + (char c, const cmt_string& s);
+
+#endif
Index: /CMT/v1r20/source/cmt_symbol.cxx
===================================================================
--- /CMT/v1r20/source/cmt_symbol.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_symbol.cxx	(revision 368)
@@ -0,0 +1,2985 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+#include "cmt_system.h"
+#include "cmt_database.h"
+
+// Global inhibitor of any display
+bool Symbol::m_inhibit_display = false;
+
+//-------------------------------------------------------------
+class SetBuilder : public ValueBuilder
+{
+public:
+  const cmt_string build (const Symbol& symbol,
+                          const cmt_string& tag_name = "");
+  const cmt_string clean (const Symbol& symbol,
+                          const cmt_string& tag_name = "")
+      {
+        static const cmt_string empty = "";
+        return (empty);
+      }
+};
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
+class PathBuilder : public ValueBuilder
+{
+public:
+  const cmt_string build (const Symbol& symbol,
+                          const cmt_string& tag_name = "");
+  const cmt_string clean (const Symbol& symbol,
+                          const cmt_string& tag_name = "");
+};
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
+class MacroBuilder : public ValueBuilder
+{
+public:
+  const cmt_string build (const Symbol& symbol,
+                          const cmt_string& tag_name = "");
+  const cmt_string clean (const Symbol& symbol,
+                          const cmt_string& tag_name = "")
+      {
+        static const cmt_string empty = "";
+        return (empty);
+      }
+};
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
+class ScriptBuilder : public ValueBuilder
+{
+public:
+  const cmt_string build (const Symbol& symbol,
+                          const cmt_string& tag_name = "");
+  const cmt_string clean (const Symbol& symbol,
+                          const cmt_string& tag_name = "")
+      {
+        static const cmt_string empty = "";
+        return (empty);
+      }
+};
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
+class ActionBuilder : public ValueBuilder
+{
+public:
+  const cmt_string build (const Symbol& symbol,
+                          const cmt_string& tag_name = "");
+  const cmt_string clean (const Symbol& symbol,
+                          const cmt_string& tag_name = "")
+      {
+        static const cmt_string empty = "";
+        return (empty);
+      }
+};
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
+class symbol_marker
+{
+public:
+  symbol_marker ()
+  {
+    ptr = cmt_string::npos;
+    pattern = 0;
+    intro = 0;
+  }
+
+  symbol_marker (int a_ptr, char a_pattern, int a_intro)
+  {
+    ptr = a_ptr;
+    pattern = a_pattern;
+    intro = a_intro;
+  }
+
+  symbol_marker (const symbol_marker& other)
+  {
+    ptr = other.ptr;
+    pattern = other.pattern;
+    intro = other.intro;
+  }
+
+  void set (int a_ptr, char a_pattern, int a_intro)
+  {
+    ptr = a_ptr;
+    pattern = a_pattern;
+    intro = a_intro;
+  }
+
+  static symbol_marker& get_lowest (symbol_marker markers[], int count)
+  {
+    static symbol_marker result;
+    int real_count = 0;
+    int i;
+
+      // Check that at least one marker has result
+
+    for (i = 0; i < count; i++)
+      {
+        if (markers[i].ptr != cmt_string::npos) real_count++;
+      }
+
+    if (real_count == 0) return (result);
+
+    // since we've passed the previous test, 
+    // at least one entry is not npos.
+    // Now discards other npos by moving them to the end
+    
+    for (i = 0; i < count;)
+      {
+        if (markers[i].ptr == cmt_string::npos)
+          {
+            markers[i] = markers[count-1];
+            count--;
+            if (count == 0) break;
+          }
+        else
+          {
+            i++;
+          }
+      }
+    
+    if (count == 0) return (result);
+    
+    // now all entries in [0, count-1] are not npos
+    // let's sort the lowest one in [0]
+    
+    for (i = 1; i < count;)
+      {
+        if (markers[0].ptr > markers[i].ptr)
+          {
+            symbol_marker temp = markers[0];
+            markers[0] = markers[i];
+            markers[i] = temp;
+            i = 1;
+          }
+        else
+          {
+            i++;
+          }
+      }
+    
+    return (markers[0]);
+  }
+
+  int ptr;
+  char pattern;
+  int intro;
+};
+//-------------------------------------------------------------
+
+/**
+
+   Attempt to substitute all occurrences of
+
+      ${<symbol_name>}
+      $(<symbol_name>)
+      %<symbol_name>%    [on Windows only]
+
+      by the specified value in the given text.
+
+    This is for one symbol only
+
+ */
+static void resolve_value (cmt_string& text,
+                           const cmt_string& symbol_name,
+                           const cmt_string& value)
+{
+  static cmt_string pattern;
+
+  pattern = "${";
+  pattern += symbol_name;
+  pattern += "}";
+
+  text.replace_all (pattern, value);
+
+  pattern = "$(";
+  pattern += symbol_name;
+  pattern += ")";
+
+  text.replace_all (pattern, value);
+
+#ifdef WIN32
+  pattern = "%";
+  pattern += symbol_name;
+  pattern += "%";
+
+  text.replace_all (pattern, value);
+#endif
+}
+
+/**
+
+   Attempt to substitute into the specified text all occurrences of
+
+      ${xxx}
+      $(xxx)
+      `xxx`
+      %xxx%    [on Windows only]
+
+      by the appropriate value:
+
+        for `xxx` : 
+
+            xxx is considered as a shell command. Value is the result of its execution
+
+        for other patterns:
+
+            if xxx is a symbol name, its value is substituted to the pattern
+            otherwise, xxx is tried as an environment variable
+
+
+     ===> In all cases, the pattern is filtered away.
+
+
+ */
+static void resolve_value (cmt_string& text)
+{
+  //static cmt_regexp reg ("[$%`]");
+
+  //if (!reg.match (text)) return;
+
+  cmt_string pattern;
+  cmt_string symbol_name;
+  char end_pattern;
+
+  int start = 0;
+
+  for (;;)
+    {
+      int begin;
+      int end;
+
+      symbol_marker markers[4];
+      int num = 0;
+
+      markers[num].set (text.find (start, "$("), ')', 2); num++;
+      markers[num].set (text.find (start, "${"), '}', 2); num++;
+      markers[num].set (text.find (start, "`"), '`', 1); num++;
+
+#ifdef WIN32
+      markers[num].set (text.find (start, "%"), '%', 1); num++;
+#endif
+
+      // Find the first matching pattern
+
+      symbol_marker& marker = symbol_marker::get_lowest (markers, num);
+
+      begin = marker.ptr;
+
+      if (begin == cmt_string::npos) break;
+
+      end_pattern = marker.pattern;
+      start = begin + marker.intro;
+
+      end = text.find (start, end_pattern);
+      if (end == cmt_string::npos)
+        {
+          // The pattern is a fake one (no ending!)
+          start++;
+          continue;
+        }
+
+      // This should never happen...
+      if (end < begin) break;
+
+      // Extract the complete pattern
+      text.substr (begin, end - begin + 1, pattern);
+
+      // Then only the symbol name
+      text.substr (begin + marker.intro, end - begin - marker.intro, symbol_name);
+
+      if (text[begin] == '`')
+        {
+          cmt_string command = symbol_name;
+          resolve_value (command);
+
+            // The value is a shell command that first needs
+            // to be applied. The output of the command is then substituted
+
+          cmt_string result;
+
+          Symbol::all_set ();
+          CmtSystem::execute (command, result);
+          
+          int pos;
+          pos = result.find ('\n');
+          if (pos != cmt_string::npos) result.erase (pos);
+          pos = result.find ('\r');
+          if (pos != cmt_string::npos) result.erase (pos);
+          
+          if (Cmt::get_debug ())
+            {
+              cout << "   Executing [" << command << "] to expand a symbol value =>[" 
+                   << result << "]" << endl;
+            }
+          
+          text.replace_all (pattern, result);
+
+          // The substitution will restart from the same place
+          // allowing for recursive replacements
+          start = begin;
+        }
+      else
+        {
+          Symbol* symbol = Symbol::find (symbol_name);
+          if (symbol != 0)
+            {
+                // Symbol found
+              cmt_string value = symbol->resolve_macro_value ();
+              text.replace_all (pattern, value);
+              
+                // The substitution will restart from the same place
+                // allowing for recursive replacements
+              start = begin;
+            }
+          else
+            {
+                // Symbol not found. Look for env. variable
+              cmt_string value = CmtSystem::getenv (symbol_name);
+              
+                // When the env. variable is not defined, the replacement is empty
+                // thus all $(xxx) ${xxx} %xxx% patterns are always filtered away.
+              text.replace_all (pattern, value);
+              
+                // The substitution will restart from the same place
+                // allowing for recursive replacements
+              start = begin;
+            }
+        }
+    }
+}
+
+/**
+
+   Attempt to substitute all occurrences of
+
+      ${xxx}
+      $(xxx)
+      `xxx`
+      %xxx%    [on Windows only]
+
+      by the appropriate value:
+
+        for `xxx` : 
+
+            xxx is considered as a shell command. Value is the result of its execution
+
+        for other patterns:
+
+            if xxx is a macro name, its value is substituted to the pattern
+
+            if xxx is a set or a path, it is kept in place (after fixing the pattern
+            according to the OS style)
+
+            otherwise it is simply kept in place
+
+ */
+static void resolve_value_for_macros (cmt_string& text)
+{
+  cmt_string pattern;
+  cmt_string symbol_name;
+  char end_pattern;
+
+  int start = 0;
+
+  for (;;)
+    {
+      //
+      // Try and substitute all ${xxx} $(xxx) or %xxx% patterns
+      // using symbol values, only when the symbol is a macro.
+      //
+
+      int begin;
+      int end;
+
+      symbol_marker markers[4];
+      int num = 0;
+
+      markers[num].set (text.find (start, "$("), ')', 2); num++;
+      markers[num].set (text.find (start, "${"), '}', 2); num++;
+
+#ifdef WIN32
+      markers[num].set (text.find (start, "%"), '%', 1); num++;
+#endif
+
+      markers[num].set (text.find (start, "`"), '`', 1); num++;
+
+      // Find the first of three patterns
+
+      symbol_marker& marker = symbol_marker::get_lowest (markers, num);
+
+      begin = marker.ptr;
+
+      if (begin == cmt_string::npos) break;
+
+      end_pattern = marker.pattern;
+      start = begin + marker.intro;
+
+      end = text.find (start, end_pattern);
+      if (end == cmt_string::npos)
+        {
+          // The pattern is a fake one (no ending!)
+          start++;
+          continue;
+        }
+
+      // This should never happen...
+      if (end < begin) break;
+
+      // Extract the complete pattern
+      text.substr (begin, end - begin + 1, pattern);
+
+      // Then only the macro name
+      text.substr (begin + marker.intro, end - begin - marker.intro, symbol_name);
+
+      if (text[begin] == '`')
+        {
+          cmt_string command = symbol_name;
+          resolve_value (command);
+
+            // The macro value is a shell command that first needs
+            // to be applied. The output of the command is substituted
+
+          cmt_string result;
+
+          Symbol::all_set ();
+          CmtSystem::execute (command, result);
+          
+          int pos;
+          pos = result.find ('\n');
+          if (pos != cmt_string::npos) result.erase (pos);
+          pos = result.find ('\r');
+          if (pos != cmt_string::npos) result.erase (pos);
+          
+          if (Cmt::get_debug ())
+            {
+              cout << "   Executing [" << command << "] to expand a macro value =>[" 
+                   << result << "]" << endl;
+            }
+          
+          text.replace_all (pattern, result);
+
+          // The substitution will restart from the same place
+          // allowing for recursive replacements
+          start = begin;
+        }
+      else
+        {
+          Symbol* macro = Symbol::find (symbol_name);
+          if ((macro != 0) && 
+              (macro->type == Symbol::SymbolMacro))
+            {
+                // Macro found
+              cmt_string value = macro->resolve_macro_value ();
+              text.replace_all (pattern, value);
+
+                // The substitution will restart from the same place
+                // allowing for recursive replacements
+              start = begin;
+            }
+          else if ((macro == 0) || 
+                   ((macro->type == Symbol::SymbolSet) || (macro->type == Symbol::SymbolPath)))
+            {
+                // Set found
+                // ensure that the delimiters will match the OS dependent
+                // delimiters.
+              
+              cmt_string pattern_close = marker.pattern;
+              
+              if (pattern_close != CmtSystem::ev_close ())
+                {
+                  cmt_string new_pattern;
+                  
+                  new_pattern = CmtSystem::ev_open ();
+                  new_pattern += symbol_name;
+                  new_pattern += CmtSystem::ev_close ();
+                  
+                  text.replace (pattern, new_pattern);
+                }
+              
+              start = end + 1;
+            }
+          else
+            {
+              start = end + 1;
+            }
+        }
+    }
+}
+
+/**
+
+   This function suppress all OS delimiters ie ${ } or % % and replaces them
+   by the pure macro delimiters $( )
+
+   `xxx` pattern is replaced by the result of the execution of the command
+
+ */
+static void suppress_OS_delimiters (cmt_string& text)
+{
+  cmt_string pattern;
+  cmt_string symbol_name;
+  char end_pattern;
+
+  int start = 0;
+
+  for (;;)
+    {
+      int begin;
+      int end;
+
+      symbol_marker markers[3];
+      int num = 0;
+
+      markers[num].set (text.find (start, "${"), '}', 2); num++;
+      markers[num].set (text.find (start, "`"), '`', 1); num++;
+
+#ifdef WIN32
+      markers[num].set (text.find (start, "%"), '%', 1); num++;
+#endif
+
+      // Find the first of three patterns
+
+      symbol_marker& marker = symbol_marker::get_lowest (markers, num);
+
+      begin = marker.ptr;
+
+      if (begin == cmt_string::npos) break;
+
+      end_pattern = marker.pattern;
+      start = begin + marker.intro;
+
+      end = text.find (start, end_pattern);
+      if (end == cmt_string::npos)
+        {
+          // The pattern is a fake one (no ending!)
+          start++;
+          continue;
+        }
+
+      // This should never happen...
+      if (end < begin) break;
+
+      // Extract the complete pattern
+      text.substr (begin, end - begin + 1, pattern);
+
+      // Then only the macro name
+      text.substr (begin + marker.intro, end - begin - marker.intro, symbol_name);
+
+      if (text[begin] == '`')
+        {
+          cmt_string command = symbol_name;
+          resolve_value (command);
+
+            // The macro value is a shell command that first needs
+            // to be applied. The output of the command is substituted
+
+          cmt_string result;
+
+          Symbol::all_set ();
+          CmtSystem::execute (command, result);
+          
+          int pos;
+          pos = result.find ('\n');
+          if (pos != cmt_string::npos) result.erase (pos);
+          pos = result.find ('\r');
+          if (pos != cmt_string::npos) result.erase (pos);
+          
+          if (Cmt::get_debug ())
+            {
+              cout << "   Executing [" << command << "] to expand a macro value =>[" 
+                   << result << "]" << endl;
+            }
+          
+          text.replace_all (pattern, result);
+
+          // The substitution will restart from the same place
+          // allowing for recursive replacements
+          start = begin;
+        }
+      else
+        {
+          cmt_string new_pattern;
+
+          new_pattern = "$(";
+          new_pattern += symbol_name;
+          new_pattern += ")";
+
+          text.replace (pattern, new_pattern);
+
+          start = begin;
+        }
+    }
+}
+
+//-------------------------------------------------------------
+/*                                                          */
+/*  Operations on SymbolValues                              */
+/*                                                          */
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
+SymbolValue::SymbolValue ()
+{
+  tag = 0;
+}
+
+//-------------------------------------------------------------
+SymbolValue::~SymbolValue ()
+{
+  tag = 0;
+}
+
+//-------------------------------------------------------------
+/*                                                          */
+/*  Operations on Symbols                                   */
+/*                                                          */
+//-------------------------------------------------------------
+
+//-------------------------------------------------------------
+Symbol* Symbol::create (const cmt_string& name,
+                        CommandType command,
+                        Use* use)
+{
+  static SetBuilder Set;
+  static PathBuilder Path;
+  static MacroBuilder Macro;
+  static ScriptBuilder Script;
+  static ActionBuilder Action;
+
+  static SymbolVector& Symbols = symbols ();
+  static SymbolMap& SymbolMap = symbol_map ();
+
+  SymbolType type = SymbolUndefined;
+
+  switch (command)
+    {
+    case CommandSet:
+    case CommandSetAppend:
+    case CommandSetPrepend:
+    case CommandSetRemove:
+    case CommandSetRemoveRegexp:
+      type = SymbolSet;
+      break;
+    case CommandPath:
+    case CommandPathAppend:
+    case CommandPathPrepend:
+    case CommandPathRemove:
+    case CommandPathRemoveRegexp:
+      type = SymbolPath;
+      break;
+    case CommandMacro:
+    case CommandMacroAppend:
+    case CommandMacroPrepend:
+    case CommandMacroRemove:
+    case CommandMacroRemoveRegexp:
+    case CommandMacroRemoveAll:
+    case CommandMacroRemoveAllRegexp:
+      type = SymbolMacro;
+      break;
+    case CommandAction:
+      type = SymbolAction;
+      break;
+    case CommandAlias:
+      type = SymbolAlias;
+      break;
+    case CommandSetupScript:
+      type = SymbolSetupScript;
+      break;
+    case CommandCleanupScript:
+      type = SymbolCleanupScript;
+      break;
+    }
+
+  {
+    Symbol* symbol;
+
+    symbol = find (name);
+    if (symbol != 0) 
+      {
+        if (symbol->type != type)
+          {
+            ActionType action = Cmt::get_action ();
+
+            if ((!Cmt::get_quiet ()) &&
+                (action != action_build_tag_makefile))
+              {
+                cmt_string s1;
+                cmt_string s2;
+
+                switch (symbol->type)
+                  {
+                  case SymbolSet:
+                    s1 = "set";
+                    break;
+                  case SymbolPath:
+                    s1 = "path";
+                    break;
+                  case SymbolMacro:
+                    s1 = "macro";
+                    break;
+                  case SymbolSetupScript:
+                    s1 = "setup_script";
+                    break;
+                  case SymbolCleanupScript:
+                    s1 = "cleanup_script";
+                    break;
+                  case SymbolAction:
+                    s1 = "action";
+                    break;
+                  case SymbolAlias:
+                    s1 = "alias";
+                    break;
+                  } 
+
+                switch (type)
+                  {
+                  case SymbolSet:
+                    s2 = "set";   
+                    break;
+                  case SymbolPath:
+                    s2 = "path";   
+                    break;
+                  case SymbolMacro:
+                    s2 = "macro";   
+                    break;
+                  case SymbolSetupScript:
+                    s2 = "setup_script";  
+                    break;
+                  case SymbolCleanupScript:
+                    s2 = "cleanup_script";  
+                    break;
+                  case SymbolAction:
+                    s2 = "action";
+                    break;
+                  case SymbolAlias:
+                    s2 = "alias";
+                    break;
+                  } 
+
+                cerr << "#CMT> Warning: Symbol " << name 
+                     << " inconsistently redeclared from " << s1 << " to " << s2;
+                if (use != 0) cerr << " in package " << use->get_package_name ();
+                cerr << endl;
+              }
+          }
+
+        return (symbol);
+      }
+  }
+
+  Symbol& symbol = Symbols.add ();
+  SymbolMap.add (name, symbol);
+
+  symbol.name  = name;
+  symbol.scope = use->get_current_scope ();
+  symbol.type  = type;
+
+  symbol.value_lists.clear ();
+
+  switch (type)
+    {
+    case SymbolSet:
+      symbol.builder = &Set;
+      break;
+    case SymbolPath:
+      symbol.builder = &Path;
+      break;
+    case SymbolAlias:
+      symbol.builder = &Set;
+      break;
+    case SymbolMacro:
+      symbol.builder = &Macro;
+      break;
+    case SymbolSetupScript:
+    case SymbolCleanupScript:
+      symbol.builder = &Script;
+      break;
+    case SymbolAction:
+      symbol.builder = &Action;
+      break;
+    }
+
+  symbol.selected_value = -1;
+
+  return (&symbol);
+}
+
+//-------------------------------------------------------------
+Symbol* Symbol::find (const cmt_string& name)
+{
+  static SymbolMap& SymbolMap = symbol_map ();
+
+  Symbol* result = 0;
+
+  result = SymbolMap.find (name);
+
+  return (result);
+}
+
+//-------------------------------------------------------------
+int Symbol::symbol_number ()
+{
+  static SymbolVector& Symbols = symbols ();
+
+  return (Symbols.size ());
+}
+
+//-------------------------------------------------------------
+Symbol::SymbolVector& Symbol::symbols ()
+{
+  static Database& db = Database::instance ();
+  static SymbolVector& Symbols = db.symbols ();
+
+  return (Symbols);
+}
+
+//-------------------------------------------------------------
+Symbol::SymbolMap& Symbol::symbol_map ()
+{
+  static Database& db = Database::instance ();
+  static SymbolMap& SymbolMap = db.symbol_map ();
+
+  return (SymbolMap);
+}
+
+/**
+   Filter out faulty items of a path-like symbol value
+ */
+void Symbol::filter_path_value (const cmt_string& name, cmt_string& text)
+{
+
+  CmtSystem::cmt_string_vector paths;
+  CmtSystem::cmt_string_vector normalyzed_paths;   
+                  
+  CmtSystem::split (text, CmtSystem::path_separator (), paths);
+                  
+  for (int j = 0; j < paths.size (); ++j)
+    {
+      cmt_string& t = paths[j];
+
+      if (!CmtSystem::test_directory (t))
+	  {
+	      if (Cmt::get_warnings ())
+	      {
+	          cout << "#CMT> Warning: Wrong path item " << t << " in " << name << endl;
+	      }
+
+	  }
+	    
+      int exist = 0;  
+      for (int i = 0; i < j; ++i)
+      {
+          cmt_string& u = paths[i];
+          if (u == t)
+             exist = 1;
+      }	  	  
+      if (exist==0)
+      {
+          cmt_string& s = normalyzed_paths.add ();
+          s = t;
+      } 	    
+    }
+   
+  Cmt::vector_to_string (normalyzed_paths, CmtSystem::path_separator (), text);
+
+  for (;;)
+    {
+      int sz = text.size ();
+
+      if (sz == 0) break;
+
+      if ((text[0] == ';') || (text[0] == ':'))
+	{
+	  text.erase (0, 1);
+	}
+      else if ((text[sz-1] == ';') || (text[sz-1] == ':'))
+	{
+	  text.erase (sz-1, 1);
+	}
+      else
+	{
+	  break;
+	}
+    }
+
+  text.replace_all ("::", ":");
+  text.replace_all (";;", ";");
+}
+
+
+//-------------------------------------------------------------
+Symbol& Symbol::symbol (int index)
+{
+  static SymbolVector& Symbols = symbols ();
+
+  return (Symbols[index]);
+}
+
+//-------------------------------------------------------------
+void Symbol::action (const CmtSystem::cmt_string_vector& words,
+                     CommandType command_type,
+                     Use* use)
+{
+  int number;
+  Symbol* symbol;
+  Tag* tag;
+
+  if (words.size () < 1) return;
+  cmt_string name = words[1];
+
+  if ((command_type == CommandSetupScript) ||
+      (command_type == CommandCleanupScript))
+    {
+      cmt_string full_name;
+
+      Symbol::expand (name);
+
+      if (name != "")
+        {
+          if (CmtSystem::absolute_path (name)) 
+            {
+              full_name = name;
+            }
+          else
+            {
+#ifdef WIN32
+              full_name = "%";
+#else
+              full_name = "${";
+#endif
+              full_name += use->prefix;
+              full_name += "ROOT";
+#ifdef WIN32
+              full_name += "%";
+#else
+              full_name += "}";
+#endif
+              full_name += CmtSystem::file_separator ();
+              if (use->style == cmt_style) full_name += "cmt";
+              else if (use->style == no_version_style) full_name += "cmt";
+              else full_name += "mgr";
+              full_name += CmtSystem::file_separator ();
+              full_name += name;
+            }
+
+          symbol = create (full_name, command_type, use);
+          symbol->add_value_to_list (command_type, use,
+                                     Tag::get_default (), full_name);
+        }
+    }
+  else
+    {
+      if (words.size () < 2) return;
+      const cmt_string& default_value = words[2];
+
+      Cmt::reset_all_sets_done ();
+
+      if (Cmt::get_debug ())
+	{
+	  cout << "Symbol::action> name:" << name 
+	       << " access:" << Cmt::get_current_access () 
+	       << " scope:" << use->get_current_scope () << endl;
+	}
+
+      if (Cmt::get_current_access () == UserMode)
+	{
+	  /*
+	    The following statements mean that some symbols are 
+	    always private.
+	    This list is hardcoded. This should be replaced by a
+	    database of "private" symbols.
+	   */
+	  if (name == "constituents") return;
+	  if (name == "constituentscclean") return;
+
+          if (use->get_current_scope () == ScopePrivate) return;
+	}
+
+      symbol = create (name, command_type, use);
+
+      /*
+        Parse the default value.
+      */
+      
+      symbol->add_value_to_list (command_type, use,
+                                 Tag::get_default (), default_value);
+      
+      /*
+        Then parse all specific values
+        
+        <tag> <value>
+        ...
+      */
+      
+      number = 3;
+      while (number < (words.size () - 1))
+        {
+          cmt_string tag_name = words[number];
+          const cmt_string& value = words[number + 1];
+
+	  expand (tag_name);
+
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "Symbol::action> tag_name=" << tag_name << endl;
+	    }
+
+	  tag = Tag::find (tag_name);
+	  if (tag == 0)
+	    {
+	      tag = Tag::add (tag_name, PriorityUserTag, "use", use);
+	    }
+
+          symbol->add_value_to_list (command_type, use, tag, value);
+          
+          number += 2;
+        }
+
+      if (name == "CMTPATH")
+        {
+          Cmt::configure_cmt_path (use);
+        }
+      else if (name == "CMTPROJECTPATH")
+        {
+          Cmt::configure_cmt_path (use);
+        }
+      else if (name == "CMTSITE")
+        {
+          Cmt::configure_site_tag (use);
+        }
+      else if (name == "CMTCONFIG")
+        {
+            //cerr << "redefining CMTCONFIG" << endl;
+          Cmt::configure_tags (use);
+        }
+      else if (name == "CMTHOME")
+        {
+          Cmt::configure_home (use);
+        }
+      else if (name == "CMTUSERCONTEXT")
+        {
+          Cmt::configure_user_context (use);
+        }
+      else if (name.find ("_native_version") != cmt_string::npos)
+        {
+          cmt_string n = use->get_package_name ();
+          n += "_native_version";
+
+          if (name == n)
+            {
+              use->set_native_version (true);
+            }
+        }
+    }
+}
+
+//-------------------------------------------------------------
+int Symbol::is_selected (const cmt_string& name)
+{
+  Symbol* symbol;
+  int number;
+  int value_number;
+
+  symbol = find (name);
+  if (symbol == 0) return (0);
+
+  if (symbol->value_lists.size () == 0) return (0);
+
+  for (number = 0;
+       number < symbol->value_lists.size ();
+       number++)
+    {
+      const SymbolValueList& value_list = symbol->value_lists[number];
+
+      if (value_list.discarded) continue;
+
+      if ((value_list.command_type == CommandMacro) ||
+          (value_list.command_type == CommandSet) ||
+          (value_list.command_type == CommandSetAppend) ||
+          (value_list.command_type == CommandSetPrepend) ||
+          (value_list.command_type == CommandSetRemove) ||
+          (value_list.command_type == CommandSetRemoveRegexp) ||
+          (value_list.command_type == CommandAlias) ||
+          (value_list.command_type == CommandAction))
+        {
+          for (value_number = 0;
+               value_number < value_list.values.size ();
+               value_number++)
+            {
+              Tag* tag;
+
+              SymbolValue& value = value_list.values[value_number];
+
+              tag = value.tag;
+              if ((tag == 0) ||
+                  (tag == Tag::get_default ()) ||
+                  (tag->is_selected () != 0))
+                {
+                  return (1);
+                }
+            }
+        }
+    }
+
+  return (0);
+}
+
+//-------------------------------------------------------------
+Symbol::Symbol ()
+{
+  name = "";
+}
+
+//-------------------------------------------------------------
+Symbol::~Symbol ()
+{
+}
+
+/**
+ *  Characterizes if a value is provided as the reference to itself. 
+ */
+bool Symbol::value_is_reflexive (const cmt_string& text) const
+{
+  bool result = false;
+  int text_length = text.size ();
+
+  if (text_length == (name.size () + 3))
+    {
+      static cmt_string temp;
+              
+      if (text[0] == '$')
+        {
+          if (text[1] == '(')
+            {
+              temp = "$(";
+              temp += name;
+              temp += ")";
+              
+              if (text == temp)
+                {
+                  result = true;
+                }
+            }
+          else if (text[1] == '{')
+            {
+              temp = "${";
+              temp += name;
+              temp += "}";
+              
+              if (text == temp)
+                {
+                  result = true;
+                }
+            }
+        }
+    }
+  else if (text_length == (name.size () + 2))
+    {
+      static cmt_string temp;
+
+      temp = "%";
+      temp += name;
+      temp += "%";
+
+      if (text == temp)
+        {
+          result = true;
+        }
+    }
+
+  return (result);
+}
+
+//-------------------------------------------------------------
+void Symbol::add_value_to_list (CommandType command_type,
+                                Use* use,
+				Tag* tag,
+                                const cmt_string& text)
+{
+  SymbolValueList* value_list = 0;
+  bool is_reflexive = false;
+
+    //
+    // First pickup the most recent value_list
+    //
+  if (value_lists.size () > 0) value_list = &(value_lists.back ());
+
+    //
+    //  Create a new value list is we switch to another use or
+    //  if we switch to a new command_type (eg. switching from
+    //  macro to macro_append).
+    //
+  if ((value_list == 0) ||
+      (use != value_list->use) ||
+      (command_type != value_list->command_type) ||
+      (tag == Tag::get_default ()))
+    {
+      value_list = &(value_lists.add ());
+      value_list->use = use;
+      value_list->command_type = command_type;
+      value_list->values.clear ();
+      value_list->discarded = false;
+      value_list->is_reflexive = false;
+    }
+
+/*
+  else
+    {
+        value_list = &(value_lists[value_lists.size () - 1]);
+    }
+*/
+
+  is_reflexive = value_list->is_reflexive;
+
+    //
+    //  If the command_type is command_macro or command_set, 
+    // this is considered as a full re-set of this symbol 
+    //   In this case, we have to discard all previous values
+    //
+    //  However, we'd like to exclude from this logic the cases where
+    //  the value is **exactly* 
+    //
+    //     $(<symbol>)
+    //     ${<symbol>}
+    //     %<symbol>%
+    //
+    //   which would then mean that we do not reset the value but rather
+    //  override it.
+    //
+
+    //
+    // Inside this value_list, we add this new tag-value pair.
+    //
+
+  if ((command_type == CommandMacro) ||
+      (command_type == CommandSet) ||
+      (command_type == CommandPath) ||
+      (command_type == CommandAction))
+    {
+        //
+        // Check whether we have to hide previous settings by this new definition
+        //  (of course this is only useful if there WERE previous settings)
+        //
+      if ((value_lists.size () >= 1) && (!is_reflexive))
+        {
+          if (value_is_reflexive (text))
+            {
+              value_list->is_reflexive = true;
+              is_reflexive = true;
+            }
+          else
+            {
+	      //cout << "...discarding old values for symbol " << name << " text=[" << text << "]" << endl;
+                  
+              for (int i = 0; i < (value_lists.size () - 1); i++)
+                {
+                  SymbolValueList& vl = value_lists[i];
+                  
+                  if ((vl.use != 0) &&
+                      (vl.use->discarded))
+		    {
+                      //vl.discarded = true;
+		    }
+                }
+            }
+        }
+    }
+
+  SymbolValue& value = value_list->values.add ();
+
+  value.tag = tag;
+  value.text = text;
+  value.selected = 0;
+}
+
+/**
+   Compute the current value of all environment variables and set them to the
+   shell
+ */
+void Symbol::all_set ()
+{
+  //cerr << "all_set" << endl;
+
+  static bool running = false;
+
+
+  if (Cmt::get_debug ())
+    {
+      cout << "\nSymbol::all_set> done=" << running << endl;
+    }
+
+  if (Cmt::get_all_sets_done ()) return;
+
+  if (running) return;
+
+  running = true;
+  Cmt::set_all_sets_done ();
+
+  static SymbolVector& Symbols = symbols ();
+  Use::UsePtrVector& Uses = Use::get_ordered_uses ();
+
+  int number;
+
+  if (Symbols.size () == 0) 
+    {
+      running = false;
+      return;
+    }
+
+  cmt_string value;
+
+  for (number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      if (symbol.type != SymbolSet) continue;
+
+      value = symbol.build_macro_value ();
+      if (value != "")
+	{
+	  Symbol::expand (value);
+
+	  CmtSystem::putenv (symbol.name, value);
+	}
+    }
+
+  cmt_string cmtconfig = CmtSystem::get_cmt_config ();
+
+  if (Uses.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < Uses.size (); number++)
+        {
+          Use& use = *(Uses[number]);
+
+          if (use.discarded) continue;
+
+	  if (use.get_package_name () == "cmt_standalone") continue;
+
+	  if (use.get_strategy ("SetupConfig"))
+	    {
+	      cmt_string temp;
+
+	      temp = use.prefix;
+	      temp += "CONFIG";
+
+	      CmtSystem::putenv (temp, cmtconfig);
+	    }
+
+	  if (use.get_strategy ("SetupRoot"))
+	    {
+	      cmt_string temp;
+
+	      temp = use.prefix;
+	      temp += "ROOT";
+
+	      CmtSystem::putenv (temp, use.get_full_path ());
+	    }
+        }
+    }
+
+  {
+    Use& use = Use::current ();
+
+    if (use.get_package_name () != "cmt_standalone")
+      {
+	if (use.get_strategy ("SetupConfig"))
+	  {
+	    cmt_string temp;
+
+	    temp = use.prefix;
+	    temp += "CONFIG";
+
+	    CmtSystem::putenv (temp, cmtconfig);
+	  }
+	
+	if (use.get_strategy ("SetupRoot"))
+	  {
+	    cmt_string temp;
+
+	    temp = use.prefix;
+	    temp += "ROOT";
+
+	    CmtSystem::putenv (temp, use.get_full_path ());
+	  }
+      }
+  }
+
+  for (number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      if ((symbol.type != SymbolPath)) continue;
+
+      value = symbol.build_macro_value ();
+      if (value != "")
+	{
+	  Symbol::expand (value);
+	  filter_path_value (symbol.name, value);
+
+#ifdef WIN32
+	  value.replace_all ("/", "\\");
+#endif
+
+          if (Cmt::get_debug ())
+            {
+              cerr << "Symbol::all_set-2> " << symbol.name << " = " << value << endl;
+            }
+
+	  CmtSystem::putenv (symbol.name, value);
+	}
+    }
+
+  running = false;
+}
+
+//-------------------------------------------------------------
+void Symbol::all_print (PrintMode mode)
+{
+  static SymbolVector& Symbols = symbols ();
+
+  int number;
+
+  if (Symbols.size () == 0) return;
+
+  for (number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      if ((symbol.type == SymbolSet) ||
+          (symbol.type == SymbolAlias) ||
+          (symbol.type == SymbolSetupScript) ||
+          (symbol.type == SymbolPath))
+        {
+          if (symbol.print (mode))
+            {
+              if (mode == Bat)
+                {
+                  cout << endl;
+                }
+              else
+                {
+                  //cout << "; ";
+                  cout << endl;
+                }
+            }
+        }
+    }
+}
+
+//-------------------------------------------------------------
+void Symbol::check_all_paths ()
+{
+  static SymbolVector& Symbols = symbols ();
+
+  int number;
+
+  if (Symbols.size () == 0) return;
+
+  for (number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      if (symbol.type == SymbolPath)
+        {
+	  cmt_string temp;
+
+	  temp = symbol.build_macro_value ();
+	  expand (temp);
+
+	  Symbol::filter_path_value (symbol.name, temp);
+        }
+    }
+}
+
+//-------------------------------------------------------------
+void Symbol::all_print_clean (PrintMode mode)
+{
+  static SymbolVector& Symbols = symbols ();
+
+  int number;
+
+  if (Symbols.size () == 0) return;
+
+  for (number = Symbols.size () - 1; number >= 0; number--)
+    {
+      Symbol& symbol = Symbols[number];
+
+      if ((symbol.type == SymbolSet) ||
+          (symbol.type == SymbolAlias) ||
+          (symbol.type == SymbolCleanupScript))
+        {
+          if (symbol.print_clean (mode))
+            {
+              cout << endl;
+            }
+        }
+    }
+
+  for (number = Symbols.size () - 1; number >= 0; number--)
+    {
+      Symbol& symbol = Symbols[number];
+
+      if ((symbol.type != SymbolPath)) continue;
+
+      if (symbol.print_clean (mode))
+        {
+          cout << endl;
+        }
+    }
+}
+
+//-------------------------------------------------------------
+int Symbol::print_clean (PrintMode mode)
+{
+  int result = 0;
+  static cmt_string temp;
+
+  if (name == "CMTCONFIG") return (0);
+
+  switch (type)
+    {
+    case SymbolSet :
+      switch (mode)
+        {
+        case Csh :
+          cout << "unsetenv " << name;
+          result = 1;
+          break;
+        case Sh :
+          cout << "unset " << name;
+          result = 1;
+          break;
+        case Bat :
+          cout << "set " << name << "=";
+          result = 1;
+          break;
+        }
+      break;
+    case SymbolAlias :
+      switch (mode)
+        {
+          case Csh :
+            cout << "unalias " << name;
+            result = 1;
+            break;
+          case Sh :
+            cout << "unset " << name;
+            result = 1;
+            break;
+        }
+      break;
+    case SymbolPath :
+      temp = clean_macro_value ();
+      switch (mode)
+        {
+        case Csh :
+	  if (temp == "")
+	    {
+	      cout << "unsetenv " << name;
+	    }
+	  else
+	    {
+	      cout << "setenv " << name << " " << temp;
+	    }
+          result = 1;
+          break;
+        case Sh :
+          cout << name << "=" << temp << "; export " << name;
+          result = 1;
+          break;
+        case Bat :
+          cout << "set " << name << "=" << temp;
+          result = 1;
+          break;
+        }
+      break;
+    case SymbolCleanupScript :
+      switch (mode)
+        {
+        case Csh :
+          cout << "if ( -f " << name << ".csh ) then" << endl;
+          cout << "  source " << name << ".csh" << endl;
+          cout << "endif" << endl;
+          result = 1;
+          break;
+        case Sh :
+          cout << "if test -f " << name << ".sh; then" << endl;
+          cout << "  . " << name << ".sh" << endl;
+          cout << "fi" << endl;
+          result = 1;
+          break;
+        case Bat :
+          cout << "call " << name;
+          result = 1;
+          break;
+        }
+      break;
+    }
+
+  return (result);
+}
+
+//-------------------------------------------------------------
+int Symbol::print (PrintMode mode)
+{
+  int result = 0;
+  cmt_string temp;
+
+  temp = build_macro_value ();
+
+  bool empty = (temp.size () == 0) ? true : false;
+
+  if (type == SymbolPath)
+    {
+      expand (temp);
+      Symbol::filter_path_value (name, temp);
+    }
+
+  switch (type)
+    {
+      case SymbolSet :
+      case SymbolPath :
+        switch (mode)
+          {
+            case Csh :
+              if (empty) cout << "unsetenv " << name;
+              else cout << "setenv " << name << " \"" << temp << "\"";
+
+              result = 1;
+              break;
+            case Sh :
+              if (empty) cout << "unset " << name;
+              else cout << name << "=\"" << temp << "\"; export " << name;
+
+              result = 1;
+              break;
+            case Bat :
+              temp.replace_all ("/", "\\");
+              cout << "set " << name << "=" << temp;
+              result = 1;
+              break;
+          }
+        break;
+      case SymbolAlias :
+        switch (mode)
+          {
+            case Csh :
+              cout << "alias " << name <<
+                  " \"" << temp << "\"";
+              result = 1;
+              break;
+            case Sh :
+              cout << "alias " << name <<
+                  "=\"" << temp << "\"";
+              result = 1;
+              break;
+            case Bat :
+              cout << "set " << name <<
+                  "=" << temp;
+              result = 1;
+              break;
+          }
+        break;
+      default :
+        break;
+    }
+
+  if (temp != "")
+    {
+      switch (type)
+        {
+          case SymbolSetupScript :
+            switch (mode)
+              {
+                case Csh :
+                  cout << "if ( -f " << name << ".csh ) then" << endl;
+                  cout << "  source " << name << ".csh" << endl;
+                  cout << "endif" << endl;
+                  result = 1;
+                  break;
+                case Sh :
+                  cout << "if test -f " << name << ".sh; then" << endl;
+                  cout << "  . " << name << ".sh" << endl;
+                  cout << "fi" << endl;
+                  result = 1;
+                  break;
+                case Bat :
+                  cout << "call " << name;
+                  result = 1;
+                  break;
+              }
+            break;
+          default:
+            break;
+        }
+    }
+
+  return (result);
+}
+
+//-------------------------------------------------------------
+cmt_string Symbol::build_macro_value (bool display_it) const
+{
+  cmt_string temp;
+
+  if (display_it)
+    {
+      temp = builder->build_and_display (*this);
+    }
+  else
+    {
+      temp = builder->build (*this);
+    }
+
+  return (temp);
+}
+
+//-------------------------------------------------------------
+cmt_string Symbol::clean_macro_value () const
+{
+  cmt_string temp;
+
+  temp = builder->clean (*this);
+
+  return (temp);
+}
+
+/**
+
+   Attempt to substitute into the symbol value all occurrences of
+
+      ${xxx}
+      $(xxx)
+      `xxx`
+      %xxx%    [on Windows only]
+
+      by the appropriate value:
+
+        for `xxx` : 
+
+            xxx is considered as a shell command. Value is the result of its execution
+
+        for other patterns:
+
+            if xxx is a symbol name, its value is substituted to the pattern
+            otherwise, xxx is tried as an environment variable
+
+
+     ===> In all cases, the pattern is filtered away.
+
+  */
+cmt_string Symbol::resolve_macro_value (const cmt_string& tag_name)
+{
+  cmt_string temp = builder->build (*this, tag_name);
+
+  resolve_value (temp);
+
+  return (temp);
+}
+
+//-------------------------------------------------------------
+void Symbol::show_macro (PrintMode mode)
+{
+  if (Cmt::get_debug ())
+    {
+      cout << "Symbol::show_macro> " << name << endl;
+    }
+
+  ActionType action = Cmt::get_action ();
+
+  cmt_string value = build_macro_value (true);
+
+  if ((!Cmt::get_quiet ()) &&
+      (action != action_build_tag_makefile) &&
+      (action != action_show_macros) &&
+      (action != action_show_actions) &&
+      (action != action_show_sets))
+    {
+      cout << "#" << endl;
+      cout << "# Selection : " << endl;
+    }
+
+  if (value.size () > 0)
+    {
+      if ((action == action_show_macro) ||
+          (action == action_show_macros) ||
+          (action == action_show_sets) ||
+          (action == action_show_set) ||
+          (action == action_show_actions) ||
+          (action == action_show_action) ||
+          (action == action_build_tag_makefile) ||
+          (action == action_load) ||
+          (!Cmt::get_quiet ()))
+        {
+          if (mode == Make)
+            {
+              cout << name << "=";
+            }
+          else
+            {
+              cout << name << "='";
+            }
+        }
+
+      if ((action == action_show_macro_value) ||
+          (action == action_show_set_value) ||
+          (action == action_show_action_value))
+        {
+          expand (value);
+        }
+      else if (action == action_build_tag_makefile)
+        {
+            /* 
+               Unfortunately, the %xxx% pattern has to be kept on Unix. Therefore
+               we cannot force all patterns to become $(xxx)
+
+               This was useful on Windows so as to only keep $(xxx)
+             */
+#ifdef WIN32
+	  suppress_OS_delimiters (value);
+#endif
+        }
+
+      cout << value;
+
+      if ((action == action_show_macro) ||
+          (action == action_show_macros) ||
+          (action == action_show_sets) ||
+          (action == action_show_set) ||
+          (action == action_show_actions) ||
+          (action == action_show_action) ||
+          (action == action_build_tag_makefile) ||
+          (action == action_load) ||
+          (!Cmt::get_quiet ()))
+        {
+          if (mode != Make)
+            {
+              cout << "'";
+            }
+#ifdef WIN32
+	  else
+	    {
+              cout << " ";
+	    }
+#endif
+        }
+
+      cout << endl;
+    }
+}
+
+//-------------------------------------------------------------
+void Symbol::clear_all ()
+{
+  static SymbolVector& Symbols = symbols ();
+  static SymbolMap& SymbolMap = symbol_map ();
+
+  SymbolMap.clear ();
+  Symbols.clear ();
+}
+
+//-------------------------------------------------------------
+void Symbol::expand (cmt_string& text)
+{
+  static cmt_regexp reg ("[$%`]");
+
+  if (!reg.match (text)) return;
+
+  resolve_value (text);
+}
+
+//-------------------------------------------------------------
+ValueBuilder::ValueBuilder ()
+{
+  m_display_it = false;
+}
+
+//-------------------------------------------------------------
+const cmt_string ValueBuilder::build_and_display (const Symbol& symbol)
+{
+  cmt_string temp;
+
+  m_display_it = true;
+  temp = build (symbol);
+  m_display_it = false;
+
+  return (temp);
+}
+
+//-------------------------------------------------------------
+const cmt_string SetBuilder::build (const Symbol& symbol,
+                                    const cmt_string& /*tag_name*/)
+{
+    // Control of recursivity
+  static int level = 0;
+
+  bool show_it = false;
+
+  cmt_string temp;
+  cmt_string previous_temp;
+  cmt_string new_value;
+  static const cmt_string empty;
+
+  ActionType action = Cmt::get_action ();
+
+  if (action == action_show_set)
+    {
+      if (symbol.name == Cmt::get_current_target ())
+        {
+             // Should not display on recursive calls
+          if (level == 0) show_it = m_display_it;
+        }
+    }
+
+  level++;
+
+  temp = "";
+
+  bool first_definition = true;
+
+  for (int i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      const int selected = value_list.select_first ();
+
+      if (selected < 0) continue;
+
+      SymbolValue& value = value_list.values[selected];
+
+      if (show_it && !Symbol::get_inhibit_display())
+        {
+          value_list.show (symbol, value, first_definition);
+        }
+      
+      if (value_list.discarded) continue;
+
+        //
+        // One should accumulate values if it refers to
+        // itself.
+        //
+      
+      new_value = value.text;
+      
+      resolve_value_for_macros (new_value);
+      
+      switch (value_list.command_type)
+        {
+          case CommandSet :
+
+            if (!value_list.is_reflexive || 
+                !symbol.value_is_reflexive (value.text))
+              {
+                resolve_value (new_value, symbol.name, temp);
+                temp = new_value;
+              }
+            else if (temp == "")
+              {
+                temp = CmtSystem::getenv (symbol.name);
+              }
+
+            break;
+          case CommandSetAppend :
+            
+            if (new_value != "")
+              {
+                temp += new_value;
+              }
+            
+            break;
+          case CommandSetPrepend :
+            
+            if (new_value != "")
+              {
+                previous_temp = temp;
+                temp = new_value;
+                temp += previous_temp;
+              }
+            
+            break;
+          case CommandSetRemove :
+            
+            if (new_value != "")
+              {
+                temp.replace_all (new_value, empty);
+              }
+            
+            break;
+          case CommandSetRemoveRegexp :
+            
+            if (new_value != "")
+              {
+		cmt_regexp e (new_value);
+		cmt_regexp::iterator it;
+
+		for (;;)
+		  {
+		    it = e.begin (temp);
+		    if (it == e.end ()) break;
+
+		    temp.erase (it._pos, it._length);
+		  }
+              }
+            
+            break;
+          case CommandAlias :
+            
+            resolve_value (new_value, symbol.name, temp);
+            temp = new_value;
+            
+            break;
+        }
+    }
+
+  level--;
+
+  return (temp);
+}
+
+static bool find_path_entry (const cmt_string& paths, const cmt_string& value)
+{
+  static const cmt_string path_separator = CmtSystem::path_separator ();
+
+  cmt_string here = CmtSystem::pwd ();
+  cmt_string rvalue = value;
+
+  if (CmtSystem::cd (value))
+    {
+      rvalue = CmtSystem::pwd ();
+    }
+  else
+    {
+      CmtSystem::compress_path (rvalue);
+    }
+
+  CmtSystem::cmt_string_vector items;
+  CmtSystem::split (paths, path_separator, items);
+
+  bool found = false;
+
+  for (int i = 0; i < items.size (); i++)
+    {
+      const cmt_string& item = items[i];
+      cmt_string ritem = item;
+      if (CmtSystem::cd (item))
+	{
+	  ritem = CmtSystem::pwd ();
+	}
+      else
+	{
+	  CmtSystem::compress_path (ritem);
+	}
+
+      if (ritem == rvalue)
+	{
+	  found = true;
+	  break;
+	}
+    }
+
+  CmtSystem::cd (here);
+  return (found);
+}
+
+//-------------------------------------------------------------
+const cmt_string PathBuilder::build (const Symbol& symbol,
+                                     const cmt_string& /*tag_name*/)
+{
+    // Control of recursivity
+  static int level = 0;
+
+  bool show_it = false;
+
+  cmt_string temp;
+  cmt_string previous_temp;
+  cmt_string new_value;
+  static const cmt_string empty;
+
+  static cmt_string path_separator = CmtSystem::path_separator ();
+
+  ActionType action = Cmt::get_action ();
+
+  if (action == action_show_set)
+    {
+      if (symbol.name == Cmt::get_current_target ())
+        {
+            // Should not display on recursive calls
+          if (level == 0) show_it = m_display_it;
+        }
+    }
+
+  level++;
+
+  temp = CmtSystem::getenv (symbol.name);
+
+  bool first_definition = true;
+
+  for (int i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      const int selected = value_list.select_first ();
+      
+      if (selected < 0) continue;
+ 
+      SymbolValue& value = value_list.values[selected];
+          
+      if (show_it && !Symbol::get_inhibit_display())
+        {
+          value_list.show (symbol, value, first_definition);
+        }
+          
+      if (value_list.discarded) continue;
+
+      new_value = value.text;
+          
+          //resolve_value (new_value);
+      resolve_value_for_macros (new_value);
+          
+      switch (value_list.command_type)
+        {
+          case CommandPath :
+            
+            if (!value_list.is_reflexive || 
+                !symbol.value_is_reflexive (value.text))
+              {
+                resolve_value (new_value, symbol.name, temp);
+                temp = new_value;
+              }
+
+            break;
+          case CommandPathAppend :
+              
+            if (new_value != "")
+              {
+                if (!find_path_entry (temp, new_value))
+                  {
+                    if (temp != "") temp += path_separator;
+                      
+                    temp += new_value;
+                  }
+              }
+                  
+            break;
+          case CommandPathPrepend :
+              
+            if (new_value != "")
+              {
+                if (!find_path_entry (temp, new_value))
+                  {
+                    previous_temp = temp;
+                    temp = new_value;
+                    if (previous_temp != "") temp += path_separator;
+                    temp += previous_temp;
+                  }
+              }
+                  
+            break;
+          case CommandPathRemove :
+              
+            if (new_value != "")
+              {
+                CmtSystem::cmt_string_vector paths;
+                  
+                CmtSystem::split (temp, path_separator, paths);
+                  
+                for (int j = 0; j < paths.size (); ++j)
+                  {
+                    cmt_string& s = paths[j];
+                      
+                    if (s.find (new_value) != cmt_string::npos)
+                      {
+                        s = "";
+                      }
+                  }
+
+                Cmt::vector_to_string (paths, path_separator, temp);
+              }
+              
+            break;
+          case CommandPathRemoveRegexp :
+
+            if (new_value != "")
+              {
+		cmt_regexp e (new_value);
+
+                CmtSystem::cmt_string_vector paths;
+                  
+                CmtSystem::split (temp, path_separator, paths);
+                  
+                for (int j = 0; j < paths.size (); ++j)
+                  {
+                    cmt_string& s = paths[j];
+
+		    if (CmtSystem::getenv ("TESTPRR") != "")
+		      {
+			cout << "PRR> s=[" << s << "]";
+		      }
+
+                    if (e.match (s))
+                      {
+                        s = "";
+
+			if (CmtSystem::getenv ("TESTPRR") != "")
+			  {
+			    cout << " match ";
+			  }
+                      }
+		    else
+                      {
+			if (CmtSystem::getenv ("TESTPRR") != "")
+			  {
+			    cout << " no match ";
+			  }
+                      }
+
+		    if (CmtSystem::getenv ("TESTPRR") != "")
+		      {
+			cout << endl;
+		      }
+                  }
+
+                Cmt::vector_to_string (paths, path_separator, temp);
+              }
+              
+            break;
+        }
+
+    }
+
+  level--;
+
+  for (;;)
+    {
+      int sz = temp.size ();
+
+      if (sz == 0) break;
+
+      if ((temp[0] == ';') || (temp[0] == ':'))
+	{
+	  temp.erase (0, 1);
+	}
+      else if ((temp[sz-1] == ';') || (temp[sz-1] == ':'))
+	{
+	  temp.erase (sz-1, 1);
+	}
+      else
+	{
+	  break;
+	}
+    }
+
+  temp.replace_all ("::", ":");
+  temp.replace_all (";;", ";");
+  
+  return (temp);
+}
+
+//-------------------------------------------------------------
+const cmt_string PathBuilder::clean (const Symbol& symbol,
+                                     const cmt_string& /*tag_name*/)
+{
+    // Control of recursivity
+  static int level = 0;
+
+  cmt_string temp;
+  cmt_string new_value;
+  static const cmt_string empty;
+
+  static cmt_string path_separator = CmtSystem::path_separator ();
+
+  temp = CmtSystem::getenv (symbol.name);
+
+    //cerr << "#####1 temp=" << temp << endl;
+
+  for (int i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if (value_list.discarded) continue;
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      const int selected = value_list.select_first ();
+      
+      if (selected < 0) continue;
+ 
+      SymbolValue& value = value_list.values[selected];
+          
+      new_value = value.text;
+          
+          //resolve_value (new_value);
+
+        //cerr << "#####1 new_value=" << new_value << endl;
+
+      resolve_value_for_macros (new_value);
+      resolve_value (new_value);
+          
+        //cerr << "#####2 new_value=" << new_value << endl;
+
+      switch (value_list.command_type)
+        {
+          case CommandPath :
+            
+            temp = "";
+            
+            break;
+          case CommandPathAppend :
+          case CommandPathPrepend :
+          case CommandPathRemove :
+
+            if (new_value != "")
+              {
+                CmtSystem::cmt_string_vector paths;
+                  
+                CmtSystem::split (temp, path_separator, paths);
+                  
+                for (int j = 0; j < paths.size (); ++j)
+                  {
+                    cmt_string& s = paths[j];
+                      
+                    if (s.find (new_value) != cmt_string::npos)
+                      {
+                        s = "";
+                      }
+
+                    if (j > 0)
+                      {
+                        cmt_string& s2 = paths[j-1];
+                        if (s2 == s)
+                          {
+                            s2 = "";
+                          }
+                      }
+                  }
+
+                Cmt::vector_to_string (paths, path_separator, temp);
+                temp.replace_all ("::", ":");
+                temp.replace_all (";;", ";");
+              }
+              
+            break;
+          case CommandPathRemoveRegexp :
+
+            if (new_value != "")
+              {
+		cmt_regexp e (new_value);
+
+                CmtSystem::cmt_string_vector paths;
+                  
+                CmtSystem::split (temp, path_separator, paths);
+                  
+                for (int j = 0; j < paths.size (); ++j)
+                  {
+                    cmt_string& s = paths[j];
+                      
+                    if (e.match (s))
+                      {
+                        s = "";
+                      }
+
+                    if (j > 0)
+                      {
+                        cmt_string& s2 = paths[j-1];
+                        if (s2 == s)
+                          {
+                            s2 = "";
+                          }
+                      }
+                  }
+
+                Cmt::vector_to_string (paths, path_separator, temp);
+                temp.replace_all ("::", ":");
+                temp.replace_all (";;", ";");
+              }
+              
+            break;
+        }
+    }
+
+    //cerr << "#####2 temp=" << temp << endl;
+  
+  return (temp);
+}
+
+//-------------------------------------------------------------
+const cmt_string MacroBuilder::build (const Symbol& symbol,
+                                      const cmt_string& tag_name)
+{
+    // Control of recursivity
+  static int level = 0;
+
+  cmt_string temp;
+  cmt_string previous_temp;
+  static const cmt_string empty;
+  bool show_it = false;
+
+  ActionType action = Cmt::get_action ();
+
+  if (action == action_show_macro)
+    {
+      if (symbol.name == Cmt::get_current_target ())
+        {
+             // Should not display on recursive calls
+          if (level == 0) show_it = m_display_it;
+        }
+    }
+
+  level++;
+
+  temp = "";
+
+  int i;
+
+  bool first_definition = true;
+
+  for (i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      if (value_list.command_type != CommandMacroPrepend) continue;
+
+      const int selected = value_list.select_first (tag_name);
+
+      if (selected < 0) continue;
+
+      SymbolValue& value = value_list.values[selected];
+
+      if (show_it && !Symbol::get_inhibit_display())
+        {
+          value_list.show (symbol, value, first_definition);
+        }
+
+      if (value_list.discarded) continue;
+
+      previous_temp = temp;
+      temp = value.text;
+      temp += previous_temp;
+    }
+
+  previous_temp = temp;
+  temp = "";
+
+  first_definition = true;
+
+  for (i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      if (value_list.command_type != CommandMacro) continue;
+
+      const int selected = value_list.select_first (tag_name);
+
+      if (selected < 0) continue;
+
+      SymbolValue& value = value_list.values[selected];
+
+      if (show_it && !Symbol::get_inhibit_display())
+        {
+          value_list.show (symbol, value, first_definition);
+        }
+
+      // WARNING:
+      // Commented just for a test : should be uncommented after the test
+      if (value_list.discarded) continue;
+      
+      if (!value_list.is_reflexive || 
+          !symbol.value_is_reflexive (value.text))
+        {
+          temp = value.text;
+        }
+    }
+
+  previous_temp += temp;
+  temp = previous_temp;
+
+  for (i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      if (value_list.command_type != CommandMacroAppend) continue;
+
+      const int selected = value_list.select_first (tag_name);
+
+      if (selected < 0) continue;
+
+      SymbolValue& value = value_list.values[selected];
+
+      if (show_it && !Symbol::get_inhibit_display())
+        {
+          value_list.show (symbol, value, first_definition);
+        }
+
+      if (value_list.discarded) continue;
+
+      temp += value.text;
+    }
+
+  for (i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      if ((value_list.command_type != CommandMacroRemove) &&
+          (value_list.command_type != CommandMacroRemoveRegexp) &&
+          (value_list.command_type != CommandMacroRemoveAll) &&
+          (value_list.command_type != CommandMacroRemoveAllRegexp)) continue;
+
+      const int selected = value_list.select_first (tag_name);
+
+      if (selected < 0) continue;
+
+      SymbolValue& value = value_list.values[selected];
+
+      if (show_it && !Symbol::get_inhibit_display())
+        {
+          value_list.show (symbol, value, first_definition);
+        }
+
+      if (value_list.discarded) continue;
+
+      switch (value_list.command_type)
+        {
+          case CommandMacroRemove :
+            temp.replace (value.text, empty);
+            break;
+          case CommandMacroRemoveRegexp :
+            if (value.text != "")
+              {
+		cmt_regexp e (value.text);
+		cmt_regexp::iterator it;
+
+		it = e.begin (temp);
+		if (it != e.end ())
+		  {
+		    temp.erase (it._pos, it._length);
+		  }
+              }
+            break;
+          case CommandMacroRemoveAll :
+            temp.replace_all (value.text, empty);
+            break;
+          case CommandMacroRemoveAllRegexp :
+            if (value.text != "")
+              {
+		cmt_regexp e (value.text);
+		cmt_regexp::iterator it;
+
+		for (;;)
+		  {
+		    it = e.begin (temp);
+		    if (it != e.end ())
+		      {
+			temp.erase (it._pos, it._length);
+		      }
+		    else
+		      {
+			break;
+		      }
+		  }
+              }
+            break;
+        }
+    }
+
+  level--;
+
+  return (temp);
+}
+
+//-------------------------------------------------------------
+const cmt_string ScriptBuilder::build (const Symbol& symbol,
+                                       const cmt_string& tag_name)
+{
+    // Control of recursivity
+  static int level = 0;
+
+  static const cmt_string empty = "";
+
+  if (symbol.value_lists.size () > 0)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[0];
+
+      if (value_list.discarded) return (empty);
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) return (empty);
+    }
+
+  return (symbol.name);
+}
+
+//-------------------------------------------------------------
+const cmt_string ActionBuilder::build (const Symbol& symbol,
+				       const cmt_string& tag_name)
+{
+    // Control of recursivity
+  static int level = 0;
+
+  cmt_string temp;
+  cmt_string previous_temp;
+  static const cmt_string empty;
+  bool show_it = false;
+
+  ActionType action = Cmt::get_action ();
+
+  if (action == action_show_action)
+    {
+      if (symbol.name == Cmt::get_current_target ())
+        {
+             // Should not display on recursive calls
+          if (level == 0) show_it = m_display_it;
+        }
+    }
+
+  level++;
+
+  int i;
+
+  bool first_definition = true;
+
+  temp = "";
+
+  for (i = 0; i < symbol.value_lists.size (); i++)
+    {
+      const SymbolValueList& value_list = symbol.value_lists[i];
+
+      if ((value_list.use != 0) &&
+          (value_list.use->discarded)) continue;
+
+      if (value_list.command_type != CommandAction) continue;
+
+      const int selected = value_list.select_first (tag_name);
+
+      if (selected < 0) continue;
+
+      SymbolValue& value = value_list.values[selected];
+
+      if (show_it && !Symbol::get_inhibit_display())
+        {
+          value_list.show (symbol, value, first_definition);
+        }
+
+      // WARNING:
+      // Commented just for a test : should be uncommented after the test
+      if (value_list.discarded) continue;
+      
+      if (!value_list.is_reflexive || 
+          !symbol.value_is_reflexive (value.text))
+        {
+          temp = value.text;
+        }
+    }
+
+  level--;
+
+  return (temp);
+}
+
+//-------------------------------------------------------------
+int SymbolValueList::select_first (const cmt_string& tag_name) const
+{
+  int priority = 0;
+  int value_number;
+  int selected = -1;
+
+  Tag* the_tag = 0;
+
+  if (tag_name != "") the_tag = Tag::find (tag_name);
+
+  for (value_number = 0;
+       value_number < values.size ();
+       value_number++)
+    {
+      const SymbolValue& value = values[value_number];
+
+      const Tag* tag = value.tag;
+
+      if (the_tag == 0)
+        {
+          if (!tag->is_selected ()) continue;
+        }
+      else
+        {
+          if (tag != the_tag) continue;
+          selected = value_number;
+        }
+
+      //
+      // Only the first value at a given priority is
+      // selected (which implies the '>' test instead
+      // of '>=')
+      //
+
+      if (tag->get_priority () > priority)
+        {
+          priority = tag->get_priority ();
+          selected = value_number;
+        }
+    }
+
+  return (selected);
+}
+
+//-------------------------------------------------------------
+int SymbolValueList::select_last () const
+{
+  int priority = 0;
+  int value_number;
+  int selected = -1;
+
+  for (value_number = 0;
+       value_number < values.size ();
+       value_number++)
+    {
+      SymbolValue& value = values[value_number];
+
+      const Tag* tag = value.tag;
+
+      if (tag->is_selected ())
+        {
+          //
+          // The last value at a given priority is
+          // selected (which implies the '>=' test instead
+          // of '>')
+          //
+
+          if (tag->get_priority () >= priority)
+            {
+              priority = tag->get_priority ();
+              selected = value_number;
+            }
+        }
+    }
+
+  return (selected);
+}
+
+//-------------------------------------------------------------
+void SymbolValueList::show (const Symbol& symbol, 
+                            const SymbolValue& value, 
+                            bool& first_definition) const
+{
+  cmt_string discarded_text;
+  cmt_string define_text;
+  ActionType action = Cmt::get_action ();
+
+  switch (command_type)
+    {
+      //case CommandSet :
+      case CommandSetAppend :
+      case CommandSetPrepend :
+      case CommandSetRemove :
+      case CommandSetRemoveRegexp :
+	//case CommandAlias :
+	//case CommandPath :
+      case CommandPathAppend :
+      case CommandPathPrepend :
+      case CommandPathRemove :
+      case CommandPathRemoveRegexp :
+      case CommandMacroPrepend :
+	//case CommandMacro :
+      case CommandMacroAppend :
+      case CommandMacroRemove :
+      case CommandMacroRemoveRegexp :
+      case CommandMacroRemoveAll :
+      case CommandMacroRemoveAllRegexp :
+	//case CommandAction :
+	if (value.text == "") return;
+        break;
+    }
+
+  if (discarded) discarded_text = " (discarded by override)";
+  else discarded_text = "";
+
+  if (first_definition) define_text = "defines";
+  else define_text = "overrides";
+
+  cout << "# Package ";
+  if (use != 0)
+    {
+      cout << use->get_package_name () << " " << use->version;
+    }
+
+  switch (command_type)
+    {
+      case CommandSet :
+        cout << " " << define_text << " set " << symbol.name << " as ";
+        first_definition = false;
+        break;
+      case CommandSetAppend :
+        cout << " appends to set " << symbol.name << " : ";
+        break;
+      case CommandSetPrepend :
+        cout << " prepends to set " << symbol.name << " : ";
+        break;
+      case CommandSetRemove :
+        cout << " removes from set " << symbol.name << " : ";
+        break;
+      case CommandSetRemoveRegexp :
+        cout << " removes RE from set " << symbol.name << " : ";
+        break;
+      case CommandAlias :
+        cout << " " << define_text << " alias " << symbol.name << " as ";
+        first_definition = false;
+        break;
+      case CommandPath :
+        cout << " " << define_text << " path " << symbol.name << " as ";
+        first_definition = false;
+        break;
+      case CommandPathAppend :
+        cout << " appends to path " << symbol.name << " : ";
+        break;
+      case CommandPathPrepend :
+        cout << " prepends to path " << symbol.name << " : ";
+        break;
+      case CommandPathRemove :
+        cout << " removes from path " << symbol.name << " : ";
+        break;
+      case CommandPathRemoveRegexp :
+        cout << " removes RE from path " << symbol.name << " : ";
+        break;
+      case CommandMacroPrepend :
+        cout << " prepends to macro " << symbol.name << " : ";
+        break;
+      case CommandMacro :
+        cout << " " << define_text << " macro " << symbol.name << " as ";
+        break;
+      case CommandMacroAppend :
+        cout << " appends to macro " << symbol.name << " : ";
+        break;
+      case CommandMacroRemove :
+        cout << " remove from macro " << symbol.name << " : ";
+        break;
+      case CommandMacroRemoveRegexp :
+        cout << " remove RE from macro " << symbol.name << " : ";
+        break;
+      case CommandMacroRemoveAll :
+        cout << " remove all from macro " << symbol.name << " : ";
+        break;
+      case CommandMacroRemoveAllRegexp :
+        cout << " remove all RE from macro " << symbol.name << " : ";
+        break;
+      case CommandAction :
+        cout << " " << define_text << " action " << symbol.name << " as ";
+        first_definition = false;
+        break;
+    }
+
+  cout << "'" << value.text << "'";
+          
+  Tag* selected_tag = value.tag;
+          
+  if ((selected_tag == 0) ||
+      (selected_tag == Tag::get_default ()))
+    {
+      cout << " for default tag";
+    }
+  else
+    {
+      cout << " for tag '" << selected_tag->get_name () << "'";
+    }
+  
+  cout << discarded_text << endl;
+}
+
+//-------------------------------------------------------------
+bool Symbol::check_tag_used (Tag* tag)
+{
+  if (tag == 0) return (false);
+
+  static SymbolVector& Symbols = symbols ();
+
+  if (Symbols.size () == 0) 
+    {
+      return (false);
+    }
+
+  for (int number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+
+      for (int i = 0; i < symbol.value_lists.size (); i++)
+	{
+	  const SymbolValueList& value_list = symbol.value_lists[i];
+
+	  for (int j = 0; j < value_list.values.size (); j++)
+	    {
+	      const SymbolValue& value = value_list.values[j];
+	      Tag* t = value.tag;
+
+	      if (t != 0)
+		{
+		  if (t->use_operand (tag)) return (true);
+		}
+	    }
+	}
+    }
+
+  return (false);
+}
+
+//-------------------------------------------------------------
+cmt_string Symbol::get_env_value (const cmt_string& name)
+{
+  cmt_string s;
+
+  Symbol* symbol = Symbol::find (name);
+  if (symbol != 0)
+    {
+      m_inhibit_display = true;
+
+      s = symbol->build_macro_value ();
+      Symbol::expand (s);
+
+      m_inhibit_display = false;
+    }
+  else
+    {
+      s = CmtSystem::getenv (name);
+    }
+
+  return (s);
+}
+
+bool Symbol::get_inhibit_display ()
+{
+  return (m_inhibit_display);
+}
+
Index: /CMT/v1r20/source/cmt_symbol.h
===================================================================
--- /CMT/v1r20/source/cmt_symbol.h	(revision 368)
+++ /CMT/v1r20/source/cmt_symbol.h	(revision 368)
@@ -0,0 +1,140 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_symbol_h__
+#define __cmt_symbol_h__
+
+#include "cmt_tag.h"
+#include "cmt_use.h"
+#include "cmt_map.h"
+
+class SymbolValue
+{
+public:
+  typedef cmt_vector<SymbolValue> SymbolValueVector;
+
+  SymbolValue ();
+  ~SymbolValue ();
+
+  Tag* tag;
+  cmt_string text;         /* A symbol value is created only if */
+                           /* its text is non empty */
+  int selected;
+};
+
+class SymbolValueList
+{
+public:
+  typedef cmt_vector<SymbolValueList> SymbolValueListVector;
+
+  int select_first (const cmt_string& tag_name = "") const;
+  int select_last () const;
+  void show (const Symbol& symbol, const SymbolValue& value, bool& first_definition) const;
+
+  CommandType command_type;
+  Use* use;
+  SymbolValue::SymbolValueVector values;
+  bool is_reflexive;
+  bool discarded;
+};
+
+class Symbol;
+
+class ValueBuilder
+{
+public:
+  ValueBuilder ();
+  const cmt_string build_and_display (const Symbol& symbol);
+
+  virtual const cmt_string build (const Symbol& symbol,
+                                  const cmt_string& tag_name = "") = 0;
+  virtual const cmt_string clean (const Symbol& symbol,
+                                  const cmt_string& tag_name = "") = 0;
+ protected:
+  bool m_display_it;
+};
+
+class Symbol
+{
+public:
+  typedef cmt_vector<Symbol> SymbolVector;
+  typedef cmt_map<cmt_string, Symbol> SymbolMap;
+
+  typedef enum
+    {
+      SymbolUndefined,
+      SymbolAction,
+      SymbolAlias,
+      SymbolMacro,
+      SymbolSetupScript,
+      SymbolCleanupScript,
+      SymbolSet,
+      SymbolPath
+    } SymbolType;
+
+  static Symbol* create (const cmt_string& name,
+                         CommandType command,
+                         Use* use = 0);
+  
+  static Symbol* find (const cmt_string& name);
+  static void action (const CmtSystem::cmt_string_vector& words,
+                      CommandType command_type,
+                      Use* use);
+  static int is_selected (const cmt_string& name);
+
+  static void all_set ();
+  static void all_print (PrintMode mode);
+  static void all_print_clean (PrintMode mode);
+  static void check_all_paths ();
+
+  static int symbol_number ();
+  static SymbolVector& symbols ();
+  static SymbolMap& symbol_map ();
+  static Symbol& symbol (int index);
+  static void clear_all ();
+  static void expand (cmt_string& text);
+
+  static void filter_path_value (const cmt_string& name, cmt_string& text);
+
+  static bool check_tag_used (Tag* tag);
+
+  static cmt_string get_env_value (const cmt_string& name);
+
+  static bool get_inhibit_display ();
+
+public:
+  Symbol ();
+  ~Symbol ();
+  bool value_is_reflexive (const cmt_string& text) const;
+  void add_value_to_list (CommandType command_type,
+                          Use* use,
+                          Tag* tag,
+                          const cmt_string& text);
+
+  int print_clean (PrintMode mode);
+  int print (PrintMode mode);
+  cmt_string build_macro_value (bool display_it = false) const;
+  cmt_string clean_macro_value () const;
+  cmt_string resolve_macro_value (const cmt_string& tag_name = "");
+  void show_macro (PrintMode mode);
+
+  ValueBuilder* builder;
+
+  cmt_string name;
+  ScopeType scope;
+  SymbolType type;
+
+  SymbolValueList::SymbolValueListVector value_lists;
+
+  int selected_value;        /* according to the last selected tag */
+
+private:
+
+  static bool m_inhibit_display;  // Global inhibitor of any display
+
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_syntax.cxx
===================================================================
--- /CMT/v1r20/source/cmt_syntax.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_syntax.cxx	(revision 368)
@@ -0,0 +1,1949 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include "cmt_syntax.h"
+#include "cmt.h"
+#include "cmt_symbol.h"
+#include "cmt_constituent.h"
+#include "cmt_pattern.h"
+#include "cmt_error.h"
+#include "cmt_branch.h"
+#include "cmt_error.h"
+#include "cmt_script.h"
+#include "cmt_language.h"
+#include "cmt_project.h"
+#include "cmt_cmtpath_pattern.h"
+
+
+class KwdAction : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandAction, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdAlias : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandAlias, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdApplication : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use == &(Use::current ()))
+    {
+	    Constituent::action (Application, words);
+     }
+  }
+  
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdApplyPattern : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    ApplyPattern::action (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdApplyTag : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Tag::action_apply (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+                    action (words, project->get_use(), file_name, line_number);    
+      }
+
+};
+
+//----------------------------------------------------------
+class KwdAuthor : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    use->author_action (words);
+
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+      cmt_string author;
+      project->project_author_action (words);
+  }
+};
+//----------------------------------------------------------
+
+
+class KwdBranches : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use == &(Use::current ())) 
+      {
+	Branch::action (words);
+      }
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdBuildStrategy : public Kwd
+{
+public:
+  bool decode (const cmt_string& w, cmt_string& strategy, cmt_string& value)
+  {
+    bool result = true;    
+     
+    value =  w;  
+    
+    /*Symbol* symbol = Symbol::find ("use_strategy");
+    if (symbol != 0)
+    {
+      cmt_string s = symbol->build_macro_value ();
+      Symbol::expand (s);
+      cerr <<"# value s: "<<s<<endl;      
+    } */ 
+
+    Symbol::expand(value);
+    //cerr <<"# value: "<<value<<endl;
+    
+    if (value == "prototypes")
+      {
+	strategy = "BuildPrototypes";
+      }
+    else if (value == "no_prototypes")
+      {
+	strategy = "BuildPrototypes";
+      }
+    else if ((value == "with_installarea") || (value == "with_install_area"))
+      {
+	value = "with_installarea";
+	strategy = "InstallArea";
+      }
+    else if ((value == "without_installarea") || (value == "without_install_area"))
+      {
+	value = "without_installarea";
+	strategy = "InstallArea";
+      }
+    else
+      {
+	result = false;
+      }
+
+    return (result);
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+        
+    cmt_string cmtpath;
+    cmt_string offset;
+
+    use->get_cmtpath_and_offset (cmtpath, offset);
+
+    Project* p = Project::find_by_cmtpath (cmtpath);
+
+    for (int i = 1; i < words.size (); i++)
+      {
+	       const cmt_string& w = words[i];
+
+	       cmt_string strategy;
+	       cmt_string value;
+
+	       bool in_error = false;
+
+	       if (decode (w, strategy, value))
+	       {
+	           
+	           if (p != 0) p->set_strategy (strategy, value, use->get_package_name ());
+	  }
+	else
+	  {
+	    in_error = true;
+
+	    CmtError::set (CmtError::syntax_error, "ParseRequirements> bad strategy keyword");
+	  }
+      }
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Project* project,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+      
+      // action (words, project->get_use(), file_name, line_number);
+      // cout<<project->get_use()->get_strategy("InstallArea")<<endl;   
+  
+            
+      for (int i = 1; i < words.size (); i++)
+      {
+	       const cmt_string& w = words[i];
+
+	       cmt_string strategy;
+	       cmt_string value;
+
+	bool in_error = false;
+
+	if (decode (w, strategy, value))
+	  {
+	    if (project != 0) 
+	    {
+	       // project->set_strategy (strategy, value, project->get_use()->get_package_name ());
+	       project->set_strategy (strategy, value, "");
+	       cmt_string s  = "build_strategy ";
+           s             += words[i];
+           s             += "\n";            
+	       bool no_found = true;	                 
+           int size =  project->m_extra_lines.size ();
+           for (int n = 0; n < size; n++)
+           {
+            if (s==project->m_extra_lines[n])
+                no_found = false;
+           }
+           if (no_found)         
+           {  
+    	      cmt_string & buffer = project->m_extra_lines.add();           
+    	      buffer = s;
+           }
+	    }  
+	  }
+	else
+	  {
+	    in_error = true;
+
+	    CmtError::set (CmtError::syntax_error, "ParseRequirements> bad strategy keyword");
+	  }
+      }
+  }
+};
+
+class KwdCleanupScript : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Script::action (words, CleanupScript, use);
+    Symbol::action (words, CommandCleanupScript, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdCmtPathPattern : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& /*file_name*/,
+	       int /*line_number*/)
+  {
+    CmtPathPattern::action (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdCmtPathPatternRevert : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& /*file_name*/,
+	       int /*line_number*/)
+  {
+    CmtPathPattern::action (words, use, true);
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdContainer : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Project* project,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    project->container_action (words[1], words[2]);
+  }
+};
+
+class KwdDocument : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use == &(Use::current ()))
+      {
+	Constituent::action (Document, words);
+      }
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdEndPrivate : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use != &(Use::current ()))
+      {
+	use->pop_scope_section ();
+      }
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdEndPublic : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use != &(Use::current ()))
+      {
+	use->pop_scope_section ();
+      }
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdIgnorePattern : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    IgnorePattern::action (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdIncludeDirs : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Include::action (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdIncludePath : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (words.size () > 1)
+      {
+	use->set_include_path (words[1]);
+      }
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdLanguage : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Language::action (words);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdLibrary : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use == &(Use::current ()))
+      {
+	Constituent::action (Library, words);
+      }
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdMacro : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandMacro, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+        action (words, project->get_use(), file_name, line_number);    
+  }
+};
+
+class KwdMacroPrepend : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandMacroPrepend, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+            action (words, project->get_use(), file_name, line_number);
+      }
+};
+
+class KwdMacroAppend : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandMacroAppend, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+            action (words, project->get_use(), file_name, line_number);
+      }
+};
+
+class KwdMacroRemove : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandMacroRemove, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+            action (words, project->get_use(), file_name, line_number);
+      }
+};
+
+class KwdMacroRemoveRegexp : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandMacroRemoveRegexp, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  
+  {
+            action (words, project->get_use(), file_name, line_number);
+      }
+};
+
+class KwdMacroRemoveAll : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandMacroRemoveAll, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+            action (words, project->get_use(), file_name, line_number);
+      }
+};
+
+class KwdMacroRemoveAllRegexp : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandMacroRemoveAllRegexp, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+            action (words, project->get_use(), file_name, line_number);
+      }
+};
+
+class KwdMakeFragment : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Fragment::action (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdManager : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    use->manager_action (words);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdPackage : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    /*
+    if (words.size () > 1)
+      {
+	if (use == &(Use::current()))
+	  {
+	    m_current_package = words[1];
+	    build_prefix (m_current_package, m_current_prefix);
+	    
+	    if ((use->get_package_name () != "") &&
+		(use->get_package_name () != m_current_package))
+	      {
+		if (!m_quiet)
+		  {
+		    //  cerr << "#CMT> package name mismatch in requirements of " <<
+		    //  use->get_package_name () << " " <<
+		    //  use->version << " line #" << line_number;
+                    //  cerr << " : " << m_current_package << " versus " <<
+		    //  use->get_package_name () << endl;
+		  }
+	      }
+	    
+	    use->set (m_current_package,
+		      m_current_version,
+		      m_current_path,
+		      "",
+		      "");
+	    
+	    use->change_path (m_current_path);
+	    use->style = m_current_style;
+	  }
+      }
+    */
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdPath : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandPath, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+
+};
+
+class KwdPathAppend : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandPathAppend, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdPathPrepend : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandPathPrepend, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+  
+class KwdPathRemove : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandPathRemove, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}  
+};
+
+class KwdPathRemoveRegexp : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandPathRemoveRegexp, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}  
+};
+
+class KwdPattern : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Pattern::action (words, use);
+  }
+   void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}   
+};
+
+class KwdPrivate : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use != &(Use::current ()))
+      {
+	use->push_scope_section (ScopePrivate);
+      }
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}  
+};
+
+class KwdProject : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Project* project,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+  } 
+};
+
+class KwdPublic : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    if (use != &(Use::current ()))
+      {
+	use->push_scope_section (ScopePublic);
+      }
+  }
+   void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}   
+};
+
+class KwdSet : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandSet, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}    
+};
+
+class KwdSetAppend : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandSetAppend, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}    
+};
+
+class KwdSetPrepend : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandSetPrepend, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}    
+};
+
+class KwdSetRemove : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandSetRemove, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}    
+};
+
+class KwdSetRemoveRegexp : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Symbol::action (words, CommandSetRemoveRegexp, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}  
+};
+
+class KwdSetupScript : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Script::action (words, SetupScript, use);
+    Symbol::action (words, CommandSetupScript, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdSetupStrategy : public Kwd
+{
+public:
+  bool decode (const cmt_string& w, cmt_string& strategy, cmt_string& value)
+  {
+    bool result = true;
+
+    value =  w; 
+    Symbol::expand(value);
+
+
+    if (value == "config")
+      {
+	strategy = "SetupConfig";
+      }
+    else if (value == "no_config")
+      {
+	strategy = "SetupConfig";
+      }
+    else if (value == "root")
+      {
+	strategy = "SetupRoot";
+      }
+    else if (value == "no_root")
+      {
+	strategy = "SetupRoot";
+      }
+    else if (value == "cleanup")
+      {
+	strategy = "SetupCleanup";
+      }
+    else if (value == "no_cleanup")
+      {
+	strategy = "SetupCleanup";
+      }
+    else
+      {
+	result = false;
+      }
+
+    return (result);
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    cmt_string cmtpath;
+    cmt_string offset;
+
+    use->get_cmtpath_and_offset (cmtpath, offset);
+
+    Project* p = Project::find_by_cmtpath (cmtpath);
+
+    for (int i = 1; i < words.size (); i++)
+      {
+	const cmt_string& w = words[i];
+
+	cmt_string strategy;
+	cmt_string value;
+
+	bool in_error = false;
+
+	if (decode (w, strategy, value))
+	  {
+	    if (p != 0) p->set_strategy (strategy, value, use->get_package_name ());
+	  }
+	else
+	  {
+	    in_error = true;
+
+	    CmtError::set (CmtError::syntax_error, "ParseRequirements> bad strategy keyword");
+	  }
+      }
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Project* project,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    for (int i = 1; i < words.size (); i++)
+      {
+	const cmt_string& w = words[i];
+
+	cmt_string strategy;
+	cmt_string value;
+
+	bool in_error = false;
+
+	if (decode (w, strategy, value))
+	  {
+	    if (project != 0) project->set_strategy (strategy, value, "");
+        cmt_string s  = "setup_strategy ";
+        s             += words[i];
+        s             += "\n";            
+        bool no_found = true;	                 
+        int size =  project->m_extra_lines.size ();
+        for (int n = 0; n < size; n++)
+        {
+        if (s==project->m_extra_lines[n])
+            no_found = false;
+        }
+        if (no_found)         
+        {  
+	      cmt_string & buffer = project->m_extra_lines.add();           
+	      buffer = s;
+        }	    
+	  }
+	else
+	  {
+	    in_error = true;
+
+	    CmtError::set (CmtError::syntax_error, "ParseRequirements> bad strategy keyword");
+	  }
+      }
+  }
+};
+
+class KwdStructureStrategy : public Kwd
+{
+public:
+  bool decode (const cmt_string& w, cmt_string& strategy, cmt_string& value)
+  {
+    bool result = true;
+
+    value = w;
+    Symbol::expand(value);
+
+    if (value == "with_version_directory")
+      {
+	strategy = "VersionDirectory";
+      }
+    else if (value == "without_version_directory")
+      {
+	strategy = "VersionDirectory";
+      }
+    else
+      {
+	result = false;
+      }
+
+    return (result);
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    cmt_string cmtpath;
+    cmt_string offset;
+
+    use->get_cmtpath_and_offset (cmtpath, offset);
+
+    Project* p = Project::find_by_cmtpath (cmtpath);
+
+    for (int i = 1; i < words.size (); i++)
+      {
+	const cmt_string& w = words[i];
+
+	cmt_string strategy;
+	cmt_string value;
+
+	bool in_error = false;
+
+	if (decode (w, strategy, value))
+	  {
+	    if (p != 0) p->set_strategy (strategy, value, use->get_package_name ());
+	  }
+	else
+	  {
+	    in_error = true;
+
+	    CmtError::set (CmtError::syntax_error, "ParseRequirements> bad strategy keyword");
+	  }
+      }
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Project* project,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    for (int i = 1; i < words.size (); i++)
+      {
+	const cmt_string& w = words[i];
+
+	cmt_string strategy;
+	cmt_string value;
+
+	bool in_error = false;
+
+	if (decode (w, strategy, value))
+	  {
+	    if (project != 0) project->set_strategy (strategy, value, "");
+	    cmt_string s  = "structure_strategy ";
+        s             += words[i];
+        s             += "\n";            
+        bool no_found = true;	                 
+        int size =  project->m_extra_lines.size ();
+        for (int n = 0; n < size; n++)
+        {
+        if (s==project->m_extra_lines[n])
+            no_found = false;
+        }
+        if (no_found)         
+        {  
+	      cmt_string & buffer = project->m_extra_lines.add();           
+	      buffer = s;
+        }	    
+
+	  }
+	else
+	  {
+	    in_error = true;
+
+	    CmtError::set (CmtError::syntax_error, "ParseRequirements> bad strategy keyword");
+	  }
+      }
+  }
+};
+
+class KwdTag : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Tag::action (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+    action (words, project->get_use(), file_name, line_number);    
+  }  
+};
+
+class KwdTagExclude : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Tag::action_exclude (words, use);
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {
+              action (words, project->get_use(), file_name, line_number);    
+      }  
+};
+
+class KwdUse : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    Use::action (words, use);
+  }
+
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Project* project,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    project->use_action (words[1], words[2]);
+  }
+};
+
+class KwdVersionStrategy : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    cerr << "# Package " << use->get_package_name () <<
+      " sets obsolescent version strategy" << endl;
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdVersion : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+  }
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {}
+};
+
+class KwdDefault : public Kwd
+{
+public:
+  void action (const CmtSystem::cmt_string_vector& words,
+	       Use* use,
+	       const cmt_string& file_name,
+	       int line_number)
+  {
+    /*
+      Unknown keyword : just ignore the line
+    */
+    if (!Cmt::get_quiet ())
+      {
+	cerr << "#CMT> bad syntax in requirements of " << use->get_package_name ()
+	     << " " << use->version << " line #" << line_number;
+	cerr << " [" << words[0] << "...]" << endl;
+      }
+    
+    CmtError::set (CmtError::syntax_error, "ParseRequirements> ");
+  }
+  
+  void action (const CmtSystem::cmt_string_vector& words,
+		  Project* project,
+		  const cmt_string& file_name,
+		  int line_number)
+  {action (words, project->get_use(), file_name, line_number);}
+};
+
+SyntaxParser& SyntaxParser::instance ()
+{
+  static SyntaxParser p;
+
+  return (p);
+}
+
+/**
+ *  Parse the input file, rejecting comments and
+ * rebuilding complete lines (from sections separated by
+ *  \ characters.
+ *
+ *  Each reformatted line is parsed by filter_line
+ */
+void SyntaxParser::parse_requirements (const cmt_string& file_name, Use* use)
+{
+  SyntaxParser& me = instance ();
+
+  if (use != 0)
+    {
+      cmt_string buffer;
+
+      use->fill_standard_macros (buffer);
+
+      AccessMode saved_current_access = Cmt::get_current_access ();
+      Cmt::set_current_access (UserMode);
+      me.do_parse_text (buffer, "", package_context, use, 0);
+      Cmt::set_current_access (saved_current_access);
+    }
+
+  me.do_parse_requirements (file_name, use);
+
+
+  if (use != 0)
+  {
+        //
+         
+        Project* p = use->get_project ();
+        if (p != 0)
+        {      
+           Use* p_use =  p->get_use();
+           if (p_use != 0 && p_use != use)
+           {
+              
+              //{
+              //  int  size  = use->sub_uses.size ();
+              //  for (int n = 0; n < size; n++)
+              //  {
+              //      Use* tuse = use->sub_uses[n];
+              //      cerr << "\tpackage file [" << tuse->get_package_name() << "]" <<p_use->get_package_name()<< endl;         
+              //  }
+              //}
+              
+              // add the dependency
+              use->add_sub_use (p_use);
+              
+              // add the right extra statements
+              {
+                int size =  p->m_extra_lines.size ();
+                for (int n = 0; n < size; n++)
+                {
+                    cmt_string& s = p->m_extra_lines[n];
+                    SyntaxParser::parse_requirements_line (s, use);
+                }  
+              } 
+              
+              // Fill other values                
+              use->sub_use_scopes.push_back (use->get_current_scope ());
+              use->sub_use_auto_imports.push_back (p_use->auto_imports);
+              // cmt_string& request = use->requests.add ();                                          
+              // request = package_name;
+              // request += " ";
+              // request += version;
+              // request += " ";
+              // request += path;
+
+             // add at the uses level ?????
+            static Use::UsePtrVector& uses = Use::get_ordered_uses ();
+            //const Use& cu = Use::current ();
+
+            bool found = false;
+            int  size  = uses.size ();
+            // cerr << "\n size:"<<size<< ":" << endl;     
+            for (int n = 0; n < size; n++)
+            {
+                Use* tuse = uses[n];
+                // cerr << "\tpackage file [" << tuse->get_package_name() << "]" <<p_use->get_package_name()<< endl;                    
+                if (tuse->get_package_name()==p_use->get_package_name())
+                   found=true;
+            }    
+            if (not found)
+            {
+                  uses.push_back (p_use);
+                p_use->m_index = uses.size () - 1;
+             }
+                          
+           }
+        }                 
+        use->close_scope_sections ();
+  }
+}
+
+/**
+ */
+void SyntaxParser::parse_project_file_text (const cmt_string& text,
+					    const cmt_string& file_name,
+					    Project* project)
+{
+  SyntaxParser& me = instance ();
+  me.do_parse_text (text, file_name, project_context, 0, project);
+}
+
+/**
+ *  Parse a text, rejecting comments and
+ * rebuilding complete lines (from sections separated by
+ *  \ characters.
+ *
+ *  Each reformatted line is parsed by filter_line
+ */
+void SyntaxParser::parse_requirements_text (const cmt_string& text,
+					    const cmt_string& file_name,
+					    Use* use)
+{
+  SyntaxParser& me = instance ();
+
+    /**
+     *
+     *    We have to preserve m_current_access since it reflects whether
+     *   the current cmt action is run in the context of the current package.
+     *   (the opposite is when the cmt command specifies the current package
+     *    in its arguments -use=... therefore the pwd is NOT the directory
+     *    of the current package)
+     *
+     *   m_current_access is Developer when pwd =  current
+     *                       User      when pwd != current
+     *
+     *    Therefore, as soon as we reach a used package, this must be switched to User
+     *
+     *   On the other hand, Cmt::scope reflects the status of the public/private 
+     *  statements. By default, we are in public context when entering a new requirements
+     *  file.
+     *
+     */
+
+  AccessMode saved_current_access;
+
+  saved_current_access = Cmt::get_current_access ();
+
+  if (use == 0) use = &(Use::current ());
+
+  if (use != &(Use::current ()))
+    {
+      if (Cmt::get_debug ())
+	{
+	  cout << "parse_requirements_text> set UserMode" << endl;
+	}
+
+      Cmt::set_current_access (UserMode);
+    }
+  else
+    {
+      if (Cmt::get_debug ())
+	{
+	  cout << "parse_requirements_text> set DeveloperMode" << endl;
+	}
+
+      Cmt::set_current_access (DeveloperMode);
+    }
+
+  me.do_parse_text (text, file_name, package_context, use, 0);
+
+  Cmt::set_current_access (saved_current_access);
+}
+
+/**
+ *  Apply the basic parser to one single line :
+ *
+ *   o Append to global text if previous back_slash
+ *   o Split into words
+ *   o Apply the generic Select operator
+ */
+void SyntaxParser::parse_requirements_line (const cmt_string& line,
+					    Use* use,
+					    const cmt_string& file_name,
+					    int line_number)
+{
+  SyntaxParser& me = instance ();
+  me.do_parse_line (line, file_name, line_number, package_context, use, 0);
+}
+
+SyntaxParser::SyntaxParser ()
+{
+  m_keywords.add ("action", new KwdAction ());
+  m_keywords.add ("alias", new KwdAlias ());
+  m_keywords.add ("application", new KwdApplication ());
+  m_keywords.add ("apply_pattern", new KwdApplyPattern ());
+  m_keywords.add ("apply_tag", new KwdApplyTag ());
+  m_keywords.add ("author", new KwdAuthor ());
+  m_keywords.add ("branches", new KwdBranches ());
+  m_keywords.add ("build_strategy", new KwdBuildStrategy ());
+  m_keywords.add ("cleanup_script", new KwdCleanupScript ());
+  m_keywords.add ("cmtpath_pattern", new KwdCmtPathPattern ());
+  m_keywords.add ("cmtpath_pattern_reverse", new KwdCmtPathPatternRevert ());
+  m_keywords.add ("document", new KwdDocument ());
+  m_keywords.add ("end_private", new KwdEndPrivate ());
+  m_keywords.add ("end_public", new KwdEndPublic ());
+  m_keywords.add ("ignore_pattern", new KwdIgnorePattern ());
+  m_keywords.add ("include_dirs", new KwdIncludeDirs ());
+  m_keywords.add ("include_path", new KwdIncludePath ());
+  m_keywords.add ("language", new KwdLanguage ());
+  m_keywords.add ("library", new KwdLibrary ());
+  m_keywords.add ("macro", new KwdMacro ());
+  m_keywords.add ("macro+", new KwdMacroAppend ());
+  m_keywords.add ("macro_prepend", new KwdMacroPrepend ());
+  m_keywords.add ("macro_append", new KwdMacroAppend ());
+  m_keywords.add ("macro_remove", new KwdMacroRemove ());
+  m_keywords.add ("macro_remove_regexp", new KwdMacroRemoveRegexp ());
+  m_keywords.add ("macro_remove_all", new KwdMacroRemoveAll ());
+  m_keywords.add ("macro_remove_all_regexp", new KwdMacroRemoveAllRegexp ());
+  m_keywords.add ("make_fragment", new KwdMakeFragment ());
+  m_keywords.add ("manager", new KwdManager ());
+  m_keywords.add ("package", new KwdPackage ());
+  m_keywords.add ("path", new KwdPath ());
+  m_keywords.add ("path_append", new KwdPathAppend ());
+  m_keywords.add ("path_prepend", new KwdPathPrepend ());
+  m_keywords.add ("path_remove", new KwdPathRemove ());
+  m_keywords.add ("path_remove_regexp", new KwdPathRemoveRegexp ());
+  m_keywords.add ("pattern", new KwdPattern ());
+  m_keywords.add ("public", new KwdPublic ());
+  m_keywords.add ("private", new KwdPrivate ());
+  m_keywords.add ("project", new KwdProject ());
+  m_keywords.add ("set", new KwdSet ());
+  m_keywords.add ("set_append", new KwdSetAppend ());
+  m_keywords.add ("set_prepend", new KwdSetPrepend ());
+  m_keywords.add ("set_remove", new KwdSetRemove ());
+  m_keywords.add ("set_remove_regexp", new KwdSetRemoveRegexp ());
+  m_keywords.add ("setup_script", new KwdSetupScript ());
+  m_keywords.add ("setup_strategy", new KwdSetupStrategy ());
+  m_keywords.add ("structure_strategy", new KwdStructureStrategy ());
+  m_keywords.add ("tag", new KwdTag ());
+  m_keywords.add ("tag_exclude", new KwdTagExclude ());
+  m_keywords.add ("use", new KwdUse ());
+  m_keywords.add ("version_strategy", new KwdVersionStrategy ());
+  m_keywords.add ("version", new KwdVersion ());
+
+  m_project_keywords.add ("author", new KwdAuthor());
+  m_project_keywords.add ("apply_tag", new KwdApplyTag ());
+  m_project_keywords.add ("build_strategy", new KwdBuildStrategy ());
+  m_project_keywords.add ("container", new KwdContainer ());
+  m_project_keywords.add ("macro", new KwdMacro ());
+  // m_project_keywords.add ("macro+", new KwdMacroAppend ());
+  // m_project_keywords.add ("macro_prepend", new KwdMacroPrepend ());
+  // m_project_keywords.add ("macro_append", new KwdMacroAppend ());
+  //m_project_keywords.add ("macro_remove", new KwdMacroRemove ());
+  //m_project_keywords.add ("macro_remove_regexp", new KwdMacroRemoveRegexp ());
+  //m_project_keywords.add ("macro_remove_all", new KwdMacroRemoveAll ());
+  //m_project_keywords.add ("macro_remove_all_regexp", new KwdMacroRemoveAllRegexp ());
+
+  m_project_keywords.add ("project", new KwdProject ());
+  m_project_keywords.add ("setup_strategy", new KwdSetupStrategy ());
+  
+  m_project_keywords.add ("tag", new KwdTag ());
+  //m_project_keywords.add ("tag_exclude", new KwdTagExclude ());
+
+  
+  m_project_keywords.add ("structure_strategy", new KwdStructureStrategy ());
+  m_project_keywords.add ("use", new KwdUse ());
+}
+
+void SyntaxParser::do_parse_requirements (const cmt_string& file_name, Use* use)
+{
+  cmt_string actual_file_name = file_name;
+  cmt_string text;
+
+  CmtError::clear ();
+
+  if (!CmtSystem::test_file (actual_file_name))
+    {
+      actual_file_name = "..";
+      actual_file_name += CmtSystem::file_separator ();
+      actual_file_name += "cmt";
+      actual_file_name += CmtSystem::file_separator ();
+      actual_file_name += file_name;
+
+      if (!CmtSystem::test_file (actual_file_name))
+        {
+          actual_file_name = "..";
+          actual_file_name += CmtSystem::file_separator ();
+          actual_file_name += "mgr";
+          actual_file_name += CmtSystem::file_separator ();
+          actual_file_name += file_name;
+
+          if (!CmtSystem::test_file (actual_file_name))
+            {
+              return;
+            }
+        }
+    }
+
+  text.read (actual_file_name);
+
+  SyntaxParser::parse_requirements_text (text, actual_file_name, use);
+}
+
+/**
+ *  Parse a text, rejecting comments and
+ * rebuilding complete lines (from sections separated by
+ *  \ characters.
+ *
+ *  Each reformatted line is parsed by filter_line
+ */
+void SyntaxParser::do_parse_text (const cmt_string& text,
+				  const cmt_string& file_name,
+				  ContextType context,
+				  Use* use,
+				  Project* project)
+{
+  cmt_string line;
+  int pos;
+  int max_pos;
+  int line_number = 1;
+
+  if (context == package_context)
+    {
+      if (use == 0) use = &(Use::current ());
+    }
+
+  m_filtered_text.erase (0);
+
+  pos = 0;
+  max_pos = text.size ();
+
+  for (pos = 0; pos < max_pos;)
+    {
+      int cr = text.find (pos, "\r\n");
+      int nl = text.find (pos, '\n');
+      int first = nl;
+      int length = 1;
+
+      if (cr != cmt_string::npos)
+        {
+          if (nl == cmt_string::npos)
+            {
+              first = cr;
+              length = 2;
+            }
+          else
+            {
+              first = (nl < cr) ? nl : cr;
+              length = (nl < cr) ? 1 : 2;
+            }
+        }
+
+      if (first == cmt_string::npos)
+        {
+          text.substr (pos, line);
+          pos = max_pos;
+        }
+      else if (first > pos)
+        {
+          text.substr (pos, first - pos, line);
+          pos = first + length;
+        }
+      else
+        {
+          line.erase (0);
+          pos += length;
+        }
+
+      do_parse_line (line, file_name, line_number, context, use, project);
+
+      if ((Cmt::get_action () == action_check_configuration) && CmtError::has_pending_error ())
+        {
+          //break;
+        }
+
+      line_number++;
+    }
+}
+
+void SyntaxParser::do_parse_line (const cmt_string& line,
+				  const cmt_string& file_name,
+				  int line_number,
+				  ContextType context,
+				  Use* use,
+				  Project* project)
+{
+  int length;
+  int nl;
+  int back_slash;
+  cmt_string temp_line = line;
+
+  if (temp_line.size () == 0) return;
+  if (temp_line[0] == '#') return;
+
+  nl = temp_line.find_last_of ('\n');
+  if (nl != cmt_string::npos) temp_line.erase (nl);
+
+  length = temp_line.size ();
+  if (length == 0) return;
+
+  //
+  // We scan the line for handling backslashes.
+  //
+  // o Really terminating backslashes (ie those only followed by spaces/tabs
+  // mean continued line
+  //
+  //
+
+  bool finished = true;
+
+  length = temp_line.size ();
+
+  back_slash = temp_line.find_last_of ('\\');
+
+  if (back_slash != cmt_string::npos)
+    {
+      //
+      // This is the last backslash
+      // check if there are only space chars after it
+      //
+      
+      bool at_end = true;
+
+      for (int i = (back_slash + 1); i < length; i++)
+        {
+          char c = temp_line[i];
+          if ((c != ' ') && (c != '\t'))
+            {
+              at_end = false;
+              break;
+            }
+        }
+
+      if (at_end)
+        {
+          temp_line.erase (back_slash);
+          finished = false;
+        }
+      else
+        {
+          // This was not a trailing backslash.
+          finished = true;
+        }
+    }
+
+  m_filtered_text += temp_line;
+
+  if (!finished)
+    {
+      // We still need to accumulate forthcoming lines
+      // before parsing the resulting text.
+      return;
+    }
+
+  /*
+    Here a full line (possibly accumulating several lines
+    ended by backslashes) is parsed :
+    
+    o Special characters are filtered now :
+    
+    <cmt:tab/>  \t
+    <cmt:cr/>   \r
+    <cmt:lf/>   \n
+    
+    o Split into words (a word is a string not containing
+    spaces or enclosed in quotes)
+
+    o Parse the word array (function Select)
+
+  */
+
+  m_filtered_text.replace_all ("<cmt:tab/>", "\t");
+  m_filtered_text.replace_all ("<cmt:cr/>",  "\r");
+  m_filtered_text.replace_all ("<cmt:lf/>",  "\n");
+
+  if (Cmt::get_debug ())
+    {
+      cout << "parse_requirements_line [" << m_filtered_text << "]" << endl;
+    }
+  
+  static CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (m_filtered_text, " \t", words);
+  
+  if (words.size () != 0)
+    {
+      switch (context)
+	{
+	case project_context:
+	  do_parse_words (words, file_name, line_number, project);
+	  break;
+	case package_context:
+	  do_parse_words (words, file_name, line_number, use);
+	  break;
+	}
+    }
+  
+  m_filtered_text.erase (0);
+}
+
+void SyntaxParser::do_parse_words (const CmtSystem::cmt_string_vector& words,
+				   const cmt_string& file_name,
+				   int line_number,
+				   Use* use)
+{
+  CmtError::clear ();
+
+  if (words.size () == 0) return;
+
+  const cmt_string& command = words[0];
+
+  if (command.size () == 0) return;
+
+  //
+  // First analyze the syntax
+  //
+
+  Kwd* keyword = m_keywords.find (command);
+  if (keyword == 0)
+    {
+      /*
+
+	When the first word of the line is not a keyword, it may be an
+	implicit pattern application.
+
+       */
+
+      Pattern* p = Pattern::find (command);
+      if (p == 0)
+	{
+	  CmtError::set (CmtError::syntax_error, "ParseRequirements> ");
+	}
+      else
+	{
+	  keyword = m_keywords.find ("apply_pattern");
+	}
+    }
+
+  if (CmtError::has_pending_error ())
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cerr << "#CMT> bad syntax in requirements of " << use->get_package_name ()
+               << " " << use->version 
+               << " " << use->specified_path 
+               << " line #" << line_number;
+          cerr << " [" << command << " ...]" << endl;
+        }
+
+      return;
+    }
+
+  //
+  // Then interpret the action
+  //
+
+  keyword->action (words, use, file_name, line_number);
+}
+
+void SyntaxParser::do_parse_words (const CmtSystem::cmt_string_vector& words,
+				   const cmt_string& file_name,
+				   int line_number,
+				   Project* project)
+{
+  CmtError::clear ();
+
+  if (words.size () == 0) return;
+
+  const cmt_string& command = words[0];
+
+  if (command.size () == 0) return;
+
+  //
+  // First analyze the syntax
+  //
+
+  Kwd* keyword = m_project_keywords.find (command);
+  if (keyword == 0)
+    {
+      CmtError::set (CmtError::syntax_error, "ParseRequirements> ");
+    }
+
+  if (CmtError::has_pending_error ())
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cerr << "#CMT> bad syntax in project file of " << project->get_name ()
+               << " line #" << line_number;
+          cerr << " [" << command << " ...]" << endl;
+        }
+
+      return;
+    }
+
+  //
+  // Then interpret the action
+  //
+
+  keyword->action (words, project, file_name, line_number);
+}
Index: /CMT/v1r20/source/cmt_syntax.h
===================================================================
--- /CMT/v1r20/source/cmt_syntax.h	(revision 368)
+++ /CMT/v1r20/source/cmt_syntax.h	(revision 368)
@@ -0,0 +1,91 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_syntax_h__
+#define __cmt_syntax_h__
+
+#include "cmt_map.h"
+#include "cmt_string.h"
+#include "cmt_system.h"
+#include "cmt_use.h"
+#include "cmt_project.h"
+
+class Kwd
+{
+public:
+  virtual void action (const CmtSystem::cmt_string_vector& words,
+		       Use* use,
+		       const cmt_string& file_name,
+		       int line_number) = 0;
+
+  virtual void action (const CmtSystem::cmt_string_vector& words,
+		       Project* project,
+		       const cmt_string& file_name,
+		       int line_number) = 0;
+};
+
+class SyntaxParser
+{
+public:
+  static SyntaxParser& instance ();
+
+  static void parse_requirements (const cmt_string& file_name, Use* use);
+
+  static void parse_project_file_text (const cmt_string& text,
+				       const cmt_string& file_name,
+				       Project* project);
+
+  static void parse_requirements_text (const cmt_string& text,
+				       const cmt_string& file_name,
+				       Use* use);
+
+  static void parse_requirements_line (const cmt_string& line,
+				       Use* use,
+				       const cmt_string& file_name = "",
+				       int line_number = 0);
+
+private:
+
+  typedef enum
+    {
+      project_context,
+      package_context
+    } ContextType;
+
+  void do_parse_requirements (const cmt_string& file_name, Use* use);
+
+  void do_parse_text (const cmt_string& text,
+		      const cmt_string& file_name,
+		      ContextType context,
+		      Use* use,
+		      Project* project);
+
+  void do_parse_line (const cmt_string& line,
+		      const cmt_string& file_name,
+		      int line_number,
+		      ContextType context,
+		      Use* use,
+		      Project* project);
+
+  void do_parse_words (const CmtSystem::cmt_string_vector& words,
+		       const cmt_string& file_name,
+		       int line_number,
+		       Use* use);
+
+  void do_parse_words (const CmtSystem::cmt_string_vector& words,
+		       const cmt_string& file_name,
+		       int line_number,
+		       Project* project);
+
+  SyntaxParser ();
+  cmt_map <cmt_string, Kwd> m_keywords;
+  cmt_map <cmt_string, Kwd> m_project_keywords;
+  cmt_string m_filtered_text;
+};
+
+
+#endif
Index: /CMT/v1r20/source/cmt_system.cxx
===================================================================
--- /CMT/v1r20/source/cmt_system.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_system.cxx	(revision 368)
@@ -0,0 +1,2306 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#ifdef WIN32
+#include <direct.h>
+#define chdir _chdir
+#define rmdir _rmdir
+//#define mkdir _mkdir
+#define getcwd _getcwd
+#define popen _popen
+#define pclose _pclose
+#define S_IFDIR _S_IFDIR
+#define USE_GETCWD 1
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <io.h>
+#include <windows.h>
+
+#define stat _stat
+
+#else
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <dirent.h>
+#endif
+
+#ifdef __hpux__
+#define USE_GETCWD 1
+#endif
+
+#ifdef __linux__
+#define USE_GETCWD 1
+#endif
+
+#ifdef USE_GETCWD
+char* getwd (const char* name)
+{
+  char dir[256];
+  getcwd (dir, sizeof (dir));
+  strcpy ((char*) name, dir);
+  return ((char*) name);
+}
+#endif
+
+#include "cmt_system.h"
+#include "cmt_error.h"
+#include "cmt_map.h"
+
+//--------------------------------------------------
+cmt_string CmtSystem::pwd ()
+{
+  char buffer[256] = "";
+  char* ptr = 0;
+  char* pwd_env = 0;
+
+#ifdef USE_PWD
+  pwd_env = ::getenv ("PWD");  
+#endif
+
+  if (pwd_env != 0)
+    {
+      strcpy (buffer, pwd_env);
+    }
+  else
+    {
+      ptr = getcwd (buffer, sizeof (buffer));
+    }
+
+  const char* t = &buffer[0];
+  return ((cmt_string) t);
+}
+
+//--------------------------------------------------
+bool CmtSystem::cd (const cmt_string& dir)
+{
+  static cmt_string new_dir;
+
+  if ((dir.size () == 2) && (dir[1] == ':'))
+    {
+      new_dir = dir;
+      new_dir += file_separator ();
+      if (chdir (new_dir.c_str ()) == 0) 
+	{
+#ifdef USE_PWD
+	  new_dir = dir;
+	  new_dir += file_separator ();
+	  putenv ("PWD", new_dir);
+#endif
+
+	  return (true);
+	}
+      return (false);
+    }
+  else
+    {
+      if (chdir (dir.c_str ()) == 0) 
+	{
+#ifdef USE_PWD
+	  putenv ("PWD", dir);
+#endif
+
+	  return (true);
+	}
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+void CmtSystem::basename (const cmt_string& file_name, cmt_string& result)
+{
+  int pos = file_name.find_last_of ('/');
+  if (pos == cmt_string::npos)
+    {
+      pos = file_name.find_last_of ('\\');
+    }
+
+  if (pos == cmt_string::npos)
+    {
+      result = file_name;
+    }
+  else
+    {
+      file_name.substr (pos + 1, result);
+    }
+}
+
+//--------------------------------------------------
+void CmtSystem::basename (const cmt_string& file_name,
+                          const cmt_string& /*suffix*/,
+                          cmt_string& result)
+{
+  basename (file_name, result);
+
+  int pos;
+
+  pos = result.find_last_of ('.');
+
+  if (pos != cmt_string::npos)
+    {
+      result.erase (pos);
+    }
+}
+
+//--------------------------------------------------
+void CmtSystem::dirname (const cmt_string& file_name, cmt_string& result)
+{
+  int pos = file_name.find_last_of ('/');
+  if (pos == cmt_string::npos)
+    {
+      pos = file_name.find_last_of ('\\');
+    }
+
+  if (pos == cmt_string::npos)
+    {
+      result = "";
+    }
+  else
+    {
+      result = file_name;
+      result.erase (pos);
+    }
+}
+
+//--------------------------------------------------
+void CmtSystem::name (const cmt_string& file_name, cmt_string& result)
+{
+  int pos;
+
+  result = file_name;
+
+  // remove the suffix
+
+  pos = result.find_last_of ('.');
+
+  if (pos != cmt_string::npos)
+    {
+      result.erase (pos);
+    }
+
+  // remove the directory name
+
+  pos = result.find_last_of ('/');
+  if (pos == cmt_string::npos)
+    {
+      pos = result.find_last_of ('\\');
+    }
+
+  if (pos != cmt_string::npos)
+    {
+      result.erase (0, pos + 1);
+    }
+}
+
+//-------------------------------------------------
+void CmtSystem::get_suffix (const cmt_string& file, cmt_string& result)
+{
+  int pos = file.find_last_of ('.');
+  int sep = file.find_last_of (file_separator ());
+
+  if ((pos == cmt_string::npos) || (pos < sep))
+    {
+      result = "";
+    }
+  else
+    {
+      file.substr (pos + 1, result);
+    }
+}
+
+//-------------------------------------------------
+void CmtSystem::get_dot_suffix (const cmt_string& file, cmt_string& result)
+{
+  int pos = file.find_last_of ('.');
+  int sep = file.find_last_of (file_separator ());
+
+  if ((pos == cmt_string::npos) || (pos < sep))
+    {
+      result = "";
+    }
+  else
+    {
+      file.substr (pos, result);
+    }
+}
+
+//--------------------------------------------------
+bool CmtSystem::has_prefix (const cmt_string& name)
+{
+  if ((name.find ('/') == cmt_string::npos) &&
+      (name.find ('\\') == cmt_string::npos))
+    {
+      return (false);
+    }
+
+  return (true);
+}
+
+//--------------------------------------------------
+bool CmtSystem::realpath (const cmt_string& path, cmt_string& result)
+{
+  cmt_string here = CmtSystem::pwd ();
+  if  (test_directory(path))
+  {
+      CmtSystem::cd (path);
+      result = CmtSystem::pwd ();
+      CmtSystem::cd (here);
+      return true;
+   }
+   return false;
+}
+
+//--------------------------------------------------
+bool CmtSystem::absolute_path (const cmt_string& name)
+{
+  if (name.size () == 0) return (false);
+
+  if ((name[0] == '/') ||
+      (name[0] == '\\')) return (true);
+
+  if (name.size () >= 2)
+    {
+      if (name[1] == ':')
+        {
+          return (true);
+        }
+    }
+  return (false);
+}
+
+//--------------------------------------------------
+bool CmtSystem::has_device (const cmt_string& name)
+{
+#ifdef WIN32
+  if (name.size () == 0) return (false);
+
+  if (name.size () >= 2)
+    {
+      if (name[1] == ':')
+        {
+          return (true);
+        }
+      else if ((name[0] == '\\') && (name[1] == '\\'))
+        {
+          return (true);
+        }
+    }
+#endif
+
+  return (false);
+}
+
+//--------------------------------------------------
+cmt_string CmtSystem::current_branch ()
+{
+  cmt_string result;
+
+  basename (pwd (), result);
+
+  return (result);
+}
+
+//--------------------------------------------------
+bool CmtSystem::test_directory (const cmt_string& name)
+{
+  struct stat file_stat;
+  int status;
+
+  status = stat (name.c_str (), &file_stat);
+
+  //cerr << "status(stat) for " << name << " : " << status << " st_mode=" << file_stat.st_mode << endl;
+
+  if (status == 0)
+    {
+      if ((file_stat.st_mode & S_IFDIR) == 0)
+        {
+          return (false);
+        }
+      else
+        {
+          return (true);
+        }
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+bool CmtSystem::test_file (const cmt_string& name)
+{
+  struct stat file_stat;
+  int status;
+
+  status = stat (name.c_str (), &file_stat);
+
+  if (status == 0)
+    {
+      if ((file_stat.st_mode & S_IFDIR) == 0)
+        {
+          return (true);
+        }
+      else
+        {
+          return (false);
+        }
+    }
+  else
+    {
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+bool CmtSystem::compare_files (const cmt_string& name1,
+                               const cmt_string& name2)
+{
+  struct stat file_stat1;
+  struct stat file_stat2;
+  int status;
+
+  status = stat (name1.c_str (), &file_stat1);
+
+  if (status == 0)
+    {
+      if ((file_stat1.st_mode & S_IFDIR) != 0)
+        {
+          return (false);
+        }
+    }
+  else
+    {
+      return (false);
+    }
+
+  status = stat (name2.c_str (), &file_stat2);
+
+  if (status == 0)
+    {
+      if ((file_stat2.st_mode & S_IFDIR) != 0)
+        {
+          return (false);
+        }
+    }
+  else
+    {
+      return (false);
+    }
+
+  if (((int) file_stat1.st_size) != ((int) file_stat2.st_size))
+    {
+      return (false);
+    }
+
+  static cmt_string s1;
+  static cmt_string s2;
+
+  s1.read (name1);
+  s2.read (name2);
+
+  return ((s1 == s2));
+}
+
+//--------------------------------------------------
+//
+// Function use to change file timestamps
+//
+//--------------------------------------------------
+bool CmtSystem::touch_file (const cmt_string& name)
+{
+    if (CmtSystem::test_file(name))
+       {
+            static cmt_string s;
+            s.read (name);
+            //unlink  (name);            
+            FILE* f = fopen (name, "wb");
+            if (f != NULL)
+            {
+              s.write (f);
+              fclose (f);
+              return (true);
+            }
+            chmod (name.c_str(), 0777);
+/*            FILE* f = fopen (name, "a+");
+
+            if (f != NULL)
+            {
+                 cmt_string empty = " ";
+                 empty.write(f);
+                 
+                 fclose (f);
+                 return true;
+             }    
+*/             
+        }
+    return false;
+}
+    
+
+//--------------------------------------------------
+//
+// Check if the file "name1" is identical to "name2"
+// if they are identical, "name1" will be simply deleted
+// otherwise "name1" will be copied to "name2" and deleted afterwards
+//
+//--------------------------------------------------
+bool CmtSystem::compare_and_update_files (const cmt_string& name1,
+                                          const cmt_string& name2)
+{
+  struct stat file_stat1;
+  struct stat file_stat2;
+  static cmt_string s1;
+  static cmt_string s2;
+  int status;
+
+  status = stat (name1.c_str (), &file_stat1);
+
+  if (status == 0)
+    {
+      if ((file_stat1.st_mode & S_IFDIR) != 0)
+        {
+          // name1 is a directory.
+          return (false);
+        }
+    }
+  else
+    {
+      // name1 does not exist
+      return (false);
+    }
+
+  s1.read (name1);
+
+  status = stat (name2.c_str (), &file_stat2);
+
+  if (status == 0)
+    {
+      if ((file_stat2.st_mode & S_IFDIR) != 0)
+        {
+          // name2 is a directory
+          return (false);
+        }
+
+      if (((int) file_stat1.st_size) == ((int) file_stat2.st_size))
+        {
+          s2.read (name2);
+          if (s1 == s2)
+            {
+              unlink (name1);
+              return (true);
+            }
+        }
+    }
+
+  FILE* f = fopen (name2, "wb");
+  if (f != NULL)
+    {
+      s1.write (f);
+      fclose (f);
+
+      unlink (name1);
+
+      return (true);
+    }
+  else
+    {
+      //
+      // keep the new file "name1" since it cannot be
+      // copied to "name2"
+      //
+      return (false);
+    }
+}
+
+//--------------------------------------------------
+int CmtSystem::file_size (const cmt_string& name)
+{
+  struct stat file_stat;
+  int status;
+
+  status = stat (name.c_str (), &file_stat);
+
+  if (status == 0)
+    {
+      return ((int) file_stat.st_size);
+    }
+  else
+    {
+      return (0);
+    }
+}
+
+//--------------------------------------------------
+char CmtSystem::file_separator ()
+{
+#ifdef WIN32
+  return ('\\');
+#else
+  return ('/');
+#endif
+}
+
+/**
+ *  Transform all / or \ characters in the text into the current file_separator
+ *  Reduce all multiple file_separator into single ones.
+ */
+void CmtSystem::reduce_file_separators (cmt_string& text)
+{
+  if (file_separator () == '/')
+    {
+      text.replace_all ("\\", "/");
+      while (text.find ("//") != cmt_string::npos)
+	{
+	  text.replace_all ("//", "/");
+	}
+    }
+  else
+    {
+      text.replace_all ("/", "\\");
+      while (text.find ("\\\\") != cmt_string::npos)
+	{
+	  text.replace_all ("\\\\", "\\");
+	}
+    }
+}
+
+//--------------------------------------------------
+char CmtSystem::path_separator ()
+{
+#ifdef WIN32
+  return (';');
+#else
+  return (':');
+#endif
+}
+
+//--------------------------------------------------
+char CmtSystem::command_separator ()
+{
+#ifdef WIN32
+  return ('&');
+#else
+  return (';');
+#endif
+}
+
+//--------------------------------------------------
+const cmt_string& CmtSystem::ev_open ()
+{
+#ifdef WIN32
+  static const cmt_string s = "%";
+#else
+  static const cmt_string s = "${";
+#endif
+
+  return (s);
+}
+
+//--------------------------------------------------
+const cmt_string& CmtSystem::ev_close ()
+{
+#ifdef WIN32
+  static const cmt_string s = "%";
+#else
+  static const cmt_string s = "}";
+#endif
+
+  return (s);
+}
+
+//-------------------------------------------------
+bool CmtSystem::create_symlink (const cmt_string& oldname,
+                                const cmt_string& newname)
+{
+  ::unlink (newname.c_str ());
+
+#ifdef WIN32
+  int status = 1;
+#else
+  int status = ::symlink (oldname.c_str (), newname.c_str ());
+#endif
+
+  if (status == 0) return (true);
+  return (false);
+}
+
+//-------------------------------------------------
+bool CmtSystem::remove_file (const cmt_string& name)
+{
+  if (::unlink (name) != 0)
+    {
+      cerr << "#CMT> Cannot remove file " << name << endl;
+      return (false);
+    }
+
+  return (true);
+}
+
+//-------------------------------------------------
+bool CmtSystem::remove_directory (const cmt_string& name)
+{
+  //cerr << "Try to remove directory " << name << endl;
+
+  cmt_string_vector files;
+
+  scan_dir (name, files);
+
+  for (int i = 0; i < files.size (); i++)
+    {
+      cmt_string& file = files[i];
+
+      if (test_directory (file))
+        {
+	  //cerr << "D=" << file << endl;
+          if (!remove_directory (file)) return (false);
+        }
+      else
+        {
+	  //cerr << "F=" << file << endl;
+          if (!remove_file (file)) return (false);
+        }
+    }
+
+  int status = ::rmdir (name);
+  if (status != 0)
+    {
+      cerr << "#CMT> Cannot remove directory " << name << " errno=" << errno << endl;
+      return (false);
+    }
+
+  return (true);
+}
+
+//-------------------------------------------------
+bool CmtSystem::mkdir (const cmt_string& name)
+{
+  static cmt_string_vector path_vector;
+  int i;
+  static cmt_string full_path;
+  char double_fs[] = "  ";
+
+  double_fs[0] = file_separator ();
+  double_fs[1] = file_separator ();
+
+  full_path = name;
+
+  if (file_separator () == '/')
+    {
+      full_path.replace_all ("\\", file_separator ());
+    }
+  else
+    {
+      full_path.replace_all ("/", file_separator ());
+    }
+
+  full_path.replace_all (double_fs, file_separator ());
+
+  split (full_path, file_separator (), path_vector);
+
+  full_path = "";
+
+  if (absolute_path (name))
+    {
+      if (!has_device (name))
+        {
+          full_path = file_separator ();
+        }
+    }
+
+  for (i = 0; i < path_vector.size (); i++)
+    {
+      const cmt_string& path = path_vector[i];
+
+      if (i > 0) full_path += file_separator ();
+      full_path += path;
+
+      if (has_device (path)) continue;
+
+      if (!test_directory (full_path))
+        {
+#ifdef WIN32
+          if (::_mkdir (full_path.c_str ()) != 0)
+            {
+                // cerr << "CMT> cannot create directory " << full_path << endl;
+              return (false);
+            }
+#else
+          if (::mkdir (full_path.c_str (), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) != 0)
+            {
+                // cerr << "CMT> cannot create directory " << full_path << endl;
+              return (false);
+            }
+#endif
+        }
+    }
+
+  return (true);
+}
+
+//----------------------------------------------------------
+void CmtSystem::scan_dir (const cmt_string& dir_name,
+                          cmt_string_vector& list)
+{
+  static cmt_string dir_prefix;
+  static cmt_string name_prefix;
+
+  dir_prefix = dir_name;
+  if (dir_name == "") dir_prefix = ".";
+
+  if (!test_directory (dir_prefix))
+    {
+      dirname (dir_prefix, dir_prefix);
+      basename (dir_name, name_prefix);
+    }
+  else
+    {
+      name_prefix = "";
+    }
+
+  bool need_filter = false;
+
+  int wild_card;
+
+  wild_card = name_prefix.find ('*');
+  if (wild_card != cmt_string::npos)
+    {
+      name_prefix.erase (wild_card);
+    }
+
+  if (name_prefix.size () > 0)
+    {
+      need_filter = true;
+    }
+
+  list.clear ();
+
+#ifdef WIN32
+
+  long dir;
+  struct _finddata_t entry;
+
+  static cmt_string search;
+
+  search = dir_prefix;
+  search += file_separator ();
+  search += "*";
+
+  dir = _findfirst (search.c_str (), &entry);
+  if (dir > 0)
+    {
+      for (;;)
+        {
+          if ((strcmp ((char*) entry.name, ".") != 0) &&
+              (strcmp ((char*) entry.name, "..") != 0) &&
+              (strncmp ((char*) entry.name, ".nfs", 4) != 0))
+            {
+              const char* name = entry.name;
+
+              if (!need_filter ||
+                  (strncmp (name, name_prefix.c_str (), name_prefix.size ()) == 0))
+                {
+                  cmt_string& name_entry = list.add ();
+
+                  name_entry = dir_prefix;
+                  name_entry += file_separator ();
+                  name_entry += name;
+                }
+            }
+
+          int status = _findnext (dir, &entry);
+          if (status != 0)
+            {
+              break;
+            }
+        }
+
+      _findclose (dir);
+    }
+#else
+
+  //cout << "scan_dir> dir=" << dir_name << endl;
+
+  DIR* dir = opendir (dir_prefix.c_str ());
+
+  struct dirent* entry;
+
+  if (dir != 0)
+    {
+      while ((entry = readdir (dir)) != 0)
+        {
+          //if (entry->d_name[0] == '.') continue;
+          if (!strcmp ((char*) entry->d_name, ".")) continue;
+          if (!strcmp ((char*) entry->d_name, "..")) continue;
+          if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue;
+
+          const char* name = entry->d_name;
+
+          if (need_filter &&
+              (strncmp (name, name_prefix.c_str (), name_prefix.size ()) != 0)) continue;
+
+          //cout << "scan_dir> name=" << name << endl;
+
+          cmt_string& name_entry = list.add ();
+
+          name_entry = dir_prefix;
+          name_entry += file_separator ();
+          name_entry += name;
+        }
+
+      closedir (dir);
+    }
+#endif
+
+}
+
+//----------------------------------------------------------
+void CmtSystem::scan_dir (const cmt_string& dir_name,
+                          const cmt_regexp& expression,
+                          cmt_string_vector& list)
+{
+  static cmt_string dir_prefix;
+
+  dir_prefix = dir_name;
+  if (dir_name == "") dir_prefix = ".";
+
+  if (!test_directory (dir_prefix))
+    {
+      dirname (dir_prefix, dir_prefix);
+    }
+
+  list.clear ();
+
+#ifdef WIN32
+
+  long dir;
+  struct _finddata_t entry;
+
+  static cmt_string search;
+
+  search = dir_prefix;
+  search += file_separator ();
+  search += "*";
+
+  dir = _findfirst (search.c_str (), &entry);
+  if (dir > 0)
+    {
+      for (;;)
+        {
+          if ((entry.name[0] != '.') &&
+              (strcmp ((char*) entry.name, ".") != 0) &&
+              (strcmp ((char*) entry.name, "..") != 0) &&
+              (strncmp ((char*) entry.name, ".nfs", 4) != 0))
+            {
+              const char* name = entry.name;
+              
+              if (expression.match (name))
+                {
+                  cmt_string& name_entry = list.add ();
+
+                  name_entry = dir_prefix;
+                  name_entry += file_separator ();
+                  name_entry += name;
+                }
+            }
+
+          int status = _findnext (dir, &entry);
+          if (status != 0)
+            {
+              break;
+            }
+        }
+      _findclose (dir);
+    }
+#else
+
+  //cout << "scan_dir> dir=" << dir_name << endl;
+
+  DIR* dir = opendir (dir_prefix.c_str ());
+
+  struct dirent* entry;
+
+  if (dir != 0)
+    {
+      while ((entry = readdir (dir)) != 0)
+        {
+          //if (entry->d_name[0] == '.') continue;
+          if (!strcmp ((char*) entry->d_name, ".")) continue;
+          if (!strcmp ((char*) entry->d_name, "..")) continue;
+          if (!strncmp ((char*) entry->d_name, ".nfs", 4)) continue;
+
+          const char* name = entry->d_name;
+
+          if (!expression.match (name)) continue;
+
+          cmt_string& name_entry = list.add ();
+
+          name_entry = dir_prefix;
+          name_entry += file_separator ();
+          name_entry += name;
+        }
+
+      closedir (dir);
+    }
+#endif
+
+}
+
+//----------------------------------------------------------
+CmtSystem::cmt_string_vector& CmtSystem::scan_dir (const cmt_string& dir_name)
+{
+  static cmt_string_vector result;
+
+  scan_dir (dir_name, result);
+
+  return (result);
+}
+
+//----------------------------------------------------------
+const cmt_string& CmtSystem::get_cmt_root ()
+{
+  static cmt_string root;
+
+  root = "";
+
+  const char* env = ::getenv ("CMTROOT");
+  if (env != 0)
+    {
+      root = env;
+
+      dirname (root, root);
+      dirname (root, root);
+      root.replace_all ("\"", "");
+      return (root);
+    }
+
+#ifdef WIN32
+  LONG status;
+  HKEY key = 0;
+
+  status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 
+                         0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      char temp[256];
+      DWORD length = sizeof (temp) - 1;
+      DWORD type;
+
+      status = RegQueryValueEx (key, "root", 0, &type, (LPBYTE) temp, &length);
+      if (status == ERROR_SUCCESS)
+        {
+          root = temp;
+          return (root);
+        }
+    }
+#endif
+
+  return (root);
+}
+
+//----------------------------------------------------------
+void CmtSystem::get_cmt_version (cmt_string& version)
+{
+  version = "";
+
+  const char* env = ::getenv ("CMTROOT");
+  if (env != 0)
+    {
+      cmt_string s = env;
+      basename (s, version);
+      version.replace_all ("\"", "");
+    }
+  else
+    {
+#ifdef WIN32
+      LONG status;
+      HKEY key = 0;
+
+      status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 
+                             0, KEY_READ, &key);
+      if (status == ERROR_SUCCESS)
+        {
+          char temp[256];
+          DWORD length = sizeof (temp) - 1;
+          DWORD type;
+          
+          status = RegQueryValueEx (key, "version", 0, &type, 
+                                    (LPBYTE) temp, &length);
+          if (status == ERROR_SUCCESS)
+            {
+              version = temp;
+            }
+        }
+#endif
+    }
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::get_cmt_config ()
+{
+  const char* env = ::getenv ("CMTCONFIG");
+  if (env != 0)
+    {
+      return (cmt_string (env));
+    }
+
+  env = ::getenv ("CMTBIN");
+  if (env != 0)
+    {
+      return (cmt_string (env));
+    }
+
+#ifdef WIN32
+  LONG status;
+  HKEY key = 0;
+
+  status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 
+                         0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      char temp[256];
+      DWORD length = sizeof (temp) - 1;
+      DWORD type;
+
+      status = RegQueryValueEx (key, "config", 0, &type, 
+                                (LPBYTE) temp, &length);
+      if (status == ERROR_SUCCESS)
+        {
+          cmt_string config (temp);
+          return (config);
+        }
+    }
+
+  return ("VisualC");
+#endif
+
+  return ("");
+
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::get_cmt_site ()
+{
+  const char* env = ::getenv ("CMTSITE");
+  if (env != 0)
+    {
+      return (cmt_string (env));
+    }
+
+#ifdef WIN32
+  LONG status;
+  HKEY key = 0;
+
+  status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 
+                         0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      char temp[256];
+      DWORD length = sizeof (temp) - 1;
+      DWORD type;
+
+      status = RegQueryValueEx (key, "site", 0, &type, (LPBYTE) temp, &length);
+      if (status == ERROR_SUCCESS)
+        {
+          cmt_string site (temp);
+          return (site);
+        }
+    }
+#endif
+
+  return ("");
+}
+
+//----------------------------------------------------------
+void CmtSystem::get_uname (cmt_string& uname)
+{
+#ifdef WIN32
+  uname = "WIN32";
+#else
+
+  uname = "";
+
+  FILE* file;
+
+  file = popen ("uname", "r");
+
+  if (file != 0)
+    {
+      char line[1024];
+      char* ptr;
+      char* nl;
+
+      line[0] = 0;
+      ptr = fgets (line, sizeof (line), file);
+      if (ptr != 0)
+        {
+          nl = strrchr (ptr, '\n');
+          if (nl != 0) *nl = 0;
+
+          uname = ptr;
+        }
+      pclose (file);
+    }
+#endif
+}
+
+//----------------------------------------------------------
+void CmtSystem::get_hosttype (cmt_string& hosttype)
+{
+  hosttype = "";
+
+  char* ptr;
+
+  ptr = ::getenv ("HOSTTYPE");
+  if (ptr != 0)
+    {
+      hosttype = ptr;
+    }
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::get_temporary_name ()
+{
+  cmt_string name;
+
+  name = ::tmpnam (NULL);
+
+  return (name);
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::get_home_package ()
+{
+  cmt_string name = "CMTHOME";
+
+  return (name);
+}
+
+//----------------------------------------------------------
+bool CmtSystem::is_home_package (const cmt_string& name,
+                                 const cmt_string& version)
+{
+  if (name == "CMTHOME") return (true);
+
+  return (false);
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::get_user_context_package ()
+{
+  cmt_string name = "CMTUSERCONTEXT";
+
+  return (name);
+}
+
+//----------------------------------------------------------
+bool CmtSystem::is_user_context_package (const cmt_string& name,
+					 const cmt_string& version)
+{
+  if (name == "CMTUSERCONTEXT") return (true);
+
+  return (false);
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::get_project_package ()
+{
+  cmt_string name = "PROJECT";
+
+  return (name);
+}
+
+//----------------------------------------------------------
+bool CmtSystem::is_project_package (const cmt_string& name,
+                                    const cmt_string& version)
+{
+  if (name == "PROJECT") return (true);
+
+  return (false);
+}
+
+//----------------------------------------------------------
+bool CmtSystem::testenv (const cmt_string& name)
+{
+  const char* env = ::getenv (name);
+  if (env == 0) return (false);
+  return (true);
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::getenv (const cmt_string& name)
+{
+  cmt_string result;
+
+  const char* env = ::getenv (name);
+  if (env != 0)
+    {
+      result = env;
+    }
+
+  if (name == "CMTCONFIG")
+  {
+    return (get_cmt_config ());
+  }
+
+  /*
+  if (name == "CMTROOT")
+  {
+          return (get_cmt_root ());
+  }
+
+  if (name == "CMTSITE")
+  {
+          return (get_cmt_site ());
+  }
+  */
+
+  return (result);
+}
+
+/**
+   Implementation based on a local static map of used environment
+variables to ensure a stable character string. The OS requires
+that the character string sent via a putenv is kept untouched forever
+ */
+bool CmtSystem::putenv (const cmt_string& name, const cmt_string& value)
+{
+  static cmt_map <cmt_string, cmt_string> envs;
+
+  if (!envs.has (name))
+    {
+      cmt_string& v = *(new cmt_string);
+      v = name;
+      v += "=";
+      v += value;
+      envs.add (name, v);
+    }
+  else
+    {
+      cmt_string& v = *(envs.find (name));
+      v = name;
+      v += "=";
+      v += value;
+    }
+
+  {
+    const cmt_string& v = *envs.find (name);
+    //cerr << "#CmtSystem::putenv> name=" << name << " &v=" << &v << endl;
+
+    int status = ::putenv ((char*) v.c_str ());
+
+    if (status == 0) return (true);
+    else return (false);
+  }
+
+}
+
+//----------------------------------------------------------
+//
+// This singleton interacts with the ProjectFactory to consistently create
+// the project graph.
+//
+// In particular a single-depth stack of the top project is maintained.
+//
+//----------------------------------------------------------
+class CMTPathManager
+{
+public:
+  static CMTPathManager& instance ();
+  static void reset ();
+  static void add_cmt_path (const cmt_string& path,
+			    const cmt_string& path_source,
+			    IProjectFactory& factory);
+
+private:
+  CMTPathManager () : m_project (0)
+  {
+  }
+
+  void do_reset ()
+  {
+    m_project = 0;
+  }
+
+  void do_add_cmt_path (const cmt_string& path,
+			const cmt_string& path_source,
+			IProjectFactory& factory)
+  {
+    cmt_string npath = path;
+
+    if (npath == "") return;
+
+#ifdef WIN32
+    if (npath.size () == 2)
+      {
+	if (npath[1] == ':')
+	  {
+	    npath += CmtSystem::file_separator ();
+	  }
+      }
+#endif
+
+    npath.replace_all ("\\", CmtSystem::file_separator ());
+    npath.replace_all ("/", CmtSystem::file_separator ());
+
+    if (!CmtSystem::absolute_path (npath))
+      {
+	cmt_string h = CmtSystem::pwd ();
+	h += CmtSystem::file_separator ();
+	h += npath;
+	npath = h;
+      }
+    
+    CmtSystem::compress_path (npath);
+
+    //cerr << "adding npath=" << npath << endl;
+
+    while (npath[npath.size ()-1] == CmtSystem::file_separator ())
+      {
+	npath.erase (npath.size ()-1);
+      }
+    
+    //cerr << "adding npath=[" << npath << "]" << endl;
+    
+    if (npath != "")
+      {
+	cmt_string project_name;
+
+	if ((path_source == "CMTUSERCONTEXT") ||
+	    (path_source == "CMTHOME"))
+	  {
+	    project_name = path_source;
+	  }
+
+	m_project = factory.create_project (project_name, npath, path_source, m_project);
+      }
+  }
+
+  Project* m_project;
+};
+
+CMTPathManager& CMTPathManager::instance ()
+{
+  static CMTPathManager me;
+  
+  return (me);
+}
+
+void CMTPathManager::reset ()
+{
+  static CMTPathManager& me = instance ();
+  me.do_reset ();
+}
+
+void CMTPathManager::add_cmt_path (const cmt_string& path,
+				   const cmt_string& path_source,
+				   IProjectFactory& factory)
+{
+  static CMTPathManager& me = instance ();
+  me.do_add_cmt_path (path, path_source, factory);
+}
+
+
+
+//----------------------------------------------------------
+static void add_cmt_paths_from_text (const cmt_string& text,
+				     const cmt_string& context,
+				     IProjectFactory& factory)
+{
+  static CmtSystem::cmt_string_vector path_vector;
+  int i;
+
+  CmtSystem::split (text, CmtSystem::path_separator (), path_vector);
+
+  for (i = 0; i < path_vector.size (); i++)
+    {
+      const cmt_string& path = path_vector[i];
+
+      CMTPathManager::add_cmt_path (path, context, factory);
+    }
+}
+
+//----------------------------------------------------------
+static void add_cmt_paths_from_file (const cmt_string& file_name, IProjectFactory& factory)
+{
+  if (!CmtSystem::test_file (file_name)) return;
+
+  static cmt_string text;
+
+  text.read (file_name);
+
+  int pos = text.find ("CMTPATH");
+  if (pos == cmt_string::npos) return;
+  pos += strlen ("CMTPATH");
+  pos = text.find (pos, "=");
+  if (pos == cmt_string::npos) return;
+  pos++;
+
+  text.erase (0, pos);
+
+  int nl = text.find (pos, "\n");
+  if (nl != cmt_string::npos) text.erase (nl);
+
+  add_cmt_paths_from_text (text, file_name, factory);
+}
+
+//----------------------------------------------------------
+//
+// With this function we analyse all possible ways of
+// externally entering CMTPATH items
+//  + from the environment variable
+//  + from .cmtrc files
+//  + from registry on Windows
+//  + from EV settings for CMTUSERCONTEXT and CMTHOME
+// 
+// Then projects are created from these settings.
+//
+// (The other way to enter project graph is through project files)
+//----------------------------------------------------------
+void CmtSystem::get_cmt_paths (IProjectFactory& factory, 
+			       const cmt_string& init_text,
+			       const cmt_string& cmt_user_context,
+			       const cmt_string& cmt_home)
+{
+  CMTPathManager::reset ();
+
+  if (init_text != "")
+    {
+      add_cmt_paths_from_text (init_text, "initialization", factory);
+    }
+
+#ifdef WIN32
+  LONG status;
+  HKEY key = 0;
+
+  status = RegOpenKeyEx (HKEY_CURRENT_USER, "Software\\CMT\\path",
+                         0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      DWORD index = 0;
+      char name[256];
+      char temp[256];
+
+      for (;;)
+        {
+          DWORD name_length = sizeof (name) - 1;
+          DWORD length = sizeof (temp) - 1;
+          DWORD type;
+          status = RegEnumValue (key, index,
+                                 name, &name_length, 0, &type,
+                                 (LPBYTE) temp, &length);
+          if ((status == ERROR_SUCCESS) ||
+              (status == 234))
+            {
+              const cmt_string path = temp;
+              CMTPathManager::add_cmt_path (path, "HKEY_CURRENT_USER", factory);
+            }
+
+          if (status == 259)
+            {
+              break;
+            }
+
+          index++;
+        }
+    }
+
+  status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT\\path",
+                         0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      DWORD index = 0;
+      char name[256];
+      char temp[256];
+
+      for (;;)
+        {
+          DWORD type;
+          DWORD name_length = sizeof (name) - 1;
+          DWORD length = sizeof (temp) - 1;
+
+
+          status = RegEnumValue (key, index,
+                                 name, &name_length, 0, &type,
+                                 (LPBYTE) temp, &length);
+          if (status != ERROR_NO_MORE_ITEMS)
+            {
+              const cmt_string path = temp;
+              CMTPathManager::add_cmt_path (path, "HKEY_LOCAL_MACHINE", factory);
+            }
+          else
+            {
+              break;
+            }
+          index++;
+        }
+    }
+
+#endif
+
+  //-----------------------------------------
+  // look for .cmtrc files :
+  //  first look in ./
+  //  then in "~/"
+  //  then in ${CMTROOT}/mgr
+  //-----------------------------------------
+  cmt_string rc_name;
+
+  add_cmt_paths_from_file (".cmtrc", factory);
+
+  if (get_home_directory (rc_name))
+    {
+      rc_name += file_separator ();
+      rc_name += ".cmtrc";
+      add_cmt_paths_from_file (rc_name, factory);
+    }
+
+  rc_name = get_cmt_root ();
+  rc_name += file_separator ();
+  rc_name += "CMT";
+  rc_name += file_separator ();
+  cmt_string version;
+  get_cmt_version (version);
+  rc_name += version;
+  rc_name += file_separator ();
+  rc_name += "mgr";
+  rc_name += file_separator ();
+  rc_name += ".cmtrc";
+
+  add_cmt_paths_from_file (rc_name, factory);
+
+  CMTPathManager::add_cmt_path (cmt_user_context, "CMTUSERCONTEXT", factory);
+  CMTPathManager::add_cmt_path (cmt_home, "CMTHOME", factory);
+}
+
+//----------------------------------------------------------
+int CmtSystem::execute (const cmt_string& command)
+{
+  //cout << "CmtSystem::execute1> [" << command << "]" << endl;
+
+  return (system (command.c_str ()));
+}
+
+//----------------------------------------------------------
+int CmtSystem::execute (const cmt_string& command, cmt_string& output)
+{
+  output = "";
+
+  //cout << "CmtSystem::execute2> [" << command << "]" << endl;
+
+  FILE* f = popen (command.c_str (), "r"); 
+  
+  if (f != 0) 
+    { 
+      char line[256]; 
+      char* ptr;
+
+      while ((ptr = fgets (line, sizeof (line), f)) != NULL) 
+        {
+          output += ptr;
+        } 
+      pclose (f);
+
+      return (0);
+    }
+
+  return (1);
+}
+
+//----------------------------------------------------------
+bool CmtSystem::is_package_directory (const cmt_string& name)
+{
+  cmt_string_vector dirs;
+
+  cmt_regexp exp ("^[a-zA-Z.][0-9]+([a-zA-Z.][0-9]+([a-zA-Z.][0-9]+)?)?");
+
+  scan_dir (name, exp, dirs);
+
+  cmt_string req;
+
+  req = name;
+  req += file_separator ();
+  req += "cmt";
+  req += file_separator ();
+  req += "requirements";
+
+  if (test_file (req)) return (true);
+
+  if (dirs.size () == 0) 
+    {
+      return (false);
+    }
+
+  for (int i = 0; i < dirs.size (); i++)
+      {
+        const cmt_string& d = dirs[i];
+
+        req = d;
+        req += file_separator ();
+        req += "mgr";
+        req += file_separator ();
+        req += "requirements";
+
+        if (test_file (req)) return (true);
+
+      req = d;
+      req += file_separator ();
+      req += "cmt";
+      req += file_separator ();
+      req += "requirements";
+      
+      if (test_file (req)) return (true);
+    }
+
+  return (false);
+}
+
+//----------------------------------------------------------
+bool CmtSystem::is_version_directory (const cmt_string& name)
+{
+  int v;
+  int r;
+  int p;
+
+  return (is_version_directory (name, v, r, p));
+}
+
+//----------------------------------------------------------
+bool CmtSystem::is_version_directory (const cmt_string& name,
+                                      int& v,
+                                      int& r,
+                                      int& p)
+{
+  if ((name == "HEAD") || (name == "head"))
+    {
+      v = 0;
+      r = 0;
+      p = 0;
+
+      return (true);
+    }
+
+  static const cmt_string numbers = "0123456789";
+
+  static const int id_version = 0;
+  static const int id_release = 1;
+  static const int id_patch   = 2;
+
+  cmt_string buffer;
+
+  enum 
+  {
+    starting,
+    at_key,
+    at_number
+  } state;
+
+  int id;
+  int pos;
+  int value;
+
+  v = 0;
+  r = 0;
+  p = 0;
+
+  //
+  // version : v-field
+  //         | v-field r-field
+  //         | v-field r-field p-field
+  //
+  // v-field : field
+  // r-field : field
+  // p-field : field
+  //
+  // field   : key '*'
+  //         | key number
+  //
+  // key     : letters
+  //
+
+  state = starting;
+  id    = id_version;
+
+  for (pos = 0; pos < name.size (); pos++)
+    {
+      char c = name[pos];
+
+      if (c == '*')
+        {
+          // A wild card
+          switch (state)
+            {
+            case starting:
+              // cannot start with a wild card ??
+	      v = -1;
+	      r = -1;
+	      p = -1;
+              return (false);
+            case at_key:
+              // the numeric field is valued with a wild card
+              switch (id)
+                {
+                case id_version:
+                  v = -1;
+                case id_release:
+                  r = -1;
+                case id_patch:
+                  p = -1;
+                  break;
+                }
+              return (true);
+            case at_number:
+              // question:
+	      // a number followed by a wild-card is considered as:
+	      //   1) a wild card on the number itself (1* comp with 1, 10, 12, 120, etc)
+	      //   2) a wild card on the next fields (1* comp with 1r1, 1-12 etc)
+	      //
+
+	      //  Here we select option 1)
+
+              sscanf (buffer.c_str (), "%d", &value);
+              switch (id)
+                {
+                case id_version:
+		  //
+                  // lazy option 1 implies v = -1;
+                  // strict option 1 would imply v = -value;
+                  // option 2 implies v = value;
+		  //
+
+                  v = -1;
+		  r = -1;
+		  p = -1;
+                  break;
+                case id_release:
+                  r = value;
+		  p = -1;
+                  break;
+                case id_patch:
+                  p = value;
+                  break;
+                }
+
+              return (true);
+            }
+        }
+      else if (numbers.find (c) == cmt_string::npos)
+        {
+          // A letter
+          switch (state)
+            {
+            case starting:
+              state = at_key;
+              break;
+            case at_key:
+              // Multiple letter key (is it permitted??)
+              break;
+            case at_number:
+              sscanf (buffer.c_str (), "%d", &value);
+              switch (id)
+                {
+                case id_version:
+                  v = value;
+                  break;
+                case id_release:
+                  r = value;
+                  break;
+                case id_patch:
+                  p = value;
+                  break;
+                }
+              buffer = "";
+              id++;
+              state = at_key;
+              break;
+            }
+        }
+      else
+        {
+          // a number
+          switch (state)
+            {
+            case starting:
+              // not starting by a letter (syntax error)
+              //return (false);
+            case at_key:
+              // the numeric field for the current id is starting now
+              buffer += c;
+              state = at_number;
+              break;
+            case at_number:
+              // continuing the current numeric field
+              buffer += c;
+              break;
+            }
+        }
+    }
+
+  switch (state)
+    {
+    case starting:
+      // Empty version string
+      return (false);
+    case at_key:
+      // Syntax error (when only letters. Ending letters is not an error)
+      if (id == id_version) return (false);
+      else return (true);
+    case at_number:
+      sscanf (buffer.c_str (), "%d", &value);
+      switch (id)
+        {
+        case id_version:
+          v = value;
+          break;
+        case id_release:
+          r = value;
+          break;
+        case id_patch:
+          p = value;
+          break;
+        }
+      id++;
+      state = at_key;
+      return (true);
+    }
+
+  return (false);
+}
+
+//----------------------------------------------------------
+//  Split a line into words. Separators are spaces and tabs
+//  Text enclosed in double quotes is one word.
+//----------------------------------------------------------
+void CmtSystem::split (const cmt_string& text,
+                       const cmt_string& separators,
+                       cmt_string_vector& strings)
+{
+  static char* buffer = 0;
+  static int allocated = 0;
+
+  bool finished = false;
+
+  strings.clear ();
+
+  if (text.size () == 0) return;
+
+  /*
+    We are going to work in a copy of the text, since
+    \0 will be inserted right after each found word.
+
+    Then the vector of strings is iteratively filled by each found word.
+  */
+
+  if (buffer == 0)
+    {
+      allocated = text.size ();
+      buffer = (char*) malloc (allocated + 1);
+    }
+  else
+    {
+      if (text.size () > allocated)
+        {
+          allocated = text.size ();
+          buffer = (char*) realloc (buffer, allocated + 1);
+        }
+    }
+
+  strcpy (buffer, text.c_str ());
+
+  /*
+    Algorithm :
+
+    We look for words separated by <separators> which may be
+    o spaces (' ' or '\t')
+    o other characters such as ':'
+
+    A word is a character string not containing any separator. A substring in
+    this word my be enclosed between quotes (" or ') which permits separator
+    inclusion within words.
+  */
+
+  char* current_word = buffer;
+
+  while (*current_word != 0)
+    {
+      size_t prefix_length;
+      size_t word_length;
+
+      /*
+        while ((*current_word == ' ') ||
+        (*current_word == '\t'))
+        {
+        current_word++;
+        }
+      */
+
+      // first skip all starting separators.
+
+      prefix_length = strspn (current_word, separators.c_str ());
+      if (prefix_length > 0)
+        {
+          // Move to the first non-separator character
+
+          current_word += prefix_length;
+        }
+
+      /*
+        Parse the next word.
+
+        It may contain enclosures in quote characters or not.
+        Quotes must be identical on both sides of each enclosure.
+      */
+
+      char* running_char = current_word;
+
+      word_length = 0;
+
+      for (;;)
+        {
+          size_t unquoted_length;
+          size_t separator_offset;
+
+	  for (int p = 0;;)
+	    {
+	      unquoted_length = strcspn (running_char + p, "\"\'") + p;
+	      if ((unquoted_length > 0) && (running_char[unquoted_length-1] == '\\'))
+		{
+		  p = unquoted_length + 1;
+		}
+	      else
+		{
+		  break;
+		}
+	    }
+
+          separator_offset = strcspn (running_char, separators.c_str ());
+
+          if (separator_offset <= unquoted_length)
+            {
+              // no quote in this word -> we are finished for this one.
+              running_char += separator_offset;
+              break;
+            }
+
+          // We have found a quoted enclosure. Move to it.
+
+          running_char += unquoted_length;
+
+          char quote = running_char[0];
+
+          // Remove it.
+          {
+            char* p = running_char;
+            while (p[1] != 0)
+              {
+                *p = p[1];
+                p++;
+              }
+            *p = 0;
+          }
+
+          // Look for the next occurence of this quote.
+          {
+            char* p = strchr (running_char, quote);
+            if (p == 0)
+              {
+                // Unmatched quote : the rest of the line will be taken as a word...
+                running_char += strlen (running_char);
+                finished = true;
+                break;
+              }
+            else
+              {
+                running_char = p;
+              }
+          }
+
+          // Now we remove the ending quote from the word
+          // (by shifting all remaining characters by one place to the left)
+
+          {
+            char* p = running_char;
+            while (p[1] != 0)
+              {
+                *p = p[1];
+                p++;
+              }
+            *p = 0;
+          }
+        }
+
+      word_length = running_char - current_word;
+
+      if (current_word[word_length] == 0)
+        {
+          finished = true;
+        }
+      else
+        {
+          current_word[word_length] = 0;
+        }
+
+      /*
+        if ((t[0] == '"') ||
+        (t[0] == '\'') ||
+        (t[0] == ':'))
+        {
+        char* quote;
+
+        t++;
+        quote = strchr (t, sep);
+        if (quote != 0) *quote = 0;
+        else finished = true;
+        }
+        else
+        {
+        int offset;
+
+        offset = strcspn (t, " \t:");
+        if ((offset < 0) || (t[offset] == 0)) finished = true;
+        if (!finished)
+        {
+        space = t + offset;
+        *space = 0;
+        }
+        }
+      */
+
+      // Store the current word into the vector of strings
+
+      {
+        cmt_string& s = strings.add ();
+        s = current_word;
+      }
+
+      if (finished) break;
+
+      // Move to the next possible word.
+      current_word += word_length + 1;
+    }
+}
+
+//----------------------------------------------------------
+void CmtSystem::compress_path (const cmt_string& dir, cmt_string& new_dir)
+{
+  new_dir = dir;
+
+  compress_path (new_dir);
+}
+
+//----------------------------------------------------------
+//
+//  We try to detect the aaaa/xxxx/../bbbb patterns which should be 
+// equivalent to aaaa/bbbb
+//  this therefore consists in removing all /xxxx/../ when 
+//     xxxx is different from ".."
+//     xxxx is different from "."
+//     xxxx does not contain any macro reference
+//
+//----------------------------------------------------------
+void CmtSystem::compress_path (cmt_string& dir)
+{
+#ifdef WIN32
+  static const char pattern[] = "\\..";
+  static const char fs[] = "\\\\";
+#else
+  static const char pattern[] = "/..";
+  static const char fs[] = "//";
+#endif
+
+  if (dir.size () == 0) return;
+
+  //
+  // We first synchronize to using file_separator() in any case.
+  //
+
+  if (file_separator () == '/')
+    {
+      dir.replace_all ("\\", file_separator ());
+    }
+  else
+    {
+      dir.replace_all ("/", file_separator ());
+    }
+
+  // Suppress all duplicated file separators
+  dir.replace_all (fs, file_separator ());
+
+  for (;;)
+    {
+      int pos1;
+      int pos2;
+      int pos3;
+
+      pos1 = dir.find (pattern);
+      if (pos1 == cmt_string::npos) break;
+
+        //
+        // extract "aaaa/xxxx" from "aaaa/xxxx/../bbbb"
+        //
+      cmt_string p = dir.substr (0, pos1);
+
+      cmt_string dn;
+      basename (p, dn);
+      if (dn == "..") break;
+      if (dn == ".") break;
+      if (dn == "") break;
+      
+        //
+        // Is "aaaa/xxxx" only made of "xxxx" ?
+        // 
+      pos2 = p.find_last_of (file_separator ());
+      
+      if (pos2 == cmt_string::npos) 
+	{
+	  // the pattern was xxxx/..
+	  //
+	  // so xxxx is [0:pos1-1]
+	  //
+	  pos3 = p.find ("$");
+	  if (pos3 == cmt_string::npos)
+	    {
+	      dir.erase (0, pos1 + 3);
+	    }
+	  else
+	    {
+	      break;
+	    }
+	}
+      else
+	{
+	  //    01234567890123456
+	  //    aaaa/xxxx/../bbbb
+	  //        2    1   3
+	  //
+	  // erase the "/xxxx/.." pattern
+	  // result will be "aaaa/bbbb"
+	  //
+	  // Here xxxx is [pos2+1:pos1-1]
+	  //
+
+	  pos3 = p.find (pos2, "$");
+	  if (pos3 == cmt_string::npos)
+	    {
+	      dir.erase (pos2, pos1 + 3 - pos2);
+	    }
+	  else
+	    {
+	      break;
+	    }
+	}
+    }
+
+    //if (dir[dir.size () - 1] == file_separator ()) dir.erase (dir.size () - 1);
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::now ()
+{
+  cmt_string result;
+
+  time_t ltime;
+  time (&ltime);
+  result = ctime (&ltime);
+
+  result.replace_all ("\n", "");
+
+  return (result);
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::user ()
+{
+#ifdef _WIN32
+  cmt_string result = getenv ("USERNAME");
+#else
+  cmt_string result = getenv ("USER");
+#endif
+
+  return (result);
+}
+
+//----------------------------------------------------------
+void CmtSystem::get_cvsroot (cmt_string& cvsroot)
+{
+  cvsroot = "";
+
+  const char* env = ::getenv ("CVSROOT");
+  if (env != 0)
+    {
+      cvsroot = env;
+      return;
+    }
+
+#ifdef WIN32
+  LONG status;
+  HKEY key = 0;
+
+  status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 
+                         0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      char temp[256];
+      DWORD length = sizeof (temp) - 1;
+      DWORD type;
+
+      status = RegQueryValueEx (key, "CVSROOT", 0, &type, 
+                                (LPBYTE) temp, &length);
+      if (status == ERROR_SUCCESS)
+        {
+          cvsroot = temp;
+          return;
+        }
+    }
+#endif
+}
+
+//----------------------------------------------------------
+bool CmtSystem::get_home_directory (cmt_string& dir)
+{
+  bool status = false;
+
+#ifdef WIN32
+  const char* homedrive = ::getenv ("HOMEDRIVE");
+  const char* homepath = ::getenv ("HOMEPATH");
+
+  if ((homedrive != 0) && (homepath != 0))
+    {
+      dir = homedrive;
+      dir += homepath;
+      status = true;
+    }
+
+#else
+  const char* home_env = ::getenv ("HOME");
+  if (home_env != 0)
+    {
+      dir = home_env;
+      status = true;
+    }
+#endif
+
+  return (status);
+}
+
+//----------------------------------------------------------
+cmt_string CmtSystem::get_makefile_suffix ()
+{
+#ifdef WIN32
+  return "nmake";
+#else
+  return "make";
+#endif
+}
+
Index: /CMT/v1r20/source/cmt_system.h
===================================================================
--- /CMT/v1r20/source/cmt_system.h	(revision 368)
+++ /CMT/v1r20/source/cmt_system.h	(revision 368)
@@ -0,0 +1,147 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_system_h__
+#define __cmt_system_h__
+
+#include "cmt_std.h"
+#include "cmt_string.h"
+#include "cmt_vector.h"
+#include "cmt_regexp.h"
+
+class Project;
+
+class IProjectFactory
+{
+public:
+  virtual void reset () = 0;
+  virtual Project* create_project (const cmt_string& name,
+				   const cmt_string& path,
+				   const cmt_string& path_source,
+				   Project* parent) = 0;
+};
+
+class CmtSystem
+{
+public:
+  typedef cmt_vector<cmt_string> cmt_string_vector;
+
+  static cmt_string pwd ();
+  static bool cd (const cmt_string& dir);
+
+  static void basename (const cmt_string& file_name, cmt_string& result);
+  static void basename (const cmt_string& file_name,
+                        const cmt_string& suffix,
+                        cmt_string& result);
+
+  // Resolve symbolic links in a path.
+  static bool realpath (const cmt_string& path, cmt_string& result);
+
+  static void dirname (const cmt_string& file_name, cmt_string& result);
+
+  static void name (const cmt_string& file, cmt_string& result);
+
+  static void get_suffix (const cmt_string& file, cmt_string& result);
+  static void get_dot_suffix (const cmt_string& file, cmt_string& result);
+  static bool has_prefix (const cmt_string& name);
+  static bool absolute_path (const cmt_string& name);
+  static bool has_device (const cmt_string& name);
+
+  static cmt_string current_branch ();
+
+    /**
+     * Implementation of the "test -d" equivalent
+     */
+  static bool test_directory (const cmt_string& name);
+    /**
+     * Implementation of the "test -f" equivalent
+     */               
+  static bool test_file (const cmt_string& name);
+    /**
+     * Implementation of the "touch" function equivalent
+     */               
+  static bool touch_file (const cmt_string& name);    
+    /**
+     * Check if the file "name1" is identical to "name2"
+     */
+  static bool compare_files (const cmt_string& name1,
+                             const cmt_string& name2);
+    /**
+     * Check if the file "name1" is identical to "name2"
+     * if they are identical, "name1" will be simply deleted
+     * otherwise "name1" will be copied to "name2" and deleted afterwards
+     */
+  static bool compare_and_update_files (const cmt_string& name1,
+                                        const cmt_string& name2);
+  static int file_size (const cmt_string& name);
+  static char file_separator ();
+  static void reduce_file_separators (cmt_string& text);
+  static char path_separator ();
+  static char command_separator ();
+  static const cmt_string& ev_open ();
+  static const cmt_string& ev_close ();
+  static bool create_symlink (const cmt_string& oldname,
+                              const cmt_string& newname);
+  static bool remove_file (const cmt_string& name);
+  static bool remove_directory (const cmt_string& name);
+  static bool mkdir (const cmt_string& name);
+  static void scan_dir (const cmt_string& dir_name,
+                        cmt_string_vector& list);
+  static void scan_dir (const cmt_string& dir_name,
+                        const cmt_regexp& expression,
+                        cmt_string_vector& list);
+  static cmt_string_vector& scan_dir (const cmt_string& dir_name);
+  static const cmt_string& get_cmt_root ();
+  static void get_cmt_version (cmt_string& version);
+  static cmt_string get_cmt_config ();
+  static cmt_string get_cmt_site ();
+  static void get_uname (cmt_string& uname);
+  static void get_hosttype (cmt_string& hosttype);
+  static cmt_string get_temporary_name ();
+  
+  static cmt_string get_home_package ();
+  static bool is_home_package (const cmt_string& name,
+                               const cmt_string& version);
+  
+  static cmt_string get_user_context_package ();
+  static bool is_user_context_package (const cmt_string& name,
+                                       const cmt_string& version);
+  
+  static cmt_string get_project_package ();
+  static bool is_project_package (const cmt_string& name,
+				  const cmt_string& version);
+  
+  static bool testenv (const cmt_string& name);
+  static cmt_string getenv (const cmt_string& name);
+  static bool putenv (const cmt_string& name, const cmt_string& value);
+  static void get_cmt_paths (IProjectFactory& factory,
+                             const cmt_string& init_text,
+                             const cmt_string& cmt_user_context,
+                             const cmt_string& cmt_home);
+  static int execute (const cmt_string& command);
+  static int execute (const cmt_string& command, cmt_string& output);
+  static bool is_package_directory (const cmt_string& name);
+  static bool is_version_directory (const cmt_string& name);
+  static bool is_version_directory (const cmt_string& name, int& v, int& r, int& p);
+  static void split (const cmt_string& text,
+                     const cmt_string& separators,
+                     cmt_string_vector& strings);
+
+  static void compress_path (const cmt_string& dir, cmt_string& new_dir);
+  static void compress_path (cmt_string& dir);
+
+  static cmt_string now ();
+  static cmt_string user ();
+
+  static void get_cvsroot (cmt_string& cvsroot);
+
+  static bool get_home_directory (cmt_string& dir);
+
+  static cmt_string get_makefile_suffix ();
+
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_tag.cxx
===================================================================
--- /CMT/v1r20/source/cmt_tag.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_tag.cxx	(revision 368)
@@ -0,0 +1,908 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "cmt_tag.h"
+#include "cmt_database.h"
+#include "cmt_log.h"
+
+/*----------------------------------------------------------*/
+/*                                                          */
+/*  Operations on Tags                                      */
+/*                                                          */
+/*----------------------------------------------------------*/
+
+/*----------------------------------------------------------*/
+void Tag::unmark ()
+{
+  if (!is_primary ()) return;
+  if (!m_selected) return;
+
+  Log;
+
+  if ((m_priority == PriorityDefault) ||
+      (m_priority == PrioritySite) ||
+      (m_priority == PriorityUname)) return;
+
+  log << "Unmarking tag[" << this << "] " << m_name << " p=" << m_priority << log_endl;
+
+  m_selected = false;
+  m_def_use = 0;
+}
+
+/*----------------------------------------------------------*/
+void Tag::unmark_all ()
+{
+  static TagPtrVector& vector = tags ();
+
+  int tag_number;
+
+  for (tag_number = 0; tag_number < vector.size (); tag_number++)
+    {
+      Tag* tag = vector[tag_number];
+
+      tag->unmark ();
+    }
+}
+
+/**
+ *   Restore the tag tree after cleaning up one tag and
+ *   its local tree.
+ */
+void Tag::restore_tree ()
+{
+  static TagPtrVector& vector = tags ();
+
+  int tag_number;
+
+  for (tag_number = 0; tag_number < vector.size (); tag_number++)
+    {
+      Tag* tag = vector[tag_number];
+      
+      if (tag->is_primary () && tag->is_selected ())
+	{
+	  if (tag->m_tag_refs.size () > 0)
+	    {
+	      int number;
+	      
+	      for (number = 0; number < tag->m_tag_refs.size (); number++)
+		{
+		  Tag* ref = tag->m_tag_refs[number];
+		  
+		  ref->mark ();
+		}
+	    }
+	}
+    }
+}
+
+/*----------------------------------------------------------*/
+void Tag::mark ()
+{
+  if (!is_primary ()) return;
+  if (m_selected) return;
+
+  Log;
+
+  if (m_tag_excludes.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < m_tag_excludes.size (); number++)
+        {
+          Tag* ref = m_tag_excludes[number];
+
+	  if (ref->is_selected ()) 
+            {
+              if (m_priority > ref->m_priority)
+                {
+                    //
+                    // Although this other contradictory tag is already selected,
+                    // its priority is lower. Therefore it will lose !! It has to be 
+                    // unselected ...
+                    //
+
+                  ref->unmark ();
+                }
+              else
+                {
+                    /*
+                  if (!Cmt::quiet)
+                    {
+                      cerr << "Cannot mark excluded tag " << m_name << " p=" << m_priority
+                           << " because " << ref->m_name << "(" << ref->m_priority << ")" << endl;
+                      show (0);
+                    }
+                    */
+
+                  return;
+                }
+            }
+        }
+    }
+
+  m_selected = true;
+
+  log << "Marking tag[" << this << "] " << m_name << " p=" << m_priority << log_endl;
+
+  if (m_tag_refs.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < m_tag_refs.size (); number++)
+        {
+          Tag* ref = m_tag_refs[number];
+
+          ref->mark ();
+        }
+    }
+}
+
+/*----------------------------------------------------------*/
+void Tag::action (const CmtSystem::cmt_string_vector& words, Use* use)
+{
+  cmt_string name;
+  Tag* tag;
+  Tag* ref;
+
+  if (words.size () < 1) return;
+  name = words[1];
+  if (name == "") return;
+
+  tag = add (name, PriorityUserTag, "use", use);
+
+  int priority = PriorityUserTag;
+  if (tag->m_priority > priority)
+    {
+      priority = tag->m_priority;
+    }
+
+  //if (tag->m_tag_refs.size () == 0)
+  //{
+
+  tag->m_set_use = use;
+
+  //}
+
+  for (int i = 2; i < words.size (); i++)
+    {
+      name = words[i];
+      if (name == "") break;
+      ref = add (name, priority, "use", use);
+      tag->add_tag_ref (ref);
+      if (tag->is_selected ())  // it was previously selected
+	{
+	  ref->mark ();
+	}
+    }
+}
+
+/*----------------------------------------------------------*/
+void Tag::action_apply (const CmtSystem::cmt_string_vector& words, Use* use)
+{
+  cmt_string name;
+  Tag* tag;
+  
+    if (words.size () < 1) return;
+  name = words[1];
+  if (name == "") return;
+  
+  if (use->get_current_scope () == ScopePrivate) return;
+
+  Symbol::expand (name);
+  
+  
+  if (name == "")
+    {
+      if (!Cmt::get_quiet ())
+	{
+	  cerr << "#CMT> Warning: apply_tag with empty name [" << words[1] << "]" << endl;
+	}
+    }
+  else
+    {
+      tag = find (name);
+      if (tag == 0)
+	{
+	  tag = add (name, PriorityUserTag, "use", use);
+	}
+
+      tag->mark ();
+    }
+}
+
+/*----------------------------------------------------------*/
+void Tag::action_exclude (const CmtSystem::cmt_string_vector& words, Use* use)
+{
+  cmt_string name;
+  Tag* tag;
+  Tag* ref;
+
+  if (words.size () < 1) return;
+  name = words[1];
+  if (name == "") return;
+  if (use->get_current_scope () == ScopePrivate) return;
+
+  tag = add (name, PriorityUserTag, "use", use);
+
+  if (tag->m_tag_excludes.size () == 0)
+    {
+      tag->m_set_use = use;
+
+      int i;
+
+      for (i = 2; i < words.size (); i++)
+	{
+          cmt_string n;
+	  n = words[i];
+	  if (n == "") break;
+	  ref = add (n, PriorityUserTag, "use", use);
+
+            /*
+          if (!Cmt::quiet)
+            {
+              cerr << "Excluding tag " << n << "(" << ref->m_priority << ") from tag " 
+                   << name << "(" << tag->m_priority << ")" << endl;
+            }
+            */
+
+	  tag->add_tag_exclude (ref);
+	  ref->add_tag_exclude (tag);
+	}
+
+        //
+        // We have to check that some of the excluded tags may be already selected.
+        // Then we have to figure out which one has to win:
+        //
+        //  the one with the highest priority
+        //  or the first that had been declared.
+        //
+      
+      int count = 0;
+      int winner_count = 0;
+      
+      Tag* winner = 0;
+
+      if (tag->is_selected ()) 
+        {
+          count++;
+          winner = tag;
+          winner_count = 1;
+        }
+
+      for (i = 0; i < tag->m_tag_excludes.size (); i++)
+        {
+          Tag* ref = tag->m_tag_excludes[i];
+          
+          if (ref == 0) continue;
+              
+          if (ref->is_selected ()) 
+            {
+              count++;
+
+              if ((winner == 0) ||
+                  (ref->m_priority > winner->m_priority))
+                {
+                  winner = ref;
+                  winner_count = 1;
+                }
+              else if (ref->m_priority == winner->m_priority)
+                {
+                  winner_count++;
+                }
+            }
+        }
+      
+      if (count > 1)
+        {
+          if (winner_count > 1)
+            {
+                //
+                // Several contradictory tags are selected and have the same priority!!
+                //
+            }
+
+            //
+            // We have at least one selected, and one winner. 
+            // All others will be unselected.
+            //
+          
+          if (tag != winner)
+            {
+              tag->unmark ();
+            }
+
+          for (i = 0; i < tag->m_tag_excludes.size (); i++)
+            {
+              Tag* ref = tag->m_tag_excludes[i];
+              
+              if (ref == 0) continue;
+              if (ref == winner) continue;
+              
+              ref->unmark ();
+            }
+        }
+    }
+}
+
+/*----------------------------------------------------------*/
+Tag* Tag::find (const cmt_string& name)
+{
+  TagMap& map = tag_map ();
+
+  Tag* result = map.find (name);
+
+  return (result);
+
+  /*
+  TagPtrVector& vector = tags ();
+
+  int tag_index;
+  Tag* tag;
+
+  if (vector.size () == 0) return (0);
+
+  for (tag_index = 0; tag_index < vector.size (); tag_index++)
+    {
+      tag = vector[tag_index];
+
+      if ((tag != 0) && (tag->m_name == name))
+        {
+          return (tag);
+        }
+    }
+
+  return (0);
+    */
+}
+
+/*----------------------------------------------------------*/
+Tag* Tag::find (const cmt_string& name, TagMap& instances)
+{
+  Tag* result = instances.find (name);
+
+  return (result);
+
+  /*
+  int tag_index;
+
+  if (instances.size () == 0) return (0);
+
+  for (tag_index = 0; tag_index < instances.size (); tag_index++)
+    {
+      Tag& tag = instances[tag_index];
+
+      if (tag.m_name == name)
+        {
+          return (&tag);
+        }
+    }
+
+  return (0);
+  */
+}
+
+/*----------------------------------------------------------*/
+Tag* Tag::add (const cmt_string& name, 
+	       int priority, 
+               const cmt_string& context, 
+	       Use* use)
+{
+  Log;
+
+  TagMap& map = tag_map ();
+  TagPtrVector& vector = tags ();
+  TagVector& instances = all_tags ();
+
+  Tag* tag;
+
+  if (name == "") return (0);
+
+  tag = find (name);
+  if (tag != 0)
+    {
+      if (priority > tag->m_priority) 
+        {
+          tag->m_priority = priority;
+
+            /*
+          if (!Cmt::quiet)
+            {
+              cerr << "increasing priority of " << name << " p=" << priority << endl;
+            }
+            */
+        }
+      else
+        {
+            /*
+          if (!Cmt::quiet)
+            {
+              cerr << "keeping priority of " << name << " p=" << tag->m_priority << endl;
+            }
+            */
+        }
+
+      log << "re-adding tag[" << tag << "] " << name << " p=" << priority << log_endl;
+
+      return (tag);
+    }
+
+  Tag& tag_object = instances.add ();
+  tag = &tag_object;
+  vector.push_back (tag);
+  map.add (name, tag_object);
+
+  log << "adding tag[" << tag << "] " << name << " p=" << priority << log_endl;
+
+  tag->clear ();
+
+  tag->m_name = name;
+  tag->m_priority = priority;
+  tag->m_def_use = use;
+  tag->m_context = context;
+
+  int pos = 0;
+  int length = name.size ();
+  while (pos < length)
+    {
+      int and_pos = name.find (pos, "&");
+      if ((and_pos == cmt_string::npos) && (pos == 0)) break;
+
+      cmt_string op_name;
+
+      if (and_pos == cmt_string::npos)
+        {
+          name.substr (pos, op_name);
+        }
+      else
+        {
+          name.substr (pos, and_pos - pos, op_name);
+        }
+
+      if (op_name != "")
+        {
+          Tag* t = find (op_name);
+          if (t == 0)
+            {
+              t = add (op_name, priority, context, use);
+            }
+
+          if (t != 0)
+            {
+              tag->m_and_operands.push_back (t);
+              if (t->get_priority () > priority)
+                {
+                  tag->m_priority = t->get_priority ();
+                }
+            }
+          else
+            {
+              cerr << "#Tag::add> unknown tag " << op_name << " in tag expression" << endl;
+            }
+        }
+
+      if (and_pos == cmt_string::npos) break;
+
+      pos = and_pos + 1;
+    }
+
+  return (tag);
+}
+
+/*----------------------------------------------------------*/
+int Tag::tag_number ()
+{
+  static TagPtrVector& vector = tags ();
+
+  return (vector.size ());
+}
+
+/*----------------------------------------------------------*/
+Tag* Tag::tag (int index)
+{
+  static TagPtrVector& vector = tags ();
+
+  return (vector[index]);
+}
+
+/*----------------------------------------------------------*/
+void Tag::clear_all ()
+{
+  TagMap& map = tag_map ();
+  TagPtrVector& vector = tags ();
+  TagVector& instances = all_tags ();
+
+  int tag_index;
+
+  for (tag_index = 0; tag_index < instances.size (); tag_index++)
+    {
+      Tag& tag = instances[tag_index];
+      tag.clear ();
+    }
+
+  map.clear ();
+  vector.clear ();
+  instances.clear ();
+}
+
+/*----------------------------------------------------------*/
+Tag::TagMap& Tag::tag_map ()
+{
+  static Database& db = Database::instance ();
+  TagMap& map = db.tag_map ();
+
+  return (map);
+}
+
+/*----------------------------------------------------------*/
+Tag::TagVector& Tag::all_tags ()
+{
+  static Database& db = Database::instance ();
+  TagVector& vector = db.all_tags ();
+
+  return (vector);
+}
+
+/*----------------------------------------------------------*/
+Tag::TagPtrVector& Tag::tags ()
+{
+  static Database& db = Database::instance ();
+  TagPtrVector& vector = db.tags ();
+
+  return (vector);
+}
+
+/*----------------------------------------------------------*/
+Tag* Tag::get_default ()
+{
+  static Tag default_tag;
+  static bool initialized = false;
+  if (!initialized)
+    {
+      initialized = true;
+
+      default_tag.m_name = "Default";
+      default_tag.m_selected = true;
+      default_tag.m_context = "Default";
+      default_tag.m_priority = PriorityDefault;
+    }
+
+  return (&(default_tag));
+}
+
+/*----------------------------------------------------------*/
+bool Tag::check_tag_used (const Tag* tag)
+{
+  if (tag == 0) return (false);
+
+  if (tag->m_tag_refs.size () > 0) return (true);
+  if (tag->m_tag_excludes.size () > 0) return (true);
+
+  return (false);
+}
+
+/*----------------------------------------------------------*/
+Tag::Tag () :
+  m_name (""),
+  m_selected (false),
+  m_context (""),
+  m_def_use (0),
+  m_set_use (0),
+  m_priority (0)
+{
+  clear ();
+}
+
+/*----------------------------------------------------------*/
+Tag::Tag (const Tag& other)
+{
+  clear ();
+
+  m_name = other.m_name;
+  m_selected = other.m_selected;
+  m_and_operands = other.m_and_operands;
+  m_tag_refs = other.m_tag_refs;
+  m_tag_excludes = other.m_tag_excludes;
+  m_context = other.m_context;
+  m_def_use = other.m_def_use;
+  m_set_use = other.m_set_use;
+  m_priority = other.m_priority;
+}
+
+/*----------------------------------------------------------*/
+Tag& Tag::operator = (const Tag& other)
+{
+  clear ();
+
+  m_name = other.m_name;
+  m_selected = other.m_selected;
+  m_and_operands = other.m_and_operands;
+  m_tag_refs = other.m_tag_refs;
+  m_tag_excludes = other.m_tag_excludes;
+  m_context = other.m_context;
+  m_def_use = other.m_def_use;
+  m_set_use = other.m_set_use;
+  m_priority = other.m_priority;
+
+  return (*this);
+}
+
+/*----------------------------------------------------------*/
+Tag::~Tag ()
+{
+}
+
+/*----------------------------------------------------------*/
+void Tag::clear ()
+{
+  m_name = "";
+  m_tag_refs.clear ();
+  m_tag_excludes.clear ();
+  m_priority = PriorityUserTag;
+  m_def_use = 0;
+  m_set_use = 0;
+  m_context = "";
+
+  m_selected = false;
+  m_and_operands.clear ();
+}
+
+/*----------------------------------------------------------*/
+void Tag::add_tag_ref (Tag* ref)
+{
+  if (ref == 0) return;
+
+  if (m_tag_refs.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < m_tag_refs.size (); number++)
+        {
+          Tag* t = m_tag_refs[number];
+	  if (t == ref) return;
+        }
+    }
+
+  m_tag_refs.push_back (ref);
+}
+
+/*----------------------------------------------------------*/
+void Tag::add_tag_exclude (Tag* ref)
+{
+  if (ref == 0) return;
+
+  if (m_tag_excludes.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < m_tag_excludes.size (); number++)
+        {
+          Tag* t = m_tag_excludes[number];
+	  if (t == ref) return;
+        }
+    }
+
+  m_tag_excludes.push_back (ref);
+}
+
+/*----------------------------------------------------------*/
+void Tag::show_definition (bool quiet) const
+{
+  static const cmt_string priority_text[] = {
+    "Lowest",
+    "Default",
+    "Uname",
+    "Config",
+    "UserTag",
+    "PrimaryUserTag",
+    "Tag"
+  };
+
+  if (m_name == "Default") return;
+
+  cout << m_name;
+
+  if (!quiet)
+    {
+      //cout << "context=" << m_context << " use=" << m_def_use << endl;
+      
+      if ((m_context == "use") || (m_def_use != 0))
+	{
+	  if (m_def_use != 0)
+	    {
+	      cout << " (from ";
+	      if (m_context != "use") cout << m_context;
+	      cout << "package " << m_def_use->get_package_name () << ")";
+	    }
+	}
+      else
+	{
+	  cout << " (from " << m_context << ")";
+	}
+      //cout << " (" << priority_text[m_priority] << ")";
+      
+      if (m_tag_refs.size () > 0)
+	{
+	  int number;
+	  
+	  if (m_set_use != 0)
+	    {
+	      cout << " package " << m_set_use->get_package_name ();
+	    }
+	  
+	  cout << " implies [";
+	  
+	  for (number = 0; number < m_tag_refs.size (); number++)
+	    {
+	      Tag* ref = m_tag_refs[number];
+	      if (number > 0) cout << " ";
+	      cout << ref->m_name;
+	    }
+	  
+	  cout << "]";
+	}
+      
+      if (m_tag_excludes.size () > 0)
+	{
+	  int number;
+	  
+	  if (m_set_use != 0)
+	    {
+	      cout << " package " << m_set_use->get_package_name ();
+	    }
+	  
+	  cout << " excludes [";
+	  
+	  for (number = 0; number < m_tag_excludes.size (); number++)
+	    {
+	      Tag* ref = m_tag_excludes[number];
+	      if (number > 0) cout << " ";
+	      cout << ref->m_name;
+	    }
+	  
+	  cout << "]";
+	}
+    }
+  cout << endl;
+}
+
+/*----------------------------------------------------------*/
+void Tag::show (bool quiet) const
+{
+  if (is_primary () && is_selected ()) show_definition (quiet);
+}
+
+/*----------------------------------------------------------*/
+bool Tag::is_selected () const
+{
+  if (is_primary ())
+    {
+      return (m_selected);
+    }
+  else
+    {
+      for (int i = 0; i < m_and_operands.size(); i++)
+	{
+	  Tag* t = m_and_operands[i];
+
+	  if (!t->is_selected ()) return (false);
+	}
+
+      return (true);
+    }
+}
+
+/*----------------------------------------------------------*/
+bool Tag::is_primary () const
+{
+  return (m_and_operands.size() == 0);
+}
+
+/*----------------------------------------------------------*/
+const cmt_string& Tag::get_name () const
+{
+  return (m_name);
+}
+
+/*----------------------------------------------------------*/
+int Tag::get_priority () const
+{
+  return (m_priority);
+}
+
+/**
+ *  Recomputes all references to other tags using the new set of 
+ *  instances.  This concerns
+ *
+ *    TagPtrVector m_and_operands;
+ *    TagPtrVector m_tag_refs;
+ *    TagPtrVector m_tag_excludes;
+ *
+ *   The pointers stored in those reference vectors are pointing to Tag objects
+ *  in one collection
+ *    We want to convert these pointers to pointers to the same Tag objects but 
+ *  stored in the other Tag collection provided in the argument.
+ *
+ */
+void Tag::install (TagMap& instances)
+{
+  int i;
+
+  for (i = 0; i <  m_and_operands.size (); i++)
+    {
+      Tag* t = m_and_operands[i];
+      if (t != 0)
+        {
+          t = find (t->m_name, instances);
+          m_and_operands[i] = t;
+        }
+    }
+
+  for (i = 0; i <  m_tag_refs.size (); i++)
+    {
+      Tag* t = m_tag_refs[i];
+      if (t != 0)
+        {
+          t = find (t->m_name, instances);
+          m_tag_refs[i] = t;
+        }
+    }
+
+  for (i = 0; i <  m_tag_excludes.size (); i++)
+    {
+      Tag* t = m_tag_excludes[i];
+      if (t != 0)
+        {
+          t = find (t->m_name, instances);
+          m_tag_excludes[i] = t;
+        }
+    }
+}
+
+/*
+  Check if a tag is part of the operands of a tag
+ */
+bool Tag::use_operand (const Tag* other) const
+{
+  if (other == this) return (true);
+  if (m_and_operands.size () == 0) return (false);
+
+  for (int i = 0; i < m_and_operands.size (); i++)
+    {
+      Tag* t = m_and_operands[i];
+
+      if (t != 0)
+        {
+	  if (t->use_operand (other)) return (true);
+        }
+    }
+
+  return (false);
+}
+
+/*
+  Check if a tag is part of the refs of a tag
+ */
+bool Tag::use_ref (const Tag* other) const
+{
+  if (other == this) return (false);
+  if (m_tag_refs.size () == 0) return (false);
+
+  for (int i = 0; i < m_tag_refs.size (); i++)
+    {
+      Tag* t = m_tag_refs[i];
+
+      if (t == other) return (true);
+    }
+
+  return (false);
+}
+
+
Index: /CMT/v1r20/source/cmt_tag.h
===================================================================
--- /CMT/v1r20/source/cmt_tag.h	(revision 368)
+++ /CMT/v1r20/source/cmt_tag.h	(revision 368)
@@ -0,0 +1,76 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_tag_h__
+#define __cmt_tag_h__
+
+#include "cmt_parser.h"
+#include "cmt_system.h"
+#include "cmt_use.h"
+#include "cmt_map.h"
+
+class Tag
+{
+public:
+  typedef cmt_map<cmt_string, Tag> TagMap;
+  typedef cmt_vector<Tag> TagVector;
+  typedef cmt_vector<Tag*> TagPtrVector;
+
+  static void action (const CmtSystem::cmt_string_vector& words, Use* use);
+  static void action_apply (const CmtSystem::cmt_string_vector& words, Use* use);
+  static void action_exclude (const CmtSystem::cmt_string_vector& words, Use* use);
+  static Tag* find (const cmt_string& name, TagMap& instances);
+  static Tag* find (const cmt_string& name);
+  static Tag* add (const cmt_string& name, int priority,
+                   const cmt_string& context, Use* use = 0);
+  static int tag_number ();
+  static Tag* tag (int index);
+  static void unmark_all ();
+  static void restore_tree ();
+  static void clear_all ();
+
+  static TagMap& tag_map ();
+  static TagVector& all_tags ();
+  static TagPtrVector& tags ();
+
+  static Tag* get_default ();
+
+  static bool check_tag_used (const Tag* tag);
+
+public:
+  Tag ();
+  Tag (const Tag& other);
+  Tag& operator = (const Tag& other);
+  ~Tag ();
+  void clear ();
+  void add_tag_ref (Tag* ref);
+  void add_tag_exclude (Tag* ref);
+  void unmark ();
+  void mark ();
+  void show_definition (bool quiet) const;
+  void show (bool quiet) const;
+  bool is_selected () const;
+  bool is_primary () const;
+  const cmt_string& get_name () const;
+  int get_priority () const;
+  void install (TagMap& instances);
+  bool use_operand (const Tag* other) const;
+  bool use_ref (const Tag* other) const;
+
+private:
+  cmt_string m_name;
+  bool m_selected;
+  TagPtrVector m_and_operands;
+  TagPtrVector m_tag_refs;
+  TagPtrVector m_tag_excludes;
+  cmt_string m_context;
+  Use* m_def_use;
+  Use* m_set_use;
+  int m_priority;
+  ScopeType scope;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_triggers.cxx
===================================================================
--- /CMT/v1r20/source/cmt_triggers.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_triggers.cxx	(revision 368)
@@ -0,0 +1,838 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+/*
+
+From Frank Behner, John Allison 13th February 1999.
+From Christian Arnault               Oct.     2000
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "cmt_triggers.h"
+#include "cmt_std.h"
+#include "cmt_string.h"
+#include "cmt_system.h"
+#include "cmt_awk.h"
+#include "cmt_use.h"
+#include "cmt_symbol.h"
+#include "cmt_constituent.h"
+#include "cmt_syntax.h"
+
+//--------------------------------------------------
+class Libmap
+{
+public:
+  typedef cmt_vector<Libmap> LibmapVector;
+
+  static Libmap& find (const cmt_string& name, const cmt_string& package);
+  static Libmap& add (const cmt_string& name, const cmt_string& package);
+  static LibmapVector& libmaps ();
+  static Libmap& find_with_trigger (const cmt_string& name);
+  static Libmap& null ();
+
+public:
+  Libmap ();
+
+  void add_trigger (const cmt_string& trigger_name);
+  void add_use (const cmt_string& use_name);
+  int operator != (const Libmap& other) const;
+  int operator == (const Libmap& other) const;
+  void set_used ();
+
+  cmt_string name;
+  cmt_string package;
+  CmtSystem::cmt_string_vector triggers;
+  bool used;
+  CmtSystem::cmt_string_vector uses;
+};
+//--------------------------------------------------
+
+//--------------------------------------------------
+Libmap& Libmap::find (const cmt_string& name, const cmt_string& package)
+{
+  LibmapVector& table = libmaps ();
+
+  for (int i = 0; i < table.size (); i++)
+    {
+      Libmap& libmap = table[i];
+
+#ifdef USE_PACKAGE_SCOPE
+      if ((name == libmap.name) &&
+	  (package == libmap.package)) return (libmap);
+#else
+      if (name == libmap.name) return (libmap);
+#endif
+    }
+
+  return (null ());
+}
+
+Libmap& Libmap::add (const cmt_string& name, const cmt_string& package)
+{
+  {
+    Libmap& libmap = find (name, package);
+
+    if (libmap != null ()) return (libmap);
+  }
+
+  LibmapVector& table = libmaps ();
+
+  Libmap& libmap = table.add ();
+
+  libmap.name = name;
+  libmap.package = package;
+
+  return (libmap);
+}
+
+Libmap::LibmapVector& Libmap::libmaps ()
+{
+  static cmt_vector<Libmap> table;
+
+  return (table);
+}
+
+Libmap::Libmap () : used (false)
+{
+}
+
+void Libmap::add_trigger (const cmt_string& trigger_name)
+{
+  cmt_string& trigger = triggers.add ();
+
+  trigger = trigger_name;
+}
+
+void Libmap::add_use (const cmt_string& use_name)
+{
+  cmt_string& use = uses.add ();
+
+  use = use_name;
+}
+
+Libmap& Libmap::find_with_trigger (const cmt_string& name)
+{
+  LibmapVector& table = libmaps ();
+
+  for (int i = 0; i < table.size (); i++)
+    {
+      Libmap& libmap = table[i];
+
+      for (int j = 0; j < libmap.triggers.size (); j++)
+	{
+	  const cmt_string& trigger = libmap.triggers[j];
+
+	  if (name == trigger) return (libmap);
+	}
+    }
+
+  return (null ());
+}
+
+Libmap& Libmap::null ()
+{
+  static Libmap null_libmap;
+
+  return (null_libmap);
+}
+
+int Libmap::operator != (const Libmap& other) const
+{
+  return (this != &other);
+}
+
+int Libmap::operator == (const Libmap& other) const
+{
+  return (this == &other);
+}
+
+void Libmap::set_used ()
+{
+  if (used) return;
+
+  used = true;
+
+  cmt_string package_name;
+  cmt_string use_name;
+
+  for (int i = 0; i < uses.size (); i++)
+    {
+      const cmt_string& use = uses[i];
+
+      int pos = use.find ("::");
+
+      if (pos == cmt_string::npos)
+	{
+	  package_name = "";
+	  use_name = use;
+	}
+      else
+	{
+	  use.substr (0, pos, package_name);
+	  use.substr (pos + 2, use_name);
+
+	  Libmap& libmap = find (use_name, package_name);
+	  if (libmap != null ())
+	    {
+	      libmap.set_used ();
+	    }
+	}
+    }
+}
+//--------------------------------------------------
+
+//--------------------------------------------------
+//
+//  This class analyzes a trigger description file (ie a file
+// named <constituent>.triggers and located in the cmt directory of
+// a package).
+//
+//  The file is expected to include lines of the form:
+//
+//    <constituent>_implied_libs=<lib> <lib> ...
+//    <constituent>_triggers=<trigger> <trigger> ...
+//
+//  with <lib> having the form:
+//
+//    <package>::<constituent>
+//     eg: Cm::Cm
+//
+//    or more simply
+//
+//    <constituent>
+//
+//  and <trigger> being an include file path (in the same form as
+//  the one used in the dependency files)
+//
+//     eg: $(CMROOT)/src/Cm.h
+//         $(AGDDROOT)/AGDD/AGDD.h
+// 
+//
+//    When reading one trigger description file, one Libmap object is 
+// created, and its list of uses and triggers are filled in.
+//
+//--------------------------------------------------
+class TriggerAnalyzer : public FAwk
+{
+public:
+  TriggerAnalyzer (const cmt_string& package_name);
+  void begin ();
+  void filter (const cmt_string& line);
+  void end ();
+
+private:
+  cmt_string package;
+};
+//--------------------------------------------------
+
+//--------------------------------------------------
+TriggerAnalyzer::TriggerAnalyzer (const cmt_string& package_name) :
+  package (package_name)
+{
+}
+
+void TriggerAnalyzer::begin ()
+{
+}
+
+void TriggerAnalyzer::filter (const cmt_string& line)
+{
+  int pos = line.find ("=");
+  if (pos == 0)
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cerr << "Syntax error in trigger file : empty name" << endl;
+        }
+      exit (0);
+    }
+  if (pos == cmt_string::npos)
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cerr << "Syntax error in trigger file : no = sign" << endl;
+        }
+      exit (0);
+    }
+
+  cmt_string name;
+  cmt_string text;
+  CmtSystem::cmt_string_vector words;
+
+  line.substr (0, pos, name);
+  line.substr (pos + 1, text);
+  CmtSystem::split (text, " ", words);
+
+  if (name.find ("_triggers") != cmt_string::npos)
+    {
+      name.replace ("_triggers", "");
+
+      Libmap& libmap = Libmap::add (name, package);
+
+      for (int i = 0; i < words.size (); i++)
+	{
+	  const cmt_string& w = words[i];
+	  libmap.add_trigger (w);
+	}
+    }
+  else if (name.find ("_implied_libraries") != cmt_string::npos)
+    {
+      name.replace ("_implied_libraries", "");
+
+      Libmap& libmap = Libmap::add (name, package);
+
+      for (int i = 0; i < words.size (); i++)
+	{
+	  const cmt_string& w = words[i];
+	  libmap.add_use (w);
+	}
+    }
+  else
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cerr << "Syntax error in trigger file : bad keyword (" << 
+              name << ")" << endl;
+        }
+      exit (0);
+    }
+}
+
+void TriggerAnalyzer::end ()
+{
+}
+//--------------------------------------------------
+
+//--------------------------------------------------
+//
+//  This filter scans the CMT dependency file of a constituent.
+//
+//  The file should contains a set of entries, each composed of one line:
+//
+//      <module-name>_dependencies=<dependency> <dependency> ...
+//
+//  (Each such line actually defines one make macro used to trigger the
+//   rebuild of the corresponding module)
+//
+//  Dependencies may typically be:
+//     o the module source itself
+//     o a local dependency (ie. one which is preficed by one of the
+//              include dirs)
+//     o an external dependency (all other cases)
+//
+//  Local dependencies will generate triggers for this constituent (filling
+//  up the "triggers" unique-vector)
+//
+//  External dependencies will trigger the use of one Libmap object (thus
+//  filling up the "uses" unique-vector)
+//
+//  At the end of the scan, the results are printed to standard output
+//  with a format of a trigger description file.
+//
+//    For libraries, only the first level list is output (ie. only Libmap
+//  object directly triggered by dependencies of that constituent are
+//  listed)
+//
+//    For applications, indirect dependencies are considered and resolved
+//  recursively.
+//
+//--------------------------------------------------
+class DependencyAnalyzer : public FAwk
+{
+public:
+  DependencyAnalyzer (const cmt_string& package_name, 
+		      Constituent& constituent_ref);
+  void begin ();
+  void filter (const cmt_string& line);
+  virtual void end ();
+
+protected:
+
+  void add_trigger (const cmt_string& name);
+  void add_use (Libmap& libmap);
+
+  CmtSystem::cmt_string_vector include_dirs;
+  cmt_vector<Libmap*> uses;
+  CmtSystem::cmt_string_vector triggers;
+  Constituent& constituent;
+  cmt_string package;
+  cmt_string package_upper;
+};
+
+class LibraryAnalyzer : public DependencyAnalyzer
+{
+public:
+  LibraryAnalyzer (const cmt_string& package_name, 
+                   Constituent& constituent_ref);
+  void end ();
+};
+
+class ApplicationAnalyzer : public DependencyAnalyzer
+{
+public:
+  ApplicationAnalyzer (const cmt_string& package_name, 
+                       Constituent& constituent_ref);
+  void end ();
+};
+//--------------------------------------------------
+
+//--------------------------------------------------
+DependencyAnalyzer::DependencyAnalyzer (const cmt_string& package_name, 
+					Constituent& constituent_ref) :
+        package (package_name),
+        constituent (constituent_ref)
+{
+  cmt_string dirs;
+
+  int pos;
+  char c;
+
+  package_upper = package;
+
+  for (pos = 0; pos < package_upper.size (); pos++)
+    {
+      c = package_upper[pos];
+      package_upper[pos] = toupper (c);
+    }
+
+  CmtSystem::execute ("cmt show include_dirs", dirs);
+  dirs.replace_all ("\n", "");
+  CmtSystem::split (dirs, " ", include_dirs);
+}
+
+void DependencyAnalyzer::begin ()
+{
+}
+
+void DependencyAnalyzer::filter (const cmt_string& line)
+{
+    /* Clip target out of dependency file... */
+  int pos = line.find ("=");
+  if ((pos == 0) || (pos == cmt_string::npos))
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cerr << "  ERROR: Syntax in dependency file: " << line << endl;
+          cerr << "  Missing = or target name." << endl;
+        }
+      exit (1);
+    }
+
+  cmt_string module;
+
+  line.substr (0, pos, module);
+  module.trim ();
+  module.replace ("_dependencies", "");
+
+  if (module == "cmt_path_make") return;
+
+  int underscore = module.find_last_of ("_");
+
+  if (underscore != cmt_string::npos)
+    {
+      module[underscore] = '.';
+    }
+
+  static cmt_string dependencies;
+
+  line.substr (pos + 1, dependencies);
+
+  if (dependencies == "") 
+    {
+      cerr << "#CMT> Warning: It seems there is nothing after \'=\' "
+          "in dependency file " << m_file_name << endl;
+      return;
+    }
+
+  CmtSystem::cmt_string_vector deps;
+
+  CmtSystem::split (dependencies, " ", deps);
+
+  for (int i = 0; i < deps.size (); i++)
+    {
+      const cmt_string& dep = deps[i];
+
+        //
+        // dep may either be:
+        //  o the module itself
+        //  o a file in one of include_dirs
+        //  o something else
+        //
+
+      if (dep.find (module) != cmt_string::npos)
+        {
+	  // This is the module itself.
+        }
+      else
+        {
+          bool found = false;
+
+          for (int j = 0; j < include_dirs.size (); j++)
+            {
+              const cmt_string& dir = include_dirs[j];
+
+              if (dep.find (dir) == 0)
+                {
+		  // This is a local dependency.
+
+                  cmt_string name = dep;
+
+		  if (dir == "$(src)")
+		    {
+		      cmt_string new_dir;
+
+		      new_dir = "$(";
+		      new_dir += package_upper;
+		      new_dir += "ROOT)/src/";
+
+		      name.replace (dir, new_dir);
+		    }
+
+		  if (CmtSystem::file_separator () == '\\')
+		    {
+		      name.replace_all (CmtSystem::file_separator (), "/");
+		    }
+
+		  Libmap& libmap = Libmap::find_with_trigger (name);
+
+		  if (libmap != Libmap::null ())
+		    {
+		      add_use (libmap);
+		    }
+		  else
+		    {
+		      add_trigger (name);
+		    }
+
+                  found = true;
+                  break;
+                }
+            }
+
+          if (!found)
+            {
+	      cmt_string name = dep;
+
+	      if (CmtSystem::file_separator () == '\\')
+		{
+		  name.replace_all (CmtSystem::file_separator (), "/");
+		}
+
+	      // This is an external dependency.
+
+	      Libmap& libmap = Libmap::find_with_trigger (name);
+
+	      if (libmap != Libmap::null ())
+		{
+		  add_use (libmap);
+		}
+            }
+        }
+    }
+}
+
+void DependencyAnalyzer::end ()
+{
+}
+
+void DependencyAnalyzer::add_trigger (const cmt_string& name)
+{
+  for (int i = 0; i < triggers.size (); i++)
+    {
+      const cmt_string& trigger = triggers[i];
+
+      if (trigger == name) return;
+    }
+
+  cmt_string& new_trigger = triggers.add ();
+
+  new_trigger = name;
+}
+
+void DependencyAnalyzer::add_use (Libmap& libmap)
+{
+  for (int i = 0; i < uses.size (); i++)
+    {
+      const Libmap& ref = *(uses[i]);
+
+      if (ref == libmap) return;
+    }
+
+  uses.push_back (&libmap);
+}
+
+LibraryAnalyzer::LibraryAnalyzer (const cmt_string& package_name, 
+                                  Constituent& constituent_ref) :
+    DependencyAnalyzer (package_name, constituent_ref)
+{
+}
+
+void LibraryAnalyzer::end ()
+{
+  cmt_string macro_name;
+  cmt_string output;
+
+  int i;
+
+  if (uses.size () > 0)
+    {
+      for (i = 0; i < uses.size (); i++)
+	{
+	  Libmap& libmap = *(uses[i]);
+
+	  libmap.set_used ();
+	}
+
+      Libmap::LibmapVector& table = Libmap::libmaps ();
+
+      macro_name = constituent.name;
+      macro_name += "_implied_libraries";
+
+      output  = "macro_prepend ";
+      output += macro_name;
+      output += " \"";
+      for (i = 0; i < table.size (); i++)
+	{
+	  Libmap& libmap = table[i];
+	  
+	  if (libmap.used)
+	    {
+#ifdef USE_PACKAGE_SCOPE
+	      output += libmap.package;
+              output += "::";
+#endif
+              output += libmap.name;
+              output += " ";
+	    }
+	}
+      output += "\"";
+
+      SyntaxParser::parse_requirements_text (output, "", 0);
+
+      Symbol* macro = Symbol::find (macro_name);
+      output = macro_name;
+      output += "=";
+      output += macro->build_macro_value ();
+
+      cout << output << endl;
+    }
+
+  if (triggers.size () > 0)
+    {
+      macro_name = constituent.name;
+      macro_name += "_triggers";
+
+      output  = "macro_prepend ";
+      output += macro_name;
+      output += " \"";
+      for (i = 0; i < triggers.size (); i++)
+	{
+	  const cmt_string& trigger = triggers[i];
+	  
+	  output += trigger;
+          output += " ";
+	}
+      output += "\"";
+
+      SyntaxParser::parse_requirements_text (output, "", 0);
+
+      Symbol* macro = Symbol::find (macro_name);
+      output = macro_name;
+      output += "=";
+      output += macro->build_macro_value ();
+
+      cout << output << endl;
+    }
+}
+
+ApplicationAnalyzer::ApplicationAnalyzer (const cmt_string& package_name, 
+                                          Constituent& constituent_ref) :
+    DependencyAnalyzer (package_name, constituent_ref)
+{
+}
+
+void ApplicationAnalyzer::end ()
+{
+  cmt_string macro_name;
+  cmt_string output;
+
+  int i;
+
+  if (uses.size () > 0)
+    {
+      for (i = 0; i < uses.size (); i++)
+	{
+	  Libmap& libmap = *(uses[i]);
+
+	  libmap.set_used ();
+	}
+
+      Libmap::LibmapVector& table = Libmap::libmaps ();
+
+      macro_name = constituent.name;
+      macro_name += "linkopts";
+
+      output  = "macro_prepend ";
+      output += macro_name;
+      output += " \"";
+      for (i = 0; i < table.size (); i++)
+	{
+	  Libmap& libmap = table[i];
+	  
+	  if (libmap.used)
+	    {
+              output += "$(implied_library_prefix)";
+              output += libmap.name;
+              output += "$(implied_library_suffix) ";
+	    }
+	}
+      output += "\"";
+
+      SyntaxParser::parse_requirements_text (output, "", 0);
+
+      Symbol* macro = Symbol::find (macro_name);
+      output = macro_name;
+      output += "=";
+      output += macro->build_macro_value ();
+
+      cout << output << endl;
+    }
+}
+//--------------------------------------------------
+
+//--------------------------------------------------
+//
+//  The UseAnalyzer is called first to reach all used packages.
+// For each package found, it retreives the *.triggers files
+// which contain the trigger descriptions for every constituent
+// of the package.
+//
+//  For each trigger description file found, a TriggerAnalyzer is run
+// which in turn fills in the database of Libmap objects.
+//
+//--------------------------------------------------
+class UseAnalyzer
+{
+public:
+  void run (const cmt_string& constituent);
+  void run (const cmt_string& location, 
+            const cmt_string& package,
+            const cmt_string& filter_out = "");
+};
+//--------------------------------------------------
+
+//--------------------------------------------------
+void UseAnalyzer::run (const cmt_string& constituent)
+{
+  Use* use = &(Use::current ());
+
+  run ("./", use->get_package_name (), constituent);
+
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+  for (int i = 0; i < uses.size (); i++)
+    {
+      use = uses[i];
+
+      cmt_string s;
+                                  
+      s = use->real_path;
+      s += CmtSystem::file_separator ();
+      s += use->get_package_name ();
+      s += CmtSystem::file_separator ();
+      s += use->version;
+      s += CmtSystem::file_separator ();
+                                  
+      if (use->style == mgr_style) s += "mgr";
+      else s += "cmt";
+
+      s += CmtSystem::file_separator ();
+
+      run (s, use->get_package_name ());
+    }
+}
+
+void UseAnalyzer::run (const cmt_string& location, 
+                       const cmt_string& package,
+                       const cmt_string& filter_out)
+{
+  static cmt_regexp expression ("[.]triggers$");
+
+  TriggerAnalyzer analyzer (package);
+
+  CmtSystem::cmt_string_vector files;
+
+  CmtSystem::scan_dir (location, expression, files);
+
+  cmt_string name;
+
+  for (int i = 0; i < files.size (); i++)
+    {
+      const cmt_string& file = files[i];
+
+      if (filter_out != "")
+        {
+          CmtSystem::basename (file, ".triggers", name);
+          if (name == filter_out) continue;
+        }
+
+      analyzer.run (file);
+    }
+}
+//--------------------------------------------------
+
+
+//--------------------------------------------------
+void TriggerGenerator::run (const cmt_string& constituent_name)
+{
+  Constituent* constituent = Constituent::find (constituent_name);
+
+  Use* use = &(Use::current ());
+  cmt_string package = use->get_package_name ();
+
+    // UseAnalyzer use_analyzer (package);
+    // use_analyzer.run ("cmt show uses -quiet");
+
+  UseAnalyzer use_analyzer;
+  use_analyzer.run (constituent_name);
+
+  cmt_string file_name;
+
+  file_name = "./";
+  file_name += constituent_name;
+  file_name += "_dependencies.";
+#ifdef WIN32
+  file_name += "nmake";
+#else
+  file_name += "make";
+#endif
+
+  DependencyAnalyzer* analyzer = 0;
+
+  if (constituent->type == Library)
+    {
+      analyzer = new LibraryAnalyzer (package, *constituent);
+    }
+  else if (constituent->type == Application)
+    {
+      analyzer = new ApplicationAnalyzer (package, *constituent);
+    }
+  else
+    {
+      return;
+    }
+
+  if (analyzer->run (file_name) == Awk::failed)
+    {
+      cerr << "  File " << file_name << " not found" << endl;
+    }
+
+  delete analyzer;
+}
+//--------------------------------------------------
Index: /CMT/v1r20/source/cmt_triggers.h
===================================================================
--- /CMT/v1r20/source/cmt_triggers.h	(revision 368)
+++ /CMT/v1r20/source/cmt_triggers.h	(revision 368)
@@ -0,0 +1,19 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_triggers_h__
+#define __cmt_triggers_h__
+
+#include "cmt_std.h"
+#include "cmt_string.h"
+
+class TriggerGenerator
+{
+public:
+  static void run (const cmt_string& constituent_name);
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_use.cxx
===================================================================
--- /CMT/v1r20/source/cmt_use.cxx	(revision 368)
+++ /CMT/v1r20/source/cmt_use.cxx	(revision 368)
@@ -0,0 +1,4437 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cmt_use.h"
+#include "cmt_system.h"
+#include "cmt_symbol.h"
+#include "cmt_error.h"
+#include "cmt_database.h"
+#include "cmt_syntax.h"
+
+static void show_packages ();
+
+/*
+ *   Design.
+ *
+ *   There is one central database of all Use objects. This in the Database using:
+ *       Database::instance().get_instances ();
+ *
+ *   There is also a list of selected Use pointers available from
+ *       Database::instance().get_ordered_uses ();
+ *
+ *   A new Use object is created when a new use statement requires it:
+ *     o if the specified version is specified for the first time
+ *     o if the specified path is specified for the first time
+ *
+ */
+
+static bool add_request (const cmt_string& path,
+			 const cmt_string& package_name,
+			 const cmt_string& version)
+{
+  static cmt_map <cmt_string, bool> requests;
+
+  cmt_string request = package_name;
+  request += " ";
+  request += version;
+  request += " ";
+  request += path;
+  static bool b = true;
+
+  bool new_request = false;
+
+  if (!requests.has ((const cmt_string&) request))
+    {
+      new_request = true;
+      requests.add ((const cmt_string&) request, b);
+    }
+
+  return (new_request);
+}
+
+class UseContext
+{
+public:
+
+  static UseContext& current ()
+  {
+    static UseContext me;
+
+    return (me);
+  }
+
+  UseContext ()
+  {
+    m_auto_imports = On;
+  }
+
+  UseContext (const UseContext& other)
+  {
+    m_auto_imports = other.m_auto_imports;
+  }
+
+  UseContext& operator = (const UseContext& other)
+  {
+    m_auto_imports = other.m_auto_imports;
+
+    return (*this);
+  }
+
+  static void set_current (State auto_imports)
+  {
+    UseContext& c = current ();
+
+    c.m_auto_imports = auto_imports;
+  }
+
+  static State get_current_auto_imports ()
+  {
+    UseContext& c = current ();
+
+    return (c.m_auto_imports);
+  }
+
+private:
+  State m_auto_imports;
+};
+
+
+class BestFitSelector
+{
+public:
+  Use* operate (Use* ref_use, Use* new_use);
+};
+
+//----------------------------------------------------------
+
+typedef enum
+{
+  IdenticalIds,
+
+  IncompatibleMajorIds,
+  NewMajorIdGreaterThanOld,
+  OldMajorIdGreaterThanNew,
+  ExplicitOldMajorIdWinsAgainstWildarded,
+  ExplicitNewMajorIdWinsAgainstWildarded,
+
+  ExplicitOldMinorIdWinsAgainstWildarded,
+  ExplicitNewMinorIdWinsAgainstWildarded,
+  NewMinorIdGreaterThanOld,
+
+  ExplicitOldPatchIdWinsAgainstWildarded,
+  ExplicitNewPatchIdWinsAgainstWildarded,
+  NewPatchIdGreaterThanOld
+} CompareStatus;
+
+static CompareStatus compare_versions (const cmt_string& ref_version, const cmt_string& new_version)
+{
+  CompareStatus result = IdenticalIds;
+
+  int old_v = -1;
+  int old_r = -1;
+  int old_p = -1;
+
+  int new_v = -1;
+  int new_r = -1;
+  int new_p = -1;
+
+  CmtSystem::is_version_directory (ref_version, old_v, old_r, old_p);
+
+  CmtSystem::is_version_directory (new_version, new_v, new_r, new_p);
+
+  if ((new_v != -1) && (old_v != -1) && (new_v != old_v))
+    {
+      /*
+      if (!Cmt::get_quiet ())
+	{
+	  cout << "#1 Required version " << new_version <<
+	    " incompatible with selected version " << ref_version <<
+	    endl;
+	}
+      */
+
+      if (new_v > old_v)
+	{
+	  result = NewMajorIdGreaterThanOld;
+	}
+      else
+	{
+	  result = OldMajorIdGreaterThanNew;
+	}
+      //result = IncompatibleMajorIds;
+    }
+  else if ((new_v == -1) || (old_v == -1))
+    {
+      //
+      // we plan to discard new_use, but if it was specified as explicit 
+      // and ref_use was wildcarded then new_use will win !!
+      //
+      // So then we'll have to understand where are the wild
+      // cards... If they are on v or r, then we consider them.
+      // 
+      //
+
+
+      if ((old_v == -1) && (new_v != -1))
+	{
+	  /*
+	  if (!Cmt::get_quiet ())
+	    {
+	      cout << "#2 Select version " << new_version <<
+		" instead of existing " << ref_version <<
+		endl;
+	    }
+	  */
+
+          result = ExplicitNewMajorIdWinsAgainstWildarded;
+	}
+      else
+	{
+	  /*
+	  if (!Cmt::get_quiet ())
+	    cout << "#3 keep version " << ref_version <<
+	      " (ignore version " << new_version << ")" <<
+	      endl;
+	  */
+
+          result = ExplicitOldMajorIdWinsAgainstWildarded;
+	}
+    }
+  else if ((new_r == -1) || (old_r == -1) || (new_r < old_r))
+    {
+      //
+      // we plan to discard new_use, but if it was specified as explicit 
+      // and ref_use was wildcarded then new_use will win !!
+      //
+      // So then we'll have to understand where are the wild
+      // cards... If they are on v or r, then we consider them.
+      // 
+      //
+
+
+      if ((old_r == -1) && (new_r != -1))
+	{
+	  // old has wild card and new has not => new wins
+
+	  /*
+	  if (!Cmt::get_quiet ())
+	    {
+	      cout << "#4 Select release " << new_version
+		   << " instead of existing " << ref_version
+		   << endl;
+	    }
+	  */
+
+          result = ExplicitNewMinorIdWinsAgainstWildarded;
+	}
+      else
+	{
+	  /*
+	  if (!Cmt::get_quiet ())
+	    cout << "#5 keep release " << ref_version <<
+	      " (ignore release " << new_version << ")" <<
+	      endl;
+	  */
+
+          result = ExplicitOldMinorIdWinsAgainstWildarded;
+	}
+    }
+  else if (new_r > old_r)
+    {
+      /*
+      if (!Cmt::get_quiet ())
+        {
+          cout << "#6 Select release " << new_version <<
+            " instead of existing " << ref_version <<
+            endl;
+        }
+      */
+ 
+      result = NewMinorIdGreaterThanOld;
+   }
+  else if ((new_p == -1) || (old_p == -1) || (new_p < old_p))
+    {
+      //
+      // we plan to discard new_use, but if it was specified as explicit 
+      // and ref_use was wildcarded then new_use will win !!
+      //
+
+
+      if ((old_p == -1) && (new_p != -1))
+	{
+	  /*
+	  if (!Cmt::get_quiet ())
+	    {
+	      cout << "#7 Select patch " << new_version <<
+		" instead of existing " << ref_version <<
+		endl;
+	    }
+	  */
+
+	  result = ExplicitNewPatchIdWinsAgainstWildarded;
+	}
+      else
+	{
+	  /*
+	  if (!Cmt::get_quiet ())
+	    cout << "#8 keep patch " << ref_version <<
+	      " (ignore version " << new_version << ")" <<
+	      endl;
+	  */
+
+	  result = ExplicitOldPatchIdWinsAgainstWildarded;
+	}
+    }
+  else if (new_p > old_p)
+    {
+      /*
+      if (!Cmt::get_quiet ())
+        {
+          cout << "#9 Select patch " << new_version <<
+            " instead of existing " << ref_version <<
+            endl;
+        }
+      */
+
+      result = NewPatchIdGreaterThanOld;
+    }
+
+  return (result);
+}
+
+//----------------------------------------------------------
+//
+//  Operations on Use
+//
+//----------------------------------------------------------
+
+/**
+ *  Mark all clients of the current package.
+ */
+void Use::select_clients (const cmt_string& package,
+                          const cmt_string& version)
+{
+  static UsePtrVector& uses = get_ordered_uses ();
+
+  int number;
+  Use* use = 0;
+
+  unselect_all ();
+  undiscard_all ();
+
+  for (number = uses.size () - 1; number >= 0; number--)
+    {
+      use = uses[number];
+      if (use == 0) continue;
+      if (use->is_selected ()) continue;
+      use->select ();
+      if (!use->is_client (package, version)) use->discard ();
+    }
+}
+
+//----------------------------------------------------------
+void Use::show_all (bool skip_discarded)
+{
+  show_all ("use ", skip_discarded);
+}
+
+//----------------------------------------------------------
+void Use::show_cycles ()
+{
+  static int level = 0;
+  static UsePtrVector stack;
+  int size = 0;
+
+  if (level == 0)
+    {
+      unselect_all ();
+      unselect ();
+      stack.clear ();
+    }
+
+  //for (int i = 0; i < level; i++) cout << "  ";
+  //cout << "Use::show_cycles> " << level << " " << get_package_name () << endl;
+  
+  // Detect cycles.
+  for (int k = 0; k < level; k++)
+    {
+      Use* u = stack[k];
+      if (u == this) 
+	{
+	  for (;k < level; k++)
+	    {
+	      u = stack[k];
+	      cout << u->get_package_name () << " ";
+	    }
+
+	  cout << endl;
+
+	  return;
+	}
+    }
+
+  // Save this to the stack.
+  if (stack.size () <= level)
+    {
+      stack.push_back (this);
+    }
+  else
+    {
+      stack[level] = this;
+    }
+
+  if (selected) return;
+  selected = true;
+
+  size = sub_uses.size ();
+  for (int n = 0; n < size; n++)
+    {
+      Use* use = sub_uses[n];
+      
+      if (use == 0) continue;
+      
+      //for (int i = 0; i < level; i++) cout << "  ";
+      //cout << "Use::show_cycles> " << get_package_name () << " uses " << use->get_package_name () << endl;
+
+      if (use->discarded)
+	{
+	  Use* u;
+	  
+	  u = use->get_selected_version ();
+	  if (u == 0) continue;
+	  
+	  use = u;
+	}
+      
+      level++;
+      use->show_cycles ();
+      level--;
+    }
+}
+
+//----------------------------------------------------------
+void Use::push_scope_section (ScopeType type)
+{
+  scope_sections.push_back (type);
+}
+
+//----------------------------------------------------------
+void Use::pop_scope_section ()
+{
+  scope_sections.pop_back ();
+}
+
+//----------------------------------------------------------
+void Use::close_scope_sections ()
+{
+  scope_sections.clear ();
+}
+
+//----------------------------------------------------------
+ScopeType Use::get_current_scope () const
+{
+  if (scope_sections.size () == 0) return (initial_scope);
+  const ScopeSection& s = scope_sections.back ();
+  return (s.get_scope ());
+}
+
+//----------------------------------------------------------
+void Use::show_all (const cmt_string& prefix, bool skip_discarded)
+{
+  static UsePtrVector& uses = get_ordered_uses ();
+
+  Use* use;
+  int number;
+
+  if (Cmt::get_debug ())
+    {
+      cout << "use::show_all-1> ";
+      
+      int i;
+      
+      for (i = 0; i < uses.size (); i++)
+	{
+	  Use* u = uses[i];
+	  cout << u->get_package_name () << "[" << u->get_index () << "]" << " ";
+	}
+      
+      cout << endl;
+    }
+
+  unselect_all ();
+
+  use = &(current ());
+  use->unselect ();
+  if (!Cmt::get_quiet ()) use->show_sub_uses ("", skip_discarded);
+
+  if (uses.size () > 0)
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cout << "#\n";
+          cout << "# Selection :\n";
+        }
+
+      //
+      //  First move the CMT package to the end of the use set.
+      //  (ie. used by everybody)
+      //
+      use = Use::find ("CMT");
+      Use::move (use);
+
+      for (number = uses.size () - 1; number >= 0; number--)
+        {
+          use = uses[number];
+
+          if (use->discarded) continue;
+          if (use->m_hidden) continue;
+
+          if (!use->located ())
+            {
+              if (!Cmt::get_quiet ())
+                {
+                  cout << "# package " << use->get_package_name () <<
+                      " " << use->version << " " << use->path << 
+                      " not found" <<
+                      endl;
+                }
+              CmtError::set (CmtError::package_not_found, use->get_package_name ());
+            }
+          else
+            {
+              static const cmt_string empty;
+              cmt_string p = use->real_path;
+              if (use->path != "")
+                {
+		  int pos = p.find_last_of (use->path);
+		  if (pos != cmt_string::npos)
+		    {
+		      p.erase (pos);
+		    }
+                }
+              
+              cout << prefix << use->get_package_name ()
+		   << " " << use->version;
+
+	      if (CmtSystem::absolute_path (use->path))
+		{
+		  if (!Cmt::get_quiet ()) 
+		    {
+		      cout << " (" << use->path << ")";
+		    }
+		}
+	      else
+		{
+		  cout << " " << use->path;
+		}
+
+              if (!Cmt::get_quiet ()) 
+                {
+                  if (p != "") cout << " (" << p << ")";
+                  if (use->auto_imports == Off) cout << " (no_auto_imports)";
+                }
+
+              cout << endl;
+            }
+        }
+
+      if (Cmt::get_cmt_home () != "")
+        {
+          cout << prefix << CmtSystem::get_home_package () << " v0";
+	  if (!Cmt::get_quiet ()) 
+	    {
+	      cout << " (" << Cmt::get_cmt_home () << ")";
+	    }
+	  cout << endl;
+        }
+
+      if (Cmt::get_cmt_user_context () != "")
+        {
+          cout << prefix << CmtSystem::get_user_context_package () << " v0";
+	  if (!Cmt::get_quiet ()) 
+	    {
+	      cout << " (" << Cmt::get_cmt_user_context () << ")";
+	    }
+	  cout << endl;
+        }
+    }
+}
+
+/**
+ *   This private class parses the use statement after macro expansion
+ *   This is a finite state machine.
+ *    It maintains the results of the parsing in terms of a package name,
+ *   a version, a path, and state variables (no_auto_imports)
+ */
+class use_action_iterator
+{
+public:
+
+  use_action_iterator ()
+      {
+        state = need_package;
+        auto_imports = Unspecified;
+      }
+
+  void set (const cmt_string& w)
+      {
+        if (w.find (0, "-native_version=") != -1)
+          {
+               native_version = w.substr (16);
+          }
+          else if (w == "-auto_imports")
+          {
+            auto_imports = On;
+          }
+        else if (w == "-no_auto_imports")
+          {
+            auto_imports = Off;
+          }
+        else if (w == "|")
+          {
+            state = need_version_alias;
+          }
+        else
+          {
+            switch (state)
+              {
+                case need_package:
+                  package = w;
+                  state = need_version;
+                  break;
+                case need_version:
+                  version = w;
+                  state = need_path;
+                  break;
+                case need_path:
+                  path = w;
+		  while (path[path.size() - 1] == '/') path.erase (path.size() - 1);
+		  while (path[path.size() - 1] == '\\') path.erase (path.size() - 1);
+                  state = finished;
+                  break;
+                case need_version_alias:
+                  version_alias = w;
+                  state = need_path_alias;
+                  break;
+                case need_path_alias:
+                  path_alias = w;
+		  while (path_alias[path_alias.size() - 1] == '/') path_alias.erase (path_alias.size() - 1);
+		  while (path_alias[path_alias.size() - 1] == '\\') path_alias.erase (path_alias.size() - 1);
+                  state = finished;
+                  break;
+              }
+          }
+      }
+
+  bool ok ()
+      {
+        if (package == "") return (false);
+        if (CmtSystem::is_home_package (package, version)) return (false);
+        if (CmtSystem::is_user_context_package (package, version)) return (false);
+        if (CmtSystem::is_project_package (package, version)) return (false);
+
+        return (true);
+      }
+
+  /**
+   *
+   *  Build or retreive the Use object corresponding to the parsed specification.
+   *
+   */
+  Use* get_use (Use* parent)
+      {
+        static Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+        if (version == "") version = "*";
+
+        if (Cmt::get_debug ())
+          {
+            int i;
+
+            cout << "use::action1> current=" << parent->get_package_name () <<
+                " package=" << package << " ";
+
+            for (i = 0; i < uses.size (); i++)
+              {
+                Use* u = uses[i];
+                cout << u->get_package_name () << " ";
+              }
+            cout << endl;
+          }
+
+        const Use& cu = Use::current ();
+
+        /**
+         *   Do not continue the operations for private uses
+         *  accessed from an external context.
+         *
+         *   Exceptions should be considered for 
+         *     - cmt broadcast
+         *     - cmt show uses
+         */
+
+        ActionType action = Cmt::get_action ();
+
+        if (Cmt::get_debug ())
+          {
+            cout << "before adding " << package <<"> auto_imports=" << auto_imports
+                 << " (current AI was " << UseContext::get_current_auto_imports () << ")" 
+                 << " (Use::scope=" << parent->get_current_scope () << ")"
+                 << " (parent=" << parent->get_package_name () << ")"
+                 << endl;
+          }
+
+	bool hidden_by_scope = false;
+
+	if (parent->get_current_scope () == ScopePrivate)
+	  {
+	    hidden_by_scope = true;
+
+	    // Do not hide immediate children of the current package.
+	    if ((parent == 0) || 
+		(parent->get_package () == cu.get_package ())) hidden_by_scope = false;
+
+	    // Override default rule according to the scope filtering mode.
+
+	    if (Cmt::get_scope_filtering_mode () == reach_private_uses) hidden_by_scope = false;
+	  }
+
+	if (hidden_by_scope)
+          {
+            return (0);
+          }
+
+        // Here the version may contain wild cards
+
+        UseContext save = UseContext::current ();
+
+          /**
+           *  "auto_imports" is the state which is specified on the use statement 
+           *  currently being parsed.
+           */
+        switch (auto_imports)
+          {
+            case Unspecified:
+
+                // unspecified => we forward the state saved in the current use context
+
+              UseContext::set_current (UseContext::get_current_auto_imports ());
+              break;
+            case Off:
+
+                // off => the context becomes constrained to be off
+
+              UseContext::set_current (Off);
+              break;
+            case On:
+
+                // on => if current context is off it is kept off
+                //       otherwise it is forced to on
+
+              if (UseContext::get_current_auto_imports () != Off)
+                {
+                  UseContext::set_current (On);
+                }
+              break;
+          }
+
+        if (Cmt::get_debug ())
+          {
+            cout << "about to add " << package << endl;
+	    show_packages ();
+	  }
+
+        /// Now do create or retreive the Use object.
+        Use* new_use = Use::add (path, package, version, 
+                                 version_alias, path_alias, native_version,
+                                 parent, auto_imports);
+
+        if (new_use != 0)
+          {
+            if (Cmt::get_debug ())
+              {
+                cout << "after adding1 " << package
+		     << "> auto_imports=" << new_use->auto_imports << endl;
+
+		show_packages ();
+              }
+
+            switch (new_use->auto_imports)
+              {
+                case Unspecified:
+                  new_use->auto_imports = UseContext::get_current_auto_imports ();
+                  if (new_use->auto_imports == Unspecified)
+		    {
+		      new_use->auto_imports = On;
+		    }
+                  break;
+                case On:
+                  break;
+                case Off:
+                  if (UseContext::get_current_auto_imports () == On)
+                    {
+                        /**
+                         *  Warning : this Use had been previously specified as -no_auto_imports
+                         *  Now this new specification tries to turn it to auto_imports.
+                         *  It will be required to propagate the change, according to the 
+                         *  specifications:
+                         *
+                         *    for all sub_uses:
+                         *       if it is unspecified OR specified as auto_imports:
+                         *          turn it to auto_imports
+                         *
+                         */
+                      new_use->set_auto_imports (On);
+                    }
+                  break;
+              }
+
+
+            if (Cmt::get_debug ())
+              {
+                cout << "after adding2 " << package 
+		     << "> auto_imports=" << new_use->auto_imports << " ";
+                cout << endl;
+              }
+
+            UseContext& c = UseContext::current ();
+            c = save;
+
+            Use::reorder (new_use, parent);
+            
+            if (Cmt::get_debug ())
+              {
+                cout << "use::action2> current=" << parent->get_package_name ()
+                     << " package=" << package << " ";
+
+                int i;
+                
+                for (i = 0; i < uses.size (); i++)
+                  {
+                    Use* u = uses[i];
+                    cout << u->get_package_name () << "[" << u->get_index () << "]" << " ";
+                  }
+
+                cout << endl;
+              }
+          }
+
+        return (new_use);
+      }
+
+private:
+
+  enum
+  {
+    need_package,
+    need_version,
+    need_path,
+    need_version_alias,
+    need_path_alias,
+    finished
+  } state;
+  
+  State auto_imports;
+  cmt_string native_version;
+  cmt_string package;
+  cmt_string version;
+  cmt_string path;
+  cmt_string version_alias;
+  cmt_string path_alias;
+};
+
+//----------------------------------------------------------
+Use* Use::action (const CmtSystem::cmt_string_vector& words, Use* parent)
+{
+  Use* new_use;
+
+  //
+  // complete syntax : "use <package> <version> <path> <-native_version=<version>>"  
+  // minimal syntax  : "use <package>"
+  //
+  //  o if <version> is omitted then take any version available
+  //  o <version> can be specified using "v*" or "v<n>r*" or "v<n>r<m>p*"
+  //
+  //  o the notation "v*" is preferred to omission (particularly since
+  //    omission does not permit <path>)
+  //
+  if (words.size () < 2) return (0);
+
+  use_action_iterator it;
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& w = words[i];
+      cmt_string ew = w;
+
+      Symbol::expand (ew);
+      if (ew != w)
+        {
+          CmtSystem::cmt_string_vector ws;
+
+          CmtSystem::split (ew, " ", ws);
+
+          for (int j = 0; j < ws.size (); ++j)
+            {
+              const cmt_string& ww = ws[j];
+              it.set (ww);
+            }
+        }
+      else
+        {
+             it.set (ew);
+        }
+    }
+
+  if (!it.ok ()) return (0);
+
+  static int level = 0;
+
+  level++;
+  new_use = it.get_use (parent);
+  level--;
+
+  return (new_use);
+}
+
+//----------------------------------------------------------
+void Use::author_action (const CmtSystem::cmt_string_vector& words)
+{
+  if (author != "") author += "\n";
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& w = words[i];
+      
+      if (i > 1) author += " ";
+      author += w;
+    }
+}
+//----------------------------------------------------------
+void Use::manager_action (const CmtSystem::cmt_string_vector& words)
+{
+  if (manager != "") manager += "\n";
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& w = words[i];
+      
+      if (i > 1) manager += " ";
+      manager += w;
+    }
+}
+
+//----------------------------------------------------------
+Use* Use::find (const cmt_string& package, 
+                const cmt_string& version, 
+                const cmt_string& path)
+{
+  Package* p = Package::find (package);
+  if (p == 0) return (0);
+
+  UsePtrVector& uses = p->get_uses ();
+
+  int use_index;
+  int size = uses.size ();
+
+  for (use_index = 0; use_index < size; use_index++)
+    {
+      Use& use = (*uses[use_index]);
+
+      // If the version argument is omitted then
+      // take the first registered version
+      if (version == "") return (&use);
+          
+      // Otherwise compare against specified_version and path
+      //if ((use.specified_version == version) && 
+      //  (use.specified_path == path)) return (&use);
+      
+      // what about comparing wild cards?
+
+      if (use.specified_version == version) return (&use);
+    }
+
+  return (0);
+}
+
+//----------------------------------------------------------
+int Use::find_index (const cmt_string& package_name, 
+                     const cmt_string& version, 
+                     const cmt_string& path)
+{
+  Package* package = Package::find (package_name);
+  if (package == 0) return (-1);
+
+  UsePtrVector& uses = package->get_uses ();
+
+  int use_index;
+  int size = uses.size ();
+  for (use_index = 0; use_index < size; use_index++)
+    {
+      Use* use = uses[use_index];
+
+      if (Cmt::get_debug ())
+        {
+          cout << "Use::find_index> " << package_name
+               << " " << use
+               << " " << use->m_index
+               << endl;
+        }
+
+      // If the version argument is omitted then
+      // take the first registered version
+      if (version == "") return (use->m_index);
+      
+      // Otherwise compare against specified_version and path
+      //if ((use.specified_version == version) && 
+      //  (use.specified_path == path)) return (&use);
+      
+      // what about comparing wild cards?
+      
+      if (use->specified_version == version) return (use->m_index);
+    }
+
+  return (-1);
+}
+
+/**
+ *   1) Given a Use object identified by its index in the ordered_uses() array,
+ *   2) Given a vector of states containing the auto_imports states of all uses,
+ *
+ *     we want to switch to 'On' the auto_imports states of all
+ *     sub_uses of the argument that were Off.
+ *
+ */
+void Use::set_auto_imports_state (int use_index,
+                                  cmt_vector<bool>& auto_imports_states)
+{
+  // check boundaries (this should be an error when out bondaries)
+  if ((use_index < 0) || (use_index >= auto_imports_states.size ())) return;
+
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  if (Cmt::get_debug ())
+    {
+      int i;
+      
+      cout << "Use::set_auto_imports_state> use_index=" << use_index << " ";
+      
+      for (i = 0; i < auto_imports_states.size (); i++)
+	{
+	  cout << (auto_imports_states[i] ? "|" : "o");
+	}
+
+      for (i = 0; i < auto_imports_states.size (); i++)
+	{
+	  cout << " " << (uses[i])->get_package_name ();
+	}
+
+      cout << endl;
+    }
+
+  // check if this is already done (recursivity ending)
+  if (auto_imports_states[use_index]) return;
+
+  Use* use = uses[use_index];
+
+  // We only have to deal with Use objects that were
+  // actually turned Off
+  if (use->auto_imports != Off) return;
+
+  /**
+   *  Here, use points to a Use object which had been declared as
+   *  no_auto_imports. But we need to switch it On. Therefore, 
+   *
+   *    1) the state in auto_imports_states has to be set On 
+   *    2) the operation has to be recursively propagated to all
+   *         sub_uses which also had no_auto_imports. (only to those)
+   *  
+   */
+  
+  auto_imports_states[use_index] = true;
+
+  int size = 0;
+
+  size = use->sub_uses.size ();
+  for (int i = 0; i < size; i++)
+    {
+      Use* u = use->sub_uses[i];
+
+      // first find the index of this use.
+
+      int j = u->m_index;
+
+      if (j >= 0)
+	{
+	  if (u->sub_use_auto_imports[i] == Off)
+	    {
+	      set_auto_imports_state (j, auto_imports_states);
+	    }
+	  else
+	    {
+	      auto_imports_states[j] = true;
+	    }
+        }
+    }
+}
+
+//----------------------------------------------------------
+//
+//  Move use to the end
+//
+//----------------------------------------------------------
+void Use::move (Use* use)
+{
+  if (use == 0) return;
+
+  static UsePtrVector& uses = get_ordered_uses ();
+
+  int size = uses.size ();
+
+  if (size == 0) return;
+
+  //
+  // On se positionne sur le pointeur.
+  //
+
+  int use_index = use->m_index;
+
+  if (use_index < 0) return;
+
+  //
+  // On deplace tous les pointeurs d'une case en arriere
+  //
+  for (use_index++; use_index < size; use_index++)
+    {
+      Use* u = uses[use_index];
+      u->m_index--;
+
+      uses[use_index - 1] = uses[use_index];
+    }
+
+  //
+  // use est donc replace en derniere position
+  //
+
+  use->m_index = size - 1;
+  uses[size - 1] = use;
+}
+
+/**
+ *   Reorder provider versus client in the UsePtrVector list, 
+ *  so that the order reflects the fact that client makes use of provider.
+ *   The result should be that provider appears before client in the list.
+ */
+void Use::reorder (Use* provider, Use* client)
+{
+  static UsePtrVector& uses = get_ordered_uses ();
+
+  int use_index;
+
+  int size = uses.size ();
+
+  if (size == 0) return;
+  if (provider == client) return;
+
+  //
+  // First locate the two use objects into the uses vector.
+  //   -> provider_index and client_index
+  //
+
+  int provider_index = -1;
+  int client_index = -1;
+
+  provider_index = provider->m_index;
+  client_index = client->m_index;
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reorder> provider=" << provider_index << " client=" << client_index << endl;
+    }
+
+  //
+  // Both objects must be installed in uses before acting.
+  //
+  if (provider_index == -1) return;
+  if (client_index == -1) return;
+
+  if (client_index < provider_index)
+    {
+      //
+      // client is already before provider so job is finished
+      //
+      return;
+    }
+
+  //
+  // before : <a a a P b b b C c c c>
+  //                 ^       ^
+  //                 ip      ic
+  //
+  //  1) move "P b b b" by one place to the right
+  // thus :   <a a a P P b b b c c c>
+  //
+  //  2) move "C" to [ip]
+  //
+  // after  : <a a a C P b b b c c c>
+  //
+  
+  for (use_index = client_index - 1; use_index >= provider_index; use_index--)
+    {
+      Use* use = uses[use_index];
+      use->m_index++;
+
+      uses[use_index + 1] = uses[use_index];
+    }
+  
+  uses[provider_index] = client;
+  client->m_index = provider_index;
+}
+
+//----------------------------------------------------------
+void Use::clear_all ()
+{
+  static UsePtrVector& uses = get_ordered_uses ();
+  static UseVector& instances = get_instances ();
+
+  int use_index;
+
+  for (use_index = 0; use_index < instances.size (); use_index++)
+    {
+      Use& use = instances[use_index];
+      use.clear ();
+    }
+
+  uses.clear ();
+  instances.clear ();
+}
+
+//----------------------------------------------------------
+void Use::unselect_all ()
+{
+  static UsePtrVector& uses = get_ordered_uses ();
+
+  int use_index;
+
+  int size = uses.size ();
+
+  if (size == 0) return;
+
+  for (use_index = 0; use_index < size; use_index++)
+    {
+      Use* use = uses[use_index];
+
+      if (use != 0)
+        {
+          use->unselect ();
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Use::undiscard_all ()
+{
+  static UsePtrVector& uses = get_ordered_uses ();
+
+  int use_index;
+
+  if (uses.size () == 0) return;
+
+  for (use_index = 0; use_index < uses.size (); use_index++)
+    {
+      Use* use = uses[use_index];
+
+      if (use != 0)
+        {
+          use->undiscard ();
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Use::fill_macro_all (cmt_string& buffer, const cmt_string& suffix)
+{
+  UsePtrVector& uses = get_ordered_uses ();
+
+  buffer = "macro_append use_";
+  buffer += suffix;
+  buffer += " \" ";
+  (Use::current()).fill_macro (buffer, suffix);
+
+  for (int number = 0; number < uses.size (); number++)
+    {
+      Use* use = uses[number];
+      
+      Package* p = use->get_package ();
+      if (p->is_cmt ()) continue;
+
+      if (use->discarded) continue;
+      if (use->auto_imports == Off) continue;
+
+      use->fill_macro (buffer, suffix);
+    }
+  
+  buffer += "\"";
+}
+
+//----------------------------------------------------------
+Use::Use ()
+{
+  done = false;
+  discarded = false;
+  auto_imports = Unspecified;
+  m_package = 0;
+  m_index = -1;
+  native_version = "";
+
+  clear ();
+}
+
+//----------------------------------------------------------
+Use::Use (const cmt_string& new_package,
+          const cmt_string& new_version,
+          const cmt_string& new_path)
+{
+  auto_imports = Unspecified;
+  m_located = false;
+  m_package = 0;
+  m_index = -1;
+
+  set (new_package, new_version, new_path);
+}
+
+//----------------------------------------------------------
+Use::~Use ()
+{
+  clear ();
+}
+
+//----------------------------------------------------------
+void Use::clear ()
+{
+  specified_path = "";
+  path      = "";
+
+  if (m_package != 0)
+    {
+      m_package->remove_use (this);
+      m_package = 0;
+    }
+
+  version   = "";
+  author    = "";
+  manager   = "";
+  real_path = "";
+
+  prefix    = "";
+  style     = mgr_style;
+  initial_scope = ScopePublic;
+  done      = false;
+  discarded = false;
+  selected  = false;
+  m_hidden  = false;
+  auto_imports = Unspecified;
+
+  includes.clear ();
+  include_path = "";
+  scripts.clear ();
+  apply_patterns.clear ();
+  ignore_patterns.clear ();
+
+  sub_uses.clear ();
+  sub_use_scopes.clear ();
+  sub_use_auto_imports.clear ();
+
+  requests.clear ();
+
+  alternate_versions.clear ();
+  alternate_paths.clear ();
+
+  version_alias = "";
+  path_alias    = "";
+
+  m_located = false;
+  m_has_native_version = false;
+  m_index = -1;
+}
+
+//----------------------------------------------------------
+void Use::set (const cmt_string& new_package,
+               const cmt_string& new_version,
+               const cmt_string& new_path,
+               const cmt_string& new_version_alias,
+               const cmt_string& new_path_alias)
+{
+  clear ();
+
+  Package* p = Package::add (new_package);
+
+  m_package = p;
+  p->add_use (this);
+
+  specified_path    = new_path;
+  // specified_path.replace_all ("\\", "/");
+
+  specified_version = new_version;
+  version           = new_version;
+  path              = specified_path;
+  Symbol::expand (path);
+  real_path         = "";
+  style             = mgr_style;
+  initial_scope     = ScopePublic;
+  done              = false;
+  discarded         = false;
+  Cmt::build_prefix (new_package, prefix);
+
+  version_alias = new_version_alias;
+  path_alias    = new_path_alias;
+}
+
+//----------------------------------------------------------
+void Use::change_path (const cmt_string& new_path)
+{
+  // 
+  // This methods changes real_path after an actual location
+  // where this package/version has been found.
+  //
+
+  real_path = "";
+
+  if (new_path != "")
+    {
+      if ((path.size () > 0) &&
+          (!CmtSystem::absolute_path (path)))
+        {
+          real_path = new_path;
+          real_path += CmtSystem::file_separator ();
+          real_path += path;
+        }
+      else
+        {
+          real_path = new_path;
+        }
+      // real_path.replace_all ("\\", "/");
+
+      CmtSystem::compress_path (real_path);
+    }
+  
+  m_located = true;
+}
+
+//----------------------------------------------------------
+int Use::reach_package (const cmt_string& from_path, const cmt_string& n_version)
+{
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reach_package> (" << get_package_name () << " " 
+	   << version << ")from " << from_path << endl;
+	  cout << "Use::reach_package> native_version required "<<n_version<<endl;
+    }
+    
+  //
+  // We try to reach a package/version starting from from_path
+  //
+
+  // check if from_path is at least real
+  if ((from_path != "") && !CmtSystem::cd (from_path)) return (0);
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reach_package-2>" << endl;
+    }
+
+  // check in case from_path is a new search path 
+  if (from_path != real_path)
+    {
+      // Move to that prefix only if it is a relative path.
+      if ((path.size () > 0) && (!CmtSystem::absolute_path (path)))
+        {
+          if (!CmtSystem::cd (path))
+            {
+              return (0);
+            }
+        }
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reach_package-3>" << endl;
+    }
+
+  // Special treatment for CMTHOME package...
+  if (get_package_name () == CmtSystem::get_home_package ())
+    {
+      discarded = 1;
+      if (!CmtSystem::test_file ("requirements"))
+        {
+          return (0);
+        }
+      else
+        {
+          return (1);
+        }
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reach_package-4>" << endl;
+    }
+
+  // Special treatment for CMTUSERCONTEXT package...
+  if (get_package_name () == CmtSystem::get_user_context_package ())
+    {
+      discarded = 1;
+      if (!CmtSystem::test_file ("requirements"))
+        {
+          return (0);
+        }
+      else
+        {
+          return (1);
+        }
+    }
+
+  // Special treatment for PROJECT package...
+  if (get_package_name () == CmtSystem::get_project_package ())
+    {
+      discarded = 1;
+      if (!CmtSystem::test_file ("project"))
+        {
+          return (0);
+        }
+      else
+        {
+          return (1);
+        }
+    }
+
+  if (Cmt::get_debug ())
+    {
+        cout << "Use::reach_package-5>" << endl;
+    }
+
+  // Now from_path exists, try if the package exists there
+  if (!CmtSystem::cd (get_package_name ()))
+    {
+      return (0);
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reach_package-6>" << endl;
+    }
+
+  if (CmtSystem::test_file ("cmt/requirements"))
+  {
+      CmtSystem::cd ("cmt");
+
+      style = no_version_style;
+
+      if (CmtSystem::test_file ("version.cmt"))
+	  {
+	       cmt_string v;
+
+	       v.read ("version.cmt");
+	       int pos;
+	       pos = v.find ('\n');
+	       if (pos != cmt_string::npos) v.erase (pos);
+	       pos = v.find ('\r');
+	       if (pos != cmt_string::npos) v.erase (pos);
+
+	       CompareStatus s = compare_versions (version, v);
+
+	       if (Cmt::get_debug ())
+	       {
+	           cout << "Use::reach_package-6.1> version=" << version << " v=" << v << " s=" << s << endl;
+	        }
+
+	       switch (s)
+	       {
+	           case IdenticalIds:
+	           case ExplicitOldMajorIdWinsAgainstWildarded:
+	           case ExplicitOldMinorIdWinsAgainstWildarded:
+	           case ExplicitOldPatchIdWinsAgainstWildarded:
+	               break;
+	           case ExplicitNewMajorIdWinsAgainstWildarded:
+	           case ExplicitNewMinorIdWinsAgainstWildarded:
+	           case NewMinorIdGreaterThanOld:
+	           case ExplicitNewPatchIdWinsAgainstWildarded:
+	           case NewPatchIdGreaterThanOld:
+	               break;
+	           case OldMajorIdGreaterThanNew:
+	           case NewMajorIdGreaterThanOld:
+	               break;
+	           case IncompatibleMajorIds:
+	           return (0);
+	       }
+	       version = v;
+	   }
+       else if (version == "")
+	   {
+	       version = "v0";
+	   }
+        return (1);
+    }
+  else if (!CmtSystem::cd (version))
+    {
+      //
+      // The specified version cannot be found per-se
+      // There are alternate possibilities when it contains wild cards
+      //
+      if ((version == "") || (version.find ("*") != cmt_string::npos))
+        {
+          static CmtSystem::cmt_string_vector versions;
+          static cmt_string name;
+
+          name = ".";
+          name += CmtSystem::file_separator ();
+          if (version == "") name += "*";
+          else name += version;
+
+          CmtSystem::scan_dir (name, versions);
+          if (n_version != "")
+          {
+              CmtSystem::cmt_string_vector native_versions;           
+              for (int i = 0; i < versions.size (); i++)
+              {
+                  cmt_string path;
+                  if (CmtSystem::test_directory (versions[i]))
+                  {
+                      path  = versions[i];
+                      path += CmtSystem::file_separator ();
+                      path += "cmt";
+                  }
+                  else
+                  {
+                      path = "cmt";
+                  }
+                  path += CmtSystem::file_separator ();
+                  path += "native_version.cmt";        
+                                  
+                  if (CmtSystem::test_file (path))
+	              {
+	                  cmt_string nv;
+	                  nv.read (path);
+	                  int pos = nv.find ('\n');
+	                  if (pos != cmt_string::npos) nv.erase (pos);
+	                  pos     = nv.find ('\r');
+	                  if (pos != cmt_string::npos) nv.erase (pos);
+	                  if (nv == n_version)
+	                  {
+	                       cmt_string& name_entry = native_versions.add ();
+	                       // We have found at least one
+	                       // cout <<"native_version :"<<n_version<<" ,version: "<< versions[i]<<endl;
+	                       this->native_version   = n_version;
+	                       name_entry            += versions[i];
+	                  }
+	              }                   
+              }
+              versions = native_versions;
+          }
+          
+          int i;
+          bool found = false;
+          
+          for (i = 0; i < versions.size (); i++)
+            {
+              const cmt_string& vers = versions[i];
+              
+              if (Cmt::get_debug ())
+                {
+                  cout << "     ... version " << vers << " exists" << endl;
+                }
+
+              CmtSystem::basename (vers, name);
+              
+              int v;
+              int r;
+              int p;
+              
+              if (CmtSystem::is_version_directory (name, v, r, p))
+                {
+                  /*
+                    This check is not sufficient !! We need to check in addition
+                    that the selected directory is really the start of a true CMT
+                    package (ie with either /mgr/requirements or /cmt/requirements below)
+                  */
+
+                  cmt_string req;
+
+                  req = name;
+                  req += CmtSystem::file_separator ();
+                  req += "mgr";
+                  req += CmtSystem::file_separator ();
+                  req += "requirements";
+
+                  if (!CmtSystem::test_file (req))
+                    {
+                      req = name;
+                      req += CmtSystem::file_separator ();
+                      req += "cmt";
+                      req += CmtSystem::file_separator ();
+                      req += "requirements";
+
+                      if (!CmtSystem::test_file (req)) continue;
+                    }
+
+                  cmt_string& new_v = alternate_versions.add ();
+                  new_v = name;
+                  cmt_string& new_p = alternate_paths.add ();
+                  new_p = from_path;
+
+                  found = true;
+                }
+            }
+
+          if (!found)
+            {
+              if (CmtSystem::test_file ("cmt/requirements"))
+                {
+                  CmtSystem::cd ("cmt");
+                  style = no_version_style;
+                  return (1);
+                }
+            }
+        }
+
+      if (Cmt::get_debug ())
+        {
+          cout << "  ... end of version scan" << endl;
+        }
+
+        //
+        //  We have now the list of possible alternate versions. However
+        // we return that the expected package/version was not found (yet).
+        //
+
+      return (0);
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reach_package-7>" << endl;
+    }
+
+  //cerr << "  ... version " << version << " exists" << endl;
+
+  // Now we have met the exact specified version!
+  if (!CmtSystem::test_file ("cmt/requirements"))
+    {
+      if (!CmtSystem::test_file ("mgr/requirements"))
+        {
+          return (0);
+        }
+      else
+        {
+          CmtSystem::cd ("mgr");
+          style = mgr_style;
+        }
+    }
+  else
+    {
+      CmtSystem::cd ("cmt");
+      style = cmt_style;
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::reach_package-8>" << endl;
+    }
+
+  return (1);
+}
+
+class UseProjectAction : public IProjectAction
+{
+public:
+  UseProjectAction (Use* use, cmt_string n_version="") : m_use (use), m_found (false), native_version(n_version)
+  {
+  }
+
+  bool found () const
+  {
+    return (m_found);
+  }
+
+  bool run (const Project& project)
+  {
+    const cmt_string& path = project.get_cmtpath ();
+      
+    m_use->alternate_versions.clear ();
+    m_use->alternate_paths.clear ();
+
+    if (m_use->reach_package (path, this->native_version))
+    {
+	if (Cmt::get_debug ())
+	  {
+	    cout << "move_to4> " << path << endl;
+	  }
+	
+	m_use->change_path (path);
+
+	m_found = true;
+
+	return (false);
+      }
+    else if (m_use->alternate_versions.size () > 0)
+      {
+	if (m_use->select_alternate ()) 
+	  {
+	    if (Cmt::get_debug ())
+	      {
+		cout << "move_to5> " << m_use->real_path << endl;
+	      }
+
+	    m_found = true;
+
+	    return (false);
+	  }
+      }
+    
+    return (true);
+  }
+
+private:
+  Use* m_use;
+  bool m_found;
+  cmt_string native_version;
+};
+
+//----------------------------------------------------------
+bool Use::move_to (const cmt_string& native_version)
+{
+  if (m_located)
+    {
+      //
+      // The real path where this version/package can be found 
+      // has already been resolved. We thus first go there.
+      //
+
+      if (Cmt::get_debug ())
+        {
+          cout << "move_to1> " << real_path << endl;
+        }
+
+      reach_package (real_path, native_version);
+
+      return (true);
+    }
+
+  cmt_string expanded_path = path;
+
+  //
+  // Try here.
+  //
+  if (expanded_path == "")
+    {
+      if (reach_package ("", native_version))
+        {
+          if (Cmt::get_debug ())
+            {
+              cout << "move_to2> " << expanded_path << endl;
+            }
+
+          change_path (expanded_path);
+
+          return (true);
+        }
+      else if (alternate_versions.size () > 0)
+        {
+          if (select_alternate ()) 
+            {
+              if (Cmt::get_debug ())
+                {
+                  cout << "move_to5> " << real_path << endl;
+                }
+              
+              return (true);
+            }
+        }
+    }
+      
+  //
+  // If the path specified in this use is a true absolute path,
+  // then we search the package from there first.
+  //
+  if (CmtSystem::absolute_path (expanded_path))
+    {
+      if (reach_package (expanded_path,  native_version))
+        {
+          if (Cmt::get_debug ())
+            {
+              cout << "move_to3> " << expanded_path << endl;
+            }
+
+          change_path (expanded_path);
+
+          return (true);
+        }
+      else if (alternate_versions.size () > 0)
+        {
+          if (select_alternate ()) 
+            {
+              if (Cmt::get_debug ())
+                {
+                  cout << "move_to5> " << real_path << endl;
+                }              
+
+              return (true);
+            }
+        }
+    }
+      
+  //
+  // Second try is among the CMTPATHs
+  //
+  UseProjectAction pa (this, native_version);
+
+  Project::broadcast (pa);
+
+  if (pa.found ()) return (true);
+
+  return (false);
+}
+
+//----------------------------------------------------------
+bool Use::select_alternate ()
+{
+  int i;
+
+  int v0 = 0;
+  int r0 = 0;
+  int p0 = 0;
+
+  int v = 0;
+  int r = 0;
+  int p = 0;
+
+  int selected_index = -1;
+
+  for (i = 0; i < alternate_versions.size (); i++)
+    {
+      cmt_string& name = alternate_versions[i];
+
+        /*
+      if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "")
+        {
+          cout << "select_alternate[" << this << "]> package " << get_package_name () << 
+              " sv=" << specified_version << 
+              " v=" << version << 
+              " av[" << i << "]=" << name << endl;
+        }
+        */
+
+      if (i == 0)
+        {
+          CmtSystem::is_version_directory (name, v0, r0, p0);
+          selected_index = 0;
+        }
+      else
+        {
+          CmtSystem::is_version_directory (name, v, r, p);
+
+          if (v > v0)
+            {
+              selected_index = i;
+              v0 = v;
+              r0 = r;
+              p0 = p;
+            }
+          else if (v == v0)
+            {
+              if (r > r0)
+                {
+                  selected_index = i;
+                  r0 = r;
+                  p0 = p;
+                }
+              else if (r == r0)
+                {
+                  if (p > p0)
+                    {
+                      selected_index = i;
+                      p0 = p;
+                    }
+                }
+            }
+        }
+    }
+
+  if (selected_index >= 0)
+    {
+      if (CmtSystem::cd (alternate_paths[selected_index]))
+        {
+          version = alternate_versions[selected_index];
+          if (reach_package (alternate_paths[selected_index]))
+            {
+                /*
+              if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "")
+                {
+                  cout << "select_alternate2> package " << get_package_name () << 
+                      " sv=" << specified_version << 
+                      " v=" << version << endl;
+                }
+                */
+
+              if (Cmt::get_debug ())
+                {
+                  cout << "select_alternate> " << alternate_paths[selected_index] << endl;
+                }
+
+              change_path (alternate_paths[selected_index]);
+              return (true);
+            }
+        }
+    }
+
+  return (false);
+}
+
+//----------------------------------------------------------
+bool Use::need_new (const cmt_string& path,
+                    const cmt_string& package,
+                    const cmt_string& version,
+                    const cmt_string& n_version,
+                    Use** old_use,
+		            Use* context_use)
+{
+  bool new_request = add_request (path, package, version);
+   
+  Use& current_use = Use::current ();
+
+  if (package == current_use.get_package_name ())
+    {
+      if (Cmt::get_debug ())
+	{
+	  cout << "  ... recursive use to current package" << endl;
+	}
+
+      if (old_use != 0) *old_use = &current_use;
+      return (false);
+    }
+
+  Package* p = Package::add (package);
+
+  UsePtrVector& uses = p->get_uses ();
+
+  bool do_need_new = true;
+  Use* found = 0;
+  Use* registered = 0;
+
+  int req_v = -1;
+  int req_r = -1;
+  int req_p = -1;
+
+  CmtSystem::is_version_directory (version, req_v, req_r, req_p);
+
+  if (Cmt::get_debug ())
+    {
+      cout << "need_new> p=" << package << " v=" << version << " v=" << req_v << " r=" << req_r << " p=" << req_p << endl;
+    }
+
+  bool has_wild_card = (req_v == -1) || (req_r == -1) || (req_p == -1);
+
+  int new_v = -1;
+  int new_r = -1;
+  int new_p = -1;
+
+  int use_index;
+
+  if (old_use != 0) *old_use = 0;
+
+  // Acquire the registered use.
+  for (use_index = 0; use_index < uses.size (); use_index++)
+    {
+      Use& use = (*uses[use_index]);
+
+      if (use.m_index < 0) continue;
+
+      registered = &use;
+
+      break;
+    }
+
+  // Make a first try with the registered use if it exists.
+
+  cmt_string decision;
+
+  if (registered != 0)
+    {
+      Use& use = (*registered);
+
+      found = &use;
+
+      CmtSystem::is_version_directory (use.specified_version, new_v, new_r, new_p);
+
+      bool use_has_wild_card = (new_v == -1) || (new_r == -1) || (new_p == -1);
+
+      if (has_wild_card && !use_has_wild_card)
+	{
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "  ... wildcarded request loses against existing explicit" << endl;
+	    }
+	  
+	  do_need_new = false; // We don't need a new one
+	}
+      else
+	{
+	  // here either !has_wild_card or use_has_wild_card
+
+	  if ((version == use.specified_version) &&
+	      (path == use.specified_path))
+	    {
+	      
+	      if (Cmt::get_debug ())
+		  {
+		      cout << " ... exactly same version and path!" << endl;
+		  }	      
+	      do_need_new = false; // We don't need a new one
+	      if (n_version != use.native_version)
+	      {
+	          if (Cmt::get_debug ())
+	               cout << " ... but native_version differs (" <<n_version<<"!="<<use.native_version<<") !" <<endl; 
+	          do_need_new = true;    
+	      }	      
+	   }
+	  else if (version != use.specified_version)
+	    {
+	      if (Cmt::get_debug ())
+		{
+		  cout << "requested explicit wins against existing wildcarded"
+		       << endl;
+		}
+
+	      // The registered use loses against the request
+	    }
+	  else
+	    {
+	      if (Cmt::get_debug ())
+		{
+		  cout << "only paths differ, consider the new one."
+		       << endl;
+		}
+
+	      // The registered use loses against the request
+	    }
+	}
+
+
+      //if (new_request && !Cmt::get_quiet () && (Cmt::get_action () == action_show_uses))
+      if (new_request && !Cmt::get_quiet ())
+	{
+	  if ((new_v != -1) && (req_v != -1) && (new_v != req_v))
+	    {
+              cout << "# Required version " << version
+		   << " of package " << package;
+
+	      if (context_use != 0)
+		{
+		  cout << " [from " << context_use->get_package_name () << "]";
+		}
+
+	      cout << " incompatible with selected version " << use.version;
+
+	      if (use.version != use.specified_version)
+		{
+		  cout << " (" << use.specified_version << ")" ;
+		}
+
+	      cout << endl;
+	    }
+	}
+
+      if (Cmt::get_debug ())
+	{
+	  cout << "# " << package << " " << version;
+
+	  if (context_use != 0)
+	    {
+	      cout << " [from " << context_use->get_package_name () << "]";
+	    }
+
+	  if (do_need_new)
+	    {
+	      cout << " > ";
+	    }
+	  else
+	    {
+	      cout << " < ";
+	    }
+
+	  cout << use.version;
+	  if (use.version != use.specified_version)
+	    {
+	      cout << " (" << use.specified_version << ")" ;
+	    }
+
+	  cout << " (r) ";
+
+	  cout << endl;
+	}
+    }
+
+  if (do_need_new)
+    {
+      // Now try unregistered uses, since the registered one is not appropriate.
+      // to see is any other existing use could match
+
+      for (use_index = 0; use_index < uses.size (); use_index++)
+	{
+	  Use& use = (*uses[use_index]);
+	  
+	  if (use.m_index >= 0) continue;
+	  
+	  // Always save the latest found.
+	  
+	  found = &use;
+
+	  CmtSystem::is_version_directory (use.specified_version, new_v, new_r, new_p);
+
+	  bool use_has_wild_card = (new_v == -1) || (new_r == -1) || (new_p == -1);
+
+	  if (has_wild_card && !use_has_wild_card)
+	    {
+	      if (Cmt::get_debug ())
+		{
+		  cout << "  ... requested wildcarded loses against existing explicit" << endl;
+		}
+	      
+	      do_need_new = false; // We don't need a new one
+	    }
+	  else
+	    {
+	      // here either !has_wild_card or use_has_wild_card
+	  
+	      if ((version == use.specified_version) &&
+		  (path == use.specified_path))
+		{
+		  if (Cmt::get_debug ())
+		    {
+		      cout << " ... exactly same version and path!" << endl;
+		    }
+	      
+		  do_need_new = false; // We don't need a new one
+		  if (n_version != use.native_version)
+	      {
+	          if (Cmt::get_debug ())
+	               cout << " ... but native_version differs (" <<n_version<<"!="<<use.native_version<<") !" <<endl;
+	          do_need_new = true;    
+	      }
+		  
+		}
+	      else if (version != use.specified_version)
+		{
+		  if (Cmt::get_debug ())
+		    {
+		      cout << "requested explicit wins against existing wildcarded"
+			   << endl;
+		    }
+
+		  // This use loses against the request
+		}
+	      else
+		{
+		  if (Cmt::get_debug ())
+		    {
+		      cout << "only paths differ, consider the new one."
+			   << endl;
+		    }
+
+		  // This use loses against the request
+		}
+	    }
+
+	  //if (new_request && !Cmt::get_quiet () && (Cmt::get_action () == action_show_uses))
+	  if (new_request && !Cmt::get_quiet ())
+	    {
+	      if ((new_v != -1) && (req_v != -1) && (new_v != req_v))
+		{
+		  cout << "# Required version " << version
+		       << " of package " << package;
+
+		  if (context_use != 0)
+		    {
+		      cout << " [from " << context_use->get_package_name () << "]";
+		    }
+	      
+		  cout << " incompatible with selected version " << use.version;
+
+		  if (use.version != use.specified_version)
+		    {
+		      cout << " (" << use.specified_version << ")" ;
+		    }
+
+		  cout << endl;
+		}
+	    }
+
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "# " << package << " " << version;
+	      
+	      if (context_use != 0)
+		{
+		  cout << " [from " << context_use->get_package_name () << "]";
+		}
+	      
+	      if (do_need_new)
+		{
+		  cout << " > ";
+		}
+	      else
+		{
+		  cout << " < ";
+		}
+	      
+	      if ((new_v != -1) && (req_v != -1) && (new_v != req_v))
+		{
+		  cout << "(incompatible) ";
+		}
+
+	      cout << use.version;
+	      if (use.version != use.specified_version)
+		{
+		  cout << " (" << use.specified_version << ")" ;
+		}
+	      cout << endl;
+	    }
+	}
+    }
+
+  if (old_use != 0)
+    {
+      if (registered != 0) *old_use = registered;
+      else *old_use = found;
+    }
+
+  return (do_need_new);
+}
+
+//----------------------------------------------------------
+//
+//  Here the version which is provided here is the specified version.
+// It may contain wild cards or it may be simply empty.
+//
+//----------------------------------------------------------
+Use* Use::create (const cmt_string& path,
+                  const cmt_string& package,
+                  const cmt_string& version,
+                  const cmt_string& version_alias,
+                  const cmt_string& path_alias,
+                  const cmt_string& n_version)
+{
+  Package* p = 0;
+
+  p = Package::add (package);
+
+  UsePtrVector& vector = p->get_uses ();
+
+  // We first look in the database.
+  for (int use_index = 0; use_index < vector.size (); use_index++)
+    {
+      Use* use = vector[use_index];
+
+      if ((use->specified_version == version) && 
+	  (use->specified_path == path) && use->native_version==n_version) return (use);
+    }
+
+  // We now really create a new Use entry.
+
+  static UseVector& instances = get_instances ();
+
+  Use& use_object = instances.add ();
+
+  use_object.set (package, version, path, version_alias, path_alias);
+
+  return (&use_object);
+}
+
+//----------------------------------------------------------
+//  Add a use request into the database.
+//
+//  o If a use request already exist in the database,
+//    check the version compatibility
+//
+//----------------------------------------------------------
+Use* Use::add (const cmt_string& path,
+               const cmt_string& package_name,
+               const cmt_string& version,
+               const cmt_string& version_alias,
+               const cmt_string& path_alias,
+               const cmt_string& native_version,
+               Use* context_use,
+               State specified_auto_imports)
+{
+  bool do_need_new = false;
+
+  Use* old_use = 0;
+  Use* use = 0;
+
+  do_need_new = need_new (path, package_name, version, native_version, &old_use, context_use);
+
+  if (Cmt::get_debug ())
+    {
+      if (old_use != 0 && !do_need_new)
+	{
+	  cout << "add> old_use " << old_use->get_package_name () <<
+	    " " << old_use->version <<
+	    " " << old_use->path <<
+	    endl;
+	}
+    }
+
+  if (do_need_new)
+    {
+      use = create (path, package_name, version, version_alias, path_alias, native_version);
+    }
+  else
+    {
+      // Since we don't need a new Use, it means that old_use exists !
+      //if (specified_auto_imports !=old_use->auto_imports)
+      //{
+      //   if (Cmt::get_debug ())
+      //      cout <<"# update auto_imports field in the use"<<endl;
+      //  old_use->auto_imports = specified_auto_imports;        
+      //}
+      use = old_use;
+      old_use = 0;
+    }
+
+  if (package_name == CmtSystem::get_home_package ())
+    {
+      return (use);
+    }
+
+  if (package_name == CmtSystem::get_user_context_package ())
+    {
+      return (use);
+    }
+
+  if (package_name == CmtSystem::get_project_package ())
+    {
+      return (use);
+    }
+
+  cmt_string here = CmtSystem::pwd ();
+
+    //
+    // Store the specified sub_uses. Some of them may become discarded
+    // later on.
+    //
+  if (context_use != 0)
+    {
+      context_use->sub_uses.push_back (use);
+
+      context_use->sub_use_scopes.push_back (context_use->get_current_scope ());
+
+      context_use->sub_use_auto_imports.push_back (specified_auto_imports);
+
+      cmt_string& request = context_use->requests.add ();
+
+      request = package_name;
+      request += " ";
+      request += version;
+      request += " ";
+      request += path;
+
+
+      if (Cmt::get_debug ())
+        {
+          cout << "Use::add context(" << context_use->get_package_name () << ") "
+               << "[u:" << package_name
+               << " s:" << context_use->get_current_scope ()
+               << " ai:" << specified_auto_imports
+               << "]" << endl;
+        }
+    }
+
+  if (use == &(Use::current ())) 
+    {
+      return (use);
+    }
+
+  /*
+   *   Now we have a Use object. If it is a new one, we have to
+   *    1) understand if it exists physically
+   *    2) it is better than the old ones.
+   *
+   *   Here, we may have :
+   *    1) old_use = 0 
+   *         there was no Use object before for this package
+   *         the existing one is fine
+   *
+   *    2) old_use != 0 
+   *         we have created a new Use (which has to be validated)
+   */
+  bool found = use->move_to (native_version);
+
+  if (Cmt::get_debug ())
+    {
+      cout << "add> use [" << use << "] " << use->get_package_name () 
+           << " " << use->version
+           << " " << use->path
+           << " found=" << found
+           << " done=" << use->done
+           << endl;
+
+      show_packages ();
+    }
+      
+  if (!found)
+    {
+      if (!Cmt::get_quiet ())
+        {
+          cerr << "#CMT> Warning: package " << use->get_package_name () <<
+            " " << use->version << " " << use->path << 
+            " not found";
+
+	  if (context_use != 0)
+	    {
+	      cerr << " (requested by " << context_use->get_package_name () << ")";
+	    }
+
+	  cerr << endl;
+        }
+
+      //CmtError::set (CmtError::package_not_found, use->get_package_name ());
+      use = 0;
+    }
+
+  if ((old_use != 0) && (use != old_use))
+    {
+      if (Cmt::get_debug ())
+	{
+	  cout << "There was another version of this Use. \n"
+	       << "But a new one was created due to some criteria. \n"
+	       << "Now we are going to apply the version strategy to make the final selection"
+	       << endl;
+	}
+
+      /*
+       *    There was another version of this Use. 
+       *    But a new one was created due to some criteria.
+       *    Now we are going to apply the version strategy to make the final selection.
+       */
+
+      if (Cmt::get_debug ())
+        {
+	  cout << "select? [" << use << "] "<< use->version <<" vs old_use[" << old_use << "] "
+	       << old_use->get_package_name ()
+	       << " " << old_use->version
+	       << " " << old_use->path
+	       << endl;
+        }
+
+      if (!found)
+        {
+          /*
+           *  This new Use does not correspond to any physical package.
+           *  let's simply discard it (and go back to old_use)
+           */
+
+          if (use != 0) use->discard ();
+          use = old_use;
+          found = use->move_to (native_version);
+        }
+      else
+        {
+            //
+            //  This new version is different from the old one
+            // thus we have to choose
+            //
+	  static BestFitSelector selector;
+      Use* selected_use = selector.operate (old_use, use);
+
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "after operate old=" << old_use << "(" << old_use->m_index << ")"
+		   << " use=" << use << "(" << use->m_index << ")"
+		   << " => selected=" << selected_use
+		   << endl;
+	    }
+
+	    //
+            // Some situations managed by selector.operate happen
+            // to fail discarding the rejected Use.
+            //
+          if (use != selected_use) 
+            {
+	           use = use->set_selected_version (selected_use);
+            }
+          
+
+          /*
+           *   current directory is moved to the selected one
+           */
+          found = use->move_to (native_version);
+        }
+    }
+
+    //
+    // The following statement is no longer considered as useful.
+    // It is commented. But we should clarify why it was really needed!
+    //
+    //use->undiscard ();
+
+  if (found)
+    {
+      static UsePtrVector& uses = get_ordered_uses ();
+
+      bool registered = false;
+      const Use& cu = Use::current ();
+
+      Package* package = Package::find (package_name);
+
+      //
+      // A pointer to this new object is also added or replaced.
+      //
+      if ((use != &cu) && (package == cu.get_package ()))
+        {
+            // This is a recursive call to the current package!!
+          registered = true;
+          use->done = true;
+	  use->m_index = -1;
+        }
+      else
+        {
+	  //
+	  // Now sort out the registration in ordered uses
+	  //
+	  //  cases:
+	  //
+	  //   use is not yet registered (m_index < 0)
+	  //     o if another use of the same package is registered,
+	  //       it must be substituted with the new one
+	  //     o otherwise create a new entry at the end (it will be sorted
+	  //       afterwards)
+	  //
+	  //   use is already registered (m_index >= 0)
+	  //     o if another use of the same package is registered,
+	  //       it must be discarded, but this may mean that
+	  //       two versions are simultaneously registered (bug?)
+	  //     o otherwise we keep it in place
+	  //
+
+	  UsePtrVector& puses = package->get_uses ();
+
+	  if (use->m_index >= 0) registered = true;
+
+	  /*
+	    We look for all existing uses in that package.
+	   */
+	  for (int i = 0; i < puses.size(); i++)
+	    {
+	      Use* u = puses[i];
+              
+	      if (Cmt::get_debug ())
+		{
+		  cout << "add> check registering between " << use
+		       << ":" << use->get_package_name ()
+		       << "(" << use->m_index << ")"
+		       << " and " << u
+		       << ":" << u->get_package_name () 
+		       << "(" << u->m_index << ")"
+		       << endl;
+		}
+
+	      if ((u != use) && (u->m_index >= 0))
+		{
+		  // Another use of that package is already registered
+
+		  if (Cmt::get_debug ())
+		    {
+		      cout << "add> Another use of that package is already registered " 
+			   << " use(" << use->m_index << ")";
+		      if (use->m_index >= 0)
+			{
+			  cout << "[" << (uses[use->m_index])->get_package_name () << "]";
+			}
+		      cout << " u(" << u->m_index << ")";
+		      if (u->m_index >= 0)
+			{
+			  cout << "[" << (uses[u->m_index])->get_package_name () << "]";
+			}
+		      cout << endl;
+		    }
+
+		  if (use->m_index < 0)
+		    {
+		      /*
+			the newly selected use (use) should replace the one which was registered (u)
+		      */
+
+		      u->set_selected_version (use);
+
+		      registered = true;
+		    }
+		  else
+		    {
+		      // bug??
+		      if (Cmt::get_debug ())
+			{
+			  cout << "Duplicate entry in ordered uses" << endl;
+			}
+		    }
+		}
+	    }
+
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "add> registering completed" << endl;
+	      show_packages ();
+	    }
+        }
+      
+      if (!registered) 
+	{
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "add> We install use at the end the ordered list of uses" << endl;
+	    }
+
+	  uses.push_back (use);
+	  use->m_index = uses.size () - 1;
+	}
+
+      if (Cmt::get_debug ())
+	{
+	  for (int use_index = 0; use_index < uses.size (); use_index++)
+	    {
+	      Use* u = (Use*) uses[use_index];
+	      cout << "  use[" << use_index << "] p=(" << u << ")" << u->get_package_name () 
+		   << " v=" << u->version
+		   << " discarded=" << u->discarded
+		   << " selected=" << u->selected 
+		   << " done=" << u->done
+		   << " index=" << u->m_index
+		   << endl;
+	    }
+	  
+	}
+          
+      if (!use->done && Cmt::get_recursive ())
+        {
+          use->done = true;
+
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "Parsing requirements file at " << CmtSystem::pwd () << endl;
+	    }
+
+          SyntaxParser::parse_requirements ("requirements", use);
+        }
+      else
+	{
+	  if (Cmt::get_debug ())
+	    {
+	      cout << "Requirements file at " << CmtSystem::pwd () << " already parsed" << endl;
+	    }
+	}
+    }
+
+  CmtSystem::cd (here);
+
+  return (use);
+}
+
+//----------------------------------------------------------
+void Use::discard ()
+{
+  discarded = true;
+}
+
+//----------------------------------------------------------
+void Use::undiscard ()
+{
+  discarded = false;
+}
+
+//----------------------------------------------------------
+void Use::select ()
+{
+  selected = true;
+}
+
+//----------------------------------------------------------
+void Use::unselect ()
+{
+  selected = false;
+}
+
+//----------------------------------------------------------
+bool Use::is_selected ()
+{
+  return (selected);
+}
+
+/**
+ *    Check if the package makes use of the specified package/version
+ *
+ *    The seach only considers the first level of uses (thus it is
+ *   NOT recursive)
+ */
+bool Use::is_client (const cmt_string& used_package,
+                     const cmt_string& used_version)
+{
+  // A package is client of itself
+
+  Package* package = Package::find (used_package);
+
+  if ((get_package () == package) &&
+      (version == used_version)) return (true);
+
+  if (discarded) return (false);
+
+  int i;
+
+  for (i = 0; i < sub_uses.size (); i++)
+    {
+      Use* use = sub_uses[i];
+      if (use == 0) continue;
+
+      if ((use->get_package () == package) &&
+          (use->version == used_version)) return (true);
+
+      /*
+        if (use->is_client (used_package, used_version))
+        {
+        return (true);
+        }
+      */
+    }
+
+  return (false);
+}
+
+//----------------------------------------------------------
+void Use::apply_global_patterns ()
+{
+  int i;
+
+  Pattern::PatternVector& vector = Pattern::patterns ();
+
+  for (i = 0; i < vector.size (); i++)
+    {
+      Pattern& p = vector[i];
+
+      if (p.global)
+        {
+          p.apply (this);
+        }
+    }
+}
+
+//----------------------------------------------------------
+void Use::set_include_path (const cmt_string& new_path)
+{
+  include_path = new_path;
+}
+
+/**
+ *   Compute the full real path of a found package.
+ *   Takes the structuring style into account
+ *
+ *    Result is used to fill in the referenced string
+ *    Result does NOT include the trailing file_separator
+ */
+void Use::get_full_path (cmt_string& s) const
+{
+  if (real_path == "") s = CmtSystem::pwd ();
+  else s = real_path;
+
+  s += CmtSystem::file_separator ();
+  s += get_package_name ();
+  
+  if (style != no_version_style)
+    {
+      s += CmtSystem::file_separator ();
+      s += version;
+    }
+}
+
+/**
+ *   Compute the full real path of a found package.
+ *   Takes the structuring style into account
+ */
+cmt_string Use::get_full_path () const
+{
+  cmt_string result;
+
+  get_full_path (result);
+
+  return (result);
+}
+
+/**
+ *   Considering a given path, try and reduce the part of it 
+ *  that corresponds to the full path of this package into its
+ *  normal form ${<PACKAGE>ROOT}
+ *   The argument is modified if the pattern is exactly found.
+ */
+void Use::reduce_path (cmt_string& s) const
+{
+  cmt_string pattern;
+  get_full_path (pattern);
+  pattern += CmtSystem::file_separator ();
+  
+  cmt_string replacement = "${";
+  replacement += prefix;
+  replacement += "ROOT}";
+  replacement += CmtSystem::file_separator ();
+
+  s.replace (pattern, replacement);
+}
+
+//----------------------------------------------------------
+void Use::get_cmtpath_and_offset (cmt_string& cmtpath, cmt_string& offset) const
+{
+  if (get_package_name () == CmtSystem::get_project_package ())
+    {
+      offset = "";
+      CmtSystem::dirname (path, cmtpath);
+      return;
+    }
+  else if (get_package_name () == CmtSystem::get_home_package ())
+    {
+      offset = "";
+      cmtpath = path;
+      return;
+    }
+  else if (get_package_name () == CmtSystem::get_user_context_package ())
+    {
+      offset = "";
+      cmtpath = path;
+      return;
+    }
+
+  cmtpath = "";
+  offset = "";
+
+  cmtpath = Project::find_in_cmt_paths (real_path);
+
+  if (cmtpath != "")
+    {
+      CmtSystem::compress_path (cmtpath);
+
+      static const cmt_string empty_string;
+      static const cmt_string fs = CmtSystem::file_separator ();
+      
+      offset = real_path;
+      offset.replace (cmtpath, empty_string);
+
+      /**
+	 try to remove this current CMTPATH entry from path.  This
+	 has a meaning when the specified path already contains an
+	 absolute path.
+      */
+      
+      if (offset[0] == CmtSystem::file_separator ())
+	{
+	  // Just in case there is a part left after removing the cmtpath entry
+		
+	  offset.replace (fs, empty_string);
+	}
+    }
+}
+
+//------------------------------------------------------------
+bool Use::get_strategy (const cmt_string& name) const
+{
+  Project* p = Project::find_by_cmtpath (real_path);
+
+  bool strategy;
+
+  if (p == 0)
+    {
+      static const Project::ProjectVector& projects = Project::projects ();
+
+      if (projects.size () == 0) strategy = StrategyMgr::get_default_strategy (name);
+      else
+        {
+          p = &(projects[0]);
+          strategy = p->get_strategy (name);
+        }
+    }
+  else
+    {
+      strategy = p->get_strategy (name);
+    }
+
+  return (strategy);
+}
+
+//----------------------------------------------------------
+void Use::fill_includes_macro (cmt_string& buffer) const
+{
+  if (include_path == "")
+    {
+      buffer += "$(ppcmd)\"$(";
+      buffer += get_package_name ();
+      buffer += "_root)";
+      buffer += CmtSystem::file_separator ();
+      buffer += "src\" ";
+    }
+  else if (include_path != "none")
+    {
+      buffer += "$(ppcmd)\"";
+      buffer += include_path;
+      buffer += "\" ";
+    }
+  
+  for (int i = 0; i < includes.size (); i++)
+    {
+      Include& incl = includes[i];
+
+      if (incl.name == "") continue;
+      
+      buffer += "$(ppcmd)\"";
+      buffer += incl.name;
+      buffer += "\" ";
+    }
+}
+
+//----------------------------------------------------------
+void Use::fill_macro (cmt_string& buffer, const cmt_string& suffix) const
+{
+  buffer += " $(";
+  buffer += get_package_name ();
+  buffer += "_";
+  buffer += suffix;
+  buffer += ") ";
+}
+
+//----------------------------------------------------------
+void Use::fill_standard_macros (cmt_string& buffer) const
+{
+  static cmt_string fs = CmtSystem::file_separator ();
+
+  buffer = "";
+
+  cmt_string package_name = get_package_name ();
+
+  buffer += "macro ";
+  buffer += package_name;
+  buffer += "_tag";
+  buffer += " \"$(tag)\"";
+  buffer += "\n";
+
+  if (located ())
+    {
+      buffer += "macro ";
+      buffer += prefix;
+      buffer += "ROOT";
+      buffer += " \"";
+      buffer += get_full_path ();
+      buffer += "\"";
+      buffer += "\n";
+
+      buffer += "macro ";
+      buffer += package_name;
+      buffer += "_root";
+      buffer += " \"";
+      buffer += real_path;
+      buffer += fs;
+      buffer += package_name;
+      if (style != no_version_style)
+	{
+	  buffer += fs;
+	  buffer += version;
+	}
+      buffer += "\"";
+      buffer += "\n";
+    }
+
+  buffer += "macro ";
+  buffer += prefix;
+  buffer += "VERSION";
+  buffer += " \"";
+  buffer += version;
+  buffer += "\"";
+  buffer += "\n";
+
+  cmt_string cmtpath = "";
+  cmt_string offset = "";
+
+  get_cmtpath_and_offset (cmtpath, offset);
+
+  buffer += "macro ";
+  buffer += package_name;
+  buffer += "_cmtpath";
+  buffer += " \"";
+  buffer += cmtpath;
+  buffer += "\"";
+  buffer += "\n";
+
+  buffer += "macro ";
+  buffer += package_name;
+  buffer += "_offset";
+  buffer += " \"";
+  buffer += offset;
+  buffer += "\"";
+  buffer += "\n";
+  
+  Project* p = Project::find_by_cmtpath (cmtpath);
+
+  buffer += "macro ";
+  buffer += package_name;
+  buffer += "_project";
+  buffer += " \"";
+  if (p != 0)
+    {
+      buffer += p->get_name ();
+    }
+  buffer += "\"";
+  buffer += "\n";
+
+  buffer += "macro ";
+  buffer += package_name;
+  buffer += "_project_release";
+  buffer += " \"";
+  if (p != 0)
+    {
+      buffer += p->get_release ();
+    }
+  buffer += "\"";
+}
+
+
+//----------------------------------------------------------
+static bool same_dirs (const cmt_string& d1, const cmt_string& d2)
+{
+  bool result = false;
+
+  cmt_string here = CmtSystem::pwd ();
+
+  cmt_string h1;
+  if (CmtSystem::cd (d1)) h1 = CmtSystem::pwd ();
+
+  CmtSystem::cd (here);
+
+  cmt_string h2;
+  if (CmtSystem::cd (d2)) h2 = CmtSystem::pwd ();
+
+  result = (h1 == h2);
+
+  CmtSystem::cd (here);
+
+  return (result);
+}
+
+//----------------------------------------------------------
+static bool install_library (const cmt_string& source_library_name, 
+			     const cmt_string& dest_library_name, 
+			     const cmt_string& cmtinstallarea, 
+			     const cmt_string& tag, 
+			     const cmt_string& symlinkcmd)
+{
+  cmt_string libname = source_library_name;
+  cmt_string name = dest_library_name;
+  cmt_string s;
+  Use& current_use = Use::current ();
+
+  Symbol::expand (name);
+  Symbol::expand (libname);
+
+  if (cmtinstallarea != "")
+    {
+      s = cmtinstallarea;
+      s += CmtSystem::file_separator ();
+      s += tag;
+      s += CmtSystem::file_separator ();
+      s += "lib";
+      s += CmtSystem::file_separator ();
+      s += name;
+      
+      // Now creating the reference file
+
+      cmt_string ref_file = s;
+      ref_file += ".cmtref";
+
+      cmt_string text = libname;
+      text += "\n";
+
+      Symbol::expand (ref_file);
+      Symbol::expand (text);
+
+      if (!Cmt::get_quiet ()) cout << "   Creating the reference file " << ref_file << endl;
+      text.write (ref_file);
+    }
+  else
+    {
+      s = "../$(";
+      s += current_use.get_package_name ();
+      s += "_tag)/";
+      s += name;
+    }
+
+  Symbol::expand (s);
+
+  cmt_string source;
+  cmt_string dest;
+
+  CmtSystem::dirname (libname, source);
+  CmtSystem::dirname (s, dest);
+
+  if (same_dirs (source, dest))
+    {
+      return (false);
+    }
+
+  //if (!Cmt::get_quiet ()) 
+  cout << "   Symlinking " << libname << " to " << s << endl;
+
+  if (symlinkcmd == "")
+    {
+      if (!CmtSystem::create_symlink (libname, s))
+	{
+	  cerr << "#CMT> Cannot create a symbolic link to " << libname << endl;
+	  return (false);
+	}
+    }
+  else
+    {
+      cmt_string cmd = symlinkcmd;
+      cmd += " ";
+      cmd += libname;
+      cmd += " ";
+      cmd += s;
+      
+      int status = CmtSystem::execute (cmd);
+      
+      if (status != 0)
+	{
+	  cerr << "#CMT> Cannot create a symbolic link to " << libname << endl;
+	  return (false);
+	}
+    }
+
+  return (true);
+}
+
+
+/**
+   Centralize the construction of library links for this Use.
+*/
+void Use::build_library_links (const cmt_string& cmtinstallarea, 
+			       const cmt_string& tag, 
+			       const cmt_string& shlibsuffix, 
+			       const cmt_string& symlinkcmd) const
+{
+  if (!located ())
+    {
+      if (!Cmt::get_quiet ())
+	{
+	  cout << "# package " << get_package_name () <<
+	    " " << version << " " << path << 
+	    " not found" <<
+	    endl;
+	}
+      return;
+    }
+
+  cmt_string s;
+
+  s = get_package_name ();
+  s += "_libraries";
+
+  Symbol* libraries_macro = Symbol::find (s);
+
+  if (libraries_macro == 0) return;
+
+  cmt_string libraries = libraries_macro->build_macro_value ();
+  Symbol::expand (libraries);
+  static CmtSystem::cmt_string_vector values;
+
+  CmtSystem::split (libraries, " \t", values);
+
+  for (int j = 0; j < values.size (); j++)
+    {
+      const cmt_string& library = values[j];
+
+      static cmt_string libname;
+      static cmt_string name;
+
+      // Is it a simple name or a complete path?
+
+      libname = library;
+      Symbol::expand (libname);
+
+      bool is_absolute = false;
+
+      is_absolute = CmtSystem::absolute_path (libname);
+
+      if (is_absolute)
+	{
+	  /**
+	   *   We assume here that "library" contains a complete path.
+	   *   (including the complete syntax libxxx.so)
+	   */
+
+	  cmt_string suffix;
+	  CmtSystem::basename (library, name);
+	}
+      else
+	{
+	  /**
+	   *   Here we expect that only the base name of the library
+	   *   is given : ie it should not contain the "lib" prefix, 
+	   *   nor the suffix .so, nor any path prefix.
+	   *    This of course should generally correspond to a constituent name.
+	   */
+	  
+	  libname = "${";
+	  libname += prefix;
+	  libname += "ROOT}/${";
+	  libname += get_package_name ();
+	  libname += "_tag}/";
+	  libname += "$(library_prefix)";
+	  libname += library;
+	  libname += "$(library_suffix)";
+	  libname += ".";
+	  libname += shlibsuffix;
+
+	  name = "$(library_prefix)";
+	  name += library;
+	  name += "$(library_suffix)";
+	  name += ".";
+	  name += shlibsuffix;
+	}
+
+      if (!install_library (libname, name, cmtinstallarea, tag, symlinkcmd))
+	{
+	  continue;
+	}
+
+#ifdef __APPLE__
+      if (!is_absolute)
+	{
+	  libname = "${";
+	  libname += prefix;
+	  libname += "ROOT}/${";
+	  libname += get_package_name ();
+	  libname += "_tag}/";
+	  libname += library;
+	  libname += ".bundle";
+
+	  name = library;
+	  name += ".bundle";
+	  
+	  if (!install_library (libname, name, cmtinstallarea, tag, symlinkcmd))
+	    {
+	      continue;
+	    }
+	}
+#endif
+    }
+}
+
+/**
+ *   This function tries to get the replacement of a Use when it has
+ *  been discarded by a better match to version constraints.
+ */
+Use* Use::get_selected_version ()
+{
+    //cout << "get_selected_version for package " << get_package_name () << endl;
+
+  if (!discarded) return (this);
+
+  Package* p = m_package;
+
+  Use::UsePtrVector& uses = p->get_uses ();
+
+  bool dbg = Cmt::get_debug ();
+
+  int size = uses.size ();
+
+  for (int i = 0; i < size; i++)
+    {
+      Use* u = uses[i];
+      if (u == 0) continue;
+      if (u->discarded) continue;
+      if (dbg)
+	{
+	  cout << "Use::get_selected_version> for package " << get_package_name ()
+	       << "  got a version " << u << endl;
+	}
+      return (u);
+    }
+
+  return (0);
+}
+
+/**
+   Switching from one use to another one, (better wrt
+   various criteria). 
+
+   When switching, m_index and auto_imports are
+   transfered from the un-selected to the newly selected.
+ */
+Use* Use::set_selected_version (Use* selected_use)
+{
+  if (this == selected_use) return (this);
+
+  static UsePtrVector& uses = get_ordered_uses ();
+
+  if (m_index >= 0)
+    {
+      // This discarded package was registered. We have to substitute
+      // it with the new one.
+
+      selected_use->m_index = m_index;
+      selected_use->auto_imports = auto_imports;
+
+      selected_use->undiscard ();
+
+      m_index = -1;
+
+      uses[selected_use->m_index] = selected_use;
+    }
+
+  discard ();
+
+  return (selected_use);
+}
+
+void Use::set_auto_imports (State new_state)
+{
+  if (Cmt::get_debug ())
+    {
+      cout << "Use::set_auto_imports>(" << get_package_name () << ") " 
+           << auto_imports << " -> " << new_state << endl;
+    }
+
+  if (auto_imports == new_state) return;
+  
+  State old_state = auto_imports;
+  
+  auto_imports = new_state;
+
+    // We propagate only when we switch from Off to On
+
+  if ((old_state == Off) && (new_state == On))
+    {
+      cmt_string s;
+      static const cmt_string state_text[] = {"Unspecified", "Off", "On"};
+
+      if (Cmt::get_debug ())
+        {
+          s = "Use::set_auto_imports>(";
+          s += get_package_name ();
+          s += ") ";
+
+          cout << s << endl;
+        }
+
+      for (int i = 0; i < sub_uses.size (); i++)
+        {
+          Use* u = sub_uses[i];
+          State state = sub_use_auto_imports[i];
+          
+          if (Cmt::get_debug ())
+            {
+              s += " ";
+              s += u->get_package_name ();
+              s += "(";
+              s += state_text[state];
+              s += ")";
+            }
+
+          if (state == Unspecified)
+            {
+              u->set_auto_imports (On);
+            }
+        }
+          
+      if (Cmt::get_debug ())
+        {
+          cout << s << endl;
+        }
+    }
+}
+
+void Use::set_native_version (bool state)
+{
+  m_has_native_version = state;
+}
+
+bool Use::has_native_version () const
+{
+  return (m_has_native_version);
+}
+
+Package* Use::get_package () const
+{
+  return (m_package);
+}
+
+const cmt_string& Use::get_package_name () const
+{
+  static const cmt_string null = "";
+
+  Package* p = m_package;
+  if (p == 0) return (null);
+
+  return (p->get_name ());
+}
+
+void Use::set_package_name (const cmt_string& name)
+{
+  Package* p = Package::add (name);
+
+  m_package = p;
+  p->add_use (this);
+}
+
+int Use::get_index () const
+{
+  return (m_index);
+}
+
+//----------------------------------------------------------
+bool Use::get_all_clients (const cmt_string& to_name)
+{
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  Use* use = Use::find (to_name);
+
+  if (use == 0)
+    {
+      cerr << "#CMT> No access to " << to_name << endl;
+      return (false);
+    }
+
+  cmt_map <cmt_string, Use*> all_clients;
+  cmt_map <cmt_string, Use*> all_clients_ok;
+
+  const cmt_string& name = get_package_name ();
+
+  Use* me = this;
+
+  all_clients.add (name, me);
+  all_clients_ok.add (name, me);
+
+  bool status = get_all_clients (use, to_name, all_clients, all_clients_ok); 
+
+  return (status);
+}
+
+//----------------------------------------------------------
+bool Use::get_all_clients (Use* to, 
+			   const cmt_string& result, 
+			   cmt_map <cmt_string, Use*>& all_clients, 
+			   cmt_map <cmt_string, Use*>& all_clients_ok)
+{
+  if (this == to)
+    {
+      cout << result << endl;
+      return (true);
+    }
+
+  const cmt_string& to_name = to->get_package_name ();
+  const cmt_string& to_version = to->version;
+
+  //cout << "gac> from " << get_package_name () << " to " << to_name << " -> " << result << endl;
+
+  if (all_clients.has (to_name))
+    {
+      if (all_clients_ok.has (to_name))
+	{
+	  cout << "   ..." << result << endl;
+	  return (true);
+	}
+      else
+	{
+	  return (false);
+	}
+    }
+
+  all_clients.add (to_name, to);
+
+  bool status = false;
+
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+  Use* use = 0;
+
+  for (int n = 0; n < uses.size (); ++n)
+    {
+      use = uses[n];
+
+      if (use->discarded) continue;
+      if (use->m_hidden) continue;
+
+      if (!use->located ()) continue;
+
+      if (use == to) continue;
+
+      if (use->is_client (to_name, to_version))
+	{
+	  const cmt_string& n = use->get_package_name ();
+
+	  cmt_string r;
+
+	  if ((use->initial_scope != ScopeUnspecified) &&
+	      (use->initial_scope != ScopePublic)) 
+	    {
+	      r += "(private)";
+	    }
+	  
+	  if (use->auto_imports == Off) r += "(no_auto_imports)";
+
+	  r += n;
+	  r += ".";
+	  r += result;
+
+	  //cout << "gac> " << n << " is client of " << to_name << endl;
+
+	  if (get_all_clients (use, r, all_clients, all_clients_ok))
+	    {
+	      all_clients_ok.add (n, use);
+	      status = true;
+	    }
+	}
+    }
+
+  use = this;
+
+  if (use->is_client (to_name, to_version))
+    {
+      const cmt_string& n = use->get_package_name ();
+      
+      cmt_string r;
+
+      if ((use->initial_scope != ScopeUnspecified) &&
+	  (use->initial_scope != ScopePublic)) 
+	{
+	  r += "(private)";
+	}
+      
+      if (use->auto_imports == Off) r += "(no_auto_imports)";
+
+      r += n;
+      r += ".";
+      r += result;
+      
+      //cout << "gac> " << n << " is client of " << to_name << endl;
+      
+      if (get_all_clients (use, r, all_clients, all_clients_ok))
+	{
+	  all_clients_ok.add (n, use);
+	  status = true;
+	}
+    }
+
+  return (status);
+}
+
+/**
+   Let's consider two packages in the use graph "this" and "to"
+   This function finds all packages that are reached in between
+   following all possible paths between "this" and "to"
+
+   Result s accumulated into "list"
+ */
+bool Use::get_paths (Use* to, UsePtrVector& list)
+{
+  bool is_in_path = false;
+  bool cycle = false;
+  bool already_in_path = false;
+  bool dbg = Cmt::get_debug ();
+
+  static int level = 0;
+
+  int size = 0;
+
+  if (level == 0)
+    {
+      unselect_all ();
+      selected = false;
+    }
+
+  if (selected) 
+    {
+      /**
+	 If this use is already in the list, we don't duplicate the entry.
+	 (protection duplicate paths in the graph)
+      */
+
+      size = list.size ();
+
+      for (int m = 0; m < size; m++)
+	{
+	  Use* u = list[m];
+	  if (u == this)
+	    {
+	      if (dbg)
+		{
+		  for (int lll = 0; lll < level; lll++) cout << "  ";
+		  cout << "  Use::get_paths." << level << "> try1.2 sub="
+		       << get_package_name () << " already_in_path " << endl;
+		}
+	      
+	      return (true);
+	    }
+	}
+
+      return (false);
+    }
+
+  selected = true;
+
+  if (dbg)
+    {
+      for (int lll = 0; lll < level; lll++) cout << "  ";
+      cout << "Use::get_paths." << level << ">" << get_package_name ()
+	   << " to=" << to->get_package_name () 
+	   << " list=[";
+
+      for (int m = 0; m < list.size (); m++)
+        {
+          Use* u = list[m];
+	  cout << u->get_package_name () << " ";
+        }
+
+      cout << "]" << endl;
+    }
+
+  /**
+     Now "this" is a candidate new entry in the list
+   */
+
+  // First figure out whether 'to' is used by 'this'.
+
+  if (this->get_package_name () == to->get_package_name ())
+    {
+      // We've reached the goal (for the first time)
+      is_in_path = true;
+    }
+  else
+    {
+      /**
+	 Let's scan sub_uses now
+       */
+      size = sub_uses.size ();
+
+      if (dbg)
+	{
+	  for (int lll = 0; lll < level; lll++) cout << "  ";
+	  cout << "  Use::get_paths." << level << "> size=" << size << endl;
+	}
+
+      for (int n = 0; n < size; n++)
+        {
+          Use* use = sub_uses[n];
+
+          if (use == 0) continue;
+
+	  if (dbg)
+	    {
+	      for (int lll = 0; lll < level; lll++) cout << "  ";
+	      cout << "  Use::get_paths." << level << "> try1 sub="
+		   << use->get_package_name () << "(" << use << ") " << use->discarded << endl;
+	    }
+
+          if (use->discarded)
+            {
+              Use* u;
+
+              u = use->get_selected_version ();
+              if (u == 0) 
+		{
+		  /**
+		     No way to find a valid use for this used package.
+		     Is that a bug?
+		     Anyway we don't pursue on that branch.
+		   */
+		  continue;
+		}
+
+              use = u;
+            }
+
+	  if (dbg)
+	    {
+	      for (int lll = 0; lll < level; lll++) cout << "  ";
+	      cout << "  Use::get_paths." << level << "> try2 sub="
+		   << use->get_package_name () << " " << use->discarded << endl;
+	    }
+
+          level++;
+          bool r = use->get_paths (to, list);
+          level--;
+
+          if (r)
+            {
+              is_in_path = true;
+            }
+        }
+    }
+
+  if (is_in_path)
+    {
+      if (dbg)
+	{
+	  for (int lll = 0; lll < level; lll++) cout << "  ";
+	  cout << "Use::get_paths." << level << "> push " << get_package_name () << endl;
+	}
+      list.push_back (this);
+    }
+
+  return (is_in_path);
+}
+
+//----------------------------------------------------------
+bool Use::located () const
+{
+  return (m_located);
+}
+
+//----------------------------------------------------------
+void Use::show_sub_uses (const cmt_string& request, bool skip_discarded)
+{
+  Use* current = &(Use::current ());
+  int n;
+  Use* use;
+  static int level = 0;
+
+  if (skip_discarded && discarded) return;
+  if (m_hidden) return;
+
+  if (level > 0)
+    {
+      cout << "# ";
+      for (n = 0; n < (level-1); n++) cout << "  ";
+
+      if (request == "")
+	{
+	  cout << "use " << get_package_name () << " " << specified_version;
+
+	  if (this == current) 
+	    {
+	      cout << " (current)";
+	    }
+	  else
+	    {
+	      if (specified_path != "") cout << " " << specified_path;
+	    }
+	}
+      else
+	{
+	  cout << "use " << request;
+	}
+
+      if (version_alias != "")
+        {
+          cout << " | " << version_alias << " " << path_alias;
+        }
+
+      if (initial_scope == ScopeUnspecified) cout << " (unspecified)";
+      else if (initial_scope != ScopePublic) cout << " (private)";
+
+      if (auto_imports == Off) cout << " (no_auto_imports)";
+
+      if (style == no_version_style) cout << " (no_version_directory)";
+
+      if (m_has_native_version)
+        {
+          cmt_string n = get_package_name ();
+          n += "_native_version";
+
+          Symbol* s = Symbol::find (n);
+          if (s != 0)
+            {
+              cmt_string value = s->resolve_macro_value ();
+              cout << " (native_version=" << value << ")";
+            }
+        }
+
+      cout << endl;
+    }
+
+  if (selected) return;
+  selected = true;
+
+  level++;
+  for (n = 0; n < sub_uses.size (); n++)
+    {
+      use = sub_uses[n];
+      if (use == 0) continue;
+
+      const cmt_string& request = requests[n];
+
+      ScopeType saved_scope = use->initial_scope;
+      State saved_state = use->auto_imports;
+
+      use->initial_scope = sub_use_scopes[n];
+      use->auto_imports = sub_use_auto_imports[n];
+
+      use->show_sub_uses (request, skip_discarded);
+
+      use->initial_scope = saved_scope;
+      use->auto_imports = saved_state;
+    }
+  level--;
+}
+
+//----------------------------------------------------------
+Use& Use::current ()
+{
+  static UseVector& instances = get_instances ();
+  static Use* current_use = 0;
+
+  if ((current_use == 0) || (instances.size () == 0))
+    {
+      Use& use_object = instances.add ();
+      current_use = &use_object;
+    }
+
+  return (*current_use);
+}
+
+//----------------------------------------------------------
+const Use& Use::const_current ()
+{
+  const Use& use = Use::current ();
+
+  return (use);
+}
+
+//----------------------------------------------------------
+Use::UseVector& Use::get_instances ()
+{
+  static Database& db = Database::instance ();
+  static UseVector& instances = db.all_uses ();
+
+  return (instances);
+}
+
+//----------------------------------------------------------
+Use::UsePtrVector& Use::get_ordered_uses ()
+{
+  static Database& db = Database::instance ();
+  static UsePtrVector& uses = db.uses ();
+
+  return (uses);
+}
+
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+//
+//  Check if the specified version is better than the
+//  current one.
+//
+//----------------------------------------------------------
+Use* BestFitSelector::operate (Use* ref_use, Use* new_use)
+{
+  Use* selected = ref_use;
+
+  int ref_v = -1;
+  int ref_r = -1;
+  int ref_p = -1;
+  cmt_string ref_pp;
+
+  int new_v = -1;
+  int new_r = -1;
+  int new_p = -1;
+  cmt_string new_pp;
+
+  int alias_v = -1;
+  int alias_r = -1;
+  int alias_p = -1;
+  cmt_string alias_pp;
+
+  enum { no_alias, new_has_alias, ref_has_alias } has_alias = no_alias;
+
+  // First analyze specified versions
+  cmt_string ref_version = ref_use->specified_version;
+  cmt_string new_version = new_use->specified_version;
+
+  CmtSystem::is_version_directory (ref_version, ref_v, ref_r, ref_p);
+  ref_pp = ref_use->path;
+
+  CmtSystem::is_version_directory (new_version, new_v, new_r, new_p);
+  new_pp = new_use->path;
+
+  if (new_use->version_alias != "")
+    {
+      has_alias = new_has_alias;
+      CmtSystem::is_version_directory (new_use->version_alias, 
+                                       alias_v, alias_r, alias_p);
+      alias_pp = new_use->path_alias;
+    }
+  else if (ref_use->version_alias != "")
+    {
+      has_alias = ref_has_alias;
+      CmtSystem::is_version_directory (ref_use->version_alias, 
+                                       alias_v, alias_r, alias_p);
+      alias_pp = ref_use->path_alias;
+    }
+
+  ref_use->undiscard ();
+  new_use->undiscard ();
+
+  if (new_v != ref_v)
+    {
+      if (has_alias != no_alias)
+        {
+          if (has_alias == new_has_alias)
+            {
+              new_v = alias_v;
+              new_r = alias_r;
+              new_p = alias_p;
+              new_pp = alias_pp;
+            }
+          else if (has_alias == ref_has_alias)
+            {
+              ref_v = alias_v;
+              ref_r = alias_r;
+              ref_p = alias_p;
+              ref_pp = alias_pp;
+            }
+        }
+    }
+
+  bool ref_v_wildcarded = ((ref_v) == -1);
+  bool ref_r_wildcarded = ((ref_r) == -1);
+  bool ref_p_wildcarded = ((ref_p) == -1);
+
+  bool ref_v_explicit = !ref_v_wildcarded;
+  bool ref_r_explicit = !ref_r_wildcarded;
+  bool ref_p_explicit = !ref_p_wildcarded;
+
+  bool new_v_wildcarded = ((new_v) == -1);
+  bool new_r_wildcarded = ((new_r) == -1);
+  bool new_p_wildcarded = ((new_p) == -1);
+
+  bool new_v_explicit = !new_v_wildcarded;
+  bool new_r_explicit = !new_r_wildcarded;
+  bool new_p_explicit = !new_p_wildcarded;
+
+  bool verbose = (CmtSystem::getenv ("CMTVERBOSE") != "");
+
+  cmt_string ref_vc = ref_v_wildcarded ? "wildcarded" : "explicit";
+  cmt_string ref_rc = ref_r_wildcarded ? "wildcarded" : "explicit";
+  cmt_string ref_pc = ref_p_wildcarded ? "wildcarded" : "explicit";
+  
+  cmt_string new_vc = new_v_wildcarded ? "wildcarded" : "explicit";
+  cmt_string new_rc = new_r_wildcarded ? "wildcarded" : "explicit";
+  cmt_string new_pc = new_p_wildcarded ? "wildcarded" : "explicit";
+
+  // Now compute effective version identifiers
+  CmtSystem::is_version_directory (ref_use->version, ref_v, ref_r, ref_p);
+  CmtSystem::is_version_directory (new_use->version, new_v, new_r, new_p);
+
+  cmt_string new_selected_version = new_use->version;
+
+  if (new_v_explicit && ref_v_explicit && (new_v != ref_v))
+    {
+      /*
+      if (verbose && !Cmt::get_quiet ())
+	{
+	  cerr << "# Required explicit version " << new_version
+	       << " of package " << ref_use->get_package_name () 
+	       << " incompatible with selected explicit version " << ref_version
+	       << endl;
+	}
+
+      CmtError::set (CmtError::version_conflict, "BestFitSelector::operate> ");
+
+      if (ref_use != new_use) new_use->discard ();
+      */
+
+      if (new_v > ref_v)
+	{
+	  if (verbose && !Cmt::get_quiet ())
+	    {
+	      cerr << "# Select " << new_vc << " version " << new_version 
+		   << " of package " << ref_use->get_package_name () 
+		   << " instead of existing " << ref_vc << " " << ref_version 
+		   << endl;
+	    } 
+	  
+	  if (ref_use != new_use) ref_use->discard ();
+	  selected = new_use;
+	  selected->done = false; // Will read the new requirements
+	}
+    }
+  else if (new_v_wildcarded || ref_v_wildcarded)
+    {
+      // at least one of ref or new is wildcarded
+
+      //
+      // we plan to discard new_use, but if it was specified as explicit 
+      // and ref_use was wildcarded then new_use will win !!
+      //
+      // So then we'll have to understand where are the wild
+      // cards... If they are on v or r, then we consider them.
+      // 
+      //
+
+      if (ref_v_wildcarded && new_v_explicit)
+	{
+	  if ((ref_use->real_path != new_use->real_path) ||
+	      (ref_use->version != new_use->version))
+	    {
+	      if (ref_use != new_use) ref_use->discard ();
+	      selected = new_use;
+	      selected->done = false; // Will read the new requirements
+
+	      if (verbose && !Cmt::get_quiet ())
+		{
+		  cerr << "# Select explicit version " << new_version 
+		       << "(" << new_use->version << ")" 
+		       << " of package " << ref_use->get_package_name () 
+		       << " instead of existing wildcarded " << ref_version 
+		       << "(" << ref_use->version << ")" 
+		       << endl;
+		}
+	    }
+	  else
+	    {
+	      if (ref_use != new_use) new_use->discard ();
+	      //ref_use->version = new_selected_version;
+	    }
+	}
+      else
+	{
+	  // ref is explicit or new is wildcarded
+
+	  /*
+	  if (verbose && !Cmt::get_quiet ())
+	    {
+	      cerr << "# keep " << ref_vc << " version " << ref_version
+		   << " of package " << ref_use->get_package_name () 
+		   << " (ignore " << new_vc << " version " << new_version << ")" 
+		   << endl;
+	    }
+	  */
+
+	  if (ref_use != new_use) new_use->discard ();
+	}
+    }
+  else if (new_r_wildcarded || ref_r_wildcarded || (new_r < ref_r))
+    {
+      //
+      // we plan to discard new_use, but if it was specified as explicit 
+      // and ref_use was wildcarded then new_use will win !!
+      //
+      // So then we'll have to understand where are the wild
+      // cards... If they are on v or r, then we consider them.
+      // 
+      //
+
+      if (ref_r_wildcarded && new_r_explicit)
+	{
+	  // ref has wild card and new has not => new wins
+
+	  if ((ref_use->real_path != new_use->real_path) ||
+	      (ref_use->version != new_use->version))
+	    {
+	      if (ref_use != new_use) ref_use->discard ();
+	      selected = new_use;
+	      selected->done = false; // Will read the new requirements
+
+	      if (verbose && !Cmt::get_quiet ())
+		{
+		  cerr << "# Select explicit release " << new_version
+		       << " of package " << ref_use->get_package_name ()
+		       << " instead of existing wildcarded " << ref_version
+		       << endl;
+		} 
+	    }
+	  else
+	    {
+	      // Just adapt version with new one.
+
+	      if (ref_use != new_use) new_use->discard ();
+	      //ref_use->version = new_selected_version;
+	    }
+	}
+      else
+	{
+	  /*
+	  if (verbose &&!Cmt::get_quiet ())
+	    {
+	      cerr << "# keep " << ref_rc << " release " << ref_version 
+		   << " of package " << ref_use->get_package_name () 
+		   << " (ignore " << new_rc << " release " << new_version << ")" 
+		   << endl;
+	    }
+	  */
+
+	  if (ref_use != new_use) new_use->discard ();
+	}
+    }
+  else if (new_r > ref_r)
+    {
+      if (verbose && !Cmt::get_quiet ())
+	{
+	  cerr << "# Select " << new_rc << " release " << new_version 
+	       << " of package " << ref_use->get_package_name () 
+	       << " instead of existing " << ref_rc << " " << ref_version 
+	       << endl;
+        } 
+
+      if (ref_use != new_use) ref_use->discard ();
+      selected = new_use;
+      selected->done = false; // Will read the new requirements
+    }
+  else if (new_p_wildcarded || ref_p_wildcarded || (new_p < ref_p))
+    {
+      //
+      // we plan to discard new_use, but if it was specified as explicit 
+      // and ref_use was wildcarded then new_use will win !!
+      //
+
+      if (ref_p_wildcarded && new_p_explicit)
+	{
+	  if ((ref_use->real_path != new_use->real_path) ||
+	      (ref_use->version != new_use->version))
+	    {
+	      if (ref_use != new_use) ref_use->discard ();
+	      selected = new_use;
+	      selected->done = false; // Will read the new requirements
+
+	      if (verbose && !Cmt::get_quiet ())
+		{
+		  cerr << "# Select explicit patch " << new_version 
+		       << " of package " << ref_use->get_package_name () 
+		       << " instead of existing wildcarded " << ref_version 
+		       << endl;
+		}
+	    }
+	  else
+	    {
+	      if (ref_use != new_use) new_use->discard ();
+	      ref_use->version = new_selected_version;
+	    }
+	}
+      else
+	{
+	  /*
+	  if (verbose && !Cmt::get_quiet ())
+	    {
+	      cerr << "# keep " << ref_pc << " patch " << ref_version 
+		   << " [" << ref_use->specified_version << "]" 
+		   << " of package " << ref_use->get_package_name () 
+		   << " (ignore " << new_pc << " version " << new_version << ")" 
+		   << " [" << new_use->specified_version << "]" 
+		   << endl;
+	    }
+	  */
+
+	  if (ref_use != new_use) new_use->discard ();
+	}
+    }
+  else if (new_p > ref_p)
+    {
+      if (verbose && !Cmt::get_quiet ())
+        {
+	  cerr << "# Select " << new_pc << " patch " << new_version 
+	       << " of package " << ref_use->get_package_name () 
+	       << " instead of existing " << ref_pc << " " << ref_version 
+	       << endl;
+        }
+
+      if (ref_use != new_use) ref_use->discard ();
+      selected = new_use;
+      selected->done = false; // Will read the new requirements
+    }
+  else if (new_pp != ref_pp) // same version-r-p but from different path
+    {
+      if (ref_use != new_use) ref_use->discard ();
+      selected = new_use;
+      selected->done = false; // Will read the new requirements
+    }
+
+  return (selected);
+}
+
+
+Package* Package::find (const cmt_string& name)
+{
+  static PackageMap& PackageMap = package_map ();
+
+  Package* result = 0;
+
+  result = PackageMap.find (name);
+
+  return (result);
+}
+
+Package* Package::add (const cmt_string& name)
+{
+  static PackageVector& Packages = packages ();
+  static PackageMap& PackageMap = package_map ();
+
+  {
+    Package* package;
+
+    package = find (name);
+    if (package != 0) return (package);
+  }
+
+  Package& package = Packages.add ();
+  PackageMap.add (name, package);
+
+  package.m_name = name;
+
+  if (name == "CMT")
+    {
+      package.m_is_cmt = true;
+    }
+  else if (name == "methods")
+    {
+      package.m_is_cmt = true;
+    }
+
+  if (Cmt::get_debug ())
+    {
+      cout << "Package::add (" << name << ")" << endl;
+    }
+
+  return (&package);
+}
+
+Package::PackageVector& Package::packages ()
+{
+  static Database& db = Database::instance ();
+  static PackageVector& Packages = db.packages ();
+
+  return (Packages);
+}
+
+Package::PackageMap& Package::package_map ()
+{
+  static Database& db = Database::instance ();
+  static PackageMap& PackageMap = db.package_map ();
+
+  return (PackageMap);
+}
+
+void Package::clear_all ()
+{
+  static PackageVector& Packages = packages ();
+  static PackageMap& PackageMap = package_map ();
+
+  PackageMap.clear ();
+  Packages.clear ();
+}
+
+Package::Package () : m_is_cmt (false)
+{
+  if (Cmt::get_debug ())
+    {
+      cout << "Package::Package" << endl;
+    }
+}
+
+Package::~Package ()
+{
+  m_name = "";
+}
+
+const cmt_string& Package::get_name () const
+{
+  return (m_name);
+}
+
+void Package::add_use (Use* use)
+{
+  for (int i = 0; i < m_uses.size (); i++)
+    {
+      Use* u = m_uses[i];
+      if (u == use) return;
+    }
+
+  m_uses.push_back (use);
+}
+
+void Package::remove_use (Use* use)
+{
+  if (Cmt::get_debug ())
+    {
+      cout << "Package::remove_use (" << use->get_package_name () << ")" << endl;
+      cout << "  name=" << m_name
+	   << " uses=" << m_uses.size () << endl;
+    }
+
+  Use::UsePtrVector temp;
+
+  temp = m_uses;
+
+  m_uses.clear ();
+
+  for (int i = 0; i < temp.size (); i++)
+    {
+      Use* u = temp[i];
+      if (u != use)
+	{
+	  m_uses.push_back (u);
+	}
+    }
+}
+
+Use::UsePtrVector& Package::get_uses ()
+{
+  return (m_uses);
+}
+
+bool Package::is_cmt ()
+{
+  return (m_is_cmt);
+}
+
+static void show_packages ()
+{
+  Package::PackageVector& vector = Package::packages ();
+
+  int i;
+  int j;
+
+  cout << "### Packages: ";
+  for (i = 0; i < vector.size (); i++)
+    {
+      Package& p = vector[i];
+      cout << p.get_name () << "[";
+      Use::UsePtrVector& uses = p.get_uses ();
+      for (j = 0; j < uses.size (); j++)
+	{
+	  Use* u = uses[j];
+	  cout << u << ",";
+	}
+
+      cout << "] ";
+    }
+  cout << endl;
+
+  {
+    static Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+    cout << "### Uses: ";
+    for (i = 0; i < uses.size (); i++)
+      {
+	Use* u = uses[i];
+	cout << "[" << u << "]" << u->get_package_name () << " ";
+      }
+  }
+
+  cout << endl;
+}
+
+Project* Use::get_project ()
+{    
+    Project* p;
+    cmt_string cmtpath = "";
+    cmt_string offset  = "";    
+    get_cmtpath_and_offset (cmtpath, offset);
+    p = Project::find_by_cmtpath (cmtpath);
+    return p;   
+}
Index: /CMT/v1r20/source/cmt_use.h
===================================================================
--- /CMT/v1r20/source/cmt_use.h	(revision 368)
+++ /CMT/v1r20/source/cmt_use.h	(revision 368)
@@ -0,0 +1,256 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// Modified by garonne@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_use_h__
+#define __cmt_use_h__
+
+#include "cmt_map.h"
+#include "cmt_include.h"
+#include "cmt_script.h"
+#include "cmt_pattern.h"
+#include "cmt_scope_section.h"
+
+class Package;
+class UseProjectAction;
+
+class Use
+{
+// Public class methods
+public:
+  typedef cmt_vector<Use> UseVector;
+  typedef cmt_vector<Use*> UsePtrVector;
+
+  static Use* action (const CmtSystem::cmt_string_vector& words, Use* use);
+  static Use* find (const cmt_string& package,
+                    const cmt_string& version = "",
+                    const cmt_string& path = "");
+  static int find_index (const cmt_string& package, 
+                         const cmt_string& version, 
+                         const cmt_string& path);
+  static void set_auto_imports_state (int use_index,
+                                      cmt_vector<bool>& auto_imports_states);
+  static Use* add (const cmt_string& path,
+                   const cmt_string& package,
+                   const cmt_string& version,
+                   const cmt_string& version_alias,
+                   const cmt_string& path_alias,
+                   const cmt_string& native_version,
+                   Use* context_use,
+                   State specified_auto_imports = Unspecified);
+  static void move (Use* use1);
+  static void reorder (Use* use1, Use* use2);
+  static void select_clients (const cmt_string& package,
+                              const cmt_string& version);
+  static void show_all (bool skip_discarded = false);
+  static void show_all (const cmt_string& prefix, bool skip_discarded = false);
+
+  static Use& current ();
+  static const Use& const_current ();
+
+  static UseVector& get_instances ();
+  static UsePtrVector& get_ordered_uses ();
+
+  static void clear_all ();
+  static void unselect_all ();
+  static void undiscard_all ();
+  static void fill_macro_all (cmt_string& buffer, const cmt_string& suffix);
+
+  static Use* create (const cmt_string& path,
+                      const cmt_string& package,
+                      const cmt_string& version,
+                      const cmt_string& version_alias,
+                      const cmt_string& path_alias,
+                      const cmt_string& n_version="");
+
+  void add_sub_use(Use* use) 
+  {
+      this->sub_uses.push_back (use);
+  }
+
+// Private class methods
+private:
+
+// Public instance methods
+public:
+  Use ();
+  Use (const cmt_string& new_package,
+       const cmt_string& new_version,
+       const cmt_string& new_path);
+  ~Use ();
+  void set (const cmt_string& new_package,
+            const cmt_string& new_version,
+            const cmt_string& new_path,
+            const cmt_string& new_version_alias = "",
+            const cmt_string& new_path_alias = "");
+  void author_action (const CmtSystem::cmt_string_vector& words);
+  void manager_action (const CmtSystem::cmt_string_vector& words);
+  bool move_to (const cmt_string& native_version="");
+  void discard ();
+  void undiscard ();
+  void apply_global_patterns ();
+  void set_include_path (const cmt_string& new_path);
+  void get_full_path (cmt_string& s) const;
+  cmt_string get_full_path () const;
+  void reduce_path (cmt_string& s) const;
+  void get_cmtpath_and_offset (cmt_string& cmtpath, cmt_string& offset) const;
+  bool get_strategy (const cmt_string& name) const;
+
+  void fill_includes_macro (cmt_string& buffer) const;
+  void fill_macro (cmt_string& buffer, const cmt_string& suffix) const;
+  void fill_standard_macros (cmt_string& buffer) const;
+  void build_library_links (const cmt_string& cmtinstallarea, 
+			    const cmt_string& tag, 
+			    const cmt_string& shlibsuffix, 
+			    const cmt_string& symlinkcmd) const;
+
+  bool get_all_clients (const cmt_string& to_name);
+
+  bool get_paths (Use* to, UsePtrVector& list);
+
+  bool located () const;
+
+  void change_path (const cmt_string& path);
+  void set_auto_imports (State new_state);
+  void set_native_version (bool state);
+  bool has_native_version () const;
+
+  Package* get_package () const;
+  const cmt_string& get_package_name () const;
+  void set_package_name (const cmt_string& name);
+
+  int get_index () const;
+
+  void show_cycles ();
+
+  void push_scope_section (ScopeType type);
+  void pop_scope_section ();
+  void close_scope_sections ();
+
+  ScopeType get_current_scope () const;
+
+  Project* get_project ();
+// Public attributes
+public:
+
+  cmt_string specified_version;  /* idem                            */
+  cmt_string specified_path;     /* idem                            */
+  cmt_string version_alias;
+  cmt_string path_alias;
+  cmt_string author;             /* idem                            */
+  cmt_string manager;            /* idem                            */
+
+  cmt_string path;               /* expanded path                   */
+  cmt_string version;            /* idem                            */
+  cmt_string real_path;
+  cmt_string native_version;     /* idem                            */
+  CmtDirStyle style;             /* May be cmt or mgr               */
+
+  cmt_string prefix;             /* upper case copy of package      */
+  bool done;                     /* true when requirements file has
+                                    already been read               */
+  bool discarded;                /* discarded by version strategy   */
+  bool selected;                 /* used for recursive access       */
+  bool m_located;
+  bool m_hidden;
+  ScopeType initial_scope;
+
+  UsePtrVector sub_uses;
+  cmt_vector<ScopeType> sub_use_scopes;
+  cmt_vector<State> sub_use_auto_imports;
+
+ int m_index;  // Position within the ordered list of uses
+  
+  State auto_imports;
+
+  Include::IncludeVector includes;
+  cmt_string include_path;
+  Script::ScriptVector scripts;
+  ApplyPattern::ApplyPatternVector apply_patterns;
+  IgnorePattern::IgnorePatternVector ignore_patterns;
+
+// Private methods
+private:
+  void clear ();
+  int reach_package (const cmt_string& current_path, const cmt_string& n_version="");
+  void select ();
+  void unselect ();
+  bool is_selected ();
+  bool is_client (const cmt_string& package,
+                  const cmt_string& version);
+  void show_sub_uses (const cmt_string& request, bool skip_discarded = false);
+  bool select_alternate ();
+  Use* get_selected_version ();
+  Use* set_selected_version (Use* selected_use);
+
+  static bool need_new (const cmt_string& path,
+                        const cmt_string& package,
+                        const cmt_string& version,
+                        const cmt_string& n_version,
+                        Use** old_use,
+			            Use* context_use);
+
+  bool get_all_clients (Use* to, 
+			const cmt_string& result, 
+			cmt_map <cmt_string, Use*>& all_clients, 
+			cmt_map <cmt_string, Use*>& all_clients_ok);
+
+// Private attributes
+private:
+
+  Package* m_package;
+  //cmt_string m_package_name; /* directly read from requirements */
+
+  bool m_has_native_version;
+
+
+  cmt_vector<ScopeSection> scope_sections;
+
+  CmtSystem::cmt_string_vector alternate_versions;
+  CmtSystem::cmt_string_vector alternate_paths;
+
+  CmtSystem::cmt_string_vector requests;
+
+ 
+
+  friend class UseProjectAction;
+};
+
+class Package
+{
+public:
+
+  typedef cmt_map<cmt_string, Package> PackageMap;
+  typedef cmt_vector<Package> PackageVector;
+
+  static Package* find (const cmt_string& name);
+  static Package* add (const cmt_string& name);
+
+  static PackageVector& packages ();
+  static PackageMap& package_map ();
+
+  static void clear_all ();
+
+public:
+
+  Package ();
+  ~Package ();
+
+  const cmt_string& get_name () const;
+  void add_use (Use* use);
+  void remove_use (Use* use);
+  Use::UsePtrVector& get_uses ();
+
+  bool is_cmt ();
+
+private:
+  bool m_is_cmt;
+
+  cmt_string m_name;
+  Use::UsePtrVector m_uses;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_vector.h
===================================================================
--- /CMT/v1r20/source/cmt_vector.h	(revision 368)
+++ /CMT/v1r20/source/cmt_vector.h	(revision 368)
@@ -0,0 +1,283 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_vector_h__
+#define __cmt_vector_h__
+
+#include <stdlib.h>
+
+template <class T> class cmt_vector
+{
+public:
+  typedef T   element_type;
+  typedef T*  element_ptr;
+  typedef T** frame_ptr;
+
+  cmt_vector ()
+    {
+      _data = 0;
+      _frames = 0;
+      _size = 0;
+    }
+
+  cmt_vector (const cmt_vector& other)
+    {
+      _data = 0;
+      _frames = 0;
+      _size = 0;
+
+      cmt_vector<T>& me = *this;
+
+      extend (other._size);
+      for (int i = 0; i < _size; i++)
+        {
+          me.element_at (i) = other.element_at (i);
+        }
+    }
+
+  cmt_vector (int n)
+    {
+      _data = 0;
+      _frames = 0;
+      _size = 0;
+
+      extend (n);
+    }
+
+  ~cmt_vector ()
+    {
+      if (_data != 0)
+        {
+          for (int i = 0; i < _frames; i++)
+            {
+              delete[] _data[i];
+              _data[i] = 0;
+            }
+#ifdef CMT_USE_NEW_DELETE
+          delete[] _data;
+#else
+          free (_data);
+#endif
+        }
+      _data = 0;
+      _frames = 0;
+      _size = 0;
+    }
+
+  void push_back (const T& object)
+    {
+      extend (1);
+      element_at (_size - 1) = object;
+    }
+
+  T& add ()
+    {
+      resize (size() + 1);
+      return (back ());
+    }
+
+  void pop_back ()
+    {
+      if (_size > 0) _size--;
+    }
+
+  void erase (int index)
+    {
+      if ((_data == 0) ||
+          (index < 0) ||
+          (index >= _size))
+        {
+          return;
+        }
+
+      for (int i = index; i < (_size - 1); i++)
+        {
+          element_at (i) = element_at (i + 1);
+        }
+
+      _size--;
+    }
+
+  cmt_vector& operator = (const cmt_vector& other)
+    {
+      clear ();
+
+      cmt_vector<T>& me = *this;
+
+      extend (other._size);
+      for (int i = 0; i < _size; i++)
+        {
+          element_at (i) = other.element_at (i);
+        }
+
+      return (me);
+    }
+
+  T& operator [] (int index) const
+    {
+      if ((_data == 0) ||
+          (index < 0) ||
+          (index >= _size))
+        {
+          static T object;
+          return (object);
+        }
+      else
+        {
+          return (element_at (index));
+        }
+    }
+
+  T& operator [] (int index)
+    {
+      if ((_data == 0) ||
+          (index < 0) ||
+          (index >= _size))
+        {
+          static T object;
+          return (object);
+        }
+      else
+        {
+          return (element_at (index));
+        }
+    }
+
+  T& back () const
+    {
+      if ((_data == 0) ||
+          (_size == 0))
+        {
+          static T object;
+          return (object);
+        }
+      else
+        {
+          return (element_at (_size - 1));
+        }
+    }
+
+  T& back ()
+    {
+      if ((_data == 0) ||
+          (_size == 0))
+        {
+          static T object;
+          return (object);
+        }
+      else
+        {
+          return (element_at (_size - 1));
+        }
+    }
+
+  void resize (int new_size)
+    {
+      if (new_size < 0) return;
+
+      extend (new_size - _size);
+      _size = new_size;
+    }
+
+  int size () const
+    {
+      return (_size);
+    }
+
+  void clear ()
+    {
+      _size = 0;
+    }
+
+  frame_ptr get_frame () const
+      {
+        return (_data);
+      }
+
+  int get_frame_number () const
+      {
+        return (_frames);
+      }
+
+  int get_frame_size () const
+      {
+        return (frame_size);
+      }
+
+private:
+
+  enum {frame_size = 4};
+
+  T& element_at (int index)
+    {
+      int frame = index / frame_size;
+      return (_data[frame][index % frame_size]);
+    }
+
+  T& element_at (int index) const
+    {
+      int frame = index / frame_size;
+      return (_data[frame][index % frame_size]);
+    }
+
+  int frames (int n)
+    {
+      return ((n == 0) ? 0 : ((n - 1) / frame_size) + 1);
+    }
+
+  void extend (int n)
+    {
+      if (n <= 0) return;
+
+      _size += n;
+
+      int f = frames (_size);
+      if (f > _frames)
+        {
+          if (_data == 0)
+            {
+
+#ifdef CMT_USE_NEW_DELETE
+              _data = new element_ptr [f];
+#else
+              _data = (frame_ptr) malloc (f * sizeof (element_ptr));
+#endif
+
+            }
+          else
+            {
+
+#ifdef CMT_USE_NEW_DELETE
+              frame_ptr new_data;
+
+              new_data = new element_ptr [f];
+              for (int i = 0; i < _frames; i++)
+                {
+                  new_data[i] = _data[i];
+                }
+              delete[] _data;
+              _data = new_data;
+#else
+              _data = (frame_ptr) realloc (_data, f * sizeof (element_ptr));
+#endif
+
+            }
+
+          for (int i = _frames; i < f; i++)
+            {
+              _data[i] = new T[frame_size];
+            }
+
+          _frames = f;
+        }
+    }
+
+  frame_ptr _data;
+  int _frames;
+  int _size;
+};
+
+#endif
Index: /CMT/v1r20/source/cmt_vector_iterator.h
===================================================================
--- /CMT/v1r20/source/cmt_vector_iterator.h	(revision 368)
+++ /CMT/v1r20/source/cmt_vector_iterator.h	(revision 368)
@@ -0,0 +1,84 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+class iterator
+{
+  public:
+  iterator ()
+      {
+        _index = 0;
+        _vector = 0;
+      }
+
+  iterator (cmt_vector& vector)
+      {
+        _index = 0;
+        _vector = &vector;
+      }
+
+  iterator (const iterator& other)
+      {
+        _index = other._index;
+        _vector = other._vector;
+      }
+
+  iterator& operator = (const iterator& other)
+      {
+        _index = other._index;
+        _vector = other._vector;
+
+        return (*this);
+      }
+
+  bool operator == (const iterator& other)
+      {
+        if (_vector != other._vector) return (false);
+        if (_index != other._index) return (false);
+
+        return (true);
+      }
+
+  iterator& operator ++ ()
+      {
+        if (_vector != 0)
+          {
+            _index++;
+          }
+
+        return (*this);
+      };
+
+  iterator& operator -- ()
+      {
+        return (*this);
+      };
+
+  int operator - (const iterator* other)
+      {
+        return (0);
+      };
+
+  iterator operator + (int offset)
+      {
+        iterator it = *this;
+        return (it);
+      };
+
+  iterator operator - (int offset)
+      {
+        iterator it = *this;
+        return (it);
+      };
+
+  T& operator * ()
+      {
+        return ();
+      };
+
+  private:
+  int _index;
+  cmt_vector* _vector;
+};
Index: /CMT/v1r20/source/cmt_version.h
===================================================================
--- /CMT/v1r20/source/cmt_version.h	(revision 368)
+++ /CMT/v1r20/source/cmt_version.h	(revision 368)
@@ -0,0 +1,12 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __cmt_version_h__
+#define __cmt_version_h__
+
+#define CMTVERSION "HEAD"
+
+#endif
Index: /CMT/v1r20/source/install.cxx
===================================================================
--- /CMT/v1r20/source/install.cxx	(revision 368)
+++ /CMT/v1r20/source/install.cxx	(revision 368)
@@ -0,0 +1,498 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+
+//---------------------------------------------------------------------
+#include <windows.h>   // required for all Windows applications
+#include "install_resource.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <io.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "install_utils.h"
+#include "cmt_system.h"
+//---------------------------------------------------------------------
+
+//------------------------------------------------------
+static cmt_string dummy;
+//------------------------------------------------------
+
+//---------------------------------------------------------------------
+//
+//    Class definitions
+//
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+class Install;
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+class Install
+{
+public:
+  static Install& instance ();
+  BOOL initialize (HINSTANCE instance,
+                   HINSTANCE previous_instance, 
+                   int show_mode);
+  BOOL run ();
+	
+  const char* m_application_name;
+  const char* m_title;
+	
+  HINSTANCE m_instance;
+  HWND m_window;
+	
+  HWND m_dialog;
+
+private:
+	
+  static LRESULT CALLBACK process_messages (HWND window,
+                                            UINT message_type,
+                                            WPARAM parameter1,
+                                            LPARAM parameter2);
+  static LRESULT CALLBACK handle_dialog (HWND dialog,
+                                         UINT message_type,
+                                         WPARAM parameter1,
+                                         LPARAM parameter2);
+	
+  Install ();
+  void init (HWND window);
+  void install ();
+  void uninstall ();
+
+  HANDLE* m_objects;
+  int m_object_count;
+
+  WEdit m_root;
+  WEdit m_version;
+  WEdit m_config;
+  WEdit m_site;
+  WList m_path;
+};
+//---------------------------------------------------------------------
+
+
+
+//---------------------------------------------------------------------
+int APIENTRY WinMain (HINSTANCE instance,
+                      HINSTANCE previous_instance,
+                      LPSTR command_line,
+                      int show_mode)
+  //---------------------------------------------------------------------
+{
+  Install& install = Install::instance ();
+	
+  install.initialize (instance, previous_instance, show_mode);
+	
+  return install.run ();
+	
+  UNREFERENCED_PARAMETER (command_line);
+  return (0);
+}
+
+
+
+//---------------------------------------------------------------------
+//
+//    Class implementations
+//
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+Install& Install::instance ()
+{
+  static Install the_instance;
+  return (the_instance);
+}
+
+BOOL Install::initialize (HINSTANCE instance,
+                          HINSTANCE previous_instance,
+                          int show_mode)
+{
+  WNDCLASS  window_class;
+	
+  // Fill in window class structure with parameters that describe the
+  // main window.
+	
+  if (!previous_instance) 
+    {
+      window_class.style         = CS_OWNDC;
+      window_class.lpfnWndProc   = (WNDPROC) process_messages;
+      window_class.cbClsExtra    = 0;
+      window_class.cbWndExtra    = 0;
+      window_class.hInstance     = instance;
+      window_class.hIcon         = LoadIcon (instance, m_application_name);
+      window_class.hCursor       = LoadCursor (NULL, IDC_ARROW);
+      window_class.hbrBackground = (HBRUSH) (COLOR_MENU+1);
+      window_class.lpszMenuName  = "IDR_MENU";
+      window_class.lpszClassName = m_application_name;
+		
+      if (!RegisterClass (&window_class)) return (FALSE);
+    }
+	
+  m_instance = instance;
+	
+  m_window = CreateWindow (m_application_name,
+                           m_title,
+                           WS_OVERLAPPEDWINDOW,
+                           CW_USEDEFAULT, 0, 440, 590,
+                           NULL,
+                           NULL,
+                           m_instance,
+                           NULL);
+	
+  // If window could not be created, return "failure"
+	
+  if (!m_window)
+    {
+      return (FALSE);
+    }
+	
+  ShowWindow (m_window, show_mode);
+  UpdateWindow (m_window);
+	
+  return (TRUE);
+}
+
+BOOL Install::run ()
+{
+  MSG message;
+  DWORD result;
+  HANDLE objects[1];
+  int count = 0;
+	
+  while (TRUE)
+    {
+      result = MsgWaitForMultipleObjects (count, objects, FALSE, 
+                                          INFINITE, QS_ALLINPUT);
+      if (result == (WAIT_OBJECT_0 + count))
+        {
+          while (PeekMessage (&message, NULL, 0, 0, PM_REMOVE))
+            {
+              if ((m_dialog == NULL) ||
+                  !IsDialogMessage (m_dialog, &message))
+                {
+                  if (!TranslateAccelerator (message.hwnd, NULL, &message))
+                    {
+                      if (message.message == WM_QUIT) return (0);
+						
+                      TranslateMessage (&message);
+                      DispatchMessage (&message);
+                    }
+                }
+            }
+        }
+      else
+        {
+          // For future async objects
+        }
+    }
+	
+  return (message.wParam);
+}
+
+Install::Install () : m_application_name ("install"), m_title ("install")
+{
+  m_dialog = 0;
+  m_objects = 0;
+  m_object_count = 0;
+}
+
+void Install::init (HWND window)
+{
+  m_window = window;
+
+  m_dialog = CreateDialog (m_instance, 
+                           MAKEINTRESOURCE(IDD_DIALOG1), 
+                           m_window,
+                           (DLGPROC) handle_dialog);
+
+  m_root.init (m_dialog, IDC_ROOT);
+  m_version.init (m_dialog, IDC_VERSION);
+  m_config.init (m_dialog, IDC_CONFIG);
+  m_site.init (m_dialog, IDC_SITE);
+  m_path.init (m_dialog, IDC_PATH);
+
+  cmt_string root = CmtSystem::pwd ();
+  cmt_string v;
+  cmt_string p;
+
+  for (;;)
+    {
+      CmtSystem::basename (root, v);
+      CmtSystem::dirname (root, root);
+      CmtSystem::basename (root, p);
+      if ((p == "Cmt") || (p == "CMT") || (p == "cmt")) break;
+    }
+
+  CmtSystem::dirname (root, root);
+
+  m_root.set (root);
+  m_version.set (v);
+  m_config.set ("VisualC");
+  m_site.set (CmtSystem::get_cmt_site ());
+	
+  CmtSystem::cmt_string_vector paths;
+  CmtSystem::cmt_string_vector filtered_paths;
+  CmtSystem::cmt_string_vector path_sources;
+
+  CmtSystem::get_cmt_paths (paths, path_sources);
+	
+  for (int i = 0; i < paths.size (); i++)
+    {
+      const cmt_string& s = paths[i];
+      if (s == root) continue;
+      cmt_string& f = filtered_paths.add ();
+      f = s;
+    }
+
+  m_path.set (filtered_paths);
+}
+
+void Install::install ()
+{
+  cmt_string root    = m_root.get ();
+  cmt_string version = m_version.get ();
+  cmt_string config  = m_config.get ();
+  cmt_string site    = m_site.get ();
+  CmtSystem::cmt_string_vector paths;
+  m_path.get (paths);
+	
+  LONG status;
+  HKEY key = 0;
+  HKEY subkey = 0;
+  DWORD disposition;
+	
+  status = RegCreateKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 0, "", 
+                           REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &disposition);
+  if (status == ERROR_SUCCESS)
+    {
+      DWORD length;
+		
+      length = root.size ();
+      status = RegSetValueEx (key, "root", 0, REG_SZ, (LPBYTE) root.c_str (), length);
+		
+      length = version.size ();
+      status = RegSetValueEx (key, "version", 0, REG_SZ, (LPBYTE) version.c_str (), length);
+		
+      length = config.size ();
+      status = RegSetValueEx (key, "config", 0, REG_SZ, (LPBYTE) config.c_str (), length);
+		
+      length = site.size ();
+      status = RegSetValueEx (key, "site", 0, REG_SZ, (LPBYTE) site.c_str (), length);
+		
+      status = RegDeleteKey (key, "path");
+		
+      status = RegCreateKeyEx (key, "path", 0, "", 
+                               REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &subkey, &disposition);
+      if (status == ERROR_SUCCESS)
+        {
+          DWORD index = 0;
+          char name[256];
+          char temp[256];
+			
+          for (;;)
+            {
+              DWORD name_length = sizeof (name) - 1;
+              DWORD length = sizeof (temp) - 1;
+              DWORD type;
+              status = RegEnumValue (subkey, index,
+                                     name, &name_length, 0, &type,
+                                     (LPBYTE) temp, &length);
+              if ((status == ERROR_SUCCESS) ||
+                  (status == 234))
+                {
+                  RegDeleteValue (subkey, name);
+                }
+				
+              if (status == 259)
+                {
+                  break;
+                }
+				
+              index++;
+            }
+
+          for (int i = 0; i < paths.size (); i++)
+            {
+              const cmt_string& s = paths[i];
+
+              sprintf (temp,  "#%d", i);
+				
+              length = s.size ();
+              status = RegSetValueEx (subkey, temp, 0, REG_SZ, (LPBYTE) s.c_str (), length);
+            }
+			
+          status = RegCloseKey (subkey);
+        }
+		
+      status = RegCloseKey (key);
+    }
+
+  cmt_string mgr = root;
+  mgr += "\\CMT\\";
+  mgr += version;
+  mgr += "\\mgr";
+
+  CmtSystem::cd (mgr);
+  CmtSystem::execute ("INSTALL");
+}
+
+void Install::uninstall ()
+{
+  LONG status;
+  HKEY key = 0;
+  HKEY subkey = 0;
+	
+  status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software\\CMT", 0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      status = RegDeleteKey (key, "root");
+      status = RegDeleteKey (key, "version");
+      status = RegDeleteKey (key, "config");
+      status = RegDeleteKey (key, "site");
+      status = RegDeleteKey (key, "path");
+      status = RegCloseKey (key);
+    }
+
+  status = RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Software", 0, KEY_READ, &key);
+  if (status == ERROR_SUCCESS)
+    {
+      status = RegDeleteKey (key, "CMT");
+      status = RegCloseKey (key);
+    }
+}
+
+LRESULT CALLBACK Install::process_messages (HWND window,
+                                            UINT message_type,
+                                            WPARAM parameter1,
+                                            LPARAM parameter2)
+{
+  Install& install = Install::instance ();
+	
+  int menu_item;
+  static HPEN blue_pen;
+  static HPEN red_pen;
+	
+  SetLastError (0);
+	
+  switch (message_type) 
+    {
+    case WM_CREATE:
+      {
+        HDC context;
+        LOGFONT log_font;
+        HFONT font;
+				
+        context = GetDC (window);
+				
+        memset (&log_font, 0, sizeof(LOGFONT));
+        log_font.lfHeight = -72;
+        strcpy ((LPSTR) &(log_font.lfFaceName), "arial");
+				
+        font = CreateFontIndirect (&log_font); 
+        SelectObject (context, font);
+				
+        blue_pen = CreatePen (PS_SOLID, 1, RGB(0,0,255));
+        red_pen  = CreatePen (PS_SOLID, 1, RGB(255,0,0));
+      }
+			
+      install.init (window);
+			
+      break;
+		
+    case WM_COMMAND:
+      menu_item = LOWORD (parameter1);
+			
+      switch (menu_item) 
+        {
+        case ID_FILE_QUIT:
+          DestroyWindow (window);
+          break;
+        default:
+          return (DefWindowProc (window, message_type, 
+                                 parameter1, parameter2));
+        }
+      break;
+    case WM_DESTROY:
+      PostQuitMessage (0);
+      break;
+    default:
+      return (DefWindowProc (window, message_type, parameter1, parameter2));
+    }
+  return (0);
+}
+  
+LRESULT CALLBACK Install::handle_dialog (HWND dialog,
+                                         UINT message_type,
+                                         WPARAM parameter1,
+                                         LPARAM parameter2)
+{
+  Install& install = Install::instance ();
+	
+  int menu_item;
+	
+  switch (message_type) 
+    {
+    case WM_CREATE:
+      break;
+    case WM_SETFONT:
+      break;
+    case WM_INITDIALOG:
+      {
+        int x = 0;
+        int y = 0;
+        int width;
+        int height;
+        RECT rectangle;
+				
+        GetWindowRect (dialog, &rectangle);
+				
+        width = rectangle.right - rectangle.left;
+        height = rectangle.bottom - rectangle.top;
+				
+        MoveWindow (install.m_window, x, y, width, height, TRUE);
+      }
+			
+      break;
+    case WM_COMMAND:
+      menu_item = LOWORD (parameter1);
+			
+      switch (menu_item)
+        {
+        case IDC_INSTALL:
+          install.install ();
+          break;
+        case IDC_UNINSTALL:
+          install.uninstall ();
+          break;
+        case IDC_EDITPATH:
+          {
+            ListEditor editor (install.m_path);
+            editor.run (install.m_instance, install.m_dialog);
+          }
+          break;
+        case IDC_EXIT:
+          DestroyWindow (install.m_window);
+          break;
+        }
+			
+      break;
+    case WM_ACTIVATE:
+      menu_item = LOWORD (parameter1);
+      break;
+    default:
+      return (FALSE);
+    }
+  return (TRUE);
+}
+//---------------------------------------------------------------------
+
Index: /CMT/v1r20/source/install_resource.h
===================================================================
--- /CMT/v1r20/source/install_resource.h	(revision 368)
+++ /CMT/v1r20/source/install_resource.h	(revision 368)
@@ -0,0 +1,38 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by C:\dev\CMT\v1r6\src\setup.rc
+//
+#define IDC_UNINSTALL                   3
+#define IDD_DIALOG1                     102
+#define IDD_TEXTEDIT                    103
+#define IDD_LISTEDIT                    104
+#define IDC_ROOT                        1001
+#define IDC_VERSION                     1002
+#define IDC_CONFIG                      1003
+#define IDC_SITE                        1004
+#define IDC_PATH                        1009
+#define IDC_EDITPATH                    1010
+#define IDC_INSTALL                     1011
+#define IDC_EXIT                        1013
+#define IDLE_LIST                       3001
+#define IDLE_ADD                        3002
+#define IDLE_REMOVE                     3003
+#define IDTE_TEXT                       4001
+#define ID_FILE_QUIT                    40001
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        111
+#define _APS_NEXT_COMMAND_VALUE         40006
+#define _APS_NEXT_CONTROL_VALUE         1014
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
Index: /CMT/v1r20/source/install_utils.cxx
===================================================================
--- /CMT/v1r20/source/install_utils.cxx	(revision 368)
+++ /CMT/v1r20/source/install_utils.cxx	(revision 368)
@@ -0,0 +1,842 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+//---------------------------------------------------------------------
+#include "install_utils.h"
+#include <windowsx.h>
+#include "install_resource.h"
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+WWindow::WWindow ()
+{
+  _window = NULL;
+}
+
+void WWindow::enable ()
+{
+  EnableWindow (_window, TRUE);
+}
+
+void WWindow::disable ()
+{
+  EnableWindow (_window, FALSE);
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+WEdit::WEdit ()
+{
+  _edit = NULL;
+}
+
+WEdit::WEdit (HWND edit)
+{
+  _edit = edit;
+  _window = _edit;
+}
+
+WEdit::WEdit (HWND container, int id)
+{
+  _edit = GetDlgItem (container, id);
+  _window = _edit;
+}
+
+void WEdit::init (HWND container, int id)
+{
+  _edit = GetDlgItem (container, id);
+  _window = _edit;
+}
+
+WEdit& WEdit::operator = (HWND edit)
+{
+  _edit = edit;
+  _window = _edit;
+  return (*this);
+}
+
+void WEdit::set (const char* text)
+{
+  int status = SendMessage (_edit, WM_SETTEXT, (WPARAM) 0, (LPARAM) text);
+}
+
+void WEdit::set (const cmt_string& text)
+{
+  set (text.c_str ());
+}
+
+void WEdit::clear ()
+{
+  set ("");
+}
+
+cmt_string WEdit::get () const
+{
+  int size = SendMessage (_edit, WM_GETTEXTLENGTH, (WPARAM) 0, (LPARAM) 0);
+
+  cmt_string text (size);
+
+  SendMessage (_edit, WM_GETTEXT, (WPARAM) size + 1, (LPARAM) text.c_str ());
+
+  return (text);
+}
+
+void WEdit::copy (const WEdit& other)
+{
+  clear ();
+  set (other.get ());
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+WList::WList ()
+{
+  _list = NULL;
+  _selected_index = -1;
+  _width = 0;
+}
+
+WList::WList (HWND list)
+{
+  _list = list;
+  _window = _list;
+  _width = get_width ();
+  set_extent ();
+  get_selected_index ();
+}
+
+WList::WList (HWND container, int id)
+{
+  _list = GetDlgItem (container, id);
+  _window = _list;
+  _width = get_width ();
+  set_extent ();
+  get_selected_index ();
+}
+
+void WList::init (HWND container, int id)
+{
+  _list = GetDlgItem (container, id);
+  _window = _list;
+  _width = get_width ();
+  set_extent ();
+  get_selected_index ();
+}
+
+WList& WList::operator = (HWND list)
+{
+  _list = list;
+  _window = _list;
+  _width = get_width ();
+  set_extent ();
+  get_selected_index ();
+  return (*this);
+}
+
+void WList::append (const char* text)
+{
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) -1, (LPARAM) text);
+  int w = strlen (text);
+  if (w > _width) 
+  {
+    _width = w;
+    set_extent ();
+  }
+}
+
+void WList::append (const cmt_string& text)
+{
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) -1, (LPARAM) text.c_str ());
+  int w = text.size ();
+  if (w > _width) 
+  {
+    _width = w;
+    set_extent ();
+  }
+}
+
+void WList::insert (int index, const cmt_string& text)
+{
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) index, (LPARAM) text.c_str ());
+  int w = text.size ();
+  if (w > _width) 
+  {
+    _width = w;
+    set_extent ();
+  }
+}
+
+void WList::modify (int index, const cmt_string& text)
+{
+  SendMessage (_list, LB_DELETESTRING, (WPARAM) index, (LPARAM) 0);
+  SendMessage (_list, LB_INSERTSTRING, (WPARAM) index, (LPARAM) text.c_str ());
+
+  _width = get_width ();
+  set_extent ();
+}
+
+void WList::delete_item (int index)
+{
+  SendMessage (_list, LB_DELETESTRING, (WPARAM) index, (LPARAM) 0);
+
+  _width = get_width ();
+  set_extent ();
+}
+
+void WList::clear ()
+{
+  SendMessage (_list, LB_RESETCONTENT, (WPARAM) 0, (LPARAM) 0);
+  _selected_index = -1;
+  _width = 0;
+  set_extent ();
+}
+
+void WList::cancel_selection ()
+{
+  SendMessage (_list, LB_SETCURSEL, (WPARAM) -1, (LPARAM) 0);
+  _selected_index = -1;
+}
+
+int WList::get_selected_index ()
+{
+  int index;
+                
+  index = SendMessage (_list, LB_GETCURSEL, (WPARAM) 0, (LPARAM) 0);
+  _selected_index = index;
+
+  return (index);
+}
+
+void WList::set_selected_index (int index)
+{
+  SendMessage (_list, LB_SETCURSEL, (WPARAM) index, (LPARAM) 0);
+  _selected_index = index;
+}
+
+cmt_string WList::get_selected ()
+{
+  int index = get_selected_index ();
+
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0);
+
+  cmt_string text (size + 1);
+
+  SendMessage (_list, LB_GETTEXT, (WPARAM) index, (LPARAM) text.c_str ());
+
+  return (text);
+}
+
+int WList::get_item_count () const
+{
+  int item;
+        
+  item = SendMessage (_list, LB_GETCOUNT, (WPARAM) 0, (LPARAM) 0);
+
+  return (item);
+}
+
+cmt_string WList::get_item (int index) const
+{
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0);
+
+  cmt_string text (size + 1);
+        
+  SendMessage (_list, LB_GETTEXT, (WPARAM) index, (LPARAM) text.c_str ());
+
+  return (text);
+}
+
+void WList::get_item (int index, cmt_string& text) const
+{
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0);
+
+  static cmt_string temp;
+  temp.resize (size);
+	  
+  SendMessage (_list, LB_GETTEXT, (WPARAM) index, (LPARAM) temp.c_str ());
+
+  text = temp;
+}
+
+int WList::get_item_length (int index) const
+{
+  int size = SendMessage (_list, LB_GETTEXTLEN, (WPARAM) index, (LPARAM) 0);
+
+  return (size);
+}
+
+void WList::copy (const WList& other)
+{
+  int items;
+  int i;
+
+  clear ();
+
+  items = other.get_item_count ();
+  for (i = 0; i < items; i++)
+    {
+      append (other.get_item (i));
+    }
+}
+
+void WList::set (const CmtSystem::cmt_string_vector& v, int first)
+{
+  int i;
+
+  clear ();
+
+  for (i = first; i < v.size (); i++)
+    {
+      append (v[i]);
+    }
+}
+
+void WList::set (const cmt_string& file_name)
+{
+  clear ();
+
+  cmt_string text;
+  cmt_string line;
+  int pos;
+  int max_pos;
+
+  text.read (file_name);
+
+  pos = 0;
+  max_pos = text.size ();
+
+  for (pos = 0; pos < max_pos;)
+    {
+      int cr = text.find (pos, "\r\n");
+      int nl = text.find (pos, '\n'); 
+      int first = nl;
+      int length = 1;
+
+      if (cr != cmt_string::npos)
+        {
+          if (nl == cmt_string::npos)
+            {
+              first = cr;
+              length = 2;
+            }
+          else
+            {
+              first = (nl < cr) ? nl : cr;
+              length = (nl < cr) ? 1 : 2;
+            }
+        }
+
+      if (first == cmt_string::npos)
+        {
+          text.substr (pos, line);
+          pos = max_pos;
+        }
+      else if (first > pos)
+        {
+          text.substr (pos, first - pos, line);
+          pos = first + length;
+        }
+      else
+        {
+          line = "";
+          pos += length;
+        }
+
+      append (line);
+    }
+}
+
+void WList::get (CmtSystem::cmt_string_vector& v) const
+{
+  int count = get_item_count ();
+  int i;
+
+  v.clear ();
+
+  for (i = 0; i < count; i++)
+    {
+      v.push_back (get_item (i));
+    }
+}
+
+void WList::get (cmt_string& s) const
+{
+  int count = get_item_count ();
+  int i;
+
+  s = "";
+
+  for (i = 0; i < count; i++)
+    {
+      if (i > 0) s += '\n';
+      s += get_item (i);
+    }
+}
+
+void WList::set_extent ()
+{
+  int width = get_extent ();
+  ListBox_SetHorizontalExtent (_list, width);
+}
+
+int WList::get_width () const
+{
+  if (_list == 0) return (0);
+
+  int count = get_item_count ();
+  int w = 0;
+
+  int i;
+  for (i = 0; i < count; i++)
+  {
+	  int length = get_item_length (i);
+	  if (length > w) w = length;
+  }
+
+  return (w);
+}
+
+int WList::get_extent () const
+{
+  if (_width == 0) return (0);
+
+  cmt_string text (_width + 1);
+
+  HDC context = GetDC (_list);
+  int saved_context = SaveDC (context);
+  HFONT font = GetWindowFont (_list);
+  if (font != NULL) SelectFont (context, font);
+
+  int w = 0;
+
+  int count = get_item_count ();
+
+  int i;
+  for (i = 0; i < count; i++)
+  {
+	  SIZE size;
+
+	  get_item (i, text);
+	  GetTextExtentPoint32 (context, text.c_str (), text.size (), &size);
+	  if (size.cx > w) w = size.cx;
+  }
+
+  RestoreDC (context, saved_context);
+  ReleaseDC (_list, context);
+
+  w += GetSystemMetrics (SM_CXVSCROLL);
+
+  return (w);
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+mysb::mysb (WList& list) : _list (list)
+{
+    //list_clear (list);
+  _buf = 0;
+#ifdef OLD_HEADERS
+  _old = cout.rdbuf ();
+  cout = this;
+#else
+  _old = cout.rdbuf (this);
+#endif
+}
+
+mysb::~mysb ()
+{
+  if (_buf != 0)
+  {
+    //delete _buf;
+	_buf = 0;
+  }
+
+#ifdef OLD_HEADERS
+  cout = _old;
+#else
+  cout.rdbuf (_old);
+#endif
+}
+
+int_type mysb::overflow (int_type c)
+{
+  if (_buf == 0)
+  {
+    _buf = new cmt_string;
+  }
+
+  cmt_string& buf = *_buf;
+
+  if (c == '\n')
+    {
+      _list.append (buf);
+      buf = "";
+    }
+  else
+    {
+      buf += c;
+    }
+  return (c);
+}
+        
+int mysb::underflow ()
+{
+  return (EOF);
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+WDialog::WDialog ()
+{
+}
+
+void WDialog::action (UINT message_type,
+                      WPARAM parameter1,
+                      LPARAM parameter2)
+{
+}
+
+void WDialog::init_action ()
+{
+}
+
+void WDialog::menu_action (int menu_item,
+                           WPARAM parameter1,
+                           LPARAM parameter2)
+{
+  switch (menu_item) 
+    {
+      case IDOK:
+        break;
+      case IDCANCEL:
+        break;
+      default:
+        break;
+    }
+}
+
+int WDialog::run (HINSTANCE instance, HWND father, int id)
+{
+  return (DialogBoxParam (instance, 
+                          MAKEINTRESOURCE(id), 
+                          father,
+                          (DLGPROC) proc,
+                          (LPARAM) this));
+}
+
+LRESULT CALLBACK WDialog::proc (HWND dialog,
+                                UINT message_type,
+                                WPARAM parameter1,
+                                LPARAM parameter2)
+{
+  static cmt_vector <WDialog*> objects;
+  WDialog* object = NULL;
+  int menu_item;
+
+  switch (message_type) 
+    {
+      case WM_CREATE:
+        break;
+      case WM_SETFONT:
+        break;
+      case WM_INITDIALOG:
+        object = (WDialog*) parameter2;
+        if (object != NULL)
+          {
+            objects.push_back (object);
+
+            object->_dialog = dialog;
+            object->init_action ();
+          }
+        break;
+      case WM_COMMAND:
+        menu_item = LOWORD (parameter1);
+
+        if (objects.size () > 0)
+          {
+            object = objects.back ();
+          }
+
+        if (object != NULL)
+          {
+            object->menu_action (menu_item, parameter1, parameter2);
+          }
+
+        switch (menu_item) 
+          {
+            case IDOK:
+              EndDialog (dialog, IDOK);
+              objects.pop_back ();
+              break;
+            case IDCANCEL:
+              EndDialog (dialog, IDCANCEL);
+              objects.pop_back ();
+              break;
+            default:
+              break;
+          }
+        break;
+      default:
+        if (objects.size () > 0)
+          {
+            object = objects.back ();
+          }
+
+        if (object != NULL)
+          {
+            object->action (message_type, parameter1, parameter2);
+          }
+        return (FALSE);
+    }
+  return (TRUE);
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+TextEditor::TextEditor (cmt_string& ref) : _ref (ref)
+{
+}
+
+int TextEditor::run (HINSTANCE instance, HWND father)
+{
+  return (WDialog::run (instance, father, IDD_TEXTEDIT));
+}
+
+void TextEditor::action (UINT message_type,
+                         WPARAM parameter1,
+                         LPARAM parameter2)
+{
+}
+
+void TextEditor::init_action ()
+{
+  _edit = GetDlgItem (_dialog, IDTE_TEXT);
+  _edit.set (_ref);
+}
+
+void TextEditor::menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2)
+{
+  switch (menu_item) 
+    {
+      case IDOK:
+        _ref = _edit.get ();
+        break;
+      case IDCANCEL:
+        break;
+      default:
+        break;
+    }
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+ListEditor::ListEditor (WList& list) : _ref_list (list)
+{
+}
+
+int ListEditor::run (HINSTANCE instance, HWND father)
+{
+  _instance = instance;
+  return (WDialog::run (instance, father, IDD_LISTEDIT));
+}
+
+void ListEditor::action (UINT message_type,
+                         WPARAM parameter1,
+                         LPARAM parameter2)
+{
+}
+
+void ListEditor::set_position (int index)
+{
+  _list.set_selected_index (index);
+  _selected_index = index;
+  _last_index = index;
+}
+
+void ListEditor::init_action ()
+{
+  _list.init (_dialog, IDLE_LIST);
+  _list.copy (_ref_list);
+  _ref_selected_index = _ref_list.get_selected_index ();
+  _list.set_selected_index (_ref_selected_index);
+  _selected_index = _ref_selected_index;
+  _last_index = _ref_selected_index;
+}
+
+void ListEditor::menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2)
+{
+  int index = _list.get_selected_index ();
+
+  switch (menu_item) 
+    {
+      case IDOK:
+        _ref_list.copy (_list);
+        _ref_list.set_selected_index (_ref_selected_index);
+        break;
+      case IDCANCEL:
+        break;
+      case IDLE_ADD:
+      {
+        cmt_string s;
+        TextEditor editor (s);
+
+        if (editor.run (_instance, _dialog) == IDOK)
+          {
+            _list.insert (index, s);
+          }
+      }
+      break;
+      case IDLE_REMOVE:
+      {
+        if (index != -1)
+          {
+            _list.delete_item (index);
+          }
+      }
+      break;
+      case IDLE_LIST:
+     {
+        switch (HIWORD(parameter1))
+          {
+            case LBN_DBLCLK:
+            {
+              if (index == -1) index = _last_index;
+              cmt_string s = _list.get_item (index);
+              TextEditor editor (s);
+        
+              if (editor.run (_instance, _dialog) == IDOK)
+                {
+                  _list.modify (index, s);
+                }
+              _list.set_selected_index (index);
+              _selected_index = index;
+              _last_index = index;
+            }
+            break;
+            case LBN_SELCHANGE:
+              if (_selected_index == -1)
+                {
+                  _selected_index = index;
+                  _last_index = index;
+                }
+              else if (_selected_index == index)
+                {
+                  _list.cancel_selection ();
+                  _selected_index = -1;
+                }
+              else
+                {
+                  _selected_index = index;
+                  _last_index = index;
+                }
+              break;
+            case LBN_SELCANCEL:
+            {
+            }
+            break;
+          }
+      }
+      break;
+      default:
+        break;
+    }
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+CmtMutex::CmtMutex ()
+{
+  InitializeCriticalSection (&_section);
+}
+
+CmtMutex::~CmtMutex ()
+{
+  DeleteCriticalSection (&_section);
+}
+
+void CmtMutex::lock ()
+{
+  EnterCriticalSection (&_section);
+}
+
+void CmtMutex::unlock ()
+{
+  LeaveCriticalSection (&_section);
+}
+//---------------------------------------------------------------------
+
+//---------------------------------------------------------------------
+CmtThread::CmtThread ()
+{
+  _shutdown = FALSE;
+  _running = FALSE;
+}
+
+CmtThread::~CmtThread ()
+{
+}
+
+void CmtThread::run ()
+{
+}
+
+bool CmtThread::is_running ()
+{
+  bool result = false;
+
+  _mutex.lock ();
+  result = _running;
+  _mutex.unlock ();
+
+  return (result);
+}
+
+void CmtThread::set_running ()
+{
+  _mutex.lock ();
+  _running = TRUE;
+  _mutex.unlock ();
+}
+
+void CmtThread::reset_running ()
+{
+  _mutex.lock ();
+  _running = FALSE;
+  _mutex.unlock ();
+}
+
+bool CmtThread::start ()
+{
+  if (!is_running ())
+    {
+      _thread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) run_it,
+                              this, 0, &_id);
+
+	  return (TRUE);
+    }
+  else
+    {
+	  return (FALSE);
+    }
+}
+
+void CmtThread::stop ()
+{
+  _mutex.lock ();
+  _shutdown = TRUE;
+  _mutex.unlock ();
+
+  WaitForSingleObject (_thread, INFINITE);
+}
+
+void CmtThread::run_it (CmtThread* thread)
+{
+  thread->set_running ();
+  thread->run ();
+  thread->reset_running ();
+}
+//---------------------------------------------------------------------
+
Index: /CMT/v1r20/source/install_utils.h
===================================================================
--- /CMT/v1r20/source/install_utils.h	(revision 368)
+++ /CMT/v1r20/source/install_utils.h	(revision 368)
@@ -0,0 +1,221 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#ifndef __windows_utils_h__
+#define __windows_utils_h__
+
+#include <windows.h>
+
+#include "cmt_std.h"
+#include "cmt_string.h"
+#include "cmt_vector.h"
+#include "cmt_system.h"
+
+//-------------------------------------------------------------------
+class WWindow
+{
+public:
+  WWindow ();
+
+  void enable ();
+  void disable ();
+
+protected:
+  HWND _window;
+};
+//-------------------------------------------------------------------
+
+//-------------------------------------------------------------------
+class WEdit : public WWindow
+{
+public:
+  WEdit ();
+  WEdit (HWND edit);
+  WEdit (HWND container, int id);
+
+  void init (HWND container, int id);
+  WEdit& operator = (HWND edit);
+  void set (const char* text);
+  void set (const cmt_string& text);
+  void clear ();
+  cmt_string get () const;
+  void copy (const WEdit& other);
+
+private:
+  HWND _edit;
+};
+//-------------------------------------------------------------------
+
+//-------------------------------------------------------------------
+class WList : public WWindow
+{
+public:
+  WList ();
+  WList (HWND list);
+  WList (HWND container, int id);
+
+  void init (HWND container, int id);
+  WList& operator = (HWND list);
+  void append (const char* text);
+  void append (const cmt_string& text);
+  void insert (int index, const cmt_string& text);
+  void modify (int index, const cmt_string& text);
+  void delete_item (int index);
+  void clear ();
+  void cancel_selection ();
+  int get_selected_index ();
+  void set_selected_index (int index);
+  cmt_string get_selected ();
+  int get_item_count () const;
+  cmt_string get_item (int index) const;
+  void get_item (int index, cmt_string& text) const;
+  int get_item_length (int index) const;
+  void copy (const WList& other);
+  void set (const CmtSystem::cmt_string_vector& v, int first = 0);
+  void set (const cmt_string& file_name);
+  void get (CmtSystem::cmt_string_vector& v) const;
+  void get (cmt_string& s) const;
+  void set_extent ();
+  int get_width () const;
+  int get_extent () const;
+
+private:
+  HWND _list;
+  int _selected_index;
+  int _width;
+};
+//-------------------------------------------------------------------
+
+/*---------------------------------------------------------------------*/
+class mysb :public streambuf
+{
+public:
+  mysb (WList& list);
+  ~mysb ();
+
+private:
+  int_type overflow (int_type c);
+  int underflow ();
+
+  streambuf* _old;
+  cmt_string* _buf;
+  WList& _list;
+};
+/*---------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------*/
+class WDialog
+{
+public:
+  WDialog ();
+
+  virtual void action (UINT message_type,
+                       WPARAM parameter1,
+                       LPARAM parameter2);
+  virtual void init_action ();
+  virtual void menu_action (int menu_item,
+                            WPARAM parameter1,
+                            LPARAM parameter2);
+
+protected:
+
+  int run (HINSTANCE instance, HWND father, int id);
+
+  HWND _dialog;
+
+private:
+
+  static LRESULT CALLBACK proc (HWND dialog,
+                                UINT message_type,
+                                WPARAM parameter1,
+                                LPARAM parameter2);
+};
+/*---------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------*/
+class TextEditor : public WDialog
+{
+public:
+  TextEditor (cmt_string& ref);
+
+  int run (HINSTANCE instance, HWND father);
+  virtual void action (UINT message_type,
+                       WPARAM parameter1,
+                       LPARAM parameter2);
+  void init_action ();
+  void menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2);
+
+private:
+  cmt_string& _ref;
+  WEdit _edit;
+};
+/*---------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------*/
+class ListEditor : public WDialog
+{
+public:
+  ListEditor (WList& list);
+
+  int run (HINSTANCE instance, HWND father);
+  virtual void action (UINT message_type,
+                       WPARAM parameter1,
+                       LPARAM parameter2);
+  void set_position (int index);
+  void init_action ();
+  void menu_action (int menu_item, WPARAM parameter1, LPARAM parameter2);
+
+private:
+  WList& _ref_list;
+  WList _list;
+  HINSTANCE _instance;
+  int _selected_index;
+  int _last_index;
+  int _ref_selected_index;
+};
+/*---------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------*/
+class CmtMutex
+{
+public:
+  CmtMutex ();
+  ~CmtMutex ();
+
+  void lock ();
+  void unlock ();
+
+private:
+  CRITICAL_SECTION _section;
+};
+/*---------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------*/
+class CmtThread
+{
+public:
+  CmtThread ();
+  virtual ~CmtThread ();
+
+  virtual void run ();
+  bool is_running ();
+  void set_running ();
+  void reset_running ();
+  bool start ();
+  void stop ();
+
+private:
+  static void run_it (CmtThread* thread);
+
+  HANDLE _thread;
+  DWORD _id;
+  CmtMutex _mutex;
+  bool _shutdown;
+  bool _running;
+};
+/*---------------------------------------------------------------------*/
+
+#endif
Index: /CMT/v1r20/src/Makefile
===================================================================
--- /CMT/v1r20/src/Makefile	(revision 368)
+++ /CMT/v1r20/src/Makefile	(revision 368)
@@ -0,0 +1,10 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+include $(CMTROOT)/src/Makefile.header
+
+include $(CMTROOT)/src/constituents.make
+
Index: /CMT/v1r20/src/Makefile.core
===================================================================
--- /CMT/v1r20/src/Makefile.core	(revision 368)
+++ /CMT/v1r20/src/Makefile.core	(revision 368)
@@ -0,0 +1,144 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+cflags    = $(CFLAGS)
+cppflags  = $(CFLAGS)
+fflags    = $(CFLAGS)
+
+cc        = cc
+ccomp     = $(cc)  -c -I$(inc) $(cflags)
+clink     = $(cc)
+
+cpp       = g++
+cppcomp   = $(cpp) -c -I$(inc) $(cppflags)
+cpplink   = $(cpp)
+
+for       = f77
+fcomp     = $(for) -c -I$(inc) $(fflags)
+flink     = $(for)
+
+lexflags  =
+lex       = lex $(lexflags)
+
+yaccflags =
+yacc      = yacc $(yaccflags)
+
+mkdir     = mkdir
+
+comp      = $(ccomp)
+link      = $(cc)
+
+ar        = ar -crl
+ranlib    = ranlib
+
+cmtexe = $(CMTROOT)/$(CMTBIN)/cmt.exe
+
+#---------------------------------------------
+# Controlling the verbosity of Make
+#
+
+ifdef QUIET
+LEX_QUIET = 1
+YACC_QUIET = 1
+C_QUIET = 1
+CPP_QUIET = 1
+FORTRAN_QUIET = 1
+JAVA_QUIET = 1
+LINK_QUIET = 1
+LIB_QUIET = 1
+CLEANUP_QUIET = 1
+silent = @
+echo = @/bin/echo 
+else
+silent =
+echo = @- echo 
+endif
+
+ifdef LEX_QUIET
+lex_silent = @
+lex_echo = @/bin/echo rebuilding 
+else
+lex_silent =
+lex_echo = $(echo)
+endif
+
+ifdef YACC_QUIET
+yacc_silent = @
+yacc_echo = @/bin/echo rebuilding 
+else
+yacc_silent =
+yacc_echo = $(echo)
+endif
+
+ifdef C_QUIET
+c_silent = @
+c_echo = @/bin/echo rebuilding 
+else
+c_silent =
+c_echo = $(echo)
+endif
+
+ifdef CPP_QUIET
+cpp_silent = @
+cpp_echo = @/bin/echo rebuilding 
+else
+cpp_silent =
+cpp_echo = $(echo)
+endif
+
+ifdef FORTRAN_QUIET
+fortran_silent = @
+fortran_echo = @/bin/echo rebuilding 
+else
+fortran_silent =
+fortran_echo = $(echo)
+endif
+
+ifdef JAVA_QUIET
+java_silent = @
+java_echo = @/bin/echo rebuilding 
+else
+java_silent =
+java_echo = $(echo)
+endif
+
+ifdef LINK_QUIET
+link_silent = @
+link_echo = @/bin/echo rebuilding 
+else
+link_silent =
+link_echo = $(echo)
+endif
+
+ifdef LIB_QUIET
+lib_silent = @
+lib_echo = @/bin/echo rebuilding 
+else
+lib_silent =
+lib_echo = $(echo)
+endif
+
+ifdef CLEANUP_QUIET
+cleanup_silent = @
+cleanup_echo = @/bin/echo removing 
+else
+cleanup_silent =
+cleanup_echo = $(echo)
+endif
+
+SHELL     = /bin/sh
+
+src       = ../src/
+inc       = ../src/
+mgr       = ../mgr/
+cmt       = ../cmt/
+bin       = ../$(tag)/
+
+#
+#dirs ::
+#	@if test ! -r requirements ; then echo "No requirements file" ; fi; \
+#	  if test ! -d $(bin) ; then $(mkdir) -p $(bin) ; fi
+#
Index: /CMT/v1r20/src/Makefile.header
===================================================================
--- /CMT/v1r20/src/Makefile.header	(revision 368)
+++ /CMT/v1r20/src/Makefile.header	(revision 368)
@@ -0,0 +1,121 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+include ${CMTROOT}/src/Makefile.core
+
+#
+#  Basic tag management
+#
+ifdef tag
+CMTEXTRATAGS = $(tag)
+else
+tag       = $(CMTCONFIG)
+endif
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+ifdef READONLY
+cmt_local_tagfile = /tmp/CMT_$(tag).make$$$$
+else
+cmt_local_tagfile = $(tag).make
+endif
+
+#
+#  Generic entry points for all targets
+#
+all :: check_config
+
+check_config ::
+	@$(cmtexe) check configuration; status=$$?; \
+	if test $${status} = 0; then \
+	  /bin/rm -f $(cmt_local_tagfile); \
+	  $(MAKE) --no-print-directory $(MAKEFLAGS) target="first config all" common_target; \
+	else \
+	  echo "#CMT> There are configuration errors. Please correct them before running gmake"; \
+	fi
+
+binclean ::
+	@if test ! "$(bin)" = "./"; then \
+	  if test -d $(bin) ; then \
+	    echo "------> (Makefile.header) Cleaning all from $(bin)"; \
+	    /bin/rm -rf $(bin) ; \
+	  fi ; \
+	fi
+
+clean ::
+	@$(cmtexe) check configuration
+	@$(MAKE) --no-print-directory target="$@" common_target
+
+.DEFAULT ::
+	@$(cmtexe) check configuration
+	@$(MAKE) --no-print-directory target="config $@" common_target
+
+#
+#  Capture all possible targets
+#
+common_target ::
+	@tmpdir=/tmp; \
+	  if test ! "${TMPDIR}" = ""; then tmpdir=${TMPDIR}; fi; \
+	  cmt_lock_pid=`mkdir -p $${tmpdir}; mktemp $${tmpdir}/CMT_XXXXXX | sed -e 's#'"$${tmpdir}"'/CMT_##'`; \
+	  temp_marker=$${tmpdir}/CMT_$${cmt_lock_pid}; \
+	  temp_lock=$${tmpdir}/CMT_lock$${cmt_lock_pid}.make; \
+	  temp_constituents=$${tmpdir}/CMT_constituents$${cmt_lock_pid}; \
+	  if test ! "${CMTMAKEDEBUG}" = 1; then\
+	    trap '/bin/rm -f $${temp_lock} $${temp_constituents} $${temp_marker}; exit $${status}' 0 1 2 15; \
+	  fi; \
+	  /bin/rm -f $${temp_marker}; \
+	  /bin/rm -f $${temp_lock}; \
+	  echo "------> (Makefile.header) Rebuilding constituents.make"; \
+	  $(cmtexe) -quiet -tag=$(tags) build constituents_makefile -out=$${temp_constituents}; status=$$?; \
+	  if test $${status} = 0; then \
+	    /bin/rm -f $(cmt_local_tagfile); \
+	    $(MAKE) --no-print-directory -f $${temp_constituents} cmt_lock_pid=$${cmt_lock_pid} $(target); \
+	    status=$$?; \
+	  else \
+	    echo "#CMT> Error generating constituents makefile"; \
+	  fi; \
+	  exit $${status}
+
+
+#
+#  Ancient mechanism for remote launchers (kept for backward compatibility)
+#
+$(gmake_hosts) ::
+	rsh $@ "sh -c '(cd `$(cmtexe) show pwd -quiet`; . setup.sh; gmake $(MAKEFLAGS) $(target))'"
+
+$(make_hosts) ::
+	rsh $@ "sh -c '(cd `$(cmtexe) show pwd`; . setup.sh; make $(MAKEFLAGS) $(target))'"
+
+
+everywhere :: $(everywhere)
+
+#
+#   Display all targets
+#
+help ::
+	@echo '--------------------------------------------------------------------------'
+	@echo 'You may select one of the following make targets :'
+	@echo ' '
+	@echo 'help        : this help'
+	@echo 'all         : rebuild all constituents according to the $$(constituents) macro'
+	@echo '              (this is the default target)'
+	@echo 'clean       : remove everything that can be rebuilt'
+	@echo 'binclean    : fast erase of the binary directory'
+	@echo ' '
+	@groups=`$(cmtexe) show groups -quiet -tag=$(tags)`; \
+	  for g in $${groups}; do \
+	    echo "$${g} : rebuild all constituents of group $${g}"; \
+	  done
+	@echo "Constituents:"; \
+	  for c in `$(cmtexe) show constituent_names -quiet -tag=$(tags)` ; do \
+	    echo "  $${c}  $${c}clean"; \
+	  done
+	@echo ' '
+	@echo 'check :'
+	@echo '              run all applications defined with the -check option'
+	@echo ' '
+
+
Index: /CMT/v1r20/src/NMake
===================================================================
--- /CMT/v1r20/src/NMake	(revision 368)
+++ /CMT/v1r20/src/NMake	(revision 368)
@@ -0,0 +1,9 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+!include $(CMTROOT)\src\NMakefile.header
+
+!include $(CMTROOT)\src\constituents.mak
Index: /CMT/v1r20/src/NMakefile.core
===================================================================
--- /CMT/v1r20/src/NMakefile.core	(revision 368)
+++ /CMT/v1r20/src/NMakefile.core	(revision 368)
@@ -0,0 +1,134 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+ 
+cflags    = $(CFLAGS)
+cppflags  = $(CFLAGS)
+fflags    = $(CFLAGS)
+
+cc        = cl.exe
+ccomp     = $(cc) /nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /Fo"$(bin)\\" /Fd"$(bin)\\" /FD /c
+clink   = link.exe kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+cpp       = cl.exe
+cppcomp   = $(cpp) /nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /c
+cpplink   = link.exe kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+####for       = f77
+####fcomp     = $(for) -c -I$(inc) $(fflags)
+####flink     = $(for)
+
+####lexflags  =
+####lex       = lex $(lexflags)
+
+####yaccflags =
+####yacc      = yacc $(yaccflags)
+
+ar        = link.exe -lib
+ranlib    = ranlib
+
+src       = ../src/
+inc       = ../src/
+mgr       = ../mgr/
+cmt       = ../cmt/
+bin       = ..\$(tag)\ 
+shortbin  = ..\$(tag)
+
+#---------------------------------------------
+# Controlling the verbosity of Make
+#
+
+!if defined (QUIET)
+LEX_QUIET = 1
+YACC_QUIET = 1
+C_QUIET = 1
+CPP_QUIET = 1
+FORTRAN_QUIET = 1
+JAVA_QUIET = 1
+LINK_QUIET = 1
+LIB_QUIET = 1
+CLEANUP_QUIET = 1
+silent = @
+echo = @echo 
+!else
+silent =
+echo = echo 
+!endif
+
+!if defined (LEX_QUIET)
+lex_silent = @
+lex_echo = @echo rebuilding 
+!else
+lex_silent =
+lex_echo = -@ $(echo)
+!endif
+
+!if defined (YACC_QUIET)
+yacc_silent = @
+yacc_echo = @echo rebuilding 
+!else
+yacc_silent =
+yacc_echo = -@ $(echo)
+!endif
+
+!if defined (C_QUIET)
+c_silent = @
+c_echo = @echo rebuilding 
+!else
+c_silent =
+c_echo = -@ $(echo)
+!endif
+
+!if defined (CPP_QUIET)
+cpp_silent = @
+cpp_echo = @echo rebuilding 
+!else
+cpp_silent =
+cpp_echo = -@ $(echo)
+!endif
+
+!if defined (FORTRAN_QUIET)
+fortran_silent = @
+fortran_echo = @echo rebuilding 
+!else
+fortran_silent =
+fortran_echo = -@ $(echo)
+!endif
+
+!if defined (JAVA_QUIET)
+java_silent = @
+java_echo = @echo rebuilding 
+!else
+java_silent =
+java_echo = -@ $(echo)
+!endif
+
+!if defined (LINK_QUIET)
+link_silent = @
+link_echo = @echo rebuilding 
+!else
+link_silent =
+link_echo = -@ $(echo)
+!endif
+
+!if defined (LIB_QUIET)
+lib_silent = @
+lib_echo = @echo rebuilding 
+!else
+lib_silent =
+lib_echo = -@ $(echo)
+!endif
+
+!if defined (CLEANUP_QUIET)
+cleanup_silent = @
+cleanup_echo = @echo removing 
+!else
+cleanup_silent =
+cleanup_echo = @ $(echo)
+!endif
+
+cmtexe = $(CMTROOT)\$(CMTBIN)\cmt.exe
+
+
Index: /CMT/v1r20/src/NMakefile.header
===================================================================
--- /CMT/v1r20/src/NMakefile.header	(revision 368)
+++ /CMT/v1r20/src/NMakefile.header	(revision 368)
@@ -0,0 +1,64 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+!include $(CMTROOT)/src/NMakefile.core
+
+#
+#  Basic tag management
+#
+!if defined (tag)
+CMTEXTRATAGS = $(tag)
+!else
+!if defined (CMTCONFIG)
+tag = $(CMTCONFIG) 
+!else
+tag = VisualC
+!endif
+!endif
+
+tags      = $(tag),$(CMTEXTRATAGS)
+
+#
+#  Generic entry points for all targets
+#
+build_strategy = rebuild_makefiles
+build_dependencies = echo
+
+all :: check_config
+
+check_config ::
+	$(cmtexe) check configuration
+
+configclean ::
+	del *nmake* setup.* cleanup.*
+
+help :: dirs
+	@echo --------------------------------------------------------------------------
+	@echo You may select one of the following make targets :
+	@echo  
+	@echo help        : this help
+	@echo all         : rebuild everything according to the $$(constituents) macro
+	@echo               (this is the default target)
+	@echo clean       : remove everything that can be rebuilt
+	@echo configclean : remove configuration files (*.nmake)
+	@echo  
+	@echo check :
+	@echo               run all applications defined with the -check option
+	@echo  
+	@echo everywhere [target=...] : 
+	@echo               o Rebuild on all plateforms specified in the $$(everywhere) macro
+	@echo               o Use "cmt show macro everywhere -tag=<site>" to check it
+	@echo               o The "target" option permits to transmit a target to the remote site
+
+
+!if [$(cmtexe) -quiet build constituents_makefile -tag=$(tags)] == 0
+!endif
+
+!include constituents.nmake
+
+
+
+
Index: /CMT/v1r20/src/cleanup.csh
===================================================================
--- /CMT/v1r20/src/cleanup.csh	(revision 368)
+++ /CMT/v1r20/src/cleanup.csh	(revision 368)
@@ -0,0 +1,24 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+set newpath=
+
+foreach p ( `echo ${PATH} | sed 's#:# #g'` )
+  echo ${p} | egrep '/CMT/' >& /dev/null
+  set s=${status}
+  if ( "${s}" != 0 ) then
+    if ( ${newpath} == "" ) then
+      set newpath=${p}
+    else
+      set newpath=${newpath}:${p}
+    endif
+  endif
+end
+
+setenv PATH ${newpath}
+unsetenv CMTCONFIG
+unsetenv CMTROOT
+
Index: /CMT/v1r20/src/cleanup.sh
===================================================================
--- /CMT/v1r20/src/cleanup.sh	(revision 368)
+++ /CMT/v1r20/src/cleanup.sh	(revision 368)
@@ -0,0 +1,21 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+newpath=""
+for p in `echo ${PATH} | sed 's/:/ /g'`; do
+  if test ! "`echo ${p} | egrep CMT`" ; then
+    if test "${newpath}" = "" ; then
+      newpath=${p}
+    else
+      newpath=${newpath}:${p}
+    fi
+  fi
+done
+
+PATH=${newpath}; export PATH
+
+CMTCONFIG=; export CMTCONFIG
+CMTROOT=; export CMTROOT
Index: /CMT/v1r20/src/constituents.make
===================================================================
--- /CMT/v1r20/src/constituents.make	(revision 368)
+++ /CMT/v1r20/src/constituents.make	(revision 368)
@@ -0,0 +1,33 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+#
+#constituents.make : cmt_path.make requirements
+#	@if test ! -f constituents.make -o "$(build_strategy)" = "rebuild_makefiles"; then \
+#	  echo "Rebuilding $@"; \
+#	  $(cmtexe) build constituents_makefile -quiet -tag=$(tags); \
+#	fi
+#
+#
+#build_library_links : dirs cmt_path.make requirements
+#	@echo "Rebuilding library links"; \
+#	  if test ! -d $(bin) ; then $(mkdir) -p $(bin) ; fi; \
+#	  $(build_library_links)
+#
+###-include constituents.make
+#
+#clean ::
+#	@echo "Removing library links" \
+#	  $(remove_library_links); \
+#
+#makefilesclean ::
+#	/bin/rm -f $(bin)*.make* ; \
+#	/bin/rm -f *.make* ; \
+#	/bin/rm -f checkuses
+#
+#clean :: makefilesclean
+#
+
Index: /CMT/v1r20/src/constituents.nmake
===================================================================
--- /CMT/v1r20/src/constituents.nmake	(revision 368)
+++ /CMT/v1r20/src/constituents.nmake	(revision 368)
@@ -0,0 +1,15 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+#
+#!if [echo $(cmtexe) -quiet build constituents_makefile -tag=$(tags)] == 0
+#!endif
+#!if [$(cmtexe) -quiet build constituents_makefile -tag=$(tags)] == 0
+#!endif
+#
+#!include constituents.nmake
+#
+
Index: /CMT/v1r20/src/demo/demo1.cmt
===================================================================
--- /CMT/v1r20/src/demo/demo1.cmt	(revision 368)
+++ /CMT/v1r20/src/demo/demo1.cmt	(revision 368)
@@ -0,0 +1,302 @@
+%%%-----------------------------------------------------------
+%%% Copyright Christian Arnault LAL-Orsay CNRS
+%%% arnault@lal.in2p3.fr
+%%% See the complete license in cmt_license.txt "http://www.cecill.info". 
+%%%-----------------------------------------------------------
+
+%%%---------------------------------
+%%%------ demoA --------------------
+%%%---------------------------------
+%%package demoA
+
+branches classes demoA
+
+application demoA demoA.cxx foo=bar -target_tag
+application A A.java 
+
+pattern -global multi macro m1 "" Linux m1linux alpha m1alpha ; macro m2 m2
+
+macro m3 m3
+
+make_fragment rename -header=rename_header
+
+document rename XXX OFFSET=XXX demoA.cxx
+
+application XXXdemoA -check -group=X XXXdemoA.cxx
+
+include_path $(demoA_root)
+
+setup_script init
+
+%%%---------------------------------
+%%file cmt/init.bat
+
+echo "doing A init"
+
+%%%---------------------------------
+%%file cmt/init.csh
+
+echo "doing A init"
+
+%%%---------------------------------
+%%file cmt/init.sh
+
+echo "doing A init"
+
+%%%---------------------------------
+%%file src/demoA.cxx
+#include <stdio.h>
+ 
+int main ()
+{
+  //xxx
+  printf ("demoA\n");
+
+  return (0);
+}
+
+%%%---------------------------------
+%%file demoA/demoA.h
+
+#define demoA 123
+
+%%%---------------------------------
+%%file src/A.java
+
+public class A
+{
+  public static void main (String arg[])
+  {
+    System.out.println ("A");
+  }
+}
+
+%%%---------------------------------
+%%file cmt/fragments/rename
+
+## ${SUFFIX}
+
+${CONSTITUENT} :: ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
+
+${FILEPATH}${OFFSET}${NAME}${FILESUFFIX} : ${FULLNAME}
+	cp $? $@
+
+clean::
+	/bin/rm -f ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
+%%%---------------------------------
+%%file cmt/fragments/rename_header
+
+%%%---------------------------------
+%%file cmt/fragments/nmake/rename
+
+## ${SUFFIX}
+
+${CONSTITUENT} :: ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
+${FILEPATH}${OFFSET}${NAME}${FILESUFFIX} : ${FULLNAME}
+	copy $? $@
+
+clean::
+	del ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
+%%%---------------------------------
+%%file cmt/fragments/nmake/rename_header
+
+%%%---------------------------------
+%%%------ demoB --------------------
+%%%---------------------------------
+%%package demoB
+package demoB
+
+use demoA
+
+application demoB -check demoB.cxx
+
+#application B B.java
+
+set before_init "before_init"
+
+setup_script init
+
+set after_init "after_init"
+
+%%file cmt/init.bat
+
+echo "doing B init"
+
+%%file cmt/init.csh
+
+echo "doing B init"
+
+%%file cmt/init.sh
+
+echo "doing B init"
+
+%%file src/demoB.cxx
+#include <stdio.h>
+
+#include <demoA/demoA.h>
+ 
+int main ()
+{
+  printf ("demoB demoA=%d\n", demoA);
+
+  return (0);
+}
+
+%%file src/B.java
+
+public class B
+{
+  public static void main (String arg[])
+  {
+    System.out.println ("B");
+  }
+}
+
+%%%---------------------------------
+%%%------ demoC --------------------
+%%%---------------------------------
+%%package demoC
+package demoC
+
+build_strategy rebuild_makefiles
+
+include_path ../demoC
+
+branches demoC
+
+library C C*.cxx
+
+macro demoC_linkopts "-L$(DEMOCROOT)/$(demoC_tag) -lC" \
+      WIN32          ""
+
+application demoC -check demoC.cxx
+
+path_append LD_LIBRARY_PATH "" \
+            Linux "../$(demoC_tag)"
+
+
+%%file src/demoC.cxx
+#include <stdio.h>
+
+typedef void (*Procedure) ();
+
+#ifdef WIN32
+#include <windows.h>
+
+Procedure get_proc (const char* name)
+{
+  void* f = ::LoadLibrary ("..\\Win32Debug\\C.dll");
+
+  if (f == 0)
+    {
+      f = ::LoadLibrary ("..\\VisualC\\C.dll");
+    }
+
+  if (f == 0)
+    {
+      printf ("Cannot load the library\n");
+      exit (0);
+    }
+
+  Procedure p;
+
+  p = (Procedure)::GetProcAddress ((HMODULE) f, name);
+  if (p == 0)
+    {
+      char* s = new char[strlen(name) + 2];
+      s[0] = '_';
+      strcpy (s+1, name);
+      p = (Procedure)::GetProcAddress((HMODULE) f, s);
+    } 
+
+  if (p == 0)
+    {
+      printf ("Cannot get the module %s\n", name);
+      exit (0);
+    }
+
+  return (p);
+}
+#else
+extern "C" {
+void C1 ();
+void C2 ();
+void C3 ();
+}
+#endif
+
+int main ()
+{
+  printf ("demoC\n");
+
+#ifdef WIN32
+
+  Procedure c = 0;
+
+  c = get_proc ("C1");
+  c ();
+  c = get_proc ("C2");
+  c ();
+  c = get_proc ("C3");
+  c ();
+#else
+  C1 ();
+  C2 ();
+  C3 ();
+#endif
+
+  return (0);
+}
+
+%%file src/C1.cxx
+#include <stdio.h>
+
+extern "C" { 
+  void C1 ();
+}
+
+void C1 ()
+{
+  printf ("C1\n");
+}
+
+%%file src/C2.cxx
+#include <stdio.h>
+ 
+extern "C" { 
+  void C2 ();
+}
+
+void C2 ()
+{
+  printf ("C2\n");
+}
+
+%%file src/C3.cxx
+#include <stdio.h>
+ 
+extern "C" { 
+  void C3 ();
+}
+
+void C3 ()
+{
+  printf ("C3\n");
+}
+
+%%%---------------------------------
+%%%------ Actions ------------------
+%%%---------------------------------
+%%cdpackage demoA
+%%cmt run "gmake all_groups"
+%%%cmt run "gmake check"
+%%cdpackage demoB
+%%%cmt run "gmake all"
+%%%cmt run "gmake check"
+%%cdpackage demoC
+%%%cmt run "cmt config"
+%%%cmt run ". setup.sh ; gmake QUIET=1 all check"
Index: /CMT/v1r20/src/demo/demoA/A.java
===================================================================
--- /CMT/v1r20/src/demo/demoA/A.java	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/A.java	(revision 368)
@@ -0,0 +1,14 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+public class A
+{
+  public static void main (String arg[])
+  {
+    System.out.println ("A");
+  }
+}
+
Index: /CMT/v1r20/src/demo/demoA/demoA.cxx
===================================================================
--- /CMT/v1r20/src/demo/demoA/demoA.cxx	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/demoA.cxx	(revision 368)
@@ -0,0 +1,15 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+ 
+int main ()
+{
+  //xxx
+  printf ("demoA\n");
+
+  return (0);
+}
Index: /CMT/v1r20/src/demo/demoA/demoA.h
===================================================================
--- /CMT/v1r20/src/demo/demoA/demoA.h	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/demoA.h	(revision 368)
@@ -0,0 +1,7 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#define demoA 123
Index: /CMT/v1r20/src/demo/demoA/fragments/nmake/rename
===================================================================
--- /CMT/v1r20/src/demo/demoA/fragments/nmake/rename	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/fragments/nmake/rename	(revision 368)
@@ -0,0 +1,16 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+## ${SUFFIX}
+
+${CONSTITUENT} :: ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
+${FILEPATH}${OFFSET}${NAME}${FILESUFFIX} : ${FULLNAME}
+	copy $? $@
+
+clean::
+	del ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
Index: /CMT/v1r20/src/demo/demoA/fragments/nmake/rename_header
===================================================================
--- /CMT/v1r20/src/demo/demoA/fragments/nmake/rename_header	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/fragments/nmake/rename_header	(revision 368)
@@ -0,0 +1,7 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+
Index: /CMT/v1r20/src/demo/demoA/fragments/rename
===================================================================
--- /CMT/v1r20/src/demo/demoA/fragments/rename	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/fragments/rename	(revision 368)
@@ -0,0 +1,17 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+## ${SUFFIX}
+
+${CONSTITUENT} :: ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
+
+${FILEPATH}${OFFSET}${NAME}${FILESUFFIX} : ${FULLNAME}
+	cp $? $@
+
+clean::
+	/bin/rm -f ${FILEPATH}${OFFSET}${NAME}${FILESUFFIX}
+
Index: /CMT/v1r20/src/demo/demoA/fragments/rename_header
===================================================================
--- /CMT/v1r20/src/demo/demoA/fragments/rename_header	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/fragments/rename_header	(revision 368)
@@ -0,0 +1,7 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+
Index: /CMT/v1r20/src/demo/demoA/init.bat
===================================================================
--- /CMT/v1r20/src/demo/demoA/init.bat	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/init.bat	(revision 368)
@@ -0,0 +1,8 @@
+
+rem
+rem Copyright Christian Arnault LAL-Orsay CNRS
+rem arnault@lal.in2p3.fr
+rem See the complete license in cmt_license.txt "http://www.cecill.info". 
+rem
+
+echo "doing A init"
Index: /CMT/v1r20/src/demo/demoA/init.csh
===================================================================
--- /CMT/v1r20/src/demo/demoA/init.csh	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/init.csh	(revision 368)
@@ -0,0 +1,7 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+echo "doing A init"
Index: /CMT/v1r20/src/demo/demoA/init.sh
===================================================================
--- /CMT/v1r20/src/demo/demoA/init.sh	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/init.sh	(revision 368)
@@ -0,0 +1,7 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+echo "doing A init"
Index: /CMT/v1r20/src/demo/demoA/requirements
===================================================================
--- /CMT/v1r20/src/demo/demoA/requirements	(revision 368)
+++ /CMT/v1r20/src/demo/demoA/requirements	(revision 368)
@@ -0,0 +1,32 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+package demoA
+
+branches classes demoA
+
+application demoA demoA.cxx foo=bar -target_tag
+application A A.java 
+
+pattern -global multi macro m1 "" Linux m1linux alpha m1alpha ; macro m2 m2
+
+macro m3 m3
+
+make_fragment rename -header=rename_header
+
+document rename XXX OFFSET=XXX demoA.cxx
+
+application XXXdemoA -check -group=X XXXdemoA.cxx
+
+include_path $(demoA_root)
+
+setup_script init
+
+path_remove PATH "" WIN32 'Java'
+path_remove PATH "" WIN32 'jdk'
+path_prepend PATH "" WIN32 '"C:\jdk1.3\bin"'
+
+
Index: /CMT/v1r20/src/demo/demoB/B.java
===================================================================
--- /CMT/v1r20/src/demo/demoB/B.java	(revision 368)
+++ /CMT/v1r20/src/demo/demoB/B.java	(revision 368)
@@ -0,0 +1,14 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+public class B
+{
+  public static void main (String arg[])
+  {
+    System.out.println ("B");
+  }
+}
+
Index: /CMT/v1r20/src/demo/demoB/demoB.cxx
===================================================================
--- /CMT/v1r20/src/demo/demoB/demoB.cxx	(revision 368)
+++ /CMT/v1r20/src/demo/demoB/demoB.cxx	(revision 368)
@@ -0,0 +1,16 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+
+#include <demoA/demoA.h>
+ 
+int main ()
+{
+  printf ("demoB demoA=%d\n", demoA);
+
+  return (0);
+}
Index: /CMT/v1r20/src/demo/demoB/init.bat
===================================================================
--- /CMT/v1r20/src/demo/demoB/init.bat	(revision 368)
+++ /CMT/v1r20/src/demo/demoB/init.bat	(revision 368)
@@ -0,0 +1,8 @@
+
+rem
+rem Copyright Christian Arnault LAL-Orsay CNRS
+rem arnault@lal.in2p3.fr
+rem See the complete license in cmt_license.txt "http://www.cecill.info". 
+rem
+
+echo "doing B init"
Index: /CMT/v1r20/src/demo/demoB/init.csh
===================================================================
--- /CMT/v1r20/src/demo/demoB/init.csh	(revision 368)
+++ /CMT/v1r20/src/demo/demoB/init.csh	(revision 368)
@@ -0,0 +1,7 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+echo "doing B init"
Index: /CMT/v1r20/src/demo/demoB/init.sh
===================================================================
--- /CMT/v1r20/src/demo/demoB/init.sh	(revision 368)
+++ /CMT/v1r20/src/demo/demoB/init.sh	(revision 368)
@@ -0,0 +1,7 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+echo "doing B init"
Index: /CMT/v1r20/src/demo/demoB/requirements
===================================================================
--- /CMT/v1r20/src/demo/demoB/requirements	(revision 368)
+++ /CMT/v1r20/src/demo/demoB/requirements	(revision 368)
@@ -0,0 +1,20 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+package demoB
+
+use demoA
+
+application demoB -check demoB.cxx
+
+#application B B.java
+
+set before_init "before_init"
+
+setup_script init
+
+set after_init "after_init"
+
Index: /CMT/v1r20/src/demo/demoC/C1.cxx
===================================================================
--- /CMT/v1r20/src/demo/demoC/C1.cxx	(revision 368)
+++ /CMT/v1r20/src/demo/demoC/C1.cxx	(revision 368)
@@ -0,0 +1,16 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+
+extern "C" { 
+  void C1 ();
+}
+
+void C1 ()
+{
+  printf ("C1\n");
+}
Index: /CMT/v1r20/src/demo/demoC/C2.cxx
===================================================================
--- /CMT/v1r20/src/demo/demoC/C2.cxx	(revision 368)
+++ /CMT/v1r20/src/demo/demoC/C2.cxx	(revision 368)
@@ -0,0 +1,16 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+ 
+extern "C" { 
+  void C2 ();
+}
+
+void C2 ()
+{
+  printf ("C2\n");
+}
Index: /CMT/v1r20/src/demo/demoC/C3.cxx
===================================================================
--- /CMT/v1r20/src/demo/demoC/C3.cxx	(revision 368)
+++ /CMT/v1r20/src/demo/demoC/C3.cxx	(revision 368)
@@ -0,0 +1,16 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+ 
+extern "C" { 
+  void C3 ();
+}
+
+void C3 ()
+{
+  printf ("C3\n");
+}
Index: /CMT/v1r20/src/demo/demoC/demoC.cxx
===================================================================
--- /CMT/v1r20/src/demo/demoC/demoC.cxx	(revision 368)
+++ /CMT/v1r20/src/demo/demoC/demoC.cxx	(revision 368)
@@ -0,0 +1,79 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+#include <stdio.h>
+
+typedef void (*Procedure) ();
+
+#ifdef WIN32
+#include <windows.h>
+
+Procedure get_proc (const char* name)
+{
+  void* f = ::LoadLibrary ("..\\Win32Debug\\C.dll");
+
+  if (f == 0)
+    {
+      f = ::LoadLibrary ("..\\VisualC\\C.dll");
+    }
+
+  if (f == 0)
+    {
+      printf ("Cannot load the library\n");
+      exit (0);
+    }
+
+  Procedure p;
+
+  p = (Procedure)::GetProcAddress ((HMODULE) f, name);
+  if (p == 0)
+    {
+      char* s = new char[strlen(name) + 2];
+      s[0] = '_';
+      strcpy (s+1, name);
+      p = (Procedure)::GetProcAddress((HMODULE) f, s);
+    } 
+
+  if (p == 0)
+    {
+      printf ("Cannot get the module %s\n", name);
+      exit (0);
+    }
+
+  return (p);
+}
+#else
+extern "C" {
+void C1 ();
+void C2 ();
+void C3 ();
+}
+#endif
+
+int main ()
+{
+  printf ("demoC\n");
+
+  Procedure c = 0;
+
+#ifdef WIN32
+  c = get_proc ("C1");
+  c ();
+  c = get_proc ("C2");
+  c ();
+  c = get_proc ("C3");
+  c ();
+#else
+  C1 ();
+  C2 ();
+  C3 ();
+#endif
+
+  return (0);
+}
+
+
+
Index: /CMT/v1r20/src/demo/demoC/requirements
===================================================================
--- /CMT/v1r20/src/demo/demoC/requirements	(revision 368)
+++ /CMT/v1r20/src/demo/demoC/requirements	(revision 368)
@@ -0,0 +1,25 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+package demoC
+
+build_strategy rebuild_makefiles
+
+include_path ../demoC
+
+branches demoC
+
+library C C*.cxx
+
+macro demoC_linkopts "-L$(DEMOCROOT)/$(demoC_tag) -lC" \
+      WIN32          ""
+
+application demoC -check demoC.cxx
+
+path_append LD_LIBRARY_PATH "" \
+            Linux "../$(demoC_tag)"
+
+
Index: /CMT/v1r20/src/demo/scenario.awk
===================================================================
--- /CMT/v1r20/src/demo/scenario.awk	(revision 368)
+++ /CMT/v1r20/src/demo/scenario.awk	(revision 368)
@@ -0,0 +1,48 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+BEGIN {started = 0; running = 0; if (style == "") { vdir = "/v1"; } else { vdir = ""; }}
+{
+  line = $0;
+
+  if ($1 == "%%package")
+  {
+    if (running)
+      {
+	print "END";
+	running = 0;
+      }
+    package = $2;
+    print "cmt create " package " v1";
+    filename = package vdir "/cmt/requirements";
+    started = 1;
+  }
+  else if ($1 == "%%file") 
+  {
+    if (running)
+      {
+	print "END";
+	running = 0;
+      }
+    file = $2;
+    print "mkdir -p `dirname " package vdir "/" file "`";
+    filename = package vdir "/" file; 
+    started = 1;
+  }
+  else
+  {
+    gsub ("[$]", "\\$", line);
+    print line;
+  }
+
+  if (started)
+    {
+      started = 0;
+      print "cat <<END >" filename;
+      running = 1;
+    }
+}
+
Index: /CMT/v1r20/src/demo/tprivate.cmt
===================================================================
--- /CMT/v1r20/src/demo/tprivate.cmt	(revision 368)
+++ /CMT/v1r20/src/demo/tprivate.cmt	(revision 368)
@@ -0,0 +1,98 @@
+%%%-----------------------------------------------------------
+%%% Copyright Christian Arnault LAL-Orsay CNRS
+%%% arnault@lal.in2p3.fr
+%%% See the complete license in cmt_license.txt "http://www.cecill.info". 
+%%%-----------------------------------------------------------
+
+
+%%package A
+
+
+use P v1
+use C v1
+
+private
+use B v1
+
+application AAA AAA.c -import=F 
+application BBB BBB.c -import=I 
+
+%%package B
+
+
+use P v1
+use D v1
+use E v1 -no_auto_imports
+
+%%package C
+
+
+use P v1
+use E v1
+use F v1 -no_auto_imports
+
+private
+use G v1
+
+%%package D
+
+
+use P v1
+use H v1
+
+%%package E
+
+
+use P v1
+use I v1 -no_auto_imports
+
+%%package F
+
+
+use P v1
+use J v1
+
+%%package G
+
+
+use P v1
+use K v1
+
+%%package H
+
+
+use P v1
+
+%%package I
+
+
+use P v1
+
+%%package J
+
+include_path none
+include_dirs $(J_root)/J
+
+use P v1
+
+%%package K
+
+
+use P v1
+
+%%package P
+
+
+pattern -global P   macro PPP<package>PPP "bla<package>bla"
+
+ignore_pattern P
+
+%%cdpackage A
+%%cmt show uses
+%%cmt show macros PPP
+%%cmt show macros use_linkopts
+%%cmt show macros _cppflags
+%%cmt show macros _cflags
+%%cmt show macros _fflags
+%%cmt show macros _includes
+
Index: /CMT/v1r20/src/demo/tprivate.out
===================================================================
--- /CMT/v1r20/src/demo/tprivate.out	(revision 368)
+++ /CMT/v1r20/src/demo/tprivate.out	(revision 368)
@@ -0,0 +1,193 @@
+# cmt run_sequence: sequence ${CMTROOT}/src/demo/tprivate.cmt
+------------------------------------------
+Configuring environment for package A version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package B version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package C version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package D version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package E version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package F version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package G version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package H version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package I version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package J version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package K version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+------------------------------------------
+Configuring environment for package P version v1.
+CMT version ${version}.
+Root set to ${CMTROOT}/demo.
+System is ${CMTCONFIG}
+------------------------------------------
+Installing the package directory
+Installing the version directory
+Installing the cmt directory
+Installing the src directory
+Creating setup scripts.
+Creating cleanup scripts.
+# use P v1
+# use C v1
+#   use P v1
+#   use E v1
+#     use P v1
+#     use I v1 (no_auto_imports)
+#       use P v1
+#   use F v1 (no_auto_imports)
+#     use P v1
+#     use J v1
+#       use P v1
+#   use G v1 (private)
+#     use P v1
+#     use K v1
+#       use P v1
+# use B v1 (private)
+#   use P v1
+#   use D v1
+#     use P v1
+#     use H v1
+#       use P v1
+#   use E v1 (no_auto_imports)
+#
+# Selection :
+use CMT ${version} /exp/atlas/arnault/devcmt
+use P v1  (${CMTROOT}/demo)
+use H v1  (${CMTROOT}/demo)
+use D v1  (${CMTROOT}/demo)
+use K v1  (${CMTROOT}/demo)
+use G v1  (${CMTROOT}/demo)
+use J v1  (${CMTROOT}/demo) (no_auto_imports)
+use F v1  (${CMTROOT}/demo) (no_auto_imports)
+use I v1  (${CMTROOT}/demo) (no_auto_imports)
+use E v1  (${CMTROOT}/demo)
+use B v1  (${CMTROOT}/demo)
+use C v1  (${CMTROOT}/demo)
+PPPIPPP='blaIbla'
+PPPEPPP='blaEbla'
+PPPJPPP='blaJbla'
+PPPFPPP='blaFbla'
+PPPCPPP='blaCbla'
+PPPHPPP='blaHbla'
+PPPDPPP='blaDbla'
+PPPBPPP='blaBbla'
+PPPAPPP='blaAbla'
+use_linkopts='  $(A_linkopts)  $(C_linkopts)  $(B_linkopts)  $(E_linkopts)  $(D_linkopts)  $(H_linkopts)  $(P_linkopts) '
+AAA_use_linkopts='  $(A__linkopts)  $(C__linkopts)  $(B__linkopts)  $(E__linkopts)  $(F__linkopts)  $(J__linkopts)  $(D__linkopts)  $(H__linkopts)  $(P__linkopts) '
+BBB_use_linkopts='  $(A__linkopts)  $(C__linkopts)  $(B__linkopts)  $(E__linkopts)  $(I__linkopts)  $(D__linkopts)  $(H__linkopts)  $(P__linkopts) '
Index: /CMT/v1r20/src/demo/tproject.cmt
===================================================================
--- /CMT/v1r20/src/demo/tproject.cmt	(revision 368)
+++ /CMT/v1r20/src/demo/tproject.cmt	(revision 368)
@@ -0,0 +1,44 @@
+%%%-----------------------------------------------------------
+%%% Copyright Christian Arnault LAL-Orsay CNRS
+%%% arnault@lal.in2p3.fr
+%%% See the complete license in cmt_license.txt "http://www.cecill.info". 
+%%%-----------------------------------------------------------
+
+%%package P1
+project P1
+
+%%package P2
+project P2
+
+%%package B
+use P1
+
+apply_tag t1
+
+macro bbb "" \
+      t1&t2 "bbb12" \
+      t1 "bbb1" \
+      t2 "bbb2"
+
+%%package C
+use P2
+
+apply_tag t1
+apply_tag t2
+
+macro bbc "" \
+      t1&t2 "bbc12" \
+      t1 "bbc1" \
+      t2 "bbc2"
+
+
+%%package D
+%%package A
+use B
+use C
+use D
+
+%%cdpackage A
+%%cmt show uses
+%%cmt show macros bb
+%%cmt -tag_add=t2 show macros bb
Index: /CMT/v1r20/src/install.rc
===================================================================
--- /CMT/v1r20/src/install.rc	(revision 368)
+++ /CMT/v1r20/src/install.rc	(revision 368)
@@ -0,0 +1,174 @@
+//-----------------------------------------------------------
+// Copyright Christian Arnault LAL-Orsay CNRS
+// arnault@lal.in2p3.fr
+// See the complete license in cmt_license.txt "http://www.cecill.info". 
+//-----------------------------------------------------------
+
+//Microsoft Developer Studio generated resource script.
+//
+#include "..\src\install_resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// French (France) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
+#ifdef _WIN32
+LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "..\\src\\install_resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 213, 198
+STYLE DS_MODALFRAME | WS_CHILD | WS_VISIBLE
+FONT 8, "MS Sans Serif"
+BEGIN
+    EDITTEXT        IDC_ROOT,57,24,149,13,ES_AUTOHSCROLL
+    CTEXT           "Root",IDC_STATIC,7,24,48,13,SS_CENTERIMAGE
+    CTEXT           "Version",IDC_STATIC,7,40,48,13,SS_CENTERIMAGE
+    CTEXT           "Config",IDC_STATIC,7,56,48,13,SS_CENTERIMAGE
+    CTEXT           "Site",IDC_STATIC,7,72,48,13,SS_CENTERIMAGE
+    EDITTEXT        IDC_VERSION,57,40,149,13,ES_AUTOHSCROLL
+    EDITTEXT        IDC_CONFIG,57,56,149,13,ES_AUTOHSCROLL
+    EDITTEXT        IDC_SITE,57,72,149,13,ES_AUTOHSCROLL
+    CTEXT           "CMT installation setup",IDC_STATIC,7,7,199,12,
+                    SS_CENTERIMAGE
+    PUSHBUTTON      "Install",IDC_INSTALL,91,151,35,13,BS_CENTER | 
+                    BS_VCENTER
+    CTEXT           "Path",IDC_STATIC,7,89,48,13,SS_CENTERIMAGE
+    LISTBOX         IDC_PATH,57,88,149,59,LBS_SORT | LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP
+    PUSHBUTTON      "Uninstall",IDC_UNINSTALL,129,151,47,13,BS_CENTER | 
+                    BS_VCENTER
+    PUSHBUTTON      "Edit",IDC_EDITPATH,29,111,26,11
+    PUSHBUTTON      "Exit",IDC_EXIT,179,151,27,13
+END
+
+IDD_TEXTEDIT DIALOG DISCARDABLE  0, 0, 137, 46
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Dialog"
+FONT 8, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,7,25,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,80,25,50,14
+    EDITTEXT        IDTE_TEXT,7,7,123,12,ES_AUTOHSCROLL
+END
+
+IDD_LISTEDIT DIALOGEX 0, 0, 235, 122
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Dialog"
+FONT 8, "MS Sans Serif", 0, 0, 0x1
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,7,101,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,61,101,50,14
+    LISTBOX         IDLE_LIST,7,7,221,85,LBS_NOINTEGRALHEIGHT | 
+                    LBS_DISABLENOSCROLL | WS_VSCROLL | WS_HSCROLL | 
+                    WS_TABSTOP,WS_EX_ACCEPTFILES
+    PUSHBUTTON      "Add",IDLE_ADD,123,101,50,14
+    PUSHBUTTON      "Remove",IDLE_REMOVE,178,101,50,14
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    IDD_DIALOG1, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 206
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 164
+    END
+
+    IDD_TEXTEDIT, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 130
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 39
+    END
+
+    IDD_LISTEDIT, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 228
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 115
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+IDR_MENU MENU DISCARDABLE 
+BEGIN
+    POPUP "File"
+    BEGIN
+        MENUITEM "Quit",                        ID_FILE_QUIT
+    END
+END
+
+#endif    // French (France) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
Index: /CMT/v1r20/src/os9make.header
===================================================================
--- /CMT/v1r20/src/os9make.header	(revision 368)
+++ /CMT/v1r20/src/os9make.header	(revision 368)
@@ -0,0 +1,33 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+#---------------------------------------------------------
+#
+#  Automaticaly generated Makefile.
+#
+#  Install private stuff after the "User area" flag.
+#
+#---------------------------------------------------------
+
+CFLAGS  =
+
+cflags  = $(CFLAGS)
+cc      = cc
+
+src     = ../src/
+mgr     = ../mgr/
+bin     = ../BIN/
+lib     = ../LIB/
+
+ccomp   = $(cc)  -c -I$(src) $(cflags)
+comp    = $(ccomp)
+
+link    = $(cc)
+libgen  = libgen
+
+
+
+
Index: /CMT/v1r20/src/setup.bat
===================================================================
--- /CMT/v1r20/src/setup.bat	(revision 368)
+++ /CMT/v1r20/src/setup.bat	(revision 368)
@@ -0,0 +1,19 @@
+
+
+@echo off
+
+rem 
+rem Copyright Christian Arnault LAL-Orsay CNRS
+rem arnault@lal.in2p3.fr
+rem See the complete license in cmt_license.txt "http://www.cecill.info". 
+rem 
+
+set here=%cd%
+cd /D %~d0%~p0
+cd ..
+set CMTROOT=%cd%
+cd /D %here%
+
+set CMTBIN=VisualC
+if not defined CMTCONFIG set CMTCONFIG=%CMTBIN%
+set PATH=%CMTROOT%\%CMTBIN%;%PATH%
Index: /CMT/v1r20/src/setup.csh
===================================================================
--- /CMT/v1r20/src/setup.csh	(revision 368)
+++ /CMT/v1r20/src/setup.csh	(revision 368)
@@ -0,0 +1,53 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+setenv CMTBIN `uname`-`uname -m | sed -e 's# ##g'`
+
+if ( $?CMTCONFIG == 0 ) then
+  setenv CMTCONFIG `${CMTROOT}/mgr/cmt_system.sh`
+endif
+
+if ( `basename "$SHELL"` == "tcsh" ) then
+  source ${CMTROOT}/src/setup.tcsh
+endif
+
+set newpath=
+
+foreach p ( `echo ${PATH} | sed 's#:# #g'` )
+  echo ${p} | egrep '/CMT/' >& /dev/null
+  set s=${status}
+  if ( "${s}" != 0 ) then
+    if ( ${newpath} == "" ) then
+      set newpath=${p}
+    else
+      set newpath=${newpath}:${p}
+    endif
+  endif
+end
+
+setenv PATH ${newpath}:"${CMTROOT}/${CMTBIN}"
+alias cmt '${CMTROOT}/${CMTBIN}/cmt.exe'
+
+if ( $?CLASSPATH == 0) then
+  setenv CLASSPATH ${CMTROOT}/java
+else
+  set newpath=
+  foreach p ( `echo ${CLASSPATH} | sed 's#:# #g'` )
+    echo ${p} | egrep '/CMT/' >& /dev/null
+    set s=${status}
+    if ( "${s}" != 0 ) then
+      if ( ${newpath} == "" ) then
+        set newpath=${p}
+      else
+        set newpath=${newpath}:${p}
+      endif
+    endif
+  end
+
+  setenv CLASSPATH ${newpath}:${CMTROOT}/java/cmt.jar
+endif
+
+alias jcmt '(java cmt_parser)'
Index: /CMT/v1r20/src/setup.sh
===================================================================
--- /CMT/v1r20/src/setup.sh	(revision 368)
+++ /CMT/v1r20/src/setup.sh	(revision 368)
@@ -0,0 +1,46 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+CMTBIN=`uname`-`uname -m | sed -e 's# ##g'`; export CMTBIN
+
+if test "${CMTCONFIG}" = "" ; then
+  CMTCONFIG=`${CMTROOT}/mgr/cmt_system.sh`; export CMTCONFIG
+fi
+
+
+eval function b {} 1>/dev/null 2>&1
+if test "$?" = "0"; then
+. ${CMTROOT}/src/setup.zsh
+fi
+
+newpath=""
+for p in `echo ${PATH} | sed 's/:/ /g'`; do
+  if test ! "`echo ${p} | egrep CMT`" ; then
+    if test "${newpath}" = "" ; then
+      newpath=${p}
+    else
+      newpath=${newpath}:${p}
+    fi
+  fi
+done
+
+PATH=${newpath}:${CMTROOT}/${CMTBIN}; export PATH
+alias cmt='${CMTROOT}/${CMTBIN}/cmt.exe'; export cmt
+
+newpath=""
+for p in `echo ${CLASSPATH} | sed 's/:/ /g'`; do
+  if test ! "`echo ${p} | egrep CMT`" ; then
+    if test "${newpath}" = "" ; then
+      newpath=${p}
+    else
+      newpath=${newpath}:${p}
+    fi
+  fi
+done
+
+CLASSPATH=${newpath}:${CMTROOT}/java/cmt.jar; export CLASSPATH
+
+alias jcmt='(java cmt_parser)'; export jcmt
Index: /CMT/v1r20/src/setup.tcsh
===================================================================
--- /CMT/v1r20/src/setup.tcsh	(revision 368)
+++ /CMT/v1r20/src/setup.tcsh	(revision 368)
@@ -0,0 +1,26 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# modified by garonne@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+complete cmt p/1/'(broadcast build check check_files checkout co cleanup config create expand filter help lock relocate remove run setup show system unlock version cvstags cvsbranches cvssubpackages cvssubprojects)'/ \
+ n/build/'(CMT_pacman constituent_makefile constituents_makefile dependencies library_links make_setup msdev os9_makefile prototype readme tag_makefile temporary_name triggers win_makefile)'/ \
+ n/show/'(action action_names action_value actions all_tags applied_patterns author branches clients cmtpath_patterns constituent constituent_names constituents cycles fragment fragments groups include_dirs language languages macro macro_names macro_value macros manager packages path pattern patterns projects project_author pwd set set_names set_value sets strategies tags use_paths uses versions)'/ \
+ n/check/'(configuration files version)'/ \
+ n/expand/'(model)'/ \
+ n/constituent/'`cmt -quiet show constituent_names`'/ \
+ n/fragment/'`cmt -quiet show fragments | sed -e "s#.*fragments.##" `'/ \
+ n/action/'`cmt -quiet show action_names | sed -e "s#=.*##" `'/ \
+ n/action_value/'`cmt -quiet show action_names | sed -e "s#=.*##" `'/ \
+ n/build/'(CMT_pacman constituent_makefile constituents_makefile dependencies library_links make_setup msdev os9_makefile prototype readme tag_makefile temporary_name triggers win_makefile)'/ \
+ n/broadcast/'(-begin= -select= -exclude= -local -global -depth=)'/ \
+ n/macro/'`cmt -quiet show macro_names | sed -e "s#=.*##" `'/ \
+ n/macro_value/'`cmt -quiet show macro_names | sed -e "s#=.*##" `'/ \
+ n/pattern/'`cmt -quiet show pattern_names`'/ \
+ n/set/'`cmt -quiet show set_names | sed -e "s#=.*##" `'/ \
+ n/set_value/'`cmt -quiet show set_names | sed -e "s#=.*##" `'/ \
+ n/triggers/'`cmt -quiet show constituent_names`'/ \
+ n/co/'(-l,-R,-r,-d,-o,-requirements)'/ \
+ n/checkout/'(-l,-R,-r,-d,-o,-requirements)'/
Index: /CMT/v1r20/src/setup.zsh
===================================================================
--- /CMT/v1r20/src/setup.zsh	(revision 368)
+++ /CMT/v1r20/src/setup.zsh	(revision 368)
@@ -0,0 +1,48 @@
+#-----------------------------------------------------------
+# Copyright Christian Arnault LAL-Orsay CNRS
+# arnault@lal.in2p3.fr
+# Modified by garonne@lal.in2p3.fr
+# See the complete license in cmt_license.txt "http://www.cecill.info". 
+#-----------------------------------------------------------
+
+function cmt_macros { reply=(`cmt -quiet show macro_names`)}; \
+   function cmt_actions { reply=(`cmt -quiet show action_names`)}; \
+   function cmt_sets { reply=(`cmt -quiet show set_names`)}; \
+   function cmt_constituents { reply=(`cmt -quiet show constituent_names`) }; \
+   function cmt_fragments { reply=(`cmt -quiet show fragments | sed 's#.*/fragments/##'`)}; \
+   function cmt_default_path { d=`dirname ${CMTROOT}`; reply=(`dirname ${d}`) }; \
+   function cmt_patterns { reply=(`cmt -quiet show pattern_names`) }; \
+   compctl -k '(broadcast,build,check,check_files,checkout,co,cleanup,config,create,create_project,expand,filter,help,lock,relocate,remove,run,setup,show,system,unlock,version,cvstags,cvsbranches,cvssubpackages,cvssubprojects)' -x \
+   'c[-1,broadcast]' -k '(-begin=,-select=,-exclude=,-local,-global,-depth=)' - \
+   's[build],c[-1,build]' -k '(CMT_pacman, constituent_makefile,constituents_makefile,dependencies,library_links,make_setup,msdev,os9_makefile,prototype,readme,tag_makefile,temporary_name,triggers,win_makefile)' - \
+   'w[1,build] c[-1,constituent_makefile]' -K cmt_constituents - \
+   'w[1,build] c[-1,triggers]' -K cmt_constituents - \
+   'c[-1,check]' -k '(configuration,files,version)' - \
+   'w[1,create] p[2]' -X '> give package name' - \
+   'w[1,create] p[3]' -X '> give version tag' - \
+   'w[1,create] p[4]' -X '> give a path if not created from current path' - \
+   's[expand],c[-1,expand]' -k '(model)' - \
+   'w[1,remove] p[2]' -X '> library_links or give package name' - \
+   'w[1,remove] p[3]' -X '> give version tag' - \
+   'w[1,remove] p[4]' -X '> give a path if not located from the current path ' - \
+   's[show],c[-1,show]' -k '(action,action_names,action_value,actions,all_tags,applied_patterns,author,branches,clients,cmtpath_patterns,constituent,constituent_names,constituents,cycles,fragment,fragments,groups,include_dirs,language,languages,macro,macro_names,macro_value,macros,manager,packages,path,pattern,patterns,projects,project_author,pwd,set,set_names,set_value,sets,strategies,tags,use_paths,uses,versions)' - \
+   'w[1,show] c[-1,constituent]' -K cmt_constituents - \
+   'w[1,show] c[-1,fragment]' -K cmt_fragments - \
+   'w[1,show] c[-1,action]' -K cmt_actions - \
+   'w[1,show] c[-1,action_value]' -K cmt_actions - \
+   'w[1,show] c[-1,macro]' -K cmt_macros - \
+   'w[1,show] c[-1,macro_value]' -K cmt_macros - \
+   'w[1,show] c[-1,pattern]' -K cmt_patterns - \
+   'w[1,show] c[-1,set]' -K cmt_sets - \
+   'w[1,show] c[-1,set_value]' -K cmt_sets - \
+   'c[-1,co]' -k '(-l,-R,-r,-d,-o,-requirements)' - \
+   'c[-1,checkout]' -k '(-l,-R,-r,-d,-o,-requirements)' - \
+   'c[-1,-r]' -X 'give a CVS tag' - \
+   'c[-1,-d]' -X 'give a directory name' - \
+   'c[-1,-o]' -X 'give an offset in the CVS repository' - \
+   'c[-1,-requirements]' -f - \
+   'c[-1,co]' -X 'give package name' \
+   --  cmt.exe
+
+
+
