Codigos de Yuri Grille

[Arkangel_0x7C5]

bueno, hay tienen el code, al que no le guste algo de el code , que lo cambie. Lo de usar unos registros en puesto de otros es cuestión de gustos, yo si tengo registros sin usar no usare la pila, y siempre suelo dejar para los últimos edi y esi. lo de ah y al da lo mismo porque un caracter nunca superara el tamaño de 1 byte al menos con ascii.


Saludos

[YST]

bueno, hay tienen el code, al que no le guste algo de el code , que lo cambie. Lo de usar unos registros en puesto de otros es cuestión de gustos, yo si tengo registros sin usar no usare la pila, y siempre suelo dejar para los últimos edi y esi. lo de ah y al da lo mismo porque un caracter nunca superara el tamaño de 1 byte al menos con ascii.


Saludos

No te pongas sensible . No es por usar los registro seguramente que lo dijo seguro se refiere a usar cmpsb.

[Arkangel_0x7C5]

bueno, hay tienen el code, al que no le guste algo de el code , que lo cambie. Lo de usar unos registros en puesto de otros es cuestión de gustos, yo si tengo registros sin usar no usare la pila, y siempre suelo dejar para los últimos edi y esi. lo de ah y al da lo mismo porque un caracter nunca superara el tamaño de 1 byte al menos con ascii.


Saludos

No te pongas sensible . No es por usar los registro seguramente que lo dijo seguro se refiere a usar cmpsb.

ok pero si usas cmpsb con el rep necesitaras saber la longitud de alguno de ellos. y no podría pasarlo de minúsculas a mayúsculas sin modificar lo en memoria. y a veces eso no es conveniente.

Saludos

PD:Pa mi gusto esta bien, lo único es que lo de Case Sensitive podría dar problemas con caracteres como el punto y demás

[Yurix]

-- Ambas hileras tienen que ser del mismo tamaño cierto? sino podría estar en crisis el --or eax,eax  jeje.

Señores, ese codigo no necesita saber el tamaño de la string , observen , el detecta el final .

lea esi,CadTexto01
lea ebx,CadTexto02
empi:
mov al, byte ptr ds:[esi]
mov ah, byte ptr ds:[ebx]
cmp     al, ah
jnz enda
inc     esi
inc     ebx
or      eax, eax
jnz     empi
inc     eax
enda:


Si son iguales hace un inc eax y debuelve a "al" con valor 1 .

Ahora estoy creando un código mas rápido usando dwords

SaLuD os

[Yurix]

Hola a todos , esta es mi forma de pasar un texto a mayuscula o minuscula
(add    byte ptr ds:[eax], 20h) , no es mejor ni peor solo es la forma que encontre.
Escriban las suyas para comparar

lea     eax, string
dec eax
inicio:
inc     eax
cmp     byte ptr ds:[eax], 0
je      salir

cmp     byte ptr ds:[eax], 61h
jb      inicio               ; Salta si es menor a "61" o "a"
cmp     byte ptr ds:[eax], 7Ah
ja      inicio               ; Salta si es mayor que "7a" o "z"
sub     byte ptr ds:[eax], 20h  ; Resta 20 para hacerlos mayuscula
jmp     inicio ; SAlta a el principio
salir:

[Yurix]

;;;;;;;;;;;;;;;;;;;;;;;;;Invertir una string por Yuri Grille
COMMENT *Este codigo sirve para invertir una string , puede ser mejorado pero eso sera mas adelante.
Tiene como proposito ver el principio de funcionamiento de la pila (ultimo en guardar
primero en sacar )
Utilizo la pila para guardar los primeros caracteres hasta llegar al final donde los recupero y los
muevo a el principio de la cadena.
Hay que tener cuidado con el tamaño de la string a imbertir ya que la pila creo que tiene un limite.Si alguien puede argumentarme esta duda , por favor que escriba *

