Indice de contenido -> Capítulo 4 - Descripción de instrucciones de compilación

Instrucciones de compilación TEIMSI.

1)- Declarar variables

2)- Variables predefinidas

3)- @assumevar

4)- Constantes de sendas

5)- Instrucciones de flujo.

6)- Declaración de procedimiento.

7)- Puntero función/variable pública/etiqueta

8)- Inclusión de archivos y Carpetas. Constantes predefinidas de sendas

9)- Declaración de constantes locales en TEIMSI.

10)- Declaración de constantes extendidas a ensamblador.

11)- @eof_file

12)- @import:

13)- bloques de datos

14)- bloques de código ensamblador

15)- _savelocal

16)- Instrucciones para compilación condicional

17)- Creación e Inclusión de archivos TCO.

Para declarar variables, se utiliza "var variable=valor" dónde "variable" es el nombre de la variable. El nombre debe comenzar con una letra o "." (punto) o caracter "_" (guión bajo), los caracteres posteriores pueden tener números. El valor es opcional, puede omitirse el "=valor" y la variable toma el valor "undefined". Dentro de algunos de los tipos de datos que pueden tener las variables: Entero de 32 bits, Doble (número decimal de precisión doble), cadena, booleano, matriz, "undefined" y otros.

Ejemplos:

var cantidad=1832 // Entero.

var numero=32.44 // Doble.

var cadena="Hola!" // Cadena.

var matriz=array(1,3,5,7) // Matriz de cuatro ítems.

var matriz2=array(234) // Matriz de 234 ítems, todos de valor -1 (predeterminado). Si se especifíca solamente un entero, será el tamaño de la matriz.

var verdad=true // Booleano

var resultado=(8*7+3) // Entero, es el resultado de evaluar una expresión.

var str1=ucase("agua"), str2=lcase("Sol") // Dos variables tipo cadena declaradas en la misma línea que toman el valor devuelto por ciertas funciones

// ("ucase" pasa una cadena a mayúscula y "lcase" a minúscula).

A continuación se muestran malos ejemplos de uso de "var":

		var 8cadena="Hola!"
	
		var eax=3212
	
		//	"eax" es una palabra reservada para el código ensamblador que leerá "FASM", entre otras se encuentran:  push, pop, mov, mul, div, sub, add, stc, ret, 
		//	proc, endp, struct, ends, local, locals, endl y todas las utilizadas por compilador de ensamblador.

Las variables predefinidas se utilizan por ser de uso cotidiano, por ejemplo "_nl" es la variable retorno de línea (la suma de caracteres de código Ascii 13 y 10: chr(13)+chr(10)), "_c0" es chr(0). Ver la siguiente lista:

Ejemplos:

		alert("Fila 1"+_nl+"Fila 2")
	
		alert("Se eligió SI = " + (alert_ex("Hola! elegir \"si\" o \"no\":","Ejemplo",_mb_yesno+_mb_iconexclamation)==_mbret_yes));

La declaración "@assumevar" permite especificar variables que no se han declarado con "var" pero cuyo contenido se ha declarado en la sección de datos inicializados. Ello permite agregar variables TEIMSI cuyo valor se importa desde otro lugar. Se utiliza la instrucción "place_idata" para poner variables en la sección de datos del ensamblador (ver también bloques de datos).

Ejemplo:

	place_idata{
			_cadena_1_cont		db "Hol",97,0

		cadena1 dd 0, 3, _cadena_1_cont, 5	;	Una variable en TEIMSI se expresa con 16 bytes en la sección de datos, por más información ver Introducción al uso de FASM con TEIMSI

								;	El primer dword entero "0" indica el modo de la variable "_mod_stat", el segundo dword indica el tipo de datos "_sysstr", el tercero la posición de inicio de la cadena estática, y el cuarto la longitud.
								;	Si la cadena tuviera modo dinámico ("_mod_dina") el tercer dword tendría el manejador (entero dword) de la cadena.

		entero1 dd 0, 1, 111, 0			;	El primer dword entero "0" indica el modo de la variable "_mod_stat", el segundo el tipo de datos "_syslong", el tercero es el entero, y cuarto debe ser cero.

		doble1 dd 0, 2				;	El primer dword entero "0" indica el modo de la variable "_mod_stat", el segundo el tipo de datos "_sysdbl", el tercero es un "qword" con el valor.
			 dq 3.51
	}

	@assumevar:cadena1,entero1,doble1

		alert(cadena1)
		alert(entero1)
		alert(doble1)

