Since Version 5.0, the following corrections have been made:

• Using ASSOCIATED with f90 pointer now gives correct answer.
• Using vector subscripts in MATMUL now gives correct answer.
• Passing %REF argument to a routine with explicit INTERFACE no longer gets an internal error.
• CSHIFT of an array pointer contained within a derived type no longer gets an internal error.
• Compiling files that contain very long routine names with -V no longer gets an internal error.
• Using assignments in a defined generic assignment subroutine when the subroutine is not RECURSIVE now gets an error.
• Parameter constant is allowed as argument of a LOC intrinsic.
• Using UNION within derived type now gets correct result.
• Having EQUIVALENCEd character array elements within a MODULE no longer gets internal error.
• Duplicate SAVE statement no longer gets an error.
• Parameter constant can be used as case-value in a SELECT CASE statement.
• ALIAS attribute can now be specified in a cDEC$ ATTRIBUTE directive for a variable that has not been declared EXTERNAL (EXTERNAL is assumed).
• Interface with optional function argument is now resolved properly.
• Using record fields in multiply and add operations now produces correct result.
• Using the following operators: ==, /=, <, >, <=, and >= no longer get non-standard conforming warnings.
• Extra trailing blanks are now allowed and ignored when used in specifier of OPEN statement, e.g., FORM='formatted '.
• Passing an array argument to a statement function now gets an error.
• INTEGER*2 array now gets correct result when compiled with -integer_size 16 .
• Fix a bug related to module importing with modules that contain PRIVATE statement.
• Parameter constant defined in a MODULE is now imported when its use is only in a variable format expression.
• C attribute can be specified in a cDEC$ ATTRIBUTE directive for module variables.
• Parameter constants are allowed in a structure constructor.
• A derived type component having the same name as a common block no longer gets an internal error.
• IVDEP directive can be specified between PDO and DO statements.
• A non-standard warning is issued if the first argument of a GENERIC assignment procedure is not INTENT(OUT) or INTENT(INOUT).
• $PACK directive and the -align recNbyte option now affect alignment of data items in a SEQUENCE derived-type.
• Using a structure constructor to initialize a multi-dimensional array component of a derived-type no longer causes an internal error.
• Fix $omp parallel copyin (/common_block/) directive.
• The -fpconstant option now works correctly for assignment to double complex variables.
• Having a D line as the first non-comment line after a conditional $ENDIF directive no longer gets an error.
• No longer flag ES format as non-standard.
• Remove an internal limit on the number of entries of a NAMELIST
• Using substring of a character array as argument of ICHAR intrinsic no longer gets internal error
• Pointer assignment of an array of character substrings now gets correct result. For example: p=>a(:)(2:4) )
• Using array transformation intrinsics such as PACK, SPREAD, and RESHAPE with array of derived-type as argument in a PRINT statement now gets correct results
• Allow an array with a name of TYPE
• Specifying $NOFREEFORM in a .f90 file now sets the line size to 72 columns
• Remove a limit of 256 number of arguments for subroutines and functions
• An incorrect statement: "IF (ABS(I).GT 1) I=0" now gets an error message
• An incorrect statement: "CHARACTER(LEN=1), PARAMETER :: CPSCLR = '' ''" now gets an error message
• Using record fields in multiply and subtract operations now produces correct results
• Having a PRIVATE, EQUIVALENCE variable in a module no longer causes compile time segmentation violation
• Specifying ONLY on one variable in a COMMON block now only declares the one variable (not the entire variables) in the COMMON block
• Allow user-defined operator to be used as the format character expression in a PRINT or READ statement
• Using modules and the AUTOMATIC statement in the same routine no longer gets internal error
• Module variables with EXTERN attributes now work properly
• Increase an internal limit so that large programs no longer get the "text handle table overflow" message
• Using record fields in exponentiation and subtract operations now produce correct result
• Flag incorrect usage of an entry dummy argument in an executable statement before its declaration in the entry statement
• Disallow optional return dummy argument following other OPTIONAL dummy arguments
• An invalid WRITE statement no longer gets an internal error
• Allow passing NULL intrinsic function as argument to other routines
• Allow AUTOMATIC variables to be used in an EQUIVALENCE statement
• Using a structure constructor with scalar value to assign an array element now produces correct result
• Using an array constructor with integer value to initialize a real or complex array now produces correct result
• Flag common block name and routine name conflict
• Fix elemental character function with varying length
• Fix problem where -assume dummy_aliases wasn't being taken into account in checks for overlap in array assignment.
• If !DEC$ ATTRIBUTES C is specified in an INTERFACE block, and an argument is declared as having an array type, always pass that argument by reference even if the actual argument is a single array element.
• Allow a concatenation expression as the first argument to TRANSFER.
• Implement -std90 and -std95 options.
• A STRUCTURE with no fields no longer causes a compiler failure.
• No longer issue standards warning for certain cases with a relational operator followed by a unary minus.
• Do not give spurious "more variables than values" warning for certain cases of data initialization of multi-dimensional arrays.
• User-defined generic interface for IDATE no longer causes internal compiler error.
• LOC(funcname) as an actual argument when used inside function "funcname" now properly returns the address of the return value variable and not the entry point.
• The compiler no longer gives spurious errors (including internal compiler failures) in certain cases where a module file cannot be opened.
• Certain incorrect programs which include a reference to fields of an undeclared STRUCTURE no longer cause an internal compiler error.
• Give error when ALLOCATED is used on a non-ALLOCATABLE object.
• Allow a recursive function name to be passed as an actual argument inside the function.
• If an INCLUDE file includes a directive to change the source form, revert to the original setting after returning to the including source file.
  The following limitations were fixed in Version 2.0 or previous releases:
  • The f90 command option -wsf and its related options are now supported.
  • Allocatable arrays that are allocated but not deallocated before routine exit are now deallocated upon exit from routine.
  • The f90 command options -cord and -feedback described in the documentation have now been implemented.

