• Revista PROGRAMAR: Já está disponível a edição #53 da revista programar. Faz já o download aqui!

tiagolimpo

ajuda calculadora DUVIDA URGENTE!!!

1 mensagem neste tópico

EDIT: por favor consultar as regras deste fórum

http://www.portugal-a-programar.pt/guidelines/

tenho aqui uma calculadora hexadecimal, programada em assemble 486

section .data
res		dd	0	; guarda res
op1		dd	0	; guarda operando 1
op2		dd	0	; guarda operando 2
num_lidos	dd	0	;guarda numeros lidos
tipo		dd	0	;guarda tipo de dados

strcalc		db	0xa,"Calculadora Assembly",0xa,"LEI-1D2",0xa,"-Tiago Limpo",0xa,"Nº 20075800",0xa,"-João Brito",0xa,"Nº 20075054",0xa,"-Pedro Viegas",0xa,"Nº 20075832",0xa,
tamtrab		equ	$ - strcalc		;tamanho do tipo de dados

tipodados	db	0xa,"Escolha:",0xa,"i: inteiro ",0xa,"f: float ",0xa,">"
tamtipodados	equ	$ - tipodados		;tamanho do tipo de dados

operacaovf	db	0xa,"Introduza um operador (+,-,*,/)>" ; para a operação de float só fazemos as operações apresentadas
tamoperacaovf	equ	$ - operacaovf		;tamanho da operaçao float

operacaoi	db	0xa,"Introduza um operador (+, -, *, /, &, |, ^, SL, SR, RL, RR)>" ; para a operação de float só fazemos as operações apresentadas
tamoperacaoi	equ	$ - operacaoi		;tamanho da operaçao inteiros

txtnumerrado	db	0xa,"Valor errado, introduza novos valores correctos"
tamnumerrado	equ	$ - txtnumerrado		;tamanho da txt op errada

txtoverflow	db	0xa,"Overflow",0xa
tamoverflow	equ	$ - txtoverflow		;tamanho txt overflow

txtdivzero	db	0xa,"Realizou uma divisão por zero.",0xa
tamdivzero	equ	$ - txtdivzero		;tamanho txt divzero

pedido  db      0xa,"Insira numero> "
tamped  equ     $ - pedido

msg	db	0xa,"res: "
tamsg	equ	$ - msg

branco	db	0xa,0xa
tbranco	equ	$ - branco

section .bss

MAX_LINHA	equ	9
linha		resb	MAX_LINHA

MAX_TIPO        equ     9
linhatipo       resb    MAX_TIPO

MAX_OPERACAO    equ     9
linhaope        resb    MAX_OPERACAO

section .text

global	_start

_start:
mov	eax, ds
mov	es, eax



;********************************************************************************;
;*****************************;Apresentação;*************************************;
;********************************************************************************;


        mov     edx, tamtrab
        mov     ecx, strcalc
        mov     ebx, 1 ;1 argumento: file handle (stdout)
        mov     eax, 4 ;system call number (sys_write)
        int     0x80   ; chamada ao kernel

;_______________________________________________________________________________;




;*******************************************************************************;
;**************************;Pedido tipo de dados********************************;
;*******************************************************************************;

; pede input de dados

        mov     edx, tamtipodados
        mov     ecx, tipodados
        mov     ebx, 1 ;1 argumento: file handle (stdout)
        mov     eax, 4 ;system call number (sys_write)
        int     0x80   ; chamada ao kernel


;*******************************************************************************;
;************************;Leitura tipo de dados;********************************;
;*******************************************************************************;

mov     edx, MAX_TIPO
        mov     ecx, linhatipo
        mov     ebx, 0 ;1 argumento:  file handle (stdin)
        mov     eax, 3 ;system call number (sys_read) 
        int     0x80   ; chamada ao kernel
mov	al, byte[linhatipo]
mov	[tipo], al


;*******************************************************************************;
;***************;Conversão de Maiuscula para minusculas;************************;
;*******************************************************************************;

mov	esi, linhatipo
mov	edi, linhatipo
cld			; apaga flag de directório, DF=0
mov	ecx, [tipo]


ciclo:

