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