The new SHADOW directive, as defined in Version 2.0 of the High Performance Fortran Language Specification, is now supported. SHADOW is now a separate HPF directive, rather than a keyword inside the DISTRIBUTE directive.

1.9.3.2 Pointers Now Handled in Parallel

Mapped variables with the POINTER attribute are now handled in parallel. This capability is an approved extension of the High Performance Fortran Language Specification.

1.9.3.3 SHADOW Directive Required for Nearest-Neighbor POINTER or TARGET Arrays

The compiler will not generate shadow edges automatically for arrays with the POINTER or TARGET attributes. In order to be eligible for the compiler's nearest-neighbor optimization, POINTER or TARGET arrays must explicitely be given shadow edges using the SHADOW directive. If pointer assignment is done, both the POINTER and the TARGET must have the same mapping, including shadow edges.

For More Information:

• On the conditions that must be satisfied for a statement to be eligible for the nearest-neighbor optimization, see Section 1.8.1.4 of these Release Notes.

In Version 1 of the HPF Language Specification, a special form of the DISTRIBUTE and ALIGN directives was used in interfaces and procedures when mapped arrays were passed to a procedure. Known as descriptive mapping, it was specified by an asterisk (*) appearing before the left parenthesis "(" in a DISTRIBUTE directive, or after the WITH in an ALIGN directive. For example,

!HPF$ DISTRIBUTE R*(BLOCK, BLOCK) !HPF$ ALIGN S WITH *R

Beginning with version 2.0 of the High Performance Fortran Language Specification (DIGITAL Fortran 90 Version 5.0), the meaning of descriptive syntax has changed. Descriptive mapping is now a weak assertion that the programmer believes that no data communication is required at the procedure interface. If this assertion is wrong, the data communication will in fact occur.

Although there is now no semantic difference between the descriptive form and the ordinary prescriptive form, there is still some benefit in using the descriptive form. Compaq Fortran generates informational messages when a descriptive directive is specified if the compiler is unable to confirm that there will in fact be no communication. These messages can uncover subtle programming mistakes that cause performance degradation.

Existing programs with descriptive mapping directives will continue to compile and run with no modification.

In the future, DIGITAL may provide a command-line option that specifies that descriptive directives be treated as strong assertions that data communication will not be necessary at the procedure interface. This would allow the compiler to omit checking whether the mappings of the actual and dummy agree, leading to performance improvement in some cases.

1.9.3.5 New support for HPF Local Library Routines GLOBAL_LBOUND and GLOBAL_UBOUND

The following HPF Local Library routines are now supported:

• GLOBAL_LBOUND
• GLOBAL_UBOUND

The REDUCTION clause in INDEPENDENT directives is now supported.

1.9.3.7 HPF_SERIAL Restriction Lifted for Procedures Called from INDEPENDENT DO Loops

Previous versions required procedures called from inside INDEPENDENT DO loops to HPF_SERIAL in order to obtain parallel execution. This restriction is now lifted.

