コード例 #1
0
        public void ReadInstructions(string[] instructions)
        {
            foreach (string input in instructions)
            {
                try
                {
                    memory.AddInstruction(input);
                }
                catch (AssemblerException ex)
                {
                    window.Error(ex.InstrctionNumber, ex.Message);
                }
            }

            window.Console.WriteLine("---------------------------------------------");
        }
コード例 #2
0
ファイル: Thread.cs プロジェクト: Elifas90/UVSim
        /// <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);
        }
コード例 #3
0
ファイル: Compilator.cs プロジェクト: Elifas90/UVSim
        /// <summary>
        /// Compile program
        /// </summary>
        public void Compile()
        {
            // Write first lines
            builder.AppendLine("using System;");
            builder.AppendLine();
            builder.AppendLine("namespace UVSim");
            builder.AppendLine("{");
            builder.AppendLine("\tclass Program");
            builder.AppendLine("\t{");
            builder.AppendLine("\t\tstatic void Main(string[] args)");
            builder.AppendLine("\t\t{");
            builder.AppendLine("\t\t\tint acc = 0;");

            try
            {
                // Make run
                for (int i = 0; i < Thread.THREAD_OFFSET; i++)
                {
                    // Get the opCode
                    int opCode  = memory[i] / 100;
                    int operand = memory[i] % 100;

                    // Check is this instruction is variable or number then miss it
                    if (isNumber.Contains(i) || isVariable.ContainsKey(i) || isVariable.ContainsKey(i - 1))
                    {
                        continue;
                    }

                    // Switch statment to execute the targeted instruction based on the opCode.
                    switch (opCode)
                    {
                    // READ
                    case 10:
                        builder.AppendLine($"Label{i}:\tConsole.Write(\"Enter an integer: \");");
                        builder.AppendLine($"\t\t\t{GetVar(operand)} = int.Parse(Console.ReadLine());");
                        break;

                    // WRITE
                    case 11:
                        builder.AppendLine($"Label{i}:\tConsole.WriteLine({GetVar(operand)});");
                        break;

                    // READ - INDIRECT
                    case 12:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tConsole.Write(\"Enter an integer: \");");
                        builder.AppendLine($"\t\t\t{GetVar(operand)} = int.Parse(Console.ReadLine());");
                        break;

                    // WRITE - INDIRECT
                    case 13:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tConsole.WriteLine({GetVar(operand)});");
                        break;

                    // LOAD
                    case 20:
                        builder.AppendLine($"Label{i}:\tacc = {GetVar(operand)};");
                        break;

                    // STORE
                    case 21:
                        builder.AppendLine($"Label{i}:\t{GetVar(operand)} = acc;");
                        break;

                    // LOAD - INDIRECT
                    case 22:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tacc = {GetVar(operand)};");
                        break;

                    // STORE - INDIRECT
                    case 23:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\t{GetVar(operand)} = acc;");
                        break;

                    // ADD
                    case 30:
                        builder.AppendLine($"Label{i}:\tacc+= {GetVar(operand)};");
                        break;

                    // SUBTRACT
                    case 31:
                        builder.AppendLine($"Label{i}:\tacc-= {GetVar(operand)};");
                        break;

                    // DIVIDE
                    case 32:
                        builder.AppendLine($"Label{i}:\tacc/= {GetVar(operand)};");
                        break;

                    // MULTIPLY
                    case 33:
                        builder.AppendLine($"Label{i}:\tacc*= {GetVar(operand)};");
                        break;

                    // ADD - INDIRECT
                    case 34:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tacc+= {GetVar(operand)};");
                        break;

                    // SUBTRACT - INDIRECT
                    case 35:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tacc-= {GetVar(operand)};");
                        break;

                    // DIVIDE - INDIRECT
                    case 36:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tacc/= {GetVar(operand)};");
                        break;

                    // MULTIPLY - INDIRECT
                    case 37:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tacc*= {GetVar(operand)};");
                        break;

                    // BRANCH
                    case 40:
                        builder.AppendLine($"Label{i}:\tgoto Label{operand}");
                        break;

                    // BRANCHNEG
                    case 41:
                        builder.AppendLine($"Label{i}:\tif (acc < 0) goto Label{operand};");
                        break;

                    // BRANCHZERO
                    case 42:
                        builder.AppendLine($"Label{i}:\tif (acc == 0) goto Label{operand};");
                        break;

                    // HALT
                    case 43:
                        builder.AppendLine($"Label{i}:\treturn;");
                        break;

                    // BRANCH - INDIRECT
                    case 44:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tgoto Label{operand}");
                        break;

                    // BRANCHNEG - INDIRECT
                    case 45:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tif (acc < 0) goto Label{operand};");
                        break;

                    // BRANCHZERO - INDIRECT
                    case 46:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tif (acc == 0) goto Label{operand};");
                        break;

                    // REMINDER
                    case 50:
                        builder.AppendLine($"Label{i}:\tacc%= {GetVar(operand)};");
                        break;

                    // EXPONENTIATION
                    case 51:
                        builder.AppendLine($"Label{i}:\tacc = (int)Math.Pow(acc, {GetVar(operand)});");
                        break;

                    // REMINDER - INDIRECT
                    case 52:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tacc%= {GetVar(operand)};");
                        break;

                    // EXPONENTIATION - INDIRECT
                    case 53:
                        i++;
                        operand = memory[i];
                        builder.AppendLine($"Label{i}:\tacc = (int)Math.Pow(acc, {GetVar(operand)});");
                        break;

                    // Defult.
                    default:
                        break;
                    }
                }
                window.Console.WriteLine("Compilation successful!");
            }
            catch (Exception ex)
            {
                window.Error(ex.Message);
            }

            // Iterate through all variables and initialize them
            foreach (int key in isVariable.Keys)
            {
                int location = key;
                builder.Insert(113, $"\t\t\tint {isVariable[key]} = {ComposeDWORD(ref location)};\r\n");
            }

            builder.AppendLine("\t\t}");
            builder.AppendLine("\t}");
            builder.AppendLine("}");
        }