WinFPT and FPT Version 3.7-m
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.
SHOW INCLUDE TREE and SHOW 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 translating 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
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.
WinFPT and FPT Version 3.7-d
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.
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!)
WinFPT and FPT Version 3.7-a
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
and module a is used by module b, which contains an interface
INTERFACE OPERATOR (*)
MODULE PROCEDURE str_mult_ch_ch
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
Checks and Reports
Earlier versions of FPT sometimes reported a spurious array reference out-of-bounds in references of
INTEGER :: ia(0:10)
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.
WinFPT and FPT Version 3.6-n
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.
WinFPT and FPT Versions 3.5-j to 3.6-l
Versions 3,6-l and later support overloading of the pre-defined Fortran operators.
Overloading is specified in INTERFACE OPERATOR
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
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
% write stop statements on one line
Versions 3.5-l and later support the HP-UX ON keyword used to specify exception handling,
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
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:
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
A = B(i)
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.
FPT 3.5-a to FPT 3.5-i
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
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
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.
FPT 3.4-l to FPT 3.4-w
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 3.4-h to FPT 3.4-k
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
FPT 3.4-a to FPT 3.4-e
%edit symbols names
systematically edits the names of user-defined symbols throughout a program.
It may be used, for example, to replace the
$ characters used in
variable names in Gould-SEL (Encore) and Compaq VMS Fortran respectively.
%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.
%check program flow
has been implemented. This command shows statements which cannot be reached
during program execution.
FPT 3.3-v - Changes since FPT 3.3-u
Handling and checking of statement labels has been revised.
An error has been corrected in handling embedded format expressions
containing string concatenation,
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.
FPT 3.3-t - Changes since FPT 3.3-s
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
is now generated only if it is required. In earlier versions it was generated
whenever the command
%CORRECT MISSING ARGUMENTS
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:
%COMPLETE REAL NUMBERS changes numbers written, for example,
17.0 respectively. It now
also converts exponentiated numbers, for example,
FPT 3.3-s - Changes since FPT 3.3-i
New Features and Commands - Fortran Language
New Features and Commands - Checks and Analyses
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:
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:
The Gould-SEL run-time EXTENDED BASE construct is supported, for example:
EXTENDED BASE /VPX/*
Right-justified Hollerith assignments are supported, for example:
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
HP3000 partial word designators and sub-string designators are accepted.
Partial word designators are written, for example:
where ISTAT and
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:
where, in each bracketted expression, the first number is the character position
and the second number is the length of the sub-string.
New Features and Commands - Code Modification
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.
Changes to Existing Commands and Features - Fortran Language
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
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.
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
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.
Changes to Existing Commands - Code Modification
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 '&'
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.
Bug Fixes and Error Corrections - Fortran Language
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.
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
Bug Fixes and Error Corrections - Checks and Analyses
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
COLUMN FORMAT DECLARATIONS
was specified. This has been corrected.
Bug Fixes and Error Corrections - Code Modification
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,
This has been corrected.
Bug Fixes and Error Corrections - Interactive Environment
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:
However, some code modification commands were confused when the character variable
was labelled by a
UNIT= specifier, for example:
This is corrected in FPT 3.3-s.
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.
SPECIFY GLOBAL SAVE could, in
some circumstances, write the SAVE statement after, rather than before an
INCLUDE statement. This has been corrected.
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 features in FPT 3.3-h and FPT 3.3-i
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:
New features and revisions in FPT 3.3-f
Support for the data type
(as opposed to
). Commands are supported to convert between the different type declarations.
Support for binary literal values, for example,
(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
FPT 3.3-d and FPT 3.3-e
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
(as opposed to
) and the less common arguments to the
keyword, for example,
(There is no advantage in upgrading from version 3.3-c unless you use Gould-SEL
show logical units
may be used interactively in version 3.3-e.
Revisions in FPT 3.3-c
statements to non-character arrays are now supported. This conforms to the
observed behaviour under VMS and some other systems. They are marked by
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
without arguments and
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
command now removes them completely).
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
is a Fortran keyword may now be suppressed independently of the warnings for
Some spurious error messages have been removed in handling unusual arguments to
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.
Revisions in FPT 3.3-b
- % 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.
New commands in FPT V3.3-a include:
Diagnostic handling, and many other features have been extensively revised.