if 0;
# automake - create Makefile.in from Makefile.am
-# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free
-# Software Foundation, Inc.
+# Copyright (C) 1994-2012 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
# Override SHELL. This is required on DJGPP so that system() uses
# bash, not COMMAND.COM which doesn't quote arguments properly.
# Other systems aren't expected to use $SHELL when Automake
- # runs, but it should be safe to drop the `if DJGPP' guard if
+ # runs, but it should be safe to drop the "if DJGPP" guard if
# it turns up other systems need the same thing. After all,
# if SHELL is used, ./configure's SHELL is always better than
# the user's SHELL (which may be something like tcsh).
$ENV{'SHELL'} = '@SHELL@' if exists $ENV{'DJDIR'};
}
-use Automake::Struct;
-struct (# Short name of the language (c, f77...).
+use Class::Struct ();
+Class::Struct::struct (
+ # Short name of the language (c, f77...).
'name' => "\$",
# Nice name of the language (C, Fortran 77...).
'Name' => "\$",
# List of configure variables which must be defined.
'config_vars' => '@',
- # `pure' is `1' or `'. A `pure' language is one where, if
+ # 'pure' is '1' or ''. A 'pure' language is one where, if
# all the files in a directory are of that language, then we
# do not require the C compiler or any code to call it.
'pure' => "\$",
use Automake::Condition qw/TRUE FALSE/;
use Automake::DisjConditions;
use Automake::Options;
-use Automake::Version;
use Automake::Variable;
use Automake::VarDef;
use Automake::Rule;
# Only recognize leading spaces, not leading tabs. If we recognize
# leading tabs here then we need to make the reader smarter, because
-# otherwise it will think rules like `foo=bar; \' are errors.
+# otherwise it will think rules like 'foo=bar; \' are errors.
my $ASSIGNMENT_PATTERN = '^ *([^ \t=:+]*)\s*([:+]?)=\s*(.*)' . "\$";
# This pattern recognizes a Gnits version id and sets $1 if the
# release is an alpha release. We also allow a suffix which can be
# Copyright on generated Makefile.ins.
my $gen_copyright = "\
-# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-# Foundation, Inc.
+# Copyright (C) 1994-$RELEASE_YEAR Free Software Foundation, Inc.
+
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# These constants are returned by the lang_*_rewrite functions.
# LANG_SUBDIR means that the resulting object file should be in a
# subdir if the source file is. In this case the file name cannot
-# have `..' components.
+# have '..' components.
use constant LANG_IGNORE => 0;
use constant LANG_PROCESS => 1;
use constant LANG_SUBDIR => 2;
use constant QUEUE_CONF_FILE => "conf file";
use constant QUEUE_LOCATION => "location";
use constant QUEUE_STRING => "string";
-\f
## ---------------------------------- ##
## Variables related to the options. ##
# Directory to search for configure-required files. This
# will be computed by &locate_aux_dir and can be set using
# AC_CONFIG_AUX_DIR in configure.ac.
-# $CONFIG_AUX_DIR is the `raw' directory, valid only in the source-tree.
+# $CONFIG_AUX_DIR is the 'raw' directory, valid only in the source-tree.
my $config_aux_dir = '';
my $config_aux_dir_set_in_configure_ac = 0;
# $AM_CONFIG_AUX_DIR is prefixed with $(top_srcdir), so it can be used
# Where version is defined.
my $package_version_location;
-# TRUE if we've seen AM_ENABLE_MULTILIB.
-my $seen_multilib = 0;
-
# TRUE if we've seen AM_PROG_AR
my $seen_ar = 0;
my $seen_automake_version = 0;
# Hash table of discovered configure substitutions. Keys are names,
-# values are `FILE:LINE' strings which are used by error message
+# values are 'FILE:LINE' strings which are used by error message
# generation.
my %configure_vars = ();
my %extension_map = ();
# List of the DIST_COMMON files we discovered while reading
-# configure.in
+# configure.ac.
my $configure_dist_common = '';
# This maps languages names onto objects.
# The name of the Makefile currently being processed.
my $am_file = 'BUG';
-\f
################################################################
# to delete.
my %libtool_clean_directories;
-# Value of `$(SOURCES)', used by tags.am.
+# Value of $(SOURCES), used by tags.am.
my @sources;
# Sources which go in the distribution.
my @dist_sources;
# This keeps track of the directories for which we've already
# created dirstamp code. Keys are directories, values are stamp files.
# Several keys can share the same stamp files if they are equivalent
-# (as are `.//foo' and `foo').
+# (as are './/foo' and 'foo').
my %directory_map;
# All .P files.
# handling on a per-language basis.
my %lang_specific_files;
-# This is set when `handle_dist' has finished. Once this happens,
+# This is set when 'handle_dist' has finished. Once this happens,
# we should no longer push on dist_common.
my $handle_dist_run;
# under consideration.
my %linkers_used;
-# True if we need `LINK' defined. This is a hack.
+# True if we need 'LINK' defined. This is a hack.
my $need_link;
# Does the generated Makefile have to build some compiled object
# Record each file processed by make_paragraphs.
my %transformed_files;
-\f
################################################################
%clean_files = ();
%compile_clean_files = ();
- # We always include `.'. This isn't strictly correct.
+ # We always include '.'. This isn't strictly correct.
%libtool_clean_directories = ('.' => 1);
@sources = ();
'pure' => 1,
'extensions' => ['.m']);
+# Objective C++.
+register_language ('name' => 'objcxx',
+ 'Name' => 'Objective C++',
+ 'config_vars' => ['OBJCXX'],
+ 'linker' => 'OBJCXXLINK',
+ 'link' => '$(OBJCXXLD) $(AM_OBJCXXFLAGS) $(OBJCXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@',
+ 'autodep' => 'OBJCXX',
+ 'flags' => ['OBJCXXFLAGS', 'CPPFLAGS'],
+ 'compile' => '$(OBJCXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_OBJCXXFLAGS) $(OBJCXXFLAGS)',
+ 'ccer' => 'OBJCXX',
+ 'compiler' => 'OBJCXXCOMPILE',
+ 'compile_flag' => '-c',
+ 'output_flag' => '-o',
+ 'lder' => 'OBJCXXLD',
+ 'ld' => '$(OBJCXX)',
+ 'pure' => 1,
+ 'extensions' => ['.mm']);
+
# Unified Parallel C.
register_language ('name' => 'upc',
'Name' => 'Unified Parallel C',
# Preprocessed Fortran 77
#
# The current support for preprocessing Fortran 77 just involves
-# passing `$(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS)
-# $(CPPFLAGS)' as additional flags to the Fortran 77 compiler, since
-# this is how GNU Make does it; see the `GNU Make Manual, Edition 0.51
-# for `make' Version 3.76 Beta' (specifically, from info file
-# `(make)Catalogue of Rules').
+# passing "$(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS)
+# $(CPPFLAGS)" as additional flags to the Fortran 77 compiler, since
+# this is how GNU Make does it; see the "GNU Make Manual, Edition 0.51
+# for 'make' Version 3.76 Beta" (specifically, from info file
+# '(make)Catalogue of Rules').
#
# A better approach would be to write an Autoconf test
# (i.e. AC_PROG_FPP) for a Fortran 77 preprocessor, because not all
# $BACKPATH
-# &backname ($REL-DIR)
+# &backname ($RELDIR)
# --------------------
-# If I `cd $REL-DIR', then to come back, I should `cd $BACKPATH'.
-# For instance `src/foo' => `../..'.
-# Works with non strictly increasing paths, i.e., `src/../lib' => `..'.
+# If I "cd $RELDIR", then to come back, I should "cd $BACKPATH".
+# For instance 'src/foo' => '../..'.
+# Works with non strictly increasing paths, i.e., 'src/../lib' => '..'.
sub backname ($)
{
my ($file) = @_;
if ($_ eq '..')
{
pop @res
- or prog_error ("trying to reverse path `$file' pointing outside tree");
+ or prog_error ("trying to reverse path '$file' pointing outside tree");
}
else
{
################################################################
-# `silent-rules' mode handling functions.
+# 'silent-rules' mode handling functions.
# verbose_var (NAME)
# ------------------
-# The public variable stem used to implement `silent-rules'.
+# The public variable stem used to implement 'silent-rules'.
sub verbose_var ($)
{
my ($name) = @_;
# verbose_private_var (NAME)
# --------------------------
-# The naming policy for the private variables for `silent-rules'.
+# The naming policy for the private variables for 'silent-rules'.
sub verbose_private_var ($)
{
my ($name) = @_;
return 'am__v_' . $name;
}
-# define_verbose_var (NAME, VAL)
-# ------------------------------
-# For `silent-rules' mode, setup VAR and dispatcher, to expand to VAL if silent.
-sub define_verbose_var ($$)
+# define_verbose_var (NAME, VAL-IF-SILENT, [VAL-IF-VERBOSE])
+# ----------------------------------------------------------
+# For 'silent-rules' mode, setup VAR and dispatcher, to expand to
+# VAL-IF-SILENT if silent, to VAL-IF-VERBOSE (defaulting to empty)
+# if not.
+sub define_verbose_var ($$;$)
{
- my ($name, $val) = @_;
+ my ($name, $silent_val, $verbose_val) = @_;
+ $verbose_val = '' unless defined $verbose_val;
my $var = verbose_var ($name);
my $pvar = verbose_private_var ($name);
my $silent_var = $pvar . '_0';
+ my $verbose_var = $pvar . '_1';
if (option 'silent-rules')
{
- # For typical `make's, `configure' replaces AM_V (inside @@) with $(V)
+ # For typical 'make's, 'configure' replaces AM_V (inside @@) with $(V)
# and AM_DEFAULT_V (inside @@) with $(AM_DEFAULT_VERBOSITY).
- # For strict POSIX 2008 `make's, it replaces them with 0 or 1 instead.
+ # For strict POSIX 2008 'make's, it replaces them with 0 or 1 instead.
# See AM_SILENT_RULES in m4/silent.m4.
define_variable ($var, '$(' . $pvar . '_@'.'AM_V'.'@)', INTERNAL);
define_variable ($pvar . '_', '$(' . $pvar . '_@'.'AM_DEFAULT_V'.'@)', INTERNAL);
- Automake::Variable::define ($silent_var, VAR_AUTOMAKE, '', TRUE, $val,
- '', INTERNAL, VAR_ASIS)
+ Automake::Variable::define ($silent_var, VAR_AUTOMAKE, '', TRUE,
+ $silent_val, '', INTERNAL, VAR_ASIS)
if (! vardef ($silent_var, TRUE));
- }
+ Automake::Variable::define ($verbose_var, VAR_AUTOMAKE, '', TRUE,
+ $verbose_val, '', INTERNAL, VAR_ASIS)
+ if (! vardef ($verbose_var, TRUE));
+}
}
# Above should not be needed in the general automake code.
# silent_flag
# -----------
-# Contents of %SILENT%: variable to expand to `@' when silent.
+# Contents of %SILENT%: variable to expand to '@' when silent.
sub silent_flag ()
{
return verbose_flag ('at');
# define_verbose_tagvar (NAME)
# ----------------------------
-# Engage the needed `silent-rules' machinery for tag NAME.
+# Engage the needed 'silent-rules' machinery for tag NAME.
sub define_verbose_tagvar ($)
{
my ($name) = @_;
if (option 'silent-rules')
{
define_verbose_var ($name, '@echo " '. $name . ' ' x (8 - length ($name)) . '" $@;');
- define_verbose_var ('at', '@');
}
}
# define_verbose_texinfo
# ----------------------
-# Engage the needed `silent-rules' machinery for assorted texinfo commands.
+# Engage the needed 'silent-rules' machinery for assorted texinfo commands.
sub define_verbose_texinfo ()
{
my @tagvars = ('DVIPS', 'MAKEINFO', 'INFOHTML', 'TEXI2DVI', 'TEXI2PDF');
# define_verbose_libtool
# ----------------------
-# Engage the needed `silent-rules' machinery for `libtool --silent'.
+# Engage the needed 'silent-rules' machinery for 'libtool --silent'.
sub define_verbose_libtool ()
{
define_verbose_var ('lt', '--silent');
return verbose_flag ('lt');
}
+sub handle_silent ()
+{
+ return unless option 'silent-rules';
+ # *Always* provide the user with 'AM_V_GEN' for 'silent-rules' mode.
+ define_verbose_tagvar ('GEN');
+ define_verbose_var ('at', '@');
+}
+
################################################################
if ($var->has_conditional_contents)
{
msg_var ('unsupported', $var,
- "`AUTOMAKE_OPTIONS' cannot have conditional contents");
+ "'AUTOMAKE_OPTIONS' cannot have conditional contents");
}
my @options = map { { option => $_->[1], where => $_->[0] } }
$var->value_as_list_recursive (cond_filter => TRUE,
if ($var->rdef ($cond)->owner == VAR_MAKEFILE)
{
msg_cond_var ('gnu', $cond, $flag,
- "`$flag' is a user variable, "
+ "'$flag' is a user variable, "
. "you should not override it;\n"
- . "use `AM_$flag' instead");
+ . "use 'AM_$flag' instead");
}
}
}
require_conf_file ("$am_file.am", FOREIGN, 'depcomp');
my @deplist = sort keys %dep_files;
- # Generate each `include' individually. Irix 6 make will
+ # Generate each 'include' individually. Irix 6 make will
# not properly include several files resulting from a
# variable expansion; generating many separate includes
# seems safest.
# This is not used by depend2.am.
my $der_ext = (&{$lang->output_extensions} ($ext))[0];
- # When we output an inference rule like `.c.o:' we
+ # When we output an inference rule like '.c.o:' we
# have two cases to consider: either subdir-objects
# is used, or it is not.
#
# In the latter case the rule is used to build objects
# in the current directory, and dependencies always
- # go into `./$(DEPDIR)/'. We can hard-code this value.
+ # go into './$(DEPDIR)/'. We can hard-code this value.
#
# In the former case the rule can be used to build
# objects in sub-directories too. Dependencies should
# go into the appropriate sub-directories, e.g.,
- # `sub/$(DEPDIR)/'. The value of this directory
+ # 'sub/$(DEPDIR)/'. The value of this directory
# needs to be computed on-the-fly.
#
# DEPBASE holds the name of this directory, plus the
# basename part of the object file (extensions Po, TPo,
# Plo, TPlo will be added later as appropriate). It is
- # either hardcoded, or a shell variable (`$depbase') that
+ # either hardcoded, or a shell variable ('$depbase') that
# will be computed by the rule.
my $depbase =
option ('subdir-objects') ? '$$depbase' : '$(DEPDIR)/$*';
my $obj_compile = $lang->compile;
- # Rewrite each occurrence of `AM_$flag' in the compile
- # rule into `${derived}_$flag' if it exists.
+ # Rewrite each occurrence of 'AM_$flag' in the compile
+ # rule into '${derived}_$flag' if it exists.
for my $flag (@{$lang->flags})
{
my $val = "${derived}_$flag";
"\$(LIBTOOL) $ltverbose $libtool_tag\$($ptltflags) \$(LIBTOOLFLAGS) "
. "--mode=compile $obj_compile";
- # We _need_ `-o' for per object rules.
+ # We _need_ '-o' for per object rules.
my $output_flag = $lang->output_flag || '-o';
my $depbase = dirname ($obj);
BASE => $obj,
SOURCE => $source,
SOURCEFLAG => $sourceflags{$srcext} || '',
- # Use $myext and not `.o' here, in case
+ # Use $myext and not '.o' here, in case
# we are actually building a new source
# file -- e.g. via yacc.
OBJ => "$obj$myext",
%transform, %lang);
# If the source to a program consists entirely of code from a
- # `pure' language, for instance C++ or Fortran 77, then we
+ # 'pure' language, for instance C++ or Fortran 77, then we
# don't need the C compiler code. However if we run into
# something unusual then we do generate the C code. There are
# probably corner cases here that do not work properly.
# Call the finisher.
$lang->finish;
- # Flags listed in `->flags' are user variables (per GNU Standards),
+ # Flags listed in '->flags' are user variables (per GNU Standards),
# they should not be overridden in the Makefile...
my @dont_override = @{$lang->flags};
# ... and so is LDFLAGS.
unless defined $done{$languages{'c'}};
define_linker_variable ($languages{'c'});
}
-
- # Always provide the user with `AM_V_GEN' for `silent-rules' mode.
- define_verbose_tagvar ('GEN');
}
foreach my $file (@files)
{
err_var ($prefix . $one_file . '_SOURCES',
- "automatically discovered file `$file' should not" .
+ "automatically discovered file '$file' should not" .
" be explicitly mentioned")
if defined $libsources{$file};
}
# $VAR is the name of the variable that the source filenames come from
# $TOPPARENT is the name of the _SOURCES variable which is being processed
# $DERIVED is the name of resulting executable or library
-# $OBJ is the object extension (e.g., `.lo')
+# $OBJ is the object extension (e.g., '.lo')
# $FILE the source file to transform
# %TRANSFORM contains extras arguments to pass to file_contents
# when producing explicit rules
if (/^\@.*\@$/)
{
my $parent_msg = '';
- $parent_msg = "\nand is referred to from `$topparent'"
+ $parent_msg = "\nand is referred to from '$topparent'"
if $topparent ne $var->name;
err_var ($var,
- "`" . $var->name . "' includes configure substitution `$_'"
+ "'" . $var->name . "' includes configure substitution '$_'"
. $parent_msg . ";\nconfigure " .
"substitutions are not allowed in _SOURCES variables");
next;
}
- # If the source file is in a subdirectory then the `.o' is put
+ # If the source file is in a subdirectory then the '.o' is put
# into the current directory, unless the subdir-objects option
# is in effect.
# yacc output).
my $derived_source = 0;
- # This holds the `aggregate context' of the file we are
+ # This holds the 'aggregate context' of the file we are
# currently examining. If the file is compiled with
# per-object flags, then it will be the name of the object.
- # Otherwise it will be `AM'. This is used by the target hook
+ # Otherwise it will be 'AM'. This is used by the target hook
# language function.
my $aggregate = 'AM';
# object. In this case we rewrite the object's
# name to ensure it is unique.
- # We choose the name `DERIVED_OBJECT' to ensure
+ # We choose the name 'DERIVED_OBJECT' to ensure
# (1) uniqueness, and (2) continuity between
# invocations. However, this will result in a
# name that is too long for losing systems, in
# Each item on this list is a reference to a list consisting
# of four values followed by additional transform flags for
# file_contents. The four values are the derived flag prefix
- # (e.g. for `foo_CFLAGS', it is `foo'), the name of the
+ # (e.g. for 'foo_CFLAGS', it is 'foo'), the name of the
# source file, the base name of the output file, and
# the extension for the object file.
push (@{$lang_specific_files{$lang->name}},
next;
}
- err_am "object `$object' created by `$full' and `$object_map{$object}'"
+ err_am "object '$object' created by '$full' and '$object_map{$object}'"
if (defined $object_map{$object}
&& $object_map{$object} ne $full);
!= (COMPILE_LIBTOOL | COMPILE_ORDINARY))
&& $object_compilation_map{$comp_obj} != $comp_val)
{
- err_am "object `$comp_obj' created both with libtool and without";
+ err_am "object '$comp_obj' created both with libtool and without";
}
$object_compilation_map{$comp_obj} |= $comp_val;
# project
# For Java, the way we're handling it right now, a
- # `..' component doesn't make sense.
+ # '..' component doesn't make sense.
if ($lang && $lang->name eq 'java' && $object =~ /(\/|^)\.\.\//)
{
- err_am "`$full' should not contain a `..' component";
+ err_am "'$full' should not contain a '..' component";
}
- # Make sure object is removed by `make mostlyclean'.
+ # Make sure object is removed by 'make mostlyclean'.
$compile_clean_files{$object} = MOSTLY_CLEAN;
# If we have a libtool object then we also must remove
# the ordinary .o.
# $NODEFINE is a boolean: if true, $OBJVAR will not be defined (but
# work done to determine the linker will be).
# $ONE_FILE is the canonical (transformed) name of object to build
-# $OBJ is the object extension (i.e. either `.o' or `.lo').
+# $OBJ is the object extension (i.e. either '.o' or '.lo').
# $TOPPARENT is the _SOURCES variable being processed.
# $WHERE context into which this definition is done
# %TRANSFORM extra arguments to pass to file_contents when producing
# Arguments are:
# canonical (transformed) name of target to build
# actual target of object to build
-# object extension (i.e., either `.o' or `$o')
+# object extension (i.e., either '.o' or '$o')
# location of the source variable
# extra arguments to pass to file_contents when producing rules
# Return the name of the linker variable that must be used.
-# Empty return means just use `LINK'.
+# Empty return means just use 'LINK'.
sub handle_source_transform ($$$$%)
{
# one_file is canonical name. unxformed is given name. obj is
my $loc = $where->clone;
$loc->pop_context;
msg ('obsolete', $loc,
- "the default source for `$unxformed' has been changed "
- . "to `$default_source'.\n(Using `$old_default_source' for "
+ "the default source for '$unxformed' has been changed "
+ . "to '$default_source'.\n(Using '$old_default_source' for "
. "backward compatibility.)");
$default_source = $old_default_source;
}
define_pretty_variable ($one_file . '_OBJECTS', TRUE, $where, @keys);
}
- # If we want to use `LINK' we must make sure it is defined.
+ # If we want to use 'LINK' we must make sure it is defined.
if ($linker eq '')
{
$need_link = 1;
my ($xname, $varname) = @_;
my $var = var ($varname);
- prog_error "`$varname' undefined"
+ prog_error "'$varname' undefined"
unless $var;
- prog_error "unexpected variable name `$varname'"
+ prog_error "unexpected variable name '$varname'"
unless $varname =~ /^(.*)(?:LIB|LD)ADD$/;
my $prefix = $1 || 'AM_';
$flagvar = 1;
# FIXME: should display a stack of nested variables
# as context when $var != $subvar.
- err_var ($var, "linker flags such as `$val' belong in "
- . "`${prefix}LDFLAGS'");
+ err_var ($var, "linker flags such as '$val' belong in "
+ . "'${prefix}LDFLAGS'");
}
return ();
}
# If LIBOBJS files must be built in another directory we have
# to define LIBOBJDIR and ensure the files get cleaned.
# Otherwise LIBOBJDIR can be left undefined, and the cleaning
- # is achieved by `rm -f *.$(OBJEXT)' in compile.am.
+ # is achieved by 'rm -f *.$(OBJEXT)' in compile.am.
if ($config_libobj_dir
&& $relative_dir ne $config_libobj_dir)
{
}
else
{
- error ("`\$($var)' cannot be used outside `$config_libobj_dir' if"
- . " `subdir-objects' is not set");
+ error ("'\$($var)' cannot be used outside '$config_libobj_dir' if"
+ . " 'subdir-objects' is not set");
}
}
{
foreach my $xt (@suffixes)
{
- reject_var ("$name$xt", "use `$xname$xt', not `$name$xt'");
+ reject_var ("$name$xt", "use '$xname$xt', not '$name$xt'");
}
}
push @incs, '-I' . dirname ($hdr);
}
}
- # We want `-I. -I$(srcdir)', but the latter -I is redundant
+ # We want '-I. -I$(srcdir)', but the latter -I is redundant
# and unaesthetic in non-VPATH builds. We use `-I.@am__isrc@`
# instead. It will be replaced by '-I.' or '-I. -I$(srcdir)'.
# Items in CONFIG_HEADER are never in $(srcdir) so it is safe
- # to just put @am__isrc@ right after `-I.', without a space.
+ # to just put @am__isrc@ right after '-I.', without a space.
($default_includes = ' ' . uniq (@incs)) =~ s/ @/@/;
}
'_SOURCES', '_OBJECTS',
'_DEPENDENCIES');
- $where->push_context ("while processing program `$one_file'");
+ $where->push_context ("while processing program '$one_file'");
$where->set (INTERNAL->get);
my $linker = &handle_source_transform ($xname, $one_file, $obj, $where,
}
reject_var ($xname . '_LIBADD',
- "use `${xname}_LDADD', not `${xname}_LIBADD'");
+ "use '${xname}_LDADD', not '${xname}_LIBADD'");
set_seen ($xname . '_DEPENDENCIES');
set_seen ('EXTRA_' . $xname . '_DEPENDENCIES');
my $suggestion = dirname ($onelib) . "/$bn";
$suggestion =~ s|^\./||g;
msg ('error-gnu/warn', $where,
- "`$onelib' is not a standard library name\n"
- . "did you mean `$suggestion'?")
+ "'$onelib' is not a standard library name\n"
+ . "did you mean '$suggestion'?")
}
($known_libraries{$onelib} = $bn) =~ s/\.a$//;
- $where->push_context ("while processing library `$onelib'");
+ $where->push_context ("while processing library '$onelib'");
$where->set (INTERNAL->get);
my $obj = '.$(OBJEXT)';
}
reject_var ($xlib . '_LDADD',
- "use `${xlib}_LIBADD', not `${xlib}_LDADD'");
+ "use '${xlib}_LIBADD', not '${xlib}_LDADD'");
# Make sure we at look at this.
set_seen ($xlib . '_DEPENDENCIES');
if (! $seen_ar)
{
msg ('extra-portability', $where,
- "`$onelib': linking libraries using a non-POSIX\n"
- . "archiver requires `AM_PROG_AR' in `$configure_ac'")
+ "'$onelib': linking libraries using a non-POSIX\n"
+ . "archiver requires 'AM_PROG_AR' in '$configure_ac'")
}
}
}
# We reject libraries which are installed in several places
# in the same condition, because we can only specify one
- # `-rpath' option.
+ # '-rpath' option.
$var->traverse_recursively
(sub
{
if ($msg)
{
error ($where, $msg, partial => 1);
- my $dirtxt = "installed " . ($strip_subdir ? "in" : "below") . " `$dir'";
- $dirtxt = "built for `$dir'"
+ my $dirtxt = "installed " . ($strip_subdir ? "in" : "below") . " '$dir'";
+ $dirtxt = "built for '$dir'"
if $dir eq 'EXTRA' || $dir eq 'noinst' || $dir eq 'check';
my $dircond =
$full_cond->true ? "" : " in condition $hcond";
- error ($where, "`$val' should be $dirtxt$dircond ...",
+ error ($where, "'$val' should be $dirtxt$dircond ...",
partial => 1);
my $hacond = $acond->human;
my $adir = $instdirs{$val}{$acond};
- my $adirtxt = "installed in `$adir'";
- $adirtxt = "built for `$adir'"
+ my $adirtxt = "installed in '$adir'";
+ $adirtxt = "built for '$adir'"
if ($adir eq 'EXTRA' || $adir eq 'noinst'
|| $adir eq 'check');
my $adircond = $acond->true ? "" : " in condition $hacond";
my $suggestion = dirname ($onelib) . "/$bn";
$suggestion =~ s|^\./||g;
msg ('error-gnu/warn', $where,
- "`$onelib' is not a standard libtool $type name\n"
- . "did you mean `$suggestion'?")
+ "'$onelib' is not a standard libtool $type name\n"
+ . "did you mean '$suggestion'?")
}
($known_libraries{$onelib} = $bn) =~ s/\.la$//;
- $where->push_context ("while processing Libtool library `$onelib'");
+ $where->push_context ("while processing Libtool library '$onelib'");
$where->set (INTERNAL->get);
# Make sure we look at these.
}
reject_var ("${xlib}_LDADD",
- "use `${xlib}_LIBADD', not `${xlib}_LDADD'");
+ "use '${xlib}_LIBADD', not '${xlib}_LDADD'");
my $linker = &handle_source_transform ($xlib, $onelib, $obj, $where,
if (! $seen_ar)
{
msg ('extra-portability', $where,
- "`$onelib': linking libtool libraries using a non-POSIX\n"
- . "archiver requires `AM_PROG_AR' in `$configure_ac'")
+ "'$onelib': linking libtool libraries using a non-POSIX\n"
+ . "archiver requires 'AM_PROG_AR' in '$configure_ac'")
}
}
}
for my $cond ($var->conditions->conds)
{
$varname =~ /^(?:EXTRA_)?(?:nobase_)?(?:dist_|nodist_)?(.*)_[[:alnum:]]+$/;
- msg_var ('syntax', $var, "variable `$varname' is defined but no"
- . " program or\nlibrary has `$1' as canonical name"
+ msg_var ('syntax', $var, "variable '$varname' is defined but no"
+ . " program or\nlibrary has '$1' as canonical name"
. " (possible typo)")
unless $var->rdef ($cond)->seen;
}
if ($outfile =~ /\.([^.]+)$/ && $1 ne 'info')
{
error ("$filename:$.",
- "output `$outfile' has unrecognized extension");
+ "output '$outfile' has unrecognized extension");
return;
}
}
if (! $outfile)
{
- err_am "`$filename' missing \@setfilename";
+ err_am "'$filename' missing \@setfilename";
return;
}
{
my ($source, $dest, $insrc, @deps) = @_;
- # Split `a.texi' into `a' and `.texi'.
+ # Split 'a.texi' into 'a' and '.texi'.
my ($spfx, $ssfx) = ($source =~ /^(.*?)(\.[^.]*)?$/);
my ($dpfx, $dsfx) = ($dest =~ /^(.*?)(\.[^.]*)?$/);
if ($infobase eq $texi)
{
# FIXME: report line number.
- err_am "texinfo file `$texi' has unrecognized extension";
+ err_am "texinfo file '$texi' has unrecognized extension";
next;
}
# make would not rebuild it in the build tree.
# (2) having two copies of .info files, one in the source tree
# and one (newer) in the build tree is not a problem
- # because `make dist' always pick files in the build tree
+ # because 'make dist' always pick files in the build tree
# first.
# However it turned out the be a bad idea for several reasons:
# * Tru64, OpenBSD, and FreeBSD (not NetBSD) Make do not behave
# build tree can be annoying during development because
# - if the files is kept under CVS, you really want it
# to be updated in the source tree
- # - it is confusing that `make distclean' does not erase
+ # - it is confusing that 'make distclean' does not erase
# all files in the build tree.
#
# Consequently, starting with Automake 1.8, .info files are
# If a vers*.texi file is needed, emit the rule.
if ($vtexi)
{
- err_am ("`$vtexi', included in `$texi', "
- . "also included in `$versions{$vtexi}'")
+ err_am ("'$vtexi', included in '$texi', "
+ . "also included in '$versions{$vtexi}'")
if defined $versions{$vtexi};
$versions{$vtexi} = $texi;
# Handle all Texinfo source.
sub handle_texinfo ()
{
- reject_var 'TEXINFOS', "`TEXINFOS' is an anachronism; use `info_TEXINFOS'";
+ reject_var 'TEXINFOS', "'TEXINFOS' is an anachronism; use 'info_TEXINFOS'";
# FIXME: I think this is an obsolete future feature name.
reject_var 'html_TEXINFOS', "HTML generation not yet supported";
# Handle any man pages.
sub handle_man_pages
{
- reject_var 'MANS', "`MANS' is an anachronism; use `man_MANS'";
+ reject_var 'MANS', "'MANS' is an anachronism; use 'man_MANS'";
# Find all the sections in use. We do this by first looking for
# "standard" sections, and then looking for any additional
{
foreach ($var->value_as_list_recursive)
{
- # A page like `foo.1c' goes into man1dir.
+ # A page like 'foo.1c' goes into man1dir.
if (/\.([0-9a-z])([a-z]*)$/)
{
$sections{$1} = 1;
if (var ('SUBDIRS'))
{
$output_rules .= ("tags-recursive:\n"
- . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
+ . "\tlist='\$(SUBDIRS)'; for subdir in \$\$list; do \\\n"
# Never fail here if a subdir fails; it
# isn't important.
. "\t test \"\$\$subdir\" = . || (\$(am__cd) \$\$subdir"
&depend ('.MAKE', 'tags-recursive');
$output_rules .= ("ctags-recursive:\n"
- . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
+ . "\tlist='\$(SUBDIRS)'; for subdir in \$\$list; do \\\n"
# Never fail here if a subdir fails; it
# isn't important.
. "\t test \"\$\$subdir\" = . || (\$(am__cd) \$\$subdir"
&depend ('.MAKE', 'ctags-recursive');
$output_rules .= ("cscopelist-recursive:\n"
- . "\tlist=\'\$(SUBDIRS)\'; for subdir in \$\$list; do \\\n"
+ . "\tlist='\$(SUBDIRS)'; for subdir in \$\$list; do \\\n"
# Never fail here if a subdir fails; it
# isn't important.
. "\t test \"\$\$subdir\" = . || (\$(am__cd) \$\$subdir"
set_seen 'TAGS_DEPENDENCIES';
}
elsif (reject_var ('TAGS_DEPENDENCIES',
- "it doesn't make sense to define `TAGS_DEPENDENCIES'"
- . " without\nsources or `ETAGS_ARGS'"))
+ "it doesn't make sense to define 'TAGS_DEPENDENCIES'"
+ . " without\nsources or 'ETAGS_ARGS'"))
{
}
else
}
}
-# Handle multilib support.
-sub handle_multilib
-{
- if ($seen_multilib && $relative_dir eq '.')
- {
- $output_rules .= &file_contents ('multilib', new Automake::Location);
- push (@all, 'all-multi');
- }
-}
-
# user_phony_rule ($NAME)
# -----------------------
my %transform;
# Define DIST_SUBDIRS. This must always be done, regardless of the
- # no-dist setting: target like `distclean' or `maintainer-clean' use it.
+ # no-dist setting: target like 'distclean' or 'maintainer-clean' use it.
my $subdirs = var ('SUBDIRS');
if ($subdirs)
{
}
else
{
- # We always define this because that is what `distclean'
+ # We always define this because that is what 'distclean'
# wants.
define_pretty_variable ('DIST_SUBDIRS', TRUE, INTERNAL,
'$(SUBDIRS)');
&push_dist_common ($cfile);
}
- # Don't use `elsif' here because a file might meaningfully
+ # Don't use 'elsif' here because a file might meaningfully
# appear in both directories.
if ($check_aux && dir_has_case_matching_file ($config_aux_dir, $cfile))
{
# %dist_common if we think we need to. If the file appears in our
# directory, we would have discovered it already, so we don't
# check that. But if the file is in a subdir without a Makefile,
- # we want to distribute it here if we are doing `.'. Ugly!
+ # we want to distribute it here if we are doing '.'. Ugly!
# Also, in some corner cases, it's possible that the following code
# will cause the same file to appear in the $(DIST_COMMON) variables
# of two distinct Makefiles; but this is not a problem, since the
- # `distdir' target in `lib/am/distdir.am' can deal with the same
+ # 'distdir' target in 'lib/am/distdir.am' can deal with the same
# file being distributed multiple times.
# See also automake bug#9651.
if ($relative_dir eq '.')
}
# Files to distributed. Don't use ->value_as_list_recursive
- # as it recursively expands `$(dist_pkgdata_DATA)' etc.
+ # as it recursively expands '$(dist_pkgdata_DATA)' etc.
my @dist_common = split (' ', rvar ('DIST_COMMON')->variable_value);
@dist_common = uniq (sort for_dist_common (@dist_common));
variable_delete 'DIST_COMMON';
$transform{'DISTCHECK-HOOK'} = !! rule 'distcheck-hook';
$transform{'GETTEXT'} = $seen_gettext && !$seen_gettext_external;
- # If the target `dist-hook' exists, make sure it is run. This
+ # If the target 'dist-hook' exists, make sure it is run. This
# allows users to do random weird things to the distribution
# before it is packaged up.
push (@dist_targets, 'dist-hook')
error $where, "required directory $reldir/$dir does not exist"
unless -d "$reldir/$dir";
- # If an `obj/' directory exists, BSD make will enter it before
- # reading `Makefile'. Hence the `Makefile' in the current directory
+ # If an 'obj/' directory exists, BSD make will enter it before
+ # reading 'Makefile'. Hence the 'Makefile' in the current directory
# will not be read.
#
# % cat Makefile
# echo World
# World
msg ('portability', $where,
- "naming a subdirectory `obj' causes troubles with BSD make")
+ "naming a subdirectory 'obj' causes troubles with BSD make")
if $dir eq 'obj';
- # `aux' is probably the most important of the following forbidden name,
+ # 'aux' is probably the most important of the following forbidden name,
# since it's tempting to use it as an AC_CONFIG_AUX_DIR.
msg ('portability', $where,
- "name `$dir' is reserved on W32 and DOS platforms")
+ "name '$dir' is reserved on W32 and DOS platforms")
if grep (/^\Q$dir\E$/i, qw/aux lpt1 lpt2 lpt3 com1 com2 com3 com4 con prn/);
}
{
push (@ac_deps, '$(ACLOCAL_M4_SOURCES)');
msg_var ('obsolete', 'ACLOCAL_M4_SOURCES',
- "`ACLOCAL_M4_SOURCES' is obsolete.\n"
+ "'ACLOCAL_M4_SOURCES' is obsolete.\n"
. "It should be safe to simply remove it");
}
else
{
msg ('error', $ac_config_files_location{$file},
- "required file `$i' not found")
+ "required file '$i' not found")
unless $i =~ /\$/ || exists $output_files{$i} || -f $i;
($i) = prepend_srcdir ($i);
push_dist_common ($i);
}
reject_var ('CONFIG_HEADER',
- "`CONFIG_HEADER' is an anachronism; now determined "
- . "automatically\nfrom `$configure_ac'");
+ "'CONFIG_HEADER' is an anachronism; now determined "
+ . "automatically\nfrom '$configure_ac'");
my @config_h;
foreach my $spec (@config_headers)
# We skip files that aren't in this directory. However, if
# the file's directory does not have a Makefile, and we are
- # currently doing `.', then we create a rule to rebuild the
+ # currently doing '.', then we create a rule to rebuild the
# file in the subdir.
my $fd = dirname ($file);
if ($fd ne $relative_dir)
{
# We skip links that aren't in this directory. However, if
# the link's directory does not have a Makefile, and we are
- # currently doing `.', then we add the link to CONFIG_CLEAN_FILES
- # in `.'s Makefile.in.
+ # currently doing '.', then we add the link to CONFIG_CLEAN_FILES
+ # in '.'s Makefile.in.
my $local = basename ($link);
my $fd = dirname ($link);
if ($fd ne $relative_dir)
my $fd = dirname ($file);
# We distribute files that are in this directory.
- # At the top-level (`.') we also distribute files whose
+ # At the top-level ('.') we also distribute files whose
# directory does not have a Makefile.
if (($fd eq $relative_dir)
|| ($relative_dir eq '.' && ! &is_make_dir ($fd)))
my @subdirs = $subdirs->value_as_list_recursive;
msg_var ('syntax', $subdirs,
- "AM_GNU_GETTEXT used but `po' not in SUBDIRS")
+ "AM_GNU_GETTEXT used but 'po' not in SUBDIRS")
if ! grep ($_ eq 'po', @subdirs);
# intl/ is not required when AM_GNU_GETTEXT is called with the
- # `external' option and AM_GNU_GETTEXT_INTL_SUBDIR is not called.
+ # 'external' option and AM_GNU_GETTEXT_INTL_SUBDIR is not called.
msg_var ('syntax', $subdirs,
- "AM_GNU_GETTEXT used but `intl' not in SUBDIRS")
+ "AM_GNU_GETTEXT used but 'intl' not in SUBDIRS")
if (! ($seen_gettext_external && ! $seen_gettext_intl)
&& ! grep ($_ eq 'intl', @subdirs));
# intl/ should not be used with AM_GNU_GETTEXT([external]), except
# if AM_GNU_GETTEXT_INTL_SUBDIR is called.
msg_var ('syntax', $subdirs,
- "`intl' should not be in SUBDIRS when "
+ "'intl' should not be in SUBDIRS when "
. "AM_GNU_GETTEXT([external]) is used")
if ($seen_gettext_external && ! $seen_gettext_intl
&& grep ($_ eq 'intl', @subdirs));
sub handle_footer
{
reject_rule ('.SUFFIXES',
- "use variable `SUFFIXES', not target `.SUFFIXES'");
+ "use variable 'SUFFIXES', not target '.SUFFIXES'");
# Note: AIX 4.1 /bin/make will fail if any suffix rule appears
# before .SUFFIXES. So we make sure that .SUFFIXES appears before
}
-# Generate `make install' rules.
+# Generate 'make install' rules.
sub handle_install ()
{
$output_rules .= &file_contents
{
my ($makefile) = @_;
- # Output `all-am'.
+ # Output 'all-am'.
# Put this at the beginning for the sake of non-GNU makes. This
# is still wrong if these makes can run parallel jobs. But it is
if dirname ($out) eq $relative_dir;
}
- # Install `all' hooks.
+ # Install 'all' hooks.
push (@all, "all-local")
if user_phony_rule "all-local";
&depend ('.PHONY', 'all-am', 'all');
- # Output `all'.
+ # Output 'all'.
my @local_headers = ();
push @local_headers, '$(BUILT_SOURCES)'
{
# We need to make sure config.h is built before we recurse.
# We also want to make sure that built sources are built
- # before any ordinary `all' targets are run. We can't do this
+ # before any ordinary 'all' targets are run. We can't do this
# by changing the order of dependencies to the "all" because
# that breaks when using parallel makes. Instead we handle
# things explicitly.
else
{
# The check target must depend on the local equivalent of
- # `all', to ensure all the primary targets are built. Then it
+ # 'all', to ensure all the primary targets are built. Then it
# must build the local check rules.
$output_rules .= "check-am: all-am\n";
if (@check)
}
depend '.PHONY', 'check', 'check-am';
- # Handle recursion. We have to honor BUILT_SOURCES like for `all:'.
+ # Handle recursion. We have to honor BUILT_SOURCES like for 'all:'.
$output_rules .= ("check: "
. (var ('BUILT_SOURCES')
? "\$(BUILT_SOURCES)\n\t\$(MAKE) \$(AM_MAKEFLAGS) "
unless exists $rms{$when};
my $rm = "rm -f $file";
- # If file is a variable, make sure when don't call `rm -f' without args.
+ # If file is a variable, make sure when don't call 'rm -f' without args.
$rm ="test -z \"$file\" || $rm"
if ($file =~ /^\s*\$(\(.*\)|\{.*\})\s*$/);
# &target_cmp ($A, $B)
# --------------------
-# Subroutine for &handle_factored_dependencies to let `.PHONY' and
-# other `.TARGETS' be last.
+# Subroutine for &handle_factored_dependencies to let '.PHONY' and
+# other '.TARGETS' be last.
sub target_cmp
{
return 0 if $a eq $b;
{
my $x = $utarg;
$x =~ s/-.*-/-/;
- reject_rule ($utarg, "use `$x', not `$utarg'");
+ reject_rule ($utarg, "use '$x', not '$utarg'");
}
reject_rule ('install-local',
- "use `install-data-local' or `install-exec-local', "
- . "not `install-local'");
+ "use 'install-data-local' or 'install-exec-local', "
+ . "not 'install-local'");
reject_rule ('install-hook',
- "use `install-data-hook' or `install-exec-hook', "
- . "not `install-hook'");
+ "use 'install-data-hook' or 'install-exec-hook', "
+ . "not 'install-hook'");
# Install the -local hooks.
foreach (keys %dependencies)
# to append dependencies. This would not work if Automake
# refrained from defining its own .PHONY target as it does
# with other overridden targets.
- # Likewise for `.MAKE'.
+ # Likewise for '.MAKE'.
my @undefined_conds = (TRUE,);
if ($_ ne '.PHONY' && $_ ne '.MAKE')
{
}
else
{
- prog_error ("test suffix `$test_suffix' lacks leading dot")
+ prog_error ("test suffix '$test_suffix' lacks leading dot")
unless $test_suffix =~ m/^\.(.*)/;
$pfx = uc ($1) . '_';
$generic = 1;
# The "test driver" program, deputed to handle tests protocol used by
# test scripts. By default, it's assumed that no protocol is used,
# so we fall back to the old "parallel-tests" behaviour, implemented
- # by the `test-driver' auxiliary script.
+ # by the 'test-driver' auxiliary script.
if (! var "${pfx}LOG_DRIVER")
{
require_conf_file ($parallel_tests_option->{position}, FOREIGN,
{
foreach my $c ('DEJATOOL', 'RUNTEST', 'RUNTESTFLAGS')
{
- reject_var ($c, "`$c' defined but `dejagnu' not in "
- . "`AUTOMAKE_OPTIONS'");
+ reject_var ($c, "'$c' defined but 'dejagnu' not in "
+ . "'AUTOMAKE_OPTIONS'");
}
}
if ($var->has_conditional_contents)
{
msg_var 'unsupported', $var,
- "`TEST_EXTENSIONS' cannot have conditional contents";
+ "'TEST_EXTENSIONS' cannot have conditional contents";
}
my @test_suffixes = $var->value_as_list_recursive;
if ((my @invalid_test_suffixes =
if ($val =~ /(\$\((top_)?srcdir\))\//o)
{
msg ('error', $subvar->rdef ($cond)->location,
- "parallel-tests: using `$1' in TESTS is currently broken: `$val'");
+ "parallel-tests: using '$1' in TESTS is currently broken: '$val'");
}
foreach my $test_suffix (@test_suffixes)
if ($package_version !~ /^$GNITS_VERSION_PATTERN$/)
{
msg ('error-gnits', $package_version_location,
- "version `$package_version' doesn't follow " .
+ "version '$package_version' doesn't follow " .
"Gnits standards");
}
if (defined $1 && -f 'README-alpha')
# Handle $local:$input syntax.
my ($local, @rest) = split (/:/);
@rest = ("$local.in",) unless @rest;
- msg ('portability', $where,
- "omit leading `./' from config file names such as `$local',"
- . "\nas not all make implementations treat `file' and `./file' equally")
- if ($local =~ /^\.\//);
+ # Keep in sync with 'conffile-leading-dot.test'.
+ msg ('unsupported', $where,
+ "omit leading './' from config file names such as '$local';"
+ . "\nremake rules might be subtly broken otherwise")
+ if ($local =~ /^\.\//);
my $input = locate_am @rest;
if ($input)
{
AC_REQUIRE_AUX_FILE => 1,
AC_SUBST_TRACE => 1,
AM_AUTOMAKE_VERSION => 1,
+ AM_PROG_MKDIR_P => 0, # FIXME: to be removed in 1.13
AM_CONDITIONAL => 2,
- AM_ENABLE_MULTILIB => 0,
AM_GNU_GETTEXT => 0,
AM_GNU_GETTEXT_INTL_SUBDIR => 0,
AM_INIT_AUTOMAKE => 0,
my $traces = ($ENV{AUTOCONF} || '@am_AUTOCONF@') . " ";
- # Use a separator unlikely to be used, not `:', the default, which
+ # Use a separator unlikely to be used, not ':', the default, which
# has a precise meaning for AC_CONFIG_FILES and so on.
$traces .= join (' ',
map { "--trace=$_" . ':\$f:\$l::\$d::\$n::\${::}%' }
$where = new Automake::Location $here;
my $macro = $args[0];
- prog_error ("unrequested trace `$macro'")
+ prog_error ("unrequested trace '$macro'")
unless exists $traced{$macro};
# Skip and diagnose malformed calls.
$seen_automake_version = 1;
}
- elsif ($macro eq 'AM_CONDITIONAL')
+ elsif ($macro eq 'AM_PROG_MKDIR_P') # FIXME: to be removed in 1.13
{
- $configure_cond{$args[1]} = $where;
+ msg 'obsolete', $where, <<'EOF';
+The 'AM_PROG_MKDIR_P' macro is deprecated, and will soon be removed.
+You should use the Autoconf-provided 'AC_PROG_MKDIR_P' macro instead,
+and use '$(MKDIR_P)' instead of '$(mkdir_p)'in your Makefile.am files.
+EOF
}
- elsif ($macro eq 'AM_ENABLE_MULTILIB')
+ elsif ($macro eq 'AM_CONDITIONAL')
{
- $seen_multilib = $where;
+ $configure_cond{$args[1]} = $where;
}
elsif ($macro eq 'AM_GNU_GETTEXT')
{
$seen_init_automake = $where;
if (defined $args[2])
{
+ msg 'obsolete', $where, <<'EOF';
+AM_INIT_AUTOMAKE: two- and three-arguments forms are deprecated. For more info, see:
+http://www.gnu.org/software/automake/manual/automake.html#Modernize-AM_INIT_AUTOMAKE-invocation
+EOF
$package_version = $args[2];
$package_version_location = $where;
}
|| $macro eq 'm4_sinclude'
|| $macro eq 'sinclude')
{
- # Skip missing `sinclude'd files.
+ # Skip missing 'sinclude'd files.
next if $macro ne 'm4_include' && ! -f $args[1];
# Some modified versions of Autoconf don't use
# &scan_autoconf_files ()
# -----------------------
-# Check whether we use `configure.ac' or `configure.in'.
-# Scan it (and possibly `aclocal.m4') for interesting things.
+# Check whether we use 'configure.ac' or 'configure.in'.
+# Scan it (and possibly 'aclocal.m4') for interesting things.
# We must scan aclocal.m4 because there might be AC_SUBSTs and such there.
sub scan_autoconf_files ()
{
{
require_conf_file ($required_aux_file{$file}->get, FOREIGN, $file)
}
- err_am "`install.sh' is an anachronism; use `install-sh' instead"
+ err_am "'install.sh' is an anachronism; use 'install-sh' instead"
if -f $config_aux_dir . '/install.sh';
# Preserve dist_common for later.
my $cygnus = option 'cygnus';
return unless $cygnus;
+ # This feature is deprecated, will be removed in the next
+ # Automake major release.
+ msg 'obsolete', $cygnus->get,
+ "support for Cygnus-style trees is deprecated";
+
set_strictness ('foreign');
set_option ('no-installinfo', $cygnus);
set_option ('no-dependencies', $cygnus);
set_option ('no-dist', $cygnus);
- err_ac "`AM_MAINTAINER_MODE' required when --cygnus specified"
+ err_ac "'AM_MAINTAINER_MODE' required when --cygnus specified"
if !$seen_maint_mode;
}
for my $opt ('no-installman', 'no-installinfo')
{
msg ('error-gnu', option $opt,
- "option `$opt' disallowed by GNU standards")
+ "option '$opt' disallowed by GNU standards")
if option $opt;
}
}
#
# Functions to handle files of each language.
-# Each `lang_X_rewrite($DIRECTORY, $BASE, $EXT)' function follows a
+# Each 'lang_X_rewrite($DIRECTORY, $BASE, $EXT)' function follows a
# simple formula: Return value is LANG_SUBDIR if the resulting object
# file should be in a subdir if the source file is, LANG_PROCESS if
# file is to be dealt with, LANG_IGNORE otherwise.
# libtool is always able to put the object at the proper place,
# so we do not have to require AM_PROG_CC_C_O when building .lo files.
msg_var ('portability', $var,
- "compiling `$base.c' in subdir requires "
- . "`AM_PROG_CC_C_O' in `$configure_ac'",
+ "compiling '$base.c' in subdir requires "
+ . "'AM_PROG_CC_C_O' in '$configure_ac'",
uniq_scope => US_GLOBAL,
uniq_part => 'AM_PROG_CC_C_O subdir')
unless $seen_cc_c_o || $obj eq '.lo';
&& $obj ne '.lo')
{
msg_var ('portability',
- $var, "compiling `$base.c' with per-target flags requires "
- . "`AM_PROG_CC_C_O' in `$configure_ac'",
+ $var, "compiling '$base.c' with per-target flags requires "
+ . "'AM_PROG_CC_C_O' in '$configure_ac'",
uniq_scope => US_GLOBAL,
uniq_part => 'AM_PROG_CC_C_O per-target')
}
return &lang_sub_obj;
}
+# Rewrite a single Objective C++ file.
+sub lang_objcxx_rewrite
+{
+ return &lang_sub_obj;
+}
+
# Rewrite a single Unified Parallel C file.
sub lang_upc_rewrite
{
my ($self, $name) = @_;
my $derived = canonicalize ($name);
- my $varname = $derived . '_SOURCES';
- my $var = var ($varname);
+ my $var = var "${derived}_SOURCES";
+ return unless $var;
- if ($var)
+ my @vala_sources = grep { /\.(vala|vapi)$/ } ($var->value_as_list_recursive);
+
+ # For automake bug#11229.
+ return unless @vala_sources;
+
+ foreach my $vala_file (@vala_sources)
{
- foreach my $file ($var->value_as_list_recursive)
+ my $c_file = $vala_file;
+ if ($c_file =~ s/(.*)\.vala$/$1.c/)
{
- $output_rules .= "\$(srcdir)/$file: \$(srcdir)/${derived}_vala.stamp\n"
+ $c_file = "\$(srcdir)/$c_file";
+ $output_rules .= "$c_file: \$(srcdir)/${derived}_vala.stamp\n"
. "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
. "\t\@if test -f \$@; then :; else \\\n"
. "\t \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
- . "\tfi\n"
- if $file =~ s/(.*)\.vala$/$1.c/;
+ . "\tfi\n";
+ $clean_files{$c_file} = MAINTAINER_CLEAN;
}
}
if (grep (/$lastflag/, ('-H', '-h', '--header', '--internal-header',
'--vapi', '--internal-vapi', '--gir')))
{
- my $headerfile = $flag;
- $output_rules .= "\$(srcdir)/$headerfile: \$(srcdir)/${derived}_vala.stamp\n"
+ my $headerfile = "\$(srcdir)/$flag";
+ $output_rules .= "$headerfile: \$(srcdir)/${derived}_vala.stamp\n"
. "\t\@if test -f \$@; then :; else rm -f \$(srcdir)/${derived}_vala.stamp; fi\n"
. "\t\@if test -f \$@; then :; else \\\n"
. "\t \$(MAKE) \$(AM_MAKEFLAGS) \$(srcdir)/${derived}_vala.stamp; \\\n"
my $compile = $self->compile;
- # Rewrite each occurrence of `AM_VALAFLAGS' in the compile
- # rule into `${derived}_VALAFLAGS' if it exists.
+ # Rewrite each occurrence of 'AM_VALAFLAGS' in the compile
+ # rule into '${derived}_VALAFLAGS' if it exists.
my $val = "${derived}_VALAFLAGS";
$compile =~ s/\(AM_VALAFLAGS\)/\($val\)/
if set_seen ($val);
# VALAFLAGS is a user variable (per GNU Standards),
# it should not be overridden in the Makefile...
- check_user_variables ['VALAFLAGS'];
+ check_user_variables 'VALAFLAGS';
my $dirname = dirname ($name);
my $verbose = verbose_flag ('VALAC');
my $silent = silent_flag ();
+ my $stampfile = "\$(srcdir)/${derived}_vala.stamp";
$output_rules .=
- "\$(srcdir)/${derived}_vala.stamp: \$(${derived}_SOURCES)\n".
+ "\$(srcdir)/${derived}_vala.stamp: @vala_sources\n".
# Since the C files generated from the vala sources depend on the
# ${derived}_vala.stamp file, we must ensure its timestamp is older than
# those of the C files generated by the valac invocation below (this is
# especially important on systems with sub-second timestamp resolution).
# Thus we need to create the stamp file *before* invoking valac, and to
# move it to its final location only after valac has been invoked.
- "\t${silent}rm -f \$@ && echo stamp > \$@-t\n".
- "\t${verbose}\$(am__cd) \$(srcdir) && ${compile} \$(${derived}_SOURCES)\n".
- "\t${silent}mv -f \$@-t \$@\n";
+ "\t${silent}rm -f \$\@ && echo stamp > \$\@-t\n".
+ "\t${verbose}\$(am__cd) \$(srcdir) && $compile @vala_sources\n".
+ "\t${silent}mv -f \$\@-t \$\@\n";
- push_dist_common ("${derived}_vala.stamp");
+ push_dist_common ($stampfile);
- $clean_files{"${derived}_vala.stamp"} = MAINTAINER_CLEAN;
+ $clean_files{$stampfile} = MAINTAINER_CLEAN;
}
# Add output rules to invoke valac and create stamp file as a witness
{
my ($self, $aggregate, $output, $input, %transform) = @_;
- # If some relevant *YFLAGS variable contains the `-d' flag, we'll
+ # If some relevant *YFLAGS variable contains the '-d' flag, we'll
# have to to generate special code.
my $yflags_contains_minus_d = 0;
if ($yflagsvar->has_conditional_contents)
{
msg_var ('unsupported', $yflagsvar,
- "`${pfx}YFLAGS' cannot have conditional contents");
+ "'${pfx}YFLAGS' cannot have conditional contents");
}
else
{
if ($yflags_contains_minus_d)
{
- (my $output_base = $output) =~ s/$KNOWN_EXTENSIONS_PATTERN$//;
- my $header = $output_base . '.h';
-
- # Found a `-d' that applies to the compilation of this file.
+ # Found a '-d' that applies to the compilation of this file.
# Add a dependency for the generated header file, and arrange
# for that file to be included in the distribution.
+
+ # The extension of the output file (e.g., '.c' or '.cxx').
+ # We'll need it to compute the name of the generated header file.
+ (my $output_ext = basename ($output)) =~ s/.*(\.[^.]+)$/$1/;
+
+ # We know that a yacc input should be turned into either a C or
+ # C++ output file. We depend on this fact (here and in yacc.am),
+ # so check that it really holds.
+ my $lang = $languages{$extension_map{$output_ext}};
+ prog_error "invalid output name '$output' for yacc file '$input'"
+ if (!$lang || ($lang->name ne 'c' && $lang->name ne 'cxx'));
+
+ (my $header_ext = $output_ext) =~ s/c/h/g;
+ # Quote $output_ext in the regexp, so that dots in it are taken
+ # as literal dots, not as metacharacters.
+ (my $header = $output) =~ s/\Q$output_ext\E$/$header_ext/;
+
foreach my $cond (Automake::Rule::define (${header}, 'internal',
RULE_AUTOMAKE, TRUE,
INTERNAL))
# compile a lex file.
sub lang_lex_target_hook
{
- my ($self, $aggregate, $output, $input) = @_;
- # If the files are built in the build directory, then we want to
- # remove them with `make clean'. If they are in srcdir they
- # shouldn't be touched. However, we can't determine this
- # statically, and the GNU rules say that yacc/lex output files
- # should be removed by maintainer-clean. So that's what we do.
- $clean_files{$output} = MAINTAINER_CLEAN;
+ my ($self, $aggregate, $output, $input, %transform) = @_;
+ # The GNU rules say that yacc/lex output files should be removed
+ # by maintainer-clean. However, if the files are not distributed,
+ # then we want to remove them with "make clean"; otherwise,
+ # "make distcheck" will fail.
+ $clean_files{$output} = $transform{'DIST_SOURCE'} ? MAINTAINER_CLEAN : CLEAN;
}
# This is a helper for both lex and yacc.
return if defined $language_scratch{'yacc-done'};
$language_scratch{'yacc-done'} = 1;
- reject_var 'YACCFLAGS', "`YACCFLAGS' obsolete; use `YFLAGS' instead";
+ reject_var 'YACCFLAGS', "'YACCFLAGS' obsolete; use 'YFLAGS' instead";
yacc_lex_finish_helper;
}
{
my (%linkers) = @_;
- foreach my $l (qw(GCJLINK CXXLINK F77LINK FCLINK OBJCLINK UPCLINK))
+ foreach my $l (qw(GCJLINK OBJCXXLINK CXXLINK F77LINK FCLINK OBJCLINK UPCLINK))
{
return $l if defined $linkers{$l};
}
{
if (exists $link_languages{$link})
{
- prog_error ("`$link' has different definitions in "
+ prog_error ("'$link' has different definitions in "
. $lang->name . " and " . $link_languages{$link}->name)
if $lang->link ne $link_languages{$link}->link;
}
# derive_suffix ($EXT, $OBJ)
# --------------------------
# This function is used to find a path from a user-specified suffix $EXT
-# to $OBJ or to some other suffix we recognize internally, e.g. `cc'.
+# to $OBJ or to some other suffix we recognize internally, e.g. 'cc'.
sub derive_suffix ($$)
{
my ($source_ext, $obj) = @_;
my %_am_macro_for_cond =
(
AMDEP => "one of the compiler tests\n"
- . " AC_PROG_CC, AC_PROG_CXX, AC_PROG_CXX, AC_PROG_OBJC,\n"
+ . " AC_PROG_CC, AC_PROG_CXX, AC_PROG_OBJC, AC_PROG_OBJCXX,\n"
. " AM_PROG_AS, AM_PROG_GCJ, AM_PROG_UPC",
am__fastdepCC => 'AC_PROG_CC',
am__fastdepCCAS => 'AM_PROG_AS',
am__fastdepCXX => 'AC_PROG_CXX',
am__fastdepGCJ => 'AM_PROG_GCJ',
am__fastdepOBJC => 'AC_PROG_OBJC',
+ am__fastdepOBJCXX => 'AC_PROG_OBJCXX',
am__fastdepUPC => 'AM_PROG_UPC'
);
if (exists $_am_macro_for_cond{$cond})
{
my $mac = $_am_macro_for_cond{$cond};
- $text .= "\n The usual way to define `$cond' is to add ";
- $text .= ($mac =~ / /) ? $mac : "`$mac'";
- $text .= "\n to `$configure_ac' and run `aclocal' and `autoconf' again";
+ $text .= "\n The usual way to define '$cond' is to add ";
+ $text .= ($mac =~ / /) ? $mac : "'$mac'";
+ $text .= "\n to '$configure_ac' and run 'aclocal' and 'autoconf' again";
# These warnings appear in Automake files (depend2.am),
# so there is no need to display them more than once:
$scope = US_GLOBAL;
# define_compiler_variable ($LANG)
# --------------------------------
-# Define a compiler variable. We also handle defining the `LT'
+# Define a compiler variable. We also handle defining the 'LT'
# version of the command when using libtool.
sub define_compiler_variable ($)
{
my $xlink = $linker ? $linker : 'LINK';
my $lang = $link_languages{$xlink};
- prog_error "Unknown language for linker variable `$xlink'"
+ prog_error "Unknown language for linker variable '$xlink'"
unless $lang;
my $link_command = $lang->link;
. "--mode=link " . $link_command;
}
- # Rewrite each occurrence of `AM_$flag' in the link
- # command into `${derived}_$flag' if it exists.
+ # Rewrite each occurrence of 'AM_$flag' in the link
+ # command into '${derived}_$flag' if it exists.
my $orig_command = $link_command;
my @flags = (@{$lang->flags}, 'LDFLAGS');
push @flags, 'LIBTOOLFLAGS' if var 'LIBTOOL';
{
my ($where, $line) = @_;
- # Ignore `##' lines.
+ # Ignore '##' lines.
return 0 if $$line =~ /$IGNORE_PATTERN/o;
# Catch and fix a common error.
}
elsif ($prev_state == IN_COMMENT)
{
- # If the line doesn't start with a `#', add it.
+ # If the line doesn't start with a '#', add it.
# We do this because a continued comment like
# # A = foo \
# bar \
$last_where = $where->clone;
if ($3 ne '' && substr ($3, -1) eq "\\")
{
- # We preserve the `\' because otherwise the long lines
+ # We preserve the '\' because otherwise the long lines
# that are generated will be truncated by broken
- # `sed's.
+ # 'sed's.
$last_var_value = $3 . "\n";
}
# Normally we try to output variable definitions in the
# Always use the $(top_srcdir) prefix in DIST_COMMON,
# otherwise OSF make will implicitly copy the included
- # file in the build tree during `make distdir' to satisfy
+ # file in the build tree during "make distdir" to satisfy
# the dependency.
# (subdircond2.test and subdircond3.test will fail.)
push_dist_common ("\$\(top_srcdir\)/$path");
push (@include_stack, "\$\(srcdir\)/$path");
# Always use the $(srcdir) prefix in DIST_COMMON,
# otherwise OSF make will implicitly copy the included
- # file in the build tree during `make distdir' to satisfy
+ # file in the build tree during "make distdir" to satisfy
# the dependency.
# (subdircond2.test and subdircond3.test will fail.)
push_dist_common ("\$\(srcdir\)/$path");
$path = $relative_dir . "/" . $path if $relative_dir ne '.';
}
- $where->push_context ("`$path' included from here");
+ $where->push_context ("'$path' included from here");
&read_am_file ($path, $where);
$where->pop_context;
}
$output_trailer .= $cond->subst_string;
$output_trailer .= $_;
$comment = $spacing = '';
- error $where, "`#' comment at start of rule is unportable"
+ error $where, "'#' comment at start of rule is unportable"
if $_ =~ /^\t\s*\#/;
}
$output_vars .= $gen_copyright;
# We want to predefine as many variables as possible. This lets
- # the user set them with `+=' in Makefile.am.
+ # the user set them with '+=' in Makefile.am.
&define_standard_variables;
# Read user file, which might override some of our values.
{
my ($token, $transform, $key) = @_;
my $res = $transform->{$key};
- prog_error "Unknown key `$key' in `$token'" unless defined $res;
+ prog_error "Unknown key '$key' in '$token'" unless defined $res;
return $res;
}
}
}
-
-# @PARAGRAPHS
-# &make_paragraphs ($MAKEFILE, [%TRANSFORM])
-# ------------------------------------------
-# Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
-# paragraphs.
-sub make_paragraphs ($%)
+# $TEXT
+# preprocess_file ($MAKEFILE, [%TRANSFORM])
+# -----------------------------------------
+# Load a $MAKEFILE, apply the %TRANSFORM, and return the result.
+# No extra parsing of post-processing is done (i.e., recognition of
+# rules declaration or of make variables definitions).
+sub preprocess_file ($%)
{
my ($file, %transform) = @_;
'LIBTOOL' => !! var ('LIBTOOL'),
'NONLIBTOOL' => 1,
- 'FIRST' => ! $transformed_files{$file},
%transform);
- $transformed_files{$file} = 1;
- $_ = $am_file_cache{$file};
-
- if (! defined $_)
+ if (! defined ($_ = $am_file_cache{$file}))
{
verb "reading $file";
# Swallow the whole file.
$_ = $fc_file->getline;
$/ = $saved_dollar_slash;
$fc_file->close;
-
# Remove ##-comments.
# Besides we don't need more than two consecutive new-lines.
s/(?:$IGNORE_PATTERN|(?<=\n\n)\n+)//gom;
-
+ # Remember the contents of the just-read file.
$am_file_cache{$file} = $_;
}
| \? !? [\w\-]+ \?
)/transform($&, \%transform)/gex;
# transform() may have added some ##%-comments to strip.
- # (we use `##%' instead of `##' so we can distinguish ##%##%##% from
+ # (we use '##%' instead of '##' so we can distinguish ##%##%##% from
# ####### and do not remove the latter.)
s/^[ \t]*(?:##%)+.*\n//gm;
- # Split at unescaped new lines.
- my @lines = split (/(?<!\\)\n/, $_);
+ return $_;
+}
+
+
+# @PARAGRAPHS
+# &make_paragraphs ($MAKEFILE, [%TRANSFORM])
+# ------------------------------------------
+# Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
+# paragraphs.
+sub make_paragraphs ($%)
+{
+ my ($file, %transform) = @_;
+ $transform{FIRST} = !$transformed_files{$file};
+ $transformed_files{$file} = 1;
+
+ my @lines = split /(?<!\\)\n/, preprocess_file ($file, %transform);
my @res;
while (defined ($_ = shift @lines))
if ($cond != FALSE)
{
my $file = ($is_am ? "$libdir/am/" : '') . $1;
- $where->push_context ("`$file' included from here");
- # N-ary `.=' fails.
+ $where->push_context ("'$file' included from here");
+ # N-ary '.=' fails.
my ($com, $vars, $rules)
= file_contents_internal ($is_am, $file, $where, %transform);
$where->pop_context;
# FIXME: 3. We are not robust to people defining a subset
# of a previously defined "multiple-target" rule. E.g.
- # `foo:' after `foo bar:'.
+ # 'foo:' after 'foo bar:'.
# Output only if not in FALSE.
if (defined $dependencies{$_} && $cond != FALSE)
elsif (/$ASSIGNMENT_PATTERN/mso)
{
my ($var, $type, $val) = ($1, $2, $3);
- error $where, "variable `$var' with trailing backslash"
+ error $where, "variable '$var' with trailing backslash"
if /\\$/;
$is_rule = 0;
else
{
# This isn't an error; it is probably some tokens which
- # configure is supposed to replace, such as `@SET-MAKE@',
+ # configure is supposed to replace, such as '@SET-MAKE@',
# or some part of a rule cut by an if/endif.
if (! $cond->false && ! ($is_rule && $discard_rule))
{
# &am_primary_prefixes ($PRIMARY, $CAN_DIST, @PREFIXES)
# -----------------------------------------------------
# Find all variable prefixes that are used for install directories. A
-# prefix `zar' qualifies iff:
+# prefix 'zar' qualifies iff:
#
-# * `zardir' is a variable.
-# * `zar_PRIMARY' is a variable.
+# * 'zardir' is a variable.
+# * 'zar_PRIMARY' is a variable.
#
# As a side effect, it looks for misspellings. It is an error to have
# a variable ending in a "reserved" suffix whose prefix is unknown, e.g.
if ($dist ne '' && ! $can_dist)
{
err_var ($var,
- "invalid variable `$varname': `dist' is forbidden");
+ "invalid variable '$varname': 'dist' is forbidden");
}
# Standard directories must be explicitly allowed.
elsif (! defined $valid{$X} && exists $standard_prefix{$X})
{
err_var ($var,
- "`${X}dir' is not a legitimate directory " .
- "for `$primary'");
+ "'${X}dir' is not a legitimate directory " .
+ "for '$primary'");
}
# A not explicitly valid directory is allowed if Xdir is defined.
elsif (! defined $valid{$X} &&
- $var->requires_variables ("`$varname' is used", "${X}dir"))
+ $var->requires_variables ("'$varname' is used", "${X}dir"))
{
# Nothing to do. Any error message has been output
# by $var->requires_variables.
}
-# Handle `where_HOW' variable magic. Does all lookups, generates
+# Handle 'where_HOW' variable magic. Does all lookups, generates
# install code, and possibly generates code to define the primary
# variable. The first argument is the name of the .am file to munge,
# the second argument is the primary variable (e.g. HEADERS), and all
# Now that configure substitutions are allowed in where_HOW
# variables, it is an error to actually define the primary. We
- # allow `JAVA', as it is customarily used to mean the Java
+ # allow 'JAVA', as it is customarily used to mean the Java
# interpreter. This is but one of several Java hacks. Similarly,
- # `PYTHON' is customarily used to mean the Python interpreter.
- reject_var $primary, "`$primary' is an anachronism"
+ # 'PYTHON' is customarily used to mean the Python interpreter.
+ reject_var $primary, "'$primary' is an anachronism"
unless $primary eq 'JAVA' || $primary eq 'PYTHON';
# Get the prefixes which are valid and actually used.
if ($nodir_name eq 'EXTRA')
{
error ($where,
- "`$one_name' contains configure substitution, "
+ "'$one_name' contains configure substitution, "
. "but shouldn't");
}
# Check here to make sure variables defined in
my $check_options_p = $install_p && !! option 'std-options';
# Use the location of the currently processed variable as context.
- $where->push_context ("while processing `$one_name'");
+ $where->push_context ("while processing '$one_name'");
# The variable containing all files to distribute.
my $distvar = "\$($one_name)";
}
err_var ($require_extra,
- "`$require_extra' contains configure substitution,\n"
- . "but `EXTRA_$primary' not defined")
+ "'$require_extra' contains configure substitution,\n"
+ . "but 'EXTRA_$primary' not defined")
if ($require_extra && ! var ('EXTRA_' . $primary));
# Push here because PRIMARY might be configure time determined.
################################################################
# Each key in this hash is the name of a directory holding a
-# Makefile.in. These variables are local to `is_make_dir'.
+# Makefile.in. These variables are local to 'is_make_dir'.
my %make_dirs = ();
my $make_dirs_set = 0;
}
# This is needed to allow a construct in a non-top-level Makefile.am
# to require a file in the build-aux directory (see at least the test
- # script `test-driver-is-distributed.test'). This is related to the
+ # script 'test-driver-is-distributed.test'). This is related to the
# automake bug#9546. Note that the use of $config_aux_dir instead
# of $am_config_aux_dir here is deliberate and necessary.
elsif ($dir eq $config_aux_dir)
# here.
# If a required file is above the source tree, it is important
- # to prefix it with `$(srcdir)' so that no VPATH search is
+ # to prefix it with '$(srcdir)' so that no VPATH search is
# performed. Otherwise problems occur with Make implementations
# that rewrite and simplify rules whose dependencies are found in a
# VPATH location. Here is an example with OSF1/Tru64 Make.
# echo a
# a
#
- # Dependency `../a' was found in `sub/../a', but this make
- # implementation simplified it as `a'. (Note that the sub/
+ # Dependency '../a' was found in 'sub/../a', but this make
+ # implementation simplified it as 'a'. (Note that the sub/
# directory does not even exist.)
#
# This kind of VPATH rewriting seems hard to cancel. The
$found_it = 1;
}
- # `--force-missing' only has an effect if `--add-missing' is
+ # '--force-missing' only has an effect if '--add-missing' is
# specified.
return
if $found_it && (! $add_missing || ! $force_missing);
# Only install missing files according to our desired
# strictness level.
- my $message = "required file `$fullfile' not found";
+ my $message = "required file '$fullfile' not found";
if ($add_missing)
{
if (-f "$libdir/$file")
# Install the missing file. Symlink if we
# can, copy if we must. Note: delete the file
# first, in case it is a dangling symlink.
- $message = "installing `$fullfile'";
+ $message = "installing '$fullfile'";
# The license file should not be volatile.
if ($file eq "COPYING")
}
else
{
- $trailer = "\n `automake --add-missing' can install `$file'"
+ $trailer = "\n 'automake --add-missing' can install '$file'"
if -f "$libdir/$file";
}
# the file that any target requiring this directory should be made
# dependent upon.
# We don't want to emit the rule twice, and want to reuse it
-# for directories with equivalent names (e.g., `foo/bar' and `./foo//bar').
+# for directories with equivalent names (e.g., 'foo/bar' and './foo//bar').
sub require_build_directory ($)
{
my $directory = shift;
define_pretty_variable ('am__dirstamp', TRUE, INTERNAL,
'$(am__leading_dot)dirstamp');
- # Directory must be removed by `make distclean'.
+ # Directory must be removed by 'make distclean'.
$clean_files{$dirstamp} = DIST_CLEAN;
$output_rules .= ("$dirstamp:\n"
my $def = $v->def (TRUE);
prog_error "$var not defined in condition TRUE"
unless $def;
- reject_var $var, "`$var' should not be defined"
+ reject_var $var, "'$var' should not be defined"
if $def->owner != VAR_AUTOMAKE;
}
}
# Catch some obsolete variables.
msg_var ('obsolete', 'INCLUDES',
- "`INCLUDES' is the old name for `AM_CPPFLAGS' (or `*_CPPFLAGS')")
+ "'INCLUDES' is the old name for 'AM_CPPFLAGS' (or '*_CPPFLAGS')")
if var ('INCLUDES');
# Must do this after reading .am file.
handle_programs;
handle_scripts;
+ handle_silent;
+
# These must be run after all the sources are scanned. They
# use variables defined by &handle_libraries, &handle_ltlibraries,
# or &handle_programs.
define_pretty_variable ('DIST_SOURCES', TRUE, INTERNAL, @dist_sources);
}
- handle_multilib;
handle_texinfo;
handle_emacs_lisp;
handle_python;
mkdir ($am_relative_dir, 0755) if ! -d $am_relative_dir;
- # We make sure that `all:' is the first target.
+ # We make sure that 'all:' is the first target.
my $output =
"$output_vars$output_all$output_header$output_rules$output_trailer";
Library files:
-a, --add-missing add missing standard files to package
- --libdir=DIR directory storing library files
+ --libdir=DIR set directory storing library files
+ --print-libdir print directory storing library files
-c, --copy with -a, copy missing files (default is symlink)
-f, --force-missing force update of standard files
{
print <<EOF;
automake (GNU $PACKAGE) $VERSION
-Copyright (C) 2011 Free Software Foundation, Inc.
+Copyright (C) $RELEASE_YEAR Free Software Foundation, Inc.
License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl-2.0.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
'version' => \&version,
'help' => \&usage,
'libdir=s' => \$libdir,
+ 'print-libdir' => sub { print "$libdir\n"; exit 0; },
'gnu' => sub { $strict = 'gnu'; },
'gnits' => sub { $strict = 'gnits'; },
'foreign' => sub { $strict = 'foreign'; },
my $errspec = 0;
foreach my $arg (@ARGV)
{
- fatal ("empty argument\nTry `$0 --help' for more information")
+ fatal ("empty argument\nTry '$0 --help' for more information")
if ($arg eq '');
# Handle $local:$input syntax.
}
else
{
- error "no Automake input file found for `$arg'";
+ error "no Automake input file found for '$arg'";
$errspec = 1;
}
}
($am_file = $file) =~ s/\.in$//;
if (! -f ($am_file . '.am'))
{
- error "`$am_file.am' does not exist";
+ error "'$am_file.am' does not exist";
}
else
{
my $msg = '';
$msg = "\nDid you forget AC_CONFIG_FILES([Makefile]) in $configure_ac?"
if -f 'Makefile.am';
- fatal ("no `Makefile.am' found for any configure output$msg");
+ fatal ("no 'Makefile.am' found for any configure output$msg");
}
my $nthreads = get_number_of_threads ();
projects / platform / upstream / automake.git / blobdiff