push 00  ; Introdusco 0 en la pila para despues recuperarlo y saber que es el caracter final
lea eax,string ; Muevo a eax la direccion en memoria de la string

gam:
cmp     byte ptr ds:[eax], 0  ;Comparamos el primer caracter
jz segpart                  ; Si son iguales es el fin y saltamos a la segunda parte
mov cl , byte ptr ds:[eax]    ; Movemos a cl el primer byte de la string
inc eax                    ;Incrementamos el puntero para el proximo byte de la cadena
push ecx                 ; Guardamos el registro "ecx" en la pila ,el cual contiene a "cl"
jmp gam                    ; Saltamos a el principio .:^:. gam

segpart:

lea eax,string  ; Movemos otra vez la direccion en memoria de la string a eax

mas:
cmp byte ptr ds:[eax], 0 ;Comparamos el primer caracter
jz completo             ; Si son iguales es el fin y saltamos al final
pop ecx                ; Recuperamos de la pila el ultimo valor almacenado
mov byte ptr ds:[eax] , cl ; Y esto lo movemos a la direccion inicial de la cadena
inc eax                ; Incrementamos el puntero para el segundo caracter
jmp mas                ; Saltamos al principio

completo:
;;;;;;;;;;;;;;;;;;;;;;;;;Invertir una string por Yuri Grille , saludos 

[ny0x]

usa el GeSHI para que el codigo se vea mas bonito y si la pila tiene un limite.
En fin dejo una version de strrev un tanto chapucera porque no me acostumbro todavia a programar en asm.

Código (asm) [Seleccionar] Expandir


strrev:
        push ebp
        mov ebp,esp
        push edi
        mov edi,[ebp + 8]
        push edi
        call strlen
        xor ecx,ecx
        dec eax
        jmp LL1
        LL0:
                dec eax
                inc ecx
                cmp ecx,eax
                jge LL2
        LL1:
                mov dl,byte[edi + ecx]
                xchg byte[edi + eax],dl
                mov byte[edi + ecx],dl
                jmp LL0

        LL2:
        mov eax,[ebp + 8]
        pop edi
        pop ebp
retn 4

strlen:
push edi
xor ecx,ecx
mov edi, [esp + 8]
not ecx
xor eax,eax
cld
repne scasb
not ecx
pop edi
add eax,ecx
dec eax
retn 4



la funcion depende de strlen pero eso se puede corregir injertandolo dentro de la misma funcion yo no lo hice porque ya tenia strlen y me dio hueva ponerlo ademas, que no se me hace facil todavia planear un codigo asm

[Yurix]

Gracias por el code ,despues lo analizo en casa.

[ny0x]

Hola a todos , esta es mi forma de pasar un texto a mayuscula o minuscula
(add    byte ptr ds:[eax], 20h) , no es mejor ni peor solo es la forma que encontre.
Escriban las suyas para comparar

lea     eax, string
dec eax
inicio:
inc     eax
cmp     byte ptr ds:[eax], 0
je      salir

cmp     byte ptr ds:[eax], 61h
jb      inicio               ; Salta si es menor a "61" o "a"
cmp     byte ptr ds:[eax], 7Ah
ja      inicio               ; Salta si es mayor que "7a" o "z"
sub     byte ptr ds:[eax], 20h  ; Resta 20 para hacerlos mayuscula
jmp     inicio ; SAlta a el principio
salir:

a mayusculas

Código (asm) [Seleccionar] Expandir


toUpper:
push ebp
mov ebp,esp
    mov esi,[ebp + 8]
begin:
    lodsb
    cmp al,0
    je endx
    sub al,0x61
    cmp al,0x1A
    ja incr
    and byte[esi-1],0xDF
    incr:
jmp begin
endx:
pop ebp

retn 4


a minusculas

Código (asm) [Seleccionar] Expandir


toLower:
    push ebp
    mov ebp,esp
    mov esi,[ebp + 8]
beginL:
    lodsb
    cmp al,0
    je endx
    sub al,0x41
    cmp al,0x1A
    ja incrL
    or byte[esi-1],0x20
    incrL:
