Main.asm

Main.asm

;;;; Main.asm

title Main
include Irvine32.inc

;;;; Escriba las instrucciones necesarias en lenguaje ensamblador para que
;;;; dado un desplazamiento y un mensaje_claro se obtenga un mensaje_cifrado
;;;; a partir de desplazar los caracteres del mensaje_claro tantos caracteres
;;;; a la derecha lo establezca el desplazamiento.
;;;;
;;;; Observaciones:
;;;;
;;;; 1) El mensaje en claro más pequeño solo podrá ser de 3 caracteres.
;;;; 2) El desplazamiento solo podrá tener los valores de 1 hasta (longitud de mensaje_claro – 1)

.data
     ;;;; Para solucion1()
     desplazamiento1     dword     6

     ;;;; Para solucion2()
     desplazamiento2     byte      6

     ;;;; Para solucion3()
     desplazamiento3     byte      6

     mensaje_claro       byte      '¡Hola mundo!'
     separador1          byte      '#=@=@=@=@=@=@=@=@=@=@=@=@=@=@=@=@=#'

     ;;;; Resultado ante cualquiera de las soluciones: 'mundo!¡Hola '
     mensaje_cifrado     byte      sizeof mensaje_claro dup(0) 

     separador2          byte      '#=@=@=@=@=@=@=@=@=@=@=@=@=@=@=@=@=#'
.code
     solucion1 proc  ;;;; solucion1() {
          preparar_registros_para_los_primeros: ;;;; {
               mov eax, 0
               mov ebx, 0
               mov ecx, 0
               mov edx, 0
               
               mov eax, offset mensaje_claro
               
               mov ebx, offset mensaje_cifrado
               add ebx, desplazamiento1
               
               mov edx, sizeof mensaje_claro
               sub edx, desplazamiento1
               mov ecx, edx
          ;;;; }
          
          desplazar_los_primeros: ;;;; {
               mov  dl, [eax]
               xchg dl, [ebx]
               inc  eax
               inc  ebx
               loop desplazar_los_primeros
          ;;;; }
          
          preparar_registros_para_el_resto: ;;;; {
               mov ebx, offset mensaje_cifrado
               mov ecx, desplazamiento1
          ;;;; }
          
          desplazar_el_resto: ;;;; {
               mov  dl, [eax]
               xchg dl, [ebx]
               inc  eax
               inc  ebx
               loop desplazar_el_resto
          ;;;; }
          exit
     solucion1 endp  ;;;; }

     solucion2 proc ;;;; solucion2() {
          mov   esi, sizeof mensaje_claro 
          movsx ebx, [desplazamiento2]
          sub   esi, ebx
          mov   eax, 0
          mov   cl, desplazamiento2
          
          salto:
               mov  dl, mensaje_claro[esi]
               mov  mensaje_cifrado[eax], dl
               inc  esi
               inc  eax
               loop salto
          
          mov   esi, sizeof mensaje_claro 
          movsx ebx, [desplazamiento2]
          sub   esi, ebx
          mov   ecx, esi
          mov   esi, 0
          
          salto2:
               mov  dl, mensaje_claro[esi]
               mov  mensaje_cifrado[eax], dl
               inc  esi
               inc  eax
               loop salto2
          
          exit  
     solucion2 endp ;;;; }

     solucion3 proc ;;;; solucion3() {
          mov   esi, offset mensaje_claro
          mov   ebx, offset mensaje_cifrado
          movzx edx, desplazamiento3
          
          mov ecx, sizeof mensaje_claro
          sub ecx, edx
          
          etqa:
               mov  al, [esi]
               mov  [ebx + edx], al
               inc  edx
               inc  esi
               loop etqa
          
          movzx ecx, desplazamiento3
          mov   ebx, offset mensaje_cifrado
          mov   esi, offset mensaje_claro
          mov   edx, sizeof mensaje_claro
          sub   edx, ecx
          
          etqb:
               mov  al, [esi + edx]
               mov  [ebx], al
               inc  ebx
               inc  edx
               loop etqb
          
          exit
     solucion3 endp ;;;; }

;;;; end solucion1
;;;; end solucion2
;;;; end solucion3