EMULADOR 8051 (9/12) (EJECUTA)

    Como ya se ha visto como ejecutar el programa en la rutina BUSES, ahora podemos crear la rutina del menú de ejecución. Esta rutina permitirá ejecutar el programa en varios modos:

    PASO - Avanza un paso   

   Modos de trabajo

        TRACE - ejecuta una  instrucción cada vez que se pulse paso

       CONTINUO- Ejecuta mediante reloj controlado por pc de forma continua el programa. No hay visualización de registros

      EXTER - ejecuta a velocidad de reloj externo. No hay visualización de registros

    ANIMATE - ejecuta de forma continua el programa mediante pulsos del PC, mostrando en cada paso el estado de los registros, memoria y refrescando el listado de instrucciones

      A demás en este módulo están las funciones para añadir, eliminar y presentar los puntos de interrupción. Estos puntos podrán ser programados, para detener el programa en ellos cuando se ejecuten en modo continuo y anímate.

    Como se puede ver en el programa esta función llama a interpreta.  Al igual que la anterior función, en modo continuo, anímate y paso a paso, necesita conocer el número de pulsos de reloj de cada instrucción para ejecutarla al completo.

EJECUTA.ASM

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/

include main.mac
include stdio.mac
include 48iocent.mac
include mouse.mac
include 8051.mac
INCLUDE WINDOW.MAC

.model compact,pascal

        public ejecuta
        public masBrk
        public menosBrk
        public prn_brk

;CONTROL
PASO EQU 1
MANUAL EQU 2
TRACE EQU 4
CONTINUO EQU 8
EXTER EQU 16
ANIMATE EQU 32


.data
extrn m_ventana:byte
extrn control:byte
extrn des_base:word
extrn mostrada:word
extrn vez_sec:byte
extrn vez_reg:byte
extrn freg:byte
extrn velocida:word
public brk_gotol
public brk_goto
public tabla_brk
public Dir_cur

Dir_cur dw 0
brk_gotol db 0
brk_goto dw 0
tabla_brk db 20 dup (0,0,0)
dato dw 0,0
direccion dw 0,0
borra db "    ",0
stop db 0
mBrk db "Direcc.",0
mlista db "Lista BRK",0
TablaLlena db "Tabla de punteros llena",0
nada db 0
x db 0
y db 0
ends

.code


        extrn secuencia:near
        extrn prn_reg:near
        extrn conf_int:near
        extrn _trace:near
        extrn Interpreta:near

ejecuta proc near
        call conf_int

        test CONTROL,CONTINUO
        jNz c1
        JMP C
c1:
        test control,Paso
        jz c2
        jmp c
c2:
        dec velocida+4
        jz c3
        jmp b
c3:
        mov ax,velocida
        mov velocida+4,ax
        dec velocida+6
        jnz b
        mov ax,velocida
        mov velocida+6,ax
        cmp stop,1
        jz Brk_off
        mov dx,Dir_cur
        cmp brk_gotol,1
        jnz otro_punto
        cmp brk_goto,dx
        jz no_paso
otro_punto:
        mov cx,20
        mov bx,offset tabla_brk
busca:
        cmp byte ptr [bx],1
        jnz no_brk
        cmp [bx+1],dx
        jz no_paso
no_brk:
       add bx,3
        loop busca
brk_off:
        mov stop,0
        or CONTROL,PASO
        ret
no_paso:
        mov stop,1
        mov brk_gotol,0
        and CONTROL, not CONTINUO
        and CONTROL, NOT ANIMATE
        jmp muestra
b:
        ret
c:
        test CONTROL,PASO
        jz nopaso
nofinpaso:
        mov dx,Dir_cur
        call interpreta
        dec dx
        mov bx,ax
        mov cl,[bx+1]
        xor ch,ch
        call _trace
        test CONTROL,ANIMATE
        JZ NOPASO
muestra:
        cmp freg,1
        jnz noregistro
        call prn_reg
        mov vez_reg,1
noregistro:
        mov cx,Dir_cur
        mov des_base,cx
        mov mostrada,0
        call secuencia
        mov vez_sec,1
nopaso:
        ret
ejecuta endp
masBrk proc near
        getwindow m_ventana,6,34,8,44
        window 6,34,8,44,MBRK
        gotoxy 35,7
        scanf Dato,@h
        putwindow m_ventana,6,34,8,44
        mov cx,20
        mov bx,offset Tabla_BRK
Busca1:
        cmp byte ptr [bx],0
        jz libre
        add bx,3
        loop Busca1
        getwindow  m_ventana,10,10,12,37
        window 10,10,12,37,nada
        gotoxy 11,11
        printf TablaLlena
        getch al
        putwindow m_ventana,10,10,12,37
        ret
libre:  mov byte ptr [bx],1
        mov ax,dato
        mov [bx+1],ax
        ret
masBrk endp
menosBrk proc near
        getwindow m_ventana,6,34,8,44
        window 6,34,8,44,MBRK
        gotoxy 35,7
        scanf Dato,@h
        putwindow m_ventana,6,34,8,44
        mov cx,20
        mov bx,offset Tabla_BRK
Busca2:
        cmp byte ptr [bx],0
        jz otro
        mov ax,[bx+1]
        cmp ax,dato
        jnz otro
        mov byte ptr [bx],0
otro:
        add bx,3
        loop Busca2
        ret
menosBrk endp
prn_brk proc near
        window 6,34,17,45,mLista
        mov x,35
        mov y,7
        mov bx,offset Tabla_brk
        mov cx,20
sigui:
        cmp byte ptr [bx],0
        jz sigue
        gotoxy x,y
        mov ax,[bx+1]
        mov dato,ax
        printf dato,@h
        inc y
        cmp y,17
        jnz sigue
        mov y,7
        mov x,41
sigue:
        add bx,3
        loop sigui
        ret
prn_brk endp

end ejecuta

EMULADOR 8051 (8/12) (TEST BUSES)

   Hemos visto como leer la memoria de la placa prototipo, como leer el programa e interpretarlo, como ver el valor de los registros. Pero todo esto solo se podrá hacer si la placa prototipo está correctamente diseñada y cableada. Por ello algo importante que debe tener el emulador es una forma de testear el prototipo.

   En realidad, en cualquier prototipo, lo primero que habrá que hacer con el emulador es testear la placa. A partir de ahí podremos introducir un programa y ejecutarlo, pero nunca antes de disponer de hard bien montado.

    Esta rutina, como parte del emulador permite la ejecución directa del micro en tres modos, y aprovechar esto para visualizar el estado de los buses de control y datos:

     Manual - los pulsos de reloj se mandan mediante el ratón. Ejecuta microinstrucción a microinstrucción para ver el accionamiento de cada señal de bus.

    Paso a paso- Ejecuta instrucción a instrucción.

   Continuo- Ejecuta de forma continua el programa, pero controlado por el PC, de forma que entre cada instrucción lee el estado de los buses y los presenta en pantalla. La velocidad de ejecución, por lo tanto, no será la real.

   Control Externo.- Da paso al cristal del reloj de la placa, de forma que el programa funciona a frecuencia real.

    Como se puede ver en el programa esta función llama a interpreta. No es para ver el formato de la instrucción, sino para conocer sus ciclos de reloj.

