## A program for the MIPS emulator: "PCSpim" 
##
## Objective: 
## Count the occurance of ascii byte 'char' in an ascii string.
##
## t0 - holds each byte from string in turn
## t1 - index into array: k in str(k)
## t2 - count of occurences
## t3 - holds the character to search for
##
.data
    str: .asciiz "abcd"    # this is the target string to search
   char: .asciiz "a"       # this is the original target character       
  char2: .asciiz "z"       # this is the target char your trying to implement       
   txt1: .asciiz "\n\n the number of "           # report message string
   txt2: .asciiz " in the above string is:: "    # message string
   endl: .asciiz "\n Bye, please test again! \n" # message string

.text
.globl main
main:
  nop                   # no operation 'instruction'
  li  $t1, 0            # $t1 holds the array index
  li  $t2, 0            # $t2 holds n_timesfound counter
  lb  $t3, char         # $t3 holds the search-for character
                        # MAYBE A SECOND SEARCH-FOR ASSIGNMENT TO $t4 ??
#
  loop:
    lb   $t0, str($t1)  # load byte from address  str($t1)  into $t0
    beqz $t0, strEnd    # if NULL, goto "strEnd" label  (exit loop)

                        #### THIS IS WHERE YOUR COUNT IS INCREMENTED ####
    bne  $t0, $t3, con  # if $t0 != $t3 (char), breakto "con" label
                        # which is essentially "if != skip the next line"
                        # which is essentially "if == DO the next line"
    add  $t2, $t2, 1    # increment counter (t2)
    con:                # the 'break to'  label
                        # OK SO YOU JUST NEED TO DO ANOTHER CONDITIONAL
                        # LIKE THE ONE IN THE LAST THREE LINES FOR char2 
                        # YOU WILL ALSO NEED TO WORK IT INTO  
                        # THE REPORT PRINTING ROUTINE BELOW 
                        #################################################
                        
    add  $t1, $t1, 1    # increment index
  j loop                # "jump" to (goto) the "loop" label
#
  strEnd:             # string search all done so deliver output

                      # PRINT THE TARGET STRING 
  la $a0, str         # load string address represented by str into register a0
  li $v0, 4           # load int syscallcode 4 (print string) into register v0 
  syscall             # interrupt kernel to do syscall 4

                      # PRINT FIRST PART OF OUTPUT MESSAGE
  la $a0, txt1        # load string address of txt1 into register a0
  syscall             # syscall  (syscallcode 4 (print string) is still in v0 ) 

                      # PRINT SINGLE SEARCH-FOR CHARACTR
  la $a0, char        # load string address represented by "char" into a0
  syscall             # syscall  (syscallcode 4 (print string) is still in v0 ) 
  
                      # PRINT CENTER PART OF MESSAGE 
  la $a0, txt2        # load string address represented by "txt2" into a0
  syscall             # syscall  (syscallcode 4 (print string) is still in v0 ) 

                      # PRINT THE N_TIMES SEARCH-FOR CHARACTER WAS FOUND
  move $a0, $t2       # move value found in register t2 (n_timesfound) into a0
  li   $v0, 1         # load the callcode to print an integer (1) into v0
  syscall             # interrupt kernel to do syscall 1

                      # PRINT THE CLOSING MESSAGE LINE
  la $a0, endl        # load string address of endl into register a0
  li $v0, 4           # change callcode in v0  back to 4 (print string)
  syscall             # interrupt kernel to do syscall 4

  li $v0, 10          # (usual quit)  (SYSCODE TO EXIT)
  syscall             # au revoir...
