Guide to Editing

Дата канвертавання19.04.2016
Памер88.71 Kb.

Gaziantep University Linux:

Compiling Fortran 77 Programs

A Guide to Editing, Compiling, and Running Fortran 77 Programs on Central Linux Servers in the University of Gaziantep.

Fortran 77

gul-fortran77.doc, version 1.4

For the most up-to-date version of this guide download:

Version 1.0 25/08/2001

Version 1.1 17/07/2001

Version 1.2 07/12/2001

Version 1.3 20/08/2002

Version 1.4 09/10/2002

Revisions since version 1.0:

- Permitted Fortran file extensions (for the Fortran command) are .f and .f90

- Fortran 90 compiler

- g2 graphics library

- -fbounds-check available (and added to the Fortran command)

- file extension .f95 is permitted, and an unlimited number of options/source files.

- new web site, only .f and .f90 extensions permitted, removed library links.

- linking of libraries now requires the –L . option.

Dr Andrew Beddall


1. Introduction

2. Editing Fortran 77 Programs (edit)

3. Compiling Fortran 77 Programs (fortran)

4. Advanced Compiler Options (g77)

5. Creating Libraries (ar)

6. Program Execution (run)

7. Killing Executing Programs (kill)

8. Obtaining a Printout of your Fortran Source (print)

A. Obtaining Human Help

A very brief summary of this document (for the inpatient)

To edit, compile, and execute a Fortran program where the source file is called myprog.f the following commands can be used:

$ edit myprog.f

$ fortran myprog.f

$ run myprog

Read on for the details…

1. Introduction

Central Linux servers in the university of Gaziantep ( for staff and for students) provide account holders with programming facilities including editing, compiling, running and storing programs and data. Compilers include Fortran, C/C++, Perl and Latex, This document is intended as a detailed introductory guide to using central Linux servers for programming in Fortran. This guide assumes the reader is familiar with logging into a central Linux server.

This document is not a Fortran language guide.

2. Editing Fortran 77 Programs (edit)

Various editors are available under Linux, the recommended editor for programming is the PICO editor. PICO is a powerful and very easy to use editor. It is invoked with the commands pico or edit. The command edit is equivalent to pico –w, the option –w option turns off word wrapping; the edit command also prevents the user from editing binary files which can otherwise cause PICO to hang or crash.

Fortran source programs should have the extension .f and .f90, it is expected that .f95 will be available in the future.

Example ($ is the Linux command prompt):

$ edit myprog.f

This command loads the file myprog.f into the PICO editor or creates a new file if it doesn’t already exist:

UW PICO(tm) 3.6 File: myprog.f



PRINT *, 'Type the length in Feet'


METRES = FEET*0.3048

PRINT *, FEET,' feet = ',METRES,' metres'


[ Read 11 lines ]

ctrl ^G Get Help ^O WriteOut ^R Read File ^Y Prev Pg ^K Cut Text ^C Cur Pos

ctrl ^X Exit ^J Justify ^W Where is ^V Next Pg ^U UnCut Text ^T To Spell

The top row of the PICO window gives the PICO program version and the currently open file. At the bottom of the PICO window is a menu of Control-key commands (not all available commands are shown). For example, to write you modifications to your file-space press the ctrl and O keys together, to search for a word press ctrl-W, to exit the editor press ctrl-X . A list of the complete set of commands is obtained by pressing ctrl-G. Some of the more commonly used commands are listed below:

^G Display this help text.

^P move to the Previous line.

^N move to the Next line.

^A move to the beginning of the current line.

^E move to the End of the current line.

^V move forward a page of text.

^Y move backward a page of text.

^W Search for (where is) text, neglecting case.

^L Refresh the display.

^^ Mark cursor position as beginning of selected text.

^K Cut selected text (displayed in inverse characters).

^U Uncut (paste)

^J Format (justify) the current paragraph.

^T To invoke the spelling checker

^C Report current cursor position

^R Insert an external file at the current cursor position.

^O Output the current buffer to a file, saving it.

^X Exit pico, saving buffer.

3. Compiling Fortran 77 Programs (fortran)

The Fortran compiler on central Linux servers is called g77, this command takes various compiler parameters and options; the recommended basic options are provided in the simplified compilation command fortran , for example:

$ fortran myprog.f

This command compiles the Fortran program source contained in the file myprog.f and creates (if the compilation is successful) the executable myprog.

The example is equivalent to the following g77 compilation (which is explained in Section 4):

g77 myprog.f -o myprog -O2 -Wall -fbounds-check
Other examples of the command fortran:
$ fortran myprog.f90 (Fortran 90 support)

$ fortran myprog.f –L. –lmylib (link library libmylib.a)

$ fortran myprog.f myprog2.f (append myprog2.f to the compilation)