BUSES.ASM

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/

include main.mac
include stdio.mac
include 48iocent.mac
include mouse.mac

include 8051.mac

.model compact,pascal


;CONTROL
PASO EQU 1
MANUAL EQU 2
TRACE EQU 4
CONTINUO EQU 8
EXTER EQU 16

led macro puerto,senal
   local fuera
        mov al,' '
        test Puerto,senal
        jz fuera
        mov al,' '
fuera:
        putchar al
endm


.data
extrn Dir_cur:word
public control
public Dato
Pantalla label byte
DB '╔═══════════════════════════ Monitor 8051══════════════════════════════════════╗'
DB '║                                                                              ║'
DB '║     Nivel alto                                                             ║'
DB '║    ╔══════════════════╗     ╔═════════════════╗                              ║'
DB '║    ║   Interrupciones ║     ║    Control Bus  ║                              ║'
DB '║    ╠══════════════════╣     ╠═════════════════╣                              ║'
DB '║    ║    /INT0         ║     ║       /WR       ║                              ║'
DB '║    ║    /INT1         ║     ║       /RD       ║                              ║'
DB '║    ║                  ║     ║       ALE       ║                              ║'
DB '║    ║    RESET         ║     ║       /PSEN     ║                              ║'
DB '║    ╚══════════════════╝     ╚═════════════════╝                              ║'
DB '║                                                                              ║'
DB '║       DIRECCION       DATO                                                   ║'
DB '║       ┌───────┐  ┌─────┬─────┐                                               ║'
DB '║       │       │  │     │     │                                               ║'
DB '║       └───────┘  └─────┴─────┘                                               ║'
DB '║                                                                              ║'
DB '║      Paso              Velocidad  1                                          ║'
DB '║                                                                              ║'
DB '║      Manual            Control externo                                       ║'
DB '║      Trace                                                                   ║'
DB '║      Continuo          Salir                                                 ║'
DB '║                                                                              ║'
DB '╚══════════════════════════════════════════════════════════════════════════════╝'
DB 0




dato dw 0,0
direccion dw 0,0
CONTROL DB 0
borra db "    ",0
borraa db "      ",0
raton dw 0
velocidad dw 1,0
          dw 1,1

.code

        public buses
        public conf_int
        extrn _reset:near
        extrn interpreta:near
        extrn _trace:near
        extrn Dma_off:near

buses proc near
        mouse off
        clrscr                          ;inicializacion programa
        printf Pantalla
        call Dma_off
        mouse on

present:
        inp cl,PA1              ;lectura de señales AD0-AD7
        inp ch,PB1              ;A8-A15
        inp dl,PC1              ;CONTROL MICRO
        call actualiza          ;actualiza pantalla
        getmouse                ;comprueba el estado del rfaton
        cmp ax,1
        jnz pantal              ;si no se ha pulsado se sigue
        cmp ax,raton            ;si se pulso se verifica si ha sido un
        mov raton,ax            ;flanco de subida
        jnz seleccion           ;si es asi se selecciona la opcion deseada
pantal:
        mov raton,ax
pantall:
        call conmutador         ;se llama a la subrutina que realiza las
        jmp present             ;acciones de los conmutadores seleccionados

seleccion:                      ;selecciona el comnutador deseado
        getmousex               ;comprueba las posiciones del raton
        sub ax,7*8              ;y si estan dentro del margen deseado se
        jb no
        cmp ax,7*8              ;pone el indicador correspondiente
        jb s0
   no:
        getmousex
        sub ax,25*8
        jb pantall
        cmp ax,5*8
        jnb pantall
        jmp a1
   s0:
        getmousey
        cmp ax,17*8
        jnz s1
        xor CONTROL,PASO
        jmp present
  s1:
        cmp ax,19*8
        jnz s2
        call conf_int
        mov CONTROL,MANUAL
        jmp present
   s2:
        cmp ax,20*8
        jnz s3
        call conf_int
        mov CONTROL,TRACE
        jmp present
    s3:
        cmp ax,21*8
        jnz s6
        call conf_int
        mov CONTROL,CONTINUO
        JMP PRESENT
    s6:
        cmp ax,9*8                      ;RESET
        jnz s4
        call _reset
S4:
        jmp present

    a1:
        getmousey
        cmp ax,21*8
        jnz aa
        jmp fin
    aa:
        cmp ax,19*8
        jnz a2
        call conf_ext
        mov CONTROL,EXTER
        jmp s4
    a2:
        cmp ax,17*8
        jnz s4
        setcursor on
de_nuevo:
        gotoxy 35,17
        printf borraa
        gotoxy 35,17
        scanf velocidad
        cmp velocidad,20
        ja de_nuevo
        mov ax,velocidad
        mov velocidad+4,ax
        mov velocidad+6,ax
        setcursor off
        jmp s4
 fin:
        ret

buses endp
conf_int proc near
        test CONTROL,EXTER
        jz no_conf
        outp p0,BUSRQPC_ON
        outp p0,CLK_OFF
        outp p0,EXTERNO_OFF
  NO_CONF:
        ret
conf_int endp
conf_ext proc near
        outp p0,CLK_ON
        OUTP P0,BUSRQPC_ON
        outp P0,EXTERNO_ON
        ret
conf_ext endp
actualiza proc near
        test dl,ALE
        jnz es_direcc
no_es_direcc:
        test dl,RD
        jz es_dato
        test dl,WR
        jz es_dato
        test dl,PSEN
        jz es_dato
        jmp no_es_dato

es_direcc:
        mov word ptr direccion,cx
        mov Dir_cur,cx
        gotoxy 10,14
        printf borra
        gotoxy 10,14
        printf direccion,@h
        gotoxy 21,14
        printf borra
        gotoxy 26,14
        printf borra
        jmp no_es_dato
es_dato:
        mov byte ptr dato,cl
        gotoxy 21,14
        printf dato,@h
        gotoxy 26,14
        printf byte ptr dato
no_es_dato:
        gotoxy 7,6
        led dl,INT0
        gotoxy 7,7
        led dl,INT1
        gotoxy 7,9
        led dl,RESET
        gotoxy 34,6
        led dl,WR
        gotoxy 34,7
        led dl,RD
        gotoxy 34,8
        led dl,ALE
        gotoxy 34,9
        led dl,PSEN
        gotoxy 4,17
        led CONTROL,PASO
        gotoxy 4,19
        led CONTROL,MANUAL
        gotoxy 4,20
        led CONTROL,TRACE
        gotoxy 4,21
        led CONTROL,CONTINUO
        gotoxy 23,19
        led CONTROL,EXTER
        ret
