🚨 Oracle not porting Rdb to x86 and EOL on Itanium 12/2027 🚨
View all
Technical Capabilities
LANGUAGES
GnuCOBOL -fdec - DEC/VSI COBOL Language Extensions
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/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
VX/CDD - Common Data Dictionary / Repository
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$
VX/TDMS - Terminal Data Management System
VX/DECFORMS+ - TDMS Compatibility Extensions
RMS
VX/DATAX - OpenVMS RMS Data exchange
VX/FDL - File Description Language Routines
VX/RMS - SYS$ Routines for RMS
ACMS
VX/ACMS - Application Control and Management System
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/CDD - Common Data Dictionary / Repository
VX/SQL-FORTRAN - FORTRAN with embedded Rdb/SQL to PostgreSQL or Oracle
VX/SQL-MODULE - SQLMOD to Embedded SQL
VX/SQL-COBOL - COBOL with embedded Rdb/SQL to PostgreSQL or Oracle
VX/RDML - Convert RDML to embedded SQL
UTILITIES
VX/CDD - Common Data Dictionary / Repository
VX/JSP - OpenVMS Print & Batch
VX/CLD - OpenVMS CLD Compiler
VX/MSG - OpenVMS Message Compiler
VX/MMS - OpenVMS MMS to make and XML
EDT$ - Callable Editor
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
/
RMS
/
VX/FDL - File Description Language Routines

VX/FDL - File Description Language Routines

Overview

VX/FDL is an implementation of the OpenVMS File Definition Language (FDL) for Linux and Windows. It is the callable library that describes RMS file structure: it parses an FDL text into RMS control blocks, creates an RMS file from an FDL specification, and generates an FDL description back from an existing RMS file, so file definitions carry over to the migrated platform with identical structure and behaviour.

The product ships as four public FDL$ routines compiled into the shared VX/RT runtime, plus two VX/DCL command front ends (CREATE/FDL and ANALYZE/RMS_FILE). There is no separate daemon or binary: VX/FDL is a library and DCL surface that recompiled OpenVMS applications link and call without source changes, handling all Indexed, Relative, and Sequential organizations.

