## Directivas
Todas las directivas inician con un caracter ```#``` y se procesan durante el análisis (parseo) de los archivos dkl conforme se van identificando,
esto ocurre antes de que se realice la interpretación o ejecución del programa.
### Inclusión de archivos de código
La directiva ```#include ``` inserta otros archivos en uno principal haciendo que se interprete todo como si se tratara de un solo documento.
```
#include "archivo"
#include "archivo" build
#include "archivo" with "plantilla"
#include UTF8 "archivo"
#include UTF8 "archivo" build
#include UTF8 "archivo" with "plantilla"
```
* ```Archivo``` es la ubicación local o remota de un archivo que va a incorporarse en la posición donde se encuentre la sentencia.
Debido a que el parámetro archivo de la sentencia es una cadena y se usa la sintaxis de C, deberá usar doble \\ para indicar una \.
Ejemplos:
``` DKL
#include "c:\\archivo.dkl" //Correcto
#include "c:\archivo.dkl" //Incorrecto
#include "archivo.dkl" /*Correcto, el archivo se busca en la misma ubicación que el programa
que lo requiere o en las ubicaciones predeterminadas del entorno.*/
#include "https://dev.induxsoft.net/archivo.dkl" //Correcto
```
### Definición de meta-atributos
La directiva ```#set``` agrega información a las declaraciones (que se corresponden a nodos Xml) de Devkron.
```DKL
# set "meta-atributo" "valor"
```
Asignación de meta atributos al elemento (nodo) inmediato siguiente a la sentencia.
```DKL
# set "AtributoAsociado" "valor"
E(a="5") { }
```
El elemento E tiene asociado un meta-atributo denominado AtributoAsociado.
### Definición de plantillas de elementos
La directiva ```#def``` asocia un identificador con una cadena que puede usarse en la construcción de declaraciones para simplificarlas o incluso admitir secuencias de caracteres no válidas para la sintaxis de Devkron pero sí válidas para Xml o Html.
```
#def identificador [(atributos por orden)] "valor" [(atributos predeterminados)]
```
Asignación de cadena a identificador
Es la forma más simple de uso de la palabra ```#def``` funciona asignando un valor de cadena que es reemplazado durante la formación del XML. (Casi como una variable o macro)
En Devkron:
``` DKL
#def J "Juan"
#def P "Pedro"
#def C "Camila"
#def n "nombre"
Personas(cantidad="5")
{
Persona(n=J)
Persona(n=P)
Persona(n=C)**
}
```
En Xml:
```
```
Combinando el uso de #def e #include
```archivo1.dkl```:
``` DKL
# def J "Juan"
# def P "Pedro"
# def C "Camila"
# def n "nombre"
```
```archivo2.dkl```:
``` DKL
#include "archivo1.dkl"
Personas(cantidad="5")
{
Persona(n=J)
Persona(n=P)
Persona(n=C)
}
```
Resultado en ```XML```:
```XML
```
Si la directiva ```#def``` sólo relaciona una cadena con un identificador puede usarse indistintamente como nombre de elemento, atributo y valor.
Ejemplo ```DKL```:
``` DKL
# def n "nombre"
n(n=n)
```
Equivalente ```Xml```:
```XML
```
Atributos por orden
Es una lista de identificadores o cadenas separadas por comas que simplifican la asignación de valores de atributos en una declaración de elemento.
#### Redefinición de plantilla
La directiva ```#redef``` cambia la cadena asociada a una declaración ```#def``` previa.
El efecto de ```#redef``` es al código que le sigue únicamente.
### Definición de patrones de sintaxis
La directiva ```#pattern``` permite definir un patrón de declaración que será reconocido y transformado a un nodo del árbol que constituye el documento (programa) de Devkron.
De hecho, toda la sintaxis imperativa de Devkron, está definida mediante directivas ```#pattern``` que se encuentran en el archivo ```dkli.dkh```
```
#pattern Identificador cadena_de_patrón
```
Identificador es cualquiera definido previamente por una sentencia #def.
cadena_de_patron es una cadena que contiene los símbolos válidos para esa sintaxis en particular.
Ejemplo:
```DKL
#def color (nombre) "prefijoXml:Color"
#pattern color "COLOR '$nombre'"
```
Permitiría el siguiente código:
``` DKL
COLOR azul
```
Que sería formado como:
``` Xml
```
Tabla de prefijos para símbolos en patrones:
|Prefijo|Uso |
|:-------:|----|
| $ | Identificador (los admitidos en el lenguaje C) |
| & | Expresión (Expresión válida según sintaxis de C)|
| % | Macro o uso del definidor (reemplaza el nombre por lo que corresponda en una sentencia #def previa) |
| @ | Cadena (Cadena válida de C [Entre comillas dobles o simples])|
| # | Número (Sintaxis de C para valores numéricos)|
| * | Mezcla (Número, cadena o Identificador)|
(Si no se especifica un prefijo, se asume que es una expresión)
En la sintaxis de un patrón no se permiten las siguientes secuencias:
- ```Expresión``` ```Expresión```
- ```Identificador``` ```Expresión```
- ```PalabraReservada``` ```Expresión```
### Contexto declarativo e imperativo
El contexto se refiere al modo como son procesados los elementos del árbol del programa DKL y son dos:
- Contexto declarativo. Significa que los elementos son transformados a su equivalente XML tal como han sido expresados.
- Contexto imperativo. Significa que los elementos serán considerados sentencias sujetas de interpretación al estilo de cualquier lenguaje imperativo, es decir se realizarán asignaciones de variables, llamadas a funciones, ciclos, etc.
Las directivas de selección de contexto sirven para establecerlos en el código del programa.
#### Conmutación de contexto
La directiva ```##``` conmuta entre contextos, si la secuencia de ejecución está en modo declarativo cambia a imperativo y viceversa.
#### Contexto imperativo
La directiva ```#!``` pasa a modo imperativo el contexto de ejecución para las líneas siguientes, si ya está en modo imperativo simplemente no hace nada más.
#### Contexto declarativo
La directiva ```#$``` pasa a modo declarativo el contexto de ejecución para las líneas siguientes, si ya está en modo declarativo no hace más nada.
### Inyección de expresiones
En ocasiones requerirá que el valor o nombre de elementos o atributos, así como partes del texto contenido dentro de elementos, se genere dinámicamente por el programa.
Para hacerlo, use la siguiente sintaxis:
```#```
Por ejemplo:
```
a(href="#"){"Hipervínculo"} // coloca el valor de una variable denominada url en la posición de la marca.
```
Dentro de las marcas de inyección pueden escribirse expresiones completas.
Adicionalmente, el carácter ```:``` se utiliza para que al resultado de la expresión se le proporcione un formato específico (solo aplica cuando el resultado es numérico).
```
nodo {" El valor monetario es: #"}
```
Genera un nodo con formato.
La marca de inyección únicamente puede usarse en:
- El nombre o el valor de atributos
- El nombre de elementos
- Bloques de texto dentro de elementos
- En cadenas que sean procesadas por la función ```ftext()``` en el contexto imperativo