
            Release Notes for DIGITAL Visual Fortran
        Version 5.0.A Standard and Professional Editions

    This file contains information about the v5.0.A release of
the DIGITAL Visual Fortran products.  Various items of interest are
noted below.  "DIGITAL Visual Fortran" is abbreviated "DVF" below.


-------- General Release Notes  --------

    DIGITAL Visual Fortran v5.0.A is available in two separate
products:

 o DIGITAL Visual Fortran v5.0.A Standard Edition

   The DVF Standard Edition contains the DVF compiler, libraries, and
   Developer Studio to support Intel processors running Windows/NT
   or Windows 95.

 o DIGITAL Visual Fortran v5.0.A Professional Edition

   The DVF Professional Edition contains the DVF compiler, libraries,
   and Developer Studio to support the DIGITAL Alpha processors
   running Windows NT;  it contains the IMSL math and statistics
   libraries for both Intel and Alpha;  it also contains what the
   Standard Edition contains:  the DVF compiler, libraries, and
   Developer Studio to support Intel processors running Windows/NT
   or Windows 95.

    This product requires that you be running Windows NT Version 4.0
(released version) or Windows 95. The requirement for Windows NT v4.0
comes from the use of the Developer Studio IDE. The command line
portions might work on 3.51 but such usage is unsupported. 

    DVF v5.0.A contains the Developer Studio v5.0 and is compatible
with the Developer Studio on DVF/Intel Standard v5.0 and VC++ (Intel
and Alpha) v5.0.  If you are using Visual C++ from Microsoft, DVF
v5.0.A will only work with their released v5.0 version. 

    The v4.0 Microsoft Fortran 90 compiler for Intel is supplied on
the Standard kit to allow users with some ABSOLUTE compatibility
requirement to continue compiling programs. This is the MS v4.0
compiler AS IS with no bug fixes or any other enhancements. It is our
goal that no users should ever have to use this old compiler. As such
we are extremely interested in any requirements to do so. 

    The Alpha version of DVF v5.0.A cannot be installed with or
on-top-of DIGITAL Fortran v1.2 for Alpha/NT.  The libraries, DLLs,
and tools from DF/ANT v1.2 are not compatible.  It should also be
noted that certain switch setting defaults have changed.  Please read
the on-line documentation to see what the new switches are and what
they do. 

    Users of DIGITAL Fortran on other platforms (Unix/OpenVMS)
will no doubt be concerned about code portability with those
other platforms. Where it makes sense to do so, features that
have been added to the compiler and runtime support for this
product will also be provided on the other DIGITAL Fortran
platforms in future releases.

    Another goal of the Intel version of this product is to
be compatible with libraries previously compiled with the
Microsoft Powerstation compiler. Since the two implementations
of the language use different code bases for the run time
support, it will not be possible to mix object modules that
utilize Fortran IO and various other core functionality of
the language. It is our intention that compute-only subroutines
and functions compiled by the Powerstation compiler should be
able to be linked together with objects from the DIGITAL
Visual Fortran product and produce correct results.


--------  Installation Release Notes  --------

 o (Alpha Only)
   If your Alpha system is running V1.0 or V1.1 of DIGITAL FX!32, you
   need to disable FX!32 while running the Visual Fortran
   installation.  You may re-enable FX!32 after the Visual Fortran
   installation has completed.  If you do not, the installation will
   display an error similar to:

   "Target file C:\WINDOWS\SYSTEM32\*.* is read only.  Please remove
    the read-only attribute form the target file.  Retry?"

   and the installation will fail.

   To disable or enable FX!32, choose the Add/Remove Programs icon
   from the Control Panel.  Select FX!32 from the displayed list of 
   applications.  Select Disable FX!32 and Reboot computer now to 
   disable FX!32.  Select Enable FX!32 and Reboot computer now to 
   enable FX!32.

 o (Intel Only)
   Do not install Visual Fortran v5.0 in the same directory as
   Microsoft Fortran PowerStation v4.0.  Installing Visual Fortran
   v5.0 on top of Microsoft Fortran PowerStation v4.0 will render the
   v4.0 tools unusable.  Install Visual Fortran v5.0 into a directory
   separate from your Microsoft Fortran PowerStation v4.0
   installation.  Visual Fortran v5.0 can co-exist with a v4.0
   installation, as long as both versions reside in different
   directories.      

 o If you install Microsoft Visual C++ Professional or Standard
   Edition, or Microsoft Visual J++, after installing Visual Fortran
   v5.0, you must run the icon named "Repair #1 (VC++ or VJ++
   Installation)". This program fixes a registry entry that is
   incorrectly modified by the VC++ or VJ++ installation.  If you do
   not run this program, Fortran debugging will not work properly. 

 o If you attempt to install Visual Fortran v5.0 using any of the
   methods described in "Getting Started - Using Setup to Install
   Visual Fortran", and the root directory SETUP.EXE fails to run,
   then try the following: 

   - On Intel, run \X86\SETUPX86.EXE
   - On Alpha, run \AXP\SETUPAXP.EXE

   This runs the same installation procedure as the root directory
   SETUP.EXE. 

 o Visual Fortran v5.0 and other Developer Studio products (for
   example, Microsoft Visual C++ or Microsoft Visual J++) are
   engineered to co-exist in Microsoft Developer Studio. However, the
   versions of all products MUST match or you will receive version
   mismatch errors when starting Developer Studio. An example of the
   error message you would receive is: 
 
    "Cannot load package 'xxxxxx' because its internal version number,
    or the internal version number of one of it components, does not
    match the version of the Developer Studio shell." 

 o If you install multiple Developer Studio products and later
   uninstall one or more of them, you may need to re-install the
   others.

 o The Visual Fortran 5.0.A CD-ROM contains Microsoft Internet 
   Explorer 3.0.2.  The installation program will ask you to install
   this if you need it in order to view the on-line documentation.
   If you already have a sufficient version of Internet Explorer,
   it will not ask.

   If the installation program does not ask and you want to install 
   Microsoft Internet Explorer 3.0.2:
    - On Intel, run \X86\SUPPORT\MISC\MSIE302.EXE from the Visual 
      Fortran 5.0 CD.
      On Alpha, run \AXP\SUPPORT\MISC\MSIE302.EXE from the Visual 
      Fortran 5.0 CD.

