mirror/autoconf
2
0
Fork 0
mirror of git://git.sv.gnu.org/autoconf synced 2024-12-15 02:20:10 +08:00
Code Issues Packages Projects Releases Wiki Activity
bf0d5c6195
autoconf/bin/autoscan.in
Akim Demaille 1b9b5dd33a * configure.ac: Also find tested executables in bin. 
* bin/autoconf.in, bin/autoheader.in, bin/autoreconf.in,
* bin/autoscan.in, autoupdate.in: Use exclusively the name of the
installed peer executables, only PATH is allowed to resolve it.
Pass `autoconf_dir' via options, not via invisible envvars.
* lib/Autom4te/General.pm (&find_peer): Remove.
* lib/autotest/general.m4 (AT_INIT): `AUTOTEST_PATH=a:b' gives
`abuild:asrc:bbuild:bsrc', not `abuild:bbuild:asrc:bsrc'.
* man/Makefile.am: Let help2man rely on PATH instead of trying to
find the executables for it.
* tests/Makefile.am: Major cleanup.  Too lazy to document...
* tests/atlocal.in: Remove all the obscure envvar manipulations.
We only need PERL.
* tests/atspecific.m4, tests/tools.at: Passing --localdir is
indeed related to running the test suite, while passing
--autoconf-dir and others is related to running non installed
Autoconf executables.  So don't do that, leave it to...
* tests/autoconf, tests/autoheader, tests/autom4te, tests/autoupdate,
* tests/autoscan: New.
* tests/atspecific.m4 (AT_CHECK_M4SUGAR, AT_CHECK_M4SH): Don't
refer to library files: rely on --language.
2001-08-31 13:30:11 +00:00

608 lines
15 KiB
Perl
Raw Blame History