actualiza endp
conmutador proc near
        test CONTROL,CONTINUO
        jz b1
        dec velocidad+4
        jnz b
        mov ax,velocidad
        mov velocidad+4,ax
        dec velocidad+6
        jnz b
        mov ax,velocidad
        mov velocidad+6,ax
        outp p0,CLK_ON
        outp p0,CLK_OFF

b:      ret
b1:
        test CONTROL,TRACE
        jz b2
        test CONTROL,PASO
        jz b
        mov dx,Dir_cur
        call interpreta
        dec dx
        mov bx,ax
        mov cl,[bx+1]
        xor ch,ch
        call _trace
        gotoxy 21,14
        printf dato,@h
        gotoxy 26,14
        printf byte ptr dato

Pasos:
        ret
b2:
        test CONTROL,MANUAL
        jz b3
        test CONTROL,PASO
        jz b3
        and CONTROL,NOT PASO
        outp P0,CLK_ON
        outp P0,CLK_OFF
b3:     ret
conmutador endp

end buses

EMULADOR 8051 (6/12) (LISTADO)

   Como función superior a las anteriores está la que pongo hoy. Esta función generará el listado completo del programa sobre fichero, apoyándose en las anteriores: PRN_INST e INTERPRETE.

    Abrirá un fichero e irá enviando a él todas las líneas de programa desensambladas.

LISTADO.ASM

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/

include main.mac
include string.mac
include io.mac

.model compact,pascal

        public listado
.data
extrn prn_ini:word
extrn prn_fin:word
extrn nombrelst:byte
public bufferprn
dato dw 0,0
bufferprn db 50 dup (0)
handle dw 0
nb dw 0
tab1 db " ",0
tab db "       ",0


.code
        
        extrn interpreta:near
        extrn prn_inst:near
        extrn Dma_on:near
        extrn Dma_off:near
listado proc near
        call Dma_on
        creat nombrelst,_Archivo,handle

        mov dx,prn_ini
 otro:
        mov dato,dx
        itoa bufferprn,dato,16
        strlen bufferprn
        mov nb,ax
        cmp ax,3
        jz t3
        strcat bufferprn,bufferprn,tab1
        cmp nb,2
        jz t3
        strcat bufferprn,bufferprn,tab1
t3:
        strcat bufferprn,bufferprn,tab
        call prn_inst
        strlen bufferprn
        mov nb,ax
        write handle,nb,bufferprn
n_prn:
        call interpreta
        mov bx,ax
        mov al,[bx]
        cmp al,0
        jz contado
        inc dx
        cmp al,2
        jz acuenta
        cmp al,4
        jz acuenta
        cmp al,5
        jz acuenta
        cmp al,8
        jnz contado
acuenta:
        inc dx
contado:
        cmp dx,prn_fin
        jae fin
        jmp otro
fin:
        close handle
        call Dma_off
        ret

listado endp

end listado

EMULADOR 8051 (5/12) (DESENSAMBLADOR SOBRE BUFFER)

    Como deseamos tener una copia del programa en papel para analizarlo con tranquilidad, debemos tener la posibilidad de imprimir el programa desensamblado, o almacenarlo en un fichero.

    Esta es, pues, la versión de listado de programa sobre buffer. Básicamente es la misma que la de impresión de pantalla, con la salvedad de que aquí no se limitará a un número concreto de instrucciones, sino que realizará el programa completo. Pero ese control lo llevará el programa padre. Este versión de la instrucción se limita a cambiar la salida de impresión de la pantalla a un buffer de impresión llamado bufferprn, sobre el que se generará el listado y que posteriormente será lanzado sobre la impresora o a un fichero.

PRN_INST.ASM

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/

include main.mac
include stdio.mac
include io.mac
include string.mac

.model compact,pascal

             public prn_inst
.data
extrn bufferprn:byte
dato dw 0,0
registro db "P0.",5 DUP (0)
         db "TCON.",3 DUP (0)
         db "P1.",5 DUP (0)
         db "SCON.",3 DUP (0)
         db "P2.",5 DUP (0)
         db "IE.",5 DUP (0)
         db "P3.",5 DUP (0)
         db "IP.",5 DUP (0)
         db "PSW.",4 DUP (0)
         db "ACC.",4 DUP (0)
         db "B.",6 DUP (0)
hprn dw 0
numero db 10 dup (0)
nlinea db 13,10,0
mas db "+",0
menos db  "-",0

code
        
       
        extrn interpreta:near
        extrn lee:near
prn_inst proc near  uses dx cx bx
        
        call interpreta
        mov bx,ax
        mov al,[bx]
        cmp al,0                        ;solo codigo instrucc. de 1 byte
        jnz decod1
        strcat bufferprn,bufferprn,[bx+3]
        jmp linea
decod1:
        cmp al,1                 ;1 codigo inst , 1 byte de dato
        jnz decod2
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea
decod2:
        cmp al,2                ;1codico + 2 byte
        jnz decod3
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov ch,al
        call lee
        inc dx
        mov cl,al
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea

decod3:
        cmp al,3                ;1 codigo + 1 byte + codigo
        jnz decod4
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        inc bx
        inc bx
busca1:
        inc bx
        cmp byte ptr [bx],0
        jnz busca1
        strcat bufferprn,bufferprn,[bx+1]
        jmp linea

decod4:                         ;1 codigo + 2 byte + codigo
        cmp al,4
        jnz decod5
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov cl,al
        call lee
        inc dx
        mov ch,al
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        inc bx
        inc bx
busca2:
        inc bx
        cmp byte ptr [bx],0
        jnz busca2
        strcat bufferprn,bufferprn,[bx+1]
        jmp linea
decod5:
        cmp al,5                ;1 codigo + 1 byte relativo + codigo + byte
        jz escod5
        jmp DECOD6
escod5:
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        cmp cl,0
        jz busc3
        test cx,80h
        jz positivo1
        strcat bufferprn,bufferprn,menos
        not cl
        inc cx
        jmp short negativo1
positivo1:
        strcat bufferprn,bufferprn,mas
negativo1:
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
busc3:
        inc bx
        inc bx
busca3:
        inc bx
        cmp byte ptr [bx],0
        jnz busca3
        strcat bufferprn,bufferprn,[bx+1]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea

decod6:
        cmp al,6                        ;SALTO RELATIVO
        jnz decod7
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        cbw
        add ax,dx
        mov cx,ax
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea

decod7:
        cmp al,7                ;1 codigo + 1 byte relativo + codigo
        jz ss1
        jmp caso8
