poly712 0 Newbie Poster

hi everyone!
i need help on this code it is a calculator that asked the user to input an expression (eg. 56+2) in one line and output the answer..it suppose to manipulate mdas.

please help me fix this code..
(i mean this is not really my code but i did tried to fix it.)

.model small
.stack 64
.data
	error_alpha db "Invalid input. Expression contains letter/s. ",13,10,"$"
	error_range db "Invalid input. Operand/s may be out of range. ",13,10,"$"
	error_overflow db "An overflow has occurred. ",13,10,"$"
	error_invalidinput db "Invalid Input. ",13,10, "$"
	redo db "Please enter a valid one.",13,10,"$"
	newline db 13,10,"$"
	inputlen dw 2
	op1len dw 1
	op2len dw 2
	prompt db "Enter an expression: ","$"
	inputLabel label byte
	inputmaxLen db 50
	inputcurLen db ?
	inputData db 50 dup (?)
	str_operand1 db 10 dup (?)
	str_operand2 db 10 dup (?)
	str_operator db 2 dup (?)

	operand_sign1 db 2 dup (?)
	operand_sign2 db 2 dup (?)

	sign_counter db 0h
	multbyTen db 10
	op_temp1 dw ?
	op_temp2 dw ?

	op_fin1 dw ?
	op_fin2 dw ?
	tempAnswer dw ?
	finalAnswer dw ?
	divAnswer dw 0h
	remainder db ?
	finalRem dw ?
	outputDecimal db "DECIMAL: $"
	outputBinary db "BINARY: $"
	outputOctal db "OCTAL: $"
	outputHex db "HEXADECIMAL: $"

	rev_ascii_decimal db ?
	rev_ascii_binary db ?
	rev_ascii_octal db ?
	rev_ascii_hexadecimal db ?
	outputSign db ?

	dec_len dw 0h
	bin_len dw 0h
	oct_len dw 0h
	hex_len dw 0h


	find_operand1 dw 0h
	find_operand2 dw 0h

	temp dw 0h

	sum dw 0h
	multiplier dw 0h
	product dw 0h
	
