If you have a current maintenance contract please download new versions of FPT to extend and update your installations.

Download the New Versions

New Commands and Features

• COMMAND FILE AFTER WRITING FORTRAN. This command specifies a command (batch) file which will be run after the Fortran output files have been written by FPT or WinFPT. By default the command file is sought in the primary output directory. The command file may be used, for example, to copy the output files to alternative directories or to build an application.

• INCLUDE TREE and MODULE TREE. These commands report the INCLUDE and USE trees of the program. They are not yet implemented in the WinFPT GUI but may be accessed through the Tools | FPT Command Line menu.

• SHOW LIVES and SEPARATE SYMBOL LIVES. A scalar Fortran variable has multiple lives if it is used to hold different quantities within a program or sub-program. Different quantities are assigned or initialised in different assignment statements. If either one of two different assignments may be used as the same right-hand-side input to the same statement, the assignments contribute to the same life. If the different assignments only reach separate right-hand-side uses the lives are separate. If a variable has separate lives, the meaning of the program would not change if the separate lives had different names and occupied different memory locations. The command SEPARATE SYMBOL LIVES renames duplicate lives and inserts appropriate declarations. This may be important in implementing some optimisations, and has been used in trtanslating codes for execution by new computer architectures. Please see the description of Hydra.

• SCALARISE / SCALARIZE. This command replaces array references in the code with constant indices by scalar variables. It is used with the command UNWIND ALL LOOPS to break an array based algorithm into scalar expressions which may then be optimised for parallel computer architectures.

• UNWIND INNER LOOPS FIRST and UNWIND OUTER LOOPS FIRST. FPT versions before 3.7-m always carried out loop unwinding starting with the innermost loop. This creates the most efficient code if the loop unwinding is incomplete. However, the inner loop control variables may sometimes depend on the variables in the outer loops, for example, when unwinding loops for half-diagonal arrays. These commands specify the order of unwinding.

• SIMPLIFY EXPRESSIONS TO TRIPLES. This command separates long scalar expressions into series of short expressions of the form A = B <operator> C. This exposes the code to more efficient optimisation and has been used in preparing code for execution by new parallel computer architectures. New temporary variables are created to hold intermediate results and declarations are inserted automatically.

Changes to Code QA Checks and Analyses

• An additional filter has been added to the sub-program argument check: ARGUMENT CHECK TO IGNORE ARRAY RANK. This command may be used to suppress warnings when arrays are re-shaped across a sub-program call site, for example, where a 2-dimensional array is passed into a routine which treats it internally as a 3-dimensional array. Note that SimCon does not recommend this practice!

• The handling of the filter NAME CHECK TO IGNORE ARGUMENTS has been revised. This filter suppresses warnings when the same variable name is used for a variable in one routine and for a formal argument in another. In versions of FPT before 3.7-m there were circumstances in which the warnings could not be suppressed.

Bugs and Error Corrections

• FPT version 3.7-d and earlier sometimes reported ENDIF statements as unreachable. This has been corrected.

• The code modifications made by the command PROTECT AGAINST DIVISION BY ZERO have been revised. In some circumstances code containing Fortran 90 derived types and trailing comments was handled incorrectly by FPT versions 3.7-d and before.

• The code generated by the commands CHANGE ENCODE TO INTERNAL WRITE and CHANGE DECODE TO INTERNAL READ has been revised so as to use the number of characters specified in the ENCODE and DECODE statements in all cases.

Hosts - Windows 7

WinFPT version 3,7-d runs under Windows 7. Microsoft changed some aspects of he Windows registry between Windows Vista and Windows 7, The result was that a number of applications, including WinFPT 3.7-c, would not run. WinFPT 3.7-d does not use the registry features affected.

Fortran Language

The keyword ELEMENTAL is recognised by WinFPT 3.7-d.

Systematic Code Changes

• Coverage analysis has been revised. WinFPT now inserts code to track entry to sub-programs. An error has been corrected in the handling of WHERE constructs. Versions of WinFPT before 3.7-c would sometimes attempt to insert coverage counters within the constructs. This is illegal and the error has now been corrected.

