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

Sign in to follow this  
ricpap

Assembly486 -- Duvida com numeros negativos e flutuante[Calculadora]

Recommended Posts

ricpap

Boas, tou aqui com um problema numa calculadora que estou a fazer, o objectivo e fazer operacoes aritmeticas normais com inteiros e flutuantes ( fora and or e xor, isso ja consegui fazer).

2 problemas:

1º nao consigo fazer o complemento para dois.. ja tentei e ou da me segmentation fault ou entao vai me pa mensagem de overflow..

2º nao tou a conseguir por os valores no stack da FPU..

De resto eu sei que tenho que mudar as flags de overflow e as operacoes para funcionarem com numeros em complemento para dois,, n tou a conseguir mesmo e fazer a conversao :S

Se alguem puder ajudar thanks

Codigo:

section .data

pdr_numero	db	"Introduza o operando em Hexadecimal: "		; pede operando
tam_numero	equ	$ - pdr_numero



str_resultado 	db	"O resultado é: "	; exibe resultado
tam_resultado	equ	$ - str_resultado

pdr_operador	db	"Introduza o operador +, -, *, /, &, |, ^, SL, SR, RL, RR: "  
tam_operador	equ 	$ - pdr_operador

pdr_formato	db 	"Introduza o formato dos operandos: Inteiros ou Flutuantes ? (I/F) : "
tam_formato	equ	$ - pdr_formato

str_endline		db	0xA, 0xA

tam_endline		equ	$ - str_endline

sair		db 	"Deseja terminar o programa? (Y/N) : "

tam_buffer	dd	0

overflow_msg	db	"Erro: Overflow!"
tam_overflow	equ	$ - overflow_msg

erro_form	db	"Erro: formato nao reconhecido, insira um formato valido ( F ou I )"
tam_erro_form   equ	$ - erro_form	

erro_sinal 	db	"Erro: Insira sinal + ou - nos operandos"
tam_erro_sinal	equ	$ - erro_sinal

num1 		dd 	0,0
num2		dd	0,0
resultado_calc	dd	0,0

section .bss
MAX_BUFFER	equ	80+2
buffer		resb	MAX_BUFFER



section .text
global _start
_start:
mov     eax,ds

mov     es,eax

;Pede Formato 


mov	edx, tam_formato	
mov	ecx, pdr_formato
mov	ebx, 1

mov	eax, 4

int	0x80

; Le Formato
mov	edx, MAX_BUFFER

mov	ecx, buffer

mov	ebx, 0

mov	eax, 3

int	0x80
mov	dh, [buffer]
cmp	dh, 'F'
je	floating
cmp	dh, 'I'
jne	erroFormato


;pede le e converte operador1
call 	funcao_pede
mov	[num1], eax

;pede le e converte operador2
call 	funcao_pede
mov	[num2], eax

;pede operador
mov	edx, tam_operador
mov	ecx, pdr_operador
mov	ebx, 1

mov	eax, 4

int	0x80

;ler operador
mov	edx, MAX_BUFFER

mov	ecx, buffer

mov	ebx, 0

mov	eax, 3

int	0x80


; Executa operacoes

mov	eax, [num1]

mov	ebx, [num2]




mov	dl, [buffer] ;ver o primeiro caracter do operador
;compara com os operadores reconhecidos
cmp	dl, '+'

je	somar

cmp	dl, '-'

je	subtrair

cmp	dl, '*'

je	multiplicar

cmp	dl, '/'

je	dividir
cmp	dl, '&'
je	and
cmp	dl, '|'
je	inclusiveOR
cmp	dl, '^'
je	exclusiveOR
cmp	dx, 'SR'
je	shiftL
cmp	dx, 'SR'
je	shiftR
cmp	dx, 'RL'
je	rotateL
cmp	dx, 'RR'
je	rotateR


somar:

adc 	eax,ebx
jnc	escreve
jmp	overflow

subtrair:

sub	eax,ebx
jnc	escreve
jmp	overflow

