Data Types and Data Items
2
Data Types and Data Items |
2 |
|
This chapter describes the data types and data structures in Sun FORTRAN 77:
Types, Constants, Variables, Arrays, Substrings, Structures, and Pointers.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.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;
An array element has the same type as the array name.
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
Chapter 6, "Intrinsic Functions."An external function can have its type specified in any of the following ways:
Example: Explicitly by putting its name in a type statement:
FUNCTION F ( X ) INTEGER F, X F = X + 1 RETURN END |
Example: Explicitly in its FUNCTION statement:
INTEGER FUNCTION F ( X ) INTEGER X F = X + 1 RETURN END |
Example: Implicitly by its name, as with variables:
FUNCTION NXT ( X ) INTEGER X NXT = X + 1 RETURN END |
This section describes the data types, what each is for, the way storage is allocated for each of them, and the alignment of the different types. Storage and alignment are always given in bytes. Values that can fit into a single byte are byte-aligned.
Default data alignment and sizes may be changed by compiling with special options, such as-f, -dalign, -dbl_align_all,
-dbl, -r8, -i2, and -xtypemap. The descriptions in this manual in general assume that these
options are not in force.
Default data declarations, those that do not explicitly declare a
data size, such as REAL A, INTEGER B, COMPLEX C, LOGICAL D, DOUBLEPRECISION E,
have their meanings changed by these options, along with data not explicitly declared.
Data alignment is also platform dependent.
Refer to the Fortran User's Guide for details.
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:If it is interpreted as a logical value, a value of 0 represents .FALSE., and any other value is interpreted as .TRUE.
f77 allows the BYTE type as an array index, just as it allows the REAL type, but it does not allow BYTE as a DO loop index (where it allows only INTEGER, REAL, and DOUBLE PRECISION). Wherever FORTRAN makes an explicit check for INTEGER, it does not allow BYTE. Examples:BYTE Bit3 / 8 /, C1 / 'W' /, & Counter / 0 /, Switch / .FALSE. / |
A BYTE item occupies 1 byte of storage, and is aligned on 1-byte boundaries.
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.
A CHARACTER item occupies 1 byte (8 bits) of storage.
A CHARACTER item is aligned on 1-byte boundaries.
The 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. A CHARACTER*n variable 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.A complex datum is an approximation of a complex number. The complex data type, COMPLEX, which defaults to a synonym for COMPLEX*8, is a pair of REAL*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. The default alignment is on 4-byte boundaries. However, these defaults can be changed by compiling with certain special options. The complex data type COMPLEX*8 is a synonym for COMPLEX, except that it always has a size of 8 bytes, independent of any compiler options.
The complex data type COMPLEX*16 is a synonym for DOUBLE COMPLEX, except that it always has a size of 16 bytes, independent of any compiler options.
(SPARC, PowerPC only) The complex data type COMPLEX*32 is a quadruple-precision complex. It is a pair of REAL*16 elements, where each has a sign bit, a 15-bit exponent, and a 112-bit fraction. These REAL*16 elements in f77 conform to the IEEE standard.
The size for COMPLEX*32 is 32 bytes. COMPLEX*32 is aligned on 4-byte boundaries, except if compiled on a Sun-4 or SPARC computer with the -f option, in which case it is aligned on 8-byte boundaries. The complex data type, DOUBLE COMPLEX, which usually has the synonym, COMPLEX*16, is a pair of DOUBLE 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. COMPLEX*16 is aligned on 4-byte boundaries. However, these defaults can be changed by compiling with certain special options.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. DOUBLE PRECISION is aligned on 4-byte boundaries. However, these defaults can be changed by compiling with certain special options. A DOUBLE PRECISION element has a sign bit, an 11-bit exponent, and a 52-bit fraction. These DOUBLE PRECISION elements in f77 conform to the IEEE standard for double-precision floating-point data. The layout is shown in Appendix C, "Data Representations."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. The short integer data type, INTEGER*2, holds a signed integer. An expression involving only objects of type INTEGER*2 is of that type. Using this feature may have adverse performance implications, and we do not recommend it.
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 type INTEGER (no explicit size) are of type INTEGER*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 of LOGICAL 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 type long int, and 1-byte integers are of C type short 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. The integer data type, INTEGER*4, holds a signed integer.
An INTEGER*4 occupies 4 bytes. INTEGER*4 is aligned on 4-byte boundaries. 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.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. The one-byte logical data type, LOGICAL*1, which has the synonym, BYTE, can hold any of the following:
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.
The data type, LOGICAL*2, holds logical value .TRUE. or .FALSE. The value is defined as for LOGICAL.
A LOGICAL*2 occupies 2 bytes. LOGICAL*2 is aligned on 2-byte boundaries. The logical data type, LOGICAL*4 holds a logical value .TRUE. or .FALSE. The value is defined as for LOGICAL.
A LOGICAL*4 occupies 4 bytes. LOGICAL*4 is aligned on 4-byte boundaries. The logical data type, LOGICAL*8, holds the logical value .TRUE. or .FALSE. This data type is allowed only if the -dbl option is set. The value is defined the same way as for the LOGICAL data type.
A LOGICAL*8 occupies 8 bytes. LOGICAL*8 is aligned on 8-byte boundaries.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. 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.
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.
(SPARC, PowerPC only) The REAL*16 data type is a quadruple-precision real.The size for a REAL*16 item is 16 bytes. A REAL*16 element has a sign bit, a 15-bit exponent, and a 112-bit fraction. These REAL*16 elements in f77 conform to the IEEE standard for extended precision.
The size and alignment of types depends on various compiler options and platforms.
Table 2-1 summarizes the default size and alignment, ignoring other aspects of types and options.REAL*16 and COMPLEX*32 are only available on SPARC and
PowerPC. Compiling with options -i2,-r8, or -dbl changes
the defaults for certain data declarations that appear without an explicit size:
See the Fortran User's Guide for details.
A 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.
There are three general kinds of constants: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:| Typed Constants |
Typeless Constants |
| Complex | Binary |
| Double complex | Octal |
| Double precision | Hexadecimal |
| Integer | Hollerith |
| Real |
A character-string constant is a string of characters enclosed in apostrophes or
quotes. The apostrophes are standard; the quotes are not.
'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.
"abc" "abc" "ain't" 'in vi type "h9Y' |
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' stop end demo% f77 NulChr.f NulChr.f: MAIN: demo% a.out ab demo% |
Example: Length of null character string:
demo% cat NulVar.f character*1 x / 'a' /, y / '' /, z / 'c' / write(*,*) x, y, z write(*,*) len( y ) end demo% f77 NulVar.f NulVar.f: MAIN: demo% a.out a c 1 demo% |
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.
Technically, the escape sequences are not nonstandard, but are implementation- defined.
A complex constant is an ordered pair of real or integer 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 |
A double-complex constant, COMPLEX*16, is an ordered pair of real or integer
constants, where one of the constants is REAL*8, and the other is INTEGER, REAL*4, or
REAL*8.
( 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 |
(SPARC, PowerPC 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 is INTEGER, REAL*4, REAL*8, or REAL*16.
, uses 32 bytes of
storage.
Example: Quad complex constants (SPARC, PowerPC 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*16 |
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 range (-2147483648, 2147483647). Compiling with the -dbl or -r8 option alters the range to: 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 type INTEGER.
Example: The following two statements are equivalent:JCOUNT = ICOUNT + "703 JCOUNT = ICOUNT + 451 |
You can also specify typeless constants as binary, octal, hexadecimal, or Hollerith. See "Typeless Constants (Binary, Octal, Hexadecimal)" on page 34.
Compiling with the -dbl or -r8 option alters the range from
(-21474836, 21474836) to (-9223372036854775808, 9223372036854775807). The integer constant
is stored or passed as an 8-byte integer, data type INTEGER*8.
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 type INTEGER*2.
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.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.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.5 |
A real exponent consists of the letter E, followed by an optional plus or minus sign, followed by an integer.
Example: Real exponents:E+12 E-3 E6 |
A real constant has one of these forms:
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:A 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. The REAL*8 notation is
nonstandard.
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 a D is used instead of an E. Examples of double-precision constants are:(SPARC, PowerPC only) A quadruple-precision constant is a basic real constant (see the start of the section,
"Real Constants" on page 31), or an integer constant, such that it is followed by a quadruple-precision exponent.
Example: Quadruple-precision constants:
Typeless numeric constants are so named because their expressions assume data types
based on how they are used.
PARAMETER ( P1 = Z'1F' ) INTEGER*2 N1, N2, N3, N4 DATA N1 /B'0011111'/, N2/O'37'/, N3/X'1f'/, N4/Z'1f'/ WRITE ( *, 1 ) N1, N2, N3, N4, P1 1 FORMAT ( 1X, O4, O4, Z4, Z4, Z4 ) END |
Example: Binary, octal, and hexadecimal, other than in DATA and
PARAMETER:
INTEGER*4 M, ICOUNT/1/, JCOUNT REAL*4 TEMP M = ICOUNT + B'0001000' JCOUNT = ICOUNT + O'777' TEMP = X'FFF99A' WRITE(*,*) M, JCOUNT, TEMP END |
The above statements are treated as the following:
M = ICOUNT + 8 JCOUNT = ICOUNT + 511 TEMP = 2.35076E-38 |
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' ) |
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 or PARAMETER 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'O 37'O Invalid--missing initial apostrophe '37' Not numeric-- missing letter O '397'O Invalid--invalid digit |
For hexadecimals, enclose a string of hex digits in apostrophes and append the letter X.
Example: Hex alternate notation for typeless constants:
'ab'X 3fff'X '1f'X '1fX Invalid--missing trailing apostrophe '3f' Not numeric-- missing X '3g7'X Invalid--invalid digit g |
Here are the rules and restrictions for binary, octal, and hexadecimal 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 in DATA 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*2 INTEGER TAG*2 DATA TAG / 2Hok / CODE = 2Hno IF ( C .EQ. 1HZ ) CALL PUNT |
The rules and restrictions on Hollerith constants are:
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 Section , "Types," for more details on the rules for data typing.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," on page 14 for details.You can declare an array in any of the following statements:
An array declarator specifies the name and properties of an array.
The syntax of an array declarator is:a ( d [, d ] ... ) |
A dimension declarator has the form:
[ dl:] du
where:
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) |
Example: Default lower bound of 1:
REAL V(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) |
CHARACTER M(3,4)*7, V(9)*4 |
The 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:
An adjustable array is an array which is a dummy argument, and which has one or more of its dimensions or bounds as integer variables that are either themselves dummy arguments, or are in a common block.
You can declare adjustable arrays in the usual DIMENSION, COMMON, or type statements. In f77,you can also declare adjustable arrays in a RECORD statement, if that RECORD statement is not inside a structure declaration block. Example: Adjustable array bounds with arguments, and variables in common;SUBROUTINE POPUP ( A, B, N ) COMMON / DEFS / M, L, K REAL A(3:5, 7, M:N), B(N+1:2*N) |
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. In f77, the following extensions are allowed: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.
An array name with no subscripts indicates the entire array. It can appear in any of the following statements:
In an EQUIVALENCE statement, the array name without subscripts indicates the first element of the array.
An array element name is an array name qualified by a subscript.
A subscript is a parenthesized list of subscript expressions. There must be one subscript expression for each dimension of the array.
The form of a subscript is:( s [, s ] ... )
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.0 |
The above code assigns 0.0 to the element in row 1, column 2, of array M.
Subscript expressions have the following properties and restrictions:
REAL V(-1:8) V(2) = 0.0 |
In the above example, the fourth element of V is set to zero.
Subscript expressions cannot exceed the range of INTEGER*4. It is not controlled, but if the subscript expression is not in the rangeArray 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.
INTEGER*4 A(3,2) |
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.
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:v( [ e1 ] : [ e2 ] )
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 |
S(I:L) |
In the above example, there are L-I+1 characters in the substring.
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:
L the declared length, where I is the initial
position, and L is the last position. Examples: Substrings--the value of the element in column 2, row 3 is e23:
A structure is a generalization of an array.
The structure declaration has the following syntax:
Each field declaration can be one of the following:
Example: A STRUCTURE declaration:
STRUCTURE /PRODUCT/ INTEGER*4 ID CHARACTER*16 NAME CHARACTER*8 MODEL REAL*4 COST REAL*4 PRICE END STRUCTURE |
In the above example, a structure named PRODUCT is defined to consist of the five fields ID, NAME, MODEL, COST, and PRICE. For an example with a field-list, see "Structure within a Structure" on page 53.
Note the following:
Fields that are type declarations use the identical syntax of normal FORTRAN type statements. All f77 types are allowed, subject to the following rules and restrictions:
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
Appendix C, "Data Representations," for a summary of storage allocation.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:Example: A RECORD that uses the previous STRUCTURE example:
RECORD /PRODUCT/ CURRENT, PRIOR, NEXT, LINE(10) |
Note the following rules and restrictions for records:
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:record-name[.field-name] ... [.field-name] |
|
| record-name | Name of a previously defined record variable |
| 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 = NEXT LINE(1) = CURRENT WRITE ( 9 ) CURRENT NEXT.ID = 82 |
Example: Structure and record declarations, record and field assignments:
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 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 BUYER INTEGER*2 QUANTITY RECORD /PRODUCT/ ITEM END STRUCTURE |
You can nest a declaration within a declaration.
Example: If /PRODUCT/ is not declared previously, then you can declare it within the declaration of SALE:STRUCTURE /SALE/ CHARACTER*32 BUYER INTEGER*2 QUANTITY STRUCTURE /PRODUCT/ ITEM INTEGER*4 ID CHARACTER*16 NAME CHARACTER*8 MODEL REAL*4 COST REAL*4 PRICE END STRUCTURE END STRUCTURE |
You can refer to fields within substructures.
Example: Refer to fields of substructures (PRODUCT and SALE, from the previous examples, are defined in the current program unit):... RECORD /SALE/ JAPAN ... N = JAPAN.QUANTITY I = JAPAN.ITEM.ID ... |
Note the following:
A union declaration defines groups of fields that share memory at runtime.
The syntax of a union declaration is:
UNION map-declaration map-declaration [map-declaration] ... [map-declaration] END UNION |
The syntax of a map declaration is as follows.
MAP field-declaration [field-declaration] ... [field-declaration] END MAP |
Each field-declaration in a map declaration can be one of the following:
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 either NAME, CLASS, and MAJOR--or NAME, CLASS, CREDITS, and GRAD_DATE:STRUCTURE /STUDENT/ CHARACTER*32 NAME INTEGER*2 CLASS UNION MAP CHARACTER*16 MAJOR END MAP MAP INTEGER*2 CREDITS CHARACTER*8 GRAD_DATE END MAP END UNION END STRUCTURE |
The POINTER statement establishes pairs of variables and pointers. Each pointer contains the address of its paired variable.
POINTER ( p1, v1 ) [, ( p2, v2 ) ... ] |
The POINTER statement has the following syntax:
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. The pointer is the integer variable that contains the address.
Example: A simple POINTER statement:POINTER ( P, V ) |
Here, V is a pointer-based variable, and P is its associated pointer.
Normal use of pointer-based variables involves the following steps. The first two steps can be in either order.
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.
Theloc(), malloc(), and free() routines
associate and deassociate memory addresses with pointers. (These routines are described in
Chapter 6.)
You 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*12 DATA A / 'ABCDEFGHIJKL' / P = LOC( A ) PRINT *, V(5:5) END |
The 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 Z REAL X, Y POINTER ( P1, X ), ( P2, Y ), ( P3, Z ) ... P1 = MALLOC ( 10000 ) ... |
The subroutine FREE() deallocates a region of memory previously allocated by MALLOC(). The argument given to FREE() must be a pointer previously returned by MALLOC(), but not already given to FREE(). 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 ) ... |
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, or NAMELIST 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. If the expression is not in the range (-2147483648, 2147483647), then the results are unpredictable.Pointers have the annoying side effect of reducing the assumptions that the global optimizer can make. For one thing, compare the following:
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.
There are two alternatives for optimization with pointers.
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 in CALC.
Any of the following coding practices, and many others, could cause problems with an optimization level of -O3 or -O4:
Example: One kind of code that could cause trouble with -O3 or -O4:
COMMON A, B, C POINTER ( P, V ) P = LOC(A) + 4 ! ... |
Possible problems if optimized