OPERACIONES EN TURBO ASSEMBLER

INSTITUTO TECNOLOGICO SUPERIOR DE INFORMATICA IBARRA

TRABAJO DE ORGANIZACIÓN DE COMPUTADORAS

NOMBRE: Marcelo Aguirre

NIVEL: 3ro Sistemas Nocturno

INSTALACION DEL PROGRAMA TURBO ASSEMBLER

Sera el programa que vamos a utilizar.

La instalación es sencilla, pueden ver aquí los pasos:

Si todo sale bien, tendremos en INICIO > TODOS LOS PROGRAMAS > instalado el BORLAND TASM.

OPERACIONES EN TURBO ASSEMBLER

Para crear nuestro programa, emplearemos el bloc de notas.

- Abrimos el bloc de notas y tecleamos el siguiente código: ; Ensamblador utilizado NASM ;;

[BITS 16] ; Set 16 bit code generationSEGMENT junk ; Segment containing code

..start: ; The two dots tell the linker to Start Here.

mov ax,data ; Move segment address of data segment into AXmov ds,ax ; Copy address from AX into DSmov es,ax ;mov ax,stack ; Move segment address of stack segment into AXmov ss,ax ; Copy address from AX into SS

mov sp,stacktop ; Point SP to the top of the stack

;==============================|; MAIN |;==============================|

Inicio:

call Reset ; Limpiar variables

call Menu ; Imprimir menu

Opcion:

call GetCh ; Leer caracter de seleccion de opcion del menu

cmp al, 27 ; es ESC ?je Fin ; terminal si es ESC

cmp al, '1' ; es ASCII 1?jne Opt2 ; saltar si no es igual

call DoSuma ; ingresar los datos y operar la suma

jmp Inicio ; repetir el ciclo

Opt2:

cmp al, '2' ; es ASCII 2jne Opt3 ; saltar si no es igual

call DoResta ; ingresar datos y operar la resta


Opt3:

cmp al, '3' ; es ASCII 3jne Opt4 ; saltar si no es igual

call DoMulti ; ingreasar datos y operar la multiplicacion


Opt4:

cmp al, '4' ; es ASCII 4jne Opcion ; si no repetir el ingreso de caracter

call DoDiv ; ingresar datos y operar la division

jmp Inicio ; repetir ciclo

Fin:

mov ax, 04C00H ; salir int 21H ; fin de programa

;======================================================================

; funcion DoDiv; ingresa datos y opera la division

DoDiv:

call NewLine ;

mov dx, Msg13 ;call Writeln ;

Call NewLine ;

mov dx, Msg6 ;call Write ;

mov cx, 10 ; 10 digitosmov di, OpA ; guardarlo en memoria OpAcall Read128BitNum ; llamar a la funcion que lee el numero

Call NewLine ;


mov cx, 10 ; 10 digitosmov di, OpB ; guardarlo en memoria OpBcall Read128BitNum ; llamar a la funcion que lee el numero

mov si, OpB ; parametros para comparar el operador Bmov di, Cero128Bits ; con cero, division por cero?

call Cmp128Bits ; compara dos numeros de 128bitsje DoDivFin ; si el B == 0 error division por cero

Call NewLine ;

mov si, OpA ; parametros de la divisionmov di, OpB ; etcmov bx, prd ; resultado

call Div128Bits ; funcion que divide dos numeros

mov dx, Msg8 ;

call Write ;

mov si, prd ; resultado de la division en binariomov cx, 20 ;

mov bx, Res ;

call Write128BitS ; funcion que convierte de binario a decimal

mov si,Res ; en Res esta guardado el numero en decimal como cadena

call WriteNum ; imprimir el numero en pantalla

Call NewLine ;Call NewLine ;

ret ;

DoDivFin:

Call NewLine ; Exception, en caso de division por cermov dx, Msg14 ; imprimir un mensaje extra de errorcall Writeln ; y regresar sin hacer nada.

ret ;

;======================================================================

; funcion DoMulti; ingresa datos y opera la multiplicacion

DoMulti:

call NewLine ;


Call NewLine ;


mov cx, 10 ; ingresar un numero de mov di, OpA ; 10 digitos y guardarlocall Read128BitNum ; en binario en OpA

Call NewLine ;


