View all
Technical Capabilities
LANGUAGES
VX/COBOL - OpenVMS COBOL to ANSI COBOL
VX/C - OpenVMS C to ANSI C
VX/FORTRAN - OpenVMS FORTRAN to ANSI FORTRAN
VX/PASCAL - OpenVMS PASCAL to ANSI C++
VX/BASIC - OpenVMS BASIC to ANSI C
DCL
VX/CDD - OpenVMS CDD
VX/SOR - OpenVMS SORT MERGE
VX/JSP - OpenVMS Print & Batch
VX/DCL - OpenVMS DCL
VX/CLD - OpenVMS CLD Compiler
VX/MMS - OpenVMS MMS to make and XML
VX/LCKMGR: OpenVMS Lock Manager
API
CLI$ - OpenVMS Command Interface
CONV$ - File Conversion
VX/RT APIs
STR$ - STRING Interface Routines
LIB$ - General Routines
COB$ - COBOL Support Routines
SYS$ - SYS$ Interface Routines
PAS$ - PASCAL Support Routines
FORMS$ - DECFORMS Integration
OTS$ - Data Conversion Routines
MTH$ - MATH Routines
BAS$ - BASIC Runtime Support
EXE$ - Operating System Interface
FOR$ - FORTRAN Support Routines
EDT$ - Callable Editor
FMS$ - Forms Management System
LBR$- Callable Librarian
SMG$ - Screen Management
SOR$ - Interface to SORT
SQL$ - SQL Database Interface
FDL$ - File Definition Language
DEC FORMS/SCREENS
VX/SMG - SMG
VX/FMS - OpenVMS Forms Management
VX/DECFORMS - DECforms IFDL Compiler and FORMS$
RMS
VX/DATAX - OpenVMS RMS Data exchange
VX/FDL - File Description Language Routines
VX/RMS - SYS$ Routines for RMS
ACMS
VX/RTR - OpenVMS RTR V2 to Async RTR V3
VX/DMQ - OpenVMS DMQ (PAMS) for x86 Linux
VX/ACMS - OpenVMS ACMS(TDF,MDF,GDF,ADF) to C++
RDB
VX/PF2PC-FORTRAN - FORTRAN with embedded SQL to Pro*C
VX/SQLMOD- SQLMOD to Embedded SQL
UTILITIES
VX/CDD - OpenVMS CDD
VX/JSP - OpenVMS Print & Batch
VX/CLD - OpenVMS CLD Compiler
VX/MSG - OpenVMS Message Compiler
VX/MMS - OpenVMS MMS to make and XML
VX/LCKMGR: OpenVMS Lock Manager
VX/DATAX - OpenVMS RMS Data exchange
Having trouble finding what you need?
Get in touch with us, so we can answer your specific questions directly.
Get In Touch
technical
/
3GL
/
VX/FORTRAN - OpenVMS FORTRAN to ANSI FORTRAN

VX/FORTRAN - OpenVMS FORTRAN to ANSI FORTRAN

Overview

VX/Fortran is a powerful automated migration tool that translates OpenVMS Fortran to ANSI-compliant Fortran (Intel Fortran) for execution on x86 Linux and Windows. It extends Fortran Partner (FPT) with VMS-specific features, standards adherence, and performance optimizations.

VX/Fortran is used by aerospace, defense, and high-tech industries to ensure complete, error-free Fortran migration, preserving decades of software investment without requiring manual code modifications.

Key Features

• 100% Automated Migration – Converts VMS / OpenVMS Fortran to Intel Fortran, preserving functionality.

• Zero Code Freeze – Continue development on VMS while migrating to Linux/Windows.

• Advanced Static Analysis – Detects syntax, logical, and performance issues before migration.

• Embedded SQL Conversion – Automatically converts Pro*Fortran SQL to external C functions.

• Seamless ISAM Support – VX/RMS replaces obsolete ISAM handling with modern Fortran I/O.

• Code Optimization – Performs loop unrolling, inline expansion, and memory access optimizations.

• Comprehensive Testing Tools – Supports record/replay execution, trace logs, and QA compliance.

• Security & Obfuscation – Can protect source code while ensuring it remains compilable.

VX/Fortran Migration Process

VX/Fortran automates the entire migration workflow, ensuring a smooth transition from OpenVMS Fortran to modern platforms.
‍

