#! /usr/bin/env perl
# -*- Mode: perl; -*-
#
# f77tof90 indir outdir [ Makefile-template [Make-Append] ]
# For each file in indir/*.[fF], create a corresponding file in outdir
# with .f90/.F90, and with any include "mpif.h" replaced with use mpi
# It also changes to the new comment style, because some compilers
# use the comment style to choose other features of the language
#
# We also allow the file name to be modified to help out Windows, since
# programs in a project need to have distinct names
#
use warnings;
$indir = $ARGV[0];
$outdir = $ARGV[1];
$makeTemplate = $ARGV[2];
$makeAppend = $ARGV[3];
$convertToFreeForm = 1;
$convertToNewComments = 1;
# Including a newline variable allows us to handle Unix and DOS source files
$newline = "\n";
%replaceInclude = ( 'iodisp' => 'integer (kind=MPI_OFFSET_KIND) disp',
'ioaint' => 'integer (kind=MPI_ADDRESS_KIND) aint',
'iooffset' => 'integer (kind=MPI_OFFSET_KIND) offset',
'type1aint' => 'integer (kind=MPI_ADDRESS_KIND) aint',
'typeaints' => 'integer (kind=MPI_ADDRESS_KIND) aint, aintv(max_asizev)',
'attr1aints' => 'integer (kind=MPI_ADDRESS_KIND) extrastate, valin, valout, val',
'attraints' => 'integer (kind=MPI_ADDRESS_KIND) extrastate, valin, valout, val',
'addsize' => 'integer (kind=MPI_ADDRESS_KIND) asize',
'add1size' => 'integer (kind=MPI_ADDRESS_KIND) asize',
);
%excludePrograms = ();
$debugReplace = 0;
$reportSkipped = 1;
# --------------------------------------------------------------------------
# Check the input arguments
if ($indir eq "" || $outdir eq "") {
print STDERR "Usage: f77tof90 indir outdir [ makefile-template ]\n";
exit 1;
}
if ( ! -d $indir) {
print STDERR "Input directory $indir does not exist\n";
exit 1;
}
if (! -d $outdir) {
print STDERR "Output directory $outdir does not exist\n";
exit 1;
}
# --------------------------------------------------------------------------
# --------------------------------------------------------------------------
opendir( DIR, "$indir" );
my @filelist = ();
while ($file = readdir(DIR)) {
# Extract the extension
if ($file =~ /^(.*)\.([^\.]*)$/) {
$name = $1;
$ext = $2;
# Special handling for C files, if any
if ($ext eq "c") {
my $name90 = $name;
# don't transform "ctypesfromc" to "ctypesf90romc"
if ($name ne "ctypesfromc") {
$name90 =~ s/f/f90/g;
}
&ConvertCFile( "$indir/$file", "$outdir/$name90.c.new" );
&ReplaceIfDifferent( "$outdir/$name90.c",
"$outdir/$name90.c.new" );
next;
}
# Skip if the file isn't a Fortran source file
if ($ext ne "f" && $ext ne "F") { next; }
&ConvertToF90( "$indir/$file", "$outdir/${name}90.${ext}90.new" );
&ReplaceIfDifferent( "$outdir/${name}90.${ext}90",
"$outdir/${name}90.${ext}90.new" );
$filelist[$#filelist+1] = $file;
}
}
closedir( DIR );
# &CreateMakefile( "filelist", $outdir );
if (defined($makeTemplate) && $makeTemplate ne "" &&
-s "$indir/$makeTemplate") {
&ConvertMakefile( $indir, $outdir, $makeTemplate );
if (defined($makeAppend) && -s "$outdir/$makeAppend") {
# If there is a makeAppend in the output directory, then
# append that to the generated makefile
&AppendFile( "$outdir/$makeAppend", "$outdir/$makeTemplate.new" );
}
&ReplaceIfDifferent( "$outdir/$makeTemplate",
"$outdir/$makeTemplate.new" );
# unconditionally update the stamp file to assist the maintainer rebuild
# rules
open(STAMP, '>', "$outdir/Makefile.am-stamp");
print STAMP localtime()."\n";
close(STAMP);
}
if (-s "$indir/testlist" || -s "$indir/testlist.in") {
# We allow both testlist.in and testlist as source files;
# testlist.in gets priority
my $filename = "testlist";
if (-s "$indir/testlist.in") {
$filename = "testlist.in";
}
&ConvertTestlist( $indir, $outdir, $filename );
if (-s "$outdir/testlist.ap") {
&AppendFile( "$outdir/testlist.ap", "$outdir/$filename.new" );
}
&ReplaceIfDifferent( "$outdir/$filename", "$outdir/$filename.new" );
}
exit 0;
# -----------------------------------------------------------------------------
sub ConvertToF90 {
my $infile = $_[0];
my $outfile = $_[1];
open (INF, "<$infile" ) || die "Could not open $infile\n";
open (OUTF, ">$outfile" ) || die "Could not open $outfile\n";
print OUTF "! This file created from $infile with f77tof90\n";
my $lastLine = "";
my $firstline = 1;
while (<INF>) {
if (/\r/) { $newline = "\r\n"; }
# Remove any end-of-line characters
s/[\r\n]*//g;
# The implicit none must not come before the use mpi statement,
# but in F77, it must come before the include mpif.h statement.
# Rather than try and fix this, rely on the F77 versions to
# catch undeclared variables
if (/[Ii][Mm][Pp][Ll][Ii][Cc][Ii][Tt]\s+[Nn][Oo][Nn][Ee]/) { next; }
if (/^(\s*)include\s+[\'\"]mpif\.h/) {
$_ = "$1use mpi";
}
# Allow the insertion of Fortran 90 only statements, such as
# interface definitions
if (/^CF90/) {
s/^CF90/ /;
}
# Remove lines used only for F77, such as external MPI function declarations
if (/!\s*F77ONLY\s*$/i) {
$_ = "";
}
# Since we use interface statements for the error handlers,
# remove their external declaration
if (/^\s+external myerrhanfunc/) {
s/^\s/!/;
}
if ($convertToNewComments) {
s/^C/!/;
s/^c/!/;
}
# Update the special includes that are used to provide
# address or offset sized types with ones the use the
# Fortran90 KIND style
if (/^(\s*)include\s+[\'\"]([\/\.\w]+)\.h[\"\']/) {
my $leading = $1;
my $includename = $2;
if (defined($replaceInclude{$includename})) {
$_ = $leading . $replaceInclude{$includename} . "\n";
}
}
# We need to handle the special case of the program
# name in spawn commands
if (/(.*)\"([\.\/\w]*spawn[^\"]*)\"(.*)/) {
my $before = $1;
my $name = $2;
my $after = $3;
$_ = $before . "\"" . $name . "90" . "\"" . $after;
}
# We could also detect continuations in column six and
# convert to free-form input by holding one line back.
if ($convertToFreeForm) {
if (/^ \S(.*)/) {
$leftover = $1;
# This line contains a continuation marker
# Add a continuation marker to the previous line if
# it doesn't already have one
if (! ($lastline =~ /\&\s*$/) ) {
$lastline .= " &";
}
$_ = " \&$leftover";
}
}
print OUTF "$lastline$newline" if (! $firstline);
$firstline = 0;
$lastline = $_;
}
print OUTF "$lastline$newline";
close (INF);
close (OUTF);
}
#
# A very simple routine for creating a version of a C file that refers
# to F90 instead of F77.
sub ConvertCFile {
my $infile = $_[0];
my $outfile = $_[1];
open (INF, "<$infile" ) || die "Could not open $infile\n";
open (OUTF, ">$outfile" ) || die "Could not open $outfile\n";
print OUTF "/* This file created from $infile with f77tof90 */\n";
while (<INF>) {
if (/\r/) { $newline = "\r\n"; }
# Remove any end-of-line characters
s/[\r\n]*//g;
# replace F77 with F90, mostly for CPP tests, except for name
# mapping
if (! /F77_NAME/) {
s/F77/F90/g;
}
print OUTF "$_$newline";
}
close (INF);
close (OUTF);
}
# Create a makefile from a template. Replace @EXECS@ with the programs
# in the filelist.
# CreateMakefile( "filelist", $outdir )
sub CreateMakefile {
my $filelist = $_[0];
my $outdir = $_[1];
print STDERR "This function is not implemented\n";
return 0;
}
#
# Take an existing makefile and perform the following transformations:
# .f -> .f90, .F -> .F90
# Others as necessary
# ConvertMakefile( indir, outdir, filename )
# By providing the filename, we can accept Makefile, Makefile.in, Makefile.ap,
# Makefile.sm, or even nonstandard names such as buildscript.
sub ConvertMakefile {
my ($indir, $outdir, $filename) = @_;
%excludePrograms = ();
my $saw_maintainercleanfiles = 0;
my $saw_extra_dist = 0;
open( INF, "<$indir/$filename" ) || die "Cannot open $indir/$filename\n";
open( OUTF, ">$outdir/$filename.new" ) || die "Cannot open $outdir/$filename.new\n";
print OUTF "# This $filename generated automatically by f77tof90\n";
print OUTF "# from $indir/$filename. DO NOT EDIT\n";
while (<INF>) {
if (not m/^\s*#/ and m/MAINTAINERCLEANFILES/) {
$saw_maintainercleanfiles = 1;
}
if (not m/^\s*#/ and m/EXTRA_DIST/) {
$saw_extra_dist = 1;
}
# First, check for sources that are not present. These
# may be derived files (see f77/io for an example). For now,
# we'll skip these unless they are explicitly expected to not be present
# (by the presence of a "nodist_" prefix.
if (/^(nodist_)?(\w+)_SOURCES\s*=\s*(\w+\.f)/) {
my $nodist = $1;
my $sourcebase = $2;
my $sourcename = $3;
if (not $nodist and ! -s "$indir/$sourcename") {
print "Skipping source file $indir/$sourcename because it is not present\n" if $reportSkipped;
$excludePrograms{$sourcebase} = 1;
next;
}
}
# Headers like f77/spawn/type1aints.h are not used in the f90 tests.
# They are instead replaced with appropriate "kind=" type declarations
# in a different part of this script. So we drop any lines that add
# dependencies on a header.
if (m/^\w+f\.\$\(OBJEXT\):.*\.h/) {
my $chomped = $_;
chomp $_;
next;
}
# convert program names from foof.f to foof90.f90
s/f_SOURCES/f90_SOURCES/g;
s/f_DEPENDENCIES/f90_DEPENDENCIES/g;
if (/f\.f/) {
s/f\.f/f90.f90/g;
}
else {
# Move files to f90
s/\.f/.f90/g;
}
s/mtestf\.o/mtestf90.o/;
s/\.F/.F90/g;
s/f77/f90/g;
s/F77/FC/g;
# Update any per-program LDADD values
s/f_LDADD/f90_LDADD/g;
#
# Handle special cases:
# Force the c2f2c test to use the f90 compiler
s/c2f2cf90_SOURCES.*/c2f2cf90_SOURCES = c2f2cf90.f90 c2f902c.c/;
s/c2f2ciof90_SOURCES.*/c2f2ciof90_SOURCES = c2f2ciof90.f90 c2f902cio.c/;
# s/c2f2ciof90_LDADD/c2f2cfio90_LDADD/g;
s/c2f2cwinf90_SOURCES.*/c2f2cwinf90_SOURCES = c2f2cwinf90.f90 c2f902cwin.c/;
s/c2fmult/c2f90mult/g;
if (/EXTRA_PROGRAMS/) {
s/allocmemf/allocmemf90/; # allocmemf test is special
}
# Handle the special case of C programs (used for f2c/c2f testing)
if (/^(\w+)_SOURCES(\s*=\s*)(\w+)\.c\s*$/) {
my $progname = $1;
my $spacing = $2;
my $name = $3;
if ($name !~ m/ctypesfromc/) {
$name =~ s/f(?!90)/f90/;
$progname =~ s/f(?!90)/f90/;
$_ = "$progname" . "_SOURCES" . $spacing . $name . ".c\n";
}
}
# Catch any bare "Xf" tests listed in noinst_PROGRAMS or
# EXTRA_PROGRAMS. Check for "Xf.f" to avoid substituting any random
# word that ends in "f". We also cheat a bit and look into the
# ioharness.defn in the indir directory for valid file names.
if (not m/^\s*#/) {
while (m/\b(\w+f)\b/g) {
my $word = $1;
next if $word eq "if" or $word eq "rf" or $word eq "endif"; # filter out some noise
if (-e "$indir/${word}.f" or
0 == system(qq(grep 'TESTDEFN filename="${word}\\.f"' '$indir/ioharness.defn' >/dev/null 2>&1)))
{
s/\b${word}\b/${word}90/g;
}
else
{
print "Skipping word '${word}' because file $indir/${word}.f is not present\n" if $reportSkipped;
}
}
}
# f90 makefiles should use the corresponding common automake fragment
s/Makefile_f77.mtest/Makefile_f90.mtest/g;
# Eventually need some way to update directory paths (particularly
# relative ones) and add F90 compile rules when not present.
print OUTF $_;
}
my $mcf_plus = '';
if ($saw_maintainercleanfiles) {
$mcf_plus = '+';
}
my $ed_plus = '';
if ($saw_extra_dist) {
$ed_plus = '+';
}
my $testlist_ap = '';
if (-f "${outdir}/testlist.ap") {
$testlist_ap = 'testlist.ap';
}
my $makefile_ap = '';
if (-f "${outdir}/Makefile.ap") {
$makefile_ap = 'Makefile.ap';
}
# append a rule to help remake the f90 Makefile.am if the f77 Makefile.am is
# updated
print OUTF <<EOT;
if MAINTAINER_MODE
# f77tof90 only replaces output files if the contents differ, so we must use a
# separate timestamp file in order avoid constantly trying to remake the f90
# copy of the Makefile when the f77 copy is updated in a way that does not
# change its contents
\$(srcdir)/Makefile.am: \$(srcdir)/Makefile.am-stamp
\$(srcdir)/Makefile.am-stamp: \$(master_top_srcdir)/${indir}/Makefile.am \$(master_top_srcdir)/maint/f77tof90
\t( cd \$(master_top_srcdir) && ./maint/f77tof90 ${indir} ${outdir} Makefile.am Makefile.ap )
MAINTAINERCLEANFILES ${mcf_plus}= Makefile.am-stamp
EXTRA_DIST ${ed_plus}= Makefile.am-stamp ${testlist_ap} ${makefile_ap}
endif MAINTAINER_MODE
EOT
close( INF );
close( OUTF );
# The check on a file change is handled in the routine that calls this
# because we may append to this file first.
}
# Append infile to the end of inout file
#( infile, inoutfile )
sub AppendFile {
my $infile = $_[0];
my $outfile = $_[1];
open( INA, "<$infile" ) || die "Cannot open $infile\n";
open( OUTA, ">>$outfile" ) || die "Cannot open $outfile\n";
while (<INA>) {
print OUTA $_;
}
close(INA);
close(OUTA);
}
#
# Replace old file with new file only if new file is different
# Otherwise, remove new filename
sub ReplaceIfDifferent {
my ($oldfilename,$newfilename) = @_;
my $rc = 1;
if (-s $oldfilename) {
$rc = system "cmp -s $newfilename $oldfilename";
$rc >>= 8; # Shift right to get exit status
}
if ($rc != 0) {
print STDERR "Replacing $oldfilename\n";
if ($debugReplace && -s $oldfilename) {
print STDERR "Differences are:";
system "diff $newfilename $oldfilename";
}
# The files differ. Replace the old file
# with the new one
if (-s $oldfilename) {
unlink $oldfilename;
}
rename $newfilename, $oldfilename ||
die "Could not replace $oldfilename";
}
else {
unlink $newfilename;
}
}
# Change the names of the tests. Remove any that were skipped from the
# Makefile. Check for a testlist.in before testlist
sub ConvertTestlist {
my ($indir, $outdir, $filename) = @_;
open( INF, "<$indir/$filename" ) || die "Cannot open $indir/$filename\n";
open( OUTF, ">$outdir/$filename.new" ) || die "Cannot open $outdir/$filename.new\n";
print OUTF "# This file generated by f77tof90\n";
while (<INF>) {
if (/^(\w+)\s/) {
my $sourcebase = $1;
if (defined($excludePrograms{$sourcebase})) { next; }
}
if (/^(\w+f)\s+(.*)/) {
$_ = $1 . "90 " . $2 . "\n";
}
elsif (/^c2fmult(\w*)\s+(.*)/) {
# This is a special case for programs that are not Fortran
# programs but are part of the Fortran tests; principly, these
# are the tests of MPI handle conversion
# note the \w* instead of \w+; this allows us to match both
# c2fmult.c and c2fmultio.c
$_ = "c2f90mult$1 $2\n";
}
elsif (/^\@ALLOCMEMF\@/) {
# This is a special case for an optional feature (using
# Cray-style pointers for MPI_Alloc_mem).
$_ = "\@ALLOCMEMFC\@\n";
}
elsif (/^(\@\w+\@)(\s*\w+f)\s+(.*)/) {
# This handles the case where an autoconf variable in the
# testlist.in file is used to optionally comment out a test
$_ = $1 . $2 . "90 " . $3 . "\n";
}
print OUTF $_;
}
close INF;
close OUTF;
}