Recordando cosas: más es menos

¡Estoy olvidando lo que sé! Bueno, ya puedo decir que he olvidado lo que sabía :'(. Me explico.

Es normal que si no usamos un lenguaje se nos "oxide" la habilidad que hemos llegado a desarrollar. Pues parece que si algo se oxida mucho acaba rompiéndose. Por ejemplo mi ensablador, que está a punto de fractura.

Problema: convertir una cadena de texto a minúsculas.

Solución a.asm (corta, que resulta la más larga):

section .data

_str	db	'ESTA es la cadena a CONVERTIR XD',0
strLen  equ     ($-_str)-1

section .text
global _start

_start:

        lea     esi,[_str]	; cargamos la cadena
        cld			; hace falta?
bucle:
        lodsb			; carga un byte de [esi]
        or      al,al		; si es cero acabamos
        jz      finBucle
        or      al,20h		; a minúsculas
        mov     edi,esi		; dirección a destino
        dec     edi		; posición anterior (lodsb
				; incrementa uno)
        stosb			; almacena
        jmp     bucle		; siguiente iteración
finBucle:

				; muestra la cadena
        mov     ecx,_str	; convertida
        mov     edx,strLen
        mov     eax,4
        mov     ebx,1
        int     0x80

        mov     eax,1		; vuelta al sistema
        int     0x80

Compilamos con:

nasm -f elf a.asm && ld -s -o a a.o

Bueno, la sintáxis de AT&T olvidada por completo :(. Para mi gas ha muerto definitivamente... lo que recuerdo es la sintáxis de INtel, así que estoy usando nasm.

Tamaño: 536 bytes. No está mal.

Solución b.asm (más código, pero la más corta contra todo pronóstico):

section .text
global _start

_str	db	'ESTA es la cadena a CONVERTIR XD',0
strLen  equ     ($-_str)-1

_start:
        push    ebp		; reservamos espacio
        mov     ebp,esp		; en la pila: variable
        sub     esp,strLen	; local

        mov     edi,ebp		; almacenaremos en la pila
        lea     esi,[_str]	; cargamos la cadena igual
        cld
bucle:				; el bucle es similar,
        lodsb			; aunque no hace falta
        or      al,al		; preparar edi en cada
        jz      finBucle	; vuelta
        or      al,20h
        stosb
        jmp     bucle
finBucle:
				; mostramos resultado
        mov     ecx,ebp
        mov     edx,strLen
        mov     eax,4
        mov     ebx,1
        int     0x80

        leave			; opcode 'mágico'...
				; restaura la pila y
				; 'desapila' ebp
        mov     eax,1
        int     0x80

Tamaño: 492 Bytes.

La explicación:

$ objdump -s a | grep sección
Contenido de la sección .text:
Contenido de la sección .data:
Contenido de la sección .bss:
Contenido de la sección .comment:

$ objdump -s b | grep sección
Contenido de la sección .text:
Contenido de la sección .bss:
Contenido de la sección .comment:

¡Claro! la solución b no tiene sección de datos. En su lugar emplea la pila (la sección de código donde he metido la cadena original no tiene permisos de escritura) y, aunque necesita más código para hacerlo, ahorra mucho espacio.

Como no me ponga de tanto en tanto a repasar conocimientos me temo que voy a tener que quitar ciertas cosas del currículum :(. ¡Que pérdida es olvidar lo aprendido con tanto esfuerzo! ¿Por qué no será todo como montar en bicicleta? :D