ver Inclusión de archivos y Carpetas. Constantes predefinidas de sendas

Se describirá el uso de las siguientes instrucciones para TEIMSI:

1)- "if"

2)- "for"

3)- "while"

4)- "<etiqueta>:"

5)- "jmp"

6)- "jmpcase"

7)- "sys.quit()"

Evalúa si una condición es verdadera, si eso ocurre ejecuta el bloque comprendido entre llaves "{" y "}". Puede indicarse un "}else{" en lugar de la llave de cierre "}" para ejecutar código si no se satisface "condición", también puede indicarse un "}else if(condicion2){" si quiere evaluarse una segunda condición y ejecutarse el bloque TEIMSI que comprende en caso de no cumplirse la primera condición.

Ejemplo:

			var numero=8
		
			if(numero==8){
				alert("El número es 8")
		
			}else if(numero==9){
				alert("El número es 9")
		
			}else{
				alert("El número no es ni 8 ni 9")
		
			}

La instrucción "for" ejecuta en forma repetida las instrucciones que se encuentran en el bloque comprendido entre llaves "{" y "}". La expresión "condición_de_hacer_el_ciclo" se evalúa para saber si permanecer del bucle "for" o salir del mismo. Las "declaraciones" son de la forma var <nombre>=valor separadas por "," comas; se utilizan para inicializar variables utilizadas en el bucle "for", más especifícamente la utilizada como índice variante. La ecuación y expresión "instrucción_variación" se ejecuta cada vez que se ejecuta el código en el bloque de código TEIMSI de "for".

La instrucción "break" puede utilizarse para salir del ciclo "for" en cualquier momento deseado.

Ejemplo 1:

			for(var t=0;t<7;t++){

				alert("t = "+t)

				if(t==4){break}
			}

Ejemplo 2:

			for(var k=-5,u=0; k<6 ; k++,u++ ){
	
				alert("k = "+k+_nl+"u = "+u)
			}

La instrucción "while" ejecuta en forma repetida las instrucciones que se encuentran en el bloque comprendido entre llaves "{" y "}". La expresión "condición" se evalúa para saber si permanecer del bucle "while" o salir del mismo.

La instrucción "break" puede utilizarse para salir del ciclo "while" en cualquier momento deseado.

		Ejemplo:
			var t=0
			while(t<7){
				alert("t = "+t)
				if(t==4){break}
				t++
			}

Declara una etiqueta, un punto en el programa que será utilizado para instrucciones de salto tanto en TEIMSI como en ensamblador. Para TEIMSI, las instrucciones de salto son "jmp(etiqueta)" y "jmpcase(<condición>,etiqueta)". Para ensamblador existen varias instrucciones posibles como "jmp", "call", también referencias a dicha ubicación en la sección de código y ciertas macroinstrucciones.

La instrucción "jmp(etiqueta)" cambia el flujo de ejecución de código TEIMSI a la ubicación de la etiqueta.

Ejemplo:

		var k=0
		ciclo_de_k:
			alert("k = "+k)

			if(k==5){
				jmp(ciclo_de_kfin)
			}
			k++
		jmp(ciclo_de_k)

		ciclo_de_kfin:

La instrucción "jmpcase(condición, etiqueta)" evalúa la expresión "condición" si es verdadera, en cuyo caso cambia el flujo de ejecución de código TEIMSI a la ubicación de la etiqueta.

Ejemplo:

		var k=0
		ciclo_de_k:
			alert("k = "+k)
			k++
		jmpcase(k<=5,ciclo_de_k)

La instrucción "sys.quit()", realiza la terminación la ejecución del programa .Exe actualmente ejecutándose.

Ejemplo:

			alert("hola!")
	
			sys.quit()
	
			alert("Esto no se muestra!")

Las declaraciones de procedimientos/funciones de TEIMSI se realizan con la instrucción "function". La instrucción "return" sale de la función, opcionalmente recibe el valor que devuelve la función.

