diff options
| author | tma <tma@edf5b092-35ff-0310-97b2-ce42778d08ea> | 2005-09-25 21:46:55 +0000 |
|---|---|---|
| committer | tma <tma@edf5b092-35ff-0310-97b2-ce42778d08ea> | 2005-09-25 21:46:55 +0000 |
| commit | 2202e36a35f4534b340b45b876482b1f6bf2a955 (patch) | |
| tree | 61fd750d0cce1880af7a341a3da5e8e3032fcf96 | |
| parent | 486c79d7d9de397c30c9668a84a68d72ab366d67 (diff) | |
| download | ioquake3-aero-2202e36a35f4534b340b45b876482b1f6bf2a955.tar.gz ioquake3-aero-2202e36a35f4534b340b45b876482b1f6bf2a955.zip | |
* Removed stray cons script
git-svn-id: svn://svn.icculus.org/quake3/trunk@106 edf5b092-35ff-0310-97b2-ce42778d08ea
| -rwxr-xr-x | code/unix/pcons-2.3.1 | 7911 |
1 files changed, 0 insertions, 7911 deletions
diff --git a/code/unix/pcons-2.3.1 b/code/unix/pcons-2.3.1 deleted file mode 100755 index 550297f..0000000 --- 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 - |