# Release notes

> Notation
> - New features
> - Bug fixes
> - Internal management

- v1r26p20160527, v1r25p20160527
  - For "cmt checkout" command, in case of trunk checkout, skip the check whether trunk corresponds to a particular tag if CMTHEADVERSION environment variable is unset, its value is empty, or starts with '!'
  - Do not produce error for "cmt show uses" command run in "cmt_standalone" package context
- v1r26p20140131, v1r25p20140131
  - Implement enhanced cached requirements file generation, with "cmt setup -requirements" command, i.e., resolve sets for macros if possible, resolve paths fully if possible, so as to strip path of non-existent directories by default, explicitly controlled by options -(no)_strip_path
  - Implement enhanced usage of cached requirements file by reading additional flags from requirements file, e.g., with "cmt run <command>"
  - In "cmt show tags" command output, print uses in which apply_tag statement appears for tag
  - Make -tag_remove=<tag-list> option functional on any tags (rather than only those specified on the command line or in CMTEXTRATAGS environment variable)
  - For "cmt broadcast" command, implement enhanced handling of special CMTHOME, CMTUSERCONTEXT projects packages - visited if in current project only or with special depth values (0: CMTUSERCONTEXT project packages only, -1: CMTHOME project packages only)
  - Make requirements file in special CMTHOME, CMTUSERCONTEXT projects non-mandatory
  - Add support for devbranches directory - additional branches location - in Subversion repository
  - Make -use=<package>:<version>:<path> option fully functional with standard use statement syntax, make -path=<path> option functional for relative <path> as with standard use statement syntax, e.g.,

        pattern find_pkg \
          macro <package>_find_<pkg> "`cmt -q -use=<pkg>:<ver>:<offset> check configuration&&echo <package>_<pkg>_found||echo <package>_<pkg>_not_found`" ; \
          apply_tag $(<package>_find_<pkg>)

        pattern use_pkg_if_found \
          apply_pattern find_pkg pkg=<pkg> ver=<ver> offset=<offset> ; \
          macro <package>_<pkg>_info "" <package>_<pkg>_found "<pkg> <ver> <offset>" ; \
          use $(<package>_<pkg>_info)

        apply_pattern use_pkg_if_found pkg=MyExtraPatterns ver=*

  - Fully resolve set values in setup scripts for consistency
  - Make fixes/improvements to source files dependencies generator (reported by Joerg Stelzer)
  - Improve diagnostics messages for project file syntax errors
  - Optimise and improve CMT shell setup and cleanup scripts
  - Optimise and make cleaner initial configuration procedure
  - General performance optimisation
  - Optimise "cmt checkout" command performance (algorithm suggested by Wim Lavrijsen), introduce SVNDEBUG environment variable to facilitate debugging
  - Work around Make errors if stamps files do not exist
- v1r25p20130606
  - Exclude aliases from the output of commands "cmt show set_names", "cmt show sets" (requested by David Quarrie)
  - Allow for possibly multi-line output of commands in command substitution (introduced with backquotes, `COMMAND`)
  - Detect clang compiler on Mac OS X platform
  - Parse includes acquired via include_dirs statement for imported uses
  - For applications belonging to "check" group, ensure that application is built before running check (reported by Andrei Kazarov and Andrei Salnikov)
  - Fix cleanup of libraries for Darwin platform
  - Ensure that *.in files are cleaned up in binary tag directory only (reported by Andrei Kazarov)
  - Optimise makefile fragments so that implicit rule is not searched for
- v1r26
  - Compile dependent applications, libraries in parallel for build time optimisation
  - For applications and libraries, introduce options -modules and -no_modules (default), to be used if they are built with files in languages with modules (like Fortran 90 and later). Necessary, in order to compile applications, libraries dependent upon application, library with -modules option after compiling latter
  - Exclude aliases from the output of commands "cmt show set_names", "cmt show sets" (requested by David Quarrie)
  - Allow for possibly multi-line output of commands in command substitution (introduced with backquotes, `COMMAND`)
  - Detect clang compiler on Mac OS X platform
  - Parse includes acquired via include_dirs statement for imported uses
  - For applications belonging to "check" group, ensure that application is built before running check (reported by Andrei Kazarov and Andrei Salnikov)
  - Fix cleanup of libraries for Darwin platform
  - Optimise makefile fragments so that implicit rule is not searched for
