COMPUTING SCIENCE 370
Programming Languages

Fortran -- Data Structures and Name Structures

Data Structures

• Primitive types are scalars:

  INTEGER
REAL
DOUBLE PRECISION
COMPLEX
LOGICAL (Boolean)
  CHARACTER (FORTRAN 77)

• Numeric operations are representation-independent.

Abstract Data Type

A set of data values, together with a set of operations on those values, that is defined without reference to the representation of the data values

Mathematics: integers are a subset of reals, which are a subset of complex numbers.

Computer arithmetic (typical):

Integer representation

±

bn

. . .

b3

b2

b1

b0

Floating point representation

±

ck

. . .

c1

c0

mn

. . .

m2

m1

m0

sign     bit

characteristic          (biased)

mantissa

• Operators are overloaded;
  e.g., + may be used with both INTEGER and REAL.

• Type coercion is implicit;
  e.g., if J is INTEGER and X is REAL,

  J = X + J

  means

  J = IFIX( X + FLOAT( J )

• Type declarations are implicit:
  • an identifier beginning with I to N is implicitly INTEGER
  • all others are implicitly REAL
  but can be made explicit.

Arrays

• One data constructor: the array.
  • 1-, 2-, or 3-dimensional

ZERO-ONE-INFINITY PRINCIPLE

The only reasonable numbers in a programming language design are zero, one, and infinity.

• Arrays are static.
  • size fixed at CT
  • allocation at LT, not RT

• Type and size of an array may be declared in separate declarations

  REAL A
DIMENSION A(100)

  or in a single declaration.

  REAL A(100)

• Arrays are stored in column-major order.

  	1	2	3	. . .	n
  1	|	|	|		|
  2	|	|	|		|
  3	|	|	|	. . .	|
  :	|	|	|		|
  m	V	V	V		V

  • addressing equations

    1-dimensional:

    addr{A(i)} = addr{A(1)} + size{A_elem}·(i-1)

    2-dimensional, where DIMENSION A(M,N):

    addr{A(i,j)} = addr{A(1,1)} + size{A_elem}·[M·(j-1)+(i-1)]

    3-dimensional:

    EXERCISE

Name Structures

• Declarations
  • nonexecutable
  • static allocation (CT)
  • binding via a symbol table

    Name	Type	Location
    :	:	:
    I	INTEGER	0245
    J	INTEGER	0246
    X	REAL	0247
    :	:	:

  • initialization

    DATA SUM, VEL, VOLT, LENGTH /0.0, 32.75, -2.5, 10/

  • automatic (implicit) declarations --> compiler can't catch typos

    FEET = FEAT + 1

Context (environment)

The set of declarations that are visible to a construct.

• Context is necessary to define meaning.
  E.g.,

  X = COUNT (I)

  X: REAL or INTEGER?
  COUNT: function or array?

Scope of the binding of a name

The region of the program over which the binding is visible.

• Scoping rules:
  • Variable name: local to the subprogram that contains it.
  • Subprogram name: global (entire program)
    [See contour diagram, Figure 2.9, p. 80.]

• Sharing data between subprograms:
  1. Declare variables in MAIN and pass them as parameters to all subprograms which need them.
     • MAIN does not need the data but can see it.
     • Difficult to make changes to the code.

  2. Use COMMON blocks.

     C     MAIN PROGRAM
             :
           CALL ARRAY2 (NM, AVAIL, INTCOD, M, N)
             :
           END
     
           SUBROUTINE ARRAY2 (N, L, C, D1, D2)
           COMMON /SYMTAB/ NAMES(100), LOC(100), TYPE(100), DIMS(100)
             :
           END
     
           SUBROUTINE VAR (N, L, C)
           COMMON /SYMTAB/ NAMES(100), LOC(100), TYPE(100), DIMS(100)
             :
           END
     

Aliasing

Binding more than one name to the same memory location.

1. Implicit aliasing using a COMMON block.
   E.g.,

   SUBROUTINE ARRAY2 (N, L, C, D1, D2)
   COMMON /SYMTAB/ NAMES(100), LOC(100), TYPE(100), DIMS(100)
     :
   END
   
   SUBROUTINE VAR (N, L, C)
   COMMON /SYMTAB/ NM(100), WHERE(100), MODE(100), SIZE(100)
     :
   END
   

   or even

   COMMON /B/ M, A(100)
   

   and

   COMMON /B/ X, K, C(50), D(50)
   

   B

   M		X
   A(1)		K
   A(2)		C(1)
   :	:	:
   A(51)		C(50)
   A(52)		D(1)
   :	:	:
   A(100)		D(49)
   		D(50)

2. Explicit aliasing using EQUIVALENCE
   E.g.,

   DIMENSION A(100), B(50)
   EQUIVALENCE (A(40), B(1))
   

   • Even different types can share memory.