Sintaxis: "function nombre(parámetros){bloque}"

Ejemplo de un programa:

		var num=ecuation1(44)

		alert("24*91+44*13 = " + num)

		function ecuation1(parametro1){
			return (24*91+parametro1*13)
		}

Es posible cargar en un entero, el puntero interno a la sección de datos o código que corresponda una determinada variable pública o etiqueta o ubicación de procedimiento.

Dicho valor entero tiene usos avanzados y algunos determinados en funciones predeterminadas específicas de TEIMSI como reghotkey y regtimer.

Ejemplo 1:

		var numero=932
		numero=@numero
	
		function ecuation1(parametro1){
			etiqueta1:
			return (24*91+parametro1*13)
		}
	
		alert(numero)		//	Muestra un número que nada tiene que ver con 932. (posición en la sección de datos de esta variable).
		alert(@ecuation1)	//	Muestra la posición en la sección de código de ese procedimiento.
		alert(@etiqueta1)	//	Muestra la posición en la sección de código de esa etiqueta.

Ejemplo 2 (avanzado):

		var numero=-932
		var lugar_numero=@numero
		_direct{
			mov esi, [lugar_numero+reg.vo]	;	Carga en "esi" la posición de la variable "numero" desde el valor entero de la variable "lugar_numero".
			neg dword [esi+reg.vo]		;	Cambia el signo del valor entero en la variable "numero".
		}
		alert(numero)		//	Muestra 932 en lugar de -932.

En esta sección se explica como se incluyen archivos TEIMSI, es necesario saber que el archivo cabecera (principal) de un cierto proyecto TEIMSI (que tendrá preferiblemente la extensión TSI) es donde se permite la inclusión de otros archivos de código TEIMSI (que preferiblemente a modo de convención tendrían extensión THP). Para la versión 0.95 del Editor de TEIMSI, la inclusión de archivos TEIMSI desde archivos ya incluidos no está habilitada.

Ejemplo:

		// La siguiente instrucción incluye el archivo "text2clipboard.tco" que se encuentra en la carpeta "tco_inc" del Editor de TEIMSI.

		include_tco(tco_inc\text2clipboard.tco)