lodsb
cmp	al, 'Z'
jg	nao_maiuscula
cmp	al, 'A'
jb	nao_maiuscula
add	al, 32


nao_maiuscula:

stosb
loop	ciclo

;_______________________________________________________________________________;




;********************************************************************************;
;***;Código pedir ao utilizador a introdução de um número e posterior leitura;***;
;********************************************************************************;

; Pedir o número

        mov     edx, tamped
        mov     ecx, pedido
        mov     ebx, 1
        mov     eax, 4
        int     0x80   		;chamada ao kernel


        ; Ler o numero

        mov     edx, MAX_LINHA
        mov     ecx, linha
        mov     ebx, 0 		;1 argumento: file handle (stdin)
        mov     eax, 3 		;system call number (sys_read)
        int     0x80   		;chamada ao kernel
dec	eax
        mov     [num_lidos], eax


; Converter "linha" para num

push	dword[num_lidos]
push	linha
call	convnum
add	esp, 8
mov	[op1], eax

;_______________________________________________________________________________;




;*******************************************************************************;
;*Codigo para pedir ao utilizador a introdução e leitura o 2 numero introduzido*;
;*******************************************************************************;

        ; Pedir o numero

        mov     edx, tamped
        mov     ecx, pedido
        mov     ebx, 1
        mov     eax, 4
        int     0x80   ; chamada ao kernel

        ; Ler o 2 nmero

        mov     edx, MAX_LINHA
        mov     ecx, linha
        mov     ebx, 0
        mov     eax, 3
        int     0x80   ; chamada ao kernel
dec	eax
        mov     [num_lidos], eax

; Converter "linha" para num

push	dword[num_lidos]
push	linha
call	convnum
add	esp, 8
mov	[op2], eax

;_______________________________________________________________________________;



;*******************************************************************************;
;***********;Código que vai fazer a verificação se é inteiro ou float;**********;
;*******************************************************************************;

xor	edx, edx	; apaga edx
xor	eax, eax	; apaga eax
mov    	ebx,linhatipo
mov    	al,byte[ebx]
cld

cmp     al,'i'
je      inteiros

cmp     al,'f'
je      virgulafsalto

jmp     operacaonaodefinida

;_______________________________________________________________________________;



;*******************************************************************************;
;*Código que vai pedir ao utilzador, vai ler e verificar operações com inteiros*;
;*******************************************************************************;

inteiros:
        ; Pedido da operação a realizar
mov     edx, tamoperacaoi	
mov     ecx, operacaoi	
mov     ebx, 1
mov     eax, 4
        int     0x80   ; chamada ao kernel

        ; Ler a operação pedida
        mov     edx, MAX_LINHA
        mov     ecx, linha
        mov     ebx, 0			;1 argumento: file handle (stdin)
        mov     eax, 3 			;system call number (sys_read)
        int     0x80   			;chamada ao kernel
dec	eax      		;subtraccaor 1 ao número de caracteres lidos
        mov     [num_lidos], eax

; Avaliar o operador
mov	ebx, linha		;em linha esta a operação 
mov	al, byte[ebx]		;um byte esta no endereco al

cmp	al, '+'			;se a string com o operador for um '+', vai para a funcao soma
je	soma			

cmp	al, '-'			;se a string com o operador for um '-', vai para a funcao subtraccao
je	subtraccao		

cmp	al, '*'			;se a string com o operador for um '*', vai para a funcao multiplicacao
je	multiplicacao		

cmp	al, '/'			;se a string com o operador for um '/', vai para a funcao divisao
je	divisao			

jmp	outros_operadores	;senao jump outros op

virgulafsalto:
jmp      virgulaf


;*******************************************************************************;
***************;Código para realizar operações com inteiros;********************;
;*******************************************************************************;

soma:
mov	eax, [op1]		;move valor em op1 para eax
add	eax, [op2]		;adiciona op2 a eax
mov	[res], eax		;move valor em eax para res
jmp	escreve			;jump para escrever res

subtraccao:
mov	eax, [op1]		;move valor em op1 para eax
sub	eax, [op2]		;subtraccao op2 a eax
mov	[res], eax		;move valor em eax para res
jmp	escreve			;jump para escrever res

