- ALLOCATE regression in 5.20
- Support for Visual Studio 2008
- Additional project support in Visual Studio 2005/2008. User folders can now be created in the solution explorer
- Plato Version 4 now supports Unicode. Note that version 4 is not compatible with Windows 9x
- Further support for Windows Vista and Windows Server 2008
The following is a summary of FTN95 bugs that have been fixed at version 5.20.
- 'Compile' file in Visual Studio solution explorer behaviour fixed.
- Further fixes and support for debugging under Vista.
- False type warning when using REAL(COUNT(i)) as an argument.
- Error not reported for array assignment with mismatched shapes.
- ALLOCATE does not fail when size of block overflows.
- /OLD_ARRAYS gives a false error report when A(1) is not an argument.
- Missing "TYPE" in "END TYPE" causes a module to terminate prematurely.
- Error not reported when named DO statement does not have matching ENDDO name.
- OPENF@ not working under .NET.
- NINT(AR,1) fails for two-dimensional array AR.
- PRIVATE not implemented when member is used in module.
- Initialisation of TYPE members within a MODULE fails for large arrays.
- "Operand incompatible with opcode" failure on integer*1 = integer*4 assignment.
- USE ONLY f=>g does not link when the function g is declared in another module.
- Compiler crashes when writing linker data for a certain module.
- Warning about unreachable code not provided in /DEBUG mode.
- SUM intrinsic used as argument for DOT_PRODUCT does not compile.
- IBITS not working for INTEGER*8.
- /CONVERT not working.
- IACHAR not available in array initialisation implied DO loop.
- Explicit declaration needed for a function used on RHS of a statement function.
- False warning when compiler-defined constant is not used.
The following changes has been made:
- Use of ALLOCATABLE in TYPE declaration is now tollerated though not standard conforming.
- /WIDE_SOURCE limit increased to 1024 characters per line.
- GET_COMMAND_ARGUMENT intrinsic function, character limit increased from 128 to 256.
- Improved compatibility with AMD Geode range of processors
- Improvide Vista support from SDBG and Visual Studio Win32 debugger
The following is a summary of FTN95 bugs that have been fixed at version 5.10.
- Poor error report when MAX is used with an array argument.
- .NET false error report about miss-matched argument types in function call.
- False warning with ALLOCATE, statement will not be executed.
- ABS not implemented for INTEGER*8.
- Missing error report when trying to use JUMP@ under .NET.
- Some array sections not checked at runtime for shape conformance.
- Another .NET false error report about miss-matched argument types.
- Operand incompatible with opcode failure with particular use of TRANSFER intrinsic.
- False warning, RESULT not set in certain recursive function definitions.
- Character variable in a particular WHERE test gives internal compiler error.
- An INCLUDE statement corrupts some CONTAINed subroutines.
- False error report for certain internal PURE routines.
- FORALL statement using SUM intrinsic fails to initialise correctly.
- User-defined assignment was not implemented in the context of an paricular array assignment.
- Regression in Plato3 fixed: Problem with project file list and dependency
checking.
- Regression in FTN95 fixed: Arrays were not correctly initialised (i.e.
simultaneously declared and initialised) in modules.
- In some circumstances the Visual Studio 2005 integration was not fully installed and theefore not fully functional.
- Arguments are now passed to the debugee when using the Visual Studio debugger in Win32 mode
- NEW FEATURE: Visual Studio 2005 integration.
- NEW FEATURE: Microsoft .NET 2.0 compatibility.
The following is a summary of FTN95 bugs that have been fixed at version 5.00.
- REPEAT intrinsic has 32K limit on second argument.
- Illegal memory reference bug in matrix reallocation program.
- UNDEF failure with OPTIONAL character argument.
- Register tracking failure over INVOKE.
- Use of /PROFILE can cause incorrect function return.
- Missing label not reported when followed by CONTAINS.
- Recovery from underflow is not automatic for Win64.
- <= is not parsed correctly in some situations.
- Particular use of User-defined == operator fails.
- Optional INTENT(OUT) causes runtime failure with FULL_UNDEF.
- Initialisation fails with TARGET and UNDEF.
- Regression at 4.9. Assigned GOTO does not work in fixed format.
- Regression at 4.9. Access violation when reading a MODULE.
- BIT_SIZE does not work for 64 bit integers.
- SIZE = len fails in READ statement.
- INTENT(IN) does not prevent assignment via a READ statement.
- Incorrect result for a particular use of the TRANSFER function.
- Incorrect result for a complex arithmetic calculation.
- Size of .NET debug information reduced
- An assigned GOTO with array value failed to compile.
- An access violation occurred when reading a certain TYPE from a module.
- Changes essential for using /F_STDCALL
- NEW FEATURE: /LOCAL_ZERO added for .NET only. Like /ZEROISE but for local variables. Cannot be used with /UNDEF.
- NEW FEATURE: Size of /UNDEF executable reduced for .NET MODULE containing large array.
- NEW FEATURE: Size of .NET DLL reduced when it contains a large MODULE array.
- NEW FEATURE: NET OBJECTs can now be initialised when declared.
- NEW FEATURE: REAL assigned to hexadecimal value now generates a warning.
- NEW FEATURE: /F_STDCALL option added for Win32
The following is a summary of FTN95 bugs that have been fixed at version 4.9.
- Missing member initialation in array elements of user-defined TYPE.
- INQUIRE(PAD=...) missing.
- Runtime problem with SHAPE intrinsic - arrays erroneously reported as not conforming.
- Corrupt header of very large record in unformatted IO.
- INTEGER i = 'F' does not generate warning or code for .NET.
- /OPT failure with benchmark test
- INTENT(OUT) fails for .NET objects with /CHECK.
- FORALL construct gives incorrect results for multiple "overlapping" assignments.
- FORALL construct expanded incorrectly.
- Call to routine with optional arguments fails under /CHECK.
- False error report with MVBITS.
- NET false runtime error "Array subscript > upper bound".
- False compilation error "Duplicate sub-program name".
- Problem with implied-DO in PARAMETER initialisation.
- /OPT failure - mixed REAL*4 and REAL*8 in DO-loop assignment.
- False compilation error for computed GOTO with integer expression.
- /STATISTICS gives floating point exception for "zero" elapsed time.
- /INTS should not over-ride INTEGER*4.
- INTENT(IN) problem with /CHECK and .NET DLL.
- Problem with different TYPEs with same member name.
- Garbage collection problem under .NET.
- Temporary array overwrites allocated array.
- False /CHECK runtime error "Too few array elements".
- Member of TYPE falsely reported as missing.
- False error report with pointer assignment.
- TYPE constructor fails when passing a pointer.
- INQUIRE gives error when calculating IOLENGTH of TYPE.
- NEW FEATURE: UNDEF array values in a MODULE are nolonger stored as static values.
- NEW FEATURE: ASSEMBLY_INTERFACE extended to allow pass by reference.
- NEW FEATURE: SLINK modified to make executables "Large address aware".
- NEW FEATURE: New comment embedded directives added (see help file).
- NEW FEATURE: UBOUND and SIZE can be used with .NET arrays.
- NEW FEATURE: /UNDEF applied to .NET NEW@ array.
The following is a summary of FTN95 bugs that have been fixed at version 4.8.
- Automatic DEALLOCATE (on exit from subprogram) not implemented for .NET.
- IO problem when OPEN follows OPEN on the same unit without intervening CLOSE.
- Regression. Blank lines after a comment causes error report line numbers to go wrong.
- /OPTIMISE problem when ASSIGN TO is used in a DO loop.
- ALLOCATE size is incorrect when calculated using INTEGER*1 variable arithmetic.
- Paricular application of MVBITS under .NET gives incorrect result.
- NET problem with MODULE procedure that has an internal function.
- Locked register problem with PRODUCT.
- Problem with open_wav_file_read@ when invalid file is encountered.
- IO is not initialised when READF@ called without prior OPEN etc.
- Foating point stack overflow problem. Incorrect assembly instruction under Win32.
- Problem with CSHIFT when used with /SAVE and /CHECKMATE.
- INTENT(INOUT) used with array passes incorrect address.
- False warning with INQUIRE and implied DO.
- NET problem with /DEBUG etc, too many members in TYPE causes access violation.
- NET problem with /CHECK and passing character variables to subprograms.
- False warning 133 with .NET and /CHECK.
- NET assignment of 2-dim .NET array element to variable does not work.
- NET assignment of character variable to string does not work when string is an argument in a subprogram.
- VAX style DATA list does not work for CHARACTER variables.
- Regression. Problem with CODE command when full stop is the first character in an assembly comment.
- ENTRY point problem under .NET when using /UNDEF.
- False warning with logical IF statement.
- FCORE4 failure at runtime when using /CHECK.
- Bug fix for regression at 4.70 concerning subprogram ENTRY
points
- Windows XP control styles are now available.
- Fix for fatal error in 4.70 release of Plato3; this occurred when
restarting a project after a project file had been deleted.
- A subprogram ENTRY point problem in .NET dll.
- Regression. A subroutine ENTRY point problem - incorrect bound for 2-dim
automatic array.
- An alternate RETURN fails for subprogram with CHARACTER argument.
- A .NET problem with DATE_AND_TIME optional arguments.
- A Win32 problem when storing long CHARACTER variables in a MODULE.
- A Win32 problem when using CHAR intrinsic in a subprogram.
- A .NET linker problem when using optional arguments.
- A .NET problem with /FULL_UNDEF when using CHARACTER variables.
- A Win32 problem with /CHECK - subprogram fails to match generic.
- A JIT (.NET) problem when printing a substring and compiling with
/CHECKMATE.
- Regression. Complex expression has incorrect sign.
- A Generic functions fail to distingish between .NET objects.
- An array name beginning with "IF" fails to parse.
- A CHARACTER PARAMETER name beginning with "FUNCTION" fails to parse.
- A problem with EQUIVALENCE linked to COMMON BOLCK.
- An optimising problem with MINLOC.
- Passing TRIM(ADJUST(C)) as an argument gives access violation.
- A problem with differing TYPEs having the same member name.
- /UNDEF does not trap scalar argument when array is expected.
- A vector subscript in implied DO loop causes run-time access violation.
- A problem with INTEGER PARAMETER used as KIND value in IMPLICIT REAL
statement.
- /ALT_KINDS documented but not implemented.
- IN(...) FORALL(...) not implemented.
- A problem with parsing f(d%list(1)%array).
- A problem with WHERE statement when LHS of assignment is ALLOCATABLE.
- A problem with PUBLIC attribute in mutually recursive TYPEs.
- A false error message for pointer assignment.
- A problem with array section for array member of user-defined TYPE.
- "LIBRARY" cannot be used as the name of a variable.
- A problem passing signed array argument to a generic function.
- A problem with member intialisation when one TYPE is derived from another.
- A false run-time error "Active do-loop index altered".
- An assumed size array falsely accepted in subroutine.
- A problem passing array section to function that returns an array.
- A problem with ENTRY point and unused argument.
- A false error message for rank of WHERE construct.
- A false error message for rank of WHERE construct nested in FORALL.
- A DO WHILE test not calculated correctly.
- A problem with execution order in array of elements of user-defined TYPE.
- A missing bounds check for an array section.
- A problem with DO loop variable declared in a MODULE.
- A problem when calling TRANSFER from a
subroutine.
- Attempting to index a scalar value element of a derived type was causing a compiler crash. The compiler now issues an error message.
- Introduction of a C-style preprocessor, making use of #ifdef..#endif etc. This requires the use of the compiler switch /CFPP.
- A problem where the type of an allocatable array in the main program block was not being shown in the debugger when there is a contained routine has been fixed.
- The TRIM intrinsic was returning garbage when used on a local character variable with length determined by an argument. This has been solved.
- Calling the size intrinsic with a call to the pack intrinsic as its argument was causing a crash at runtime. This has been fixed.
- Arrays with the INTENT(OUT) attribute are now set to the undefined state on entry to the routine they are defined in when using /FULL_UNDEF.
- An unwanted "END statement not executed" warning, produced when an alternate return and format statement have been used, has now been removed.
- A problem where variables declared in a module cannot be seen correctly from the main program in a different file has been fixed.
- The compile option is now shown in each file's context menu in the Visual Studio .NET FTN95 plugin even when Visual C++ .NET is not installed.
- A problem with ALLOCATE returning an invalid pointer in some cases when a result statement is used has been solved.
- When a function has been overloaded and all overloads accept a pointer to an array of differing rank as their only argument then a compile time error was produced. This has now been fixed.
- Attempting to call a subroutine that expects an array argument with a scalar now gives an error when compiled with /CHECK.
- A new Win32 debugger is avaliable for Microsoft Visual Studio .NET 2003 capable of debugging Salford applications.
- The F2000 standard keyword 'TYPEALIAS' is now accepted as well as the non-standard variant, 'TYPE_ALIAS'.
- .MOD files will now only be updated if any interface or module variable is changed (or added or deleted). This reduces the number of compilations required when using makefiles, for example.
- A memory leak related to IF constructs and the generation of array temporaries has been fixed.
- Assumed shape arrays in ENTRY statements could in some circumstances cause invalid errors. This is now solved.
- Spurious errors could be caused with derived type constants containing array pointer components. This has been fixed.
- An Internal Compiler Error with UBOUND has been solved.
- CHARACTER variables used with UNPACK could generate invalid machine instructions, this is now solved.
- A problem related to Real*10 and equivalence in certain cases has been fixed.
- A problem with namelists contained within modules has been fixed.
- A problem related to very large source files containing thousands of labels has been solved.
- An equivalance bug related to the re-use of a value from a register rather than memory has been fixed.
- A problem related to bit_test@ has been solved. BTEST was not affected.
- Some problems using mixed CHECK and DEBUG code have been identified and solved.
- An internal compiler error concerned with the use of array valued functions in some cases has been fixed.
- Calling routines with CHARACTER,POINTER elements of a derived type now behaves correctly in all cases.
- A problem related to the printing of an array with array name as index has been solved.
- A CHECK problem where missing OPTIONAL arguments were not detected has been fixed.
- An internal compiler error related to derived type array component elements in exceptional circumstances has been fixed.
- An INQUIRE issue with IOLENGTH related to derived types has been solved.
- A problem related to CHECK and statement functions has been fixed.
-
ASSEMBLY_INTERFACE statements are
not permitted in MODULE or CONTAIN'ed routines in /CLR mode. Only routines that
would normally be callable by other .NET languages can be exposed and called in
this way. A new diagnostic has been introduced to correctly inform the user of
this.
-
Incorrect reporting of some source formatting errors has been fixed.
-
Generic interfaces having the same name as a specific contained within the interface
are now handled correctly in all cases.
-
Erroneous symbols being added to debuggable MODULE's when inside type definitions
have been removed.
-
Derived types with pointer components behave correctly in all cases.
-
Calling array valued functions in modules in .NET configuration was causing problems n some cases. This is
fixed.
-
.NET enumerations passed from .NET languages to Fortran now behave correctly.
-
A .NET linker error related to calling contained routines has been fixed.
-
An UNDEF problem related to derived types with pointer elements has been fixed.
-
Derived types with the SEQUENCE attribute that are used as routine arguments behave
correctly in .NET mode when declarations of the TYPE appear both in caller and callee.
-
A problem related to some temporary variables being incorrectly SAVE'd with the use
of a global SAVE statement has been fixed.
-
Use of ALLOCATED has been restricted to ALLOCATABLE arrays as specified by the
standard with /ISO, a warning is generated as standard. ASSOCIATED should be used for
POINTERS.
-
A problem related to pointer assignment in unusual circumstances has been resolved.
-
A problem related to /INTS when using some mathematical constucts has been resolved.
-
Compatibility with version 1.1 of the .NET framework.
-
FTN95 now integrates with Microsoft Visual Studio .NET 2003.
-
Other miscellaneous bugs fixed.
-
/CONFIG producing an access violation has been fixed.
-
Win32 DLL's can now be called from .NET correctly in all cases.
-
An optimisation problem related to nested DO loops within contained routines has been
fixed.
-
An optimisation problem related to the use of special loops for for loops in certain
circumstances has been fixed.
-
Another optimisation problem related to maxval and related functions has been fixed.
Use of non-numeric arguments in calls to MIN/MAX diagnosed correctly.
-
Several bugs related to /P6 have been fixed.
-
Many optimisation improvements have been identified and implemented. This results in a
significant speed increase with code compiled with /OPTIMISE (~10% or more).
-
A problem with the initialisation expressions in calls to REAL in certain circumstances
has been fixed
-
A problem related to the upper and lower bounds of some pointer arrays has been fixed.
-
A /CHECK problem with an incorrect error of "Active do-loop index altered" solved.
-
A specific problem with calling TRANSPOSE with certain arguments in a WHERE block has
been fixed.
-
NAMELIST and aliasing now behaves correctly.
-
A problem in /CHECK mode where /INHIBIT_CHECK 11 was previously required has been solved.
-
Problems with an assignment of a matmul result to an array section in some cases has been
fixed.
-
Nested array valued intrinsics now behave correctly accross the board.
-
ISTAT is set correctly when an UNALLOCATED variable is DEALLOCATED in all cases.
-
Character vaiables will only accept assignments of character variables.
-
Functions being called as subroutines correctly detected.
-
Some uses of STDCALL routines inside MODULE's were causing problems with argument
mismatches, now fixed.
-
Use of intrinsic names as variables inside modules in certain circumstances is now fixed.
-
Other miscellaneous bugs fixed.
-
A debugger problem related to
modules precceding the main program within the same file has been fixed. Module
variables now display correctly in the debugger.
-
Entry statements with the same
result variable as a function with a result clause now behave properly when the
variable is used after the entry statement. A related problem with variables
declared as INTENT(IN) when using entry statements that contained the dummy
argument has been fixed.
-
Use of an array as a result
variable in a public function contained within a module used to produce an
erroneous error message.
-
A problem related to Integer*2
causing an internal compiler error when used in a substring statement when
compiling with /UNDEF has been fixed.
-
A MINLOC/MAXLOC problem when two
values were the same in an array, where the pos of the second (or higher) value
was being picked up, in certain circumstances has been fixed for both Win32 and
.NET.
-
If a library file is not found
when using the LIBRARY directive when using Visual Studio .NET a dialog is
presented allowing the user to choose the correct file.
-
A problem with recursive entry
statements implemented in certain circumstances has been fixed.
-
An optimisation, where array
temporaries are not required for one dimensional array sections has been
introduced.
-
If a do-loop index was
subsequently used as an array constructor variable inside the same do-loop, the
index was incremented incorrectly. This has been fixed.
-
A problem related to calling
functions via an interface with OPTIONAL and keyword arguments in certain
circumstances has been fixed.
-
Automatic arrays larger than
19648 bytes in CHECK mode were failing at runtime, this has been solved.
-
An equivalence bug with multiple
equivalences in some circumstances has been fixed.
-
Allocatable arrays which have the
SAVE attribute are now correctly dealt with.
-
A problem with ENTRY statements
inside MODULE's with in .NET configuration has been fixed.
-
Square brackets can now be used
for array constructors.
-
New intrinsics, GET_COMMAND and
COMMAND_ARGUMENT_COUNT and GET_COMMAND_ARGUMENT added, these are part of the
Fortran 200x standard.
-
A problem related to optional
arguments when calling generic functions in certain circumstances has been
fixed.
-
Other miscellaneous bugs fixed.
-
The default directory structure
has been changed to "C:\Program Files\Salford Software\FTN95". It was changed
to conform with 'standard practice' and for compliance with standards for
Microsoft .NET (which we are now supporting). Please accept our apologies for
any inconvienience caused.
-
A new switch is available, /CLR -
this enables FTN95 to produce code suitable for the Microsoft .NET runtime
environment. Note that a new linker DBK_LINK.EXE is required to link .NET
object code (.dbk files). This enables transparent mixing of FTN95 generated
code with other CLR language code such as C# and VB .NET.
-
FTN95 can now be used inside
Microsoft Visual Studio .NET, with the usage of a Visual Studio .NET plugin.
Multi-threaded programming is possible in .NET configuration using the switch
/MULTI_THREADED.
-
Further improvements have been
made to the IO library, with the .NET IO library operating completely in .NET
managed C++.
-
A bug related to characters being
invalidly replaced has been fixed.
-
Some minor equivalence fixes have
been made.
-
A floating point stack overflow
in /CHECK mode with very large source files has been fixed.
-
A problem with read statements in
implied do loops has been fixed.
-
CPU_TIME intrinsic now returns
correct processor time on NT based systems.
-
Business format for Integer*8
fixed.
-
A character comparison bug has
been fixed where the right hand side of the expression was empty in certain
circumstances.
-
Changes have been made so that
debug relocation entries in excess of 64K are handled correctly.
-
Many other miscellaneous bug
fixes.
-
There is a new option,
/NO_SCALAR_TO_ARRAY, available. This option will make the compiler treat an
'<array> = <scalar>' assignment expression as an error.
This can be useful to debug old code.
-
Improvements have been made to
the IO library with much of the code being replaced.
-
Reentrant IO has been implemented
in order that functions within IO statements may themselves perform IO, this is
an extension to the standard. This is disabled by default and can be enabled by
calling the function: enable_reentrant_io@(.TRUE.)
-
Many miscellaneous bugs have been
fixed.
-
The SAVE attribute for large
arrays in functions has been modified such that the array is no longer included
in the object file. This can in some situations give a great reduction in
object and executable file size.
-
Many small problems found when
utilising advanced features of the Fortran 95 standard have now been overcome.
-
The link between ClearWin+ and
OpenGL has been extended. Many existing OpenGL applications are written in
terms of an additional library of functions known as GLUT.
-
Many of the GLUT routines - such
as those which construct models of entire objects - are now directly callable
once an OpenGL window has been opened using %OG. Other functions are declared
in OPENGL.INS in such a way that the GLUT function is replaced by an equivalent
function in SALFLIBC.DLL.
-
Thus the only change which
should be required to make a GLUT/OpenGL Fortran program work under ClearWin+
is to include OPENGL.INS in any routine which makes GLUT calls.
-
A new option is available with
Win32 compilers, /PROGRESS_METER, which will add an estimate of how far the
compilation has progressed on the console title bar (like "FTN95 (50%)") when a
compilation is estimated to take longer than about a second.
-
The environment variable used to
configure the compiler has been renamed to SALFORD_COLOUR from FTN95COLOUR.
Versions of the C++ compiler newer than 3.06 and versions of SLINK newer than
1.27 will use this variable also. This is the only way to get SLINK to display
colours, use "set SALFORD_COLOUR=*" if you want to switch on colour without
changing the defaults.
-
The compiler now supports a new
syntax for specifying zero-terminated strings (for passing to C/C++ routines):
"foo"C (as in Compaq Visual Fortran.) This can save a C_EXTERNAL statement for
simple calls, although C_EXTERNAL is still the recommended way to interface to
C, as the zero-termination used here works for variables, as well as permitting
call-by-value arguments.
-
"FTN95 /?" output has been
enhanced (especially with Win32.) The line-wrapping routines used to output the
help now work correctly. /PAUSE is no longer required with Win32 compilers, as
the output will automatically pause after every screenfull.
-
A new option, /HEXPLIST, has
been added which is similar to /EXPLIST, except that the actual hexadecimal
bytes for the instructions generated are also output in the .LIS file.
Subprogram calls and references to SAVE, COMMON, MODULE or PARAMETER data will
not have the correct addresses fixed up yet so these bytes will differ after
the linking process is complete. This option is mainly intended for (very)
low-level debugging.
-
A new datatype, INTEGER(KIND=4), has been added. This
is a 64 bit integer type. As the x86 architecture only provides native support
for this datatype using the FPU, programs will be considerably slower using
this type compared to INTEGER(KIND=3). Note that the compiler's memory
limitations are still 32-bit (e.g. array indices). Note also that several
components of the run-time system (e.g. the IOSTAT=var, INQUIRE(...)) will not
work correctly when INTEGER(4) arguments are given to them. Actual Input/Output
of these large integers is fully supported, however. Because of this we do not
recommend the use of "/DEFINT_KIND 4" unless there is only simple (or no) I/O.
-
A new compiler option is available with the compiler:
"/COLOUR". This will cause the compiler to output colour messages using
low-level console routines with win32 versions of the compiler, or to output
ANSI sequences with DBOS versions of the compiler (requires ANSI.SYS or
equivalent to be loaded.) These colours can be redefined with win32
compilers using the environment variable "FTN95COLOUR" which has the following
syntax:
SET FTN95COLOUR=<e>[;<w>[;<c>[;<s>[;<l>]]]]
where <n>,<l>, <e>,<w>, and <c> are one of the
following:
k - blacK
b - Blue
g - Green
c - Cyan
r - Red
m - Magenta
y - Yellow
w - White
* - Use default value
A preceding hyphen indicates that high intensity will be used. The values
specify the following colours:
<e> Error messages
<w> Warning messages
<c> Comment messages
<s> Summary lines (e.g. "NO ERRORS [<...> FTN95/WIN32 v2.00]")
<l> Program source in error reports
An example setup would be:
set FTN95COLOUR=-r;r;y;-w;-y
If this environment variable is unset (or the compiler is a DBOS version), the
compiler will assume a value of "-r;-y;-g;w;-w" for FTN95COLOUR.
-
The environment variable FTN95ANSI is now ignored.
-
Some support has been added to aid users wishing to use
MMX or SSE extensions. A new intrinsic CPUID@ has been added which takes
two arguments, the first being the Input value, the second being any datatype
which is larger than 16 bytes (usually a rank one INTEGER(3) array of size 4.)
This will return the EAX, EBX, ECX and EDX values returned from a "cpuid"
instruction. Two other intrinsics (which use CPUID@) have also been added:
HAS_MMX@ and HAS_SSE@ which are both LOGICAL(3) functions which return .TRUE.
if the feature is available on the running machine. CODE..EDOC fully
supports the new MMX and SSE instructions.
-
To force a variable to be aligned to a different
boundary than is usual for the data-type, an new specification has been added
to the type-declaration statement, ALIGN(n), where n is 8,16,32,64 or 128 and
is the size (in bits) of the alignment required, e.g. "INTEGER(2), ALIGN(32) ::
a, b, c" would declare 3 2-byte integers which are aligned on 4-byte
boundaries. This extension should be used with care as incorrect alignment can
result in code running slower or not at all (if it uses some SSE instructions.)
-
The check-mode heap mechanism has been extended to
allow for large memory footprints. The default heap size is now equal to the
amount of physical memory minus 8M. This heap will "spill over" into the
non-check heap for allocation of "large" (see below) arrays. The heap's
behaviour can be altered using the routines described below for version 1.52
with the following additions:
CALL SET_BIG_CHUNK_SIZE@(i)
Sets the size of "large" for the heap "spillover".
Calling this with the value of HUGE(1) will suppress the "spill over"
mechanism.
-
Modules with very large uninitialised arrays will no
longer create large .OBJ files.
-
A new option "/P6PRESENT" has been added. This will set
the /P6 flag if the compiler is being run on a Pentium Pro or above. This is
most usefully set with /LGO since the executable will not run on
386/486/Pentium class machines.
-
A new option "/NO_COMMENT" has been added. This will
suppress all comments while allowing warnings and errors to be output.
-
/PAUSE_ON_ERROR now has a different behaviour under
win32. Now the compiler pauses every screen-full of information only if a
warning or error has been output, much as if the output had been piped through
through a conditional "more". Redirecting or piping the compiler output will
cause win32 versions of the compiler to ignore the /PAUSE_ON_ERROR option and
not pause after any messages.
-
Many bugs have been fixed.
-
Default compiler switches can
now also be set using the environment variable FTN95CFG. This over-rides values
in the FTN95.CFG files, but it is over-ridden by the command-line switches,
OPTIONS statement and !FTN95$OPTIONS pragma.
-
Three new compiler switches have
been added:
/DEFINT_KIND<n>
/DEFREAL_KIND <n>
/DEFLOG_KIND <n>
These set the default kind for INTEGER, REAL (implying COMPLEX), and LOGICAL
types. The value for <n> must vary from 1 to 3 for REAL and LOGICAL, and
2 or 3 for INTEGER. Note that this allows the user to specify LOGICAL(KIND=1)
as a default type, and note also that the compiler is not standard conforming
if the default kinds are changed as the standard requires that (excuse the C!):
sizeof(INTEGER) == sizeof(REAL) == sizeof(LOGICAL) == (2 * sizeof(COMPLEX))
-
A new compiler pragma has been
added: "!FTN95$LIBRARY" which is equivalent to the LIBRARY directive,
e.g.
!ftn95$library 'foo.obj'
is equivalent to
LIBRARY 'foo.obj'
-
FTN95 will now print a comment
when a user specifies the kind of a type using an integer value, e.g.
"INTEGER(3)", as this is non-portable, and may cause problems when using the
code on another compiler. If you don't like it, you can switch it off with
"/SET_ERROR_LEVEL S 981" on the command-line or in a configuration file.
-
A bug in allocating
derived-types which contain both CHARACTER components as well as at least two
derived-type components has been fixed.
-
A bug in SELECT..CASE statements
where the expression to select was a variable length character function which
could cause program crashes has been fixed.
-
A bug in the processing of
IMPLICIT statements which contain derived-types has been fixed.
-
PRIVATE attributes are now
faulted if applied to non-module variables/functions.
-
ELEMENTAL SUBROUTINEs can now
have INTENT(OUT) arguments.
-
The presence of the blank SAVE
statement in a routine with CHARACTER(*) arguments could cause incorrect code
to be generated. This is now fixed.
-
FTN95 will now correctly report
an error when a user attempts I/O on an expression which is a derived-type
which has POINTER components.
-
Complex CHARACTER statement
functions no longer cause an internal compiler error.
-
MAXVAL/MINVAL would return the
incorrect result in some cases with /P6. This has been fixed.
-
A regression with "IF (X) a,b,c"
where X is REAL and a==b or b==c which caused the IF to jump incorrectly when
X==0.0 has been fixed.
-
A regression from version 1.52
with respect to memory leaks in WHERE loops involving varying-size arrays has
been fixed.
-
Contains a fix to a memory leak
inside ClearWin+ which could, after some time, make the machine stop
responding. This was caused by an initialisation routine being called
repeatedly. Only programs using ClearWin+ may be affected, the FTN95 compiler
itself is not changed from 1.52.
-
The user can now specify the
size of the CHECK mode heap using the environment variable "FTN95CHECKHEAP". It
is recommended that this is set to half the physical memory, e.g. "set
FTN95CHECKHEAP=32" would allow FTN95 to use 32M for CHECK mode heap. The larger
this value, the better the chance of catching a dangling pointer, but this
should not be set too high to avoid excess paging to disk.
-
The size of the CHECK mode heap
can also be set in a program with a routine SET_CHECK_HEAP@ which takes a
single integer argument to specify the heap in bytes. This call *must* be made
before the 1st ALLOCATE statement in a program and over-rides the
FTN95CHECKHEAP value. Use of this routine after an ALLOCATE or more than once
in a program may cause programs to operate incorrectly.
-
The intrinsics ISHFT and ISHFTC
now work correctly when used in specification expressions when the intrinsic
has an array argument.
-
A memory leak with CHECK mode
ALLOCATE which caused a page-fault has been fixed.
-
FORALL now works correctly with
array dummy arguments.
-
EQUIVALENCE now works correctly
on MODULE variables.
-
CHARACTER assignments have been
optimised for execution speed.
-
Comments are no longer
upper-cased in a listing file (except for !FTN95$ pragmas.)
-
FORMAT statements and FORMAT=
strings are now compiled to be out of the code stream when compiled with
/OPTIMISE to reduce code cache usage, reduce cache line fills and improve BTB
lookups by reducing the number of branches executed.
-
A bug which caused a spurious
IMPLICIT error with a PRIVATE module variable has now been fixed.
-
Very large CHARACTER variables
are now allocated on a 16-byte boundary to aid the faster Pentium II/III REP
STOS/MOVS sequences.
-
Fixed a regression using
NAMELIST declared in a module and used in its contained module procedure.
-
/UNDEF will now correctly trap
undefined ALLOCATABLE variables.
-
Some error messages have been
altered so that members of a derived-type are consistently called "components"
in line with the ISO standard.
-
ALLOCATABLE derived-type arrays
would not apply default component values to all the members after an ALLOCATE.
This has been fixed.
-
Some intrinsics would give wrong
results when the arguments were components of arrays of a derived type, e.g.
"MINVAL(A(:)%X)". This has been fixed.
-
Array constructor expressions
like (/1.0*X, 2.0*X/) where X is also an array caused FTN95 to report
conformance errors. This has been fixed.
-
The intrinsics SUM and PRODUCT
are now optimised for small constant-sized array arguments by unrolling the
loop.
-
COMPLEX SUM/PRODUCT intrinsic
calls where DIM was absent caused the compiler to crash. This is now fixed.
-
REAL(KIND=3) and INTEGER(KIND=1)
SUM/PRODUCT intrinsics no longer causes an 'incorrect operand' error.
-
FTN95 is now much more tolerant
of what constitutes an end-of-line character for the source file. Previously,
the presence of a Unix-style line in an MS-DOS formatted text file would cause
error messages to report incorrect line numbers and/or appear on incorrect
lines.
-
Lines containing semicolons no
longer cause some compiler messages to be output on incorrect lines.
-
/UNDEF now detects the output of
undefined variables (with /FULL_UNDEF for CHARACTER output) with PRINT/WRITE.
Previously, UNDEF checks were only performed if the item to output was an
expression rather than a variable. This can be inhibited using /INHIBIT_CHECK
(see notes for version 1.26 below.)
-
Derived TYPEs without the
SEQUENCE attribute now have their components re-ordered to improve alignment
and cache utilisation. SEQUENCE TYPEs are now aligned on 1 byte boundaries
(previously 2 bytes) to aid calling C++ code, the components are allocated in
order as previously.
-
Allocation of stack-based
variables has been improved to reduce memory usage and improve data alignment
by filling in any padding from "odd" sized variables (e.g. REAL(3) which
previously wasted 6 bytes of stack as it requires 16 bytes of storage after
alignment, yet the variable only uses 10 bytes.) This should improved cache
hits and memory bandwidth.
-
Raising a negative REAL number
by a REAL number was not reported as an error in some cases. This has been
fixed.
-
Exponentiation of a REAL with a
REAL which is a whole integer with /OPTIMISE has been improved to be much
faster. This optimisation is also applied to COMPLEX exponentiation where the
imaginary part is zero.
-
Problems with the SAVE attribute
incorrectly being applied to compiler generated temporaries have been fixed.
-
Functions which return derived
TYPE results when the type has default values now correctly initialise the
result.
-
Some problems with
varying-length CHARACTER functions have been fixed.
-
Several optimiser bugs have been
fixed.
-
Z format input no longer
requires the input to be upper-case.
-
Conformance checks between the
arguments of an ELEMENTAL call are now implemented.
-
An optimiser bug with /INTS
which caused array-bounds corruption has been fixed.
-
/P6 now uses the
conditional-move instruction for the integer DIM intrinsic (and the implied DIM
in array bounds calculations) as well as in some MAX/MIN, MAXVAL/MINVAL and
MAXLOC/MINLOC calls.
-
A bug with /P6 and statements
like:
IF (ABS(x) .GT. SIN(y)) STOP
has been fixed.
-
Arithmetic IF statements now
work correctly with /P6.
-
A compiler bug which caused a
spurious error with the following sequence has been fixed:
REAL R(10), P
EQUIVALENCE(R,P(1))
DIMENSION P(10)
DATA P/10*1.0/
-
A DATA statement with a REAL
array being initialised with a CHARACTER(LEN=0) constant and a repeat count,
e.g. "DATA FOO/10*''/" now works correctly.
-
Using an array element as the
lower or upper bound of an array loop, e.g.:
INTEGER :: I, J(2) = (/1,10/)
DO I = J(1), J(2)
PRINT *, I
END DO
generated incorrect code with /OPTIMISE which caused an infinite loop to be
generated. This has been fixed.
-
A spurious warning of
'<fun> has been called with too many arguments" with /CHECK and
no-interface calls has been fixed.
-
A bug with vector subscripts
being applied to a base-zero array has been fixed.
-
A spurious "right hand side is
not a POINTER or TARGET" error has been fixed.
-
Problems with array-valued
functions and the RESULT clause has been fixed.
-
An optimiser problem which
caused an infinite loop on run-time with an optimised DO loop has been fixed.
-
REAL(KIND=3) arguments no longer
cause a strange error message in check mode about argument type mismatch.
-
/PROFILE no longer causes some
INTEGER valued functions to return erroneous results.
-
A memory leak with modules has
been fixed.
-
Several spurious errors with
array-constructors have been fixed.
-
ELEMENTAL CHARACTER functions
had a problem which caused them to broadcast their first value -- this has now
been fixed.
-
OPTIONAL POINTER dummy arguments
will now not cause an error when used with the PRESENT intrinsic.
-
POINTER array dummy arguments
will now not cause a "argument ... has been called with too few array elements"
error with /CHECK mode.
-
Several bugs relating to
overloaded generic procedures have been fixed.
-
Problems with expressions like
'A(10)%I(:)' where 'I' is a POINTER component have been fixed.
-
Setting the environment variable
FTN95ANSI to any value will result in FTN95 outputting ANSI.SYS escape codes to
use colour in error displays and the help screen.
-
A new clause can be added to a
FUNCTION/SUBROUTINE declaration. The extended syntax for a sub-program
declaration is:
(<type> FUNCTION | SUBROUTINE) <name> ([<args>]) [ALIAS
<str>] [RESULT(<name>)]
This allows you to specify the external name for a routine if the standard
Fortran default (all uppercase) is not what you want, e.g.:
PROGRAM test
INTERFACE
SUBROUTINE foo ALIAS 'TheFunction'
END SUBROUTINE
END INTERFACE
CALL foo
END
The call to 'foo' above will actually be reported to the linker as a call to
'TheFunction'. Note that the '()' are required for a routine with no
arguments. This can also be used in the definition of a routine, e.g.:
RECURSIVE FUNCTION foo(i) ALIAS 'foo' RESULT(n)
INTEGER :: i, n
...
END FUNCTION foo
This function would be called in C with "n = foo(&i)" instead of "n =
FOO(&i)" if it followed the default Fortran rules.
-
A spurious error with IMPLICIT
definitions of FUNCTION types has been fixed.
-
A new option /RUNTRACE has been
added. This adds a call to RUN_TRACE@ after every line. This routine gets the
current line number, the current function name, and the current filename as
arguments. The default action is to output these values to the screen, but the
user can supply their own RUN_TRACE@ routine provided it is declared as:
SUBROUTINE RUN_TRACE@(line_num, fun_name, file_name)
INTEGER(3) line_num
CHARACTER(*) fun_name, file_name
...
END SUBROUTINE
-
/CHECK will now produce a clear
diagnostic when an OPTIONAL argument which has not been supplied is used in a
sub-program.
-
/CHECK will now diagnose
INTERFACE mismatch problems where the INTERFACE does not have the same
arguments as the actual routine.
-
A memory-leakage problem when
using automatic arrays in a module procedure where the size of these arrays
depended on the size of an array pointer dummy argument has been fixed.
-
IMPLICIT NONE with USE ONLY
caused occasional spurious IMPLICIT errors when used with modules containing
NAMELISTs -- this has now been fixed.
-
A bug which caused incorrect
code to be generated for POINTER functions which were of a user-defined TYPE
has now been fixed.
-
Some array-valued functions
without RESULT clauses were causing a compiler crash.
-
/IGNORE now works with all
errors and warnings. Previously it would only suppress warnings and comments.
Use with care...
-
A new option /NO_SCREEN_MESSAGES
has been added. This gives the same behaviour as FTN77 when /LIST is present
(i.e. all warnings etc. are added to the list file but not output to screen.)
-
A bug which caused some
occasional spurious errors when a user-defined TYPE component shared the same
name as a dummy argument of a different type has been fixed.
-
A new option /MAC_EOL has been
added which will allow FTN95 to compile an Apple Macintosh text file (i.e. CRs
only, no LF).
-
Placing /LINK or /LGO into
FTN95.CFG now works correctly.
-
A bug in /CHECK which caused a
compiler GPE with certain CONTAINed functions has been fixed.
-
A bug with /CHECK which caused a
spurious run-time error about CHARACTER dummy arguments being declared longer
than the actual argument has been fixed.
-
Scalar variables erroneously
used in function calls/array references are now trapped correctly.
-
Error checking of IF/WHERE/DO
WHILE statements has been improved with regard to the appearance of
array-valued or scalar expressions.
-
Some non-standard constructs
were not being detected with /ISO, such as mixing default and non-default kind
variables in an EQUIVALENCE statement -- this has now been fixed.
-
An obscure bug in the
EQUIVALENCE algorithm caused spurious errors with some redundant EQUIVALENCE
statements, e.g.
REAL a(4), b(4), c(2, 4)
COMMON a, b
EQUIVALENCE(a, c(1,1))
EQUIVALENCE(b, c(2,1))
This has now been fixed.
-
Error messages with incorrectly
nested END* statements have been improved, and a case which caused the compiler
to hang has been fixed.
-
Comments are now supported in
/OPTIONS files, and the FTN95.CFG files. A comment must appear on a line of its
own, the first character of which must be '!'.
-
Individual checks can now be
inhibited with /INHIBIT_CHECK <n>, or using the new directives
!FTN95$INHIBIT_CHECK and !FTN95$ENABLE_CHECK to disable/enable checks on a
per-function basis. The following check numbers are currently
defined:
1 - suppress marking DO-loop indices as unwritable in a function call
2 - " " INTENT(IN) args " " " "
3 - suppress POINTER checking via PCHECK but allow POINTER checking on any
function called.
4 - suppress POINTER checking completely
5 - suppress the argument type/size checking on function entry
6 - suppress CHECK mode function calls
These should only be used as a workaround for code which has known bugs.
-
A new command line option has
been added (/SET_ERROR_LEVEL) as well as a new compiler directive
!FTN95$SET_ERROR_LEVEL. These both allow reconfiguration of warnings and
comments to suppress them or raise their
error level. The syntax is:
/SET_ERROR_LEVEL <Level> <ErrorNum>
Where <ErrorNum> is the number of the warning/comment (found by using
/ERROR_NUMBERS) and <Level> is one of the following: Suppress, Comment,
Warning, Restricted, Error, Fatal (or just the 1st character of these words.)
"Restricted" messages are silent unless /RESTRICT_SYNTAX is on (see below) when
they become errors.
-
A new option /RESTRICT_SYNTAX
has been added which causes the compiler to reject code which is
standard-conforming, but "dubious", such as using an EQUIVALENCED variable as a
DO-loop index, which can result in undefined behaviour. The following are
currently restricted (with the error number following in square brackets):
- Using EQUIVALENCED DO-loop indices where the body contains function calls or
has assignments to other EQUIVALENCED variables. [954]
- Variables in INCLUDE files which are not PARAMETERs, nor in a COMMON block,
and are not INTRINSIC or EXTERNAL (or C_EXTERNAL etc.) This traps mis-spellings
in an INCLUDE file for code which would not compile with IMPLICIT NONE. [955]
- Variables which could be confused with DO loops, or be from a badly formed DO
loop, such as DO10I. [212]
- Variables with the same name as a Fortran keyword. [306]
These can all be configured using /SET_ERROR_LEVEL, e.g. "/SET_ERROR_LEVEL S
306" would allow the use of Fortran keywords as variable names when
/RESTRICT_SYNTAX was switched on.
-
This version has the capability
of calling routines in dynamic link libraries generated for DEC Visual Fortran
(DVF). Fixed problems with embedded blanks in integers in run time format
parsing.
Also fixed problems with the first edit descriptor following a non comma
delimited descriptor not being recognised if it is lower case. (Salford
extension.)
-
Logical values are now treated
as zero for false and non zero for true, whereas previously only the value '1'
was treated as true.
-
A problem using COUP@ with
trailing blanks which sometimes caused garbage to be displayed has been fixed.
-
Several problems with the
CheckMate facility have been fixed as well as bugs in complex conjugation.
-
Changed result of MINLOC/MAXLOC
to return array result. MINLOC/MAXLOC always return an array result, except for
one particular case, i.e. arguments with array rank 1 and DIM=1.
-
Several bugs fixed which are
difficult to describe briefly.
-
CHECK mode has been extended to
check POINTER variables for various errors such as dangling pointers,
attempting to deallocate a block twice and attempting to deallocate part of a
allocated block.
-
IMPLICIT NONE scoping in
CONTAINed routines now works correctly.
-
Varying-length CHARACTER
functions no longer cause "can't free locked registers" error messages.
-
Enhancements to the stability of
conditional compilation have been made.
-
Various bugs have been fixed.
-
Two new compiler switches have
been added: /FPP and /SPARAM. These are to allow conditional compilation. The
first switch must be present when compiling a file containing CIF/CELSE/CENDIF
statements when there is no /SPARAM present. While configuring this flag as set
does not affect the eventual results of compilation, compiling will be slower
as an extra pass and a temporary file are required to pre-process a file.
-
Added new compiler switch
/VPARAM to support extension to CIF processing. The /VPARAM <name>
<val> switch allows a user to over-ride a specific SPECIAL PARAMETER
value, unlike /SPARAM which sets all SPECIAL PARAMETER values to the same
value. /VPARAM values over-ride any /SPARAM values.
-
CIF statements have been
extended to cope with all the integer relation operators (.EQ.,.LT., /=, >=,
etc) and also the new form CIF (BooleanVariable) which allows processing when
BooleanVariable is non-zero, useful in conjunction with /VPARAM.
-
A new compiler switch /XREAL has
been added which sets the default kind for REAL to 3 (c.f. /DREAL)
-
A new compiler switch
/PAUSE_ON_ERROR has been added which causes the compiler to wait for a keypress
after every warning/error/comment.
-
FTN95 now has default options
files. When FTN95 is invoked, it first looks for a file FTN95.CFG in its
directory, then looks for a file FTN95.CFG in the current directory. These
files are the same format as files used by the /OPTIONS switch.
-
Two new directives have been
added: !FTN95$FOR_DBOS and !FTN95$FOR_WIN32. These are used to confirm the
target, i.e. if a file contained !FTN95$FOR_WIN32, and was compiled using a
DBOS version of FTN95, an error message will be output.
-
Several bugs connected with
pointers have been fixed.
-
Several bugs connected with the
optimisation of DO loops have been removed.
-
The optimiser can now switch the
variables that it holds in registers within a routine if that generates better
code.
-
Several spurious syntax errors
associated with CODE/EDOC sequences have been resolved.
-
The SELECT CASE statement had
problems when some of the cases involved a range, this has been fixed.
-
A bug which could cause the
/CHECK option to generate incorrect code in certain circumstances has been
fixed.
-
Problems involving pointers (to
arrays) in common have been fixed.
-
The NOT function now works with
short integer arguments.
-
Several spurious syntax errors
associated with MODULE's and INTERFACE's have bee fixed.
-
A bug which caused the debugger
to print misleading information after a reference to undefined data (/UNDEF)
has been resolved.
-
COMMON blocks starts now aligned
on 8-byte boundaries (previously 4-byte.)
-
"Simple" functions are now
implemented, where a simple function is one like:
INTEGER FUNCTION SIMPLE(I)
INTEGER :: I
SIMPLE = ifun(I)
END FUNCTION
The code produced for these functions is optimised to remove the need for a
"(Result of SIMPLE)" variable, i.e. the body of the function would simply be:
push address of I
call IFUN
without any need to load EAX with the return value.
-
Added new directives:
!FTN95$INHIBIT_OPT <opt-num>
!FTN95$ENABLE_OPT <opt-num>
!FTN95$WINAPP
-
Added support for directives a
la DVF, currently only:
!FTN95$OPTIONS(<option-list>)
This permits a user to use OPTIONS statement in a standard-conforming manner,
e.g.:
!FTN95$OPTIONS(SAVE, DO1)
!FTN95$FIXED
!FTN95$FREE
!FTN95$RESTORE_FORMAT
Specify the format of the source to preserve compatibility across source
formats. Use in files like WINDOWS.INS, like:
!FTN95$FIXED
....
!FTN95$RESTORE_FORMAT
|
"60,000 lines of SIMPLEPLOT Fortran code compiled first time with the .NET compiler
and we were able to get a user program running against it within a few hours of
downloading the compiler … We would certainly recommend the Salford FTN95 for
Microsoft .NET compiler to our customers and to anyone who wishes to move an application
to .NET while reusing legacy Fortran code." Andrew Roberts - Buss Ltd
|