<!-- Webflow embed (min). Source: fdl-page-technical/fdl-tech-body-embed-dark.html → python3 website/embeds/minify_webflow_embed.py … --> <div class="s7-tech-embed" data-vxfdld-body-embed="1" data-technical-mega-embed="1" lang="en"><h2 id="architecture">Architecture and components</h2><p> FDL is a small text description language for RMS file structure. An <code>.FDL</code> file is a sequence of primary sections (<code>FILE</code>, <code>RECORD</code>, <code>KEY</code>, <code>AREA</code> and others) whose indented attribute lines describe a file's organization, record format, sizes, and index keys. VX/FDL is the callable library that reads and writes that description: it parses an FDL text into RMS control blocks (a FAB plus a RAB), creates an RMS file from an FDL, and generates an FDL text back from an existing RMS file. </p><p> VX/FDL is a <strong>library plus a DCL command surface</strong>, not a long-running service. The routines compile into the shared VX/RT runtime archive (<code>libvxrt.a</code>) that a migrated application links directly, and two VX/DCL commands provide the operator front end. There is no daemon to administer and no separate binary to deploy. </p><div class="table-wrapper"><table><thead><tr><th>Translation unit</th><th>Public entry point</th><th>Role</th><th>Status</th></tr></thead><tbody><tr><td><code>FDL_CRE</code></td><td><code>FDL$CREATE</code></td><td>Read an FDL, build and <code>SYS$CREATE</code> the matching RMS file.</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL_GEN</code></td><td><code>FDL$GENERATE</code></td><td>Open an RMS file and emit an FDL text describing it.</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL_PAR</code></td><td><code>FDL$PARSE</code></td><td>Parse an FDL into freshly allocated FAB and RAB blocks.</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL_REL</code></td><td><code>FDL$RELEASE</code></td><td>Free the FAB and RAB (and their FNA and XAB) that <code>FDL$PARSE</code> allocated.</td><td><span class="ac-live">live</span></td></tr></tbody></table></div><div class="callout"><strong>No server to administer.</strong> VX/FDL adds no process to the runtime. The four <code>FDL$</code> routines are entry points inside <code>libvxrt.a</code>, and the DCL commands call them in-process. The only surface is the four routines plus <code>CREATE/FDL</code>, <code>ANALYZE/RMS_FILE</code>, and <code>CONVERT/FDL</code>. </div><h6>Call lifecycle</h6><p> The three operations share one internal flow: parse an FDL description into control blocks, act on those blocks (create a file, or the reverse: read a file and emit its description), then release any blocks that were allocated. </p><style>.s7-tech-embed .fdl-flow {margin: 1.5rem 0;padding: 16px;border: 1px solid var(--s7t-border);border-radius: 10px;background: rgba(255, 255, 255, 0.01);}.s7-tech-embed .fdl-flow-path {display: grid;grid-template-columns: minmax(0, 0.8fr) minmax(0, 1fr) minmax(0, 1.35fr);gap: 10px;align-items: stretch;}.s7-tech-embed .fdl-flow-path + .fdl-flow-path {margin-top: 10px;}.s7-tech-embed .fdl-flow-node {min-width: 0;padding: 14px 16px;border-radius: 8px;background: var(--s7t-surface);color: var(--s7t-text);}.s7-tech-embed .fdl-flow-node strong,.s7-tech-embed .fdl-flow-node span {display: block;}.s7-tech-embed .fdl-flow-node strong {margin-bottom: 4px;}.s7-tech-embed .fdl-flow-node span {color: var(--s7t-muted);font-size: 0.9em;line-height: 1.45;}.s7-tech-embed .fdl-flow-action {border-top: 3px solid var(--s7t-accent);background: var(--s7t-surface2);}.s7-tech-embed .fdl-flow-output {border: 1px solid var(--s7t-note-bd);background: var(--s7t-note-bg);}.s7-tech-embed .fdl-flow-label {margin: 12px 0 8px;color: var(--s7t-accent);font-family: var(--s7t-mono);font-size: 0.76em;font-weight: 700;letter-spacing: 0.08em;text-transform: uppercase;}@media (max-width: 800px) {.s7-tech-embed .fdl-flow-path {grid-template-columns: 1fr;}}</style><div class="fdl-flow" aria-label="VX/FDL parse, create, generate, and release lifecycle"><div class="fdl-flow-label">Parse and release control blocks</div><div class="fdl-flow-path"><div class="fdl-flow-node"><strong>.FDL text</strong><span>File structure description</span></div><div class="fdl-flow-node fdl-flow-action"><strong><code>FDL$PARSE</code></strong><span>Allocates FAB and RAB control blocks</span></div><div class="fdl-flow-node fdl-flow-output"><strong><code>FDL$RELEASE</code></strong><span>Frees the FAB, RAB, FNA, and XAB blocks</span></div></div><div class="fdl-flow-label">Create an RMS file</div><div class="fdl-flow-path"><div class="fdl-flow-node"><strong>.FDL text</strong><span>Organization, format, size, and keys</span></div><div class="fdl-flow-node fdl-flow-action"><strong><code>FDL$CREATE</code></strong><span>Parses the description and calls <code>SYS$CREATE</code></span></div><div class="fdl-flow-node fdl-flow-output"><strong>New RMS file</strong><span>Built from the parsed control blocks</span></div></div><div class="fdl-flow-label">Generate an FDL description</div><div class="fdl-flow-path"><div class="fdl-flow-node"><strong>RMS file</strong><span>Existing file and attributes</span></div><div class="fdl-flow-node fdl-flow-action"><strong><code>FDL$GENERATE</code></strong><span>Reads the file's FAB and RAB values</span></div><div class="fdl-flow-node fdl-flow-output"><strong>.FDL text</strong><span>Organization, format, size, and keys</span></div></div></div><h2 id="fdl-format">The FDL text format</h2><p> An FDL file is a flat, line-oriented text tokenised on whitespace, semicolons, and newlines. The parser dispatches on a <strong>primary</strong> keyword; each primary section is followed by indented <strong>secondary</strong> attribute lines, and inside <code>KEY</code> and <code>AREA</code> sections a further set of key-specific keywords applies. There is no nesting beyond primary, secondary, and an optional qualifier value. </p><h6>Primary sections</h6><p>The 13 primary sections VX/FDL recognises:</p><div class="kw-grid"><div>TITLE</div><div>IDENT</div><div>SYSTEM</div><div>FILE</div><div>DATE</div><div>RECORD</div><div>ACCESS</div><div>SHARING</div><div>CONNECT</div><div>AREA</div><div>KEY</div><div>ANALYSIS_OF_AREA</div><div>ANALYSIS_OF_KEY</div></div><h6>FILE and RECORD attribute keywords</h6><p> The secondary keywords accepted under <code>FILE</code>, <code>RECORD</code>, and related sections cover organization, record format, allocation, and file-handling options: </p><div class="kw-grid"><div>BEST_TRY_CONTIGUOUS</div><div>BLOCK_IO</div><div>BLOCK_SPAN</div><div>CARRIAGE_CONTROL</div><div>CONTIGUOUS</div><div>CREATE_IF</div><div>DEFAULT_NAME</div><div>DELETE</div><div>DELETE_ON_CLOSE</div><div>FILE_NON_STRUCTURED</div><div>FORMAT</div><div>GET</div><div>MULTISTREAM</div><div>NAME</div><div>ORGANIZATION</div><div>OUTPUT_FILE_PARSE</div><div>PRINT_ON_CLOSE</div><div>PROHIBIT</div><div>PROTECTION</div><div>PUT</div><div>RECORD_IO</div><div>SEQUENTIAL_ONLY</div><div>SIZE</div><div>SUPERSEDE</div><div>TEMPORARY</div><div>TRUNCATE</div><div>TRUNCATE_ON_CLOSE</div><div>UPDATE</div><div>USER_INTERLOCK</div><div>WINDOW_SIZE</div></div><h6>KEY section keywords</h6><p> The <code>KEY</code> section carries 33 keywords, including the eight segment position and length pairs (<code>SEG0_POSITION</code> and <code>SEG0_LENGTH</code> through <code>SEG7_*</code>) plus area, fill, compression, and prologue attributes: </p><div class="kw-grid"><div>NAME</div><div>POSITION</div><div>LENGTH</div><div>TYPE</div><div>DUPLICATES</div><div>CHANGES</div><div>NULL_KEY</div><div>PROLOG</div><div>DATA_AREA</div><div>DATA_FILL</div><div>INDEX_AREA</div><div>INDEX_FILL</div><div>LEVEL1_INDEX_AREA</div><div>DATA_KEY_COMPRESSION</div><div>DATA_RECORD_COMPRESSION</div><div>INDEX_COMPRESSION</div><div>SEG0_POSITION</div><div>SEG0_LENGTH</div><div>...</div><div>SEG7_LENGTH</div></div><h6>KEY data types</h6><p>The 16 key data types accepted by the <code>TYPE</code> keyword:</p><div class="kw-grid"><div>BIN2</div><div>BIN4</div><div>BIN8</div><div>DBIN2</div><div>DBIN4</div><div>DBIN8</div><div>INT2</div><div>INT4</div><div>INT8</div><div>DINT2</div><div>DINT4</div><div>DINT8</div><div>DECIMAL</div><div>DDECIMAL</div><div>STRING</div><div>DSTRING</div></div><h6>Example: an indexed file</h6><p> A minimal indexed FDL that VX/FDL round-trips through <code>CREATE/FDL</code>, using the banking demo domain: </p> <pre><span class="kw">TITLE</span> <span class="str">"Customer master, indexed by account number"</span> <span class="kw">SYSTEM</span> <span class="kw">SOURCE</span> <span class="str">"VAX/VMS"</span> <span class="kw">FILE</span> <span class="kw">NAME</span> <span class="str">"CUSTOMER.DAT"</span> <span class="kw">ORGANIZATION</span> indexed <span class="kw">RECORD</span> <span class="kw">CARRIAGE_CONTROL</span> none <span class="kw">FORMAT</span> fixed <span class="kw">SIZE</span> 180 <span class="kw">KEY</span> 0 <span class="kw">NAME</span> <span class="str">"ACCOUNT_NUMBER"</span> <span class="kw">TYPE</span> string <span class="kw">DUPLICATES</span> no <span class="kw">CHANGES</span> no <span class="kw">SEG0_POSITION</span> 0 <span class="kw">SEG0_LENGTH</span> 10</pre> <h2 id="api">The FDL$ routine API</h2><p> VX/FDL exports the four public OpenVMS <code>FDL$</code> routines. Each is defined under an internal name and aliased to the VMS spelling, so both <code>FDL$CREATE</code> and lowercase <code>fdl$create</code> resolve to the same symbol and existing object references link unchanged. </p><div class="table-wrapper"><table><thead><tr><th>Routine</th><th>Signature</th><th>Purpose</th><th>Status</th></tr></thead><tbody><tr><td><code>FDL$CREATE</code></td><td><code>FDL$CREATE(fdl, fname)</code></td><td>Create an RMS file as defined by an FDL specification.</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL$GENERATE</code></td><td><code>FDL$GENERATE(flags, fab, rab, fdl)</code></td><td>Open the file named in <code>fab</code> and write an FDL description to <code>fdl</code> (a file spec) or, if empty, to the terminal.</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL$PARSE</code></td><td><code>FDL$PARSE(fdl, fab, rab, flags, def, stmt)</code></td><td>Parse an FDL, from a file or from a string, into newly allocated FAB and RAB blocks.</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL$RELEASE</code></td><td><code>FDL$RELEASE(pfab, prab, flags, badblk)</code></td><td>Free the FAB and RAB allocated by <code>FDL$PARSE</code>; nulls the caller's pointers.</td><td><span class="ac-live">live</span></td></tr></tbody></table></div><p> Every routine follows the VMS condition-value convention: the function result is returned by value, an odd value means success and an even value means failure, so callers test <code>ODD(status)</code>. </p><h6>FORTRAN-callable jackets</h6><p><code>FDL$CREATE</code>, <code>FDL$GENERATE</code>, and <code>FDL$PARSE</code> also expose FORTRAN-callable jackets (the <code>F4_*</code> variants). These accept FORTRAN string descriptors, unpack them, and call the C entry point, so mixed COBOL, FORTRAN, and C application code links against the same library. <code>FDL$RELEASE</code> has no FORTRAN jacket. </p><h6>Flag bits</h6><p> Four public flag bits gate the string-versus-file behaviour of <code>FDL$PARSE</code> and <code>FDL$GENERATE</code>: </p><div class="table-wrapper"><table><thead><tr><th>Symbol</th><th>Value</th><th>Meaning</th></tr></thead><tbody><tr><td><code>FDL$M_SIGNAL</code></td><td><code>0x1</code></td><td>Signal errors rather than return them. Reserved for source compatibility; not acted on in this release.</td></tr><tr><td><code>FDL$M_FDL_STRING</code></td><td><code>0x2</code></td><td>The <code>fdl</code> argument is an in-memory FDL string, not a file spec.</td></tr><tr><td><code>FDL$M_DEFAULT_STRING</code></td><td><code>0x4</code></td><td>The <code>def</code> argument is a defaults string, not a file spec.</td></tr><tr><td><code>FDL$M_FULL_OUTPUT</code></td><td><code>0x8</code></td><td>Emit the full, non-abbreviated FDL on generate. Reserved for source compatibility; not acted on in this release.</td></tr></tbody></table></div><h6>Status reporting</h6><p> The FDL facility defines 33 <code>FDL$_</code> message codes for source compatibility, tested with the usual <code>(status &amp; 1)</code> success convention. The shipping library emits <code>FDL$_OPENFDL</code> when a <code>CREATE/FDL</code> input file is not found, and otherwise returns the generic RMS and system status codes (<code>RMS$_NORMAL</code>, <code>RMS$_FNF</code> for file not found, <code>SS$_NORMAL</code>, and related values). FDL-facility status reporting is therefore thinner than the OpenVMS original; see the status matrix below. </p><h2 id="lifecycle">Call lifecycle</h2><p> The routines cooperate through the RMS control blocks. <code>FDL$PARSE</code> allocates and fills a FAB and RAB from an FDL text; <code>FDL$CREATE</code> parses internally and materialises a file; <code>FDL$GENERATE</code> reads a file and emits a text; <code>FDL$RELEASE</code> frees whatever <code>FDL$PARSE</code> allocated. </p><h6>Create path</h6><p><code>FDL$CREATE</code> seeds RMS defaults into a FAB and RAB, parses the FDL text into that FAB, resolves the output file name (from the routine argument or the FDL's <code>DEFAULT_NAME</code>), then runs <code>SYS$PARSE</code> and <code>SYS$SEARCH</code> to compute the next version and <code>SYS$CREATE</code> to materialise the structure, followed by <code>SYS$CONNECT</code>, <code>SYS$DISCONNECT</code>, and <code>SYS$CLOSE</code>. It supports three creation modes: the legacy in-place create, an erase-then-create-in-place mode, and a build-into-a-temporary-file mode used by <code>CONVERT/FDL</code>. </p><h6>Parse path</h6><p><code>FDL$PARSE</code> allocates a fresh FAB and RAB, seeds RMS type, length, and organization defaults, and cross-links the RAB to the FAB. If a defaults source is supplied it is read first (from a string when <code>FDL$M_DEFAULT_STRING</code> is set, otherwise from a file), then the main FDL source is read and overlaid on top (from a string when <code>FDL$M_FDL_STRING</code> is set, otherwise from a file). File resolution tries the VMS-to-unix name, then retries with a <code>.FDL</code> type appended, then retries lowercased, returning <code>RMS$_FNF</code> only after all three miss. The <code>stmt</code> single-statement parameter is accepted for source compatibility but not used in this release. </p><h6>Release path</h6><p><code>FDL$RELEASE</code> takes the address of the FAB and RAB pointers, frees the file-name string and any extended attribute block, then the FAB and the RAB, and nulls the caller's pointers to avoid dangling references. The <code>flags</code> and <code>badblk</code> arguments are accepted but unused. </p><h6>End-to-end C example</h6><p> The canonical setup, call, check, and cleanup path for a C caller parsing an FDL file into control blocks. Note the <code>ODD()</code> status test and the address-of-pointer passed to <code>FDL$RELEASE</code>: </p> <pre><span class="cmt">/* string descriptor for the FDL spec */</span> VMS_DESCR fdl; FABDEF *fab = 0; RABDEF *rab = 0; U32 flags = 0; <span class="cmt">/* 0 means fdl_path is a FILE spec */</span> U32 status; vxrt_dsc64t(&amp;fdl, (U16)strlen(fdl_path), (char *)fdl_path); <span class="cmt">/* parse the FDL file into freshly allocated FAB / RAB */</span> status = FDL$PARSE(&amp;fdl, &amp;fab, &amp;rab, &amp;flags, <span class="cmt">/*def*/</span> 0, <span class="cmt">/*stmt*/</span> 0); <span class="kw">if</span> (!ODD(status)) <span class="cmt">/* e.g. RMS$_FNF if the .FDL is absent */</span> <span class="kw">return</span> status; <span class="cmt">/* ... use fab / rab: SYS$CREATE, SYS$OPEN, inspect organization ... */</span> <span class="cmt">/* free exactly what FDL$PARSE allocated; fab and rab become NULL */</span> FDL$RELEASE(&amp;fab, &amp;rab, <span class="cmt">/*flags*/</span> 0, <span class="cmt">/*badblk*/</span> 0); <span class="kw">return</span> SS$_NORMAL;</pre> <p> To parse an in-memory FDL string instead of a file, set <code>flags = FDL$M_FDL_STRING</code> and point the descriptor at the text. </p><h2 id="dcl">VX/DCL command surface</h2><p> Two VX/DCL commands are the operator front end to the library, and a third also consumes an FDL. They live in VX/DCL and their syntax matches the OpenVMS originals, so existing <code>.COM</code> procedures and build scripts run with minimal change. </p><div class="table-wrapper"><table><thead><tr><th>Command</th><th>Calls</th><th>Behaviour</th></tr></thead><tbody><tr><td><code>CREATE/FDL=fdl-file [out-file]</code></td><td><code>FDL$CREATE</code></td><td>Build the output spec, defaulting a missing type on the FDL to <code>.FDL</code>, verify the FDL file exists, then create the RMS file. The <code>/FDL=</code> value is required and non-negatable. Emits an open error and a file-not-found status if the FDL is missing.</td></tr><tr><td><code>ANALYZE/RMS_FILE [/OUTPUT=x.FDL] file</code></td><td><code>FDL$GENERATE</code></td><td>Scan each file spec, default a missing type to <code>.DAT</code>, verify the file exists, build the output FDL spec, then generate the FDL. A missing output name or type defaults to the input name with a <code>.FDL</code> type.</td></tr><tr><td><code>CONVERT/FDL=fdl-file in... out</code></td><td><code>FDL$CREATE</code></td><td>Create the output from the FDL into a temporary file, copy records with <code>SYS$GET</code> and <code>SYS$PUT</code>, then rename to the target. Accepts up to 20 input files; <code>/FDL</code> is required unless <code>/APPEND</code> is given.</td></tr></tbody></table></div><h6>CREATE/FDL</h6><p> The <code>/FDL=</code> value is required and non-negatable; the optional trailing parameter is the output file name. The handler runs a file scan over the FDL spec to fill in device, directory, and name, and supplies <code>.FDL</code> when no type is given. <code>/LOG</code> prints a line reporting whether the file was created. </p> <pre><span class="cmt">! FDL to RMS file (FDL$CREATE)</span> $ CREATE /FDL=CUSTOMER.FDL CUSTOMER.DAT</pre> <h6>ANALYZE/RMS_FILE</h6><p> The <code>ANALYZE/RMS_FILE</code> sub-syntax parses <code>/CHECK</code>, <code>/FDL</code>, <code>/INTERACTIVE</code>, <code>/RU_JOURNAL</code>, <code>/STATISTICS</code>, <code>/SUMMARY</code>, and <code>/OUTPUT</code>, but the handler acts only on <code>/OUTPUT</code> in this release: it writes the generated FDL to the named file. The other analysis qualifiers are accepted by the parser and not yet acted on. Use <code>/OUTPUT=name.FDL</code> to capture the FDL description. </p> <pre><span class="cmt">! RMS file to FDL (FDL$GENERATE)</span> $ ANALYZE /RMS_FILE /OUTPUT=CUSTOMER.FDL CUSTOMER.DAT</pre> <h6>CONVERT/FDL</h6> <pre><span class="cmt">! load records into an FDL-defined output file</span> $ CONVERT /FDL=CUSTOMER.FDL CUSTOMER.SEQ CUSTOMER.IDX</pre> <h2 id="generate">What FDL$GENERATE emits</h2><p><code>FDL$GENERATE</code> (the routine behind <code>ANALYZE/RMS_FILE /OUTPUT</code>) opens the file named in the FAB and writes an FDL text describing it. If the file was created outside RMS and lacks VMS attributes it retries as a variable-format file rather than failing. Output goes to the FDL descriptor when non-empty, otherwise to the terminal. </p><p>The generated FDL is written in a fixed order and covers:</p><div class="table-wrapper"><table><thead><tr><th>Emitted section</th><th>Source</th></tr></thead><tbody><tr><td><code>IDENT</code></td><td>File creation time.</td></tr><tr><td><code>SYSTEM SOURCE</code></td><td>The host identity from <code>uname</code>.</td></tr><tr><td><code>FILE NAME</code></td><td>The resolved file specification.</td></tr><tr><td><code>ORGANIZATION</code></td><td>One of <code>sequential</code>, <code>relative</code>, or <code>indexed</code>.</td></tr><tr><td><code>RECORD FORMAT</code></td><td>One of <code>fixed</code>, <code>stream</code>, <code>variable</code>, or <code>undefined</code>.</td></tr><tr><td><code>SIZE</code></td><td>The maximum record size.</td></tr><tr><td><code>KEY</code> blocks</td><td>For indexed files only, one block per key, pulled from the runtime key descriptors.</td></tr></tbody></table></div><div class="callout"><strong>Scope of the generated FDL.</strong> The generator reproduces organization, record format, size, and keys. It does not reconstruct <code>AREA</code> allocations, bucket sizes, <code>ACCESS</code>, <code>SHARING</code>, or <code>CONNECT</code> sections, protections, or the <code>ANALYSIS_OF_*</code> statistics that a native VMS <code>ANALYZE/RMS_FILE</code> would produce. This is the main difference in fidelity from the OpenVMS original, and is enough to recreate a working file structure through <code>CREATE/FDL</code>. </div><p> The <code>SYSTEM SOURCE</code> line reflects the Linux or Windows host the generator runs on rather than a VMS node identity, because there is no VMS node lookup on the target platform. </p><h2 id="compatibility">Compatibility and status</h2><p> VX/FDL covers the create, parse, generate, and release path end to end for all three RMS file organizations. The table records what is live and what is intentionally out of scope in this release. </p><div class="table-wrapper"><table><thead><tr><th>Capability</th><th>Status</th></tr></thead><tbody><tr><td><code>FDL$CREATE</code>: build an RMS file from an FDL</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL$PARSE</code>: FDL text to FAB and RAB, from a file or a string</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL$RELEASE</code>: free parsed blocks</td><td><span class="ac-live">live</span></td></tr><tr><td><code>FDL$GENERATE</code>: RMS file to FDL (organization, format, size, keys)</td><td><span class="ac-live">live</span></td></tr><tr><td>FORTRAN-callable jackets for CREATE, GENERATE, and PARSE</td><td><span class="ac-live">live</span></td></tr><tr><td>Indexed, Relative, and Sequential organizations</td><td><span class="ac-live">live</span></td></tr><tr><td>Record formats fixed, variable, stream, and undefined</td><td><span class="ac-live">live</span></td></tr><tr><td><code>CREATE/FDL</code>, <code>ANALYZE/RMS_FILE /OUTPUT</code>, and <code>CONVERT/FDL</code> DCL commands</td><td><span class="ac-live">live</span></td></tr><tr><td>Generation of <code>AREA</code>, <code>ACCESS</code>, <code>SHARING</code>, <code>CONNECT</code>, and <code>ANALYSIS</code> sections</td><td><span class="ac-no">out of scope</span></td></tr><tr><td><code>ANALYZE/RMS_FILE</code> qualifiers other than <code>/OUTPUT</code> (<code>/CHECK</code>, <code>/STATISTICS</code>, <code>/SUMMARY</code> and others)</td><td><span class="ac-no">parsed, not acted on</span></td></tr><tr><td>Full <code>FDL$_</code> message-facility reporting (33 codes)</td><td><span class="ac-v1">partial: codes defined, generic RMS status returned</span></td></tr><tr><td><code>FDL$PARSE</code> single-statement (<code>stmt</code>) parameter</td><td><span class="ac-no">accepted, not used</span></td></tr></tbody></table></div><h6>Divergences from OpenVMS FDL</h6><ul><li><code>FDL$GENERATE</code> emits organization, record format, size, and key sections, not the <code>AREA</code>, <code>ACCESS</code>, <code>SHARING</code>, <code>CONNECT</code>, or <code>ANALYSIS</code> statistics blocks. The host RMS layer exposes those attributes through the FAB and key descriptors only.</li><li>The <code>SYSTEM SOURCE</code> line comes from the Linux or Windows host name rather than a VMS node, because there is no VMS node identity on the target platform.</li><li>FDL-facility status reporting is reduced to a small set of codes; most work returns the generic RMS and system status values. The full set of <code>FDL$_</code> symbols exists for source compatibility.</li><li><code>ANALYZE/RMS_FILE</code> honours <code>/OUTPUT</code>; the other analysis qualifiers are accepted but inert in this release, which implements the FDL-generation path rather than the full ANALYZE utility family.</li></ul><h6>Related pages</h6><ul><li><a href="/technical/vx-rms-sys-routines-for-rms">VX/RMS SYS$ Routines for RMS</a> reads and writes the RMS files that FDL defines.</li><li><a href="/technical/api-fdl-file-definition-language">FDL$ File Definition Language API</a> is the callable routine set this page describes.</li><li><a href="/technical/vx-dcl-vms-dcl">VX/DCL OpenVMS DCL</a> hosts the <code>CREATE/FDL</code>, <code>ANALYZE/RMS_FILE</code>, and <code>CONVERT/FDL</code> commands.</li><li><a href="/technical/vx-datax-vms-rms-data-exchange">VX/DATAX OpenVMS RMS Data Exchange</a> for moving RMS data between VMS and the target host.</li></ul><h2 id="quickref">Quick reference</h2><h6>Public routines</h6> <pre>FDL$CREATE (fdl, fname) <span class="cmt">// create RMS file from FDL</span> FDL$GENERATE (flags, fab, rab, fdl) <span class="cmt">// RMS file to FDL text</span> FDL$PARSE (fdl, fab, rab, flags, def, stmt) <span class="cmt">// FDL to FAB / RAB</span> FDL$RELEASE (pfab, prab, flags, badblk) <span class="cmt">// free parsed FAB / RAB</span></pre> <p>Return convention: <strong>odd means success, even means failure</strong>; test <code>ODD(status)</code>.</p><h6>VX/DCL commands</h6> <pre>$ CREATE /FDL=CUSTOMER.FDL CUSTOMER.DAT <span class="cmt">! FDL to RMS file (FDL$CREATE)</span> $ ANALYZE /RMS_FILE /OUTPUT=CUSTOMER.FDL CUSTOMER.DAT <span class="cmt">! RMS file to FDL (FDL$GENERATE)</span> $ CONVERT /FDL=CUSTOMER.FDL CUSTOMER.SEQ CUSTOMER.IDX <span class="cmt">! load records into FDL-defined file</span></pre> <h6>Flag bits</h6><div class="kw-grid"><div>FDL$M_SIGNAL 0x1</div><div>FDL$M_FDL_STRING 0x2</div><div>FDL$M_DEFAULT_STRING 0x4</div><div>FDL$M_FULL_OUTPUT 0x8</div></div><h6>FDL primary sections</h6><div class="kw-grid"><div>TITLE</div><div>IDENT</div><div>SYSTEM</div><div>FILE</div><div>DATE</div><div>RECORD</div><div>ACCESS</div><div>SHARING</div><div>CONNECT</div><div>AREA</div><div>KEY</div><div>ANALYSIS_OF_AREA</div><div>ANALYSIS_OF_KEY</div></div><h6>KEY data types</h6><div class="kw-grid"><div>BIN2</div><div>BIN4</div><div>BIN8</div><div>DBIN2</div><div>DBIN4</div><div>DBIN8</div><div>INT2</div><div>INT4</div><div>INT8</div><div>DINT2</div><div>DINT4</div><div>DINT8</div><div>DECIMAL</div><div>DDECIMAL</div><div>STRING</div><div>DSTRING</div></div><h6>File organizations and record formats</h6><div class="kw-grid"><div>Indexed</div><div>Relative</div><div>Sequential</div><div>Fixed</div><div>Variable</div><div>Stream</div><div>Undefined</div></div></div>
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
What is VX/FDL and how does it help with OpenVMS migration to Linux?