- v1r25
  - Implement commands "cmt show alias", "cmt show alias_names", "cmt show alias_value", "cmt show aliases" (requested by David Quarrie)
  - Implement enhanced mechanism of source files dependencies generation at compilation time making use of -MMD preprocessor option for C/C++ libraries/applications, to enable, tag c_native_dependencies/cpp_native_dependencies should be activated
  - In setup/cleanup scripts, unset set variables only to work around Z Shell unset builtin command being POSIX non-conformant (exit code of 1 on unset variables)
  - Fix/improve prototypes handling (reported by Andrei Kazarov and Franco Carbognani)
  - Optimise internal source files dependencies generator, command "cmt build dependencies" (make more than 4 times faster)
  - Optimise requirements files parsing (make ~ 2 times faster), optimise string manipulation functions
  - Make use of system functions realpath (POSIX) and _fullpath (Windows)
  - Introduce use member to hold canonicalized absolute realpath so as not to re-calculate it several times
  - Optimise/improve paths handling
  - Optimise CMT setup scripts by reducing the number of processes
  - Improve error handling
- v1r24
  - Optimise and enhance "cmt build dependencies" command so that it makes use of files and include directories from CLI input, of input file dependencies[_CONSTITUENT].in, generate dependencies[_CONSTITUENT].in files
  - Optimise and enhance "cmt build/remove library_links" commands so that they make use of input file library_links.in, generate library_links.in file
  - Pass necessary for script $(make_shlib) macro values via environment, in cmt_make_shlib_common.sh script, take necessary macro values from environment, if available, rather than invoke CMT multiple times
  - Introduce and implement BCAST mode (set CMTBCAST to non-empty string) to build all used packages of the current package with "(cmt) make". If run in the project container, builds the whole project. Using Make -j option (number of job slots, not available with NMake on Windows), this mode allows to parallelise independent packages builds and, depending on project structure and number of processors, may be significantly (several times) faster than "cmt broadcast make".
  - By default, set MAKEFLAGS, if unset, to set number of job slots to number of processors, and enable CMT QUICK mode
  - In QUICK mode, rebuild constituent(s) or broadcast (N)Makefile and corresponding macros files, if any requirements file changes only
  - In QUICK mode, run "cmt build/remove library_links" commands with library_links input file, if any requirements file changes only
  - In QUICK mode, files dependencies are always rebuilt, if a file or its dependency change
  - Implement dynamic help messages on variables targets available for BCAST mode
  - Add package selection criterion based on <package>_native_version (-native_version=VERSION option) in case of CMT structuring style without_version_directory (similarly to style with_version_directory)
  - Enhance/fix command completions for TCSH, ZSH, implement command completion for BASH
  - Make "cmt check configuration" command exit with error, if non-constant cmtpath_pattern found for package outside CMTPATH - cannot be applied
  - Do not keep .DEFAULT target in constituents Makefile, if PEDANTIC is defined
  - Ensure document source files dependencies get rebuilt whenever source file or its dependencies change
  - Make uninstall target (rather than clean target) dependent on remove_library_links target to ensure library links uninstallation
  - Implement error handling for "cmt create" command
  - Make "cmt build dependencies" command exit with error, if path specified for dependencies calculation is not found
  - In class CmtSystem functions, check return value of system functions and propagate it via return value, or via setting error, and/or by printing error message
  - Enhance error handling for input files generation, if fragment is not found
  - In (un)install_action.sh(.bat) scripts, exit with error on file command or reference file command error
  - Print help info on stdout (rather than stderr)
  - In class cmt_regexp, introduce and implement clear function, use it in classes Use, Project
  - In class CmtGenerator, remove prepare_use_context function, m_deps_builder member
  - Do not assign target_<name> tag to document corresponding to action by default but only if this tag is used in tag or symbol expression
  - For all constituents with -target_tag option, assign associated tag target_<name> only if this tag is used in tag or symbol expression
  - Incorporate call to do_check_configuration into function do_build_constituents_config
  - Print warning message if package requested for import cannot be imported for constituent without target tag during cmt build constituents_config, otherwise during cmt build constituent_config
  - Make constituent name optional for "cmt build dependencies" command
  - In (N)Makefile fragments, specify explicit empty command in (un)install, check target rules (for optimisation, to avoid implicit rule search)
  - In class CmtError, introduce system_error code
  - On Windows, use _unlink, _chmod, _putenv instead of deprecated - beginning in Visual C++ 2005 - POSIX names functions
