On crates.io, PyPI and npm

ironwork 0.7.0 runs dynamic SQL and programs that take a file's name from a data item, and gives numeric functions the precision IBM documents. A program that PREPAREs and EXECUTEs statements it builds runs instead of ending at its first PREPARE, and an expression holding MAX, MIN or MOD gives Enterprise COBOL's digits.

• Dynamic SQL: PREPARE, EXECUTE, EXECUTE IMMEDIATE and cursors declared for a prepared statement, against PostgreSQL or a recording, under Db2 13's rules and SQLCODEs.
• ASSIGN to a data item: under --compliance extended, ASSIGN TO an item's name, ASSIGN DYNAMIC and ASSIGN USING take the DD name from the item's value at each OPEN, and the input trace records it as a dynamic-file-path sink at the SELECT.
• Numeric function precision: MAX, MIN, RANGE, REM and SUM keep their arguments' decimal places and count them in an expression's intermediate precision; INTEGER, INTEGER-PART and MOD have IBM's digits.
• MOVE of a numeric function: refused under --compliance strict, as Enterprise COBOL refuses it, and moved at IBM's precision with IWX0008-W under extended.

Limit: DESCRIBE, PREPARE ... INTO and USING DESCRIPTOR are refused by name until the SQLDA is read. An ASSIGN item's value names a DD, never a host path: a path, or a name the run was not given, fails the OPEN with status 35 (C360).

ironwork 0.6.0 runs more of what a batch job's utility steps do. A job whose SORT step reformats and edits records with DFSORT IFTHEN, or whose IDCAMS steps list the catalog, print data sets or define alternate indexes, runs instead of being refused or ending with condition code 12.

• IFTHEN: INREC, OUTREC and OUTFIL IFTHEN with WHEN=INIT, a condition (HIT=NEXT), NONE and GROUP (BEGIN, KEYBEGIN, END, RECORDS, PUSH), applied in DFSORT's order.
• Editing and conversion: edit masks M0 to M26, EDIT and EDxy with SIGNS and LENGTH, and TO= conversions between ZD, PD, BI, FI and the other formats, with Table 12's lengths.
• Symbols: SYMNAMES, with each statement substituting symbols by its own context and the table written to SYMNOUT.
• Bad data: an invalid ZD or PD digit abends the step S0C7. FINDREP, PARSE, arithmetic, dates and SEQNUM are refused by name before any step runs.
• LISTCAT: lists the catalog in IBM's layouts, with ENTRIES, LEVEL, generic names, type selections and ALL.
• PRINT: lists a key-sequenced, entry-sequenced or relative record cluster, an alternate index, a path or a sequential data set in DUMP, HEX or CHARACTER format, with SKIP, COUNT, FROMKEY and TOKEY.
• Alternate indexes: DEFINE ALTERNATEINDEX and PATH, BLDINDEX, and a DD that names a path reads the base cluster in alternate-key order. A step that changes a base cluster rebuilds its alternate indexes.
• Catalog: DEFINE CLUSTER takes KEYS, RECORDSIZE, the organization and RECATALOG. A command that ends at condition code 12 or more closes with IDC3003I.
• Messages: IDCAMS writes its messages to SYSPRINT, not into the OUTFILE data set.
• Fuzzing: a loop that runs on every input is no longer reported as a hang the input caused.

Limit: a program's ALTERNATE RECORD KEY reads use the base cluster as it stands, and the base-ddname+N path DDs are not opened (C350).

ironwork 0.5.0 makes run --vm and cics --vm write the same evidence journal and coverage report as the interpreter, and does the same for a compiled module, so cobolwork can verify a run of either executor. It also reads GnuCOBOL and Micro Focus extensions on request, runs DBCS data, and gives GnuCOBOL's results where a migration needs them.