--------  Late breaking news  --------

The following items of interest were discovered in the last phases
of testing these kits:

 o A Product Overview is in \AXP\SUPPORT\OVERVIEW and
   \X86\SUPPORT\OVERVIEW on the CD-ROM. 

   The Visual Fortran product overview is a PowerPoint
   slide show that contains tutorial help for users unfamiliar
   with Visual Fortran and Developer Studio.

   The PowerPoint 97 Viewer should be used to view this
   tutorial information and can be downloaded as described in
   the product overview "read me" file on the Visual Fortran
   CD-ROM:

     ...\SUPPORT\OVERVIEW\README.TXT

   Once the PowerPoint 97 Viewer is installed, run the viewer
   and open the product overview from the following location
   on the Visual Fortran CD-ROM:

     ...\SUPPORT\OVERVIEW\OVERVIEW.PPT

 o Minimal field width editing in FORMAT descriptors is not yet
   correctly implemented. This will be corrected in a future release.

 o asm files generated by the compiler may not assemble properly.
   This will be corrected in a future release.

 o Regarding how many files can be simultaneously open in a DVF
   program: 

   - On Windows NT, a DIGITAL Visual Fortran program was able to open
     successfully 5000 files simultaneously.

   - On Windows 95, a DIGITAL Visual Fortran program was able to open
     successfully 250 files simultaneously before it got an OPEN
     error.

 o Using NT v4.0 SP3 {service pack 3}, a DVF program can compile and
   execute with a COMMON block up to 1.75GB is size.

 o DVF allocates array temporaries and automatic arrys to the stack
   at run-time.  The default size of the Win32 stack is not very
   large so you may need to increase the stack size.

   It is possible to increase the stack size either when you link
   the executable, or by using EDITBIN on the executable later.

   On the link command you can use the /stack qualifier, as:

        link /stack:400000 

   Or, as part of the df or f90 command:

        df foo.f /link /stack:4000000

   You also have the option to modify the stack size in the executable
   itself using editbin, as:

        editbin /stack:4000000 foo.exe

   By default, the stack size is 0x100000, or (1,048,576 decimal).

 o The FULLAPI.F90  file.   If  the  /winapp  switch  does  not
   eliminate  undefined  globals from compiling a native windows
   application, try adding this file to your project or  command
   line.   FULLAPI.F90  contains  library  search directives for
   almost all needed libraries.

 o The directories \X86\USUPPORT and \AXP\USUPPORT on the CD-ROM
   contain some unsupported but nevertheless useful tools.  For
   example:

  - ...\MISC\CTEST.EXE

    This program may be renamed to "WHICH.EXE" and placed somewhere on
    a users PATH to perform the function of the Unix "which" command,
    that identifies the path to a specified program.

  - ...\MISC\WHAT.EXE

    This program will scan a binary file for Unix style "what" strings
    and display any that are found. The DECFOR90.EXE may be used as an
    example of a file that contains these "what strings".

  - ...\MISC\STRSUB.EXE

    This program will process a text file and replace all occurances
    of a given string with another string.

  - ...\MISC\FIXMSTAB.EXE

    This program converts Fortran source code that uses Microsoft
    style tab rules to follow DIGITAL Fortran standard TAB rules.

  - ...\MISC\CBANL.EXE

    This program analyzes object and library files for inconsistencies
    in Fortran COMMON blocks that can lead to LINK errors and program
    failures.  For instance, this tool will tell you if you have
    declared two COMMON blocks of the same name that have different
    sizes.

  - ...\MISC\CBANLW.EXE

    A Windows version of the above CBANL tool.

 o The interaction of the 'C' and 'REFERENCE' attributes with
   character parameters has been corrected to match the documented
   behavior (see the Programmer's Guide online documentation,
   "calling conventions, mixed language programming" for complete
   details).  The following cases are of particular interest: 

   - If the C and REFERENCE attributes are assigned to a routine,
     then any character argument that does not also have the
     REFERENCE attribute will be passed with a hidden length, e.g.

        interface
          subroutine foo(ch)
            !DEC$ATTRIBUTES c, reference :: foo
            character*(*) ch
          end subroutine
        end interface

     The parameter 'ch' is now passed with a hidden length.

   - If the C or STDCALL attribute is assigned to a routine in
     an interface block, and a character parameter is assigned
     the REFERENCE attribute, then only the address of the 
     character parameter is passed (no length is passed), e.g.

        interface
          subroutine foo(ch)
            !DEC$ATTRIBUTES c :: foo
            !DEC$ATTRIBUTES reference :: ch
            character*(*) ch
          end subroutine
        end interface

     This is useful when calling a C routine that expects only
     the address of a string, and not the length.

   - If the C or STDCALL attribute is assigned to a routine in
     a procedure declaration, and a passed-length character
     parameter is assigned the REFERENCE attribute, an error is
     generated, e.g.

        subroutine foo(ch)
        !DEC$ATTRIBUTES c :: foo
        !DEC$ATTRIBUTES reference :: ch
        character*(*) ch
        ...
        end subroutine

     results in an error since the declaration of 'ch' as a
     CHARACTER*(*) parameter requires the length to be passed
     into the subroutine, but the REFERENCE attribute given to
     'ch' in subroutine 'foo' (which has the C attribute) specifies
     that no hidden length should be passed.  This contradiction
     is an error, which the compiler now correctly flags at run time.

