CS061-Assignment 4 Solved

The purpose of this assignment is to illustrate how the .FILL pseudo-op performs the task of translating textual decimal numbers (such as the string “+5392”) into actual numbers (i.e. five thousand three hundred and ninety two, represented of course as a 16-bit two's complement binary value).

 

High Level Description
Prompt the user to enter a signed multi-digit decimal number (max 5 digits) from the keyboard. Convert the string of decimal numeric digits into the corresponding 16-bit two's complement number, stored in ​Rx (i.e. one of the 8 registers: ​you will be told which register at the start of the provided starter code​)​.  The range of acceptable values is [-32768, +32767]; the absence of a sign means the number is positive - i.e. the first character entered by the user may be '+', '-', or a numeric digit.

 

Your Tasks
Your program can be broken down into the following tasks:

1.      Read in the initial character. If it is a ‘-‘, make the final result negative by setting a "flag" (​ i.e. if the "negative" flag is set, take the 2’s complement of ​Rx​ at the end).  

If the initial character is '+' it can be ignored; likewise, if it is a numeric digit, then it is not negative.

If it is a newline, the program can just quit without any output.

Any other initial character must be treated as an error (see below).

2.      Convert the string of numeric digits input by the user into the binary number they represent (​ see examples below)​. To do this, you can follow this algorithm:

●      Initialize ​Rx​ (and any other registers as needed) to 0  DO NOT​ do this by LD'ing a 0 from memory!  

There is a much simpler & faster way - remember the "TIP" in your lab 1 notes! 

 

●      Convert each digit from ascii code to binary number as it is typed in, and add it to ​Rx​;  as subsequent digits are entered, multiply ​Rx​ by #10, and repeat.  

Stop​ when you detect the newline character ('\n' = x0A), or when you reach 5 input digits:

○ For example, if the user types ‘2’, then ​Rx​ will contain

 #2 = b0000 0000 0000 0010

○ If the user then types ‘3’, making the string now read “23”, then ​Rx ​will contain  2 x #10 + 3 = #23 = b0000 0000 0001 0111

○ If the user then types ‘4’, making the string read “234”, then ​Rx ​will contain

 #23 x #10 + 4 = #234 = b0000 0000 1110 1010

You must also perform ​input character validation​ with this assignment – i.e.  reject any ​non-numeric​ input character. That is, if the user enters “+23g”, on detecting the non-numeric 'g', your program should output an error, and  ​start over with the initial prompt​ (see sample output).

 

You must also ​count​ the number of characters entered - once it gets to 5 you should stop accepting new characters, and issue a newline (i.e. in this case, ​do not wait​ for the user's newline).

 

However, you do not have to detect overflow in this assignment – we will only test your code with inputs in the range [-32768, +32767]. 

 

Expected/ Sample output
Output 

●      Prompt

○      "Input a positive or negative decimal number (max 5 digits), followed by ENTER" ■ Newline terminated

●      Error Message

○      "ERROR: invalid input"

■ Newline terminated

 

Example 

If the user enters “+7246”, your program should read the ‘+’, ‘7’, ‘2’, ‘4’, ‘6’ and end up with the value b0001 1100 0100 1110 (​ which is the two's complement representation of the number #7246, or x1C4E) in the specified register​ .​

If the users enters “-14237”, your program should read the ‘-‘, ‘1’, ‘4’, ‘2’, ‘3’, ‘7’ and end up with the value #-14237 = xC863 = b11001000 01100011 in the specified register​         .​

 

WARNING​: In the following examples, the final result is shown in R2, which is NOT what you will use. 

You will store your result in the register specified in the header in your starter code!! Make sure you get this right, or the grader will not work, and you will get 0/10! 

 

 

  

(Valid input with a negative sign)

 

  

(Valid input with a positive sign)

 

  

(Valid input with No sign)

  

(Invalid initial input, followed by valid input) Note: 

●      You must echo the digits as they are input (no "ghost writing").

●      You do ​not​ have to output the converted binary number. It should simply be sitting happily in Rx​ ,​ where you can check it in the simpl interface.

Remember, the register in which to store your result is given to you in your code header. 

●      What should happen when an error occurs?

○ Output "ERROR: invalid input" and start over,  re-prompting the user for input ● Possible errors ​(we will test for these!)​:

○ Nothing entered before ENTER  

(this does not trigger an error message, it just terminates the program) 

○ only a sign is entered, no numeric digits

○ the first character entered is neither a sign nor a numeric digit

○ A subsequent character is not a digit

 - e.g. the sign character is entered twice, or a letter is entered in place of a digit ● ​REMEMBER: the program must be newline terminated 

 

Your code will obviously be tested with a range of different values:  Make sure you do likewise!