multiplicar:

mul 	ebx
jnc	escreve
jmp	overflow

dividir:
xor 	edx, edx
div	ebx
jnc	escreve
jmp	overflow



and:
and	eax,ebx
jmp	escreve

inclusiveOR:
or	eax,ebx
jmp	escreve

exclusiveOR:
xor	eax,ebx
jmp	escreve


shiftL:
shl 	eax, 4  
jmp	escreve


shiftR:
shr eax,4
jmp	escreve


rotateL:
rol	eax,4
jmp	escreve

rotateR:
ror	eax,4
jmp	escreve




floating:
call 	funcao_pede
mov	[num1], eax

call	funcao_pede
mov	[num2], eax



mov	dl, [buffer] ;ver o primeiro caracter do operador
;compara com os operadores reconhecidos
cmp	dl, '+'

je	somarf




somarf:
fld	qword[num1]
fadd qword[num2]
jmp escreve



;===============Funcao Escrever===========
escreve:
mov	[resultado_calc],eax
mov	ecx, 8
mov	edi, buffer

mov	ebx, [resultado_calc]

cld

xor	eax, eax


escreve_conv:

	rol	ebx, 4

	mov	eax, ebx

	and	eax, 0xF

	cmp	eax, 0x9

	jbe	escreve_digito

	add	al, 'A'-0xA

	jmp	escreve_prox

escreve_digito:

	add	al, '0'

escreve_prox:

stosb

loop	escreve_conv



; exibe str_resultado

mov	edx, tam_resultado

mov	ecx, str_resultado

mov	ebx, 1

mov	eax, 4

int	0x80



; exibe o resultado

mov	edx, 8

mov	ecx, buffer

mov	ebx, 1

mov	eax, 4

int	0x80



; exibe str_eol (quebra de linha)

mov	edx, tam_endline

mov	ecx, str_endline

mov	ebx, 1

mov	eax, 4

int	0x80



; sair do programa

mov	ebx, 0

mov	eax, 1

int	0x80



;================Funcao pede=============
funcao_pede:
;mostra no ecran
mov	edx, tam_numero
mov	ecx, pdr_numero
mov	ebx, 1
mov	eax, 4
int 	0x80

;le o numero e escreve para buffer
mov	edx, MAX_BUFFER

mov	ecx, buffer
mov	ebx, 0

mov	eax, 3

int	0x80
mov	dh, [buffer]
cmp	dh, '-'
je	complemento
dec	eax
mov	[tam_buffer],eax






;converte de hexadecimal para inteiro
xor	eax, eax

xor	ebx, ebx

mov	esi, buffer

cld

mov	ecx, [tam_buffer]
jecxz	pede_num_fim



pede_num_conv:

	lodsb

	cmp	al, '9'

	jbe	pede_num_digito

	add	al, 9

pede_num_digito:

	and	al, 0xF

	shl	ebx, 4

	add	ebx, eax

	loop	pede_num_conv

pede_num_fim:

	; copia o resultado para eax e retorna

	mov	eax, ebx

	ret


complemento:
neg	eax
add	eax, 1
dec	eax
mov	[tam_buffer],eax


;==================Overflow=======
overflow:
mov	edx, tam_overflow
mov	ecx, overflow_msg
mov	ebx, 1
mov 	eax, 4
int	0x80 
jmp	funcao_pede


;=================erroFormato=======
erroFormato:
mov	edx, erro_form
mov	ecx, tam_erro_form
mov	ebx, 1
mov 	eax, 4
int	0x80 
;sair
mov	ebx, 0

mov	eax, 1

int	0x80


;==============ErroSinal=========
erroSinal:

mov edx, erro_sinal
mov	ecx, tam_erro_sinal
mov	ebx, 1
mov 	eax, 4
int	0x80

Merci.. n sei se alguem ta com paciencia pa ler 300 e tal linhas mas obrigado lol. cumps

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Sign in to follow this  

×

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.