Lahey/GNU Fortran for 32 and 64-bit Windows

Release "Rainier"

The Rainier edition of LG Fortran contains:

Automatic parallelizing compiler producing 32 and 64-bit executables
The Lahey Visual Studio Fortran development environment features a fresh build of GFortran, using the latest
source code pulled from the stable branch of the repository, and the latest versions of the prerequisite packages.

Visual Studio 2015 Shell LG Fortran comes with the most sophisticated development environment
available - Visual Studio! The LGF compiler system will run in your choice of Visual Studio 2017, 2015, 2013 or 2012 development environments.
Already have VS 201x? Lahey's LG Fortran will
install into your existing Visual Studio without a hitch.

Lahey's Exclusive Visual Studio Fortran support Realize the full power of Visual Studio to
dramatically improve productivity with Lahey's Visual Studio Fortran support. We think that once you work
with a real Fortran development environment, you will never be able to go back to other minimal
development environments.

Full Fortran 77,
90, and 95 compliance with extensive support for the Fortran 2003 and 2008 standards.
Compatible with Visual Studio 2017/2015/2013/2012, Windows 10/8.x/7 (32 and 64-bit) and more.

Speed. Dependability. Great Development Environment. Lahey/GNU Fortran.
A new standard for Fortran programming from the leader in
Fortran language systems.

We've combined our 45 years of
producing award-winning Fortran language systems with the excellent
GFortran compiler which contains a high-performance code generator and automatic parallelization
technology to deliver the most-productive, best-supported Fortran language system for
the PC yet. Built using the latest source, the Lahey GFortran compiler is the most capable and up to date
GFortran build available.

To support the compiler, Lahey provides a sophisticated Visual Studio development
environment with an unprecedented level of Fortran-intelligent features to dramatically
improve programming productivity. Check out LG Fortran for a look at what
real language support looks like!

Whether you write new Fortran programs or maintain existing
applications, you need instant information about program parameters, easy navigation to places
of interest in your code, not to mention speed, dependability, and great tech support.
You need LG Fortran!

Statically Link GCC Object
Files

LG Fortran allows static linking with object files generated by the
companion GCC C compiler and supports the ISO_C_BINDING intrinsic module.
Combine your Fortran and C code
into one executable. For the routines you don't want to develop
yourself, you can also link with C/C++ routines from commercially
available libraries.

Legacy Fortran Support

LG Fortran provides an easy means of upgrading your old LF Fortran project files to work in
the LGF development environment. The LGF project facility even supports switching compilers
so that projects can use LF95 instead of LGF. LG Fortran extends its
language support in other directions adding many legacy Fortran
features, including g77 support and the various UNIX service
routines. These features further facilitate your move to
cost/performance efficiency on the PC platform.

LG Fortran is a
complete implementation of the ANSI/ISO Fortran 95 standard, provides major support for Fortran 2003,
and extends significant support for the Fortran 2008 Standard.

Fortran 2003 offers major improvements over Fortran 95, largely completing the ability
to perform object oriented
programming begun with Fortran 90. In addition, it introduces the concept of an intrinsic module.
An intrinsic module contains encapsulated intrinsic procedures and/or data that presents a standardized means
of providing a service defined by that intrinsic module. An example of an intrinsic module is ISO_C_BINDING,
which presents a standardized interface the Fortran user can utilize to interface with a C compiler, and defines
type parameters that can be used to represent C pointers and data in Fortran code.
Another intrinsic module, ISO_FORTRAN_ENV provides information about the
execution environment the program is running in. A companion C compiler is provided that can be called using ISO_C_BINDING
intrinsic module. Currently, the most notable exception to complete compliance is the lack of support for IEEE 1989
exception handling via the IEEE_ARITHMETIC intrinsic module.

Fortran 2008 is a minor revision in comparison with Fortran 2003, most notably, it standardizes
support for the long-standing concept of co-arrays from High Performance Fortran (HPF).

IEEE Standard 754 supportIEEE Standard
754 defines the representation and behavior of 32- and 64-bit
floating point numbers. IEEE 754 support provides for consistency of
basic computational results among platforms that use IEEE 754.
A heavy-duty online discussion of floating point numbers and the
standard is provided by David Goldberg at http://docs.sun.com/source/806-3568/index.html.

Visual Studio 2015 Shell with Lahey's exclusive
Fortran Support

Lahey's Visual Studio Fortran support is the most feature complete Visual Studio environment available.
Our attitude is that the Fortran programmer deserves all the features and conveniences that the C# or Visual Basic
programmer enjoys.

