######################################################################
# Assignment 2, Parsing Immediate Object Code
# Author: 
#   
#Description: This program disassembles and prints a
#       set of instructions. Hexademical instructions
#       are hardcoded in .data section. The hexadecimals
#        are parsed into 4 fields,printed and then not 
#       instruction is processed. Terminates
#       when it runs into a null instruction.
#Example:
#     li        $1,7                    
#     addi      $1,$1,5         
#     ori       $2,$1,7         
#     andi      $1,$2,3
#####################################################################

                .data
instr:          .half           0x10ff,0x240f,0x3980,0x4e87,0x1800,0x0
sign:           .asciiz         "$"
addiprint:      .asciiz         "      addi   "
comma:          .asciiz         ","
oriprint:       .asciiz         "      ori    "
andiprint:      .asciiz         "      andi   "
liprint:        .asciiz         "      li     "
newline:        .asciiz         "\n"
parsed:         .byte           0,0,0,0

        .globl main
        .text

main:

        la      $a1,instr       #Ad dress[instr];

loop:                       #do {  // for each instruction loop
        lh      $s0,0($a1)      #instr[0]=opcode;

        srl     $s1,$s0,12      #opcode=instr>>12;
        andi    $s1,$s1,0xF     #opcode=opcode & 0xF;
        sh      $s1,parsed      #parsed[0]=opcode;

				#switch (opcode) {
        li      $t1,1           
        beq     $s1,$t1,licase  #// li
        li      $t2,2         
        beq     $s1,$t2,addics  #// addi
        li      $t3,3           
        beq     $s1,$t3,orics   #// ori  
        li      $t4,4           
        beq     $s1,$t4,andics  #// andi

termi:                          # case default:
        li      $v0,10          #     System(exit);
        syscall

licase:                         # case 'li':
        li      $v0,4           #     Print(liprint);
        la      $a0,liprint
        syscall
        b       label           #     break;

addics:                         # case addi:
        li      $v0,4           #     Print(addiprint);
        la      $a0, addiprint
        syscall
        b       label           #     break;  

orics:                          # case ori:
        li      $v0,4           #     Print(oriprint);
        la      $a0, oriprint
        syscall
        b       label           #     break;

andics: li      $v0,4           # case andi:       
        la      $a0,andiprint   #     Print(andiprint);
        syscall

label:                          # endswitch

        li      $v0,4           #Print("$");
        la      $a0,sign
        syscall

rs:                             #//rs code
        srl     $s1,$s0,10      #rs = byte>>10;        
        andi    $s1,$s1,0x3     #rs=rs&0x3;
        sh      $s1,parsed+2    #parsed[1]=rs;

        li      $v0,1           #Print(rs);
        la      $a0,0($s1)
        syscall

        li      $v0,4           # Print(",");
        la      $a0,comma
        syscall

        lh      $t7,parsed      #parsed[0] 
        beq     $t7,$t1,imm     #if parsed[0]!= 'li' 

        li      $v0,4           #    Print("$");
        la      $a0,sign
        syscall

rd:                             #    //rd code

        srl     $s1, $s0, 8     #    rd=byte>>8;
        andi    $s1,$s1,0x3     #    rd=rd&0x3;
        sh      $s1, parsed +4  #    parsed[2]=rd;

        li      $v0,1           #    Print(rd);
        la      $a0,0($s1)
        syscall

        li      $v0,4           #    Print(",");
        la      $a0,comma
        syscall
                                #endif
imm:                            #//immediate code 

        srl     $s1, $s0, 0     #imm=byte>>0;
        andi    $s1,$s1, 0xFF   #imm=imm&0xFF;
        sh      $s1, parsed +6  #parsed[3]=imm;

        li      $v0,1           #Print(imm);
        la      $a0,0($s1)
        syscall

        li      $v0, 4          #Print("\n");
        la      $a0, newline
        syscall

        addi     $a1,$a1,2      #address = Address+2

        j       loop         #enddo