2 Data Types

• 2.1 Constants
  • 2.1.1 Integer Constants
  • 2.1.2 Real Constants
  • 2.1.3 Double Precision Constants
  • 2.1.4 Logical Constants
  • 2.1.5 Complex Constants
  • 2.1.6 Character Constants
  • 2.1.7 Octal and Hexadecimal Constants
  • 2.1.8 Hollerith Constants
• 2.2 Arrays
  • 2.2.1 An Array Declaration Element
  • 2.2.2 Deferred Shape Arrays
  • 2.2.3 Subscripts
  • 2.2.4 Character substring
• 2.3 Structures@
  • 2.3.1 Records@
  • 2.3.2 UNION and MAP Declarations@
  • 2.3.3 Data Initialization
• 2.4 Pointer Variables @
  • 2.4.1 Restrictions

Every Fortran element and expression has a data type. The data type of an element may be implicit in its definition or explicitly attached to the element in a declaration statement. This chapter describes the Fortran data types and constants that pgf77 supports.

Table 2-1 lists the standard Fortran 77 data types. Table 2-2 shows additional data types that pgf77 Fortran supports.

The BYTE type is treated as a signed one-byte integer and is equivalent to LOGICAL*1.

Assignment of a value too big for the data type to which it is assigned is an undefined operation.

A specifier is allowed after a CHARACTER function name even if the CHARACTER type word has a specifier. For example:

CHARACTER*4 FUNCTION C*8 (VAR1)

@ Floating point data items of type REAL or DOUBLE PRECISION may be used as array subscripts, in computed GOTOs, in array bounds and in alternate returns. pgf77 converts the floating point number to an integer.

The data type of the result of an arithmetic expression corresponds to the type of its data. The type of an expression is determined by the rank of its elements. Table 2-3 shows the ranks of the various data types, from lowest to highest.

The data type of a value produced by an operation on two arithmetic elements of different data types is the data type of the highest-ranked element in the operation. The exception to this rule is that an operation involving a COMPLEX*8 element and a REAL*8 element produces a COMPLEX*16 result. In this operation, the COMPLEX*8 element is converted to a COMPLEX*16 element, which consists of two REAL*8 elements, before the operation is performed.

In most cases, a logical expression will have a LOGICAL*4 result. In cases where the hardware supports LOGICAL*8 and if the expression is LOGICAL*8, the result may be LOGICAL*8.

2.1 Constants

A constant is an unchanging value. It takes a form corresponding to one of the data types.

The compiler supports octal, hexadecimal and Hollerith constants. The use of character constants in a numeric context, for example, in the right-hand side of an arithmetic assignment statement, is supported. These constants assume a data type that conforms to the context in which they appear.

2.1.1 Integer Constants

The form of a decimal integer constant is:

[s]d1d2...dn

The range, data type and storage requirement change if the -i8 flag is specified (this flag is only available on systems where the hardware supports it). With the -i8 flag, the range for integer constants is -2⁶³ to (2⁶³ - 1)). The value of an integer constant must be within the range -9223372036854775808 to 9223372036854775807. If the constant does not fit in a INTEGER*4 range, the data type is INTEGER*8 and the storage requirement is 64 bits.

Below are several examples of integer constants.

+2
-36
437

2.1.2 Real Constants

Real constants have two forms, scaled and unscaled. An unscaled real constant consists of a signed or unsigned decimal number. A scaled real constant takes the same form as an unscaled constant, but is followed by a scaling factor using the form:

E+digits
Edigit
E-digits

2.1.3 Double Precision Constants

A double precision constant has the same form as a scaled real constant except that the E is replaced by D. Table 2-5 shows several double precision constants.

2.1.4 Logical Constants

A logical constant is one of:

.TRUE.
.FALSE.

The data type and storage requirements change with the -i8 or -i8storage flag to LOGICAL*8 , requiring 8-byte values (these flags are only available on hardware supporting 64 bit values).

The abbreviations T and F can be used in place of .TRUE. and .FALSE. in data initialization statements and in namelist input.

2.1.5 Complex Constants

A complex constant is held as two real constants separated by a comma and surrounded by parentheses. The first real number is the real part and the second real number is the imaginary part. Together these values represent a complex number. Below are several examples:

(3.5,-3.5)
(6.1E2,+2.3E3)

2.1.6 Character Constants

