| # Copyright (C) 2003-2014 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, 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. If not, see <http://www.gnu.org/licenses/>. |
| |
| package Automake::Variable; |
| |
| use 5.006; |
| use strict; |
| use Carp; |
| |
| use Automake::Channels; |
| use Automake::ChannelDefs; |
| use Automake::Configure_ac; |
| use Automake::Item; |
| use Automake::VarDef; |
| use Automake::Condition qw (TRUE FALSE); |
| use Automake::DisjConditions; |
| use Automake::General 'uniq'; |
| use Automake::Wrap 'makefile_wrap'; |
| |
| require Exporter; |
| use vars '@ISA', '@EXPORT', '@EXPORT_OK'; |
| @ISA = qw/Automake::Item Exporter/; |
| @EXPORT = qw (err_var msg_var msg_cond_var reject_var |
| var rvar vardef rvardef |
| variables |
| scan_variable_expansions check_variable_expansions |
| variable_delete |
| variables_dump |
| set_seen |
| require_variables |
| variable_value |
| output_variables |
| transform_variable_recursively); |
| |
| =head1 NAME |
| |
| Automake::Variable - support for variable definitions |
| |
| =head1 SYNOPSIS |
| |
| use Automake::Variable; |
| use Automake::VarDef; |
| |
| # Defining a variable. |
| Automake::Variable::define($varname, $owner, $type, |
| $cond, $value, $comment, |
| $where, $pretty) |
| |
| # Looking up a variable. |
| my $var = var $varname; |
| if ($var) |
| { |
| ... |
| } |
| |
| # Looking up a variable that is assumed to exist. |
| my $var = rvar $varname; |
| |
| # The list of conditions where $var has been defined. |
| # ($var->conditions is an Automake::DisjConditions, |
| # $var->conditions->conds is a list of Automake::Condition.) |
| my @conds = $var->conditions->conds |
| |
| # Access to the definition in Condition $cond. |
| # $def is an Automake::VarDef. |
| my $def = $var->def ($cond); |
| if ($def) |
| { |
| ... |
| } |
| |
| # When the conditional definition is assumed to exist, use |
| my $def = $var->rdef ($cond); |
| |
| |
| =head1 DESCRIPTION |
| |
| This package provides support for Makefile variable definitions. |
| |
| An C<Automake::Variable> is a variable name associated to possibly |
| many conditional definitions. These definitions are instances |
| of C<Automake::VarDef>. |
| |
| Therefore obtaining the value of a variable under a given |
| condition involves two lookups. One to look up the variable, |
| and one to look up the conditional definition: |
| |
| my $var = var $name; |
| if ($var) |
| { |
| my $def = $var->def ($cond); |
| if ($def) |
| { |
| return $def->value; |
| } |
| ... |
| } |
| ... |
| |
| When it is known that the variable and the definition |
| being looked up exist, the above can be simplified to |
| |
| return var ($name)->def ($cond)->value; # Do not write this. |
| |
| but is better written |
| |
| return rvar ($name)->rdef ($cond)->value; |
| |
| or even |
| |
| return rvardef ($name, $cond)->value; |
| |
| The I<r> variants of the C<var>, C<def>, and C<vardef> methods add an |
| extra test to ensure that the lookup succeeded, and will diagnose |
| failures as internal errors (with a message which is much more |
| informative than Perl's warning about calling a method on a |
| non-object). |
| |
| =cut |
| |
| my $_VARIABLE_CHARACTERS = '[.A-Za-z0-9_@]+'; |
| my $_VARIABLE_PATTERN = '^' . $_VARIABLE_CHARACTERS . "\$"; |
| my $_VARIABLE_RECURSIVE_PATTERN = |
| '^([.A-Za-z0-9_@]|\$[({]' . $_VARIABLE_CHARACTERS . '[})]?)+' . "\$"; |
| |
| # The order in which variables should be output. (May contain |
| # duplicates -- only the first occurrence matters.) |
| my @_var_order; |
| |
| # This keeps track of all variables defined by &_gen_varname. |
| # $_gen_varname{$base} is a hash for all variables defined with |
| # prefix '$base'. Values stored in this hash are the variable names. |
| # Keys have the form "(COND1)VAL1(COND2)VAL2..." where VAL1 and VAL2 |
| # are the values of the variable for condition COND1 and COND2. |
| my %_gen_varname = (); |
| # $_gen_varname_n{$base} is the number of variables generated by |
| # _gen_varname() for $base. This is not the same as keys |
| # %{$_gen_varname{$base}} because %_gen_varname may also contain |
| # variables not generated by _gen_varname. |
| my %_gen_varname_n = (); |
| |
| # Declare the macros that define known variables, so we can |
| # hint the user if she try to use one of these variables. |
| |
| # Macros accessible via aclocal. |
| my %_am_macro_for_var = |
| ( |
| CCAS => 'AM_PROG_AS', |
| CCASFLAGS => 'AM_PROG_AS', |
| EMACS => 'AM_PATH_LISPDIR', |
| GCJ => 'AM_PROG_GCJ', |
| LEX => 'AM_PROG_LEX', |
| LIBTOOL => 'LT_INIT', |
| lispdir => 'AM_PATH_LISPDIR', |
| pkgpyexecdir => 'AM_PATH_PYTHON', |
| pkgpythondir => 'AM_PATH_PYTHON', |
| pyexecdir => 'AM_PATH_PYTHON', |
| PYTHON => 'AM_PATH_PYTHON', |
| pythondir => 'AM_PATH_PYTHON', |
| ); |
| |
| # Macros shipped with Autoconf. |
| my %_ac_macro_for_var = |
| ( |
| ALLOCA => 'AC_FUNC_ALLOCA', |
| CC => 'AC_PROG_CC', |
| CFLAGS => 'AC_PROG_CC', |
| CXX => 'AC_PROG_CXX', |
| CXXFLAGS => 'AC_PROG_CXX', |
| F77 => 'AC_PROG_F77', |
| FFLAGS => 'AC_PROG_F77', |
| FC => 'AC_PROG_FC', |
| FCFLAGS => 'AC_PROG_FC', |
| OBJC => 'AC_PROG_OBJC', |
| OBJCFLAGS => 'AC_PROG_OBJC', |
| OBJCXX => 'AC_PROG_OBJCXX', |
| OBJCXXFLAGS => 'AC_PROG_OBJCXX', |
| RANLIB => 'AC_PROG_RANLIB', |
| UPC => 'AM_PROG_UPC', |
| UPCFLAGS => 'AM_PROG_UPC', |
| YACC => 'AC_PROG_YACC', |
| ); |
| |
| # The name of the configure.ac file. |
| my $configure_ac; |
| |
| # Variables that can be overridden without complaint from -Woverride |
| my %_silent_variable_override = |
| (AM_MAKEINFOHTMLFLAGS => 1, |
| AR => 1, |
| ARFLAGS => 1, |
| DEJATOOL => 1, |
| JAVAC => 1, |
| JAVAROOT => 1); |
| |
| # Count of helper variables used to implement conditional '+='. |
| my $_appendvar; |
| |
| # Each call to C<Automake::Variable::traverse_recursively> gets an |
| # unique label. This is used to detect recursively defined variables. |
| my $_traversal = 0; |
| |
| |
| =head2 Error reporting functions |
| |
| In these functions, C<$var> can be either a variable name, or |
| an instance of C<Automake::Variable>. |
| |
| =over 4 |
| |
| =item C<err_var ($var, $message, [%options])> |
| |
| Uncategorized errors about variables. |
| |
| =cut |
| |
| sub err_var ($$;%) |
| { |
| msg_var ('error', @_); |
| } |
| |
| =item C<msg_cond_var ($channel, $cond, $var, $message, [%options])> |
| |
| Messages about conditional variable. |
| |
| =cut |
| |
| sub msg_cond_var ($$$$;%) |
| { |
| my ($channel, $cond, $var, $msg, %opts) = @_; |
| my $v = ref ($var) ? $var : rvar ($var); |
| msg $channel, $v->rdef ($cond)->location, $msg, %opts; |
| } |
| |
| =item C<msg_var ($channel, $var, $message, [%options])> |
| |
| Messages about variables. |
| |
| =cut |
| |
| sub msg_var ($$$;%) |
| { |
| my ($channel, $var, $msg, %opts) = @_; |
| my $v = ref ($var) ? $var : rvar ($var); |
| # Don't know which condition is concerned. Pick any. |
| my $cond = $v->conditions->one_cond; |
| msg_cond_var $channel, $cond, $v, $msg, %opts; |
| } |
| |
| =item C<$bool = reject_var ($varname, $error_msg)> |
| |
| Bail out with C<$error_msg> if a variable with name C<$varname> has |
| been defined. |
| |
| Return true iff C<$varname> is defined. |
| |
| =cut |
| |
| sub reject_var ($$) |
| { |
| my ($var, $msg) = @_; |
| my $v = var ($var); |
| if ($v) |
| { |
| err_var $v, $msg; |
| return 1; |
| } |
| return 0; |
| } |
| |
| =back |
| |
| =head2 Administrative functions |
| |
| =over 4 |
| |
| =item C<Automake::Variable::hook ($varname, $fun)> |
| |
| Declare a function to be called whenever a variable |
| named C<$varname> is defined or redefined. |
| |
| C<$fun> should take two arguments: C<$type> and C<$value>. |
| When type is C<''> or <':'>, C<$value> is the value being |
| assigned to C<$varname>. When C<$type> is C<'+'>, C<$value> |
| is the value being appended to C<$varname>. |
| |
| =cut |
| |
| use vars '%_hooks'; |
| sub hook ($$) |
| { |
| my ($var, $fun) = @_; |
| $_hooks{$var} = $fun; |
| } |
| |
| =item C<variables ([$suffix])> |
| |
| Returns the list of all L<Automake::Variable> instances. (I.e., all |
| variables defined so far.) If C<$suffix> is supplied, return only |
| the L<Automake::Variable> instances that ends with C<_$suffix>. |
| |
| =cut |
| |
| use vars '%_variable_dict', '%_primary_dict'; |
| sub variables (;$) |
| { |
| my ($suffix) = @_; |
| my @vars = (); |
| if ($suffix) |
| { |
| if (exists $_primary_dict{$suffix}) |
| { |
| @vars = values %{$_primary_dict{$suffix}}; |
| } |
| } |
| else |
| { |
| @vars = values %_variable_dict; |
| } |
| # The behaviour of the 'sort' built-in is undefined in scalar |
| # context, hence we need an ad-hoc handling for such context. |
| return wantarray ? sort { $a->name cmp $b->name } @vars : scalar @vars; |
| } |
| |
| =item C<Automake::Variable::reset> |
| |
| The I<forget all> function. Clears all know variables and reset some |
| other internal data. |
| |
| =cut |
| |
| sub reset () |
| { |
| %_variable_dict = (); |
| %_primary_dict = (); |
| $_appendvar = 0; |
| @_var_order = (); |
| %_gen_varname = (); |
| %_gen_varname_n = (); |
| $_traversal = 0; |
| } |
| |
| =item C<var ($varname)> |
| |
| Return the C<Automake::Variable> object for the variable |
| named C<$varname> if defined. Return 0 otherwise. |
| |
| =cut |
| |
| sub var ($) |
| { |
| my ($name) = @_; |
| return $_variable_dict{$name} if exists $_variable_dict{$name}; |
| return 0; |
| } |
| |
| =item C<vardef ($varname, $cond)> |
| |
| Return the C<Automake::VarDef> object for the variable named |
| C<$varname> if defined in condition C<$cond>. Return false |
| if the condition or the variable does not exist. |
| |
| =cut |
| |
| sub vardef ($$) |
| { |
| my ($name, $cond) = @_; |
| my $var = var $name; |
| return $var && $var->def ($cond); |
| } |
| |
| # Create the variable if it does not exist. |
| # This is used only by other functions in this package. |
| sub _cvar ($) |
| { |
| my ($name) = @_; |
| my $v = var $name; |
| return $v if $v; |
| return _new Automake::Variable $name; |
| } |
| |
| =item C<rvar ($varname)> |
| |
| Return the C<Automake::Variable> object for the variable named |
| C<$varname>. Abort with an internal error if the variable was not |
| defined. |
| |
| The I<r> in front of C<var> stands for I<required>. One |
| should call C<rvar> to assert the variable's existence. |
| |
| =cut |
| |
| sub rvar ($) |
| { |
| my ($name) = @_; |
| my $v = var $name; |
| prog_error ("undefined variable $name\n" . &variables_dump) |
| unless $v; |
| return $v; |
| } |
| |
| =item C<rvardef ($varname, $cond)> |
| |
| Return the C<Automake::VarDef> object for the variable named |
| C<$varname> if defined in condition C<$cond>. Abort with an internal |
| error if the condition or the variable does not exist. |
| |
| =cut |
| |
| sub rvardef ($$) |
| { |
| my ($name, $cond) = @_; |
| return rvar ($name)->rdef ($cond); |
| } |
| |
| =back |
| |
| =head2 Methods |
| |
| C<Automake::Variable> is a subclass of C<Automake::Item>. See |
| that package for inherited methods. |
| |
| Here are the methods specific to the C<Automake::Variable> instances. |
| Use the C<define> function, described latter, to create such objects. |
| |
| =over 4 |
| |
| =cut |
| |
| # Create Automake::Variable objects. This is used |
| # only in this file. Other users should use |
| # the "define" function. |
| sub _new ($$) |
| { |
| my ($class, $name) = @_; |
| my $self = Automake::Item::new ($class, $name); |
| $self->{'scanned'} = 0; |
| $self->{'last-append'} = []; # helper variable for last conditional append. |
| $_variable_dict{$name} = $self; |
| if ($name =~ /_([[:alnum:]]+)$/) |
| { |
| $_primary_dict{$1}{$name} = $self; |
| } |
| return $self; |
| } |
| |
| # _check_ambiguous_condition ($SELF, $COND, $WHERE) |
| # ------------------------------------------------- |
| # Check for an ambiguous conditional. This is called when a variable |
| # is being defined conditionally. If we already know about a |
| # definition that is true under the same conditions, then we have an |
| # ambiguity. |
| sub _check_ambiguous_condition ($$$) |
| { |
| my ($self, $cond, $where) = @_; |
| my $var = $self->name; |
| my ($message, $ambig_cond) = $self->conditions->ambiguous_p ($var, $cond); |
| |
| # We allow silent variables to be overridden silently, |
| # by either silent or non-silent variables. |
| my $def = $self->def ($ambig_cond); |
| if ($message && $def->pretty != VAR_SILENT) |
| { |
| msg 'syntax', $where, "$message ...", partial => 1; |
| msg_var ('syntax', $var, "... '$var' previously defined here"); |
| verb ($self->dump); |
| } |
| } |
| |
| =item C<$bool = $var-E<gt>check_defined_unconditionally ([$parent, $parent_cond])> |
| |
| Warn if the variable is conditionally defined. C<$parent> is the name |
| of the parent variable, and C<$parent_cond> the condition of the parent |
| definition. These two variables are used to display diagnostics. |
| |
| =cut |
| |
| sub check_defined_unconditionally ($;$$) |
| { |
| my ($self, $parent, $parent_cond) = @_; |
| |
| if (!$self->conditions->true) |
| { |
| if ($parent) |
| { |
| msg_cond_var ('unsupported', $parent_cond, $parent, |
| "automake does not support conditional definition of " |
| . $self->name . " in $parent"); |
| } |
| else |
| { |
| msg_var ('unsupported', $self, |
| "automake does not support " . $self->name |
| . " being defined conditionally"); |
| } |
| } |
| } |
| |
| =item C<$str = $var-E<gt>output ([@conds])> |
| |
| Format all the definitions of C<$var> if C<@cond> is not specified, |
| else only that corresponding to C<@cond>. |
| |
| =cut |
| |
| sub output ($@) |
| { |
| my ($self, @conds) = @_; |
| |
| @conds = $self->conditions->conds |
| unless @conds; |
| |
| my $res = ''; |
| my $name = $self->name; |
| |
| foreach my $cond (@conds) |
| { |
| my $def = $self->def ($cond); |
| prog_error ("unknown condition '" . $cond->human . "' for '" |
| . $self->name . "'") |
| unless $def; |
| |
| next |
| if $def->pretty == VAR_SILENT; |
| |
| $res .= $def->comment; |
| |
| my $val = $def->raw_value; |
| my $equals = $def->type eq ':' ? ':=' : '='; |
| my $str = $cond->subst_string; |
| |
| |
| if ($def->pretty == VAR_ASIS) |
| { |
| my $output_var = "$name $equals $val"; |
| $output_var =~ s/^/$str/meg; |
| $res .= "$output_var\n"; |
| } |
| elsif ($def->pretty == VAR_PRETTY) |
| { |
| # Suppress escaped new lines. &makefile_wrap will |
| # add them back, maybe at other places. |
| $val =~ s/\\$//mg; |
| my $wrap = makefile_wrap ("$str$name $equals", "$str\t", |
| split (' ', $val)); |
| |
| # If the last line of the definition is made only of |
| # @substitutions@, append an empty variable to make sure it |
| # cannot be substituted as a blank line (that would confuse |
| # HP-UX Make). |
| $wrap = makefile_wrap ("$str$name $equals", "$str\t", |
| split (' ', $val), '$(am__empty)') |
| if $wrap =~ /\n(\s*@\w+@)+\s*$/; |
| |
| $res .= $wrap; |
| } |
| else # ($def->pretty == VAR_SORTED) |
| { |
| # Suppress escaped new lines. &makefile_wrap will |
| # add them back, maybe at other places. |
| $val =~ s/\\$//mg; |
| $res .= makefile_wrap ("$str$name $equals", "$str\t", |
| sort (split (' ' , $val))); |
| } |
| } |
| return $res; |
| } |
| |
| =item C<@values = $var-E<gt>value_as_list ($cond, [$parent, $parent_cond])> |
| |
| Get the value of C<$var> as a list, given a specified condition, |
| without recursing through any subvariables. |
| |
| C<$cond> is the condition of interest. C<$var> does not need |
| to be defined for condition C<$cond> exactly, but it needs |
| to be defined for at most one condition implied by C<$cond>. |
| |
| C<$parent> and C<$parent_cond> designate the name and the condition |
| of the parent variable, i.e., the variable in which C<$var> is |
| being expanded. These are used in diagnostics. |
| |
| For example, if C<A> is defined as "C<foo $(B) bar>" in condition |
| C<TRUE>, calling C<rvar ('A')->value_as_list (TRUE)> will return |
| C<("foo", "$(B)", "bar")>. |
| |
| =cut |
| |
| sub value_as_list ($$;$$) |
| { |
| my ($self, $cond, $parent, $parent_cond) = @_; |
| my @result; |
| |
| # Get value for given condition |
| my $onceflag; |
| foreach my $vcond ($self->conditions->conds) |
| { |
| if ($vcond->true_when ($cond)) |
| { |
| # If there is more than one definitions of $var matching |
| # $cond then we are in trouble: tell the user we need a |
| # paddle. Continue by merging results from all conditions, |
| # although it doesn't make much sense. |
| $self->check_defined_unconditionally ($parent, $parent_cond) |
| if $onceflag; |
| $onceflag = 1; |
| |
| my $val = $self->rdef ($vcond)->value; |
| push @result, split (' ', $val); |
| } |
| } |
| return @result; |
| } |
| |
| =item C<@values = $var-E<gt>value_as_list_recursive ([%options])> |
| |
| Return the contents of C<$var> as a list, split on whitespace. This |
| will recursively follow C<$(...)> and C<${...}> inclusions. It |
| preserves C<@...@> substitutions. |
| |
| C<%options> is a list of option for C<Variable::traverse_recursively> |
| (see this method). The most useful is C<cond_filter>: |
| |
| $var->value_as_list_recursive (cond_filter => $cond) |
| |
| will return the contents of C<$var> and any subvariable in all |
| conditions implied by C<$cond>. |
| |
| C<%options> can also carry options specific to C<value_as_list_recursive>. |
| Presently, the only such option is C<location =E<gt> 1> which instructs |
| C<value_as_list_recursive> to return a list of C<[$location, @values]> pairs. |
| |
| =cut |
| |
| sub value_as_list_recursive ($;%) |
| { |
| my ($var, %options) = @_; |
| |
| return $var->traverse_recursively |
| (# Construct [$location, $value] pairs if requested. |
| sub { |
| my ($var, $val, $cond, $full_cond) = @_; |
| return [$var->rdef ($cond)->location, $val] if $options{'location'}; |
| return $val; |
| }, |
| # Collect results. |
| sub { |
| my ($var, $parent_cond, @allresults) = @_; |
| return map { my ($cond, @vals) = @$_; @vals } @allresults; |
| }, |
| %options); |
| } |
| |
| |
| =item C<$bool = $var-E<gt>has_conditional_contents> |
| |
| Return 1 if C<$var> or one of its subvariable was conditionally |
| defined. Return 0 otherwise. |
| |
| =cut |
| |
| sub has_conditional_contents ($) |
| { |
| my ($self) = @_; |
| |
| # Traverse the variable recursively until we |
| # find a variable defined conditionally. |
| # Use 'die' to abort the traversal, and pass it '$full_cond' |
| # to we can find easily whether the 'eval' block aborted |
| # because we found a condition, or for some other error. |
| eval |
| { |
| $self->traverse_recursively |
| (sub |
| { |
| my ($subvar, $val, $cond, $full_cond) = @_; |
| die $full_cond if ! $full_cond->true; |
| return (); |
| }, |
| sub { return (); }); |
| }; |
| if ($@) |
| { |
| return 1 if ref ($@) && $@->isa ("Automake::Condition"); |
| # Propagate other errors. |
| die; |
| } |
| return 0; |
| } |
| |
| |
| =item C<$string = $var-E<gt>dump> |
| |
| Return a string describing all we know about C<$var>. |
| For debugging. |
| |
| =cut |
| |
| sub dump ($) |
| { |
| my ($self) = @_; |
| |
| my $text = $self->name . ": \n {\n"; |
| foreach my $vcond ($self->conditions->conds) |
| { |
| $text .= " " . $vcond->human . " => " . $self->rdef ($vcond)->dump; |
| } |
| $text .= " }\n"; |
| return $text; |
| } |
| |
| |
| =back |
| |
| =head2 Utility functions |
| |
| =over 4 |
| |
| =item C<@list = scan_variable_expansions ($text)> |
| |
| Return the list of variable names expanded in C<$text>. Note that |
| unlike some other functions, C<$text> is not split on spaces before we |
| check for subvariables. |
| |
| =cut |
| |
| sub scan_variable_expansions ($) |
| { |
| my ($text) = @_; |
| my @result = (); |
| |
| # Strip comments. |
| $text =~ s/#.*$//; |
| |
| # Record each use of ${stuff} or $(stuff) that does not follow a $. |
| while ($text =~ /(?<!\$)\$(?:\{([^\}]*)\}|\(([^\)]*)\))/g) |
| { |
| my $var = $1 || $2; |
| # The occurrence may look like $(string1[:subst1=[subst2]]) but |
| # we want only 'string1'. |
| $var =~ s/:[^:=]*=[^=]*$//; |
| push @result, $var; |
| } |
| |
| return @result; |
| } |
| |
| =item C<check_variable_expansions ($text, $where)> |
| |
| Check variable expansions in C<$text> and warn about any name that |
| does not conform to POSIX. C<$where> is the location of C<$text> |
| for the error message. |
| |
| =cut |
| |
| sub check_variable_expansions ($$) |
| { |
| my ($text, $where) = @_; |
| # Catch expansion of variables whose name does not conform to POSIX. |
| foreach my $var (scan_variable_expansions ($text)) |
| { |
| if ($var !~ /$_VARIABLE_PATTERN/o) |
| { |
| # If the variable name contains a space, it's likely |
| # to be a GNU make extension (such as $(addsuffix ...)). |
| # Mention this in the diagnostic. |
| my $gnuext = ""; |
| $gnuext = "\n(probably a GNU make extension)" if $var =~ / /; |
| # Accept recursive variable expansions if so desired |
| # (we hope they are rather portable in practice). |
| if ($var =~ /$_VARIABLE_RECURSIVE_PATTERN/o) |
| { |
| msg ('portability-recursive', $where, |
| "$var: non-POSIX recursive variable expansion$gnuext"); |
| } |
| else |
| { |
| msg ('portability', $where, "$var: non-POSIX variable name$gnuext"); |
| } |
| } |
| } |
| } |
| |
| |
| |
| =item C<Automake::Variable::define($varname, $owner, $type, $cond, $value, $comment, $where, $pretty)> |
| |
| Define or append to a new variable. |
| |
| C<$varname>: the name of the variable being defined. |
| |
| C<$owner>: owner of the variable (one of C<VAR_MAKEFILE>, |
| C<VAR_CONFIGURE>, or C<VAR_AUTOMAKE>, defined by L<Automake::VarDef>). |
| Variables can be overridden, provided the new owner is not weaker |
| (C<VAR_AUTOMAKE> < C<VAR_CONFIGURE> < C<VAR_MAKEFILE>). |
| |
| C<$type>: the type of the assignment (C<''> for C<FOO = bar>, |
| C<':'> for C<FOO := bar>, and C<'+'> for C<'FOO += bar'>). |
| |
| C<$cond>: the C<Condition> in which C<$var> is being defined. |
| |
| C<$value>: the value assigned to C<$var> in condition C<$cond>. |
| |
| C<$comment>: any comment (C<'# bla.'>) associated with the assignment. |
| Comments from C<+=> assignments stack with comments from the last C<=> |
| assignment. |
| |
| C<$where>: the C<Location> of the assignment. |
| |
| C<$pretty>: whether C<$value> should be pretty printed (one of |
| C<VAR_ASIS>, C<VAR_PRETTY>, C<VAR_SILENT>, or C<VAR_SORTED>, defined |
| by by L<Automake::VarDef>). C<$pretty> applies only to real |
| assignments. I.e., it does not apply to a C<+=> assignment (except |
| when part of it is being done as a conditional C<=> assignment). |
| |
| This function will all run any hook registered with the C<hook> |
| function. |
| |
| =cut |
| |
| sub define ($$$$$$$$) |
| { |
| my ($var, $owner, $type, $cond, $value, $comment, $where, $pretty) = @_; |
| |
| prog_error "$cond is not a reference" |
| unless ref $cond; |
| |
| prog_error "$where is not a reference" |
| unless ref $where; |
| |
| prog_error "pretty argument missing" |
| unless defined $pretty && ($pretty == VAR_ASIS |
| || $pretty == VAR_PRETTY |
| || $pretty == VAR_SILENT |
| || $pretty == VAR_SORTED); |
| |
| error $where, "bad characters in variable name '$var'" |
| if $var !~ /$_VARIABLE_PATTERN/o; |
| |
| # ':='-style assignments are not acknowledged by POSIX. Moreover it |
| # has multiple meanings. In GNU make or BSD make it means "assign |
| # with immediate expansion", while in OSF make it is used for |
| # conditional assignments. |
| msg ('portability', $where, "':='-style assignments are not portable") |
| if $type eq ':'; |
| |
| check_variable_expansions ($value, $where); |
| |
| # If there's a comment, make sure it is \n-terminated. |
| if ($comment) |
| { |
| chomp $comment; |
| $comment .= "\n"; |
| } |
| else |
| { |
| $comment = ''; |
| } |
| |
| my $self = _cvar $var; |
| |
| my $def = $self->def ($cond); |
| my $new_var = $def ? 0 : 1; |
| |
| # Additional checks for Automake definitions. |
| if ($owner == VAR_AUTOMAKE && ! $new_var) |
| { |
| # An Automake variable must be consistently defined with the same |
| # sign by Automake. |
| if ($def->type ne $type && $def->owner == VAR_AUTOMAKE) |
| { |
| error ($def->location, |
| "Automake variable '$var' was set with '" |
| . $def->type . "=' here ...", partial => 1); |
| error ($where, "... and is now set with '$type=' here."); |
| prog_error ("Automake variable assignments should be consistently\n" |
| . "defined with the same sign"); |
| } |
| |
| # If Automake tries to override a value specified by the user, |
| # just don't let it do. |
| if ($def->owner != VAR_AUTOMAKE) |
| { |
| if (! exists $_silent_variable_override{$var}) |
| { |
| my $condmsg = ($cond == TRUE |
| ? '' : (" in condition '" . $cond->human . "'")); |
| msg_cond_var ('override', $cond, $var, |
| "user variable '$var' defined here$condmsg ...", |
| partial => 1); |
| msg ('override', $where, |
| "... overrides Automake variable '$var' defined here"); |
| } |
| verb ("refusing to override the user definition of:\n" |
| . $self->dump ."with '" . $cond->human . "' => '$value'"); |
| return; |
| } |
| } |
| |
| # Differentiate assignment types. |
| |
| # 1. append (+=) to a variable defined for current condition |
| if ($type eq '+' && ! $new_var) |
| { |
| $def->append ($value, $comment); |
| $self->{'last-append'} = []; |
| |
| # Only increase owners. A VAR_CONFIGURE variable augmented in a |
| # Makefile.am becomes a VAR_MAKEFILE variable. |
| $def->set_owner ($owner, $where->clone) |
| if $owner > $def->owner; |
| } |
| # 2. append (+=) to a variable defined for *another* condition |
| elsif ($type eq '+' && ! $self->conditions->false) |
| { |
| # * Generally, $cond is not TRUE. For instance: |
| # FOO = foo |
| # if COND |
| # FOO += bar |
| # endif |
| # In this case, we declare an helper variable conditionally, |
| # and append it to FOO: |
| # FOO = foo $(am__append_1) |
| # @COND_TRUE@am__append_1 = bar |
| # Of course if FOO is defined under several conditions, we add |
| # $(am__append_1) to each definitions. |
| # |
| # * If $cond is TRUE, we don't need the helper variable. E.g., in |
| # if COND1 |
| # FOO = foo1 |
| # else |
| # FOO = foo2 |
| # endif |
| # FOO += bar |
| # we can add bar directly to all definition of FOO, and output |
| # @COND_TRUE@FOO = foo1 bar |
| # @COND_FALSE@FOO = foo2 bar |
| |
| my $lastappend = []; |
| # Do we need an helper variable? |
| if ($cond != TRUE) |
| { |
| # Can we reuse the helper variable created for the previous |
| # append? (We cannot reuse older helper variables because |
| # we must preserve the order of items appended to the |
| # variable.) |
| my $condstr = $cond->string; |
| my $key = "$var:$condstr"; |
| my ($appendvar, $appendvarcond) = @{$self->{'last-append'}}; |
| if ($appendvar && $condstr eq $appendvarcond) |
| { |
| # Yes, let's simply append to it. |
| $var = $appendvar; |
| $owner = VAR_AUTOMAKE; |
| $self = var ($var); |
| $def = $self->rdef ($cond); |
| $new_var = 0; |
| } |
| else |
| { |
| # No, create it. |
| my $num = ++$_appendvar; |
| my $hvar = "am__append_$num"; |
| $lastappend = [$hvar, $condstr]; |
| &define ($hvar, VAR_AUTOMAKE, '+', |
| $cond, $value, $comment, $where, $pretty); |
| |
| # Now HVAR is to be added to VAR. |
| $comment = ''; |
| $value = "\$($hvar)"; |
| } |
| } |
| |
| # Add VALUE to all definitions of SELF. |
| foreach my $vcond ($self->conditions->conds) |
| { |
| # We have a bit of error detection to do here. |
| # This: |
| # if COND1 |
| # X = Y |
| # endif |
| # X += Z |
| # should be rejected because X is not defined for all conditions |
| # where '+=' applies. |
| my $undef_cond = $self->not_always_defined_in_cond ($cond); |
| if (! $undef_cond->false) |
| { |
| error ($where, |
| "cannot apply '+=' because '$var' is not defined " |
| . "in\nthe following conditions:\n " |
| . join ("\n ", map { $_->human } $undef_cond->conds) |
| . "\neither define '$var' in these conditions," |
| . " or use\n'+=' in the same conditions as" |
| . " the definitions."); |
| } |
| else |
| { |
| &define ($var, $owner, '+', $vcond, $value, $comment, |
| $where, $pretty); |
| } |
| } |
| $self->{'last-append'} = $lastappend; |
| } |
| # 3. first assignment (=, :=, or +=) |
| else |
| { |
| # There must be no previous value unless the user is redefining |
| # an Automake variable or an AC_SUBST variable for an existing |
| # condition. |
| _check_ambiguous_condition ($self, $cond, $where) |
| unless (!$new_var |
| && (($def->owner == VAR_AUTOMAKE && $owner != VAR_AUTOMAKE) |
| || $def->owner == VAR_CONFIGURE)); |
| |
| # Never decrease an owner. |
| $owner = $def->owner |
| if ! $new_var && $owner < $def->owner; |
| |
| # Assignments to a macro set its location. We don't adjust |
| # locations for '+='. Ideally I suppose we would associate |
| # line numbers with random bits of text. |
| $def = new Automake::VarDef ($var, $value, $comment, $where->clone, |
| $type, $owner, $pretty); |
| $self->set ($cond, $def); |
| push @_var_order, $var; |
| } |
| |
| # Call any defined hook. This helps to update some internal state |
| # *while* parsing the file. For instance the handling of SUFFIXES |
| # requires this (see var_SUFFIXES_trigger). |
| &{$_hooks{$var}}($type, $value) if exists $_hooks{$var}; |
| } |
| |
| =item C<variable_delete ($varname, [@conds])> |
| |
| Forget about C<$varname> under the conditions C<@conds>, or completely |
| if C<@conds> is empty. |
| |
| =cut |
| |
| sub variable_delete ($@) |
| { |
| my ($var, @conds) = @_; |
| |
| if (!@conds) |
| { |
| delete $_variable_dict{$var}; |
| } |
| else |
| { |
| for my $cond (@conds) |
| { |
| delete $_variable_dict{$var}{'defs'}{$cond}; |
| } |
| } |
| if ($var =~ /_([[:alnum:]]+)$/) |
| { |
| delete $_primary_dict{$1}{$var}; |
| } |
| } |
| |
| =item C<$str = variables_dump> |
| |
| Return a string describing all we know about all variables. |
| For debugging. |
| |
| =cut |
| |
| sub variables_dump () |
| { |
| my $text = "all variables:\n{\n"; |
| foreach my $var (variables()) |
| { |
| $text .= $var->dump; |
| } |
| $text .= "}\n"; |
| return $text; |
| } |
| |
| |
| =item C<$var = set_seen ($varname)> |
| |
| =item C<$var = $var-E<gt>set_seen> |
| |
| Mark all definitions of this variable as examined, if the variable |
| exists. See L<Automake::VarDef::set_seen>. |
| |
| Return the C<Variable> object if the variable exists, or 0 |
| otherwise (i.e., as the C<var> function). |
| |
| =cut |
| |
| sub set_seen ($) |
| { |
| my ($self) = @_; |
| $self = ref $self ? $self : var $self; |
| |
| return 0 unless $self; |
| |
| for my $c ($self->conditions->conds) |
| { |
| $self->rdef ($c)->set_seen; |
| } |
| |
| return $self; |
| } |
| |
| |
| =item C<$count = require_variables ($where, $reason, $cond, @variables)> |
| |
| Make sure that each supplied variable is defined in C<$cond>. |
| Otherwise, issue a warning showing C<$reason> (C<$reason> should be |
| the reason why these variables are required, for instance C<'option foo |
| used'>). If we know which macro can define this variable, hint the |
| user. Return the number of undefined variables. |
| |
| =cut |
| |
| sub require_variables ($$$@) |
| { |
| my ($where, $reason, $cond, @vars) = @_; |
| my $res = 0; |
| $reason .= ' but ' unless $reason eq ''; |
| |
| $configure_ac = find_configure_ac |
| unless defined $configure_ac; |
| |
| VARIABLE: |
| foreach my $var (@vars) |
| { |
| # Nothing to do if the variable exists. |
| next VARIABLE |
| if vardef ($var, $cond); |
| |
| my $text = "$reason'$var' is undefined\n"; |
| my $v = var $var; |
| if ($v) |
| { |
| my $undef_cond = $v->not_always_defined_in_cond ($cond); |
| next VARIABLE |
| if $undef_cond->false; |
| $text .= ("in the following conditions:\n " |
| . join ("\n ", map { $_->human } $undef_cond->conds) |
| . "\n"); |
| } |
| |
| ++$res; |
| |
| if (exists $_am_macro_for_var{$var}) |
| { |
| my $mac = $_am_macro_for_var{$var}; |
| $text .= " The usual way to define '$var' is to add " |
| . "'$mac'\n to '$configure_ac' and run 'aclocal' and " |
| . "'autoconf' again."; |
| # aclocal will not warn about undefined macros unless it |
| # starts with AM_. |
| $text .= "\n If '$mac' is in '$configure_ac', make sure\n" |
| . " its definition is in aclocal's search path." |
| unless $mac =~ /^AM_/; |
| } |
| elsif (exists $_ac_macro_for_var{$var}) |
| { |
| $text .= " The usual way to define '$var' is to add " |
| . "'$_ac_macro_for_var{$var}'\n to '$configure_ac' and " |
| . "run 'autoconf' again."; |
| } |
| |
| error $where, $text, uniq_scope => US_GLOBAL; |
| } |
| return $res; |
| } |
| |
| =item C<$count = $var->requires_variables ($reason, @variables)> |
| |
| Same as C<require_variables>, but a method of Automake::Variable. |
| C<@variables> should be defined in the same conditions as C<$var> is |
| defined. |
| |
| =cut |
| |
| sub requires_variables ($$@) |
| { |
| my ($var, $reason, @args) = @_; |
| my $res = 0; |
| for my $cond ($var->conditions->conds) |
| { |
| $res += require_variables ($var->rdef ($cond)->location, $reason, |
| $cond, @args); |
| } |
| return $res; |
| } |
| |
| |
| =item C<variable_value ($var)> |
| |
| Get the C<TRUE> value of a variable, warn if the variable is |
| conditionally defined. C<$var> can be either a variable name |
| or a C<Automake::Variable> instance (this allows calls such |
| as C<$var-E<gt>variable_value>). |
| |
| =cut |
| |
| sub variable_value ($) |
| { |
| my ($var) = @_; |
| my $v = ref ($var) ? $var : var ($var); |
| return () unless $v; |
| $v->check_defined_unconditionally; |
| my $d = $v->def (TRUE); |
| return $d ? $d->value : ""; |
| } |
| |
| =item C<$str = output_variables> |
| |
| Format definitions for all variables. |
| |
| =cut |
| |
| sub output_variables () |
| { |
| my $res = ''; |
| # We output variables it in the same order in which they were |
| # defined (skipping duplicates). |
| my @vars = uniq @_var_order; |
| |
| # Output all the Automake variables. If the user changed one, |
| # then it is now marked as VAR_CONFIGURE or VAR_MAKEFILE. |
| foreach my $var (@vars) |
| { |
| my $v = rvar $var; |
| foreach my $cond ($v->conditions->conds) |
| { |
| $res .= $v->output ($cond) |
| if $v->rdef ($cond)->owner == VAR_AUTOMAKE; |
| } |
| } |
| |
| # Now dump the user variables that were defined. |
| foreach my $var (@vars) |
| { |
| my $v = rvar $var; |
| foreach my $cond ($v->conditions->conds) |
| { |
| $res .= $v->output ($cond) |
| if $v->rdef ($cond)->owner != VAR_AUTOMAKE; |
| } |
| } |
| return $res; |
| } |
| |
| =item C<$var-E<gt>traverse_recursively (&fun_item, &fun_collect, [cond_filter =E<gt> $cond_filter], [inner_expand =E<gt> 1], [skip_ac_subst =E<gt> 1])> |
| |
| Split the value of the Automake::Variable C<$var> on space, and |
| traverse its components recursively. |
| |
| If C<$cond_filter> is an C<Automake::Condition>, process any |
| conditions which are true when C<$cond_filter> is true. Otherwise, |
| process all conditions. |
| |
| We distinguish two kinds of items in the content of C<$var>. |
| Terms that look like C<$(foo)> or C<${foo}> are subvariables |
| and cause recursion. Other terms are assumed to be filenames. |
| |
| Each time a filename is encountered, C<&fun_item> is called with the |
| following arguments: |
| |
| ($var, -- the Automake::Variable we are currently |
| traversing |
| $val, -- the item (i.e., filename) to process |
| $cond, -- the Condition for the $var definition we are |
| examining (ignoring the recursion context) |
| $full_cond) -- the full Condition, taking into account |
| conditions inherited from parent variables |
| during recursion |
| |
| If C<inner_expand> is set, variable references occurring in filename |
| (as in C<$(BASE).ext>) are expanded before the filename is passed to |
| C<&fun_item>. |
| |
| If C<skip_ac_subst> is set, Autoconf @substitutions@ will be skipped, |
| i.e., C<&fun_item> will never be called for them. |
| |
| C<&fun_item> may return a list of items, they will be passed to |
| C<&fun_store> later on. Define C<&fun_item> or @<&fun_store> as |
| C<undef> when they serve no purpose. |
| |
| Once all items of a variable have been processed, the result (of the |
| calls to C<&fun_items>, or of recursive traversals of subvariables) |
| are passed to C<&fun_collect>. C<&fun_collect> receives three |
| arguments: |
| |
| ($var, -- the variable being traversed |
| $parent_cond, -- the Condition inherited from parent |
| variables during recursion |
| @condlist) -- a list of [$cond, @results] pairs |
| where each $cond appear only once, and @result |
| are all the results for this condition. |
| |
| Typically you should do C<$cond->merge ($parent_cond)> to recompute |
| the C<$full_cond> associated to C<@result>. C<&fun_collect> may |
| return a list of items, that will be used as the result of |
| C<Automake::Variable::traverse_recursively> (the top-level, or its |
| recursive calls). |
| |
| =cut |
| |
| # Contains a stack of 'from' and 'to' parts of variable |
| # substitutions currently in force. |
| my @_substfroms; |
| my @_substtos; |
| sub traverse_recursively ($&&;%) |
| { |
| ++$_traversal; |
| @_substfroms = (); |
| @_substtos = (); |
| my ($var, $fun_item, $fun_collect, %options) = @_; |
| my $cond_filter = $options{'cond_filter'}; |
| my $inner_expand = $options{'inner_expand'}; |
| my $skip_ac_subst = $options{'skip_ac_subst'}; |
| return $var->_do_recursive_traversal ($var, |
| $fun_item, $fun_collect, |
| $cond_filter, TRUE, $inner_expand, |
| $skip_ac_subst) |
| } |
| |
| # The guts of Automake::Variable::traverse_recursively. |
| sub _do_recursive_traversal ($$&&$$$$) |
| { |
| my ($var, $parent, $fun_item, $fun_collect, $cond_filter, $parent_cond, |
| $inner_expand, $skip_ac_subst) = @_; |
| |
| $var->set_seen; |
| |
| if ($var->{'scanned'} == $_traversal) |
| { |
| err_var $var, "variable '" . $var->name() . "' recursively defined"; |
| return (); |
| } |
| $var->{'scanned'} = $_traversal; |
| |
| my @allresults = (); |
| my $cond_once = 0; |
| foreach my $cond ($var->conditions->conds) |
| { |
| if (ref $cond_filter) |
| { |
| # Ignore conditions that don't match $cond_filter. |
| next if ! $cond->true_when ($cond_filter); |
| # If we found out several definitions of $var |
| # match $cond_filter then we are in trouble. |
| # Tell the user we don't support this. |
| $var->check_defined_unconditionally ($parent, $parent_cond) |
| if $cond_once; |
| $cond_once = 1; |
| } |
| my @result = (); |
| my $full_cond = $cond->merge ($parent_cond); |
| |
| my @to_process = $var->value_as_list ($cond, $parent, $parent_cond); |
| while (@to_process) |
| { |
| my $val = shift @to_process; |
| # If $val is a variable (i.e. ${foo} or $(bar), not a filename), |
| # handle the sub variable recursively. |
| # (Backslashes before '}' and ')' within brackets are here to |
| # please Emacs's indentation.) |
| if ($val =~ /^\$\{([^\}]*)\}$/ || $val =~ /^\$\(([^\)]*)\)$/) |
| { |
| my $subvarname = $1; |
| |
| # If the user uses a losing variable name, just ignore it. |
| # This isn't ideal, but people have requested it. |
| next if ($subvarname =~ /\@.*\@/); |
| |
| # See if the variable is actually a substitution reference |
| my ($from, $to); |
| # This handles substitution references like ${foo:.a=.b}. |
| if ($subvarname =~ /^([^:]*):([^=]*)=(.*)$/o) |
| { |
| $subvarname = $1; |
| $to = $3; |
| $from = quotemeta $2; |
| } |
| |
| my $subvar = var ($subvarname); |
| # Don't recurse into undefined variables. |
| next unless $subvar; |
| |
| push @_substfroms, $from; |
| push @_substtos, $to; |
| |
| my @res = $subvar->_do_recursive_traversal ($parent, |
| $fun_item, |
| $fun_collect, |
| $cond_filter, |
| $full_cond, |
| $inner_expand, |
| $skip_ac_subst); |
| push (@result, @res); |
| |
| pop @_substfroms; |
| pop @_substtos; |
| |
| next; |
| } |
| # Try to expand variable references inside filenames such as |
| # '$(NAME).txt'. We do not handle ':.foo=.bar' |
| # substitutions, but it would make little sense to use this |
| # here anyway. |
| elsif ($inner_expand |
| && ($val =~ /\$\{([^\}]*)\}/ || $val =~ /\$\(([^\)]*)\)/)) |
| { |
| my $subvarname = $1; |
| my $subvar = var $subvarname; |
| if ($subvar) |
| { |
| # Replace the reference by its value, and reschedule |
| # for expansion. |
| foreach my $c ($subvar->conditions->conds) |
| { |
| if (ref $cond_filter) |
| { |
| # Ignore conditions that don't match $cond_filter. |
| next if ! $c->true_when ($cond_filter); |
| # If we found out several definitions of $var |
| # match $cond_filter then we are in trouble. |
| # Tell the user we don't support this. |
| $subvar->check_defined_unconditionally ($var, |
| $full_cond) |
| if $cond_once; |
| $cond_once = 1; |
| } |
| my $subval = $subvar->rdef ($c)->value; |
| $val =~ s/\$\{$subvarname\}/$subval/g; |
| $val =~ s/\$\($subvarname\)/$subval/g; |
| unshift @to_process, split (' ', $val); |
| } |
| next; |
| } |
| # We do not know any variable with this name. Fall through |
| # to filename processing. |
| } |
| elsif ($skip_ac_subst && $val =~ /^\@.+\@$/) |
| { |
| next; |
| } |
| |
| if ($fun_item) # $var is a filename we must process |
| { |
| my $substnum=$#_substfroms; |
| while ($substnum >= 0) |
| { |
| $val =~ s/$_substfroms[$substnum]$/$_substtos[$substnum]/ |
| if defined $_substfroms[$substnum]; |
| $substnum -= 1; |
| } |
| |
| # Make sure you update the doc of |
| # Automake::Variable::traverse_recursively |
| # if you change the prototype of &fun_item. |
| my @transformed = &$fun_item ($var, $val, $cond, $full_cond); |
| push (@result, @transformed); |
| } |
| } |
| push (@allresults, [$cond, @result]) if @result; |
| } |
| |
| # We only care about _recursive_ variable definitions. The user |
| # is free to use the same variable several times in the same definition. |
| $var->{'scanned'} = -1; |
| |
| return () |
| unless $fun_collect; |
| # Make sure you update the doc of Automake::Variable::traverse_recursively |
| # if you change the prototype of &fun_collect. |
| return &$fun_collect ($var, $parent_cond, @allresults); |
| } |
| |
| # _hash_varname ($VAR) |
| # -------------------- |
| # Compute the key associated $VAR in %_gen_varname. |
| # See _gen_varname() below. |
| sub _hash_varname ($) |
| { |
| my ($var) = @_; |
| my $key = ''; |
| foreach my $cond ($var->conditions->conds) |
| { |
| my @values = $var->value_as_list ($cond); |
| $key .= "($cond)@values"; |
| } |
| return $key; |
| } |
| |
| # _hash_values (@VALUES) |
| # ---------------------- |
| # Hash @VALUES for %_gen_varname. @VALUES should be a list |
| # of pairs: ([$cond, @values], [$cond, @values], ...). |
| # See _gen_varname() below. |
| sub _hash_values (@) |
| { |
| my $key = ''; |
| foreach my $pair (@_) |
| { |
| my ($cond, @values) = @$pair; |
| $key .= "($cond)@values"; |
| } |
| return $key; |
| } |
| # ($VARNAME, $GENERATED) |
| # _gen_varname ($BASE, @DEFINITIONS) |
| # ---------------------------------- |
| # Return a variable name starting with $BASE, that will be |
| # used to store definitions @DEFINITIONS. |
| # @DEFINITIONS is a list of pair [$COND, @OBJECTS]. |
| # |
| # If we already have a $BASE-variable containing @DEFINITIONS, reuse |
| # it and set $GENERATED to 0. Otherwise construct a new name and set |
| # $GENERATED to 1. |
| # |
| # This way, we avoid combinatorial explosion of the generated |
| # variables. Especially, in a Makefile such as: |
| # |
| # | if FOO1 |
| # | A1=1 |
| # | endif |
| # | |
| # | if FOO2 |
| # | A2=2 |
| # | endif |
| # | |
| # | ... |
| # | |
| # | if FOON |
| # | AN=N |
| # | endif |
| # | |
| # | B=$(A1) $(A2) ... $(AN) |
| # | |
| # | c_SOURCES=$(B) |
| # | d_SOURCES=$(B) |
| # |
| # The generated c_OBJECTS and d_OBJECTS will share the same variable |
| # definitions. |
| # |
| # This setup can be the case of a testsuite containing lots (>100) of |
| # small C programs, all testing the same set of source files. |
| sub _gen_varname ($@) |
| { |
| my $base = shift; |
| my $key = _hash_values @_; |
| |
| return ($_gen_varname{$base}{$key}, 0) |
| if exists $_gen_varname{$base}{$key}; |
| |
| my $num = 1 + ($_gen_varname_n{$base} || 0); |
| $_gen_varname_n{$base} = $num; |
| my $name = "${base}_${num}"; |
| $_gen_varname{$base}{$key} = $name; |
| |
| return ($name, 1); |
| } |
| |
| =item C<$resvar = transform_variable_recursively ($var, $resvar, $base, $nodefine, $where, &fun_item, [%options])> |
| |
| =item C<$resvar = $var-E<gt>transform_variable_recursively ($resvar, $base, $nodefine, $where, &fun_item, [%options])> |
| |
| Traverse C<$var> recursively, and create a C<$resvar> variable in |
| which each filename in C<$var> have been transformed using |
| C<&fun_item>. (C<$var> may be a variable name in the first syntax. |
| It must be an C<Automake::Variable> otherwise.) |
| |
| Helper variables (corresponding to sub-variables of C<$var>) are |
| created as needed, using C<$base> as prefix. |
| |
| Arguments are: |
| $var source variable to traverse |
| $resvar resulting variable to define |
| $base prefix to use when naming subvariables of $resvar |
| $nodefine if true, traverse $var but do not define any variable |
| (this assumes &fun_item has some useful side-effect) |
| $where context into which variable definitions are done |
| &fun_item a transformation function -- see the documentation |
| of &fun_item in Automake::Variable::traverse_recursively. |
| |
| This returns the string C<"\$($RESVAR)">. |
| |
| C<%options> is a list of options to pass to |
| C<Variable::traverse_recursively> (see this method). |
| |
| =cut |
| |
| sub transform_variable_recursively ($$$$$&;%) |
| { |
| my ($var, $resvar, $base, $nodefine, $where, $fun_item, %options) = @_; |
| |
| $var = ref $var ? $var : rvar $var; |
| |
| my $res = $var->traverse_recursively |
| ($fun_item, |
| # The code that defines the variable holding the result |
| # of the recursive transformation of a subvariable. |
| sub { |
| my ($subvar, $parent_cond, @allresults) = @_; |
| # If no definition is required, return anything: the result is |
| # not expected to be used, only the side effect of $fun_item |
| # should matter. |
| return 'report-me' if $nodefine; |
| # Cache $subvar, so that we reuse it if @allresults is the same. |
| my $key = _hash_varname $subvar; |
| $_gen_varname{$base}{$key} = $subvar->name; |
| |
| # Find a name for the variable, unless this is the top-variable |
| # for which we want to use $resvar. |
| my ($varname, $generated) = |
| ($var != $subvar) ? _gen_varname ($base, @allresults) : ($resvar, 1); |
| |
| # Define the variable if we are not reusing a previously |
| # defined variable. At the top-level, we can also avoid redefining |
| # the variable if it already contains the same values. |
| if ($generated |
| && !($varname eq $var->name && $key eq _hash_values @allresults)) |
| { |
| # If the new variable is the source variable, we assume |
| # we are trying to override a user variable. Delete |
| # the old variable first. |
| variable_delete ($varname) if $varname eq $var->name; |
| # Define an empty variable in condition TRUE if there is no |
| # result. |
| @allresults = ([TRUE, '']) unless @allresults; |
| # Define the rewritten variable in all conditions not |
| # already covered by user definitions. |
| foreach my $pair (@allresults) |
| { |
| my ($cond, @result) = @$pair; |
| my $var = var $varname; |
| my @conds = ($var |
| ? $var->not_always_defined_in_cond ($cond)->conds |
| : $cond); |
| |
| foreach (@conds) |
| { |
| define ($varname, VAR_AUTOMAKE, '', $_, "@result", |
| '', $where, VAR_PRETTY); |
| } |
| } |
| } |
| set_seen $varname; |
| return "\$($varname)"; |
| }, |
| %options); |
| return $res; |
| } |
| |
| |
| =back |
| |
| =head1 SEE ALSO |
| |
| L<Automake::VarDef>, L<Automake::Condition>, |
| L<Automake::DisjConditions>, L<Automake::Location>. |
| |
| =cut |
| |
| 1; |
| |
| ### Setup "GNU" style for perl-mode and cperl-mode. |
| ## Local Variables: |
| ## perl-indent-level: 2 |
| ## perl-continued-statement-offset: 2 |
| ## perl-continued-brace-offset: 0 |
| ## perl-brace-offset: 0 |
| ## perl-brace-imaginary-offset: 0 |
| ## perl-label-offset: -2 |
| ## cperl-indent-level: 2 |
| ## cperl-brace-offset: 0 |
| ## cperl-continued-brace-offset: 0 |
| ## cperl-label-offset: -2 |
| ## cperl-extra-newline-before-brace: t |
| ## cperl-merge-trailing-else: nil |
| ## cperl-continued-statement-offset: 2 |
| ## End: |