mov cx, 10 ; Ingresar numero de 10mov di, OpB ; digitos en binario y guardarlo call Read128BitNum ; en OpB

Call NewLine ;

mov si, OpA ;mov di, OpB ;mov bx, prd ; resultado de la multiplicacion

call Mult128Bits ; realizar la multiplicacion

mov dx, Msg8 ;

call Write ;

mov si, prd ;mov cx, 20 ;mov bx, Res ;

call Write128BitS ; convertir de binario a decimal

mov si,Res ;

call WriteNum ; imprimir el resultado en pantalla


ret ;

;======================================================================

; funcion DoResta; ingresa datos y opera

DoResta:

call NewLine ;


Call NewLine ;


mov cx, 20 ;mov di, OpA ;call Read128BitNum ;

Call NewLine ;


mov cx, 20 ;mov di, OpB ;call Read128BitNum ;

Call NewLine ;

mov si, OpA ;mov di, OpB ;mov bx, prd ;

call Resta128Bits ;

mov dx, Msg8 ;

call Write ;


call Write128BitS ;

mov si,Res ;

call WriteNum ;


ret ;

;======================================================================

; funcion DoSuma; ingresa datos y opera

DoSuma:

call NewLine ;


Call NewLine ;


mov cx, 20 ;mov di, OpA ;call Read128BitNum ;

Call NewLine ;


mov cx, 20 ;mov di, OpB ;call Read128BitNum ;

Call NewLine ;

mov si, OpA ;mov di, OpB ;mov bx, prd ;

call Suma128Bits ;

mov dx, Msg8 ;

call Write ;


call Write128BitS ;

mov si,Res ;

call WriteNum ;


ret ;

;======================================================================

; funcion CeroStr; llena una cadena de 0's; Parametro cx cantidad de digitos; Parametro di direccion de la cadena a rellenar

CeroStr:

mov si, strCero ;

cld ;

CeroStrCopiar:

movsb ;

dec si ;

loop CeroStrCopiar ;

ret ;

;======================================================================

; funcion Reset; pone a 0 las variables A B y RES, TMP y PRD

Reset:

mov si, OpA ;call SetCero128Bits ;

mov si, OpB ;call SetCero128Bits ;

mov si, prd ;call SetCero128Bits ;

mov si, tmp ;call SetCero128Bits ;

mov di, Res ;mov cx, 21 ;call CeroStr ;

ret ;

;======================================================================

; funcion Menu; imprime las cadenas que forman el menu

Menu:

call NewLine ;call NewLine ;





mov dx, Msg9 ;

call Writeln ;

call NewLine ;call NewLine ;


ret ;

;======================================================================

; funcion Cmp128Bits; compararacion de 128 bits; si operador a; di operador b; al = 0 -> A = B; al = 1 -> A > B; al = 2 -> A < B

Cmp128Bits

mov eax, [si + 12] ;mov ebx, [di + 12] ;

cmp eax, ebx ;

ja Cmp128BitsAgB ;jb Cmp128BitsBgA ;


cmp eax, ebx ;



cmp eax, ebx ;


mov eax, [si] ;mov ebx, [di] ;

cmp eax, ebx ;


; mov al, 'E' ; depuracion; call PutCh ;

mov al, 0 ;cmp al , 0 ;

ret ;

Cmp128BitsAgB :

; mov al, 'A' ; depuracion; call PutCh ;

mov al, 1 ;cmp al, 0 ;

ret ;

Cmp128BitsBgA :

; mov al, 'B' ; depuracion; call PutCh ;

mov al, 0 ;cmp al, 1 ;

ret ;

;======================================================================

; funcion SetCero128Bits; si numero; pone un numero de 128bits a cero

SetCero128Bits:

xor eax, eax ; a Xor a = 0 mov [si], eax ; [si] = 0mov [si+4], eax ; bits 32-63mov [si+8], eax ; bits 64-95mov [si+12], eax ; bits 96-127

ret ;

;======================================================================

; funcion Inc128Bits; si operador a; ecx, incremento; incrementa el numero en SI , CX veces

; osea, OP = OP + CX , pasando la direccion; de OP en si

Inc128Bits:

mov eax, [si] ; primera palabra doblemov edx, ecx ; incrementoadd eax, edx ; sumar las primar partesmov [si], eax ; guardar el resultado bajo