For More Information:

• On the requirements for parallel execution of INDEPENDENT DO loops containing procedure calls, see Section 1.8.5.6 of these Release Notes.

This section lists problems in previous versions that have been fixed in this version.

• Some bugs in implementing whole structure references in IO and assignment were fixed.
• Aligning components of derived types is now supported.
• The restriction that statements with scalar subscripts are not eligible for the nearest-neighbor optimization is now removed. Statements with scalar subscripts may now be eligible for the nearest-neighbor optimization if that array dimension is (effectively) mapped serially.
• Nearest-neighbor assignments with derived types are now eligible for the nearest-neighbor optimization.

Version 5.0 is a major release that also includes corrections to problems discovered since Version 4.1 was released.

The following topics are discussed:

• Version 5.0 New Features
• Version 5.0 Corrections

The following new Compaq Fortran (DIGITAL Fortran 90) features are now supported:

• The -mp compiler option enables parallel processing using directed decomposition. Parallel processing is directed by inserting !$PAR directives in your source code. This type of parallel processing is for shared memory multiprocessor systems.
  To enable parallel processing across clusters of servers or workstations with !HPF$ directives, continue to use the -wsf compiler option.
  On a shared memory system, you can use both the -mp and the -wsf options for the same program. This combination provides improved performance for certain programs running mostly on shared memory systems.
  The new parallel directives:
  • Use the !$PAR prefix
  • Are recognized only if compiled with the -mp option
  • Some of the parallel !$PAR directives include:

    PARALLEL and END PARALLEL
    PDO
    PARALLEL DO
    PSECTIONS
    CRITICAL SECTION
    TASK COMMON

  • Environment variables control the run-time behavior. For example, MP_THREAD_COUNT specifies how many threads to create.
  
  To allow task-local thread storage, you must be using Version 4.0D (code name PTmin) of the DIGITAL UNIX operating system.
  For more information on these directives, see the Compaq Fortran User Manual for Tru64 UNIX and Linux Alpha Systems.
• The -warning_severity keyword compiler option allows you to:
  • Specify -warning_severity errors to make all compiler warning messages error-level instead of warning-level messages.
  • Specify -warning_severity stderrors to make standards checking compiler warning messages ( -std option) error-level instead of warning-level messages.
• The -warn nogranularity compiler option allows you to suppress the NONGRNACC warning message: Unable to generate code for requested granularity .
• An internal procedure can now be used as an actual argument.
• Support for certain new language extensions for compatibility with Compaq Visual Fortran (and Microsoft® Fortran PowerStation). These features include the following:
  • # Constants--constants using other than base 10
  • C Strings--NULL terminated strings
  • Conditional Compilation And Metacommand Expressions ($define, $undefine, $if, $elseif, $else, $endif)
  • $FREEFORM, $NOFREEFORM, $FIXEDFORM--source file format
  • $INTEGER, $REAL--selects size
  • $FIXEDFORMLINESIZE--line length for fixed form source
  • $STRICT, $NOSTRICT--F90 conformance
  • $PACK--structure packing
  • $ATTRIBUTES ALIAS--external name for a subprogram or common block
  • $ATTRIBUTES C, STDCALL--calling and naming conventions
  • $ATTRIBUTES VALUE, REFERENCE--calling conventions
  • \ Descriptor--prevents writing an end-of-record mark
  • Ew.dDe and Gw.dDe Edit Descriptors--similar to Ew.dEe and Gw.dEe
  • 7200 Character Statement Length
  • Free form infinite line length
  • $DECLARE and $NODECLARE == IMPLICIT NONE
  • $ATTRIBUTES EXTERN--variable allocated in another source file
  • $ATTRIBUTES VARYING--variable number of arguments
  • $ATTRIBUTES ALLOCATABLE--allocatable array
  • Mixing Subroutines/Functions in Generic Interfaces
  • $MESSAGE--output message during compilation
  • $LINE == C's #line
  • INT1 converts to one byte integer by truncating
  • INT2 converts to two byte integer by truncating
  • INT4 converts to four byte integer by truncating
  • COTAN returns cotangent
  • DCOTAN returns double precision cotangent
  • IMAG returns the imaginary part of complex number
  • IBCHNG reverses value of bit
  • ISHA shifts arithmetically left or right
  • ISHC performs a circular shift
  • ISHL shifts logically left or right

The following new High Performance Fortran (HPF) features and corrections have been added for DIGITAL Fortran Version 5.0:

