Elements of FORTRAN

1

This chapter introduces the basic elements of Sun FORTRAN 77.

Standards

The Sun FORTRAN 77 compiler f77 is an enhanced FORTRAN development system. It conforms to the ANSI X3.9-1978 FORTRAN standard and the corresponding International Standards Organization number is ISO 1539-1980. NIST (formerly GSA and NBS) validates it at appropriate intervals.

This compiler also conforms to the standards FIPS 69-1, BS 6832, and MIL-STD-1753. It provides an IEEE standard 754-1985 floating-point package.

On SPARC systems, it provides support for optimization exploiting features of SPARC V8, including the SuperSPARC^TM implementation. These features are defined in the SPARC Architecture Manual: Version 8.

Extensions

Extensions to the standard FORTRAN 77 language include recursion, pointers, double-precision complex, quadruple-precision real, quadruple-precision complex, and many VAXŽ and VMSŽ FORTRAN 5.0 extensions, including NAMELIST, DO WHILE, structures, records, unions, maps, and variable formats. Multiprocessor FORTRAN includes automatic and explicit loop parallelization.

Sun FORTRAN 77 accepts many VMS extensions, so that programs originally written for VAX systems will port easily to Solaris.

Basic Terms

Some of the FORTRAN basic terms and concepts are:

A program consists of one or more program units.

A program unit is a sequence of statements, terminated by an END.

A statement consists of zero or more key words, symbolic names, literal constants, statement labels, operators, and special characters.

Each key word, symbolic name, literal constant, and operator consists of one or more characters from the FORTRAN character set.

A character constant can include any valid ASCII character.

A statement label consists of 1 to 5 digits, with at least one nonzero.

Character Set

The character set consists of the following:

Uppercase and lowercase letters, A - Z and a - z

Numerals 0 - 9

Special characters--The following table shows the special characters that are used for punctuation:

