Lenguaje eWamblador

El eWamblador es el lenguaje más básico de programación en la RedeWa, a excepción de los escasamente abstractos lenguajes de Binarios (0 y 1) y de Mnemónicos (0, 1, 2..., C, D, E, y F) y, sin duda, el menos abstracto de los entendibles por Humanos.

Instrucciones heradadas del eWamblador

Como el eWamblador está basado en el lenguaje de Mnemónicos, las 16 instrucciones de toda la Arquitectura eWa las herada y pueden ser usadas (y se usan para programar las mejores optimizaciones) simplemente escribiéndolas en línea:

7250B	//7250B
7210B	//1B
3250B	//3B
 654A	//64A
3654D	//3D
3614D	//2D
F	//F

En ese código se ha puesto el código completo en la columna de la izquierda, y después de los // el código optimizado. Como se podrá leer más abajo todo ese código no hace nada en especial.

Instrucciones propias del eWamblador

Pero como puede ser muy tedioso escribir (, repetir) e incluso entender programas escritos de esa forma, se han creado las instrucciones propias del eWamblador, que sin ser tan abstractas y simples como las del resto de lenguajes de ensamblador (con instrucciones mov, push, etc...) recuerdan un poco más a la sencillez de la Arquitectura eWa y a los programas de orientación a objetos como el C.

De esta forma, el código anterior se puede escribir como:

witQ         //selecciona el puntero Q
wit = 0      //el puntero Q a todo 0s
wit2         //pone a witQ2
k = 1        //pone k = 1
witx[7] = k  //pone witQ2[7] = 1
witx[5] = k  //pone witQ2[5] = 1
[witx] = k   //pone [witQ] = 1

En ese código se ha puesto el código resumido en la columna de la izquierda, y después de los // el código completo. Como ahora igual ya sí se puede entender, lo que hace este código es poner el puntero Q apuntando a la posición 0xA000 (1010000000000000) que, paradógicamente..., es la dirección de mapeo del controlador estándar de pantalla. Esto quiere decir, que si le añadimos un wit = 1, escribiremos un 1 en el primer bit del controlador de la pantalla; y, un wit+10 = 0 para escribir en el bit 11 del controlador un 0... más adelante, leyendo la información sobre la controladora de pantalla, podréis saber para qué sirve eso.

Lo primero de todo es ¿qué es k y qué es wit? Aunque en la Arquitectura eWa se ve con más calma y dedicación podríamos decir de estas dos variables son:

K

La k es un registro real de un solo bit (o un 0 o un 1) en el que podemos tener acceso en cualquier tiempo de ejecución de un programa. Es el registro de intercambio de información entre la ABU y la MMU y está localizado en la CPU.

Wit

Significa puntero y, aunque apunta siempre a un puntero real parcial o completo, se suele conocer más bien como un puntero virual de tantos bits (w-bits -> w-b-its -> wits) como sea el espacio de direcciones de la MMU, ya que ese es el tamaño de todos los punteros. Para el eWamblador es la parte más básica y su división se realiza en páginas de 8 bits (1 octal) cada una, o en (para MMUs de espacio de direcciones de 64 bits, las más usadas) 64 componentes absolutas numeradas de la 0 a la 63. A su vez, cada página se divide en 8 componentes relativas numerados de la 0 a la 7, que siempre corresponden con los registros reales 0x0 al 0x7 de la CPU.

Aunque esos registros son reales, normalmente el eWamblador utiliza unos punteros virtuales para agilizar el proceso de ejecución y las optimizaciones; es por eso por lo que los punteros, los wits, se entienden como virtuales.

Instrucciones del eWamblador

Pero, en el código anterio, ¿qué es cada una de esas instrucciones? Las instrucciones del eWamblador se detallan a continuación:

Las selecciones

Wits

• De punteros

wit; // selecciona el puntero Actual
witQ; // selecciona puntero Q
witR; // selecciona puntero R
witS; // selecciona puntero S
witT; // selecciona puntero T

• De página

witx; // selecciona la página actual del puntero Actual
wit0; // selecciona la página 0 del puntero Actual
wit1; // selecciona la página 1 del puntero Actual
wit2; // selecciona la página 2 del puntero Actual
wit3; // selecciona la página 3 del puntero Actual
wit4; // selecciona la página 4 del puntero Actual
wit5; // selecciona la página 5 del puntero Actual
wit6; // selecciona la página 6 del puntero Actual
wit7; // selecciona la página 7 del puntero Actual

Valdría lo mismo cambiando wit por cualquiera de las wits de punteros, por ejemplo witT7.

• De componente