multiplicacao:
mov	eax, [op1]		;move valor em op1 para eax
mov	ebx, [op2]		;move valor em op2 para ebx
mul	ebx			;multiplicacao 
mov	[res],	eax		;move valor em eax para res
jmp	escreve			;jump para escrever res

divisao:
xor	edx, edx		; Apagar edx
mov	eax, [op1]		;move valor em op1 para eax
mov	ebx, [op2]		;move valor em op2 para ebx
div	ebx			;divisao ebx
mov	[res], eax	        ;move valor em eax para res
jmp	escreve			;jump para escrever res

outros_operadores:
cmp	al, '&'			;se a string com o operador for um '&', vai para a funcao OP_and
je	OP_and			

cmp	al, '|'			;se a string com o operador for um '|', vai para a funcao OP_or
je	OP_or	

cmp	al, '^'			;se a string com o operador for um '^', vai para a funcao OP_xor
je	OP_xor			

jmp	outros_operadores1	

OP_and:					;operação AND
mov	eax, [op1]
and	eax, [op2]
mov	[res], eax
jmp	escreve

OP_or:					;operação OR
mov	eax, [op1]
or	eax, [op2]
mov	[res], eax
jmp	escreve

OP_xor:					;operação XOR
mov	eax, [op1]
xor	eax, [op2]
mov	[res], eax
jmp	escreve

outros_operadores1:
; Converte maiúsculas em minúsculas
mov	esi, linha
mov	edi, linha
cld				; apaga flag de direcção, DF=0
mov	ecx, [num_lidos]
ciclo1:
lodsb
cmp	al, 'Z'
jg	nao_maiuscula1
cmp	al, 'A'
jb	nao_maiuscula1
add	al, 32
nao_maiuscula1:
stosb
loop	ciclo1

mov	ebx, linha		;em linha esta a operação 
mov	al, byte[ebx]		;um byte esta no endereço al
cmp	al, 's'
je	operacaoshift
cmp	al, 'r'
je	operacaorotate
jmp	operacaonaodefinida


operacaoshift:
mov	al, byte[ebx+1]		;ebx+1 para obter o segundo caracter
cmp	al, 'r'
je	shift_right
jmp	shift_left

operacaorotate:
mov	al, byte[ebx+1]		;ebx+1 para obter o segundo caracter
cmp	al, 'r'
je	rotate_right
jmp	rotate_left


shift_right:

mov	eax, [op1]
mov	ecx, [op2]
shr	eax, cl
mov	[res], eax
jmp	escreve

shift_left:

mov	eax, [op1]
mov	ecx, [op2]
shl	eax, cl
mov	[res], eax
jmp	escreve

rotate_right:

mov	eax, [op1]
mov	ecx, [op2]
ror	eax, cl
mov	[res], eax
jmp	escreve

rotate_left:

mov	eax, [op1]
mov	ecx, [op2]
rol	eax, cl
mov	[res], eax
jmp	escreve

;_______________________________________________________________________________;



;*******************************************************************************;
;*******;Codigo para pedir, ler e realizar operacoes de virgula flutuante;******;
;*******************************************************************************;

virgulaf:
        ; Pedir o operacao
        mov     edx, tamoperacaovf	
        mov     ecx, operacaovf
        mov     ebx, 1
        mov     eax, 4
        int     0x80   			;chamada ao kernel
        ; Ler a operacao
        mov     edx, MAX_LINHA
        mov     ecx, linha
        mov     ebx, 0
        mov     eax, 3
        int     0x80  			;chamada ao kernel
dec	eax      		;subtraccaor 1 a numero de caracteres lidos
        mov     [num_lidos], eax
; verifica qual operacao
xor	edx, edx		; apaga edx
xor	eax, eax		; apaga 
mov     ebx,linha
mov     al,byte[ebx]
cld

cmp     al,'+'
je      somavf
cmp     al,'-'
je      subtracaovf
cmp     al,'*'
je      multiplicacaocaovf
cmp     al,'/'
je      divisaovf
jmp     operacaonaodefinida


;*******************************************************************************;
;**********;codigo para realizar as operacoes em virgula flutuante;*************;
;*******************************************************************************;