Step Process
Source Code Analysis Identifies **VMS-specific extensions**,
**RMS file dependencies**,
and **Pro*Fortran SQL statements**.
Transpile to Modern Fortran Automatically converts **VMS extensions** to
**ANSI-standard Fortran**.
Compile & Optimize Optimizes for **Intel Fortran**,
**expanding loops** and **removing
legacy constraints**.
Execute & Validate Runs automated test cases to verify
**identical execution behavior**.

Code Migration Examples

File Handling - VMS vs. Migrated Code

VX/Fortran automatically translates VMS file-handling commands to modern Fortran.
‍

VMS Fortran Code Migrated ANSI Fortran Code
OPEN (UNIT=report_lun,
FILE='LOGS:MONITOR.LOG',
STATUS='UNKNOWN') 		OPEN (UNIT=report_lun,
FILE=vxrms_translate_file_name
('LOGS:MONITOR.LOG'),
STATUS='UNKNOWN')
OPEN(UNIT=INDXUFLUN,
ACCESS='KEYED',
FILE='INDXUF.DAT',
STATUS='OLD') 		CALL VXRMS_OPEN('UNIT=',
INDXUFLUN, 'ACCESS=',
'KEYED', 'FILE=',
'INDXUF.DAT', 'STATUS=', 'OLD')
Inline Function Expansion for Performance

VX/Fortran expands subroutines inline to reduce function call overhead.

Before (VMS Fortran)
REAL*4 FUNCTION INTERP1(INPUT, BP, FUNTAB)
REAL*4 INPUT
REAL*4 BP(*)
REAL*4 FUNTAB(*)
I = 1
DO WHILE (BP(I) .LT. INPUT)
  I = I + 1
ENDDO
INTERP1 = FUNTAB(I-1) + (FUNTAB(I) - FUNTAB(I-1))
* (INPUT - BP(I-1)) / (BP(I) - BP(I-1))
RETURN
END
After (Optimized Fortran)
DO WHILE (TYREVBP(I) .LT. TYRESPEED)
  I = I + 1
ENDDO
FR = TYREFRICT(I-1) + (TYREFRICT(I) - TYREFRICT(I-1))
* (TYRESPEED - TYREVBP(I-1)) / (TYREVBP(I) - TYREVBP(I-1))


🔹 Eliminates function calls

🔹 Reduces memory access latency

🔹 Speeds up execution time by up to 40%

Automated Fortran Code Quality Analysis

VX/Fortran automatically detects and fixes errors, improving code quality and maintainability.

Diagnostic Count Impact
Missing subroutine declarations 12 Prevents compilation errors
Inconsistent argument types 8 Fixes potential runtime crashes
Unsafe integer-to-real conversion 15 Prevents loss of precision

Why Choose VX/Fortran?

✔ 100% Automated Migration – No Manual Remediation Required

✔ Zero Code Freeze – Develop & Migrate in Parallel

✔ Optimized Execution – Faster Than Legacy VMS Fortran

✔ Seamless RMS & SQL Handling – Works Out-of-the-Box

✔ Bug-Free Code – Automated Testing & Debugging

🔹 VX/Fortran is the fastest and most reliable way to modernize your VMS Fortran applications for Linux & Windows.

On this page
I
Example H2
II
Example H3
III
Example H4
IV
Example H5
II
Example H6

Frequently Asked Questions

Curious about how Sector7 can facilitate your application migration? Explore our FAQs for expert insights.

Free Code Assessment
Contact Us
Our OpenVMS application makes use of multiple System Services. How do you support that?

Sector7 has an extensive library of these services running on Linux to perform the same functions as on OpenVMS.  our language conversion tools will adapt the arguments in the procedure API to work with this library.  For instance, VX/COBOL or VX/FORTRAN etc will transform the argument passed BY DESCRIPTOR to a method that will work on Linux.

When the code is compiled on Linux, the compiled objects are linked with the Sector7 library of system services and the program executes on Linux just as it does on OpenVMS, making full use of the various system services.

The critical point here is that there is no need to touch the original source code, the Sector7 tools do all the work.

What is VX/FORTRAN and how does it help with OpenVMS migration?

VX/FORTRAN is a powerful automated migration tool that translates OpenVMS FORTRAN to ANSI-compliant FORTRAN (Intel Fortran) for execution on Linux. It extends Fortran Partner (FPT) with VMS-specific features, standards adherence, and performance optimizations.

The tool is specifically designed for aerospace, defense, and high-tech industries to ensure complete, error-free Fortran migration while preserving decades of software investment. To learn more about how VX/FORTRAN can modernize your legacy systems, contact our migration experts.