• Trailing semicolon characters in declaration statements caused earlier versons of WinFPT to insert executable code for run-time trace and coverage amongst the declarations. This is corrected in version 3.7-d. (The trailing semicolon is itself probably an error in any case!)

Fortran Language

• The analysis of Fortran declarations has been completely revised in version 3.7-a. The revisions were made in order to handle some aspects of Fortran 95 declarations within modules. In particular:

  • USE statements may appear within interface blocks within modules, in module sub-programs and in internal sub-programs within module sub-programs. These can generate circular references to modules which are successfully resolved by some compilers. WinFPT and FPT can now handle most of these cases.

  • Module sub-programs and INTERFACE blocks which contain MODULE PROCEDURE statements may have compilation dependencies on other module sub-programs. This situation can usually be resolved by compiling all of the declarations in all module sub-programs and interface blocks in a module before compiling the sub-program bodies. WinFPT and FPT now do this for each module in turn. Please note that some compilers are less tolerant of interlocking declarations and therefore a successful analysis by WinFPT does not always guarantee that the code will compile in these situations.

• Overloading of pre-defined operators has been revised. Overloads are now correctly cumulated from each module to the next. For example, if module a contains an interface of the form:

          INTERFACE OPERATOR (*)
  	   MODULE PROCEDURE str_mult_r_ch
  	END INTERFACE
  

  and module a is used by module b, which contains an interface

          INTERFACE OPERATOR (*)
  	   MODULE PROCEDURE str_mult_ch_ch
  	END INTERFACE
  

  the two overloads are both applied within module b or when module b is referenced in a use statement.

• The WHERE, ELSEWHERE and ENDWHERE constructs are now fully supported.

Systematic Code Modification

• Earlier versons of WinFPT sometimes inserted INCLUDE statements before USE statements. This has been corrected.

Checks and Reports

• Earlier versions of FPT sometimes reported a spurious array reference out-of-bounds in references of the form:

          INTEGER :: ia(0:10)
                  :
                  :
          ia(0:)=0
  

  The spurious report occurred at the reference to ia(0:). This has been corrected.

• The intrinsic function PRESENT returns a default logical scalar result. In earlier versions of WinFPT the result was incorrectly interpreted as having the shape of the corresponding argument. This did not change the code generated by WinFPT but lead to spurious reports of mis-matched shapes. The error has been corrected.

Fortran Language

• Versions 3,6-n and later support the INTERFACE ASSIGNMENT(=) statement which specifies overloading of the assignment operator for user-defined and intrinsic data types. The command % show translations of generic interfaces may be used to show the overloading of specific assignments in the code.

• Handling of array shape specifications, in particular in nested cases such as A(B(3:5,3:5)) has been improved. Some of these constructs generated spurious errors in earlier versions.

Checks and Reports

• The use of mixed real and complex data sizes, which results in a loss of precision, is now reported in all occurrences in arithmetic expressions, and not just across an equals sign as in earlier versions.

• Version 3.6-n does not report the double quote string delimiter as non-standard. Strictly it is non-standard in FORTRAN 77, but is standard in Fortran 90 and is accepted by g77 and by nearly all other extended FORTRAN 77 compilers. The command %change string delimiters may be used to change the delimiters throughout a program and therefore to remove double quotes if they cause a problem.

WinFPT and FPT Behaviour

• An error has been corrected in handling the symbol table filters in WinFPT. In earlier versions, when a symbol was selected while using a filtered sub-set of the entire symbol table, the selection could be lost or mis-referenced when the symbol was retrieved from the symbol selection history. Also, the symbol table was not fully restored when a new symbol was selected by clicking in the code pane. The new version handles these situations correctly.

Fortran Language

• Versions 3,6-l and later support overloading of the pre-defined Fortran operators. Overloading is specified in INTERFACE OPERATOR statements.

  The command % show translations of generic interfaces has been added to show the translation of the operators and of all generic sub-program interfaces.

