##################################################################################
#CS2710 Homework 5 Solution.
##################################################################################
.data 		# Tells the assembler that the following directives affect the .data section of memory	
PI:
.float 3.1415927  # constant value for PI
prompt: 
.asciiz "Enter the diameter: "	# input prompt string
answer:
.asciiz "The area is: "		# output message string
input_error_msg:
.asciiz "The input value is invalid. Exiting... " # error message string


.text		# text tells the assembler that following this are program instructions
start:
	jal	promptUser		# prompt user to input diameter of the circle; return value in $v0
	mtc1	$v0, $f0		# move return value bits from $v0 to $f0; f0 now holds diameter in single-precision

# next, check to see if the entered value is <0.0. It will also be 0.0 if the input entered is invalid (e.g. "abc")
	addi	$t1, $zero, 0		# t1=0
	mtc1	$t1, $f1		# move bits from t1 to f1 (bit pattern of all 0's represents 0.0 in f1)
	c.le.s	$f0, $f1		# check to see if f0<f1 (returned diameter < 0.0). Note: sets coprocessor condition flag 0 to TRUE
	bc1f	input_ok		# branch if coprocessor condition flag is FASLE = continue processing if input diameter is valid
	
# invalid input was detected; print an error message and exit
	la	$a0, input_error_msg	# load addr of string with error message
	jal	printErrorMessage	# print the error message
	jal	exit			# ... and quit
	
input_ok:
# input diameter was valid; continue processing.

# We first need a value of 2.0 in an f register (note we could also load the value from memory as an alternate approach)
	addi	$t1, $zero, 2		# t1=2
	mtc1	$t1, $f2		# move bits from t1 to f2 (note bit pattern in f2 does not yet represent 2.0!)
	cvt.s.w $f2, $f2		# convert from int in f2 to float in f2 (now f2 represents 2.0)
	
# Now do the math A = PI * R**2
	div.s	$f0, $f0, $f2		# f0 = f0/2.0 (f0 now holds the radius of the circle)
	mul.s	$f0, $f0, $f0		# f0 = f0*f0 (f0 now holds the square of the radius)
	l.s	$f1, PI			# f1=PI (PI is defined in the .data section)
	mul.s	$f0, $f0, $f1		# f0=f0*f1 (Area=r**2 x PI; f0 now holds the area of the circle)

	mfc1	$a0, $f0		# move bits from f0 to a0, since a0 is the argument to printArea
	jal	printArea		# print the result
	jal	exit			# quit
# end of main program
#################################################################################

##################################################################################################
# This is procedure promptUser; it prompts the user for the diameter of a circle,
# whose single-precision floating-point value is returned in $v0
promptUser:
	sw	$ra, ($sp)		# push the return address onto the stack
	addi	$sp, $sp, -4		# decrement $sp (by 4 bytes) to point at the next available stack location
	
	la	$a0, prompt		# load string addr
	#addi	$v0, $zero, 52		# opcode for input prompt
	li	$v0, 52			# another way to load 52 into $v0
	syscall				# $f0=diameter, $a1=status after syscall
	beqz	$a1, promptUser_ok	# check status in a1; will be negative if not ok
# next 3 lines are executed if the user input could not be parsed; in this case, a "fake" return value of -1.0 is created	
	addi	$t1, $zero, -1		# t1=-1
	mtc1	$t1, $f0		# move bits from t1 to f2 (note f2 does not represent -1.0!)
	cvt.s.w $f0, $f0		# convert from int in f0 to float in f0 (now f0 represents -1.0)
	
promptUser_ok:	
	mfc1    $v0, $f0		# move bits from f0 to v0, since return value goes in v0
	
	addi	$sp, $sp, 4		# increment $sp (by 4 bytes) to point to the return address
	lw	$ra, ($sp)		# pop the return address from the stack
	jr	$ra			# return to the instruction referenced by $ra (return address register)		
# end procedure promptUser
##################################################################################################

##################################################################################################
# This is procedure printArea, which prints out the area of a circle whose value is specified
# in $a0
printArea:
	sw	$ra, ($sp)		# push the return address onto the stack
	addi	$sp, $sp, -4		# decrement $sp (by 4 bytes) to point at the next available stack location
	
# Area is supplied in $a0, but syscall requires the f.p. value to be in $f12. Thus, we have to move
# the bits from $a0 to $f12
	mtc1	$a0, $f12		# move bits from a0 to f12 

	la	$a0, answer		# load string addr
	addi	$v0, $zero, 57		# opcode for dialog with float; float in $f12
	syscall				# print the area
	
	addi	$sp, $sp, 4		# increment $sp (by 4 bytes) to point to the return address
	lw	$ra, ($sp)		# pop the return address from the stack
	jr	$ra			# return to the instruction referenced by $ra (return address register)		
# end procedure printArea
##################################################################################################


##################################################################################################
# This is procedure printErrorMessage. It encapsulates the syscall to the "MessageDialog" service routine,
# specifying that an error dialog should be displayed.
# Note that this procedure assumes that the calling routine has loaded the address of the string
# to be printed into $a0. 
printErrorMessage:
	sw	$ra, ($sp)		# push the return address onto the stack
	addi	$sp, $sp, -4		# decrement $sp (by 4 bytes) to point at the next available stack location
	
	li	$v0,	55		# function code for "print string" system service
	li	$a1,	0		# function code for error message
	syscall				# invoke the service routine
	
	addi	$sp, $sp, 4		# increment $sp (by 4 bytes) to point to the return address
	lw	$ra, ($sp)		# pop the return address from the stack
	jr	$ra			# return to the instruction referenced by $ra (return address register)
# end procedure printErrorMessage
##################################################################################################

##################################################################################################
# This is procedure exit. It encapsulates the syscall to the "terminate execution" service routine.
# Note that this procedure never returns, so it is not necessary to implement stack management.
exit:
	li	$v0, 	10		# function code for "terminate execution" 
	syscall				# invoke the service routine
# end procedure exit
##################################################################################################