## Directivas
### Inclusión de archivos de código
**#include**
- **#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
**#set**
```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
**#def**

**#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 y funciona asignando un valor de cadena que es reemplazado durante la formación del XML. (Casi como una variable o macro)

**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)**
  
**XML**

- `<Personas cantidad = "5" >`
	- `<Persona nombre = "Juan" />`
	- `<Persona nombre = "Pedro" />`
	- `<Persona nombre = "Camila" />`
- `</Personas>`

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)
}

```
**XML**
```XML
<Personas cantidad = "5" >
	<Persona nombre = "Juan" />
	<Persona nombre = "Pedro" />
	<Persona nombre = "Camila" />
</Personas>
```
Si la sentencia #def sólo relaciona una cadena con un identificador puede usarse indistintamente como nombre de elemento, atributo y valor.

**DKL**
```DKL
# def n "nombre"
n(n=n)
```
**XML**
```XML
<nombre nombre = "nombre" />
```
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.
### #redef
La sentencia #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
**#pattern**

#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.
```DKL
#def color (nombre) "prefijoXml:Color"
#pattern color "COLOR '$nombre'"

```
Permitiría el siguiente código:

**COLOR azul**

Que sería formado como:

```DKL
<prefijoXml:Color nombre="azul"/>
```
Tabla de prefijos para símbolos en patrones:
| $ | 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.

###Contexto declarativo

La directiva:

**#$**

Pasa a modo declarativo el contexto de ejecución para las líneas siguientes.

###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:

**#<expresión : formato> Inserción de expresiones**

Por ejemplo:

**a(href="#<url>"){"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:#<monto * 1.16 : $ #,#.00>"}**
  
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