• Versions 3.6-j and later fully support array sub-range assignments of the form

          arr(2:)=barr(2:)
  

  The bounds and the data types of the sub-scripts are checked.

• Versions 3.5-l and later support a command to prevent long STOP messages from being split across two or more lines by the automatic formatting rules. This is required under HP-UX where all STOP messages must be written on a single line, irrespective of length. The command is:

  % write stop statements on one line
  

• Versions 3.5-l and later support the HP-UX ON keyword used to specify exception handling, for example:

          ON REAL(4) DIV 0 CALL except_report('REAL*4 divide by zero')
          ON REAL(8) DIV 0 CALL except_report('REAL*8 divide by zero')
  

• Versions 3.5-k and later recognise and analyse Fortran 90 Construct tags, for example:

          Analysis_Loop: DO I=1,6
                :
             IF (retry_f) CYCLE Analysis_loop
                :
             IF (finished_f) EXIT Analysis_loop
                :
          ENDDO Analysis_loop
  

Fortran Migration Issues

• Versions 3.6-c and later support the command encapsulate read access to integer*1 objects. This command is important in the migration of code from Gould-SEL MPX systems. In these systems, INTEGER*1 variables are unsigned. This has the side effect that array references and the arithmetic results are not always as expected. For example, in:

          INTEGER*1 I1
          REAL*4 A(-200:200)
             :
          I1=-20
             :
          WRITE(6,'(F12.6)')A(I1)
  

  the value written will be A(147) not A(-20). The new command encloses the INTEGER*1 object in an access function, of type INTEGER*4, which makes the code portable.

• Version 3.5-l and later support the command % change extended memory statements to standard form. This command converts all Gould-SEL extended memory constructs.

Checks and Reports

• Versions 3.6-h and later support the command % check whole array assignments. This is implemented in WinFPT in the "Check" drop-down menu.

  The issue is that in Fortran 90, and in Gould-SEL Extended FORTRAN 77 (From at least 1978 if not earlier) an un-subscripted array may be assigned across an equals sign, for example:

          REAL*8 A(200),B(200),X      ! Arrays A and B, scalar X
            :
          A = B   ! Each element of A receives the corresponding value of B
            :
          A = X   ! Each element of A receives the value of X
  

  The problem is that we have seen a disturbing number of errors of the form

          DO i,1,200
             A = B(i)
          ENDDO
  

  The author intended that each element of A should receive the value of the corresponding element of B. What happens is that all elements of A receive B(1), then B(2) and so on and at the end of the loop, every element of A contains B(200).

  The check made by WinFPT has three variants:

  % check whole array assignments from scalar variables
  % check whole array assignments from all scalars
  % check whole array assignments
  

  The first of these traps only the dangerous case shown above. The second shows occurrences where all elements of an array are set to a literal value. The third shows all unsubscripted array asssignments across an equals sign.

  Note that in Fortran 90 (Not in Gould-SEL FORTRAN 77) a whole array assignment can be written unambiguously as, for example, A(:) = X. WinFPT does not trap these as unsubscripted whole array assignments.

• Versions 3.6-a and later support a facility to list all of the variables in COMMON blocks which are used in only one routine. The issue is that these variables could be local to the routines concerned. This would probably improveme efficiency, and would remove clutter from the shared name spaces. The command is:

  % show symbols in common used in only 1 sub-program
  

• Command-line FPT Versions 3.6-a and later support symbol table reports filtered by usage, sub-program and COMMON Block. The commands are, for example:

  % clear symbol filters
  % set symbol filter: usage: local
  % set symbol filter: sub-program: <sub-program_name>
  % set symbol filter: common: /<common_name>/
  % show symbols matching filters
  % show filters for symbols
  

  Symbol filtering has always been available in WinFPT.

• Versions 3.5-l and later write a table of the diagnostics reported in analysis, the number of occurrences of each, and the contribution to the Q.A. index. The table is written to the list (FPL) file.

