| | | |

FTN95 Enhancements

Silverfrost FTN95 - Version 5.20 released (March 13th 2008)

Version 5.20

New features include:

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.

Version 5.10

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

Version 5.01

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

Version 5.00

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

Version 4.91

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

Version 4.90

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.

Version 4.80

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.

Version 4.71

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.

Version 4.70

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.

Version 4.60

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.

Version 4.50

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.

Version 4.00

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.

Version 3.40

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

Version 3.20

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.

Version 3.00

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.

Version 2.54

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.

Version 2.50

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.

Version 2.04

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.

Version 2.00

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.

Version 1.60

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.

Version 1.53

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.

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

Version 1.51

Fixed a regression using NAMELIST declared in a module and used in its contained module procedure.

Version 1.50

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

Version 1.32

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.

Version 1.31

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.

Version 1.30

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

Version 1.28

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.

Version 1.27

Student Edition

Version 1.26

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.

Version 1.25

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.

Version 1.22

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.

Version 1.21

Several bugs fixed which are difficult to describe briefly.

Version 1.20

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.

Version 1.14

Several bugs connected with pointers have been fixed.

Version 1.12

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.

Version 1.09

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.

Version 1.08

Added new directives:
!FTN95$INHIBIT_OPT <opt-num>
!FTN95$ENABLE_OPT <opt-num>
!FTN95$WINAPP

Version 1.07

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

Programs for Programmers

FTN95 Enhancements