jmp beginL
endxL:
pop ebp
retn 4


no son la mejor implementacion del mundo pero funcionan 

[Yurix]

Como saber si un numero alojado en un registro (ej eax) es par:

Simplemente :

and eax,1
jnz Par
Si eax es 0 es par.

Sencillo pero modifica a eax , solo en el caso de que necesitemos a eax con el valor
original podemos usar este código que no lo modifica:

test eax,1
je Par    ;Si Salta es par

Pero un código aun mejor es este: *Por Orniaco (Honor a quien honor merece)

Ventajas : Se usa la instrucción bt la cual tiene un consumo nulo
de los siclos del CPU de los 808x (Eso dicen en los opcode) y no modifica a EAX

bt      eax, 0
jnb     Espar  ; Salta a donde trabajaremos si es par

---------------------------------------------------------------------------------------
----------------------------------------------------------------Consumos de CPU y Bytes
---------------------------------------------------------------------------------------

                       Ciclos                 Tamaño
Operands         808x  286   386   486          Bytes
reg,immed         4     3     2     1            3-4       <<<<<<<<< El consumo de And
reg,immed         5     3     2     1            3-4        <<<<<<< El consumo de Test
reg16,immed8     -     -     3     3            4-8  <<<<<<<<<< El consumo de Bt

Consumo exacto de Bytes:

83E0 01          and     eax, 1     <<<<<<<< El consumo de And  eax,1 (3 bytes)
A9 01000000      test    eax, 1     <<<<<<<< El consumo de Test eax,1 (5 bytes)
0FBAE0 00        bt      eax, 0  <<<<<<<<<< El consumo de Bt   eax,0 (4 bytes)

---------------------------------------------------------------------------------------
----------------------------------------------------------------Consumos de CPU y Bytes
---------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------
--------------------------------------------Mi (Humilde) Conclusión ; jajaja  YST-H1N1
---------------------------------------------------------------------------------------

Si queremos saber si un numero es par sin modificar a eax usar (test eax,1) , si deseamos
cerar a eax en el caso que sea par podemos usar (and eax,1) ,

Pero:
Si estamos dentro de un ciclo repetitivo con X cantidad de operaciones y queremos saber
con rapidez si es par,lo mejor es usar (Bt eax,0) , ademas de no modificar a eax , para
una necesidad posterior.


No necesariamente tiene que estar en eax , puede ser en cualquier otro.

---------------------------------------------------------------------------------------
--------------------------------------------------------------------------Opcode usados
---------------------------------------------------------------------------------------

Uso:  TEST    destino,fuente

Modifica las banderas: CF OF PF SF ZF (AF undefined)

Performs a logical AND of the two operands updating the flags register without saving the result.
(Hace un And lógico con los dos operados , actualizando las Banderas sin salvar el resultado.)

                        Ciclos CPU             Tamaño
Operands         808x  286   386   486          Bytes
reg,reg                3     2     1     1             2
reg,mem          9+EA   6     5     1            2-4  (W88=13+EA)
mem,reg          9+EA   6     5     2            2-4  (W88=13+EA)
reg,immed           5     3     2     1            3-4  <<<<<<<El consumo de Test eax,1
mem,immed   11+EA   6     5     2            3-6
accum,immed       4     3     2     1            2-3

--------------------------------------------------------------------------------------

Uso:  BT      destino,fuente (source)

Modifica las banderas: CF

The destination bit indexed by the source value is copied into the
Carry Flag.

(El bit de destino indexado por el valor de la fuente es copiado dentro del Carry Flag (Bandera de Acarreo))

                        Clocks                 Size
Operands         808x  286   386   486          Bytes
reg16,immed8      -     -     3     3            4-8 <<<<<<<<<
mem16,immed8    -     -     6     6            4-8
reg16,reg16          -     -     3     3            3-7
mem16,reg16       -     -     12    12           3-7