Assembler.java

import java.util.HashMap;

public class Assembler {
    // Hashmap to store codes which are in 2r or immediate formats.
    private static HashMap<String, String> TwoRImmediateOpCodes = new HashMap<String, String>();
    // Hashmap to store codes which are in call/return formats
    private static HashMap<String, String> CallReturnOpCodes = new HashMap<String, String>();
    // Method to place codes and their corresponding binary vals.
    private static void setOpCodes(){
        TwoRImmediateOpCodes.put("halt", "fffff");
        TwoRImmediateOpCodes.put("add", "fffft");
        TwoRImmediateOpCodes.put("and", "ffftf");
        TwoRImmediateOpCodes.put("multiply","ffftt");
        TwoRImmediateOpCodes.put("leftshift", "fftff");
        TwoRImmediateOpCodes.put("subtract","fftft");
        TwoRImmediateOpCodes.put("or", "ffttf");
        TwoRImmediateOpCodes.put("rightshift", "ffttt");
        CallReturnOpCodes.put("syscall", "ftfff");
        CallReturnOpCodes.put("call", "ftfft");
        CallReturnOpCodes.put("return", "ftftf");
        TwoRImmediateOpCodes.put("compare", "ftftt");
        CallReturnOpCodes.put("ble", "fttff");
        CallReturnOpCodes.put("blt", "fttft");
        CallReturnOpCodes.put("bge", "ftttf");
        CallReturnOpCodes.put("bgt", "ftttt");
        CallReturnOpCodes.put("beq", "tffff");
        CallReturnOpCodes.put("bne", "tffft");
        TwoRImmediateOpCodes.put("load", "tfftf");
        TwoRImmediateOpCodes.put("store", "tfftt");
        TwoRImmediateOpCodes.put("copy", "tftff");
    }
    // Method to convert integer number into binary format
    private static String convertNumber(int value, int size){
        // Final string fin to return for method
        String fin = "";
        // isNegative checks to see if the val is less than 0, if so prepare to negate it by adding 1 and conditionally manipulating the bits
        // (depending on whether its a negative or not)
        boolean isNegative = (value < 0);
        // Index to ensure that the final string doesn't become bigger than index
        int index = size;
        if(isNegative)
            value++;
        // while the value isn't 0, divide it by 2, if the remainder after being divided isn't true, then set it to 1 (or 0). If it's negative and odd, then
        // also set the bit to true.
        while(value != 0 && index != 0){
            if(!isNegative && ((value % 2) == 0))
                fin += "f";
            else if(!isNegative && ((value % 2) != 0))
                fin += "t";
            else if(isNegative && ((value % 2) == 0))
                fin += "t";
            else
                fin += "f";
            index--;
            value /=2;
        }
        // Padding to convert negative numbers in the case the fin string is less than size.
        String padding = "";
        int len = size - fin.length();
        int n = 0;
        char ch = 'f';
        // set ch to t if negative
        if(isNegative)
            ch = 't';
        // Set padding to character
        while(n < len){
            padding += ch;
            n++;
        }
        // Return padding + reversed string.
        StringBuilder sb = new StringBuilder(fin);
        return padding + sb.reverse();
    }
    public static String[] assemble(String[] input) {
        // Set up the operation codes
        setOpCodes();
        // Initialize an output string
        String[] output = new String[input.length];
        // i to keep track the location of the string in each input string
        int i = 0;
        // iterate thru input and derivce the line from input string list.
        for(String ln : input){
            // isCallReturnFormat boolean to determine the type of format of ln.
            boolean isCallReturnFormat = false;
            // strForOutput is the final input to be used for the output str list
            String strForOutput = "";
            // wrds is the result of the ln splitted by space, this will then assemble
            // the whole line into a legible 16 bit output.
            String[] wrds = ln.split(" ");
            for(String wrd : wrds){
                // First check if the wrd is a number and is not in CallReturn format
                if(checkIfNumber(wrd) && !isCallReturnFormat){
                    // If number, then replace 'f' with 't' to instructions + bin num.
                    strForOutput = strForOutput.substring(0, strForOutput.length()-1);
                    strForOutput += "t"+convertNumber(Integer.parseInt(wrd), 5);
                }
                // If not in call returnFormat, then add integer of size 11
                else if(checkIfNumber(wrd)){
                    strForOutput += convertNumber(Integer.parseInt(wrd), 11);
                }
                // Check if wrd is a register + a number.
                else if(wrd.charAt(0) == 'r' && !CallReturnOpCodes.containsKey(wrd) && !TwoRImmediateOpCodes.containsKey(wrd))
                    strForOutput += convertNumber(Integer.parseInt(wrd.substring(1)),5);
                // Add CallReturnOpCodes bin val to strForOutput
                else if(CallReturnOpCodes.containsKey(wrd)){
                    strForOutput += CallReturnOpCodes.get(wrd);
                    isCallReturnFormat = true;
                }
                // Add TwoRImmediateOpcodes val of string to strForOutput
                else{
                    strForOutput += TwoRImmediateOpCodes.get(wrd) + "f";
                }
            }
            // Fill the string with f if size of strForOutput is less than 16
            int len = strForOutput.length();
            while(len != 16){
                strForOutput += 'f';
                len++;
            }
            // Set output to strForOutput, add i to set up for next conversion.
            output[i] = strForOutput;
            i++;
        }
        return output;
    }
    // Check if number checks if a string is able to be converted to an int.
    private static boolean checkIfNumber(String s){
        try{
           Integer.parseInt(s);
           return true;
        } catch(Exception e){
        return false;
        }
    }
    public static String[] finalOutput(String[] input) {
        // newSize to account for odd instances of input len.
        int newSize = (input.length + 1) / 2;
        // Fin to be created as the output.
        String[] fin  = new String[newSize];
        // Halt string in cases of a singular line.
        String halt = "ffffffffffffffff";
        // For each index in fin, if i value is in input, add it,
        // else, add the final line plus halt as the final output for the assembler.
        for (int i = 0; i < fin.length; i++) {
            if (2 * i + 1 < input.length)
                fin[i] = input[2 * i] + input[2 * i + 1];
            else
                fin[i] = input[2 * i] + halt;
        }
        return fin;
    }
}