Character string constants may be delimited using either an apostrophe (') or a double quote ("). The apostrophe or double quote acts as a delimiter and is not part of the character constant. Use two apostrophes together to include an apostrophe as part of the expression. If a string begins with one variety of quote mark, the other may be embedded within it without using the repeated quote or backslash escape. Within character constants, blanks are significant. The length of the string must be at least one character. For further information on the use of the backslash character, refer to -Mbackslash in the pgf77 User's Guide.

Below are several examples of character constants.

'abc'
'abc '
'ab''c'

2.1.7 Octal and Hexadecimal Constants

The form of an octal constant is:

'c1c2...cn'O

'a1a2...an'X

@	    x'a1a2...an'

Octal and hexadecimal constants are stored as either 32-bit or 64-bit quantities. They are padded on the left with zeroes if needed and assume data types based on how they are used.

The following are the rules for converting these data types:

• A constant is always either 32 or 64 bits in size and is typeless. Sign-extension and type-conversion are never performed. All binary operations are performed on 32-bit or 64-bit quantities. This implies that the rules to follow are only concerned with mixing 32-bit and 64-bit data.
• When a constant is used with an arithmetic binary operator (including the assignment operator) and the other operand is typed, the constant assumes the type and size of the other operand.
• When a constant is used as an argument to the generic AND, OR, EQV, NEQV, SHIFT, or COMPL function, a 32-bit operation is performed if no argument is more than 32 bits in size; otherwise, a 64-bit operation is performed. The size of the result corresponds to the chosen operation.
• When a constant is used as an actual argument in any other context, no data type is assumed; however, a length of four bytes is always used. If necessary, truncation on the left occurs.
• When a specific 32-bit or 64-bit data type is required, that type is assumed for the constant. Array subscripting is an example.
• When a constant is used in a context other than those mentioned above, an INTEGER*4 data type is assumed. Logical expressions and binary arithmetic operations with other untyped constants are examples.
• When the required data type for a constant implies that the length needed is more than the number of digits specified, the leftmost digits have a value of zero. When the required data type for a constant implies that the length needed is less than the number of digits specified, the constant is truncated on the left. Truncation of nonzero digits is allowed.

	I = '1234'X       ! Leftmost Pad with zero.
	J = '1234567'X    ! Truncate Leftmost 3 hex digits
	D = '40000123456789ab'X
	D = NEQV(D,'ff'X)  ! 64-bit Exclusive Or

2.1.8 Hollerith Constants

The form of a Hollerith constant is:

nHc1c2...cn

• Sign-extension is never performed.
• The byte size of the Hollerith constant is determined by its context and is not strictly limited to 32 or 64 bits like hexadecimal and octal constants.
• When the constant is used with a binary operator (including the assignment operator), the data type of the constant assumes the data type of the other operand.
• When a specific data type is required, that type is assumed for the constant. When an integer or logical is required, INTEGER*4 and LOGICAL*4 are assumed. When a float is required, REAL*4 is assumed (array subscripting is an example of the use of a required data type).
• When a constant is used as an argument to certain generic functions (AND, OR, EQV, NEQV, SHIFT, and COMPL), a 32-bit operation is performed if no argument is larger than 32 bits; otherwise, a 64-bit operation is performed. The size of the result corresponds to the chosen operation.
• When a constant is used as an actual argument, no data type is assumed and the argument is passed as an INTEGER*4 array. Character constants are passed by descriptor only.
• When a constant is used in any other context, a 32-bit INTEGER*4 array type is assumed.

2.2 Arrays

An array is a group of consecutive, contiguous storage locations associated with a symbolic name which is the array name. Each individual element of storage, called the array element, is referenced by the array name modified by a list of subscripts. Arrays are declared with type declaration statements, DIMENSION statements and COMMON statements; they are not defined by implicit reference. These declarations will introduce an array name and establish the number of dimensions and the bound of each dimension. If a symbol, modified by a list of subscripts is not defined as an array, then it will be assumed to be a FUNCTION reference with an argument list.

2.2.1 An Array Declaration Element

An array declaration has the following form:

name([lb:]ub[,[lb:]ub]... )

(ub-lb+1)*(ub-lb+1)*...

2.2.2 Deferred Shape Arrays

Deferred-shape arrays are those arrays whose shape can be changed by an executable statement. Deferred shape arrays are declared with a rank, but with no bounds information. They assume their shape when either an ALLOCATE statement or a REDIMENSION statement is encountered.

For example, the following statement declares a deferred shape REAL array A with two dimensions.

REAL A(:, :)

2.2.3 Subscripts

A subscript is used to locate an array element for access. An array name qualified by a subscript list has the following form:

name(sub[,sub]...)

Each sub must be an integer expression yielding a value which is within the range of the lower and upper bounds. Arrays are stored as a linear sequence of values in memory and are held such that the first element is in the first store location and the last element is in the last store location. In a multi-dimensional array the first subscript varies more rapidly than the second, the second more rapidly than the third, and so on (column major order).

2.2.4 Character substring

A character substring is a contiguous portion of a character variable and is of type character. A character substring can be referenced, assigned values and named. It can take either of the following forms:

character_variable_name (x1 : x2)
character_array (subscripts) (x1 : x2)

For example:

J(2:4)

the characters in positions 2 to 4 of character variable J.

K(3,5)(1:4)

the characters in positions 1 to 4 of array element K(3,5).

2.3 Structures@

A structure is a user-defined aggregate data type having the following form:

STRUCTURE [/structure_name/][field_namelist]
	 field_declaration
	  [field_declaration]
	 	  ... 
	  [field_declaration]
END STRUCTURE

structure_name

is unique and is used both to identify the structure and to allow its use in subsequent RECORD statements.

field_namelist

is a list of fields having the structure of the associated structure declaration. A field_namelist is allowed only in nested structure declarations.

field_declaration

can consist of any combination of substructure declarations, typed data declarations, union declarations or unnamed field declarations.

Field names within the same declaration nesting level must be unique, but an inner structure declaration can include field names used in an outer structure declaration without conflict. Also, because records use periods to separate fields, it is not legal to use relational operators (for example, .EQ., .XOR.), logical constants (.TRUE. or .FALSE.), or logical expressions (.AND., .NOT., .OR.) as field names in structure declarations.

Fields in a structure are aligned as required by hardware; therefore a structure's storage requirements are machine-dependent. Because explicit padding of records is not necessary, the compiler recognizes the %FILL intrinsic, but performs no action in response to it.

Data initialization can occur for the individual fields.

2.3.1 Records@

A record is a user-defined aggregate data item having the following form:

RECORD /structure_name/record_namelist
	      [,/structure_name/record_namelist]
                 ... 
      [,/structure_name/record_namelist]

structure_name

is the name of a previously declared structure.

record_namelist

is a list of one or more variable or array names separated by commas.

You can access individual fields in a record by combining the parent record name, a period (.), and the field name (for example, recordname.fieldname). For records, a scalar reference means a reference to a name that resolves to a single typed data item (for example, INTEGER), while an aggregate reference means a reference that resolves to a structured data item.

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

The following is an example of RECORD and STRUCTURE usage.

	STRUCTURE /person/    ! Declare a structure to define a person
	   INTEGER id
	   LOGICAL living
	   CHARACTER*5 first, last, middle
	   INTEGER age
	END STRUCTURE
	   ! Define population to be an array where each element is of
	   ! type person.  Also define a variable, me, of type person.
	RECORD /person/ population(2), me
	   ...
	me.age = 34            ! Assign values for the variable me to
	me.living = .TRUE.     ! some of the fields.
	me.first = 'Steve'
	me.id = 542124822
	   ...
	population(1).last = 'Jones' ! Assign the "last" field of
	                             ! element 1 of array population.
	population(2) = me           ! Assign all the values of record
	                             ! "me" to the record population(2)

2.3.2 UNION and MAP Declarations@

A UNION declaration is a multi-statement declaration defining a data area that can be shared intermittently during program execution by one or more fields or groups of fields. It declares groups of fields that share a common location within a structure. Each group of fields within a union declaration is declared by a MAP declaration, with one or more fields per MAP declaration.

Union declarations are used when one wants to use the same area of memory to alternately contain two or more groups of fields. Whenever one of the fields declared by a union declaration is referenced in a program, that field and any other fields in its map declaration become defined. Then, when a field in one of the other map declarations in the union declaration is referenced, the fields in that map declaration become defined, superseding the fields that were previously defined.

A union declaration is initiated by a UNION statement and terminated by an END UNION statement. Enclosed within these statements are one or more map declarations, initiated and terminated by MAP and END MAP statements, respectively. Each unique field or group of fields is defined by a separate map declaration. The format of a UNION statement is as follows:

UNION
   map_declaration
   [map_declaration]
         ...
   [map_declaration]
END UNION

MAP
   field_declaration
   [field_declaration]
         ...
   [field_declaration]
END MAP

Data can be initialized in field declaration statements in union declarations. Note, however, it is illegal to initialize multiple map declarations in a single union.

Field alignment within multiple map declarations is performed as previously defined in structure declarations.

The size of the shared area for a union declaration is the size of the largest map defined for that union. The size of a map is the sum of the sizes of the field(s) declared within it plus the space reserved for alignment purposes.

Manipulating data using union declarations is similar to what happens using EQUIVALENCE statements. However, union declarations are probably more similar to union declarations for the language C. The main difference is that the language C requires one to associate a name with each "map" (union). Fortran field names must be unique within the same declaration nesting level of maps.

The following is an example of RECORD, STRUCTURE, MAP and UNION usage. The size of each element of the recarr array would be the size of typetag (4 bytes) plus the size of the largest MAP, the employee map (24 bytes).

        STRUCTURE /account/
	    INTEGER typetag			! Tag to determine defined map.
	    UNION
		MAP					! Structure for an employee
			CHARACTER*12	ssn		! Social Security Number
			REAL*4		salary
			CHARACTER*8	empdate		! Employment date
		END MAP
		MAP					! Structure for a customer
			INTEGER*4	acct_cust
			REAL*4		credit_amt
			CHARACTER*8	due_date
		END MAP
		MAP					! Structure for a supplier
			INTEGER*4	acct_supp
			REAL*4		debit_amt
			BYTE		num_items
			BYTE		items(12)	! Items supplied
		END MAP
	    END UNION
        END STRUCTURE 
        RECORD /account/ recarr(1000)

2.3.3 Data Initialization

@ Within data type declaration statements, data initialization is allowed. Data is initialized by placing values bounded by slashes immediately following the symbolic name (variable or array) to be initialized. Initialization of fields within structure declarations is allowed, but initialization of unnamed fields and records is not.

Hollerith, octal and hexadecimal constants can be used to initialize data in both data type declarations and in DATA statements. Truncation and padding occur for constants that differ in size from the declared data item (as specified in the discussion of constants above).

2.4 Pointer Variables @

The POINTER statement declares a scalar variable to be a pointer variable (of data type INTEGER), and another variable to be its pointer-based variable.

The syntax of the POINTER statement is:

POINTER (p1, v1) [, (p2, v2) ...]

v1 and v2

are pointer-based variables. A pointer-based variable can be of any type, including STRUCTURE. A pointer-based variable can be dimensioned in a separate type, in a DIMENSION statement, or in the POINTER statement. The dimension expression may be adjustable, where the rules for adjustable dummy arrays regarding any variables which appear in the dimension declarators apply.

p1 and p2

are the pointer variables corresponding to v1 and v2. A pointer variable may not be an array. The pointer is an integer variable containing the address of a pointer-based variable. The storage located by the pointer variable is defined by the pointer-based variable (for example, array, data type, etc.). A reference to a pointer-based variable appears in Fortran statements like a normal variable reference (for example, a local variable, a COMMON block variable, or a dummy variable). When the based variable is referenced, the address to which it refers is always taken from its associated pointer (that is, its pointer variable is dereferenced).

• By assigning the value of the LOC function.
• By assigning a value defined in terms of another pointer variable.
• By dynamically allocating a memory area for the based variable. If a pointer-based variable is dynamically allocated, it may also be freed.

	REAL XC(10)
	COMMON IC, XC
	POINTER (P, I)
	POINTER (Q, X(5))
	
	P = LOC(IC)
	I = 0			! IC gets 0
	
	P = LOC(XC)
	Q =  P + 20		! same as LOC(XC(6))
	X(1) = 0		! XC(6) gets 0
	ALLOCATE (X)		! Q  locates  an  allocated  memory  area

2.4.1 Restrictions

The following restrictions apply to the POINTER statement:

• No storage is allocated when a pointer-based variable is declared.
• If a pointer-based variable is referenced, its pointer variable is assumed to be defined.
• A pointer-based variable may not appear in the argument list of a SUBROUTINE or FUNCTION and may not appear in COMMON, EQUIVALENCE, DATA, NAMELIST, or SAVE statements.
• A pointer-based variable can be adjusted only in a SUBROUTINE or FUNCTION subprogram. If a pointer-based variable is an adjustable array, it is assumed that the variables in the dimension declarator(s) are defined with an integer value at the time the SUBROUTINE or FUNCTION is called. For a variable which appears in a pointer-based variable's adjustable declarator, modifying its value during the execution of the SUBROUTINE or FUNCTION does not modify the bounds of the dimensions of the pointer-based array.
• A pointer-based variable is assumed not to overlap with another pointer-based variable.

[*] The option -Munixlogical defines a logical expression to be true if its value is non-zero and false otherwise; also, the internal value of .TRUE. is 1. Refer to the pgf77 User's Guide for details.