Lines Matching full:as
17 As a general principle, this compiler will accept by default and
20 so long as the recognition of those features would not cause a
33 `SIZE` that (as mentioned below) may return non-default
38 so long as they contain no executable code, no internal subprograms,
43 are being emitted, as is the case with internal output, this
47 Because it seems least wrong, we emit one copy of the delimiter as
48 the last character of the current record and another as the first
52 to be usable later as input anyway.)
53 Consequently, the output is not suitable for use as list-directed or
55 behavior will change as needed to conform.
66 an object of the same name as the index variable in a bounds
79 constant on a machine with 32-bit two's-complement integers as
80 kind 4, because the grammar of Fortran expressions parses it as a
86 As most (but not all) compilers implement `BLOCK` scoping of construct
89 from sharing the same name as a symbol in its scope's host, if it
92 * A module name from a `USE` statement can also be used as a
96 * `NULL()` without `MOLD=` is not allowed to be associated as an
111 generic interface are inadequate, as admitted in note C.11.6 of F'2023.
117 * `PROCEDURE(), BIND(C) :: PROC` is not conforming, as there is no
125 as `PURE` functions, which allows their use in parallel constructs
145 arithmetic exception is signaled, as well as processors that do not
160 * `<>` as synonym for `.NE.` and `/=`
161 * `$` and `@` as legal characters in names
171 * `DOUBLE COMPLEX` as a synonym for `COMPLEX(KIND(0.D0))` --
178 * `BYTE` as synonym for `INTEGER(KIND=1)`; but not when spelled `TYPE(BYTE)`.
181 * `X` prefix/suffix as synonym for `Z` on hexadecimal literals
182 * `B`, `O`, `Z`, and `X` accepted as suffixes as well as prefixes
189 * Cray based `POINTER(p,x)` and `LOC()` intrinsic (with `%LOC()` as
200 * `NAME=` as synonym for `FILE=`
202 * `D` lines in fixed form as comments or debug code
210 * Character literals as elements of an array constructor without an explicit
224 * BOZ literals can be used as INTEGER values in contexts where the type is
226 of INTEGER entities, as actual arguments to a few intrinsic functions
227 (ACHAR, BTEST, CHAR), and as actual arguments of references to
230 converted. BOZ literals are interpreted as default INTEGER only
231 when they appear as the first items of array constructors with no
233 not be known (e.g., `IAND(X'1',X'2')`, or as arguments of `DIM`, `MOD`,
236 * BOZ literals can also be used as REAL values in some contexts where the
237 type is unambiguous, such as initializations of REAL parameters.
239 as well as of sequences of non-default kinds of numeric types
244 * Some intrinsic functions are specified in the standard as requiring the
248 the arguments as if they were operands to an intrinsic `+` operator,
255 double precision kind. Their result kinds remain as specified.
266 to be associated with a compatible monomorphic dummy argument, as
285 expression, such as an array bound, in a scope with IMPLICIT NONE(TYPE)
287 as default INTEGER if IMPLICIT NONE(TYPE) were absent.
288 * OPEN(ACCESS='APPEND') is interpreted as OPEN(POSITION='APPEND')
292 we also treat scalars as being trivially contiguous, so that they
305 and defined as `ERROR_UNIT` in the intrinsic `ISO_FORTRAN_ENV` module.
316 integer scalars are accepted so long as they are simply contiguous.
319 as modifiable formats.
322 as if they were comment lines, even if not begun with `!`.
325 * Legacy names `AND`, `OR`, and `XOR` are accepted as aliases for
330 * The name `IMAG` is accepted as an alias for the generic intrinsic
342 * A type-bound procedure binding can be passed as an actual
343 argument corresponding to a dummy procedure and can be used as
360 such as USE-association as well as an `IMPORT` from its host,
375 `PROCEDURE` statements in generic interfaces, as in some other
377 * A `NULL()` pointer is treated as an unallocated allocatable
394 the first two cannot be converted, as it may not be present.
396 derived type can be used as such where an interoperable type is
406 when it is not a dummy argument or in COMMON, so long as it is
408 * `PRINT namelistname` is accepted and interpreted as
411 is accepted before an array specification (`ch*3(2)`) as well
412 as afterwards.
422 * `.XOR.` as a synonym for `.NEQV.` [-fxor-operator]
424 the same amount of storage as the default `REAL` type. Default
444 * `.LG.` as synonym for `.NE.`
448 * `ACCEPT` as synonym for `READ *`
449 * `TYPE` as synonym for `PRINT`
450 * `ARRAY` as synonym for `DIMENSION`
451 * `VIRTUAL` as synonym for `DIMENSION`
452 * `ENCODE` and `DECODE` as synonyms for internal I/O
458 * `T` and `F` as abbreviations for `.TRUE.` and `.FALSE.` in DATA (PGI/XLF)
460 * ALLOCATE(TYPE(derived)::...) as variant of correct ALLOCATE(derived::...) (PGI only)
463 * NULL() as a structure constructor expression for an ALLOCATABLE component (PGI).
473 * Mixing INTEGER types as operands to bit intrinsics (e.g., IAND); only two
490 * User (non-intrinsic) `ELEMENTAL` procedures may not be passed as actual
495 as a portability warning only, not a hard error.
514 ## Standard features that might as well not be
517 constrained, as initial data targets for data pointers in
520 This Fortran 2008 feature might as well be viewed like an
531 appears as part of a complex-literal-constant be a scalar, but
596 some seem to treat the references to `m` as if they were host associations
598 treat them as references to implicitly typed local variables, and
622 file, it functions as an effective maximum record length.
623 Longer records, if any, will appear as if they had been truncated to
627 For sequential formatted output, RECL= serves as a limit on record lengths
630 * When a `DATA` statement in a `BLOCK` construct could be construed as
633 a `DATA` statement as being a "declaration" rather than a "specification"
634 construct, and notes that the `BLOCK` construct is defined as localizing
654 but does not have the `USE`-associated non-generic procedure as a
675 This case elicits a warning from f18, as it should not be treated
681 most compilers disallow it as well.
696 or class (4) shall not be the same as a global identifier used in that scope..."
697 is read so as to allow the name of a module, submodule, main program,
703 second argument `TARGET=` is required to be "allowable as the data-target or
709 As there is no good reason to disallow (say) an `INTENT(IN)` pointer here,
710 or even `NULL()` as a well-defined case that is always `.FALSE.`,
716 in the same compilation unit, so long as mutual dependencies do not form
754 As other compilers do apply rounding, so does this one.
760 * When `INDEX` is used as an unrestricted specific intrinsic function
761 in the context of an actual procedure, as the explicit interface in
762 a `PROCEDURE` declaration statement, or as the target of a procedure
766 This is how `INDEX` as an unrestricted specific intrinsic function was
794 Reading "would have if it were" as being the subjunctive, this would mean that
797 the "would have if it were" as meaning "has if it is" -- i.e., if the name
798 is visible in the enclosing scope, the type of that name is used as the
822 or contiguous array can be used as the initial element of a storage
823 sequence. For example, "&GRP A(1)=1. 2. 3./" is treated as if had been