- v1r23
  - Ensure that all sub-uses of packages imported with -import=<package> constituent option are also imported recursively if not imported yet and not specified with -no_auto_imports option
  - Provide tag activation context in "cmt show tags" command output, if does not duplicate already printed information
  - In "cmt check configuration" command, if current use is outside CMTPATH, issue warning or set error, provided [CMT]PEDANTIC environment variable is set
  - Ensure head version (matching CMTHEADVERSION environment variable, or HEAD or head) satisfies any use request and takes precedence
  - When generating setup/cleanup scripts, ensure sets, paths names are converted into valid shell variable names (issuing corresponding message if replacement happens)
  - Rename cmt/version.cmt and issue warning if under version control and checked out with CMT structuring style with_version_directory
  - Optimise fragment search, issue warning, if not found
  - Improve error handling, diagnostic and help messages for some commands
  - Improve handling of -no_auto_imports option of use statement, ensure "cmt show uses" command shows where auto_imports state gets set
  - Improve handling of -f=<file> option
  - Make option -e=<extra-statement(s)> functional
  - Reduce the number of reads of requirements files tree by generating input requirements file for constituent(s) without associated tag in one CMT invocation. Then from it, generate constituent Makefile
  - When building CMT with GNU Make, allow for user overrides/extra flags via CXXFLAGS, LDFLAGS, TARGET_ARCH variables
  - Reduce the number of pwd function invocations
- v1r22
  - Introduce option -requirements for command "cmt setup" to generate standalone requirements file from which generate setup script
  - Introduce option -xml to produce output in XML format (with document type definition), currently for commands "cmt setup", "cmt show projects", "cmt show uses" (requested by Marco Clemencic)
  - Ensure QUICK mode can be used for from scratch build (requested by RD Schaffer)
  - Introduce command "cmt build constituents_config" to generate constituents Makefile, tag specific Makefile, and setup definitions file, and "cmt build constituent_config" to generate constituent Makefile fragment, tag specific Makefile, and setup definitions file at the same time (rather than use 3 commands) for build time optimisation
  - Ensure CMTSTRUCTURINGSTYLE environment variable setting be functional with "cmt co" command
  - Enhance cleanup of setup temporary files
  - Make "cmt show tags" commands more informative, i.e. show list of packages which imply tags for particular tag (rather than last package from list)
  - When several alternative values are specified through several tag-value pairs, select the first matching condition (rather than based on conditions priorities)
  - For -no_static mode, generate <library>.stamp in addition to <library>.shstamp
  - Projects (other than current project) coming from CMTPATH entries are not ignored in case current project does not have parents
  - Enhance error handling in NMakefiles
  - To generate setup/cleanup scripts for standalone package, use same functions as for standard packages
  - In case of project requested with conflicting releases, issue warning, do not set CmtError
  - Add optional argument of type ostream for several functions
  - Do not use Makefile common_target to have one process fewer
- v1r21
  - Introduce and implement "cmt show container [<path>]..." command. Apply tag container_package if current package is container package of project (requested by Marco Clemencic)
  - Introduce new setup strategy with values scripts and no_scripts. Do not generate (or remove existing) cleanup and setup scripts if setup_strategy includes no_scripts (requested by David Rousseau and RD)
  - Implement new options -C (for context), -i (for info) of "cmt co|checkout" command
  - Make options -R (recursive checkout) and -requirements (checkout from requirements file) functional with Subversion
  - Introduce the CMTHEADVERSION environment variable to hold the string that is written into the version.cmt file on "cmt checkout" of the package's trunk when it is different from any existing tag. The value may contain the templates <package>, <PACKAGE>, <revision>, where <revision> is replaced with last_changed_rev of the trunk
  - Introduce cmt_parallel_bins tag to enable locking mechanism which allows for simultaneous/parallel builds for multiple binary tags (not activated by default)
  - Use command specified by macro "devenv_command" to retrieve version of Microsoft (R) Visual Studio and define a corresponding tag (vs<digit(s)>). Set macro devenv_command to "devenv /?" if VS (for Visual Studio) tag is activated (not activated by default)
  - Use system dependent size PATH_MAX for path name arrays instead of 256 (requested by Francesco Prelz)
  - Print warning in current package, when package applies an undefined pattern. When building constituents makefile, print a warning message if a package requested for import for a constituent cannot be imported (requested by Sebastien Binet)
  - Make behaviour wrt package versions matching consistent for both package structuring styles (with_version_directory and without_version_directory). In version specification, v* matches any version as well as *
  - Allow for doing setup with setup scripts generated by "cmt config" from any place (with a correct CMTPROJECTPATH), resolving ticket #57
  - Enhance/Improve error handling in general, diagnostic and help messages
  - Exit with an error on file (including stdout) write errors
  - Upon execution of setup.[c]sh, cleanup.[c]sh scripts, exit with a non-zero status on failure, taking into account failures of user provided setup, cleanup scripts
  - Improve projects ordering
  - Optimise retrieval of Mac OS version
  - Introduce diagnostic function for CMTVERBOSE level
  - Do not use "no_version_style"