La carpeta activa durante la compilación es la carpeta del programa Editor de TEIMSI, por lo que para hacer referencia a archivos incluidos en un proyecto deben utilizarse las siguientes constantes que se reemplazan en tiempo de compilación por una senda real (que no incluye al caracter "\" o "/" al final de la misma).

Entonces, se muestra algunos ejemplos:

		// La siguiente instrucción incluye el archivo "funciones2.thp" que se encuentra en la misma carpeta del archivo .tsi del proyecto.
	
		includec(º_scriptdir_\funciones2.thp)
	
	
		// La siguiente instrucción incluye el archivo "report_timelong.tco" que se encuentra en la carpeta del Editor de TEIMSI.
	
		include_tco(tco_inc\report_timelong.tco)
	
	
		// La siguiente instrucción realiza lo mismo que la anterior porque la senda actual es la que contiene la constante "º_editordir_".
	
		include_tco(º_editordir_\tco_inc\report_timelong.tco)
	
	
		// La siguiente instrucción (ubicada en un bloque "_direct") pone la senda a la inclusión del archivo a utilizarse por FASM en tiempo de ensamblaje.
	
		_direct{
			include "º_scriptdir_\fnasm1.asm"
		}

Esto funciona porque dichas constantes (y las que se declaran de la forma ºnombre_constante===valor en TEIMSI") se reemplazan antes de la compilación por sus valores correspondientes. En efecto, es posible darle otras aplicaciones como lo hace la siguiente instrucción:

	alert("Senda al proyecto original compilado = º_scriptdir_")

Ver también Declaración de constantes

Declaración de constantes

Nuestro compilador el Editor de TEIMSI, permite definir cadenas constantes que se ha deseado predefinir. Dichas cadenas constantes se reemplazan antes de la compilación (así como las constantes de sendas predefinidas, ver Inclusión de archivos y Carpetas. Constantes predefinidas de sendas) y pueden expresar también instrucciones en TEIMSI. Para declararlas el nombre de la variable debe antecederse de un caracter "º" numerativo. Como en los siguientes ejemplos:

	ºlacosa==="Hola mundo!"+_nl+"Hello world!"
	ºfun1===alert

	ºfun1(ºlacosa)

Este tipo de constantes, se reemplazan antes de la compilación pero su contenido debe respetar el formato aceptado por la instrucción "equ" utilizada en ensamblador. Esto ocurre porque el Compilador escribe en la sección de datos una asignación de valor a una constante.

Al declarar en el script de TEIMSI:

		ªcadena==="Hola mundo!"
		ªnumero===8000

En la sección de datos de ensamblador aparecerá:

ªcadena equ "Hola mundo!"

ªnumero equ 8000

De esa forma es posible utilizar constantes visibles a los dos compiladores: TEIMSI y Ensamblador.

La declaración "@eof_file" indica el final del módulo raíz y se utiliza así como está (sin espacios a la izquierda y sin nada a la derecha).

Para el compilador ésta línea, la línea existente que le sigue y su representación la cual se muestra indica el final del texto programado del proyecto. El compilador desprende el texto que no le incumbe para hacer el trabajo de crear el ejecutable, librería u objeto compilado TEIMSI de salida.

Esta instrucción es de gran utilidad para situar luego de ella textos programados, comentarios o bien texto que el programador desee incorporar en el archivo del proyecto.

Ejemplo de un programa TEIMSI:

	alert("Hola")

@eof_file

	>Este texto no será interpretado por el compilador<

La declaración "@import", permite agregar a la lista de funciones de las API's de Win * 2000/XP/7/... importadas determinada función/es. La lista de archivos .inc y nombres de librerías (base de datos) están definidas en la variable "fasminclist" en el archivo "teimsicfg.ini" dentro de la carpeta del Editor de TEIMSI, y describen las librerías a importar. La variable "fasm_api_dir" indica la senda a la carpeta que tiene los archivos .inc, por ejemplo: "c:\fasm\include\api".

El siguiente Programa de ejemplo muestra su uso:

	@import:Sleep,GetTickCount

	var tickc=0

	alert("Espera 1 segundo")
	_direct{
		invoke Sleep, 1000

		invoke GetTickCount
		mov [tickc+reg.vo], eax
	}
	alert("Listo."+_nl+"TickCount = "+tickc)

	// Nota: las funciones Sleep y GetTickCount están en la lista de funciones importadas de forma predeterminada (desde Kernel32.dll), dicha lista 
	//	se puede ver en el archivo "import_dll.def" de la carpeta "internal" dentro de la carpeta "engine" en el directorio del Editor de TEIMSI.

Un programa o librería a ensamblarse se compone (en forma predeterminada) de distintas secciones en su estructura interna: la sección de código, la de datos inicializados, la de datos no inicializados, la de recursos (que puede tener datos de iconos, cadenas binarias desde archivos, estructuras de diálogos, información específica de objeto Exe o Dll como "Copyright", Etc.) y la de funciones importadas de APIs.

Para incorporar variables de datos a las secciones de datos de ensamblador, están las instrucciones A) "place_idata", B) "place_udata" y C) "place_rdata".

A) place_idata, ubica variables u otros datos de ensamblador en la sección de datos inicializados.

B) place_udata, ubica variables u otros datos de ensamblador en la sección de datos no inicializados.

C) place_rdata, ubica variables u otros datos de ensamblador en la sección de recursos.

Ejemplo de Programa:

		place_idata{
			str1asm db "Hello!",0
		}

		place_udata{
			str2asm db 10000 dup(?)		;	Búfer de 10 "Kilobytes" aproximadamente.
		}
		//	El archivo "icono.ico" debe estar en la carpeta del script .Tsi de ejemplo a compilarse. Se cargará como el icono del programa.

		place_rdata{
		section '.rsrc' resource data readable
			directory RT_ICON,icons,\
				RT_GROUP_ICON,group_icons,\
				RT_VERSION,versions
			resource icons,\
				2,LANG_NEUTRAL,icon_data
			resource group_icons,\
				500,LANG_NEUTRAL,main_icon
			resource versions,\
				1,LANG_NEUTRAL,version
			icon main_icon,icon_data,'º_scriptdir_\icono.ico'
			versioninfo version,VOS__WINDOWS32,VFT_APP,VFT2_UNKNOWN,LANG_SPANISH+SUBLANG_DEFAULT,0,\
				'FileDescription','Ejemplo',\
				'LegalCopyright','Copyright (c) 3057 ? Rights reserved.',\
				'FileVersion','1.0',\
				'ProductVersion','1.0',\
				'OriginalFilename','ejemplo.exe',\
				'Comments','Ejemplo TEIMSI.'
		}

