# Funciones de sistema
| Función | Descripción |
|---|---|
| `runscript(archivo [, nombre, objeto])` | Ejecuta otro programa DKL y devuelve su árbol XML como cadena. |
| `runcode(código [, nombre, objeto])` | Ejecuta código DKL dado en una cadena y devuelve su árbol XML. |
| `eval(expresión)` | Evalúa una expresión DKL escrita en una cadena. |
| `fxml([args…])` | Devuelve el XML producido hasta el momento en el elemento actual y lo quita de la salida. |
| `ftext(texto)` | Devuelve el texto con las marcas `#<…>` evaluadas. |
| `isset(nombre)` | 1 si la variable existe. |
| `vartype(nombre)` | Tipo de la variable. |
| `isnull(ref)` | 1 si la referencia apunta a nulo. |
| `ifnull(ref, ref_predeterminada)` | La segunda referencia si la primera es nula; si no, la primera. |
| `_null()` | Una referencia nueva a nulo. |
| `_free(ref)` | Libera el objeto de una referencia. |
| `dklversion()` | Versión del motor. |
| `dkl_license_info()` | Información de la licencia (objeto). |
## runscript y runcode
- `runscript(archivo)` ejecuta el programa y devuelve su salida XML. La ruta se resuelve respecto al directorio de trabajo del proceso.
- `runscript(archivo, nombre, objeto)` además pasa `objeto` al programa como la global `@nombre` (`nombre` va sin `@`). El hijo trabaja sobre el mismo objeto.
- `runcode(código)` y `runcode(código, nombre, objeto)` hacen lo mismo con el código en una cadena.
- Solo se admiten 1 o 3 argumentos.
- El código del hijo es un programa independiente: si usa funciones de bibliotecas (`@@`, `trim`…), debe incluir `dkli.dkh` y `functions.dkh` como cualquier programa.
```dkl
s = runcode("nodo(a=\"1\") { hijo{} }")
do print(s)
new datos { @"n": 20 }
r = runcode("#include \"dkli.dkh\"\n#!\nprogram \"x\"\n{\n #include \"functions.dkh\"\n @d<\"doble\">: @@(@d, \"#n\") * 2\n #$\n ok{}\n}", "d", datos)
do print(to.json(datos))
```
```text
{"n":20,"doble":40}
```
Ejemplo con un archivo y paso de datos en [Temas avanzados](/es/devkron/2.0/lenguaje/imperativo/temas-avanzados.md).
## eval
`eval(expresión)` evalúa una cadena que contiene una expresión DKL y devuelve el resultado, con las variables del contexto actual. No ejecuta sentencias.
```dkl
a = 5
do print(eval("1 + 2 * 3"))
do print(eval("a * 2"))
do print(eval("\"txt\" + \"x\""))
do print(eval("toupper(\"abc\")"))
```
```text
7
10
txtx
ABC
```
## fxml
`fxml(args…)` evalúa sus argumentos (una lista variable de expresiones, por ejemplo llamadas a funciones que imprimen), y devuelve como cadena el XML producido hasta ese momento dentro del elemento actual, quitándolo de la salida.
```dkl
#$
pagina
{
antes(n="1") {}
#!
s = fxml()
do print("capturado: " + s)
#$
despues(n="2") {}
}
```
```text
capturado:
```
Más ejemplos en [Temas avanzados](/es/devkron/2.0/lenguaje/imperativo/temas-avanzados.md).
## ftext
`ftext(texto)` devuelve el texto con las marcas `#` y `#` evaluadas en el contexto actual. Es la única forma de usar marcas en el código imperativo.
```dkl
new r
{
@"nombre": "Ana"
@"total": 1234.5
}
do print(ftext("Cliente: #<@@(r, \"nombre\")> total #<@@(r, \"#total\"):#,#.00>"))
sql = "select * from t where id=#<5 * 2>"
do print(ftext(sql))
```
```text
Cliente: Ana total 1,234.50
select * from t where id=10
```
Vea [Marcas de expresión](/es/devkron/2.0/lenguaje/declarativo/marcas-de-expresion.md).
## isset
`isset(nombre)` devuelve 1 si existe una variable con ese **nombre** (una cadena), local o global (`"@g"`).
## vartype
`vartype(nombre)` devuelve el tipo de la variable con ese **nombre**:
| Valor | Significado |
|---|---|
| `-1` | la variable no existe |
| `0` | la variable es nula |
| `1` | cadena |
| `2` | número |
| `3` | referencia |
Si le pasa la variable en lugar del nombre (`vartype(a)` en vez de `vartype("a")`), busca una variable cuyo nombre es el **valor** de `a` y normalmente devuelve -1.
```dkl
do print(isset("a"))
a = 1
b = "s"
ref c = record.create()
do print(isset("a"))
do print(isset("@g"))
@g = "x"
do print(isset("@g"))
do print(vartype("a"))
do print(vartype("b"))
do print(vartype("c"))
do print(vartype("noexiste"))
do print(vartype(a))
```
```text
0
1
0
1
2
1
3
-1
-1
```
## isnull, ifnull, _null y @null
- `isnull(ref)`: 1 si la referencia apunta a nulo.
- `ifnull(ref, ref_predeterminada)`: devuelve `ref_predeterminada` si `ref` es nula, si no `ref`. Asigne el resultado con `ref`.
- `_null()`: crea una referencia nueva a nulo. La global `@null` es la forma usual (`ref x = @null`).
En la documentación de 1.x esta función aparecía como `null()`; el nombre real es `_null()` (`null()` da `Función: null no reconocida`).
```dkl
ref n = @null
do print(isnull(n))
ref r = record.create()
do print(isnull(r))
ref x = ifnull(n, r)
do print(isnull(x))
ref z = _null()
do print(isnull(z))
ref sub = ifnull(@@(r, "&noexiste"), record.create())
do print(to.json(sub))
```
```text
1
0
0
1
{}
```
El patrón de la última línea (leer un objeto opcional con un valor por omisión) es el que usan las vistas de CRUD-L: `ref @http_context = ifnull(@@(@crud_context, "&http"), record.create())`.
## _free
`_free(ref)` libera el objeto al que apunta la referencia; la variable queda apuntando a nulo. Normalmente no hace falta: el motor libera los objetos cuando ninguna variable los referencia, y en 2.0 también llama a `Dispose` de los objetos que quedan vivos al terminar cada ejecución. Úselo para soltar pronto un objeto grande dentro de un proceso largo. En la documentación de 1.x aparecía como `free()`; el nombre real es `_free()`.
```dkl
ref grande = list.create()
do list.addstr(grande, "datos")
do _free(grande)
do print(isnull(grande))
```
```text
1
```
## dklversion y dkl_license_info
- `dklversion()` devuelve la versión del motor como cadena: desde 2.0.5.0 con cuatro partes (`2.0.5.0`); de 2.0.1 a 2.0.4 con tres (`2.0.4`).
- `dkl_license_info()` devuelve una referencia con la información de la licencia del servidor de aplicaciones; en consola, sin una instancia de servidor, es nula.
```dkl
do print(dklversion())
ref li = dkl_license_info()
do print(isnull(li))
```
```text
2.0.5.0
1
```
Devkron 2.0 usa una clave de licencias distinta a la de 1.x: las licencias de 1.x no se aceptan. Vea [Instalación](/es/devkron/2.0/instalacion/).