Indice de contenido -> Capítulo 2 - Ejemplos básicos de uso de TEIMSI

Los siguientes ejemplos de "Scripts" pueden guardarse en archivos .TSI, editar los archivos con el editor de TEIMSI y compilarse en programas ".EXE". Los ejemplos se pueden ver situados dentro de dos renglones con líneas separadoras (que son cadenas de la forma "; //################# ... "), en el editor basta apretar el botón F9 para insertar una donde está el cursor en el texto.

Lista de ejemplos:

Ejemplo 1 (programa para transformar un archivo cualquiera en notación db decimal)

Ejemplo 2 (creador de Tabla de trigonometría)

Ejemplo 3 (numerador de líneas en archivos de texto)

Ejemplo 4 (Encriptación simétrica bit a bit)

Ejemplo 1

Programa para transformar un archivo cualquiera en notación db decimal


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

	//	En este ejemplo, el contenido del archivo de entrada se tiene que limitar al de caracteres legibles en textos. Los "Bytes" del archivo "archivo1.txt" serán
	//	 transformados a números de códigos ASCII en el rango de valores del 0 al 255, la lista generada se escribirá en el archivo "archivo2.txt".

	var archivo1="archivo1.txt"
	var archivo2="archivo2.txt"
	
	alert("Este programa cargará el archivo " + archivo1 + ", y guardará en el archivo " + archivo2 + ", el contenido del primero en una notación decimal de datos.")
	
	if(fileexists(archivo1)==false){
		alert("No se hallo el archivo  "+archivo1);
		sys.quit()
	}
	if(filesize(archivo1)>100000){
		alert("El archivo no se cargará porque tiene más de 100 kb de tamaño.");
		sys.quit()
	}
	
	var datos=binary_read(archivo1)
	if(datos==false){
		alert("Error al cargar "+archivo1);
		sys.quit()
	}
	var longitud=len(datos), puntero=0, bytes_por_renglon=50, texto_salida="";
	
	while(puntero<longitud){
	
		var cantidad_bytes=min((longitud-puntero),bytes_por_renglon)
		texto_salida+="	db "
		for(var c=0;c<cantidad_bytes;c++){
			if(c>0){
				texto_salida+=",";
			}
			texto_salida+=ascat(datos, puntero+c);
		}
		texto_salida+=_nl;		//	Observación: _nl = chr(13)+chr(10)
		puntero+=bytes_por_renglon
	}
	
	alert("Resultado de escritura en archivo2.txt = " + binary_write(archivo2, texto_salida)+_nl+"La tarea ha finalizado!.")
	
	
@eof_file


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

Volver arriba

Ejemplo 2

Creador de Tabla de trigonometría


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

	// Para este ejemplo se escribió la función "roundn" que redondea un número decimal. La tabla generada es escrita en un archivo y luego se llama al programa asociado
	//  para archivos ".txt" que es tipicamente el bloc de notas.

	alert_ex("Se creará una Tabla de trigonometría.", "Información", _mb_iconinformation)

	var cp_index=0, cp_index_max=90, cp_index_inc=1

	var list="Ángulo	Radianes	Seno	Coseno	Tangente"+_nl+_nl
	
	for(var cp_index=0;cp_index<=cp_index_max;cp_index+=cp_index_inc){

		var cp_rads = cp_index * _PI / 180;

		list+= roundn(cp_index,3)+_c9+ roundn(cp_rads,3)+_c9+roundn(sin(cp_rads),3)+_c9+roundn(cos(cp_rads),3)+_c9+roundn(tan(cp_rads),3)+_nl

	}

	binary_write("tabla.txt", list)

	openapp("tabla.txt")


	function roundn(rx_elnum, rx_lascif0){

		var rx_lascif=parseint(rx_lascif0)

		if(rx_lascif<=0){return ron(rx_elnum)}

		if(rx_lascif>14){return rx_elnum}

		var rx_tmp10ec=(10 ** rx_lascif)		//	halla 10 elevado a rx_lascif

		return ron(rx_elnum*rx_tmp10ec)/rx_tmp10ec
	}



@eof_file


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

Volver arriba

Ejemplo 3

Numerador de líneas en archivos de texto


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

	//	El siguiente programa intenta modificar tres archivos de texto, agregando una numeración a sus renglones.

	var arr_files=array("texto1.txt","texto2.txt","texto3.txt")

	for(var t=0;t<count(arr_files);t++){

		var file1=arr_files[t]

		if(fileexists(file1)==false){
			alert_ex("No se hallo el archivo " + file1, "Información", _mb_iconinformation);
			continue;
		}
		if(filesize(file1)>10000000){
			alert("El archivo " + file1 + " tiene más de 10 millones de bytes y no será procesado por limitar la cantidad de memoria física utilizada.")
			continue;
		}
		var arr_lines=explode(_nl,binary_read(file1));

		for(var t2=0;t2<count(arr_lines);t2++){
			arr_lines[t2]=(t2+1) + "- " + arr_lines[t2]
		}

		if(-binary_write(file1, implode(_nl,arr_lines))){
			alert_ex("No se logró escribir en el archivo " + file1+ _nl+ "Descripción del error: "+err_description(err_number())  , "Información", _mb_iconerror);
		}
	}

	alert_ex("Se ha terminado de procesar los archivos de texto: " + implode(",", arr_files), "Información", _mb_iconinformation)