ss1:
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        cmp cl,0
        jz busc7
        test cx,80h
        jz positivo
        strcat bufferprn,bufferprn,menos
        not cl
        inc cx
        jmp short negativo
positivo:
        strcat bufferprn,bufferprn,mas
negativo:
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
busc7:
        inc bx
        inc bx
busca7:
        inc bx
        cmp byte ptr [bx],0
        jnz busca7
        strcat bufferprn,bufferprn,[bx+1]
        jmp linea

caso8:
        cmp al,8
        jz ss2
        jmp caso9
ss2:
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        inc bx
        inc bx
busca8:
        inc bx
        cmp byte ptr [bx],0
        jnz busca8
        strcat bufferprn,bufferprn,[bx+1]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea
caso9:
        cmp al,9                ;texto + direc 8 bits + texto + dato 8 bits rel
        jnz alcaso9
        jmp caso10
alcaso9:
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        inc bx
        inc bx
busca9:
        inc bx
        cmp byte ptr [bx],0
        jnz busca9
        strcat bufferprn,bufferprn,[bx+1]
        call lee
        inc dx
        cbw
        add ax,dx
        mov dato,AX
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea

caso10:
        cmp al,10                ;texto + direcc 11 bits
        jnz alcaso10
        jmp caso11
alcaso10:
        strcat bufferprn,bufferprn,[bx+3]
        dec dx      ;releeo el codigo para obtener la parte alta de la direccion
        call lee
        inc dx
        mov cl,5
        shr al,cl
        mov ch,al
        call lee
        inc dx
        mov cl,al
        mov  dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea
caso11:
        cmp al,11                ;texto + bit
        jnz alcaso11
        jmp caso12
alcaso11:
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        cmp al,7fh
        jbe directo
        push bx
        sub al,80h
        mov ah,al
        and al,07h
        push ax
        and ah,0f8h
        mov bl,ah
        xor bh,bh
        mov si,offset registro
        strcat bufferprn,bufferprn,[bx+3]     ;envia nombre del registro
        pop ax
        pop bx
directo:
        mov cl,al
        mov  dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea
caso12:
        cmp al,12                ;texto + bit + texto
        jnz alcaso12
        jmp caso13
alcaso12:
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        cmp al,7fh
        jbe directo12
        push bx
        sub al,80h
        mov ah,al
        and al,07h
        push ax
        and ah,0f8h
        mov bl,ah
        xor bh,bh
        mov si,offset registro
        strcat bufferprn,bufferprn,[bx+si]   ;envia nombre del registro
        pop ax
        pop bx
directo12:
        mov cl,al
        mov  dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        inc bx
        inc bx
busca12:
        inc bx
        cmp byte ptr [bx],0
        jnz busca12
        strcat bufferprn,bufferprn,[bx+1]
        jmp linea
caso13:
        cmp al,13                ;texto + bit + texto
        jnz alcaso13
        jmp linea
alcaso13:
        strcat bufferprn,bufferprn,[bx+3]
        call lee
        inc dx
        cmp al,7fh
        jbe directo13
        push bx
        sub al,80h
        mov ah,al
        and al,07h
        push ax
        and ah,0f8h
        mov bl,ah
        xor bh,bh
        mov si,offset registro
        strcat bufferprn,bufferprn,[bx+si]   ;envia nombre del registro
        pop ax
        pop bx
directo13:
        mov cl,al
        mov  dato,cx
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero

        inc bx
        inc bx
busca13:
        inc bx
        cmp byte ptr [bx],0
        jnz busca13
        strcat bufferprn,bufferprn,[bx+1]
        call lee
        inc dx
        cbw
        add ax,dx
        mov dato,AX
        itoa numero,dato,@h
        strcat bufferprn,bufferprn,numero
        jmp linea

linea:
        strcat bufferprn,bufferprn,nlinea

        ret
prn_inst endp

end prn_inst

EMULADOR 8051 (4/12) (DESENSAMBLADOR)

   Esta rutina será el nivel superior al interprete colocado dos entradas atrás. Apoyándose en el intérprete, esta función compondrá el texto completo de la instrucción en ensamblador, con los datos correspondiente de la instrucción.

  Para conseguirlo llamará con el código máquina de la instrucción al Intérprete, el cual le devolverá un puntero a la estructura de la instrucción. Según esta estructura, el desensamblador irá imprimiendo los textos que representan el código de instrucción e irá leyendo el resto de los datos para presentarlos posteriormente.

   Por todo esto la instrucción la llamé "presenta instrucción", dado que la hice de forma que directamente presentaba en pantalla la instrucción. Para usarla, simplemente, el programa que genera el listado de instrucciones irá situando en pantalla el puntero e irá llamando a esta función pasando en dx el offset de la instrucción en código máquina correspondiente.

PRES_INST.ASM

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/

include main.mac
include stdio.mac
.model compact,pascal
         public pres_inst
         
.data
dato dw 0,0
;lista de registros para colocar en su lugar durante la interpretación de la instrucción
registro db "P0.",5 DUP (0)
         db "TCON.",3 DUP (0)
         db "P1.",5 DUP (0)
         db "SCON.",3 DUP (0)
         db "P2.",5 DUP (0)
         db "IE.",5 DUP (0)
         db "P3.",5 DUP (0)
         db "IP.",5 DUP (0)
         db "PSW.",4 DUP (0)
         db "ACC.",4 DUP (0)
         db "B.",6 DUP (0)


.code
       
        extrn interpreta:near
        extrn lee:near
pres_inst proc uses cx bx
      ;en dx se le psasrá la direccción del código a interpretar
        call interpreta     ;llama a la interpretación indicando la dirección en dx
        mov bx,ax
        mov al,[bx]
        cmp al,0                        ;solo codigo instrucc. de 1 byte
        jnz decod1
        printf byte ptr [bx+3]
        jmp linea
decod1:
        cmp al,1                 ;1 codigo inst , 1 byte de dato
        jnz decod2
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        printf dato,@h
        jmp linea
decod2:
        cmp al,2                ;1codico + 2 byte
        jnz decod3
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov ch,al
        call lee
        inc dx
        mov cl,al
        mov  dato,cx
        printf dato,@h
        jmp linea

decod3:
        cmp al,3                ;1 codigo + 1 byte + codigo
        jnz decod4
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        printf dato,@h
        inc bx
        inc bx
busca1:
        inc bx
        cmp byte ptr [bx],0
        jnz busca1
        printf byte ptr [bx+1]
        jmp linea

decod4:                         ;1 codigo + 2 byte + codigo
        cmp al,4
        jnz decod5
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov cl,al
        call lee
        inc dx
        mov ch,al
        mov dato,cx
        printf dato,@h
        inc bx
        inc bx
busca2:
        inc bx
        cmp byte ptr [bx],0
        jnz busca2
        printf byte ptr [bx+1]
        jmp linea
