WebSVN – DevTools – Diff – /core_devl/trunk/TOOLS/jats.pl

 our $USER               = $ENV{'USER'}               || '';
 our $PERL5LIB           = $ENV{'PERL5LIB'}           || '';
 our $JAVA_HOME          = $ENV{'JAVA_HOME'}          || '';
 our $GBE_ABT            = $ENV{'GBE_ABT'}            || '';
 our $GBE_VIEWBASE       = $ENV{'GBE_VIEWBASE'}       || '';
+our $GBE_VCS            = $ENV{'GBE_VCS'}            || 'CC';
 our $GBE_UNIX           = 1;
 our $CWD;
 #-------------------------------------------------------------------------------
 #   Clean up some environment variables
 #       GBE_BUILDFILTER - may be space or comma separated list
 #       GBE_PLATFORM - may be space or comma separated list
 #       GBE_ABT - may be space or comma separated list
 #       GBE_HOSTNAME - No whitespace
+#       GBE_VCS - lowercase to match command ccrelease and others
+#
 $GBE_BUILDFILTER = join (' ', split( /[,\s]+/, $GBE_BUILDFILTER));
 $GBE_PLATFORM    = join (' ', split( /[,\s]+/, $GBE_PLATFORM));
 $GBE_ABT         = join (' ', split( /[,\s]+/, $GBE_ABT));
 $GBE_HOSTNAME    =~ s~\s+~~g;
+$GBE_VCS         = lc( $GBE_VCS );
 #-------------------------------------------------------------------------------
 #   Parse the user options
 #   GetOptions has been configured so that it will stop parsing on the first
 #   non-options. This allows the command syntax to the script to have options
 $ENV{'GBE_UNIX'}          = $GBE_UNIX;
 $ENV{'USER'}              = $USER;
 $ENV{'COMSPEC'}           = $COMSPEC;
 $ENV{'GBE_HOSTNAME'}      = $GBE_HOSTNAME;
 $ENV{'GBE_VIEWBASE'}      = $GBE_VIEWBASE;
+$ENV{'GBE_VCS'}           = $GBE_VCS;
 #-------------------------------------------------------------------------------
 # Function        : PathPrepend
+#
 # Description     : Prepend stuff to the PATH
 run_ant (@ARGV)                         if ( $cmd =~ m/^ant$/ );
 run_abt (@ARGV)                         if ( $cmd =~ m/^abt$/ );
 etool ('cache_dpkg', @ARGV)                         if ( $cmd =~ m/^dpkg/ );
 etool ('gen_msprojects', @ARGV)                     if ( $cmd =~ m/^gen_msproject/ );
-etool ('jats_ccrelease.pl', @ARGV)                  if ( $cmd =~ m/^cbuild/ );
-etool ('jats_ccrelease.pl', @ARGV)                  if ( $cmd =~ m/^release/ );
+etool ("jats_${GBE_VCS}release.pl", @ARGV)                  if ( $cmd =~ m/^release/ );
-etool ('jats_ccrelease.pl', '-extractfiles' ,@ARGV) if ( $cmd =~ m/^extractf/ );
+etool ("jats_${GBE_VCS}release.pl", '-extractfiles' ,@ARGV) if ( $cmd =~ m/^extractf/ );
-etool ('jats_ccrelease.pl', '-extract' ,@ARGV)      if (!$opr_done && $cmd =~ m/^extract/ );
+etool ("jats_${GBE_VCS}release.pl", '-extract' ,@ARGV)      if (!$opr_done && $cmd =~ m/^extract/ );
-etool ('jats_label', @ARGV)                         if ( $cmd =~ m/^label$/ );
+etool ("jats_${GBE_VCS}label", @ARGV)                       if ( $cmd =~ m/^label$/ );
 etool ('jats_sandbox', @ARGV)                       if ( $cmd =~ m/^sandbox$/ );
 etool ('jats_help', @ARGV)                          if ( $cmd =~ m/^help$/ );
 etool ('jats_help', '-man', @ARGV)                  if ( $cmd =~ m/^man$/ );
 etool ('jats_vars.pl', @ARGV)                       if ( $cmd =~ m/^var/ );
 #   Documentation
+#
 =pod
+=for htmltoc    CORE::AA::Jats
 =head1 NAME
 jats - JATS utility interface tool
 =head1 SYNOPSIS
     label               - Labelling functions
     release             - Build a release from a clearcase label
     extract             - Extract a release from a clearcase label
     dpkg_cache          - Maintain a dpkg cache
     gen_msproject       - Generate MSVC project files