- v1r20p20090520
  - Implement the generation of dependencies Makefiles (one per source file) making use of the language compiler (preprocessor)

        The corresponding compiler options should be passed via the -dependencies_options=OPTIONS option of the language

        Define the cppdepflags, cdepflags macros that hold the compiler options to generate dependencies for Linux,
        Darwin, VisualC when the tags cpp_native_dependencies, c_native_dependencies are activated

        Pass cppdepflags, cdepflags to the c++, c languages as defined by CMT

        Introduce mgr/cmt_format_deps.sh(.bat) scripts to be used for the generation of one dependencies (N)Makefile
        per source file, define the format_dependencies macro via the introduced scripts

        NOTE: To use the feature, the tags cpp_native_dependencies, c_native_dependencies need to be activated
        (not activated by default)

  - Implement the generation of dependencies depending on the files modifications rather than every time NMake is run for Windows

        Same as for Unix-like systems

  - Complete the message of the "cmt make help" command
  - If the Verbose level is activated (the CMTVERBOSE environment variable is set to a non-empty string), check whether the names of different packages in upper case coincide and issue a warning appropriately, print a warning message when an undefined pattern is referenced
  - For Darwin, build statically linked (archive) libraries with "libtool", the recommended way
  - Add the possibility to do checkout of CMT packages from Subversion repository via the "cmt checkout" command

        The choice between CVS and Subversion is made based on which environment variable - CVSROOT or SVNROOT - is set

        For checkout from Subversion repository, the command specified via macro svn_checkout_command (set by CMT to
        mgr/cmt_svn_checkout.py, based on Subversion Python bindings) is used

        CVS checkout is done via the CVS command line client

  - Ensure that the <constituent>_use_linkopts macro is set in case the constituent -import=<package> options effectively import nothing
  - Ensure that the use_stamps macro is set taking into account the -no_auto_imports options
  - Ensure that command "cmt show groups" is functional
  - Use POSIX conformant syntax for shell utilities
  - Ensure that dangling symbolic links can be uninstalled
  - Ensure "cmt checkout" command exit status is set to a nonzero value on error
  - Optimise the retrieval of the Mac OS version
  - In the QUICK mode, generate $(cmt_local_tagfile) if non-existent
  - Ensure that uninstallation (make uninstall) be done in reverse build order (for Unix-like systems for now)
  - Remove the connection between clean and uninstall targets for Windows - same as for Unix-like systems
  - Add .make .stamp .cxx to the list of known suffixes and a rule with an empty command for $(use_requirements) for optimisation
  - Change the names of the files recording the setup to $(bin)setup.(n)make and $(bin)setup_${CONSTITUENT}.(n)make
  - Make the READONLY mode obsolete (the relocation of the binary build directory provides this functionality as well)
