Es recomendable tener conocimiento del conjunto de instrucciones para procesadores de los modelos 386 (ver archivo Cpu386.html en Enlaces) ya que hará más fácil la compresión del tema y toda la documentación.
Un "Byte" puede ser un entero entre 0 y 255 incluidos, que también puede representar uno de los 256 carácteres de la tabla ASCII. Como ejemplo, se puede decir que casi todos los carácteres de esta documentación tienen su propio código decimal ASCII correspondiente, el de la letra "a" es 97. Un "Byte" puede expresarse en el sistema numérico binario, por lo cual bastan 8 Bits (Digitos binarios) para representar cualquier Byte (256 = 2 ^ 8 =2 x 2 x 2 x 2 x 2 x 2 x 2 x 2).
Un "Word" (palabra) se representa con dos "Bytes" o 16 Bits, es un entero entre 0 y 65535 incluidos.
Un "Dword" (palabra doble) se representa con cuatro "Bytes" o 32 Bits, es un entero entre 0 y 4294967295 incluidos. Las variables de TEIMSI tipo entero tienen este tamaño de 4 Bytes también conocido como entero largo (large integer en inglés). Un entero largo en TEIMSI se representa con un valor entre -2147483648 y 2147483647 (entero largo con signo), la notación hexadecimal de -2147483648 es "80000000h" y la de 2147483647 es "7FFFFFFFh", la de -1 es "FFFFFFFFh" y así sucesivamente. Con dicha representación de los enteros negativos conocida como BCD (decimal decodificado en binario) se mantiene la coherencia de resultados por la suma y resta con las instrucciones del CPU llamadas "add" y "sub" (para la multiplicación y división no es el caso, se utilizan "imul" y "idiv" para enteros con signo y "mul" y "div" para enteros sin signo).
Se puede ver que cuando el Bit más alto es uno, el entero (con signo) es negativo. Si la suma de dos números da mayor o igual que 2 ^ 32, los Bits en posición 32 o superior no son utilizados, Por ejemplo: -4 + 7 = 3, en notación hexadecimal eso es FFFFFFFCh + 00000007h = 100000003h pero al utilizar sólo lo 4 "Bytes" resulta ser 00000003h o bien igual a 3.
En TEIMSI, la representación mediante la función "alert" de enteros largos se considera que pueden ser negativos (que tienen signo) para evitar la representación del signo puede hacerse una maniobra de conversión interna como en el siguiente ejemplo:
; //#################################### var num=-123 // Entero negativo, la representación en hexadecimal es FFFFFF85h que en sistema numérico decimal es 4294967173. alert(num) // Muestra el entero -123 _direct{ push dword 0 ; Guardar en la pila local el un valor entero de 8 bytes ("Qword") o doble "Dword", cargarlo al coprocesador y guardarlo como un número decimal de precisión doble. push dword [num+regvar.vofix] fild qword [ss:esp] fstp qword [num+regvar.vofix] mov [num+regvar.vtype], sysdbl ; Cambiar el tipo de datos de entero a doble, ningún otro cambio es necesario en la estructura "regvar" de esta variable llamada "num" es necesario porque no se trata ni de una cadena ni de una matriz. pop eax eax ; (para sumar 8 a "esp") } alert(num) // Muestra el número de coma flotante "4294967173" ; //####################################
Con las instrucciónes "movsx" y "movzx" del CPU, es posible transferir el valor de un registro o memoria de menor tamaño a uno de mayor tamaño. La instrucción "movsx" copia los valores con signo y "movzx" sólo copia la parte baja en el registro destino dejando la parte alta con ceros como lo muestra el siguiente ejemplo:
; //#################################### var num1=0, num2=0 _direct{ mov bl, 131 ; La expresión en hexadecimal de 131 es 83h, y en binario es 10000011b. Si el Byte tiene signo, entonces vale -125 = 131 - 256. movsx eax, bl movzx ecx, bl mov [num1+reg.vo], eax mov [num2+reg.vo], ecx } // Al ser el bit más alto (bit 7) del byte 131 igual a 1, el número es negativo. alert("El Byte 131 con signo pasado a Dword vale: "+num1) alert("El Byte 131 sin signo pasado a Dword vale: "+num2) ; //####################################
Es posible cargar y guardar los enteros largos con signo desde el procesador matemático, como en el siguiente ejemplo.
; //#################################### var num1=154, num2=-425, result=0.0 // Para que el compilador de TEIMSI distinga entre un entero y un número de coma // flotante, hay que poner una coma "." su definición con "var". _direct{ fild [num1+reg.vo] fidiv [num2+reg.vo] fstp qword [result+reg.vo] ; Pone "num1" dividido "num2" en "result" fild [num1+reg.vo] ; Pone (num1*num1 + num2*num2) en "num1". fld st fmulp st1, st fild [num2+reg.vo] fld st fmulp st1, st faddp st1, st fistp dword [num1+reg.vo] } alert("154/-425 = " + result) alert("154*154 + 425*425 = "+num1) ; //####################################
Ver también los capítulos "Variables de TEIMSI" y "Ejemplos básicos de uso de TEIMSI"