• Versions 3.5-k and later check the number of indices used in arrays in executable statements, and check that the values of the indices are within bounds if they are constant expressions or literal values. These checks were omitted in error in some earlier versions of FPT.

WinFPT and FPT Behaviour

• In versions 3.5-l and later, the FPT library directories are protected from accidental overwriting by Fortran output files written by FPT. In earlier versions, the command % keep output directories could cause accidental overwriting.

• Versions 3.5-l and later support the command:

  % [do not] remove old errors
  

  FPT diagnostics written in earlier runs may be removed from the code. This is now the default behaviour.

• The commands MAKE TEMPLATES FOR ALL ROUTINES and MAKE TEMPLATES FOR MISSING ROUTINES are supported in FPT 3.5-i and later. These commands automatically generate template (FTM) files.

• Analysis of expressions was revised in FPT 3.5-h. All of the checks associated with data types and type coercions have been collected together and are controlled by a single command: in WinFPT the drop-down menu Checks | Expressions, and in command-line FPT the command CHECK EXPRESSIONS.

• FPT versions 3.5-d and later support the facility to expand internal sub-programs in-line.

• Handling of some intrinsic functions was revised in FPT version 3.5-d. Some inconsistencies were corrected in the handling of data sizes.

• FPT versions 3.5-a and later include a facility to re-program ENCODE and DECODE statements as internal READ and WRITE.

• The run-time trace code has been revised to insert a sequence number in each trace statement. These numbers may be used to identify the statements in the code which have been executed.

• Several minor errors have been corrected in the formatting of free-format code.

• FPT version 3.4-h, and later versions support coverage analysis. Code is inserted to measure the number of times each statement is executed at run-time. The analysis may be used to identify hot spots for optimization and to assess test coverage.

  Versions 3.4-i and 3.4-j support coverage analysis within the logical expressions in IF-THEN-ELSE constructs. Version 3.4-k corrects an error in flow analysis where executable statements occur in include files.

• The command %edit symbols names systematically edits the names of user-defined symbols throughout a program. It may be used, for example, to replace the : and $ characters used in variable names in Gould-SEL (Encore) and Compaq VMS Fortran respectively.

• The commands %change real size, %change integer size etc. have been revised to deal with the case where a system routine with fixed sizes for arguments or for a function return is called from the code to be modified.

• The command %check program flow has been implemented. This command shows statements which cannot be reached during program execution.

• Handling and checking of statement labels has been revised.

• An error has been corrected in handling embedded format expressions containing string concatenation, //, operators.

• Handling of the situation where a function is declared both in a template (FTM) file and the program code has been revised.

• FPT 3.3-u corrects an error in handling long file names.

  In FPT versions 3.3-p to 3.3-t, output file names were required to be unique in the first 80 characters. If they were not, FPT would hang indefinitely, and would not generate output. This has now been corrected.

  In all other respects, FPT 3.3-u is identical to FPT 3.3-t.

• Automatic correction of inconsistent arguments has been extended:

  All cases where the inconsistency is only in INTENT may be corrected automatically - for example, where an expression is passed as an argument to a subroutine which will write to it.

  Character arguments which are inconsistent in length may be corrected. Correction is controlled by the command:

  % CORRECT INCONSISTENT STRING ARGUMENTS

• The INCLUDE file fpt_missing_string_argument.fpi is now generated only if it is required. In earlier versions it was generated whenever the command %CORRECT MISSING ARGUMENTS was made.

• An error has been corrected in the argument check which could cause a spurious inconsistent argument report when the formal and actual arguments were both of type BYTE.