decod5:
        cmp al,5                ;1 codigo + 1 byte relativo + codigo + byte
        jz escod5
        jmp DECOD6
escod5:
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        cmp cl,0
        jz busc3
        test cx,80h
        jz positivo1
        putchar '-'
        not cl
        inc cx
        jmp short negativo1
positivo1:
        putchar '+'
negativo1:
        mov dato,cx
        printf dato,@h
busc3:
        inc bx
        inc bx
busca3:
        inc bx
        cmp byte ptr [bx],0
        jnz busca3
        printf byte ptr [bx+1]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        printf dato,@h
        jmp linea

decod6:
        cmp al,6                        ;SALTO RELATIVO
        jnz decod7
        printf byte ptr [bx+3]
        call lee
        inc dx
        cbw
        add ax,dx
        mov dato,AX
        printf dato,@h
        jmp linea

decod7:
        cmp al,7                ;1 codigo + 1 byte relativo + codigo
        jnz caso8
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        cmp cl,0
        jz busc7
        test cx,80h
        jz positivo
        putchar '-'
        not cl
        inc cx
        jmp short negativo
positivo:
        putchar '+'
negativo:
        mov dato,cx
        printf dato,@h
busc7:
        inc bx
        inc bx
busca7:
        inc bx
        cmp byte ptr [bx],0
        jnz busca7
        printf byte ptr [bx+1]
        jmp linea

caso8:
        cmp al,8                ;texto + direc 8 bits + texto + dato 8 bits
        jnz caso9
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        printf dato,@h
        inc bx
        inc bx
busca8:
        inc bx
        cmp byte ptr [bx],0
        jnz busca8
        printf byte ptr [bx+1]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        printf dato,@h
        jmp linea

caso9:
        cmp al,9                ;texto + direc 8 bits + texto + dato 8 bits rel
        jnz caso10
        printf byte ptr [bx+3]
        call lee
        inc dx
        mov cl,al
        mov ch,0
        mov dato,cx
        printf dato,@h
        inc bx
        inc bx
busca9:
        inc bx
        cmp byte ptr [bx],0
        jnz busca9
        printf byte ptr [bx+1]
        call lee
        inc dx
        cbw
        add ax,dx
        mov dato,AX
        printf dato,@h
        jmp linea

caso10:
        cmp al,10                ;texto + direcc 11 bits
        jnz caso11
        printf byte ptr [bx+3]
        dec dx      ;releeo el codigo para obtener la parte alta de la direccion
        call lee
        inc dx
        mov cl,5
        shr al,cl
        mov ch,al
        call lee
        inc dx
        mov cl,al
        mov  dato,cx
        printf dato,@h
        jmp linea
caso11:
        cmp al,11                ;texto + bit
        jnz caso12
        printf byte ptr [bx+3]
        call lee
        inc dx
        cmp al,7fh
        jbe directo
        push bx
        sub al,80h
        mov ah,al
        and al,07h
        push ax
        and ah,0f8h
        mov bl,ah
        xor bh,bh
        mov si,offset registro
        printf byte ptr [bx+si]   ;envia nombre del registro
        pop ax
        pop bx
directo:
        mov cl,al
        mov  dato,cx
        printf dato,@h
        jmp linea
caso12:
        cmp al,12                ;texto + bit + texto
        jnz caso13
        printf byte ptr [bx+3]
        call lee
        inc dx
        cmp al,7fh
        jbe directo12
        push bx
        sub al,80h
        mov ah,al
        and al,07h
        push ax
        and ah,0f8h
        mov bl,ah
        xor bh,bh
        mov si,offset registro
        printf byte ptr [bx+si]   ;envia nombre del registro
        pop ax
        pop bx
directo12:
        mov cl,al
        mov  dato,cx
        printf dato,@h
        inc bx
        inc bx
busca12:
        inc bx
        cmp byte ptr [bx],0
        jnz busca12
        printf byte ptr [bx+1]
        jmp linea
caso13:
        cmp al,13                ;texto + bit + texto + dato 8bits
        jz acaso13
        jmp linea
acaso13:
        printf byte ptr [bx+3]
        call lee
        inc dx
        cmp al,7fh
        jbe directo13
        push bx
        sub al,80h
        mov ah,al
        and al,07h
        push ax
        and ah,0f8h
        mov bl,ah
        xor bh,bh
        mov si,offset registro
        printf byte ptr [bx+si]   ;envia nombre del registro
        pop ax
        pop bx
directo13:
        mov cl,al
        mov  dato,cx
        printf dato,@h

        inc bx
        inc bx
busca13:
        inc bx
        cmp byte ptr [bx],0
        jnz busca13
        printf byte ptr [bx+1]
        call lee
        inc dx
        cbw
        add ax,dx
        mov dato,AX
        printf dato,@h
        jmp linea

linea:
        ret
pres_inst endp

end pres_inst

EMULADOR 8051 (1/12) (INTERPRETE)

   Como parte fundamental de un emulador está el desensamblador.
    Ya tenemos resuelto el problema del Hardware, y conocemos como vamos a controlar las señales provenientes del microprocesador y la paca prototipo. Para ello he puesto los esquemas de las tarjetas y las funciones que darán el interface con las tarjetas.

    Ahora podemos ponernos al meollo de la cuestión. El entrono del depurador.
    Al menos debe de contener las siguientes características.
              - Debe de tener una ventana de datos de memoria, en la que se puedan modificar y visualizar estos.
              - Debe de ser capaz de mostrar el programa desensambaldo.
              - Debe mostrar los registros del microprocesador.
              - Debe de tener modo de ejecución continuo, paso a paso y puntos de ruptura.
              - Debe de se amigable, aunque lo estemos realizando en DOS y en Ensamblador.

    El hecho de usar ensamblador y no utilizar un entorno gráfico, fue debido en su momento a la necesidad de velocidad. Ahora, aunque los ordenadores son más rápidos, la velocidad nunca bien mal.
    ¿Por qué tanta necesidad de velocidad? Porque el traceo lo hace el ordenador directamente. Es el ordenador el que da los pulsos de reloj, para ir ejecutando las instrucciones, y además entre pulsos va a tomar datos de la placa a través de los buses. Por ello, si queremos tracear a una buena velocidad, necesitamos que el manejo del Hard sea lo más rápido posible. Necesitamos que la interpretación del código, el desensamblado también, y sobre todo necesitamos que la respuesta en pantalla sea instantanea.

    Es por ese motivo que la función Puts y Printf, que en su momento ya he puesto en el blog, no esté hecha mediante llamadas al DOS, sino mediante volcado directo a pantalla.

    Para  empezar el depurador, por lo tanto, voy  a comenzar por la rutina principal. La que desensambla.
    Para realizar el desensamblador de una forma muy rápida y con poco código, creo una tabla de desensamblado, en la cuál asignaremos un a serie de datos a cada código que encontremos en código máquina.
   
     Así mediante una tabla de indexado, llamada Tabla, accederemos a una tabla de interpretación de código. Cuando leamos un byte de código máquina, usaremos Tabla localizar el formato de la instrución que codifica.
   A través de ese puntero recorreremos la lista correspondiente de datos de la instrucción, que nos indicará:  