Se utiliza la instrucción "_direct" para situar datos o instrucciones/procedimientos en la sección de código de ensamblador del archivo .exe o .dll. Al encontrar el flujo de ejecución del programa un bloque "_direct" las instrucciones allí son ejecutadas, por ello si en dicho bloque se declaran procedimientos; estos deben ser antecedidos por una instrucción de salto (jmp) hacia una etiqueta que esté luego de dichos procedimientos declarados. La macro instrucción "s_quit" equivale a la instrucción "sys.quit()" de TEIMSI (ver Instrucciones de flujo.) y puede ser útil si se quiere expresar (en código ensamblador) que allí termina el flujo del programa. La macro "s_quit" hace solamente un salto al código de terminación del programa y es lo mismo que se ejecuta luego al final terminado todo el código TEIMSI de un Script principal de un proyecto.

Ejemplo de uso de "_direct":

		place_idata{
			str1asm db "Este mensaje se muestra desde ensamblador, hola!",0
		}
		place_udata{
			str1pointer dd ?
		}

		_direct{

			mov eax, (str1asm)
			mov [str1pointer], eax

			call2 funcasm_usuario, (str1pointer)		;	La macro "call2" hace lo mismo que "invoke" pero se utiliza para funciones que no son importadas.

			jmp eofdirect1

				proc funcasm_usuario, punteroapuntero	;	Procedimiento de ejemplo en ensamblador.
				locals
					asm_num dd ?
				endl
					mov [asm_num], 0			;	Variable local de ejemplo.

					mov esi, [punteroapuntero]
					mov esi, [esi]

					invoke MessageBox,0, esi, esi, [asm_num]
				ret
				endp	;	funcasm_usuario

			eofdirect1:
		}

Los procedimientos en TEIMSI, se escriben también como procedimientos en ensamblador. Eso es, la declaración "function" crea una declaración "proc" y "endp" en la sección de código con el mismo nombre de la función, es posible incorporar variables locales para el procedimiento en ensamblador desde TEIMSI. La declaración "_savelocal" se utiliza para ello, recibe la lista de variables locales que tienen separadas por "," (comas), Cada variable incluye a su derecha el tipo de dato ("dd" para enteros de 32bits, "db" para "bytes", Etc.).

El siguiente programa ejemplo, muestra el entero 503 y la senda al directorio actual desde ensamblador:

		@import:GetCurrentDirectory

		place_idata{
			titulo db "Directorio actual:",0
		}

		function tarea_n1(){
		_savelocal: registro dd ?, espacio db 256 dup(?)
			_direct{
				mov [registro], 504
				dec [registro]
		
				MOSTRAR2 [registro]					;	La macro predefinida "MOSTRAR2" muestra un entero/registro de 32bits.
	
				lea eax, [espacio]
				invoke GetCurrentDirectory, 256, eax		;	Es posible guardar una cadena de datos en la pila, porque el registro "ss" es igual
											;	 al registro "ds" del procesador en forma predeterminada (a menos que se altere manualmente).
				lea esi, [espacio]
				invoke MessageBox,0, esi, (titulo), 0
			}
		}
		tarea_n1()

La compilación condicional de código TEIMSI se hace con tres instrucciones las cuales deben declararse sin espacios ni otras instrucciones a su izquierda:

El siguiente programa ejemplo que muestra su uso:

@cc_set(LANGUAGE, english)
@cc_set(SUBJECT, work)

@cc_if(LANGUAGE==english)

	alert("El lenguaje es Inglés.")

	includec(º_scriptdir_\english.thp)		//		Incluir un archivo según la variable de compilación condicional "LANGUAGE".

