f77_help

<PLAINTEXT>
IBM-FORTRAN (Ryan-McFarland)
===========
Sprachbeschreibung (Fortran 77) s. Manual (Kurzfassung unten)
1. Quellcode erzeugen (mit einem Editor, z.B. MS oder SPFPC)
--> XXX.FOR
2. Programm kompilieren
PROFORT XXX
-->
XXX.OBJ
evtl. mit Optionen:
/B /C n /D /E /F /I /L /M /P n /T /W /X /Z
/I
/D
/L
INTEGER bedeutet INTEGER*2 (default *4)
conditionally compile statements with D in column 1
Listing + Map (allocation, subprograms,
labels, statements)
/L/M
Listing mit ausfuehrlicher Map
/F
DO-loops mit count=0 werden durchgefuehrt
/L/X
Listing mit Cross References
3. Linken mit LINK
-->
XXX.EXE
LINK XXX <Enter>
Run File [XXX.EXE] <Enter>
List File [NUL.MAP] <Enter>
(keine Map)
Libraries [.LIB] <Enter>
FTN-Kommandos (IBM Ryan-McFarland)
=============
ASSIGN statement-label TO integer-variable
BACKSPACE ( unit [, IOSTAT=..., ERR=label]) ein Record zurueck
BLOCKDATA [name] block-data-subprogram
CALL subroutine-name [([ aktuelle Argumente ])]
CHARACTER[*n] = String aus n (>=1) 8-bit-Characters ('...''...')
CLOSE ( unit [, IOSTAT=v_int*4, STATUS=..., ERR=label])
Anm. optional STATUS = 'KEEP' | 'DELETE' .
COMMON [ /name/ ] common-item-list
COMPLEX = COMPLEX*8 (2 real*4)
CONTINUE
DATA variable-list /constant-list/
DIMENSION (up to 7 dimensions)
DO statement-label variable=initial-val.,terminal-val. [,increm.]
DOUBLEPRECISION = REAL*8, auf 16 Stellen genau, Bereich D(+-)308
ELSE
ELSEIF (logical-expression)
END
ENDFILE ( unit [, IOSTAT=..., ERR=label]) schreibt EOF-Marke
ENDIF
ENTRY name [ ( [dummy-Argumente] ) ]
EQUIVALENCE ( equiv-item, equiv-item )
EXTERNAL external-procedure
(zur Spezifikation externer Proz.)
FORMAT ( format-list )
repeatable: Dw.d, Ew.d[Ee], Fw.d, Gw.d[Ee], Iw[.m],
Lw, A[w];
nonrepeatable: ', nH, T, TL, TR, nX, /, :, S, SP, SS, kP,
BN | BZ .
FUNCTION - [type] FUNCTION name ( [dummy-Argumente] )
GOTO statement-number | assigned goto | GOTO (label-list)[,]int.
IF - arithmetic-if | logical-if | block-if
IF (arithm. exp.) label, label, label
(fuer LT, EQ, GT 0)
IF (log. exp.) executable-statement
IF (log. exp.) THEN
(mit ELSEIF, ELSE, ENDIF)
IMPLICIT INTEGER (I-N) (z.B.; entspricht Default)
INCLUDE 'filename' [not standard]
INQUIRE ( <unit | FILE=name> [, IOSTAT=v_int*4, RECL=v_int*4,
NEXTREC=v_int*4, NUMBER=v_int*4, EXIST=v_log,
OPENED=v_log, NAMED=v_log, NAME=v_char, ACCESS=v_char,
SEQUENTIAL=v_char, DIRECT=v_char, FORM=v_char,
FORMATTED=v_char, UNFORMATTED=v_char, BLANK=v_char,
ERR=label])
Anm.: IOSTAT=0 falls alles okay, -1 bei EOF.
INTEGER = INTEGER*4 (oder integer*2 bei Compiler-Option /I)
INTEGER*4 -2147483648 bis +2147483647
INTEGER*2 -32768 bis +32767
INTEGER*1 -128 bis +127
INTRINSIC intrinsic-function
LOGICAL = LOGICAL*4, .FALSE. oder .TRUE. (F oder T in I/O)
LOGICAL*2
LOGICAL*1
OPEN ( unit [, IOSTAT=v_int*4, RECL=int*4, FILE=name, STATUS=...,
ACCESS=..., FORM=..., BLANK=..., ERR=label])
Anm.: entweder 'FORMATTED' oder 'UNFORMATTED';
ACCESS='SEQUENTIAL' ohne RECL (default 'FORMATTED'),
ACCESS='DIRECT': RECL def. (default 'UNFORMATTED');
STATUS= 'NEW' | 'OLD' | 'SCRATCH' | 'UNKNOWN' (default)
(Anm.: 'SCRATCH' ohne Filename!).
PARAMETER ( constant-name = expression, ...)
PAUSE [ digit-string | character-constant ] (-> DOS)
PRINT format-id. [, iolist]
PROGRAM name
READ (read-write-control) [iolist] | READ format-id. [, iolist]
(unit [,format, REC=..., IOSTAT=..., END=label, ERR=label])
REAL = REAL*4, auf 7 Stellen genau, Bereich E(+-)38
RETURN [ integer-expression ]
REWIND ( unit [, IOSTAT=..., ERR=label]) zum Anfang des Files
SAVE [ /block-name/ variable-name ]
(hier ueberfluessig!)
STOP [ digit-string | character-constant ]
SUBROUTINE name [(dummy-Argumente)]
TO (vgl. ASSIGN)
WRITE (read-write-control) [iolist]
(unit [,format, REC=..., IOSTAT=..., ERR=label])
Extensions provided by IBM-Fortran
INCLUDE 'filename'
(.NEQV. entspricht der Wirkung von XOR)
Date and time:
GETDAT,SETDAT,GETTIM,SETTIM
Hollerith constants (though obsolete) are supported (5HHello)
UNIT=5 or 6 is treated as * in READ/WRITE
Variablennamen: max. 8 Character fuer globale, 31 fuer lokale.
Integer-Konstanten auch hexadezimal (Z'34AF'); in I/O: Z[w]
Sonstige Kommandos/Worte in F77
'DELETE'
'KEEP'
'DIRECT'
'SEQUENTIAL'
'YES'
'NO'
'UNKNOWN'
'ZERO'
'NULL'
'FORMATTED'
'UNFORMATTED'
'NEW'
'OLD'
'SCRATCH'
UNIT=
FMT=
REC=
IOSTAT=
END=
ERR=
STATUS=
ACCESS=
FORM=
RECL=
BLANK=
EXIST=
OPENED=
NUMBER=
NAMED=
NAME=
NEXTREC=
OPEN(u,FILE=...,STATUS='OLD'),CLOSE(u,STATUS='D-')
(in STATUS=)
(random access; RECL= muss spezifiziert werden)
(in ACCESS=)
(autom. 'SCRATCH'/'OLD'/'NEW'; oder kein STATUS=)
seq. num. Input: Blanks werden zu 0
seq. num. Input: Blanks werden ignoriert
(in FORM=)
(in FORM=)
(in STATUS=; File darf nicht existieren!)
(in STATUS=; File muss existieren)
(ohne FILE=; interner Workfile)
Nummer 0...255
label (Format-Anweisung)
direct access: Record-Nr. (1,2,3,...)
0: kein Fehler, <0: EOF, >0: Fehler
label (EOF-Abfrage, nur bei sequential READ)
label (Fehler-Abfrage)
'NEW','OLD','SCRATCH','UNKNOWN';'KEEP','DELETE'
'DIRECT','SEQUENTIAL'
'FORMATTED','UNFORMATTED'
Record-Laenge in Byte (formatted: max. 255)
'NULL' (default) oder 'ZERO'
(logical)
(logical)
(unit identifier)
(logical)
(Filename)
Nr. des naechsten Records (direct access)
Standardfunktionen
ABS(x)
ACOS(x)
AIMAG(x)
AINT(x)
ALOG(x)
ALOG10(x)
AMAX0(x,y,...)
|x|
arccos(x)
Im(x)
int(x)
ln(x)
lg(x)
max
R(R)
R(R)
R(C)
R(R)
R(R)
R(R)
R(I)
AMAX1(x,y,...)
AMIN0(x,y,...)
AMIN1(x,y,...)
AMOD(x,y)
ANINT(x)
ASIN(x)
ATAN(x)
ATAN2(x,y)
BTEST(x,y)
CABS(x)
CCOS(x)
CEXP(x)
CHAR(x)
CLOG(x)
CMPLX(x[,y])
CONJG(x)
COS(x)
COSH(x)
CSIN(x)
CSQRT(x)
DABS(x)
DACOS(x)
DASIN(x)
DATAN(x)
DATAN2(x,y)
DBLE(x)
DCOS(x)
DCOSH(x)
DDIM(x,y)
DEXP(x)
DIM(x,y)
DINT(x)
DLOG(x)
DLOG10(x)
DMAX1(x)
DMIN1(x)
DMOD(x,y)
DNINT(x)
DPROD(x,y)
DSIGN(x,y)
DSIN(x)
DSINH(x)
DSQRT(x)
DTAN(x)
DTANH(x)
EXP(x)
FLOAT(x)
HFIX(x)
I(x,y)
IABS(x)
IBCHNG(x,y)
IBCLR(x,y)
IBSET(x,y)
ICHAR(char)
max
R(R)
min
R(I)
min
R(R)
mod(x/y)
R(R)
int(x0.5)
R(R)
arcsin(x)
R(R)
arctan(x)
R(R)
arctan(x/y)
R(R)
true if bit y in x is 1
L(I)
abs(x)
R(C)
cos(x)
C(C)
exp(x)
C(C)
character
char(I)
ln(x)
C(C)
complex(Re,Im) C(...)
cmplx(Re,-Im) C(C)
cos(x)
R(R)
cosh(x)
R(R)
sin(x)
C(C)
x
C(C)
|x|
D(D)
arccos(x)
D(D)
arcsin(x)
D(D)
arctan(x)
D(D)
arctan(x/y)
D(D)
double prec.
D(...)
cos(x)
D(D)
cosh(x)
D(D)
x-y if >0
D(D)
exp(x)
D(D)
x-y if >0
R(R)
int(x)
D(D)
ln(x)
D(D)
lg(x)
D(D)
max
D(D)
min
D(D)
mod(x/y)
D(D)
int(x0.5)
D(D)
x*y
D(R)
|x|*sign(y)
D(D)
sin(x)
D(D)
sinh(x)
D(D)
x
D(D)
tan(x)
D(D)
tanh(x)
D(D)
exp(x)
R(R)
real
R(I)
short integer H(...)
logical product
I(I)
|x|
I(I)
reverse bit y in x I(I)
set bit y in x to 0
I(I)
set bit y in x to 1
I(I)
ASCII
I(char)
IDIM(x,y)
IDINT(x)
IDNINT(x)
IEOR(x,y)
IFIX(x)
INDEX(a1,a2)
INT(x)
IOR(x,y)
ISHA(x,y)
ISHC(x,y)
ISHFT(x,y)
ISHL(x,y)
ISIGN(x,y)
JFIX(x)
LEN(a)
LGE(a,b)
LGT(a,b)
LLE(a,b)
LLT(a,b)
LOG(x)
LOG10(x)
MAX(x,y,...)
MAX0(x,y,...)
MAX1(x,y,...)
MIN(x,y,...)
MIN0(x,y,...)
MIN1(x,y,...)
MOD(x,y)
NINT(x)
REAL(x)
SIGN(x,y)
SIN(x)
SINH(x)
SNGL(x)
SQRT(x)
TAN(x)
TANH(x)
x-y if >0
I(I)
integer
I(D)
int(x0.5)
I(D)
exclusive or
I(I)
integer
I(R)
index(a2 in a1)I(char)
integer
I(R)
inclusive or
I(I)
shift x arithmetically left y bits
rotate x left y bits
I(I)
= ISHL
shift x logically left y bits
|x|*sign(y)
I(I)
long integer
J(...)
length
I(char)
lex(>=)
L(char)
lex(>)
L(char)
lex(<=)
L(char)
lex(<)
L(char)
ln(x)
R(R)(?)
lg(x)
R(R)(?)
max
I(I)(?)
max
I(I)
max
I(R)
min
I(I)(?)
min
I(I)
min
I(R)
mod(x/y)
I(I)
int(x0.5)
I(R)
real
R(I)
|x|*sign(y)
R(R)
sin(x)
R(R)
sinh(x)
R(R)
real
R(D,C)
x
R(R)
tan(x)
R(R)
tanh(x)
R(R)
I(I)
I(I)
weitere Intrinsic Routines (Achtung: Argumente als INTEGER*2)
GETTIM(ihour,iminute,isecond,ihundredsecond)
SETTIM(...)
GETDAT(iyear,imonth,iday)
SETDAT(...)
IBM-F77: Anmerkungen
Dimensionierung von Arrays (default l.b.=1, max. 7 Dimensionen):
DIMENSION ARRAY([lower_bound:]upper-bound{,...})
Files:
formatted sequential:
auf Disk endet jedes Record mit CRLF
(Unit 6 oder *: Spezialfall)
unformatted sequential: Record-Laenge in 4-Byte Header + Trailer
direct-access:
alle Records muessen die gleiche Laenge haben
(definiert mit RECL)
formatted direct-access: entweder RECL=1 oder Record-Laenge = RECL+2
mit abschliessendem CRLF
unformatted direct-access: Record-Laenge = RECL
READ/PRINT/WRITE auf Terminal: * als Unit (oder 5 bzw. 6)
spezielle I/O-Dateinamen:
CON
(display, keyboard)
PRN (LPT1,LPT2,LPT3)
(Drucker)
AUX (COM1,COM2)
(RS-232)
Device identifications/units:
unit=5 or *
standard input (CON)
unit=6 or *
standard output (CON)
0
standard error output (CON)
1-4
FORT1-FORT4
7-255
FORT7-FORT255
Achtung: bei Ausgabe auf * oder 6 (standard output) wird das
erste Zeichen in der FORMAT-Anweisung als Vorschubsteuerung
interpretiert; sonst nicht! (Standard output: Zeilenvorschub vor
der WRITE-Ausgabe, sonst nach der WRITE-Ausgabe.)
Vorschubsteuerung fuer Drucker
blank
0
1
+
Vorschub zur naechsten Zeile (CRLF,...)
Vorschub zur uebernaechsten Zeile (CRLFLF,...)
Vorschub zur naechsten Seite
kein Zeilenvorschub (CR,...)
unformatted i/o:
[FORM='UNFORMATTED']
OPEN(7,FILE='DAFL',ACCESS='DIRECT',RECL=100)
WRITE(7,REC=1)
...
interne Datei:
character*150 intern
write(intern,'(I4)') A,B,C,D
(zur Umwandlung von Datentypen)
Operatoren:
arithmetische Operatoren: + - * / **
Character Concatenation:
//
Vergleichsoperatoren: .LT. .LE. .EQ. .NE. .GE. .GT.
logische Operatoren: .NOT.
.AND. .OR.
.EQV. .NEQV.
lower-case / upper-case: gleichwertig ausser in Character-Konst.
einige Anmerkungen zum IBM-Fortran:
Apostrophs (') in Strings ('...'): zwei Apostrophs (''), nicht ".
Substrings, character variable: v(p1:p2)
v(:) bedeutet v (gesamter String)
array element a(s1,s2,...)(p1:p2)
Kommentar: C oder c oder * in Spalte 1.
alternate returns:
CALL VALJMP(*200,*600,A,*100)
...
SUBROUTINE VALJMP(*,*,X,*)
IF(X.GT.0.0) RETURN 1
IF(X.EQ.0.0) RETURN 2
RETURN 3
END
Runtime out-of-range: hex 8000