mov eax, [si+4] ; segunda doble palabramov edx, 0 ; el incremento es solo de 32 bits a lo sumoadc eax, edx ; suma con carrymov [si+4], eax ; guardar ETC...

mov eax, [si+8] ; ... 64-95mov edx, 0 ;adc eax, edx ;mov [si+8], eax ;

mov eax, [si+12] ; ... 96-127mov edx, 0 ;adc eax, edx ;mov [si+12], eax ;

ret ;

;======================================================================

; funcion Div128Bits; si operador a; di operador b; bx resultado; divide dos numeros mediante ; restas sucesivas, y optimizada con dezplamientos; A / B ==> ; SI A > ( B * 4096 ) ENTONCES ; A = A - 4096 ; RES = RES + B * 4096; para optimizar divisiones grandes

Div128Bits:

push si ;push di ;push bx ;

mov si, di ;mov di, tmp ;

call ShiftLeft128Bits ; desplazar b a la izquierda.

mov ecx, 11 ; 11 desplazamientos que faltan para hacer los 12.

mov si, tmp ;

Div128BitsL1:

call ShiftLeft128Bits ; 11 veces aqui

loop Div128BitsL1 ; al salir de este loop en tmp estara b * 4096 calculado con desplazamiento

pop bx ;pop di ;pop si ;

Div128BitsCiclo: ; ciclo principal de la division, cuantas veces cabe el operador B

; en el operador A? es contar la cantidad de restas, antes de que

; A sea negativo.


call Cmp128Bits ; Cmp A,B


jl Div128BitsFin ; Sale si B > A porque ya no cabe el operador B en A


mov di, tmp ;

call Cmp128Bits ; comparar con tmp que es B * 4096 para hacer la optimizacion

; de divisiones grandes


jl Div128BitsN ; si es menor, hacer el paso de 1 en 1 normalmente


mov di, tmp ; sino restar tmp de A; osea A = A - 4096 * B

mov bx, si ;

call Resta128Bits ; operar la resta



mov ecx, 4096 ; incrementar el contador o resultado ; en 4096

mov si, bx ;

call Inc128Bits ; sumar RES = RES + 4096;


jmp Div128BitsCiclo ; repetir el proceso.

Div128BitsN:


mov bx, si ;

call Resta128Bits ; restar A - B



mov ecx, 1 ; incrementar el resultado en 1mov si, bx ;

call Inc128Bits ;


jmp Div128BitsCiclo ;

Div128BitsFin:

ret ;

;======================================================================

; funcion ShiftLeft128Bits; si numero a ser desplazado; di resultado; desplazar a la izquierda un numero de 128bits

ShiftLeft128Bits:

mov eax, [si] ;shl eax, 1 ;mov [di], eax ;

mov eax, [si + 4] ;rcl eax, 1 ;mov [di + 4], eax ;



ret ;

;======================================================================

; funcion Mult128Bits; di operador a; si operador b; resultado en bx; multiplicar con sumas repetidas en un ciclo; y optimizaciones mediante shift a la izquierda

Mult128Bits:

Mult128BitsCiclo:

mov eax, [si] ;or eax, [si+4] ;or eax, [si+8] ;or eax, [si+12] ;

jz NEAR Mult128BitsFin ;

xor eax, eax ;

mov eax, [si+4] ;or eax, [si+8] ;or eax, [si+12] ;

jz NEAR Opt23 ;

; mov al, 'A' ;; call PutCh ;

push di ;push si ;


call ShiftLeft128Bits ;mov si, tmp ;

mov cx, 30 ;

Mult128BitsL1:

call ShiftLeft128Bits ;

loop Mult128BitsL1 ;

mov di, tmp ;

mov si, bx ;

call Suma128Bits ;

pop si ;pop di ;

push bx ;

push si ;push di ;

mov bx, si ;

mov di, DosA31 ;

call Resta128Bits ;

pop si ;pop di ;pop bx ;

jmp Mult128BitsCiclo ;

Opt23:

mov eax, [si] ;and eax, 0xFF000000 ;or eax, [si+4] ;or eax, [si+8] ;or eax, [si+12] ;

jz NEAR Opt7 ;

; mov al, 'M' ;; call PutCh ;

push di ;push si ;

