Utilities.java

import java.io.*;
import java.util.*;
import java.util.regex.*;

public class Utilities {
	
	public static int hexstr_to_int(String hex_str) {
	    long v = Long.parseLong(hex_str, 16);
	    return (int)v;
	}
	
	public static int str_to_int(String str) {
	    long v = Long.decode(str);
	    return (int)v;
	}
	
	// nbits must be less than 32
	public static String int_to_bin_string(int v, int nbits)
	{
		v = (v & ((1 << nbits) - 1)) | (1 << nbits);
		return Integer.toBinaryString(v).substring(1);
	}
	
	public static void print_int(String s, int i)
	{
		System.out.format("%s=0x%08X %11d", s, i, i);
	}

	public static void println_int(String s, int i)
	{
		System.out.format("%s=0x%08X %11d\n", s, i, i);
	}
	
	public static void print_signal(String s, int v, int n)
	{
		if (n == 1) {
			System.out.format("%s=%d\n", s, v & 1);
		}
		else if (n < 16) {
			System.out.format("%s=0b%s %d\n", s, int_to_bin_string(v, n), v);
		}
		else if (n == 16) {
			v = v & 0xFFFF;
			System.out.format("%s=0x%04X %d\n", s, v, v);
		}
		else {
			System.out.format("%s=0x%08X %d\n", s, v, v);
		}
	}
	
	public static void print_new_cycle(int cycle_num)
	{
        System.out.println("==========================================\nCycle " + cycle_num);
	}

	public static void print_signals_1(Signals sig)
	{
		print_signal("opcode", sig.opcode, 6);
		print_signal("funct", sig.funct, 6);
		print_signal("rs", sig.rs, 5);
		print_signal("rt", sig.rt, 5);
		print_signal("rd", sig.rd, 5);
		print_signal("immediate", sig.immediate, 16);
		print_signal("RegDst", sig.RegDst, 1);
		print_signal("Jump", sig.Jump, 1);
		print_signal("Branch", sig.Branch, 1);
		print_signal("MemRead", sig.MemRead, 1);
		print_signal("MemtoReg", sig.MemtoReg, 1);
		print_signal("ALUOp", sig.ALUOp, 2);
		print_signal("MemWrite", sig.MemWrite, 1);
		print_signal("ALUSrc", sig.ALUSrc, 1);
		print_signal("RegWrite", sig.RegWrite, 1);
		print_signal("Sign_extended_immediate", sig.Sign_extended_immediate, 32);
		print_signal("ALU_operation", sig.ALU_operation, 4);
		print_signal("Branch_address", sig.Branch_address, 32);
		print_signal("Jump_address", sig.Jump_address, 32);
		print_signal("Write_register", sig.Write_register, 5);
	}

	public static void print_signals_2(Signals sig)
	{
		print_signal("RF_read_data_1", sig.RF_read_data_1, 32);
		print_signal("RF_read_data_2", sig.RF_read_data_2, 32);
		print_signal("ALU_input_2", sig.ALU_input_2, 32);
		print_signal("ALU_result", sig.ALU_result, 32);
		print_signal("Zero", sig.Zero, 1);
		print_signal("MEM_read_data", sig.MEM_read_data, 32);
		print_signal("Write_data", sig.Write_data, 32);
		print_signal("PCSrc", sig.PCSrc, 1);
		print_signal("PC_branch", sig.PC_branch, 32);
		print_signal("PC_new", sig.PC_new, 32);
	}
	
	public static void load_file(Memory IMem, String filename)
	{
		String line;
		BufferedReader br;
        String pattern =  "^(0x\\p{XDigit}+)\\s+(0x\\p{XDigit}+)";
        Pattern r = Pattern.compile(pattern);
        int		addr;
        long	data;
        		
        IMem.set_memread(0);
        IMem.set_memwrite(1);        
		try {
		     br = new BufferedReader(new FileReader(filename));
		        		
    	    while ((line = br.readLine()) != null) { // while loop begins here
    	           // System.out.println(line);
    	           Matcher m = r.matcher(line);
    	           if (m.find()) {
    	                // System.out.println(m.group(1) + " " + m.group(2));
    	                addr = Integer.decode(m.group(1));
    	                data = Long.decode(m.group(2));
    	                IMem.set_address(addr);
    	    	        IMem.set_data((int)data); // only the lower 32 bits
    	    	        IMem.run();
    	           }
    	    } // end while     		
		} catch (IOException e){
	        System.err.println("Error: " + e.getMessage());
	    }
        IMem.set_memwrite(0);
	}
}