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

• If you have a workstation licence, you may use FPT on any supported host.

• If you have a PC licence, you may use the Intel Linux, Win32 and DOS releases.

• The documentation may be downloaded without restriction.

Download the New Versions

• 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.