1. Byte 0 =  tipo instrucción

•  0  ----  inmediato            (1 byte)
•  1  ----  texto + num 8 bits   (2 bytes)
•  2  ----  texto + num 16 bits  (3 bytes)
•  3  ----  texto + num 8bits + texto
•  4  ----  texto + num 16 bits + texto
•  5  ----  texto + num 8 bits relativo + texto + num 8 bits
•  6  ----  texto + num 8 bits relativo
•  7  ----  texto + num 8 bits relativo + texto
•  8  ----  texto + num 8bits + texto + num 8 bits
•  9  ----  texto + num 8 bits + texto + num 8 bits relativo
• 10  ----  texto + num 11bits  (2 bytes)
• 11  ----  texto + num 8 bits ref_bit
• 12  ----  texto + num 8 bits ref_bit + texto
• 13  ----  texto + num 8 bits ref_bit + texto + num 8 bits relativo
• 0ffh  ----  nueva tabla INSTRUCCION COMPUESTA

1. byte 1 = Ciclos de reloj de la instrución
2. byte 2= numero de bytes de la instrucción
3. byte 3 en adelante =  Nemónico  

La tabla de indexación Tabla, se enlaza a nivel de compilación con la lista de instruciiones mediante una macro que crea todas las etiquetas de forma automática.
     Estas macros son INSTRUC y TABLA_INST. La primera crea la etiqueta con los valores del contador de TABLA_INST y esta última lleva la cuenta del bucle, en este caso 100h, colocando delante un nemónico inicial "I", que es enviado en todas las llamadas posteriores a INSTRUC, para que lo coloque delante del número del contador.
     Esta función interpretará el código de insgtrucción indicando el formato que debe usarse en la lectura de los siguientes bytes. Para ello, interpreta el código de instrucción y devuelve un puntero a la cadena de interpretación. Esta cadena contiene la estructura de textos que han de colocarse, insertando entre medias los datos que correspondan.
      Por lo tanto esta función es subrutina de una de mayor nivel que desensamblará la instrucción completa.
        Este interprete es un proceso muy sencillo que he utilizado en otros lenguajes para desensamblar otros códigos máquina, resultando muy eficaz y sencillo de programar.
        Esta función no solo servirá para reconocer la instrucción al presentaral en pantalla o listarla. Sino mucho más importante será usada por las rutinas de ejecución para conocer el numero de pulsos de reloj de cada instrucción de ensamblador, y poder así ejecutar la instrucción por completo.

INTERPRETA.ASM

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/

include main.mac
include stdio.mac
include window.mac
include 8051.mac
include 48iocent.mac

 public _interpreta

;definición de instrución en la tabla
INSTRUC MACRO ETI,X
IFDEF ETI&X
        DB X
        DW ETI&X
ENDIF
endm
;macro para definir tabla de instrucciones
TABLA_INST MACRO ETI
        LB=0
          REPT 100h
          INSTRUC ETI,%LB
          LB=LB+1
          ENDM
 ENDM

DIR_RESET EQU 0  
 
.model compact,pascal


.data




;CONTROL
;Lista de instrucciones

; estructura de la entrada en la tabla
     ;byte 0 =tipo instruciión
               ;0 inmediato            (1 byte)
               ;1 texto + num 8 bits   (2 bytes)
               ;2 texto + num 16 bits  (3 bytes)
               ;3 texto + num 8bits + texto
               ;4 texto + num 16 bits + texto
                ;5 texto + num 8 bits relativo + texto + num 8 bits
               ;6 texto + num 8 bits relativo
               ;7 texto + num 8 bits relativo + texto
               ;8 texto + num 8bits + texto + num 8 bits
               ;9 texto + num 8 bits + texto + num 8 bits relativo
               ;10 texto + num 11bits  (2 bytes)
               ;11 texto + num 8 bits ref_bit
               ;12 texto + num 8 bits ref_bit + texto
               ;13 texto + num 8 bits ref_bit + texto + num 8 bits relativo
               ;0ffh nueva tabla INSTRUCCION COMPUESTA
     ;byte 1 = Ciclos de reloj de la instrución
     ;byte 2= numero de bytes de la instruciión
     ;Resto hasta "0" Nemónico
   