Project system

The project is a
basic building block that Visual Studio uses to create applications.
A project will normally take a set of one or more source files and
produce a compiled executable, but a project can also produce things
like DLLs or static libraries, or do other sorts of processing. All
the source files within a project are usually written in one
programming language, and are compiled with one compiler. The Fortran
support package provides several type of projects, and allows
users of previous versions of Visual Studio to automatically upgrade
their native Fortran projects to VS 2015. The Fortran project facility
automatically scans all source files at build time and ensures all
files are built in the proper order to satisfy module
dependencies.

Project templates

On-line integrated help

The
VS Fortran support package provides documentation that is viewed using the
Visual Studio help system. The comprehensive documentation
covers the Fortran language, compiler usage, and explanations of the Fortran-smart
Visual Studio editing features:

Syntax coloring

Syntax coloring
provides the ability to differentiate code elements based on color.
For example, a keyword may appear in blue, comments may appear in
green, while character strings might be maroon. The Fortran language
allows variables and procedures to have the same names as keywords,
and this can pose a problem for colorizers that do not have a strong
parsing ability. Since the parser used in the Lahey colorizer is
derived from a Fortran compiler, it is unlikely that it would be
confused by an identifier with the same name as a keyword. The
support package allows the user to customize the colorizing
scheme.

Expandable code

Expandable code
can make the chore of navigating through sections of code easier by
allowing you to collapse a region of code into a single line. This
feature works at the module and procedure levels by default, but the
user has the ability to add new outlining regions, or to remove
existing outlining regions.

A portion of the collapsed code can be viewed by hovering
the mouse over the box containing the "...":

Method tips for intrinsic
functions

Parameter Info is a feature that helps the user
write code by displaying information about intrinsic procedures as
the user is typing. Parameter Info is currently implemented for all
intrinsic procedures, and Lahey extensions supported by
LGF.As a procedure invocation is typed, the open parenthesis
character triggers the Parameter Info tooltip for the first
argument:

As typing continues, each succeeding comma character that is
typed will trigger a tooltip for the next parameter:

When a close parenthesis character is typed, the tooltip
window is dismissed. The tooltip window is also dismissed whenever
the cursor is moved outside of the area of the argument
list.

Quick info for local and global
variables

Quick Info provides the user with information
about variables and intrinsic procedures by displaying an
informational tooltip window when the mouse is hovered over a name.
Quick Info is currently implemented for all intrinsic
procedures, Lahey extensions supported by LGF, and variables that
are defined within the same project.

Block commenting and
indenting

Block commenting is a feature that allows the
user to quickly comment or uncomment selected blocks of code. Block
indenting allows the user to change the indentation of a selected
block of code. Both of these features work for code that is
highlighted. If any portion of a line is highlighted, the feature
works on the entire line. If there is no highlighted code,
commenting or indenting will work on the single line where the
cursor resides.

The indenting rules and options you desire can be set within Visual Studio:

Parenthesis matching

Parenthesis
matching is a feature that locates a matching parenthesis and
highlights the parenthesis pair. This feature can be quite useful
when examining a complex statement. The following diagram shows a
single multiline code statement with the matching parentheses highlighted
with a light gray box:

Block Reformatting

Block
Reformatting is a free-format source code feature that allows the
user to quickly reformat the current line, selected blocks of code,
or the entire document. Reformatting is done by optionally
highlighting a section of code, then choosing the
Edit|Advanced|Reformat Selection menu option. You may select Format
Document instead of Format Selection, and the entire document will
be reformatted regardless of selection area. Indentation level can be controlled from the
Visual Studio Tools|Options menu. If any portion of a
line is highlighted, the feature works on the entire line. If there
is no highlighted code, the single line where the cursor resides
will be reformatted.

The formatting rules and options you desire can be set within Visual Studio:

A section of code before
reformatting:

And
after:

Code Completion

Code
Completion is a source code editor feature that assists rapid
development by offering an alphabetical list of possible keywords,
names, and code snippets that might be entered as code is typed into
the editor. The list display is triggered by typing an alphabetic
character at the beginning of a line, after whitespace, or after any
symbol.

If
another character is typed, the list will be reduced to only those
items that begin with that text.

Code Snippets

Code Snippets
are a source code editor feature that assists rapid development by
allowing pre-defined blocks of code to be easily inserted into the
editor. Snippets are normally code that is often entered, such as IF
constructs, FUNCTION definitions, and header comment blocks. Code
Snippets can be inserted by selecting from the Code Completion list
(press Tab after selecting), or by right-clicking and selecting
"Insert Snippet...".