.code
	;asks the user for input
	prompt_for_input proc
		mov dx, offset prompt
		mov ah, 9h
		int 21h
		mov dx, offset inputLabel
		mov ah, 0ah
		int 21h
		mov bx, 0h
		mov bl, inputcurLen
		mov inputData[bx], "$"
		mov bx, 0
		mov bl, inputcurLen
		mov inputlen, bx
		ret
	prompt_for_input endp
	
	; gets the operands and the operator from the one line of input
	get_operators_and_operands proc
		mov ax, 0
		mov bx, 0
		mov dx, 0
		mov cx, 0
		mov si, 0
		mov bp, 0
		mov op1len, 0h
		mov op2len, 0h

		pre_conv1:
			mov al, inputData[bx]
			call check_if_digit
			jz pre_start_operand1

		check_sign1:
			cmp al, "-"
			je negative_op1
			cmp al, "+"
			je positive_op1

		call invalid_input

		negative_op1:
			mov operand_sign1[0], "-"
			mov operand_sign1[1], "$"
			inc bx
			jmp start_operand1

		positive_op1:
			mov operand_sign1[0], "+"
			mov operand_sign1[1], "$"
			inc bx
			jmp start_operand1

		pre_start_operand1:
			mov operand_sign1[0], "+"
			mov operand_sign1[1], "$"
			jmp start_operand1

		start_operand1:
			mov al, inputData[bx]
			cmp al, " "
			je end_operand1
			push bx
			mov bx, 0
			mov bx, cx
			mov str_operand1[bx],al
			pop bx
			inc op1len
			inc cx
			inc bx
			jmp start_operand1

		end_operand1:
			push bx
			mov bx, 0
			mov bx, cx
			mov str_operand1[bx], "$"
			pop bx
			jmp get_operator

		get_operator:
			inc bx
			mov al, inputData[bx]
			mov str_operator[0], al
			mov str_operator[1], "$"
			inc bx
			inc bx
			mov ax, 0
			mov cx, 0
			jmp pre_conv2

		pre_conv2:
			mov al, inputData[bx]
			call check_if_digit
			jz pre_start_operand2
			jnz check_sign2

		check_sign2:
			cmp al, "-"
			je negative_op2
			cmp al, "+"
			je positive_op2

		call invalid_input

		pre_start_operand2:
			mov operand_sign2[0], "+"
			mov operand_sign2[1], "$"
			jmp start_operand2

		start_operand2:
			mov al, inputData[bx]
			cmp al, "$"
			je end_operand2
			push bx
			mov bx, 0
			mov bx, cx
			mov str_operand2[bx],al
			pop bx
			inc op2len
			inc cx
			inc bx
			jmp start_operand2

		end_operand2:
			push bx
			mov bx, 0
			mov bx, cx
			mov str_operand2[bx], "$"
			pop bx

			ret

		negative_op2:
			mov operand_sign2[0], "-"
			mov operand_sign2[1], "$"
			inc bx
			jmp start_operand2

		positive_op2:
			mov operand_sign2[0], "+"
			mov operand_sign2[1], "$"
			inc bx
			jmp start_operand2
			get_operators_and_operands endp
	
	;checks what operator was used and performs the indicated operation
	check_operator proc
		mov bx, 0
		mov bl, str_operator[0]
		cmp bl, "+"
		jne check_sub
		call add_nos
		ret
		check_sub:
		cmp bl, "-"
		jne check_mul
		call sub_nos
		ret
		check_mul:
		cmp bl, "*"
		jne check_div
		call mul_nos
		ret
		check_div:
		cmp bl, "/"
		jne call_invalid_input
		call div_nos
		ret
		call_invalid_input:
		call invalid_input
	check_operator endp

	;jumps to the procedure input_out_of_range
	to_input_out_of_range proc
		jmp input_out_of_range
	to_input_out_of_range endp

	;converts the operands to decimal to be used in the arithmetic operations
	convert_operands_to_decimal proc
		mov bx, 0h
		find_eostring1:
		mov ax, 0
		mov al, str_operand1[bx]
		cmp al, "$"
		je two
		sub al, 30h
		mov str_operand1[bx], al
		inc bx
		jmp find_eostring1
		two:
		mov bx, 0h
		find_eostring2:
		mov ax, 0
		mov al, str_operand2[bx]
		cmp al, "$"
		je exit_cotd
		sub al, 30h
		mov str_operand2[bx], al
		inc bx
		jmp find_eostring2

		exit_cotd:
		cmp op1len, 6
		jg to_input_out_of_range2
		cmp op2len, 6
		jg to_input_out_of_range2

		ret
	convert_operands_to_decimal endp

	;performs addition if the operator is the '+' sign
	add_nos proc
		mov cl, operand_sign1[0]
		mov bl, operand_sign2[0]
		cmp cl, bl
		jne subit
		mov al, str_operand1
		mov dl, str_operand2
		add al, dl
		add al, 30h
		mov dl, al
		mov ah, 9h
		int 21h
		ret
		subit:
		mov bx, op1len
		mov cx, op2len
		cmp bx, cx
		jl subop2
		subop1:
		mov cl, operand_sign1[0]
		mov outputSign[0],cl
		mov outputSign[1],"$"
		sub al, dl
		ret
		subop2:
		mov dl, operand_sign2[0]
		mov outputSign[0],dl
		mov outputSign[1],"$"
		sub dl, al
		ret
	add_nos endp

	;performs subtraction if the operator is the '-' sign
	sub_nos proc
		ret
	sub_nos endp
	
	;jumps to the procedure input_out_of_range
	to_input_out_of_range2 proc
		jmp input_out_of_range
	to_input_out_of_range2 endp
	
	;performs multiplication if the operator is the '*' sign
	mul_nos proc
		mov al, str_operand1
		mov dl, str_operand2
		mul dl
		mov finalAnswer,ax

		mov cl, operand_sign1[0]
		mov bl, operand_sign2[0]
		cmp cl, bl
		je outputSign_is_pos
		mov outputSign[0],"-"
		jmp endsignmul
		outputSign_is_pos:
		mov outputSign[0]," "
		endsignmul:
		mov outputSign[1],"$"
		ret
	mul_nos endp

	;performs division if the operator is the '/' sign
	div_nos proc
		mov dx, 0
		mov al, str_operand1
		mov bl, str_operand2
		div bl
		mov remainder, ah
		mov ah, 0
		mov divAnswer, ax

		mov cl, operand_sign1[0]
		mov bl, operand_sign2[0]
		cmp cl, bl
		je outputSign_is_pos2
		mov outputSign[0],"-"
		jmp endsigndiv
		outputSign_is_pos2:
		mov outputSign[0]," "
		endsigndiv:
		mov outputSign[1],"$"
		ret
	div_nos endp

	;prints the error message indicating that an operand's value is greater that 65536
	input_out_of_range proc
		call print_new_line
		mov dx, offset error_range
		mov ah, 09h
		int 21h
		call print_new_line
		mov dx, offset redo
		mov ah, 09h
		int 21h
		call print_new_line
		jmp start_program
	input_out_of_range endp

	;prints the error message indicating that an overflow has occured
	overflow proc
		call print_new_line
		mov dx, offset error_overflow
		mov ah, 09h
		int 21h
		call print_new_line
		mov dx, offset redo
		mov ah, 09h
		int 21h
		call print_new_line
		jmp start_program
	overflow endp

	;checks if there is a letter in the input
	isalpha proc
		mov cx , inputlen
		mov si, 0
		start:
		mov ax, 0
		mov al, inputData[si]
		call check_if_alpha
		jz input_is_alpha
		inc si
		loop start
		ret
	isalpha endp

	;prints the error message indicating that there are letter/s or symbol/s in the input
	input_is_alpha proc
		call print_new_line
		mov dx, offset error_alpha
		mov ah, 09h
		int 21h
		call print_new_line
		mov dx, offset redo
		mov ah, 09h
		int 21h
		call print_new_line
		call start_program
	input_is_alpha endp

	;prints the error message indicating that the syntax of the input is wrong
	invalid_input proc
		call print_new_line
		mov dx, offset error_invalidinput
		mov ah, 09h
		int 21h
		call print_new_line
		mov dx, offset redo
		mov ah, 09h
		int 21h
		call print_new_line
		call start_program
		;ret
	invalid_input endp

	;prints the decimal equivalent of the answer
	print_decimal_output proc
		mov dx, offset outputDecimal
		mov ah, 9h
		int 21h

		mov ax, finalAnswer
		mov bl, 0ah
		div bl
		mov ah, 0
		mov rev_ascii_decimal,al

		mov bx, 0
		mov cx, dec_len
		convertdecloop:
		mov al, rev_ascii_decimal[bx]
		add al, 30h
		mov rev_ascii_decimal, al
		inc bx
		loop convertdecloop

		mov ax, 0
		mov bx, 0
		mov cx, dec_len
		;mov bx, dec_len
		decimalloop:
		mov ah, 02h
		mov dl, rev_ascii_decimal[bx]
		int 21h
		inc bx
		loop decimalloop

		call print_new_line
		call print_binary_output
	print_decimal_output endp

	;prints the binary equivalent of the number
	print_binary_output proc
		mov dx, offset outputBinary
		mov ah, 9h
		int 21h

		mov dx, offset outputSign
		mov ah, 02h
		int 21h

		mov bx, 0
		mov ax, finalAnswer
		convertbinloop:
		mov cl, 2
		div cl
		cmp ah, 0
		je zerobin
		mov rev_ascii_binary[bx],"1"
		zerobin:
		mov rev_ascii_binary[bx],"0"
		nextbin:
		inc bx
		cmp bx, bin_len
		je endbinary
		jmp convertbinloop

		endbinary:
		;mov bx, bin_len
		;mov bx, 4
		mov rev_ascii_binary[bx],"$"
		;mov ax, 0
		mov bx, 4
		;mov cx, bin_len
		mov cx, 4
		;mov bx, bin_len

		binaryloop:
		mov ah, 02h
		mov dl, rev_ascii_binary[bx]
		int 21h
		dec bx
		loop binaryloop

		call print_new_line
		ret
		;call print_octal_output
	print_binary_output endp

	;prints the octal equivalent of the answer
	print_octal_output proc
		mov dx, offset outputOctal
		mov ah, 9h
		int 21h

		mov ax, finalAnswer
		convertoctloop:
		mov cl, 16
		div cl
		cmp ah, 0
		je zerooct
		mov rev_ascii_octal[bx], "1"
		jmp nextoct
		zerooct:
		mov rev_ascii_octal[bx], "0"
		nextoct:
		inc bx
		cmp bx, oct_len
		je endoct
		jmp convertoctloop
		endoct:
		mov rev_ascii_octal[bx],"$"

		mov ax, 0
		mov bx, 0
		mov cx, oct_len
		mov bx, oct_len
		octalloop:
		mov ah, 02h
		mov dl, rev_ascii_octal[bx]
		int 21h
		inc bx
		loop octalloop

		call print_new_line
		call print_hex_output
	print_octal_output endp

	;prints the hexidecimal equivalent of the number
	print_hex_output proc
		mov dx, offset outputHex
		mov ah, 9h
		int 21h
		mov ax, finalAnswer
		mov bx, 0
		converthexloop:
		mov cl, 16
		div cl
		cmp ah, 0
		je zerohex
		mov rev_ascii_hexadecimal[bx], "1"
		jmp nexthex
		zerohex:
		mov rev_ascii_hexadecimal[bx], "0"
		nexthex:
		inc bx
		cmp bx, hex_len
		je endhex
		jmp converthexloop
		endhex:
		mov rev_ascii_hexadecimal[bx],"$"

		mov ax, 0
		mov cx, hex_len
		mov bx, hex_len
		hexadecimalloop:
		mov ah, 02h
		mov dl, rev_ascii_hexadecimal[bx]
		int 21h
		inc bx
		loop hexadecimalloop

		call end_program
	print_hex_output endp

	;prints a new line
	print_new_line proc
		mov dx, offset newline
		mov ah, 09h
		int 21h
		ret
	print_new_line endp

	check_if_alpha proc
		push ax
		and al, 11011111b
		cmp al, 'A'
		jb B1
		cmp al, 'Z'
		ja B1
		test ax, 0
		B1: pop ax
		ret
	check_if_alpha endp

	check_if_digit proc
		cmp al, '0'
		jb A1
		cmp al, '9'
		ja A1
		test ax, 0
		A1: ret
	check_if_digit endp

	;terminates the program
	end_program proc
		mov ah, 4ch
		int 21h
	end_program endp
	
	main proc
		mov ax, @data
		mov ds, ax

		call setcolors

		start_program:
		call prompt_for_input
		call print_new_line

		mov dx, offset inputData
		mov ah, 09h
		int 21h

		call isalpha

		call print_new_line

		call get_operators_and_operands

		call convert_operands_to_decimal

		call check_operator

		call print_decimal_output
		call end_program
		
	main endp

end main
Be a part of the DaniWeb community

We're a friendly, industry-focused community of 1.20 million developers, IT pros, digital marketers, and technology enthusiasts learning and sharing knowledge.