Lahey/GNU Fortran for 32 and 64 bit Windows
New Release “Lassen”
- Visual Studio 2013 Shell
- Advanced, configurable, source code formatting (indenting, spacing, etc.).
- VS Start Page for Lahey Fortran with links and checkbox to revert to the VS default Start Page ( this replaces the old getting started html page)
- GFortran 4.9.1 (note: .MOD files must be recompiled)
- WiSK v10.0
The Lassen 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 2013 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 2013, 2012 or 2010 development environments. Already have VS201x? 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 2013/2012/2010, Windows 8/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!
LG Fortran Delivers!
LGF includes fresh builds of the powerful GNU Fortran auto-parallelizing compiler, linker, command line debugger, librarian, Microsoft’s Visual Studio 2013 Shell with Lahey’s exclusive Fortran support, integrated GDB debugger, the Winteracter Starter Kit WiSK for creating Windows GUIs and displaying graphics, support for creating DLLs, calling Windows APIs, online documentation, and a year of technical support. Also included is a coverage analysis tool that detects unexecuted code and performs range-of-operation checking, an execution profiler that helps tune program performance, and a companion optimized parallelizing GCC C compiler.
- LG Performance.
- LG Optimizations.
- Statically Static Link with GCC Object Files.
- DLL Interfaces to Visual Basic, VC++, and .Net.
- Legacy Fortran Support.
- ANSI/ISO-Compliant Fortran 95.
- Visual Studio 2012 Shell with Lahey’s exclusive Fortran Support.
- Winteracter Starter Kit.
- LGF Driver
- GCC C Language System.
- Support Policies.
LG Fortran Performance
LG Fortran Optimizations
- Constant folding
- Common subexpression elimination
- Predictive commoning
- Copy propagation optimization
- Branch and jump optimizations
- Algebraic simplification
- Variable tracking
- Dead code elimination
- Peephole optimizations
- Loop invariant code motion
- Register move optimizations
- Instruction scheduling
- Address calculation optimization
- Array optimization
Program Reconstruction Optimizations
- Parma Polyhedra Graphite optimizations
- Loop unrolling
- Loop interchange
- Loop blocking
- Loop peeling
- Loop strip-mining
- Tree-level loop optimizations
- Loop parallelization
- Tree vectorization of loops
- Function reordering
- Code Inlining
- Stack Optimization
- Inter-procedural optimizations
- Whole-program optimization
- Support for the following processors: i386, i486, i586, pentium, pentium-mmx, pentiumpro, i686, pentium2, pentium3, pentium3m, pentium-m, pentium4, pentium4m, prescott, nocona, core2, corei7, corei7-avx, core-avx-i, atom, k6, k6-2, k6-3, athlon, athlon-tbird, athlon-4, athlon-xp, athlon-mp, k8, opteron, athlon64, athlon-fx, k8-sse3, opteron-sse3, athlon64-sse3, amdfam10, barcelona, bdver1, bdver2, btver1, winchip-c6, winchip2, c3, c3-2, geode
- Set FPU floating point precision
- Prefetch optimization
- Fast input/output libraries
- Supports AVX, AVX2, BMI2, FMA2, MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 built-in functions and instructions
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.
DLL Interfaces to Visual Basic, Visual C/C++, GCC and Microsoft .NET Languages
Create 32 and 64 bit Windows DLLs from your Fortran code and call the Fortran routines from 32 and 64 bit Windows programs created with Microsoft Visual Basic, Microsoft Visual C++, and Microsoft .NET languages.
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.
Create highly optimized, inheritable, instantiable and static class objects using LG Fortran
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 support
IEEE 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.
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
- Win32 project templates
- On-line integrated help
- Syntax coloring
- Expandable code
- Method tips for intrinsic functions
- Quick info for local and global variables
- Block commenting and indenting
- Parenthesis matching
- Block Reformatting
- Code Completion
- Code Snippets
- Collapsible Regions
- Find All References
- Go To Declaration
- Navigation Bars
- Smart Indenting
- Building Projects and Viewing Errors
- Integrated Debugger
- Class View and Object Browser
- Automation support
- MSBuild support
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 2013. 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.
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 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 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 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 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.
A section of code before reformatting:
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 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.
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:
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 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.
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.
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.
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.
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 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 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.
New Features in WiSK 9.1
- Support for Windows XP/Vista/7 visual styles. Dialog controls can automatically adapt to native “look” of current platform.
- Substantially updated resource editor
- Documentation extensively updated
- Resizable dialogs
- Integer and real numeric dialog fields
- New and updated example programs
- Improved runtime error reporting
- Additional library and system interrogation functions
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.
LGF Driver Options
|-32||Generate 32 bit code|
|-64||Generate 64 bit code|
|-[n]ap||Guarantee consistency of REAL and COMPLEX calculations|
|-[n]c||Create object and/or module files without an executable|
|-[n]chk [<args>]||Check substrings and array subscripts, non-common variables accessed before initialization, and mismatched procedure arguments|
|-[n]co||Display compiler options|
|-[n]cover||Generate information for use by the coverage tool|
|-[n]dbl||Extend REAL and COMPLEX variables, arrays, constants, and functions to KIND=8|
|-[n]dll||Generate a dynamic link library|
|-[n]f95||Generate warnings for non-standard Fortran 95 compliance|
|-[n]f2003||Generate warnings for non-standard Fortran 2003 compliance|
|-[n]f2008||Generate warnings for non-standard Fortran 2008 compliance|
|-[n]fix||Interpret source files as Fortran 95 fixed source form|
|-[n]g||Generate debugger information|
|-i <path>||Specify search path for Fortran INCLUDE files|
|-[n]in||Equivalent to including an IMPLICIT NONE statement in each program unit|
|-[n]inline [<value>]||Inline user-defined procedures|
|-[n]li||Avoid recognizing non-standard Lahey intrinsic procedures|
|-lib <file>||Specify library file for linker|
|-libpath <path>||Specify search path for libraries|
|-[n]long||Extend all default INTEGER variables, arrays, constants, and functions to KIND=8|
|-[no]map <name>||Link only. Create a map file with the same name as output file|
|-[n]maxfatals <value>||Specify maximum number of fatal errors allowed before stopping compilation|
|-ml <arg>||Generate code compatible with other languages|
|-mod <path>||Specify search path for module files|
|-o0||Optimization level 0 – perform no optimization|
|-o1||Optimization level 1 – perform full optimization|
|-o2||-o1 plus loop and array optimizations|
|-o3||-o2 plus additional loop and array optimizations|
|-os||Optimize for minimum size|
|-ofast||Optimization level 3 plus fast math and stack optimizations|
|-out||Specify output file name|
|-[n]parallel||Automatic parallelization and vectorization|
|-[n]pause||Create pause after program completion|
|-[n]prefetch <value>||Generate prefetch optimizations|
|-[n]private||Set default block size for OPEN statements|
|-[n]quad||Extend all double-precision REAL and COMPLEX variables, arrays, rays, constants, and functions to KIND=16|
|-[n]sav||Allocate local variables in a compiler-generated SAVE area|
|-[n]sse||Optimize using SSE instructions|
|-t <arg>||Specify target processor|
|-[n]trace||Include procedure traceback and line numbers in runtime error messages|
|-[n]trap <args>||Trap numeric data processor (NDP) exceptions at runtime|
|-[n]unroll [<value>]||Control loop unrolling|
|-[n]verbose [<value>]||Verbose compiler output|
|-version||Display version and owner information only|
|-[n]w||Generate warning messages|
|-wide||Wide fixed form line length|
|-win||Create Windows application|
|-winconsole||Create Windows Console application|
|-[n]wisk||Create application that uses the Winteracter Starter Kit (WiSK)|
|-[n]wpo||Whole program optimizations|
LG Fortran System Requirements
Lahey/GNU Fortran with Visual Studio Fortran Support
Visual Studio 201x must be installed before the Visual Studio Fortran Support package can be installed.
Lahey/GNU Fortran must be installed for the Visual Studio Fortran Support to function correctly.
Typical installation requirements for the Compiler with Visual Studio 2013:
Hardware (Recommended Minimum)
- Computer that has a 1.6GHz or faster processor
- 1 GB RAM for x86
- 2 GB RAM for x64
- An additional 512 MB RAM if running in a Virtual Machine
- 2 GB of available hard disk space
- 5400 RPM hard disk drive
- DirectX 9-capable video card that runs at 1024 x 768 or higher display resolution
- Operating System
- Windows 8.1 (KB2883200, available through Windows Update, is required)
- Windows 8
- Windows 7 Service Pack 1
- Windows Server 2012 R2 (KB2883200, available through Windows Update, is required)
- Windows Server 2012
- Windows Server 2008 R2 SP1
Lahey/GNU Fortran without Visual Studio
- Windows Vista or later
- 300 MB of available hard disk space on the installation drive
Target Operating System
LG Fortran applications are compatible with Microsoft Windows 8, 7, Vista, XP, 2000, NT 4.0, Me, 98, and 95.
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 unlimited 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 support. If support is not renewed, the language system will continue to function at the level it was when support expired, but the customer will not be allowed any further access to support, product updates, or bug fixes.