When a Snippet is first inserted, the
snippet-entry mode is activated. The names that are normally changed
by the author will be highlighted fields. When the cursor is in a
field, that field's text can be changed.

Press Tab to move to the
next field. Press Enter when finished changing the fields, thereby
terminating snippet-entry mode. It is possible for a Code Snippet to
have no fields and not activate the snippet-entry mode.

Collapsible
Regions

User-defined Collapsible Regions can make the
chore of navigating through sections of source code easier by
allowing you to collapse a region of code into a single line. The
Fortran compiler treats these lines as comments. The region can then
be collapsed by clicking on the minus symbol in the margin next to
the !#region line. To expand the region, click the plus symbol in
the margin.

Once collapsed,
you can hover the mouse over the [...] box to see the contents of the collapsed
region:

Find All References

Find All
References is a feature that allows the user to display a list of
all known references to a name within all of the source code in the
Solution. It works in both the source code editor window, Class View
and Object Browser. Right-click on a name in a Fortran code editor
window to display a list of all known references to that name within
the scope of the current cursor position. Right-clicking on anything
other than a name will have no effect. Right-click on a item in the
Member pane of Class View or Object Browser to display a list of all
known references to that name within the Solution. The list will be
displayed in the Find Symbol Results window. Double-click on a line
in the list to open the source code file and jump to the position of
that reference.

Go To Declaration

Go To
Declaration is a feature that allows you to jump to the declaration
of a variable or procedure. This can be done by placing the mouse
over the name you want to see the declaration for, right clicking
and selecting "Go To Declaration" from the floating menu.

The
edit cursor will then jump to the line that contains the declaration
for the name:

Navigation Bars

Use the
drop-down navigation bars above a Fortran code editor window to view
or jump to a module or procedure definition within the code. The
navigation bar on the left contains the Main Program and Modules
defined in the source code file. Note that if a file contains
subprogram(s) and no Main Program, "(MAIN)" will be displayed as a
placeholder for the Main Program. The navigation bar on the right
contains procedures defined in the source code file. Dimmed
procedure names are out of scope for the current cursor position,
but can still be selected.

Smart Indenting

Smart Indenting
is a free-format source code feature that allows the editor to
indent the last line entered (terminated by the Enter key) as
appropriate in relation to the previous line or the beginning
statement of a code block. A code block consists of any statement
that has a corresponding END statement.

Building Projects and Viewing
Errors

To build a Fortran project, select the "Build
Solution" or "Rebuild Solution" option from the Build pull down
menu. Alternatively, you can right-click on the project name in the
Solution Explorer and select "Build" or "Rebuild" from the context
menu that appears. The Error List window shows any build errors that
occurred. Double-click on a message in the list to open the source
code file and jump to the position where the error occurred. The
current source code editor window will mark the location of build
errors with a squiggly underline. Positioning the mouse pointer over
the location of those markers will display the error in a Quick Tip.

Integrated Debugger

Fortran programs can be debugged using Visual
Studio, which hosts the command line debugger. The LG Fortran
support package uses Visual Studio debugging interfaces to seamlessly integrate
the command line debugger and enable the sophisticated Visual Studio debugging interface.
This allows you to debug your Fortran
program using the Visual Studio Debugging interface. While debugging, you can
watch the values of variables change during program execution and
set breakpoints with a mouse click. Using the VS debugging
interface, you can run your program, set breakpoints, step a line at
a time, view the values of variables in your program in several
different ways, change the values of variables, and examine stack
frames while running your program. The current executable line and
any breakpoints are indicated with markers in the left margin of the
source code display. If needed, the program will be rebuilt, the
debugger will be started and the program will begin execution. When
the program breaks execution, the execution pointer is displayed at
the corresponding location in source code.

Locals display

To
examine all local variables within the scope of the current
procedure, open the Debug menu and expand the "Windows" item. Select
"Locals" from the "Windows" sub menu.

Watch Windows

To
watch a variable within the scope of the current procedure, open the
Debug menu and select "QuickWatch". A dialog will appear that allows
you to type the name of the variable you want to watch. If the name
matches a valid variable in the program, it will be added to the
watch list. To view a watch window, open the Debug menu and expand
the "Windows" item. Select "Watch" from the "Windows" sub
menu.

Quick Debugging Info

