assume

assume none

Disables all the assume options.

assume bscc

Tells the compiler to treat the backslash character (\) as a C-style control (escape) character syntax in character literals. The "bscc" keyword means "BackSlashControlCharacters."

assume buffered_io

Tells the compiler to accumulate records in a buffer. This sets the default for opening sequential files to BUFFERED='YES', which also occurs if the FORT_BUFFERED run-time environment variable is specified.

When this option is specified, the internal buffer is filled, possibly by many record input statements (READ) or output statements (WRITE), before it is read from disk, or written to disk, by the Fortran run-time system. If a file is opened for direct access, I/O buffering is ignored.

Using buffered reads and writes usually makes disk I/O more efficient by handling larger blocks of data on disk less often. However, if you request buffered writes, records not yet written to disk may be lost in the event of a system failure.

The OPEN statement BUFFERED specifier applies to a specific logical unit. In contrast, the assume [no]buffered_io option and the FORT_BUFFERED environment variable apply to all Fortran units.

assume buffered_stdout

Tells the Fortran run-time system to accumulate data for the standard output device in a buffer. When the buffer is full or the user executes a FLUSH on OUTPUT_UNIT in intrinsic module ISO_FORTRAN_ENV, the data is displayed on the standard output unit.

Using buffered writes may be a more efficient in time and space but use assume nobuffered_stdout if you want data displayed immediately on the standard output device, like for an input prompt.

assume [no]buffered_stdout does not affect and is not affected by assume [no]buffered_io.

After compiling with this option, the default blocksize for stdout is 8 KB.

assume byterecl

Specifies that the units for the OPEN statement RECL specifier (record length) value are in bytes for unformatted data files, not longwords (four-byte units). For formatted files, the RECL value is always in bytes.

If a file is open for unformatted data and assume byterecl is specified, INQUIRE returns RECL in bytes; otherwise, it returns RECL in longwords. An INQUIRE returns RECL in bytes if the unit is not open.

assume cc_omp

Enables conditional compilation as defined by the OpenMP Fortran API. That is, when "!$space" appears in free-form source or "c$spaces" appears in column 1 of fixed-form source, the rest of the line is accepted as a Fortran line.

assume dummy_aliases

Tells the compiler that dummy (formal) arguments to procedures share memory locations with other dummy arguments (aliases) or with variables shared through use association, host association, or common block use.

Specify the option when you compile the called subprogram. The program semantics involved with dummy aliasing do not strictly obey Standard Fortran and they slow performance, so you get better run-time performance if you do not use this option.

However, if a program depends on dummy aliasing and you do not specify this option, the run-time behavior of the program will be unpredictable. In such programs, the results will depend on the exact optimizations that are performed. In some cases, normal results will occur, but in other cases, results will differ because the values used in computations involving the offending aliases will differ.

assume fpe_summary

Causes a summary of floating-point exceptions that occurred during program execution to be displayed when a STOP statement is encountered. Counts will be shown for each exception. This is the behavior specified by the Fortran 2003 standard.

Note that if there is no STOP statement, no summary is displayed.

assume ieee_fpe_flags

Tells the compiler to save floating-point exception and status flags on routine entry and restore them on routine exit.

This option can slow runtime performance because it provides extra code to save and restore the floating-point exception and status flags (and the rounding mode) on entry to and exit from every routine compiled with the option.

This option can be used to get the full Fortran Standard behavior of intrinsic modules IEEE EXCEPTIONS, IEEE ARITHMETIC, and IEEE FEATURES, which require that if a flag is signaling on routine entry, the processor will set it to quiet on entry and restore it to signaling on return. If a flag signals while the routine is executing, it will not be set to quiet on routine exit.

Options fpe and fpe-all can be used to set the initial state for which floating-point exceptions will signal.

assume minus0

Tells the compiler to use Fortran 95 standard semantics for the treatment of the IEEE* floating value -0.0 in the SIGN intrinsic, which distinguishes the difference between -0.0 and +0.0, and to write a value of -0.0 with a negative sign on formatted output.

assume old_boz

Tells the compiler that the binary, octal, and hexadecimal constant arguments in intrinsic functions INT, REAL, DBLE, and CMPLX should be treated as signed integer constants.

assume noold_ldout_format

Tells the compiler to use Fortran 2003 standard semantics for output of integer and real values in list-directed and namelist-directed output.

Integers are written using an I0 format with a leading blank for spacing.

Real and complex values are written using and E or F format with a leading blank for spacing. The format used depends on the magnitude of the value. Values that are zero are written using an F format.

assume old_logical_assign

In the assignment statement L = N, where L is a logical variable and N is a numeric value, N is converted to integer if necessary, and L is assigned the bit value of the integer value without conversion.