The following known problems remain:

 o ALL .pdb files should be deleted.

   ALL target .pdb files MUST be deleted or the linker may report
   incompatible pdb file formats.

 o Control C handlers

   Problems have been reported with implementing console event
   handlers (e.g., control C handlers) in programs built with Visual
   Fortran.  The symptom is usually that the handler is seemingly
   never invoked.  This is due to the implementation of console
   event handling on WIN32 platforms.  In response to a cntl-C event,
   the operating system will create a new thread to execute the
   handler in.  In order for the new thread to execute, it must
   obtain priority.  If the currently executing thread does not
   relinquish its priority, it is possible that program execution will
   terminate before the console event handler ever executes.  For
   example, a READ statement directed at the console which is
   interrupted by a control-C can cause an end-of-file error to be
   processed, resulting in program termination, before an event
   handler can execute.  This is a WIN32 restriction, not a bug in
   DVF, and developers need to be defensive when implementing console
   event handlers.  For example, the READ statement above could
   supply an END=label where at label, a call to Sleep(0) causes the
   current thread to give up its priority and might allow a handler
   to execute.

 o signal() problems

   Signal handlers established with the C signal() routine or the
   Fortran SIGNALQQ function do not interoperate correctly with
   the default Fortran rtl handler.  There is no current workaround
   other than to disable the Fortran default handler completely
   and supply your own complete handler.  You can disable the Fortran
   default handler by setting environment variable
   FOR_IGNORE_EXCEPTIONS to true.


--------  Changes to the DIGITAL Visual Fortran Compiler --------

    The following changes have been made to DVF v5.0.A since DVF v5.0
