Fortran dependencies

The files needed to compile a file, i.e the prerequisites of the file are:

—

The source file itself

—

Files with interface information about USEd modules, created by the compiler while compiling the modules (often named modulename.mod or something similar, hereafter called mod-files).

—

Include-files (including files included and mod-files of modules USEd from these include-files).

—

Coco set-files, if coco(1) is being used and set-files exist.

Since different compilers use different naming conventions for the mod-files, listing them in the dependency list results in non-portable makefiles. Therefore it's common practise to list the object file (filename.o) corresponding to the sourcefile containing the USEd modules instead. This is the default behaviour of makedepf90. To change this, use the -m option (e.g -m "%m.mod" if your compiler names the mod files modulename.mod)

Include files not found in the working directory will not be listed in the dependency list, assuming they are part of a (seldom changing) library not part of the program. Neither will mod-files of modules whose definitions aren't found be listed by the same reason.

Basic Usage

Here's an example of basic makedepf90 usage together with make(1). Create a file named Makefile with the following contents:

----------------------

# FC = the compiler to use
FC=f90

# Compiler options
FFLAGS=-O

# List libraries used by the program here
LIBS=

# Suffix-rules: Begin by throwing away all old suffix-
# rules, and then create new ones for compiling
# *.f90-files.
.SUFFIXES:
.SUFFIXES: .f90 .o

.f90.o:
$(FC) -c $(FFLAGS) $<

# Include the dependency-list created by makedepf90 below
include .depend

# target 'clean' for deleting object- *.mod- and other
# unwanted files
clean:
rm -f *.o *.mod core

# Create a dependency list using makedepf90. All files
# that needs to be compiled to build the program,
# i.e all source files except include files, should
# be given on the command line to makedepf90.
#
# The argument to the '-o' option will be the name of the
# resulting program when running 'make', in this case
# 'foobar'
depend .depend:
makedepf90 -o foobar *.f90 > .depend

-----------------------

(Note that all the indented lines should be indented with tabs, not spaces)

With this makefile, the command make should perform all the commands needed to compile and link the program foobar out of all *.f90 files in the working directory.

The dependency list .depend will be (re)created if .depend doesn't exist, or if the command make depend is run. This should be done every time changes has been made to the program that affect the dependencies of the files (e.g if new source files has been added to the project).

Example With Coco

If you are using a pre-processor, things might get more complicated. If you are lucky, your compiler supports your pre-processor and runs it on your code automatically, but if it doesn't, you have to give the commands to run the pre-processor yourself. Below is an example of an Makefile for coco(1)-users.

-----------------------
FC=f90
FFLAGS=-O
PREPROCESSOR=coco

.SUFFIXES:
.SUFFIXES: .f .f90 .o

# Files ending in .f90 are compiled directly ...
.f90.o:
$(FC) -c $(FFLAGS) $<

# ... while those ending in .f are preprocessed first.
.f.o:
$(PREPROCESSOR) $*; $(FC) -c $(FFLAGS) $*.f90

include .depend

clean:
rm -f *.o *.mod core

depend .depend:
makedepf90 -coco -o foobar *.f90 *.f > .depend

-----------------------

NOTE: Some implementations of make(1) will not execute any commands — not even make depend — with the Makefiles above unless there exists a file named .depend. To overcome this problem, either run makedepf90 manually, or begin by creating an empty .depend file with the command touch .depend.