• Handling of string delimiters and of strings which extend across continuation lines has been revised.

  Some compilers assume that strings which extend across continuation lines are padded by spaces to column 72 (or 132 in extended source). Some count the number of trailing space characters on the line. In Fortran 90 free format the issue is handled by the & continuation characters. In fixed or tab format, FPT now attempts to generate code which is independent of the compiler behaviour. Strings which extend across continuations are terminated and linked by string concatenation, //, operators, or in FORMAT statements by commas, as appropriate. DATA statements and STOP statements cannot be handled in this way, and the unterminated string continuations are then marked by warnings. A new command,

  % [DO NOT] COUNT TRAILING SPACES IN STRINGS

  has been added to copy the behaviour of the target compiler.

  An error has been corrected in handling strings in FORMAT statements which end with multiple quotation characters.

• FPT now accepts data statements in which separate DATA specifications are not separated by commas. For example:

        DATA X /3.0/ Y /4.0/

• An error has been corrected in handling the G format descriptor. In FPT versions 3.3-p to 3.3-s, a spurious comma was inserted before the exponent specification in formats of the form:

        FORMAT (G16.3E5)

• The command %COMPLETE REAL NUMBERS changes numbers written, for example, .1 or 17. to 0.1 and 17.0 respectively. It now also converts exponentiated numbers, for example, 3.D8 to 3.0D8.

New Features and Commands - Fortran Language

• Fortran 90 data type and attribute declarations are now fully accepted, for example:

        INTEGER,PARAMETER :: P1=1

• FPT now formats the tokens within FORMAT strings, and within embedded format specifications within READ and WRITE statements. Embedded expressions in formats delimited by < > characters are accepted, for example:

        WRITE (4,'(/,I< ilength >)') n

