Indice de contenido -> Capítulo 17 - La Framework predeterminada y los ejemplos de proyectos

	includec(º_scriptdir_\local_bmp_compresion.thp)		//	Incluye un archivo "local_bmp_compresion" (común) que se encuentra en la carpeta del script .Tsi actual.

	include_tco(tco_inc\bitmaps\bmpobject.tco)		//	Incluye el archivo objeto "bmpobject.tco" que está en la carpeta "tco_inc\bitmaps" dentro de la carpeta del editor.

; //########################################################################################################
	
	/*
	
		A diferencia de los archivos pequeños (de menos de 500 kilobytes aproximadamente) los archivos de texto de mayor tamaño deben tratarse de forma distinta o de lo contrario se generará un error de falta de memoria en la instrucción	"var arr_lines=explode(_nl,binary_read(arr_files[t]));", eso ocurre porque la función "explode" crea una matriz cuyos ítems son cadenas, y cada cadena utiliza un manejador interno cuya cantidad es limitada en nuestra versión del compilador; además se consume tiempo en crear la matriz de renglones. Por tanto para realizar el procesamiento de archivos no pequeños es recomendable acelerar la tarea apoyándose en la ayuda de ensamblador. 
	
		El ejemplo de a continuación es relativamente rápido en comparación con otros métodos, aunque la suma de cadenas en TEIMSI puede resultar mucho más lenta que en ensamblador. Se mostrará como se buscan los renglones desde una única cadena que tiene el contenido del archivo de entrada.
	
	*/
	
		main()
		
		function main(){
		_savelocal: ult_linea dd ?,num_b_nl dd ?, pos_final dd ?, et_tocall dd ?, tmppos_esi dd ?
	
			// "_savelocal" declara variables locales en el procedimiento expresado en lenguaje ensamblador.
	
			alert_ex("Este programa de ejemplo, intentará cargar el archivo \"gigante.txt\" numerar sus renglones y poner el resultado en el archivo \"gigante2.txt\" !", "Información", _mb_iconinformation);
	
			var inputfile="gigante.txt";
			var outputfile="gigante2.txt";
	
			if(-fileexists(inputfile)){
				alert_ex("No se halló el archivo " + inputfile, "Información", _mb_iconinformation);
				return;
			}
			var file_content=binary_read(inputfile)		//	Leer el contenido del archivo en una única cadena grande.
	
			var maxsizeline=2000, line=str_repeatn(" ", maxsizeline), reco_reti=0, strout=""	//	Estas variables son utilizadas en el procesamiento del texto de entrada, la variable line tiene un búfer
															// de espacio donde se colocará cada renglón del archivo y no debe modificarse.
	
			var contador=1 	//	El contador indica el número de renglón inicial, se incrementará con cada renglón procesado.
	
		//	El siguiente código de ensamblador situado en el bloque "_direct" se encarga de inicializar variables que serán utilizadas por la rutina interna "RECORRER_TEXTO"; dicha rutina será llamada en un "ciclo" que cargará cada renglón del contenido del archivo en la variable "line".
	
	
	jmp(continuacion_temisi)
	
	; //###############################
	
	//	Estas líneas tienen una rutina que procesa cada renglón cargado, la etiqueta "procesar_renglon" indica el inicio de esta rutina que es llamada desde ensamblador.
	
	procesar_renglon:
	
		var line2= contador+"- "+line
		contador++
		strout=strout+line2+_nl

		//	En este bloque de TEIMSI, se podría escribir solamente:  strout=strout+line+_nl, lo cual dejaría al archivo de salida "gigante2.txt" con el mismo contenido del archivo de entrada "gigante.txt", pero antes de ello procesamos la línea del renglón para efectuar la tarea deseada de numeración.
		//	
		//	En este caso la variable "line" no debe modificarse porque su búfer interno de datos es utilizado por ensamblador.  La variable "reco_reti" tiene un cero, pero es posible indicar reco_reti=1 si ocurrió un error (ejemplo: error de sintaxis en el renglón), lo cual hará que el ciclo de lectura de renglones se interrumpa y se muestre el mensaje "Error en línea " (contenido de renglón).
	
	_direct{
		mov eax, [reco_reti+reg.vo]
		RET
	}
	
	; //###############################
	
	continuacion_temisi:
		_direct{
			mov [tmppos_esi], 0				;	Se realiza la carga del puntero en memoria y longitud de la cadena "file_content".
			mov eax, [file_content+reg.vo]
			NWPOS_eax
			mov ecx, [file_content+reg.nu]
			m2ma [et_tocall], (procesar_renglon)
			mov [reco_reti+reg.vo], 0
	
			call RECORRER_TEXTO
		}
		if(reco_reti==1){
			alert("Error en línea " +line)
			sys.quit()
		}
	
		binary_write(outputfile,strout)
	
		alert_ex("Se ha escrito en el archivo " + outputfile, "Información", _mb_iconinformation);
	return;

			_direct{

			RECORRER_TEXTO:
	
			;	A continuación se ve el "ciclo" que pone en la variable "line" cada renglón del archivo de texto de entrada.
	
				mov eax, [file_content+reg.vo]		;	Se determina el puntero en memoria al contenido del archivo.
				NWPOS_eax
				mov [tmppos_esi], esi
				mov ecx, [file_content+reg.nu]
				mov [ult_linea], 0
			
				lea eax, [esi+ecx]
				mov [pos_final], eax
			
				task_c1:
	
					mov ecx, [pos_final]			;	Un renglón termina con un carácter chr(10) o también con la cadena chr(13)+chr(10).
					sub ecx, esi
			
					mov edi, esi
					mov al, 10
			
					or ebx, 1
					repnz scasb
					jz @f
						mov [ult_linea], 1		;	Se activa indicador del último renglón si se llega al final del archivo.
					@@:
					jnz @f
						mov [num_b_nl], 1
				
						dec edi
						cmp byte [edi-1], 13
						jnz @f
				
						mov [num_b_nl], 2
						dec edi
					@@:
					mov ecx, edi
					sub ecx, esi
	
				push esi ecx ebx
	
					cmp ecx, [maxsizeline+reg.vo]		;	Para evitar problemas se limita el tamaño de cada renglón leído.
					jb @f
						mov ecx, [maxsizeline+reg.vo]
					@@:
	
					mov [line+reg.nu], ecx			;	La longitud del renglón ya se tiene, falta copiarlo en la variable "line" y procesarlo.
					mov eax, [line+reg.vo]
					NWPOS_eaxedi
			
					mov eax, ecx
					and eax, 3
					shr ecx, 2
					rep movsd
					mov ecx, eax
					rep movsb
			
					call dword [et_tocall]
	
					mov ebx, [file_content+reg.vo]		;	ahora se ajusta la variable [pos_final] en caso de que la posición en memoria del contenido del
					NWPOS_ebx					;	 archivo halla cambiado.
	
					mov edx, esi
					sub esi, [tmppos_esi]
					jz @f
						mov [tmppos_esi], edx
						add edx, [file_content+reg.nu]
						mov [pos_final], edx
						add [ss:esp+8], esi			;	esi = (oldesi - oldloccad) + newloccad
					@@:
	
				pop  ebx ecx esi
	
					mov byte [esi+ecx], bl
	
					cmp eax, 1
					jz @f
				
					add esi, ecx
					add esi, [num_b_nl]
	
				cmp [ult_linea], 0
				jz task_c1
				@@:

			RET
			}
		}