While
debugging, variable values are added to the intellisense "Quick
Info" display, which allows values to be examined by hovering the
mouse over the variable in question.

Stack navigation

When stopped at a breakpoint, stack frames can be
examined using the "Call Stack" window:

By double clicking on a different stack frame,
that frame is activated and variables within that frame can now be examined:

Class View and Object
Browser

Class View displays the entity names defined in
the application you are developing. You can open Class View from the
View menu. There are two panes: an upper Objects pane and a lower
Members pane. The Objects pane contains an expandable tree of names
whose top-level nodes represent Projects. Expand a Project name in
the Objects pane to list the Main Program and/or Modules defined
within it. Variables, constants, procedures, TYPEs, INTERFACEs, and
USEs for the selected Object are listed in the Members pane. Note
that if a project contains subprogram(s) and no Main Program
definition, a placeholder for the Main Program named "(MAIN)" will
appear in the Objects pane. Right-click on an item in the Members
pane to find all references of that name or to open files and
navigate directly to the line where that name is defined.

The
Object Browser is similar to Class View but shows more information.
It also displays the names defined in the application you are
developing. You can open Object Browser from the View menu. There
are three panes: an Objects pane on the left, a Members pane on the
upper right, and a Description pane on the lower right. If you
resize the Object Browser into a single column, the Objects pane
moves to the top, the Members pane to the middle, and the
Description pane to the bottom. The Objects pane contains an
expandable tree of names whose top-level nodes represent Projects.
Expand a Project name in the Objects pane to list the Main Program
and/or Modules defined within it. Variables, constants, procedures,
TYPEs, INTERFACEs, and USEs for the selected Object are listed in
the Members pane. Details on the item selected in the Objects pane
or Members pane appear in the Description pane. Note that if a
project contains subprogram(s) and no Main Program definition, a
placeholder for the Main Program named "(MAIN)" will appear in the
Objects pane. Right-click on an item in the Members pane to find all
references to that name or to open files, and navigate directly to
the line where the name is defined. You can also click on a USEd
module name in the Description pane to jump to that member in Object
Browser.

Automation
support

Automation is the ability to control Visual
Studio, solutions and projects with software. It allows the user to
programmatically control project creation and modification, to set
project and file compilation options, and to build and execute
projects.

MSBuild support

MSBuild is
Microsoft's XML-based build system. It is integrated with Visual
Studio, but it can also be used on the command line. The LG Fortran
Project facility uses MSbuild when building projects. For a
comprehensive description of MSBuild, see the MSDN documentation for
msbuild.exe.

Other Development Tools

Complementing the Windows
Development Environment, LG Fortran includes a linker, librarian,
coverage tool, and other utilities for building and linking programs and libraries.

Winteracter Starter Kit

Use the
Winteracter Starter Kit -WiSK - to create GUI-based
Fortran programs, using standard Windows controls. WiSK is a
subset of the Winteracter toolset created by Interactive
Software Services, Ltd. Winteracter is a Fortran callable,
user-interface and graphics development kit with versions available
for Windows, Linux and Mac OS X . Derived from Winteracter,
WiSK provides a library of subroutines to manage user
interface components such as windows, menus, dialogs, mouse and
keyboard. Menus and dialogs are designed/maintained using the
supplied visual resource editor, ResEdit. A manifest creation
tool enables use of the latest visual styles on Windows XP onwards.
A set of graphics primitives are also included in the WiSK
library, along with source code for an emulation of the earlier
Lahey Video Graphics Library. WiSK is completed by the
Application Wizard, which provides a jump start when producing new
GUI based applications.

LGF Driver Program

LG Fortran includes the powerful command line LGF driver program to simplify and enhance use of GFortran in a console environment, and to maintain compatibility with previous versions of Lahey Fortran. The LGF driver is able to accept LF95 options, and "translate" them into commands that GFortran can understand.

Target Operating System

Support Policies

Lahey provides support exclusively to licensed customers of Lahey products.
However, if you have a trial version of our product and require some help getting
started, please contact Lahey support.

Terms of support

Lahey provides installation and getting started email support for the compiler, tools and development environment, as well as access to product enhancements, upgrades and bug fixes, for a period of one year after purchase of the product. At the end of this period and each period thereafter, the customer has the option of renewing maintenance. If maintenance is not renewed, the language system will continue to function at the level it was when maintenance expired, but the customer will not be allowed any further access to product updates or bug fixes. Customers purchasing new hardware for use with an existing Lahey product can contact Lahey support at any time for assistance with new license keys.