$ fortran myprog.f myprog2.o (link object myprog2.o)

$ fortran myprog.f -finit-local-zero (an extra g77 option, see Section4)

In all of the above examples the output executable is called myprog (i.e the source file name minus the dot extension). Note that only two program source extension types are permitted: .f and .f90. After the main source file name an unlimited number of compiler options and sub-program sources can be added to the fortran command.

4. Advanced Compiler Options (g77)

The following compiler options can be appended to the end of your fortran command, or alternatively you can use the g77 command directly.

Here is a summary of g77 options covering most of what you might need for more advanced compilation of Fortran programs (including linking objects and libraries). Complete g77 Fortran compilation options and other detailed information about the g77 compiler can be found at:
A basic compilation:
$ g77 myprog.f –o myprog
where the Fortran program source is contain in the file myprog.f and the compiled executable program is myprog.
Other options can be included, for example the command fortran (explained in Section 3) is equivalent to the following g77 compilation:
g77 myprog.f -o myprog -O2 -Wall -fbounds-check
-O2 is an optimise option (your program might run about twice as fast).

-Wall instructs the compiler to give warnings.

-fbound-check run-time array boundary checking.

To compile without linking use the -c option:
$ g77 myprog.f -c
this gives a compiled object file myprog.o
To link two sources or objects use any of the following commands:
$ g77 -o myprog myprog.f lapbits.f

$ g77 -o myprog myprog.f lapbits.o

$ g77 -o myprog myprog.o lapbits.o
the .o object files must exist; i.e. created with ‘g77 –c’
To give the address of INCLUDE files:
$ g77 myprog.f -I/home/yilmaz/fortran/inc/graphics/

or $ g77 myprog.f -I$MYINC

where the environment variable MYINC is set with:

$ MYINC=/home/yilmaz/fortran/inc/graphics/

Libraries are linked as follows:
$ g77 –o myprog myprog.f –L. -lgrafs
the convention is to begin the library name with ‘lib' and end with ‘.a’ these are omitted following the -l option and so the library linked in this example is called libgrafs.a
$ g77 –o myprog myprog.f -L/usr/lib -lgrafs
The –L option tells the compiler that the library can be found in /usr/lib i.e. the library /usr/lib/libgrafs.a exists.
Other compiler options:
-O2 (uppercase o) optimise (programs often run twice as fast with this).

-fbounds-check runt-me checking of array boundary errors (recommended!)

-fno-backslash \\ may be interpreted different from other compilers!

-fno-silent print program units being compiled.

-ffree-form free-format souce code (i.e. no column 6,7,72 etc restrictions).

-ffixed-line-length-132 up to 132 characters allowed , can be any value.

-fpedantic checks for statements which might be ambiguous when porting

from other compilers.

-Wimplicit Warning : implicit none.

-Wunused Warning : declared but unused variables.

-Wuninitialized Warning : uninitialised variables (you must use -O2 here).

-Wall Warning : = unused+uninitialised.

-finit-local-zero Initialises all un-initialised variables to zero.
Random number generator: RAN() (this is not a g77 option, it is a local library)

A random number generator is supplied on local Linux servers in /usr/local/lib (which is in your PATH variable). The usage is the same as the VMS FORTRAN Function 'RAN()' so programs ported from VMS will work in this sense; but you need to link the 'ran' library; for example:

$ g77 myprog.f -o myprog –L/usr/local/lib -lran
Example of usage (as in VMS FORTRAN) is given below; the program outputs ten random numbers:
C Fortran 77 program making use of the RAN() function

ISEED=314159265 ! initialise the seed

DO I=1,10

R=RAN(ISEED) ! call RAN() for a random number



Note: 'RAN()' is based on Park and Miller's "Minimal Standard" random number generator (Comm. ACM, 31, 1192, 1988) it has a period of about 109; If you need a 'serious' generator (e.g. with a very long period) then you shouldn’t use this function.
The g2 Graphics Library (this is not a g77 option, it is a local library)

You can obtain graphical output by using commands from the g2 graphic library;

Other g77 facilities
- g77 supports the three-octal-digit for ASCII codes, for example
print *,'\265' outputs the greek mu character

print *,'\007' gives a bell

- Linux commands can be given from the SYSTEM call:
CALL SYSTEM('Linux command',ISTAT)
where 'Linux command' can be, for example, 'ls' for directory listing. ISTAT is an INTEGER containing the exit status of the call.

Some notes which you might find useful:

1. In the currently installed g77 version there is no facility for run-time bounds checking (the next upgrade will contain a bounds checking option)
2. Uninitialised variables are NOT automatically set to zero (unlike the VMS compiler), you should therefore initialise all your variables otherwise they will take unpredictable values. If your program behaves strangely and you suspect it is due