Does VX/FORTRAN require manual code modifications during migration?

No, VX/FORTRAN provides 100% automated migration without requiring manual code modifications.

What types of VMS-specific features does VX/FORTRAN handle?

VX/FORTRAN handles VMS-specific extensions, RMS file dependencies, Pro*Fortran SQL statements, and seamless ISAM support through VX/RMS integration.

How does the VX/FORTRAN migration workflow operate?

The migration follows four automated steps: source code analysis to identify VMS-specific extensions and dependencies, transpilation to ANSI-standard Fortran, compilation with Intel Fortran optimization, and validation through automated testing to verify identical execution behavior.

Can I continue development during the migration process?

Yes, VX/FORTRAN supports zero code freeze, allowing you to continue development on VMS while migrating to Linux. This parallel approach ensures business continuity throughout the modernization process.

Organizations like Amprion GmbH have successfully used this approach for large-scale FORTRAN migrations involving millions of lines of code.

Does VX/FORTRAN provide code optimization capabilities?

VX/FORTRAN performs advanced optimizations including loop unrolling, inline expansion, and memory access optimizations that can speed up execution time by up to 40%.

How does VX/FORTRAN handle embedded SQL conversion?

VX/FORTRAN automatically converts Pro*Fortran SQL statements to external C functions, ensuring seamless database integration on the target Linux platform without manual intervention.

What quality assurance and testing capabilities does VX/FORTRAN provide?

VX/FORTRAN includes comprehensive testing tools that support record/replay execution, trace logs, and QA compliance. The tool automatically detects and fixes errors, improving code quality and maintainability by identifying issues like missing subroutine declarations, inconsistent argument types, and unsafe conversions.

Companies like BNY Mellon have leveraged similar automated migration capabilities for critical financial systems. For detailed information about our testing methodologies and quality assurance processes, contact our team.

How does VX/FPT assist in migrating Fortran code from VMS systems?

When migrating Fortran code from VMS systems, VX/FPT addresses several challenges:

  • Syntactic Differences: Automatically converts VMS-specific syntax to standard Fortran.
  • Language Extensions: Handles VMS-specific language features not supported by modern compilers.
  • Semantic Differences: Identifies and corrects statements that behave differently under VMS compared to modern systems.
  • System Libraries: Works in conjunction with Sector7's VMS emulation libraries to emulate VMS system library routines under Linux or Unix
What types of systematic Fortran errors does VX/FPT detect and correct?

VX/FPT is designed to identify and address various classes of systematic errors, including:

  • Use of Fortran keywords or intrinsic function names as variable names.
  • Inconsistent use of names, such as different values for the same parameter name or different COMMON block addresses for the same name.
  • Uninitialized variables.
  • Mismatched arguments in subroutine or function calls.
Can VX/FPT modernize legacy Fortran code?

VX/FPT can analyze, re-engineer, and migrate legacy Fortran programs. The approach includes

  • Identifying and correcting systematic errors in the code.
  • Generating documentation reports.
  • Re-engineering code for migration, optimization, and standardization.
  • Instrumenting code for regression testing and coverage analysis.

‍

How can I assess whether I need VX or Sector7's VX/RT libraries for my Fortran migration project?

All OpenVMS FORTRAN applications use OpeVMS specific APIs and command line functions, it is very unlikely that your FORTRAN application uses no OpenVMS capabilities or libraries.

  • Determine the need for Sector7's libraries: Use the command show missing sub-programs. If you see routines with names like SYS$, LIB$, or SMG$, you likely require these libraries.
  • Determine if you need DCL or any other OpenVMS utilities.
  • Assess the necessity of VX/FPT: Use the command check arguments and review the diagnostics for warnings related to language issues. A significant number of mismatched arguments or other issues indicate that fpt would be beneficial.
  • Easiest: Sector7 will scan your application and create an index of all OpenVMS specific library calls (APIs)
