The Fortran compiler supports the following types of arithmetic constants:

An arithmetic constant can be signed or unsigned. A signed constant has a leading plus or minus sign to denote a positive or negative number. A constant that can be either signed or unsigned is called an optionally signed constant. Only arithmetic constants can be optionally signed.

---

Note: The value zero is neither positive nor negative; a signed zero has the same value as an unsigned zero.

---

sww

0 +0   +176   –1352   06310   35 

$0123456789
$ABCDEF
$A2B2C3D4

5E4    5.E4    .5E5    5.0E+4    +5E04    50000. 

1.23456D3 
8.9743D0 
–4.D–10 
16.8D–6 

5D2  +5D02  5.D2  5.D+02  5D0002 

Logical constants represent only the values true or false, represented by one of the forms in Table 2-6.

A character constant is a string of one or more characters that can be represented by the processor. Each character in the string is numbered consecutively from left to right beginning with 1.

---

Note: The quotation mark (") is an extension to Fortran 77.

---

If the delimiter is ", then a quotation mark within the character string is represented by two consecutive quotation marks with no intervening blanks.

If the delimiter is ', then an apostrophe within the character string is represented by two consecutive apostrophes with no intervening blanks.

Blanks within the string of characters are significant.

The length of a character constant is the number of characters, including blanks, between the delimiters. The delimiters are not counted, and each pair of apostrophes or quotation marks between the delimiters counts as a single character.

A character constant is normally associated with the CHARACTER data type. The Fortran 77 standard is extended (except as noted below) to allow character constants to appear in the same context as a numeric constant. A character constant in the context of a numeric constant is treated the same as a Hollerith constant.

---

Note: Character constants cannot be used as actual arguments to numeric typed dummy arguments.

---

Table 2-7 provides examples of valid character constants and shows how they are stored.

Table 2-8 lists examples of invalid character constants and the reasons they are invalid.

Use Hollerith constants to manipulate packed character strings in the context of integer data types. A Hollerith constant consists of a character count followed by the letter H (either uppercase or lowercase) and a string of characters as specified in the character count and has the following format:

nHxxx...x

where n is a nonzero, unsigned integer constant and where the x's represent a string of exactly n contiguous characters. The blank character is significant in a Hollerith constant.

Examples of valid Hollerith constants are

3H A 
10H'VALUE = ' 
8H MANUAL 

Table 2-9 provides some examples of invalid Hollerith constants and the reasons they are invalid.

The following rules apply to Hollerith constants:

You can use bit constants anywhere numeric constants are allowed. Table 2-10 shows the allowable bit constants and their format.

The following are examples of bit constants used in a DATA statement.

integer a(4)
data a/b'1010',o'12',z'a',x'b'/

The above statement initializes the first elements of a four-element array to binary, the second element to an octal value, and the last two elements to hexadecimal values.

The following rules apply to bit constants:

A substring name defines the corresponding substring and allows it to be referenced in a character expression. A substring name has one of the following forms:

v([e1]:[e2])

a(s[,s]...) ([e1]:[e2])

where

The value e1 specifies the left most character position of the substring relative to the beginning of the variable or array element from which it was abstracted, while e2 is the right most position. Positions are numbered left to right beginning with 1. For example, the following denotes characters in positions three through five of the character variable EX:

EX(3:5)

The following specifies characters in positions one through five of the character array element NAME(2,4):

NAME(2,4)(1:5)

A character substring has the length e2 – e1 + 1.

The value of the numeric expressions e1 and e2 in a substring name must fall within the range

1 \xb2 e1 \xb2 e2 \xb2 len

where len is the length of the character variable or array element. A value of one is implied if e1 is omitted. A value of len is taken if e2 is omitted. When both e1 and e2 are not specified, the form v(:) is equivalent to v and the form a(s [,s]...)(:) is equivalent to a(s [,s]...).

The specification for e1 and e2 can be any numeric integer expression, including array element references and function references. Consider the character variable

XCHAR = 'QRSTUVWXYZ' 

Table 2-11 lists examples of valid substrings taken from this variable.

Other examples are

A record is a composite or aggregate entity containing one or more record elements or fields. Each element of a record is usually named. References to a record element consist of the name of the record and the name of the desired element. Records allow you to organize heterogeneous data elements within one structure and to operate on them either individually or collectively. Because they can be composed of heterogeneous data elements, records are not typed like arrays are.

Define the form of a record with a group of statements called a structure definitionblock. Establish a structure declaration in memory by specifying the name of the structure in a RECORD statement. A structure declaration block can include one or more of the following items:

The following sections describe these items. Refer to the RECORD and STRUCTURE declarations block sections in Chapter 4, "Specification Statements," for details on specifying a structure in a source program.

The generic term scalar reference refers to all references that resolve to single typed data items. A scalar field reference of an aggregate falls into this category. The generic term aggregate reference is used to refer to all references that resolve to references of structured data items defined by a RECORD statement.

Scalar field references can appear wherever normal variables or array elements can appear, with the exception of COMMON, SAVE, NAMELIST, and EQUIVALENCE statements. Aggregate references can only appear in aggregate assignment statements, in unformatted I/O statements, and as parameters to subprograms.

Aggregates can be assigned as whole entities. This special form of the assignment statement is indicated by an aggregate reference on the left-hand side of an assignment statement and requires an identical aggregate to appear on the right-hand side of the assignment.

An array name is the symbolic name given to the array and must conform to the rules given in Chapter 1, "Fortran Elements and Concepts," for symbolic names. When referencing the array as a whole, specify only the array name. An array name is local to a program unit.

An array element is specified by the array name and a subscript. The form of an array element name is

a (s [,s]...)

where

For example, DATE(1,5) accesses the element in the first row, fifth column, of the DATE array.

The number of subscript expressions must be equal to the number of dimensions in the array declarator for the array name.

An array element can be any of the valid Fortran data types. All array elements must be the same data type. Specify the data type explicitly using a type statement or implicitly using the first character of the array name. Refer to Chapter 1, "Fortran Elements and Concepts," for details about data types.

Reference a different array element by changing the subscript value of the array element name.

An array declarator specifies a symbolic name for the array, the number of dimensions in the array, and the size and bounds of each dimension. Only one array declarator for an array name is allowed in a program unit. The array declarator can appear in a DIMENSION statement, a type statement, or a COMMON statement but not in more than one of these.

An array declarator has the form

a (d [,d]...)

where

[d1:] d2

where:

If d1 or d2 is not of type integer, it is converted to integer values; any fractional part is truncated.

An array declarator can have a dummy argument as an array name and, therefore, be a dummy array declarator. An array declarator can be one of three types: a constant array declarator, an adjustable array declarator, or an assumed-size array declarator.

Each of the dimension bounds in a constant array declarator is a numeric constant expression. An adjustable array declarator is a dummy array declarator that contains one or more dimension bounds that are integer expressions but not constant integer expressions. An assumed-size array declarator is a dummy array declarator that has integer expressions for all dimension bounds, except that the upper dimension bound, d2, of the last dimension is an asterisk (*).

A dimension-bound expression cannot contain a function or array element name reference.

The lower-dimension bound, d1, and the upper-dimension bound, d2, can have positive, negative, or zero values. The value of the upper-dimension bound, d2, must be greater than or equal to that of the lower-dimension bound, d1.

If a lower-dimension bound is not specified, its value is assumed to be one (1). The upper-dimension bound of an asterisk (*) is always greater than or equal to the lower dimension bound.

The size of a dimension that does not have an asterisk (*) as its upper bound has the value (d1 - d2) +1.

The size of a dimension that has an asterisk (*) as its upper bound is not specified.

The size of an array is exactly equal to the number of elements contained by the array. Therefore, the size of an array equals the product of the dimensions of the array. For constant and adjustable arrays, the size is straightforward. For assumed-size dummy arrays, however, the size depends on the actual argument corresponding to the dummy array. There are three cases:

---

Note: Given an assumed-size dummy array with n dimensions, the product of the sizes of the first n – 1 dimensions must not be greater than the size of the array (the size of the array is determined as described above).

---

Storage for an array is allocated in the program unit in which it is declared, except in subprograms where the array name is specified as a dummy argument. The former declaration is called an actual array declaration. The declaration of an array in a subprogram where the array name is a dummy argument is called a dummy array declaration.

The elements of an array are ordered in sequence and stored in column order. This means that the left most subscript varies first, as compared to row order, in which the right most subscript varies first. The first element of the array has a subscript value of one; the second element has a subscript value of two; and so on. The last element has a subscript value equal to the size of the array.

Consider the following statement that declares an array with an INTEGER type statement:

INTEGER t(2,3)

Figure 2-1 shows the ordering of elements of this array.

Figure 2-1. Order of Array Elements

The subscript describes the position of the element in an array and allows that array element to be defined or referenced. The form of a subscript is

(s [,s]...)

where s is a subscript expression. The term subscript includes the parentheses that delimit the list of subscript expressions.

A subscript expression must be a numeric expression and can contain array element references and function references. However, it cannot contain any function references that affect other subscript expressions in the same subscript.

A non-integer character can be specified for subscript expression. If specified, the non-integer character is converted to an integer before use; fractional portions remaining after conversion are truncated.

If a subscript expression is not of type integer, it is converted to integer values; any fractional part is truncated.

Because an array is stored as a sequence in memory, the values of the subscript expressions must be combined into a single value that is used as the offset into the sequence in memory. That single value is called the subscript value.

The subscript value determines which element of the array is accessed. The subscript value is calculated from the values of all the subscript expressions and the declared dimensions of the array (see Table 2-12).

The subscript value and the subscript expression value are not necessarily the same, even for a one-dimensional array. For example,

DIMENSION X(10,10),Y(–1:8) 
Y(2) = X(1,2) 

Y(2) identifies the fourth element of array Y, the subscript is (2) with a subscript value of four, and the subscript expression is 2 with a value of two. X(1,2) identifies the eleventh element of X, the subscript is (1,2) with a subscript value of eleven, and the subscript expressions are 1 and 2 with the values of one and two, respectively.