![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to of77.ms CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / vol2 / f77|
Return to of77.ms CVS log | Up to [Research Unix] / researchv10dc / vol2 / f77 |
1.1 root 1: .so ../ADM/mac
2: .XX f77 315 "A Portable Fortran 77 Compiler"
3: .de XX
4: .IP "\f(CW\\$1\f1" 5
5: ..
6: .EQ
7: delim $$
8: .EN
9: . \".ND "1 August 1978"
10: .ND "30 June 1989"
11: .TL
12: A Portable Fortran 77 Compiler\(dg
13: .AU
14: S. I. Feldman
15: P. J. Weinberger
16: .AI
17: .MH
18: .AB
19: .PP
20: We report here on the first complete implementation of a compiler and run-time system for
21: the current Fortran language, known as Fortran 77.
22: The compiler is designed to be portable,
23: to be correct and complete,
24: and to generate code compatible with calling sequences produced by C compilers.
25: In particular, this Fortran is quite usable on
26: .UX
27: systems.
28: In this paper, we describe the language compiled,
29: interfaces between procedures,
30: and file formats assumed by the I/O system.
31: An appendix describes the Fortran 77 language.
32: .AE
33: .2C
34: .FS
35: \(dg This is a version of |reference(f77 v7man) revised by D. M. Gay.
36: .FE
37: .NH 1
38: Introduction
39: .PP
40: The current Fortran language, known as Fortran 77,
41: became an official American National Standard|reference(standard f77)
42: on April 3, 1978.
43: Fortran 77 supplants 1966 Standard Fortran|reference(standard f66).
44: We report here on a compiler and run-time system for Fortran 77.
45: The compiler and computation library were written by SIF, the I/O system by PJW.
46: We believe ours to be the first complete Fortran 77 system
47: to have been implemented.
48: This compiler is designed to be portable to a number of different machines,
49: to be correct and complete,
50: and to generate code compatible with calling sequences produced
51: by compilers for the C language|reference(cbook).
52: In particular,
53: it is in use on
54: .UX
55: systems.
56: The C compilers in use at Bell Labs include two families,
57: one based on D. M. Ritchie's PDP-11 compiler|reference(%type pamphlet
58: %author D. M. Ritchie
59: %title private communication), another
60: based on S. C. Johnson's portable C compiler|reference(pcc).
61: This Fortran compiler can drive the second passes of either family.
62: In this paper, we describe the language compiled,
63: interfaces between procedures,
64: and file formats assumed by the I/O system.
65: .NH 2
66: Usage
67: .PP
68: .I F77
69: is a general-purpose command for compiling and loading Fortran and Fortran-related files.
70: The command to run the compiler is
71: .P1
72: f77 \fIflags file . . .\fR
73: .P2
74: EFL|reference(efl) and Ratfor|reference(ratfor)
75: source files will be preprocessed before
76: being presented to the Fortran compiler.
77: C and assembler source files will be compiled by the appropriate programs.
78: Object files will be loaded.
79: (The
80: .I f77
81: and
82: .I cc
83: commands cause slightly different loading sequences to be generated,
84: since Fortran programs need a few extra libraries and a different startup routine
85: than do C programs.)
86: The following file name suffixes are understood:
87: .TS
88: center;
89: aFCW a.
90: \&.f Fortran source file
91: \&.e EFL source file
92: \&.r Ratfor source file
93: \&.c C source file
94: \&.s Assembler source file
95: \&.o Object file
96: .TE
97: .Tm Options s
98: The following flags are understood:
99: .XX -S
100: Generate assembler output for each source file, but do not assemble it.
101: Assembler output for a source file
102: .CW x.f ,
103: .CW x.e ,
104: .CW x.r ,
105: or
106: .CW x.c
107: is put on file
108: .CW x.s .
109: .XX -c
110: Compile but do not load.
111: Output for
112: .CW x.f ,
113: .CW x.e ,
114: .CW x.r ,
115: .CW x.c ,
116: or
117: .CW x.s
118: is put on file
119: .CW x.o .
120: .XX -m
121: Apply the M4 macro preprocessor to each EFL or Ratfor source file before using the appropriate compiler.
122: .XX -p
123: Generate code to produce usage profiles.
124: .XX "-o \fIf\fR"
125: Put executable module on file
126: .I f.
127: (Default is
128: .CW a.out ).
129: .XX -w
130: Suppress all warning messages.
131: .XX -w66\
132: Suppress warnings about Fortran 66 features used.
133: .XX -O
134: Invoke the C object code optimizer.
135: .XX -C
136: Compile code the checks that subscripts are within array bounds.
137: .XX -onetrip\ \
138: Compile code that performs every
139: .CW do
140: loop at least once.
141: (See Section 2.12).
142: .XX -U
143: Do not convert upper case letters to lower case.
144: The default is to convert Fortran programs to lower case.
145: .XX -u
146: Make the default type of a variable
147: .CW undefined.
148: (See Section 2.3).
149: .XX -I2
150: On machines which support short integers,
151: make the default integer constants and variables short.
152: (\f(CW-I4\fR is the standard value of this option). (See Section 2.14).
153: All logical quantities will be short.
154: .XX -E
155: The remaining characters in the argument are used as an EFL flag argument.
156: .XX -R
157: The remaining characters in the argument are used as a Ratfor flag argument.
158: .XX -F
159: Ratfor and EFL source programs are pre-processed into Fortran files,
160: but those files are not compiled or removed.
161: .in -1i
162: .LP
163: Other flags,
164: all library names (arguments beginning \f(CW-l\fR),
165: and any names not ending with one of the understood suffixes are passed to the loader.
166: .NH 2
167: Documentation Conventions
168: .PP
169: In running text, we write Fortran keywords and other literal strings in boldface lower case.
170: Examples will be presented in lightface lower case.
171: Names representing a class of values will be printed in italics.
172: .NH 2
173: Implementation Strategy
174: .PP
175: The compiler and library are written entirely in C.
176: The compiler generates C compiler intermediate code.
177: Since there are C compilers running on a variety of machines,
178: relatively small changes will make this Fortran compiler generate code for any of them.
179: Furthermore, this approach guarantees that the resulting programs are compatible with C usage.
180: The runtime computational library is complete.
181: The mathematical functions rely on the functions in C's \fIlibm\fR.
182: The runtime I/O library makes use of D. M. Ritchie's Standard C I/O package
183: |reference(stdio)
184: for transferring data.
185: With the exception described below, only documented calls are used,
186: so it should be relatively easy to modify the I/O library
187: to run on other operating
188: systems.
189: .NH 1
190: Language Extensions
191: .PP
192: Fortran 77 includes almost all of Fortran 66 as a subset.
193: We describe the differences briefly in the Appendix.
194: The most important additions are a character string data type,
195: file-oriented input/output statements, and random access I/O.
196: Also, the language has been cleaned up considerably.
197: .PP
198: In addition to implementing the language specified in the Fortran 77 Standard,
199: our compiler implements a few extensions described in this section.
200: Most are useful additions to the language.
201: The remainder are extensions
202: to make it easier to communicate with C procedures
203: or to permit compilation of
204: old (1966 Standard) programs.
205: .NH 2
206: Double Complex Data Type
207: .PP
208: The new type
209: .CW "double complex"
210: is defined.
211: Each datum is represented by a pair of double precision real variables.
212: A double complex version of every
213: .CW complex
214: built-in function is provided.
215: The specific function names begin with \f(CWz\fR instead of \f(CWc\fR.
216: .NH 2
217: Internal Files
218: .PP
219: The Fortran 77 standard introduces ``internal files'' (memory arrays), but
220: restricts their use to formatted sequential I/O statements.
221: Our I/O system also permits internal files to be used
222: in direct and unformatted reads and writes.
223: .NH 2
224: Implicit Undefined statement
225: .PP
226: Fortran 66 has a fixed rule that the type of a variable that does not appear in a type statement
227: is
228: .CW integer
229: if its first letter is one of
230: .CW ijklmn
231: and
232: .CW real
233: otherwise.
234: Fortran 77 has an
235: .CW implicit
236: statement for overriding this rule.
237: As an aid to good programming practice, we permit an additional type,
238: .CW undefined .
239: The statement
240: .P1
241: implicit undefined(a-z)
242: .P2
243: turns off the automatic data typing mechanism,
244: and the compiler will issue a diagnostic for each variable that is used but does
245: not appear in a type statement.
246: Specifying the
247: .CW -u
248: compiler flag is equivalent to beginning each procedure with this statement.
249: .NH 2
250: Recursion
251: .PP
252: Procedures may call themselves, directly or through a chain of other procedures.
253: .NH 2
254: Automatic Storage
255: .PP
256: Two new keywords are recognized,
257: .CW static
258: and
259: .CW automatic .
260: These keywords may appear as ``types'' in type statements and in
261: .CW implicit
262: statements.
263: Local variables are static by default;
264: there is exactly one copy of the datum, and its value is retained between calls.
265: There is one copy of each variable declared
266: .CW automatic
267: for each invocation of the procedure.
268: Automatic variables may not appear in
269: .CW equivalence ,
270: .CW data ,
271: or
272: .CW save
273: statements.
274: .NH 2
275: Source Input Format
276: .PP
277: The Standard expects input to the compiler to be in 72 column format:
278: except in comment lines,
279: the first five characters are the statement number, the next is the continuation character,
280: and the next sixty-six are the body of the line.
281: (If there are fewer than seventy-two characters on a line, the compiler pads it with blanks;
282: characters after the seventy-second are ignored).
283: .PP
284: To make typing Fortran programs easier,
285: our compiler also accepts input in variable length lines.
286: An ampersand
287: .CW &
288: in the first position of a line indicates a continuation
289: line; the remaining characters form the body of the line.
290: A tab character in one of the first six positions of a line signals the
291: end of the statement number and continuation part of the line;
292: the remaining characters form the body of the line.
293: A tab elsewhere on the line is treated as another kind of blank by the
294: compiler.
295: .PP
296: In the Standard, there are only 26 letters \(em Fortran is a one-case language.
297: Consistent with ordinary
298: .UX
299: system usage, our compiler expects lower case input.
300: By default, the compiler converts all upper case characters to lower case except those inside character constants.
301: However, if the
302: .CW -U
303: compiler flag is specified, upper case letters are not transformed.
304: In this mode, it is possible to specify external names with upper case letters in them,
305: and to have distinct variables differing only in case,
306: but then all Fortran keywords must be in lower case.
307: .NH 2
308: \f(CWinclude\fR Statement
309: .PP
310: The statement
311: .P1
312: include 'stuff'
313: .P2
314: is replaced by the contents of the file
315: .CW stuff .
316: .CW include s
317: may be nested to a reasonable depth, currently ten.
318: .NH 2
319: Binary Initialization Constants
320: .PP
321: A
322: .CW logical ,
323: .CW real ,
324: or
325: .CW integer
326: variable may be initialized in a
327: .CW data
328: statement
329: by a binary constant, denoted by a letter followed by a quoted string.
330: If the letter is
331: .CW b ,
332: the string is binary, and only zeros and ones are permitted.
333: If the letter is
334: .CW o ,
335: the string is octal, with digits
336: .CW 0-7 .
337: If the letter is
338: .CW z
339: or
340: .CW x ,
341: the string is hexadecimal, with digits
342: .CW 0-9a-f .
343: Thus, the statements
344: .P1
345: integer a(3)
346: data a / b'1010', o'12', z'a' /
347: .P2
348: initialize all three elements of
349: .I a
350: to ten.
351: .NH 2
352: Character Strings
353: .PP
354: For compatibility with C usage, the following backslash escapes are recognized:
355: .TS
356: center;
357: aFCW a.
358: \en newline
359: \et tab
360: \eb backspace
361: \ef form feed
362: \e0 null
363: \e' apostrophe (does not terminate a string)
364: \e" quotation mark (does not terminate a string)
365: \e\e \e
366: \e\fIx\fP \fIx\fR, where \fIx\fR is any other character
367: .TE
368: Fortran 77 only has one quoting character, the apostrophe.
369: Our compiler and I/O system recognize
370: both the apostrophe
371: .CW '
372: and the double-quote
373: .CW \" .
374: If a string begins with one variety of quote mark, the other may be embedded within it
375: without using the repeated quote or backslash escapes.
376: .PP
377: Every unequivalenced scalar local character variable and every character string constant is aligned
378: on an
379: .CW integer
380: word boundary.
381: Each character string constant appearing outside a
382: .CW data
383: statement is followed by a
384: null character to ease communication with C routines.
385: .NH 2
386: Hollerith
387: .PP
388: Fortran 77 does not have the old Hollerith (\fIn\|\f(CWh\fR)
389: notation,
390: though the new Standard recommends implementing the old Hollerith feature
391: in order to improve compatibility with old programs.
392: In our compiler, Hollerith data may be used in place of character string constants,
393: and may also be used to initialize non-character variables in
394: .CW data
395: statements.
396: .NH 2
397: Equivalence Statements
398: .PP
399: As a very special and peculiar case,
400: Fortran 66 permits an element of a multiply-dimensioned array to be represented by
401: a singly-subscripted reference in
402: .CW equivalence
403: statements.
404: Fortran 77 does not permit this usage, since
405: subscript lower bounds may now be different from 1.
406: Our compiler permits single subscripts in
407: .CW equivalence
408: statements,
409: under the interpretation that all missing subscripts are equal to 1.
410: A warning message is printed for each such incomplete subscript.
411: .NH 2
412: One-Trip \f(CWdo\fP Loops
413: .PP
414: The Fortran 77 Standard requires that the range of a
415: .CW do
416: loop not be performed
417: if the initial value is already past the limit value,
418: as in
419: .P1
420: do 10 i = 2, 1
421: .P2
422: The 1966 Standard stated that the effect of such a statement was undefined,
423: but it was common practice that the range of a
424: .CW do
425: loop would be performed
426: at least once.
427: In order to accommodate old programs, though they were in violation of the 1966 Standard,
428: the
429: .CW -onetrip
430: compiler flag causes non-standard loops to be generated.
431: .NH 2
432: Commas in Formatted Input
433: .PP
434: The I/O system attempts to be more lenient than the
435: Standard when it seems worthwhile.
436: In a formatted read of non-character variables,
437: commas may be used as value separators in the input record,
438: overriding the field lengths given in the format statement.
439: Thus,
440: the format
441: .P1
442: (i10, f20.10, i4)
443: .P2
444: will read the record
445: .P1
446: -345,.05e-3,12
447: .P2
448: correctly.
449: .NH 2
450: Short Integers
451: .PP
452: On machines that support halfword integers,
453: the compiler accepts declarations of type
454: .CW integer\(**2 .
455: (Ordinary integers follow the Fortran rules about occupying the same
456: space as a
457: .CW real
458: variable; they are assumed to be of C type
459: .CW "long int" ;
460: halfword integers are of C type
461: .CW "short int" .)
462: An expression involving only objects of type
463: .CW integer\(**2
464: is of that type.
465: Generic functions return short or long integers depending on the actual types of their arguments.
466: If a procedure is compiled using the
467: .CW -I2
468: flag, all small integer constants will be
469: of type
470: .CW integer\(**2 .
471: If the precision of an integer-valued intrinsic function is not determined by the generic function rules,
472: one will be chosen that returns the prevailing length
473: (\f(CWinteger\(**2\fR when the \f(CW-I2\fR command flag is in effect).
474: When the
475: .CW -I2
476: option is in effect, all quantities of type
477: .CW logical
478: will be short.
479: Note that these short integer and logical quantities do not obey the standard rules for storage association.
480: .NH 2
481: Additional Intrinsic Functions
482: .PP
483: This compiler supports all of the intrinsic functions specified in the Fortran 77 Standard.
484: In addition, there are functions for performing bitwise Boolean operations
485: (\fIor\fR, \fIand\fR, \fIxor\fR, and \fInot\fR)
486: and for accessing the
487: .UX
488: command arguments
489: (\fIgetarg\fR and \fIiargc\fR).
490: .NH 1
491: Violations of the Standard
492: .PP
493: We know only two ways in which our Fortran system violates
494: the Fortran 77 standard:
495: .NH 2
496: Double Precision Alignment
497: .PP
498: The Fortran standards (both 1966 and 1977)
499: permit
500: .CW common
501: or
502: .CW equivalence
503: statements to force a double precision quantity onto an odd word boundary,
504: as in the following example:
505: .P1 I
506: real a(4)
507: double precision b,c
508: .sp .5
509: equivalence (a(1),b), (a(4),c)
510: .P2
511: Some machines (e.g., Honeywell 6000, IBM 360) require that double precision quantities be on double word boundaries;
512: other machines (e.g., IBM 370), run inefficiently if this alignment rule is not observed.
513: It is possible to tell which equivalenced and common variables suffer from a forced odd
514: alignment, but every double precision argument would have to be assumed on a bad boundary.
515: To load such a quantity on some machines,
516: it would be necessary to use separate operations to move the upper and lower halves
517: into the halves of an aligned temporary, then to load that double precision temporary; the reverse would be
518: needed to store a result.
519: We have chosen to require that all double precision real and complex quantities
520: fall on even word boundaries on machines with corresponding hardware requirements,
521: and to issue a diagnostic if the source code demands a violation of the rule.
522: .NH 2
523: \f(CWt\fR and \f(CWtl\fR Formats
524: .PP
525: The implementation of the
526: .CW t
527: (absolute tab)
528: and
529: .CW tl
530: (leftward tab)
531: format codes
532: is defective.
533: These codes allow rereading or rewriting part of the
534: record which has already been processed.
535: (See Section 6.3.2 in the Appendix.)
536: The implementation uses seeks,
537: so if the unit is not one which allows seeks,
538: such as a terminal,
539: the program is in error.
540: (People who can make a case for using
541: .CW tl
542: should let us know.)
543: A benefit of the implementation chosen is
544: that there is no upper limit on the length of
545: a record,
546: nor is it necessary to predeclare any record
547: lengths except where specifically required
548: by Fortran or the operating system.
549: .NH 1
550: Inter-Procedure Interface
551: .PP
552: To be able to write C procedures that call or are called by Fortran procedures,
553: it is necessary to know the conventions for procedure names,
554: data representation,
555: return values,
556: and argument lists that the compiled code obeys.
557: .NH 2
558: Procedure Names
559: .PP
560: On
561: .UX
562: systems,
563: the name of a common block or a Fortran procedure
564: has an underscore appended to it by the compiler
565: to distinguish it from a C procedure or external variable
566: with the same user-assigned name.
567: Fortran library procedure names have embedded underscores to avoid clashes
568: with user-assigned subroutine names.
569: .KF
570: .TS
571: center;
572: c c
573: l l.
574: Fortran C
575: .sp .5
576: integer\(**2 x short int x;
577: integer x long int x;
578: logical x long int x;
579: real x float x;
580: double precision x double x;
581: complex x struct { float r, i; } x;
582: double complex x struct { double dr, di; } x;
583: character\(**6 x char x[6];
584: .TE
585: .ce
586: \fBTable 1. Fortran and C declarations
587: .KE
588: .NH 2
589: Data Representations
590: .PP
591: Table 1 shows corresponding Fortran and C declarations:
592: (By the rules of Fortran,
593: .CW integer,
594: .CW logical,
595: and
596: .CW real
597: data occupy the same amount of memory).
598: .NH 2
599: Return Values
600: .PP
601: A function of type
602: .CW integer ,
603: .CW logical ,
604: .CW real ,
605: or
606: .CW "double precision"
607: must be declared as a C function that returns the corresponding type.
608: A
609: .CW complex
610: or
611: .CW "double complex"
612: function is equivalent to a C routine
613: with an additional
614: initial argument that points to the place where the return value is to be stored.
615: Thus,
616: .P1
617: complex function f( . . . )
618: .P2
619: is equivalent to
620: .P1
621: f_(temp, . . .)
622: struct { float r, i; } \(**temp;
623: . . .
624: .P2
625: A character-valued function is equivalent to a C routine with
626: two extra initial arguments:
627: a data address and a length.
628: Thus,
629: .P1
630: character\(**15 function g( . . . )
631: .P2
632: is equivalent to
633: .P1
634: g_(result, length, . . .)
635: char result[ ];
636: long int length;
637: . . .
638: .P2
639: and could be invoked in C by
640: .P1
641: char chars[15];
642: . . .
643: g_(chars, 15L, . . . );
644: .P2
645: Subroutines are invoked as if they were
646: .CW integer -valued
647: functions
648: whose value specifies which alternate return to use.
649: Alternate return arguments (statement labels) are not passed to the function,
650: but are used to do an indexed branch in the calling procedure.
651: (If the subroutine has no entry points with alternate return arguments,
652: the returned value is undefined.)
653: The statement
654: .P1
655: call nret(\(**1, \(**2, \(**3)
656: .P2
657: is treated exactly as if it were the computed
658: .CW goto
659: .P1
660: goto (1, 2, 3), nret( )
661: .P2
662: .NH 2
663: Argument Lists
664: .PP
665: All Fortran arguments are passed by address.
666: In addition,
667: for every non-function argument that is of type character,
668: an argument giving the length of the value is passed.
669: (The string lengths are
670: .CW "long int"
671: quantities passed by value).
672: The order of arguments is then:
673: extra arguments for complex and character functions,
674: address for each datum or function,
675: a \f(CWlong int\fR for each character argument (other than character-valued functions).
676: Thus, the call in
677: .P1
678: external f
679: character\(**7 s
680: integer b(3)
681: . . .
682: call sam(f, b(2), s)
683: .P2
684: is equivalent to that in
685: .P1
686: int f();
687: char s[7];
688: long int b[3];
689: . . .
690: sam_(f, &b[1], s, 7L);
691: .P2
692: Note that the first element of a C array always has subscript zero,
693: but Fortran arrays begin at 1 by default.
694: Fortran arrays are stored in column-major order, C arrays are stored in row-major order.
695: .NH 1
696: File Formats
697: .NH 2
698: Structure of Fortran Files
699: .PP
700: Fortran requires four kinds of external files:
701: sequential formatted and unformatted,
702: and direct formatted and unformatted.
703: On
704: .UX
705: systems,
706: these are all implemented as ordinary files
707: which are assumed to have the proper
708: internal structure.
709: .PP
710: Fortran I/O is based on ``records''.
711: When a direct file is opened in a Fortran program,
712: the record length of the records must be given,
713: and this is used by the Fortran I/O system to
714: make the file look as if it is made up of records
715: of the given length.
716: In the special case that the record length is given
717: as 1,
718: the files are not considered to be divided into records,
719: but are treated as byte-addressable byte strings;
720: that is,
721: as ordinary
722: .UX
723: file system files.
724: (A read or write request on such a file keeps consuming bytes until
725: satisfied, rather than being restricted to a single record.)
726: .PP
727: The peculiar requirements on sequential unformatted files
728: make it unlikely that they will ever be read or written by any means except Fortran I/O statements.
729: Each record is preceded and followed by
730: an integer containing the record's length in bytes.
731: .PP
732: The Fortran I/O system breaks sequential formatted files
733: into records while reading by using each newline
734: as a record separator.
735: The result of reading off the end of a record is undefined according to the Standard.
736: The I/O system is permissive and
737: treats the record as being extended by blanks.
738: On output,
739: the I/O system will write a newline at the end of each
740: record.
741: It is also possible for programs to write newlines
742: for themselves.
743: This is an error,
744: but the only effect will be that the single record
745: the user thought he wrote will be treated as
746: more than one record when being read or
747: backspaced over.
748: .NH 2
749: Portability Considerations
750: .PP
751: The Fortran I/O system uses only the facilities of the
752: standard C I/O library,
753: a widely available and fairly portable package,
754: with the following exceptions.
755: The I/O system needs to know whether a file
756: can be used for direct I/O,
757: and whether or not it is possible to backspace.
758: Both of these facilities are implemented
759: using the
760: .I fseek
761: routine,
762: so there is a routine
763: .I canseek
764: which determines if
765: .I fseek
766: will have the desired effect.
767: Combinations of the
768: \f(CWbackspace\fR, \f(CWwrite\fR, \f(CWendfile\fR, and
769: .CW close
770: statements may require that a file be shortened.
771: For efficiency, the \fIcopy\fR routine
772: that does this job uses the
773: .UX
774: system calls \fIcreat\fR, \fIread\fR, \fIwrite\fR, and \fIclose\fR.
775: Finally, to open write-only files, the I/O system must resort to the
776: \fIcreat\fR and \fIopen\fR system calls.
777: .NH 2
778: Pre-Connected Files and File Positions
779: .PP
780: Units 5, 6, and 0 are preconnected when the program starts.
781: Unit 5 is connected to the standard input,
782: unit 6 is connected to the standard output,
783: and unit 0 is connected to the standard error unit.
784: All are connected for sequential formatted I/O.
785: .PP
786: All the other units are also preconnected when execution
787: begins.
788: Unit
789: .I n
790: is connected to a file named \f(CWfort.\fIn\fR.
791: These files need not exist,
792: nor will they be created unless their units are used
793: without first executing an
794: .CW open .
795: The default connection is for sequential formatted I/O.
796: .PP
797: The Standard does not specify where a file which has been explicitly \f(CWopen\fRed
798: for sequential I/O is initially positioned.
799: Following common practice, the I/O system positions the file
800: at its beginning (and has done so for several years).
801: Originally it attempted to position the file
802: at the end, but this was a frequent source of confusion, and it
803: limited portability.
804: . \"In fact,
805: . \"the I/O system attempts to position the file at the end,
806: . \"so a
807: . \".B write
808: . \"will append to the file and a
809: . \".B read
810: . \"will result in an end-of-file indication.
811: . \"To position a file to its beginning,
812: . \"use a
813: . \".B rewind
814: . \"statement.
815: The preconnected units
816: 0, 5, and 6 are positioned as they come
817: from the program's parent process.
818: .NH
819: References
820: .LP
821: |reference_placement
822: .NH
823: Appendix. Differences Between Fortran 66 and Fortran 77
824: .PP
825: The following is a very brief description of the differences
826: between the 1966 and the 1977 Standard languages.
827: We assume that the reader is familiar with Fortran 66.
828: We do not pretend to be complete, precise,
829: or unbiased,
830: but plan to describe what we feel are the most important aspects of the new language.
831: .NH 0
832: Features Deleted from Fortran 66
833: .NH 2
834: Hollerith
835: .PP
836: All notions of ``Hollerith''
837: (\fIn\|\f(CWh\fR)
838: as data
839: have been officially removed, although our compiler, like almost all in the foreseeable future,
840: will continue to support this archaism.
841: .NH 2
842: Extended Range
843: .PP
844: In Fortran 66, under a set of very restrictive and rarely understood conditions, it is permissible
845: to jump out of the range of a
846: .CW do
847: loop, then jump back into it.
848: Extended range has been removed in the Fortran 77 language.
849: The restrictions are so special, and the implementation of extended range is so unreliable in many compilers,
850: that this change really counts as no loss.
851: .NH 1
852: Program Form
853: .NH 2
854: Blank Lines
855: .PP
856: Completely blank lines are now legal comment lines.
857: .NH 2
858: Program and Block Data Statements
859: .PP
860: A main program may now begin with a statement that gives that program an external name:
861: .P1
862: program work
863: .P2
864: Block data procedures may also have names.
865: .P1
866: block data stuff
867: .P2
868: There is now a rule that only
869: .I one
870: unnamed
871: block data procedure may appear in a program.
872: (This rule is not enforced by our system.)
873: The Standard does not specify the effect of the program and block data names,
874: but they are clearly intended to aid conventional loaders.
875: .NH 2
876: ENTRY Statement
877: .PP
878: Multiple entry points are now legal.
879: Subroutine and function subprograms may have additional entry points,
880: declared by an
881: .CW entry
882: statement with an optional argument list.
883: .P1
884: entry extra(a, b, c)
885: .P2
886: Execution begins at the first statement following the
887: .CW entry
888: line.
889: All variable declarations must precede all executable statements in the procedure.
890: If the procedure begins with a
891: .CW subroutine
892: statement,
893: all entry points are subroutine names.
894: If it begins with a
895: .CW function
896: statement, each entry is a function entry point,
897: with type determined by the type declared for the entry name.
898: If any entry is a character-valued function,
899: then all entries must be.
900: In a function, an entry name of the same type as that where control entered
901: must be assigned a value.
902: Arguments do not retain their values between calls.
903: (The ancient trick of calling one entry point with a large number of arguments
904: to cause the procedure to ``remember'' the locations of those arguments,
905: then invoking an entry with just a few arguments for later calculation,
906: is still illegal.
907: Furthermore, the trick doesn't work in our implementation,
908: since arguments are not kept in static storage.)
909: .NH 2
910: \f(CWdo\fP Loops
911: .PP
912: .CW do
913: variables and range parameters may now be of integer, real, or double precision types.
914: (The use of floating point
915: .CW do
916: variables is very dangerous
917: because of the possibility of unexpected roundoff,
918: and we strongly recommend against their use).
919: The action of the
920: .CW do
921: statement is now defined for all values of the
922: .CW do
923: parameters.
924: The statement
925: .P1
926: do 10 i = l, u, d
927: .P2
928: performs one iteration if $l ~=~ u$ and
929: $ max (0^,^ left floor ( u - l ) / d^ right floor )$
930: iterations otherwise.
931: The
932: .CW do
933: variable has a predictable value when exiting a loop:
934: the value at the time a
935: .CW goto
936: or
937: .CW return
938: terminates the loop;
939: otherwise
940: the value that failed the limit test.
941: .NH 2
942: Alternate Returns
943: .PP
944: In a
945: .CW subroutine
946: or subroutine
947: .CW entry
948: statement,
949: some of the arguments may be noted by an asterisk, as in
950: .P1
951: subroutine s(a, \(**, b, \(**)
952: .P2
953: The meaning of the ``alternate returns'' is described in section 5.2 of the Appendix.
954: .NH 1
955: Declarations
956: .NH 2
957: \f(CWcharacter\fP Data Type
958: .PP
959: One of the biggest improvements to the language is the addition of a character-string data type.
960: Local and
961: common character variables must have a length denoted by a constant expression:
962: .P1
963: character\(**17 a, b(3,4)
964: character\(**(6+3) c
965: .P2
966: If the length is omitted entirely, it is assumed equal to 1.
967: A character string argument may have a constant length,
968: or the length may be declared to be the same as that of the corresponding actual argument at run time
969: by a statement like
970: .P1
971: character\(**(\(**) a
972: .P2
973: (There is an intrinsic function
974: .CW len
975: that returns the actual length of a character string).
976: Character arrays and common blocks containing character variables must be packed:
977: in an array of character variables, the first character of one element must follow the last character of
978: the preceding element, without holes.
979: .NH 2
980: \f(CWimplicit\fP Statement
981: .PP
982: The traditional implied declaration rules still hold:
983: a variable whose name begins with one of
984: .CW ijklmn
985: is of type
986: .CW integer .
987: Other variables are of type
988: .CW real
989: unless otherwise declared.
990: This general rule may be overridden with an
991: .CW implicit
992: statement:
993: .P1 0
994: implicit real(a-c,g), complex(w-z)
995: implicit character*(17) (s)
996: .P2
997: declares that variables whose name begins with one of
998: .CW abcg
999: are
1000: .CW real ;
1001: those beginning with
1002: .CW wxyz
1003: are assumed
1004: .CW complex ,
1005: and so on.
1006: It is still poor practice to depend on implicit typing,
1007: but this statement is an industry standard.
1008: .NH 2
1009: \f(CWparameter\fP Statement
1010: .PP
1011: It is now possible to give a constant a symbolic name, as in
1012: .P1 0
1013: parameter (pi=3.1415d0,y=pi/3,s='hello')
1014: .P2
1015: The type of each parameter name is governed by the same implicit and explicit rules as for a variable.
1016: The right side of each equal sign must be a constant expression
1017: (an expression made up of constants, operators, and already defined parameters).
1018: .NH 2
1019: Array Declarations
1020: .PP
1021: Arrays may now have as many as seven dimensions.
1022: (Only three were permitted in 1966).
1023: The lower bound of each dimension may be declared
1024: to be other than 1 by
1025: using a colon.
1026: Furthermore, an adjustable array bound may be an integer expression involving constants,
1027: arguments, and variables in
1028: .CW common .
1029: .P1 0
1030: real a(-5:3, 7, m:n), b(n+1:2\(**n)
1031: .P2
1032: The upper bound on the last dimension of an array argument may be denoted by an asterisk
1033: to indicate that the upper bound is not specified:
1034: .P1 0
1035: integer a(5, \(**), b(\(**), c(0:1, -2:\(**)
1036: .P2
1037: .NH 2
1038: \f(CWsave\fP Statement
1039: .PP
1040: A poorly known rule of Fortran 66 is that local variables in a procedure do not necessarily retain their values between
1041: invocations of that procedure.
1042: At any instant in the execution of a program,
1043: if a common block is declared neither in the currently executing procedure
1044: nor in any of the procedures in the chain of callers,
1045: all of the variables in that common block also become undefined.
1046: (The only exceptions are variables that have been defined in a
1047: .CW data
1048: statement and never changed).
1049: These rules permit overlay and stack implementations for the affected variables.
1050: Fortran 77 permits one to specify that certain variables and common blocks are to retain their
1051: values between invocations.
1052: The declaration
1053: .P1
1054: save a, /b/, c
1055: .P2
1056: leaves the values of the variables
1057: .CW a
1058: and
1059: .CW c
1060: and all of the contents of common block
1061: .CW b
1062: unaffected by a return.
1063: The simple declaration
1064: .P1
1065: save
1066: .P2
1067: has this effect on all variables and common blocks in the procedure.
1068: A common block must be
1069: .CW save d
1070: in every procedure in which it is declared if the desired effect is to occur.
1071: .NH 2
1072: \f(CWintrinsic\fP Statement
1073: .PP
1074: All of the functions specified in the Standard
1075: are in the single category ``intrinsic functions'',
1076: rather than being divided into ``intrinsic'' and ``basic external'' functions.
1077: If an intrinsic function is to be passed to another procedure, it must be declared
1078: .CW intrinsic .
1079: Declaring it
1080: .CW external
1081: (as in Fortran 66) causes a function other than the built-in one to be passed.
1082: .NH 1
1083: Expressions
1084: .NH 2
1085: Character Constants
1086: .PP
1087: Character string constants are marked by strings surrounded by apostrophes.
1088: If an apostrophe is to be included in a constant, it is repeated:
1089: .P1
1090: 'abc'
1091: 'ain''t'
1092: .P2
1093: There are no null (zero-length) character strings in Fortran 77.
1094: Our compiler has two different quotation marks,
1095: .CW '
1096: and
1097: .CW \" .
1098: (See Section 2.9 in the main text.)
1099: .NH 2
1100: Concatenation
1101: .PP
1102: One new operator has been added, character string concatenation, marked by a double slash
1103: .CW // .
1104: The result of a concatenation is the string containing the characters of the left operand followed by the characters of
1105: the right operand.
1106: The strings
1107: .P1
1108: 'ab' // 'cd'
1109: 'abcd'
1110: .P2
1111: are equal.
1112: The strings being concatenated must be of constant length in all concatenations
1113: that are not the right sides of assignments.
1114: (The only concatenation expressions in which a
1115: character string declared adjustable with a
1116: .CW *(*)
1117: modifier
1118: or a substring denotation with nonconstant position values may appear
1119: are the right sides of assignments).
1120: .NH 2
1121: Character String Assignment
1122: .PP
1123: The left and right sides of a character assignment may not share storage.
1124: (The assumed implementation of character assignment is to copy characters from the right to the left side.)
1125: If the left side is longer than the right, it is padded with blanks.
1126: If the left side is shorter than the right, trailing characters are discarded.
1127: .NH 2
1128: Substrings
1129: .PP
1130: It is possible to extract a substring of a character variable or character array element, using the colon notation:
1131: .P1
1132: a(i,\|j) (m:n)
1133: .P2
1134: is the string of $(n-m+1)$ characters beginning at the
1135: $m sup th$ character of the character array element $a sub ij$.
1136: Results are undefined unless $m<=n$.
1137: Substrings may be used on the left sides of assignments and as procedure actual arguments.
1138: .NH 2
1139: Exponentiation
1140: .PP
1141: It is now permissible to raise real quantities to complex powers,
1142: or complex quantities to real or complex powers.
1143: (The principal part of the logarithm is used).
1144: Also, multiple exponentiation is now defined:
1145: .P1
1146: a\(**\(**b\(**\(**c = a \(**\(** (b\(**\(**c)
1147: .P2
1148: .NH 2
1149: Relaxation of Restrictions
1150: .PP
1151: Mixed mode expressions are now permitted.
1152: (For instance,
1153: it is permissible to combine integer and complex quantities in an expression.)
1154: .PP
1155: Constant expressions are permitted where a constant is allowed,
1156: except in
1157: .CW data
1158: statements.
1159: (A constant expression is made up of explicit constants and
1160: .CW parameter s
1161: and the Fortran operators,
1162: except for exponentiation to a floating-point power).
1163: An adjustable dimension may now be an integer expression involving constants,
1164: arguments, and variables in
1165: .CW common .
1166: .PP
1167: Subscripts may now be general integer expressions;
1168: the old
1169: $c v +- c'$
1170: rules have been removed.
1171: .CW do
1172: loop bounds may be general integer, real, or double precision expressions.
1173: Computed
1174: .CW goto
1175: expressions and I/O unit numbers may be general integer expressions.
1176: .NH 1
1177: Executable Statements
1178: .NH 2
1179: Block If
1180: .PP
1181: At last, an
1182: if-then-else
1183: branching structure (``Block If'') has been added to Fortran.
1184: A Block If begins with a statement of the form
1185: .P1
1186: if ( . . . ) then
1187: .P2
1188: and ends with an
1189: .P1
1190: end if
1191: .P2
1192: statement.
1193: Two other new statements may appear in a Block If.
1194: There may be several
1195: .P1
1196: else if(. . .) then
1197: .P2
1198: statements,
1199: followed by at most one
1200: .P1
1201: else
1202: .P2
1203: statement.
1204: If the logical expression in the Block If statement is true,
1205: the statements following it up to the
1206: next
1207: .CW elseif ,
1208: .CW else ,
1209: or
1210: .CW endif
1211: are executed.
1212: Otherwise, the next
1213: .CW elseif
1214: statement in the group is executed.
1215: If none of the
1216: .CW elseif
1217: conditions are true, control passes to the statements following the
1218: .CW else
1219: statement, if any.
1220: (The
1221: .CW else
1222: must follow all
1223: .CW elseif s
1224: in a Block If.
1225: Of course, there may be Block Ifs embedded inside of other Block If structures).
1226: A case construct may be rendered
1227: .P1
1228: if (s .eq. 'ab') then
1229: . . .
1230: else if (s .eq. 'cd') then
1231: . . .
1232: else
1233: . . .
1234: end if
1235: .P2
1236: .NH 2
1237: Alternate Returns
1238: .PP
1239: Some of the arguments of a subroutine call may be statement labels preceded by an asterisk, as in
1240: .P1
1241: call joe(j, \(**10, m, \(**2)
1242: .P2
1243: A
1244: .CW return
1245: statement may have an integer expression, such as
1246: .P1
1247: return k
1248: .P2
1249: If the entry point has
1250: $n$
1251: alternate return (asterisk) arguments
1252: and if $1<=k<=n$, the return is followed by a branch to the corresponding statement label;
1253: otherwise the usual return to the statement following the
1254: .CW call
1255: is executed.
1256: .NH 1
1257: Input/Output
1258: .NH 2
1259: Format Variables
1260: .PP
1261: A format may be the value of a character expression (constant or otherwise),
1262: or be stored in a character array, as in
1263: .P1
1264: write(6, '(i5)') x
1265: .P2
1266: .NH 2
1267: \f(CWend=\fP, \f(CWerr=\fP, and \f(CWiostat=\fP Clauses
1268: .PP
1269: A
1270: .CW read
1271: or
1272: .CW write
1273: statement may contain
1274: .CW end= ,
1275: .CW err= ,
1276: and
1277: .CW iostat=
1278: clauses, as in
1279: .P1 0
1280: write(6, 101, err=20, iostat=a(4))
1281: read(5, 101, err=20, end=30, iostat=x)
1282: .P2
1283: Here 5 and 6 are the
1284: .I unit s
1285: on which the I/O is done,
1286: 101 is the statement number of the associated format,
1287: 20 and 30 are statement numbers,
1288: and
1289: .CW a
1290: and
1291: .CW x
1292: are integers.
1293: If an error occurs during I/O,
1294: control returns to the program at statement 20.
1295: If the end of the file is reached,
1296: control returns to the program at statement 30.
1297: In any case, the variable referred to in
1298: the
1299: .CW iostat=
1300: clause is given a value when
1301: the I/O statement finishes.
1302: (Yes, the value is assigned to the name on the right side of the equal sign.)
1303: This value is zero if all went well,
1304: negative for end of file,
1305: and some positive value for errors.
1306: .NH 2
1307: Formatted I/O
1308: .NH 3
1309: Character Constants
1310: .PP
1311: Character constants in formats are copied literally to the output.
1312: Character constants cannot be read into.
1313: .P1 0
1314: write(6,'(i2,'' isn''''t '',i1)') 7, 4
1315: .P2
1316: produces
1317: .P1
1318: 7 isn't 4
1319: .P2
1320: Here the format is the character constant
1321: .P1
1322: (i2,' isn''t ',i1)
1323: .P2
1324: and the character constant
1325: .P1
1326: isn't
1327: .P2
1328: is copied into the output.
1329: .NH 3
1330: Positional Editing Codes
1331: .PP
1332: .CW t ,
1333: .CW tl ,
1334: .CW tr ,
1335: and
1336: .CW x
1337: codes
1338: control where the
1339: next character is in the record.
1340: .CW tr\fIn
1341: or \fIn\f(CWx\fR
1342: specifies that the next character is
1343: $n$ to the right of the current position.
1344: .CW tl\fIn
1345: specifies that the next character is
1346: $n$ to the left of the current position,
1347: allowing parts of the record to be reconsidered.
1348: .CW t\fIn
1349: says that the next character is to be character
1350: number $n$ in the record.
1351: (See section 3.2 in the main text.)
1352: .NH 3
1353: Colon
1354: .PP
1355: A colon in the format terminates the I/O operation
1356: if there are no more data items in the I/O list,
1357: otherwise it has no effect.
1358: In the fragment
1359: .P1
1360: x='("hello", :, " there", i4)'
1361: write(6, x) 12
1362: write(6, x)
1363: .P2
1364: the first
1365: .CW write
1366: statement prints
1367: .CW "hello there 12" ,
1368: while the second only prints
1369: .CW hello .
1370: .NH 3
1371: Optional Plus Signs
1372: .PP
1373: According to the Standard,
1374: each implementation has the option of putting
1375: plus signs in front of non-negative
1376: numeric output.
1377: The
1378: .CW sp
1379: format code may be used to make the optional plus
1380: signs actually appear for all subsequent items
1381: while the format is active.
1382: The
1383: .CW ss
1384: format code guarantees that the I/O system will not
1385: insert the optional plus signs,
1386: and the
1387: .CW s
1388: format code restores the default behavior of
1389: the I/O system.
1390: (Since we never put out optional plus signs,
1391: .CW ss
1392: and
1393: .CW s
1394: codes have the same effect in our implementation.)
1395: .NH 3
1396: Blanks on Input
1397: .PP
1398: Blanks in numeric input fields,
1399: other than leading blanks
1400: will be ignored following a
1401: .CW bn
1402: code in a format
1403: statement,
1404: and will be treated as zeros following a
1405: .CW bz
1406: code in a format statement.
1407: The default for a unit may be changed by using
1408: the
1409: .CW open
1410: statement.
1411: (Blanks are ignored by default.)
1412: .NH 3
1413: Unrepresentable Values
1414: .PP
1415: The Standard requires that if a numeric item
1416: cannot be represented in the form required by a format code,
1417: the output field must be filled with asterisks.
1418: (We think this should have been an option.)
1419: .NH 3
1420: \f(CWI\fIw.m\fR Format
1421: .PP
1422: There is a new integer output code
1423: .CW i\fIw.m
1424: which is the same as
1425: .CW i\fIw ,
1426: except that there will be at least $m$
1427: digits in the output field,
1428: including,
1429: if necessary,
1430: leading zeros.
1431: The case
1432: .CW i\fIw\fP.0
1433: is special,
1434: in that if the value being printed is 0,
1435: the output field is
1436: entirely blank.
1437: .CW i\fIw\fP.1
1438: is the same as
1439: .CW i\fIw .
1440: .NH 3
1441: Floating Point
1442: .PP
1443: On input, exponents may start with one of
1444: .CW EeDd .
1445: All have the same meaning.
1446: On output we always use
1447: .CW E .
1448: The
1449: .CW e
1450: and
1451: .CW d
1452: format codes also have identical meanings.
1453: A leading zero before the decimal point in
1454: .CW e
1455: output
1456: without a scale factor is optional with the
1457: implementation.
1458: (We do not print it.)
1459: There is a
1460: .CW g\fIw.d
1461: format code which is the same as
1462: .CW e\fIw.d
1463: and
1464: .CW f\fIw.d
1465: on input,
1466: but which chooses
1467: .CW f
1468: or
1469: .CW e
1470: formats for output depending
1471: on the size of the number and of $d$.
1472: .NH 3
1473: \f(CWa\fP Format
1474: .PP
1475: A codes are used for character values.
1476: .CW a\fIw
1477: use a field width of $w$,
1478: while a plain
1479: .CW a
1480: uses the length of the character item.
1481: .NH 2
1482: Standard Units
1483: .PP
1484: There are default formatted input and output units.
1485: The statement
1486: .P1
1487: read 10, a, b
1488: .P2
1489: reads from the standard unit using format statement 10.
1490: The default unit may be explicitly specified by an asterisk, as in
1491: .P1
1492: read(*, 10) a,b
1493: .P2
1494: Similarly, the standard output units is specified by a
1495: .CW print
1496: statement or an asterisk unit:
1497: .P1
1498: print 10
1499: write(*, 10)
1500: .P2
1501: .NH 2
1502: List-Directed Formatting
1503: .PP
1504: List-directed I/O is a
1505: kind of free form input for sequential I/O.
1506: It is invoked by using an asterisk as the
1507: format identifier, as in
1508: .P1
1509: read(6, *) a,b,c
1510: .P2
1511: .PP
1512: On input,
1513: values are separated by strings of blanks
1514: and possibly a comma.
1515: Values,
1516: except for character strings,
1517: cannot contain blanks.
1518: End of record counts as a blank,
1519: except in character strings,
1520: where it is ignored.
1521: Complex constants are given as two real constants
1522: separated by a comma and enclosed in parentheses.
1523: A null input field,
1524: such as between two consecutive commas,
1525: means the corresponding variable in the
1526: I/O list is not changed.
1527: Values may be preceded by repetition counts,
1528: as in
1529: .P1
1530: 4*(3.,2.) 2*, 4*'hello'
1531: .P2
1532: which stands for 4 complex constants, 2 null values,
1533: and 4 string constants.
1534: .PP
1535: For output, suitable formats are chosen for
1536: each item.
1537: The values of character strings are printed;
1538: they are not enclosed in quotes, so they cannot be read back
1539: using list-directed input.
1540: .NH 2
1541: Direct I/O
1542: .PP
1543: A file connected for direct access consists of
1544: a set of equal-sized records each of which is
1545: uniquely identified by a positive integer.
1546: The records may be written or read in any order,
1547: using direct access I/O statements.
1548: .PP
1549: Direct access
1550: .CW read
1551: and
1552: .CW write
1553: statements
1554: have an extra argument,
1555: .CW rec=,
1556: which gives the record number to be read or written.
1557: .P1 0
1558: read(2, rec=13, err=20) (a(i), i=1, 203)
1559: .P2
1560: reads the thirteenth record into the array
1561: .CW a.
1562: .PP
1563: The size of the records must be given by an
1564: .CW open
1565: statement
1566: (see below).
1567: Direct access files may be connected for either formatted
1568: or unformatted I/O.
1569: .NH 2
1570: Internal Files
1571: .PP
1572: Internal files are character string objects,
1573: such as variables or substrings,
1574: or arrays of type character.
1575: In the former cases there is only a single record
1576: in the file,
1577: in the latter case each array element is a record.
1578: The Standard includes only sequential
1579: formatted I/O on internal files.
1580: (I/O is not a very precise term to use here,
1581: but internal files are dealt with using
1582: .CW read
1583: and
1584: .CW write ).
1585: There is no list-directed I/O on internal files.
1586: Internal files are used by giving the name of the
1587: character object in place of the unit number, as in
1588: .P1
1589: character\(**80 x
1590: read(5,"(a)") x
1591: read(x,"(i3,i4)") n1,n2
1592: .P2
1593: which reads a card image into
1594: .CW x
1595: and then reads
1596: two integers from the front of it.
1597: A sequential
1598: .CW read
1599: or
1600: .CW write
1601: always starts at the beginning
1602: of an internal file.
1603: .PP
1604: (We also support a compatible extension, direct I/O on internal files.
1605: This is like direct I/O on external files,
1606: except that the number of records in the file cannot be
1607: changed.)
1608: .NH 2
1609: File Control Statements
1610: .PP
1611: These statements are used to connect and disconnect
1612: units and files,
1613: and to gather information about units and files.
1614: .NH 3
1615: \f(CWopen\fP Statement
1616: .PP
1617: The
1618: .CW open
1619: statement is used to connect a file with a
1620: unit,
1621: or to alter some properties of the connection.
1622: The following is a minimal example.
1623: .P1
1624: open(1, file='fort.junk')
1625: .P2
1626: .CW open
1627: takes a variety of arguments with meanings described below.
1628: .RS
1629: . \" macros here
1630: .EQ
1631: delim off
1632: .EN
1633: .de HP
1634: .RT
1635: .if !\\(IP .nr IP +1
1636: .sp \\n(PDu
1637: .ne 3v
1638: .in +\\n(PIu
1639: .ti -\\n(PIu
1640: \f(CW\\$1\fR\ \c
1641: ..
1642: .de TH
1643: .RT
1644: .sp \\n(PDu
1645: .ne 3v
1646: \f(CW\\$1\\$2\\$3\\$4\\$5\\$6\fR\ \c
1647: ..
1648: . \" end of macros
1649: .EQ
1650: delim $$
1651: .EN
1652: .HP unit=
1653: a small non-negative integer which is the unit to
1654: which the file is to be connected.
1655: We allow,
1656: at the time of this writing,
1657: 0 through 99.
1658: If this parameter is the first one in the
1659: .CW open
1660: statement,
1661: the
1662: .CW unit=
1663: can be omitted.
1664: .HP iostat=
1665: is the same as in
1666: .CW read
1667: or
1668: .CW write.
1669: .HP err=
1670: is the same as in
1671: .CW read
1672: or
1673: .CW write.
1674: .HP file=
1675: a character expression,
1676: which when stripped of trailing blanks,
1677: is the name of the file to be connected to the unit.
1678: The filename should not be given if the
1679: .CW status='scratch' .
1680: .HP status=
1681: one of
1682: .CW 'old' ,
1683: .CW 'new' ,
1684: .CW 'scratch' ,
1685: or
1686: .CW 'unknown' .
1687: If this parameter is not given,
1688: .CW 'unknown'
1689: is assumed.
1690: If
1691: .CW 'scratch'
1692: is given,
1693: a temporary file will be created.
1694: Temporary files are destroyed at the end of execution.
1695: If
1696: .CW 'new'
1697: is given,
1698: the file will be created if it doesn't exist,
1699: or truncated if it does.
1700: The meaning of
1701: .CW 'unknown'
1702: is processor dependent;
1703: our system complains if an
1704: .CW 'old'
1705: file does not exist,
1706: and creates a nonexistent file
1707: if it is
1708: .CW 'unknown' .
1709: .HP access=
1710: .CW 'sequential'
1711: or
1712: .CW 'direct' ,
1713: depending on whether the file is
1714: to be opened for sequential or direct I/O.
1715: .HP form=
1716: .CW 'formatted'
1717: or
1718: .CW 'unformatted' .
1719: .HP recl=
1720: a positive integer specifying the record length of
1721: the direct access file being opened.
1722: We measure all record lengths in bytes.
1723: On
1724: .UX
1725: systems a record length of 1 has the special meaning explained
1726: in section 5.1 of the text.
1727: .HP blank=
1728: .CW 'null'
1729: or
1730: .CW 'zero' .
1731: This parameter has meaning only for formatted I/O.
1732: The default value is
1733: .CW 'null' .
1734: .CW 'zero'
1735: means that blanks,
1736: other than leading blanks,
1737: in numeric input fields are to be treated as zeros.
1738: .RE
1739: .PP
1740: Opening a new file on a unit which is already connected
1741: has the effect of first closing the old file.
1742: .NH 3
1743: \f(CWclose\fP Statement
1744: .PP
1745: .CW close
1746: severs the connection between a unit and a file.
1747: The unit number must be given.
1748: The optional parameters are
1749: .CW iostat=
1750: and
1751: .CW err=
1752: with
1753: their usual meanings,
1754: and
1755: .CW status=
1756: either
1757: .CW 'keep'
1758: or
1759: .CW 'delete' .
1760: Scratch files cannot be kept,
1761: otherwise
1762: .CW 'keep'
1763: is the default.
1764: .CW 'delete'
1765: means the file will be removed.
1766: A simple example is
1767: .P1
1768: close(3, err=17)
1769: .P2
1770: .NH 3
1771: \f(CWinquire\fP Statement
1772: .PP
1773: The
1774: .CW inquire
1775: statement gives information about
1776: a unit
1777: (``inquire by unit'')
1778: or a file (``inquire by file'').
1779: Simple examples are:
1780: .P1 0
1781: inquire(unit=3, namexx)
1782: inquire(file='junk', number=n, exist=l)
1783: .P2
1784: .RS
1785: .HP file=
1786: a character variable specifies the file the
1787: .CW inquire
1788: is about.
1789: Trailing blanks in the file name are ignored.
1790: .HP unit=
1791: an integer variable specifies the unit the
1792: .CW inquire
1793: is about.
1794: Exactly one of
1795: .CW file=
1796: or
1797: .CW unit=
1798: must be used.
1799: .HP "iostat=, err="
1800: are as before.
1801: .HP exist=
1802: a logical variable.
1803: The logical variable is set to
1804: .CW ".true."
1805: if the file or unit
1806: exists and is set to
1807: .CW ".false."
1808: otherwise.
1809: .HP opened=
1810: a logical variable.
1811: The logical variable is set to
1812: .CW ".true."
1813: if the file
1814: is connected to a unit or if the unit is connected
1815: to a file,
1816: and it is set to
1817: .CW ".false."
1818: otherwise.
1819: .HP number=
1820: an integer variable to which is assigned the
1821: number of the unit connected to the file,
1822: if any.
1823: .HP named=
1824: a logical variable to which is assigned
1825: .CW ".true."
1826: if the file has a name, or
1827: .CW ".false."
1828: otherwise.
1829: .HP name=
1830: a character variable to which is assigned the name
1831: of the file (inquire by file) or, if known, the name of the
1832: file connected to the unit (inquire by unit).
1833: .HP access=
1834: a character variable to which will be assigned
1835: the value
1836: .CW 'sequential'
1837: if the connection is for
1838: sequential I/O,
1839: .CW 'direct'
1840: if the connection is for direct I/O.
1841: The value becomes undefined if there is no connection.
1842: .HP sequential=
1843: a character variable to which is assigned the
1844: value
1845: .CW 'yes'
1846: if the file could be connected for
1847: sequential I/O,
1848: .CW 'no'
1849: if the file could not be connected for sequential I/O,
1850: and
1851: .CW 'unknown'
1852: if we can't tell.
1853: .HP direct=
1854: a character variable to which is assigned the value
1855: .CW 'yes'
1856: if the file could be connected for direct I/O,
1857: .CW'no'
1858: if the file could not be connected for direct
1859: I/O,
1860: and
1861: .CW 'unknown'
1862: if we can't tell.
1863: .HP form=
1864: a character variable to which is assigned the value
1865: .CW 'formatted'
1866: if the file is connected for formatted I/O,
1867: or
1868: .CW 'unformatted'
1869: if the file is connected for unformatted
1870: I/O.
1871: .HP formatted=
1872: a character variable to which is assigned the value
1873: .CW 'yes'
1874: if the file could be connected for formatted I/O,
1875: .CW 'no'
1876: if the file could not be connected for formatted I/O,
1877: and
1878: .CW 'unknown'
1879: if we can't tell.
1880: .HP unformatted=
1881: a character variable to which is assigned the value
1882: .CW 'yes'
1883: if
1884: the file could be connected for unformatted I/O,
1885: .CW 'no'
1886: if the file could not be connected for unformatted I/O,
1887: and
1888: .CW 'unknown'
1889: if we can't tell.
1890: .HP recl=
1891: an integer variable to which is assigned the record length
1892: of the records in the file if the file is connected
1893: for direct access.
1894: .HP nextrec=
1895: an integer variable to which is assigned one more
1896: than the number of the last record read from a file connected
1897: for direct access.
1898: .HP blank=
1899: a character variable to which is assigned the value
1900: .CW 'null'
1901: if null blank control is in effect for the file
1902: connected for formatted I/O,
1903: .CW 'zero'
1904: if blanks are being converted to zeros and
1905: the file is connected for formatted I/O.
1906: .RE
1907: .PP
1908: The gentle reader
1909: will remember that the people who wrote the standard
1910: probably weren't thinking of his needs.
1911: Here is an example.
1912: The declarations are omitted.
1913: .P1
1914: open(1, file="/dev/console")
1915: .P2
1916: On a
1917: .UX
1918: system this statement opens the console for formatted sequential
1919: I/O.
1920: An
1921: .CW inquire
1922: statement for either unit 1 or file
1923: .CW "/dev/console"
1924: would reveal that the file exists, is connected to unit 1,
1925: has a name, namely
1926: .CW "/dev/console" ,
1927: is opened for sequential I/O,
1928: could be connected for sequential I/O,
1929: could not be connected for direct I/O (can't seek),
1930: is connected for formatted I/O,
1931: could be connected for formatted I/O,
1932: could not be connected for unformatted I/O
1933: (can't seek),
1934: has neither a record length nor a next record number,
1935: and is ignoring blanks in numeric fields.
1936: .PP
1937: In the
1938: .UX
1939: system environment,
1940: the only way to discover what permissions you have
1941: for a file is to open it and try to read and write it.
1942: The
1943: .CW err=
1944: parameter will return system error numbers.
1945: The
1946: .CW inquire
1947: statement does not give a way of determining permissions.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.