## THE END

                        #### THIS IS WHERE YOUR COUNT IS INCREMENTED ####
    bne  $t0, $t3, con  # if $t0 != $t3 (char), breakto "con" label
                        # which is essentially "if != skip the next line"
                        # which is essentially "if == DO the next line"
    add  $t2, $t2, 1    # increment counter (t2)
    con:                # the 'break to'  label
                        # OK SO YOU JUST NEED TO DO ANOTHER TEST LIKE
                        # THE ONE IN THE LAST THREE LINES FOR char2 
                        # YOU WILL ALSO NEED TO WORK IT INTO  
                        # THE REPORT PRINTING ROUTINE BELOW 
                        #################################################

if( $to != $t3 )
{
  /* skip the else (do nothing)   */
}
else
{ 
  $t2++;
}

lb $t10, char4
li $t11,0 #counter d
li $t12,0 #array 4

        I'LL USE  #~  TO NOTES MY COMMENTS IN THE FOLLOWING:
main:
  nop                   # no operation 'instruction'
  li  $t1, 0            # $t1 holds the array index
  li  $t2, 0            # $t2 holds n_timesfound counter
  lb  $t3, char         # $t3 holds the search-for character
  lb  $t4, char2         # MAYBE A SECOND SEARCH-FOR ASSIGNMENT TO $t4 ??
  li  $t5, 0		# next counter for b
  li  $t6, 0		
 
#
  loop:
    lb   $t0, str($t1)  # load byte from address  str($t1)  into $t0
    beqz $t0, strEnd    # if NULL, goto "strEnd" label  (exit loop)

                        #### THIS IS WHERE YOUR COUNT IS INCREMENTED ####
    bne  $t0, $t3, con  # if $t0 != $t3 (char), breakto "con" label
                        # which is essentially "if != skip the next line"
                        # which is essentially "if == DO the next line"
    add  $t2, $t2, 1    # increment counter (t2)
    con:                # the 'break to'  label
                        # OK SO YOU JUST NEED TO DO ANOTHER CONDITIONAL
                        # LIKE THE ONE IN THE LAST THREE LINES FOR char2 
                        # YOU WILL ALSO NEED TO WORK IT INTO  
                        # THE REPORT PRINTING ROUTINE BELOW 
                        #################################################
                        
    add  $t1, $t1, 1    # increment index #~ <-- NOT HERE! DO IT JUST 
                                          #~ <-- THE END OF LOOP: 'j loop'
    bne $t0, $t4, con2  #~ <-- TEST2- OK 
      add $t5,$t5,1     #~ <-- INCREMENT COUNT2- OK
                        #~ <-- MOVE CON2 TO HERE!!! 
  j loop                # "jump" to (goto) the "loop" label #~ <-- OK
    
    con2:             #~ <-- SHOULD IMMEDIATELY FOLLOW THE INCREMENT OF COUNT2
    add $t6,$t6,1     #~ <-- IS THIS A SECOND INCREMENT?  NOT NEEDED... 
  j loop              #~ <-- NOT NEEDED USE THE MECHANICS OF THE FIRST LOOP

  strEnd:             # string search all done so deliver output  #~ <-- OK

To search for a second character your loop should resemble this illustration:
(quasi C style:) 

## set some data:
char1= a, char2= b, string = "\n abcde";             ## btw:   !=   means "not equal to" 

## Set the registers:
$t0 = 0            # will be assigned each succesive char of string in loop
$t1 = 0            # holds the array index
$t2 = 0            # holds n_timesfound-1 counter
$t3 = char1        # holds the search-for-1 character
$t4 = 0            # holds n_timesfound-1 counter
$t5 = char2        # holds the search-for-2 character

loop:
{
    get next char from string into t0
    test t0 for zero (terminator) if yes goto "END" 
  
    test: if( t0 != t3 ) skip to "con1"                 ## <-- FIRST SEARCH
    {
        no skip so this line increments t2 (n_timesfound-1)
    }
    con1:

    test: if( t0 != t5)  skip to "con2"                 ## <-- SECOND SEARCH
    {
        no skip so this line increments t4 (n_timesfound-2)
    }
    con2:
  
} jump to "loop"                                     ## ONLY ONE LOOP USED 
END: