Table B-1 FORTRAN Statement Samples
Name
|
Examples
|
Comments
|
|
ACCEPT 
|
ACCEPT *, A, I
|
Compare to READ.
|
|
ASSIGN
|
ASSIGN 9 TO I
|
|
|
ASSIGNMENT
|
C = 'abc'
C = "abc"
C = S // 'abc'
C = S(I:M)
|
Character
|
|
L = L1 .OR. L2
L = I .LE. 80
|
Logical
|
|
N = N+1
X = '7FF00000'x
|
Arithmetic
Hex
|
|
CURR = NEXT
NEXT.ID = 82
|
Compare to RECORD.
|
|
AUTOMATIC
|
AUTOMATIC A, B, C
AUTOMATIC REAL P, D, Q
IMPLICIT AUTOMATIC REAL (X-Z)
|
|
|
BACKSPACE
|
BACKSPACE U
BACKSPACE( UNIT=U, IOSTAT=I, ERR=9 )
|
|
|
BLOCK DATA
|
BLOCK DATA
BLOCK DATA COEFFS
|
|
|
BYTE
|
BYTE A, B, C
BYTE A, B, C(10)
BYTE A /'x'/, B /255/, C(10)
|
Initialize A and B
|
|
CALL
|
CALL P( A, B )
CALL P( A, B, *9 )
CALL P( A, B, &9 )
CALL P
|
Alternate return
Alternate return
|
|
CHARACTER
|
CHARACTER C*80, D*1(4)
CHARACTER*18 A, B, C
CHARACTER A, B*3 /'xyz'/, C /'z'/
|
Initialize B and C
|
|
CLOSE
|
CLOSE ( UNIT=I )
CLOSE( UNIT=U, ERR=90, IOSTAT=I )
|
|
|
COMMON
|
COMMON / DELTAS / H, P, T
COMMON X, Y, Z
COMMON P, D, Q(10,100)
|
|
|
COMPLEX
|
COMPLEX U, V, U(3,6)
COMPLEX U*16
COMPLEX U*32
COMPLEX U / (1.0,1.0) /, V /(1.0,10.0) /
|
Double complex
Quad complex (SPARC)
Initialize U and V
|
|
CONTINUE
|
100 CONTINUE
|
|
|
DATA
|
DATA A, C / 4.01, 'z' /
DATA (V(I),I=1,3) /.7, .8, .9/
DATA ARRAY(4,4) / 1.0 /
DATA B,O,X,Y /B'0011111', O'37', X'1f', Z'1f'/
|
|
|
DECODE
|
DECODE ( 4, 1, S ) V
|
|
|
DIMENSION
|
DIMENSION ARRAY(4, 4)
DIMENSION V(1000), W(3)
|
|
|
DO
|
DO 100 I = INIT, LAST, INCR
...
100 CONTINUE
|
|
|
DO I = INIT, LAST
...
END DO
|
Unlabeled DO
|
|
DO WHILE ( DIFF .LE. DELTA )
...
END DO
|
DO WHILE
|
|
DO 100 WHILE ( DIFF .LE. DELTA )
...
100 CONTINUE
|
|
|
DOUBLE COMPLEX
|
DOUBLE COMPLEX U, V
DOUBLE COMPLEX U, V
COMPLEX U / (1.0,1.0D0) /, V / (1.0,1.0D0) /
|
COMPLEX*16
COMPLEX
Initialize U and V
|
|
DOUBLE PRECISION
|
DOUBLE PRECISION A, D, Y(2)
DOUBLE PRECISION A, D / 1.2D3 /, Y(2)
|
REAL*8
Initialize D
|
|
ELSE
|
ELSE
|
Compare to IF (Block)
|
|
ELSE IF
|
ELSE IF
|
|
|
ENCODE
|
ENCODE( 4, 1, T ) A, B, C
|
|
|
END
|
END
|
|
|
END DO
|
END DO
|
Compare to DO
|
|
ENDFILE
|
ENDFILE ( UNIT=I )
ENDFILE I
ENDFILE( UNIT=U, IOSTAT=I, ERR=9 )
|
|
|
END IF
|
END IF
|
|
|
END MAP
|
END MAP
|
Compare to MAP
|
|
END STRUCTURE
|
END STRUCTURE
|
Compare to STRUCTURE
|
|
END UNION
|
END UNION
|
Compare to UNION
|
|
ENTRY
|
ENTRY SCHLEP( X, Y )
ENTRY SCHLEP( A1, A2, *4 )
ENTRY SCHLEP
|
|
|
EQUIVALENCE
|
EQUIVALENCE ( V(1), A(1,1) )
EQUIVALENCE ( V, A )
EQUIVALENCE (X,V(10)), (P,D,Q)
|
|
|
EXTERNAL
|
EXTERNAL RNGKTA, FIT
|
|
|
FORMAT
|
10 FORMAT(// 2X, 2I3, 3F6.1, 4E12.2, 2A6,3L2 )
10 FORMAT(// 2D6.1, 3G12.2 )
10 FORMAT( 2I3.3, 3G6.1E3, 4E12.2E3 )
|
X I F E A L
D G
w
|
|
10 FORMAT('a quoted string', " another", I2)
10 FORMAT( 18Ha hollerith string, I2)
10 FORMAT( 1X, T10, A1, T20, A1 )
|
Strings
Hollerith
Tabs
|
|
10 FORMAT( 5X, TR10, A1, TR10, A1, TL5, A1 )
10 FORMAT(" Init=", I2, :, 3X, "Last=", I2)
10 FORMAT( 1X, "Enter path name ", $ )
|
Tab right, left
:
$
|
|
10 FORMAT( F4.2, Q, 80 A1 )
10 FORMAT( 'Octal ', O6, ', Hex ' Z6 )
10 FORMAT( 3F<N>.2 )
|
Q
Octal, hex
Variable expression
|
|
FUNCTION
|
FUNCTION Z( A, B )
FUNCTION W( P,D, *9 )
CHARACTER FUNCTION R*4(P,D,*9 )
INTEGER*2 FUNCTION M( I, J )
|
Short integer
|
|
GO TO
|
GO TO 99
|
Unconditional
|
|
GO TO I, ( 10, 50, 99 )
GO TO I
|
Assigned
|
|
GO TO ( 10, 50, 99), I
|
Computed
|
|
IF
|
IF ( I -K ) 10, 50, 90
|
Arithmetic IF
|
|
IF ( L ) RETURN
|
LOGICAL IF
|
|
IF ( L ) THEN
N=N+1
CALL CALC
ELSE
K=K+1
CALL DISP
ENDIF
|
BLOCK IF
|
|
IF ( C .EQ. 'a' ) THEN
NA=NA+1
CALL APPEND
ELSE IF ( C .EQ. 'b' ) THEN
NB=NB+1
CALL BEFORE
ELSE IF ( C .EQ. 'c' ) THEN
NC=NC+1
CALL CENTER
END IF
|
BLOCK IF
With ELSE IF
|
|
IMPLICIT
|
IMPLICIT COMPLEX (U-W,Z)
IMPLICIT UNDEFINED (A-Z)
|
|
|
INCLUDE
|
INCLUDE 'project02/header'
|
|
|
INQUIRE
|
INQUIRE( UNIT=3, OPENED=OK )
INQUIRE( FILE='mydata', EXIST=OK )
INQUIRE( UNIT=3, OPENED=OK, IOSTAT=ERRNO )
|
|
|
INTEGER
|
INTEGER C, D(4)
INTEGER C*2
INTEGER*4 A, B, C
|
Short integer
|
|
INTEGER A/ 100 /, B, C / 9 /
|
Initialize A and C
|
|
INTRINSIC
|
INTRINSIC SQRT, EXP
|
|
|
LOGICAL
|
LOGICAL C
LOGICAL B*1, C*1
LOGICAL*1 B, C
LOGICAL*4 A, B, C
|
|
|
LOGICAL B / .FALSE. /, C
|
Initialize B
|
|
Map
|
MAP
CHARACTER *18 MAJOR
END MAP
MAP
INTEGER*2 CREDITS
CHARACTER*8 GRAD_DATE
END MAP
|
Compare to STRUCTURE and UNION
|
|
NAMELIST
|
NAMELIST /CASE/ S, N, D
|
|
|
OPEN
|
OPEN( UNIT=3, FILE="data.test" )
OPEN( UNIT=3, IOSTAT=ERRNO )
|
|
|
OPTIONS
|
OPTIONS /CHECK /EXTEND_SOURCE
|
|
|
PARAMETER
|
PARAMETER (A="xyz"), (PI=3.14)
PARAMETER (A="z", PI=3.14)
PARAMETER X=11, Y=X/3
|
|
|
PAUSE
|
PAUSE
|
|
|
POINTER
|
POINTER ( P, V ), ( I, X )
|
|
|
PRAGMA
|
EXTERNAL RNGKTA, FIT !$PRAGMA C(RNGKTA, FIT)
|
C() directive
|
|
PROGRAM
|
PROGRAM FIDDLE
|
|
|
PRINT
|
PRINT *, A, I
|
List-directed
|
|
PRINT 10, A, I
|
Formatted
|
|
PRINT 10, M
|
Array M
|
|
PRINT 10, (M(I),I=J,K)
|
Implied-DO
|
|
PRINT 10, C(I:K)
|
Substring
|
|
PRINT '(A6,I3)', A, I
PRINT FMT='(A6,I3)', A, I
|
Character constant format
|
|
PRINT S, I
PRINT FMT=S, I
|
Switch variable has format number
|
|
PRINT G
|
Namelist
|
|
READ
|
READ *, A, I
|
List-directed
|
|
READ 1, A, I
|
Formatted
|
|
READ 10, M
|
Array M
|
|
READ 10, (M(I),I=J,K)
|
Implied-DO
|
|
READ 10, C(I:K)
|
Substring
|
|
READ '(A6,I3)', A, I
|
Character constant format
|
|
|
READ( 1, 2 ) X, Y
READ( UNIT=1, FMT=2) X,Y
READ( 1, 2, ERR=8,END=9) X,Y
READ( UNIT=1, FMT=2, ERR=8,END=9) X,Y
|
Formatted read from a file
|
|
READ( *, 2 ) X, Y
|
Formatted read from standard input
|
|
READ( *, 10 ) M
|
Array M
|
|
READ( *, 10 ) (M(I),I=J,K)
|
Implied-DO
|
|
READ( *, 10) C(I:K)
|
Substring
|
|
READ( 1, * ) X, Y
READ( *, * ) X, Y
|
List-directed from file--from standard input
|
|
READ( 1, '(A6,I3)') X, Y
READ( 1, FMT='(A6,I3)') X, Y
|
Character constant format
|
|
READ( 1, C ) X, Y
READ( 1, FMT=C ) X, Y
|
|
READ( 1, S ) X, Y
READ( 1, FMT=S ) X, Y
|
Switch variable has format number
|
|
READ( *, G )
READ( 1, G )
|
Namelist read
Namelist read from a file
|
|
READ( 1, END=8, ERR=9 ) X, Y
|
Unformatted direct access
|
|
READ( 1, REC=3 ) V
READ( 1 ' 3 ) V
|
Unformatted direct access
|
|
READ( 1, 2, REC=3 ) V
|
Formatted direct access
|
|
READ( CA, 1, END=8, ERR=9 ) X, Y
|
Internal formatted sequential
|
|
READ( CA, *, END=8, ERR=9 ) X, Y
|
Internal list-directed sequential access
|
|
READ( CA, REC=4, END=8, ERR=9 ) X, Y
|
Internal direct access
|
|
REAL
|
REAL R, M(4)
REAL R*4
REAL*8 A, B, C
REAL*16 A, B, C
|
Double precision
Quad precision (SPARC only)
|
|
REAL A / 3.14 /, B, C / 100.0 /
|
Initialize A and C
|
|
RECORD
|
RECORD /PROD/ CURR,PRIOR,NEXT
|
|
|
RETURN
|
RETURN
RETURN 2
|
Standard return
Alternate return
|
|
REWIND
|
REWIND 1
REWIND I
REWIND ( UNIT=U, IOSTAT=I, ERR=9 )
|
|
|
SAVE
|
SAVE A, /B/, C
SAVE
|
|
|
STATIC
|
STATIC A, B, C
STATIC REAL P, D, Q
IMPLICIT STATIC REAL (X-Z)
|
|
|
STOP
|
STOP
STOP "all gone"
|
|
|
STRUCTURE
|
STRUCTURE /PROD/
INTEGER*4 ID / 99 /
CHARACTER*18 NAME
CHARACTER*8 MODEL / 'XL' /
REAL*4 COST
REAL*4 PRICE
END STRUCTURE
|
|
|
SUBROUTINE
|
SUBROUTINE SHR( A, B, *9 )
SUBROUTINE SHR( A, B, &9 )
SUBROUTINE SHR( A, B )
SUBROUTINE SHR
|
Alternate return
|
|
TYPE
|
TYPE *, A, I
|
Compare to PRINT
|
|
UNION
|
UNION
MAP
CHARACTER*18 MAJOR
END MAP
MAP
INTEGER*2 CREDITS
CHARACTER*8 GRAD_DATE
END MAP
END UNION
|
Compare to STRUCTURE
|
|
VIRTUAL
|
VIRTUAL M(10,10), Y(100)
|
|
|
VOLATILE
|
VOLATILE V, Z, MAT, /INI/
|
|
|
WRITE
|
WRITE( 1, 2 ) X, Y }
WRITE( UNIT=1, FMT=2 ) X, Y
WRITE( 1, 2, ERR=8, END=9 ) X, Y
WRITE( UNIT=1, FMT=2, ERR=8, END=9 ) X, Y
|
Formatted write to a file
|
|
|
WRITE( *, 2 ) X, Y
WRITE( *, 10 ) M
|
Formatted write to stdout
Array M
|
|
WRITE( *, 10 ) (M(I),I=J,K)
|
Implied-DO
|
|
WRITE( *, 10) C(I:K)
|
Substring
|
|
WRITE( 1, * ) X, Y
WRITE( *, * ) X, Y
|
List-directed write to a file
List-directed write to standard output
|
|
WRITE( 1, '(A6,I3)') X, Y
WRITE( 1, FMT='(A6,I3)') X, Y
|
Character constant format
|
|
WRITE( 1, C ) X, Y
WRITE( 1, FMT=C ) X, Y
|
Character variable format
|
|
WRITE( 1, S ) X, Y
WRITE( 1, FMT=S ) X, Y
|
Switch variable has format number
|
|
WRITE( *, CASE )
WRITE( 1, CASE )
|
Namelist write
Namelist write to a file
|
|
WRITE( 1, END=8, ERR=9 ) X, Y
|
Unformatted sequential access
|
|
WRITE( 1, REC=3 ) V
WRITE( 1 ' 3 ) V
|
Unformatted direct access
|
|
WRITE( 1, 2, REC=3 ) V
|
Formatted direct access
|
|
WRITE( CA, 1, END=8, ERR=9 ) X, Y
|
Internal formatted sequential
|
|
WRITE( CA, *, END=8, ERR=9 ) X, Y
|
Internal list-directed sequential access
|
|
WRITE( CA, REC=4, END=8, ERR=9 ) X, Y
|
Internal direct access
|