Table 1-1 Special Character Usage
Character	Name	Usage
Space	Space	Ignored in statements, except as part of a character constant
Tab	Tab	Establish the line as a tab-format source line
`=`	Equals	Assignment
`+`	Plus	Add, unary operator
`-`	Minus	Subtract, unary operator
`*`	Asterisk	Multiply, alternate returns, comments, exponentiation, `stdin`, `stdout`, list-directed I/O
`/`	Slash	Divide, delimit data, labeled commons, structures, end-of-record
`( )`	Parentheses	Enclose expressions, complex constants, equivalence groups, formats, argument lists, subscripts
`,`	Comma	Separator for data, expressions, complex constants, equivalence groups, formats, argument lists, subscripts
`.`	Period	Radix point, delimiter for logical constants and operators, record fields
`'`	Apostrophe	Quoted character literals
`"`	Quote	Quoted character literals, octal constants
`$`	Dollar sign	Delimit namelist input, edit descriptor, directives
`!`	Exclamation	Comments
`:`	Colon	Array declarators, substrings, edit descriptor
`%`	Percent	Special functions: `%REF`, `%VAL`, `%LOC`
`&`	Ampersand	Continuation, alternate return, delimit namelist input; in column 1: establish the line as a tab-format source line
`?`	Question mark	Request names in namelist group
`\`	Backslash	Escape character
< >	Angle brackets	Enclose variable expressions in formats

Note the following usage and restrictions:

Uppercase and lowercase--The case is not significant in the key words of FORTRAN statements or in symbolic names.

The -U option of f77 makes case significant in symbolic names.

Control characters --Even though they are not in the character set, most control characters are allowed as data. The exceptions are: Control A, Control B, Control C, which are not allowed as data. These characters can be entered into the program in other ways, such as with the char() function.

ASCII characters--Any ASCII character is valid as literal data in a character string.

For the backslash (\) character, you may need to use an escape sequence or use the -xl compiler option. The backslash (\) is also called a reverse solidus, and the slash (/), a solidus. For the newline (\n) character, you must use an escape sequence. See also Table 2-3.

Symbolic Names

The items in the following table can have symbolic names:

Table 1-2 Items with Symbolic Names

The following restrictions apply:

Symbolic names can any number of characters long. The standard is 6.

Symbolic names consist of letters, digits, the dollar sign ($), and the underscore character (_). $ and _ are not standard.

Symbolic names generally start with a letter--never with a digit or dollar sign ($). Names that start with an underscore (_) are allowed, but may conflict with names in the Fortran and system libraries.

Uppercase and lowercase are not significant; the compiler converts them all to lowercase. The -U option on the f77 command line overrides this default, thereby preserving any uppercase used in your source file.

Example: These names are equivalent with the default in effect:

	ATAD = 1.0E-6

	Atad = 1.0e-6

The space character is not significant.

Example: These names are equivalent:

	IF ( X .LT. ATAD ) GO TO 9

	IF ( X .LT. A TAD ) GO TO 9

	IF(X.LT.ATAD)GOTO9

Here are some sample symbolic names:

Table 1-3 Sample Symbolic Names
Valid	Invalid	Reason
`X2`	`2X`	Starts with a digit.
`DELTA_TEMP`	`_DELTA_TEMP`	Starts with an `_` (reserved for the compiler).
`Y$Dot`	`Y\|Dot`	There is an invalid character `\|`.

In general, for any single program unit, different entities cannot have the same symbolic name. The exceptions are:

Throughout any program of more than one programming unit, no two of the following can have the same name:

Program

A program unit is a sequence of statements, terminated by an END statement. Every program unit is either a main program or a subprogram. If a program is to be executable, it must have a main program.

There are three types of subprograms: subroutines, functions, and block data subprograms. The subroutines and functions are called procedures, which are invoked from other procedures or from the main program. The block data subprograms are handled by the loader.

Statements

A statement consists of one or more key words, symbolic names, literal constants, and operators, with appropriate punctuation. In FORTRAN, no keywords are reserved in all contexts. Most statements begin with a keyword; the exceptions are the statement function and assignment statements.

Executable or Nonexecutable Statements

Every statement is either executable or nonexecutable. In general, if a statement specifies an action to be taken at runtime, it is executable. Otherwise, it is nonexecutable.

The nonexecutable statements specify attributes, such as type and size; determine arrangement or order; define initial data values; specify editing instructions; define statement functions; classify program units; and define entry points. In general, nonexecutable statements are completed before execution of the first executable statement.

FORTRAN Statements

Table 1-4 FORTRAN Statements

GOTO (Unconditional)*

PRINT*

The asterisk (*) in the table indicates an executable statement.

Source Line Formats

A statement takes one or more lines; the first line is called the initial line; the subsequent lines are called the continuation lines.

You can format a source line in either of two ways:

Standard fixed format

Tab format

Standard Fixed Format

The standard fixed format source lines are defined as follows:

The first 72 columns of each line are scanned. See "Extended Lines," page 8.

The first five columns must be blank or contain a numeric label.

Continuation lines are identified by a nonblank, nonzero in column 6.

Short lines are padded to 72 characters.

Long lines are truncated. See "Extended Lines," below.

Tab-Format

The tab-format source lines are defined as follows:

A tab in any of columns 1 through 6, or an ampersand in column 1, establishes the line as a tab-format source line.

If the tab is the first nonblank character, the text following the tab is scanned as if it started in column 7.

A comment indicator or a statement number can precede the tab.

Continuation lines are identified by an ampersand (&) in column 1, or a nonzero digit after the first tab.

Mixing Formats

You can format lines both ways in one program unit, but not in the same line.

Continuation Lines

The default maximum number of continuation lines is 99 (1 initial and 99 continuation). To change this number of lines, use the -Nln option.

Extended Lines

To extend the source line length to 132 characters, use the -e option. Otherwise, by default, f77 ignores any characters after column 72.

Example: Compile to allow extended lines:

demo% f77 -e prog.f

Padding

Padding is significant in lines such as the two in the following DATA statement:

C        1         2         3         4         5         6         7 
C23456789012345678901234567890123456789012345678901234567890123456789012

      DATA SIXTYH/60H

     1                              /

Comments and Blank Lines

A line with a c, C, *, d, D, or! in column one is a comment line, except that if the -xld option is set, then the lines starting with D or d are compiled as debug lines. The d, D, and! are nonstandard.

If you put an exclamation mark (!) in any column of the statement field, except within character literals, then everything after the ! on that line is a comment.

A totally blank line is a comment line.

Example: c, C, d, D, *,!, and blank comments:

c	Start expression analyzer

	CHARACTER S, STACK*80

	COMMON /PRMS/ N, S, STACK

...

*	Crack the expression:

	IF ( S .GE. '0' .AND. S .LE. '9' ) THEN ! EoL comment

		CALL PUSH 	! Save on stack. EoL comment

d		PRINT *, S	! Debug comment & EoL comment

	ELSE

		CALL TOLOWER ! To lowercase EoL comment

	END IF

D	PRINT *, N		! Debug comment & EoL comment

...

C	Finished

!	expression analyzer

Directives

A directive passes information to a compiler in a special form of comment. Directives are also called compiler pragmas. There are two kinds of directives:

General directives

Parallel directives

General Directives

The form of a general directive is one of the following:

C$PRAGMA id

C$PRAGMA id ( a [ , a] ... ) [ , id ( a [ , a ] ... ) ] ,...

C$PRAGMA sun id=

The variable id identifies the kind of directive; a is an argument.

Syntax

A directive has the following syntax:

In column one, any of the comment-indicator characters c, C, !, or *

In any column, the ! comment-indicator character

The next 7 characters are $PRAGMA, no blanks, any uppercase or lowercase

Rules and Restrictions

After the first eight characters, blanks are ignored, and uppercase and lowercase are equivalent, as in FORTRAN text.

Because it is a comment, a directive cannot be continued, but you can have many C$PRAGMA lines, one after the other, as needed.

If a comment satisfies the above syntax, it is expected to contain one or more directives recognized by the compiler; if it does not, a warning is issued.

The `C()` Directive

The C() directive specifies that its arguments are external functions written in the C language. It is equivalent to an EXTERNAL declaration with the addition that the f77 compiler does not append an underscore to such names, as it ordinarily does with external names.

The C() directive for a particular function must appear before the first reference to that function in each subprogram that contains such a reference. The recommended usage is:

	EXTERNAL ABC, XYZ  !$PRAGMA C(ABC, XYZ)

The `unroll` Directive

The unroll directive requires that you specify sun after C$PRAGMA.

The C$PRAGMA sun unroll=n directive allows the optimizer to unroll loops n times, where n is a positive integer. The choices are:

If n=1, this directive orders the optimizer not to unroll any loops.

If n>1, this directive suggests to the optimizer that it unroll loops n times.

Loops are only unrolled if deemed profitable by the optimizer. If any loops are actually unrolled, then the executable file becomes larger. For a discussion of loop unrolling, see the Sun Fortran: Programmer's Guide chapter Performance and Optimization.

Example: To unroll loops two times:

C$PRAGMA SUN UNROLL=2

The `WEAK` Directive

The WEAK directive defines a symbol to have less precedence than an earlier definition of the same symbol. This pragma is used mainly in sources files for building libraries. The linker does not produe an error message if it is unable to resolve a weak symbol.