• Embedded expressions in formats, delimited by < > characters, may be converted automatically to standard Fortran 77. The code above, for example, is converted to:

        CHARACTER*(10) embedded_expressions (1:4)
            :
        WRITE ( embedded_expressions (1),'(1I10)') ilength
        WRITE (4,'(/,I'// embedded_expressions (1)//')') n

  (This method was published in comp.lang.fortran by Tim Prince).

• VMS external parameters (Psychic parameters) are supported on all hosts. For example:

        EXTERNAL FOR$IOS_ENDDURREA
          :
        IF (ISTAT .EQ. %LOC(FOR$IOS_ENDDURREA)) THEN

  Commands are supported to convert these automatically to standard parameters.

• The Gould-SEL (Encore) DATAPOOL construct is fully supported.

  DATAPOOL has been supported by FPT for several years, but in earlier versions the DATAPOOL was automatically converted to a standard Fortran 77 COMMON block. FPT version 3.3-s allows the DATAPOOL statements to remain in Gould-SEL format.

• Gould-SEL logical file codes are supported. These are short strings used instead of logical unit numbers, for example:

        WRITE('DT1',400)X,Y,H,P,Q,R

• The Gould-SEL run-time EXTENDED BASE construct is supported, for example:

        EXTENDED BASE /VPX/*

• Right-justified Hollerith assignments are supported, for example:

        TFC=4R TT6

• Optional comment delimiters X and Y are accepted and are converted to standard comment delimiters.

• Directives introduced by '%' characters in column 1 are accepted, but are treated as comments.

• The PAGE keyword is accepted. PAGE is used to control list file format in Gould-SEL (Encore) Fortran. A command is provided to comment-out the PAGE statements.

• HP3000 partial word designators and sub-string designators are accepted. Partial word designators are written, for example:

        ISTAT[12:4]=IE[8:4]

  where ISTAT and IE are integers, and 4 bits starting at bit 8 are copied from IE and are written into 4 bits in ISTAT starting at bit 12.

  Sub-string designators are written, for example:

        OUTSTR[22:32]=VNAME[1,32]

  where, in each bracketted expression, the first number is the character position and the second number is the length of the sub-string.

• The total size of a COMMON block is now tracked through each sub-program in which it occurs. FPT now issues a warning if the size of a named COMMON block varies between sub-programs.

• The command: INSERT INCLUDE FILES INLINE has been added. This is particularly useful in preparing code for the HP-UX Fortran 90 compiler, which may generate a bad symbol table for the interactive debugger when INCLUDE files are present.

• Directives may be inserted in template (FTM) files which specify specific default arguments which are to be inserted by the CORRECT MISSING ARGUMENTS command.

• The command ADD PARENTHESES TO FUNCTION DECLARATIONS supplies empty parentheses for function declarations in which they have been omitted. The parentheses are required in the Fortran 90 standard and by some compilers, but are optional on many systems.

• The command REMOVE LINE COMMENTS AFTER END deletes line comments between an END statement and the end of a file. Some compilers see text following an END statement as the start of a new sub-program, even though no declaration or executable statements are present.

• The command REVERSE OUTPUT FILE NAMES causes output file names to be written with the extension first, followed by the base name. Thus, for example, the input name ST_SP1.F is reversed to read F.ST_SP1. This is the format required by the Gould-SEL (Encore) MPX operating system.

• There are new commands to edit the file names written in INCLUDE statements. The names of the files written to the output directories are not affected. It is then possible to use FPT under one operating system to prepare code for execution on another. We have used this command in-house to prepare code for compilation under MPX, while running under Linux and Win32.

• The handlers for strings and format statements which extend across multiple lines have been revised. If a string is written across multiple continuation lines in Fortran 77 fixed or tab format, the interpretation of the string is dependent on the compiler and on compilation switches. For example, with fixed format 72 column input, the interpretation depends whether the compiler counts trailing spaces or assumes that there are 72 characters in the line, and on the interpretation of tab characters in the line. FPT now attempts to generate compiler-independent code. (Note that the problem does not arise in Fortran 90 free format. A token may be broken and resumed by the use of '&' continuation characters).

• FPT uses different formatting rules and commands for header comments at the start of a sub-program and for comments within the code. In earlier versions of FPT, the header contained all comments written before the PROGRAM, SUBROUTINE, FUNCTION or BLOCK DATA statement, and all comments written between this statement and the first declaration. OPTIONS and OPTION statements were also permitted within the header. In FPT 3.3-s, the header may also contain SAVE and IMPLICIT statements, and the rules for formatting the code body are not applied until the first declaration statement is encountered.

• The commands CHANGE REAL SIZE and CHANGE COMPLEX SIZE change the declaration statements for variables. They now also change the way in which literal numbers are written. Thus, for example:

        PHID = 53.2

  is converted by the command

  CHANGE REAL SIZE TO: 8    to

        PHID = 53.2D0

  This is particularly useful in preparing code for the HP-UX Fortran 90 compiler where real literal numbers default to single precision even though they are used in double precision arithmetic.

• The commands which change data sizes, CHANGE INTEGER SIZE etc., no longer change the sizes of arguments specified in template (FTM) files.

• The CORRECT ARGUMENTS command now has an option to correct the lengths of string arguments when the length of the actual argument differs from the length of the formal argument. Most compilers automatically pad or truncate a string when there is a length mis-match. Some, in particular the Absoft compilers, make no correction and data corruption may occur.

• Syntax restrictions on OPTION and OPTIONS statements have been relaxed. There are no universal conventions for the syntax of OPTIONS statements, and some of the more unusual statements could generate spurious errors.

• Fortran 90 declaration statements with multiple attributes were formatted poorly when COLUMN FORMAT DECLARATIONS was specified. This has been corrected.

• The command CHECK NAMES failed to report Fortran PARAMETERs of type CHARACTER with different values in different sub-programs. In some circumstances FPT also failed to report names used for variables in COMMON on one sub-program and for local variables in another. Both errors have been corrected.

• In some contexts, the usage check failed to recognise that the members of NAMELIST sets could be read or written to in namelist-directed I/O statements. This has been corrected.

• The usage check failed to recognise that a variable could be read or written when its address was passed into a sub-program as, for example, LOC(X) or %LOC(X). This has been corrected.

• The command MAXIMUM BASE FILE NAME LENGTH could generate incorrect file names if the entire output file name length became very much shorter than the original length. This is corrected in FPT 3.3-s.

• FPT correctly recognises internal WRITE statements which write into character variables, for example:

        WRITE(WORK_STRING,400) I

  However, some code modification commands were confused when the character variable was labelled by a UNIT= specifier, for example:

        WRITE(UNIT=WORK_STRING,400) I

  This is corrected in FPT 3.3-s.

• The command CORRECT USE OF INTEGER FOR LOGICAL can convert expressions of the form:

        IF (ISTAT) GOTO 999

  where ISTAT is integer, to

        IF (IAND(ISTAT,1) .NE. 0) GOTO 999

  However, the literal value 1 is (by default) INTEGER*4. A problem arises on some systems is ISTAT is INTEGER*2. FPT now matches the sizes of the operands.

• The command SPECIFY GLOBAL SAVE could, in some circumstances, write the SAVE statement after, rather than before an INCLUDE statement. This has been corrected.

• The command LOWER CASE SYMBOLS could prevent the recognition of a symbol name in an FPT directive written in the code. In particular, this could affect the interpretation of %INTENT directives. The problem is corrected in FPT 3.3-s.

• Control characters typed to the FPT prompt could cause some of the Unix versions of FPT to hang. This has been corrected.

• New formatting commands allow conversion from fixed or tab format to free format code, and back again.

• Labelled DO - CONTINUE constructs may now be replaced automatically by DO - ENDDO constructs, optionally removing the statement labels.

• An error has been corrected which, in some circumstances, prevented the translation of VMS library references where the entire file name is enclosed in parentheses, for example:

        INCLUDE '($FORIOSDEF)'

• Support for the data type DOUBLE COMPLEX (as opposed to COMPLEX*16 or COMPLEX*32 ). Commands are supported to convert between the different type declarations.

• Support for binary literal values, for example, B'1001' or '1110101'b (Hex and octal literals have always been supported).

• The Win32 version now supports file and directory names which contain spaces. A side effect is that FPT may now be installed below C:\Program files.

• FPT version 3.3-d has improved error handling for the Gould-SEL (Encore) DATAPOOL construct. Version 3.3-e also supports the Gould-SEL keyword OPTION (as opposed to OPTIONS ) and the less common arguments to the OPEN keyword, for example, MININCREMENT=... and SPOOLFILE=... (There is no advantage in upgrading from version 3.3-c unless you use Gould-SEL Fortran).

• The command show logical units may be used interactively in version 3.3-e.

• Internal READ and WRITE statements to non-character arrays are now supported. This conforms to the observed behaviour under VMS and some other systems. They are marked by diagnostics.

• An exclamation mark in column 6 is now accepted as a continuation character, not as a comment delimiter. A diagnostic is issued!

• The interpretations of DO without arguments and LEAVE have been revised to conform to the Gould-SEL (Encore) MPX usage.

• Formatting of comments has been revised to keep Gould-SEL or IBM line numbers in column 73 (The truncate command now removes them completely).

• The FPT rename command has been revised to allow sub-programs and common blocks to be renamed explicitly without affecting the names of variables.

• Error handling has been revised. A new command suppress all errors allows all diagnostics to be removed from the output code. This prevents the accumulation of old error messsages when code is cleaned-up in several sessions. The warning that EXIT is a Fortran keyword may now be suppressed independently of the warnings for other keywords.

• Some spurious error messages have been removed in handling unusual arguments to INQUIRE and in handling sub-program arguments used to declare array bounds.

• Errors have been corrected in the interactive interface to FPT. These did not result in the generation of incorrect code, but were sometimes frustrating. In particular, the interface to check data types has been revised.

• % change ISAM file accessess to sub-program calls
  % change I/O to sub-program calls

  have been revised. The code generated is simplified.

• % correct inconsistent arguments
  

  has been revised and some (very rare) errors have been corrected.

• % show logical units
• % check data types
• % check data in common blocks
• % check data in structures
• % correct use of integer for logical
• % change all I/O to sub-program calls
• % remove %DESCR
• % change character parameters to CHAR() or to HEX

Diagnostic handling, and many other features have been extensively revised.