• VM evidence: run --vm and cics --vm take --evidence, its traces and --coverage. On cobolwork's 438 test fixtures, the site's programs and CardDemo's 31 programs the two executors gave the same journals, coverage, output and files, and cobolwork's verifier accepts them.
• Modules: ironwork cics x.iwm runs a module's first program as a task's first program, and --coverage and --evidence work on a module run. A module run gives the journal and coverage report its source run gives.
• Code as text: ironwork dump prints a module's generated code as readable text, with data names, subscripts and source lines, in place of Rust debug output.
• Dialect: --dialect gnucobol gives cobc's results where ironwork's assumptions chose otherwise: intermediate arithmetic, DISPLAY of signed and binary items and of numeric literals, ACCEPT at the end of SYSIN, dynamic CALL of an ENTRY name, a shorter EXTERNAL record, and NOINVDATA comparisons. --dialect ibm is the default and changes nothing.
• Compliance: --compliance extended reads six extensions found in real programs, each with a warning: free-form source, level-78 and CONSTANT entries, <>, & between literals, BINARY-SHORT, -LONG and -DOUBLE, and a PROGRAM-ID with no IDENTIFICATION DIVISION. strict is the default and changes nothing.
• DBCS: PICTURE G and N under NSYMBOL(DBCS), USAGE DISPLAY-1 and GRAPHIC host variables compile and run under all eleven mixed CCSIDs of the Programming Guide's Table 47, on both executors.
• VM speed: the VM meets each speed target set for it: table search runs in 0.187 of the interpreter's time and call-heavy code in 0.184 (target 0.20), packed decimal in 0.294 (target 0.33), and sequential I/O in 0.66 of cobc -O2's time (target 1.25).
• Differential testing: CI runs all 384 NIST CCVS85 programs the interpreter runs on the VM too and compares them. ironwork fuzz --differential runs generated inputs on both executors and keeps a smaller input for each way they differ.
• Compiler checks: ten shapes that Enterprise COBOL refuses are now refused when compiling, not when generating code, and five shapes it accepts now run on the VM.
• Subprogram fuzzing: ironwork fuzz --interface runs a subprogram as a caller would, and run --argument gives a program its USING items.
• IBM's rules: twelve results that departed from Enterprise COBOL's documented rules now follow them, among them a quotient's decimal places, FUNCTION MOD's sign, floating-point exponentiation and DISPLAY of national data; seven more NIST CCVS85 programs run clean (376 of 384).
• Fixes: INITIALIZE of a reference-modified item no longer writes past the item, and the evidence ledger lock is broken by cobolwork's rule.

Limit: the VM is still opt-in. run and cics use the interpreter unless given --vm, --vm with --serve is refused, and a run that reaches something the VM does not run yet stops with exit status 243.

ironwork 0.4.1 publishes what 0.4.0 built to npm, crates.io and PyPI, says through its exit status who ended a run, and runs CICS LINK and XCTL closer to CICS.

• Exit codes: run, cics and job pass a RETURN-CODE of 0 to 238 through and keep 239 and above for ironwork: 240 an abend, 241 no program to run, 242 a code-generation refusal, 243 a VM stop, 244 a construct ironwork does not run, 245 an unreadable source, JCL or module, 246 usage, 255 a panic.
• cobolwork's convention: --exit-code gives cobolwork's verdict codes in place of the band.
• CICS: LINK and XCTL raise LENGERR for a COMMAREA length outside 0 to 32763 and for a COMMAREA with no address, and each LINK or XCTL run unit has its own FUNCTION RANDOM sequence and RETURN-CODE.
• VM and lowering: SEARCH ALL keys, floating-point EXEC CICS options and unsubscripted SQL indicator arrays give the interpreter's results on the VM.

Limit: 0.4.0 is on GitHub only; its npm job failed on a path in the release workflow, and crates.io and PyPI waited behind it.

ironwork can now compile a program to a load module and run it, and a second executor, the VM, runs what the interpreter runs. Every test program lowers (1482 of 1482), and the VM runs 680 of 682 test programs to the end with no difference from the interpreter; the 2 stops are FUNCTION RANDOM in a place and FUNCTION UUID4.

• Load modules: ironwork compile writes a module, ironwork dump reads one, and ironwork run x.iwm runs its first program. A CALL, a function invocation, INVOKE, LINK and XCTL find their programs in the modules already read, then in NAME.iwm in the program libraries, then in source.
• VM: ironwork run --vm and ironwork cics --vm now run file I/O, SORT and MERGE, the Report Writer, JSON and XML GENERATE and PARSE, EXEC CICS and EXEC SQL, INVOKE and the JNI services, LE callable services and the virtual printer, EXTERNAL and GLOBAL storage, and NUMCHECK and PARMCHECK programs.
• User-defined functions: FUNCTION-ID definitions and prototypes compile, an invocation is checked against its definition, and the function runs as a CALLed program runs. IBM's docalc example gives the Programming Guide's result 010230.
• CICS fidelity: HANDLE ABEND follows the rules for logical levels, across CALL, LINK and XCTL. STOP RUN below level one returns to the LINKing program, and each LINK, XCTL and HANDLE ABEND PROGRAM exit starts a run unit with its own programs, EXTERNAL data and heap.
• Recursion: a CALL of an active program that is not RECURSIVE ends with U4038 and IGZ0064S, and a RECURSIVE main program can CALL itself.
• Fuzzing: ironwork fuzz now fuzzes variable-length and relative files, a main program's PARM, a job's data sets, in-stream data and step PARMs (--job), and a CICS task's COMMAREA and terminal input (--cics). It keeps a loop an input caused, and runs each kept abend again at OPTIMIZE(2).
• Compiler options: OPTIMIZE(0|1|2) is read, and at 1 and 2 a zoned item compared with zero is compared by its bytes, as IBM's example shows.
• National data: INSPECT of a NATIONAL item counts, matches and replaces in characters, not bytes.
• VSAMOPENFS: a VSAM data set left open for output, by a run that ended under TRAP(OFF), opens next time with status 97 under VSAMOPENFS(COMPAT) or 00 under SUCC.
• Evidence: a run given --evidence and --trace-input records whether an input byte may be in a sink's operand, including through EXEC CICS.

