send
Grupo de Telegram
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.

Suma y Resta + Flags (registro de estado) [INTEL 8086]

  • 4 Respuestas
  • 3202 Vistas

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

Desconectado Olger346

  • *
  • Underc0der
  • Mensajes: 30
  • Actividad:
    0%
  • Reputación 1
    • Ver Perfil
  • Twitter: @Olger346
« en: Julio 07, 2015, 01:01:28 am »
El objetivo de este programa es notar la variación de las banderas después de ejecutar una operación aritmetica, en este caso suma y resta.
Espero haber documentado bien el código para que todo haya quedado claro, también quiero decir que la rutina de scanum la saque de un sitio brujo, pero podeís observar que hace emulando paso por paso.

Las variables se almacenan en el registro cx, el cual hay que moverselo a una variable, de lo contrario se pierde el valor de la variable.
El programa solo corre en un rango de -128 a 127.
Hay algunas banderas que probablemente no cambiaran.

Espero que sea de utilidad. ^w^b
Código: ASM
  1. imprime_car macro   car
  2.    
  3.     mov    ah,10
  4.     mov    al,car
  5.     mov    bh,0
  6.     mov    cx,1
  7.     int    10h      
  8.  
  9. endm
  10.  
  11. print  macro cad
  12.     mov   ah,9
  13.     lea   dx,cad
  14.     int   21h
  15.    
  16. endm    
  17.  
  18. getch macro dato
  19.    
  20.     mov  ah,0   ; servicio 0 de Teclado
  21.     int  16h    ; Interrupcion de teclado
  22.    
  23.     mov  dato,al
  24.    
  25. endm
  26.  
  27. cursor_xy  macro X,Y
  28.    
  29.     mov    ah,2     ; servicio 2 de video
  30.     mov    dh,Y     ; coordenada de la fila
  31.     mov    dl,X     ; coordenada de la columna
  32.     mov    bh,0    
  33.     int    10h      ; interrupcion de video
  34.    
  35. endm
  36.  
  37. putc macro   car
  38.    
  39.     mov    ah,10
  40.     mov    al,car
  41.     mov    bh,0
  42.     mov    cx,1
  43.     int    10h
  44. endm  
  45.  
  46. getint macro dato       ;modificaciones de la macro getch
  47.    
  48.     mov  ah,0   ; servicio 0 de Teclado
  49.     int  16h    ; Interrupcion de teclado
  50.    
  51.     mov  dato,ax ;cambiar a ax para recojer datos de 2bytes osea mayores a 127
  52.    
  53. endm
  54.  
  55. .data
  56.   error db "error",13,10,36
  57.   h1 db "                                                      ",13,10,
  58.      db "                  Registro de Estado          Olger346",13,10,
  59.      db "              Operaciones con Negativos               ",13,10,
  60.      db "                      + Suma                    11R122",13,10,
  61.      db "                      - Resta                         ",13,10,
  62.      db "                      ESC                             ",13,10,36
  63.          
  64.   h2 db "                 Valor de A (127-128)                 ",13,10,36
  65.   h3 db "                 Valor de B (127-128)                 ",13,10,36
  66.      
  67.   h4 db "       - - - - O D I T S Z - A - P - C                ",13,10,
  68.      db "                                                      ",13,10,
  69.      db "                                                      ",13,10,
  70.      db " Aritmeticos & Logicos   Control                      ",13,10,
  71.      db " Acarreo         =       Direccion    =                    ",13,10,
  72.      db " Paridad         =       Interrupcion =           Valor    ",13,10,
  73.      db " Auxiliar        =       Trazado      =           A=       ",13,10,
  74.      db " Cero            =                                B=       ",13,10,
  75.      db " Signo           =                         resultado       ",13,10,
  76.      db " Desbordamiento  =                                         ",13,10,36
  77.                                                                      
  78.    B db "  ",36 ;variable xa impresion hexadecimal y otras
  79.    A dw ?       ;1er valor a introducir
  80.    C dw ?       ;segundo valor a introducir
  81.    G db ?  
  82.    M dw ?       ;resultado de suma o resta
  83.    I dw ?       ;recoje un caracter ya sea +-
  84.    X db 40  ;variable de barrido de impresion
  85.                                                     make_minus db ?
  86.  ten dw 10
  87.  msg db    0,25,36
  88.  K   db 16
  89.  bla db "   ",36
  90.              ;variables de control de ciclo
  91.  U   db 40
  92.  V   db 40
  93.  W   db 37
  94. flag dw ?      ;variable para almacenar el registro de estado
  95.  ntr db "0",36  
  96.  control db 40  
  97.  ecchi db 40
  98.  
  99.    
  100. .stack
  101.    
  102. .code
  103.        
  104.     mov ax,@data
  105.     mov ds,ax  
  106.        
  107.     cursor_xy 0,1      
  108.     print h1        
  109.     cursor_xy 26,6  ;coloca cursor en el primer ingreso del signo aritmetico
  110.    
  111.    
  112. ciclo:    
  113.    
  114.     mov I,0
  115.     cursor_xy 26,6
  116.     print bla
  117.     cursor_xy 26,6
  118.     getint  I
  119.     mov ax,I
  120.     mov B,al ;se imprime  
  121.     print B    
  122.    
  123.     cmp I,4E2Bh    ;podeis cambiar esto a 1 y funcionara con el 1 del teclado
  124.     je  suma
  125.    
  126.     cmp I, 4A2Dh   ;igual podeis cambiar a 2
  127.     je  resta
  128.    
  129.     cmp I,01
  130.     je  final
  131.    
  132.     print error
  133.     jmp ciclo
  134.    
  135.     ;call SCAN_NUM   ;scanea el signo aritmetico    
  136.     ;mov     G,cx      
  137.    
  138.    
  139. suma:
  140.      
  141.     mov cx,0        ; en cx queda un valor hay que resetearlo para que no haya basura en el valor que se vuelve a introducir nuevamente
  142.     mov A,0         ;limpiamos el valor que tenia la variable A
  143.     cursor_xy 0,7  
  144.     print h2
  145.     cursor_xy 38,7  ;coloca cursor en el primer ingreso del primer valor
  146.     call SCAN_NUM   ;scanea el primer valor
  147.     mov     A,cx    
  148.    
  149.     cmp   A,128
  150.     je    suma
  151.    
  152.     cmp   A,-129
  153.     je    suma
  154.    
  155.     mov cx,0
  156.     mov C,0
  157.     cursor_xy 0,8
  158.     print h3
  159.     cursor_xy 38,8  ;coloca cursor en el primer ingreso del segund valor
  160.     call SCAN_NUM   ;scanea el segundo valor
  161.     mov     C,cx    
  162.    
  163.     cmp   C,128
  164.     je   suma
  165.    
  166.     cmp   C,-128
  167.     je    suma
  168.    
  169.     mov  ax,A ; mov para sumar
  170.     add  ax,C ; anade a ax lo q tiene c
  171.     mov  M,ax ; mov la suma a la variable M
  172.    
  173.     mov ax,M
  174.     xchg al,ah
  175.     push ax
  176.     call HEXA
  177.        
  178.     cursor_xy 60,22    
  179.     print B   ;imprime la parte high de ax osea M
  180.    
  181.     mov  ax,M
  182.     push ax
  183.     call HEXA
  184.    
  185.    
  186.     cursor_xy 62,22
  187.     print B ;imprime 1byte de la parte low de ax osea M
  188.    
  189.     cursor_xy 0,14
  190.     print h4 ;imprime esquema de flag
  191.    
  192.    
  193.     mov  ax,A ; mov para sumar
  194.     add  ax,C ; anade a ax lo q tiene c
  195.        
  196.     pushf    ; ax=Flag
  197.     pop ax ;pop F para almacenar las flags
  198.    
  199.     cursor_xy 0,16  ;impresion de flags
  200.     mov flag,ax
  201.                              
  202.     jmp binario4
  203.        
  204.    
  205.    
  206.    
  207. resta:  
  208.    
  209.     mov cx,0        ; en cx queda un valor hay que resetearlo para que no haya basura en el valor que se vuelve a introducir nuevamente
  210.     mov A,0         ; limpiamos el valor que habia en A
  211.     cursor_xy 0,7  
  212.     print h2
  213.     cursor_xy 38,7  ;coloca cursor en el primer ingreso del primer valor
  214.     call SCAN_NUM   ;scanea el primer valor
  215.     mov     A,cx  
  216.    
  217.     cmp   A,128
  218.     je   resta
  219.    
  220.     cmp   A,-129
  221.     je    resta
  222.    
  223.     mov cx,0        ; en cx queda un valor hay que resetearlo para que no haya basura en el valor que se vuelve a introducir nuevamente
  224.     mov C,0         ;limpiamos el valor que queda en C
  225.     cursor_xy 0,8
  226.     print h3
  227.     cursor_xy 38,8  ;coloca cursor en el primer ingreso del segund valor
  228.     call SCAN_NUM   ;scanea el segundo valor
  229.     mov     C,cx
  230.    
  231.     cmp   C,128
  232.     je   resta
  233.    
  234.     cmp   C,-129
  235.     je    resta  
  236.    
  237.    
  238.     mov  ax,A       ; mov para sumar
  239.     sub  ax,C       ; anade a ax lo q tiene c
  240.     mov  M,ax       ; mov la suma a la variable M
  241.    
  242.     mov ax,M
  243.     xchg al,ah
  244.     push ax
  245.     call HEXA
  246.     cursor_xy 60,22
  247.     print B         ;imprime la parte high de ax osea M
  248.    
  249.     mov ax,M
  250.     push ax
  251.     call HEXA
  252.     cursor_xy 62,22
  253.     print B         ;imprime 1byte de la parte low de ax osea M
  254.    
  255.    
  256.    
  257.     cursor_xy 0,14
  258.     print h4        ;imprime esquema de flag
  259.    
  260.     mov  ax,A ; mov para sumar
  261.     sub  ax,C ; anade a ax lo q tiene c
  262.        
  263.     pushf    ; ax=Flag
  264.     pop ax ;pop F para almacenar las flags
  265.    
  266.     cursor_xy 0,16  ;impresion de flags
  267.     mov flag,ax
  268.                                        
  269.     jmp binario4
  270.        
  271.    
  272.  
  273. binario1:
  274.        
  275.         mov   ax,A  
  276.                             ;mov   bx,ax
  277.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  278.        
  279.        
  280.         cursor_xy U,9
  281.         add   al,48     ;suma para que aparezca el caracter en pantalla ascii
  282.         putc  al
  283.        
  284.         sub   U,2       ; y esto para convertir a octal y ya
  285.         shr   A,1
  286.         dec   K                ;sub K,1
  287.          
  288.         cmp U,28        ;barrido para impresion de pantalla
  289.         jae binario1
  290.         add U,14
  291.        
  292.         jmp binario2
  293.        
  294. binario2:
  295.  
  296.         mov   ax,C  
  297.                             ;mov   bx,ax
  298.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  299.        
  300.        
  301.         cursor_xy V,10
  302.         add   al,48    ;suma para que aparezca el caracter en pantalla ascii
  303.         putc  al
  304.        
  305.         sub   V,2  ; y esto para convertir a octal y ya
  306.         shr   C,1
  307.         dec   K                ;sub K,1
  308.          
  309.         cmp V,28      ;barrido para impresion de pantalla
  310.         jae binario2
  311.         add V,14
  312.         jmp binario3  
  313.        
  314. binario3:
  315.  
  316.          
  317.         mov   ax,M  
  318.                                   ;mov   bx,ax
  319.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  320.        
  321.        
  322.         cursor_xy X,11
  323.         add   al,48    ;suma para que aparezca el caracter en pantalla ascii
  324.         putc  al
  325.        
  326.         sub   X,2  ; y esto para convertir a octal y ya
  327.         shr   M,1
  328.         dec   K                ;sub K,1
  329.          
  330.         cmp X,28      ;barrido para impresion de pantalla
  331.         jae binario3
  332.         add X,14  
  333.         jmp ciclo
  334.  
  335. binario4:
  336.  
  337.          
  338.         mov   ax,flag  
  339.                                   ;mov   bx,ax
  340.         and   ax,1          ;cambias esto            ; Residuo de dividir entre 2  
  341.        
  342.        
  343.         cursor_xy W,16
  344.         add   al,48    ;suma para que aparezca el caracter en pantalla ascii
  345.         putc  al
  346.        
  347.         sub   W,2  ; y esto para convertir a octal y ya
  348.         sub   control,2
  349.         shr   flag,1
  350.                        ;sub K,1
  351.        
  352.         cmp   ecchi,40
  353.         je    acarreo
  354.         cmp   control,34
  355.         je    par
  356.         cmp   control,30
  357.         je    aux
  358.         cmp   control,26
  359.         je    zero
  360.         cmp   control,24
  361.         je    sig
  362.         cmp   control,20
  363.         je    inter
  364.        
  365.        
  366.          
  367.         cmp W,18      ;barrido para impresion de pantalla
  368.         jae binario4
  369.         add W,20
  370.         add control,20
  371.         jmp binario1
  372.        
  373.        
  374. par:
  375.         cursor_xy     20,19
  376.         putc al
  377.         jmp binario4  
  378.  
  379. zero:
  380.         cursor_xy     20,21
  381.         putc al
  382.         jmp binario4
  383. sig:
  384.         cursor_xy     20,22
  385.         putc al
  386.         cursor_xy     20,23
  387.         print ntr
  388.         jmp binario4
  389. inter:  
  390.         cursor_xy     40,19
  391.         putc al
  392.         cursor_xy     40,18
  393.         print ntr
  394.         cursor_xy     40,20
  395.         print ntr
  396.         jmp binario4
  397.  
  398. acarreo:
  399.        
  400.         cursor_xy     20,18
  401.         putc al
  402.         sub ecchi,2
  403.         jmp binario4
  404. aux:
  405.         cursor_xy     20,20
  406.         putc al
  407.         jmp binario4        
  408.        
  409.                          
  410. final:
  411.     mov ah,21h
  412.     int 21h
  413.              
  414.              
  415.              
  416.              
  417.              
  418.              
  419.              
  420.              
  421.              
  422.              
  423.              
  424.              
  425.              
  426.              
  427.              
  428.        
  429.      
  430. ;/////////RUTINA SCAN_NUM
  431.    
  432. ; -32768 : 65535
  433. ; gets the multi-digit SIGNED number from the keyboard,
  434. ; and stores the result in CX register:
  435. SCAN_NUM        PROC    NEAR
  436.         PUSH    DX
  437.         PUSH    AX
  438.         PUSH    SI
  439.        
  440.         MOV     CX, 0
  441.  
  442.         ; reset flag:
  443.         MOV     make_minus, 0
  444.  
  445. next_digit:
  446.  
  447.         ; get char from keyboard
  448.         ; into AL:
  449.         MOV     AH, 00h
  450.         INT     16h
  451.         ; and print it:
  452.         MOV     AH, 0Eh
  453.         INT     10h
  454.  
  455.         ; check for MINUS:
  456.         CMP     AL, '-'
  457.         JE      set_minus
  458.  
  459.         ; check for ENTER key:
  460.         CMP     AL, 0Dh  ; carriage return?
  461.         JNE     not_cr
  462.         JMP     stop_input
  463. not_cr:
  464.  
  465.  
  466.         CMP     AL, 8                   ; 'BACKSPACE' pressed?
  467.         JNE     backspace_checked
  468.         MOV     DX, 0                   ; remove last digit by
  469.         MOV     AX, CX                  ; division:
  470.         DIV     ten                  ; AX = DX:AX / 10 (DX-rem).
  471.         MOV     CX, AX
  472.         PUTC    ' '                     ; clear position.
  473.         PUTC    8                       ; backspace again.
  474.         JMP     next_digit
  475. backspace_checked:
  476.  
  477.  
  478.         ; allow only digits:
  479.         CMP     AL, '0'
  480.         JAE     ok_AE_0
  481.         JMP     remove_not_digit
  482. ok_AE_0:        
  483.         CMP     AL, '9'
  484.         JBE     ok_digit
  485. remove_not_digit:      
  486.         PUTC    8       ; backspace.
  487.         PUTC    ' '     ; clear last entered not digit.
  488.         PUTC    8       ; backspace again.        
  489.         JMP     next_digit ; wait for next input.      
  490. ok_digit:
  491.  
  492.  
  493.         ; multiply CX by 10 (first time the result is zero)
  494.         PUSH    AX
  495.         MOV     AX, CX
  496.         MUL     ten                  ; DX:AX = AX*10
  497.         MOV     CX, AX
  498.         POP     AX
  499.  
  500.         ; check if the number is too big
  501.         ; (result should be 16 bits)
  502.         CMP     DX, 0
  503.         JNE     too_big
  504.  
  505.         ; convert from ASCII code:
  506.         SUB     AL, 30h
  507.  
  508.         ; add AL to CX:
  509.         MOV     AH, 0
  510.         MOV     DX, CX      ; backup, in case the result will be too big.
  511.         ADD     CX, AX
  512.         JC      too_big2    ; jump if the number is too big.
  513.  
  514.         JMP     next_digit
  515.  
  516. set_minus:
  517.         MOV     make_minus, 1
  518.         JMP     next_digit
  519.  
  520. too_big2:
  521.         MOV     CX, DX      ; restore the backuped value before add.
  522.         MOV     DX, 0       ; DX was zero before backup!
  523. too_big:
  524.         MOV     AX, CX
  525.         DIV     ten  ; reverse last DX:AX = AX*10, make AX = DX:AX / 10
  526.         MOV     CX, AX
  527.         PUTC    8       ; backspace.
  528.         PUTC    ' '     ; clear last entered digit.
  529.         PUTC    8       ; backspace again.        
  530.         JMP     next_digit ; wait for Enter/Backspace.
  531.        
  532.        
  533. stop_input:
  534.         ; check flag:
  535.         CMP     make_minus, 0
  536.         JE      not_minus
  537.         NEG     CX
  538. not_minus:
  539.  
  540.         POP     SI
  541.         POP     AX
  542.         POP     DX
  543.         RET
  544.  
  545. SCAN_NUM        ENDP
  546.  
  547. ;//////// RUTINA HEXADECIMAL
  548.  
  549. Hexa        proc    near
  550.             push    bp
  551.             mov     bp,sp
  552.             mov     al,[bp+4]
  553.             shr     al,4
  554.             add     al,48
  555.             cmp     al,58
  556.             js      nible2
  557.             add     al,7
  558. nible2:     mov     B,al
  559.             mov     al,[bp+4]
  560.             shl     al,4
  561.             shr     al,4
  562.             add     al,48
  563.             cmp     al,58
  564.             js      nible1
  565.             add     al,7
  566. nible1:     mov     B[1],al
  567.             pop     bp
  568.             ret
  569. Hexa        endp
  570.  
  571. ;////////////FIN DEL PROGRAMA
  572.  
  573.  
  574.  
  575. .exit
  576.  
