Mensajes

Hola y disculpa porque se me olvido que hay que declarar en el codigo una string "vacia" en el codigo solo ocupa dos bytes y nos ahorra mucho codigo :

inicio db " ",0

Debes de poner esta string primero y despues todas las que desees y funciona a la perfeccion , saludos y gracias por darte cuenta

Una forma de Salir sin usar ExitProcess , introduscanlo en olly para que vean como es.

http://sites.google.com/site/compactamos/descargas/Calc.zip?attredirects=0

Una pista : xxxxxxxxxxxx

Hola a todos , esta es una forma de invertir una string sin usar la pila que fue el ejemplo anterior que publique , este codigo necesita tener en eax la longitud de la string.

Saludos

Código (asm) [Seleccionar] Expandir

mov ebx,string
add eax,ebx
dec ebx

asd:
mov ch, byte ptr ds:[ebx]
xchg [eax],ch
xchg [ebx],ch

inc ebx
dec eax
cmp     ebx,eax
jbe asd  ; Salta si es Menor o igual

-----------------
Nota> Para usar este código es necesario introducir una string con un caracter al principio de nuestro codigo , es decir , antes de declara la string que invertiremos tenemos que declarar > vacia db " ",0
No olvidar esto
-----------------
------------------------------------------------------ off topic
Si en algo siempre tendré la razón es cuando diga:
"Los hombres no piensan igual"
a)Si no estas de acuerdo con esta frase me estas dando la razón.
B)Si estas de acuerdo , gracias por coincidir con mis pensamientos.

Gracias , muy bueno. 

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

Gracias por el code ,despues lo analizo en casa.

;;;;;;;;;;;;;;;;;;;;;;;;;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 

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:

-- 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

Invertir un Byte
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1315200#msg1315200

El flag P
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1289013#msg1289013

Un metodo de ordenamiento
http://foro.elhacker.net/asm/un_metodo_de_ordenamiento-t264478.0.html

Convertir a hexadecimal !!!
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1286565#msg1286565

De Ascii a binario (01011001)
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1269217#msg1269217

Explicación sencilla sobre AND XOR OR NOT
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1266079#msg1266079

Buscar una string dentro de otra (Soporta Búsqueda con asterisc*s)
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1257143#msg1257143

Invertir una string (codigo sencillo y sin usar la pila)(Mejorado)
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1255196#msg1255196

Par o Impar?
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1255115#msg1255115

De minúsculas a MAYÚSCULAS
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1254101#msg1254101


Comparando dos strings:

Esta es una pequeña forma de comparar strings.

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:

Strings con 00 como final.

SaLuDoS

y prueben el sistema operativo hecho en ASM
http://www.menuetos.net/
Esta very good.