Previous Next Contents Index Doc Set Home


Program Development

3

This chapter briefly introduces two powerful program development tools, make and SCCS, that can be used very successfully with Fortran programs.

Facilitating Program Builds With the make Utility

The make utility applies intelligence to the task of program compilation and linking. Typically, a large application may exist as a set of source files and INCLUDE files, which require 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 insures that only the files that need recompiling are recompiled and that relinking to build the executable uses the options and libraries you want. The following discussion provides a simple example of how to use make. For a summary, see make(1).

The makefile

A file called makefile tells make in a structured manner which source and object files depend on other files, and defines the commands required to compile and link them.

For example, suppose you have a program of four source files and the makefile:

demo% ls 

makefile 

commonblock 

computepts.f 

pattern.f 

startupcore.f 

demo%

Assume both pattern.f and computepts.f have an INCLUDE of commonblock, and you wish to compile each.f file and link the three relocatable files, along with a series of libraries, into a program called pattern.

The makefile looks like this: 

demo% cat makefile 

pattern: pattern.o computepts.o startupcore.o 

	f77 pattern.o computepts.o startupcore.o -lcore77 \ 

	-lcore -lsunwindow -lpixrect -o pattern 

pattern.o: pattern.f commonblock 

	f77 -c -u pattern.f 

computepts.o: computepts.f commonblock 

	f77 -c -u computepts.f 

startupcore.o: startupcore.f 

	f77 -c -u startupcore.f 

demo%

The first line of this makefile indicates that making pattern depends on pattern.o, computepts.o, and startupcore.o. The next line and its continuations give the command for making pattern 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-list
TAB build-commands

make Command

The make command can be invoked with no arguments, simply:

demo% make

The make utility looks for a file named makefile or Makefile in the current directory and takes its instructions from that file.

The make utility:

Macros

The make utility's macro facility allows simple parameterless string substitutions. For example, the list of relocatable files that make up the target program pattern can be expressed as a single macro string, making it easier to change.

A macro string definition has the form:

NAME = string

Use of a macro string is indicated by

$(NAME)

which is replaced by make with the actual value of the macro string named.

This example adds a macro definition naming all the object files to the beginning of makefile:

OBJ = pattern.o computepts.o startupcore.o

Now the macro can be used in both the list of dependencies as well as on the f77 link command for target pattern in makefile:

pattern: $(OBJ)

	f77 $(OBJ) -lcore77 -lcore -lsunwindow \

	-lpixrect -o pattern

For 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 to make. For example, with the following line to the top of makefile:

FFLAGS=-u

and the compile-line of computepts.f: 

f77 $(FFLAGS) -c computepts.f

and the final link:

f77 $(FFLAGS) $(OBJ) -lcore77 -lcore -lsunwindow \ 

   lpixrect -o pattern

Now a simple make command without arguments uses the value of FFLAGS set above. However, this can be overridden from the command line: 

demo% make "FFLAGS=-u -O"

Here, the definition of the FFLAGS macro on the make command line overrides the makefile initialization, and both the -O flag and the -u flag are passed to f77. Note that "FFLAGS=" can also be used on the command to reset the macro so that it has no effect.

Suffix Rules in make

To make writing a makefile easier, make has its own default rules that it will use depending on the suffix of a target file. Recognizing the .f suffix, make uses the f77 compiler passing as arguments any flags specified by the FFLAGS macro, the -c flag, and the name of the source file to be compiled.

The example below demonstrates this rule twice:

OBJ = pattern.o computepts.o startupcore.o 

FFLAGS=-u 

pattern: $(OBJ) 

	f77 $(OBJ) -lcore77 -lcore -lsunwindow \ 

	-lpixrect -o pattern 

pattern.o: pattern.f commonblock 

	f77 $(FFLAGS) -c pattern.f 

computepts.o: computepts.f commonblock 

startupcore.o: startupcore.f

make uses default rules to compile computepts.f and startupcore.f.

Similarly, suffix rules for .f90 files also exist to invoke the f90 compiler

More Information

A number of good, commercially published books on using make as a program development tool are currently available, including Managing Projects with make, by Oram and Talbott, from O'Reilly & Associates.

Version Tracking and Control With SCCS

SCCS stands for Source Code Control System. SCCS provides a way to:

The basic three operations of SCCS are:

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, and delget.

Controlling Files With SCCS

Putting files under SCCS control involves:

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 SCCS

SCCS must be in uppercase.

Inserting 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 or delget command. There are three likely places to put these strings:

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. Some files, like ASCII data files or makefiles, the SCCS information appears in comments.

SCCS keywords appear in the form %keyword% and are expanded into their values by the SCCS get command. The most commonly used keywords are:

%Z% expands to the identifier string @(#) recognized by the what 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, we could identify the makefile with a make comment containing these keywords: 

#	%Z%%M%	 %I% 	%E%

The source files, startupcore.f, computepts.f, and pattern.f can be identified by initialized data of the form:

	CHARACTER*50 SCCSID 

	DATA SCCSID/"%Z%%M% 	%I%	 %E%\n"/

When this file is processed by SCCS and then compiled and the object file processed by the what command, the following will be displayed:

demo% f77 -c pattern.f

...

demo% what pattern

pattern:

	pattern.f 1.2 96/06/10

You can also create a PARAMETER named CTIME that is automatically updated whenever the file is accessed with get. 

	CHARACTER*(*) CTIME

	PARAMETER ( CTIME="%E%")

INCLUDE files can be annotated with a Fortran comment containing the SCCS stamp: 

C 	%Z%%M% 	%I% 	%E%

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 is 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.

Check in the modified file with the sccs delget command when you have completed your editing. For example:

demo% sccs delget computepts.f

This command causes the SCCS system to do the following:

1. Make sure that you are the user who checked out the file by comparing login names.

2. Prompt for a comment from you on the changes.

3. Make a record of what was changed in this editing session.

4. Delete the writable copy of computepts.f from the current directory.

5. 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 and get. The delta command performs the first three tasks in the list above; the get command performs the last two tasks.

More Information

We recommend the book Applying RCS and SCCS, by Bolinger and Bronson, from O'Reilly & Associates.


Previous Next Contents Index Doc Set Home