@eof_file

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

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

	/*
		Este programa obtiene información sobre la memoria física y virtual utilizando la función "GlobalMemoryStatus" de la librería kernel32. Más información puede
	 hallarse en la documentación de las API's de sistemas Window* en el archivo "win32.hlp" descargable desde Internet utilizando los enlaces a las herramientas disponibles del capítulo Enlaces.
	
	*/
	
	place_idata{
	
		struct _MEMORYSTATUS
			dwLength		dd ?
			dwMemoryLoad		dd ?
			dwTotalPhys		dd ?
			dwAvailPhys		dd ?
			dwTotalPageFile	dd ?
			dwAvailPageFile	dd ?
			dwTotalVirtual	dd ?
			dwAvailVirtual	dd ?
		ends
		memory_info _MEMORYSTATUS
	
		MACRO copy_2tsi_dbl dest_tsi_dbl, mem_dword
	
			push dword 0
			push dword mem_dword
				fild qword [ss:esp]
				fstp qword [dest_tsi_dbl+reg.vo]
			add esp, 8
		ENDM
	}
	
	@import:GlobalMemoryStatus
	
	var d_dwLength=0.0, d_dwMemoryLoad=0.0, d_dwTotalPhys=0.0, d_dwAvailPhys=0.0, d_dwTotalPageFile=0.0, d_dwAvailPageFile=0.0, d_dwTotalVirtual=0.0, d_dwAvailVirtual=0.0
	
	_direct{
		mov dword [memory_info+_MEMORYSTATUS.dwLength], sizeof._MEMORYSTATUS
		invoke GlobalMemoryStatus, (memory_info)
	
	
		copy_2tsi_dbl d_dwLength,       [memory_info.dwLength]
		copy_2tsi_dbl d_dwMemoryLoad,   [memory_info.dwMemoryLoad]
		copy_2tsi_dbl d_dwTotalPhys,    [memory_info.dwTotalPhys]
		copy_2tsi_dbl d_dwAvailPhys,    [memory_info.dwAvailPhys]
		copy_2tsi_dbl d_dwTotalPageFile,[memory_info.dwTotalPageFile]
		copy_2tsi_dbl d_dwAvailPageFile,[memory_info.dwAvailPageFile]
		copy_2tsi_dbl d_dwTotalVirtual, [memory_info.dwTotalVirtual]
		copy_2tsi_dbl d_dwAvailVirtual, [memory_info.dwAvailVirtual]
	}
	
	
	var reporte = "Memoria RAM Total		= " + d_dwTotalPhys + _nl + "Memoria RAM en Uso	= " + (d_dwTotalPhys - d_dwAvailPhys) + _nl + "Memoria local virtual Total	= " + d_dwTotalVirtual + _nl + "Memoria local virtual en Uso	= " + (d_dwTotalVirtual-d_dwAvailVirtual) + _nl
	
	alert_ex(reporte, "Información sobre la Memoria del sistema:", _mb_iconinformation)
	
	
@eof_file

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