Limit: the VM still stops at FUNCTION UUID4, FUNCTION RANDOM in a subscript, a SEND MAP or RECEIVE MAP whose MAP is held in a data item, and a CALL, LINK, function or method that does not lower; the interpreter stays the default, and ironwork cics --serve keeps it.

Every program of the 3,000-program census that is valid Enterprise COBOL 6.4 now compiles, and IBM’s run-time checks work.

• Compiles: EXTERNAL and GLOBAL records and files, and USE GLOBAL; the REPLACE statement; items after an OCCURS DEPENDING ON table; INITIALIZE WITH FILLER, TO VALUE, REPLACING and DEFAULT; SET TO ENTRY; CURRENCY SIGN X'hh'; ALPHABETIC-UPPER and -LOWER, NX and floating-point VALUE literals; ASSIGN’s later names, PASSWORD and FUNCTION ALL INTRINSIC.
• Checks: NUMCHECK and ZONECHECK test the zoned, packed and binary senders a statement reads; PARMCHECK catches a CALL that writes past WORKING-STORAGE; INITCHECK warns of an item used before any path sets it.
• Runs: EXEC CICS HANDLE ABEND PROGRAM, LABEL, CANCEL and RESET; lp and lpr print on DD PRINTER; ironwork job passes PARM to a COBOL program and runs DFSORT’s INCLUDE, OMIT, INREC, OUTREC and OUTFIL; a MOVE of a zoned or packed sender holding a non-digit no longer abends at the MOVE.
• Evidence: ironwork fuzz keeps each abend a generated input causes, with its smallest input, journal and coverage; --trace-statements records the statements a run starts.
• VM: ironwork run --vm runs a lowered program’s core statements on the VM, and every test program that lowers runs on both executors.

Limit: the VM stops a run at file I/O, SORT, Report Writer, EXEC CICS and SQL, JSON and XML, Language Environment services and object-oriented COBOL, and the interpreter stays the default.

IBM’s compiler options from the card, load modules, and job steps that sort.

• Options: APOST and QUOTE, CURRENCY, NSYMBOL, DISPSIGN, INTDATE, QUALIFY(EXTEND), INITIAL, VLR, ZWB, INVDATA and ZONEDATA are honoured from a CBL or PROCESS card.
• Compiles: ironwork compile writes a load module and ironwork dump prints one; every intrinsic function of Enterprise COBOL 6.4; JSON and XML GENERATE and PARSE; CORRESPONDING; EXEC DLI checked with the DL/I interface block.
• Runs: a variable-length READ gives status 04 where IBM’s table does, and DISPLAY of a positive signed binary or packed item no longer overpunches.
• Jobs: SORT, MERGE and COPY steps, DISP=MOD, generation data groups, and a hash-chained step journal.
• Evidence: --trace-marker shows whether an input reached each sink, and run --coverage with compare names the changed paragraphs no run reached.

Batch programs with SQL, sorts, reports and classes run.

• Runs: EXEC SQL against PostgreSQL or a recording, with TLS in a separate build; SORT and MERGE with FASTSRT; Report Writer; object-oriented COBOL; Language Environment services; collating sequences.
• Compiles: ENTRY, ALTER and GO TO DEPENDING ON; DECLARATIVES; LINAGE; PERFORM ranges as IBM runs them; programs with E-level messages, which now run; EXEC DLI, refused by name.
• Checks: diagnostics with IBM’s severities; compare and compile provenance; sealed run evidence.
• Tools: --serve with a CSD-defined region; ironwork ddl; ironwork job with job equivalence; the rt and jcl crates.

Installs from PyPI and npm, with builds for each platform.

• The machine and compiler models, and the oracle.
• The interpreter: COPY, sequential, indexed and relative files, and subprograms.
• EXEC SQL and EXEC CICS checked when compiled; CICS tasks, BMS maps and the TN3270 server.

The crates, each carrying the licence, the notice and the runtime exception.