mov ecx, 5 ;


call ShiftLeft128Bits ;mov si, tmp ;mov cx, 22 ;

Mult128BitsL2:



mov di, tmp ;

mov si, bx ;

call Suma128Bits ;

pop si ;

pop di ;

mov ecx, 8388608 ;

call Dec128Bits ;


Opt7:

mov eax, [si] ;cmp eax, 256 ;

jb Mult128BitsN ;

; mov al, 'R' ;

; call PutCh ;

push di ;push si ;


call ShiftLeft128Bits ;mov si, tmp ;mov cx, 6 ;

Mult128BitsL3:



mov di, tmp ;

mov si, bx ;

call Suma128Bits ;

pop si ;

pop di ;

mov ecx, 128 ;

call Dec128Bits ;


Mult128BitsN:

push si ;

mov si, bx ;

call Suma128Bits ;

pop si ;

mov ecx, 1 ;

call Dec128Bits ;


Mult128BitsFin:

ret ;

;======================================================================

; Dec128Bits; decrementar un numero en ECX; si el numero; si = si - ecx; resta de 32 bits el segundo operador

Dec128Bits ;

mov eax, [si] ;mov edx, ecx ;sub eax,edx ;

mov edx, 0 ;

mov [si], eax ;

mov eax, [si+4] ;sbb eax,edx ;mov [si+4], eax ;



ret ;

;======================================================================

; funcion Resta128Bits; si operador a; di operador b; resultado en bx; resta de dos numeros de 128bits en binario

Resta128Bits:

mov eax, [si] ;mov edx, [di] ;sub eax, edx ;mov [bx], eax ;

mov eax, [si+4] ;mov edx, [di+4] ;sbb eax, edx ;

mov [bx+4], eax ;

mov eax, [si+8] ;mov edx, [di+8] ;sbb eax, edx ;mov [bx+8], eax ;

mov eax, [si+12] ;mov edx, [di+12] ;sbb eax, edx ;mov [bx+12], eax ;

ret ;

;======================================================================

; funcion Suma128Bits; di operador a; si operador b; resultado en bx; sumar dos numeros de 128 bits

Suma128Bits:

mov eax, [di] ;mov edx, [si] ;add eax, edx ;mov [bx], eax ;

mov eax, [di+4] ;mov edx, [si+4] ;adc eax, edx ;mov [bx+4], eax ;



ret ;

;======================================================================

; funcion Write128BitS; bx cadena; si numero

; convierte un numero de binario a decimal y lo almacena en una cadena ; como texto; soporta numeros negativos en formato de complemento a dos. ; si es negativo llama a una funcion Write128BitNum que antepone un ; signo negativo y calcula el complemento osea 0 - Numero antes de ; convertirlo a decimal

Write128BitS:

mov al, [si+15] ;and al, 10000000B ;

jz Write128BitPos ;

call Write128BitNumNeg ;

jmp Write128BitSFin ;

Write128BitPos:

call Write128BitNum ;

Write128BitSFin:

ret ;

;======================================================================

; funcion Write128BitNumNeg; sacar numero negativo.; bx cadena de salida; si numero de entrada; convertir un numero negativo en base binaria ; a un numero decimal con signo "-" antepuesto

Write128BitNumNeg:

add bx, cx ;

push si ;push bx ;

mov bx, si ;

mov di, si ;

mov si, Cero128Bits ;

call Resta128Bits ;

pop bx ;pop si ;

Write128BitNumcicloNeg:

push bx ;call DivDiez ;pop bx ;

or al, 0x30 ;mov [bx],al ;dec bx ;

; call PutCh ;

mov eax, [si];or eax, [si+4];or eax, [si+8];or eax, [si+12];

jnz Write128BitNumcicloNeg

mov al, '-' ;mov [bx], al ;

ret ;

;======================================================================

; funcion Write128BitNum; BinToDec en cadena; si numero para convertir; bx cadena para rellenar; cx tamaño de la cadena; convierte un numero positivo en binario a decimal

Write128BitNum:

mov di, si ;add bx, cx ;

Write128BitNumciclo:

push bx ;call DivDiez ;pop bx ;

or al, 0x30 ;mov [bx],al ;dec bx ;

; call PutCh ;

mov eax, [si];or eax, [si+4];or eax, [si+8];or eax, [si+12];

