Fortran 77 Language Reference |
Data Types and Data Items
This chapter describes the data types and data structures in Sun FORTRAN 77.
Nonstandard features are tagged with a small black cross ().
Types
Except for specifically typeless constants, any constant, constant expression, variable, array, array element, substring, or function usually represents typed data.
On the other hand, data types are not associated with the names of programs or subroutines, block data routines, common blocks, namelist groups, or structured records.
Rules for Data Typing
The name determines the type; that is, the name of a datum or function determines its data type, explicitly or implicitly, according to the following rules of data typing;
- A symbolic name of a constant, variable, array, or function has only one data type for each program unit, except for generic functions.
- If you explicitly list a name in a type statement, then that determines the data type.
- If you do not explicitly list a name in a type statement, then the first letter of the name determines the data type implicitly.
- The default implicit typing rule is that if the first letter of the name is
I
,J
,K
,L
,M
, orN
, then the data type is integer, otherwise it is real.- You can change the default-implied types by using the
IMPLICIT
statement, even to the extent of turning off all implicit typing with theIMPLICIT
NONE
statement. You can also turn off all implicit typing by specifying the-u
compiler flag on the command line; this is equivalent to beginning each program unit with theIMPLICIT
NONE
statement.Array Elements
An array element has the same type as the array name.
Functions
Each intrinsic function has a specified type. An intrinsic function does not require an explicit type statement, but that is allowed. A generic function does not have a predetermined type; the type is determined by the type of the arguments, as shown in Intrinsic Functions.
An external function can have its type specified in any of the following ways:
- Explicitly by putting its name in a type statement
- Explicitly in its
FUNCTION
statement, by preceding the wordFUNCTION
with the name of a data type- Implicitly by its name, as with variables
Example: Explicitly by putting its name in a type statement:
FUNCTION F ( X )INTEGER F, XF = X + 1RETURNENDExample: Explicitly in its
FUNCTION
statement:
INTEGER FUNCTION F ( X )INTEGER XF = X + 1RETURNENDExample: Implicitly by its name, as with variables:
FUNCTION NXT ( X )INTEGER XNXT = X + 1RETURNENDImplicit typing can affect the type of a function, either by default implicit typing or by an
IMPLICIT
statement. You must make the data type of the function be the same within the function subprogram as it is in the calling program unit. Thef77
compiler does no type checking across program units.Properties of Data Types
This section describes the data types in Sun FORTRAN 77.
Default data declarations, those that do not explicitly declare a data size can have their meanings changed by certain compiler options. The next section, Size and Alignment of Data Types summarizes data sizes and alignments and the effects of these options.
BYTE
The
BYTE
data type provides a data type that uses only one byte of storage. It is a logical data type, and has the synonym,LOGICAL*1
.A variable of type
BYTE
can hold any of the following:
- One eight-bit data item
- An integer between -128 and 127
- The logical values,
.TRUE.
or.FALSE
.If it is interpreted as a logical value, a value of 0 represents
.FALSE.
, and any other value is interpreted as.TRUE
.
f77
allows theBYTE
type as an array index, just as it allows theREAL
type, but it does not allowBYTE
as aDO
loop index (where it allows onlyINTEGER
,REAL
, andDOUBLE
PRECISION
). Wherever the compiler expectsINTEGER
explicitly, it will not allowBYTE
.Examples:
BYTE Bit3 / 8 /, C1 / 'W' /,& Counter / 0 /, Switch / .FALSE. /A
BYTE
item occupies 1 byte (8 bits) of storage, and is aligned on 1-byte boundaries.
CHARACTER
The character data type,
CHARACTER
, which has the synonym,CHARACTER*1
, holds one character.The character is enclosed in apostrophes (') or quotes (
"
). Allowing quotes (") is nonstandard; if you compile with the-xl
option, quotes mean something else, and you must use apostrophes to enclose a string.The data of type
CHARACTER
is always unsigned. ACHARACTER
item occupies 1 byte (8 bits) of storage and is aligned on 1-byte boundaries.
CHARACTER*
nThe character string data type,
CHARACTER
*n, where n > 0, holds a string of n characters.A
CHARACTER
*n data type occupies n bytes of storage and is aligned on 1-byte boundaries.Every character string constant is aligned on 2-byte boundaries. If it does not appear in a
DATA
statement, it is followed by a null character to ease communication with C routines.
COMPLEX
A complex datum is an approximation of a complex number. The complex data type,
COMPLEX
, which defaults to a synonym forCOMPLEX*8
, is a pair ofREAL*4
values that represent a complex number. The first element represents the real part and the second represents the imaginary part.The default size for a
COMPLEX
item (no size specified) is 8 bytes. The default alignment is on 4-byte boundaries. However, these defaults can be changed by compiling with certain special options (see Size and Alignment of Data Types).
COMPLEX*8
The complex data type
COMPLEX*8
is a synonym forCOMPLEX
, except that it always has a size of 8 bytes, independent of any compiler options.
COMPLEX*16
(Double Complex)The complex data type
COMPLEX*16
is a synonym forDOUBLE
COMPLEX
, except that it always has a size of 16 bytes, independent of any compiler options.
COMPLEX*32
(
Quad Complex)(SPARC only) The complex data type
COMPLEX*32
is a quadruple-precision complex. It is a pair ofREAL*16
elements, where each has a sign bit, a 15-bit exponent, and a 112-bit fraction. TheseREAL*16
elements in f77 conform to the IEEE standard.The size for
COMPLEX*32
is 32 bytes.
DOUBLE COMPLEX
The complex data type,
DOUBLE
COMPLEX
, which usually has the synonym,COMPLEX*16
, is a pair ofDOUBLE
PRECISION
(REAL*8
) values that represents a complex number. The first element represents the real part; the second represents the imaginary part.The default size for
DOUBLE
COMPLEX
with no size specified is 16.
DOUBLE PRECISION
A double-precision datum is an approximation of a real number. The double-precision data type,
DOUBLE
PRECISION
, which has the synonym,REAL*8
, holds one double-precision datum.The default size for
DOUBLE
PRECISION
with no size specified is 8 bytes.A
DOUBLE
PRECISION
element has a sign bit, an 11-bit exponent, and a 52-bit fraction. TheseDOUBLE
PRECISION
elements in f77 conform to the IEEE standard for double-precision floating-point data. The layout is shown in Data Representations.
INTEGER
The integer data type,
INTEGER
, holds a signed integer.The default size for
INTEGER
with no size specified is 4, and is aligned on 4-byte boundaries. However, these defaults can be changed by compiling with certain special options (see Size and Alignment of Data Types).
INTEGER*2
The short integer data type,
INTEGER*2
, holds a signed integer. An expression involving only objects of typeINTEGER*2
is of that type. Using this feature may have adverse performance implications, and is not recommended.Generic functions return short or long integers depending on the default integer type. If a procedure is compiled with the
-i2
flag, all integer constants that fit and all variables of typeINTEGER
(no explicit size) are of typeINTEGER*2
. If the precision of an integer-valued intrinsic function is not determined by the generic function rules, one is chosen that returns the prevailing length (INTEGER*2
) when the-i2
compilation option is in effect. With-i2
, the default length ofLOGICAL
quantities is 2 bytes.Ordinary integers follow the FORTRAN rules about occupying the same space as a
REAL
variable. They are assumed to be equivalent to the C typelong
int
, and 2-byte integers are of C typeshort
int
. These short integer and logical quantities do not obey the standard rules for storage association.An
INTEGER*2
occupies 2 bytes.
INTEGER*2
is aligned on 2-byte boundaries.
INTEGER*4
The integer data type,
INTEGER*4
, holds a signed integer.An
INTEGER*4
occupies 4 bytes.
INTEGER*4
is aligned on 4-byte boundaries.
INTEGER*8
The integer data type,
INTEGER*8
, holds a signed 64-bit integer.An
INTEGER*8
occupies 8 bytes.
INTEGER*8
is aligned on 8-byte boundaries.
LOGICAL
The logical data type,
LOGICAL
, holds a logical value.TRUE.
or.FALSE.
The value 0 represents.FALSE.
; any other value represents.TRUE.
The usual default size for an
LOGICAL
item with no size specified is 4, and is aligned on 4-byte boundaries. However, these defaults can be changed by compiling with certain special options.
LOGICAL*1
The one-byte logical data type,
LOGICAL*1
, which has the synonym,BYTE
, can hold any of the following:
- One character
- An integer between -128 and 127
- The logical values
.TRUE.
or.FALSE
.The value is as defined for
LOGICAL
, but it can hold a character or small integer. An example:
LOGICAL*1 Bit3 / 8 /, C1 / 'W' /,& Counter / 0 /, Switch / .FALSE. /A
LOGICAL*1
item occupies one byte of storage.
LOGICAL*1
is aligned on one-byte boundaries.
LOGICAL*2
The data type,
LOGICAL*2
, holds logical value.TRUE.
or.FALSE.
The value is defined as forLOGICAL
.
LOGICAL*2
is aligned on 2-byte boundaries.
LOGICAL*4
The logical data type,
LOGICAL*4
holds a logical value.TRUE.
or.FALSE.
The value is defined as forLOGICAL
.
LOGICAL*4
is aligned on 4-byte boundaries.
LOGICAL*8
The logical data type,
LOGICAL*8
, holds the logical value.TRUE.
or.FALSE.
The value is defined the same way as for theLOGICAL
data type.
LOGICAL*8
is aligned on 8-byte boundaries.
REAL
A real datum is an approximation of a real number. The real data type, REAL, which usually has the synonym, REAL*4, holds one real datum.
The usual default size for a REAL item with no size specified is 4 bytes, and is aligned on 4-byte boundaries. However, these defaults can be changed by compiling with certain special options.
A REAL element has a sign bit, an 8-bit exponent, and a 23-bit fraction. These REAL elements in f77 conform to the IEEE standard.
REAL*4
The REAL*4 data type is a synonym for REAL, except that it always has a size of 4 bytes, independent of any compiler options.
REAL*8
(Double-Precision Real)The REAL*8, data type is a synonym for DOUBLE PRECISION, except that it always has a size of 8 bytes, independent of any compiler options.
REAL*16
(Quad Real)(SPARC only) The
REAL*16
data type is a quadruple-precision real. The size for aREAL*16
item is 16 bytes. AREAL*16
element has a sign bit, a 15-bit exponent, and a 112-bit fraction. TheseREAL*16
elements in f77 conform to the IEEE standard for extended precision.Size and Alignment of Data Types
Storage and alignment are always given in bytes. Values that can fit into a single byte are byte-aligned.
The size and alignment of types depends on various compiler options and platforms, and how variables are declared. The maximum alignment in COMMON blocks is to 4-byte boundaries.
Default data alignment and storage allocation can be changed by compiling with special options, such as
-aligncommon
,-f
,-dalign
,-dbl_align_all
,-dbl
,-xmemalign
,-r8
,-i2
, and-xtypemap
. The default descriptions in this manual assume that these options are not in force.Refer to the Fortran User's Guide for details of specific compiler options.
The following table summarizes the default size and alignment, ignoring other aspects of types and options.
REAL*16
andCOMPLEX*32
are only available on SPARC only. In 64-bit environments (compiling with-xarch=v9
orv9a
) the default alignment is on 16-byte (rather than 8-byte) boundaries, as indicated by 8/16 in the table.- Arrays and structures align according to their elements or fields. An array aligns the same as the array element. A structure aligns the same as the field with the widest alignment.
Compiling with options
-i2
,-r8,
or-dbl
changes the defaults for certain data declarations that appear without an explicit size:
Do not combine
-i2
with-r8
as this can produce unexpected results.REAL*16
andCOMPLEX*32
are SPARC only.With
-dbl
or-r8
,INTEGER
andLOGICAL
are allocated the larger space indicated above. This is done to maintain the FORTRAN requirement that an integer item and a real item have the same amount of storage. However, with-r8
8 bytes are allocated but only 4-byte arithmetic is done. With-dbl
, 8 bytes are allocated and full 8-byte arithmetic is done. In all other ways,-dbl
and-r8
produce the same results. A disadvantage of using-r8
or-dbl
is that it also promotesDOUBLE PRECISION
data toQUAD PRECISION
, possibly degrading performance.Use of the more flexible
-xtypemap
option is preferred over the older-r8
and-dbl
options. Both-dbl
and-r8
have their-xtypemap
equivalents:
- On SPARC
:
-dbl
same as:-xtypemap=real:64,double:128,integer:64
same as:
-r8-xtypemap=real:64,double:128,integer:mixed
- On x86
:
-dbl
same as:-xtypemap=real:64,double:64,integer:64
same as:
-r8-xtypemap=real:64,double:64,integer:mixed
The mapping
integer:mixed
indicates 8 byte integers but only 4 byte arithmetic.There are two additional possibilities on SPARC:
-xtypemap=real:64,double:64,integer:mixed
-xtypemap=real:64,double:64,integer:64which map both default
REAL
andDOUBLE
to 8 bytes, and should be preferable over using-r8
or-dbl
.Note that
INTEGER
andLOGICAL
are treated the same, andCOMPLEX
is mapped as twoREAL
value
s. Also,DOUBLE
COMPLEX
will be treated the wayDOUBLE
is mapped.Options
-f
or-dalign
(SPARC only) force alignment of all 8, 16, or 32-byte data onto 8-byte boundaries. Option-dbl_align_all
causes all data to be aligned on 8-byte boundaries. Programs that depend on the use of these options may not be portable.See the Fortran User's Guide for details on these compiler options.
Constants
A literal constant is a datum whose value cannot change throughout the program unit. The form of the string representing a constant determines the value and data type of the constant. (For a named constant, defined by a
PARAMETER
statement, the name defines the data type.)There are three general kinds of constants:
- Arithmetic
- Logical
- Character
Blank characters within an arithmetic or logical constant do not affect the value of the constant. Within character constants, they do affect the value.
Here are the different kinds of arithmetic constants:
Complex Binary Double complex Octal Double precision Hexadecimal Integer Hollerith Real
A signed constant is an arithmetic constant with a leading plus or minus sign. An unsigned constant is an arithmetic constant without a leading sign.
For integer, real, and double-precision data, zero is neither positive nor negative. The value of a signed zero is the same as that of an unsigned zero.
Compiling with any of the options
-i2
,-dbl
,-r8
, or-xtypemap
alters the default size of integer, real, complex, and double precision constants. These options are described in Chapter 2, and in the Fortran User's Guide.Character Constants
A character-string constant is a string of characters enclosed in apostrophes or quotes. The apostrophes are standard; the quotes are not.
If you compile with the
-xl
option, then the quotes mean something else, and you must use apostrophes to enclose a string.To include an apostrophe in an apostrophe-delimited string, repeat it. To include a quote in a quote-delimited string, repeat it. Examples:
'abc' "abc"'ain''t' "in vi type ""h9Y"If a string begins with one kind of delimiter, the other kind can be embedded within it without using the repeated quote or backslash escapes. See TABLE 2-3.
Example: Character constants:
"abc" "abc""ain't" 'in vi type "h9Y'Null Characters
Each character string constant appearing outside a
DATA
statement is followed by a null character to ease communication with C routines. You can make character string constants consisting of no characters, but only as arguments being passed to a subprogram. Such zero length character string constants are not FORTRAN standard.Example: Null character string:
demo%cat NulChr.f
write(*,*) 'a', '', 'b'stopenddemo%f77 NulChr.f
NulChr.f:MAIN:demo% a.outabdemo%However, if you put such a null character constant into a character variable, the variable will contain a blank, and have a length of at least 1 byte.
Example: Length of null character string:
demo%cat NulVar.f
character*1 x / 'a' /, y / '' /, z / 'c' /write(*,*) x, y, zwrite(*,*) len( y )enddemo%f77 NulVar.f
NulVar.f:MAIN:demo%a.out
a c1demo%Escape Sequences
For compatibility with C usage, the following backslash escapes are recognized. If you include the escape sequence in a character string, then you get the indicated character.
If you compile with the
-xl
option, then the backslash character (\
) is treated as an ordinary character. That is, with the-xl
option, you cannot use these escape sequences to get special characters.Technically, the escape sequences are not nonstandard, but are implementation- defined.
Complex Constants
A complex constant is an ordered pair of real or integer constants (or
PARAMETER
constants). The constants are separated by a comma, and the pair is enclosed in parentheses. The first constant is the real part, and the second is the imaginary part. A complex constant,COMPLEX*8
, uses 8 bytes of storage.Example: Complex constants:
( 9.01, .603 )( +1.0, -2.0 )( +1.0, -2 )( 1, 2 )( 4.51, ) Invalid --need second part
COMPLEX*16
ConstantsA double-complex constant,
COMPLEX*16
, is an ordered pair of real or integer constants, where one of the constants isREAL*8
, and the other isINTEGER
,REAL*4
, orREAL*8
.The constants are separated by a comma, and the pair is enclosed in parentheses. The first constant is the real part, and the second is the imaginary part. A double-complex constant,
COMPLEX*16
, uses 16 bytes of storage.Example: Double-complex constants:
( 9.01D6, .603 )( +1.0, -2.0D0 )( 1D0, 2 )( 4.51D6, ) Invalid--need second part( +1.0, -2.0 )
Not DOUBLE COMPLEX--need a REAL*8
COMPLEX*32
(Quad Complex) Constants(SPARC only) A quad complex constant is an ordered pair of real or integer constants, where one of the constants is
REAL*16
, and the other isINTEGER
,REAL*4
,REAL*8
, orREAL*16
.The constants are separated by a comma, and the pair is enclosed in parentheses. The first constant is the real part, and the second is the imaginary part. A quad complex constant,
COMPLEX*32
, uses 32 bytes of storage.Example: Quad complex constants (SPARC only):
( 9.01Q6, .603 )( +1.0, -2.0Q0 )( 1Q0, 2 )( 3.3Q-4932, 9 )( 1, 1.1Q+4932 )( 4.51Q6, ) Invalid--need second part( +1.0, -2.0 ) Not quad complex --need a REAL*16Integer Constants
An integer constant consists of an optional plus or minus sign, followed by a string of decimal digits.
- No other characters are allowed except, of course, a space.
- If no sign is present, the constant is assumed to be nonnegative.
- The value must be in the
INTEGER*4
range (-2147483648, 2147483647), unless compiled with an option that promotes integers to 64 bits, in which case the range becomesINTEGER*8
(-9223372036854775808,9223372036854775807). See Size and Alignment of Data Types.Example: Integer constants:
Alternate Octal Notation
You can also specify integer constants with the following alternate octal notation. Precede an integer string with a double quote (") and compile with the
-xl
option. These are octal constants of typeINTEGER
.Example: The following two statements are equivalent:
JCOUNT = ICOUNT + "703JCOUNT = ICOUNT + 451You can also specify typeless constants as binary, octal, hexadecimal, or Hollerith. See Typeless Constants (Binary, Octal, Hexadecimal).
Long Integers
Compiling with an option that promotes the range from
INTEGER*4
(-21474836, 21474836) toINTEGER*8
(-9223372036854775808, 9223372036854775807). The integer constant is stored or passed as an 8-byte integer, data typeINTEGER*8
.Short Integers
If a constant argument is in the range (-32768, 32767), it is usually widened to a 4-byte integer, data type
INTEGER*4
; but compiling with the-i2
option will cause it to be stored or passed as a 2-byte integer, data typeINTEGER*2
.Logical Constants
A logical constant is either the logical value true or false. The only logical constants are
.TRUE.
and.FALSE.
; no others are possible. The period delimiters are necessary.A logical constant takes 4 bytes of storage. If it is an actual argument, it is passed as 4 bytes, unless compiled with the
-i2
option, in which case it is passed as 2.Real Constants
A real constant is an approximation of a real number. It can be positive, negative, or zero. It has a decimal point or an exponent. If no sign is present, the constant is assumed to be nonnegative.
Real constants,
REAL*4
, use 4 bytes of storage.Basic Real Constant
A basic real constant consists of an optional plus or minus sign, followed by an integer part, followed by a decimal point, followed by a fractional part.
The integer part and the fractional part are each strings of digits, and you can omit either of these parts, but not both.
Example: Basic real constants:
+82.-32.90.98.5Real Exponent
A real exponent consists of the letter
E
, followed by an optional plus or minus sign, followed by an integer.Example: Real exponents:
E+12E-3E6Real Constant
A real constant has one of these forms:
- Basic real constant
- Basic real constant followed by a real exponent
- Integer constant followed by a real exponent
A real exponent denotes a power of ten. The value of a real constant is the product of that power of ten and the constant that precedes the
E
.Example: Real constants:
- Other than the optional plus or minus sign, a decimal point, the digits 0 through 9, and the letter
E
, no other characters are allowed.- The magnitude of a normalized single-precision floating-point value must be in the approximate range (1.175494E-38, 3.402823E+38).
REAL*8
(Double-Precision Real) ConstantsA double-precision constant is an approximation of a real number. It can be positive, negative, or zero. If no sign is present, the constant is assumed to be nonnegative. A double-precision constant has a double-precision exponent and an optional decimal point. Double-precision constants,
REAL*8
, use 8 bytes of storage. TheREAL*8
notation is nonstandard.Double-Precision Exponent
A double-precision exponent consists of the letter
D
, followed by an optional plus or minus sign, followed by an integer.A double-precision exponent denotes a power of 10. The value of a double-precision constant is the product of that power of 10 and the constant that precedes the
D
. The form and interpretation are the same as for a real exponent, except that aD
is used instead of anE
.Examples of double-precision constants are:
- Other than the optional plus or minus sign, a decimal point, the digits 0 through 9, a blank, and the letter
D
. No other characters are allowed.- The magnitude of an IEEE normalized double-precision floating-point value must be in the approximate range (2.225074D-308, 1.797693D+308).
REAL*16
(Quad Real) Constants(SPARC only) A quadruple-precision constant is a basic real constant or an integer constant, such that it is followed by a quadruple-precision exponent. See Real Constants.
A quadruple-precision exponent consists of the letter
Q
, followed by an optional plus or minus sign, followed by an integer.A quadruple-precision constant can be positive, negative, or zero. If no sign is present, the constant is assumed to be nonnegative.
Example: Quadruple-precision constants:
The form and interpretation are the same as for a real constant, except that a
Q
is used instead of anE
.
- Other than the optional plus or minus sign, a decimal point, the digits 0 through 9, a blank, and the letter Q. No other characters are allowed.
- The magnitude of an IEEE normalized quadruple-precision floating-point value must be in the approximate range (3.362Q-4932, 1.20Q+4932).
- It occupies 16 bytes of storage.
- Each such datum is aligned on 8-byte boundaries.
Typeless Constants (Binary, Octal, Hexadecimal)
Typeless numeric constants are so named because their expressions assume data types based on how they are used.
These constants are not converted before use. However, in f77, they must be distinguished from character strings.
The general form is to enclose a string of appropriate digits in apostrophes and prefix it with the letter B, O, X, or Z. The B is for binary, the O is for octal, and the X or Z are for hexadecimal.
Example: Binary, octal, and hexadecimal constants,
DATA
andPARAMETER
:
PARAMETER ( P1 = Z'1F' )INTEGER*2 N1, N2, N3, N4DATA N1 /B'0011111'/, N2/O'37'/, N3/X'1f'/, N4/Z'1f'/WRITE ( *, 1 ) N1, N2, N3, N4, P11 FORMAT ( 1X, O4, O4, Z4, Z4, Z4 )ENDNote the edit descriptors in
FORMAT
statements:O
for octal, andZ
for hexadecimal. Each of the above integer constants has the value 31 decimal.Example: Binary, octal, and hexadecimal, other than in
DATA
andPARAMETER
:
INTEGER*4 M, ICOUNT/1/, JCOUNTREAL*4 TEMPM = ICOUNT + B'0001000'JCOUNT = ICOUNT + O'777'TEMP = X'FFF99A'WRITE(*,*) M, JCOUNT, TEMPENDIn the above example, the context defines
B'0001000'
andO'777'
asINTEGER*4
andX'FFF99A'
asREAL*4
. For a real number, using IEEE floating-point, a given bit pattern yields the same value on different architectures.The above statements are treated as the following:
M = ICOUNT + 8JCOUNT = ICOUNT + 511TEMP = 2.35076E-38Control Characters
You can enter control characters with typeless constants, although the
CHAR
function is standard, and this way is not.Example: Control characters with typeless constants:
CHARACTER BELL, ETX / X'03' /PARAMETER ( BELL = X'07' )Alternate Notation for Typeless Constants
For compatibility with other versions of FORTRAN, the following alternate notation is allowed for octal and hexadecimal notation. This alternate does not work for binary, nor does it work in
DATA
orPARAMETER
statements.For an octal notation, enclose a string of octal digits in apostrophes and append the letter O.
Example: Octal alternate notation for typeless constants:
'37'O37'O Invalid -- missing initial apostrophe'37' Not numeric -- missing letter O'397'O Invalid -- invalid digitFor hexadecimals, enclose a string of hex digits in apostrophes and append the letter
X
.Example: Hex alternate notation for typeless constants:
'ab'X3fff'X'1f'X'1fX Invalid--missing trailing apostrophe'3f' Not numeric-- missing X'3g7'X Invalid--invalid digit gHere are the rules and restrictions for binary, octal, and hexadecimal constants:
- These constants are for use anywhere numeric constants are allowed.
- These constants are typeless. They are stored in the variables without any conversion to match the type of the variable, but they are stored in the appropriate part of the receiving field--low end, high end.
- If the receiving data type has more digits than are specified in the constant, zeros are filled on the left.
- If the receiving data type has fewer digits than are specified in the constant, digits are truncated on the left. If nonzero digits are lost, an error message is displayed.
- Specified leading zeros are ignored.
- You can specify up to 8 bytes of data for any one constant--at least that's all that are used.
- If a typeless constant is an actual argument, it has no data type, but it is always 4 bytes that are passed.
- For binary constants, each digit must be 0 or 1.
- For octal constants, each digit must be in the range 0 to 7.
- For hexadecimal constants, each digit must be in the range 0 to 9 or in the range A to F, or a to f.
- Outside of
DATA
statements, such constants are treated as the type required by the context. If a typeless constant is used with a binary operator, it gets the data type of the other operand (8.0 + '37'O).- In
DATA
statements, such constants are treated as typeless binary, hexadecimal, or octal constants.Hollerith Constants
A Hollerith constant consists of an unsigned, nonzero, integer constant, followed by the letter
H
, followed by a string of printable characters where the integer constant designates the number of characters in the string, including any spaces and tabs.A Hollerith constant occupies 1 byte of storage for each character.
A Hollerith constant is aligned on 2-byte boundaries.
The FORTRAN standard does not have this old Hollerith notation, although the standard recommends implementing the Hollerith feature to improve compatibility with old programs.
Hollerith data can be used in place of character-string constants. They can also be used in
IF
tests, and to initialize noncharacter variables inDATA
statements and assignment statements, though none of these are recommended, and none are standard. These are typeless constants.Example: Typeless constants:
CHARACTER C*1, CODE*2INTEGER TAG*2DATA TAG / 2Hok /CODE = 2HnoIF ( C .EQ. 1HZ ) CALL PUNTThe rules and restrictions on Hollerith constants are:
- The number of characters has no practical limit.
- The characters can continue over to a continuation line, but that gets tricky. Short standard fixed format lines are padded on the right with blanks up to 72 columns, but short tab-format lines stop at the newline.
- If a Hollerith constant is used with a binary operator, it gets the data type of the other operand.
- If you assign a Hollerith constant to a variable, and the length of the constant is less than the length of the data type of the variable, then spaces (ASCII 32) are appended on the right.
- If the length of a Hollerith constant or variable is greater than the length of the data type of the variable, then characters are truncated on the right.
- If a Hollerith constant is used as an actual argument, it is passed as a 4-byte item.
- If a Hollerith constant is used, and the context does not determine the data type, then
INTEGER*4
is used.Fortran 95-Style Constants
The Sun WorkShop Fortran 77 compiler recognizes the Fortran 95-style syntax for integer and real constants that allows literal specification of the size of the data item. In Fortran 95 terminology, a constant literal may include an optional trailing underscore followed by a "kind type parameter".
In the Sun Fortran 77 implementation, the "kind type parameter" is limited to the digits 1, 2, 4, 8, or 16, and its use specifies the data size, in bytes, of the literal constant. For example:
With complex constants, the real and imaginary parts may be specified with different kind type parameters,
(1.0_8,2.0_4)
, but the resulting data item will have the real and imaginary parts with the same size, taking the larger one specified.This construction is valuable when calling subprograms with constant arguments when a specific data type is required, as in the following example:
call suby(A,1.5_8,0_8,Y)...subroutine suby(H0, M, N, W)INTEGER *8 M, N,...Variables
A variable is a symbolic name paired with a storage location. A variable has a name, a value, and a type. Whatever datum is stored in the location is the value of the variable. This does not include arrays, array elements, records, or record fields, so this definition is more restrictive than the usual usage of the word "variable."
You can specify the type of a variable in a type statement. If the type is not explicitly specified in a type statement, it is implied by the first letter of the variable name: either by the usual default implied typing, or by any implied typing of
IMPLICIT
statements. See Types for more details on the rules for data typing.At any given time during the execution of a program, a variable is either defined or undefined. If a variable has a predictable value, it is defined; otherwise, it is undefined. A previously defined variable may become undefined, as when a subprogram is exited.
You can define a variable with an assignment statement, an input statement, or a
DATA
statement. If a variable is assigned a value in aDATA
statement, then it is initially defined.Two variables are associated if each is associated with the same storage location. You can associate variables by use of
EQUIVALENCE
,COMMON
, orMAP
statements. Actual and dummy arguments can also associate variables.Arrays
An
array is a named collection of elements of the same type. It is a nonempty sequence of data and occupies a group of contiguous storage locations. An array has a name, a set of elements, and a type.
An array name is a symbolic name for the whole sequence of data.
An array element is one member of the sequence of data. Each storage location holds one element of the array.
An array element name is an array name qualified by a subscript. See Array Subscripts for details.
You can declare an array in any of the following statements:
DIMENSION
statementCOMMON
statement- Type statements:
BYTE
,CHARACTER
,INTEGER
,REAL
, and so forthArray Declarators
An array declarator specifies the name and properties of an array.
The syntax of an array declarator is:
a ( d [, d ] ... )
- a is the name of the array
- d is a dimension declarator
A dimension declarator has the form:
- dl is the lower dimension bound
- du is the upper dimension bound
An array must appear only once in an array declarator within a program unit (main program, subroutine, function, or block common). The compiler flags multiple or duplicate array declarations within the same unit as errors.
The number of dimensions in an array is the number of dimension declarators. The minimum number of dimensions is one; the maximum is seven. For an assumed-size array, the last dimension can be an asterisk.
The lower bound indicates the first element of the dimension, and the upper bound indicates the last element of the dimension. In a one-dimensional array, these are the first and last elements of the array.
Example: Array declarator, lower and upper bounds:
REAL V(-5:5)In the above example,
V
is an array of real numbers, with 1 dimension and 11 elements. The first element isV(-5)
; the last element isV(5)
.Example: Default lower bound of 1:
REAL V(1000)In the above example,
V
is an array of real numbers, with 1 dimension and 1000 elements. The first element isV(1)
; the last element isV(1000)
.Example: Arrays can have as many as 7 dimensions:
REAL TAO(2,2,3,4,5,6,10)Example: Lower bounds other than one:
REAL A(3:5, 7, 3:5), B(0:2)Example: Character arrays:
CHARACTER M(3,4)*7, V(9)*4The array
M
has 12 elements, each of which consists of 7 characters.The array
V
has 9 elements, each of which consists of 4 characters.The following restrictions on bounds apply:
- Both the upper and the lower bounds can be negative, zero, or positive.
- The upper bound must be greater than or equal to the lower bound.
- If only one bound is specified, it is the upper, and the lower is one.
- In assumed-size arrays, the upper bound of the last dimension is an asterisk.
- Each bound is an integer expression, and each operand of the expression is a constant, a dummy argument, or a variable in a common block. No array references or user-defined functions are allowed.
Adjustable Arrays
An adjustable array is an array that is a dummy argument or local array with one or more of its dimensions or bounds as an expression of integer variables that are either themselves dummy arguments, or are in a common block.
You can declare adjustable arrays in the usual
DIMENSION
or type statements. In f77, you can also declare adjustable arrays in aRECORD
statement, if thatRECORD
statement is not inside a structure declaration block.Example: Adjustable arrays;
SUBROUTINE POPUP ( A, B, N )COMMON / DEFS / M, LREAL A(3:5, L, M:N), B(N+1:2*N) ! These arrays are dummy argsREAL C(N+1,2*N) ! This array is local
- The size of an adjustable array cannot exceed the size of the corresponding actual argument.
- In the first caller of the call sequence, the corresponding array must be dimensioned with constants.
- You cannot declare an adjustable array in
COMMON
.If the array is local to the routine, memory is allocated on entry to the routine and deallocated on return to the caller.
Assumed-Size Arrays
An assumed-size array is an array that is a dummy argument, and which has an asterisk as the upper bound of the last dimension.
You can declare assumed-size arrays in the usual
DIMENSION
,COMMON
, or type statements.The following
f77
extensions allow you to:
- declare assumed-size arrays in a
RECORD
statement, if thatRECORD
statement is not inside a structure declaration block.- use an assumed-size array as a unit identifier for an internal file in an I/O statement.
- use an assumed-size array as a runtime format specifier in an I/O statement.
Example: Assumed-size with the upper bound of the last dimension an asterisk:
SUBROUTINE PULLDOWN ( A, B, C )INTEGER A(5, *), B(*), C(0:1, 2:*)An assumed-size array cannot be used in an I/O list.
Array Names with No Subscripts
An array name with no subscripts indicates the entire array. It can appear in any of the following statements:
COMMON
DATA
- I/O statements
NAMELIST
RECORD
statementsSAVE
- Type statements
In an
EQUIVALENCE
statement, the array name without subscripts indicates the first element of the array.Array Subscripts
An array element name is an array name qualified by a subscript.
Form of a Subscript
A subscript is a parenthesized list of subscript expressions. There must be one subscript expression for each dimension of the array.
where s is a subscript expression. The parentheses are part of the subscript.
Example: Declare a two-by-three array with the declarator:
REAL M(2,3)With the above declaration, you can assign a value to a particular element, as follows:
M(1,2) = 0.0The above code assigns
0.0
to the element in row 1, column 2, of arrayM
.Subscript Expressions
Subscript expressions have the following properties and restrictions:
- A subscript expression is an integer, real, complex, logical, or byte expression. According to the FORTRAN Standard, it must be an integer expression.
- A subscript expression can contain array element references and function references.
- Evaluation of a function reference must not alter the value of any other subscript expression within the same subscript.
- Each subscript expression is an index into the appropriate dimension of the array.
- Each subscript expression must be within the bounds for the appropriate dimension of the array.
- A subscript of the form ( L1, ..., Ln ), where each Li is the lower bound of the respective dimension, references the first element of the array.
- A subscript of the form (U1, ..., Un), where each Ui is the upper bound of the respective dimension, references the last element of the array.
- Array element
A(n)
is not necessarily the nth element of arrayA
:
REAL V(-1:8)V(2) = 0.0In the above example, the fourth element of
V
is set to zero.Subscript expressions cannot exceed the range of
INTEGER*4
in 32-bit environments. It is not controlled, but if the subscript expression is not in the range
(-2147483648, 2147483647), then the results are unpredictable. When compiled for 64-bit environments,INTEGER*8
subscript expressions are allowed.Array Ordering
Array elements are usually considered as being arranged with the first subscript as the row number and the second subscript as the column number. This corresponds to traditional mathematical nxm matrix notation:
a1,1 a1,2 a1,3 ... a1,m a2,1 a2,2 ... a2,m ... ... ai,j ... ai,m an,1 an,2 ... an,m
Element ai,j is located in row i, column j.
The elements of
A
are conceptually arranged in 3 rows and 2 columns:
A(1,1)
A(1,2)
A(2,1)
A(2,2)
A(3,1)
A(3,2)
Array elements are stored in column-major order.
Example: For the array
A
, they are located in memory as follows:
A(1,1)
A(2,1)
A(3,1)
A(1,2)
A(2,2)
A(3,2)
The inner (leftmost) subscript changes more rapidly.
Substrings
A character datum is a sequence of one or more characters. A character substring is a contiguous portion of a character variable or of a character array element or of a character field of a structured record.
A substring name can be in either of the following two forms:
a
(
s[,
s] ... ) ( [
e1] : [
e2] )
where
v Character variable name a (
s[,
s] ... )
Character array element name e1 Leftmost character position of the substring e2 Rightmost character position of the substring
:Both e1 and e2 are integer expressions. They cannot exceed the range of
INTEGER*4
on 32-bit environments. If the expression is not in the range (-2147483648, 2147483647), then the results are unpredictable. When compiled for 64-bit environments, the substring character position expressions can be in the range ofINTEGER*8
.Example: The string with initial character from the Ith character of S and with the last character from the Lth character of S:
S(I:L)
In the above example, there are L-I+1 characters in the substring.
The following string has an initial character from the Mth character of the array element A(J,K), with the last character from the Nth character of that element.
A(J,K)(M:N)
In the above example, there are N-M+1 characters in the substring.
Here are the rules and restrictions for substrings:
- Character positions within a substring are numbered from left to right.
- The first character position is numbered 1, not 0.
- The initial and last character positions must be integer expressions.
- If the first expression is omitted, it is 1.
- If the second expression is omitted, it is the declared length.
- The result is undefined unless 0 < L the declared length, where I is the initial position, and L is the last position.
- Substrings can be used on the left and right sides of assignments and as procedure actual arguments.
- Substrings must not be overlapping.
ASTR(2:4) = ASTR(3:5)
is illegal.Examples: Substrings--the value of the element in column 2, row 3 is e23:
Structures
A structure is a generalization of an array.
Just as an array is a collection of elements of the same type, a structure is a collection of elements that are not necessarily of the same type.
As elements of arrays are referenced by using numeric subscripts, so elements of structures are referenced by using element (or field) names.
The structure declaration defines the form of a record by specifying the name, type, size, and order of the fields that constitute the record. Once a structure is defined and named, it can be used in
RECORD
statements, as explained in the following subsections.Syntax
The structure declaration has the following syntax:
field-list List of fields of the specified structure field-declaration Defines a field of the record. field-declaration is defined in the next section.
Field Declaration
Each field declaration can be one of the following:
- A substructure--either another structure declaration, or a record that has been previously defined
- A union declaration, which is described later
- A FORTRAN type declaration
Example: A
STRUCTURE
declaration:
STRUCTURE /PRODUCT/INTEGER*4 IDCHARACTER*16 NAMECHARACTER*8 MODELREAL*4 COSTREAL*4 PRICEEND STRUCTUREIn the above example, a structure named
PRODUCT
is defined to consist of the five fieldsID
,NAME
,MODEL
,COST
, andPRICE
. For an example with a field-list, see Structure Within a Structure.Rules and Restrictions for Structures
- The name is enclosed in slashes, and is optional only in nested structures.
- If slashes are present, a name must be present.
- You can specify the field-list within nested structures only.
- There must be at least one field-declaration.
- Each structure-name must be unique among structures, although you can use structure names for fields in other structures or as variable names.
- The only statements allowed between the
STRUCTURE
statement and theEND
STRUCTURE
statement are field-declaration statements andPARAMETER
statements. APARAMETER
statement inside a structure declaration block is equivalent to one outside.Rules and Restrictions for Fields
Fields that are type declarations use the identical syntax of normal
FORTRAN
type statements. Allf77
types are allowed, subject to the following rules and restrictions:
- Any dimensioning needed must be in the type statement. The
DIMENSION
statement has no effect on field names.- You can specify the pseudo-name
%FILL
for a field name.%FILL
is provided for compatibility with other versions ofFORTRAN
. It is not needed inf77
because the alignment problems are taken care of for you. It may be a useful feature if you want to make one or more fields that you cannot reference in some particular subroutine. The only thing that%FILL
does is provide a field of the specified size and type, and preclude referencing it.- You must explicitly type all field names. The
IMPLICIT
statement does not apply to statements in aSTRUCTURE
declaration, nor do the implicitI
,J
,K
,L
,M
,N
rules apply.- You cannot use arrays with adjustable or assumed size in field declarations, nor can you include passed-length
CHARACTER
declarations.In a structure declaration, the offset of field n is the offset of the preceding field, plus the length of the preceding field, possibly corrected for any adjustments made to maintain alignment. See Data Representations for a summary of storage allocation.
Record Declaration
The
RECORD
statement declares variables to be records with a specified structure, or declares arrays to be arrays of such records.The syntax of a
RECORD
statement is:
record-list List of variables, arrays, or arrays with dimensioning and index ranges, separated by commas.
Example: A
RECORD
that uses the previousSTRUCTURE
example:
RECORD /PRODUCT/ CURRENT, PRIOR, NEXT, LINE(10)Each of the three variables,
CURRENT
,PRIOR
, andNEXT
, is a record which has thePRODUCT
structure;LINE
is an array of 10 such records.Note the following rules and restrictions for records:
- Each record is allocated separately in memory.
- Initially, records have undefined values, unless explicitly initialized.
- Records, record fields, record arrays, and record-array elements are allowed as arguments and dummy arguments. When you pass records as arguments, their fields must match in type, order, and dimension. The record declarations in the calling and called procedures must match. Within a union declaration, the order of the map fields is not relevant. See Unions and Maps.
- Record fields are not allowed in
COMMON
statements.- Records and record fields are not allowed in
DATA
,EQUIVALENCE
, orNAMELIST
statements. Record fields are not allowed inSAVE
statements.Record and Field Reference
You can refer to a whole record, or to an individual field in a record, and since structures can be nested, a field can itself be a structure, so you can refer to fields within fields, within fields, and so forth.
The syntax of record and field reference is:
field-name Name of a field in the record immediately to the left.
Example: References that are based on structure and records of the above two examples:
...RECORD /PRODUCT/ CURRENT, PRIOR, NEXT, LINE(10)...CURRENT = NEXTLINE(1) = CURRENTWRITE ( 9 ) CURRENTNEXT.ID = 82
- The first assignment statement copies one whole record (all five fields) to another record.
- The second assignment statement copies a whole record into the first element of an array of records.
- The WRITE statement writes a whole record.
- The last statement sets the
ID
of one record to 82.Example: Structure and record declarations, record and field assignments:
Substructure Declaration
A structure can have a field that is also a structure. Such a field is called a substructure. You can declare a substructure in one of two ways:
- A
RECORD
declaration within a structure declaration- A structure declaration within a structure declaration (nesting)
Record Within a Structure
A nested structure declaration is one that is contained within either a structure declaration or a union declaration. You can use a previously defined record within a structure declaration.
Example: Define structure SALE using previously defined record PRODUCT:
STRUCTURE /SALE/CHARACTER*32 BUYERINTEGER*2 QUANTITYRECORD /PRODUCT/ ITEMEND STRUCTUREIn the above example, the structure
SALE
contains three fields,BUYER
,QUANTITY
, andITEM
, whereITEM
is a record with the structure,/PRODUCT/
.Structure Within a Structure
You can nest a declaration within a declaration.
Example: If
/PRODUCT/
is not declared previously, then you can declare it within the declaration ofSALE
:
STRUCTURE /SALE/CHARACTER*32 BUYERINTEGER*2 QUANTITYSTRUCTURE /PRODUCT/ ITEMINTEGER*4 IDCHARACTER*16 NAMECHARACTER*8 MODELREAL*4 COSTREAL*4 PRICEEND STRUCTUREEND STRUCTUREHere, the structure
SALE
still contains the same three fields as in the prior example:BUYER
,QUANTITY
, andITEM
. The fieldITEM
is an example of a field-list (in this case, a single-element list), as defined under "Structure Declaration."The size and complexity of the various structures determine which style of substructure declaration is best to use in a given situation.
Field Reference in Substructures
You can refer to fields within substructures.
Example: Refer to fields of substructures (
PRODUCT
andSALE
, from the previous examples, are defined in the current program unit):
...RECORD /SALE/ JAPAN...N = JAPAN.QUANTITYI = JAPAN.ITEM.ID...Rules and Restrictions for Substructures
- You must define at least one field name for any substructure.
- No two fields at the same nesting level can have the same name. Fields at different levels of a structure can have the same name; however, doing so might be questionable programming practice.
- You can use the pseudo-name,
%FILL
, to align fields in a record, and create an unnamed empty field.- You must not include a structure as a substructure of itself, at any level of nesting.
Unions and Maps
A union declaration defines groups of fields that share memory at runtime.
Syntaxes
The syntax of a union declaration is:
UNIONmap-declarationmap-declaration[
map-declaration]
...[
map-declaration]
END UNIONThe syntax of a map declaration is as follows.
MAPfield-declaration[field-declaration]...[field-declaration]END MAPFields in a Map
Each field-declaration in a map declaration can be one of the following:
- Structure declaration
- Record
- Union declaration
- Declaration of a typed data field
A map declaration defines alternate groups of fields in a union. During execution, one map at a time is associated with a shared storage location. When you reference a field in a map, the fields in any previous map become undefined and are succeeded by the fields in the map of the newly referenced field. The amount of memory used by a union is that of its biggest map.
Example: Declare the structure
/STUDENT/
to contain eitherNAME
,CLASS
, andMAJOR
--orNAME
,CLASS
,CREDITS
, andGRAD_DATE
:
STRUCTURE /STUDENT/CHARACTER*32 NAMEINTEGER*2 CLASSUNIONMAPCHARACTER*16 MAJOREND MAPMAPINTEGER*2 CREDITSCHARACTER*8 GRAD_DATEEND MAPEND UNIONEND STRUCTUREIf you define the variable
PERSON
to have the structure/STUDENT/
from the above example, thenPERSON.MAJOR
references a field from the first map, andPERSON.CREDITS
references a field from the second map. If the variables of the second map field are initialized, and then the program references the variablePERSON.MAJOR
, the first map becomes active, and the variables of the second map become undefined.Pointers
The
POINTER
statement establishes pairs of variables and pointers. Each pointer contains the address of its paired variable.Syntax Rules
The POINTER statement has the following syntax:
POINTER ( p1, v1 ) [, ( p2, v2 ) ... ]
- v1, v2 are pointer-based variables, also called pointees.
- p1, p2 are the corresponding pointers.
A pointer-based variable is a variable paired with a pointer in a
POINTER
statement. A pointer-based variable is usually just called a based variable, or a pointee. The pointer is the integer variable that contains the address. (Variable names appearing on aPOINTER
statement are consideredVOLATILE
by the compiler.)Example: A simple
POINTER
statement:
POINTER ( P, V )Here, V is a pointee, and P is its associated pointer.
See POINTER, for more examples.
Usage of Pointers
Normal use of pointer-based variables involves the following steps. The first two steps can be in either order.
1. Define the pairing of the pointer-based variable and the pointer in aPOINTER
statement.2. Define the type of the pointer-based variable.
- The pointer itself is integer type and should not appear in a type declaration.
3. Set the pointer to the address of an area of memory that has the appropriate size and type.
- You do not normally do anything else explicitly with the pointer.
4. Reference the pointer-based variable.
- Just use the pointer-based variable in normal FORTRAN statements--the address of that variable is always from its associated pointer.
Address and Memory
No storage for the variable is allocated when a pointer-based variable is defined, so you must provide an address of a variable of the appropriate type and size, and assign the address to a pointer, usually with the normal assignment statement or data statement.
The
loc(), malloc(),
andfree()
routines associate and deassociate memory addresses with pointers. (These routines are described in Chapter 6.)When compiled for 64-bit environments, pointers declared by the
POINTER
statement areINTEGER*8
values.Address by
LOC()
FunctionYou can obtain the address from the intrinsic function
LOC()
.Example: Use the
LOC()
function to get an address:
* ptr1.f: Assign an address via LOC()POINTER ( P, V )CHARACTER A*12, V*12DATA A / 'ABCDEFGHIJKL' /P = LOC( A )PRINT *, V(5:5)ENDIn the above example, the
CHARACTER
statement allocates 12 bytes of storage forA
, but no storage forV
. It merely specifies the type ofV
becauseV
is a pointer-based variable, then assign the address ofA
toP
, so now any use ofV
will refer toA
by the pointerP
. The program prints anE
.When compiled for 64-bit environments,
LOC()
returns anINTEGER*8
value. The receiving variable must be either a pointer or anINTEGER*8
variable to avoid possible address truncation.Memory and Address by
MALLOC()
FunctionThe function
MALLOC()
allocates an area of memory and returns the address of the start of that area. The argument to the function is an integer specifying the amount of memory to be allocated, in bytes. If successful, it returns a pointer to the first item of the region; otherwise, it returns an integer 0. The region of memory is not initialized in any way.Example: Memory allocation for pointers, by MALLOC
:
COMPLEX ZREAL X, YPOINTER ( P1, X ), ( P2, Y ), ( P3, Z )...P1 = MALLOC ( 10000 )...In the above example,
MALLOC()
allocates 10,000 bytes of memory and associates the address of that block of memory with the pointer P1.Deallocation of Memory by
FREE()
SubroutineThe subroutine
FREE()
deallocates a region of memory previously allocated byMALLOC()
. The argument given toFREE()
must be a pointer previously returned byMALLOC()
, but not already given toFREE()
. The memory is returned to the memory manager, making it unavailable to the programmer.Example: Deallocate via
FREE
:
POINTER ( P1, X ), ( P2, Y ), ( P3, Z )...P1 = MALLOC ( 10000 )...CALL FREE ( P1 )...In the above example,
MALLOC()
allocates 10,000 bytes of memory, which are associated with pointerP1
.FREE()
later returns those same 10,000 bytes to the memory manager.Special Considerations
Here are some special considerations when working with pointers and memory allocation with
malloc(),
loc(),
andfree()
:
- The pointers are of type integer, and are automatically typed that way by the compiler. You must not type them yourself.
- A pointer-based variable cannot itself be a pointer.
- The pointer-based variables can be of any type, including structures.
- No storage is allocated when such a pointer-based variable is declared, even if there is a size specification in the type statement.
- You cannot use a pointer-based variable as a dummy argument or in
COMMON
,EQUIVALENCE
,DATA
, orNAMELIST
statements.- The dimension expressions for pointer-based variables must be constant expressions in main programs. In subroutines and functions, the same rules apply for pointer-based array variables as for dummy arguments--the expression can contain dummy arguments and variables in common. Any variables in the expressions must be defined with an integer value at the time the subroutine or function is called.
- Address expressions cannot exceed the range of
INTEGER*4
on 32-bit environments. If the expression is not in the range (-2147483648, 2147483647), then the results are unpredictable.- When compiling for 64-bit environments, use
malloc64()
to access the 64-bit address space. Routinemalloc64()
takes anINTEGER*8
argument and returns a 64-bit pointer value. In 64-bit programs, pointers defined by thePOINTER
statement are 64-bitINTEGER*8
values. See the Fortran Library Reference Manual and the malloc(3F) man pages.Optimization and Pointers
Pointers have the annoying side effect of reducing the assumptions that the global optimizer can make. For one thing, compare the following:
- Without pointers, if you call a subroutine or function, the optimizer knows that the call will change only variables in common or those passed as arguments to that call.
- With pointers, this is no longer valid, since a routine can take the address of an argument and save it in a pointer in common for use in a subsequent call to itself or to another routine.
Therefore, the optimizer must assume that a variable passed as an argument in a subroutine or function call can be changed by any other call. Such an unrestricted use of pointers would degrade optimization for the vast majority of programs that do not use pointers.
General Guidelines
There are two alternatives for optimization with pointers.
- Do not use pointers with optimization level
-O4
.- Use a pointer only to identify the location of the data for calculations and pass the pointer to a subprogram. Almost anything else you do to the pointer can yield incorrect results.
The second choice also has a suboption: localize pointers to one routine and do not optimize it, but do optimize the routines that do the calculations. If you put the calling the routines on different files, you can optimize one and not optimize the other.
Example: A relatively "safe" kind of coding with
-O3
or-O4
:
If you want to optimize only
CALC
at level-O4
, then avoid using pointers inCALC
.Some Problematic Code Practices
Any of the following coding practices, and many others, could cause problems with an optimization level of
-O3
or-O4
:
- A program unit does arithmetic with the pointer.
- A subprogram saves the address of any of its arguments between calls.
- A function returns the address of any of its arguments, although it can return the value of a pointer argument.
- A variable is referenced through a pointer, but the address of the variable is not explicitly taken with the
LOC()
orMALLOC()
functions.Example: Code that could cause trouble with
-O3
or-O4
:
COMMON A, B, CPOINTER ( P, V )P = LOC(A) + 4 Possible problems here if optimizedThe compiler assumes that a reference through
P
may changeA
, but notB
; this assumption could produce incorrect code.
Sun Microsystems, Inc. Copyright information. All rights reserved. Feedback |
Library | Contents | Previous | Next | Index |