Instrucciones del Compilador eWa de Idioma eWa
Las Instrucciones del Compilador de Idioma eWa son un conjunto de sentencias (estructuras y procedimientos) para desarrollar un lenguaje que reconocerá un compilador de Idioma eWa en tiempo de compilación.
En el caso particular del Compilador eWa son el conjunto de estructuras y procedimientos que se mostrarán a continuación. En este listado se incluyen todas aquellas instrucciones que están disponibles en cualquiera de los LeWaS que implementan el Idioma eWa desarrollados por el Proyecto eWa: Lenguaje eWamblador, Lenguaje eWa o Lenguaje eWa++.
Estas instrucciones permiten concretar las estructuras (rutinas y segmentos) primitivas que usarán los lenguajes de programación.
Aparición y uso
Por sí solo, el Idioma eWa no contiene prácticamente ninguna estructura definida. Sólo detecta instrucciones, funciones, argumentos, comentarios, cadenas de literales, caracteres escapados, números naturales de precisión infinita, prioridades; y, por suerte, las Instrucciones del Compilador. Aunque la lista anterior es muy jugosa, en realidad no da juego alguno para la creación de soluciones informáticas. Es necesario, al menos, el uso de algunas de estas instrucciones.
Por qué no están incluidas en el Idioma
El hecho de que las instrucciones del Compilador estén fuera de la definición del Idioma eWa lo convierten en un Idioma de programación realmente modular. La capacidad que tiene de transformarse es realmente útil. De esta manera, es posible utilizar el mismo Idioma (el eWa) para un mismo entorno de programación y a la vez usar diferentes compiladores que, por poder, pueden tener diferentes, más o menos, Instrucciones del Compilador.
Otro beneficio directo consiste en que varias soluciones informáticas pueden hacer uso de código escrito para otro compilador usando el mismo Idioma, lo que garantiza la portabilidad. De igual forma, se pueden usar compiladores específicos para trabajar como zona de pruebas y otros más genéricos o estándares para hacer más eficaz la Solución Informática.
Estructuras Básicas
El conjunto de Instrucciones del Compilador de Idioma eWa incluyen unas estructuras predefinidas y otras heredadas del Idioma eWa. Éstas estructuras se refieren básicamente a las que detecta el propio idioma, aunque en realidad hay otras que no está detectado (pero sí contemplado) por el idioma.
Propias
Primero mostraremos las estructuras propias generadas por este Compilador eWa de Idioma, que solo se garantiza que estarán disponibles en este Compilador.
#
Es la estructura por defecto. Está destinada a trabajar como estructura global, accesible desde todo el código. Su uso está destinado también como campo para referirse al contenido, es decir, la función que se ejecuta al seleccionar la estructura en el código.
#VOID
Es la estructura vacía. Está destinada a trabajar la estructura que no tiene tipo.
#DEFINED
Es la estructura definida. Cualquier valor definido será una estructura #DEFINED.
#UNDEFINED
Es la estructura indefinida. Cualquier otra estructura que no entre dentro de las demás, será #UNDEFINED.
Heredadas
Y estas son las estructuras heredadas del Idioma eWa, disponibles para todos los Compiladores de Idioma eWa.
#FUNCTION
Es la estructura función. Está destinada a detectar y referenciar las estructuras que el Idioma eWa genera con el símbolo de las llaves ({ }).
#STRING
Es la estructura cadena de literales. Está destinada a detectar y referenciar las estructuras que el Idioma eWa genera con los símbolos de comillas dobles (" ") o comillas simples (' ').
#UINT
Es la estructura entero sin signo. Está destinada a detectar y referenciar las estructuras que el Idioma eWa genera con los números enteros sin signo del Idioma eWa. Utiliza una reducción al nivel 1 la implementación de la estructura STRING.
#OBJECT
Es la estructura objeto. Está destinada a trabajar con las estructuras que el Idioma eWa genera con el símbolo dos puntos (:).
#ARGUMENT
Es la estructura argumento. Está destinada a detectar y referenciar las estructuras que el Idioma eWa genera con el símbolo coma (,) y, por defecto, con el espacio ( ).
Porcedimientos
La sintaxis de las Instrucciones del Compilador de Idioma eWa se define como procedimientos que empiezan por el símbolo almohadilla (#), salvo las estructuras básicas anteriormente citadas. El conjunto de Instrucciones del Compilador de Idioma eWa tienen procedimientos que, nativamente en Español, permiten realizar las distintas tareas de creación de estructuras: los tipos de datos (objetos), y los métodos (funciones). Además, permite reservar y liberar de recursos de bajo nivel. Los lenguajes traducen estos procedimientos a otras lenguas, o completan este conjunto, o lo bloquean, pero siempre sin alterar eliminar la funcionalidad nativa.
Selección del Compilador
Es un procedimientos estándar que indica el compilador que se va a utilizar para el Idioma eWa. Para el caso particular del Compilador eWa simplementa hay que nombrarlo con ewa.
#compilador <<nombre del compilador>> #compilador ewa
Selección del Lenguaje
Es un procedimientos que indica que lenguaje se va a utilizar para el Idioma eWa. Para el caso particular de los LeWaS se usa uno de los tres lenguajes: el Lenguaje eWamblador, el Lenguaje eWa, o el Lenguaje eWa++. El hecho de que los LeWaS herenden del inmediatamente anterior permite que todas las estructuras generadas, por ejemplo, el Lenguaje eWamblador sean aprovechadas por los otros dos.
#lenguaje <<nombre del lenguaje>> #lenguaje ewamblador
Crear estructuras
Es un procedimientos que recibe un objeto #UNDEFINED que se va a convertir en una estructura. A partir de ese momento, para el compilador, ese objeto del Idioma eWa pasará a ser una estructura.
Cabe recordar que las estructuras tienen, como todos los identificadores de casi cualquier lenguaje, una restricción importante: no se puede comenzar con números ni contener símbolos u operadores de Idioma. Como es sensitivo (distingue mayúsculas y minúsculas), dentro del Proyecto eWa se recomienda un buen hábito: el uso de la primera letra en mayúscula.
#estructura <<nombre de la nueva estructura>> #estructura Bool
También tiene el procedimientos inverso, es decir, el que da de baja una estructura generada por el compilador previamente.
#destruye <<nombre de la estructura a destruir>> #destruye Bool
Definir reemplazos
Es un procedimientos que se comunica con el compilador para definir valores a ciertas cadenas. Recibe dos parámetros que son cadenas literales (entrecomilladas); siendo la primera para indicar qué cadena del código se eliminará.
Se pueden concatenar cadenas con mas (+) en la primera cadena y utilizar números en la segunda para referirse a las porciones de la primera, así como caracteres comodín (expresiones regulares) para detectar procedimientos más complejas.
Este procedimientos, como todos, es multi-paso: cuando se termina el primer paso para realizar los cambios que puedan hacerse, se vuelve a pasar y solo se parará cuando durante el último paso no se realice ningún cambio. OJO: puede generar un bucle infinito; aunque los compiladores suelen delimitar el número de pasos a realizar o ajustarlos.
#define <<valor buscado>> <<valor escrito>> #define "reg[\"Z\"]=0;" "0w3;"
Tiene también un procedimientos inverso para eliminar esos remplazos a partir de que se escriben. El compilador se puede configurar para que dé aviso en caso de que no exista una regla de reemplazo con el <<valor buscado>> indicado.
#undefine <<valor ya no buscado>> #undefine "reg[\"Z\"]=0;"
Crear campos de Estructuras
Es un procedimientos que recibe varios objetos básicos:
- El primero es la estructura devuelta que será, a vista del Idioma eWa, una estructura indefinida (#UNDEFINED), inclusive la estructura vacía (#VOID).
- Seguidamente pueden aparecer una serie de estructuras:
- El nombre de una estructura (o la estructura por defecto (#), o una estructura indefinida (#UNDEFINED) que haya reconocido previamente el compilador habiéndose llamado a #estructura <<nombre de esa estructura>>) que se va a convertir en una estructura.
- Un nuevo campo para esa estructura que vuelve a ser una estructura indefinida (#UNDEFINED) que puede pulular de forma segmentada.
- Una serie de pares #UNDEFINED:#OBJECT o argumentos (#ARGUMENT) que podrá ser vacía
- Para finalizar, una función (#FUNCTION).
Este procedimiento permite la introducción de operadores del Idioma eWa de forma intercalada, in campo aperto, a partir del nombre de la estructura. También permite la des-argumentación, es decir, crear casos concretos de campos, y fijar la estructura de las estructuras (#OBJECT) recibidos. Las posibilidades de este procedimientos son casi infinitas.
#crea <<estructura>> <<estructura devuelta>> <<nuevo campo>> <<argumentos>> <<función>>
#crea #VOID if condicion:BOOL funcion:#FUNCTION {
witQ=funcion.ini; // copiar el WIT de comienzo de la funcion:#FUNCTION en witQ
witR=this.vuelve;// copiar en witR el WIT de regreso de esta this:#FUNCTION
funcion.vuelve=this.vuelve; // poner en el WIT de regreso de funcion#FUNCTION el de
// regreso de this:#FUNCTION
reg["Z"]=0;
reg["U"]=1;
reg["V"]=0;
reg["W"]=condicion.bit;
}
#crea #VOID if condicion:BOOL funcionSI:#FUNCTION else funcionNO:#FUNCTION {
if condicion funcionSI;
if condicion==false funcionNO;
}