#! @PERL@ -w
# -*- perl -*-
# autoscan - Create configure.scan (a preliminary configure.ac) for a package.
# Copyright 1994, 1999, 2000, 2001 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
# 02111-1307, USA.
# Written by David MacKenzie <djm@gnu.ai.mit.edu>.
BEGIN
{
my $prefix = "@prefix@";
my $perllibdir = $ENV{'autom4te_perllibdir'} || "@datadir@";
unshift @INC, "$perllibdir";
}
use File::Basename;
use File::Find;
use Getopt::Long;
use IO::File;
use Autom4te::General;
use strict;
use vars qw(@cfiles @makefiles @shfiles %c_keywords %printed);
# $USED{KIND}{ITEM} is set if ITEM is used in the program.
# It is set to its list of locations.
my %used = ();
# $MACRO{KIND}{ITEM} is the list of macros to use to test ITEM.
my %macro = ();
# $NEEDED_MACROS{MACRO} is an array of locations requiring MACRO.
my %needed_macros = ();
my @kinds = qw (functions headers identifiers programs makevars libraries);
# For each kind, the default macro.
my %generic_macro =
(
'functions' => 'AC_CHECK_FUNCS',
'headers' => 'AC_CHECK_HEADERS',
'identifiers' => 'AC_CHECK_TYPES',
'programs' => 'AC_CHECK_PROGS',
'libraries' => 'AC_CHECK_LIB'
);
my %kind_comment =
(
'functions' => 'Checks for library functions.',
'headers' => 'Checks for header files.',
'identifiers' => 'Checks for typedefs, structures, and compiler characteristics.',
'programs' => 'Checks for programs.',
);
my $configure_scan = 'configure.scan';
my $log = new IO::File ">$me.log"
or die "$me: cannot open $me.log: $!\n";
# Autoconf and lib files.
my $autoconf = $ENV{'AUTOCONF'} || '@autoconf_name@';
my $datadir = $ENV{"AC_MACRODIR"} || "@datadir@";
## ------------------------ ##
## Command line interface. ##
## ------------------------ ##
# print_usage ()
# --------------
# Display usage (--help).
sub print_usage ()
{
print "Usage: $0 [OPTION] ... [SRCDIR]
Examine source files in the directory tree rooted at SRCDIR, or the
current directory if none is given. Search the source files for
common portability problems, check for incompleteness of
`configure.ac', and create a file `$configure_scan' which is a
preliminary `configure.ac' for that package.
-h, --help print this help, then exit
-V, --version print version number, then exit
-v, --verbose verbosely report processing
Library directories:
-A, --autoconf-dir=ACDIR Autoconf's files location (rarely needed)
-l, --localdir=DIR location of `aclocal.m4' and `acconfig.h'
Report bugs to <bug-autoconf\@gnu.org>.\n";
exit 0;
}
# print_version ()
# ----------------
# Display version (--version).
sub print_version
{
print "autoscan (@PACKAGE_NAME@) @VERSION@
Written by David J. MacKenzie.
Copyright 1994, 1999, 2000, 2001 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n";
exit 0;
}
# parse_args ()
# -------------
# Process any command line arguments.
sub parse_args ()
{
my $srcdir;
Getopt::Long::config ("bundling");
Getopt::Long::GetOptions ("A|autoconf-dir|m|macrodir=s" => \$datadir,
"h|help" => \&print_usage,
"V|version" => \&print_version,
"v|verbose" => \$verbose)
or exit 1;
die "$me: too many arguments
Try `$me --help' for more information.\n"
if (@ARGV > 1);
($srcdir) = @ARGV;
$srcdir = "."
if !defined $srcdir;
print "srcdir=$srcdir\n" if $verbose;
chdir $srcdir || die "$me: cannot cd to $srcdir: $!\n";
}
# init_tables ()
# --------------
# Put values in the tables of what to do with each token.
sub init_tables ()
{
# Initialize a table of C keywords (to ignore).
# Taken from K&R 1st edition p. 180.
# ANSI C, GNU C, and C++ keywords can introduce portability problems,
# so don't ignore them.
foreach (qw (int char float double struct union long short unsigned
auto extern register typedef static goto return sizeof break
continue if else for do while switch case default))
{
$c_keywords{$_} = 0;
}
# The data file format supports only one line of macros per function.
# If more than that is required for a common portability problem,
# a new Autoconf macro should probably be written for that case,
# instead of duplicating the code in lots of configure.ac files.
my $tables_are_consistent = 1;
foreach my $kind (@kinds)
{
my $file = "$datadir/autoscan/$kind";
my $table = new IO::File $file
or die "$me: cannot open $file: $!\n";
while ($_ = $table->getline)
{
# Ignore blank lines and comments.
next
if /^\s*$/ || /^\s*\#/;
unless (/^(\S+)\s+(\S.*)$/ || /^(\S+)\s*$/)
{
die "$me: cannot parse definition in $file:\n$_\n";
}
my $word = $1;
my $macro = $2 || $generic_macro{$kind};
# The default macro must be explicitly listed for words
# which have a specific macros. This allows to enforce
# consistency checks.
if (!defined $2 && exists $macro{$kind}{$word})
{
warn ("$datadir/autoscan/$kind:$.: "
. "ignoring implicit call to the generic macro for $word\n");
$tables_are_consistent = 0;
}
else
{
push @{$macro{$kind}{$word}}, $macro;
}
}
$table->close
or die "$me: cannot close $file: $!\n";
}
die "$me: some tables are inconsistent\n"
if !$tables_are_consistent;
}
## ----------------------- ##
## Scanning source files. ##
## ----------------------- ##
# scan_c_file(FILENAME)
# ---------------------
sub scan_c_file ($)
{
my ($filename) = @_;
push (@cfiles, $File::Find::name);
# Nonzero if in a multiline comment.
my $in_comment = 0;
my $file = new IO::File "<$filename"
or die "$me: cannot open $filename: $!\n";
while ($_ = $file->getline)
{
# Strip out comments, approximately.
# Ending on this line.
if ($in_comment && m,\*/,)
{
s,.*\*/,,;
$in_comment = 0;
}
# All on one line.
s,/\*.*\*/,,g;
# Starting on this line.
if (m,/\*,)
{
$in_comment = 1;
}
# Continuing on this line.
next if $in_comment;
# Preprocessor directives.
if (/^\s*\#\s*include\s*<([^>]*)>/)
{
push (@{$used{'headers'}{$1}}, "$File::Find::name:$.");
}
# Ignore other preprocessor directives.
next if /^\s*\#/;
# Remove string and character constants.
s,\"[^\"]*\",,g;
s,\'[^\']*\',,g;
# Tokens in the code.
# Maybe we should ignore function definitions (in column 0)?
while (s/\b([a-zA-Z_]\w*)\s*\(/ /)
{
push (@{$used{'functions'}{$1}}, "$File::Find::name:$.")
if !defined $c_keywords{$1};
}
while (s/\b([a-zA-Z_]\w*)\b/ /)
{
push (@{$used{'identifiers'}{$1}}, "$File::Find::name:$.")
if !defined $c_keywords{$1};
}
}
$file->close
or die "$me: cannot close $filename: $!\n";
}
# scan_makefile(MAKEFILE-NAME)
# ----------------------------
sub scan_makefile ($)
{
my ($filename) = @_;
push (@makefiles, $File::Find::name);
my $file = new IO::File "<$filename"
or die "$me: cannot open $filename: $!\n";
while ($_ = $file->getline)
{
# Strip out comments and variable references.
s/#.*//;
s/\$\([^\)]*\)//g;
s/\${[^\}]*}//g;
s/@[^@]*@//g;
# Variable assignments.
while (s/\b([a-zA-Z_]\w*)\s*=/ /)
{
push (@{$used{'makevars'}{$1}}, "$File::Find::name:$.");
}
# Libraries.
while (s/\B-l([a-zA-Z_]\w*)\b/ /)
{
push (@{$used{'libraries'}{$1}}, "$File::Find::name:$.");
}
# Tokens in the code.
while (s/(?<![-\w.])([a-zA-Z_][\w+.-]+)/ /)
{
push (@{$used{'programs'}{$1}}, "$File::Find::name:$.");
}
}
$file->close
or die "$me: cannot close $filename: $!\n";
}
# scan_sh_file(SHELL-SCRIPT-NAME)
# -------------------------------
sub scan_sh_file ($)
{
my ($filename) = @_;
push (@shfiles, $File::Find::name);
my $file = new IO::File "<$filename"
or die "$me: cannot open $filename: $!\n";
while ($_ = $file->getline)
{
# Strip out comments and variable references.
s/#.*//;
s/#.*//;
s/\${[^\}]*}//g;
s/@[^@]*@//g;
# Tokens in the code.
while (s/\b([a-zA-Z_]\w*)\b/ /)
{
push (@{$used{'programs'}{$1}}, "$File::Find::name:$.");
}
}
$file->close
or die "$me: cannot close $filename: $!\n";
}
# scan_file ()
# ------------
# Called by &find on each file. $_ contains the current filename with
# the current directory of the walk through.
sub scan_file ()
{
# Wanted only if there is no corresponding FILE.in.
return
if -f "$_.in";
# Save $_ as Find::File requires it to be preserved.
my $underscore = $_;
# Strip a useless leading `./'.
$File::Find::name =~ s,^\./,,;
if (/\.[chlym](\.in)?$/)
{
push (@{$used{'programs'}{"cc"}}, $File::Find::name);
scan_c_file ($_);
}
elsif (/\.(cc|cpp|cxx|CC|C|hh|hpp|hxx|HH|H|yy|ypp|ll|lpp)(\.in)?$/)
{
push (@{$used{'programs'}{"c++"}}, $File::Find::name);
scan_c_file ($_);
}
elsif (/^[Mm]akefile(\.in)?$/ || /^GNUmakefile(\.in)?$/)
{
scan_makefile ($_);
}
elsif (/\.sh(\.in)?$/)
{
scan_sh_file ($_);
}
$_ = $underscore;
}
# scan_files ()
# -------------
# Read through the files and collect lists of tokens in them
# that might create nonportabilities.
sub scan_files ()
{
find (\&scan_file, '.');
if ($verbose)
{
print "cfiles:", join(" ", @cfiles), "\n";
print "makefiles:", join(" ", @makefiles), "\n";
print "shfiles:", join(" ", @shfiles), "\n";
foreach my $kind (@kinds)
{
print "\n$kind:\n";
foreach my $word (sort keys %{$used{$kind}})
{
print "$word: @{$used{$kind}{$word}}\n";
}
}
}
}
## ----------------------- ##
## Output configure.scan. ##
## ----------------------- ##
# output_kind ($FILE, $KIND)
# --------------------------
sub output_kind ($$)
{
my ($file, $kind) = @_;
# Lists of words to be checked with the generic macro.
my @have;
print $file "\n# $kind_comment{$kind}\n"
if exists $kind_comment{$kind};
foreach my $word (sort keys %{$used{$kind}})
{
# Words that were caught, but not to be checked according to
# the autoscan library files.
next
if ! exists $macro{$kind}{$word};
# Output the needed macro invocations in $configure_scan if not
# already printed, and remember these macros are needed.
foreach my $macro (@{$macro{$kind}{$word}})
{
if (exists $generic_macro{$kind}
&& $macro eq $generic_macro{$kind})
{
push (@have, $word);
push (@{$needed_macros{"$generic_macro{$kind}([$word])"}},
@{$used{$kind}{$word}});
}
else
{
if (! $printed{$macro})
{
print $file "$macro\n";
$printed{$macro} = 1;
}
push (@{$needed_macros{$macro}},
@{$used{$kind}{$word}});
}
}
}
print $file "$generic_macro{$kind}([" . join(' ', sort(@have)) . "])\n"
if @have;
}
# output_libraries ($FILE)
# ------------------------
sub output_libraries ($)
{
my ($file) = @_;
print $file "\n# Checks for libraries.\n";
foreach my $word (sort keys %{$used{'libraries'}})
{
print $file "# FIXME: Replace `main' with a function in `-l$word':\n";
print $file "AC_CHECK_LIB([$word], [main])\n";
}
}
# output (CONFIGURE_SCAN)
# -----------------------
# Print a proto configure.ac.
sub output ($)
{
my $configure_scan = shift;
my %unique_makefiles;
my $file = new IO::File ">$configure_scan"
or die "$me: cannot create $configure_scan: $!\n";
print $file "# Process this file with autoconf to produce a configure script.\n";
print $file "AC_INIT(FULL-PACKAGE-NAME, VERSION, BUG-REPORT-ADDRESS)\n";
if (defined $cfiles[0])
{
print $file "AC_CONFIG_SRCDIR([$cfiles[0]])\n";
print $file "AC_CONFIG_HEADER([config.h])\n";
}
output_kind ($file, 'programs');
output_kind ($file, 'makevars');
output_libraries ($file);
output_kind ($file, 'headers');
output_kind ($file, 'identifiers');
output_kind ($file, 'functions');
# Change DIR/Makefile.in to DIR/Makefile.
foreach my $m (@makefiles)
{
$m =~ s/\.in$//;
$unique_makefiles{$m}++;
}
print $file "\nAC_CONFIG_FILES([",
join ("\n ", sort keys %unique_makefiles), "])\n";
print $file "AC_OUTPUT\n";
$file->close
or die "$me: cannot close $configure_scan: $!\n";
}
## --------------------------------------- ##
## Checking the accuracy of configure.ac. ##
## --------------------------------------- ##
# check_configure_ac (CONFIGURE_AC)
# ---------------------------------
# Use autoconf to check if all the suggested macros are included
# in CONFIGURE_AC.
sub check_configure_ac ($)
{
my ($configure_ac) = @_;
# Find what needed macros are invoked in CONFIGURE_AC.
# I'd be very happy if someone could explain to me why sort (uniq ...)
# doesn't work properly: I need `uniq (sort ...)'. --akim
my $trace_option =
join (' -t ', '',
uniq (sort (map { s/\(.*//; $_ } keys %needed_macros)));
verbose "running: $autoconf -A $datadir $trace_option $configure_ac";
my $traces =
new IO::File "$autoconf -A $datadir $trace_option $configure_ac|"
or die "$me: cannot open traces reading pipe: $!\n";
while ($_ = $traces->getline)
{
chomp;
my ($file, $line, $macro, @args) = split (/:/, $_);
if ($macro =~ /^AC_CHECK_(HEADER|FUNC|TYPE|MEMBER)S$/)
{
# To be rigorous, we should distinguish between space and comma
# separated macros. But there is no point.
foreach my $word (split (/\s|,/, $args[0]))
{
# AC_CHECK_MEMBERS wants `struct' or `union'.
if ($macro eq "AC_CHECK_MEMBERS"
&& $word =~ /^stat.st_/)
{
$word = "struct " . $word;
}
delete ($needed_macros{"$macro([$word])"});
}
}
else
{
delete ($needed_macros{$macro});
}
}
$traces->close
or die "$me: cannot close traces reading pipe: $!\n";
# Report the missing macros.
foreach my $macro (sort keys %needed_macros)
{
warn ("$configure_ac: warning: missing $macro wanted by: "
. (${$needed_macros{$macro}}[0])
. "\n");
print $log "$me: warning: missing $macro wanted by: \n";
foreach my $need (@{$needed_macros{$macro}})
{
print $log "\t$need\n";
}
}
}
## -------------- ##
## Main program. ##
## -------------- ##
parse_args;
my $configure_ac = find_configure_ac;
init_tables;
scan_files;
output ('configure.scan');
if ($configure_ac)
{
check_configure_ac ($configure_ac);
}
$log->close
or die "$me: cannot close $me.log: $!\n";
exit 0;
Reference in New Issue View Git Blame Copy Permalink