« Última modificación: Enero 06, 2018, 05:53:42 pm por Olger346 »
"Cuando se nace pobre, estudiar es el mayor acto de rebeldía contra el sistema. El saber rompe las cadenas de la esclavitud" -Tomas Bulat.

Desconectado rfgaz

  • *
  • Underc0der
  • Mensajes: 9
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #1 en: Diciembre 23, 2015, 07:47:09 pm »
Muy bueno aunque entienda muy poco, eso hace que me agrade ver el código.


Desconectado UpecBlack

  • *
  • Underc0der
  • Mensajes: 69
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #2 en: Enero 01, 2016, 01:07:43 am »
es para NASM o FASM??

Desconectado Juan

  • *
  • Underc0der
  • Mensajes: 159
  • Actividad:
    0%
  • Reputación 0
  • Ex-Drinky
    • Ver Perfil
« Respuesta #3 en: Enero 02, 2016, 11:56:48 am »
You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
es para NASM o FASM??

FASM no es. NASM, no lo sé.

Desconectado Psymera

  • *
  • Underc0der
  • Mensajes: 75
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #4 en: Enero 02, 2016, 08:50:31 pm »
Se ve mas como MASM :p
El conocimiento es libre...
La información no lo es xD

 

¿Te gustó el post? COMPARTILO!