# strccnt.spim --- A SPIM program which reads a string and a character
#    from the user, returning the frequency count of the character within
#    the string.
#
# This primarily demonstrates the use of the stack frame.


            .data
prompt1:    .asciiz "Character: "
prompt2:    .asciiz "String: "
answer:     .asciiz "Frequency count: "
nl:         .asciiz "\n"
buffer:     .space 80


            .text
            .globl main
main:
            sub $sp, $sp, 12        # Push frame and save registers.
            sw $fp, 12($sp)
            sw $ra, 8($sp)
            sw $s0, 4($sp)
            add $fp, $sp, 12

            li $v0, 4               # Print prompt to read character.
            la $a0, prompt1
            syscall

            li $v0, 8               # Read character into buffer (!).
            la $a0, buffer
            li $a1, 80
            syscall

            la $s0, buffer          # Copy character into $s0.
            lbu $s0, 0($a0)

            li $v0, 4               # Print prompt to read string.
            la $a0, prompt2
            syscall

            li $v0, 8               # Read string.
            la $a0, buffer
            li $a1, 80
            syscall

            la $a0, buffer          # Call strccnt.
            move $a1, $s0
            jal strccnt

            move $s0, $v0           # Save return value.

            li $v0, 4               # Print response message.
            la $a0, answer
            syscall

            li $v0, 1               # Print frequency count.
            move $a0, $s0
            syscall

            li $v0, 4               # Print newline.
            la $a0, nl
            syscall

            lw $s0, 4($sp)          # Restore registers and pop frame.
            lw $ra, 8($sp)
            lw $fp, 12($sp)
            add $sp, $sp, 12

            li $v0, 0               # Programs normally exit with a
                                    # return value of 0.

            jr $ra                  # Return.


######################################################################


            .text
strccnt:
            sub $sp, $sp, 24        # Push frame and save registers.
            sw $fp, 24($sp)
            sw $ra, 20($sp)
            sw $s0, 16($sp)
            sw $s1, 12($sp)
            sw $s2, 8($sp)
            sw $s3, 4($sp)
            add $fp, $sp, 24

            move $s0, $a0           # Copy arguments to working regs.
            move $s1, $a1
            li $s2, 0               # Initialize count
while:
            lbu $s3, 0($s0)         # Read next char from s.
            beqz $s3, endwhile
if:
            bne $s1, $s3, endif     # Compare next char and c.
            addi $s2, $s2, 1        # Increment count.
endif:
            addi $s0, $s0, 1        # Increment pointer.
            b while
endwhile:
            move $v0, $s2           # Copy count to return reg.

            lw $s3, 4($sp)          # Restore registers and pop frame.
            lw $s2, 8($sp)
            lw $s1, 12($sp)
            lw $s0, 16($sp)
            lw $ra, 20($sp)
            lw $fp, 24($sp)
            add $sp, $sp, 24

            jr $ra                  # Return.