diff --git a/code/unix/pcons-2.3.1 b/code/unix/pcons-2.3.1
deleted file mode 100755
index 550297fb..00000000
--- a/code/unix/pcons-2.3.1
+++ /dev/null
@@ -1,7911 +0,0 @@
-#!/usr/bin/env perl
-
-#
-# Revision history:
-# -----------------
-# July 2001, Thomas Gleerup <tgl@oticon.dk>
-#   1) pcons-1.6 (John Erickson, August 1999) merged into cons-2.3.0.
-#   2) Added automatic insertion of && for multi-line commands.
-#
-# September 2001, Thomas Gleerup <tgl@oticon.dk>
-#   1) Updated with Kevin Nolish's multi-line improvement.
-#   2) Improved this so that single [perl] commands can still be used.
-#
-
-# NOTE:  Cons intentionally does not use the "perl -w" option or
-# "use strict."  Because Cons "configuration files" are actually
-# Perl scripts, enabling those restrictions here would force them
-# on every user's config files, wanted or not.  Would users write
-# "better" Construct and Conscript files if we forced "use strict"
-# on them?  Probably.  But we want people to use Cons to get work
-# done, not force everyone to become a Perl guru to use it, so we
-# don't insist.
-#
-# That said, Cons' code is both "perl -w" and "use strict" clean.
-# Regression tests keep the code honest by checking for warnings
-# and "use strict" failures.
-
-use vars qw( $CVS_id $CVS_ver $ver_num $ver_rev $version );
-
-# I hate those CVS tags
-$CVS_id  = 'pcons-2.3.1';
-$CVS_ver = (split (/\s+/, $CVS_id))[2];
-
-$ver_num = "__VERSION__";
-$ver_rev = "__REVISION__";
-
-#$version = "This is Cons $ver_num$ver_rev ($CVS_id)\n";
-$version = "This is parallel Cons (pcons) $ver_num$ver_rev ($CVS_id)\n";
-
-# Cons: A Software Construction Tool.
-# Copyright (c) 1996-2001 Free Software Foundation, Inc.
-#
-# 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 of the License, 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.
-
-require 5.003;
-
-# See the NOTE above about why Cons doesn't "use strict".
-use integer;
-use Cwd;
-use File::Copy;
-
-use vars qw( $_WIN32 $_a $_exe $_o $_so );
-
-#------------------------------------------------------------------
-# Determine if running on win32 platform - either Windows NT or 95
-#------------------------------------------------------------------
-
-use vars qw( $PATH_SEPARATOR $iswin32 $_WIN32 $usage $indent @targets );
-
-BEGIN
-{
-    use Config;
-
-    # if the version is 5.003, we can check $^O
-    if ($] < 5.003)
-    {
-        eval("require Win32");
-        $_WIN32 = (!$@);
-    }
-    else
-    {
-        $_WIN32 = ($^O eq "MSWin32") ? 1 : 0;
-    }
-
-    # Fetch the PATH separator from Config;
-    # provide our old defaults in case it's not set.
-    $PATH_SEPARATOR = $Config{path_sep};
-    $PATH_SEPARATOR = $_WIN32 ? ';' : ':' if !defined $PATH_SEPARATOR;
-
-    # Fetch file suffixes from Config,
-    # accomodating differences in the Config variables
-    # used by different Perl versions.
-    $_exe = $Config{_exe};
-    $_exe = $Config{exe_ext} if !defined $_exe;
-    $_exe = $_WIN32 ? '.exe' : '' if !defined $_exe;
-    $_o   = $Config{_o};
-    $_o = $Config{obj_ext} if !defined $_o;
-    $_o = $_WIN32 ? '.obj' : '.o' if !defined $_o;
-    $_a  = $Config{_a};
-    $_a  = $Config{lib_ext} if !defined $_a;
-    $_a  = $_WIN32 ? '.lib' : '.a' if !defined $_a;
-    $_so = ".$Config{so}";
-    $_so = $_WIN32 ? '.dll' : '.so' if !defined $_so;
-}
-
-# Flush stdout each time.
-$| = 1;
-
-# Seed random number generator.
-srand(time . $$);    # this works better than time ^ $$ in perlfunc manpage.
-
-$usage = q(
-Usage: cons <arguments> -- <construct-args>
-
-Arguments can be any of the following, in any order:
-
-  <targets>	Build the specified targets. If <target> is a directory
-		recursively build everything within that directory.
-
-  +<pattern>	Limit the cons scripts considered to just those that
-		match <pattern>. Multiple + arguments are accepted.
-
-  <name>=<val>	Sets <name> to value <val> in the ARG hash passed to the
-		top-level Construct file.
-
-  -cc           Show command that would have been executed, when
-		retrieving from cache. No indication that the file
-		has been retrieved is given; this is useful for
-		generating build logs that can be compared with
-		real build logs.
-
-  -cd           Disable all caching. Do not retrieve from cache nor
-		flush to cache.
-
-  -cr           Build dependencies in random order. This is useful when
-		building multiple similar trees with caching enabled.
-
-  -cs           Synchronize existing build targets that are found to be
-		up-to-date with cache. This is useful if caching has
-		been disabled with -cc or just recently enabled with
-		UseCache.
-
-  -d            Enable dependency debugging.
-
-  -f <file>	Use the specified file instead of "Construct" (but first
-		change to containing directory of <file>).
-
-  -h            Show a help message local to the current build if
-		one such is defined,  and exit.
-
-  -k		Keep going as far as possible after errors.
-
-  -o <file>	Read override file <file>.
-
-  -p		Show construction products in specified trees.
-  -pa		Show construction products and associated actions.
-  -pw		Show products and where they are defined.
-
-  -q		Be quiet; multiple -q flags increase quietness level:
-		1: quiet about Installing and Removing targets
-		2: quiet about build commands, up-to-date targets
-
-  -r		Remove construction products associated with <targets>
-
-  -R <repos>	Search for files in <repos>.  Multiple -R <repos>
-		directories are searched in the order specified.
-
-  -S <pkg>	Use package sig::<pkg> to calculate file signatures.
-		Currently supported values are "md5" for MD5
-		signatures (the default) and "md5::debug" for MD5
-		signature debug information.
-
-  -t            Traverse up the directory hierarchy looking for a
-		Construct file, if none exists in the current directory.
-		(Targets will be modified to be relative to the
-		Construct file.)
-
-  -v		Show cons version and continue processing.
-  -V            Show cons version and exit.
-
-  -wf <file>    Write all filenames considered into <file>.
-
-  -x		Show this message and exit.
-
-
-   Please report any suggestions through the cons-discuss@gnu.org mailing
-   list.
-
-   To subscribe, send mail to cons-discuss-request@gnu.org with body
-   'subscribe'.
-
-   If you find a bug, please report it through the bug-cons@gnu.org
-   mailing list.
-
-   Information about CONS can be obtained from the official cons web site
-   http://www.dsmit.com/cons/ or its mirrors (listed there).
-
-   The cons maintainers can be contacted by email at cons-maintainers@gnu.org
-
-   User documentation of cons is contained in cons and can be obtained
-   by doing 'perldoc /path/to/cons'.
-
-);
-my $pcons = 1;
-
-# Simplify program name, if it is a path.
-{
-    my ($vol, $dir, $file) = File::Spec->splitpath(File::Spec->canonpath($0));
-    $0 = $file;
-}
-
-# Default parameters.
-$param::topfile = 'Construct';    # Top-level construction file.
-$param::install = 1;              # Show installations
-$param::build   = 1;              # Build targets
-     ### $param::show = 1;		# Show building of targets.
-$param::sigpro  = 'md5';    # Signature protocol.
-$param::depfile = '';       # Write all deps out to this file
-$param::salt    = '';       # Salt derived file signatures with this.
-$param::sourcesig = ['*' => 'content'];    # Source file signature calculation
-$param::rep_sig_times_ok = 1;    # Repository .consign times are in sync
-                                 #   w/files.
-$param::conscript_chdir  = 0;    # Change dir to Conscript directory
-$param::quiet            = 0;    # should we show the command being executed.
-$param::max_jobs         = 1;    # pcons
-
-@param::defaults = ();
-
-#
-$indent = '';
-
-# Display a command while executing or otherwise. This
-# should be called by command builder action methods.
-sub showcom
-{
-    print($indent . $_[0] . "\n") if ($param::quiet < 2);
-}
-
-# Default environment.
-# This contains only the completely platform-independent information
-# we can figure out.  Platform-specific information (UNIX, Win32)
-# gets added below.
-@param::base = (
-    'SIGNATURE' => ['*' => 'build'],
-    'SUFEXE'  => $_exe,         # '' on UNIX systems
-    'SUFLIB'  => $_a,           # '.a' on UNIX systems
-    'SUFLIBS' => "$_so:$_a",    # '.so:.a' on UNIX
-    'SUFOBJ'  => $_o,           # '.o' on UNIX systems
-    'SUFMAP' => {
-                  '.c'   => 'build::command::cc',
-                  '.s'   => 'build::command::cc',
-                  '.S'   => 'build::command::cc',
-                  '.C'   => 'build::command::cxx',
-                  '.cc'  => 'build::command::cxx',
-                  '.cxx' => 'build::command::cxx',
-                  '.cpp' => 'build::command::cxx',
-                  '.c++' => 'build::command::cxx',
-                  '.C++' => 'build::command::cxx',
-    },
-    'PERL' => $^X,
-    );
-
-# pcons does not allow multi-line commands
-my $ar_command = ($param::max_jobs <= 1)
-  ?    # pcons
-  ['%AR %ARFLAGS %> %<', '%RANLIB %>']
-  :                                          # cons
-  '%AR %ARFLAGS %> %<   &&   %RANLIB %>';    # pcons
-
-%param::rulesets = (
-
-    # Defaults for Win32.
-    # Defined for VC++ 6.0 by Greg Spencer <greg_spencer@acm.org>
-    # Your mileage may vary.
-    'msvc' => [
-                'CC'            => 'cl',
-                'CFLAGS'        => '/nologo',
-                'CCCOM'         => '%CC %CFLAGS %_IFLAGS /c %< /Fo%>',
-                'CXX'           => '%CC',
-                'CXXFLAGS'      => '%CFLAGS',
-                'CXXCOM'        => '%CXX %CXXFLAGS %_IFLAGS /c %< /Fo%>',
-                'INCDIRPREFIX'  => '/I',
-                'INCDIRSUFFIX'  => '',
-                'LINK'          => 'link',
-                'LINKCOM'       => '%LINK %LDFLAGS /out:%> %< %_LDIRS %LIBS',
-                'LINKMODULECOM' => '%LD /r /o %> %<',
-                'LIBDIRPREFIX'  => '/LIBPATH:',
-                'LIBDIRSUFFIX'  => '',
-                'AR'            => 'lib',
-                'ARFLAGS'       => '/nologo ',
-                'ARCOM'         => "%AR %ARFLAGS /out:%> %<",
-                'RANLIB'        => '',
-                'LD'            => 'link',
-                'LDFLAGS'       => '/nologo ',
-                'PREFLIB'       => '',
-    ],
-
-    # Defaults for a typical (?) UNIX platform.
-    # Your mileage may vary.
-    'unix' => [
-           'CC'            => 'cc',
-           'CFLAGS'        => '',
-           'CCCOM'         => '%CC %CFLAGS %_IFLAGS -c %< -o %>',
-           'CXX'           => '%CC',
-           'CXXFLAGS'      => '%CFLAGS',
-           'CXXCOM'        => '%CXX %CXXFLAGS %_IFLAGS -c %< -o %>',
-           'INCDIRPREFIX'  => '-I',
-           'INCDIRSUFFIX'  => '',
-           'LINK'          => '%CXX',
-           'LINKCOM'       => '%LINK %LDFLAGS -o %> %< %_LDIRS %LIBS',
-           'LINKMODULECOM' => '%LD -r -o %> %<',
-           'LIBDIRPREFIX'  => '-L',
-           'LIBDIRSUFFIX'  => '',
-           'AR'            => 'ar',
-           'ARFLAGS'       => 'r',                                       # rs?
-           'ARCOM'         => $ar_command,                               # pcons
-           'RANLIB'        => 'ranlib',
-           'AS'            => 'as',
-           'ASFLAGS'       => '',
-           'ASCOM'         => '%AS %ASFLAGS %< -o %>',
-           'LD'            => 'ld',
-           'LDFLAGS'       => '',
-           'PREFLIB'       => 'lib',
-           'ENV'           => {'PATH' => '/bin:/usr/bin'},
-    ],
-    );
-
-# Set the rules based on the platform.
-script::DefaultRules(script::RuleSet($_WIN32 ? 'msvc' : 'unix'));
-
-# Handle command line arguments.
-while (@ARGV)
-{
-    $_ = shift @ARGV;
-    last if /^--$/;    # Argument passing to Construct.
-    &option, next if s/^-//;
-    push (@param::include, $_), next if s/^\+//;
-    &equate, next if /=/;
-    push (@targets, $_), next;
-}
-
-sub option
-{
-    my %opt = (
-        'cc' => sub { $param::cachecom     = 1; },
-        'cd' => sub { $param::cachedisable = 1; },
-        'cr' => sub { $param::random       = 1; },
-        'cs' => sub { $param::cachesync    = 1; },
-        'd'  => sub { $param::depends      = 1; },
-        'h'  => sub { $param::localhelp    = 1; },
-        'k'  => sub { $param::kflag        = 1; },
-        'p'  => sub {
-            $param::pflag = 1;
-            $param::build = 0;
-        },
-        'pa' => sub {
-            $param::pflag = 1;
-            $param::aflag = 1;
-            $indent       = "... ";
-            $param::build = 0;
-        },
-        'pw' => sub {
-            $param::pflag = 1;
-            $param::wflag = 1;
-            $param::build = 0;
-        },
-        'q' => sub { $param::quiet++; },
-        'r' => sub {
-            $param::rflag = 1;
-            $param::build = 0;
-        },
-        't' => sub { $param::traverse = 1; },
-        'v' => sub { print($version); },
-        'V' => sub { print($version), exit(0); },
-        'x' => sub { print($usage), exit 0; },
-        );
-
-    my %opt_arg = (
-        'f' => sub { $param::topfile  = $_[0]; },
-        'o' => sub { $param::overfile = $_[0]; },
-        'R'  => sub { script::Repository($_[0]); },
-        'S'  => sub { $param::sigpro = $_[0]; },
-        'wf' => sub { $param::depfile = $_[0]; },
-        'j'  => sub { $param::max_jobs = $_[0]; },    # pcons
-        );
-
-    if (defined $opt{$_})
-    {
-        &{$opt{$_}} ();
-        return;
-    }
-    while ($_)
-    {
-        $_ =~ m/(.)(.*)/;
-        if (defined $opt{$1})
-        {
-            &{$opt{$1}} ();
-            $_ = $2;
-            next;
-        }
-        if (defined $opt_arg{$1})
-        {
-            if (!$2)
-            {
-                $_ = shift @ARGV;
-                die ("$0: -$1 option requires an argument.\n") if !$_;
-            }
-            &{$opt_arg{$1}} ($2 || $_);
-            return;
-        }
-        $_ =~ m/(..)(.*)/;
-        if (defined $opt_arg{$1})
-        {
-            if (!$2)
-            {
-                $_ = shift @ARGV;
-                die ("$0: -$1 option requires an argument.\n") if !$_;
-            }
-            &{$opt_arg{$1}} ($2 || $_);
-            return;
-        }
-        if ($_)
-        {
-            die
-              qq($0: unrecognized option "-$_".  Use -x for a usage message.\n);
-        }
-    }
-}
-
-# Process an equate argument (var=val).
-sub equate
-{
-    my ($var, $val) = /([^=]*)=(.*)/;
-    $script::ARG{$var} = $val;
-}
-
-# Define file signature protocol.
-'sig'->select($param::sigpro);
-
-# Cleanup after an interrupt.
-$SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
-    $SIG{PIPE} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = 'IGNORE';
-    $SIG{HUP} = $SIG{INT} if !$main::_WIN32;
-    warn("\n$0: killed\n");
-
-    # Call this first, to make sure that this processing
-    # occurs even if a child process does not die (and we
-    # hang on the wait).
-    sig::hash::END();
-    wait();
-    exit(1);
-};
-$SIG{HUP} = $SIG{INT} if !$main::_WIN32;
-
-# Cleanup after a broken pipe (someone piped our stdout?)
-$SIG{PIPE} = sub {
-    $SIG{PIPE} = $SIG{HUP} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = 'IGNORE';
-    warn("\n$0: broken pipe\n");
-    sig::hash::END();
-    wait();
-    exit(1);
-};
-
-if ($param::depfile)
-{
-    open(main::DEPFILE, ">" . $param::depfile)
-      || die ("$0: couldn't open $param::depfile ($!)\n");
-}
-
-# If the supplied top-level Conscript file is not in the
-# current directory, then change to that directory.
-{
-    my ($vol, $dir, $file) =
-      File::Spec->splitpath(File::Spec->canonpath($param::topfile));
-    if ($vol || $dir)
-    {
-        my ($cd) = File::Spec->catpath($vol, $dir, undef);
-        chdir($cd) || die ("$0: couldn't change to directory $cd ($!)\n");
-        $param::topfile = $file;
-    }
-}
-
-# Walk up the directory hierarchy looking for a Conscript file (if -t set).
-my ($target_top);
-my (@targetdir) = ();
-if ($param::traverse && !-f $param::topfile)
-{
-    my ($vol, $dirs, $file) = File::Spec->splitpath(cwd());
-    my (@dirs) = (File::Spec->splitdir($dirs), $file);
-    while (
-        !-f File::Spec->catpath($vol, File::Spec->catdir(@dirs),
-                                $param::topfile))
-    {
-        die ("$0: unable to find $param::topfile.\n") if !@dirs;
-        unshift (@targetdir, pop (@dirs));
-    }
-    my ($cwd) = File::Spec->catpath($vol, File::Spec->catdir(@dirs), '');
-    print "$0: Entering directory `$cwd'\n";
-    chdir($cwd);
-    @targets = map { File::Spec->catdir(@targetdir, $_) } @targets;
-}
-
-# Set up $dir::top and $dir::cwd, now that we are in the right directory.
-dir::init();
-
-#
-if (@targetdir)
-{
-    $target_top = $dir::top->lookupdir(File::Spec->catdir(@targetdir));
-}
-
-# Now handle override file.
-package override;
-if ($param::overfile)
-{
-    my ($ov) = $param::overfile;
-    die qq($0: can\'t read override file "$ov" ($!)\n) if !-f $ov;    #'
-    do $ov;
-    if ($@)
-    {
-        chop($@);
-        die qq($0: errors in override file "$ov" ($@)\n);
-    }
-}
-
-# Provide this to user to setup override patterns.
-sub Override
-{
-    my ($re, @env) = @_;
-    return if $param::overrides{$re};    # if identical, first will win.
-    $param::overrides = 1;
-    $param::overrides{$re} = \@env;
-    push (@param::overrides, $re);
-}
-
-package main;
-
-use vars qw( %priority $errors );
-
-# Check script inclusion regexps
-my $re;
-for $re (@param::include)
-{
-    if (!defined eval { "" =~ /$re/ })
-    {
-        my ($err) = $@;
-        $err =~ s/in regexp at .*$//;
-        die ("$0: error in regexp $err");
-    }
-}
-
-# Read the top-level construct file and its included scripts.
-doscripts($param::topfile);
-
-# Status priorities. This lets us aggregate status for directories
-# and print an appropriate message (at the top-level).
-%priority =
-  ('none' => 1, 'handled' => 2, 'built' => 3, 'unknown' => 4, 'errors' => 5);
-
-# If no targets were specified, supply default targets (if any).
-@targets = @param::default_targets if !@targets;
-
-$errors = 0;
-
-# Build the supplied target patterns.
-my $tgt;
-for $tgt (map($dir::top->lookup($_), @targets))
-{
-    if ($target_top && !$tgt->is_under($target_top))
-    {
-
-        # A -t option was used, and this target is not underneath
-        # the directory where we were invoked via -t.
-        # If the target is a directory and the -t directory
-        # is underneath it, then build the -t directory.
-        if (ref $tgt ne "dir" || !$target_top->is_under($tgt))
-        {
-            next;
-        }
-        $tgt = $target_top;
-    }
-    buildtoptarget($tgt);
-}
-
-exit 0 + ($errors != 0);
-
-sub buildtoptarget
-{
-    my ($tgt) = @_;
-    return if !$tgt;
-    my ($status) = buildtarget($tgt);
-    if ($status ne 'built')
-    {
-        my ($path) = $tgt->path;
-        if ($status eq "errors")
-        {
-            print qq($0: "$path" not remade because of errors.\n);
-            $errors++;
-        }
-        elsif ($status eq "handled")
-        {
-            print qq($0: "$path" is up-to-date.\n) if ($param::quiet < 2);
-        }
-        elsif ($status eq "unknown")
-        {
-
-            # cons error already reported.
-            $errors++;
-        }
-        elsif ($status eq "none")
-        {
-
-            # search for targets that may be linked to the given path.
-            my @linked = dir::linked_targets($tgt) if $target_top;
-            if (@linked)
-            {
-                my @names = map($_->path, @linked);
-                print "Linked targets: @names\n" if ($param::quiet < 1);
-                map(buildtoptarget($_), @linked);
-            }
-            else
-            {
-                print qq($0: nothing to be built in "$path".\n)
-                  if $param::build && ($param::quiet < 2);
-            }
-        }
-        else
-        {
-            print qq($0: don\'t know how to construct "$path".\n);    #'
-            $errors++;
-        }
-    }
-}
-
-# Build the supplied target directory or files. Return aggregated status.
-sub buildtarget
-{
-    my ($tgt) = @_;
-    if (ref($tgt) eq "dir")
-    {
-        my ($result)   = "none";
-        my ($priority) = $priority{$result};
-        if (exists $tgt->{member})
-        {
-            my ($members) = $tgt->{member};
-            my $entry;
-            for $entry (sort keys %$members)
-            {
-                next if $entry eq $dir::CURDIR || $entry eq $dir::UPDIR;
-                my ($tgt) = $members->{$entry};
-                next if ref($tgt) ne "dir" && !exists($tgt->{builder});
-                my ($stat) = buildtarget($members->{$entry});
-                my ($pri)  = $priority{$stat};
-                if ($pri > $priority)
-                {
-                    $priority = $pri;
-                    $result   = $stat;
-                }
-            }
-        }
-        return $result;
-    }
-    if ($param::depends)
-    {
-        my ($path) = $tgt->path;
-        if ($tgt->{builder})
-        {
-            my (@dep) = (@{$tgt->{dep}}, @{$tgt->{sources}});
-            my ($dep) = join (' ', map($_->path, @dep));
-            print("Target $path: $dep\n");
-        }
-        else
-        {
-            print("Target $path: not a derived file\n");
-        }
-    }
-    if ($param::build)
-    {
-        return build $tgt;
-    }
-    elsif ($param::pflag || $param::wflag || $param::aflag)
-    {
-        if ($tgt->{builder})
-        {
-            if ($param::wflag)
-            {
-                print qq(${\$tgt->path}: $tgt->{script}\n);
-            }
-            elsif ($param::pflag)
-            {
-                print qq(${\$tgt->path}:\n) if $param::aflag;
-                print qq(${\$tgt->path}\n)  if !$param::aflag;
-            }
-            if ($param::aflag)
-            {
-                $tgt->{builder}->action($tgt);
-            }
-        }
-    }
-    elsif ($param::rflag && $tgt->{builder})
-    {
-        my ($path) = $tgt->path;
-        if (-f $path)
-        {
-            if (unlink($path))
-            {
-                print("Removed $path\n") if ($param::quiet < 1);
-            }
-            else
-            {
-                warn("$0: couldn't remove $path\n");
-            }
-        }
-    }
-
-    return "none";
-}
-
-package NameSpace;
-
-# Return a hash that maps the name of symbols in a namespace to an
-# array of refs for all types for which the name has a defined value.
-# A list of symbols may be specified; default is all symbols in the
-# name space.
-sub save
-{
-    my $package = shift;
-    my (%namerefs, $var, $type);
-    no strict 'refs';
-    @_ = keys %{$package . "::"} if !@_;
-    foreach $var (@_)
-    {
-        $namerefs{$var} = [];
-        my $fqvar = $package . "::" . $var;
-
-        # If the scalar for this variable name doesn't already
-        # exist, *foo{SCALAR} will autovivify the reference
-        # instead of returning undef, so unlike the other types,
-        # we have to dereference to find out if it exists.
-        push (@{$namerefs{$var}}, *{$fqvar}{SCALAR})
-          if defined ${*{$fqvar}{SCALAR}};
-        foreach $type (qw(ARRAY HASH CODE IO))
-        {
-            push (@{$namerefs{$var}}, *{$fqvar}{$type})
-              if defined *{$fqvar}{$type};
-        }
-    }
-    return \%namerefs;
-}
-
-# Remove the specified symbols from the namespace.
-# Default is to remove all.
-sub remove
-{
-    my $package = shift;
-    my (%namerefs, $var);
-    no strict 'refs';
-    @_ = keys %{$package . "::"} if !@_;
-    foreach $var (@_)
-    {
-        delete ${$package . "::"}{$var};
-    }
-}
-
-# Restore values to symbols specified in a hash as returned
-# by NameSpace::save.
-sub restore
-{
-    my ($package, $namerefs) = @_;
-    my ($var, $ref);
-    no strict 'refs';
-    foreach $var (keys %$namerefs)
-    {
-        my $fqvar = $package . "::" . $var;
-        foreach $ref (@{$namerefs->{$var}})
-        {
-            *{$fqvar} = $ref;
-        }
-    }
-}
-
-# Support for "building" scripts, importing and exporting variables.
-# With the exception of the top-level routine here (invoked from the
-# main package by cons), these are all invoked by user scripts.
-package script;
-
-use vars qw( $ARG $caller_dir_path %special_var );
-
-BEGIN
-{
-
-    # We can't Export or Import the following variables because Perl always
-    # treats them as part of the "main::" package (see perlvar(1)).
-    %special_var = map { $_ => 1 } qw(ENV INC ARGV ARGVOUT SIG
-      STDIN STDOUT STDERR);
-}
-
-# This is called from main to interpret/run the top-level Construct
-# file, passed in as the single argument.
-sub main::doscripts
-{
-    my ($script) = @_;
-    Build($script);
-
-    # Now set up the includes/excludes (after the Construct file is read).
-    $param::include = join ('|', @param::include);
-
-    # Save the original variable names from the script package.
-    # These will stay intact, but any other "script::" variables
-    # defined in a Conscript file will get saved, deleted,
-    # and (when necessary) restored.
-    my (%orig_script_var) = map { $_ => 1 } keys %script::;
-    $caller_dir_path = undef;
-    my $cwd = Cwd::cwd();
-    my (@scripts) = pop (@priv::scripts);
-    while ($priv::self = shift (@scripts))
-    {
-        my ($path) = $priv::self->{script}->rsrcpath;
-        if (-f $path)
-        {
-            $dir::cwd = $priv::self->{script}->{dir};
-
-            # Handle chdir to the Conscript file directory, if necessary.
-            my ($vol, $dir, $file);
-            if ($param::conscript_chdir)
-            {
-                ($vol, $dir, $file) =
-                  File::Spec->splitpath(File::Spec->canonpath($path));
-                if ($vol ne '' || $dir ne '')
-                {
-                    $caller_dir_path = File::Spec->catpath($vol, $dir, undef);
-                    chdir($caller_dir_path)
-                      || die "Could not chdir to $caller_dir_path: $!\n";
-                }
-            }
-            else
-            {
-                $file = $path;
-            }
-
-            # Actually process the Conscript file.
-            do $file;
-
-            # Save any variables defined by the Conscript file
-            # so we can restore them later, if needed;
-            # then delete them from the script:: namespace.
-            my (@del) = grep(!$orig_script_var{$_}, keys %script::);
-            if (@del)
-            {
-                $priv::self->{script}->{pkgvars} =
-                  NameSpace::save('script', @del);
-                NameSpace::remove('script', @del);
-            }
-            if ($caller_dir_path)
-            {
-                chdir($cwd);
-                $caller_dir_path = undef;
-            }
-            if ($@)
-            {
-                chomp($@);
-                my $err = ($@ =~ /\n/ms) ? ":\n$@" : " ($@)";
-                print qq($0: error in file "$path"$err\n);
-                $run::errors++;
-            }
-            else
-            {
-
-                # Only process subsidiary scripts if no errors in parent.
-                unshift (@scripts, @priv::scripts);
-            }
-            undef @priv::scripts;
-        }
-        else
-        {
-            my $where = '';
-            my $cref  = $priv::self->{script}->creator;
-            if (defined $cref)
-            {
-                my ($_foo, $script, $line, $sub) = @$cref;
-                $where = " ($sub in $script, line $line)";
-            }
-            warn qq(Ignoring missing script "$path"$where);
-        }
-    }
-    die ("$0: script errors encountered: construction aborted\n")
-      if $run::errors;
-}
-
-# Return caller info about the method being invoked.
-# This is everything from the Perl "caller" builtin function,
-# including which Construct/Conscript file, line number,
-# subroutine name, etc.
-sub caller_info
-{
-    my ($lev) = 1;
-    my (@frame);
-    do
-    {
-        @frame = caller ++$lev;
-        if (defined($frame[3]) && $frame[3] eq '(eval)')
-        {
-            @frame = caller --$lev;
-            if ($caller_dir_path)
-            {
-                $frame[1] = File::Spec->catfile($caller_dir_path, $frame[1]);
-            }
-            return @frame;
-        }
-    } while ($frame[3]);
-    return;
-}
-
-# Link a directory to another. This simply means set up the *source*
-# for the directory to be the other directory.
-sub Link
-{
-    dir::link(@_);
-}
-
-# Add directories to the repository search path for files.
-# Strip our current directory from the list so Repository
-# (or -R options) can be used from within the repository.
-sub Repository
-{
-    my ($my_dir) = Cwd::cwd();
-    my $dir;
-    foreach $dir (@_)
-    {
-
-        # The following more direct call isn't available in
-        # Cwd.pm until some time after 5.003...
-        #	my($d) = Cwd::abs_path($dir);
-        chdir($dir);
-        my ($d) = Cwd::cwd();
-        chdir($my_dir);
-
-        #
-        next if !$d || !-d $d || $d eq $my_dir;
-
-        # We know we can get away with passing undef to lookupdir
-        # as the directory because $dir is an absolute path.
-        push (@param::rpath, dir::lookupdir(undef, $dir));
-        push @INC, $d;
-    }
-}
-
-# Return the list of Repository directories specified.
-sub Repository_List
-{
-    map($_->path, @param::rpath);
-}
-
-# Specify whether the .consign signature times in repository files are,
-# in fact, consistent with the times on the files themselves.
-sub Repository_Sig_Times_OK
-{
-    $param::rep_sig_times_ok = shift;
-}
-
-sub SourceSignature
-{
-    $param::sourcesig = [@_];
-}
-
-# Specify whether we should chdir to the containing directories
-# of Conscript files.
-sub Conscript_chdir
-{
-    $param::conscript_chdir = shift;
-}
-
-# Specify files/targets that must be present and built locally,
-# even if they exist already-built in a Repository.
-sub Local
-{
-    my (@files) = map($dir::cwd->lookupfile($_), @_);
-    map($_->local(1), @files);
-}
-
-# Export variables to any scripts invoked from this one.
-sub Export
-{
-    my (@illegal) = grep($special_var{$_}, @_);
-    if (@illegal)
-    {
-        die qq($0: cannot Export special Perl variables: @illegal\n);
-    }
-    @{$priv::self->{exports}} = grep(!defined $special_var{$_}, @_);
-}
-
-# Import variables from the export list of the caller
-# of the current script.
-sub Import
-{
-    my (@illegal) = grep($special_var{$_}, @_);
-    if (@illegal)
-    {
-        die qq($0: cannot Import special Perl variables: @illegal\n);
-    }
-    my ($parent)  = $priv::self->{parent};
-    my ($imports) = $priv::self->{imports};
-    @{$priv::self->{exports}} = keys %$imports;
-    my ($var);
-    foreach $var (grep(!defined $special_var{$_}, @_))
-    {
-        if (!exists $imports->{$var})
-        {
-            my ($path) = $parent->{script}->path;
-            die qq($0: variable "$var" not exported by file "$path"\n);
-        }
-        if (!defined $imports->{$var})
-        {
-            my $path = $parent->{script}->path;
-            my $err  =
-              "$0: variable \"$var\" exported but not "
-              . "defined by file \"$path\"\n";
-            die $err;
-        }
-        ${"script::$var"} = $imports->{$var};
-    }
-}
-
-# Build an inferior script. That is, arrange to read and execute
-# the specified script, passing to it any exported variables from
-# the current script.
-sub Build
-{
-    my (@files) = map($dir::cwd->lookupfile($_), @_);
-    my (%imports) = map { $_ => ${"script::$_"} } @{$priv::self->{exports}};
-    my $file;
-    for $file (@files)
-    {
-        next if $param::include && $file->path !~ /$param::include/o;
-        my ($self) = {
-                       'script'  => $file,
-                       'parent'  => $priv::self,
-                       'imports' => \%imports
-                       };
-        bless $self;    # may want to bless into class of parent in future
-        push (@priv::scripts, $self);
-    }
-}
-
-# Set up regexps dependencies to ignore. Should only be called once.
-sub Ignore
-{
-    die ("Ignore called more than once\n") if $param::ignore;
-    $param::ignore = join ("|", map("($_)", @_)) if @_;
-}
-
-# Specification of default targets.
-sub Default
-{
-    push (@param::default_targets, map($dir::cwd->lookup($_)->path, @_));
-}
-
-# Local Help.  Should only be called once.
-sub Help
-{
-    if ($param::localhelp)
-    {
-        print "@_\n";
-        exit 2;
-    }
-}
-
-# For windows platforms which use unix tool sets, the msvc defaults may
-# not be useful. Also, in the future, other platforms (Mac?) may have the
-# same problem.
-sub RuleSet
-{
-    my $style    = shift;
-    my @rulesets = sort keys %param::rulesets;
-    die "Unknown style for rules: $style.\n"
-      . "Supported rules are: ("
-      . join (" ", @rulesets) . ")"
-      unless eval(join ("||", map("\$style eq '$_'", @rulesets)));
-    return @param::base, @{$param::rulesets{$style}};
-}
-
-sub DefaultRules
-{
-    @param::defaults = ();
-    push @param::defaults, @_;
-}
-
-# Return the build name(s) of a file or file list.
-sub FilePath
-{
-    wantarray 
-      ? map($dir::cwd->lookupfile($_)->path, @_)
-      : $dir::cwd->lookupfile($_[0])->path;
-}
-
-# Return the build name(s) of a directory or directory list.
-sub DirPath
-{
-    wantarray 
-      ? map($dir::cwd->lookupdir($_)->path, @_)
-      : $dir::cwd->lookupdir($_[0])->path;
-}
-
-# Split the search path provided into components. Look each up
-# relative to the current directory.
-# The usual path separator problems abound; for now we'll use :
-sub SplitPath
-{
-    my ($dirs) = @_;
-    if (ref($dirs) ne "ARRAY")
-    {
-        $dirs = [split (/$main::PATH_SEPARATOR/o, $dirs)];
-    }
-    map { DirPath($_) } @$dirs;
-}
-
-# Return true if the supplied path is available as a source file
-# or is buildable (by rules seen to-date in the build).
-sub ConsPath
-{
-    my ($path) = @_;
-    my ($file) = $dir::cwd->lookup($path);
-    return $file->accessible;
-}
-
-# Return the source path of the supplied path.
-sub SourcePath
-{
-    wantarray 
-      ? map($dir::cwd->lookupfile($_)->rsrcpath, @_)
-      : $dir::cwd->lookupfile($_[0])->rsrcpath;
-}
-
-# Search up the tree for the specified cache directory, starting with
-# the current directory. Returns undef if not found, 1 otherwise.
-# If the directory is found, then caching is enabled. The directory
-# must be readable and writable. If the argument "mixtargets" is provided,
-# then targets may be mixed in the cache (two targets may share the same
-# cache file--not recommended).
-sub UseCache($@)
-{
-    my ($dir, @args) = @_;
-
-    # NOTE: it's important to process arguments here regardless of whether
-    # the cache is disabled temporarily, since the mixtargets option affects
-    # the salt for derived signatures.
-    for (@args)
-    {
-        if ($_ eq "mixtargets")
-        {
-
-            # When mixtargets is enabled, we salt the target signatures.
-            # This is done purely to avoid a scenario whereby if
-            # mixtargets is turned on or off after doing builds, and
-            # if cache synchronization with -cs is used, then
-            # cache files may be shared in the cache itself (linked
-            # under more than one name in the cache). This is not bad,
-            # per se, but simply would mean that a cache cleaning algorithm
-            # that looked for a link count of 1 would never find those
-            # particular files; they would always appear to be in use.
-            $param::salt       = 'M' . $param::salt;
-            $param::mixtargets = 1;
-        }
-        else
-        {
-            die qq($0: UseCache unrecognized option "$_"\n);
-        }
-    }
-    if ($param::cachedisable)
-    {
-        warn("Note: caching disabled by -cd flag\n");
-        return 1;
-    }
-    my ($depth) = 15;
-    while ($depth-- && !-d $dir)
-    {
-        $dir = File::Spec->catdir($dir::UPDIR, $dir);
-    }
-    if (-d $dir)
-    {
-        $param::cache = $dir;
-        return 1;
-    }
-    return undef;
-}
-
-# Salt the signature generator. The salt (a number of string) is added
-# into the signature of each derived file. Changing the salt will
-# force recompilation of all derived files.
-sub Salt($)
-{
-
-    # We append the value, so that UseCache and Salt may be used
-    # in either order without changing the signature calculation.
-    $param::salt .= $_[0];
-}
-
-# Mark files (or directories) to not be removed before building.
-sub Precious
-{
-    map($_->{precious} = 1, map($dir::cwd->lookup($_), @_));
-}
-
-# These methods are callable from Conscript files, via a cons
-# object. Procs beginning with _ are intended for internal use.
-package cons;
-
-use vars qw( %envcache );
-
-# This is passed the name of the base environment to instantiate.
-# Overrides to the base environment may also be passed in
-# as key/value pairs.
-sub new
-{
-    my ($package) = shift;
-    my ($env) = {@param::defaults, @_};
-    @{$env->{_envcopy}} = %$env;    # Note: we never change PATH
-    $env->{_cwd} = $dir::cwd;       # Save directory of environment for
-    bless $env, $package;           # any deferred name interpretation.
-}
-
-# Clone an environment.
-# Note that the working directory will be the initial directory
-# of the original environment.
-sub clone
-{
-    my ($env) = shift;
-    my $clone = {@{$env->{_envcopy}}, @_};
-    @{$clone->{_envcopy}} = %$clone;    # Note: we never change PATH
-    $clone->{_cwd} = $env->{_cwd};
-    bless $clone, ref $env;
-}
-
-# Create a flattened hash representing the environment.
-# It also contains a copy of the PATH, so that the path
-# may be modified if it is converted back to a hash.
-sub copy
-{
-    my ($env) = shift;
-    (@{$env->{_envcopy}}, 'ENV' => {%{$env->{ENV}}}, @_);
-}
-
-# Resolve which environment to actually use for a given
-# target. This is just used for simple overrides.
-sub _resolve
-{
-    return $_[0] if !$param::overrides;
-    my ($env, $tgt) = @_;
-    my ($path) = $tgt->path;
-    my $re;
-    for $re (@param::overrides)
-    {
-        next if $path !~ /$re/;
-
-        # Found one. Return a combination of the original environment
-        # and the override.
-        my ($ovr) = $param::overrides{$re};
-        return $envcache{$env, $re} if $envcache{$env, $re};
-        my ($newenv) = {@{$env->{_envcopy}}, @$ovr};
-        @{$newenv->{_envcopy}} = %$env;
-        $newenv->{_cwd} = $env->{_cwd};
-        return $envcache{$env, $re} = bless $newenv, ref $env;
-    }
-    return $env;
-}
-
-# Substitute construction environment variables into a string.
-# Internal function/method.
-sub _subst
-{
-    my ($env, $str) = @_;
-    if (!defined $str)
-    {
-        return undef;
-    }
-    elsif (ref($str) eq "ARRAY")
-    {
-        return [map($env->_subst($_), @$str)];
-    }
-    else
-    {
-
-        # % expansion.  %% gets converted to % later, so expand any
-        # %keyword construction that doesn't have a % in front of it,
-        # modulo multiple %% pairs in between.
-        # In Perl 5.005 and later, we could actually do this in one regex
-        # using a conditional expression as follows,
-        #	while ($str =~ s/($pre)\%(\{)?([_a-zA-Z]\w*)(?(2)\})/"$1".
-        #                      $env->{$3}/ge) {}
-        # The following two-step approach is backwards-compatible
-        # to (at least) Perl5.003.
-        my $pre = '^|[^\%](?:\%\%)*';
-        while (($str =~ s/($pre)\%([_a-zA-Z]\w*)/$1.($env->{$2}||'')/ge)
-               || ($str =~ s/($pre)\%\{([_a-zA-Z]\w*)\}/$1.($env->{$2}||'')/ge))
-        {
-        }
-        return $str;
-    }
-}
-
-sub AfterBuild
-{
-    my ($env)           = shift;
-    my ($perl_eval_str) = pop (@_);
-    my $file;
-    for $file (map($dir::cwd->lookup($_), @_))
-    {
-        $file->{after_build_func} = $perl_eval_str;
-
-    }
-}
-
-sub Install
-{
-    my ($env)    = shift;
-    my ($tgtdir) = $dir::cwd->lookupdir($env->_subst(shift));
-    my $file;
-    for $file (map($dir::cwd->lookupfile($env->_subst($_)), @_))
-    {
-        my ($tgt) = $tgtdir->lookupfile($file->{entry});
-        $tgt->bind(find build::install($env), $file);
-    }
-}
-
-sub InstallAs
-{
-    my $env     = shift;
-    my $tgt     = shift;
-    my $src     = shift;
-    my @sources = ();
-    my @targets = ();
-
-    if (ref $tgt)
-    {
-        die "InstallAs: Source is a file and target is a list!\n"
-          if (!ref($src));
-        @sources = @$src;
-        @targets = @$tgt;
-    }
-    elsif (ref $src)
-    {
-        die "InstallAs: Target is a file and source is a list!\n";
-    }
-    else
-    {
-        push @sources, $src;
-        push @targets, $tgt;
-    }
-
-    if ($#sources != $#targets)
-    {
-        my $tn = $#targets + 1;
-        my $sn = $#sources + 1;
-        die "InstallAs: Source file list ($sn) and target file list ($tn) "
-          . "are inconsistent in length!\n";
-    }
-    else
-    {
-        foreach (0 .. $#sources)
-        {
-            my $tfile = $dir::cwd->lookupfile($env->_subst($targets[$_]));
-            my $sfile = $dir::cwd->lookupfile($env->_subst($sources[$_]));
-            $tfile->bind(find build::install($env), $sfile);
-        }
-    }
-}
-
-# Installation in a local build directory,
-# copying from the repository if it's already built there.
-# Functionally equivalent to:
-#	Install $env $dir, $file;
-#	Local "$dir/$file";
-sub Install_Local
-{
-    my ($env)    = shift;
-    my ($tgtdir) = $dir::cwd->lookupdir($env->_subst(shift));
-    my $file;
-    for $file (map($dir::cwd->lookupfile($env->_subst($_)), @_))
-    {
-        my ($tgt) = $tgtdir->lookupfile($file->{entry});
-        $tgt->bind(find build::install($env), $file);
-        $tgt->local(1);
-    }
-}
-
-sub Objects
-{
-    my ($env) = shift;
-    map($dir::cwd->relpath($_), $env->_Objects(@_));
-}
-
-# Called with multiple source file references (or object files).
-# Returns corresponding object files references.
-sub _Objects
-{
-    my ($env)    = shift;
-    my ($suffix) = $env->{SUFOBJ};
-    map($env->_Object($_, $_->{dir}->lookupfile($_->base_suf($suffix))),
-      map { ref $_ ? $_ : $dir::cwd->lookupfile($env->_subst($_)) }
-      grep(defined $_, @_));
-}
-
-# Called with an object and source reference.  If no object reference
-# is supplied, then the object file is determined implicitly from the
-# source file's extension. Sets up the appropriate rules for creating
-# the object from the source.  Returns the object reference.
-sub _Object
-{
-    my ($env, $src, $obj) = @_;
-    return $obj if $src eq $obj;    # don't need to build self from self.
-    my ($objenv) = $env->_resolve($obj);
-    my ($suffix) = $src->suffix;
-
-    my ($builder) = $env->{SUFMAP}{$suffix};
-
-    if ($builder)
-    {
-        $obj->bind((find $builder($objenv)), $src);
-    }
-    else
-    {
-        die ("don't know how to construct ${\$obj->path} from "
-             . "${\$src->path}.\n");
-    }
-    $obj;
-}
-
-sub Program
-{
-    my ($env) = shift;
-    my ($tgt) =
-      $dir::cwd->lookupfile(
-                          file::addsuffix($env->_subst(shift), $env->{SUFEXE}));
-    my ($progenv) = $env->_resolve($tgt);
-    $tgt->bind(find build::command::link($progenv, $progenv->{LINKCOM}),
-               $env->_Objects(@_));
-}
-
-sub Module
-{
-    my ($env)    = shift;
-    my ($tgt)    = $dir::cwd->lookupfile($env->_subst(shift));
-    my ($modenv) = $env->_resolve($tgt);
-    my ($com)    = pop (@_);
-    $tgt->bind(find build::command::link($modenv, $com), $env->_Objects(@_));
-}
-
-sub LinkedModule
-{
-    my ($env)     = shift;
-    my ($tgt)     = $dir::cwd->lookupfile($env->_subst(shift));
-    my ($progenv) = $env->_resolve($tgt);
-    $tgt->bind(
-               find build::command::linkedmodule($progenv,
-                                                 $progenv->{LINKMODULECOM}),
-               $env->_Objects(@_));
-}
-
-sub Library
-{
-    my ($env) = shift;
-    my ($lib) =
-      $dir::cwd->lookupfile(
-                          file::addsuffix($env->_subst(shift), $env->{SUFLIB}));
-    my ($libenv) = $env->_resolve($lib);
-    $lib->bind(find build::command::library($libenv), $env->_Objects(@_));
-}
-
-# Simple derivation: you provide target, source(s), command.
-# Special variables substitute into the rule.
-# Target may be a reference, in which case it is taken
-# to be a multiple target (all targets built at once).
-sub Command
-{
-    my ($env)     = shift;
-    my ($tgt)     = $env->_subst(shift);
-    my ($builder) = find build::command::user($env, pop (@_), 'script');
-    my (@sources) = map($dir::cwd->lookupfile($env->_subst($_)), @_);
-    if (ref($tgt))
-    {
-
-        # A multi-target command.
-        my (@tgts) = map($dir::cwd->lookupfile($_), @$tgt);
-        die ("empty target list in multi-target command\n") if !@tgts;
-        $env = $env->_resolve($tgts[0]);
-        my ($multi) = build::multiple->new($builder, \@tgts);
-        for $tgt (@tgts)
-        {
-            $tgt->bind($multi, @sources);
-        }
-    }
-    else
-    {
-        $tgt = $dir::cwd->lookupfile($tgt);
-        $env = $env->_resolve($tgt);
-        $tgt->bind($builder, @sources);
-    }
-}
-
-sub Depends
-{
-    my ($env)  = shift;
-    my ($tgt)  = $env->_subst(shift);
-    my (@deps) = map($dir::cwd->lookup($env->_subst($_)), @_);
-    if (!ref($tgt))
-    {
-        $tgt = [$tgt];
-    }
-    my ($t);
-    foreach $t (map($dir::cwd->lookupfile($_), @$tgt))
-    {
-        push (@{$t->{dep}}, @deps);
-    }
-}
-
-# Setup a quick scanner for the specified input file, for the
-# associated environment. Any use of the input file will cause the
-# scanner to be invoked, once only. The scanner sees just one line at
-# a time of the file, and is expected to return a list of
-# dependencies.
-sub QuickScan
-{
-    my ($env, $code, $file, $path) = @_;
-    $dir::cwd->lookup($env->_subst($file))->{'srcscan', $env} =
-      find scan::quickscan($code, $env, $env->_subst($path));
-}
-
-# Generic builder module. Just a few default methods.  Every derivable
-# file must have a builder object of some sort attached.  Usually
-# builder objects are shared.
-package build;
-
-use vars qw( %builder );
-
-# Every builder must now have at least an associated environment,
-# so we can find its sigarray and calculate the proper signature.
-sub find
-{
-    my ($class, $env) = @_;
-    $builder{$env} || do
-    {
-        my $self = {env => $env};
-        $builder{$env} = bless $self, $class;
-      }
-}
-
-# Null signature for dynamic includes.
-sub includes { () }
-
-# Null signature for build script.
-sub scriptsig { () }
-
-# Not compatible with any other builder, by default.
-sub compatible { 0 }
-
-# Builder module for the Install command.
-package build::install;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(build) }
-
-# Caching not supported for Install: generally install is trivial anyway,
-# and we don't want to clutter the cache.
-sub cachin  { undef }
-sub cachout { }
-
-# Do the installation.
-sub action
-{
-    my ($self, $tgt) = @_;
-    my ($src) = $tgt->{sources}[0];
-    main::showcom("Install ${\$src->rpath} as ${\$tgt->path}")
-      if ($param::install && $param::quiet < 1);
-    return unless $param::build;
-    futil::install($src->rpath, $tgt);
-    return 1;
-}
-
-# Builder module for generic UNIX commands.
-package build::command;
-
-use vars qw( @ISA %com );
-
-BEGIN { @ISA = qw(build) }
-
-sub find
-{
-    my ($class, $env, $cmd, $package) = @_;
-    my ($act) = action::new($env, $cmd);
-    $package ||= '';
-    $com{$env, $act, $package} || do
-    {
-        my $self = {env => $env, act => $act, 'package' => $package};
-        $com{$env, $act, $package} = bless $self, $class;
-      }
-}
-
-# Default cache in function.
-sub cachin
-{
-    my ($self, $tgt, $sig) = @_;
-    if (cache::in($tgt, $sig))
-    {
-        if ($param::cachecom)
-        {
-            $self->{act}->show($self->{env}, $tgt);
-        }
-        else
-        {
-            printf("Retrieved %s from cache\n", $tgt->path)
-              if ($param::quiet < 1);
-        }
-        return 1;
-    }
-    return undef;
-}
-
-# Default cache out function.
-sub cachout
-{
-    my ($self, $tgt, $sig) = @_;
-    cache::out($tgt, $sig);
-}
-
-# Build the target using the previously specified commands.
-sub action
-{
-    my ($self, $tgt) = @_;
-    $self->{act}->execute($self->{env}, $tgt, $self->{'package'});
-}
-
-# Return script signature.
-sub scriptsig
-{
-    $_[0]->{act}->scriptsig;
-}
-
-# Create a linked module.
-package build::command::link;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(build::command) }
-
-# Find an appropriate linker.
-sub find
-{
-    my ($class, $env, $command) = @_;
-    if (!exists $env->{_LDIRS})
-    {
-        my ($ldirs) = '';
-        my ($wd)    = $env->{_cwd};
-        my ($pdirs) = $env->{LIBPATH};
-        if (!defined $pdirs)
-        {
-            $pdirs = [];
-        }
-        elsif (ref($pdirs) ne 'ARRAY')
-        {
-            $pdirs = [split (/$main::PATH_SEPARATOR/o, $pdirs)];
-        }
-        my ($dir, $dpath);
-        for $dir (map($wd->lookupdir($env->_subst($_)), @$pdirs))
-        {
-            $dpath = $dir->path;
-
-            # Add the (presumably local) directory to the -L flags
-            # if we're not using repositories, the directory exists,
-            # or it's Linked to a source directory (that is, it *will*
-            # exist by the time the link occurs).
-            $ldirs .= " " . $env->{LIBDIRPREFIX} . $dpath . $env->{LIBDIRSUFFIX}
-              if !@param::rpath || -d $dpath || $dir->is_linked;
-            next if File::Spec->file_name_is_absolute($dpath);
-            if (@param::rpath)
-            {
-                my $d;
-                if ($dpath eq $dir::CURDIR)
-                {
-                    foreach $d (map($_->path, @param::rpath))
-                    {
-                        $ldirs .= " "
-                          . $env->{LIBDIRPREFIX} . $d
-                          . $env->{LIBDIRSUFFIX};
-                    }
-                }
-                else
-                {
-                    my ($rpath);
-                    foreach $d (map($_->path, @param::rpath))
-                    {
-                        $rpath = File::Spec->catfile($d, $dpath);
-                        $ldirs .= " "
-                          . $env->{LIBDIRPREFIX} . $rpath
-                          . $env->{LIBDIRSUFFIX}
-                          if -d $rpath;
-                    }
-                }
-            }
-        }
-        $env->{_LDIRS} = "%($ldirs%)";
-    }
-
-    # Introduce a new magic _LIBS symbol which allows to use the
-    # Unix-style -lNAME syntax for Win32 only. -lNAME will be replaced
-    # with %{PREFLIB}NAME%{SUFLIB}. <schwarze@isa.de> 1998-06-18
-
-    if ($main::_WIN32 && !exists $env->{_LIBS})
-    {
-        my $libs;
-        my $name;
-        for $name (split (' ', $env->_subst($env->{LIBS} || '')))
-        {
-            if ($name =~ /^-l(.*)/)
-            {
-                $name = "$env->{PREFLIB}$1$env->{SUFLIB}";
-            }
-            $libs .= ' ' . $name;
-        }
-        $env->{_LIBS} = $libs ? "%($libs%)" : '';
-    }
-    bless find build::command($env, $command);
-}
-
-# Called from file::build. Make sure any libraries needed by the
-# environment are built, and return the collected signatures
-# of the libraries in the path.
-sub includes
-{
-    return $_[0]->{'bsig'} if exists $_[0]->{'bsig'};
-    my ($self, $tgt) = @_;
-    my ($env) = $self->{env};
-    my ($ewd) = $env->{_cwd};
-    my $ldirs = $env->{LIBPATH};
-    if (!defined $ldirs)
-    {
-        $ldirs = [];
-    }
-    elsif (ref($ldirs) ne 'ARRAY')
-    {
-        $ldirs = [split (/$main::PATH_SEPARATOR/o, $ldirs)];
-    }
-    my @lpath = map($ewd->lookupdir($_), @$ldirs);
-    my (@sigs);
-    my (@names);
-
-    # Pass %LIBS symbol through %-substituition
-    # <schwarze@isa.de> 1998-06-18
-    @names = split (' ', $env->_subst($env->{LIBS} || ''));
-    my $name;
-    for $name (@names)
-    {
-        my ($lpath, @allnames);
-        if ($name =~ /^-l(.*)/)
-        {
-
-            # -l style names are looked up on LIBPATH, using all
-            # possible lib suffixes in the same search order the
-            # linker uses (according to SUFLIBS).
-            # Recognize new PREFLIB symbol, which should be 'lib' on
-            # Unix, and empty on Win32. TODO: What about shared
-            # library suffixes?  <schwarze@isa.de> 1998-05-13
-            @allnames =
-              map("$env->{PREFLIB}$1$_", split (/:/, $env->{SUFLIBS}));
-            $lpath = \@lpath;
-        }
-        else
-        {
-            @allnames = ($name);
-
-            # On Win32, all library names are looked up in LIBPATH
-            # <schwarze@isa.de> 1998-05-13
-            if ($main::_WIN32)
-            {
-                $lpath = [$dir::top, @lpath];
-            }
-            else
-            {
-                $lpath = [$dir::top];
-            }
-        }
-        my $dir;
-        DIR: for $dir (@$lpath)
-        {
-            my $n;
-            for $n (@allnames)
-            {
-                my ($lib) = $dir->lookup_accessible($n);
-                if ($lib)
-                {
-                    last DIR if $lib->ignore;
-                    if ((build $lib) eq 'errors')
-                    {
-                        $tgt->{status} = 'errors';
-                        return undef;
-                    }
-                    push (@sigs, 'sig'->signature($lib));
-                    last DIR;
-                }
-            }
-        }
-    }
-    $self->{'bsig'} = 'sig'->collect(@sigs);
-}
-
-# Always compatible with other such builders, so the user
-# can define a single program or module from multiple places.
-sub compatible
-{
-    my ($self, $other) = @_;
-    ref($other) eq "build::command::link";
-}
-
-# Link a program.
-package build::command::linkedmodule;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(build::command) }
-
-# Always compatible with other such builders, so the user
-# can define a single linked module from multiple places.
-sub compatible
-{
-    my ($self, $other) = @_;
-    ref($other) eq "build::command::linkedmodule";
-}
-
-# Builder for a C module
-package build::command::cc;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(build::command) }
-
-sub find
-{
-    $_[1]->{_cc} || do
-    {
-        my ($class, $env) = @_;
-        my ($cpppath) = $env->_subst($env->{CPPPATH});
-        my ($cscanner) = find scan::cpp($env->{_cwd}, $cpppath);
-        $env->{_IFLAGS} = "%(" . $cscanner->iflags($env) . "%)";
-        my ($self) = find build::command($env, $env->{CCCOM});
-        $self->{scanner} = $cscanner;
-        bless $env->{_cc} = $self;
-      }
-}
-
-# Invoke the associated	 C scanner to get signature of included files.
-sub includes
-{
-    my ($self, $tgt) = @_;
-    $self->{scanner}->includes($tgt, $tgt->{sources}[0]);
-}
-
-# Builder for a C++ module
-package build::command::cxx;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(build::command) }
-
-sub find
-{
-    $_[1]->{_cxx} || do
-    {
-        my ($class, $env) = @_;
-        my ($cpppath) = $env->_subst($env->{CPPPATH});
-        my ($cscanner) = find scan::cpp($env->{_cwd}, $cpppath);
-        $env->{_IFLAGS} = "%(" . $cscanner->iflags($env) . "%)";
-        my ($self) = find build::command($env, $env->{CXXCOM});
-        $self->{scanner} = $cscanner;
-        bless $env->{_cxx} = $self;
-      }
-}
-
-# Invoke the associated	 C scanner to get signature of included files.
-sub includes
-{
-    my ($self, $tgt) = @_;
-    $self->{scanner}->includes($tgt, $tgt->{sources}[0]);
-}
-
-# Builder for a user command (cons::Command).  We assume that a user
-# command might be built and implement the appropriate dependencies on
-# the command itself (actually, just on the first word of the command
-# line).
-package build::command::user;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(build::command) }
-
-sub includes
-{
-    my ($self, $tgt) = @_;
-    my ($sig) = '';
-
-    # Check for any quick scanners attached to source files.
-    my $dep;
-    for $dep (@{$tgt->{dep}}, @{$tgt->{sources}})
-    {
-        my ($scanner) = $dep->{'srcscan', $self->{env}};
-        if ($scanner)
-        {
-            $sig .= $scanner->includes($tgt, $dep);
-        }
-    }
-
-    # XXX Optimize this to not use ignored paths.
-    if (!exists $self->{_comsig})
-    {
-        my ($env) = $self->{env};
-        $self->{_comsig} = '';
-        my ($com, $dir);
-        com:
-        for $com ($self->{act}->commands)
-        {
-            my ($pdirs) = $env->{ENV}->{PATH};
-            if (!defined $pdirs)
-            {
-                $pdirs = [];
-            }
-            elsif (ref($pdirs) ne 'ARRAY')
-            {
-                $pdirs = [split (/$main::PATH_SEPARATOR/o, $pdirs)];
-            }
-            for $dir (map($dir::top->lookupdir($_), @$pdirs))
-            {
-                my ($prog) = $dir->lookup_accessible($com);
-                if ($prog)
-                {    # XXX Not checking execute permission.
-                    if ((build $prog) eq 'errors')
-                    {
-                        $tgt->{status} = 'errors';
-                        return $sig;
-                    }
-                    next com if $prog->ignore;
-                    $self->{_comsig} .= 'sig'->signature($prog);
-                    next com;
-                }
-            }
-        }
-    }
-
-    return $self->{_comsig} . $sig;
-}
-
-# Builder for a library module (archive).
-# We assume that a user command might be built and implement the
-# appropriate dependencies on the command itself.
-package build::command::library;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(build::command) }
-
-sub find
-{
-    my ($class, $env) = @_;
-    bless find build::command($env, $env->{ARCOM});
-}
-
-# Always compatible with other library builders, so the user
-# can define a single library from multiple places.
-sub compatible
-{
-    my ($self, $other) = @_;
-    ref($other) eq "build::command::library";
-}
-
-# A multi-target builder.
-# This allows multiple targets to be associated with a single build
-# script, without forcing all the code to be aware of multiple targets.
-package build::multiple;
-
-sub new
-{
-    my ($class, $builder, $tgts) = @_;
-    bless {'builder' => $builder, 'env' => $builder->{env}, 'tgts' => $tgts};
-}
-
-sub scriptsig
-{
-    my ($self, $tgt) = @_;
-    $self->{builder}->scriptsig($tgt);
-}
-
-sub includes
-{
-    my ($self, $tgt) = @_;
-    $self->{builder}->includes($tgt);
-}
-
-sub compatible
-{
-    my ($self, $tgt) = @_;
-    $self->{builder}->compatible($tgt);
-}
-
-sub cachin
-{
-    my ($self, $tgt, $sig) = @_;
-    $self->{builder}->cachin($tgt, $sig);
-}
-
-sub cachout
-{
-    my ($self, $tgt, $sig) = @_;
-    $self->{builder}->cachout($tgt, $sig);
-}
-
-sub action
-{
-    my ($self, $invoked_tgt) = @_;
-    return $self->{built} if exists $self->{built};
-
-    # Make sure all targets in the group are unlinked before building any.
-    my ($tgts) = $self->{tgts};
-    my $tgt;
-    for $tgt (@$tgts)
-    {
-        futil::mkdir($tgt->{dir});
-        unlink($tgt->path) if !$tgt->precious;
-    }
-
-    # Now do the action to build all the targets. For consistency
-    # we always call the action on the first target, just so that
-    # $> is deterministic.
-    if ($param::max_jobs <= 1)
-    {    # pcons
-        $self->{built} = $self->{builder}->action($tgts->[0]);
-    }
-    else
-    {
-        {
-
-            # action now is non-blocking, so we must kludge blocking for this
-            # explicit call
-            local ($file::child_queue) = {parent => $tgts->[0]};    # pcons
-            $self->{built} = $self->{builder}->action($tgts->[0]);  # pcons
-            &file::wait_on_all_children();                          # pcons
-        }
-    }
-
-    # Now "build" all the other targets (except for the one
-    # we were called with). This guarantees that the signature
-    # of each target is updated appropriately. We force the
-    # targets to be built even if they have been previously
-    # considered and found to be OK; the only effect this
-    # has is to make sure that signature files are updated
-    # correctly.
-    for $tgt (@$tgts)
-    {
-        if ($tgt ne $invoked_tgt)
-        {
-            delete $tgt->{status};
-            'sig'->invalidate($tgt);
-            build $tgt;
-        }
-    }
-
-    # Status of action.
-    $self->{built};
-}
-
-package action;
-
-sub new
-{
-    my ($env, $act) = @_;
-    if (ref($act) eq 'CODE')
-    {
-        return action::perl->new($act);
-    }
-    else
-    {
-        return action::command->new($env, $act);
-    }
-}
-
-package action::command;
-
-use vars qw( @ISA %cmd %_varopts $_varletters );
-
-BEGIN
-{
-    @ISA = $main::_WIN32 ? 'action::command::win32' : 'action::command::unix';
-
-    # Internal hash for processing variable options.
-    # f: return file part
-    # d: return directory part
-    # F: return file part, but strip any suffix
-    # b: return full path, but strip any suffix (a.k.a. return basename)
-    # s: return only the suffix (or an empty string, if no suffix is there)
-    # a: return the absolute path to the file
-    # S: return the absolute path to a Linked source file
-    %_varopts = (
-        'f' => sub { return $_[0]->{entry}; },
-        'd' => sub { return $_[0]->{dir}->path; },
-        'F' => sub {
-            my $subst = $_[0]->{entry};
-            $subst =~ s/\.[^\.]+$//;
-            return $subst;
-        },
-        'b' => sub {
-            my $subst = $_[0]->path;
-            $subst =~ s/\.[^\.]+$//;
-            return $subst;
-        },
-        's' => sub {
-            my $subst = $_[0]->{entry};
-            $subst =~ m/(\.[^\.]+)$/;
-            return $1;
-        },
-        'a' => sub {
-            my $path = $_[0]->path;
-            if (!File::Spec->file_name_is_absolute($path))
-            {
-                $path = File::Spec->catfile(Cwd::cwd(), $path);
-            }
-            return $path;
-        },
-        'S' => sub {
-            my $path = $_[0]->srcpath;
-            if (!File::Spec->file_name_is_absolute($path))
-            {
-                my $cwd = File::Spec->canonpath(Cwd::cwd());
-                $path = File::Spec->catfile($cwd, $path);
-            }
-            return $path;
-        },
-        );
-
-    $_varletters = join ('', keys %_varopts);
-}
-
-# Internal routine for processing variable options.
-# Options are specified in hash in the BEGIN block above.
-# no option: return path to file (relative to top,
-# or absolute if it's outside)
-sub _variant
-{
-    my ($opt, $file) = @_;
-    $opt = '' if !defined $opt;
-    if (defined $_varopts{$opt})
-    {
-        return &{$_varopts{$opt}} ($file);
-    }
-    return $file->path;
-}
-
-sub new
-{
-    my ($class, $env, $cmd) = @_;
-    $cmd = $env->_subst($cmd);
-    $cmd{$env, $cmd} || do
-    {
-
-        # Remove unwanted bits from signature -- those bracketed by %( ... %)
-        my $sigs = $cmd;
-        my $sig  = '';
-        if (ref($sigs) eq 'ARRAY')
-        {
-
-            # This is an array of commands..
-            my $f;
-            foreach $f (@$sigs)
-            {
-                $sig .= _strip($f);
-            }
-        }
-        else
-        {
-            $sig = _strip($sigs);
-        }
-        my $self = {cmd => $cmd, cmdsig => 'sig'->cmdsig($sig)};
-        $cmd{$env, $cmd} = bless $self, $class;
-    };
-}
-
-sub _strip
-{
-    my $sig = shift;
-    $sig =~ s/^\@\s*//mg;
-    while ($sig =~ s/%\(([^%]|%[^\(])*?%\)//g) { }
-    $sig;
-}
-
-sub scriptsig
-{
-    $_[0]->{cmdsig};
-}
-
-# Return an array of all the commands (first word on each line).
-sub commands
-{
-    my ($self) = @_;
-    my (@cmds) = ();
-    my $com;
-    my $cmd = $self->{'cmd'};
-    my @allcoms;
-
-    push @allcoms, ref $cmd ? @{$cmd} : split (/\n/, $cmd);
-
-    for $com (@allcoms)
-    {
-        $com =~ s/^\s*//;
-        $com =~ s/\s.*//;
-        next if !$com;    # blank line
-        push @cmds, $com;
-    }
-    @cmds;
-}
-
-# For the signature of a basic command, we don't bother
-# including the command itself. This is not strictly correct,
-# and if we wanted to be rigorous, we might want to insist
-# that the command was checked for all the basic commands
-# like gcc, etc. For this reason we don't have an includes
-# method.
-
-# Call this to get the command line script: an array of
-# fully substituted commands.
-sub getcoms
-{
-    my ($self, $env, $tgt) = @_;
-    my (@coms);
-    my $com;
-    my @allcoms = ();
-    my $cmd     = $self->{'cmd'};
-
-    push @allcoms, ref $cmd ? @{$cmd} : split (/\n/, $cmd);
-
-    for $com (@allcoms)
-    {
-        my (@src) = (undef, @{$tgt->{sources}});
-        my (@src1) = @src;
-
-        next if $com =~ /^\s*$/;
-
-        # NOTE: we used to have a more elegant s//.../e solution
-        # for the items below, but this caused a bus error...
-
-        # Remove %( and %) -- those are only used to bracket parts
-        # of the command that we don't depend on.
-        $com =~ s/%[()]//g;
-
-        # Deal with %n, n=1,9 and variants.
-        while ($com =~ /%([1-9])(:([$_varletters]?))?/o)
-        {
-            my ($match) = $&;
-            my ($src)   = $src1[$1];
-            my ($subst) = _variant($3, $src1[$1]->rfile);
-            undef $src[$1];
-            $com =~ s/$match/$subst/;
-        }
-
-        # Deal with %0 aka %> and variants.
-        while ($com =~ /%[0>](:([$_varletters]?))?/o)
-        {
-            my ($match) = $&;
-            my ($subst) = _variant($2, $tgt);
-            $com =~ s/$match/$subst/;
-        }
-
-        # Deal with %< (all sources except %n's already used)
-        while ($com =~ /%<(:([$_varletters]?))?/o)
-        {
-            my ($match) = $&;
-            my @list = ();
-            foreach (@src)
-            {
-                push (@list, _variant($2, $_->rfile)) if $_;
-            }
-            my ($subst) = join (' ', @list);
-            $com =~ s/$match/$subst/;
-        }
-
-        # Deal with %[ %].
-        $com =~ s{%\[(.*?)%\]}{
-	    my($func, @args) = grep { $_ ne '' } split(/\s+/, $1);
-	    die("$0: \"$func\" is not defined.\n")
-		unless ($env->{$func});
-	    &{$env->{$func}}(@args);
-	}gex;
-
-        # Convert left-over %% into %.
-        $com =~ s/%%/%/g;
-
-        # White space cleanup. XXX NO WAY FOR USER TO HAVE QUOTED SPACES
-        $com = join (' ', split (' ', $com));
-        next if $com =~ /^:/ && $com !~ /^:\S/;
-        push (@coms, $com);
-    }
-    @coms;
-}
-
-# Build the target using the previously specified commands.
-sub execute
-{
-    my ($self, $env, $tgt, $package) = @_;
-
-    if ($param::build)
-    {
-        futil::mkdir($tgt->{dir});
-        unlink($tgt->path) if !$tgt->precious;
-    }
-
-    # Set environment.
-    map(delete $ENV{$_}, keys %ENV);
-    %ENV = %{$env->{ENV}};
-
-    # Handle multi-line commands.
-
-    my @cmds = $self->getcoms($env, $tgt);    # pcons
-    if ($param::max_jobs > 1)
-    {    # pcons
-        if ($#cmds > 0)
-        {
-            for ($i = 0 ; $i < @cmds ; $i++)
-            {    #pcons -kn
-                $cmds[$i] = "( " . $cmds[$i] . " )";    #pcons -kn
-            }    #pcons -kn
-            @cmds = join (" && ", @cmds);    # pcons
-        }    # pcons
-    }    # pcons
-
-    my $com;    # pcons
-    for $com (@cmds)
-    {           # pcons
-        if ($com !~ s/^\@\s*//)
-        {
-            main::showcom($com);
-        }
-        next if !$param::build;
-
-        if ($com =~ /^\[perl\]\s*/)
-        {
-            my $perlcmd = $';
-            my $status;
-            {
-
-                # Restore the script package variables that were defined
-                # in the Conscript file that defined this [perl] build,
-                # so the code executes with the expected variables.
-                # Then actually execute (eval) the [perl] command to build
-                # the target, followed by cleaning up the name space
-                # by deleting the package variables we just restored.
-                my ($pkgvars) = $tgt->{conscript}->{pkgvars};
-                NameSpace::restore($package, $pkgvars) if $pkgvars;
-                $status = eval "package $package; $perlcmd";
-                NameSpace::remove($package, keys %$pkgvars) if $pkgvars;
-            }
-            if (!defined($status))
-            {
-                warn "$0: *** Error during perl command eval: $@.\n";
-                return undef;
-            }
-            elsif ($status == 0)
-            {
-                warn "$0: *** Perl command returned $status "
-                  . "(this indicates an error).\n";
-                return undef;
-            }
-            next;
-        }
-        if (!$self->do_command($com, $tgt->path, $tgt))
-        {
-            return undef;
-        }
-    }
-
-    # success.
-    return 1;
-}
-
-sub show
-{
-    my ($self, $env, $tgt) = @_;
-    my $com;
-    for $com ($self->getcoms($env, $tgt))
-    {
-        if ($com !~ /^\@\s*/)
-        {
-            main::showcom($com);
-        }
-    }
-}
-
-package action::command::unix;
-
-sub do_command
-{
-    my ($class, $com, $path) = @_;    # cons
-    my ($class, $com, $path, $tgt) = @_;    # pcons
-
-    if ($param::max_jobs > 1)
-    {    # pcons
-        &file::wait_on_max_jobs();    # pcons
-    }    # pcons
-    my ($pid) = fork();
-    die ("$0: unable to fork child process ($!)\n") if !defined $pid;
-    if (!$pid)
-    {
-
-        # This is the child.  We eval the command to suppress -w
-        # warnings about not reaching the statements afterwards.
-        eval 'exec($com)';
-        $com =~ s/\s.*//;
-        die qq($0: failed to execute "$com" ($!). )
-          . qq(Is this an executable on path "$ENV{PATH}"?\n);
-    }
-    if ($param::max_jobs <= 1)
-    {    # pcons
-        for (; ;)
-        {
-            do { } until wait() == $pid;
-            my ($b0, $b1) = ($? & 0xFF, $? >> 8);
-
-            # Don't actually see 0177 on stopped process; is this necessary?
-            next if $b0 == 0177;    # process stopped; we can wait.
-            if ($b0)
-            {
-                my ($core, $sig) = ($b0 & 0200, $b0 & 0177);
-                my ($coremsg) = $core ? "; core dumped" : "";
-                $com =~ s/\s.*//;
-                my $err =
-                  "$0: *** \[$path\] $com terminated by signal "
-                  . "$sig$coremsg\n";
-                warn $err;
-                return undef;
-            }
-            if ($b1)
-            {
-                warn qq($0: *** [$path] Error $b1\n);  # trying to be like make.
-                return undef;
-            }
-            last;
-        }
-    }
-    else
-    {    # pcons
-        $file::child_queue->{$pid}->{com} = $com;    # pcons
-        $file::child_queue->{$pid}->{tgt} = $tgt;    # pcons
-
-    }    # pcons
-
-    return 1;
-}
-
-package action::command::win32;
-
-sub do_command
-{
-    my ($class, $com, $path, $tgt) = @_;
-    system($com);
-    if ($?)
-    {
-        my ($b0, $b1) = ($? & 0xFF, $? >> 8);
-        my $err = $b1 || $?;
-        my $warn = qq($0: *** [$path] Error $err);
-        $warn .= " (executable not found in path?)" if $b1 == 0xFF;
-        warn "$warn\n";
-        return undef;
-    }
-    return 1;
-}
-
-package action::perl;
-
-# THIS IS AN EXPERIMENTAL PACKAGE.  It's entirely possible that the
-# interface may change as this gets completed, so use at your own risk.
-#
-# There are (at least) two issues that need to be solved before blessing
-# this as a real, fully-supported feature:
-#
-#   --	We need to calculate a signature value for a Perl code ref, in
-#	order to rebuild the target if there's a change to the Perl code
-#	used to generate it.
-#
-#	This is not straightforward.  A B::Deparse package exists that
-#	decompiles a coderef into text.  It's reportedly not completely
-#	reliable for closures; it misses which variables are global, and
-#	the values of private lexicals.  Nevertheless, it'd probably
-#	be perfect for our purposes, except that it wasn't added until
-#	some time between Perl 5.00502 and 5.00554, and doesn't seem to
-#	really work until Perl 5.6.0, so by relying on it, we'd lose
-#	support for Perl versions back to 5.003*.
-#
-#   --	Ideally, a code ref should be able to use something like
-#	$env->_subst to fetch values from the construction environment
-#	to modify its behavior without having to cut-and-paste code.
-#	(Actually, since we pass the environment to the executed code
-#	ref, there's no reason you can't do this with the code as it
-#	stands today.)  But this REALLY complicates the signature
-#	calculation, because now the actual signature would depend not
-#	just on the code contents, but on the construction variables (or
-#	maybe just the environment).
-#
-# A potentially valid workaround would be to use the contents of the
-# Conscript file in which the code reference is defined as the code
-# ref's signature.  This has the drawback of causing a recompilation of
-# the target file even in response to unrelated changes in the Conscript
-# file, but it would ensure correct builds without having to solve the
-# messy issues of generating a signature directly from a code ref.
-#
-# Nevertheless, this seemed a useful enough skeleton of a feature that
-# it made sense to release it in hopes that some practical experience
-# will encourage someone to figure out how to solve the signature
-# issues.  Or maybe we'll discover these aren't big issues in practice
-# and end up blessing it as is.
-
-use vars qw( %code );
-
-sub new
-{
-    my ($class, $cref) = @_;
-    $code{$cref} || do
-    {
-        my $sig = '';
-
-        # Generating a code signature using B::Deparse doesn't really
-        # work for us until Perl 5.6.0.  Here's the code in case
-        # someone wants to use it.
-        #use B::Deparse;
-        #my $deparse = B::Deparse->new();
-        #my $body = $deparse->coderef2text($cref);
-        #$sig = $body;	# should be an MD5 sig
-        my ($self) = {cref => $cref, crefsig => $sig};
-        $code{$cref} = bless $self, $class;
-      }
-}
-
-sub scriptsig
-{
-    $_[0]->{crefsig};
-}
-
-sub execute
-{
-    my ($self, $env, $tgt) = @_;
-    if ($param::build)
-    {
-        futil::mkdir($tgt->{dir});
-        unlink($tgt->path) if !$tgt->precious;
-        my ($cref) = $self->{cref};
-        &$cref($env, $tgt->path, map($_->rpath, @{$tgt->{sources}}));
-    }
-}
-
-sub commands
-{
-    return ();
-}
-
-# Generic scanning module.
-package scan;
-
-# Returns the signature of files included by the specified files on
-# behalf of the associated target. Any errors in handling the included
-# files are propagated to the target on whose behalf this processing
-# is being done. Signatures are cached for each unique file/scanner
-# pair.
-sub includes
-{
-    my ($self, $tgt, @files) = @_;
-    my (%files, $file);
-    my ($inc) = $self->{includes} || ($self->{includes} = {});
-    while ($file = pop @files)
-    {
-        next if exists $files{$file};
-        if ($inc->{$file})
-        {
-            push (@files, @{$inc->{$file}});
-            $files{$file} = 'sig'->signature($file->rfile);
-        }
-        else
-        {
-            if ((build $file) eq 'errors')
-            {
-                $tgt->{status} = 'errors';    # tgt inherits build status
-                return ();
-            }
-            $files{$file} = 'sig'->signature($file->rfile);
-            my (@includes) = $self->scan($file);
-            $inc->{$file} = \@includes;
-            push (@files, @includes);
-        }
-    }
-    'sig'->collect(sort values %files);
-}
-
-# A simple scanner. This is used by the QuickScanfunction, to setup
-# one-time target and environment-independent scanning for a source
-# file. Only used for commands run by the Command method.
-package scan::quickscan;
-
-use vars qw( @ISA %scanner );
-
-BEGIN { @ISA = qw(scan) }
-
-sub find
-{
-    my ($class, $code, $env, $pdirs) = @_;
-    if (!defined $pdirs)
-    {
-        $pdirs = [];
-    }
-    elsif (ref($pdirs) ne 'ARRAY')
-    {
-        $pdirs = [split (/$main::PATH_SEPARATOR/o, $pdirs)];
-    }
-    my (@path) = map { $dir::cwd->lookupdir($_) } @$pdirs;
-    my ($spath) = "@path";
-    $scanner{$code, $env, $spath} || do
-    {
-        my ($self) = {code => $code, env => $env, path => \@path};
-        $scanner{$code, $env, $spath} = bless $self;
-      }
-}
-
-# Scan the specified file for included file names.
-sub scan
-{
-    my ($self, $file) = @_;
-    my ($code) = $self->{code};
-    my (@includes);
-
-    # File should have been built by now. If not, we'll ignore it.
-    return () unless open(SCAN, $file->rpath);
-    while (<SCAN>)
-    {
-        push (@includes, grep($_ ne '', &$code));
-    }
-    close(SCAN);
-    my ($wd) = $file->{dir};
-    my (@files);
-    my $name;
-    for $name (@includes)
-    {
-        my $dir;
-        for $dir ($file->{dir}, @{$self->{path}})
-        {
-            my ($include) = $dir->lookup_accessible($name);
-            if ($include)
-            {
-                push (@files, $include) unless $include->ignore;
-                last;
-            }
-        }
-    }
-    @files;
-}
-
-# CPP (C preprocessor) scanning module
-package scan::cpp;
-
-use vars qw( @ISA %scanner );
-
-BEGIN { @ISA = qw(scan) }
-
-# For this constructor, provide the include path argument (colon
-# separated). Each path is taken relative to the provided directory.
-
-# Note: a particular scanning object is assumed to always return the
-# same result for the same input. This is why the search path is a
-# parameter to the constructor for a CPP scanning object. We go to
-# some pains to make sure that we return the same scanner object
-# for the same path: otherwise we will unecessarily scan files.
-sub find
-{
-    my ($class, $dir, $pdirs) = @_;
-    if (!defined $pdirs)
-    {
-        $pdirs = [];
-    }
-    elsif (ref($pdirs) ne 'ARRAY')
-    {
-        $pdirs = [split (/$main::PATH_SEPARATOR/o, $pdirs)];
-    }
-    my @path = map($dir->lookupdir($_), @$pdirs);
-    my ($spath) = "@path";
-    $scanner{$spath} || do
-    {
-        my ($self) = {'path' => \@path};
-        $scanner{$spath} = bless $self;
-      }
-}
-
-# Scan the specified file for include lines.
-sub scan
-{
-    my ($self, $file) = @_;
-    my ($angles, $quotes);
-
-    if (exists $file->{angles})
-    {
-        $angles = $file->{angles};
-        $quotes = $file->{quotes};
-    }
-    else
-    {
-        my (@anglenames, @quotenames);
-        return () unless open(SCAN, $file->rpath);
-        while (<SCAN>)
-        {
-            next unless /^\s*#/;
-            if (/^\s*#\s*include\s*([<"])(.*?)[>"]/)
-            {
-                if ($1 eq "<")
-                {
-                    push (@anglenames, $2);
-                }
-                else
-                {
-                    push (@quotenames, $2);
-                }
-            }
-        }
-        close(SCAN);
-        $angles = $file->{angles} = \@anglenames;
-        $quotes = $file->{quotes} = \@quotenames;
-    }
-
-    my (@shortpath) = @{$self->{path}};             # path for <> style includes
-    my (@longpath)  = ($file->{dir}, @shortpath);   # path for "" style includes
-
-    my (@includes);
-
-    my $name;
-    for $name (@$angles)
-    {
-        my $dir;
-        for $dir (@shortpath)
-        {
-            my ($include) = $dir->lookup_accessible($name);
-            if ($include)
-            {
-                push (@includes, $include) unless $include->ignore;
-                last;
-            }
-        }
-    }
-
-    for $name (@$quotes)
-    {
-        my $dir;
-        for $dir (@longpath)
-        {
-            my ($include) = $dir->lookup_accessible($name);
-            if ($include)
-            {
-                push (@includes, $include) unless $include->ignore;
-                last;
-            }
-        }
-    }
-
-    return @includes;
-}
-
-# Return the include flags that would be used for a C Compile.
-sub iflags
-{
-    my ($self, $env) = @_;
-    my ($iflags) = '';
-    my ($dir, $dpath);
-    for $dir (@{$self->{path}})
-    {
-        $dpath = $dir->path;
-
-        # Add the (presumably local) directory to the -I flags
-        # if we're not using repositories, the directory exists,
-        # or it's Linked to a source directory (that is, it *will*
-        # exist by the time the compilation occurs).
-        $iflags .= " " . $env->{INCDIRPREFIX} . $dpath . $env->{INCDIRSUFFIX}
-          if !@param::rpath || -d $dpath || $dir->is_linked;
-        next if File::Spec->file_name_is_absolute($dpath);
-        if (@param::rpath)
-        {
-            my $d;
-            if ($dpath eq $dir::CURDIR)
-            {
-                foreach $d (map($_->path, @param::rpath))
-                {
-                    $iflags .=
-                      " " . $env->{INCDIRPREFIX} . $d . $env->{INCDIRSUFFIX};
-                }
-            }
-            else
-            {
-                my ($rpath);
-                foreach $d (map($_->path, @param::rpath))
-                {
-                    $rpath = File::Spec->catfile($d, $dpath);
-                    $iflags .=
-                      " " . $env->{INCDIRPREFIX} . $rpath . $env->{INCDIRSUFFIX}
-                      if -d $rpath;
-                }
-            }
-        }
-    }
-    $iflags;
-}
-
-package File::Spec;
-
-use vars qw( $_SEP $_MATCH_SEP $_MATCH_VOL );
-
-# Cons is migrating to using File::Spec for portable path name
-# manipulation.  This is the right long-term direction, but there are
-# some problems with making the transition:
-#
-#	For multi-volume support, we need to use newer interfaces
-#	(splitpath, catpath, splitdir) that are only available in
-#	File::Spec 0.8.
-#
-#	File::Spec 0.8 doesn't work with Perl 5.00[34] due to
-#	regular expression incompatibilities (use of \z).
-#
-#	Forcing people to use a new version of a module is painful
-#	because (in the workplace) their administrators aren't
-#	always going to agree to install it everywhere.
-#
-# As a middle ground, we provide our own versions of all the File::Spec
-# methods we use, supporting both UNIX and Win32.  Some of these methods
-# are home brew, some are cut-and-pasted from the real File::Spec methods.
-# This way, we're not reinventing the whole wheel, at least.
-#
-# We can (and should) get rid of this class whenever 5.00[34] and
-# versions of File::Spec prior to 0.9 (?) have faded sufficiently.
-# We also may need to revisit whenever someone first wants to use
-# Cons on some platform other than UNIX or Win32.
-
-BEGIN
-{
-    if ($main::_WIN32)
-    {
-        $_SEP       = '\\';
-        $_MATCH_SEP = "[\Q/$_SEP\E]";
-        $_MATCH_VOL = "([a-z]:)?$_MATCH_SEP";
-    }
-    else
-    {
-        $_SEP       = '/';
-        $_MATCH_SEP = "\Q$_SEP\E";
-        $_MATCH_VOL = $_MATCH_SEP;
-    }
-}
-
-sub canonpath
-{
-    my ($self, $path) = @_;
-    if ($main::_WIN32)
-    {
-        $path =~ s/^([a-z]:)/\u$1/s;
-        $path =~ s|/|\\|g;
-        $path =~ s|([^\\])\\+|$1\\|g;                       # xx////xx  -> xx/xx
-        $path =~ s|(\\\.)+\\|\\|g;                          # xx/././xx -> xx/xx
-        $path =~ s|^(\.\\)+||s unless $path eq ".\\";       # ./xx      -> xx
-        $path =~ s|\\$|| unless $path =~ m#^([A-Z]:)?\\$#s; # xx/       -> xx
-    }
-    else
-    {
-        $path =~ s|/+|/|g unless ($^O eq 'cygwin');    # xx////xx  -> xx/xx
-        $path =~ s|(/\.)+/|/|g;                        # xx/././xx -> xx/xx
-        $path =~ s|^(\./)+||s unless $path eq "./";    # ./xx      -> xx
-        $path =~ s|^/(\.\./)+|/|s;                     # /../../xx -> xx
-        $path =~ s|/$|| unless $path eq "/";           # xx/       -> xx
-    }
-    return $path;
-}
-
-sub catdir
-{
-    my $self = shift;
-    my @args = @_;
-    foreach (@args)
-    {
-
-        # append a slash to each argument unless it has one there
-        $_ .= $_SEP if $_ eq '' || substr($_, -1) ne $_SEP;
-    }
-    return $self->canonpath(join ('', @args));
-}
-
-sub catfile
-{
-    my $self = shift;
-    my $file = pop @_;
-    return $file unless @_;
-    my $dir = $self->catdir(@_);
-    $dir .= $_SEP unless substr($dir, -1) eq $_SEP;
-    $file = '' if !defined($file);
-    return $dir . $file;
-}
-
-sub catpath
-{
-    my $path = $_[1] . $_[0]->catfile(@_[2 .. $#_]);
-    $path =~ s/(.)$_MATCH_SEP*$/$1/;
-    $path;
-}
-
-sub curdir
-{
-    '.';
-}
-
-sub file_name_is_absolute
-{
-    my ($self, $file) = @_;
-    return scalar($file =~ m{^$_MATCH_VOL}is);
-}
-
-sub splitdir
-{
-    my @dirs = split (/$_MATCH_SEP/, $_[1], -1);
-    push (@dirs, '') if $dirs[$#dirs];
-    @dirs;
-}
-
-sub splitpath
-{
-    my ($self, $path) = @_;
-    my $vol = '';
-    my $sep = $_SEP;
-    if ($main::_WIN32)
-    {
-        if ($path =~ s#^([A-Za-z]:|(?:\\\\|//)[^\\/]+[\\/][^\\/]+)([\\/])#$2#)
-        {
-            $vol = $1;
-            $sep = $2;
-        }
-    }
-    my (@path) = split (/$_MATCH_SEP/, $path, -1);
-    my $file = pop @path;
-    my $dirs = join ($sep, @path, '');
-    return ($vol, $dirs, $file);
-}
-
-sub updir
-{
-    '..';
-}
-
-sub case_tolerant
-{
-    return $main::_WIN32;
-}
-
-# Directory and file handling. Files/dirs are represented by objects.
-# Other packages are welcome to add component-specific attributes.
-package dir;
-
-use vars qw( $SEPARATOR $MATCH_SEPARATOR $CURDIR $UPDIR
-  $cwd_vol %root $top $cwd );
-
-BEGIN
-{
-
-    # A portable way of determing our directory separator.
-    $SEPARATOR = File::Spec->catdir('', '');
-
-    # A fast-path regular expression to match a directory separator
-    # anywhere in a path name.
-    if ($SEPARATOR eq '/')
-    {
-        $MATCH_SEPARATOR = "\Q$SEPARATOR\E";
-    }
-    else
-    {
-        $MATCH_SEPARATOR = "[\Q/$SEPARATOR\E]";
-    }
-
-    # Cache these values so we don't have to make a method call
-    # every time we need them.
-    $CURDIR  = File::Spec->curdir;    # '.' on UNIX
-    $UPDIR   = File::Spec->updir;     # '..' on UNIX
-                                      #
-    $cwd_vol = '';
-}
-
-# Annotate a node (file or directory) with info about the
-# method that created it.
-sub creator
-{
-    my ($self, @frame) = @_;
-    $self->{'creator'} = \@frame if @frame;
-    $self->{'creator'};
-}
-
-# Handle a file|dir type exception.  We only die if we find we were
-# invoked by something in a Conscript/Construct file, because
-# dependencies created directly by Cons' analysis shouldn't cause
-# an error.
-sub _type_exception
-{
-    my ($e) = @_;
-    my ($line, $sub);
-    (undef, undef, $line, $sub) = script::caller_info;
-    if (defined $line)
-    {
-        my $err =
-          "\"${\$e->path}\" already in use as a "
-          . ref($e)
-          . " before $sub on line $line";
-        if ($e->{'creator'})
-        {
-            my $script;
-            (undef, $script, $line, $sub) = @{$e->{'creator'}};
-            $err =
-              "\t" . $err . ",\n\t\tdefined by $sub in $script, line $line";
-        }
-        $err .= "\n";
-        die $err;
-    }
-}
-
-# This wraps up all the common File::Spec logic that we use for parsing
-# directory separators in a path and turning it into individual
-# subdirectories that we must create, as well as creation of root
-# nodes for any new file system volumes we find.  File::Spec doesn't have
-# intuitively obvious interfaces, so this is heavily commented.
-#
-# Note:  This is NOT an object or class method;
-# it's just a utility subroutine.
-sub _parse_path
-{
-    my ($dir, $path) = @_;
-
-    # Convert all slashes to the native directory separator.
-    # This allows Construct files to always be written with good
-    # old POSIX path names, regardless of what we're running on.
-    $path = File::Spec->canonpath($path);
-
-    # File::Spec doesn't understand the Cons convention of
-    # an initial '#' for top-relative files.  Strip it.
-    my ($toprel) = $path =~ s/^#//;
-
-    # Let File::Spec do the heavy lifting of parsing the path name.
-    my ($vol, $directories, $entry) = File::Spec->splitpath($path);
-    my @dirs = File::Spec->splitdir($directories);
-
-    # If there was a file entry on the end of the path, then the
-    # last @dirs element is '' and we don't need it.  If there
-    # wasn't a file entry on the end (File::Spec->splitpath() knew
-    # the last component was a directory), then the last @dirs
-    # element becomes the entry we want to look up.
-    my ($e) = pop @dirs;
-    $entry = $e if $entry eq '';
-
-    if (File::Spec->file_name_is_absolute($path))
-    {
-
-        # An absolute path name.  If no volume was supplied,
-        # use the volume of our current directory.
-        $vol = $cwd_vol if $vol eq '';
-        $vol = uc($vol) if File::Spec->case_tolerant;
-        if (!defined $root{$vol})
-        {
-
-            # This is our first time looking up a path name
-            # on this volume, so create a root node for it.
-            # (On UNIX systems, $vol is always '', so '/'
-            # always maps to the $root{''} node.)
-            $root{$vol} = {
-                            path     => $vol . $SEPARATOR,
-                            prefix   => $vol . $SEPARATOR,
-                            srcpath  => $vol . $SEPARATOR,
-                            'exists' => 1
-                            };
-            $root{$vol}->{'srcdir'} = $root{$vol};
-            bless $root{$vol};
-        }
-
-        # We're at the top, so strip the blank entry from the front of
-        # the @dirs array since the initial '/' it represents will now
-        # be supplied by the root node we return.
-        shift @dirs;
-        $dir = $root{$vol};
-    }
-    elsif ($toprel)
-    {
-        $dir = $dir::top;
-    }
-    ($dir, \@dirs, $entry);
-}
-
-# Common subroutine for creating directory nodes.
-sub _create_dirs
-{
-    my ($dir, @dirs) = @_;
-    my $e;
-    foreach $e (@dirs)
-    {
-        my $d = $dir->{member}->{$e};
-        if (!defined $d)
-        {
-            bless $d = {'entry' => $e, 'dir' => $dir,}, 'dir';
-            $d->creator(script::caller_info);
-            $d->{member}->{$dir::CURDIR} = $d;
-            $d->{member}->{$dir::UPDIR}  = $dir;
-            $dir->{member}->{$e}         = $d;
-        }
-        elsif (ref $d eq 'entry')
-        {
-            bless $d, 'dir';
-            $d->{member}->{$dir::CURDIR} = $d;
-            $d->{member}->{$dir::UPDIR}  = $dir;
-        }
-        elsif (ref $d eq 'file')
-        {
-
-            # This clause is to supply backwards compatibility,
-            # with a warning, for anyone that's used FilePath
-            # to refer to a directory.  After people have using
-            # 1.8 have had time to adjust (sometime in version
-            # 1.9 or later), we should remove this entire clause.
-            my ($script, $line, $sub);
-            (undef, $script, $line, $sub) = @{$d->{'creator'}};
-            if ($sub eq 'script::FilePath')
-            {
-                print STDERR
-                  "$0:  Warning:  $sub used to refer to a directory\n"
-                  . "\tat line $line of $script.  Use DirPath instead.\n";
-                bless $d, 'dir';
-            }
-            else
-            {
-                _type_exception($d);
-            }
-        }
-        elsif (ref $d ne 'dir')
-        {
-            _type_exception($d);
-        }
-        $dir = $d;
-    }
-    $dir;
-}
-
-# Look up an entry in a directory.  This method is for when we don't
-# care whether a file or directory is returned, so if the entry already
-# exists, it will simply be returned.  If not, we create it as a
-# generic "entry" which can be later turned into a file or directory
-# by a more-specific lookup.
-#
-# The file entry may be specified as relative, absolute (starts with /),
-# or top-relative (starts with #).
-sub lookup
-{
-    my ($dir, $entry) = @_;
-
-    if ($entry !~ m#$MATCH_SEPARATOR#o)
-    {
-
-        # Fast path: simple entry name in a known directory.
-        if ($entry =~ s/^#//)
-        {
-
-            # Top-relative names begin with #.
-            $dir = $dir::top;
-        }
-        elsif ($entry =~ s/^!//)
-        {
-            $dir = $dir::cwd->srcdir;
-        }
-    }
-    else
-    {
-        my $dirsref;
-        ($dir, $dirsref, $entry) = _parse_path($dir, $entry);
-        $dir = _create_dirs($dir, @$dirsref) if @$dirsref;
-        return if !defined $dir;
-        return $dir if $entry eq '';
-    }
-
-    my $e = $dir->{member}->{$entry};
-    if (!defined $e)
-    {
-        bless $e = {'entry' => $entry, 'dir' => $dir,}, 'entry';
-        $e->creator(script::caller_info);
-        $dir->{member}->{$entry} = $e;
-    }
-
-    $e;
-}
-
-# Look up a file entry in a directory.
-#
-# The file entry may be specified as relative, absolute (starts with /),
-# or top-relative (starts with #).
-sub lookupfile
-{
-    my ($dir, $entry) = @_;
-
-    if ($entry !~ m#$MATCH_SEPARATOR#o)
-    {
-
-        # Fast path: simple entry name in a known directory.
-        if ($entry =~ s/^#//)
-        {
-
-            # Top-relative names begin with #.
-            $dir = $dir::top;
-        }
-        elsif ($entry =~ s/^!//)
-        {
-            $dir = $dir::cwd->srcdir;
-        }
-    }
-    else
-    {
-        my $dirsref;
-        ($dir, $dirsref, $entry) = _parse_path($dir, $entry);
-        $dir = _create_dirs($dir, @$dirsref) if @$dirsref;
-        return undef if $entry eq '';
-    }
-
-    my $f = $dir->{member}->{$entry};
-    if (!defined $f)
-    {
-        bless $f = {'entry' => $entry, 'dir' => $dir,}, 'file';
-        $f->creator(script::caller_info);
-        $dir->{member}->{$entry} = $f;
-    }
-    elsif (ref $f eq 'entry')
-    {
-        bless $f, 'file';
-    }
-    elsif (ref $f ne 'file')
-    {
-        _type_exception($f);
-    }
-
-    $f;
-}
-
-# Look up a (sub-)directory entry in a directory.
-#
-# The (sub-)directory entry may be specified as relative, absolute
-# (starts with /), or top-relative (starts with #).
-sub lookupdir
-{
-    my ($dir, $entry) = @_;
-
-    my $dirsref;
-    if ($entry !~ m#$MATCH_SEPARATOR#o)
-    {
-
-        # Fast path: simple entry name in a known directory.
-        if ($entry =~ s/^#//)
-        {
-
-            # Top-relative names begin with #.
-            $dir = $dir::top;
-        }
-        elsif ($entry =~ s/^!//)
-        {
-            $dir = $dir::cwd->srcdir;
-        }
-    }
-    else
-    {
-        ($dir, $dirsref, $entry) = _parse_path($dir, $entry);
-    }
-    push (@$dirsref, $entry) if $entry ne '';
-    _create_dirs($dir, @$dirsref);
-}
-
-# Look up a file entry and return it if it's accessible.
-sub lookup_accessible
-{
-    my $file = $_[0]->lookupfile($_[1]);
-    return ($file && $file->accessible) ? $file : undef;
-}
-
-# Return the parent directory without doing a lookupdir,
-# which would create a parent if it doesn't already exist.
-# A return value of undef (! $dir->up) indicates a root directory.
-sub up
-{
-    $_[0]->{member}->{$dir::UPDIR};
-}
-
-# Return whether this is an entry somewhere underneath the
-# specified directory.
-sub is_under
-{
-    my $dir = $_[0];
-    while ($dir)
-    {
-        return 1 if $_[1] == $dir;
-        $dir = $dir->up;
-    }
-    return undef;
-}
-
-# Return the relative path from the calling directory ($_[1])
-# to the object.  If the object is not under the directory, then
-# we return it as a top-relative or absolute path name.
-sub relpath
-{
-    my ($dir, $obj) = @_;
-    my @dirs;
-    my $o = $obj;
-    while ($o)
-    {
-        if ($dir == $o)
-        {
-            if (@dirs < 2)
-            {
-                return $dirs[0] || '';
-            }
-            else
-            {
-                return File::Spec->catdir(@dirs);
-            }
-        }
-        unshift (@dirs, $o->{entry});
-        $o = $o->up;
-    }
-
-    # The object was not underneath the specified directory.
-    # Use the node's cached path, which is either top-relative
-    # (in which case we append '#' to the beginning) or
-    # absolute.
-    my $p = $obj->path;
-    $p = '#' . $p if !File::Spec->file_name_is_absolute($p);
-    return $p;
-}
-
-# Return the path of the directory (file paths implemented
-# separately, below).
-sub path
-{
-    $_[0]->{path} || ($_[0]->{path} = $_[0]->{dir}->prefix . $_[0]->{entry});
-}
-
-# Return the pathname as a prefix to be concatenated with an entry.
-sub prefix
-{
-    return $_[0]->{prefix} if exists $_[0]->{prefix};
-    $_[0]->{prefix} = $_[0]->path . $SEPARATOR;
-}
-
-# Return the related source path prefix.
-sub srcprefix
-{
-    return $_[0]->{srcprefix} if exists $_[0]->{srcprefix};
-    my ($srcdir) = $_[0]->srcdir;
-    $srcdir->{srcprefix} =
-      $srcdir eq $_[0] ? $srcdir->prefix : $srcdir->srcprefix;
-}
-
-# Return the related source directory.
-sub srcdir
-{
-    $_[0]->{'srcdir'}
-      || ($_[0]->{'srcdir'} = $_[0]->{dir}->srcdir->lookupdir($_[0]->{entry}));
-}
-
-# Return if the directory is linked to a separate source directory.
-sub is_linked
-{
-    return $_[0]->{is_linked} if defined $_[0]->{is_linked};
-    $_[0]->{is_linked} = $_[0]->path ne $_[0]->srcdir->path;
-}
-
-sub link
-{
-    my (@paths)  = @_;
-    my ($srcdir) = $dir::cwd->lookupdir(pop @paths)->srcdir;
-    map($dir::cwd->lookupdir($_)->{'srcdir'} = $srcdir, @paths);
-
-    # make a reverse lookup for the link.
-    $srcdir->{links} = [] if !$srcdir->{links};
-    push @{$srcdir->{links}}, @paths;
-}
-
-use vars qw( @tail );    # TODO: Why global ????
-
-sub linked_targets
-{
-    my $tgt     = shift;
-    my @targets = ();
-    my $dir;
-    if (ref $tgt eq 'dir')
-    {
-        $dir = $tgt;
-    }
-    else
-    {
-        push @tail, $tgt;
-        $dir = $tgt->{dir};
-    }
-    while ($dir)
-    {
-        if (defined $dir->{links} && @{$dir->{links}})
-        {
-            push @targets, map(File::Spec->catdir($_, @tail), @{$dir->{links}});
-
-            #print STDERR "Found Link: ${\$dir->path} -> @{\$dir->{links}}\n";
-        }
-        unshift @tail, $dir->{entry};
-        $dir = $dir->up;
-    }
-
-    return map($dir::top->lookupdir($_), @targets);
-}
-
-sub accessible
-{
-    my $path = $_[0]->path;
-    my $err  =
-      "$0: you have attempted to use path \"$path\" both as a file "
-      . "and as a directory!\n";
-    die $err;
-}
-
-sub init
-{
-    my $path = Cwd::cwd();
-
-    # We know we can get away with passing undef to lookupdir
-    # as the directory because $dir is an absolute path.
-    $top = lookupdir(undef, $path);
-    $top->{'path'} = $top->{srcpath} = $dir::CURDIR;
-    $top->{'prefix'} = '';
-    $top->{'srcdir'} = $top;
-
-    $cwd = $top;
-
-    ($cwd_vol, undef, undef) = File::Spec->splitpath($path);
-    $cwd_vol = '' if !defined $cwd_vol;
-    $cwd_vol = uc($cwd_vol) if File::Spec->case_tolerant;
-}
-
-package file;
-
-use vars qw( @ISA $level );
-
-BEGIN { @ISA = qw(dir); $level = 0 }
-
-# Return the pathname of the file.
-# Define this separately from dir::path because we don't want to
-# cache all file pathnames (just directory pathnames).
-sub path
-{
-    $_[0]->{dir}->prefix . $_[0]->{entry};
-}
-
-# Return the related source file path.
-sub srcpath
-{
-    $_[0]->{dir}->srcprefix . $_[0]->{entry};
-}
-
-# Return if the file is (should be) linked to a separate source file.
-sub is_linked
-{
-    $_[0]->{dir}->is_linked;
-}
-
-# Repository file search.  If the local file exists, that wins.
-# Otherwise, return the first existing same-named file under a
-# Repository directory.  If there isn't anything with the same name
-# under a Repository directory, return the local file name anyway
-# so that some higher layer can try to construct it.
-sub rfile
-{
-    return $_[0]->{rfile} if exists $_[0]->{rfile};
-    my ($self)  = @_;
-    my ($rfile) = $self;
-    if (@param::rpath)
-    {
-        my ($path) = $self->path;
-        if (!File::Spec->file_name_is_absolute($path) && !-f $path)
-        {
-            my ($dir);
-            foreach $dir (@param::rpath)
-            {
-                my ($t) = $dir->prefix . $path;
-                if (-f $t)
-                {
-                    $rfile = $_[0]->lookupfile($t);
-                    $rfile->{'lfile'} = $self;
-                    last;
-                }
-            }
-        }
-    }
-    $self->{rfile} = $rfile;
-}
-
-# Returns the local file for a repository file;
-# returns self if it's already a local file.
-sub lfile
-{
-    $_[0]->{'lfile'} || $_[0];
-}
-
-# returns the "precious" status of this file.
-sub precious
-{
-    return $_[0]->{precious};
-}
-
-# "Erase" reference to a Repository file,
-# making this a completely local file object
-# by pointing it back to itself.
-sub no_rfile
-{
-    $_[0]->{'rfile'} = $_[0];
-}
-
-# Return a path to the first existing file under a Repository directory,
-# implicitly returning the current file's path if there isn't a
-# same-named file under a Repository directory.
-sub rpath
-{
-    $_[0]->{rpath} || ($_[0]->{rpath} = $_[0]->rfile->path);
-}
-
-# Return a path to the first linked srcpath file under a Repositoy
-# directory, implicitly returning the current file's srcpath if there
-# isn't a same-named file under a Repository directory.
-sub rsrcpath
-{
-    return $_[0]->{rsrcpath} if exists $_[0]->{rsrcpath};
-    my ($self) = @_;
-    my ($path) = $self->{rsrcpath} = $self->srcpath;
-    if (@param::rpath && !File::Spec->file_name_is_absolute($path) && !-f $path)
-    {
-        my ($dir);
-        foreach $dir (@param::rpath)
-        {
-            my ($t) = $dir->prefix . $path;
-            if (-f $t)
-            {
-                $self->{rsrcpath} = $t;
-                last;
-            }
-        }
-    }
-    $self->{rsrcpath};
-}
-
-# Return if a same-named file source file exists.
-# This handles the interaction of Link and Repository logic.
-# As a side effect, it will link a source file from its Linked
-# directory (preferably local, but maybe in a repository)
-# into a build directory from its proper Linked directory.
-sub source_exists
-{
-    return $_[0]->{source_exists} if defined $_[0]->{source_exists};
-    my ($self) = @_;
-    my ($path) = $self->path;
-    my ($mtime, $ctime) = (stat($path))[9, 10];
-    if ($self->is_linked)
-    {
-
-        # Linked directory, local logic.
-        my ($srcpath) = $self->srcpath;
-        my ($src_mtime, $src_ctime) = (stat($srcpath))[9, 10];
-        if ($src_mtime)
-        {
-            if (!$mtime || $src_mtime != $mtime || $src_ctime != $ctime)
-            {
-                futil::install($srcpath, $self);
-            }
-            return $self->{source_exists} = 1;
-        }
-
-        # Linked directory, repository logic.
-        if (@param::rpath)
-        {
-            if ($self != $self->rfile)
-            {
-                return $self->{source_exists} = 1;
-            }
-            my ($rsrcpath) = $self->rsrcpath;
-            if ($path ne $rsrcpath)
-            {
-                my ($rsrc_mtime, $rsrc_ctime) = (stat($rsrcpath))[9, 10];
-                if ($rsrc_mtime)
-                {
-                    if (!$mtime
-                        || $rsrc_mtime != $mtime
-                        || $rsrc_ctime != $ctime)
-                    {
-                        futil::install($rsrcpath, $self);
-                    }
-                    return $self->{source_exists} = 1;
-                }
-            }
-        }
-
-        # There was no source file in any Linked directory
-        # under any Repository.  If there's one in the local
-        # build directory, it no longer belongs there.
-        if ($mtime)
-        {
-            unlink($path) || die ("$0: couldn't unlink $path ($!)\n");
-        }
-        return $self->{source_exists} = '';
-    }
-    else
-    {
-        if ($mtime)
-        {
-            return $self->{source_exists} = 1;
-        }
-        if (@param::rpath && $self != $self->rfile)
-        {
-            return $self->{source_exists} = 1;
-        }
-        return $self->{source_exists} = '';
-    }
-}
-
-# Return if a same-named derived file exists under a Repository directory.
-sub derived_exists
-{
-    $_[0]->{derived_exists}
-      || ($_[0]->{derived_exists} = ($_[0] != $_[0]->rfile));
-}
-
-# Return if this file is somewhere under a Repository directory.
-sub is_on_rpath
-{
-    defined $_[0]->{'lfile'};
-}
-
-sub local
-{
-    my ($self, $arg) = @_;
-    if (defined $arg)
-    {
-        $self->{'local'} = $arg;
-    }
-    $self->{'local'};
-}
-
-# Return the entry name of the specified file with the specified
-# suffix appended.  Leave it untouched if the suffix is already there.
-# Differs from the addsuffix function, below, in that this strips
-# the existing suffix (if any) before appending the desired one.
-sub base_suf
-{
-    my ($entry) = $_[0]->{entry};
-    if ($entry !~ m/$_[1]$/)
-    {
-        $entry =~ s/\.[^\.]*$//;
-        $entry .= $_[1];
-    }
-    $entry;
-}
-
-# Return the suffix of the file; everything including and to the
-# right of the last dot.
-sub suffix
-{
-    my @pieces = split (/\./, $_[0]->{entry});
-    my $suffix = pop (@pieces);
-    return ".$suffix";
-}
-
-# Called as a simple function file::addsuffix(name, suffix)
-sub addsuffix
-{
-    my ($name, $suffix) = @_;
-
-    if ($suffix && substr($name, -length($suffix)) ne $suffix)
-    {
-        return $name .= $suffix;
-    }
-    $name;
-}
-
-# Return true if the file is (or will be) accessible.
-# That is, if we can build it, or if it is already present.
-sub accessible
-{
-    (exists $_[0]->{builder}) || ($_[0]->source_exists);
-}
-
-# Return true if the file should be ignored for the purpose
-# of computing dependency information (should not be considered
-# as a dependency and, further, should not be scanned for
-# dependencies).
-sub ignore
-{
-    return 0 if !$param::ignore;
-    return $_[0]->{ignore} if exists $_[0]->{ignore};
-    $_[0]->{ignore} = $_[0]->path =~ /$param::ignore/o;
-}
-
-# Build the file, if necessary.
-sub build
-{
-    return $_[0]->{status} if $_[0]->{status};
-    my ($status) = &file::_build;
-    if ($_[0]->{after_build_func})
-    {
-
-        #print STDERR "DEBUG: after_build_func=$_[0]->{after_build_func}\n";
-        my ($pkgvars) = $_[0]->{conscript}->{pkgvars};
-        NameSpace::restore('script', $pkgvars) if $pkgvars;
-        eval("package script; " . $_[0]->{after_build_func});
-        print "Error running AfterBuild for ${\$_[0]->path}: $@\n" if ($@);
-        NameSpace::remove('script', keys %$pkgvars) if $pkgvars;
-    }
-    return $status;
-}
-
-sub _build
-{
-    my @args = @_;
-
-    if ($param::max_jobs <= 1)
-    {    # pcons
-        my ($self) = @args;
-        print main::DEPFILE $self->path, "\n" if $param::depfile;
-        print((' ' x $level), "Checking ", $self->path, "\n")
-          if $param::depends;
-        if (!exists $self->{builder})
-        {
-
-            # We don't know how to build the file. This is OK, if
-            # the file is present as a source file, under either the
-            # local tree or a Repository.
-            if ($self->source_exists)
-            {
-                return $self->{status} = 'handled';
-            }
-            else
-            {
-                my ($name) = $self->path;
-                print("$0: don't know how to construct \"$name\"\n");
-                exit(1) unless $param::kflag;
-                return $self->{status} = 'errors';    # xxx used to be 'unknown'
-            }
-        }
-
-        # An associated build object exists, so we know how to build
-        # the file. We first compute the signature of the file, based
-        # on its dependendencies, then only rebuild the file if the
-        # signature has changed.
-        my ($builder) = $self->{builder};
-        $level += 2;
-
-        my (@deps) = (@{$self->{dep}}, @{$self->{sources}});
-        my ($rdeps) = \@deps;
-
-        if ($param::random)
-        {
-
-            # If requested, build in a random order, instead of the
-            # order that the dependencies were listed.
-            my (%rdeps);
-            map { $rdeps{$_, '*' x int(rand 10)} = $_ } @deps;
-            $rdeps = [values(%rdeps)];
-        }
-
-        $self->{status} = '';
-
-        my $dep;
-        for $dep (@$rdeps)
-        {
-            if ((build $dep) eq 'errors')
-            {
-
-                # Propagate dependent errors to target.
-                # but try to build all dependents regardless of errors.
-                $self->{status} = 'errors';
-            }
-        }
-
-        # If any dependents had errors, then we abort.
-        if ($self->{status} eq 'errors')
-        {
-            $level -= 2;
-            return 'errors';
-        }
-
-        # Compute the final signature of the file, based on
-        # the static dependencies (in order), dynamic dependencies,
-        # output path name, and (non-substituted) build script.
-        my ($sig) =
-          'sig'->collect(map('sig'->signature($_->rfile), @deps),
-                         $builder->includes($self), $builder->scriptsig);
-
-        # May have gotten errors during computation of dynamic
-        # dependency signature, above.
-        $level -= 2;
-        return 'errors' if $self->{status} eq 'errors';
-
-        if (@param::rpath && $self->derived_exists)
-        {
-
-            # There is no local file of this name, but there is one
-            # under a Repository directory.
-
-            if ('sig'->current($self->rfile, $sig))
-            {
-
-                # The Repository copy is current (its signature matches
-                # our calculated signature).
-                if ($self->local)
-                {
-
-                    # ...but they want a local copy, so provide it.
-                    main::showcom("Local copy of ${\$self->path} from "
-                                  . "${\$self->rpath}");
-                    futil::install($self->rpath, $self);
-                    'sig'->bsig($self, $sig);
-                }
-                return $self->{status} = 'handled';
-            }
-
-            # The signatures don't match, implicitly because something
-            # on which we depend exists locally.  Get rid of the reference
-            # to the Repository file; we'll build this (and anything that
-            # depends on it) locally.
-            $self->no_rfile;
-        }
-
-        # Then check for currency.
-        if (!'sig'->current($self, $sig))
-        {
-
-            # We have to build/derive the file.
-            print((' ' x $level), "Rebuilding ", $self->path,
-                  ": out of date.\n")
-              if $param::depends;
-
-            # First check to see if the built file is cached.
-            if ($builder->cachin($self, $sig))
-            {
-                'sig'->bsig($self, $sig);
-                return $self->{status} = 'built';
-            }
-            elsif ($builder->action($self))
-            {
-                $builder->cachout($self, $sig);
-                'sig'->bsig($self, $sig);
-                return $self->{status} = 'built';
-            }
-            else
-            {
-                die ("$0: errors constructing ${\$self->path}\n")
-                  unless $param::kflag;
-                return $self->{status} = 'errors';
-            }
-        }
-        else
-        {
-
-            # Push this out to the cache if we've been asked to (-C option).
-            # Don't normally do this because it slows us down.
-            # In a fully built system, no accesses to the cache directory
-            # are required to check any files. This is a win if cache is
-            # heavily shared. Enabling this option puts the directory in the
-            # loop. Useful only when you wish to recreate a cache from a build.
-            if ($param::cachesync)
-            {
-                $builder->cachout($self, $sig);
-                'sig'->bsig($self, $sig);
-            }
-            return $self->{status} = 'handled';
-        }
-    }
-    else
-    {    # pcons
-        my ($tgt) = @args;    # pcons
-        local ($file::child_queue) = {parent => $tgt};    # pcons
-        _pbuild($tgt);                                    # pcons
-        wait_on_all_children();                           # pcons
-        return $tgt->{status};                            # pcons
-    }
-}
-
-########################################
-# pcons only BEGIN
-#
-
-sub pbuild
-{
-    $_[0]->{status} || &file::_pbuild;
-}
-
-sub _pbuild
-{
-    my ($self) = @_;
-    $self->{status} = '';    # tgl
-    print main::DEPFILE $self->path, "\n" if param::depfile;
-    print((' ' x $level), $self->path, "\n") if $param::depends;
-    if (!exists $self->{builder})
-    {
-
-        # We don't know how to build the file. This is OK, if
-        # the file is present as a source file, under either the
-        # local tree or a Repository.
-        if ($self->source_exists)
-        {
-            return $self->{status} = 'handled';
-        }
-        else
-        {
-            my ($name) = $self->path;
-            print("$0: don't know how to construct \"$name\"\n");
-            exit(1) unless $param::kflag;
-            return $self->{status} = 'errors';    # xxx used to be 'unknown'
-        }
-    }
-
-    # An associated build object exists, so we know how to build
-    # the file. We first compute the signature of the file, based
-    # on its dependendencies, then only rebuild the file if the
-    # signature has changed.
-    my ($builder) = $self->{'builder'};
-    $level += 2;
-
-    my (@deps) = (@{$self->{dep}}, @{$self->{sources}});
-    my ($rdeps) = \@deps;
-
-    if ($param::random)
-    {
-
-        # If requested, build in a random order, instead of the
-        # order that the dependencies were listed.
-        my (%rdeps);
-
-        # FIX	map { $rdeps{$_,'*' x int(rand(0,10))} = $_ } @deps;
-        map { $rdeps{$_, '*' x int(rand(10))} = $_ } @deps;
-        $rdeps = [values(%rdeps)];
-    }
-
-    $self->{status} = '';
-
-    my $sig;
-    {
-
-        # print "in ", $self->path, "\n";
-        local ($file::child_queue) = {parent => $self};
-        for my $dep (@$rdeps)
-        {
-            if ((pbuild $dep) eq 'errors')
-            {
-
-                # Propagate dependent errors to target.
-                # but try to build all dependents regardless of errors.
-                $self->{status} = 'errors';
-            }
-        }
-        wait_on_all_children();
-
-    }
-
-    # If any dependents had errors, then we abort.
-    if ($self->{'status'} eq 'errors')
-    {
-        $level -= 2;
-        return 'errors';
-    }
-
-    # Compute the final signature of the file, based on
-    # the static dependencies (in order), dynamic dependencies,
-    # output path name, and (non-substituted) build script.
-
-    #    my($sig) = $self->{'sign'} = sig->collect(map(sig->signature($_->rfile), @deps),
-    #			    $builder->includes($self),
-    ## FIX			    $builder->script);
-    #			    $builder->scriptsig);
-
-    my ($sig) = 'sig'->collect(
-        map('sig'->signature($_->rfile), @deps),    # from cons-2.3.0
-        $builder->includes($self),                  # from cons-2.3.0
-        $builder->scriptsig
-        );    # from cons-2.3.0
-    $self->{sign} = $sig;
-
-    # May have gotten errors during computation of dynamic
-    # dependency signature, above.
-    $level -= 2;
-    return 'errors' if $self->{status} eq 'errors';
-
-    if (@param::rpath && $self->derived_exists)
-    {
-
-        # There is no local file of this name, but there is one
-        # under a Repository directory.
-
-        if ('sig'->current($self->rfile, $sig))
-        {
-
-            # The Repository copy is current (its signature matches
-            # our calculated signature).
-            if ($self->local)
-            {
-
-                # ...but they want a local copy, so provide it.
-                main::showcom(
-                         "Local copy of ${\$self->path} from ${\$self->rpath}");
-                futil::install($self->rpath, $self);
-
-                #'sig'->set($self, $sig);
-                'sig'->bsig($self, $sig);    # pcons
-            }
-            return $self->{status} = 'handled';
-        }
-
-        # The signatures don't match, implicitly because something
-        # on which we depend exists locally.  Get rid of the reference
-        # to the Repository file; we'll build this (and anything that
-        # depends on it) locally.
-        $self->no_rfile;
-    }
-
-    # Then check for currency.
-    if (!'sig'->current($self, $sig))
-    {
-
-        # We have to build/derive the file.
-        # First check to see if the built file is cached.
-        if ($builder->cachin($self, $sig))
-        {
-
-            #'sig'->set($self, $sig);
-            'sig'->bsig($self, $sig);    # pcons
-            return $self->{status} = 'built';
-
-            # action no longer blocks (for most actions), so this returns
-            # immediately, before any  commands are actually run.  The
-            # signature and return status should be overridden later in
-            # wait_on_child if a process was forked, but they are still set
-            # here in case a non-spawning action was called
-        }
-        elsif ($builder->action($self))
-        {
-            $builder->cachout($self, $sig);
-
-            #'sig'->set($self, $sig);
-            'sig'->bsig($self, $sig);    # pcons
-            return $self->{status} = 'built';
-        }
-        else
-        {
-            die ("$0: errors constructing ${\$self->path}\n")
-              unless $param::kflag;
-            return $self->{status} = 'errors';
-        }
-    }
-    else
-    {
-
-        # Push this out to the cache if we've been asked to (-C option).
-        # Don't normally do this because it slows us down.
-        # In a fully built system, no accesses to the cache directory
-        # are required to check any files. This is a win if cache is
-        # heavily shared. Enabling this option puts the directory in the
-        # loop. Useful only when you wish to recreate a cache from a build.
-        if ($param::cachesync)
-        {
-            $builder->cachout($self, $sig);
-
-            #'sig'->set($self, $sig);
-            'sig'->bsig($self, $sig);
-        }
-        return $self->{status} = 'handled';
-    }
-}
-
-my @finished;    # pcons //fix -Mstrict
-
-sub wait_on_max_jobs
-{
-    while (grep(/\d+/, keys %{$file::child_queue}) >= $param::max_jobs)
-    {
-        wait_on_child();
-    }
-}
-
-sub wait_on_all_children
-{
-
-    while (grep(/\d+/, keys %{$file::child_queue}) != 0)
-    {
-        wait_on_child();
-    }
-}
-
-sub wait_on_child
-{
-    my ($queue)  = $file::child_queue;
-    my ($parent) = $queue->{parent};
-
-    my $n = grep(/\d+/, keys %{$file::child_queue});
-
-    # printf "Waiting to build (%s): %s\n", $n, $parent->path if ref($parent) eq 'file';
-    my $pid = undef;
-
-    # first check for jobs that have already been collected from child
-    # targets
-    for my $p (@finished)
-    {
-        if ($queue->{$p})
-        {
-            $pid = $p;
-            last;
-        }
-    }
-
-    while (!$queue->{$pid})
-    {
-        $pid = wait();
-        if ($pid < 1)
-        {
-            die "wait returned invalid pid $pid";
-        }
-        else
-        {
-
-            # this job was meant for a parent, save it so that it can be
-            # found later
-            if (!$queue->{$pid})
-            {
-                push @finished, $pid;
-            }
-        }
-    }
-
-    my $child = $queue->{$pid};
-    my $tgt   = $queue->{$pid}->{'tgt'};
-    my $com   = $child->{'com'};
-    $tgt->{status} = 'built';
-
-    #print "waited: ", $tgt->path; 
-    #print "on: ",  keys %{$queue}, "\n";
-
-    my ($b0, $b1) = ($? & 0xFF, $? >> 8);
-
-    # Don't actually see 0177 on stopped process; is this necessary?
-    # next if $b0 == 0177; # process stopped; we can wait.
-    if ($b0)
-    {
-        my ($core, $sig) = ($b0 & 0200, $b0 & 0177);
-        my ($coremsg) = $core ? "; core dumped" : "";
-        $com =~ s/\s.*//;
-        my ($path) = $tgt->path;
-        warn qq($0: *** [$path] $com terminated by signal $sig$coremsg\n);
-        $parent->{status} = $tgt->{status} = 'errors';
-    }
-    if ($b1)
-    {
-        my ($path) = $tgt->path;
-        warn qq($0: *** [$path] Error $b1\n);    # trying to be like make.
-        $parent->{status} = $tgt->{status} = 'errors';
-    }
-    if ($tgt->{status} eq 'built')
-    {
-        $tgt->{builder}->cachout($tgt, $tgt->{sign});
-
-        #'sig'->set($tgt, $tgt->{sign});
-        'sig'->bsig($tgt, $tgt->{sign});
-    }
-    else
-    {
-        die ("$0: errors constructing ${\$tgt->path}\n") unless $param::kflag;
-    }
-    delete $queue->{$pid};
-
-}
-
-#
-# pcons END
-########################################
-
-# Bind an action to a file, with the specified sources. No return value.
-sub bind
-{
-    my ($self, $builder, @sources) = @_;
-    if ($self->{builder} && !$self->{builder}->compatible($builder))
-    {
-
-        # Even if not "compatible", we can still check to see if the
-        # derivation is identical. It should be identical if the builder is
-        # the same and the sources are the same.
-        if ("$self->{builder} @{$self->{sources}}" ne "$builder @sources")
-        {
-            $main::errors++;
-            my ($_foo1, $script1, $line1, $sub1) = @{$self->creator};
-            my ($_foo2, $script2, $line2, $sub2) = script::caller_info;
-            my $err =
-              "\t${\$self->path}\n"
-              . "\tbuilt (at least) two different ways:\n"
-              . "\t\t$script1, line $line1:  $sub1\n"
-              . "\t\t$script2, line $line2:  $sub2\n";
-            die $err;
-        }
-        return;
-    }
-    if ($param::wflag)
-    {
-        my ($script, $line, $sub);
-        (undef, $script, $line, $sub) = script::caller_info;
-        $self->{script} = '' if !defined $self->{script};
-        $self->{script} .= "; " if $self->{script};
-        $self->{script} .= qq($sub in "$script", line $line);
-    }
-    $self->{builder} = $builder;
-    push (@{$self->{sources}}, @sources);
-    @{$self->{dep}} = () if !defined $self->{dep};
-    $self->{conscript} = $priv::self->{script};
-}
-
-sub is_under
-{
-    $_[0]->{dir}->is_under($_[1]);
-}
-
-sub relpath
-{
-    my $dirpath = $_[0]->relpath($_[1]->{dir});
-    if (!$dirpath)
-    {
-        return $_[1]->{entry};
-    }
-    else
-    {
-        File::Spec->catfile($dirpath, $_[1]->{entry});
-    }
-}
-
-# Return the signature array for this file.
-# This probably belongs in its own "sigarray" package,
-# which would make it easier to optimize performance.
-sub sigarray
-{
-    if ($_[0]->{sigaref})
-    {
-        return @{$_[0]->{sigaref}};
-    }
-    my $self = shift;
-
-    # glob2pat based on The Perl Cookbook, p. 180.
-    sub glob2pat
-    {
-        my $globstr = shift;
-        my %patmap = (
-                     '*' => '.*',
-                     '?' => '.',
-                     '[' => '[',
-                     ']' => ']',
-                     '/' => "\Q$dir::SEPARATOR",    # Cons-specific modification
-                     );
-        $globstr =~ s{(.)} { $patmap{$1} || "\Q$1" }ge;
-        return '^' . $globstr . '$';
-    }
-    my @sigarray;
-    my $default;
-    my $builder = $self->lfile->{builder};
-    if (!$builder)
-    {
-        @sigarray = @$param::sourcesig;
-        $default  = [qw(content)];
-    }
-    else
-    {
-        if ($builder->{env} && $builder->{env}->{SIGNATURE})
-        {
-            @sigarray = @{$builder->{env}->{SIGNATURE}};
-        }
-        else
-        {
-            my $class = ref $builder;
-            my $path  = $self->path;
-            warn qq($0: Warning:  Builder package $class did not record\n)
-              . qq(\tthe calling environment for '$path'.\n)
-              . qq(\tUnable to use any %SIGNATURE construction variable\n)
-              . qq(\tfor signature configuration.\n);
-        }
-        $default = [qw(build)];
-    }
-    my $path = $self->path;
-    while (@sigarray)
-    {
-        my ($glob, $aref) = splice(@sigarray, 0, 2);
-        my $re = glob2pat($glob);
-        if ($path =~ /$re/)
-        {
-            $aref = [split (/\s+/, $aref)] if !ref $aref;
-            $self->{sigaref} = $aref;
-            return @$aref;
-        }
-    }
-    $self->{sigaref} = $default;
-    return @{$self->{sigaref}};
-}
-
-# Decide if this file's signature should be the content or build signature.
-sub sigtype
-{
-    if ($_[0]->{sigtype})
-    {
-        return $_[0]->{sigtype};
-    }
-    my $self     = shift;
-    my @sigarray = $self->sigarray;
-    my $sigtype;
-    if (grep($_ eq "build", @sigarray))
-    {
-        $sigtype = 'bsig';
-    }
-    elsif (grep($_ =~ /content$/, @sigarray))
-    {
-        $sigtype = 'csig';
-    }
-    return $self->{sigtype} = $sigtype;
-}
-
-# Return whether this file is configured to use stored
-# signature values from the .consign file.
-sub stored
-{
-    if (!defined $_[0]->{stored})
-    {
-        $_[0]->{stored} = grep($_ eq "stored-content", $_[0]->sigarray);
-    }
-    return $_[0]->{stored};
-}
-
-# Generic entry (file or directory) handling.
-# This is an empty subclass for nodes that haven't
-# quite decided whether they're files or dirs.
-# Use file methods until someone blesses them one way or the other.
-package entry;
-
-use vars qw( @ISA );
-
-BEGIN { @ISA = qw(file) }
-
-# File utilities
-package futil;
-
-# Install one file as another.
-# Links them if possible (hard link), otherwise copies.
-# Don't ask why, but the source is a path, the tgt is a file obj.
-sub install
-{
-    my ($sp, $tgt) = @_;
-    my ($tp) = $tgt->path;
-    return 1 if $tp eq $sp;
-    return 1 if eval { link($sp, $tp) };
-    unlink($tp);
-    if (!futil::mkdir($tgt->{dir}))
-    {
-        return undef;
-    }
-    return 1 if eval { link($sp, $tp) };
-    futil::copy($sp, $tp);
-}
-
-# Copy one file to another. Arguments are actual file names.
-# Returns undef on failure. Preserves mtime and mode.
-sub copy
-{
-    my ($sp, $tp) = @_;
-    my ($mode, $length, $atime, $mtime) = (stat($sp))[2, 7, 8, 9];
-
-    # Use Perl standard library module for file copying, which handles
-    # binary copies. <schwarze@isa.de> 1998-06-18
-    if (!File::Copy::copy($sp, $tp))
-    {
-        warn qq($0: can\'t install "$sp" to "$tp" ($!)\n);    #'
-        return undef;
-    }
-
-    # The file has been created, so try both the chmod and utime,
-    # first making sure the copy is writable (because permissions
-    # affect the ability to modify file times on some operating
-    # systems), and then changing permissions back if necessary.
-    my $ret   = 1;
-    my $wmode = $mode | 0700;
-    if (!chmod $wmode, $tp)
-    {
-        warn qq($0: can\'t set mode $wmode on file "$tp" ($!)\n);    #'
-        $ret = undef;
-    }
-    if (!utime $atime, $mtime, $tp)
-    {
-        warn qq($0: can\'t set modification time for file "$tp" ($!)\n);    #'
-        $ret = undef;
-    }
-    if ($mode != $wmode && !chmod $mode, $tp)
-    {
-        warn qq($0: can\'t set mode $mode on file "$tp" ($!)\n);    #'
-        $ret = undef;
-    }
-    return $ret;
-}
-
-# Ensure that the specified directory exists.
-# Aborts on failure.
-sub mkdir
-{
-    return 1 if $_[0]->{'exists'};
-    if (!futil::mkdir($_[0]->{dir}))
-    {    # Recursively make parent.
-        return undef;
-    }
-    my ($path) = $_[0]->path;
-    if (!-d $path && !mkdir($path, 0777))
-    {
-        warn qq($0: can't create directory $path ($!).\n);    #'
-        return undef;
-    }
-    $_[0]->{'exists'} = 1;
-}
-
-# Signature package.
-package sig::hash;
-
-use vars qw( $called );
-
-sub init
-{
-    my ($dir)     = @_;
-    my ($consign) = $dir->prefix . ".consign";
-    my ($dhash)   = $dir->{consign} = {};
-    if (-f $consign)
-    {
-        open(CONSIGN, $consign) || die ("$0: can't open $consign ($!)\n");
-        while (<CONSIGN>)
-        {
-            chop;
-            my ($file, $sig) = split (/:/, $_);
-            $dhash->{$file} = $sig;
-        }
-        close(CONSIGN);
-    }
-    $dhash;
-}
-
-# Read the hash entry for a particular file.
-sub in
-{
-    my ($dir) = $_[0]->{dir};
-    ($dir->{consign} || init($dir))->{$_[0]->{entry}};
-}
-
-# Write the hash entry for a particular file.
-sub out
-{
-    my ($file, $sig) = @_;
-    my ($dir) = $file->{dir};
-    ($dir->{consign} || init($dir))->{$file->{entry}} = $sig;
-    $sig::hash::dirty{$dir} = $dir;
-}
-
-# Eliminate the hash entry for a particular file.
-sub clear
-{
-    my ($file) = @_;
-    my ($dir)  = $file->{dir};
-    delete $dir->{consign}->{$file->{entry}} if $dir->{consign};
-    $sig::hash::dirty{$dir} = $dir;
-}
-
-# Flush hash entries. Called at end or via ^C interrupt.
-sub END
-{
-    return if $called++;    # May be called twice.
-    close(CONSIGN);         # in case this came in via ^C.
-    my $dir;
-    for $dir (values %sig::hash::dirty)
-    {
-        my ($consign)  = $dir->prefix . ".consign";
-        my ($constemp) = $consign . ".$$";
-        if (!open(CONSIGN, ">$constemp"))
-        {
-            die ("$0: can't create $constemp ($!)\n");
-        }
-        my ($entry, $sig);
-        while (($entry, $sig) = each %{$dir->{consign}})
-        {
-            if (!print CONSIGN "$entry:$sig\n")
-            {
-                die ("$0: error writing to $constemp ($!)\n");
-            }
-        }
-        close(CONSIGN);
-        if (!rename($constemp, $consign))
-        {
-            if (futil::copy($constemp, $consign))
-            {
-                unlink($constemp);
-            }
-            else
-            {
-                die ("$0: couldn't rename or copy $constemp to $consign "
-                     . "($!)\n");
-            }
-        }
-    }
-}
-
-# Derived file caching.
-package cache;
-
-# Find a file in the cache. Return non-null if the file is in the cache.
-sub in
-{
-    return undef unless $param::cache;
-    my ($file, $sig) = @_;
-
-    # Add the path to the signature, to make it unique.
-    $sig = 'sig'->collect($sig, $file->path) unless $param::mixtargets;
-    my ($dir) = substr($sig, 0, 1);
-    my ($cp) = File::Spec->catfile($param::cache, $dir, $sig);
-    return -f $cp && futil::install($cp, $file);
-}
-
-# Try to flush a file to the cache, if not already there.
-# If it doesn't make it out, due to an error, then that doesn't
-# really matter.
-sub out
-{
-    return unless $param::cache;
-    my ($file, $sig) = @_;
-
-    # Add the path to the signature, to make it unique.
-    $sig = 'sig'->collect($sig, $file->path) unless $param::mixtargets;
-    my ($dir) = substr($sig, 0, 1);
-    my ($sp) = $file->path;
-    my ($cp) = File::Spec->catfile($param::cache, $dir, $sig);
-    my ($cdir) = File::Spec->catfile($param::cache, $dir);
-    if (!-d $cdir)
-    {
-        mkdir($cdir, 0777)
-          || die ("$0: can't create cache directory $cdir ($!).\n");
-    }
-    elsif (-f $cp)
-    {
-
-        # Already cached: try to use that instead, to save space.
-        # This can happen if the -cs option is used on a previously
-        # uncached build, or if two builds occur simultaneously.
-        my ($lp) = ".$sig";
-        unlink($lp);
-        return if !eval { link($cp, $lp) };
-        rename($lp, $sp);
-
-        # Unix98 says, "If the old argument and the new argument both
-        # [refer] to the same existing file, the rename() function
-        # returns successfully and performs no other action."  So, if
-        # $lp and $sp are links (i.e., $cp and $sp are links), $lp is
-        # left, and we must unlink it ourselves.  If the rename failed
-        # for any reason, it is also good form to unlink the temporary
-        # $lp.  Otherwise $lp no longer exists and, barring some race,
-        # the unlink fails silently.
-        unlink($lp);
-        return;
-    }
-
-    return if eval { link($sp, $cp) };
-    return if !-f $sp;    # if nothing to cache.
-    if (futil::copy($sp, "$cp.new"))
-    {
-        rename("$cp.new", $cp);
-    }
-}
-
-# Generic signature handling package.
-# This handles the higher-layer distinction between content and build
-# signatures, relying on an underlying calculation package like
-# "sig::md5"" to provide the signature values themselves.
-package sig;
-
-use vars qw( @ISA );
-
-# Select the underlying package to be used for signature calculation.
-# We play a few namespace games here.  Specifically, we append
-# "sig::" to the beginning of the subclass we're passed.  Then,
-# if the package ends in "::debug", we actually subclass the
-# "sig::debug" package and as a wrapper around the underlying
-# (e.g.) "sig::md5" package that's doing the real calculation.
-sub select
-{
-    my ($package, $subclass) = @_;
-    my $p      = $package . "::" . $subclass;
-    my $sigpkg = $p;
-    if ($p =~ /(.*)::debug$/)
-    {
-        $sigpkg = $1;
-        $p      = 'sig::debug';
-    }
-    @ISA = ($p);
-    $p->init($sigpkg);
-};
-
-# Set or return the build signature of a file.
-# This is computed elsewhere and passed in to us.
-sub bsig
-{
-    my ($self, $file, $sig) = @_;
-    if (defined $sig)
-    {
-        $file->{'bsig'} = $sig;
-        $self->set($file);
-    }
-    elsif (!defined $file->{'bsig'})
-    {
-        $file->{'bsig'} = '';
-    }
-    $file->{'bsig'};
-}
-
-# Determine the content signature of a file.
-# This also sets the .consign entry unless the file is in a
-# repository; we don't write into repositories, only read from them.
-sub csig
-{
-    my ($self, $file) = @_;
-    if (!$file->{'csig'})
-    {
-        $file->{'csig'} = $self->srcsig($file->path);
-        $self->set($file) if !$file->is_on_rpath;
-    }
-    $_[1]->{'csig'};
-}
-
-# Determine the current signature of an already-existing or
-# non-existant file.  Unless a specific signature type (bsig
-# or csig) is requested, this consults the file's signature
-# array to decide whether to return content or build signature,
-# and whether to use a cached value from a .consign file.
-sub signature
-{
-    my ($self, $file, $sigtype) = @_;
-    $sigtype = $file->sigtype if !$sigtype;
-
-    #open(TTY, ">/dev/tty");
-    #print TTY $file->path, ": $sigtype\n";
-    #close(TTY);
-    my ($path) = $file->path;
-    my ($time) = (stat($path))[9];
-    if ($time)
-    {
-        if ($file->{$sigtype})
-        {
-            return $file->{$sigtype};
-        }
-        if ($file->is_on_rpath || $file->stored)
-        {
-            if ('sig'->fetch($file) && $file->{$sigtype})
-            {
-                if ($file->{'sigtime'} == $time
-                    || !$param::rep_sig_times_ok && $file->is_on_rpath)
-                {
-                    return $file->{$sigtype};
-                }
-            }
-            $file->{$sigtype} = undef;
-        }
-        if ($file->is_on_rpath || !File::Spec->file_name_is_absolute($path))
-        {
-            my $sig = '';
-            if    ($sigtype eq 'bsig') { $sig = $self->bsig($file); }
-            elsif ($sigtype eq 'csig') { $sig = $self->csig($file); }
-            return $sig;
-        }
-
-        # This file is not in a repository or under the local directory
-        # structure.  In the canonical case, it's a utility that will be
-        # executed by a command.  Historically, Cons has returned the
-        # name of the command concatenated with the modification time.
-        # Note that this is *not* the path ("cc" not "/bin/cc"), so it
-        # would lose in the unlikely event that a different copy of the
-        # utility was used that happened to have the same modification
-        # time (due to living in a different directory on the PATH, for
-        # example).  The obvious "fix" of using the path like so, however:
-        #	return $path . $time;
-        # is wrong.  In a multi-machine build environment, different
-        # systems may have the same utility in different locations (due
-        # to different NFS mount points, for example), which would
-        # cause a lot of unnecessary builds if we used the full path.
-        # A better solution to strengthen this signature would be to
-        # also concatenate the size of the file, but that would cause
-        # unnecessary rebuilds when coming from .consign files that used
-        # the old scheme.  All of which is to merely explain why we're
-        # leaving this as it has been, but documenting it here in case
-        # there's reason to change it in the future.
-        return $file->{entry} . $time;
-    }
-    return $file->{$sigtype} = '';
-}
-
-sub bsignature
-{
-    my ($self, $file) = @_;
-    my ($path) = $file->path;
-    my ($time) = (stat($path))[9];
-    if ($time)
-    {
-        if ($file->{'bsig'})
-        {
-            return $file->{'bsig'};
-        }
-        if ('sig'->fetch($file, 'bsig') && $file->{'bsig'})
-        {
-            if ($file->{'sigtime'} == $time
-                || !$param::rep_sig_times_ok && $file->is_on_rpath)
-            {
-                return $file->{'bsig'};
-            }
-        }
-        if ($file->is_on_rpath || !File::Spec->file_name_is_absolute($path))
-        {
-            return $self->bsig($file);
-        }
-        return $path . $time;
-    }
-    return $file->{'bsig'} = '';
-}
-
-# Invalidate a file's signature, also clearing its .consign entry.
-sub invalidate
-{
-    my ($self, $file) = @_;
-    delete $file->{'sigtime'};
-    delete $file->{'bsig'};
-    delete $file->{'csig'};
-    sig::hash::clear($file);
-}
-
-# Store the signature for a file.
-sub set
-{
-    my ($self, $file) = @_;
-    my $sig = (stat($file->path))[9];
-    $sig .= " " . ($file->{'bsig'} || '-');
-    $sig .= " " . $file->{'csig'} if $file->{'csig'};
-    sig::hash::out($file, $sig);
-}
-
-# Fetch the signature(s) for a file.
-# Returns whether there was a signature to fetch.
-sub fetch
-{
-    my ($self, $file, @kw) = @_;
-    @kw = ('bsig', 'csig') if !@kw;
-    my $sig = sig::hash::in($file) || '';
-    my ($sigtime, $bsig, $csig) = split (/ /, $sig);
-    $file->{'sigtime'} = $sigtime;
-    $file->{'bsig'}    = $bsig || '' if grep($_ eq 'bsig', @kw);
-    $file->{'csig'}    = $csig || '' if grep($_ eq 'csig', @kw);
-    $file->{'bsig'} = '' if $file->{'bsig'} eq '-';
-    return $sig ne '';
-}
-
-# MD5-based signature package.
-package sig::md5;
-
-use vars qw( $md5 );
-
-# Initialize MD5 signature calculation by finding an appropriate
-# module and creating the proper object.
-sub init
-{
-    my $self        = shift;
-    my @md5_modules = qw(Digest::MD5 MD5 Digest::Perl::MD5);
-
-    # We used to find the right module more simply, using $_ as the
-    # loop iterator and just doing:
-    #
-    #		eval "use $_";
-    #		$module = $_, $last if ! $@;
-    #
-    # in the loop.  Empirically, though, this doesn't pass back the
-    # right value in $module on some ActiveState versions.  (Maybe
-    # it's something to do with the eval in a for loop, I dunno.)
-    # Work around it by using $_ to pass the value out of the loop,
-    # which seems to work everywhere.
-    my $module;
-    for $module (@md5_modules)
-    {
-        eval "use $module";
-        $_ = $module, last if !$@;
-    }
-    $module = $_;
-    die "Cannot find any MD5 module from:  @md5_modules" if $@;
-
-    $md5 = new $module;
-}
-
-# Is the provided signature equal to the signature of the current
-# instantiation of the target (and does the target exist)?
-sub current
-{
-    my ($self, $file, $sig, $sigtype) = @_;
-    $self->bsignature($file) eq $sig;
-}
-
-# Return an aggregate signature for a list of signature values.
-sub collect
-{
-    my ($self, @sigs) = @_;
-
-    # The following sequence is faster than calling the hex interface.
-    $md5->reset();
-    $md5->add(join ('', $param::salt, @sigs));
-    unpack("H*", $md5->digest());
-}
-
-# Directly compute a file signature as the MD5 checksum of the
-# bytes in the file.
-sub srcsig
-{
-    my ($self, $path) = @_;
-    $md5->reset();
-    open(FILE, $path) || return '';
-    binmode(FILE);
-    $md5->addfile(\*FILE);
-    close(FILE);
-    unpack("H*", $md5->digest());
-}
-
-# Compute the signature of a command string.
-# For MD5, this is just the string itself, since MD5 will condense
-# the string contents into the ultimate signature.  Other signature
-# schemes may need to figure this out differently.
-sub cmdsig
-{
-    my ($self, $sig) = @_;
-    return $sig;
-}
-
-# Generic debug package for signature calculation.
-# Because of the way we're called by sig::select() and then use
-# the specified value to set up @ISA, this package is essentially a
-# factory that creates packages like sig::md5::debug, etc., on the fly.
-package sig::debug;
-
-use vars qw( @ISA $sigpkg $outfh );
-
-local *FH;
-
-sub init
-{
-    my $self = shift;
-    $sigpkg = shift;
-    @ISA    = ($sigpkg);
-    $sigpkg->init();
-    my $file = $ENV{CONS_SIG_DEBUG};
-    if ($file)
-    {
-        if (!open(FH, ">$file"))
-        {
-            die "Cannot open $file: $!";
-        }
-        $outfh = \*FH;
-    }
-    else
-    {
-        $outfh = \*STDOUT;
-    }
-}
-
-sub current
-{
-    my ($self, $file, $sig, $sigtype) = @_;
-    my $fsig = $self->bsignature($file);
-    my $sub  = "${sigpkg}::current";
-    my $sep  = "\n" . ' ' x (length($sub) + 1 - 3);
-    print $outfh "$sub(|$fsig|${sep}eq |$sig|)\n";
-    return $fsig eq $sig;
-}
-
-sub collect
-{
-    my ($self, @sigs) = @_;
-    my $sig = $sigpkg->collect(@sigs);
-    my $sub = "${sigpkg}::collect";
-    my $sep = ",\n" . ' ' x (length($sub) + 1);
-    my $buf = join ($sep, @sigs);
-    $buf = $param::salt . $sep . $buf if $param::salt;
-    print $outfh "$sub($buf)\n\t=> |$sig|\n";
-    return $sig;
-}
-
-sub srcsig
-{
-    my ($self, $path) = @_;
-    my $sig = $sigpkg->srcsig($path);
-    print $outfh "${sigpkg}::srcsig($path)\n\t=> |$sig|\n";
-    return $sig;
-}
-
-__END__;
-
-=head1 NAME
-
-Cons - A Software Construction System
-
-=head1 DESCRIPTION
-
-A guide and reference for version __VERSION____REVISION__
-
-Copyright (c) 1996-2001 Free Software Foundation, Inc.
-
-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 of the License, 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.
-
-=head1 Introduction
-
-B<Cons> is a system for constructing, primarily, software, but is quite
-different from previous software construction systems. Cons was designed
-from the ground up to deal easily with the construction of software spread
-over multiple source directories. Cons makes it easy to create build scripts
-that are simple, understandable and maintainable. Cons ensures that complex
-software is easily and accurately reproducible.
-
-Cons uses a number of techniques to accomplish all of this. Construction
-scripts are just Perl scripts, making them both easy to comprehend and very
-flexible. Global scoping of variables is replaced with an import/export
-mechanism for sharing information between scripts, significantly improving
-the readability and maintainability of each script. B<Construction
-environments> are introduced: these are Perl objects that capture the
-information required for controlling the build process. Multiple
-environments are used when different semantics are required for generating
-products in the build tree. Cons implements automatic dependency analysis
-and uses this to globally sequence the entire build. Variant builds are
-easily produced from a single source tree. Intelligent build subsetting is
-possible, when working on localized changes. Overrides can be setup to
-easily override build instructions without modifying any scripts. MD5
-cryptographic B<signatures> are associated with derived files, and are used
-to accurately determine whether a given file needs to be rebuilt.
-
-While offering all of the above, and more, Cons remains simple and easy to
-use. This will, hopefully, become clear as you read the remainder of this
-document.
-
-
-=head1 Why Cons? Why not Make?
-
-Cons is a B<make> replacement. In the following paragraphs, we look at a few
-of the undesirable characteristics of make--and typical build environments
-based on make--that motivated the development of Cons.
-
-=head2 Build complexity
-
-Traditional make-based systems of any size tend to become quite complex. The
-original make utility and its derivatives have contributed to this tendency
-in a number of ways. Make is not good at dealing with systems that are
-spread over multiple directories. Various work-arounds are used to overcome
-this difficulty; the usual choice is for make to invoke itself recursively
-for each sub-directory of a build. This leads to complicated code, in which
-it is often unclear how a variable is set, or what effect the setting of a
-variable will have on the build as a whole. The make scripting language has
-gradually been extended to provide more possibilities, but these have
-largely served to clutter an already overextended language. Often, builds
-are done in multiple passes in order to provide appropriate products from
-one directory to another directory. This represents a further increase in
-build complexity.
-
-
-=head2 Build reproducibility
-
-The bane of all makes has always been the correct handling of
-dependencies. Most often, an attempt is made to do a reasonable job of
-dependencies within a single directory, but no serious attempt is made to do
-the job between directories. Even when dependencies are working correctly,
-make's reliance on a simple time stamp comparison to determine whether a
-file is out of date with respect to its dependents is not, in general,
-adequate for determining when a file should be rederived. If an external
-library, for example, is rebuilt and then ``snapped'' into place, the
-timestamps on its newly created files may well be earlier than the last
-local build, since it was built before it became visible.
-
-
-=head2 Variant builds
-
-Make provides only limited facilities for handling variant builds. With the
-proliferation of hardware platforms and the need for debuggable
-vs. optimized code, the ability to easily create these variants is
-essential. More importantly, if variants are created, it is important to
-either be able to separate the variants or to be able to reproduce the
-original or variant at will. With make it is very difficult to separate the
-builds into multiple build directories, separate from the source. And if
-this technique isn't used, it's also virtually impossible to guarantee at
-any given time which variant is present in the tree, without resorting to a
-complete rebuild.
-
-
-=head2 Repositories
-
-Make provides only limited support for building software from code that
-exists in a central repository directory structure.  The VPATH feature of
-GNU make (and some other make implementations) is intended to provide this,
-but doesn't work as expected: it changes the path of target file to the
-VPATH name too early in its analysis, and therefore searches for all
-dependencies in the VPATH directory.  To ensure correct development builds,
-it is important to be able to create a file in a local build directory and
-have any files in a code repository (a VPATH directory, in make terms) that
-depend on the local file get rebuilt properly.  This isn't possible with
-VPATH, without coding a lot of complex repository knowledge directly into
-the makefiles.
-
-
-=head1 Keeping it simple
-
-A few of the difficulties with make have been cited above. In this and
-subsequent sections, we shall introduce Cons and show how these issues are
-addressed.
-
-=head2 Perl scripts
-
-Cons is Perl-based. That is, Cons scripts--F<Conscript> and F<Construct>
-files, the equivalent to F<Makefile> or F<makefile>--are all written in
-Perl. This provides an immediate benefit: the language for writing scripts
-is a familiar one. Even if you don't happen to be a Perl programmer, it
-helps to know that Perl is basically just a simple declarative language,
-with a well-defined flow of control, and familiar semantics. It has
-variables that behave basically the way you would expect them to,
-subroutines, flow of control, and so on. There is no special syntax
-introduced for Cons. The use of Perl as a scripting language simplifies
-the task of expressing the appropriate solution to the often complex
-requirements of a build.
-
-
-=head2 Hello, World!
-
-To ground the following discussion, here's how you could build the B<Hello,
-World!> C application with Cons:
-
-
-
-  $env = new cons();
-  Program $env 'hello', 'hello.c';
-
-If you install this script in a directory, naming the script F<Construct>,
-and create the F<hello.c> source file in the same directory, then you can
-type C<cons hello> to build the application:
-
-
-
-  % cons hello
-  cc -c hello.c -o hello.o
-  cc -o hello hello.o
-
-
-=head2 Construction environments
-
-A key simplification of Cons is the idea of a B<construction environment>. A
-construction environment is an B<object> characterized by a set of key/value
-pairs and a set of B<methods>. In order to tell Cons how to build something,
-you invoke the appropriate method via an appropriate construction
-environment. Consider the following example:
-
-
-
-  $env = new cons(
-	CC	=>	'gcc',
-	LIBS	=>	'libworld.a'
-  );
-
-  Program $env 'hello', 'hello.c';
-
-In this case, rather than using the default construction environment, as is,
-we have overridden the value of C<CC> so that the GNU C Compiler equivalent
-is used, instead. Since this version of B<Hello, World!> requires a library,
-F<libworld.a>, we have specified that any program linked in this environment
-should be linked with that library. If the library exists already, well and
-good, but if not, then we'll also have to include the statement:
-
-
-
-  Library $env 'libworld', 'world.c';
-
-Now if you type C<cons hello>, the library will be built before the program
-is linked, and, of course, C<gcc> will be used to compile both modules:
-
-
-
-  % cons hello
-  gcc -c hello.c -o hello.o
-  gcc -c world.c -o world.o
-  ar r libworld.a world.o
-  ar: creating libworld.a
-  ranlib libworld.a
-  gcc -o hello hello.o libworld.a
-
-
-=head2 Automatic and complete dependency analysis
-
-With Cons, dependencies are handled automatically. Continuing the previous
-example, note that when we modify F<world.c>, F<world.o> is recompiled,
-F<libworld.a> recreated, and F<hello> relinked:
-
-
-
-  % vi world.c
-    [EDIT]
-  % cons hello
-  gcc -c world.c -o world.o
-  ar r libworld.a world.o
-  ar: creating libworld.a
-  ranlib libworld.a
-  gcc -o hello hello.o libworld.a
-
-This is a relatively simple example: Cons ``knows'' F<world.o> depends upon
-F<world.c>, because the dependency is explicitly set up by the C<Library>
-method. It also knows that F<libworld.a> depends upon F<world.o> and that
-F<hello> depends upon F<libworld.a>, all for similar reasons.
-
-Now it turns out that F<hello.c> also includes the interface definition
-file, F<world.h>:
-
-
-
-  % emacs world.h
-    [EDIT]
-  % cons hello
-  gcc -c hello.c -o hello.o
-  gcc -o hello hello.o libworld.a
-
-How does Cons know that F<hello.c> includes F<world.h>, and that F<hello.o>
-must therefore be recompiled? For now, suffice it to say that when
-considering whether or not F<hello.o> is up-to-date, Cons invokes a scanner
-for its dependency, F<hello.c>. This scanner enumerates the files included
-by F<hello.c> to come up with a list of further dependencies, beyond those
-made explicit by the Cons script. This process is recursive: any files
-included by included files will also be scanned.
-
-Isn't this expensive? The answer is--it depends. If you do a full build of a
-large system, the scanning time is insignificant. If you do a rebuild of a
-large system, then Cons will spend a fair amount of time thinking about it
-before it decides that nothing has to be done (although not necessarily more
-time than make!). The good news is that Cons makes it very easy to
-intelligently subset your build, when you are working on localized changes.
-
-
-=head2 Automatic global build sequencing
-
-Because Cons does full and accurate dependency analysis, and does this
-globally, for the entire build, Cons is able to use this information to take
-full control of the B<sequencing> of the build. This sequencing is evident
-in the above examples, and is equivalent to what you would expect for make,
-given a full set of dependencies. With Cons, this extends trivially to
-larger, multi-directory builds. As a result, all of the complexity involved
-in making sure that a build is organized correctly--including multi-pass
-hierarchical builds--is eliminated. We'll discuss this further in the next
-sections.
-
-=head1 Building large trees--still just as simple
-
-
-=head2 A hierarchy of build scripts
-
-A larger build, in Cons, is organized by creating a hierarchy of B<build
-scripts>. At the top of the tree is a script called F<Construct>. The rest
-of the scripts, by convention, are each called F<Conscript>. These scripts
-are connected together, very simply, by the C<Build>, C<Export>, and
-C<Import> commands.
-
-
-=head2 The Build command
-
-The C<Build> command takes a list of F<Conscript> file names, and arranges
-for them to be included in the build. For example:
-
-  Build qw(
-	drivers/display/Conscript
-	drivers/mouse/Conscript
-	parser/Conscript
-	utilities/Conscript
-  );
-
-This is a simple two-level hierarchy of build scripts: all the subsidiary
-F<Conscript> files are mentioned in the top-level F<Construct> file. Notice
-that not all directories in the tree necessarily have build scripts
-associated with them.
-
-This could also be written as a multi-level script. For example, the
-F<Construct> file might contain this command:
-
-  Build qw(
-	parser/Conscript
-	drivers/Conscript
-	utilities/Conscript
-  );
-
-and the F<Conscript> file in the F<drivers> directory might contain this:
-
-  Build qw(
-	display/Conscript
-	mouse/Conscript
-  );
-
-Experience has shown that the former model is a little easier to understand,
-since the whole construction tree is laid out in front of you, at the
-top-level. Hybrid schemes are also possible. A separately maintained
-component that needs to be incorporated into a build tree, for example,
-might hook into the build tree in one place, but define its own construction
-hierarchy.
-
-By default, Cons does not change its working directory to the directory
-containing a subsidiary F<Conscript> file it is including.  This behavior
-can be enabled for a build by specifying, in the top-level F<Construct>
-file:
-
-  Conscript_chdir 1;
-
-When enabled, Cons will change to the subsidiary F<Conscript> file's
-containing directory while reading in that file, and then change back
-to the top-level directory once the file has been processed.
-
-It is expected that this behavior will become the default in some future
-version of Cons.  To prepare for this transition, builds that expect
-Cons to remain at the top of the build while it reads in a subsidiary
-F<Conscript> file should explicitly disable this feature as follows:
-
-  Conscript_chdir 0;
-
-
-=head2 Relative, top-relative, and absolute file names
-
-You may have noticed that the file names specified to the Build command are
-relative to the location of the script it is invoked from. This is generally
-true for other filename arguments to other commands, too, although we might
-as well mention here that if you begin a file name with a hash mark, ``#'',
-then that file is interpreted relative to the top-level directory (where the
-F<Construct> file resides). And, not surprisingly, if you begin it with ``/'',
-then it is considered to be an absolute pathname. This is true even on
-systems which use a back slash rather than a forward slash to name absolute
-paths.
-
-(There is another file prefix, ``!'', that is interpreted specially by
-Cons.  See discussion of the C<Link> command, below, for details.)
-
-
-=head2 Using modules in build scripts
-
-You may pull modules into each F<Conscript> file using the normal Perl
-C<use> or C<require> statements:
-
-  use English;
-  require My::Module;
-
-Each C<use> or C<require> only affects the one F<Conscript> file in which
-it appears.  To use a module in multiple F<Conscript> files, you must
-put a C<use> or C<require> statement in each one that needs the module.
-
-
-=head2 Scope of variables
-
-The top-level F<Construct> file and all F<Conscript> files begin life in
-a common, separate Perl package.  B<Cons> controls the symbol table for
-the package so that, the symbol table for each script is empty, except
-for the F<Construct> file, which gets some of the command line arguments.
-All of the variables that are set or used, therefore, are set by the
-script itself--not by some external script.
-
-Variables can be explicitly B<imported> by a script from its parent
-script. To import a variable, it must have been B<exported> by the parent
-and initialized (otherwise an error will occur).
-
-
-=head2 The Export command
-
-The C<Export> command is used as in the following example:
-
-  $env = new cons();
-  $INCLUDE = "#export/include";
-  $LIB = "#export/lib";
-  Export qw( env INCLUDE LIB );
-  Build qw( util/Conscript );
-
-The values of the simple variables mentioned in the C<Export> list will be
-squirreled away by any subsequent C<Build> commands. The C<Export> command
-will only export Perl B<scalar> variables, that is, variables whose name
-begins with C<$>. Other variables, objects, etc. can be exported by
-reference--but all scripts will refer to the same object, and this object
-should be considered to be read-only by the subsidiary scripts and by the
-original exporting script. It's acceptable, however, to assign a new value
-to the exported scalar variable--that won't change the underlying variable
-referenced. This sequence, for example, is OK:
-
-  $env = new cons();
-  Export qw( env INCLUDE LIB );
-  Build qw( util/Conscript );
-  $env = new cons(CFLAGS => '-O');
-  Build qw( other/Conscript );
-
-It doesn't matter whether the variable is set before or after the C<Export>
-command. The important thing is the value of the variable at the time the
-C<Build> command is executed. This is what gets squirreled away. Any
-subsequent C<Export> commands, by the way, invalidate the first: you must
-mention all the variables you wish to export on each C<Export> command.
-
-
-=head2 The Import command
-
-Variables exported by the C<Export> command can be imported into subsidiary
-scripts by the C<Import> command. The subsidiary script always imports
-variables directly from the superior script. Consider this example:
-
-  Import qw( env INCLUDE );
-
-This is only legal if the parent script exported both C<$env> and
-C<$INCLUDE>. It also must have given each of these variables values. It is
-OK for the subsidiary script to only import a subset of the exported
-variables (in this example, C<$LIB>, which was exported by the previous
-example, is not imported).
-
-All the imported variables are automatically re-exported, so the sequence:
-
-  Import qw ( env INCLUDE );
-  Build qw ( beneath-me/Conscript );
-
-will supply both C<$env> and C<$INCLUDE> to the subsidiary file. If only
-C<$env> is to be exported, then the following will suffice:
-
-  Import qw ( env INCLUDE );
-  Export qw ( env );
-  Build qw ( beneath-me/Conscript );
-
-Needless to say, the variables may be modified locally before invoking
-C<Build> on the subsidiary script.
-
-
-=head2 Build script evaluation order
-
-The only constraint on the ordering of build scripts is that superior
-scripts are evaluated before their inferior scripts. The top-level
-F<Construct> file, for instance, is evaluated first, followed by any
-inferior scripts. This is all you really need to know about the evaluation
-order, since order is generally irrelevant. Consider the following C<Build>
-command:
-
-  Build qw(
-	drivers/display/Conscript
-	drivers/mouse/Conscript
-	parser/Conscript
-	utilities/Conscript
-  );
-
-We've chosen to put the script names in alphabetical order, simply because
-that's the most convenient for maintenance purposes. Changing the order will
-make no difference to the build.
-
-
-=head1 A Model for sharing files
-
-
-=head2 Some simple conventions
-
-In any complex software system, a method for sharing build products needs to
-be established. We propose a simple set of conventions which are trivial to
-implement with Cons, but very effective.
-
-The basic rule is to require that all build products which need to be shared
-between directories are shared via an intermediate directory. We have
-typically called this F<export>, and, in a C environment, provided
-conventional sub-directories of this directory, such as F<include>, F<lib>,
-F<bin>, etc.
-
-These directories are defined by the top-level F<Construct> file. A simple
-F<Construct> file for a B<Hello, World!> application, organized using
-multiple directories, might look like this:
-
-  # Construct file for Hello, World!
-
-  # Where to put all our shared products.
-  $EXPORT = '#export';
-
-  Export qw( CONS INCLUDE LIB BIN );
-
-  # Standard directories for sharing products.
-  $INCLUDE = "$EXPORT/include";
-  $LIB = "$EXPORT/lib";
-  $BIN = "$EXPORT/bin";
-
-  # A standard construction environment.
-  $CONS = new cons (
-	CPPPATH => $INCLUDE,	# Include path for C Compilations
-	LIBPATH => $LIB,	# Library path for linking programs
-	LIBS => '-lworld',	# List of standard libraries
-  );
-
-  Build qw(
-	hello/Conscript
-	world/Conscript
-  );
-
-The F<world> directory's F<Conscript> file looks like this:
-
-  # Conscript file for directory world
-  Import qw( CONS INCLUDE LIB );
-
-  # Install the products of this directory
-  Install $CONS $LIB, 'libworld.a';
-  Install $CONS $INCLUDE, 'world.h';
-
-  # Internal products
-  Library $CONS 'libworld.a', 'world.c';
-
-and the F<hello> directory's F<Conscript> file looks like this:
-
-  # Conscript file for directory hello
-  Import qw( CONS BIN );
-
-  # Exported products
-  Install $CONS $BIN, 'hello';
-
-  # Internal products
-  Program $CONS 'hello', 'hello.c';
-
-To construct a B<Hello, World!> program with this directory structure, go to
-the top-level directory, and invoke C<cons> with the appropriate
-arguments. In the following example, we tell Cons to build the directory
-F<export>. To build a directory, Cons recursively builds all known products
-within that directory (only if they need rebuilding, of course). If any of
-those products depend upon other products in other directories, then those
-will be built, too.
-
-  % cons export
-  Install world/world.h as export/include/world.h
-  cc -Iexport/include -c hello/hello.c -o hello/hello.o
-  cc -Iexport/include -c world/world.c -o world/world.o
-  ar r world/libworld.a world/world.o
-  ar: creating world/libworld.a
-  ranlib world/libworld.a
-  Install world/libworld.a as export/lib/libworld.a
-  cc -o hello/hello hello/hello.o -Lexport/lib -lworld
-  Install hello/hello as export/bin/hello
-
-
-=head2 Clean, understandable, location-independent scripts
-
-You'll note that the two F<Conscript> files are very clean and
-to-the-point. They simply specify products of the directory and how to build
-those products. The build instructions are minimal: they specify which
-construction environment to use, the name of the product, and the name of
-the inputs. Note also that the scripts are location-independent: if you wish
-to reorganize your source tree, you are free to do so: you only have to
-change the F<Construct> file (in this example), to specify the new locations
-of the F<Conscript> files. The use of an export tree makes this goal easy.
-
-Note, too, how Cons takes care of little details for you. All the F<export>
-directories, for example, were made automatically. And the installed files
-were really hard-linked into the respective export directories, to save
-space and time. This attention to detail saves considerable work, and makes
-it even easier to produce simple, maintainable scripts.
-
-
-=head1 Separating source and build trees
-
-It's often desirable to keep any derived files from the build completely
-separate from the source files. This makes it much easier to keep track of
-just what is a source file, and also makes it simpler to handle B<variant>
-builds, especially if you want the variant builds to co-exist.
-
-
-=head2 Separating build and source directories using the Link command
-
-Cons provides a simple mechanism that handles all of these requirements. The
-C<Link> command is invoked as in this example:
-
-  Link 'build' => 'src';
-
-The specified directories are ``linked'' to the specified source
-directory. Let's suppose that you setup a source directory, F<src>, with the
-sub-directories F<world> and F<hello> below it, as in the previous
-example. You could then substitute for the original build lines the
-following:
-
-  Build qw(
-	build/world/Conscript
-	build/hello/Conscript
-  );
-
-Notice that you treat the F<Conscript> file as if it existed in the build
-directory. Now if you type the same command as before, you will get the
-following results:
-
-  % cons export
-  Install build/world/world.h as export/include/world.h
-  cc -Iexport/include -c build/hello/hello.c -o build/hello/hello.o
-  cc -Iexport/include -c build/world/world.c -o build/world/world.o
-  ar r build/world/libworld.a build/world/world.o
-  ar: creating build/world/libworld.a
-  ranlib build/world/libworld.a
-  Install build/world/libworld.a as export/lib/libworld.a
-  cc -o build/hello/hello build/hello/hello.o -Lexport/lib -lworld
-  Install build/hello/hello as export/bin/hello
-
-Again, Cons has taken care of the details for you. In particular, you will
-notice that all the builds are done using source files and object files from
-the build directory. For example, F<build/world/world.o> is compiled from
-F<build/world/world.c>, and F<export/include/world.h> is installed from
-F<build/world/world.h>. This is accomplished on most systems by the simple
-expedient of ``hard'' linking the required files from each source directory
-into the appropriate build directory.
-
-The links are maintained correctly by Cons, no matter what you do to the
-source directory. If you modify a source file, your editor may do this ``in
-place'' or it may rename it first and create a new file. In the latter case,
-any hard link will be lost. Cons will detect this condition the next time
-the source file is needed, and will relink it appropriately.
-
-You'll also notice, by the way, that B<no> changes were required to the
-underlying F<Conscript> files. And we can go further, as we shall see in the
-next section.
-
-=head2 Explicit references to the source directory
-
-When using the C<Link> command on some operating systems or with some
-tool chains, it's sometimes useful to have a command actually use
-the path name to the source directory, not the build directory.  For
-example, on systems that must copy, not "hard link," the F<src/> and
-F<build/> copies of C<Linked> files, using the F<src/> path of a file
-name might make an editor aware that a syntax error must be fixed in the
-source directory, not the build directory.
-
-You can tell Cons that you want to use the "source path" for a file by
-preceding the file name with a ``!'' (exclamation point).  For example,
-if we add a ``!'' to the beginning of a source file:
-
-  Program $env "foo", "!foo.c";	# Notice initial ! on foo.c
-
-Cons will compile the target as follows:
-
-  cc -c src/foo.c -o build/foo.o
-  cc -o build/foo build/foo.o
-
-Notice that Cons has compiled the program from the the F<src/foo.c>
-source file.  Without the initial ``!'', Cons would have compiled the
-program using the F<build/foo.c> path name.
-
-
-
-=head1 Variant builds
-
-
-=head2 Hello, World! for baNaNa and peAcH OS's
-
-Variant builds require just another simple extension. Let's take as an
-example a requirement to allow builds for both the baNaNa and peAcH
-operating systems. In this case, we are using a distributed file system,
-such as NFS to access the particular system, and only one or the other of
-the systems has to be compiled for any given invocation of C<cons>. Here's
-one way we could set up the F<Construct> file for our B<Hello, World!>
-application:
-
-  # Construct file for Hello, World!
-
-  die qq(OS must be specified) unless $OS = $ARG{OS};
-  die qq(OS must be "peach" or "banana")
-	if $OS ne "peach" && $OS ne "banana";
-
-  # Where to put all our shared products.
-  $EXPORT = "#export/$OS";
-
-  Export qw( CONS INCLUDE LIB BIN );
-
-  # Standard directories for sharing products.
-  $INCLUDE = "$EXPORT/include";
-  $LIB = "$EXPORT/lib";
-  $BIN = "$EXPORT/bin";
-
-  # A standard construction environment.
-  $CONS = new cons (
-	CPPPATH => $INCLUDE,	# Include path for C Compilations
-	LIBPATH => $LIB,	# Library path for linking programs
-	LIBS => '-lworld',	# List of standard libraries
-  );
-
-  # $BUILD is where we will derive everything.
-  $BUILD = "#build/$OS";
-
-  # Tell cons where the source files for $BUILD are.
-  Link $BUILD => 'src';
-
-  Build (
-	"$BUILD/hello/Conscript",
-	"$BUILD/world/Conscript",
-  );
-
-Now if we login to a peAcH system, we can build our B<Hello, World!>
-application for that platform:
-
-  % cons export OS=peach
-  Install build/peach/world/world.h as export/peach/include/world.h
-  cc -Iexport/peach/include -c build/peach/hello/hello.c -o build/peach/hello/hello.o
-  cc -Iexport/peach/include -c build/peach/world/world.c -o build/peach/world/world.o
-  ar r build/peach/world/libworld.a build/peach/world/world.o
-  ar: creating build/peach/world/libworld.a
-  ranlib build/peach/world/libworld.a
-  Install build/peach/world/libworld.a as export/peach/lib/libworld.a
-  cc -o build/peach/hello/hello build/peach/hello/hello.o -Lexport/peach/lib -lworld
-  Install build/peach/hello/hello as export/peach/bin/hello
-
-
-=head2 Variations on a theme
-
-Other variations of this model are possible. For example, you might decide
-that you want to separate out your include files into platform dependent and
-platform independent files. In this case, you'd have to define an
-alternative to C<$INCLUDE> for platform-dependent files. Most F<Conscript>
-files, generating purely platform-independent include files, would not have
-to change.
-
-You might also want to be able to compile your whole system with debugging
-or profiling, for example, enabled. You could do this with appropriate
-command line options, such as C<DEBUG=on>. This would then be translated
-into the appropriate platform-specific requirements to enable debugging
-(this might include turning off optimization, for example). You could
-optionally vary the name space for these different types of systems, but, as
-we'll see in the next section, it's not B<essential> to do this, since Cons
-is pretty smart about rebuilding things when you change options.
-
-
-=head1 Signatures
-
-Cons uses file B<signatures> to decide if a derived file is out-of-date
-and needs rebuilding.  In essence, if the contents of a file change,
-or the manner in which the file is built changes, the file's signature
-changes as well.  This allows Cons to decide with certainty when a file
-needs rebuilding, because Cons can detect, quickly and reliably, whether
-any of its dependency files have been changed.
-
-
-=head2 MD5 content and build signatures
-
-Cons uses the B<MD5> (B<Message Digest 5>) algorithm to compute file
-signatures.  The MD5 algorithm computes a strong cryptographic checksum
-for any given input string.  Cons can, based on configuration, use two
-different MD5 signatures for a given file:
-
-The B<content signature> of a file is an MD5 checksum of the file's
-contents.  Consequently, when the contents of a file change, its content
-signature changes as well.
-
-The B<build signature> of a file is a combined MD5 checksum of:
-
-=over 4
-
-the signatures of all the input files used to build the file
-
-the signatures of all dependency files discovered by source scanners
-(for example, C<.h> files)
-
-the signatures of all dependency files specified explicitly via the
-C<Depends> method)
-
-the command-line string used to build the file
-
-=back
-
-The build signature is, in effect, a digest of all the dependency
-information for the specified file.  Consequently, a file's build
-signature changes whenever any part of its dependency information
-changes: a new file is added, the contents of a file on which it depends
-change, there's a change to the command line used to build the file (or
-any of its dependency files), etc.
-
-For example, in the previous section, the build signature of the
-F<world.o> file will include:
-
-=over 4
-
-the signature of the F<world.c> file
-
-the signatures of any header files that Cons detects are included,
-directly or indirectly, by F<world.c>
-
-the text of the actual command line was used to generate F<world.o>
-
-=back
-
-Similarly, the build signature of the F<libworld.a> file will include
-all the signatures of its constituents (and hence, transitively, the
-signatures of B<their> constituents), as well as the command line that
-created the file.
-
-Note that there is no need for a derived file to depend upon any
-particular F<Construct> or F<Conscript> file.  If changes to these files
-affect a file, then this will be automatically reflected in its build
-signature, since relevant parts of the command line are included in the
-signature. Unrelated F<Construct> or F<Conscript> changes will have no
-effect.
-
-
-=head2 Storing signatures in .consign files
-
-Before Cons exits, it stores the calculated signatures for all of the
-files it built or examined in F<.consign> files, one per directory.
-Cons uses this stored information on later invocations to decide if
-derived files need to be rebuilt.
-
-After the previous example was compiled, the F<.consign> file in the
-F<build/peach/world> directory looked like this:
-
-  world.h:985533370 - d181712f2fdc07c1f05d97b16bfad904
-  world.o:985533372 2a0f71e0766927c0532977b0d2158981
-  world.c:985533370 - c712f77189307907f4189b5a7ab62ff3
-  libworld.a:985533374 69e568fc5241d7d25be86d581e1fb6aa
-
-After the file name and colon, the first number is a timestamp of the
-file's modification time (on UNIX systems, this is typically the number
-of seconds since January 1st, 1970).  The second value is the build
-signature of the file (or ``-'' in the case of files with no build
-signature--that is, source files).  The third value, if any, is the
-content signature of the file.
-
-
-=head2 Using build signatures to decide when to rebuild files
-
-When Cons is deciding whether to build or rebuild a derived file, it
-first computes the file's current build signature.  If the file doesn't
-exist, it must obviously be built.
-
-If, however, the file already exists, Cons next compares the
-modification timestamp of the file against the timestamp value in
-the F<.consign> file.  If the timestamps match, Cons compares the
-newly-computed build signature against the build signature in the
-F<.consign> file.  If the timestamps do not match or the build
-signatures do not match, the derived file is rebuilt.
-
-After the file is built or rebuilt, Cons arranges to store the
-newly-computed build signature in the F<.consign> file when it exits.
-
-
-=head2 Signature example
-
-The use of these signatures is an extremely simple, efficient, and
-effective method of improving--dramatically--the reproducibility of a
-system.
-
-We'll demonstrate this with a simple example:
-
-  # Simple "Hello, World!" Construct file
-  $CFLAGS = '-g' if $ARG{DEBUG} eq 'on';
-  $CONS = new cons(CFLAGS => $CFLAGS);
-  Program $CONS 'hello', 'hello.c';
-
-Notice how Cons recompiles at the appropriate times:
-
-  % cons hello
-  cc -c hello.c -o hello.o
-  cc -o hello hello.o
-  % cons hello
-  cons: "hello" is up-to-date.
-  % cons DEBUG=on hello
-  cc -g -c hello.c -o hello.o
-  cc -o hello hello.o
-  % cons DEBUG=on hello
-  cons: "hello" is up-to-date.
-  % cons hello
-  cc -c hello.c -o hello.o
-  cc -o hello hello.o
-
-
-=head2 Source-file signature configuration
-
-Cons provides a C<SourceSignature> method that allows you to configure
-how the signature should be calculated for any source file when its
-signature is being used to decide if a dependent file is up-to-date.
-The arguments to the C<SourceSignature> method consist of one or more
-pairs of strings:
-
-  SourceSignature 'auto/*.c' => 'content',
-		  '*' => 'stored-content';
-
-The first string in each pair is a pattern to match against derived file
-path names. The pattern is a file-globbing pattern, not a Perl regular
-expression; the pattern <*.l> will match all Lex source files.  The C<*>
-wildcard will match across directory separators; the pattern C<foo/*.c>
-would match all C source files in any subdirectory underneath the C<foo>
-subdirectory.
-
-The second string in each pair contains one of the following keywords to
-specify how signatures should be calculated for source files that match
-the pattern.  The available keywords are:
-
-=over 4
-
-=item content
-
-Use the content signature of the source file when calculating signatures
-of files that depend on it.  This guarantees correct calculation of the
-file's signature for all builds, by telling Cons to read the contents of
-a source file to calculate its content signature each time it is run.
-
-=item stored-content
-
-Use the source file's content signature as stored in the F<.consign>
-file, provided the file's timestamp matches the cached timestamp value
-in the F<.consign> file.  This optimizes performance, with the slight
-risk of an incorrect build if a source file's contents have been changed
-so quickly after its previous update that the timestamp still matches
-the stored timestamp in the F<.consign> file even though the contents
-have changed.
-
-=back
-
-The Cons default behavior of always calculating a source file's
-signature from the file's contents is equivalent to specifying:
-
-  SourceSignature '*' => 'content';
-
-The C<*> will match all source files.  The C<content> keyword
-specifies that Cons will read the contents of a source file to calculate
-its signature each time it is run.
-
-A useful global performance optimization is:
-
-  SourceSignature '*' => 'stored-content';
-
-This specifies that Cons will use pre-computed content signatures
-from F<.consign> files, when available, rather than re-calculating a
-signature from the the source file's contents each time Cons is run.  In
-practice, this is safe for most build situations, and only a problem
-when source files are changed automatically (by scripts, for example).
-The Cons default, however, errs on the side of guaranteeing a correct
-build in all situations.
-
-Cons tries to match source file path names against the patterns in the
-order they are specified in the C<SourceSignature> arguments:
-
-  SourceSignature '/usr/repository/objects/*' => 'stored-content',
-		  '/usr/repository/*' => 'content',
-		  '*.y' => 'content',
-		  '*' => 'stored-content';
-
-In this example, all source files under the F</usr/repository/objects>
-directory will use F<.consign> file content signatures, source files
-anywhere else underneath F</usr/repository> will not use F<.consign>
-signature values, all Yacc source files (C<*.y>) anywhere else will not
-use F<.consign> signature values, and any other source file will use
-F<.consign> signature values.
-
-
-=head2 Derived-file signature configuration
-
-Cons provides a C<SIGNATURE> construction variable that allows you to
-configure how signatures are calculated for any derived file when its
-signature is being used to decide if a dependent file is up-to-date.
-The value of the C<SIGNATURE> construction variable is a Perl array
-reference that holds one or more pairs of strings, like the arguments to
-the C<SourceSignature> method.
-
-The first string in each pair is a pattern to match against derived file
-path names. The pattern is a file-globbing pattern, not a Perl regular
-expression; the pattern `*.obj' will match all (Win32) object files.
-The C<*> wildcard will match across directory separators; the pattern
-`foo/*.a' would match all (UNIX) library archives in any subdirectory
-underneath the foo subdirectory.
-
-The second string in each pair contains one of the following keywords
-to specify how signatures should be calculated for derived files that
-match the pattern.  The available keywords are the same as for the
-C<SourceSignature> method, with an additional keyword:
-
-=over 4
-
-=item build
-
-Use the build signature of the derived file when calculating signatures
-of files that depend on it.  This guarantees correct builds by forcing
-Cons to rebuild any and all files that depend on the derived file.
-
-=item content
-
-Use the content signature of the derived file when calculating signatures
-of files that depend on it.  This guarantees correct calculation of the
-file's signature for all builds, by telling Cons to read the contents of
-a derived file to calculate its content signature each time it is run.
-
-=item stored-content
-
-Use the derived file's content signature as stored in the F<.consign>
-file, provided the file's timestamp matches the cached timestamp value
-in the F<.consign> file.  This optimizes performance, with the slight
-risk of an incorrect build if a derived file's contents have been
-changed so quickly after a Cons build that the file's timestamp still
-matches the stored timestamp in the F<.consign> file.
-
-=back
-
-The Cons default behavior (as previously described) for using
-derived-file signatures is equivalent to:
-
-  $env = new cons(SIGNATURE => ['*' => 'build']);
-
-The C<*> will match all derived files.  The C<build> keyword specifies
-that all derived files' build signatures will be used when calculating
-whether a dependent file is up-to-date.
-
-A useful alternative default C<SIGNATURE> configuration for many sites:
-
-  $env = new cons(SIGNATURE => ['*' => 'content']);
-
-In this configuration, derived files have their signatures calculated
-from the file contents.  This adds slightly to Cons' workload, but has
-the useful effect of "stopping" further rebuilds if a derived file is
-rebuilt to exactly the same file contents as before, which usually
-outweighs the additional computation Cons must perform.
-
-For example, changing a comment in a C file and recompiling should
-generate the exact same object file (assuming the compiler doesn't
-insert a timestamp in the object file's header).  In that case,
-specifying C<content> or C<stored-content> for the signature calculation
-will cause Cons to recognize that the object file did not actually
-change as a result of being rebuilt, and libraries or programs that
-include the object file will not be rebuilt.  When C<build> is
-specified, however, Cons will only "know" that the object file was
-rebuilt, and proceed to rebuild any additional files that include the
-object file.
-
-Note that Cons tries to match derived file path names against the
-patterns in the order they are specified in the C<SIGNATURE> array
-reference:
-
-  $env = new cons(SIGNATURE => ['foo/*.o' => 'build',
-				'*.o' => 'content',
-				'*.a' => 'stored-content',
-				'*' => 'content']);
-
-In this example, all object files underneath the F<foo> subdirectory
-will use build signatures, all other object files (including object
-files underneath other subdirectories!) will use F<.consign> file
-content signatures, libraries will use F<.consign> file build
-signatures, and all other derived files will use content signatures.
-
-
-=head2 Debugging signature calculation
-
-Cons provides a C<-S> option that can be used to specify what internal
-Perl package Cons should use to calculate signatures.  The default Cons
-behavior is equivalent to specifying C<-S md5> on the command line.
-
-The only other package (currently) available is an C<md5::debug>
-package that prints out detailed information about the MD5 signature
-calculations performed by Cons:
-
-  % cons -S md5::debug hello
-  sig::md5::srcsig(hello.c)
-          => |52d891204c62fe93ecb95281e1571938|
-  sig::md5::collect(52d891204c62fe93ecb95281e1571938)
-          => |fb0660af4002c40461a2f01fbb5ffd03|
-  sig::md5::collect(52d891204c62fe93ecb95281e1571938,
-                    fb0660af4002c40461a2f01fbb5ffd03,
-                    cc   -c %< -o %>)
-          => |f7128da6c3fe3c377dc22ade70647b39|
-  sig::md5::current(||
-                 eq |f7128da6c3fe3c377dc22ade70647b39|)
-  cc -c hello.c -o hello.o
-  sig::md5::collect()
-          => |d41d8cd98f00b204e9800998ecf8427e|
-  sig::md5::collect(f7128da6c3fe3c377dc22ade70647b39,
-                    d41d8cd98f00b204e9800998ecf8427e,
-                    cc  -o %> %<  )
-          => |a0bdce7fd09e0350e7efbbdb043a00b0|
-  sig::md5::current(||
-                 eq |a0bdce7fd09e0350e7efbbdb043a00b0|)
-  cc -o hello, hello.o
-
-
-=head1 Code Repositories
-
-Many software development organizations will have one or more central
-repository directory trees containing the current source code for one or
-more projects, as well as the derived object files, libraries, and
-executables.  In order to reduce unnecessary recompilation, it is useful to
-use files from the repository to build development software--assuming, of
-course, that no newer dependency file exists in the local build tree.
-
-
-=head2 Repository
-
-Cons provides a mechanism to specify a list of code repositories that will
-be searched, in-order, for source files and derived files not found in the
-local build directory tree.
-
-The following lines in a F<Construct> file will instruct Cons to look first
-under the F</usr/experiment/repository> directory and then under the
-F</usr/product/repository> directory:
-
-  Repository qw (
-	/usr/experiment/repository
-	/usr/product/repository
-  );
-
-The repository directories specified may contain source files, derived files
-(objects, libraries and executables), or both.  If there is no local file
-(source or derived) under the directory in which Cons is executed, then the
-first copy of a same-named file found under a repository directory will be
-used to build any local derived files.
-
-Cons maintains one global list of repositories directories.  Cons will
-eliminate the current directory, and any non-existent directories, from the
-list.
-
-
-=head2 Finding the Construct file in a Repository
-
-Cons will also search for F<Construct> and F<Conscript> files in the
-repository tree or trees.  This leads to a chicken-and-egg situation,
-though: how do you look in a repository tree for a F<Construct> file if the
-F<Construct> file tells you where the repository is?  To get around this,
-repositories may be specified via C<-R> options on the command line:
-
-  % cons -R /usr/experiment/repository -R /usr/product/repository .
-
-Any repository directories specified in the F<Construct> or F<Conscript>
-files will be appended to the repository directories specified by
-command-line C<-R> options.
-
-=head2 Repository source files
-
-If the source code (include the F<Conscript> file) for the library version
-of the I<Hello, World!> C application is in a repository (with no derived
-files), Cons will use the repository source files to create the local object
-files and executable file:
-
-  % cons -R /usr/src_only/repository hello
-  gcc -c /usr/src_only/repository/hello.c -o hello.o
-  gcc -c /usr/src_only/repository/world.c -o world.o
-  ar r libworld.a world.o
-  ar: creating libworld.a
-  ranlib libworld.a
-  gcc -o hello hello.o libworld.a
-
-Creating a local source file will cause Cons to rebuild the appropriate
-derived file or files:
-
-  % pico world.c
-    [EDIT]
-  % cons -R /usr/src_only/repository hello
-  gcc -c world.c -o world.o
-  ar r libworld.a world.o
-  ar: creating libworld.a
-  ranlib libworld.a
-  gcc -o hello hello.o libworld.a
-
-And removing the local source file will cause Cons to revert back to
-building the derived files from the repository source:
-
-  % rm world.c
-  % cons -R /usr/src_only/repository hello
-  gcc -c /usr/src_only/repository/world.c -o world.o
-  ar r libworld.a world.o
-  ar: creating libworld.a
-  ranlib libworld.a
-  gcc -o hello hello.o libworld.a
-
-
-=head2 Repository derived files
-
-If a repository tree contains derived files (usually object files,
-libraries, or executables), Cons will perform its normal signature
-calculation to decide whether the repository file is up-to-date or a derived
-file must be built locally.  This means that, in order to ensure correct
-signature calculation, a repository tree must also contain the F<.consign>
-files that were created by Cons when generating the derived files.
-
-This would usually be accomplished by building the software in the
-repository (or, alternatively, in a build directory, and then copying the
-result to the repository):
-
-  % cd /usr/all/repository
-  % cons hello
-  gcc -c hello.c -o hello.o
-  gcc -c world.c -o world.o
-  ar r libworld.a world.o
-  ar: creating libworld.a
-  ranlib libworld.a
-  gcc -o hello hello.o libworld.a
-
-(This is safe even if the F<Construct> file lists the F</usr/all/repository>
-directory in a C<Repository> command because Cons will remove the current
-directory from the repository list.)
-
-Now if we want to build a copy of the application with our own F<hello.c>
-file, we only need to create the one necessary source file, and use the
-C<-R> option to have Cons use other files from the repository:
-
-  % mkdir $HOME/build1
-  % cd $HOME/build1
-  % ed hello.c
-    [EDIT]
-  % cons -R /usr/all/repository hello
-  gcc -c hello.c -o hello.o
-  gcc -o hello hello.o /usr/all/repository/libworld.a
-
-Notice that Cons has not bothered to recreate a local F<libworld.a> library
-(or recompile the F<world.o> module), but instead uses the already-compiled
-version from the repository.
-
-Because the MD5 signatures that Cons puts in the F<.consign> file contain
-timestamps for the derived files, the signature timestamps must match the
-file timestamps for a signature to be considered valid.
-
-Some software systems may alter the timestamps on repository files (by
-copying them, e.g.), in which case Cons will, by default, assume the
-repository signatures are invalid and rebuild files unnecessarily.  This
-behavior may be altered by specifying:
-
-  Repository_Sig_Times_OK 0;
-
-This tells Cons to ignore timestamps when deciding whether a signature is
-valid.  (Note that avoiding this sanity check means there must be proper
-control over the repository tree to ensure that the derived files cannot be
-modified without updating the F<.consign> signature.)
-
-
-=head2 Local copies of files
-
-If the repository tree contains the complete results of a build, and we try
-to build from the repository without any files in our local tree, something
-moderately surprising happens:
-
-  % mkdir $HOME/build2
-  % cd $HOME/build2
-  % cons -R /usr/all/repository hello
-  cons: "hello" is up-to-date.
-
-Why does Cons say that the F<hello> program is up-to-date when there is no
-F<hello> program in the local build directory?  Because the repository (not
-the local directory) contains the up-to-date F<hello> program, and Cons
-correctly determines that nothing needs to be done to rebuild this
-up-to-date copy of the file.
-
-There are, however, many times in which it is appropriate to ensure that a
-local copy of a file always exists.  A packaging or testing script, for
-example, may assume that certain generated files exist locally.  Instead of
-making these subsidiary scripts aware of the repository directory, the
-C<Local> command may be added to a F<Construct> or F<Conscript> file to
-specify that a certain file or files must appear in the local build
-directory:
-
-  Local qw(
-	hello
-  );
-
-Then, if we re-run the same command, Cons will make a local copy of the
-program from the repository copy (telling you that it is doing so):
-
-  % cons -R /usr/all/repository hello
-  Local copy of hello from /usr/all/repository/hello
-  cons: "hello" is up-to-date.
-
-Notice that, because the act of making the local copy is not considered a
-"build" of the F<hello> file, Cons still reports that it is up-to-date.
-
-Creating local copies is most useful for files that are being installed into
-an intermediate directory (for sharing with other directories) via the
-C<Install> command.  Accompanying the C<Install> command for a file with a
-companion C<Local> command is so common that Cons provides a
-C<Install_Local> command as a convenient way to do both:
-
-  Install_Local $env, '#export', 'hello';
-
-is exactly equivalent to:
-
-  Install $env '#export', 'hello';
-  Local '#export/hello';
-
-Both the C<Local> and C<Install_Local> commands update the local F<.consign>
-file with the appropriate file signatures, so that future builds are
-performed correctly.
-
-
-=head2 Repository dependency analysis
-
-Due to its built-in scanning, Cons will search the specified repository
-trees for included F<.h> files.  Unless the compiler also knows about the
-repository trees, though, it will be unable to find F<.h> files that only
-exist in a repository.  If, for example, the F<hello.c> file includes the
-F<hello.h> file in its current directory:
-
-  % cons -R /usr/all/repository hello
-  gcc -c /usr/all/repository/hello.c -o hello.o
-  /usr/all/repository/hello.c:1: hello.h: No such file or directory
-
-Solving this problem forces some requirements onto the way construction
-environments are defined and onto the way the C C<#include> preprocessor
-directive is used to include files.
-
-In order to inform the compiler about the repository trees, Cons will add
-appropriate C<-I> flags to the compilation commands.  This means that the
-C<CPPPATH> variable in the construction environment must explicitly specify
-all subdirectories which are to be searched for included files, including the
-current directory.  Consequently, we can fix the above example by changing
-the environment creation in the F<Construct> file as follows:
-
-  $env = new cons(
-	CC	=> 'gcc',
-	CPPPATH	=> '.',
-	LIBS	=> 'libworld.a',
-  );
-
-Due to the definition of the C<CPPPATH> variable, this yields, when we
-re-execute the command:
-
-  % cons -R /usr/all/repository hello
-  gcc -c -I. -I/usr/all/repository /usr/all/repository/hello.c -o hello.o
-  gcc -o hello hello.o /usr/all/repository/libworld.a
-
-The order of the C<-I> flags replicates, for the C preprocessor, the same
-repository-directory search path that Cons uses for its own dependency
-analysis.  If there are multiple repositories and multiple C<CPPPATH>
-directories, Cons will append the repository directories to the beginning of
-each C<CPPPATH> directory, rapidly multiplying the number of C<-I> flags.
-As an extreme example, a F<Construct> file containing:
-
-  Repository qw(
-	/u1
-	/u2
-  );
-
-  $env = new cons(
-	CPPPATH	=> 'a:b:c',
-  );
-
-Would yield a compilation command of:
-
-  cc -Ia -I/u1/a -I/u2/a -Ib -I/u1/b -I/u2/b -Ic -I/u1/c -I/u2/c -c hello.c -o hello.o
-
-In order to shorten the command lines as much as possible, Cons will
-remove C<-I> flags for any directories, locally or in the repositories,
-which do not actually exist.  (Note that the C<-I> flags are not included
-in the MD5 signature calculation for the target file, so the target will
-not be recompiled if the compilation command changes due to a directory
-coming into existence.)
-
-Because Cons relies on the compiler's C<-I> flags to communicate the
-order in which repository directories must be searched, Cons' handling
-of repository directories is fundamentally incompatible with using
-double-quotes on the C<#include> directives in any C source code that
-you plan to modify:
-
-  #include "file.h"	/* DON'T USE DOUBLE-QUOTES LIKE THIS */
-
-This is because most C preprocessors, when faced with such a directive, will
-always first search the directory containing the source file.  This
-undermines the elaborate C<-I> options that Cons constructs to make the
-preprocessor conform to its preferred search path.
-
-Consequently, when using repository trees in Cons, B<always> use
-angle-brackets for included files in any C source (.c or .h) files that
-you plan to modify locally:
-
-  #include <file.h>	/* USE ANGLE-BRACKETS INSTEAD */
-
-Code that will not change can still safely use double quotes on #include
-lines.
-
-
-=head2 Repository_List
-
-Cons provides a C<Repository_List> command to return a list of all
-repository directories in their current search order.  This can be used for
-debugging, or to do more complex Perl stuff:
-
-  @list = Repository_List;
-  print join(' ', @list), "\n";
-
-
-=head2 Repository interaction with other Cons features
-
-Cons' handling of repository trees interacts correctly with other Cons
-features--which is to say, it generally does what you would expect.
-
-Most notably, repository trees interact correctly, and rather powerfully,
-with the 'Link' command.  A repository tree may contain one or more
-subdirectories for version builds established via C<Link> to a source
-subdirectory.  Cons will search for derived files in the appropriate build
-subdirectories under the repository tree.
-
-
-=head1 Default targets
-
-Until now, we've demonstrated invoking Cons with an explicit target
-to build:
-
-  % cons hello
-
-Normally, Cons does not build anything unless a target is specified,
-but specifying '.' (the current directory) will build everything:
-
-  % cons		# does not build anything
-
-  % cons .		# builds everything under the top-level directory
-
-Adding the C<Default> method to any F<Construct> or F<Conscript> file will add
-the specified targets to a list of default targets.  Cons will build
-these defaults if there are no targets specified on the command line.
-So adding the following line to the top-level F<Construct> file will mimic
-Make's typical behavior of building everything by default:
-
-  Default '.';
-
-The following would add the F<hello> and F<goodbye> commands (in the
-same directory as the F<Construct> or F<Conscript> file) to the default list:
-
-  Default qw(
-	hello
-	goodbye
-  );
-
-The C<Default> method may be used more than once to add targets to the
-default list.
-
-=head1 Selective builds
-
-Cons provides two methods for reducing the size of given build. The first is
-by specifying targets on the command line, and the second is a method for
-pruning the build tree. We'll consider target specification first.
-
-
-=head2 Selective targeting
-
-Like make, Cons allows the specification of ``targets'' on the command
-line. Cons targets may be either files or directories. When a directory is
-specified, this is simply a short-hand notation for every derivable
-product--that Cons knows about--in the specified directory and below. For
-example:
-
-  % cons build/hello/hello.o
-
-means build F<hello.o> and everything that F<hello.o> might need. This is
-from a previous version of the B<Hello, World!> program in which F<hello.o>
-depended upon F<export/include/world.h>. If that file is not up-to-date
-(because someone modified F<src/world/world.h)>, then it will be rebuilt,
-even though it is in a directory remote from F<build/hello>.
-
-In this example:
-
-  % cons build
-
-Everything in the F<build> directory is built, if necessary. Again, this may
-cause more files to be built. In particular, both F<export/include/world.h>
-and F<export/lib/libworld.a> are required by the F<build/hello> directory,
-and so they will be built if they are out-of-date.
-
-If we do, instead:
-
-  % cons export
-
-then only the files that should be installed in the export directory will be
-rebuilt, if necessary, and then installed there. Note that C<cons build>
-might build files that C<cons export> doesn't build, and vice-versa.
-
-
-=head2 No ``special'' targets
-
-With Cons, make-style ``special'' targets are not required. The simplest
-analog with Cons is to use special F<export> directories, instead. Let's
-suppose, for example, that you have a whole series of unit tests that are
-associated with your code. The tests live in the source directory near the
-code. Normally, however, you don't want to build these tests. One solution
-is to provide all the build instructions for creating the tests, and then to
-install the tests into a separate part of the tree. If we install the tests
-in a top-level directory called F<tests>, then:
-
-  % cons tests
-
-will build all the tests.
-
-  % cons export
-
-will build the production version of the system (but not the tests), and:
-
-  % cons build
-
-should probably be avoided (since it will compile tests unnecessarily).
-
-If you want to build just a single test, then you could explicitly name the
-test (in either the F<tests> directory or the F<build> directory). You could
-also aggregate the tests into a convenient hierarchy within the tests
-directory. This hierarchy need not necessarily match the source hierarchy,
-in much the same manner that the include hierarchy probably doesn't match
-the source hierarchy (the include hierarchy is unlikely to be more than two
-levels deep, for C programs).
-
-If you want to build absolutely everything in the tree (subject to whatever
-options you select), you can use:
-
-  % cons .
-
-This is not particularly efficient, since it will redundantly walk all the
-trees, including the source tree. The source tree, of course, may have
-buildable objects in it--nothing stops you from doing this, even if you
-normally build in a separate build tree.
-
-
-=head1 Build Pruning
-
-In conjunction with target selection, B<build pruning> can be used to reduce
-the scope of the build. In the previous peAcH and baNaNa example, we have
-already seen how script-driven build pruning can be used to make only half
-of the potential build available for any given invocation of C<cons>. Cons
-also provides, as a convenience, a command line convention that allows you
-to specify which F<Conscript> files actually get ``built''--that is,
-incorporated into the build tree. For example:
-
-  % cons build +world
-
-The C<+> argument introduces a Perl regular expression. This must, of
-course, be quoted at the shell level if there are any shell meta-characters
-within the expression. The expression is matched against each F<Conscript>
-file which has been mentioned in a C<Build> statement, and only those
-scripts with matching names are actually incorporated into the build
-tree. Multiple such arguments are allowed, in which case a match against any
-of them is sufficient to cause a script to be included.
-
-In the example, above, the F<hello> program will not be built, since Cons
-will have no knowledge of the script F<hello/Conscript>. The F<libworld.a>
-archive will be built, however, if need be.
-
-There are a couple of uses for build pruning via the command line. Perhaps
-the most useful is the ability to make local changes, and then, with
-sufficient knowledge of the consequences of those changes, restrict the size
-of the build tree in order to speed up the rebuild time. A second use for
-build pruning is to actively prevent the recompilation of certain files that
-you know will recompile due to, for example, a modified header file. You may
-know that either the changes to the header file are immaterial, or that the
-changes may be safely ignored for most of the tree, for testing
-purposes.With Cons, the view is that it is pragmatic to admit this type of
-behavior, with the understanding that on the next full build everything that
-needs to be rebuilt will be. There is no equivalent to a ``make touch''
-command, to mark files as permanently up-to-date. So any risk that is
-incurred by build pruning is mitigated. For release quality work, obviously,
-we recommend that you do not use build pruning (it's perfectly OK to use
-during integration, however, for checking compilation, etc. Just be sure to
-do an unconstrained build before committing the integration).
-
-
-=head1 Temporary overrides
-
-Cons provides a very simple mechanism for overriding aspects of a build. The
-essence is that you write an override file containing one or more
-C<Override> commands, and you specify this on the command line, when you run
-C<cons>:
-
-  % cons -o over export
-
-will build the F<export> directory, with all derived files subject to the
-overrides present in the F<over> file. If you leave out the C<-o> option,
-then everything necessary to remove all overrides will be rebuilt.
-
-
-=head2 Overriding environment variables
-
-The override file can contain two types of overrides. The first is incoming
-environment variables. These are normally accessible by the F<Construct>
-file from the C<%ENV> hash variable. These can trivially be overridden in
-the override file by setting the appropriate elements of C<%ENV> (these
-could also be overridden in the user's environment, of course).
-
-
-=head2 The Override command
-
-The second type of override is accomplished with the C<Override> command,
-which looks like this:
-
-  Override <regexp>, <var1> => <value1>, <var2> => <value2>, ...;
-
-The regular expression I<regexp> is matched against every derived file that
-is a candidate for the build. If the derived file matches, then the
-variable/value pairs are used to override the values in the construction
-environment associated with the derived file.
-
-Let's suppose that we have a construction environment like this:
-
-  $CONS = new cons(
-	COPT => '',
-	CDBG => '-g',
-	CFLAGS => '%COPT %CDBG',
-  );
-
-Then if we have an override file F<over> containing this command:
-
-  Override '\.o$', COPT => '-O', CDBG => '';
-
-then any C<cons> invocation with C<-o over> that creates F<.o> files via
-this environment will cause them to be compiled with C<-O >and no C<-g>. The
-override could, of course, be restricted to a single directory by the
-appropriate selection of a regular expression.
-
-Here's the original version of the Hello, World! program, built with this
-environment. Note that Cons rebuilds the appropriate pieces when the
-override is applied or removed:
-
-  % cons hello
-  cc -g -c hello.c -o hello.o
-  cc -o hello hello.o
-  % cons -o over hello
-  cc -O -c hello.c -o hello.o
-  cc -o hello hello.o
-  % cons -o over hello
-  cons: "hello" is up-to-date.
-  % cons hello
-  cc -g -c hello.c -o hello.o
-  cc -o hello hello.o
-
-It's important that the C<Override> command only be used for temporary,
-on-the-fly overrides necessary for development because the overrides are not
-platform independent and because they rely too much on intimate knowledge of
-the workings of the scripts. For temporary use, however, they are exactly
-what you want.
-
-Note that it is still useful to provide, say, the ability to create a fully
-optimized version of a system for production use--from the F<Construct> and
-F<Conscript> files. This way you can tailor the optimized system to the
-platform. Where optimizer trade-offs need to be made (particular files may
-not be compiled with full optimization, for example), then these can be
-recorded for posterity (and reproducibility) directly in the scripts.
-
-
-=head1 More on construction environments
-
-As previously mentioned, a B<construction environment> is an object that
-has a set of keyword/value pairs and a set of methods, and which is used
-to tell Cons how target files should be built.  This section describes
-how Cons uses and expands construction environment values to control its
-build behavior.
-
-=head2 Construction variable expansion
-
-Construction variables from a construction environment are expanded
-by preceding the keyword with a C<%> (percent sign):
-
-  Construction variables:
-	XYZZY => 'abracadabra',
-
-  The string:  "The magic word is:  %XYZZY!"
-  expands to:  "The magic word is:  abracadabra!"
-
-A construction variable name may be surrounded by C<{> and C<}> (curly
-braces), which are stripped as part of the expansion.  This can
-sometimes be necessary to separate a variable expansion from trailing
-alphanumeric characters:
-
-  Construction variables:
-	OPT    => 'value1',
-	OPTION => 'value2',
-
-  The string:  "%OPT %{OPT}ION %OPTION %{OPTION}"
-  expands to:  "value1 value1ION value2 value2"
-
-Construction variable expansion is recursive--that is, a string
-containing C<%->expansions after substitution will be re-expanded until
-no further substitutions can be made:
-
-  Construction variables:
-	STRING => 'The result is:  %FOO',
-	FOO    => '%BAR',
-	BAR    => 'final value',
-
-  The string:  "The string says:  %STRING"
-  expands to:  "The string says:  The result is:  final value"
-
-If a construction variable is not defined in an environment, then the
-null string is substituted:
-
-  Construction variables:
-	FOO => 'value1',
-	BAR => 'value2',
-
-  The string:  "%FOO <%NO_VARIABLE> %BAR"
-  expands to:  "value1 <> value2"
-
-A doubled C<%%> will be replaced by a single C<%>:
-
-  The string:  "Here is a percent sign:  %%"
-  expands to:  "Here is a percent sign: %"
-
-=head2 Default construction variables
-
-When you specify no arguments when creating a new construction
-environment:
-
-  $env = new cons();
-
-Cons creates a reference to a new, default construction
-environment. This contains a number of construction variables and some
-methods. At the present writing, the default construction variables on a
-UNIX system are:
-
-  CC            => 'cc',
-  CFLAGS        => '',
-  CCCOM         => '%CC %CFLAGS %_IFLAGS -c %< -o %>',
-  CXX           => '%CC',
-  CXXFLAGS      => '%CFLAGS',
-  CXXCOM        => '%CXX %CXXFLAGS %_IFLAGS -c %< -o %>',
-  INCDIRPREFIX  => '-I',
-  INCDIRSUFFIX  => '',
-  LINK          => '%CXX',
-  LINKCOM       => '%LINK %LDFLAGS -o %> %< %_LDIRS %LIBS',
-  LINKMODULECOM => '%LD -r -o %> %<',
-  LIBDIRPREFIX  => '-L',
-  LIBDIRSUFFIX  => '',
-  AR		=> 'ar',
-  ARFLAGS	=> 'r',
-  ARCOM		=> ['%AR %ARFLAGS %> %<', '%RANLIB %>'],
-  RANLIB	=> 'ranlib',
-  AS		=> 'as',
-  ASFLAGS	=> '',
-  ASCOM		=> '%AS %ASFLAGS %< -o %>',
-  LD		=> 'ld',
-  LDFLAGS	=> '',
-  PREFLIB	=> 'lib',
-  SUFLIB	=> '.a',
-  SUFLIBS	=> '.so:.a',
-  SUFOBJ	=> '.o',
-  SIGNATURE     => [ '*' => 'build' ],
-  ENV		=> { 'PATH' => '/bin:/usr/bin' },
-
-
-And on a Win32 system (Windows NT), the default construction variables
-are (unless the default rule style is set using the B<DefaultRules>
-method):
-
-  CC		=> 'cl',
-  CFLAGS	=> '/nologo',
-  CCCOM		=> '%CC %CFLAGS %_IFLAGS /c %< /Fo%>',
-  CXXCOM        => '%CXX %CXXFLAGS %_IFLAGS /c %< /Fo%>',
-  INCDIRPREFIX  => '/I',
-  INCDIRSUFFIX  => '',
-  LINK          => 'link',
-  LINKCOM       => '%LINK %LDFLAGS /out:%> %< %_LDIRS %LIBS',
-  LINKMODULECOM => '%LD /r /o %> %<',
-  LIBDIRPREFIX  => '/LIBPATH:',
-  LIBDIRSUFFIX  => '',
-  AR            => 'lib',
-  ARFLAGS       => '/nologo ',
-  ARCOM         => "%AR %ARFLAGS /out:%> %<",
-  RANLIB        => '',
-  LD            => 'link',
-  LDFLAGS       => '/nologo ',
-  PREFLIB       => '',
-  SUFEXE	=> '.exe',
-  SUFLIB	=> '.lib',
-  SUFLIBS	=> '.dll:.lib',
-  SUFOBJ	=> '.obj',
-  SIGNATURE     => [ '*' => 'build' ],
-
-These variables are used by the various methods associated with the
-environment. In particular, any method that ultimately invokes an external
-command will substitute these variables into the final command, as
-appropriate. For example, the C<Objects> method takes a number of source
-files and arranges to derive, if necessary, the corresponding object
-files:
-
-  Objects $env 'foo.c', 'bar.c';
-
-This will arrange to produce, if necessary, F<foo.o> and F<bar.o>. The
-command invoked is simply C<%CCCOM>, which expands, through substitution,
-to the appropriate external command required to build each object. The
-substitution rules will be discussed in detail in the next section.
-
-The construction variables are also used for other purposes. For example,
-C<CPPPATH> is used to specify a colon-separated path of include
-directories. These are intended to be passed to the C preprocessor and are
-also used by the C-file scanning machinery to determine the dependencies
-involved in a C Compilation.
-
-Variables beginning with underscore are created by various methods,
-and should normally be considered ``internal'' variables. For example,
-when a method is called which calls for the creation of an object from
-a C source, the variable C<_IFLAGS> is created: this corresponds to the
-C<-I> switches required by the C compiler to represent the directories
-specified by C<CPPPATH>.
-
-Note that, for any particular environment, the value of a variable is set
-once, and then never reset (to change a variable, you must create a new
-environment. Methods are provided for copying existing environments for this
-purpose). Some internal variables, such as C<_IFLAGS> are created on demand,
-but once set, they remain fixed for the life of the environment.
-
-The C<CFLAGS>, C<LDFLAGS>, and C<ARFLAGS> variables all supply a place
-for passing options to the compiler, loader, and archiver, respectively.
-
-The C<INCDIRPREFIX> and C<INCDIRSUFFIX> variables specify option
-strings to be appended to the beginning and end, respectively, of each
-include directory so that the compiler knows where to find F<.h> files.
-Similarly, the C<LIBDIRPREFIX> and C<LIBDIRSUFFIX> variables specify the
-option string to be appended to the beginning of and end, respectively,
-of each directory that the linker should search for libraries.
-
-Another variable, C<ENV>, is used to determine the system environment during
-the execution of an external command. By default, the only environment
-variable that is set is C<PATH>, which is the execution path for a UNIX
-command. For the utmost reproducibility, you should really arrange to set
-your own execution path, in your top-level F<Construct> file (or perhaps by
-importing an appropriate construction package with the Perl C<use>
-command). The default variables are intended to get you off the ground.
-
-=head2 Expanding variables in construction commands
-
-Within a construction command, construction variables will be expanded
-according to the rules described above.  In addition to normal variable
-expansion from the construction environment, construction commands also
-expand the following pseudo-variables to insert the specific input and
-output files in the command line that will be executed:
-
-=over 10
-
-=item %>
-
-The target file name.  In a multi-target command, this expands to the
-first target mentioned.)
-
-=item %0
-
-Same as C<%E<gt>>.
-
-=item %1, %2, ..., %9
-
-These refer to the first through ninth input file, respectively.
-
-=item %E<lt>
-
-The full set of input file names. If any of these have been used
-anywhere else in the current command line (via C<%1>, C<%2>, etc.), then
-those will be deleted from the list provided by C<%E<lt>>. Consider the
-following command found in a F<Conscript> file in the F<test> directory:
-
-  Command $env 'tgt', qw(foo bar baz), qq(
-	echo %< -i %1 > %>
-	echo %< -i %2 >> %>
-	echo %< -i %3 >> %>
-  );
-
-If F<tgt> needed to be updated, then this would result in the execution of
-the following commands, assuming that no remapping has been established for
-the F<test> directory:
-
-  echo test/bar test/baz -i test/foo > test/tgt
-  echo test/foo test/baz -i test/bar >> test/tgt
-  echo test/foo test/bar -i test/baz >> test/tgt
-
-=back
-
-Any of the above pseudo-variables may be followed immediately by one of
-the following suffixes to select a portion of the expanded path name:
-
-  :a    the absolute path to the file name
-  :b    the directory plus the file name stripped of any suffix
-  :d    the directory
-  :f    the file name
-  :s    the file name suffix
-  :F    the file name stripped of any suffix
-  :S    the absolute path path to a Linked source file
-
-Continuing with the above example, C<%E<lt>:f> would expand to C<foo bar baz>,
-and C<%E<gt>:d> would expand to C<test>.
-
-There are additional C<%> elements which affect the command line(s):
-
-=over 10
-
-=item %[ %]
-
-It is possible to programmatically rewrite part of the command by
-enclosing part of it between C<%[> and C<%]>.  This will call the
-construction variable named as the first word enclosed in the brackets
-as a Perl code reference; the results of this call will be used to
-replace the contents of the brackets in the command line.  For example,
-given an existing input file named F<tgt.in>:
-
-  @keywords = qw(foo bar baz);
-  $env = new cons(X_COMMA => sub { join(",", @_) });
-  Command $env 'tgt', 'tgt.in', qq(
-	echo '# Keywords: %[X_COMMA @keywords %]' > %>
-	cat %< >> %>
-  );
-
-This will execute:
-
-  echo '# Keywords: foo,bar,baz' > tgt
-  cat tgt.in >> tgt
-
-=item %( %)
-
-Cons includes the text of the command line in the MD5 signature for a
-build, so that targets get rebuilt if you change the command line (to
-add or remove an option, for example).  Command-line text in between
-C<%(> and C<%)>, however, will be ignored for MD5 signature calculation.
-
-Internally, Cons uses C<%(> and C<%)> around include and library
-directory options (C<-I> and C<-L> on UNIX systems, C</I> and
-C</LIBPATH> on Windows NT) to avoid rebuilds just because the directory
-list changes.  Rebuilds occur only if the changed directory list causes
-any included I<files> to change, and a changed include file is detected
-by the MD5 signature calculation on the actual file contents.
-
-=back
-
-=head2 Expanding construction variables in file names
-
-Cons expands construction variables in the source and target file names
-passed to the various construction methods according to the expansion
-rules described above:
-
-  $env = new cons(
-	DESTDIR	=>	'programs',
-	SRCDIR	=>	'src',
-  );
-  Program $env '%DESTDIR/hello', '%SRCDIR/hello.c';
-
-This allows for flexible configuration, through the construction
-environment, of directory names, suffixes, etc.
-
-
-=head1 Build actions
-
-Cons supports several types of B<build actions> that can be performed
-to construct one or more target files.  Usually, a build action is
-a construction command--that is, a command-line string that invokes
-an external command.  Cons can also execute Perl code embedded in a
-command-line string, and even supports an experimental ability to build
-a target file by executing a Perl code reference directly.
-
-A build action is usually specified as the value of a construction
-variable:
-
-  $env = new cons(
-	CCCOM         => '%CC %CFLAGS %_IFLAGS -c %< -o %>',
-	LINKCOM       => '[perl] &link_executable("%>", "%<")',
-	ARCOM         => sub { my($env, $target, @sources) = @_;
-				 # code to create an archive
-				}
-  );
-
-A build action may be associated directly with one or more target files
-via the C<Command> method; see below.
-
-=head2 Construction commands
-
-A construction command goes through expansion of construction variables
-and C<%-> pseudo-variables, as described above, to create the actual
-command line that Cons will execute to generate the target file or
-files.
-
-After substitution occurs, strings of white space are converted into
-single blanks, and leading and trailing white space is eliminated. It
-is therefore currently not possible to introduce variable length white
-space in strings passed into a command.
-
-If a multi-line command string is provided, the commands are executed
-sequentially. If any of the commands fails, then none of the rest are
-executed, and the target is not marked as updated, i.e. a new signature is
-not stored for the target.
-
-Normally, if all the commands succeed, and return a zero status (or whatever
-platform-specific indication of success is required), then a new signature
-is stored for the target. If a command erroneously reports success even
-after a failure, then Cons will assume that the target file created by that
-command is accurate and up-to-date.
-
-The first word of each command string, after expansion, is assumed to be an
-executable command looked up on the C<PATH> environment variable (which is,
-in turn, specified by the C<ENV> construction variable). If this command is
-found on the path, then the target will depend upon it: the command will
-therefore be automatically built, as necessary. It's possible to write
-multi-part commands to some shells, separated by semi-colons. Only the first
-command word will be depended upon, however, so if you write your command
-strings this way, you must either explicitly set up a dependency (with the
-C<Depends> method), or be sure that the command you are using is a system
-command which is expected to be available. If it isn't available, you will,
-of course, get an error.
-
-Cons normally prints a command before executing it.  This behavior is
-suppressed if the first character of the command is C<@>.  Note that
-you may need to separate the C<@> from the command name or escape it to
-prevent C<@cmd> from looking like an array to Perl quote operators that
-perform interpolation:
-
-  # The first command line is incorrect,
-  # because "@cp" looks like an array
-  # to the Perl qq// function.
-  # Use the second form instead.
-  Command $env 'foo', 'foo.in', qq(
-	@cp %< tempfile
-	@ cp tempfile %>
-  );
-
-If there are shell meta characters anywhere in the expanded command line,
-such as C<E<lt>>, C<E<gt>>, quotes, or semi-colon, then the command
-will actually be executed by invoking a shell. This means that a command
-such as:
-
-  cd foo
-
-alone will typically fail, since there is no command C<cd> on the path. But
-the command string:
-
-  cd $<:d; tar cf $>:f $<:f
-
-when expanded will still contain the shell meta character semi-colon, and a
-shell will be invoked to interpret the command. Since C<cd> is interpreted
-by this sub-shell, the command will execute as expected.
-
-=head2 Perl expressions
-
-If any command (even one within a multi-line command) begins with
-C<[perl]>, the remainder of that command line will be evaluated by the
-running Perl instead of being forked by the shell.  If an error occurs
-in parsing the Perl code, or if the Perl expression returns 0 or undef,
-the command will be considered to have failed.  For example, here is a
-simple command which creates a file C<foo> directly from Perl:
-
-  $env = new cons();
-  Command $env 'foo',
-    qq([perl] open(FOO,'>foo');print FOO "hi\\n"; close(FOO); 1);
-
-Note that when the command is executed, you are in the same package as
-when the F<Construct> or F<Conscript> file was read, so you can call
-Perl functions you've defined in the same F<Construct> or F<Conscript>
-file in which the C<Command> appears:
-
-  $env = new cons();
-  sub create_file {
-	my $file = shift;
-	open(FILE, ">$file");
-	print FILE "hi\n";
-	close(FILE);
-	return 1;
-  }
-  Command $env 'foo', "[perl] &create_file('%>')";
-
-The Perl string will be used to generate the signature for the derived
-file, so if you change the string, the file will be rebuilt.  The contents
-of any subroutines you call, however, are not part of the signature,
-so if you modify a called subroutine such as C<create_file> above,
-the target will I<not> be rebuilt.  Caveat user.
-
-=head2 Perl code references [EXPERIMENTAL]
-
-Cons supports the ability to create a derived file by directly executing
-a Perl code reference.  This feature is considered EXPERIMENTAL and
-subject to change in the future.
-
-A code reference may either be a named subroutine referenced by the
-usual C<\&> syntax:
-
-  sub build_output {
-	my($env, $target, @sources) = @_;
-	print "build_output building $target\n";
-	open(OUT, ">$target");
-	foreach $src (@sources) {
-	    if (! open(IN, "<$src")) {
-		print STDERR "cannot open '$src': $!\n";
-		return undef;
-	    }
-	    print OUT, <IN>;
-	}
-	close(OUT);
-	return 1;
-  }
-  Command $env 'output', \&build_output;
-
-or the code reference may be an anonymous subroutine:
-
-  Command $env 'output', sub {
-	my($env, $target, @sources) = @_;
-	print "building $target\n";
-	open(FILE, ">$target");
-	print FILE "hello\n";
-	close(FILE);
-	return 1;
-  };
-
-To build the target file, the referenced subroutine is passed, in order:
-the construction environment used to generate the target; the path
-name of the target itself; and the path names of all the source files
-necessary to build the target file.
-
-The code reference is expected to generate the target file, of course,
-but may manipulate the source and target files in any way it chooses.
-The code reference must return a false value (C<undef> or C<0>) if
-the build of the file failed.  Any true value indicates a successful
-build of the target.
-
-Building target files using code references is considered EXPERIMENTAL
-due to the following current limitations:
-
-=over 4
-
-Cons does I<not> print anything to indicate the code reference is being
-called to build the file.  The only way to give the user any indication
-is to have the code reference explicitly print some sort of "building"
-message, as in the above examples.
-
-Cons does not generate any signatures for code references, so if the
-code in the reference changes, the target will I<not> be rebuilt.
-
-Cons has no public method to allow a code reference to extract
-construction variables.  This would be good to allow generalization of
-code references based on the current construction environment, but would
-also complicate the problem of generating meaningful signatures for code
-references.
-
-=back
-
-Support for building targets via code references has been released in
-this version to encourage experimentation and the seeking of possible
-solutions to the above limitations.
-
-
-=head1 Default construction methods
-
-The list of default construction methods includes the following:
-
-
-=head2 The C<new> constructor
-
-The C<new> method is a Perl object constructor. That is, it is not invoked
-via a reference to an existing construction environment B<reference>, but,
-rather statically, using the name of the Perl B<package> where the
-constructor is defined. The method is invoked like this:
-
-  $env = new cons(<overrides>);
-
-The environment you get back is blessed into the package C<cons>, which
-means that it will have associated with it the default methods described
-below. Individual construction variables can be overridden by providing
-name/value pairs in an override list. Note that to override any command
-environment variable (i.e. anything under C<ENV>), you will have to override
-all of them. You can get around this difficulty by using the C<copy> method
-on an existing construction environment.
-
-
-=head2 The C<clone> method
-
-The C<clone> method creates a clone of an existing construction environment,
-and can be called as in the following example:
-
-  $env2 = $env1->clone(<overrides>);
-
-You can provide overrides in the usual manner to create a different
-environment from the original. If you just want a new name for the same
-environment (which may be helpful when exporting environments to existing
-components), you can just use simple assignment.
-
-
-=head2 The C<copy> method
-
-The C<copy> method extracts the externally defined construction variables
-from an environment and returns them as a list of name/value
-pairs. Overrides can also be provided, in which case, the overridden values
-will be returned, as appropriate. The returned list can be assigned to a
-hash, as shown in the prototype, below, but it can also be manipulated in
-other ways:
-
-  %env = $env1->copy(<overrides>);
-
-The value of C<ENV>, which is itself a hash, is also copied to a new hash,
-so this may be changed without fear of affecting the original
-environment. So, for example, if you really want to override just the
-C<PATH> variable in the default environment, you could do the following:
-
-  %cons = new cons()->copy();
-  $cons{ENV}{PATH} = "<your path here>";
-  $cons = new cons(%cons);
-
-This will leave anything else that might be in the default execution
-environment undisturbed.
-
-
-=head2 The C<Install> method
-
-The C<Install> method arranges for the specified files to be installed in
-the specified directory. The installation is optimized: the file is not
-copied if it can be linked. If this is not the desired behavior, you will
-need to use a different method to install the file. It is called as follows:
-
-  Install $env <directory>, <names>;
-
-Note that, while the files to be installed may be arbitrarily named,
-only the last component of each name is used for the installed target
-name. So, for example, if you arrange to install F<foo/bar> in F<baz>,
-this will create a F<bar> file in the F<baz> directory (not F<foo/bar>).
-
-
-=head2 The C<InstallAs> method
-
-The C<InstallAs> method arranges for the specified source file(s) to be
-installed as the specified target file(s). Multiple files should be
-specified as a file list. The installation is optimized: the file is not
-copied if it can be linked. If this is not the desired behavior, you will
-need to use a different method to install the file. It is called as follows:
-
-C<InstallAs> works in two ways:
-
-Single file install:
-
-  InstallAs $env TgtFile, SrcFile;
-
-Multiple file install:
-
-  InstallAs $env ['tgt1', 'tgt2'], ['src1', 'src2'];
-
-Or, even as:
-
-  @srcs = qw(src1 src2 src3);
-  @tgts = qw(tgt1 tgt2 tgt3);
-  InstallAs $env [@tgts], [@srcs];
-
-Both the target and the sources lists should be of the same length.
-
-=head2 The C<Precious> method
-
-The C<Precious> method asks cons not to delete the specified file or
-list of files before building them again.  It is invoked as:
-
-  Precious <files>;
-
-This is especially useful for allowing incremental updates to libraries
-or debug information files which are updated rather than rebuilt anew each
-time.  Cons will still delete the files when the C<-r> flag is specified.
-
-=head2 The C<AfterBuild> method
-
-The C<AfterBuild> method evaluates the specified perl string after
-building the given file or files (or finding that they are up to date).
-The eval will happen once per specified file.  C<AfterBuild> is called
-as follows:
-
-  AfterBuild $env 'foo.o', qq(print "foo.o is up to date!\n");
-
-The perl string is evaluated in the C<script> package, and has access
-to all variables and subroutines defined in the F<Conscript> file in
-which the C<AfterBuild> method is called.
-
-=head2 The C<Command> method
-
-The C<Command> method is a catchall method which can be used to arrange for
-any build action to be executed to update the target. For this command, a
-target file and list of inputs is provided. In addition, a build action
-is specified as the last argument.  The build action is typically a
-command line or lines, but may also contain Perl code to be executed;
-see the section above on build actions for details.
-
-The C<Command> method is called as follows:
-
-  Command $env <target>, <inputs>, <build action>;
-
-The target is made dependent upon the list of input files specified, and the
-inputs must be built successfully or Cons will not attempt to build the
-target.
-
-To specify a command with multiple targets, you can specify a reference to a
-list of targets. In Perl, a list reference can be created by enclosing a
-list in square brackets. Hence the following command:
-
-  Command $env ['foo.h', 'foo.c'], 'foo.template', q(
-	gen %1
-  );
-
-could be used in a case where the command C<gen> creates two files, both
-F<foo.h> and F<foo.c>.
-
-
-=head2 The C<Objects> method
-
-The C<Objects> method arranges to create the object files that correspond to
-the specified source files. It is invoked as shown below:
-
-  @files = Objects $env <source or object files>;
-
-Under Unix, source files ending in F<.s> and F<.c> are currently
-supported, and will be compiled into a name of the same file ending
-in F<.o>. By default, all files are created by invoking the external
-command which results from expanding the C<CCCOM> construction variable,
-with C<%E<lt>> and C<%E<gt>> set to the source and object files,
-respectively. (See the section above on construction variable expansion
-for details).  The variable C<CPPPATH> is also used when scanning source
-files for dependencies. This is a colon separated list of pathnames, and
-is also used to create the construction variable C<_IFLAGS,> which will
-contain the appropriate list of -C<I> options for the compilation. Any
-relative pathnames in C<CPPPATH> is interpreted relative to the
-directory in which the associated construction environment was created
-(absolute and top-relative names may also be used). This variable is
-used by C<CCCOM>. The behavior of this command can be modified by
-changing any of the variables which are interpolated into C<CCCOM>, such
-as C<CC>, C<CFLAGS>, and, indirectly, C<CPPPATH>. It's also possible
-to replace the value of C<CCCOM>, itself. As a convenience, this file
-returns the list of object filenames.
-
-
-=head2 The C<Program> method
-
-The C<Program> method arranges to link the specified program with the
-specified object files. It is invoked in the following manner:
-
-  Program $env <program name>, <source or object files>;
-
-The program name will have the value of the C<SUFEXE> construction
-variable appended (by default, C<.exe> on Win32 systems, nothing on Unix
-systems) if the suffix is not already present.
-
-Source files may be specified in place of objects files--the C<Objects>
-method will be invoked to arrange the conversion of all the files into
-object files, and hence all the observations about the C<Objects> method,
-above, apply to this method also.
-
-The actual linking of the program will be handled by an external command
-which results from expanding the C<LINKCOM> construction variable, with
-C<%E<lt>> set to the object files to be linked (in the order presented),
-and C<%E<gt>> set to the target. (See the section above on construction
-variable expansion for details.)  The user may set additional variables
-in the construction environment, including C<LINK>, to define which
-program to use for linking, C<LIBPATH>, a colon-separated list of
-library search paths, for use with library specifications of the form
-I<-llib>, and C<LIBS>, specifying the list of libraries to link against
-(in either I<-llib> form or just as pathnames. Relative pathnames in
-both C<LIBPATH> and C<LIBS> are interpreted relative to the directory
-in which the associated construction environment is created (absolute
-and top-relative names may also be used). Cons automatically sets up
-dependencies on any libraries mentioned in C<LIBS>: those libraries will
-be built before the command is linked.
-
-
-=head2 The C<Library> method
-
-The C<Library> method arranges to create the specified library from the
-specified object files. It is invoked as follows:
-
-  Library $env <library name>, <source or object files>;
-
-The library name will have the value of the C<SUFLIB> construction
-variable appended (by default, C<.lib> on Win32 systems, C<.a> on Unix
-systems) if the suffix is not already present.
-
-Source files may be specified in place of objects files--the C<Objects>
-method will be invoked to arrange the conversion of all the files into
-object files, and hence all the observations about the C<Objects> method,
-above, apply to this method also.
-
-The actual creation of the library will be handled by an external
-command which results from expanding the C<ARCOM> construction variable,
-with C<%E<lt>> set to the library members (in the order presented),
-and C<%E<gt>> to the library to be created.  (See the section above
-on construction variable expansion for details.)  The user may set
-variables in the construction environment which will affect the
-operation of the command. These include C<AR>, the archive program
-to use, C<ARFLAGS>, which can be used to modify the flags given to
-the program specified by C<AR>, and C<RANLIB>, the name of a archive
-index generation program, if needed (if the particular need does not
-require the latter functionality, then C<ARCOM> must be redefined to not
-reference C<RANLIB>).
-
-The C<Library> method allows the same library to be specified in multiple
-method invocations. All of the contributing objects from all the invocations
-(which may be from different directories) are combined and generated by a
-single archive command. Note, however, that if you prune a build so that
-only part of a library is specified, then only that part of the library will
-be generated (the rest will disappear!).
-
-
-=head2 The C<Module> method
-
-The C<Module> method is a combination of the C<Program> and C<Command>
-methods. Rather than generating an executable program directly, this command
-allows you to specify your own command to actually generate a module. The
-method is invoked as follows:
-
-  Module $env <module name>, <source or object files>, <construction command>;
-
-This command is useful in instances where you wish to create, for example,
-dynamically loaded modules, or statically linked code libraries.
-
-
-=head2 The C<Depends> method
-
-The C<Depends> method allows you to specify additional dependencies for a
-target.  It is invoked as follows:
-
-  Depends $env <target>, <dependencies>;
-
-This may be occasionally useful, especially in cases where no scanner exists
-(or is writable) for particular types of files. Normally, dependencies are
-calculated automatically from a combination of the explicit dependencies set
-up by the method invocation or by scanning source files.
-
-A set of identical dependencies for multiple targets may be specified
-using a reference to a list of targets. In Perl, a list reference can
-be created by enclosing a list in square brackets. Hence the following
-command:
-
-  Depends $env ['foo', 'bar'], 'input_file_1', 'input_file_2';
-
-specifies that both the F<foo> and F<bar> files depend on the listed
-input files.
-
-
-=head2 The C<RuleSet> method
-
-The C<RuleSet> method returns the construction variables for building
-various components with one of the rule sets supported by Cons.  The
-currently supported rule sets are:
-
-=over 4
-
-=item msvc
-
-Rules for the Microsoft Visual C++ compiler suite.
-
-=item unix
-
-Generic rules for most UNIX-like compiler suites.
-
-=back
-
-On systems with more than one available compiler suite, this allows you
-to easily create side-by-side environments for building software with
-multiple tools:
-
-    $msvcenv = new cons(RuleSet("msvc"));
-    $cygnusenv = new cons(RuleSet("unix"));
-
-In the future, this could also be extended to other platforms that
-have different default rule sets.
-
-
-=head2 The C<DefaultRules> method
-
-The C<DefaultRules> method sets the default construction variables that
-will be returned by the C<new> method to the specified arguments:
-
-  DefaultRules(CC     => 'gcc',
-	       CFLAGS => '',
-	       CCCOM  => '%CC %CFLAGS %_IFLAGS -c %< -o %>');
-  $env = new cons();
-  # $env now contains *only* the CC, CFLAGS,
-  # and CCCOM construction variables
-
-Combined with the C<RuleSet> method, this also provides an easy way
-to set explicitly the default build environment to use some supported
-toolset other than the Cons defaults:
-
-    # use a UNIX-like tool suite (like cygwin) on Win32
-    DefaultRules(RuleSet('unix'));
-    $env = new cons();
-
-Note that the C<DefaultRules> method completely replaces the default
-construction environment with the specified arguments, it does not
-simply override the existing defaults.  To override one or more
-variables in a supported C<RuleSet>, append the variables and values:
-
-  DefaultRules(RuleSet('unix'), CFLAGS => '-O3');
-  $env1 = new cons();
-  $env2 = new cons();
-  # both $env1 and $env2 have 'unix' defaults
-  # with CFLAGS set to '-O3'
-
-
-=head2 The C<Ignore> method
-
-The C<Ignore> method allows you to ignore explicitly dependencies that
-Cons infers on its own.  It is invoked as follows:
-
-  Ignore <patterns>;
-
-This can be used to avoid recompilations due to changes in system header
-files or utilities that are known to not affect the generated targets.
-
-If, for example, a program is built in an NFS-mounted directory on
-multiple systems that have different copies of F<stdio.h>, the differences
-will affect the signatures of all derived targets built from source files
-that C<#include E<lt>stdio.hE<gt>>.  This will cause all those targets to
-be rebuilt when changing systems.  If this is not desirable behavior, then
-the following line will remove the dependencies on the F<stdio.h> file:
-
-  Ignore '^/usr/include/stdio\.h$';
-
-Note that the arguments to the C<Ignore> method are regular expressions,
-so special characters must be escaped and you may wish to anchor the
-beginning or end of the expression with C<^> or C<$> characters.
-
-
-=head2 The C<Salt> method
-
-The C<Salt> method adds a constant value to the signature calculation
-for every derived file.  It is invoked as follows:
-
-  Salt $string;
-
-Changing the Salt value will force a complete rebuild of every derived
-file.  This can be used to force rebuilds in certain desired
-circumstances.  For example,
-
-  Salt `uname -s`;
-
-Would force a complete rebuild of every derived file whenever the
-operating system on which the build is performed (as reported by C<uname
--s>) changes.
-
-
-=head2 The C<UseCache> method
-
-The C<UseCache> method instructs Cons to maintain a cache of derived
-files, to be shared among separate build trees of the same project.
-
-  UseCache("cache/<buildname>") || warn("cache directory not found");
-
-
-=head2 The C<SourcePath> method
-
-The C<SourcePath> mathod returns the real source path name of a file,
-as opposed to the path name within a build directory.  It is invoked
-as follows:
-
-  $path = SourcePath <buildpath>;
-
-
-=head2 The C<ConsPath> method
-
-The C<ConsPath> method returns true if the supplied path is a derivable
-file, and returns undef (false) otherwise.
-It is invoked as follows:
-
-  $result = ConsPath <path>;
-
-
-=head2 The C<SplitPath> method
-
-The C<SplitPath> method looks up multiple path names in a string separated
-by the default path separator for the operating system (':' on UNIX
-systems, ';' on Windows NT), and returns the fully-qualified names.
-It is invoked as follows:
-
-  @paths = SplitPath <pathlist>;
-
-The C<SplitPath> method will convert  names prefixed '#' to the
-appropriate top-level build name (without the '#') and will convert
-relative names to top-level names.
-
-
-=head2 The C<DirPath> method
-
-The C<DirPath> method returns the build path name(s) of a directory or
-list of directories.  It is invoked as follows:
-
-  $cwd = DirPath <paths>;
-
-The most common use for the C<DirPath> method is:
-
-  $cwd = DirPath '.';
-
-to fetch the path to the current directory of a subsidiary F<Conscript>
-file.
-
-
-=head2 The C<FilePath> method
-
-The C<FilePath> method returns the build path name(s) of a file or
-list of files.  It is invoked as follows:
-
-  $file = FilePath <path>;
-
-
-=head2 The C<Help> method
-
-The C<Help> method specifies help text that will be displayed when the
-user invokes C<cons -h>.  This can be used to provide documentation
-of specific targets, values, build options, etc. for the build tree.
-It is invoked as follows:
-
-  Help <helptext>;
-
-The C<Help> method may only be called once, and should typically be
-specified in the top-level F<Construct> file.
-
-
-=head1 Extending Cons
-
-
-=head2 Overriding construction variables
-
-There are several ways of extending Cons, which vary in degree of
-difficulty. The simplest method is to define your own construction
-environment, based on the default environment, but modified to reflect your
-particular needs. This will often suffice for C-based applications. You can
-use the C<new> constructor, and the C<clone> and C<copy> methods to create
-hybrid environments. These changes can be entirely transparent to the
-underlying F<Conscript> files.
-
-
-=head2 Adding new methods
-
-For slightly more demanding changes, you may wish to add new methods to the
-C<cons> package. Here's an example of a very simple extension,
-C<InstallScript>, which installs a tcl script in a requested location, but
-edits the script first to reflect a platform-dependent path that needs to be
-installed in the script:
-
-  # cons::InstallScript - Create a platform dependent version of a shell
-  # script by replacing string ``#!your-path-here'' with platform specific
-  # path $BIN_DIR.
-
-  sub cons::InstallScript {
-	my ($env, $dst, $src) = @_;
-	Command $env $dst, $src, qq(
-		sed s+your-path-here+$BIN_DIR+ %< > %>
-		chmod oug+x %>
-	);
-  }
-
-Notice that this method is defined directly in the C<cons> package (by
-prefixing the name with C<cons::>). A change made in this manner will be
-globally visible to all environments, and could be called as in the
-following example:
-
-  InstallScript $env "$BIN/foo", "foo.tcl";
-
-For a small improvement in generality, the C<BINDIR> variable could be
-passed in as an argument or taken from the construction environment--as
-C<%BINDIR>.
-
-
-=head2 Overriding methods
-
-Instead of adding the method to the C<cons> name space, you could define a
-new package which inherits existing methods from the C<cons> package and
-overrides or adds others. This can be done using Perl's inheritance
-mechanisms.
-
-The following example defines a new package C<cons::switch> which
-overrides the standard C<Library> method. The overridden method builds
-linked library modules, rather than library archives. A new
-constructor is provided. Environments created with this constructor
-will have the new library method; others won't.
-
-  package cons::switch;
-  BEGIN {@ISA = 'cons'}
-
-  sub new {
-	shift;
-	bless new cons(@_);
-  }
-
-  sub Library {
-	my($env) = shift;
-	my($lib) = shift;
-	my(@objs) = Objects $env @_;
-	Command $env $lib, @objs, q(
-		%LD -r %LDFLAGS %< -o %>
-	);
-  }
-
-This functionality could be invoked as in the following example:
-
-  $env = new cons::switch(@overrides);
-  ...
-  Library $env 'lib.o', 'foo.c', 'bar.c';
-
-
-=head1 Invoking Cons
-
-The C<cons> command is usually invoked from the root of the build tree. A
-F<Construct> file must exist in that directory. If the C<-f> argument is
-used, then an alternate F<Construct> file may be used (and, possibly, an
-alternate root, since C<cons> will cd to F<Construct> file's containing
-directory).
-
-If C<cons> is invoked from a child of the root of the build tree with
-the C<-t> argument, it will walk up the directory hierarchy looking for a
-F<Construct> file.  (An alternate name may still be specified with C<-f>.)
-The targets supplied on the command line will be modified to be relative
-to the discovered F<Construct> file.  For example, from a directory
-containing a top-level F<Construct> file, the following invocation:
-
-  % cd libfoo/subdir
-  % cons -t target
-
-is exactly equivalent to:
-
-  % cons libfoo/subdir/target
-
-If there are any C<Default> targets specified in the directory hierarchy's
-F<Construct> or F<Conscript> files, only the default targets at or below
-the directory from which C<cons -t> was invoked will be built.
-
-The command is invoked as follows:
-
-  cons <arguments> -- <construct-args>
-
-where I<arguments> can be any of the following, in any order:
-
-=over 10
-
-=item I<target>
-
-Build the specified target. If I<target> is a directory, then recursively
-build everything within that directory.
-
-=item I<+pattern>
-
-Limit the F<Conscript> files considered to just those that match I<pattern>,
-which is a Perl regular expression. Multiple C<+> arguments are accepted.
-
-=item I<name>=<val>
-
-Sets I<name> to value I<val> in the C<ARG> hash passed to the top-level
-F<Construct> file.
-
-=item C<-cc>
-
-Show command that would have been executed, when retrieving from cache. No
-indication that the file has been retrieved is given; this is useful for
-generating build logs that can be compared with real build logs.
-
-=item C<-cd>
-
-Disable all caching. Do not retrieve from cache nor flush to cache.
-
-=item C<-cr>
-
-Build dependencies in random order. This is useful when building multiple
-similar trees with caching enabled.
-
-=item C<-cs>
-
-Synchronize existing build targets that are found to be up-to-date with
-cache. This is useful if caching has been disabled with -cc or just recently
-enabled with UseCache.
-
-=item C<-d>
-
-Enable dependency debugging.
-
-=item C<-f> <file>
-
-Use the specified file instead of F<Construct> (but first change to
-containing directory of I<file>).
-
-=item C<-h>
-
-Show a help message local to the current build if one such is defined, and
-exit.
-
-=item C<-k>
-
-Keep going as far as possible after errors.
-
-=item C<-o> <file>
-
-Read override file I<file>.
-
-=item C<-p>
-
-Show construction products in specified trees. No build is attempted.
-
-=item C<-pa>
-
-Show construction products and associated actions. No build is attempted.
-
-=item C<-pw>
-
-Show products and where they are defined. No build is attempted.
-
-=item C<-q>
-
-Make the build quiet.  Multiple C<-q> options may be specified.
-
-A single C<-q> options suppress messages about Installing and Removing
-targets.
-
-Two C<-q> options suppress build command lines and target up-to-date
-messages.
-
-=item C<-r>
-
-Remove construction products associated with <targets>. No build is
-attempted.
-
-=item C<-R> <repos>
-
-Search for files in I<repos>.  Multiple B<-R> I<repos> directories are
-searched in the order specified.
-
-=item C<-S> <pkg>
-
-Use the sig::<pkg> package to calculate.  Supported <pkg> values
-include "md5" for MD5 signature calculation and "md5::debug" for debug
-information about MD5 signature calculation.
-
-If the specified package ends in <::debug>, signature debug information
-will be printed to the file name specified in the C<CONS_SIG_DEBUG>
-environment variable, or to standard output if the environment variable
-is not set.
-
-=item C<-t>
-
-Traverse up the directory hierarchy looking for a F<Construct> file,
-if none exists in the current directory.  Targets will be modified to
-be relative to the F<Construct> file.
-
-Internally, C<cons> will change its working directory to the directory
-which contains the top-level F<Construct> file and report:
-
-  cons: Entering directory `top-level-directory'
-
-This message indicates to an invoking editor (such as emacs) or build
-environment that Cons will now report all file names relative to the
-top-level directory.  This message can not be suppressed with the C<-q>
-option.
-
-=item C<-v>
-
-Show C<cons> version and continue processing.
-
-=item C<-V>
-
-Show C<cons> version and exit.
-
-=item C<-wf> <file>
-
-Write all filenames considered into I<file>.
-
-=item C<-x>
-
-Show a help message similar to this one, and exit.
-
-=back
-
-And I<construct-args> can be any arguments that you wish to process in the
-F<Construct> file. Note that there should be a B<--> separating the arguments
-to cons and the arguments that you wish to process in the F<Construct> file.
-
-Processing of I<construct-args> can be done by any standard package like
-B<Getopt> or its variants, or any user defined package. B<cons> will pass in
-the I<construct-args> as B<@ARGV> and will not attempt to interpret anything
-after the B<-->.
-
-  % cons -R /usr/local/repository -d os=solaris +driver -- -c test -f DEBUG
-
-would pass the following to cons
-
-  -R /usr/local/repository -d os=solaris +driver
-
-and the following, to the top level F<Construct> file as B<@ARGV>
-
-  -c test -f DEBUG
-
-Note that C<cons -r .> is equivalent to a full recursive C<make clean>,
-but requires no support in the F<Construct> file or any F<Conscript>
-files. This is most useful if you are compiling files into source
-directories (if you separate the F<build> and F<export> directories,
-then you can just remove the directories).
-
-The options C<-p>, C<-pa>, and C<-pw> are extremely useful for use as an aid
-in reading scripts or debugging them. If you want to know what script
-installs F<export/include/foo.h>, for example, just type:
-
-  % cons -pw export/include/foo.h
-
-
-=head1 Using and writing dependency scanners
-
-QuickScan allows simple target-independent scanners to be set up for
-source files. Only one QuickScan scanner may be associated with any given
-source file and environment, although the same scanner may (and should)
-be used for multiple files of a given type.
-
-A QuickScan scanner is only ever invoked once for a given source file,
-and it is only invoked if the file is used by some target in the tree
-(i.e., there is a dependency on the source file).
-
-QuickScan is invoked as follows:
-
-  QuickScan CONSENV CODEREF, FILENAME [, PATH]
-
-The subroutine referenced by CODEREF is expected to return a list of
-filenames included directly by FILE. These filenames will, in turn, be
-scanned. The optional PATH argument supplies a lookup path for finding
-FILENAME and/or files returned by the user-supplied subroutine.  The PATH
-may be a reference to an array of lookup-directory names, or a string of
-names separated by the system's separator character (':' on UNIX systems,
-';' on Windows NT).
-
-The subroutine is called once for each line in the file, with $_ set to the
-current line. If the subroutine needs to look at additional lines, or, for
-that matter, the entire file, then it may read them itself, from the
-filehandle SCAN. It may also terminate the loop, if it knows that no further
-include information is available, by closing the filehandle.
-
-Whether or not a lookup path is provided, QuickScan first tries to lookup
-the file relative to the current directory (for the top-level file
-supplied directly to QuickScan), or from the directory containing the
-file which referenced the file. This is not very general, but seems good
-enough--especially if you have the luxury of writing your own utilities
-and can control the use of the search path in a standard way.
-
-Here's a real example, taken from a F<Construct> file here:
-
-  sub cons::SMFgen {
-      my($env, @tables) = @_;
-      foreach $t (@tables) {
-	  $env->QuickScan(sub { /\b\S*?\.smf\b/g }, "$t.smf",
-			  $env->{SMF_INCLUDE_PATH});
-	  $env->Command(["$t.smdb.cc","$t.smdb.h","$t.snmp.cc",
-			 "$t.ami.cc", "$t.http.cc"], "$t.smf",
-			q(smfgen %( %SMF_INCLUDE_OPT %) %<));
-      }
-  }
-
-The subroutine above finds all names of the form <name>.smf in the
-file. It will return the names even if they're found within comments,
-but that's OK (the mechanism is forgiving of extra files; they're just
-ignored on the assumption that the missing file will be noticed when
-the program, in this example, smfgen, is actually invoked).
-
-[NOTE that the form C<$env-E<gt>QuickScan ...>  and C<$env-E<gt>Command
-...> should not be necessary, but, for some reason, is required
-for this particular invocation. This appears to be a bug in Perl or
-a misunderstanding on my part; this invocation style does not always
-appear to be necessary.]
-
-Here is another way to build the same scanner. This one uses an
-explicit code reference, and also (unnecessarily, in this case) reads
-the whole file itself:
-
-  sub myscan {
-      my(@includes);
-      do {
-	  push(@includes, /\b\S*?\.smf\b/g);
-      } while <SCAN>;
-      @includes
-  }
-
-Note that the order of the loop is reversed, with the loop test at the
-end. This is because the first line is already read for you. This scanner
-can be attached to a source file by:
-
-  QuickScan $env \&myscan, "$_.smf";
-
-This final example, which scans a different type of input file, takes
-over the file scanning rather than being called for each input line:
-
-  $env->QuickScan(
-      sub { my(@includes) = ();
-	  do {
-	     push(@includes, $3)
-		 if /^(#include|import)\s+(\")(.+)(\")/ && $3
-	  } while <SCAN>;
-	  @includes
-      },
-      "$idlFileName",
-      "$env->{CPPPATH};$BUILD/ActiveContext/ACSCLientInterfaces"
-  );
-
-=head1 SUPPORT AND SUGGESTIONS
-
-Cons is maintained by the user community.  To subscribe, send mail to
-B<cons-discuss-request@gnu.org> with body B<subscribe>.
-
-Please report any suggestions through the B<cons-discuss@gnu.org> mailing
-list.
-
-=head1 BUGS
-
-Sure to be some. Please report any bugs through the B<bug-cons@gnu.org>
-mailing list.
-
-=head1 INFORMATION ABOUT CONS
-
-Information about CONS can be obtained from the official cons web site
-B<http://www.dsmit.com/cons/> or its mirrors listed there.
-
-The cons maintainers can be contacted by email at
-B<cons-maintainers@gnu.org>
-
-=head1 AUTHORS
-
-Originally by Bob Sidebotham. Then significantly enriched by the members
-of the Cons community B<cons-discuss@gnu.org>.
-
-The Cons community would like to thank Ulrich Pfeifer for the original pod
-documentation derived from the F<cons.html> file. Cons documentation is now
-a part of the program itself.
-
-=cut
-