-    sandbox             - Run Sanbox utility
+    sandbox             - Run Sandbox utility
     etool name          - Run internal tool
     eprog name          - Run external tool
     ebin name           - Run JATS binary tool
 =item B<-man[=n]>
 Prints the manual page and exits.
 If a numeric manual level is provide then it will be used to control the
-verbosity of help provided. This should be inthe range of 1 to 3.
+verbosity of help provided. This should be in the range of 1 to 3.
 =item B<-b file> B<-buildfile file>
 This option modifies the operation of the "build" command. The command will
 use the specified file instead of the normal build.pl file.
 This option is similar to the B<-locate> option, but it allows the required
 build files to be located by ensuring that the required buildfile builds the
 specified package.
 There are two forms in which the B<packagename> can be specified. It can be
-specified as a full package name and vesrion, or as a package name and the
+specified as a full package name and version, or as a package name and the
 project suffix. ie: jats-api.1.0.0000.cr or jats-api.cr
 =item B<-locatefile=file>
 This option is similar to the B<-locate> option, but it allows the name of the
 JATS will attempt to transfer the target version to the local cache in an
 attempt to improve performance.
 =item B<-[no]exportvars>
-The default operation is to export sanitised and calculated values to the
+The default operation is to export sanitized and calculated values to the
 programs running under JATS. The use of NoExportVars will prevent JATS from
 exporting modified EnvVars into the environment. This may be required by
 processes, such as the build daemons that need to pick up the current version of
 JATS on the fly and not have it fixed when the daemon is started.
 The following commands are invoked directly by the JATS script to wrap the build
 tools in a controlled manner.
 =over 8
-=item B<build>
+=item L<build|TOOLS::buildlib>
 Build or rebuild the sandbox and makefiles.
 This command must be used before the component can be "made" and when the
 contents of the "buildpl" file change. It is a common mistake to use the "build"
 command to much.
 The script will hunt for a suitable build.pl file before running the build and
 make subcommands.
-The build process has a large number of options. Use "JATS build help" to
+The build process has a large number of options.
-display the complete list.
+Use L<"JATS build help"|TOOLS::buildlib/"item_help"> to display the complete list.
-=item B<make>
+=item L<make|TOOLS::jmake>
 Make one or more components
 This command will invoke a suitable "make" program on the makefile found in
 the current directory. This makefile should have been generated by JATS.
-The make process has a large number of options. Use "JATS make help" to
+The make process has a large number of options. Use
-display the complete list.
+L<"JATS make help"|TOOLS::jmake/"item_help">" to display the complete list.
 =item B<ant>
 This command will use ANT to build a component. JATS will determine the
 build.xml file to use with the following algorithm.
 This command is used to invoke the Auto Build Tool. It will invoke ANT on the
 build.xml file in the current directory in such  manner as to not affect the
 environment of the programs running under ANT.
-The remained of the command line is passed to the ABT, with the exception of
+The remainder of the command line is passed to the ABT, with the exception of
 the options:
 =over 8
+=item *
-=item * -java=x.x. This is used to control the version of Java used by the
+-java=x.x. This is used to control the version of Java used by the
 ABT. The default is 1.6.
+=item *
-=item * -buildfile=name. This is used to provide a different build file to ant.
+-buildfile=name. This is used to provide a different build file to ant.
 The default build file is 'build.xml'.
 =back
-=item B<install>
-This command will install a generated "package" into the local_dpkg_archive
-directory. This allows a group of packages to be tested before being published
-into the global dpkg_archive.
-NOTE. This command is no longer needed. The "build" process will place a
-shortcut in the local_dpkg_archive to a components "pkg" directory. Other
-components will utilize this shortcut directly and pickup the package without
-the user needing to "install" the package - a step that can be forgotten.
-=item B<help>
+=item L<help|TOOLS::jats_help>
 Display the basic help message.
-=item B<vars [-v]>
+=item L<vars [-v]|TOOLS::jats_vars>
 This command will display all the JATS related environment variables in a
 readable form.
 Additional information will be displayed if an argument of "-v" is provided.
 the build environment. They are implemented as extensions to the basic JATS
 command scripts.
 =over 8