• The new SHADOW directive, as defined in Version 2.0 of the HPF specification, is now supported. SHADOW is now a separate HPF directive, rather than a keyword inside the DISTRIBUTE directive.
• Mapped variables with the POINTER attribute are now handled in parallel. This capability is an approved extension of the HPF specification.
• Beginning with version 2.0 of the HPF specification (DIGITAL Fortran Version 5.0), the meaning of descriptive syntax has changed. Descriptive mapping is now a weak assertion that the programmer believes that no data communication is required at the procedure interface. If this assertion is wrong, the data communication will in fact occur.
  Existing programs with descriptive mapping directives will continue to compile and run with no modification and no performance penalty.
• The following HPF Local Library routines are now supported:
  • GLOBAL_LBOUND
  • GLOBAL_UBOUND
• The REDUCTION clause in INDEPENDENT directives is now supported.
• Previous versions required procedures called from inside INDEPENDENT DO loops to HPF_SERIAL in order to obtain parallel execution. This restriction is now lifted.
• Some bugs in implementing whole structure references in IO and assignment were fixed.
• Aligning components of derived types is now supported.
• The restriction that statements with scalar subscripts are not eligible for the nearest-neighbor optimization is now removed. Statements with scalar subscripts may now be eligible for the nearest-neighbor optimization if that array dimension is (effectively) mapped serially.
• Nearest-neighbor assignments with derived types are now eligible for the nearest-neighbor optimization.

Since Version 4.1, the following corrections have been made:

