Administración de Base de Datos

jueves, 21 de marzo de 2019

MULT CON DOS CIFRAS


.model small ;Modelo de memoria m?s utilizado

.stack



.data        ;definición de datos(variables), donde se almacenara información

.code

   chr1  db ? ;primer digito

   chr2  db ? ;segundo digito

   chr3  db ? ;multiplo

   chr4  db ?

   r1    db ? ;resultado 1

   r2    db ? ;resultado 2

   r3    db ?

   r4    db ?

   ac    db 0 ;acarreo

   ac1   db 0

.startup

   ;cls

   mov ah,00h     ;Function(Set video mode)

   mov al,03      ;Mode 80x25 8x8 16

   int 10h        ;Interruption Video



   mov ah,01h     ;Function(character read) Guarda en AL

   int 21h        ;Interruption DOS functions

   sub al,30h     ;ajustamos valores

   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2



   mov ah,01h     ;Function(character read) Guarda en AL

   int 21h        ;Interruption DOS functions

   sub al,30h     ;Ajustamos valores

   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2



   mov ah,02h     ;Function(character to send to standard output)

   mov dl,'*'     ;Character to show

   int 21h



   mov ah,01h     ;Function(Read character) Guarda en AL

   int 21h        ;Interruption DOS Functions

   sub al,30h     ;Transform(0dec = 30hex)

   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2



   mov ah,01h     ;Function(Read character) Guarda en AL

   int 21h        ;Interruption DOS Functions

   sub al,30h     ;Transform(0dec = 30hex)

   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2



   mov ah,02h     ;Character to send to standar output

   mov dl,'='     ;

   int 21h        ;Interruption DOS functions



   ;Realizamos operaci?n 



   mov al,chr4  ;unidad del segundo numero

   mov bl,chr2  ;unidad del primer numero

   mul bl       ;multiplicar

   mov ah,0     ;limpiamos ah0

   aam          ;separamos de hex a dec

   mov ac1,ah   ;decenas del primera multiplicacion

   mov r4,al    ;unidades del primera multiplicacion

         

   mov al,chr4  ;unidades del segundo numero

   mov bl,chr1  ;decentas del primer numero

   mul bl       ;multiplicar

   mov r3,al    ;movemos el resultado de la operacion a r3

   mov bl,ac1   ;movemos el acarreo a bl

   add r3,bl    ;sumamos resultado mas acarreo

   mov ah,00h   ;limpiamos ah por residuos

   mov al,r3    ;movemos el resultado de la suma a al

   aam          ;separamos  de hex a dec

   mov r3,al    ;guardamos unidades en r3

   mov ac1,ah   ;guardamos decenas en ac1



   



   mov al,chr3    ;al = chr3

   mov bl,chr2    ;bl = chr2

   mul bl         ;AL = chr3*chr2 (BL*AL)

   mov Ah,0h      ;

   AAM            ;ASCII Adjusment

   mov ac,AH      ;ac = AH (Acarreo)

   mov r2,AL      ;r2 = AL       (Unidad del resultado)



   mov al,chr3    ;AL = chr3

   mov bl,chr1    ;BL = chr1

   mul bl         ;AL = chr1*chr3 (BL*AL)

   mov r1,al      ;r1 = AL       (Decena del resultado)

   mov bl,ac      ;BL = Acarreo anterior

   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)

   mov ah,00h     ;

   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)

   AAM            ;ASCII Adjustment

   mov r1,al      ;r1 = AL

   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)





   ;suma final

   ;R4 resulta ser las unidades de mul y no se toma en cuenta ya que se pasa entero





   mov ax,0000h   ;limpiamos ax



   mov al,r3      ;movemos el segundo resultado de la primera mult a al

   mov bl,r2      ;movemos primer resultado de la segunda mult a bl

   add al,bl      ;sumamos

   mov ah,00h     ;limpiamos ah

   aam            ;separamos hex a dec

   mov r3,al      ;r3 guarda las decenas del resultado final

   mov r2,ah      ;r2 se utiliza como nuevo acarreo



   mov ax,0000h   ;''''



   mov al,ac1     ;movemos el acarreo de la primera mult a al

   mov bl,r1      ;movemos segundo resultado de la segunda mult a bl

   add al,r2      ;sumamos el nuevo  acarreo de la suma anterior  a al

   add al,bl      ;sumamos al a bl

   mov ah,00h     ;limpiamos el registro ah

   aam            ;separamos de hex a dec

   mov r1,al      ;r1 guarda las centenas

   mov r2,ah      ;ah se sigue utilizando como acarreo



   mov al,r2      ;movemos el acarreo a al

   mov bl,ac      ;movemos ac a bl

   add al,bl      ;sumamos al a bl

   ;aam            ;separamos hex a dec

   mov ac,al      ;mov al a ac como nuestro acarreo final







   ;Mostramos resultado

   mov ah,02h

   mov dl,ac

   add dl,30h

   int 21h        ;Mostramos ac (millar)



   mov ah,02H

   mov dl,r1

   add dl,30h

   int 21h        ;Mostramos r1 (centena)



               



   mov ah,02H

   mov dl,r3

   add dl,30h

   int 21h        ;Mostramos r3 (decena)



   mov ah,02H

   mov dl,r4

   add dl,30h

   int 21h        ;unidad



.exit

end


miércoles, 13 de marzo de 2019

Programa que dice que si se encuentra La palabra

org 100h 
include 'emu8086.inc'
mov si, 0    ;ponemos si en 0 
   
   
comienzo: 
mov al, msg2[0]   ;copiar la primera letra de la palabra A al

cmp msg[si],"$"   ;si es el fin de la cadena mandar a final
 jz final      ; brinca si es igual

cmp msg[si], al   ;comparar si encuentra la primera letra de la cadena
 jne seguir    ;brica si es diferente


mov di, 1         ;poner en 1 di  

comprobar:

 mov al, msg2[di]
 mov bx, di
 cmp msg[si+bx], al     ;posicion de la letra coincidente + di, comparar con la cadena
 jne seguir             ;si no coincide mandar a seguir  


 inc di                 ;incrementar di para seguir recorriendo cadena

 cmp msg2[di],"$"       ;si es el fin de la cadena y el programa llego 
 jz resultado           ;aca quiere decir que la cadena es parte de la palabra


loop comprobar         ;bucle para recorrer cadena
                                                   
                                                   
seguir:  

 inc si       ;para seguir recorriendo la palabra

loop comienzo   ;bucle principal para recorrer palabra

resultado:

  mov dx, offset msg3    ;copiar msg3 a dx
  mov ah, 9              ;preparar ah con 9 para la interrupcion 21h
  int 21h                ;mostrar contenido en dx  
  
final: 



ret   

msg db "tecnologico$"
msg2 db "tec$"

msg3 db "Si se encuentra$"

martes, 12 de marzo de 2019

Despliegues con letreros Lea, Macro y Offset

;Despliegue con letrero con lea


org 100h 

.model tiny

.data
    dato db 10,13, 'letrero $'

.code

INICIO:
mov cx,4

comienzo:

mov ah,09h
    lea dx,dato
    int 21h
 
loop comienzo

ret



------------
;Desplegue de letrero con macro




ORG 100H
INCLUDE 'EMU8086.INC'

MOV CX,4

COMIENZO:
PRINTN 'LETRERO'

LOOP COMIENZO

RET

----------
;Despliegue con letrero con offset


org 100h 

.model tiny

.data
    dato db 10,13, 'letrero $'

.code

INICIO:
mov cx,4

comienzo:



mov ah,09h
    ;lea dx,dato
    mov dx,OFFSET DATO
    int 21h
 
loop comienzo

ret



jueves, 7 de marzo de 2019

Instrucciones de salto que prueban una sola bandera con ejemplos

Tabla de saltos condicionales.


salto incondicional jmp
salto condicional cmp

http://jbwyatt.com/253/emu/asm_tutorial_07.html


Ejemplo1



name"jmp incondicional"
org    100h

mov    ax, 5          ; set ax to 5.
mov    bx, 2          ; set bx to 2.

jmp    calc            ; go to 'calc'.

back:  jmp stop      ; go to 'stop'.

calc:
add    ax, bx         ; add bx to ax.
jmp    back           ; go 'back'.

stop:

ret                   ; return to operating system.



Ejemplo2






saltos condicionales
.model small
.stack
.data
include 'emu8086.inc'

    num1 db 8
    num2 db 9
    msg1 db 'numeros iguales $'
    msg2 db 'numero 1 mayor $'
    msg3 db 'numero 2 mayor $'

.code
    main:
    mov ax, @data
    mov ds,ax
 
    mov al, num1
 
    cmp al, num2
 
    jc mayor2
    jz igual
    jnz mayor1
 

.exit

igual:
   ;printn 'numeros iguales'
     jmp fin

    mov ah,09h
    lea dx,msg1
    int 21h
    jmp fin
 


mayor1:

;printn 'el numero 1 es mayor'
     jmp fin

    mov ah,09h
    lea dx,msg2
    int 21h
    jmp fin
 
 
mayor2:
    ;printn 'el numero dos es mayor'
     jmp fin

     mov ah,09h
    lea dx,msg3
    int 21h
    jmp fin
 
 
fin:
 
ret             

miércoles, 6 de marzo de 2019

Ciclos condicionales

LOOP etiqueta
La instrucción loop decrementa CX en 1, y transfiere el flujo del programa a la etiqueta dada como operando si CX es diferente a 1.
Instrucción LOOPE
Propósito: Generar un ciclo en el programa considerando el estado de ZF

LOOPE etiqueta 
Esta instrucción decrementa CX en 1. Si CX es diferente a cero y ZF es igual a 1, entonces el flujo del programa se transfiere a la etiqueta indicada como operando.

Instrucción LOOPNE
Propósito: Generar un ciclo en el programa, considerando el estado de ZF


LOOPNE etiqueta 
Esta instrucción decrementa en uno a CX y transfiere el flujo del programa solo si ZF es diferente a 0.

Emu8086





Se define como un lenguaje de programación que se usa para dar directamente órdenes al ordenador. A diferencia de otros lenguajes, que usan el sistema operativo como intermediario para ejecutar las tareas (le dicen al sistema operativo que haga una cosa y este es quien se encarga de hacerselo saber al ordenador), el lenguaje de ensamblador (en inglés assembly) no usa intermediarios, sino que directamente le dá las órdenes a la máquina.

Programa 9 Colores 2

include 'emu8086.inc' CUADRO MACRO XI,YI,XF,YF,COLOR MOV AX, 0600H MOV BH, COLOR MOV BL, 00H MOV CH, YI MOV CL, XI MOV DH, Y...