- v1r20p20081118
  - Implement the -no_static option for libraries

        by default both static and shared library are built

  - Introduce diagnostic messages levels: Debug, Info, Warning, Error, Fatal

        Default value: Info, the level to use can be configured using the environment variables
        CMTDEBUG, CMTINFO, CMTWARNING, CMTERROR, CMTFATAL (in order of precedence) if set to a non-empty string
        and/or the existing command line options -warnings (Warning), -disable_warnings (Error), -quiet (Fatal)

  - Use diagnostic messages prefix consistently

        default value: #CMT--->, can be configured using the environment variable CMTMSGPREFIX

  - Retrieve the package version when structuring style used is `without_version_directory' from:

        1) cmt/version.cmt file if available (and readable)
        2) version statement in the package requirements file

  - Allow for the relocation of the binary build directory

        via redefinition of the bin macro. E.g., macro bin "$(TMPDIR)/$(package)" in ${CMTUSERCONTEXT}/requirements, then
        $ cmt make

  - Add the -rs suffix option to the cmt checkout command

        E.g.,
        $ cmt co packagename -rs -00-01-02
        same as
        $ cmt co packagename -r packagename-00-01-02
        (proposed by David Rousseau)

  - Correct CMTPATH entries ordering and the application of cmtpath_pattern's in case of diamond project hierarchy
  - Correct the setting of macros in case the -import option of constituents is used so as to import what is requested only
  - Correct handling of the requirements file in ${CMTHOME} and/or ${CMTUSERCONTEXT} if specified and exist
  - Correct cmt broadcast in case of symlinks in the paths
  - Correct the handling of the -with_version_directory and -without_version_directory command line options with cmt checkout
  - Introduce the CMTFLAGS environment variable (set up automatically) in order to contain command line options (currently, to configure the diagnostic messages level and the structuring style) so as to pass the flags to recursive cmt invocations. If CMTFLAGS exists in the environment, the flags from it are processed before the command line options
  - Do not set macro ${CONSTITUENT}linkopts, use $(cmt_installarea_linkopts) with $(${CONSTITUENT}_use_linkopts) instead of $(use_linkopts) for applications
  - Generate the BIN macro to hold an absolute path for the path specified by the bin macro
- v1r20p20080222
  - Control the verbosity of Make

        by setting the following Make variables (in order of precedence):
        VERBOSE - print CMT messages and echo Make commands
        QUIET - print CMT messages (default)
        ECHO - echo Make commands
        SILENT - no CMT messages or Make commands echoing
        NOTE: In order to have user provided CMT documents (makefile fragments) controlled
        by these switches, the CMT document author
        - will not prefix command lines with @ (or prefix with macro $(silent))
        - will print messages (if any) starting a separate command line with macro $(echo)
        (see, e. g., mgr/fragments/tex)

  - Control the prefix of the CMT messages

        via the Make variable CMTMSGPREFIX (default value: #CMT--->)

  - Correct the passing of (N)Make options for recursive (N)Make invocations
  - Ensure CVS operations are retried in case of failure
  - Optimise a number of internally used scripts by reducing the number of processes (used a patch from KELEMEN Peter)
  - Correct the handling of the -with_version_directory and -without_version_directory command line options
  - Ensure the dependencies are re-calculated whenever the included files are changed (the problem pointed out by Marco)
  - Improve the handling of symlinks in the paths
  - Do not rebuild any *.make files when Make variable QUICK is defined

        This may be used to save time when developing a package code without changing configuration or source files dependencies

  - Make use of the structuring style, when configuring a package without a version.cmt file, to allow the use of digits in package names of such packages structured without a version directory. Improve diagnostic messages for this case
  - Allow simultaneous/parallel builds for multiple binary tags (used suggestions from Pere, Stefan, and Andrea):

        - build all the makefiles in the binary tag directory
        - implement a locking mechanism
        The mechanism is in effect for CMT documents if
        macros lock_command, unlock_command are set to non-empty strings (default).
        Then, command ${lock_command} ${CONSTITUENT}${lock_suffix} is run by CMT to create the lock file in the package cmt directory
        before the document ${CONSTITUENT} is built,
        and command ${unlock_command} ${CONSTITUENT}${lock_suffix} is run by CMT to remove the lock file
        after the document ${CONSTITUENT} is built.
        The assumption is that while CMT applications, and libraries for different binary tags deal with different files,
        documents for different binary tags may deal with (e. g., build, install)
        the same files (e. g., header files). The locking mechanism is to ensure the documents are done one at a time

  - Implement an optional header file filter mechanism to replace header files matching a pattern with a stamp file when calculating files dependencies

        The mechanism is in effect if there is a package which
        - sets macro <package>_header_file_filter (to a regular expression)
        - sets macro <package>_header_file_stamp to a path of an existing file
        or file $(PACKAGE_ROOT)/cmt/cmt_header_file.stamp exists.
        Then, each header file whose path matches one of the regular expressions (if several packages activate the mechanism)
        is replaced with the corresponding stamp file in the dependency calculation and
        its dependencies are not examined. This may reduce the dependencies calculation time significantly.
        Example:
        macro Boost_header_file_filter $(Boost_home)/include/boost-$(Boost_file_version)
        macro Boost_header_file_stamp $(Boost_home)/include/boost-$(Boost_file_version)/boost/any.hpp
        The dependencies of the source files including Boost header files will only include the any.hpp file path.

- v1r20p20070720
  - Fix the generation of source files dependencies
  - Fix the `cmt show version' command
- v1r20p20070524
  - activate the support to PWD env. var.
  - Send error & warning messages to stderr instead of stdout.
  - Fix cvs interface.
  - Make use of the $(jar) macro
- v1r20p20070208
  - Disable the creation of `<project>_ROOT/CONFIG` variables for the PACKAGE_POLICY_FOR_`<project>` virtual package
- v1r20
  - Add support for the -import=PkgA,PkgB,... syntax:

        library Lalib   *.cpp -import=A,C

  - Extend the project syntax to support macros/tags. E.g.:

                project Project

                author garonne

                use P1 v1.*

                container container v1

                # Policy definitions used by all packages belonging to this project
                tag ATLAS

                macro use_build_strategy "without_installarea" \
                           ATLAS "with_installarea"

                macro use_setup_strategy "no_root" \
                               ATLAS "root"

                macro use_structure_strategy "with_version_directory" \
                               ATLAS "without_version_directory"

                build_strategy     $(use_build_strategy)
                setup_strategy     $(use_setup_strategy)
                structure_strategy $(use_structure_strategy)
                ...

  - Extend the strategy syntax for supporting variable, e.g.:

                macro use_strategy "without_installarea" \
                           ATLAS "with_installarea"

                build_strategy $(use_strategy)

  - Enable the package selection by native_version requirements:

        use foo -native_version=2.0

    To activate this feature, it is necessary to execute the `cmt config` in all packages to create for each eligible package a `cmt/native_version.cmt` file generated from the `<package>_native_version macro` and used for the package selection.
  - Add macros $(${GROUP}_pre_constituents), $(${GROUP}_post_constituents) for ordering targets executed by default during make execution.
  - Correct problems with the cxx pre-compiler parser for dealing with continuation character, space, etc. This problem created in some case the missing dependencies problem with previous releases (Thanks to Scott Snyder, see bug report).
  - Fix bugs with `-no_auto_imports`.
  - Return status code when executing make by the `"cmt make"` action name.
  - Correct the fact that a `"apply_tag"` protected by a private section is exported in all the client packages.