VX/FDL is an implementation of OpenVMS File Description Language (FDL) for Linux that enables the creation, analysis, and management of RMS files with identical structure and behavior to their VMS counterparts. It provides a seamless migration path for legacy RMS data to remain accessible and functional on modern Linux platforms.

The tool allows you to import VMS/OpenVMS FDL files, recreate RMS files with all supported organizations and formats, and leverage VX/DCL commands for comprehensive file management. For organizations looking to modernize their infrastructure, contact us to discuss your specific migration requirements.

What file organizations does VX/FDL support?

VX/FDL handles all Indexed, Relative, and Sequential RMS file organizations with full compatibility.

Which record formats are compatible with VX/FDL?

VX/FDL supports Sequential and Fixed record formats, ensuring 1:1 mapping with VMS files for complete compatibility.

How do I create an RMS file from a VMS FDL specification?

Use the CREATE/FDL command to read your FDL file and generate a matching RMS file on Linux.

Can VX/FDL generate FDL files from existing RMS files?

Yes, VX/FDL includes the ANALYZE/FDL command that extracts an FDL specification from existing RMS files. This reverse capability allows you to document and recreate file structures as needed.

Organizations like Telstra have successfully used similar RMS migration approaches during their OpenVMS modernization projects.

What VX/DCL commands are available for FDL management?

