Question

MIPS ASSEMBLY PROGRAM:

PLEASE Write in MIPS Assembly language.

Take strings as input and calculate and print a simple checksum for each string. Make your string long enough to hold 50 characters. Don't forget to leave space for the null byte. Our checksum algorithm will produce a value which you can print with the syscall for printing a character. Stop reading strings when the user enters ".".

The syscall to read a string (sycall code 8) adds a newline to the string (before the null byte) if the string is shorter than the maximum length specified. If there is a newline in the string that you read, replace it with a null byte Do not use the newline when calculating the checksum.

To calculate our checksum, add up the ASCII codes for the characters in the string, then find the remainder after dividing by 64. Finally, add the ASCII code for blank to the remainder. This give you the checksum.

Hints

• Use the lbu instruction to load one character of the string into a register. The lbu instruction loads one byte into the low order byte of the register and sets all the other bits to 0.
• Remember that what is stored in memory for a character is the ASCII code for that character.
• Look up the ASCII codes for blank, newline (also called line feed), and dot/period. The null byte is 0x0.
• Remember your comments should reflect the purpose of the statements. Write comments like "add char to checksum" not comments like "$f7 = $f7 + $f4".
• Don't be stubborn and wait to put in your comments till the end. And remember it's very important to comment your register usage.

Sample Execution

Enter a string (. to end): Error Correction!
The checksum is: C

Enter a string (. to end): Java C C++
The checksum is: >

Enter a string (. to end): UNIX Linux
The checksum is: T

Enter a string (. to end): macOS 10.12.2
The checksum is: %

Enter a string (. to end): .

Answer 1

Program:

Sample output:

Code to copy:

####################### checksum.asm ###########################

.data

                prompt: .asciiz "Enter a string (. to end): "

                msg: .asciiz "The checksum is: "

                newline:.asciiz "\n"

                theString:    .space 51

.text

main:

                la $a0,prompt                                    # prompt for input string

                li $v0,4

                syscall

                li $v0, 8                                                 # 8=read string

                la $a0, theString

                li $a1, 51                                              # set maximum length of string to 51

                                                                                                # (including null byte)

                syscall                                                   # read string

                li $t1,1                                                   # len=0

                la $t0,theString

L0:

                lbu $t2,($t0)

                beq $t2,$zero,exit_L0

                beq $t2, 46 ,check                           # 46= ASCII of '.'

                add $t0,$t0,1

                add $t1,$t1,1

                j L0

exit_L0:

                j Chk_for_newline

check:

                beq $t1,1,ExitProg                           # if length=0 and string is "."

                                                                                                # go to label ExitProg

Chk_for_newline:

                la $t0,theString

L1:

                lbu $t1,($t0)                                       # load current character

                beq $t1,$zero,sumLoop # if reached end of the string, go to sumLoop

                beq $t1,10,replace                           # go to replace

                j next

replace:

                sb $zero,($t0)

next:

                add $t0,$t0,1                                      # go to next character

                j L1

sumLoop:

                la $t0,theString

                li $s0,0                                                  # checksum=0                  

L2:

                lbu $t1,($t0)                                       # load current char

                beq $t1,$zero,exitL1       # reached end of the string

                add $s0,$s0,$t1                 # add char to checksum

                add $t0,$t0,1                                      # move to next character

                j L2

exitL1:

                div $s0,$s0,64                                    # divide the sum by 64

                mfhi $s0                                                               # store remainder into $s0

                add $s0,$s0,32                                   # add ASCII code for blank(space)

               

                la $a0,msg

                li $v0,4

                syscall

                move $a0,$s0                                     # print the checksum

                li $v0,11

                syscall

               

                la $a0,newline                                   # print new line

                li $v0,4

                syscall

                j main

               

ExitProg:

                li $v0, 10

                syscall