@eof_file

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

Volver arriba

Ejemplo 4

Encriptación simétrica bit a bit


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

/*
	El siguiente es un ejemplo avanzado de programa que los principiantes pueden omitir leer.

	Es muy utilizada la encriptación simétrica Byte a Byte utilizando la instrucción xor. En el siguiente ejemplo sencillo se trabaja a nivel de Bits, lo cual en general incrementa la seguridad de cualquier algoritmo de encriptación. (Un Byte se compone de ocho Bits, un Bit (Binary digit) sólo puede valer cero o uno).
*/


includec(engine\internal\simple_rsrc.asm)

main()
	
	function main(){

		if(alert_ex("A continuación se realizará un encriptación simétrica de un archivo"+_nl+"Se deberá especificar la contraseña, el archivo a cargar y el archivo a guardar"+_nl+"¿continuar?", "Información", _mb_iconinformation+_mb_yesno)!=_mbret_yes){
			return
		}

		var pass=inputdlgx("Contraseña ?", "Dato necesario:","1234")
	
		var filename1 = opfopen(".","","todo archivo *.*"+chr(0)+"*.*");
		if(len(filename1)==0){ return }
	
		var filename2 = opfsave(".","","todo archivo *.*"+chr(0)+"*.*");
		if(len(filename2)==0){ return }
	
		if(-fileexists(filename1)){alert("No se hallo el archivo  "+filename1);return}

		if(fileexists(filename2)){
			if(alert_ex("El archivo " + filename2 + "Ya existe, ¿sobrescribirlo?", "Información", _mb_iconinformation+_mb_yesno)!=_mbret_yes){
				return
			}
		}

		if(filesize(filename1)>10000000){alert("El archivo " + filename1 + " tiene más de 10 millones de bytes y no será procesado por su tamaño.");return}

		var cont=binary_read(filename1)

		if(len(cont)==0){
			alert("El archivo " + filename1 + " está vacío.")
			return
		}
		var hash1=hashver(pass)			//	hashver devuelve un "hash", un entero largo único en función de una cadena.

		hash1=(hash1 ^ hashver(parsestr(hash1)))		//	Se efectúa el cálculo de un entero único en función de la contraseña usando el operador Xor para enteros largos.

		var bitstr=binstrpack(cont)		//	La función binstrpack convierte una cadena cualquiera en otra de ocho veces su tamaño cuyos bytes son ceros y unos 
							//	 que representan los bits de la cadena original.
		_direct{
			mov ebx, [hash1+reg.vo]	;	Se carga el entero único determinado según la contraseña en "ebx".
			mov eax, [bitstr+reg.vo]	;	El manejador de la cadena es un entero largo (índice) situado en el desplazamiento "reg.vo" que es 8.
			NWPOS_eax			;	La macro NWPOS_eax carga en "esi" el puntero en memoria al inicio de la cadena.

			mov edx, [bitstr+reg.nu]	;	Carga en edx la longitud de la cadena, que en este caso es múltipla de 8 y no cero.
			lea edi, [esi+edx-1]		;	Carga en edi el puntero al último byte de la cadena.
			shr edx, 1			;	Se divide "edx" a la mitad.
			enc_sample1:
				mov ah, [esi]
				mov al, [edi]

				mov cl, bl		;	Pone en bit bajo de "cl" un bit utilizado para encriptar.
				shr cl, 3
				xor cl, bl

				xor al, cl		;	Se encripta el bit más bajo en memoria (los otros bits son ignorados por la función "binstrunpack").
				xor ah, cl

				test bl, bl		;	Si es par el conteo de bits 1 en "bl", intercambiar los bits actual y el simétrico respecto al centro de la cadena.
				jp @f
					xchg al, ah
				@@:

				mov [esi], ah
				mov [edi], al

				mov cl, bl		;	En estas instrucciones se realiza una tarea cuya importancia radica (para nuestro ejemplo sencillo de encriptación)
				xor cl, dl		;	 en modificar el registro ebx "rotándo sus bits" hacia la izquierda en función de la posición del bit a encriptar y el mismo registro.
				rol ebx, cl		;		and cl, 31		;	Es una instrucción redundante porque no altera el comportamiento de "rol".
				inc ebx		;	Se asegura un poco más el algoritmo incrementando el registro "ebx".
			inc esi
			dec edi
			dec edx
			jnz enc_sample1
		}
		var cont2=binstrunpack(bitstr)	//	La función "binstrunpack" realiza la tarea inversa a "binstrpack", toma una cadena con bytes ceros y unos (aunque se admiten 
							//	todos pues sólo utiliza el bit de menos valor) de longitud múltipla de 8 y crea una cadena con bytes cuyos bits 
							//	valen lo que los bytes de la cadena original.
		
		if(-binary_write(filename2, cont2)){
			alert_ex("No se logró escribir en el archivo " + filename2+ _nl+ "Descripción del error: "+err_description(err_number())  , "Información", _mb_iconerror);
		}else{
			alert_ex("Se ha escrito correctamente el archivo procesado en " + filename2, "Información", _mb_iconinformation)
		}

	
	}


@eof_file

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

Volver arriba