In the assignment statement N = L, where N is a variable of numeric type and L is a logical value, N is assigned the bit value of the value of L without conversion.

assume old_logical_ldio

Logical values are allowed for numeric items and numeric values are allowed for logical items.

assume noold_maxminloc

Tells the compiler that MAXLOC and MINLOC should return 0 when given an empty array as an argument or every element of the mask is false. Compared to the default setting (old_maxminloc), this behavior may slow performance because of the extra code needed to check for an empty array argument or for an all-false mask.

assume noold_unit_star

Tells the compiler that READs or WRITEs to UNIT=* go to the file to which UNIT=5 or 6 is connected.

assume noold_xor

Prevents the compiler from defining .XOR. as an intrinsic operator. This lets you use .XOR. as a user-defined operator. This is a Fortran 2003 feature.

assume protect_allocates

Memory allocation requests using the ALLOCATE statement are protected with critical sections to avoid random timing problems in a multi-threaded environment in some distributions and configurations.

assume noprotect_constants

Tells the compiler to pass a copy of a constant actual argument. This copy can be modified by the called routine, even though the Fortran standard prohibits such modification. The calling routine does not see any modification to the constant.

assume protect_parens

Tells the optimizer to honor parentheses in REAL and COMPLEX expression evaluations by not reassociating operations. For example, (A+B)+C would not be evaluated as A+(B+C).

If assume noprotect_parens is specified, (A+B)+C would be treated the same as A+B+C and could be evaluated as A+(B+C) if it produced faster executing code.

Such reassociation could produce different results depending on the sizes and precision of the arguments.

For example, in (A+B)+C, if B and C had opposite signs and were very large in magnitude compared to A, A+B could result in the value as B; adding C would result in 0.0. With reassociation, B+C would be 0.0; adding A would result in a non-zero value.

assume norealloc_lhs

The compiler uses the old Fortran 2003 rules when interpreting assignment statements. The left-hand side is assumed to be allocated with the correct shape to hold the right-hand side. If it is not, incorrect behavior will occur. The option nostandard-realloc-lhs has the same effect as assume norealloc_lhs.

assume nosource_include

Tells the compiler to search the default directory for module files specified by a USE statement or source files specified by an INCLUDE statement. This option affects fpp preprocessor behavior and the USE statement.

assume nostd_intent_in

Tells the compiler to assume that dummy arguments with the INTENT(IN) attribute in a called procedure may be modified across a call. This is not in accordance with the Fortran standard.

If you specify option standard_semantics, it sets option assume std_intent_in.

assume nostd_minus0_rounding

Tells the compiler to use pre-Fortran 2008 standard semantics for the treatment of IEEE* floating values that are negative, non-zero, and when rounded for display are zero. The value should be printed without a leading minus sign.

For example, the floating value -0.00000001 when rounded in F5.1 format will be displayed as 0.0. Use assume std_minus0_rounding to use Fortran 2008 standard semantics to display this value as -0.0 when rounded in F5.1 format.

assume [no]std_minus0_rounding does not affect and is not affected by assume [no]minus0. The former controls printing of a minus sign for non-zero numbers while the latter controls printing of actual signed zero values.

assume std_mod_proc_name

Tells the compiler to revise the names of module procedures so they do not conflict with user external symbol names. For example, procedure proc in module m would be named m_MP_proc. The Fortran 2003 Standard requires that module procedure names not conflict with other external symbols.

By default, procedure proc in module m would be named m_mp_proc, which could conflict with a user-defined external name m_mp_proc.

assume nostd_value

Tells the compiler to use pre-Fortran 2003 standard semantics for the VALUE attribute so that the value of the actual argument is passed to the called procedure, not the address of the actual argument nor the address of a copy of the actual argument.

assume underscore

Tells the compiler to append an underscore character to external user-defined names: the main program name, named common blocks, BLOCK DATA blocks, global data names in MODULEs, and names implicitly or explicitly declared EXTERNAL. The name of a blank (unnamed) common block remains _BLNK__, and Fortran intrinsic names are not affected.

assume 2underscores
(Linux and OS X)

Tells the compiler to append two underscore characters to external user-defined names that contain an embedded underscore: the main program name, named common blocks, BLOCK DATA blocks, global data names in MODULEs, and names implicitly or explicitly declared EXTERNAL. The name of a blank (unnamed) common block remains _BLNK__, and Fortran intrinsic names are not affected.

This option does not affect external names that do not contain an embedded underscore. By default, the compiler only appends one underscore to those names. For example, if you specify assume 2underscores for external names my_program and myprogram, my_program becomes my_program__, but myprogram becomes myprogram_.

assume writeable-strings

Tells the compiler to put character constants into non-read-only memory.