This assignment builds off of previous ones, I need this this one done using the other assignments I made. I will attach the previous assignments with all the files together. ICSI 404 – Assignment 4,...

ICSI_404_4/404_ALU/ALU.java
ICSI_404_4/404_ALU/ALU.java
public class ALU {

    public static longword doOp(bit[] operation, longword a, longword b)
    {
        // Initializing the data I will be using.
        Impl_Longword longword_OpA = new Impl_Longword();
        Impl_Longword longword_OpB = new Impl_Longword();
        // Copying a and b into separate data so I don't accidentally touches them.
        longword_OpA.original = a;
        longword_OpB.original = b;

        // Will be returning this.
        longword result = new longword();

        if(operation[operation.length-1].getValue() == 1)
        {
            // xx11
            if(operation[operation.length-2].getValue() == 1)
            {
                //x111
                if(operation[1].getValue() == 1)
                {
                    //1111
                    if(operation[0].getValue() == 1)
                    {
                        // 1111 - subtract
                        System.out.println("\n1111 - subtract");
                        System.out.println(longword_OpA.getSigned() + " - " + longword_OpB.getSigned() + " = " + (longword_OpA.getSigned()-
                                longword_OpB.getSigned()));
                        System.out.println();
                        printBit(a.getArray());
                        printBit(b.getArray());
                        System.out.println("____________________________________");
                        result = rippleAdder.subtract(a, b);
                    // 0111
                    }else
                    {
                        // 0111 - multiply
                        System.out.println("\n0111 - multiply\n");
                        System.out.println(longword_OpA.getSigned() + " x " + longword_OpB.getSigned() + " = " 
                        + longword_OpA.getSigned()*longword_OpB.getSigned());
                        System.out.println();
                        printBit(a.getArray());
                        printBit(b.getArray());
                        System.out.println("____________________________________");
                        result = Multiplier.multiply(a, b);
                    }
                // x011 (there is only one choice that have -011 as the last three digits)
                }else
                {
                    // 1011 - not
                    System.out.println("\n1011 - not");
                    printBit(a.getArray());
                    System.out.println("____________________________________");
                    result = longword_OpA.not();
                }
            // xx01
            }else
            {
                // x101 (refer to the top for x011)
                if(operation[1].getValue() == 1)
                {
                    // 1101 - right shift
                    System.out.println("1101 - right shift");
                    printBit(a.getArray());
                    System.out.println("____________________________________");
                    result = longword_OpA.rightShift(longword_OpB.getSigned());
                // x001 (refer to the top for x011)
                }else
                {
                    // 1001 - or
                    System.out.println("\n1001 - or");
                    printBit(a.getArray());
                    printBit(b.getArray());
                    System.out.println("____________________________________");
                    result = longword_OpA.or(b);
                }
            }
        // xxx0
        }else
        {
            // xx10
            if(operation[operation.length-2].getValue() == 1)
            {
                // x110 (refer to the top for x011)
                if(operation[1].getValue() == 1)
                {
                    // 1110 - add
                    System.out.println("\n1110 - add");
                    System.out.println(longword_OpA.getSigned() + " + " + longword_OpB.getSigned() + " = " 
                    + (longword_OpA.getSigned()+longword_OpB.getSigned()));
                    System.out.println();
                    printBit(a.getArray());
                    printBit(b.getArray());
                    System.out.println("____________________________________");
                    result =rippleAdder.add(a, b);
                // x010 (refer to the top for x011)
                }else
                {
                    // 1010 - xor
                    System.out.println("\n1010 - xor");
                    printBit(a.getArray());
                    printBit(b.getArray());
                    System.out.println("____________________________________");
                    result = longword_OpA.xor(b);
                }
            // xx00 
            }else
            {
                // x100 (refer to the top for x011)
                if(operation[1].getValue() == 1)
                {
                    // 1100 - left shift
                    System.out.println("1100 - left shift");
                    printBit(a.getArray());
                    System.out.println("____________________________________");
                    result = longword_OpA.leftshift(longword_OpB.getSigned());
                    // x000 (refer to the top for x011)
                }else
                {
                    // 1000 - and
                    System.out.println("\n1000 - and");
                    printBit(a.getArray());
                    printBit(b.getArray());
                    System.out.println("____________________________________");
                    result = longword_OpA.and(b);
                }
            }
        }

        // And then return the result. Which will be unique because there should be only one operation gets actived. 
        return result;
    }