• Fix SIGN intrinsic to handle --0.
• Fix LOC intrinsic and %LOC of a derived type field.
• Fixed debug information for dynamic character variable (such as character*(i) c ).
• Add debugging support for integer (Cray) pointers.
• Fix storing to the return value of a function returning character in a containing internal routine.
• Fix Nullification of a character*n pointer argument.
• Fix using passed length argument in a containing internal routine.
• Fix compiler abort when a source line is longer than 1024 characters in freeform source file.
• Fix using IOLENGTH in a INQUIRE statement.
• Fix FORALL problem of the form " X(X(I)) = ."
• Fix contained functions returning an implicitly initialized derived-type.
• Better diagnostics for invalid programs.
• Fix compiler abort when using Nullification of a pointer in a MODULE.
• Fix a certain type of USE of a MODULE with rename list.
• Fix using -extend_source:80 and -pad_source .
• Fix compiler abort when using do-loop style implicitly initialized derived-types in a MODULE.
• Sign-extending INTEGER*2 parameter constants.
• Flag invalid nested internal procedures.
• Fix compiler abort of USE of a MODULE with namelist variables in rename list.
• Issue a warning message for a intrinsic with wrong argument type and treat it as an external.
• Issue a warning message for having a SAVE common block data object.
• Fix compiler abort of USE of a MODULE with namelists.
• Fix using SIZEOF(common_block_array) in a PARAMETER statement.
• Fix using READONLY keyword as first keyword in an OPEN statement.
• Allow record name to be the same as a structure name.
• Fix parameter character constant with embedded NULL character.
• Fix compiler abort when same name used as a structure and derived type.
• Allow BLOCKSIZE keyword in an INQUIRE statement.
• Allow a record in a SAVE statement.
• Allow a module to have the name "procedures".
• Do not flag IABS intrinsic function as nonstandard.
• Do not flag DOUBLE COMPLEX as nonstandard.
• Treat POPCNT, POPPAR, LEADZ as external functions.
• Put out an error message for ptr => pack(...) .
• Treat C$DOACROSS as a comment.
• Issue an error message for invalid derived type parameter constant.
• Fix compiler abort when passing an array constructor as an actual argument.
• Fix using derived-type components that are same as intrinsic names.
• Fix an incorrect warning about "explicit-shaped array is being passed to a routine that expects a pointer or assumed-shape array".
• Fix a problem with -warn:errors and -stand:f90 options. Nonstandard messages should be error messages.
• Fix incorrect results when compiled a program with -assume:dummy_aliasing .
• Do not flag BOZ constant as nonstandard.
• Do not flag Z format as nonstandard.
• Allow 511 continuation lines.
• Put out a standard warning for using character constant in DATA statement.
• Fix using TRANSFER in initialization.
• Fix a problem with user defined assignment statement.
• Issue an error message when passing or receiving an optional argument by value.
• Fix an invalid message about return value of a function is not defined when the function returns an initialized derived type.
• Fix a compiler abort with "text handle table overflow" message.
• Fix a compiler abort using a SAVE statement.
• Fix a problem when an existing operator is overloaded.
• Fix argument checking of intrinsic subroutines.
• Fix generic interface of elemental functions.
• Issue an argument mismatch warning message for using an integer with a statement function that takes real argument.
• Fix compiler directives processing.
• Fix a compiler abort using an invalid PARAMETER array.
• Issue an error message for SAVE of an ENTRY result variable.
• Fix using UNION within derive type.
• Fix a compiler internal error when using C and REFERENCE attributes on a function name.
• Fix a compiler internal error when using ASSOCIATED of a function returning a pointer.
• Add support for passing complex by value.
• Fix pointer assignment with a character substring.
• Allow using ICHAR in an array constructor within the initialization part of an array declaration.
• Fix a problem with using UNION declaration within the derived type.
• Allow exporting of a module procedure which has a name that is the same as a generic name.
• Fix a problem with using user defined assignment operation.
• Allow specifying NaNs in the PARAMETER statement.
• Allow D source line to continue a non-D source line.
• Fix a problem in array initialization processing.
• Cray pointees that were being allocated statically are now correctly given no storage class.
• Using assume shape array within a contained routine no longer produces an internal compiler error.
• An error message is now given for invalid keyword values given for an I/O statement's keyword.
• Declarations of the type "character, allocatable :: field*7(:)", in which the array shape specifier comes after the length specification in a deferred-shape character array no longer produces an internal compiler error.
• When assigning a derived type variable with a structure constructor, if a character scalar is supplied to an character array component, every elements of the array is assigned with the character scalar value.
• The MVBITS intrinsic now gives correct result if its 4th argument is a non-lowerbound subscripted array element.
• Reference of a character function, where the length of its return value is dependent on one or more of its arguments, no longer produces an internal compiler error.
• Pointer assignment should now work properly when the target is a component of an allocatable array with a lower bound different of 1.
• Long NAMELISTs no longer causes a compiler internal error.
• The compiler now prints out better error messages for the PDONE directive.
• When initializing a derived type variable with a structure constructor, if a scalar is supplied to an array component, every elements of the array is initialized with the scalar value.
• Allow %fill in STRUCTURE declarations using F90 syntax, such as: integer :: %fill .
• Using unary "-" operator with record fields should now give correct results.
• Use of NEAREST with two different KIND REAL arguments no longer gets a nonstandard warning.
• Allow SIZEOF of assumed size record field.
• Module importing has been improved. If a module is USEd in both the host and its internal procedure, the module is now only imported once by the compiler.
• A module that contains "PRIVATE" followed by "PUBLIC variable" no longer gets incorrect error message.
• Optional comma in DO with label, such as: label: DO, JJ = 1, N, 1 no longer gets incorrect syntax error.
• Allow a dummy argument to have the same name as a structure field.
• A module that contains USE module, ONLY : var no longer gets internal compiler error.
• A component of a derived-type with a name that starts with FILL no longer gets a syntax error.
• A PDONE directive in a statically-scheduled PDO loop no longer gets an error message.
• Allow a variable with '_' in its name to be used in a variable format expression.
• Fix for array references in CRITICAL SECTION directive.
• Set NOWAIT for paralleldo directive (the region waits, so do NOT make the loop wait as well).
• Allow variables in COMMON/EQUIVALENCE on local, lastlocal, and reduction lists. Create and use new local variables in parallel do scopes for these variables.
• Allow c$copyin of EQUIVALENCE/COMMON variables.
• Fix -mp (ordered) bug.
• No longer import any definitions if a module is used with the "USE module_name, ONLY:" statement.
• Fix a compile time stack overflow problem.
• Fix a "$IF DEFINED()" problem when a routine is defined between the conditional compilation.
• Put out error message for an invalid use of "TYPE (type_name)" statement.
• Allow RECORD in a NAMELIST.
• Fix using "# line_number" in DATA statement.
• The -pad_source option now properly pads Hollerith literals that are continued across source records.
• Add standards warning for using two consecutive operators in an expression.
• Allow POINTER attribute for character entities whose length is specified by a variable expression or an * (assumed length character).
• Do not flag as nonstandard when all of the objects in the EQUIVALENCE set are of type default integer, default real, double precision, default complex, default logical, or numeric sequence type.
• Add standards warning for assignment to the host associated variable in a PURE function.
• Add standards warning for using a dummy argument in a specification-expr as the argument of one of the intrinsic functions BIT_SIZE, KIND, LEN, or the numeric inquiry functions.
• Compiling BLOCK DATA with -recursive no longer causes a compiler internal error.
• A special usage of equivalenced variables in parallel no longer causes a compiler internal error.
• DO loop variables are now set to be PRIVATE by default in a parallel region.
• The scope of C$CHUNK and C$MP_SCHEDTYPE directives is restricted to one program unit.
• Fix a bug in a special usage of passing internal procedure as argument.