-=item B<create_dpkg>
+=item L<create_dpkg|TOOLS::create_dpkg>
 This command will install a generated package into main dpkg_archive. This
 command should not be used directly by a user as it does not ensure that package
 has been created in a repeatable manner - use "jats release".
-=item B<label>
+=item label
 This command provides a number of useful labelling mechanisms to assist in the
 labeling of source code.
+The command will determine the default Version Control System and invoke the VCS
+specific utility. This will be one of:
+=over 4
+=item   *
+ClearCase: L<cclabel|TOOLS::jats_cclabel>
+=item   *
+Subversion: L<svnlabel|TOOLS::jats_svnlabel>
+=back
-=item B<release>, B<cbuild>
+=item release
-This command allows a package to be built and released, given a Clearcase label.
+This command allows a package to be built and released, given a label.
-This is the desired release mechanism.
+This is the desired release mechanism for manually releasing a package.
 The command has two main uses:
-=over 8
+=over 4
 =item 1
 Build a package for release. The process will ensure that the build is
 controlled and repeatable.
 Rebuild a package for test or debugging purposes.
 =back
+The command will determine the default Version Control System and invoke the VCS
+specific utility. This will be one of:
+=over 4
+=item   *
+ClearCase: L<ccrelease|TOOLS::jats_ccrelease>
+=item   *
+Subversion: L<svnrelease|TOOLS::jats_svnrelease>
+=back
-=item B<extract>
+=item L<extract|/"release">
 This is the same as "release -extract"
-=item B<dpkg_cache>
+=item L<dpkg_cache|TOOLS::cache_dpkg>
 This utility provides a number of commands to maintain the local cache of
 dpkg_archive.
-=item B<gen_msproject>
+=item L<gen_msproject|TOOLS::gen_msprojects>
 This utility will generate a set of Microsoft Studio (Version 6) project and
-workspace files to encapsulate the JATS build. The resultant project allows VS
+workspace files to encapsulate the JATS build. The resultant project allows
-to be used as an editor, source browser, debugger and build tool. JATS is
+Visual Studio to be used as an editor, source browser, debugger and build tool.
-still used to perform the build.
+JATS is still used to perform the build.
+=item B<install>
+This command will install a generated "package" into the local_dpkg_archive
+directory. This allows a group of packages to be tested before being published
+into the global dpkg_archive.
+=for htmlclass Note
+Note. This command is no longer needed. The "build" process will place a
+shortcut in the local_dpkg_archive to a components "pkg" directory. Other
+components will utilize this shortcut directly and pickup the package without
+the user needing to "install" the package - a step that can be forgotten.
 =item B<etool name>
 This command allows any JATS extension program to be run. The programs will by
 found in the JATS TOOLS directory.
 =head1 DESCRIPTION
 JATS is a wrapper script. It provides:
-=over 8
+=over 4
 =item *
-A controlled and sanitised environment to all the build tools.
+A controlled and sanitized environment to all the build tools.
 =item *
 The same command interface on all supported machines: Windows, Solaris and
 Linux.
 =back
 =head1 RELATED DOCUMENTATION
-=over 0
+=over 4
-=item   * InstallationNotes
+=item   * L<Installation Notes|POD::InstallationNotes>
-=item   * OverView
+=item   * L<OverView|POD::OverView>
-=item   * EnvVars
+=item   * L<EnvVars|POD::EnvVars>
-=item   * PkgArchives
+=item   * L<PkgArchives|POD::PkgArchives>
 =back
-Use C<jats help> to see the available internal documentation.
+Use L<jats help|TOOLS::jats_help> to see the available internal documentation.
 =head1 EXAMPLES
 =over 8
-=item   JATS help
+=item   L<JATS help|TOOLS::jats_help>
 This will display the available internal documentation.
-=item   JATS build
+=item   L<JATS build|TOOLS::buildlib>
 This will prime the current package being built ready for "make". The command
 will locate the build.pl file and process it. This will locate all the external
 packages and generate the required makefiles.
-=item   JATS make
+=item   L<JATS make|TOOLS::jmake>
 This will run the GNU make program over the makefiles generated by the "build"
 command. This may be executed in a subdirectory in order to limit the targets
 that are "made".
+=for htmlclass Note
 B<NOTE:> Do not run "make" without using the JATS wrapper. It will not perform
 as expected as the environment will not have been set up correctly.
 =back

Subversion Repositories DevTools

(root)/core_devl/trunk/TOOLS/jats.pl – Rev 349 → 361