jnz Write128BitNumciclo ;

ret ;

;======================================================================

; funcion DivDiez; Divide un numero de 128 bits, por 10; USADA SOLO PARA CONVERTIR DE BINARIO A DECIMAL, ; Parametro si direccion de la 128 bits de entrada; parametro di direccion de los 128 bits de salida

; NOTA: esta funcion usa DIV solo para dividir por diez; y obtener el residuo que es utilizado en la conversion; de binario a decimal, no participa en la division.

DivDiez:

xor edx,edx ;mov eax, [si + 12] ;mov ebx, 10 ;div ebx ;

mov [di + 12], eax ;

mov eax, [si + 8] ;div ebx ;

mov [di + 8], eax ;

mov eax, [si + 4] ;div ebx ;

mov [di + 4], eax ;

mov eax, [si] ;div ebx ;

mov [di] , eax ;

mov eax, edx ;

ret ;

;======================================================================

; funcion Read128BitNum; USAL MUL SOLO PARA CONVERTIR DE DECIMAL A BINARIO; AL PRESIONAR UN DIGITO, MULTIPLICA POR 10 y SUMA

; EL DIGITO; lee un numero de 128 bits; Parametro di direccion de la 128 bits de salida; cx , cantidad de digitos

; Nota: en esta funcion se utiliza MULT. para convertir; los digitos ingresador por el teclado a un numero; en base binaria conforme son ingresados.

Read128BitNum:

Read128NumCiclo:

call GetCh ;cmp al, 13 ;je NEAR Read128NumFin ;

cmp al,0x30 ; Caracter < '0' , no aceptarjb NEAR Read128NumCiclo ;

cmp al,0x39 ; Caracter > '9' , no aceptarja NEAR Read128NumCiclo ;

cmp cx, 0 ;je NEAR Read128NumFin ;

dec cx ;

push cx ;push ax ;

or al, 0x30 ;

call PutCh ;

mov eax, 10 ;mov ebx, [di] ;mul ebx ;mov [di], eax ;mov ecx, edx ;mov eax, 10 ;mov ebx, [di + 4] ;mul ebx ;add eax, ecx ;mov [di + 4], eax ;adc edx, 0 ;mov ecx, edx ;mov eax, 10 ;mov ebx, [di + 8] ;mul ebx ;add eax, ecx ;mov [di + 8], eax ;adc edx, 0 ;mov ecx, edx ;mov eax, 10 ;

mov ebx, [di + 12] ;mul ebx ;add eax, ecx ;mov [di + 12], eax ;pop ax ;and eax, 0xF ;mov ebx, [di] ;add eax, ebx ;mov [di], eax ;mov eax, [di+4] ;adc eax, 0 ;mov [di+4], eax ;mov eax, [di+8] ;adc eax, 0 ;mov [di+8], eax ;mov eax, [di+12] ;adc eax, 0 ;mov [di+12], eax ;

pop cx ;

jmp Read128NumCiclo ;

Read128NumFin:

call NewLine ;

ret ;

;======================================================================

; funcion WriteNum; Imprime un numero sin ceros a la izquierda; Parametro si direccion de la cadena a imprimir; imprime un numero almacenado en una cadena; quitando los ceros a la izquierda; 0000000000035 -> 35

WriteNum:

WriteNumCiclo:

mov al, [si] ;

cmp al, '0' ;

jne WriteNumFin ;

inc si ;

loop WriteNumCiclo ;

WriteNumFin:

mov dx, si ;

call Write ;

ret ;

;======================================================================

; funcion Write; imprimir una cadena en pantalla;; Parametro dx direccion de la cadena; imprime una cadena terminada en $ en pantalla

Write:

push ax ; preservar ax mov ah,0x9 ; funcion 9, imprimir en pantalla int 0x21 ; interrupcion dos

pop ax ; restaurar axret ; return

;======================================================================

; funcion Writeln; imprimir + enter;; Parametro dx direccion de la cadena

Writeln: call Write ; Display the string proper through Write

mov dx,CRLF ; Load offset of newline string to DXcall Write ; Display the newline string through Writeret ; Return to the caller

;======================================================================