shipped:

 o The following changes have been made to the driver:

   - When a blank is embedded within the compiler image, fpp image,
     or linker image that will be executed, the driver was changed to
     place the image name within quotes.

   - The driver was enhanced to process lines within an indirect
     file that contain more than 255 characters.

   - switch /[no]dbglibs added.  This switch controls which C
     run-time library is linked against.  /dbglibs will link against
     a debug version of the C run-time support.  /nodbglibs will
     link against a non-debug version of the C run-time support.

     Until this change, the version of the C run-time support that
     was linked against was controlled by the /debug=full switch.
     When /debug=full was specified, the debug C run-time library
     was used.

   - keyword /warn=[no]fileopt added.  This keyword controls
     whether or not the informational message "Some interprocedural
     optimizations may be disabled when compiling in this mode" is
     printed during compilation.

 o The following changes have been made to the compiler:

   - Fix a compiler internal error when using C and REFERENCE
     attributes on a function name.

   - Fix a compiler internal error when using ASSOCIATED of a
     function returning a pointer.

   - Allow using ICHAR in an array constructor within the
     initialization part of an array declaration.

   - Fix a problem with using UNION declaration within the derived
     type.

   - Allow exporting of a module procedure which has a name that is
     the same as a generic name.

   - Fix a problem with using user defined assignment operation.

   - Real parameters containing NaNs used in expressions no longer
     cause internal compiler errors

   - An error in D-line continuation has been fixed

   - Processing of certain complex array initialization expressions
     should no longer cause internal compiler errors

   - Character array initialization expressions using the TRANSFER
     intrinsic now work properly

   - An error message is now given for invalid keyword values given
     for an I/O statement's keyword

   - Declarations of the type "character, allocatable :: field*7(:)",
     in which the array shape specifier comes after the length
     specification in a deferred-shape character array no longer
     produces an internal compiler error

   - The support for passing complex arguments by value on Alpha WNT
     has been modified to conform with the C model for passing
     structures by value (behavior now equivalent with Intel WNT
     version of DVF)

   - Calling the DATE and TIME intrinsics with character arguments
     should now work correctly

   - Scalar character pointers that point to substrings of a
     character target should now give correct results

   - Cray pointees that were being allocated statically are now
     correctly given no storage class

   - Using the browser on a file that INCLUDEs more than one include
     file will now work properly (no warning given at run time and
     behavior now correct for all files in such a case)

   - Allow a internal procedure to be used as an actual argument

   - When assigning a derived type variable with a structure
     constructor, if a character scalar is supplied to an character
     array component, every element of the array is assigned with
     the character scalar value 

   - The MVBITS intrinsic now gives correct result if its 4th
     argument is a non-lowerbound subscripted array element 

   - Reference of a character function, where the length of its
     return value is dependent on one or more of its arguments, no
     longer produces an internal compiler error

   - Pointer assignment should now work properly when the target is a
     component of an allocatable array with a lower bound different
     of 1.

   - long NAMELISTs no longer causes a compiler internal error

   - Allow %fill in STRUCTURE declarations using F90 syntax, e.g. 
     "integer :: %fill"

   - Using unary "-" operator with record fields should now give
     correct results

   - Use of NEAREST with two different KIND REAL arguments no longer
     gets a nonstandard warning

   - Allow SIZEOF of assumed size record field

   - Module importing has been improved.  If a module is USEd in both
     the host and its internal procedure, the module is now only
     imported once by the compiler

   - Optional comma in DO with label, e.g. "label: DO, JJ = 1, N, 1",
     no longer gets incorrect syntax error

   - Allow a dummy argument to have the same name as a structure field

   - A module that contains "USE module, ONLY : var" no longer gets
     internal compiler error

   - A component of a derived-type with a name that starts with FILL
     no longer gets a syntax error

   - Allow a variable with '_' in its name to be used in a variable
     format expression
      
 o The following features from MicroSoft Fortran PowerStation are not
   supported by DIGITAL Visual Fortran:

   - Tab continuation lines that start with other than the digits 1
     through 9 {see the FIXMSTAB utility above for a work-around}

   - $DEBUG, $NODEBUG-additional runtime checking

   - DATA statement style initialization in attribute style
     declaration statements

   - Debug lines (other than D)

   - $OPTIMIZE-change optimization options

   - Integer array can contain FORMAT

   - Internal files can be any type

   - Listing metacommands - $page, $pagesize, $linesize, $[no]list,
     $include


--------  Changes to the DIGITAL Visual Fortran RTL  --------

    The following changes have been made to DVF v5.0.A since DVF v5.0