    public static void printBit(bit[] toPrint)
    {
        int count = 0;
        for(int i = 0; i < toPrint.length; i++)
        {
            System.out.print(toPrint[i].getValue());
            count++;
            if(count == 8)
            {
                System.out.print(",");
                count = 0;
            }
        }
        System.out.println();
    }
}
ICSI_404_4/404_ALU/ALU_Test.java
ICSI_404_4/404_ALU/ALU_Test.java
public class ALU_Test {
    public void runTest()
    {

        long[] testData = {1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 111};
        Impl_Longword longword1 = new Impl_Longword();
        Impl_Longword longword2 = new Impl_Longword();


        int[] firstT = {200, -10};
        int[] secondT = {-3, 555};
        int shiftAmount = 3;


        for(int j = 0; j < firstT.length; j++)
        {
            System.out.println("\n-----------------------------------------------------\n");
            System.out.println("Test " + j + "\nA: " + firstT[j] + "\nB: " + secondT[j]);
        for(int i = 0; i < testData.length; i++)
        {
            longword1.set(firstT[j]);
            longword2.set(secondT[j]);
            if(i == 4 )
            {
                longword2.set(shiftAmount);
                System.out.println("left shift: " + shiftAmount);
                longword1.printBit(ALU.doOp(intTobinary(testData[i]), longword1.original, longword2.original).getArray());
            }else if(i == 5)
            {
                longword2.set(shiftAmount);
                System.out.println("right shift: " + shiftAmount);
                longword1.printBit(ALU.doOp(intTobinary(testData[i]), longword1.original, longword2.original).getArray());
            }else
            {
            longword1.printBit(ALU.doOp(intTobinary(testData[i]), longword1.original, longword2.original).getArray());
            }
            System.out.println();
        }
        }
    }

    public bit[] intTobinary(long theInt)
    {
        bit[] result = new bit[4];
        long holder = theInt;
        for(int i = 3; i >= 0; i--)
        {
            bit lastDigit = new bit();
            lastDigit.setValue((int)holder%10);
            result[i] = lastDigit;
            holder = holder / 10;
        }
        return result;
    }
}
ICSI_404_4/404_ALU/bit.java
ICSI_404_4/404_ALU/bit.java
public class bit {

    private int value;

    // the getter
    public int getValue() {
        return value;
    }
    // the setter
    public void setValue(int value) {
        this.value = value;
    }

}
ICSI_404_4/404_ALU/Driver.java
ICSI_404_4/404_ALU/Driver.java
public class Driver {

    public static void main(String[] args)
    {

        ALU_Test hi = new ALU_Test();

        hi.runTest();
    }
}
ICSI_404_4/404_ALU/ILongword.java
ICSI_404_4/404_ALU/ILongword.java
public interface ILongword {

    // Get bit i
    bit getBit(int i);

    // set bit i's value
    void setBit(int i, bit value);

    // and two longwords, returning a third
    longword and(longword other);

    // or two longwords, returning a third
    longword or(longword other);

    // xor two longwords, returning a third
    longword xor(longword other);

    // negate this longword, creating another
    longword not();

    // rightShift this longword by amount bits, creating a new longword
    longword rightShift(int amount);

    // leftShift this longword by amount bits, creating a new longword
    longword leftshift(int amount);

    // returns a comma separated string of 0's and 1's: "0,0,0,1,1,0,1"
    @Override
    String toString();

    // returns the value of this longword as a long
    long getUnsigned();

    // returns the value of this longword as an int
    int getSigned();

    // copies the values of the bits from another longword into this one
    void copy(longword other);

    // set the value of the bits of this longword(used for tests)
    void set(int value);
}
ICSI_404_4/404_ALU/Impl_Bit.java
ICSI_404_4/404_ALU/Impl_Bit.java
import java.lang.Math;
public class Impl_Bit implements I_Bit {

    // This is to store each instances of the bit class
    bit bitHolder = new bit();

    public void set(int value)
    {
        bitHolder.setValue(value);
    }

    public void toggle()
    {
        bitHolder.setValue(Math.abs(bitHolder.getValue() - 1 ));

    }
    public void set()
    {
        bitHolder.setValue(1);
    }

    public void clear()
    {
        bitHolder.setValue(0);
    }

    public int getValue()
    {
        return bitHolder.getValue();
    }

    public bit and(bit other)
    {
        bit andBit = new bit();

        if(bitHolder.getValue() == other.getValue())
        {
            if(bitHolder.getValue() == 0)
        ...