Semantic Differences - Fortran Statements which compile differently
  • Real Number Format: The real number format used under VMS is designed so that an 8-byte real value and the corresponding 4-byte real number have the same, or almost the same bit patterns in the first 4 bytes. The consequence is that a sub-program which expects a 4-byte real argument may be passed the corresponding 8-byte argument (Or vice versa) with no error except for a very small change in precision. Usually the code will run correctly. When the code is migrated and uses IEEE real numbers, the 4 and 8-byte representations have different numbers of exponent bits. Therefore, when the 8-byte bit pattern is read as a 4-byte real number (Or vice versa) a significant error occurs. fpt detects and corrects mis-matched real arguments .
    ‍
  • Integers Used as Logicals: VMS Fortran allows integer variables (Or expressions) to be used as if they were logicals, for example, in IF statements. Some compilers will reject this use. Others accept it, but may not convert the integer to a logical in the same way as VMS. VMS uses the least significant bit to determine the logical value of an integer. Other compilers may use the sign bit, or treat any non-zero value as logical true. fpt re-programs the usage.
    ‍
  • The order of Logical Tests: When VMS Fortran processes a compound IF statement, for example,
      IF ((i .LE. 0) .OR. (a(i) .EQ. 0))
    The sub-expressions in the logical expression are evaluated in turn from left to right. Thus, in this case, if the array a has bounds (1:10) and i has the value 0, VMS never evaluates a(0). This behaviour is not required by the Fortran standard. Other compilers may evaluate the sub-expressions in parallel or in a different order and the program then crashes with an array reference out-of-bounds. VX/FPT re-programs the construct.
    ‍
  • CALL Statements used to call Functions: VMS allows functions to be invoked by CALL statements. Under Linux, Unix or Windows the address of the function return value may be placed on the system stack, which then becomes corrupt. The program crashes when the unused value is eventually un-stacked, sometimes at a point which is remote from the original error. fpt re-programs the usage.
Which Fortran features are not supported by the new host compiler?

These are language constructs which are supported by VMS for which there are no simple syntactic translations to modern Fortran. The code must be re-structured. Usually, sub-programs must be called to supply the missing features.

Again, the VMS code will simply not compile or run without modification. The important issues are:

  • VMS File Names in OPEN and INQUIRE: VMS file names may contain device directory and version specifications. When these are specified in I/O statements they must be translated at run-time on the new host. This is done by calling sub-programs in Sector7's VXRMS library.
  • ISAM Files: Indexed Sequential Access Method files are files which contain linkage pointers from fields within their records to related records. Under VMS the OPEN, READ, WRITE and INQUIRE keywords are extended to support them. These extension are not supported under Linux, Unix or Windows. fpt handles ISAM files by replacing the OPEN, CLOSE, INQUIRE, READ and WRITE statements by calls to sub-programs in Sector7' VXRMS library.
  • Variables and Expressions in FORMAT Statements: Under VMS, variables and run-time expressions may be written inside FORMAT statements or in embedded format strings. The variables or expressions are written within < > delimiters. This construct is translated to standard Fortran using run-time format strings.
The VMS System Libraries - Fortran

The VMS system libraries contain many hundreds of routines which handle issues such as inter-process communication and timing, logical name handling and specialised text and form manipulation. Sector7 . has developed a very complete emulation of these libraries for Linux and Unix. libraries also provide support for the language features in VMS Fortran which are not supported by modern compilers, in particular for ISAM files.

It is important to understand how complex this emulation needs to be. The system must maintain tables which support VMS file names, including file version handling and logical name translations, and these tables must be visible to all programs which use the emulations. Similarly, VMS event flags and mailboxes must be emulated and shared in the same way as under VMS. The system must also contain a complete emulation of DCL.

The VMS system libraries are shared by all of the computer languages supported under VMS: they are not specific to Fortran. In consequence, the arguments to the library routines are sometimes passed in ways which differ from the usual Fortran defaults. Under VMS, the argument passing protocols may be specified by the pseudo-intrinsics %REF, %VAL, %LOC and %DESCR. These, and other attributes of the call-sites must be modified systematically by fpt to conform to the requirements of the target compiler.

What are the Problems?

The issues in migrating from VMS are:

  1. Syntactic Differences: where VMS Fortran simply uses a different syntax from standard Fortran for the same construct.
  2. Language Extensions: where VMS Fortran supports facilities which are not supported at all by modern compilers.
  3. Semantic Differences: where a VMS Fortran statement has the same syntax as a standard Fortran statement, but compiles with a different meaning.
  4. The VMS System Libraries: The system library routines used in a program must be emulated. Often the call-sites must be modified to change the way in which the arguments are passed.

The syntactic and semantic differences are all handled automatically by VX/FPT. The VMS system libraries, and many of the language extensions are handled by VMS emulation libraries. These libraries provide a very complete emulation of VMS under Linux or Unix.

Transform Your Legacy Software Today!

Get In Touch
Unlock the potential of your legacy software with our expert migration services.