VX/DCL includes CREATE/FDL for creating RMS files from FDL specifications and ANALYZE/FDL for extracting FDL specifications from existing RMS files.

Does VX/FDL provide programming APIs for application integration?

VX/FDL provides a call-compatible library with full implementation of the FDL$() API functions. This includes FDL$CREATE for creating RMS files, FDL$GENERATE for generating FDL files, FDL$PARSE for parsing existing FDL files, and FDL$RELEASE for memory management.

What are the key benefits of using VX/FDL for migration projects?

VX/FDL delivers full compatibility with VMS/OpenVMS FDL, enabling seamless migration of RMS files to Linux while providing identical structure and behavior for RMS data. The tool includes VX/DCL support for automation and supports both command-line and API-based workflows.

Companies like BNY Mellon have leveraged similar file system migration capabilities during their OpenVMS to Linux transitions. VX/FDL ensures legacy RMS data remains accessible, structured, and functional on modern platforms. To explore how VX/FDL can support your migration strategy, contact us for a consultation.

What is VX/FDL?

VX/FDL is an implementation of the OpenVMS File Definition Language (FDL) for Linux and Windows. It lets you create, analyze, and manage RMS files with the same structure and behaviour as their VMS counterparts, so FDL-based file definitions carry over to modern platforms.