shipped:

 o The following changes have been made to the RTL:

   - Add missing support for array sections in namelist input.

   - Change to qwin for logical return value passed to callback menu
     subroutines.

   - Qwin fix,  control-C leaves process around.

   - Qwin fix,  Missing FQWIN.HLP detected on use.

   - Alpha-compatible OpenGL files.

   - bug fix to eliminate access violation when read past the end of
     an internal file

   - RANDOM_SEED with no arguments will use random seeds based on the
     internal clock

   - the CPU_TIME intrinsic now returns the CPU time, rather than
     wall clock time

   - on Windows 95 ETIME and DTIME now use the C run-time routine
     _clock() for the time rather than returning zero

   - on Alpha NT systems calling the TIME or DATE intrinsic with
     a character argument resulted in a run-time access violation.
     This bug has been fixed.

   - RANDOM_NUMBER no longer returns an occasional 1.0.  Its output
     should now be strictly less than 1.0.

   - provided new example PEEKAPP.F90 to simulate non-blocking IO in
     QuickWin

   - GETCHARQQ now works properly in both console and QuickWin modes
     (returns a real character and doesn't wait for enter key).  This
     fix also applies to a similar problem in INCHARQQ.

   - PASSDIRKEYSQQ allows direction and page keys to be read in
     QuickWin.  See the new example DIRKEYS.F90.

   - QWIN fix, menu items now go to the appropriate routines, not just
     to PRINT

   - in DFWIN.F90, fixed interface statements to routines LZClose and
     WindowFromPoint

   - the intrinsic bjtest was returning the wrong results.  This bug
     has been fixed.

   - the run-time library was improperly reading Powerstation Fortran
     style unformatted files when the /fpscomp switch was used.

   - fixed a problem with output of run-time library error
     diagnostics in quickwin applications

   - display run-time error messages to the correct device

   - merged in MS quickwin patches for IME support
     > fixes memory leak problem when printing to a child window
     > backspace of output at text input position works properly
     > fixes celsius output hanging problem
     > IME conversion window output now positioned at the caret
     > quickwin application no longer hangs going to full screen
     > input characters now properly displayed
     > allows quickwin applications to be debugged

   - a bug involving the use of the $ and | format characters, the
     switch /fpscomp:general and inputting data with getcharqq was
     fixed.

   - when running a QuickWin application, a zero length, read-only
     file called HandleTEMPORARY was being generated.  This file is
     no longer generated.

   - if daylight savings time was in effect, the first call to
     GETFILEINFOQQ returned an answer which was one hour off.  This
     bug was fixed.

   - new FOR_DEFAULT_PRINT_DEVICE environment variable implemented 
     to allow user to specify where the print should be submitted to,
     other than the default LPT1 printer.
 
   - The definition of the data structure MTH$E_INFO in DFLIB has
     changed to correct a bug.  The layout of the arguments and result
     within the data structure was incorrect.  If you use this data
     structure (for example, in a MATHERRQQ routine), you must
     recompile and relink.

   - ALPHA NT specific:
     > fixed alpha naming problem with FDATE
     > bug relating to _matherr handling in the DPML exception
       dispatcher for Alpha Windows NT fixed - new DPML picked up 

   - INTEL specific:
     > Fixed some minor problems with the display of Microsoft style
       error messages generated by exceptions from MATH intrinsics
       on Intel.  The 'M' designation will now appear with the error
       number for error messages generated from MATH intrinsic
       exceptions.
     > Fixed problems related to handling of underflow exceptions
       generated from MATH library intrinsics on Intel.  In cases
       where underflow exceptions were unmasked (compile options
       fpe:3 -check:underflow, fpe:0, or fpe:0 -check:underflow), it
       was possible for program execution to continue from an
       underflow conditon with an incorrect result, but only if the
       condition was generated within a MATH intrinsic.

   - a bug was fixed in PACKTIMEQQ, it was only supporting STD time

   - incorrect API interfaces defined in DFWIN were corrected

   - a bug in the SETLINESTYLE routine was fixed so that all 5
     possible styles can be specified and drawn

   - test of setting of FOR_IGNORE_EXCEPTIONS environment variable 
     moved ahead of testing for intrinsic exceptions and is the very
     first thing done in the exception handling routine

 o The following problems still exist in the DVF v5.0.A RTL:

   - READ statements on an unformatted sequential file under /fpscomp,
     with an iolist containing an implied-DO operating on mixed types,
     or another READ statement following one of this description, may
     fail to produce correct results.

 o When doing mixed language programming with Fortran and C, one
   important point to get right is that you want to link your
   application against one and only one copy of the C library.

   The preferred method to do this is to get your project settings
   for both Fortran and C to agree on the default C library to link
   against.

   Fortran picks default libraries depending on your
   "Project->Settings->Fortran" selections.  Using options from

     "category:libraries->Use Fortran Run-time Libraries" and
     "category:libraries->Use C Debug Libraries",

   Here are the default libraries you will see selected:

     Static     "Use Multi-  "Use C      Fortran       C link
     or DLL      threaded     Debug      link lib      lib
                 Library"   Libraries"
     _________________________________________________________________
     Static      no            no         dfor.lib      libc.lib
     Static      no            yes        dfor.lib      libcd.lib
     Static      yes           no         dformt.lib    libcmt.lib
     Static      yes           yes        dformt.lib    libcmtd.lib

     DLL         no            no         dfordll.lib   msvcrt.lib
                                          (dforrt.dll)  (msvcrt.dll)

     DLL         no            yes        dfordll.lib   msvcrtd.lib
                                          (dforrt.dll)  (msvcrtd.dll)

     DLL         yes           no         dformd.lib    msvcrt.lib
                                          (dformd.dll)  (msvcrt.dll)

     DLL         yes           yes        dformd.lib    msvcrtd.lib
                                          (dformd.dll)  (msvcrtd.dll)

   Here's how C picks the default library.  Under "Project->
   Settings->C/C++->category:Code Generation->Use run-time library"
   there is a choice of 6 different C libraries.

      menu item                 CL option     default library
      selected                  enabled       specified in obj
      ________________________________________________________
      Single-threaded           /ML           libc.lib
      Multithreaded             /MT           libcmt.lib
      Multithreaded DLL         /MD           msvcrt.lib (msvcrt.dll)
      Debug Single-threaded     /MLd          libcd.lib
      Debug Multithreaded       /MTd          libcmtd.lib
      Debug Multithreaded DLL   /MDd          msvcrtd.lib (msvcrt.dll)


    The following differences in run-time behavior between DIGITAL
Visual Fortran and Microsoft Fortran PowerStation should be noted:

 o  The Visual Fortran RTL does not support MBCS characters.

 o  The Visual Fortran  RTL  supports  only  a  variable  of  the
    character   data  type  as  a  format  data  specifier  (ie.;
    write(unit,FMT=character_data_type_variable)). Therefore
    Integer  and  Real  expressions  cannot be used as the format
    specifier in an I/O statement.

 o  The Visual Fortran RTL supports only the character data  type
    for Internal files.

 o  The  Visual  Fortran  RTL  does  not  support   the   Fortran
    Powerstation  I/O  status  (IOSTAT) values.  Thus, the Visual
    Fortran RTL returns its own unique I/O status values.

 o  The  Visual  Fortran  RTL  does  not  support   the   Fortran
    Powerstation  I/O  messages.   Thus,  the  Visual Fortran RTL
    returns its own unique I/O error message values.

 o  For the INQUIRE statement BLANK= keyword, the Visual  Fortran
    RTL  will  return a value of "UNDEFINED" for a file which was
    not  opened  as  formatted.   This  complies  with  the   F90
    standard.    This   behavior   is   different   from  Fortran
    Powerstation which returned a value of "NULL" or "ZERO".

 o  For the INQUIRE statement PAD= keyword,  the  Visual  Fortran
    RTL  will  return  a  value of "YES" for a file which was not
    opened or connected.  This complies with  the  F90  standard.
    This  behavior  is  different from Fortran Powerstation which
    returned a value of "UNDEFINED".

 o  The Visual Fortran RTL will return an error if  the  PAD=  or
    DELIM=  specifier  is  present  on the open statement and the
    file was not opened as formatted.  This complies with the F90
    standard.

 o  The Visual Fortran RTL will return an error if the  POSITION=
    specifier  is  present on the open statement and the file was
    not opened with sequential access.  This  complies  with  the
    F90  standard.   This  behavior  is  different  from  Fortran
    Powerstation which failed to return an error.

 o  The Visual Fortran RTL recognizes files opened as CONOUT$ and
    CONIN$  as  the  terminal.   This  behavior is different from
    Fortran Powerstation which  didn't  recognize  these  special
    devices names as the terminal.

 o  The Visual Fortran RTL does not support the use  of  negative
    unit numbers.  This complies with the F90 standard.

 o  The Visual Fortran RTL does not support the use  of  the  '*'
    operator as the unit number on an INQUIRE statement.

 o  The Visual Fortran RTL  supports  only  the  record  type  of
    'STREAM' for the "RECORDTYPE" value when dealing with Fortran
    Powerstation Unformatted files.

 o  The Visual Fortran RTL  supports  only  the  record  type  of
    'FIXED'  for  the  "RECORDTYPE" value when dealing with files
    opened for Direct access.

 o  The Visual Fortran RTL  does  not  support  the  reading  and
    writing   of  direct  access  records  using  Sequential  I/O
    statements.

 o  The Visual Fortran RTL does not support the writing of direct
    access  formatted  records  with  a carriage control value of
    'FORTRAN'.

 o  The Visual Fortran RTL has  an  additional  carriage  control
    attribute  value  called  'NONE'.  Thus, the default carriage
    control  attribute  is  different  from   that   of   Fortran
    Powerstation  when  dealing  with  different file types.  For
    unformatted and binary files  the  default  carriage  control
    attribute  is  'NONE' as opposed to the value of 'LIST' which
    is given by Fortran Powerstation.

 o  The  Visual  Fortran  RTL  does  not  support   the   Fortran
    Powerstation   semantics  for  the  Binary(B),  Octal(O)  and
    Hexidecimal(Z) edit descriptors.

 o  The Visual Fortran RTL output  text  when  printing  namelist
    elements  is  different,  but should be equivalent to that of
    Fortran Powerstation.

 o  The Visual Fortran RTL  when  outputting  real  numbers  will
    always  print a leading zero(0)(ie.; 0.567) if there is room.
    This is different than Fortran Powerstation  which  does  not
    always print the leading zero(0)(ie.; .567) if there is room.

 o  The Visual  Fortran  RTL  does  not  support  the  MATHERRQQ,
    GETCONTROLFPQQ, SETCONTROLFPQQ, and GETSTATUSFPQQ routines on
    non-Intel Platforms(ie.; Alpha)

 o  The Visual Fortran  RTL  applies  the  rules  for  Iw  format
    editing  when  G  format  output  editing is specified for an
    integer data type.  This  complies  with  the  F90  standard.
    Fortran  Powerstation  applies  the  rules for Iw.m format in
    this case.

 o  The Visual Fortran RTL does not  interpret  the  backslash(\)
    edit  descriptor  on input, it has no effect.  This is unlike
    Fortran Powerstation which does  interpret  the  backslash(\)
    edit  descriptor on input.  This is in contradiction with the
    Fortran Powerstation documentation which states it has effect
    only on output.

 o  The Visual Fortran RTL does not support what appears to be an
    inconsistency  with the F90 standard and Fortran Powerstation
    list-directed output.  Fortran Powerstation properly places a
    separator  between  most  data types (ie.; int-int, int-real,
    real-int, logical-int, etc).  However it  fails  to  place  a
    separator  between  an  undelimited  character string and any
    other adjacent data  type.   For  delimited  characters  they
    properly  add  the separator.  The former behavior appears to
    be a violation of the F90 standard.  See section 10.8.2 which
    states  the  following:   "The form of the values produced is
    the  same  as  that  required  for  input,  except  as  noted
    otherwise.   With  the  exception  of  adjacent  nondelimited
    character constants, the values are separated by ONE or  MORE
    BLANKS...."  Thus,  there  should be no separator between two
    nondelimited character  constants,  but  there  should  be  a
    separator  between  a nondelimited character constant and any
    other adjacent data type.


--------  Developer Studio Release Notes  --------

 o QuickWin and Standard Graphics projects cannot be copied from
   the Intel platform to the Alpha platform and vice-versa.  You must
   recreate the project on the new platform. 

 o Fortran editor syntax coloring has limitations.  The syntax
   coloring in the Developer Studio editor cannot correctly color all
   valid Fortran source programs. In particular, white space is
   required around keywords in order for the editor to correctly
   recognize them. 

 o Fortran editor does not handle tab indents properly.  This
   problem occurs when editing a fixed format source file and using
   tabs at the beginning of the line.  When you have multiple tabs at
   the beginning of a line and press ENTER, the cursor is positioned
   to the same indent level as the previous line.  However, when you
   type the first character on the new line, all but the first tab
   are deleted. Here are 2 workarounds: 
     1. Press tab as the first character on the new line and then
        Backspace to delete it.
     2. Select the Tools menu, Options item, Tabs tab.  Select
        "Insert spaces" and set "Auto Indent" to None.

 o The .fpp file extension is now recognized as a Fortran source file
   suffix.  These files can be used with the DF /fpp switch to invoke
   the Fortran preprocessor.  If you build such a project in Developer
   Studio and export the make file for the project, you must edit the
   makefile and add the line: 

     .SUFFIXES: .fpp

   in order for the .fpp files to be compiled by the make file.

 o Visual Fortran does not support the "Attach To Process" menu
   item on the Debug menu as described in the Developer Studio
   Environment User's Guide.  You must have Microsoft Visual C++ 
   installed to use this Developer Studio feature.
 
 o Accessing online help brings up Dial-up Dialog Box. When
   accessing online help you may get a dialog box asking about your
   dial-up connection for your online service provider. This occurs
   because Internet Explorer, which has an option to automatically
   connect to the online service, is used to display the online
   documentation. The best way around this is to choose Cancel when
   asked to connect. You can disable automatic dialup. 

   To turn off the automatic dialup:

   1.Right click on the IE shortcut to get the Context menu and
     select "Properties". 
   2.In the dialog, choose the Connection tab. 
   3.In the Dialing group, uncheck the "Connect to the Internet as
     needed".  This will turn off the Auto dialup. 
   4.Click on Apply and OK to close the dialog.

 o Certain types of links in the online documentation may not appear
   to work.  They look like links, but if you click on them, nothing
   happens.  Such inactive links may be due to a setting in your
   Internet Explorer 3.0 that prevents running ActiveX scripts. 

   To enable the links, do the following: 

     1.Open Internet Explorer 3.0. 
     2.From the View menu, select Options. 
     3.In the Options dialog box, select the Security tab. 
     4.Under Active content, check the Run ActiveX scripts checkbox. 
     5.Click Apply. 
     6.Click Okay.  

 o The Developer Studio user interface does not respond to mouse
   clicks or keystrokes until a macro finishes. This design prevents
   indiscriminate interference between macros. However, processing a
   lengthy macro gives the appearance that the user interface has
   hung. 

 o When you select "Build browse info file" in the Browse Info
   option page, Developer Studio may display the following message: 

    "The Browser Information file will not be created unless 'Generate
    browse info' is checked on the C/C++ settings page for the target
    or at least one file" 

   For Fortran-only Developer Studio projects, check 'Generate Source
   Browse Information' on the Fortran page, General    category. You
   do not need to set any C/C++ settings. 

 o If Developer Studio repeatedly aborts while attempting the same
   action with the same project, try moving the project.opt file out
   of the project directory.  The project.opt file contains local
   cosmetic settings, which include information about the local
   organization and appearance of the project workspace using your
   hardware and configuration. A new project.opt file is created
   automatically when the workspace is opened and no project.opt file
   is found. 

 o If the screen flashes during builds or the wrong code page is
   used when debugging a console application, and you are using
   Windows 95, delete any of the following files from your computer: 

     _DEFAULT.PIF, DEFAULT.PIF, CONAGENT.PIF

   These files were used by Windows 3.x, and are not needed by
   Windows 95. If they are used while you are debugging a console
   application, the country settings associated with the PIF files
   will be used, and could result in the wrong code page being
   loaded. A result of their use on Windows 95 may be screen flashing
   during a build, if you have specified console windows to be full
   screen. 

 o Several project system and debugger methods are disabled when
   the BuildFinish event is fired.  Consider the following VBScript
   event handler: 

   Sub Application_BuildFinish(nNumErrors, nNumWarnings)
   if nNumErrors+nNumWarnings = 0 then
       ExecuteCommand "ToggleOutputWindow"
       ExecuteConfiguration
   end if
   End Sub

   ExecuteConfiguration fails because the BuildFinish event is fired
   before several project system and debugger commands have been
   re-enabled. The methods that invoke these commands, like
   ExecuteConfiguration, will remain disabled between the time that
   the event is fired and the time the event handler returns. After
   the Application_BuildFinish event handler returns, these methods
   will be re-enabled. 

   Workaround:

   1. Create a new macro, for example, MyBuild, with the following
      code: 

      Sub MyBuild
        Build
        ' Add other method calls here that can't appear in the
        ' BuildFinish event handler, such as "ExecuteConfiguration"
      End Sub

   2. Always invoke a build by using this new macro instead of using
      the default Build menu command or toolbar. Note that you can
      create a custom menu command or toolbar button for your new
      MyBuild macro by going to the Tools menu, choosing Customize,
      and using the Commands tab of the dialog.

   The Application_BuildFinish VBScript event handler now becomes:

   Sub Application_BuildFinish(nNumErrors, nNumWarnings)
      if nNumErrors+nNumWarnings = 0 then
        ExecuteCommand "ToggleOutputWindow"
      end if
   End Sub

   In this case Build will fire the BuildFinish event and return
   control to the MyBuild subroutine at which time the
   ExecuteConfiguration will be enabled. You can see what other
   methods are disabled simply by looking at the disabled menu items
   when a build is in progress. 


--------  Fortran Format Editor Release Notes  --------

 o The Format Editor does not support "Variable Format Expressions".

 o The Format Editor does not support "Repeat Specifications"
   greater than 99.

 o Repeatable edit descriptors can be specified without a field width
   value. Since the Format Editor does not know the attributes of the
   Fortran data that will be associated with the edit descriptor at
   run-time, it uses a default field width based upon the type of the
   edit descriptor. The following table lists the repeatable edit 
   descriptors and the default field width used by the Format Editor
   for displaying the sample field data.

   Edit Descriptor   Default Width
        A                10
        I                 7 
        L                 2
        B                 8
        O                 7
        Z                 8
        F                15
        D                15
        E                15
        G                15
        EN               15
        ES               15


--------  Debugging Related Release Notes  --------

    The following changes have been made to the debug support in
DVF v5.0.A since DVF v5.0 shipped:

 o Expression evaluator support for LF_DIMVARLU type records.

 o Support for Equivalenced variables

 o Automatic (non-dummy argument) arrays currently now show up as
   variables in the debugger.  For example, in the following code,

                subroutine foo(n)
                integer b(n)
                ...

   The variable 'b' appears in the local window and can
   be 'watched'.

 o Compiler-created temporaries are no longer displayed in the
   "locals" window in the debugger.  Getting rid of this extraneous
   information makes the display much clearer.

 o Previous to this release, a lower bound of "0" in an explicit
   array was displayed in the debugger as "1".  This has been fixed.

 o Host associated variables are now visible in the debugger from
   within the internal subroutine.  For example:

                program foo
                integer i,j
                call bar

                contains
                   subroutine bar
                   integer k,l

                   print *, i,j,k,l
                   end subroutine

                end

   Previously, when at the print statement within bar, k and l could 
   be seen in the debugger, but i and j could not.  Now all four would
   be visible.

 o Byte-sized integer types (BYTE, INTEGER*1, LOGICAL*1) did not
   display correct values in the debugger previous to this release.
   This bug has been fixed.

 o Given an array of 'n' elements of one type that is equivalenced to
   'n' scalar variables of the same type (each scalar is
   equivalenced to an element of the array), the debugger was not
   displaying the proper value for the scalar variables.  This has
   been fixed.

 o Given a user defined type with a link to another element of the
   same type, e.g. 

	type :: listType
            integer :: i
            type(listType) , pointer :: next
        end type

   it was impossible to look at the value of the 'next' field in a
   variable of this type within the debugger.  This has been fixed.

Known problems with the current support:

 o Assumed-shape arrays with alternate lower bounds do not display
   properly, e.g. in the example below:

                subroutine foo(bar)
                integer bar(5:,10:)
                ...

   bar will not display properly since alternate lower bounds (5 and
   10 for dimensions one and two, respectively) have been specified.

 o When in a module routine, a module variable cannot be seen without
   entering the decorated name.  For example, with the following
   code:

                module foo
                    integer first

                    subroutine bar()
                    ...
                    end subroutine bar
                end module foo

   If the debugger was stopped within subroutine bar, the variable
   "first" would only be visible in a watch window if "FOO_mp_FIRST"
   was entered.  The name decoration takes the form:

                {module_name}_mp_{variable_name}

 o If a variable of some derived type is given the same name as the
   name of the derived type, that variable cannot be seen within the
   debugger (the current workaround is to keep derived type names 
   distinct from variable names), e.g.

		type foo
		   integer i,j
                end type foo

		type (foo) foo

   the variable 'foo' is not currently visible in the debugger. 
   Changing the variable name to bar, e.g.

		type (foo) bar

   alleviates this problem.


(c) 1997 Digital Equipment Corporation. All rights reserved.
