##############################PRELIMINARY PART1##############################
#convertHextoDec.asm
.text
main:
#printing welcome message
la $a0, welcome
li $v0, 4
syscall
#prompting the user to enter a hexadecimal number and enter 0 to terminate
the program
loop:
la $a0, enter
li $v0, 4
syscall
#taking hexadecimal input as a char array (string)
la $a0, hexStringAddress
li $a1, 10
li $v0, 8
syscall
#loading register a0 with the address of the first element of the char array
la $a0, hexStringAddress
#checking if the user entered 0
lbu $t0, 0($a0)
subi $t0, $t0, 48
beq $t0, 0, quit
jal convertHexToDecimal
convertHexToDecimal:
move $s0, $a0 #loading register s0 with the beginning address of the
string
nextChar:
lbu $s1, 0($s0) #getting the data in the address in
register s0 and storing it into register s1
blt $s1, 10, endOfTheString #if the value in s1 is less then 10,
continue (ascii of new line is 10)
addi $s0, $s0, 1 #to obtain the next char in the string
j nextChar
endOfTheString:
subi $s0, $s0, 2 #setting the address in register s0 to the
least significant bit of the string
li $s2, 1 #to multiply with the current digit to find the
decimal value of the digit
li $s3, 16 #to multiply with s2
li $s4, 0
calculateDecimalValue:
blt $s0, $a0, finish #stop evaluating characters if the
address in s0 is less than the address in a0
lbu $s1, 0($s0) #getting the value in the address in the
register s0
blt $s1, 48, notValidHexadecimal #
blt $s1, 58, asciiToDecimalValue #
blt $s1, 65, notValidHexadecimal #
blt $s1, 71, asciiToDecimalValue # checking if the char is a
valid hexadecimal number
blt $s1, 97, notValidHexadecimal #
blt $s1, 103, asciiToDecimalValue #
bge $s1, 103, notValidHexadecimal #
asciiToDecimalValue:
bgt $s1, 70, decrement_abcdef #for abcdef
j continue1
decrement_abcdef:
subi $s1, $s1, 32 #converting abcdef to ABCDEF
continue1:
bgt $s1, 57, decrementABCDEF #keep processing ABCDEF
j continue2
decrementABCDEF:
subi $s1, $s1, 55 #converting ABCDEF to 10, 11, 12,
13, 14 and 15, respectively
j adding
continue2:
subi $s1, $s1, 48 #finding decimal value of 0123456789
(before this point, they were ascii values)
adding:
mul $s1, $s2, $s1 #multiplying the decimal value with
2^(digit number - 1) to find its contribution to sum
add $s4, $s4, $s1 #calculating the sum
subi $s0, $s0, 1 #to obtain the next char
mul $s2, $s2, $s3 #digit coefficient for the next char
j calculateDecimalValue
notValidHexadecimal:
#informing user that they input an incalid value
la $a0, invalid
li $v0, 4
syscall
j loop
finish:
#printing the result
la $a0, decimal
li $v0, 4
syscall
move $a0, $s4
li $v0, 1
syscall
la $a0, newLine
li $v0, 4
syscall
j loop
quit:
la $a0, goodbye
li $v0, 4
syscall
li $v0, 10
syscall
.data
hexStringAddress:
.space 8
welcome:
.asciiz "Welcome to the hexadecimal to decimal converter!\n"
enter:
.asciiz "\nEnter the hexadecimal number(max 8 digits)(0 to quit): "
decimal:
.asciiz "Decimal: "
goodbye:
.asciiz "Goodbye!"
invalid:
.asciiz "Invalid input!\n"
newLine:
.asciiz "\n"
##############################END OF PRELIMINARY
PART1##############################
#################################PRELIMINARY
PART2##################################
#invertByte.asm
.text
main:
#printing welcome message
la $a0, welcome
li $v0, 4
syscall
loop:
#prompting the user
la $a0, enter
li $v0, 4
syscall
#taking input
la $a0, input
li $v0, 5
syscall
#quit if user input is 0
beq $v0, 0, quit
#storing the input in a variable and taking a copy to register s0
sw $v0, input
lw $s0, input
li $s1, 7 #s1 is the max power
li $s2, 0 #s2 will be the hexadecimal sum
la $s3, hexaArray
convertToHex:
blt $s1, 0, done #to take power and control the loop
move $a0, $s1 #loading the argument (power will return
16^$a0 in register $v0)
jal power
li $t0, 0 #t0 will be the num on index s1 + 1
howMany:
blt $s0, $v0, found #taking the number values of
each digit
sub $s0, $s0, $v0 #by subtracting 16^(digitNo - 1)
addi $t0, $t0, 1 #and saving how many times did we
do the subtraction
j howMany #we save the number value of the
digit in register t0
found:
bgt $t0, 9, addHexa #if ABCDEF (10, 11, 12, 13, 14,
15), branch to addHexa
ble $t0, 9, addNum #if 0123456789, branch to addNum
addHexa:
addi $t0, $t0, 55 #getting decimal values of the
hexadecimals
beq $t0, 65, addA #
beq $t0, 66, addB #
beq $t0, 67, addC #Deciding what to add on string
beq $t0, 68, addD #
beq $t0, 69, addE #
beq $t0, 70, addF #
addA:
sb $t0, 0($s3)
j added
addB:
sb $t0, 0($s3)
j added
addC:
sb $t0, 0($s3)
j added
addD:
sb $t0, 0($s3)
j added
addE:
sb $t0, 0($s3)
j added
addF:
sb $t0, 0($s3)
j added
addNum:
addi $t0, $t0, 48 #if $t0 is 0123456789, find its decimal
value
sb $t0, 0($s3) #adding it to the string
added:
addi $s1, $s1, -1 #changing power and control temporary
addi $s3, $s3, 1 #next char of the string
blt $s1, 0, done #if at the end of the input, branch to
done
j convertToHex #if not, loop
done:
#printing the hexadecimal form of the decimal input
la $a0, hexaForm
li $v0, 4
syscall
la $a0, hexaArray
li $v0, 4
syscall
#swapping nibbles to invert bytes
la $s3, hexaArray
la $a0, InvHexaForm
li $v0, 4
syscall
la $a0, 0($s3)
la $a1, 6($s3)
jal swap
la $a0, 1($s3)
la $a1, 7($s3)
jal swap
la $a0, 2($s3)
la $a1, 4($s3)
jal swap
la $a0, 3($s3)
la $a1, 5($s3)
jal swap
#printing inverted version
la $a0, hexaArray
li $v0, 4
syscall
j loop
quit:
#printing goodbye message
la $a0, goodbye
li $v0, 4
syscall
#terminating the flow
li $v0, 10
syscall
swap:
lbu $t0, 0($a0) #temp1 = arr[1]
lbu $t1, 0($a1) #temp2 = arr[2]
sb $t0, 0($a1) #arr[1] = temp2
sb $t1, 0($a0) #arr[2] = temp1
jr $ra
power:
move $t0, $a0 #register t0 holds the power (it is also a loop
control)
li $v0, 1 #register v0 will be the return value
loopPower:
beq $t0, 0, donePower #when power = 0, done
mul $v0, $v0, 16 #taking 16^power
addi $t0, $t0, -1 #loop control
j loopPower
donePower: jr $ra
.data
input:
.word 0
welcome:
.asciiz "Welcome to byte inverter!"
enter:
.asciiz "\n\nEnter a number in decimal(max 2,147,483,647 = (2^31) -
1)(0 to quit): "
hexaForm:
.asciiz "Hexadecimal form: "
InvHexaForm:
.asciiz "\nInverted hexadecimal form: "
goodbye:
.asciiz "Goodbye!"
hexaArray:
.space 8
