Fortran Programming Guide | ![]() ![]() ![]() ![]() ![]() |
Program Development
This chapter briefly introduces two powerful program development tools,
make
and SCCS, that can be used very successfully with Fortran programs.A number of good, commercially published books on using
make
and SCCS are currently available, including Managing Projects with make, by Andrew Oram and Steve Talbott, and Applying RCS and SCCS, by Don Bolinger and Tan Bronson. Both are from O'Reilly & Associates.Facilitating Program Builds With the
make
UtilityThe
make
utility applies intelligence to the task of program compilation and linking. Typically, a large application consists of a set of source files andINCLUDE
files, requiring linking with a number of libraries. Modifying any one or more of the source files requires recompilation of that part of the program and relinking. You can automate this process by specifying the interdependencies between files that make up the application along with the commands needed to recompile and relink each piece. With these specifications in a file of directives,make
ensures that only the files that need recompiling are recompiled and that relinking uses the options and libraries you need to build the executable. The following discussion provides a simple example of how to usemake
. For a summary, seemake
(1).The Makefile
A file called
makefile
tellsmake
in a structured manner which source and object files depend on other files. It also defines the commands required to compile and link the files.For example, suppose you have a program of four source files and the makefile:
demo%ls
makefilecommonblockcomputepts.fpattern.fstartupcore.fdemo%Assume both
pattern.f
andcomputepts.f
have anINCLUDE
ofcommonblock
, and you wish to compile each.f
file and link the three relocatable files, along with a series of libraries, into a program calledpattern
.The makefile looks like this:
The first line of
makefile
indicates that makingpattern
depends onpattern.o
,computepts.o
, andstartupcore.o
. The next line and its continuations give the command for makingpattern
from the relocatable.o
files and libraries.Each entry in
makefile
is a rule expressing a target object's dependencies and the commands needed to make that object. The structure of a rule is:target
:
dependencies-listTAB
build-commands
- Dependencies. Each entry starts with a line that names the target file, followed by all the files the target depends on.
- Commands. Each entry has one or more subsequent lines that specify the Bourne shell commands that will build the target file for this entry. Each of these command lines must be indented by a tab character.
make
CommandThe
make
command can be invoked with no arguments, simply:
demo%make
The
make
utility looks for a file namedmakefile
orMakefile
in the current directory and takes its instructions from that file.
- Reads
makefile
to determine all the target files it must process, the files they depend on, and the commands needed to build them.- Finds the date and time each file was last changed.
- Rebuilds any target file that is older than any of the files it depends on, using the commands from
makefile
for that target.Macros
The
make
utility's macro facility allows simple, parameterless string substitutions. For example, the list of relocatable files that make up the target programpattern
can be expressed as a single macro string, making it easier to change.A macro string definition has the form:
Use of a macro string is indicated by:
which is replaced by
make
with the actual value of the macro string.This example adds a macro definition naming all the object files to the beginning of
makefile
:
OBJ = pattern.o computepts.o startupcore.oNow the macro can be used in both the list of dependencies as well as on the
f77
link command for targetpattern
inmakefile
:
pattern: $(OBJ)f77
$(OBJ) -lcore77 -lcore -lsunwindow \-lpixrect -o patternFor macro strings with single-letter names, the parentheses may be omitted.
Overriding of Macro Values
The initial values of
make
macros can be overridden with command-line options tomake
. For example:
Now a simple
make
command without arguments uses the value ofFFLAGS
set above. However, this can be overridden from the command line:
demo%make "FFLAGS=-u -O"
Here, the definition of the
FFLAGS
macro on themake
command line overrides themakefile
initialization, and both the-O
flag and the-u
flag are passed tof77
. Note that"FFLAGS="
can also be used on the command to reset the macro to a null string so that it has no effect.Suffix Rules in
make
To make writing a makefile easier,
make
will use its own default rules depending on the suffix of a target file. Recognizing the.f
suffix,make
uses thef77
compiler, passing as arguments any flags specified by theFFLAGS
macro, the-c
flag, and the name of the source file to be compiled.The example below demonstrates this rule twice:
make
uses default rules to compilecomputepts.f
andstartupcore.f
.
Similarly, suffix rules for
.f90
files will also invoke thef95
compiler. However, there are no suffix rules currently defined for.f95
Fortran 95 source files or.mod
Fortran 95 module files.Version Tracking and Control With SCCS
SCCS stands for Source Code Control System. SCCS provides a way to:
- Keep track of the evolution of a source file--its change history
- Prevent a source file from being simultaneously changed by other developers
- Keep track of the version number by providing version stamps
The basic three operations of SCCS are:
- Putting files under SCCS control
- Checking out a file for editing
- Checking in a file
This section shows you how to use SCCS to perform these tasks, using the previous program as an example. Only basic SCCS is described and only three SCCS commands are introduced:
create
,edit
, anddelget
.Controlling Files With SCCS
Putting files under SCCS control involves:
- Making the SCCS directory
- Inserting SCCS ID keywords into the files (this is optional)
- Creating the SCCS files
Making the SCCS Directory
To begin, you must create the SCCS subdirectory in the directory in which your program is being developed. Use this command:
demo% mkdir SCCSInserting SCCS ID Keywords
Some developers put one or more SCCS ID keywords into each file, but that is optional. These keywords are later identified with a version number each time the files are checked in with an SCCS
get
ordelget
command. There are three likely places to put these strings:
- Comment lines
- Parameter statements
- Initialized data
The advantage of using keywords is that the version information appears in the source listing and compiled object program. If preceded by the string @(#), the keywords in the object file can be printed using the
what
command.Included header files that contain only parameter and data definition statements do not generate any initialized data, so the keywords for those files usually are put in comments or in parameter statements. In some files, like ASCII data files or makefiles, the SCCS information will appear in comments.
SCCS keywords appear in the form
%
keyword%
and are expanded into their values by the SCCSget
command. The most commonly used keywords are:
%Z%
expands to the identifier string@(#)
recognized by thewhat
command.%M%
expands to the name of the source file.%I%
expands to the version number of this SCCS maintained file.%E%
expands to the current date.For example, you could identify the makefile with a
make
comment containing these keywords:
# %Z%%M% %I% %E%The source files,
startupcore.f
,computepts.f
, andpattern.f
, can be identified by initialized data of the form:
CHARACTER*50 SCCSIDDATA SCCSID/"%Z%%M% %I% %E%\n"/When this file is processed by SCCS, compiled, and the object file processed by the SCCS
what
command, the following is displayed:
demo%f77 -c pattern.f
...demo%what pattern
pattern:pattern.f 1.2 96/06/10You can also create a
PARAMETER
namedCTIME
that is automatically updated whenever the file is accessed withget
.
CHARACTER*(*) CTIMEPARAMETER ( CTIME="%E%")INCLUDE files can be annotated with a Fortran comment containing the SCCS stamp:
C %Z%%M% %I% %E%
Note Use of single letter derived type component names in Fortran 95 source code files can conflict with SCCS keyword recognition. For example, the Fortran 95 structure component referenceX%Y%Z
when passed through SCCS will becomeXZ
after an SCCSget
. Care should be taken not to define structure components with single letters when using SCCS on Fortran 95 programs. For example, had the structure reference in the Fortran 95 program been toX%YY%Z
, the%YY%
would not have been interpreted by SCCS as a keyword reference. Alternatively, the SCCSget -k
option will retrieve the file without expanding SCCS keyword IDs.
Creating SCCS Files
Now you can put these files under control of SCCS with the SCCS
create
command:
demo%sccs create makefile commonblock startupcore.f \
computepts.f pattern.f
demo%Checking Files Out and In
Once your source code is under SCCS control, you use SCCS for two main tasks: to check out a file so that you can edit it, and to check in a file you have finished editing.
Check out a file with the
sccs
edit
command. For example:
demo%sccs edit computepts.f
SCCS then makes a writable copy of
computepts.f
in the current directory, and records your login name. Other users cannot check the file out while you have it checked out, but they can find out who has checked it out.When you have completed your editing, check in the modified file with the
sccs
delget
command. For example:
demo%sccs delget computepts.f
This command causes the SCCS system to:
- Make sure that you are the user who checked out the file by comparing login names
- Prompt for a comment from you on the changes
- Make a record of what was changed in this editing session
- Delete the writable copy of
computepts.f
from the current directory- Replace it by a read-only copy with the SCCS keywords expanded
The
sccs
delget
command is a composite of two simpler SCCS commands,delta
andget
. Thedelta
command performs the first three tasks in the list above; theget
command performs the last two tasks.
Sun Microsystems, Inc. Copyright information. All rights reserved. Feedback |
Library | Contents | Previous | Next | Index |