[Noticia] EXEC RUST: Rust real compilado (1.60.9-1.60.11)

[Eslopes]

EXEC RUST deja de ser una imitación interpretada y pasa a ser Rust real, compilado dentro del binario de su programa.

Lo que había antes

EXEC RUST interpretaba un micro-lenguaje de cuatro formas: asignación compuesta, asignación simple, "let" como operación nula, y aritmética entera. Lo que no reconocía lo escribía en un log de depuración y continuaba. Un bloque de Rust auténtico "funcionaba" sin hacer absolutamente nada: sin error, sin salida, sin nada que diagnosticar. Esa rama se ha eliminado, no rodeado.

Lo que hay ahora

Cada bloque se compila como una función Rust real dentro del mismo crate que la aplicación ya construía. No hay un compilador nuevo ni carga dinámica: una aplicación compilada de PowerRustCOBOL siempre fue un crate de Rust generado, así que esto es un módulo generado más. Dispone del lenguaje completo: cierres, genéricos, cadenas de iteradores, match, el operador ? y toda la biblioteca std.

Dos clases de bloque

• De items - en CONFIGURATION SECTION, tras REPOSITORY. Contiene items de Rust: struct, enum, impl, trait, use. Se emite a nivel de módulo, de modo que todos los bloques del programa los ven.
• De sentencias - en PROCEDURE DIVISION, en cualquier punto donde quepa una sentencia, incluidos IF, EVALUATE, ON SIZE ERROR y TRY, y también dentro de un manejador de eventos de un formulario.

Por eso los 48 tipos CLASS RUST-* son un suelo y no un techo: defina su propio tipo en un bloque de items, nómbrelo con un CLASS y declare elementos de él.

CATCH RUST-EXCEPTION

Un panic dentro de un bloque se captura con TRY ... CATCH RUST-EXCEPTION e ... END-TRY: DISPLAY e imprime su texto en claro y el programa continúa. Un CATCH EXCEPTION corriente NO lo captura, y un THROW de COBOL nunca llega a la cláusula de Rust. Un mismo TRY puede llevar las dos cláusulas y cada clase va a la suya.

Los errores se informan en sus términos

Un error de tipos dentro de un bloque detiene la compilación en SU línea y SU columna de EXEC RUST, nunca en el código generado. Un diagnóstico que no se pueda atribuir a algo que usted escribió se muestra tal cual, en lugar de culpar a una línea inocente de COBOL.

Qué puede cruzar a un bloque

Solo un elemento USAGE OBJECT REFERENCE cuya CLASS nombre un tipo de Rust. Un elemento PIC se rechaza por su nombre: su valor es un decimal escalado o un campo de anchura fija, y no existe un tipo de Rust que sea eso.

El nombre en Rust es su nombre COBOL en minúsculas con los guiones convertidos en subrayados: WS-USER-NAME es ws_user_name. Y es una referencia mutable, así que se asigna a través de él:

*contador = 10;
texto.push_str("x");

Ejemplo: un diálogo abierto desde COBOL

       REPOSITORY.
           CLASS RUST-STRING IS "Rust.String"
           CLASS RUST-I32    IS "Rust.i32"

       EXEC RUST
           use eframe::egui;
           use std::sync::{Arc, Mutex};

           pub struct ButtonDialog { pub clicked: Arc<Mutex<i64>> }

           impl eframe::App for ButtonDialog {
               fn ui(&mut self, ui: &mut egui::Ui, _f: &mut eframe::Frame) {
                   ui.horizontal(|ui| {
                       for caption in [1_i64, 2_i64] {
                           if ui.button(caption.to_string()).clicked() {
                               *self.clicked.lock().unwrap() = caption;
                               ui.ctx().send_viewport_cmd(egui::ViewportCommand::Close);
                           }
                       }
                   });
               }
           }

           pub fn ask(title: &str) -> i64 {
               let clicked = Arc::new(Mutex::new(0_i64));
               let out = clicked.clone();
               let _ = eframe::run_native(title, eframe::NativeOptions::default(),
                   Box::new(move |_cc| Ok(Box::new(ButtonDialog { clicked: out }))));
               let v = *clicked.lock().unwrap();
               v
           }
       END-EXEC.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 window-title    USAGE IS OBJECT REFERENCE RUST-STRING
                          VALUE "Hello, From COBOL".
       01 clicked-button  USAGE IS OBJECT REFERENCE RUST-I32.
       01 ws-error        PIC X(120).

       PROCEDURE DIVISION.
       MAIN.
           TRY
               EXEC RUST
                   *clicked_button = ask(window_title.as_str());
               END-EXEC
           CATCH RUST-EXCEPTION ws-error
               DISPLAY "Window failed: " ws-error
           END-TRY.

           DISPLAY clicked-button.
           GOBACK.

Dos detalles que conviene saber de ese ejemplo, porque se comprobaron compilando:

• Aquí eframe es la 0.35, cuyo trait App exige fn ui, no fn update. Los tutoriales de eframe antiguos no compilan tal cual.
• Toda clase entera (RUST-I8 hasta RUST-USIZE) se enlaza como i64, y las dos de coma flotante como f64, porque así las guarda el puente de objetos: INVOKE y un bloque ven siempre el mismo valor. Por eso ask devuelve i64.

Abrir una ventana con run_native es cosa de programas de consola: un formulario ya posee su propio bucle de eventos y anidar otro aborta el proceso.

Compilar y ejecutar

Un programa que contiene un bloque se compila antes de ejecutarse, y Run lo hace por usted; uno sin bloques conserva intacto el camino rápido del intérprete. Compilar necesita la cadena de herramientas de Rust (rustup.rs); el binario que usted entrega, no. Se compila para el sistema anfitrión: Windows en Windows, macOS en macOS, Linux en Linux.

La guía del desarrollador y la Base de Conocimiento del sistema incluyen ya la sección completa con este ejemplo.

Anthropic Claude Codex Agent