; funcion HasKey; hay una tecla presionada en espera?; zf = 0 => Hay tecla esperando ; zf = 1 => No hay tecla en espera ; como el ReadKey de pascal: NO UTILIZADA

HasKey:

push ax ;

mov ah, 0x01 ; funcion 1int 0x16 ; interrupcion bios

pop ax ;

ret ; return

;======================================================================

; funcion ClearIn; Borrar Buffer del Teclado; NO UTILIZADA, me hiba a servir para limpiar posibles; pulsaciones dobles en el menu, pero no se dio el ; problema al probar con la funcion GETCH

ClearIn

ClearInL1:

call HasKey ;jz ClearInL2 ;call GetCh ;jmp ClearInL1 ;

ClearInL2: ;

ret ;

;======================================================================

; funcion PutCh; imprimir el caracter ascii en al, en pantalla; Parametro al el caracter a imprimir

PutCh:

mov ah, 0x0E ;int 0x10 ;

ret ;

;======================================================================

; funcion NewLine; nueva linea; imprimir enter en pantalla

NewLine:

mov dx, CRLF ;

call Write ;ret ;

;======================================================================

; funcion GetCh; ascii tecla presionada; Salida en al codigo ascii sin eco, via BIOS

GetCh:

xor ah,ah ;int 0x16 ;ret ;

;======================================================================

;==============================|; DATA |;==============================|

SEGMENT data ; Segment containing initialized data

Cero128Bits DW 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000

DosA31 DW 0x0000,0x8000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000

OpA DW 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000OpB DW 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000

prd DW 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000

tmp DW 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000

Msg1 DB "(1) SUMAR -> RES = A + B $"Msg2 DB "(2) RESTAR -> RES = A - B $"Msg3 DB "(3) MULTIPLICAR -> RES = A * B $"Msg4 DB "(4) DIVIDIR -> RES = A / B $"Msg9 DB "(ESC) SALIR $"

Msg5 DB "Presione el numero de opcion { 1 | 2 | 3 | 4 } ? $"

Msg6 DB "Ingrese el operador A: $"Msg7 DB "Ingrese el operador B: $"

Msg8 DB "RESULTADO = $"

Msg10 DB "Operacion Seleccionada -> SUMA $" Msg11 DB "Operacion Seleccionada -> RESTA $"

Msg12 DB "Operacion Seleccionada -> MULTIPLICACION $" Msg13 DB "Operacion Seleccionada -> DIVISION $"

Msg14 DB "#### Error Imposible Dividir por 0 ####$"

Buff DB "000000000000000000000000000000$"

Res DB "000000000000000000000$"

OperA DB "0000000000000000000000000$"

CRLF DB 0DH,0AH,'$'

strCero DB '0'

;==============================|; STACK |;==============================|

; GENERADO POR MI IDE, setup del stack y tamaño reservado

SEGMENT stack stack ; This means a segment of *type* "stack" ; that is also *named* "stack"! Some ; linkers demand that a stack segment ; have the explicit type "stack"

resb 1024 ; Reserve 64 bytes for the program stack stacktop: ; It's significant that this label points to ; the *last* of the reserved 64 bytes, and ; not the first!

A continuación, hacemos clic en ARCHIVO > GUARDAR COMO y vamos a la ruta siguiente C:TASM/BIN y lo guardamos como nombre.asm (en mi caso arqui.asm)

Hasta aquí, tenemos el código en ensamblador ya escrito. Ahora solo nos falta crear el .obj y linkarlo para obtener el .exe

Lo que haremos siempre que vayamos a general el .exe de algún código .asm sera lo siguiente:

- INICIO > EJECUTAR > CMD (se nos abrira la consola msdos)

- (Vamos a la ruta TASM/BIN). En mi caso, para llegar are:

cd.. cd.. cd tasm cd bin

- Ahora que estamos en el directorio donde tenemos nuestro codigo, (el arqui.asm) pasaremos a crear el .obj y linkarlo. Para ello usaremos los comandos:

tasm arqui tlink arqui

Ahora, ya tenemos generado nuestro arqui.exe

Sin cerrar la ventana del dos, escriban arqui y se ejecutara el programa. Les mostrara por pantalla el menú de las operaciones a realizarse.

OPERACIONES EN TURBO ASSEMBLER

Documents

Transcript of OPERACIONES EN TURBO ASSEMBLER