@cc_endif

@cc_if(LANGUAGE!=english)

	alert("El lenguaje no es Inglés.")

	includec(º_scriptdir_\nonenglish.thp)

@cc_endif


@cc_if(CONTENT==undefined)

@cc_set(CONTENT, Text1)

@cc_endif


@cc_if(SUBJECT==work)

alert("Tema: Trabajo")

@cc_endif


@cc_if(SUBJECT!=work)

alert("Tema: No es trabajo")

@cc_endif

El uso de archivos de tipo .tco (objeto compilado de TEIMSI), es una característica de este Compilador que permite guardar código de instrucciones en el modulo raíz o en procedimientos, datos, referencias a funciones importadas y todo elemento que puede expresarse en un Script de TEIMSI. Una vez incluido el archivo Tco con la instrucción "include_tco" la sección de código que tenga será incluida como si fuera un archivo incluido con la instrucción "includec", el flujo de ejecución puede llegarle a menos que se cambie con una instrucción de salto "jmp" hacia una etiqueta que esté luego del archivo o por no llegarle el flujo de ejecución por terminar antes con una instrucción "sys.quit()"en el Script de TEIMSI.

Las ventajas principales de utilizar los archivo tco, son:

1- El tiempo de compilación de un proyecto puede reducirse drásticamente.

2- Permite organizar y ordenar grandes proyectos de aplicaciones TEIMSI.

3- Tienen un formato de texto que es posible visualizar (y cambiar si se tiene cautela), conteniendo además las secciones de datos incluidas y el código TEIMSI

compilado en macroinstrucciones de ensamblador.

Para crear un archivo TCO, es necesario incluir la instrucción "@tco_filename:<nombre_archivo>". Dónde <nombre_archivo> es el nombre del archivo con extensión .tco que se creará a partir del Script actual. Para incluir un archivo Tco se utiliza la instrucción "include_tco(<senda_de_archivo_tco>)".

Al crear un .tco, es posible especificar que variables públicas serán requeridas. Para ello está la instrucción "@tco_reqrootvar:<variables>" donde <variables> es una lista de nombres de variables públicas (definidas en el módulo raíz) separadas por una coma (","). También se puede especificar que funciones TEIMSI requieren haberse definido antes de incluir el archivo .tco, para ello está la instrucción "@tco_reqfn:<funciones>" donde <funciones> es una lista de nombres de funciones previamente declaradas (o importadas desde otro archivo Tco), cada nombre de función debe estar seguido de un caracter ":" y un número entero que dice cuantos parámetros recibe dicha función; por ejemplo:

// Las funciones tareax y tareaj utilizadas en el archivo Tco, reciben 3 y 2 parámetros respectivamente:

@tco_reqfn:tareax:3,tareaj:2

También están las instrucciones "@tco_rem" y "@tco_eofrem", utilizadas para guardar comentarios e información de la descripción sobre el contenido del archivo. Por ejemplo:

@tco_rem:

<BLoque de comentarios aquí>.

<...>

<...>

<...>

@tco_eofrem

El siguiente ejemplo muestra las instrucciones descritas.

Ejemplo 1, compilar el siguiente Script para crear el archivo .tco:

	; //#####################################

		@tco_filename:miobjeto.tco

		@tco_rem:
			> Este archivo tco es un ejemplo que contiene la función "calculo(num)" que calcula un el cuadrado de un número por un coeficiente.
		@tco_eofrem


		@tco_reqrootvar:coef_publico

		@tco_reqfn:cuadrado:1


			function calculo(num){
				return (cuadrado(num)*coef_publico)
			}
			alert("Este mensaje está siendo llamado desde el archivo \"miobjeto.tco\"!")
	; //#####################################

Ejemplo 2, compilar el siguiente Script para mostrar la inclusión y uso de un .tco

	; //#####################################




		var coef_publico=0.01

		function cuadrado(num){
			return (num*num)
		}

		include_tco(º_scriptdir_\miobjeto.tco)		// Incluye el archivo "miobjeto.tco" previamente compilado.

		alert("0.8*0.8="+calculo(8))

	; //#####################################