# Temas avanzados ## Ejecutar otros programas: runscript y runcode `runscript(archivo [, nombre, objeto])` ejecuta otro programa DKL y devuelve como cadena el árbol XML que produce. Con tres argumentos, el objeto se pasa al programa hijo como la variable global `@nombre` (el nombre se escribe **sin** `@`). El hijo trabaja sobre el **mismo** objeto, así que puede devolver datos modificándolo. `runcode(código [, nombre, objeto])` hace lo mismo con código DKL en una cadena. Programa hijo `hijo.dkl`: ```dkl #include "dkli.dkh" #! program "hijo" { #include "functions.dkh" total = @@(@pedido, "#cantidad") * @@(@pedido, "#precio") @pedido<"total">: total #$ resultado(cliente="#<@@(@pedido, \"cliente\")>") { "#" } } ``` Programa padre: ```dkl #include "dkli.dkh" #! program "padre" { #include "functions.dkh" #include "serialize.dkh" new p { @"cliente": "Ana" @"cantidad": 3 @"precio": 12.5 } xml = runscript("hijo.dkl", "pedido", p) do print(xml) do print(to.json(p)) s = runcode("#include \"dkli.dkh\"\n#!\nprogram \"x\"\n{\n @dato<\"visto\">: 1\n #$\n ok{}\n}", "dato", p) do print(s) do print(to.json(p)) } ``` ```text 37.5 {"cliente":"Ana","cantidad":3,"precio":12.5,"total":37.5} {"cliente":"Ana","cantidad":3,"precio":12.5,"total":37.5,"visto":1} ``` Notas: - La ruta de `runscript` se resuelve respecto al directorio de trabajo del proceso. - Las funciones declaradas dentro de un `runscript`/`runcode` quedan registradas en el programa que los llama (comportamiento conservado de 1.x). - Un error del hijo llega como `Error al invocar runscript. …` o `Error al invocar runcode. …` (en 1.x `runcode` decía "runscript"). En 2.0, un `#include` dentro de `runcode` se resuelve normalmente (en 1.x fallaba con `Value cannot be null`). - Es la base del marco CRUD-L, que ejecuta las vistas en un contexto aparte y les pasa `@crud_context`. ## Evaluar expresiones: eval `eval(cadena)` evalúa una expresión DKL escrita en una cadena, con las variables del contexto actual: ```dkl a = 5 new r { @"nombre": "Ana" } do print(eval("1 + 2 * 3")) do print(eval("a * 2")) do print(eval("toupper(@@(r, \"nombre\")) + \"!\"")) formula = "precio * (1 + iva)" precio = 100 iva = 0.16 do print(eval(formula)) ``` ```text 7 10 ANA! 116.00 ``` `eval` evalúa **expresiones**, no sentencias; para código completo use `runcode`. No evalúe texto que venga del cliente. ## Capturar la salida declarativa: fxml `fxml(…)` devuelve como cadena el XML producido **hasta ese momento** en el elemento actual y lo quita de la salida. Los argumentos (opcionales) se evalúan antes; así se captura lo que imprimen unas funciones: ```dkl fila :: nombre, precio { #$ tr { td{ "#" } td{ "#" } } #! } html = fxml(fila("Lápiz", 5.5), fila("Goma", 1234)) do print("HTML capturado: " + html) #$ fin{} ``` ```text HTML capturado: Lápiz 5.50Goma 1,234.00 ``` Útil para armar el cuerpo de un correo o guardar un fragmento de HTML en un archivo. En 2.0 `fxml` funciona igual con la salida directa encendida. `fxml()` sin argumentos devuelve lo que produjo el elemento **declarativo** que la contiene (por ejemplo, llamada con `#!` dentro de `caja { … }`). Llamada directamente en el cuerpo de `program`, devuelve una cadena vacía: no captura lo que el programa ya escribió. ## Interoperabilidad con .NET DKL puede crear objetos de .NET, leer y escribir sus propiedades y llamar a sus métodos. Es la manera de extender el lenguaje con bibliotecas propias o del sistema. | Función | Qué hace | |---|---| | `_import_library(ensamblado)` | Carga un ensamblado (`.dll` o nombre calificado) y devuelve una referencia. Requiere `ref`. | | `_new([ensamblado,] tipo [, args…])` | Crea una instancia. Requiere `ref`. | | `_gettype([ensamblado,] tipo)` | Devuelve el `System.Type` del tipo. | | `_map_function(ensamblado, tipo, método, nombre, tipos_args, retorno)` | Registra un método como función DKL. | | `_invoke(objeto, nombre_mapeado [, args…])` | Llama a un método **de instancia** mapeado. | | `_get(objeto, propiedad)` | Lee una propiedad. | | `_set(objeto, propiedad, valor)` | Escribe una propiedad. | Detalles de cada función en [Funciones de interoperabilidad](/es/devkron/2.0/lenguaje/funciones-incorporadas/interoperabilidad.md). ### Ejemplo: expresiones regulares ```dkl ref asm = _import_library("System.Text.RegularExpressions.dll") do _map_function(asm, "System.Text.RegularExpressions.Regex", "IsMatch", "re.coincide", "System.String,System.String", "#") do _map_function(asm, "System.Text.RegularExpressions.Regex", "Replace", "re.reemplaza", "System.String,System.String,System.String", "$") do print(re.coincide("ABC-123", "^[A-Z]{3}-[0-9]+$")) do print(re.reemplaza("tel: 55 1234 5678", "[^0-9]", "")) ref rx = _new(asm, "System.Text.RegularExpressions.Regex", "[0-9]+") do _map_function(asm, "System.Text.RegularExpressions.Regex", "Match", "re.primera", "System.String", "*") ref m = _invoke(rx, "re.primera", "folio A-2026-77") do print(_get(m, "Value")) ``` ```text 1 5512345678 2026 ``` Los métodos **estáticos** mapeados se llaman como cualquier función (`re.coincide(…)`); los de **instancia**, con `_invoke(objeto, "nombre", …)`. Con `-1` como ensamblado se usan los tipos que el motor ya tiene cargados (`System.Math`, `System.Text.StringBuilder`…). ### Ejemplo: propiedades ```dkl ref ub = _new("System.UriBuilder") do _set(ub, "Host", "ejemplo.com") do _set(ub, "Scheme", "https") do _set(ub, "Path", "/api/v1") do print(_get(ub, "$Uri")) do print(_get(ub, "Port")) ref u = _get(ub, "&Uri") do print(_get(u, "Host")) ``` ```text https://ejemplo.com/api/v1 443 ejemplo.com ``` ### Lo que cambió en 2.0 - `_new` pasa **todos** los argumentos al constructor (en 1.x omitía el último). - Las funciones mapeadas se pueden llamar por `namespace`, `alias` o nombre completo. - Las extensiones .NET compiladas para Devkron 1.x funcionan sin recompilar. Las fachadas `System.Net`, `System.Web.HttpUtility`, `System.IO.Compression.ZipFile` y `System.Text.RegularExpressions` vienen en la distribución. - Reemplazar una DLL ya cargada requiere reiniciar el servidor FastCGI. - Dentro de una ejecución, la cultura del hilo es la invariante: una extensión que formatee con `ToString()` sin cultura obtiene texto con punto decimal. ## Variables globales del motor | Variable | Contenido | |---|---| | `@null` | Referencia nula (para comparar o inicializar: `ref x = @null`). | | `@_run_settings` | Configuración de la ejecución (`Arguments`, `SourceCodeFile`, `Id`…), un objeto .NET que se lee con `_get`. | | `@_document`, `@_context`, `@_parser` | Objetos internos del motor (para extensiones). | | `@http_context` | En un servidor web: la solicitud y la respuesta. | | `@crud_context` | En las vistas del marco CRUD-L: datos de la operación. | ```dkl ref args = _get(@_run_settings, "&Arguments") do print("Argumentos: " + str(_get(args, "Count"))) do print(isnull(@null)) ``` ```text Argumentos: 2 1 ``` (Para leer argumentos con comodidad use `commandline` de `functions.dkh`.) Toda referencia nula del programa (la de `@null`, `ref x = @null` o la que devuelve `@@(r, "&campo_que_no_existe")`) apunta al mismo lugar. Hasta 2.0.2, crear un objeto sobre una de ellas (una flecha `x -> g`, `new`, `using`, un bloque `$$`) lo guardaba en ese lugar compartido: desde ahí `@null` dejaba de ser nulo en todo el programa. **Desde 2.0.3 ya no pasa**: el objeto se guarda aparte y solo esa variable lo ve. Aun así, para crear una lista en un campo que puede no existir, conviene preguntar con `field.exist(r, "campo")` y crearla con `list.create()`: es claro y funciona igual en todas las versiones. `ref x = expr` y `ref x:expr` no son iguales cuando `x` ya existe y apunta a un objeto: `ref x = expr` hace que `x` apunte al objeto de la expresión; `ref x:expr` **coloca** el objeto de la expresión en el lugar de `x`, de modo que lo ven todas las variables que compartían ese lugar (por ejemplo, quien le pasó `x` a la función con `&`), y el lugar de origen queda vacío. Si `x` es nula (`ref x = @null`), `ref x:expr` solo hace que `x` apunte al objeto, como `ref x = expr`. En 2.0.3 este último caso fallaba desde la segunda llamada a la función (`x` quedaba nula y el objeto de origen se perdía); está corregido en 2.0.4. ### @http_context En un programa que atiende una solicitud HTTP (FastCGI con nginx o IIS), `@http_context` es un registro con: | Miembro | Contenido | |---|---| | `request/headers` | encabezados de la solicitud | | `request/cookies` | cookies | | `request/get` | parámetros de la URL y los marcadores de `routes.map` | | `request/post` | campos de un formulario `application/x-www-form-urlencoded` | | `request/post_string` | cuerpo crudo (aquí llega el JSON) | | `request/files` | archivos de un `multipart/form-data` | | `response/headers` | encabezados de la respuesta | | `response/output` | `standard` (el árbol XML, por omisión), `text` o `binary` | | `response/text` | respuesta de texto cuando `output` es `text` | | `response/binary*` | arreglo de bytes cuando `output` es `binary` | | `response/http_status` | estado HTTP; **en 2.0 sí se envía** (404, 201, 500…) | Un servicio que responde JSON: ```dkl #include "dkli.dkh" #! program "servicio" { #include "functions.dkh" #include "serialize.dkh" ref entrada = from.json(@@(@http_context, "request/post_string")) new datos { @"ok": 1 @"recibido*": entrada } @http_context<"response/headers/content-type">: "application/json;charset=utf-8" @http_context<"response/output">: "text" @http_context<"response/text">: to.json(datos) } ``` Detalle en [Desarrollo web](/es/devkron/2.0/marcos/). ### @crud_context Las vistas del marco CRUD-L se ejecutan en un contexto aparte y reciben `@crud_context` con `output` (o `.`), `input`, `parameters`, `error`, `database`, `http` (el `@http_context` completo) y `script`. Para que una vista funcione igual llamada directamente o desde CRUD-L, puentee el contexto: ```dkl new @crud_context { new member @"http" { @"x": "1" } } if not(isset("@http_context")) && isset("@crud_context") { ref @http_context = ifnull(@@(@crud_context, "&http"), record.create()) } do print(to.json(@http_context)) ``` ```text {"x":"1"} ``` Vea [Marcos de trabajo: CRUD-L](/es/devkron/2.0/marcos/crudl/).