Which RMS file organizations and record formats does VX/FDL support?

VX/FDL handles all Indexed, Relative, and Sequential RMS file organizations, and supports Sequential and Fixed record formats, giving a 1:1 mapping with the original VMS files.

How do I create an RMS file from an FDL specification?

Use the CREATE/FDL command (via VX/DCL) or the FDL$CREATE API call to read your FDL file and create a matching RMS file on Linux or Windows.

How do I generate an FDL file from an existing RMS file?

Use the ANALYZE/RMS_FILE command with /OUTPUT (via VX/DCL) or the FDL$GENERATE API call to extract an FDL specification from an RMS file, which can then recreate the file structure.

What VX/DCL commands does VX/FDL provide?

Two main commands: CREATE/FDL, which creates an RMS file from an FDL specification (via FDL$CREATE), and ANALYZE/RMS_FILE, which analyses an RMS file and, with /OUTPUT, writes an FDL specification describing it (via FDL$GENERATE). CONVERT/FDL is also available for loading records into a new FDL-defined RMS file.

Does VX/FDL offer a programming API as well as command-line tools?

Yes. VX/FDL includes a call-compatible library implementing the FDL$() API: FDL$CREATE (create an RMS file from FDL), FDL$GENERATE (generate FDL from an RMS file), FDL$PARSE (parse an existing FDL file), and FDL$RELEASE (release FDL structures from memory), so it fits both scripted and application-integrated workflows.

Can VX/FDL import my existing VMS or OpenVMS FDL files?

Yes. VX/FDL can import VMS and OpenVMS FDL files and recreate the corresponding RMS files with all supported organizations and formats. This preserves the file structure defined on the original VMS system.

How does VX/FDL fit an OpenVMS to Linux migration?

By reproducing RMS file structures with identical behaviour on Linux and Windows, VX/FDL keeps legacy RMS data accessible, structured, and functional on modern platforms. It supports both command-line (VX/DCL) and API-based workflows, providing a migration path for OpenVMS applications that depend on FDL-defined files.

Transform Your Legacy Software Today!

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