witx[0]; // selecciona la componente 0 del wit actual del puntero Actual
witx[1]; // selecciona la componente 1 del wit actual del puntero Actual
witx[2]; // selecciona la componente 2 del wit actual del puntero Actual
witx[3]; // selecciona la componente 3 del wit actual del puntero Actual
witx[4]; // selecciona la componente 4 del wit actual del puntero Actual
witx[5]; // selecciona la componente 5 del wit actual del puntero Actual
witx[6]; // selecciona la componente 6 del wit actual del puntero Actual
witx[7]; // selecciona la componente 7 del wit actual del puntero Actual

Valdría lo mismo cambiando witx por cualquiera de los wits de página, por ejemplo witT7[3].

• De componente absoluta

wit[0]; // selecciona la componente 0 del puntero Actual
wit[1]; // selecciona la componente 1 del puntero Actual
...	    // Entre corchetes: 2,3,...,9,10,11,12,...,61,62
wit[63]; // selecciona la componente 63 del puntero Actual

Valdría lo mismo cambiando wit por cualquiera de los wits de punteros, por ejemplo witT[33].

MEMORIA

[wit]; // selecciona el valor booleano que apunta el wit

---

Las operaciones/expresiones

Wits

• Suma de wit

wit + witS; // selecciona el valor resultante de la suma del valor del puntero Actual' más el puntero witS
wit + valor; // selecciona el valor resultante de la suma del valor del puntero Actual más el valor dado

• Diferencia de wits

witS - witR; // selecciona el valor resultante de la resta  del valor del puntero S menos el puntero R
witS - valor; // selecciona el valor resultante de la resta del valor del puntero S menos el valor dado

• Producto de wits

witS * witR; // selecciona el valor resultante de la multiplicación del valor del puntero S por el puntero R
witS * valor; // selecciona el valor resultante de la multiplicación del valor del puntero S por el valor dado

• Cociente de wits

witS / wit; // selecciona el valor resultante de la resta  del valor del puntero S menos el puntero Actual
witR / valor; // selecciona el valor cociente de la división natural del valor del puntero R entre el valor dado

---

Las asignaciones

PUNTEROS

• Se pueden asignar copias de punteros completos, constantes o expresiones de 64 bits

witS = wit; // copia el puntero Actual en el puntero S
wit = witR; // copia el puntero R en el puntero Actual
witS = witQ; // copia el puntero Q en el puntero S

witR = 1x20A1; // pone el puntero R apuntando a la posición hexadecimal 1...1120A1
witR = 0b1011; // pone el puntero R apuntando a la posición binaria 0...0000001011
witR = 0.0134; // pone el puntero R apuntando a la posición decimal 0...0000000134

(Interamente hace siempre las conversiones a binario)

wit = witS+0b110; // pone el puntero Actual a la posición 0b110 veces siguiente a la que apunta el puntero S
wit = wit+0x120; // pone el puntero Actual a la posición 0x120 veces siguiente a la Actual
wit += 2; // similar a la anterior, pone el valor Actual apuntando a la dos veces siguiente posición de memoria
wit ++; // similar a las dos anteriores, pone el valor Actual apuntando a la siguiente posición de memoria

wit = witS-0b110; // pone el puntero Actual a la posición 0b110 veces siguiente a la que apunta el puntero S
wit = wit-0x120; // pone el puntero Actual a la posición 0x120 veces anterior a la Actual
wit -= 2; // similar a la anterior, pone el valor Actual apuntando a la dos veces anterior posición de memoria
wit --; // similar a las dos anteriores, pone el valor Actual apuntando a la anterior posición de memoria

En caso de que la expresión de 64 bits sea mayor, se seleccionarán los 64 bits de menor peso, es decir, los que estarían más a la derecha (11010100 pasaría a ser, de 5 bits, 10100).

En caso de que la expresión de 64 bits sea menor, se añadirán tantos bits de mayor peso, es decir, por la izquierda (010100 pasaría a ser, de 10 bits, 0000010100) como sea necesario.

• Se pueden asignar copias de páginas de punteros, constantes o expresiones 8 bits

wit

• Se pueden asignar copias de componentes de punteros, constantes o expresiones 1 bits

witx[]

• Se pueden asignar copias de componentes absolutas de punteros, constantes o expresiones 1 bit

wit[32] = 1; // pone la componente absoluta 32 del puntero Actual a 1;
wit[21] = witS[1]; // pone la componente absoluta 21 del puntero Actual al valor de la componente absuluta 1 de la
wit[21] = witS1[1]; // pone la componente absoluta 21 del puntero Actual al valor de la componente 1 de la página 1 del puntero S
witR[1] = 1-wit[1];

MEMORIA

• Se pueden asignara constrantes o expresiones de 1 bit

[wit] = 1;