I0 DB 0,12,1,"NOP",0
I1 DB 10,24,2,"AJMP ",0
I2 DB 2,24,3,"LJMP ",0
I3 DB 0,12,1,"RR A",0
I4 DB 0,12,1,"INC A",0
I5 DB 1,12,2,"INC ",0
I6 DB 0,12,1,"INC @R0",0
I7 DB 0,12,1,"INC @R1",0
I8 DB 0,12,1,"INC R0",0
I9 DB 0,12,1,"INC R1",0
I10 DB 0,12,1,"INC R2",0
I11 DB 0,12,1,"INC R3",0
I12 DB 0,12,1,"INC R4",0
I13 DB 0,12,1,"INC R5",0
I14 DB 0,12,1,"INC R6",0
I15 DB 0,12,1,"INC R7",0
I16 DB 13,24,3,"JBC ",0,",",0
I17 db 10,24,2,"ACALL ",0
I18 DB 2,24,3,"LCALL ",0
I19 DB 0,12,1,"RRC A",0
I20 DB 0,12,1,"DEC A",0
I21 DB 1,12,2,"DEC ",0
I22 DB 0,12,1,"DEC @R0",0
I23 DB 0,12,1,"DEC @R1",0
I24 DB 0,12,1,"DEC R0",0
I25 DB 0,12,1,"DEC R1",0
I26 DB 0,12,1,"DEC R2",0
I27 DB 0,12,1,"DEC R3",0
I28 DB 0,12,1,"DEC R4",0
I29 DB 0,12,1,"DEC R5",0
I30 DB 0,12,1,"DEC R6",0
I31 DB 0,12,1,"DEC R7",0
I32 DB 13,24,3,"JB ",0,",",0
I33 DB 10,24,2,"AJMP ",0
I34 DB 0,24,1,"RET",0
I35 DB 0,12,1,"RL A",0
I36 DB 1,12,2,"ADD A,#",0
I37 DB 1,12,2,"ADD A,",0
I38 DB 0,12,1,"ADD A,@R0",0
I39 DB 0,12,1,"ADD A,@R1",0
I40 DB 0,12,1,"ADD A,R0",0
I41 DB 0,12,1,"ADD A,R1",0
I42 DB 0,12,1,"ADD A,R2",0
I43 DB 0,12,1,"ADD A,R3",0
I44 DB 0,12,1,"ADD A,R4",0
I45 DB 0,12,1,"ADD A,R5",0
I46 DB 0,12,1,"ADD A,R6",0
I47 DB 0,12,1,"ADD A,R7",0
I48 DB 13,24,3,"JNB ",0,",",0
I49 db 10,24,2,"ACALL ",0
I50 DB 0,24,1,"RETI",0
I51 DB 0,12,1,"RLC A",0
I52 DB 1,12,2,"ADDC A,#",0
I53 DB 1,12,2,"ADDC A,",0
I54 DB 0,12,1,"ADDC A,@R0",0
I55 DB 0,12,1,"ADDC A,@R1",0
I56 DB 0,12,1,"ADDC A,R0",0
I57 DB 0,12,1,"ADDC A,R1",0
I58 DB 0,12,1,"ADDC A,R2",0
I59 DB 0,12,1,"ADDC A,R3",0
I60 DB 0,12,1,"ADDC A,R4",0
I61 DB 0,12,1,"ADDC A,R5",0
I62 DB 0,12,1,"ADDC A,R6",0
I63 DB 0,12,1,"ADDC A,R7",0
I64 DB 13,24,3,"JC ",0,",",0
I65 db 10,24,2,"AJMP ",0
I66 DB 3,12,2,"ORL ",0,",A",0
I67 DB 8,24,3,"ORL ",0,",#",0
I68 DB 1,12,2,"ORL A,#",0
I69 DB 1,12,2,"ORL A,",0
I70 DB 0,12,1,"ORL A,@R0",0
I71 DB 0,12,1,"ORL A,@R1",0
I72 DB 0,12,1,"ORL A,R0",0
I73 DB 0,12,1,"ORL A,R1",0
I74 DB 0,12,1,"ORL A,R2",0
I75 DB 0,12,1,"ORL A,R3",0
I76 DB 0,12,1,"ORL A,R4",0
I77 DB 0,12,1,"ORL A,R5",0
I78 DB 0,12,1,"ORL A,R6",0
I79 DB 0,12,1,"ORL A,R7",0
I80 DB 13,24,3,"JNC ",0,",",0
I81 db 10,24,2,"ACALL ",0
I82 DB 3,12,2,"ANL ",0,",A",0
I83 DB 8,24,3,"ANL ",0,",#",0
I84 DB 1,12,2,"ANL A,#",0
I85 DB 1,12,2,"ANL A,",0
I86 DB 0,12,1,"ANL A,@R0",0
I87 DB 0,12,1,"ANL A,@R1",0
I88 DB 0,12,1,"ANL A,R0",0
I89 DB 0,12,1,"ANL A,R1",0
I90 DB 0,12,1,"ANL A,R2",0
I91 DB 0,12,1,"ANL A,R3",0
I92 DB 0,12,1,"ANL A,R4",0
I93 DB 0,12,1,"ANL A,R5",0
I94 DB 0,12,1,"ANL A,R6",0
I95 DB 0,12,1,"ANL A,R7",0
I96 DB 13,24,3,"JZ ",0,",",0
I97 db 10,24,2,"AJMP ",0
I98 DB 3,12,2,"XRL ",0,",A",0
I99 DB 8,24,3,"XRL ",0,",#",0
I100 DB 1,12,2,"XRL A,#",0
I101 DB 1,12,2,"XRL A,",0
I102 DB 0,12,1,"XRL A,@R0",0
I103 DB 0,12,1,"XRL A,@R1",0
I104 DB 0,12,1,"XRL A,R0",0
I105 DB 0,12,1,"XRL A,R1",0
I106 DB 0,12,1,"XRL A,R2",0
I107 DB 0,12,1,"XRL A,R3",0
I108 DB 0,12,1,"XRL A,R4",0
I109 DB 0,12,1,"XRL A,R5",0
I110 DB 0,12,1,"XRL A,R6",0
I111 DB 0,12,1,"XRL A,R7",0
I112 DB 13,24,3,"JNZ ",0,",",0
I113 db 10,24,2,"ACALL ",0
I114 DB 11,24,2,"ORL C,",0
I115 DB 0,24,1,"JMP @A+DPTR",0
I116 DB 1,12,2,"MOV A,#",0
I117 DB 8,24,3,"MOV ",0,",#",0
I118 DB 1,12,2,"MOV @R0,#",0
I119 DB 1,12,2,"MOV @R1,#",0
I120 DB 1,12,2,"MOV R0,#",0
I121 DB 1,12,2,"MOV R1,#",0
I122 DB 1,12,2,"MOV R2,#",0
I123 DB 1,12,2,"MOV R3,#",0
I124 DB 1,12,2,"MOV R4,#",0
I125 DB 1,12,2,"MOV R5,#",0
I126 DB 1,12,2,"MOV R6,#",0
I127 DB 1,12,2,"MOV R7,#",0
I128 DB 6,24,2,"SJMP ",0
I129 db 10,24,2,"AJMP ",0
I130 DB 11,24,2,"ANL C,",0
I131 DB 0,24,1,"MOVC A,@A+PC",0
I132 DB 0,48,1,"DIV AB",0
I133 DB 8,24,3,"MOV ",0,",",0
I134 DB 3,24,3,"MOV ",0,",@R0",0
I135 DB 3,24,3,"MOV ",0,",@R1",0
I136 DB 3,24,3,"MOV ",0,",R0",0
I137 DB 3,24,3,"MOV ",0,",R1",0
I138 DB 3,24,3,"MOV ",0,",R2",0
I139 DB 3,24,3,"MOV ",0,",R3",0
I140 DB 3,24,3,"MOV ",0,",R4",0
I141 DB 3,24,3,"MOV ",0,",R5",0
I142 DB 3,24,3,"MOV ",0,",R6",0
I143 DB 3,24,3,"MOV ",0,",R7",0
I144 DB 2,24,3,"MOV DPTR,#",0
I145 db 10,24,0,"ACALL ",0
I146 DB 12,24,0,"MOV ",0,",C",0
I147 DB 0,24,0,"MOVC A,@A+PC",0
I148 DB 1,12,0,"SUBB A,#",0
I149 DB 1,12,0,"SUBB A,",0
I150 DB 0,12,0,"SUBB A,@R0",0
I151 DB 0,12,0,"SUBB A,@R1",0
I152 DB 0,12,0,"SUBB A,R0",0
I153 DB 0,12,0,"SUBB A,R1",0
I154 DB 0,12,0,"SUBB A,R2",0
I155 DB 0,12,0,"SUBB A,R3",0
I156 DB 0,12,0,"SUBB A,R4",0
I157 DB 0,12,0,"SUBB A,R5",0
I158 DB 0,12,0,"SUBB A,R6",0
I159 DB 0,12,0,"SUBB A,R7",0
I160 DB 11,24,0,"ORL C,/",0
I161 db 10,24,0,"AJMP ",0
I162 DB 11,24,0,"MOV C,",0
I163 DB 0,24,0,"INC DPTR",0
I164 DB 0,48,0,"MUL AB",0
I165 DB 0,12,0,"????",0
I166 DB 1,12,0,"MOV @R0,",0
I167 DB 1,12,0,"MOV @R1,",0
I168 DB 1,12,0,"MOV R0,",0
I169 DB 1,12,0,"MOV R1,",0
I170 DB 1,12,0,"MOV R2,",0
I171 DB 1,12,0,"MOV R3,",0
I172 DB 1,12,0,"MOV R4,",0
I173 DB 1,12,0,"MOV R5,",0
I174 DB 1,12,0,"MOV R6,",0
I175 DB 1,12,0,"MOV R7,",0
I176 DB 11,24,0,"ANL C,/",0
I177 db 10,24,0,"ACALL ",0
I178 DB 11,12,0,"CPL ",0
I179 DB 0,12,0,"CPL C",0
I180 DB 9,24,0,"CJNE A,#",0,",",0
I181 DB 9,24,0,"CJNE A,",0,",",0
I182 DB 9,24,0,"CJNE @R0,#",0,",",0
I183 DB 9,24,0,"CJNE @R1,#",0,",",0
I184 DB 9,24,0,"CJNE R0,#",0,",",0
I185 DB 9,24,0,"CJNE R1,#",0,",",0
I186 DB 9,24,0,"CJNE R2,#",0,",",0
I187 DB 9,24,0,"CJNE R3,#",0,",",0
I188 DB 9,24,0,"CJNE R4,#",0,",",0
I189 DB 9,24,0,"CJNE R5,#",0,",",0
I190 DB 9,24,0,"CJNE R6,#",0,",",0
I191 DB 9,24,0,"CJNE R7,#",0,",",0
I192 DB 1,24,0,"PUSH ",0
I193 db 10,24,0,"AJMP ",0
I194 DB 11,12,0,"CLR ",0
I195 DB 0,12,0,"CLR C",0
I196 DB 0,12,0,"SWAP A",0
I197 DB 1,12,0,"XCH A,",0
I198 DB 0,12,0,"XCH A,@R0",0
I199 DB 0,12,0,"XCH A,@R1",0
I200 DB 0,12,0,"XCH A,R0",0
I201 DB 0,12,0,"XCH A,R1",0
I202 DB 0,12,0,"XCH A,R2",0
I203 DB 0,12,0,"XCH A,R3",0
I204 DB 0,12,0,"XCH A,R4",0
I205 DB 0,12,0,"XCH A,R5",0
I206 DB 0,12,0,"XCH A,R6",0
I207 DB 0,12,0,"XCH A,R7",0
I208 DB 1,24,0,"POP ",0
I209 db 10,24,0,"ACALL ",0
I210 DB 11,12,0,"SETB ",0
I211 DB 0,12,0,"SETB C",0
I212 DB 0,12,0,"DA A",0
I213 DB 9,24,0,"DJNZ ",0,",",0
I214 DB 0,12,0,"XCHD A,@R0",0
I215 DB 0,12,0,"XCHD A,@R1",0
I216 DB 6,24,0,"DJNE R0,",0,",",0
I217 DB 6,24,0,"DJNE R1,",0,",",0
I218 DB 6,24,0,"DJNE R2,",0,",",0
I219 DB 6,24,0,"DJNE R3,",0,",",0
I220 DB 6,24,0,"DJNE R4,",0,",",0
I221 DB 6,24,0,"DJNE R5,",0,",",0
I222 DB 6,24,0,"DJNE R6,",0,",",0
I223 DB 6,24,0,"DJNE R7,",0,",",0
I224 DB 0,24,0,"MOVX A,@DPTR",0
I225 db 10,24,0,"AJMP ",0
I226 DB 0,24,0,"MOVX A,@R0",0
I227 DB 0,24,0,"MOVX A,@R1",0
I228 DB 0,12,0,"CLR A",0
I229 DB 1,12,0,"MOV A,",0
I230 DB 0,12,0,"MOV A,@R0",0
I231 DB 0,12,0,"MOV A,@R1",0
I232 DB 0,12,0,"MOV A,R0",0
I233 DB 0,12,0,"MOV A,R1",0
I234 DB 0,12,0,"MOV A,R2",0
I235 DB 0,12,0,"MOV A,R3",0
I236 DB 0,12,0,"MOV A,R4",0
I237 DB 0,12,0,"MOV A,R5",0
I238 DB 0,12,0,"MOV A,R6",0
I239 DB 0,12,0,"MOV A,R7",0
I240 DB 0,24,0,"MOV @DPTR,A",0
I241 db 10,24,0,"ACALL ",0
I242 DB 0,24,0,"MOVX @R0,A",0
I243 DB 0,24,0,"MOVX @R1,A",0
I244 DB 0,12,0,"CPL A",0
I245 DB 3,12,0,"MOV ",0,",A",0
I246 DB 0,12,0,"MOV @R0,A",0
I247 DB 0,12,0,"MOV @R1,A",0
I248 DB 0,12,0,"MOV R0,A",0
I249 DB 0,12,0,"MOV R1,A",0
I250 DB 0,12,0,"MOV R2,A",0
I251 DB 0,12,0,"MOV R3,A",0
I252 DB 0,12,0,"MOV R4,A",0
I253 DB 0,12,0,"MOV R5,A",0
I254 DB 0,12,0,"MOV R6,A",0
I255 DB 0,12,0,"MOV R7,A",0


Tabla LABEL BYTE
   Tabla_inst I        ;tabla a lista de instrucciones
   db 0ffh              ;localizador final tabla

no_conocido db 0,0,0,"????",0      ; codigo no desensamblable
nada db 0

   
.code
           
_interpreta proc uses si bx
           ;se indicará en DX direccion de la
           ;instruccion a decodificar y devolverá
           ;en ax la direccion de la lista de interpretado
        mov si,offset Tabla

busca_mas:
        leeinst
        inc dx
 busca:
        cmp al,[si]
        jz localizado
        jb n_conoc
        cmp byte ptr [si],0ffh
        jz n_conoc
        add si,3
        jmp busca
n_conoc:
        mov bx,offset no_conocido
        jmp fin

localizado:
        mov bx,[si+1]           ;se lee la direccion de la instruccion
        mov al,[bx]             ;de la secuencia se lee el indicador
        cmp al,0ffh             ;indicador de instruccion compuesta
        jne fin
        mov si,[BX+1]
        jmp busca_mas
 fin:
        mov ax,bx
        ret
_interpreta endp

end