- v1r19
  - Add support for wildcarded project dependencies which Allow CMTPROJECTPATH overrides, e.g.: use project v*.
  - Support for the author keyword at the project level and the corresponding command is `cmt show project_author` to obtain it from command line.
  - Extend the strategy syntax for supporting variable, e.g.:

                macro use_strategy "without_installarea" \
                           ATLAS "with_installarea"

                build_strategy $(use_strategy)

  - Add a option to bypass the `cmt config` step after the cvs checkout: `cmt co -no_config ...`.
  - Add a new traversal mode for the cmtpath_pattern: `cmtpath_pattern_revert`. This is for constructing macro from current project to projects used (Atlas's request).
  - Disable warning about tags,e.g. CMTSITE. To re-enable them you should use cmt with the `-warnings` option.
  - Introduce the pre-compiler __APPLE__ macro for removing compilation warnings.
- v1r18p20061003
  - Correct problem with long word during compilation which reach make limit(Atlas's request).
- v1r18p20060606
  - Add a touch functionnality, e.g. `cvs co -t package`, 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.
  - 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. `make STRUCTURED_OUTPUT=1`. For more informations see the following Bug report.
  - Supress the n repeated entries in the CMTPATH after the first found occurence.
  - Add the cvs `"-f"` 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.
  - Translate symlinks for the `cmt show packages` command.
  - 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.
  - Correct problems when checkouting successively the same package with a different tag in the `without version directory`mode.
  - Compute the project of the package when expanding the template to fix packages with offset .
- v1r18p20051101
  - Add a new standard macro definition `$(q)` 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
  - The `pacman` source file for CMT now includes a constraint on the version of Pacman.
  - Added a mechanism to filter out bad items in a PATH symbol. This was causing troubles at `source setup` time
  - Added a protection against old protocols in the CVS pluggin
  - Better support of release-less projects on Windows
  - Added a protection against single level directories in CMTPATH
  - Added a protection against unexisting makefile fragments when running the `clean` target.
  - The definition of standard macros was not properly set when using the `cmt broadcast` command. Thus environment variables where badly preset.
  - Improve the automatic preparation of CMT releases
  - The internal `Makefile` structure has been cleaned up to remove obsolete internal targets (leading to confusing behavours in some cases)
- v1r18p20050901
  - Package creation (either from the `cmt create` or the `cmt co` commands is affected by the specification of the structuring style or of the structuring strategy.
  - 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
  - Support dependency building using external tools such as cpp -M. Fix the cmt_build_des.sh wrapper script to properly format the command output.
  - Perform the cmt checkout onto a project even if the basic directory structure of the project is already in place.
  - When no current project is defined the strategies are taken from the top project (eg obtained from the CMTPATH)
  - The include_dirs statement can now be hidden in a private section.
  - The include_dirs statement now accepts a macro reference as its value
  - Fix incorrect generation of XXXROOT and XXXCONFIG environment variables according to strategies
  - Protect against missing un/install targets
  - Fix a typo in cmt_uninstall_action.bat resulting in bad management of make cleanup on Windows
  - 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
  - Don't apply include_dirs when their expanded value is empty (avoid killing -I"")
  - Reset CMTPATH to empty when filling in CMTPATH from projects (avoid confusions and dupplications)
  - Fix a bug in dependency builder that missed some statements after a single line C++ comment
  - Cleanup unneeded duplicate path separators
  - Fix a bug in standard macro generation for projects
- v1r18p20050501
  - Fill in a pacman cache for CMT using pacman3 syntax. The Pacman package name is CMT.
  - 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.
  - Add the cvssubprojects query command to retrieve subprojects at a CVS repository level
  - 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.
  - 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.
  - Fix the production of shared libraries on CYGWIN
  - Fix ambiguities between physical paths and logical paths in PATH variables management
  - Fix arg counting bugs in cvstags and cvssubpackages commands
- v1r18p20050401
  - Introduce a new bug reporting system: Trac
  - Accept HEAD or head as a valid version tag for packages
  - The path of CMT is removed from CMTPATH. Packages aside CMT are no longer reachable by default
  - 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.
  - Introduce the management of releases for projects. Release must exactly match
  - Install a mechanism to detect unused tags from arguments or CMTSITE. This is performed during the setup generation
  - Source code management tansfered to SVN
  - Restructure the strategy management to make it fully generic.
  - Fix poor management of unknown commands
  - Suppress the export action for alias in setup.sh
  - Fix a problem in TMPDIR management with multi directory level
  - Fix a problem in cmt show packages
  - Fix bad parsing of various cmt commands
  - Fix an internal bug causing misfunction in the -import parameter of constituents.
  - Fix fragment for action to improve argument transmission
  - Fix pdb files for Visual about debug mode
- v1r18p20041201
  - Suppress the completely unused makefile strategy
  - Really apply the project specific setup strategy to control the generation of ROOT or CONFIG env. variables.
  - Change default build strategy to `without_installarea`
  - ${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.
  - 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 <action>" syntax. One can directly use "cmt <action>" when the action does not conflict with internal cmt commands.
  - Command line arguments are transmitted to "actions" now through the new standard "cmt_args" macro
  - Really force the settings of all Env. variables before running internal cmmands through broadcast, run or do commands.
  - The "cmt run" command transmits all its arguments to the launched action
  - 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.
  - Better protections for CMTPATH entries
  - 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)
  - Now produce the last revision date of the CMT documentation. Insert the complete version tag rather than just the base version tag.
  - Suppress the systematic production of bundles on Darwin machines. This must now be done explicitly.
  - 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.
  - A global checking of the configuration is performed first when running Make
  - 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
- v1r16p20040901
  - Introduce the support of SLC3 (Scientific Linux) platforms
  - Trigger the reconstruction of the dependency makefile fragment from a change in the <package>_setup.make, ie from any change in tags, uses or CMTPATHs
  - `CMTBIN` now follows a new convention on Unix `uname`-`uname -m` to differentiate among Linux platforms.
  - 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 `cmts` or `cmtv` name space keywords. `cmts:xxx` indicates a scalar modelling element `xxx` meant to be expanded only once. `cmtv:yyy` indicates a vector modelling element `yyy` meant to be expanded once per item in the vector of values.
  - Better management of temporary file generation. Now support the standard TMPDIR environment variable to redirect temporary locations.
  - Apply the new GPL-like licence officially provided by CNRS-CEA-INRIA
  - Use stderr instead of stdout to display error and warning messages. Mainly to better expose messages in the source setup operations
  - Protect against source files not found (avoid infinite loops in make)
  - Better management of the build strategy on installation area to generate various automatic macros or sets (installarea_linkopts, PATH, LD_LIBRARY_PATH, etc...)
  - Revisit the package scan algorithm to improve the detection of directory structure of packages as well as their version tags.
  - Compress the path definitions (ie compress the ../xxx patterns) and use the compressed paths everywhere
- v1r16p20040701
  - Better generation of .def files for DATA
  - fix a bug that impacted on the order of compatible use requests with different wilcarded specifications
- v1r16p20040527
  - Generate the `target_${CONSTITUENT}` tag to trigger configuration control per target. This feature is only activated when the new `-target_tag` option is specified to a constituent. Specific tag makefiles are then generated for those targets. This tag is activated either when `make <target>` or `cmt do <action>` is run.
  - Add a section on package semantics in the documentation
  - The `apply_tag` keyword now accepts macro expansion for its argument.
  - Add the support for Enterprise Linux
  - Create automatic tags from `cmt_hardware` `cmt_system_version` and `cmt_compiler_version`
  - Add a filtering script to keep 3 digits instead of 2
  - Start the implementation of a centralized log message facility
  - Implement a `READONLY` mode to Makefiles to generate all intermediate files in `/tmp/CMT_*` rather than in `../cmt`
  - Associate a dedicated project with CMTHOME and CMTUSERCONTEXT to manage strategies
  - Set the macro `shlibsuffix` for Win32
  - Use /bin/pwd instead of the raw pwd in various CMT scripts for Unix
  - Fix misunderstanding of of version specification of the form v1r2p (ie without a trailing number)
  - Explicitly close the scope sections at the end of requirements files
- v1r16
  - Offer an [x]emacs mode for editing requirements files
  - Permit macro expressions in the `tag` statement
  - Possibility to specify additional `mount_filters` in `.cmtrc`
  - Introduce new regexp-based remove operations for symbols `macro_remove_regexp`, `set_remove_regexp` and `path_remove_regexp`
  - Add `-n` and `-v` options to `cmt cvs` commands to support simulation and verbose modes
  - Ensure that the `constituents` macro is always private
  - Introduce support for projects associated with package areas, i.e. one project per item in `CMTPATH`. Possibility to setup strategies per project. Project definitions stored in a new `cmt/project.cmt` top level file. New `<package>_project` standard macro. And associated pattern templates.
  - Make `CMTINSTALLAREA` a macro instead of a set
  - Suppress dependency computation when the `make QUICK=1` option is used
  - New action 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 `make` or `cmt do`
  - public and private section can be ended by a new keyword `end_public` `end_private`. Ending keywords switch back to the previous scope active before the most recent opening keyword
  - Can use a pattern name as a plain CMT keyword. I.e. the `apply_pattern` keyword is optional except to resolve ambiguities
  - Generate part of the standard macros before reading the requirements file
  - Lots of internal optimisations checked with `valgrind` and `gprof`
  - Only set non empty environment variables
  - Fix bad definition of `<PACKAGE>VERSION`
  - Add dependency to all stamps file to trigger rebuild of shared libraries
  - Add dependency to all requirements file to trigger rebuild of applications
  - Suppress install area cleanup action from cmt config and cmt setup
  - Improved syntax checking on constituents
  - Fix construction of paths when symlinks exist along pwd
  - Added various protections for bad pattern syntaxes
- v1r14p20031120
  - Add a new standard macro $(<group>_dependencies)to specify global dependencies for a group
  - Add support for bundles on Darwin platforms
  - Consider symlinked paths in CMTPATH entries
  - Always setup cmtpath patterns even if the current installation area is undefined
  - Provide a generic pacman manifest file for CMT. All instances of the "<version>" pattern need to be substituted by the effective version of CMT to make it a real pacman file as follows:

        sed -e 's#[<]version[>]#'`cmt -quiet version`'#g' $CMTROOT/mgr/CMT.pacman

- v1r14p20031027
  - Fix a bug in the bootstrap mechanism to define CMTINSTALLAREA
- v1r14p20031022
  - Add the possibility to specify exclusion files when installing directories in Installation Area (on windows only)
  - Fix a bug : CMTINSTALLAREA symbol has to be defined before all other symbols in set_standard_macros
  - Few fixes on nmake flavour of install area mechanisms
  - Generate <package>_cmtpath and <package>_offset also for current package
  - Fix warning messages that confuse csh when environment variables are not defined
- v1r14p20031014
  - Fix a problem in broadcast operation for handling return status 2 (caused to unexpectedly break the loop in some cases)
  - Force auto_imports to On when context is unspecified (internal)
  - Stop trying to make use of PWD
  - Fix a bug in internal incomplete expansion of macros
  - Fix a bug in consistency checks of PWD vs CMTINSTALLAREA
  - Convert $(cmtpath) and $(offset) macros to $(package_cmtpath) and $(package_offset)
  - Add dependency list for constituent makefile similar to the constituent target (force the same build order)
  - Fix a bug in use graph internal management
  - Fix setup script calling mechanism in no_version style
  - Add a -k=<regexp> argument for selection patterns of constituent sources.
  - Support wildcarded suffixes (*.*) in constituent sources
  - Standardize the output format of show uses (make it reliable for user scripts)
- v1r14p20030811
  - Trailing slashes on offset specification in use statement were causing troubles. Now they are properly handled.
  - The broadcast pattern as well as the standard macro <cmtpath> is now renamed <package_cmtpath> to avoid confusion with the CMTPATH variable on Windows.
  - Make use of ${PWD} when available to acquire the value for "cmt show pwd"
  - Add or refresh tuning for CYGWIN and for LynxOS
  - Work around a limitation of some old version of the C++ compiler on LynxOS
  - Improve the display of incompatible use specifications.
  - Dynamically create the CMTDownload.html web page to really reflect what is available when installing the CMT release on the primary CMT web site.
  - Setup.bat scripts on DOS are now relocatable wrt heterogeneous file systems (AFS, DFS, etc...)
- v1r14p20030620
  - introduce a generic "Unix" tag for all Unix platforms. Both Linux, HP-UX, LynxOS, alpha, ... do validate Unix
  - 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.
  - 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
  - add a command "cmt show use_paths <target>" 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.
  - add a command "cmt show cycles" to display circular dependencies in the use graph.
  - 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)
  - 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)
  - The setup scripts for Windows now use %TEMP% instead of %HOMEDRIVE%%HOMEPATH% to store temporary files (contributions from Pere Mato and Florence Ranjard)
  - Add the --public and --private global options for cmt commands, to control whether the use graph traverses or not the private sections:

        > cmt --public ...

    only sees public uses (default behavior for most commands but not for cmt broadcast and cmt show uses which traverse the private sub graphs)

        > cmt --private ...

    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.
  - A global pattern specifying private sections did not really generate private definitions