hola
tengo una duda, cuando comparo cadena de caracteres, he estado utilizando cmpsb, por ejemplo
mov ecx, 5
mov edi, buf1
mov esi, replu
cld
repe cmpsb
je plus
el problema es que tengo que especificar a ecx la cantidad de caracteres, entonces se me ocurrio mejor analizar byte por byte y al encontrar un null brincar a la siguiente instruccion, asi que hice esto
st_lo:
mov al, byte[buf1]
mov bl, byte[replu]
cmp al, bl
jne end
cmp al, 0
je plus
inc byte[buf1]
inc byte[replu]
jmp st_lo
el objetivo era mover 1 byte a bl y al, si al compararlo no es igual entonces terminar el programa, despues volverlo a comparar, si es 0 queria decir que es el fin de la cadena y brincar a la funcion, pero si tampoco era el final de la cadena, incrementar 1 byte en el buffer que contiene la palabra para avanzar a la siguiente letra, y tambien incrementar 1 byte en en la variable replu para avanzar a la siguiente letra
entonces si yo escribo
"hola", queria que se compara letra por letra hasta encontrar el null, 'h','o','l','a','/0' <-- si es igual 0 y 0 (jmp)
el problema es que con solo escribir 'h', avanza...que es lo que estoy haciendo mal? y eso podria funcionar?
Habria que depurarlo pero vamos, si aqui haces esto:
mov al, byte[buf1]
mov bl, byte[replu]
Aumentas el valor del byte no la posicion del puntero.
Como dice mDrinky aumentas el byte.
Podrías hacer algo así
mov ecx,0 ; colocas a cero
mov al, byte[buf1+ecx]
mov bl, byte[replu+ecx]
;y vas aumentando
;inc byte[buf1] así no
;inc byte[replu] así no
inc ecx ; así si.
Bueno soy un principiante es lo que mas o menos se me viene a la mente.
ok, entiendo
buscando en google encontre un codigo que simula un strcmp, de alli saque la idea, ya que al principio solo hacia una comparacion del primer byte, y despues se me ocurrio usar cmpsb
entonces de que forma analiza una cadena este codigo?, yo creia que analizaba el primer byte, despues avanzaba 4 bytes de la cadena guardada y analizaba el siguiente byte, hasta encontrar un null
; -------------------------------------------------
; int strcmp(char *a, char *b)
; -------------------------------------------------
strcmp:
push ebx
strcmp_loop:
mov eax, [esp + 0x08]
mov al, byte [eax]
mov ebx, [esp + 0x0C]
cmp al, byte [ebx]
jne strcmp_not_equal
cmp al, 0
je strcmp_equal
inc dword [esp + 0x0C]
inc dword [esp + 0x08]
jmp strcmp_loop
strcmp_not_equal:
mov eax, 0
jmp strcmp_end
strcmp_equal:
mov eax, 1
strcmp_end:
pop ebx
ret 8
Yo lo veo así:
mov eax, [esp + 0x08] ;muevo a eax lo que hay en [esp + 0x08] (que es un puntero)
mov al, byte [eax] ;ahora muevo a al un byte del lo que hay en el puntero
mov ebx, [esp + 0x0C] ;muevo ebx lo que hay en [esp + 0x0C] (que es un puntero)
cmp al, byte [ebx] ;comparo el byte de al con el byte del puntero que tiene ebx
jne strcmp_not_equal
cmp al, 0
je strcmp_equal
inc dword[esp + 0x0C] ; incremento lo que hay en [esp + 0x0C] (El Puntero)
inc dword[esp + 0x08] ; incremento lo que hay en [esp + 0x08] (El Puntero)
PD: Espero el comentario de alguien con mas experiencia. por si estoy equivocado ???
saludos