Input Validation MIPS - validation

Question

How do I validate a user input in MIPS instruction set using MARS? In my following program I want to know how I can add validation to user input for example when asking the user if they want to decrypt or encrypt a message they need to input either 'E' or 'D' (case sensitive due to ascii values). As well as an input from (1-9) which is the encryption or decryption key. If they enter anything other than 'E', 'D' and a number from 1-9 how do I ask the user to enter a valid input using a subroutine for each prompt?
Code:
.data
encrypt_decrypt: .asciiz "Type(E)ncrypt/(D)ecrypt:"
key: .asciiz "\nEnter encryption key (1-9): "
message_prompt: .asciiz "\nEnter message: "
output: .asciiz ""
re_enter: .asciiz "\nWrong input"
buffer: .space 50
.text
main:
# Prints the prompt asking the user if they want to encrypt or decrypt
li $v0, 4
la $a0, encrypt_decrypt # Loads address from the user prompt
syscall
# Takes in E OR D based on user choice
li $v0, 12
syscall
add $t6, $v0, $0
bne $t6, 69, ELSE # Branch to else if inputed value is not E
# Prints the prompt asking the user for a message to either decrypt or
encrypt based on the users previous choice
li $v0, 4
la $a0, message_prompt # Loads address from the users message
syscall
# Takes the users message
li $v0, 8
la $a0, buffer
lb $t0, 0($a0)
li $a1, 48
syscall
la $s2, buffer
# Asks the user for a key from 1-9
li $v0, 4
la $a0, key
syscall
# Takes the users key value from 1-9
li $v0, 5
syscall
add $s0, $v0, $0
la $t0, ($s0) # Loads key
li $t1, 0 # Lower order bit to be toggled
la $t2, ($s2) # Load user message
beq $t6, 69, encrypt # 69 Is the printable ASCII value of "E"
beq $t6, 68, decrypt # 68 is the printable ASCII value of "D"
ELSE:
bne $t6, 68, E_D_VALIDATION # Branch to E_D_VALIDATION if user input is not D
E_D_VALIDATION:
li $v0, 4
la $a0, re_enter
syscall
j main
encrypt:
encrypt_loop:
lb $t3, 0($t2) # Loads character bytes
beq $t3, 10, encrypted # Branches to "encrypted" if we reach the end of a character
add $t3, $t3, $t0
addi $t4, $0, 1
sllv $t4, $t4, $t1
xor $t3, $t3, $t4 # Lower order bit toggle
sb $t3, 0($t2) # Stored encrypted character
addi $t2, $t2, 1
j encrypt_loop # Loops through the list of encrypted characters
encrypted:
li $v0, 4 # Print out encrypted message
la $a0, output
syscall
la $a0, ($s2)
syscall
j exit # Exits the program
decrypt:
decrypted_loop:
lb $t3, 0($t2) # Loads character bytes
beq $t3, 10, decrypted # Branches to "decrypted" if we reach the end of a character
addi $t4, $0, 1
sllv $t4, $t4, $t1
xor $t3, $t3, $t4
sub $t3, $t3, $t0
sb $t3, 0($t2) # Stored decrypted character
addi $t2, $t2, 1
j decrypted_loop # Loops through the list of decrypted characters
decrypted:
li $v0, 4 # Print out decrypted message
la $a0, output
syscall
la $a0, ($s2)
syscall
j exit # Exit the program
exit:

Answer 1

All you're missing is the error handling:
beq $t6, 69, encrypt # 69 Is the printable ASCII value of "E"
beq $t6, 68, decrypt # 68 is the printable ASCII value of "D"
<handle error here>
encrypt:
What to do to handle the error: print a message and quit, or print a message and goto someplace earlier in the code, maybe main or some other new label you introduce for this.
However, it might be nice to check for incorrect input before getting this far, and if you do that you won't have to check so much later: you can check for just E or just D instead of for both, because at this point you know it is only one or the other and nothing else.
So pseudo code you want to put immediately after inputting what should be the E or D:
if ( input != E && input != D ) { print input error message; goto reEnter; }
Where reEnter could be main or another location you choose to go back to get the input.
I would translate this into assembly language using the following series of transformations.
First, if-goto-label style, which skips the if-statement's then part when the condition is false:
if ( ! ( input != E && input != D ) ) goto inputOk;
print input error message
goto reEnter;
inputOk:
; continue with rest of program knowing good input (exactly E or D)
Next: distribute the negation per De Morgan:
if ( ! ( input != E ) || ! ( input != D ) ) goto inputOk;
print input error message
goto reEnter;
inputOk:
; continue with rest of program knowing good input (exactly E or D)
Next: negate the relational operators:
if ( input == E || input == D ) goto inputOk;
print input error message
goto reEnter;
inputOk:
; continue with rest of program knowing good input (exactly E or D)
Next: split the disjunction (||)
if ( input == E ) goto inputOk;
if ( input == D ) goto inputOk;
print input error message
goto reEnter;
inputOk:
; continue with rest of program knowing good input (exactly E or D)
Now, that's pretty easy to write in assembly.