/// <summary>
/// Default constructor
/// </summary>
/// <param name="mm">Memory</param>
/// <param name="w">UVSim controller</param>
public Compilator(MemoryManager mm, IUVSimController w)
{
memory = mm;
window = w;
isVariable = new Dictionary <int, string>();
isNumber = new List <int>();
charIndex = 97;
}
// Default constructor.
public VirtualMachine(MemoryManager m, int numPrograms, IUVSimController w)
{
memory = m;
window = w;
currentThread = 0;
// Creating virtual threads
threads = new Thread[numPrograms];
for (int i = 0; i < numPrograms; i++)
{
Thread thread = new Thread(i);
threads[i] = thread;
}
}
public static void Error(this IUVSimController window, string error)
{
RichEditControl console = window.Console;
console.Dispatcher.Invoke(() =>
{
console.BeginUpdate();
var paragraph = console.Document.Paragraphs.Append();
console.Document.InsertText(paragraph.Range.Start, $"{error}.\r\n");
//var charProperties = console.Document.BeginUpdateCharacters(paragraph.Range);
//charProperties.ForeColor = System.Drawing.Color.Red;
//console.Document.EndUpdateCharacters(charProperties);
console.EndUpdate();
});
}
public static int Read(this IUVSimController window)
{
window.Input = string.Empty;
window.ResetEvent = new ManualResetEvent(false);
window.Console.Dispatcher.Invoke(() =>
{
window.Console.Focus();
});
window.ResetEvent.WaitOne();
window.ResetEvent.Close();
window.ResetEvent = null;
int result = 0;
int.TryParse(window.Input, out result);
if ((result < Accumilator.MIN_NUMBER) || (result > Accumilator.MAX_NUMBER))
{
throw new ApplicationException("Overflow error: The value is beyond range.");
}
return(result);
}
public BasicMLIndirect(IUVSimController w, MemoryManager m) : base(w, m)
{
}
public BasicML(IUVSimController w, MemoryManager m)
{
window = w;
memory = m;
alu = new ALU();
}
/// <summary>
/// Execute new instruction in the thread
/// </summary>
/// <param name="memory">System memory</param>
/// <param name="window">UVSim Controller</param>
public void Execute(MemoryManager memory, IUVSimController window)
{
// Check if thread was terminated
if (Terminated)
{
return;
}
// Create executioners
BasicML directExecution = new BasicMLDirect(window, memory);
BasicML indirectExecution = new BasicMLIndirect(window, memory);
BasicMLMath directMath = new BasicMLMathDirect(window, memory);
BasicMLMath indirectMath = new BasicMLMathIndirect(window, memory);
// Retrieve pc value from memory
int pc = memory[THREAD_OFFSET * ThreadNumber + (THREAD_OFFSET - 1)];
pc = THREAD_OFFSET * ThreadNumber + pc;
//Retrieve register from memory
int memoryLocation = THREAD_OFFSET * ThreadNumber + (THREAD_OFFSET - 3);
Accumilator.Instance.Value = directExecution.ComposeDWORD(ref memoryLocation);
try
{
int opCode;
// Get the opCode
opCode = memory[pc] / 100;
// Switch statment to execute the targeted instruction based on the opCode.
switch (opCode)
{
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Josh Cooley
// READ
case 10:
window.Console.Write($"[Thread #{ThreadNumber}] ");
directExecution.Read(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Josh Cooley
// WRITE
case 11:
window.Console.Write($"[Thread #{ThreadNumber}] ");
directExecution.Write(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Josh Cooley
// READ - INDIRECT
case 12:
window.Console.Write($"[Thread #{ThreadNumber}] ");
indirectExecution.Read(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Josh Cooley
// WRITE - INDIRECT
case 13:
window.Console.Write($"[Thread #{ThreadNumber}] ");
indirectExecution.Write(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Josh Cooley
// LOAD
case 20:
directExecution.Load(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// STORE
case 21:
directExecution.Store(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// LOAD - INDIRECT
case 22:
indirectExecution.Load(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// STORE - INDIRECT
case 23:
indirectExecution.Load(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// ADD
case 30:
directMath.Add(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// SUBTRACT
case 31:
directMath.Subtract(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Caleb Hansen
// DIVIDE
case 32:
directMath.Divide(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Caleb Hansen
// MULTIPLY
case 33:
directMath.Multiply(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// ADD - INDIRECT
case 34:
indirectMath.Add(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// SUBTRACT - INDIRECT
case 35:
indirectMath.Subtract(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// DIVIDE - INDIRECT
case 36:
indirectMath.Divide(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Nikita Pestin
// MULTIPLY - INDIRECT
case 37:
indirectMath.Multiply(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Caleb Hansen
// BRANCH
case 40:
directExecution.Branch(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// BRANCHNEG
case 41:
directExecution.BranchNeg(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// BRANCHZERO
case 42:
directExecution.BranchZero(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// HALT
case 43:
// End the execution.
window.Console.WriteLine("---------------------------------------------");
terminated = true;
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Caleb Hansen
// BRANCH - Josh Cooley
case 44:
indirectExecution.Branch(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// BRANCHNEG - INDIRECT
case 45:
indirectExecution.BranchNeg(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// BRANCHZERO - INDIRECT
case 46:
indirectExecution.BranchZero(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// REMINDER
case 50:
directMath.Reminder(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// EXPONENTIATION
case 51:
directMath.Exponential(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// REMINDER - INDIRECT
case 52:
indirectMath.Reminder(ref pc);
break;
//-----------------------------------------------------------------------------------------------------------------------
// Coded by: Ali Alabdlmohsen
// EXPONENTIATION - INDIRECT
case 53:
indirectMath.Exponential(ref pc);
break;
// Defult.
default:
// Increment the program counter.
pc++;
break;
}
}
catch (Exception ex)
{
window.Console.Write($"[Thread #{ThreadNumber}] ");
window.Error(ex.Message);
terminated = true;
}
// Check termination
if ((pc % THREAD_OFFSET) >= (THREAD_OFFSET - 3))
{
terminated = true;
}
// Save program counter and accumulator to memory
pc %= THREAD_OFFSET;
memory[THREAD_OFFSET * ThreadNumber + (THREAD_OFFSET - 1)] = pc;
directExecution.SaveDWORD(THREAD_OFFSET * ThreadNumber + (THREAD_OFFSET - 3), Accumilator.Instance.Value);
}
/// <summary>
/// Window constructor
/// </summary>
public MainWindow()
{
InitializeComponent();
controller = new UVSimController(this);
}
public Assembler(IUVSimController window, MemoryManager mm)
{
this.window = window;
memory = mm;
}