This section contains information that supplements the Compaq Fortran documentation.

1.11.1 The Compaq Fortran Home Page

If you have Internet access and a World Wide Web (WWW) viewer, you are welcome to view the following:

• The Compaq Fortran home page, located at the following URL:

  http://www.compaq.com/fortran

• The Compaq Computer Corporation home page, located at the following URL:

  http://www.compaq.com

This section briefly describes the Fortran 95 language features that have been added to Compaq Fortran:

• The FORALL statement and construct
  In Fortran 95/90, you could build array values element-by-element by using array constructors and the RESHAPE and SPREAD intrinsics. The Fortran 95 FORALL statement and construct offer an alternative method.
  FORALL allows array elements, array sections, character substrings, or pointer targets to be explicitly specified as a function of the element subscripts. A FORALL construct allows several array assignments to share the same element subscript control.
  FORALL is a generalization of WHERE. They both allow masked array assignment, but FORALL uses element subscripts, while WHERE uses the whole array.
  Compaq Fortran previously provided the FORALL statement and construct as language extensions.
• PURE procedures
  Pure user-defined procedures do not have side effects, such as changing the value of a variable in a common block. To specify a pure procedure, use the PURE prefix in the function or subroutine statement. Pure functions are allowed in specification statements.
  Compaq Fortran previously allowed pure procedures as a language extension.
• ELEMENTAL procedures
  An elemental user-defined procedure is a restricted form of pure procedure. An elemental procedure can be passed an array, which is acted upon one element at a time. To specify an elemental procedure, use the ELEMENTAL prefix in the function or subroutine statement.
• Pointer initialization
  In Fortran 95/90, there was no way to define the initial value of a pointer or to assign a null value to the pointer by using a pointer assignment operation. A Fortran 95/90 pointer had to be explicitly allocated, nullified, or associated with a target during execution before association status could be determined.
  Fortran 95 provides the NULL intrinsic function that can be used to nullify a pointer.
• Derived-type structure default initialization
  Fortran 95 lets you specify, in derived-type definitions, default initial values for derived-type components.
• Automatic deallocation of allocatable arrays
  Arrays declared using the ALLOCATABLE attribute can now be automatically deallocated in cases where Fortran 95/90 would have assigned them undefined allocation status.
  Compaq Fortran previously provided this feature as a language extension.
• CPU_TIME intrinsic subroutine
  This new intrinsic subroutine returns a processor-dependent approximation of processor time.
• Enhanced CEILING and FLOOR intrinsic functions
  KIND can now be specified for these intrinsic functions.
• Enhanced MAXLOC and MINLOC intrinsic functions
  DIM can now be specified for the MAXLOC and MINLOC intrinsic functions. DIM was allowed previously as a Compaq Fortran language extension.
• Enhanced SIGN intrinsic function
  The SIGN function can now distinguish between positive and negative zero (if the processor is capable of doing so).
• Enhanced WHERE construct
  The WHERE construct has been improved to allow nested WHERE constructs and a masked ELSEWHERE statement. WHERE constructs can now be named.
• Comments allowed in namelist input
  Fortran 95 allows comments (beginning with !) in namelist input data. Compaq Fortran previously allowed this as a language extension.
• Generic identifier to END INTERFACE statement
  The END INTERFACE statement of an interface block defining a generic routine now allows a generic identifier.
• Zero-length formats
  On output, when using I, B, O, Z and F edit descriptors, the specified value of the field width can be zero (0). In such cases, the compiler selects the smallest possible positive actual field width that does not result in the field being filled with asterisks.
• New obsolescent features
  Fortran 95 deletes several language features that were obsolescent in Fortran 90, and identifies new obsolescent features:
  • REAL and DOUBLE PRECISION DO variables
  • Branching to an ENDIF from outside its IF
  • PAUSE statement
  • ASSIGN statement, assigned GOTO, and assigned FORMATs
  • H edit descriptor
  
  Compaq Fortran flags these deleted and obsolescent features, but fully supports them.