uninitialised variables then try the compiler option -finit-local-zero this will initialise all uninitialised variables to zero.

To find these variables in your source code you can switch on the warning option:

–Wuninitialized (without -finit-local-zero).

3. Double-precision constants, for example 9.43874539284958 will be interpreted as a single precision value i.e. it will be truncated to 9.4387453. You should use the double-precision notation i.e. write 9.43874539284958D0 .

5. Creating Libraries (ar)
Libraries of functions and subroutines can be created as follows:
For example, to create a library called libfruit.a containing:

apple.o , pear.o , orange.o

$ ar rcvf libfruit.a apple.o pear.o orange.o

(see man ar)

You can add objects to the library with:
$ ar rcvf libfruit.a banana.o
To list the contents of the library:
$ ar tv libfruit.a
To list subroutines/functions in a library:
$ nm libfruit.a

(see man nm)

To delete an object from the library:
$ ar dv libfruit.a pear.o
To link the library when compiling a Fortran program supper.f which requires, for example, apple.o and pear.o:
$ g77 supper.f -o supper –L. –lfruit
Note that lib and .a are dropped.

The –L. options tells the linker that the library can be found in the current directory.

If the library is not in the current directory then you should give the path:
$ g77 supper.f -o supper -L/home/yilmaz/fortran/lib -lfruit


$ g77 supper.f -o supper -L$MYLIB -lfruit

with MYLIB=/home/yilmaz/fortran/lib

6. Program Execution (run)
There are two modes of program execution; these are interactive (the commands nice and run), and background (the & symbol and the command submit). Note that there are no cpu time limits or batch queues.

Executing programs

To run an executable program you can simple type its name or use the run command. For example, you have compiled a Fortran program into an executable program called myprog. The program can be executed with one of the following commands:

$ myprog

$ ./myprog

(if myprog exists elsewhere in the user’s PATH then ‘./’ specifies that the file

to be executed is in the present working directory)

$ nice myprog (please use this one or the next to be nice to other users)

$ run myprog (preferred)

The command nice executes the program with a lower cpu priority and therefore does not interfere with interactive logins (see the command top). The command run is equivalent to the command nice plus some extra checks; this is the preferred command for executing programs, please use it.

Output redirection

Output from a program can be redirected (from the terminal screen) to a file by using the symbol ‘>’ as follows:
$ run myprog > myprog.out
In this example the output of myprog is redirected to the file myprog.out (instead of the terminal screen). Use the command edit myprog.out to view the contents of the output file.

Executing programs in background

A program can be placed in background for execution by appending the symbol ‘&’ to the execution command. Examples:
$ run myprog &
$ run myprog > myprog.out &
The program executes in background detached from the interactive login. The user can issue other commands or even log off while the program continues to run. It is usual to use redirection (the second example) when executing programs in background.
The submit command

The command submit can be used to execute a program in background, the output of the program is redirected to an output file and the user informed automatically by email when the execution is complete. Example:

$ submit myprog myprog.out
In this example the executable is myprog and the output file is myprog.out. This command is particularly useful for long-running programs (hours or days) as the user is informed by email when the job is finished. For more details type submit on its own.

7. Killing Executing Programs (kill)

It is sometimes necessary to kill a program before its execution is complete for example when it is executing for much longer than expected (infinite loop?) or producing too much output.

A program running interactively can be kill by simply pressing the Ctrl-C keys (do not use Ctrl-Z, this will stop the program but not kill it – it will wait in background for an instruction to resume execution; see the commands bg and fg).
For programs running in background the command to kill a program which is executing in background is:
$ kill %job-id
where the job-id is found with the command jobs .

$ jobs

[1]- Running run myprog &

[2]+ Running run myprog2 &

$ kill %2

In this case the second job is killed.

Note that this does not work for programs executed with the command submit, for these and any other process owned by the user an alternative method for killing programs can be used:
$ kill –9 process-id
where the process-id can be found with the command ps -a .


$ ps -a


13300 pts/2 00:00:00 bash

10475 pts/0 00:00:00 run

10476 pts/0 00:00:06 myprog

10477 pts/0 00:00:00 ps

$ kill -9 10476

In this case the program called myprog (process-id 10476) is killed.

8. Obtaining a Printout of your Fortran Source (print)

Printouts of Fortran source files can be obtained from the computer center. To submit a file to the printer the command print is used; example:

$ print myprog.f
on gul1 this command submits a file to the 132 column printer, on gul2 it submits to the 80 column printer.

A. Obtaining Human Help
Help on any of the above topics can be obtained from the author either by email (preferably in English) or a visit to my office:
Dr Andrew Beddall

GU System manager

University of Gaziantep

Department of Engineering Physics,

Room 206, Email:

End of document

База данных защищена авторским правом © 2016
звярнуцца да адміністрацыі

    Галоўная старонка