788 lines
22 KiB
Perl
Executable File
788 lines
22 KiB
Perl
Executable File
#!/usr/bin/env perl
|
|
#
|
|
# svn $Id: sfmakedepend 751 2015-01-07 22:56:36Z arango $
|
|
#######################################################################
|
|
# Copyright (c) 2002-2015 The ROMS/TOMS Group #
|
|
# Licensed under a MIT/X style license #
|
|
# See License_ROMS.txt #
|
|
##################################################### Kate Hedstrom ###
|
|
# #
|
|
# Fortran 90/77 dependency checker, version 2007b. #
|
|
# #
|
|
#######################################################################
|
|
|
|
use 5.6.0;
|
|
use strict;
|
|
use File::Basename;
|
|
use Getopt::Long;
|
|
use Pod::Usage;
|
|
use Getopt::Long;
|
|
use File::Copy;
|
|
|
|
my ($opt_help, $opt_man, $opt_file, @incdirs, @srcdirs, @defines,
|
|
$opt_modext, $opt_case, $compiler, $opt_depend, $drop_circ);
|
|
our ($cpp, $add_ext, $mod_dir, $libdeps, $longpath, $obj_dir, %defines,
|
|
$silent);
|
|
our $obj_ext = 'o';
|
|
our $ext = 'f';
|
|
|
|
# Parse the arguments, do the right thing for --help, --man.
|
|
Getopt::Long::Configure( "bundling" );
|
|
GetOptions("help" => \$opt_help, "man" => \$opt_man,
|
|
"file=s" => \$opt_file, "I=s@" => \@incdirs,
|
|
"srcdir=s@" => \@srcdirs, "moddir=s" => \$mod_dir,
|
|
"fext=s" => \$ext, "objext=s" => \$obj_ext,
|
|
"modext=s" => \$opt_modext, "addext=s" => \$add_ext,
|
|
"case=s" => \$opt_case, "compiler=s" => \$compiler,
|
|
"depend=s" => \$opt_depend, "cpp" => \$cpp,
|
|
"libdeps" => \$libdeps, "drop" => \$drop_circ,
|
|
"longpath" => \$longpath, "objdir=s" => \$obj_dir,
|
|
"D=s@" => \@defines, "silent" => \$silent )
|
|
or pod2usage("Try '$0 --help' for more information");
|
|
pod2usage(-verbose => 1) if $opt_help;
|
|
pod2usage(-verbose => 2) if $opt_man;
|
|
|
|
our @suffixes = qw( .c .C .cc .cxx .cpp .f .F .f90 .F90 .f95 .F95 .for);
|
|
our @mod_files = ();
|
|
|
|
my $mf = 'Makefile';
|
|
if ($opt_file) {
|
|
$mf = $opt_file;
|
|
} elsif (-f "makefile") {
|
|
$mf = 'makefile';
|
|
}
|
|
if ( !(-f $mf) && ($mf ne '-')) {
|
|
system "touch $mf";
|
|
}
|
|
|
|
if (@defines) {
|
|
my $foo;
|
|
foreach $foo (@defines) {
|
|
my($before, $after) = split /=/, $foo;
|
|
$defines{$before} = $after;
|
|
}
|
|
}
|
|
|
|
# extension used for compiler's private module information
|
|
our $mod_ext = "mod";
|
|
our $depend = "obj";
|
|
our $case = "lower";
|
|
our $obj_dep_flag;
|
|
my $ll = 79; # maximum line length in Makefile
|
|
my $cray;
|
|
my $parasoft;
|
|
my $nothing = "\n";
|
|
|
|
# Check the compiler first, then override the compiler-specific defaults
|
|
if ($compiler) {
|
|
if ($compiler eq "crayold") {
|
|
$cray = 1;
|
|
$case = "lower";
|
|
$depend = "obj";
|
|
$obj_dep_flag = "-p";
|
|
} elsif ($compiler eq "cray") {
|
|
$case = "upper";
|
|
} elsif ($compiler eq "parasoft") {
|
|
$parasoft = 1;
|
|
$case = "lower";
|
|
$depend = "obj";
|
|
$obj_dep_flag = "-module";
|
|
} elsif ($compiler eq "sgiold") {
|
|
$mod_ext = "kmo";
|
|
$case = "upper";
|
|
} elsif ($compiler eq "sgi" or $compiler eq "hp" or
|
|
$compiler eq "absoft") {
|
|
$case = "upper";
|
|
} elsif ($compiler eq "nag" or $compiler eq "ibm" or
|
|
$compiler eq "sun") {
|
|
$case = "lower";
|
|
} else {
|
|
warn "Unknown compiler: $compiler\n";
|
|
}
|
|
}
|
|
|
|
$depend = $opt_depend if defined($opt_depend);
|
|
if ($depend eq "obj") {
|
|
$drop_circ = 1;
|
|
}
|
|
|
|
$case = $opt_case if defined($opt_case);
|
|
|
|
# extension used for compiler's private module information
|
|
if ($opt_modext) {
|
|
$mod_ext = $opt_modext;
|
|
}
|
|
|
|
# need to add some more dependencies so the .f file gets created
|
|
our $need_f;
|
|
if ($cpp and $depend eq "obj") {
|
|
$need_f = 1;
|
|
}
|
|
|
|
my $mystring = '# DO NOT DELETE THIS LINE - used by make depend';
|
|
|
|
# Search for the includes in all the files
|
|
my $file;
|
|
my %sources;
|
|
foreach $file (@ARGV) {
|
|
my $filesrc = findsrc($file);
|
|
$sources{$file} = new Source_File($file, $filesrc, $filesrc);
|
|
$sources{$file}->find_includes();
|
|
}
|
|
|
|
# Create new Makefile with new dependencies.
|
|
|
|
if ($mf ne "-") {
|
|
copy( "$mf", "$mf.old");
|
|
open(MFILE, "$mf.old") || die "can't read Makefile $mf.old: $!\n";
|
|
open(NMFILE, "> $mf") || die "can't write $mf: $!\n";
|
|
select(NMFILE);
|
|
|
|
while (<MFILE>) {
|
|
if (!/$mystring/) {
|
|
print;
|
|
} else {
|
|
last;
|
|
}
|
|
}
|
|
print $mystring, "\n";
|
|
}
|
|
|
|
# Now print out include and use dependencies in sorted order.
|
|
my $target;
|
|
foreach $target (sort keys(%sources)) {
|
|
$sources{$target}->print();
|
|
# Hernan hack
|
|
print $nothing;
|
|
}
|
|
|
|
# print out module dependencies
|
|
if ( !( $cray || $parasoft) ) {
|
|
my $modname;
|
|
foreach $modname (sort keys(%main::mod_files)) {
|
|
my ($name, $path, $suffix) = fileparse(
|
|
$sources{$main::mod_files{$modname}}->{'filepath'}, @suffixes);
|
|
my $object = $name . "." . $obj_ext;
|
|
if (!( $drop_circ && lc($modname) eq lc($name)) ) {
|
|
$object =~ s#^\./##;
|
|
my $modfile = "$modname.$mod_ext";
|
|
my $objfile = $object;
|
|
$modfile = $mod_dir . '/' . $modfile if $mod_dir;
|
|
$objfile = $obj_dir . '/' . $objfile if $obj_dir;
|
|
print "$modfile: $objfile\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# End of main
|
|
#
|
|
|
|
sub findfile {
|
|
# Let's see if we can find the included file. Look in current
|
|
# directory first, then in directories from -I arguments.
|
|
my $file = shift;
|
|
my ($found, $i, $filepath);
|
|
|
|
$found = 0;
|
|
|
|
if ( -f $file ) {
|
|
$found = 1;
|
|
$file =~ s#^\./##; # convert ./foo.h to foo.h
|
|
return $file;
|
|
}
|
|
foreach $i (0 .. $#incdirs) {
|
|
$filepath = $incdirs[$i]."/".$file;
|
|
if ( -f $filepath ) {
|
|
$found = 1;
|
|
$filepath =~ s#^\./##; # convert ./foo.h to foo.h
|
|
return $filepath;
|
|
}
|
|
}
|
|
if ( ! $found ) {
|
|
$filepath = "";
|
|
}
|
|
$filepath;
|
|
}
|
|
#-----------------------------------------------------------------------
|
|
sub findsrc {
|
|
# Let's see if we can find the source-file. Look in current
|
|
# directory first, then in directories from --srcdir arguments.
|
|
my $src = shift;
|
|
my($found, $i, $srcpath);
|
|
|
|
$found = 0;
|
|
|
|
if ( -f $src ) {
|
|
$found = 1;
|
|
$src =~ s#^\./##; # convert ./foo.h to foo.h
|
|
return $src;
|
|
}
|
|
foreach $i (0 .. $#srcdirs) {
|
|
$srcpath = $srcdirs[$i]."/".$src;
|
|
if ( -f $srcpath ) {
|
|
$found = 1;
|
|
$srcpath =~ s#^\./##; # convert ./foo.h to foo.h
|
|
return $srcpath;
|
|
}
|
|
}
|
|
if ( ! $found ) {
|
|
$srcpath = "";
|
|
}
|
|
$srcpath;
|
|
}
|
|
|
|
#################################################################
|
|
package Source_File;
|
|
|
|
# hash containing names of included files
|
|
my %inc_files = ();
|
|
my %flist;
|
|
|
|
# Constructor
|
|
sub new {
|
|
my $type = shift;
|
|
my $filename = shift;
|
|
my $path = shift;
|
|
my $parent = shift;
|
|
my $self = {};
|
|
$self->{'Source_File'} = $filename;
|
|
$self->{'filepath'} = $path;
|
|
$self->{'parent'} = $parent;
|
|
$self->{'includes'} = {};
|
|
$self->{'uses'} = {};
|
|
$self->{'modules'} = {};
|
|
bless $self;
|
|
}
|
|
|
|
sub find_includes {
|
|
my $self = shift;
|
|
my $file = $self->{'filepath'};
|
|
my $parent = $self->{'parent'};
|
|
my($after, $filepath, $ref, $included, $use, $modname);
|
|
local(*FILE);
|
|
local($_);
|
|
|
|
if (-f $file) {
|
|
open(FILE, $file) || $silent || warn "Can't open $file: $!\n";
|
|
} else {
|
|
return;
|
|
}
|
|
while (<FILE>) {
|
|
$included = "";
|
|
$use = "";
|
|
# look for Fortran style includes
|
|
if (/^\s*include\s*['"]([^"']*)["']/i) {
|
|
$included = $1;
|
|
$after = $';
|
|
# C preprocessor style includes
|
|
} elsif (/^#\s*include\s*["<]([^">]*)[">]/) {
|
|
$included = $1;
|
|
$after = $';
|
|
# Fortran 90 "use"
|
|
} elsif (/^\s*use\s+(\w+)/i) {
|
|
# Gavin Salam attempt at dealing with multiple uses on one line
|
|
# remove trailing comments (do not take uses after a comment!)
|
|
s/\!.*//;
|
|
# try and get multiple use commands
|
|
my @commands = split(';',$_);
|
|
while (my $command = shift @commands) {
|
|
if ($command =~ /^\s*use\s+(\w+)/i) {
|
|
$use = $1;
|
|
# Change the case as needed - compiler dependent.
|
|
if ($main::case eq "upper") {
|
|
$use = uc($use);
|
|
} elsif ($main::case eq "lower") {
|
|
$use = lc($use);
|
|
}
|
|
$self->{'uses'}{$use} = 1;
|
|
}
|
|
}
|
|
# Fortran 90 module
|
|
} elsif (/^\s*module\s+(\w+)/i) {
|
|
$modname = $1;
|
|
if ($main::case eq "upper") {
|
|
$modname = uc($modname);
|
|
} elsif ($main::case eq "lower") {
|
|
$modname = lc($modname);
|
|
}
|
|
# Skip "module procedure" in interface blocks
|
|
next if (lc($modname) eq "procedure");
|
|
|
|
$main::mod_files{$modname} = $parent;
|
|
$self->{'modules'}{$modname} = 1;
|
|
}
|
|
# C preprocessor style includes of a -DROMS_HEADER sort
|
|
my $key;
|
|
foreach $key (keys(%defines)) {
|
|
if (/^#\s*include\s*($key)/) {
|
|
$included = $defines{$key};
|
|
$after = $';
|
|
}
|
|
}
|
|
if ($included) {
|
|
# See if we've already searched this file
|
|
if ( $inc_files{$included} ) {
|
|
$filepath = $inc_files{$included}{'filepath'};
|
|
} else {
|
|
$filepath = main::findfile($included);
|
|
$ref = new Source_File($included, $filepath, $parent);
|
|
$inc_files{$included} = $ref;
|
|
# Search included file for includes
|
|
$ref->find_includes();
|
|
}
|
|
if ( $filepath ) {
|
|
$self->{'includes'}{$included} = 1;
|
|
} else {
|
|
if ($after !~ /bogus/i) {
|
|
$silent || warn "Can't find file: $included\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
close FILE;
|
|
}
|
|
|
|
sub print_includes {
|
|
my $self = shift;
|
|
my $target = shift;
|
|
my $len_sum = shift;
|
|
my $file;
|
|
my $len;
|
|
|
|
foreach $file (keys %{$self->{'includes'}}) {
|
|
if (!$flist{$file}) {
|
|
$flist{$file} = 1;
|
|
my $ref = $inc_files{$file};
|
|
if ($longpath) {
|
|
$len = length($ref->{'filepath'}) + 1;
|
|
} else {
|
|
$len = length($ref->{'Source_File'}) + 1;
|
|
}
|
|
if (($len_sum + $len > $ll) &&
|
|
(length($target) + 1 < $len_sum)) {
|
|
print "\n$target:";
|
|
$len_sum = length($target) + 1;
|
|
}
|
|
if ($longpath) {
|
|
print " " . $ref->{'filepath'};
|
|
} else {
|
|
print " " . $ref->{'Source_File'};
|
|
}
|
|
$len_sum += $len;
|
|
$len_sum = $ref->print_includes($target, $len_sum);
|
|
}
|
|
}
|
|
$len_sum;
|
|
}
|
|
|
|
# return list of modules used by included files
|
|
sub inc_mods {
|
|
my $self = shift;
|
|
my($file, $ref, $mod, @sub_list);
|
|
my @list = ();
|
|
|
|
foreach $mod (keys %{$self->{'uses'}}) {
|
|
push(@list, $mod);
|
|
}
|
|
|
|
foreach $file (keys %{$self->{'includes'}}) {
|
|
$ref = $inc_files{$file};
|
|
@sub_list = $ref->inc_mods();
|
|
@list = (@list, @sub_list);
|
|
}
|
|
@list;
|
|
}
|
|
|
|
# filenames containing the modules used by file and all its includes
|
|
sub find_mods {
|
|
my $self = shift;
|
|
my($modname, $file);
|
|
my @module_files = ();
|
|
my @mod_list = ();
|
|
|
|
# find modules used by include files
|
|
if (%{$self->{'includes'}}) {
|
|
foreach $file (keys %{$self->{'includes'}}) {
|
|
my $ref = $inc_files{$file};
|
|
my @list = $ref->inc_mods();
|
|
@mod_list = (@mod_list, @list);
|
|
}
|
|
}
|
|
|
|
# add them to the uses list (hash ensures uniqueness)
|
|
foreach $modname (@mod_list) {
|
|
$self->{'uses'}{$modname} = 1;
|
|
}
|
|
|
|
# now find the filename that contains the module information
|
|
foreach $modname (keys %{$self->{'uses'}}) {
|
|
if ($main::depend eq "obj") {
|
|
if ($file = $main::mod_files{$modname}) {
|
|
my $base = main::basename($file, @main::suffixes);
|
|
$file = $base . "." . $main::obj_ext;
|
|
push(@module_files, $file);
|
|
} elsif ( !$silent ) {
|
|
warn "Don't know where module $modname lives.\n";
|
|
}
|
|
} else {
|
|
if ($main::libdeps or defined($main::mod_files{$modname})) {
|
|
$modname .= "." . $main::mod_ext;
|
|
push(@module_files, $modname);
|
|
} elsif ( !$silent ) {
|
|
warn "Couldn't locate source for module $modname\n";
|
|
}
|
|
}
|
|
}
|
|
sort(@module_files);
|
|
}
|
|
|
|
sub print {
|
|
my $self = shift;
|
|
my $source = $self->{'Source_File'};
|
|
my $compile_string = "\t" . '$(F90) $(F90FLAGS) -c';
|
|
my($len_sum, $len);
|
|
my($base, $object, $modname, $flag, $target, $ftarget);
|
|
|
|
$base = main::basename($source, @main::suffixes);
|
|
$base = $main::obj_dir . '/' . $base if $main::obj_dir;
|
|
$target = $base . "." . $main::obj_ext;
|
|
if ($main::cpp) {
|
|
$ftarget = $base . "." . $main::ext;
|
|
}
|
|
|
|
$flag = $main::obj_dep_flag;
|
|
|
|
# print out "include" dependencies
|
|
%flist = ();
|
|
if (%{$self->{'includes'}}) {
|
|
$len_sum = length($target) + 1;
|
|
if ($main::add_ext) {
|
|
print "$base.$main::add_ext ";
|
|
$len_sum += length($base) + length($main::add_ext) + 2;
|
|
}
|
|
print "$target:";
|
|
$self->print_includes($target, $len_sum);
|
|
print "\n";
|
|
if ($main::cpp) {
|
|
%flist = ();
|
|
$len_sum = length($ftarget) + 1;
|
|
print "$ftarget:";
|
|
$self->print_includes($ftarget, $len_sum);
|
|
print "\n";
|
|
}
|
|
}
|
|
|
|
# clean out "use" of modules in own file
|
|
my $mod;
|
|
foreach $mod ( keys %{$self->{'uses'}} ) {
|
|
if ( ${$self->{'modules'}}{$mod} ) {
|
|
delete ${$self->{'uses'}}{$mod};
|
|
}
|
|
}
|
|
|
|
# print out "use" dependencies
|
|
if (%{$self->{'uses'}} || %{$self->{'includes'}}) {
|
|
my @module_files = $self->find_mods();
|
|
$len_sum = 0;
|
|
my $file;
|
|
foreach $file (@module_files) {
|
|
$file = $main::mod_dir . '/' . $file if $main::mod_dir;
|
|
if( $len_sum < 1 ) {
|
|
$len_sum = length($target) + 1;
|
|
print "$target:";
|
|
}
|
|
$len = length($file) + 1;
|
|
if (($len_sum + $len > $ll) &&
|
|
(length($target) + 1 < $len_sum)) {
|
|
print "\n$target:";
|
|
$len_sum = length($target) + 1;
|
|
}
|
|
$len_sum += $len;
|
|
print " " . $file;
|
|
}
|
|
if ($main::need_f) {
|
|
$len = length($ftarget) + 1;
|
|
if (($len_sum + $len > $ll) &&
|
|
(length($target) + 1 < $len_sum)) {
|
|
print "\n$target:";
|
|
$len_sum = length($target) + 1;
|
|
}
|
|
print " " . $ftarget if $len_sum;
|
|
}
|
|
print "\n" if $len_sum;
|
|
# extra Cray / Parasoft stuff
|
|
if ($flag) {
|
|
print $compile_string;
|
|
foreach $file (@module_files) {
|
|
print $flag . $file;
|
|
}
|
|
if ($main::cpp) {
|
|
print " " . $ftarget . "\n";
|
|
} else {
|
|
print " " . $source . "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
__END__
|
|
|
|
sfmakedepend - Fortran Dependency Checker
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
sfmakedepend [--help] [--man] [--file=file] [-I dir]
|
|
[--srcdir dir] [--objdir dir] [--moddir dir]
|
|
[--fext ext] [--objext ext] [--modext ext]
|
|
[-D TAG=file] [--addext ext] [--case=up|down|asis]
|
|
[--compiler=crayold|cray|sgiold|sgi|nag|ibm|
|
|
parasoft|hp|absoft|sun]
|
|
[--depend=mod|obj] [--cpp] [--libdeps] [--drop]
|
|
[--silent] file ...
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
This is a makedepend script for Fortran, including Fortran 90.
|
|
It searches for Fortran style includes, C preprocessor includes,
|
|
and module dependencies to the extent that I understand them.
|
|
|
|
Your files must have an extension listed in the @suffixes list
|
|
in the code. You might also want to modify $compile_string;
|
|
the compiler is called $(F90).
|
|
|
|
=head1 OPTIONS AND ARGUMENTS
|
|
|
|
=over 4
|
|
|
|
=item I<--help>
|
|
|
|
Print more details about the arguments.
|
|
|
|
=item I<--man>
|
|
|
|
Print a full man page.
|
|
|
|
=item I<--file file>
|
|
|
|
Change the name of the current Makefile (default is Makefile).
|
|
Use "--file -" to write to stdout.
|
|
|
|
=item I<-I dir>
|
|
|
|
Look in alternate directories for the include files. There can be
|
|
several "-I dir" options used at once. The current directory is
|
|
still searched first.
|
|
|
|
=item I<--srcdir dir>
|
|
|
|
Look in alternate directories for the source files, much like VPATH.
|
|
It can be used multiple times to search in more than one directory.
|
|
|
|
=item I<--objdir dir>
|
|
|
|
Tells sfmakedepend to prepend objdir to all object references (and
|
|
cpp output files if used). This is required if you use a build
|
|
directory that isn't your current directory.
|
|
|
|
=item I<--moddir dir>
|
|
|
|
Tells sfmakedepend to prepend moddir to all module references. This
|
|
is required if you use a common module library directory for a
|
|
multi-directory project (+moddir= .. option on HP, eg.).
|
|
|
|
=item I<--fext>
|
|
|
|
This is used with the --cpp switch for compilers
|
|
which expect an extension other than .f on source files. For
|
|
instance, one might choose to use "--fext f90".
|
|
|
|
=item I<--objext ext>
|
|
|
|
Tells sfmakedepend what extension to use for object files. The
|
|
default is "o", but "obj", for instance, is
|
|
appropriate on MS-DOG etc.
|
|
|
|
=item I<--modext ext>
|
|
|
|
Specifies the extension to use for Fortran 90 module files. The default
|
|
extension is "mod" since this seems to be an emerging standard. Let
|
|
me know if other compilers use a different filename for the module
|
|
information (keep that --compiler option up to date).
|
|
|
|
=item I<--D tag=file>
|
|
|
|
Tells sfmakedepend to search the source files for lines such as:
|
|
|
|
#include MY_CHEESE
|
|
|
|
Where MY_CHEESE is set with a -DMY_CHEESE="wensleydale.h".
|
|
|
|
=item I<--addext ext>
|
|
|
|
Tells sfmakedepend to add targets with extension add_ext to the rules
|
|
for object files. For instance, to operate with (f77) ftnchek .prj
|
|
files, you could use
|
|
|
|
`--addext prj' to get rules like:
|
|
foo.prj foo.o: ...
|
|
|
|
=item I<--case up|down|asis>
|
|
|
|
Controls case of module names when generating module file names. Only
|
|
relevant where the module file name is named after the module rather
|
|
than after the source file.
|
|
|
|
=item I<--compiler=crayold|cray|sgiold|sgi|nag|ibm|parasoft|hp|absoft|sun>
|
|
|
|
Controls the type of target compiler, setting the module name and other
|
|
options appropriately. The cray option assumes that FFLAGS includes
|
|
-e m for creating the .mod file, while crayold refers to the default of
|
|
including that information in the object file.
|
|
|
|
=item I<--depend=mod|obj>
|
|
|
|
Whether to use the module information file or the module object file
|
|
in dependencies.
|
|
|
|
=item I<--cpp>
|
|
|
|
There are times when one might choose to run .F files through cpp and
|
|
to keep the .f files (for the debugger or for a custom preprocessor).
|
|
In that case, make must be told about the cpp include dependencies of
|
|
the .f files. This option will provide those dependencies.
|
|
|
|
=item I<--libdeps>
|
|
|
|
Generate dependencies on modules for which source code is not
|
|
available. Otherwise a warning is issued, but the dependency is not
|
|
listed.
|
|
|
|
=item I<--longpath>
|
|
|
|
Keep the full path to the include files in the dependency. Otherwise,
|
|
just print the filename and use VPATH to provide the directory
|
|
information.
|
|
|
|
=item I<--drop>
|
|
|
|
Drop module dependencies (my_mod.mod: my_mod.o). This is also done when
|
|
--depend=obj.
|
|
|
|
=item I<--silent>
|
|
|
|
The default is to warn about unfound files. This option causes those
|
|
warnings to not be printed.
|
|
|
|
=item I<[file ...]>
|
|
|
|
The list of source files to search for dependencies.
|
|
|
|
=back
|
|
|
|
=head1 EXAMPLE
|
|
|
|
Search for include files in /usr/local/include:
|
|
|
|
sfmakedepend --cpp --fext=f90 -I /usr/local/include *.F
|
|
|
|
Example usage in gnuMakefile:
|
|
|
|
SRCDIRS= srcdir1 srcdir2 srcdir3 ...
|
|
FSRCS0 := $(foreach DIR, . $(SRCDIRSH),$(wildcard $(DIR)/*.f))
|
|
FSRCS := $(sort $(notdir $(FSRCS0)))
|
|
|
|
F_makedepend=sfmakedepend --file - $(addprefix --srcdir ,$(SRCDIRSH)) \
|
|
$(subst -I,-I ,$(Includes))
|
|
depend $(MAKEFILE_INC):
|
|
$(F_makedepend) $(FSRCS) >> $(MAKEFILE_INC)
|
|
|
|
include $(MAKEFILE_INC)
|
|
|
|
=head1 AUTHOR
|
|
|
|
Kate Hedstrom (kate@arsc.edu)
|
|
First Perl 5 Fortran 90 version November 1994.
|
|
|
|
=head1 CONTRIBUTORS
|
|
|
|
Dave Love (d.love@dl.ac.uk)
|
|
Added the --objext and --addext options (1996).
|
|
|
|
Patrick Jessee
|
|
Added hp support (1997, now in --compiler option).
|
|
|
|
Sergio Gelato (gelato@tac.dk)
|
|
Added the --compiler, --depend, --case options, and
|
|
--(no)libdeps (1998).
|
|
|
|
Tobias Buchal (buchal@ifh.bau-verm.uni-karlsruhe.de)
|
|
Added the --srcdir and --file - options (1999).
|
|
|
|
Klaus Ramstock (klaus@tdm234.el.utwente.nl)
|
|
Added the --moddir option (1999).
|
|
|
|
Sandra Schroedter (sandra@fsg-ship.de)
|
|
Fix to preserve Makefile links (1999).
|
|
|
|
Holger Bauer (bauer@itsm.uni-stuttgart.de)
|
|
Added the --drop option (2000).
|
|
|
|
Gavin Salam (salam@lpthe.jussieu.fr)
|
|
Made it recognize multiple "use"s on one line (2005).
|
|
|
|
Others I've doubtless forgotten.
|
|
|
|
=cut
|
|
#
|
|
# NOTES
|
|
# This makedepend script is my first attempt at using perl 5
|
|
# objects. Therefore, it may not be the best example of how
|
|
# to do this. Also, it requires perl 5 and will die if you
|
|
# to use it with an older perl. The latest version is
|
|
# available from:
|
|
#
|
|
# http://www.arsc.edu/~kate/Perl/
|
|
# ftp://ahab.rutgers.edu/pub/perl/sfmakedepend
|
|
#
|
|
# Fortran 90 introduces some interesting dependencies. Two
|
|
# compilers I have access to (NAG f90 and IBM xlf) produce a
|
|
# private "mod_name.mod" file if you define "module mod_name"
|
|
# in your code. This file is used by the compiler when you
|
|
# use the module as a consistency check (type-safe). On the
|
|
# other hand, the Cray and Parasoft compilers store the module
|
|
# information in the object file and then files which use the
|
|
# modules need to be compiled with extra flags pointing to the
|
|
# module object files.
|
|
#
|
|
# This script assumes that all the files using and defining
|
|
# modules are in the same directory and are all in the list of
|
|
# files to be searched. It seems that the industry has not
|
|
# settled on a practical way to deal with a separate modules
|
|
# directory, anyway.
|
|
#
|
|
# I sometimes include non-existent files as a compile time
|
|
# consistency check:
|
|
#
|
|
# #ifndef PLOTS
|
|
# #include "must_define_PLOTS" /* bogus include */
|
|
# #endif
|
|
#
|
|
# This program warns about include files it can't find, but
|
|
# not if there is a "bogus" on the same line.
|
|
#
|
|
# * The f90 module dependencies can confuse some versions of
|
|
# make, especially of the System V variety. We use gnu
|
|
# make because it has no problems with these dependencies.
|
|
#
|
|
# BUGS
|
|
# It can sometimes produce duplicate dependencies.
|
|
#
|
|
# It treats C preprocessor includes the same as Fortran
|
|
# includes. This can add unnecessary dependencies if you
|
|
# use the -s flag and both kinds of includes.
|
|
#
|
|
# Please let me know if you find any others.
|
|
# Kate Hedstrom
|
|
# kate@arsc.edu
|