somavf:
fld     dword[op1]
fadd    dword[op2]
fstp    dword[res]
fstsw   ax
test    ax,8
jnz     escreveoverflowssalto
jmp     escreve

subtracaovf:
fld     dword[op1]
fsub    dword[op2]
fstp    dword[res]
fstsw   ax
test    ax,8
jnz     escreveoverflowssalto
jmp     escreve

multiplicacaocaovf:
fld     dword[op1]
fmul    dword[op2]
fstp    dword[res]
fstsw   ax
test    ax,8
jnz     escreveoverflowssalto
jmp     escreve

divisaovf:
fld     dword[op1]
fdiv    dword[op2]
fstp    dword[res]
fstsw   ax
test    ax,4
jnz     escrevedivzerosalto
test    ax,8
jnz     escreveoverflowssalto 
jmp     escreve

escreveoverflowssalto:
jmp	escreveoverflows

escrevedivzerosalto:
jmp	escrevedivzero




;*******************************************************************************;
;*******************************;funções;***************************************;
;*******************************************************************************;

;-------------- Código que faz a conversão de linha para número
; converter "linha" para "num"
; Recebe 2 par�etros:
;	- 1: linha [ebp+8]
;	- 2: num_lidos [ebp+12]
; Devolve "num" no eax	

convnum:
push	ebp
mov	ebp, esp
xor	edx, edx	; apaga edx
xor	eax, eax	; apaga eax
mov	esi, dword[ebp+8]
cld
mov	ecx, dword[ebp+12]
converte:
lodsb
cmp	al, '9'
jbe	algarismo
add	al, 9
algarismo:
and	al, 0xF
shl	edx, 4
or	edx, eax
loop	converte
mov	eax, edx
pop	ebp
ret



;*******************************************************************************;
;*********************;Código que trata da divisão por zero;********************;
;*******************************************************************************;

escrevedivzero:
; imprimir msg
mov	edx, tamdivzero
mov	ecx, txtdivzero
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel
       ; imprimir ENTER
mov	edx, 1
mov	ecx, branco
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel
        jmp     sair



;*******************************************************************************;
;***************;Código que vai tratar de situações em Overflow;****************;
;*******************************************************************************;

escreveoverflows:
; imprimir msg
mov	edx, tamoverflow
mov	ecx, txtoverflow
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel
       ; imprimir ENTER
mov	edx, 1
mov	ecx, branco
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel
        jmp     sair	



;*******************************************************************************;
;***********************;Código para dados errados;*****************************;
;*******************************************************************************;

operacaonaodefinida:
; imprimir msg
mov	edx, tamnumerrado
mov	ecx, txtnumerrado
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel

        ; imprimir ENTER
mov	edx, 1
mov	ecx, branco
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel
        jmp     sair	

;_______________________________________________________________________________;




;*******************************************************************************;
;**********;Código que vai permitir o aparecimento do res no ecrã;**************;
;*******************************************************************************;

escreve:
mov	edi, linha
cld
mov	edx, [res]
mov	ecx, 8
converte2:
rol	edx, 4
mov	eax, edx
and	eax, 0xF
cmp	eax, 9
jbe	algarismo2
sub	eax, 9
add	eax, 0x40
jmp	proximo
algarismo2:
add	eax, 0x30
proximo:
stosb
loop converte2

; imprimir msg
mov	edx, tamsg
mov	ecx, msg
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel

; imprimir numero convertido em string
mov	edx, 8
mov	ecx, linha
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel

; imprimir ENTER
mov	edx, tbranco
mov	ecx, branco
mov	ebx, 1
mov	eax, 4
int	0x80   ; chamada ao kernel




;*******************************************************************************;
;*******************;Código vai fazer a saída do programa;**********************;
;*******************************************************************************;
sair:						
mov	ebx, 0
mov	eax, 1
int	0x80   ; chamada ao kernel e consequente saída do programa

Agora o meu problema é este, nao consigo fazer a calculadora ir buscar os valores a um ficheiro texto,

precisava de uma ajuda mt rapida, é um projecto que vale 50% da minha cadeira e tenho de entregar esta 4ºf,  MT OBRIGADO A TDS.

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!


Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.


Entrar Agora