comment
IRC Chat
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

[ASM] Funciones para manipular cadenas - by regx

  • 0 Respuestas
  • 2460 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado ProcessKill

  • *
  • Underc0der
  • Mensajes: 154
  • Actividad:
    0%
  • Reputación 0
  • Arriba los hackers de Argentina!
    • Ver Perfil
    • Email
« en: Febrero 24, 2010, 04:00:18 pm »
strlen(char*)
Código: ASM
  1. strlen:
  2.      push ebp
  3.      mov ebp,esp
  4.      cld
  5.      mov edi,[ebp + 8]
  6.      mov al,0
  7.      mov ecx,0xFFFFFFFF
  8.      L1:
  9.         inc ecx
  10.         scasb
  11.         jnz L1
  12.      mov eax,ecx
  13.      pop ebp
  14. retn 4
  15.  

strcpy(char* dest, char* source);

Código: ASM
  1. strcpy:
  2.         push ebp
  3.         mov ebp,esp
  4.         push esi
  5.         push edi
  6.         cld
  7.         mov esi,[ebp + 12]
  8.         mov edi,[ebp + 8]
  9.         @1:
  10.                 movsb
  11.                 cmp byte[esi],0
  12.                 jnz @1
  13.         pop edi
  14.         pop esi
  15.         pop ebp
  16. retn 8
  17.  
strncpy(char* dest, char* source, int bytes_a_copiar)
Código: ASM
  1. strncpy:
  2.      push ebp
  3.      mov ebp,esp
  4.      push esi
  5.      push edi
  6.      push ecx
  7.      mov ecx,[ebp + 16]
  8.      mov esi,[ebp + 12]
  9.      mov edi,[ebp + 8]
  10.      repnz movsb
  11.      pop ecx
  12.      pop edi
  13.      pop esi
  14.      pop ebp
  15. retn 12
  16.  

otra funcion chapucera mas..

strrev(char*)

Código: ASM
  1. strrev:
  2.         push ebp
  3.         mov ebp,esp
  4.         push edi
  5.         mov edi,[ebp + 8]
  6.         push edi
  7.         call strlen
  8.         xor ecx,ecx
  9.         dec eax
  10.         jmp LL1
  11.         LL0:
  12.                 dec eax
  13.                 inc ecx
  14.                 cmp ecx,eax
  15.                 jge LL2
  16.         LL1:
  17.                 mov dl,byte[edi + ecx]
  18.                 xchg byte[edi + eax],dl
  19.                 mov byte[edi + ecx],dl
  20.                 jmp LL0
  21.  
  22.         LL2:
  23.         pop edi
  24.         pop ebp
  25. retn 4
  26.  

itoa(char* buff, int numero)
Código: ASM
  1. itoa:
  2.       push ebp
  3.       mov ebp,esp
  4.       pushad
  5.       mov edi,[ebp + 8]
  6.       mov eax,[ebp + 12]
  7.       mov ebx,10
  8.       L@@1:
  9.         xor edx,edx
  10.         div ebx
  11.         xchg eax,edx
  12.         or eax,48
  13.         stosb
  14.         mov eax,edx
  15.         cmp eax,0
  16.         jnz L@@1
  17.         inc edi
  18.         mov byte[edi],al
  19.         push dword[ebp + 8]
  20.         call strrev
  21.       popad
  22.       pop ebp
  23. retn 8
  24.  

strcat(char* destino, char* source)

Código: ASM
  1. strcat:
  2.         push ebp
  3.         mov ebp,esp
  4.         push esi
  5.         push edi
  6.         mov esi,[ebp + 12]
  7.         mov edi,[ebp + 8]
  8.         mov al,0
  9.         repnz scasb
  10.         dec edi
  11.         @a:
  12.                 movsb
  13.                 cmp byte[esi],al
  14.                 jnz @a
  15.         mov byte[esi],al
  16.         pop edi
  17.         pop esi
  18.         pop ebp
  19. retn 8
  20.  

toUpper(char*)
Código: ASM
  1. toUpper:
  2.         push ebp
  3.         mov ebp,esp
  4.             mov esi,[ebp + 8]
  5.         begin:
  6.             lodsb
  7.             cmp al,0
  8.             je endx
  9.             sub al,0x61
  10.             cmp al,0x1A
  11.             ja incr
  12.             and byte[esi-1],0xDF
  13.             incr:
  14.                  jmp begin
  15.         endx:
  16. pop ebp
  17.  
  18. retn 4
  19.  
  20.  
  21.  

toLower(char*)
Código: ASM
  1. toLower:
  2.             push ebp
  3.             mov ebp,esp
  4.             mov esi,[ebp + 8]
  5.         beginL:
  6.             lodsb
  7.             cmp al,0
  8.             je endxL
  9.             sub al,0x41
  10.             cmp al,0x1A
  11.             ja incrL
  12.             or byte[esi-1],0x20
  13.             incrL:
  14.                  jmp beginL
  15.         endxL:
  16. pop ebp
  17. retn 4
  18.  
« Última modificación: Febrero 08, 2014, 05:30:42 pm por Expermicid »

 

¿Te gustó el post? COMPARTILO!



Lenguaje Ensamblador para PC [Libro - Paul A. Carter - 2006]

Iniciado por Stiuvert

Respuestas: 0
Vistas: 3634
Último mensaje Agosto 09, 2012, 05:56:07 am
por Stiuvert
Funciones En Asm

Iniciado por Juan

Respuestas: 4
Vistas: 5164
Último mensaje Julio 09, 2011, 08:32:52 am
por Juan