public async Task StartVmSignsBeforeRunningState()
        {
            // --- Arrange
            var     mc       = GetMachineController();
            VmState oldState = 0;
            VmState newState = 0;
            var     msgCount = 0;

            mc.VmStateChanged += (sender, args) =>
            {
                if (++msgCount == 2)
                {
                    oldState = args.OldState;
                    newState = args.NewState;
                }
            };

            // --- Act
            mc.StartVm(new ExecuteCycleOptions(EmulationMode.UntilFrameEnds));
            await mc.StarterTask;

            // --- Assert
            oldState.ShouldBe(VmState.BuildingMachine);
            newState.ShouldBe(VmState.BeforeRun);
            mc.IsFirstStart.ShouldBeTrue();
        }
        public async Task StopVmSignsReachesStoppedState()
        {
            // --- Arrange
            var mc     = GetMachineController();
            var before = mc.SpectrumVm;

            mc.StartVm(new ExecuteCycleOptions(EmulationMode.UntilFrameEnds));
            await mc.StarterTask;

            VmState oldState = 0;
            VmState newState = 0;
            var     msgCount = 0;

            mc.VmStateChanged += (sender, args) =>
            {
                if (++msgCount == 2)
                {
                    oldState = args.OldState;
                    newState = args.NewState;
                }
            };

            // --- Act
            mc.StopVm();
            await mc.CompletionTask;

            // --- Assert
            before.ShouldBeNull();
            mc.SpectrumVm.ShouldNotBeNull();
            mc.IsFirstStart.ShouldBeTrue();
            oldState.ShouldBe(VmState.Stopping);
            newState.ShouldBe(VmState.Stopped);
        }
Пример #3
0
 private void Resolve(VmState state, byte[] value, int destination)
 {
     foreach (var b in value)
     {
         state.memory[destination++] = b;
     }
 }
Пример #4
0
        /// <summary>
        /// Moves the virtual machine to the specified new state
        /// </summary>
        /// <param name="newState">New machine state</param>
        protected void MoveToState(VmState newState)
        {
            var oldState = VmState;

            VmState = newState;
            VmStateChanged?.Invoke(this, new VmStateChangedEventArgs(oldState, newState));
        }
Пример #5
0
        private byte[] Resolve(VmState state, int length, int source)
        {
            var bytes = new byte[length];
            Array.Copy(state.memory, bytes, length);

            return bytes;
        }
 /// <summary>
 /// Override this message to respond to vm state changes events
 /// </summary>
 protected override void OnVmStateChanged(VmState oldState, VmState newState)
 {
     if (newState == VmState.Paused)
     {
         Vm.Refresh();
     }
 }
Пример #7
0
        private async Task <string> GetVmStatesAsync()
        {
            var vmList = new List <VmState>();

            var hypers = await _context.Hypervisors.Include(h => h.VirtualMachines).ToListAsync();

            if (hypers == null || hypers.Count == 0)
            {
                return(null);
            }

            foreach (var h in hypers)
            {
                foreach (var vm in h.VirtualMachines)
                {
                    var s = new VmState();

                    s.VmId            = vm.Id;
                    s.Hypervisor      = h.Name;
                    s.Name            = vm.Name;
                    s.Status          = vm.Status;
                    s.PercentComplete = vm.PercentComplete;
                    s.StatusUpdated   = vm.StatusUpdated;
                    s.LastBackup      = vm.LastBackup;

                    vmList.Add(s);
                }
            }

            return(JsonConvert.SerializeObject(vmList));
        }
Пример #8
0
        /// <summary>
        /// Changes the caption according to machine state
        /// </summary>
        /// <param name="state"></param>
        protected void ChangeCaption(VmState state)
        {
            var additional = string.Empty;

            switch (state)
            {
            case VmState.None:
                additional = " (Not Started)";
                break;

            case VmState.Stopped:
                additional = " (Stopped)";
                break;

            case VmState.Paused:
                additional = " (Paused)";
                break;

            case VmState.Running:
                var vm = SpectNetPackage.Default.MachineViewModel;
                if (vm.RunsInDebugMode)
                {
                    additional = " (Debugging)";
                }
                break;
            }
            Caption = BaseCaption + additional;
        }
        public async Task StartDoesNotInitializeVmAfterStop()
        {
            // --- Arrange
            var mc = GetMachineController();

            mc.StartVm(new ExecuteCycleOptions(EmulationMode.UntilFrameEnds));
            await mc.StarterTask;
            var before = mc.SpectrumVm;

            mc.StopVm();
            await mc.CompletionTask;

            VmState oldState = 0;
            VmState newState = 0;
            var     msgCount = 0;

            mc.VmStateChanged += (sender, args) =>
            {
                if (++msgCount == 1)
                {
                    oldState = args.OldState;
                    newState = args.NewState;
                }
            };

            // --- Act
            mc.StartVm(new ExecuteCycleOptions(EmulationMode.UntilFrameEnds));
            await mc.StarterTask;

            // --- Assert
            before.ShouldNotBeNull();
            mc.SpectrumVm.ShouldBeSameAs(before);
            oldState.ShouldBe(VmState.Stopped);
            newState.ShouldBe(VmState.BeforeRun);
        }
Пример #10
0
        static void Main(string[] args)
        {
            string[] Vms      = { "20361700", "20361698" };
            var      login    = ConfigurationSettings.AppSettings["login"];
            var      psw      = ConfigurationSettings.AppSettings["psw"];
            var      baseurl  = ConfigurationSettings.AppSettings["baseurl"];
            var      configid = ConfigurationSettings.AppSettings["configid"];
            VmState  vMState  = new VmState(baseurl, configid);

            foreach (var vm in Vms)
            {
                Console.WriteLine("Starting :... ");
                Console.WriteLine(vMState.Run(login, psw, vm));

                Console.WriteLine("Suspending :... ");
                Console.WriteLine(vMState.Suspend(login, psw, vm));

                Console.WriteLine("Resumeing :... ");
                Console.WriteLine(vMState.Resume(login, psw, vm));

                Console.WriteLine("SwitchOffing :... ");
                Console.WriteLine(vMState.SwitchOff(login, psw, vm));
            }


            Console.ReadKey();
        }
Пример #11
0
        private static VmState RunOnce(Instruction[] bytecode, VmState initialState = default)
        {
            var visited = new HashSet <int>();

            return(Run(bytecode, initialState)
                   .TakeWhile(x => visited.Add(x.InstrPointer))
                   .Last());
        }
Пример #12
0
        public void Execute(VmState state)
        {
            state.registers[RegisterName.SP] -= 4;
            var value = BitConverter.ToUInt32(state.memory, (int) state.registers[RegisterName.SP]);
            state.registers[destination] = value;

            state.registers[RegisterName.PC] += 4;
        }
Пример #13
0
        public void Execute(VmState state)
        {
            var bytes = state.registers.GetBytes(source);
            state.memory[destination] = bytes[0];
            state.memory[destination + 1] = bytes[1];
            state.memory[destination + 2] = bytes[2];
            state.memory[destination + 3] = bytes[3];

            state.registers[RegisterName.PC] += 4;
        }
Пример #14
0
        public void Execute(VmState state)
        {
            var bytes = state.registers.GetBytes(toPush);
            state.memory[state.registers[RegisterName.SP]] = bytes[0];
            state.memory[state.registers[RegisterName.SP] + 1] = bytes[1];
            state.memory[state.registers[RegisterName.SP] + 2] = bytes[2];
            state.memory[state.registers[RegisterName.SP] + 3] = bytes[3];

            state.registers[RegisterName.SP] += 4;
            state.registers[RegisterName.PC] += 4;
        }
Пример #15
0
        private void SendBroadcast(Vm vm, string action)
        {
            VmState state = new VmState
            {
                Id        = vm.Id,
                Name      = vm.Name.Untagged(),
                IsRunning = vm.State == VmPowerState.Running
            };

            _hub.Clients.Group(vm.Name.Tag()).VmEvent(new BroadcastEvent <VmState>(User, "VM." + action.ToUpper(), state));
        }
Пример #16
0
        public void Execute(VmState state)
        {
            var oldPc = BitConverter.ToUInt32(state.memory, (int) state.registers[RegisterName.FP] - 4);
            var oldFrame = BitConverter.ToUInt32(state.memory, (int) state.registers[RegisterName.FP] - 8);
            var oldStack = BitConverter.ToUInt32(state.memory, (int) state.registers[RegisterName.FP] - 12);

            state.registers[RegisterName.SP] = oldStack;
            state.registers[RegisterName.FP] = oldFrame;
            state.registers[RegisterName.PC] = oldPc;

            state.registers[RegisterName.PC] += 4;
        }
Пример #17
0
        public void Execute(VmState state)
        {
            // push stack pointer, frame pointer, and program counter then reset PC
            var pc = state.registers[RegisterName.PC];
            new Push(RegisterName.SP).Execute(state);
            new Push(RegisterName.FP).Execute(state);
            new PushIm(pc).Execute(state);
            state.registers[RegisterName.PC] = pc;

            state.registers[RegisterName.FP] = state.registers[RegisterName.SP];
            state.registers[RegisterName.SP] = state.registers[RegisterName.FP];

            state.registers[RegisterName.PC] = location;
        }
Пример #18
0
        public void Execute(VmState state)
        {
            // offset is a signed short, who's max value is +/- 32767
            // by shifting left, we multiply by 4, which gives us aligned access only
            // but allows me to offset by up to +/- 131068
            int intOffset = offset;
            intOffset <<= 2;

            int location = (int) state.registers[source] + intOffset;

            var value = BitConverter.ToUInt32(state.memory, location);
            state.registers[destination] = value;
            state.registers[RegisterName.PC] += 4;
        }
Пример #19
0
        public void Problem1(string input, long expected)
        {
            var vmState = new VmState();
            var prog    = LoadProgram(input);

            try
            {
                ExecuteUntilLoop(vmState, prog);
                Oh.Bugger();
            }
            catch (Utils.VM.Halt)
            {
                vmState.Acc.Should().Be(expected);
            }
        }
Пример #20
0
        /// <summary>
        /// Moves the virtual machine to the specified new state
        /// </summary>
        /// <param name="newState">New machine state</param>
        protected void MoveToState(VmState newState)
        {
            CheckMainThread();
            var oldState = VmState;

            VmState = newState;
            OnVmStateChanged(oldState, VmState);
            VmStateChanged?.Invoke(this, new VmStateChangedEventArgs(oldState, VmState));
            if (oldState == VmState.BeforeRun && newState == VmState.Running)
            {
                // --- We have just got the notification from the execution cycle
                // --- about the successful start.
                _vmStarterCompletionSource.SetResult(true);
            }
        }
Пример #21
0
        public static void MergeVms(this GameState state, Vm[] vms)
        {
            foreach (Vm vm in vms)
            {
                string  name = vm.Name.Untagged();
                VmState vs   = state.Vms
                               .Where(t => t.Name == name && !t.Id.NotEmpty())
                               .FirstOrDefault();

                if (vs != null)
                {
                    vs.Id        = vm.Id;
                    vs.IsRunning = vm.State == VmPowerState.Running;
                }
            }
        }
Пример #22
0
        public void Execute(VmState state)
        {
            // offset is a signed short, who's max value is +/- 32767
            // by shifting left, we multiply by 4, which gives us aligned access only
            // but allows me to offset by up to +/- 131068
            int intOffset = offset;
            intOffset <<= 2;

            int location = (int) state.registers[destination] + intOffset;

            var bytes = state.registers.GetBytes(source);
            state.memory[location] = bytes[0];
            state.memory[location + 1] = bytes[1];
            state.memory[location + 2] = bytes[2];
            state.memory[location + 3] = bytes[3];

            state.registers[RegisterName.PC] += 4;
        }
Пример #23
0
        public async Task <ActionResult <Vm> > Deploy(int id)
        {
            VmTemplate template = await _templateService.GetDeployableTemplate(id, null);

            Vm vm = await _pod.Deploy(template);

            // SendBroadcast(vm, "deploy");
            VmState state = new VmState
            {
                Id        = id.ToString(),
                Name      = vm.Name.Untagged(),
                IsRunning = vm.State == VmPowerState.Running
            };

            await _hub.Clients.Group(vm.Name.Tag()).VmEvent(new BroadcastEvent <VmState>(User, "VM.DEPLOY", state));

            return(Ok(vm));
        }
Пример #24
0
        public async Task <ActionResult <Vm> > DeployVm(string id)
        {
            VmTemplate template = await _templateService
                                  .GetDeployableTemplate(id, null)
            ;

            string name = $"{template.Name}#{template.IsolationTag}";

            AuthorizeAny(
                () => Actor.IsAdmin,
                () => CanManageVm(name, Actor.Id).Result
                );

            Vm vm = await _pod.Deploy(template, Actor.IsBuilder);

            if (template.HostAffinity)
            {
                await _pod.SetAffinity(
                    template.IsolationTag,
                    new Vm[] { vm },
                    true
                    );

                vm.State = VmPowerState.Running;
            }

            // SendBroadcast(vm, "deploy");
            VmState state = new VmState
            {
                Id          = template.Id.ToString(),
                Name        = vm.Name.Untagged(),
                IsolationId = vm.Name.Tag(),
                IsRunning   = vm.State == VmPowerState.Running
            };

            await Hub.Clients
            .Group(state.IsolationId)
            .VmEvent(new BroadcastEvent <VmState>(User, "VM.DEPLOY", state))
            ;

            return(Ok(vm));
        }
Пример #25
0
        /// <summary>
        /// Changes the caption according to machine state
        /// </summary>
        /// <param name="state"></param>
        protected void ChangeCaption(VmState state)
        {
            var additional = string.Empty;

            switch (state)
            {
            case VmState.None:
                additional = " (Not Started)";
                break;

            case VmState.Stopped:
                additional = " (Stopped)";
                break;

            case VmState.Paused:
                additional = " (Paused)";
                break;
            }
            Caption = BaseCaption + additional;
        }
Пример #26
0
 /// <summary>
 /// Cancels the execution of the virtual machine.
 /// </summary>
 /// <param name="cancelledState">Virtual machine state after cancellation</param>
 private async Task CancelVmExecution(VmState cancelledState)
 {
     try
     {
         // --- Wait for cancellation
         _cancellationTokenSource?.Cancel();
         ExecutionCompletionReason = await _completionTask;
     }
     catch (TaskCanceledException)
     {
         // --- Ok, run successfully cancelled
         ExecutionCompletionReason = ExecutionCompletionReason.Cancelled;
     }
     catch (Exception ex)
     {
         // --- Some other exception raised
         ExceptionRaised?.Invoke(this, new VmExceptionArgs(ex));
     }
     finally
     {
         // --- Now, it's cancelled
         MachineState = cancelledState;
     }
 }
Пример #27
0
 byte[] ISourceValue.Resolve(VmState state, int length, object source)
 {
     return Resolve(state, length, (int) source);
 }
Пример #28
0
 void IDestinationValue.Resolve(VmState state, byte[] value, object destination)
 {
     Resolve(state, value, (int) destination);
 }
Пример #29
0
 void IDestinationValue.Resolve(VmState state, byte[] value, object destination)
 {
     Resolve(state, value, (RegisterName) destination);
 }
Пример #30
0
        static Instruction[] LoadProgram(string input)
        {
            var program = new List <Instruction>();

            foreach (var line in FileIterator.Lines(input))
            {
                var    split  = line.Split(' ');
                OpCode opCode = split[0] switch {
                    "acc" => OpCode.ACC,
                    "jmp" => OpCode.JMP,
                    _ => OpCode.NOP
                };

                var value = long.Parse(split[1]);
                program.Add(new Instruction(opCode, value));
            }

            return(program.ToArray());
        }

        void ExecuteUntilLoop(VmState vmState, Instruction[] program)
        {
            var visited = new HashSet <long>();

            while (true)
            {
                if (vmState.Ip >= program.Length)
                {
                    return;
                }
                if (visited.Contains(vmState.Ip))
                {
                    throw new Utils.VM.Halt();
                }
                visited.Add(vmState.Ip);
                var instruction = program[vmState.Ip];

                OpCodeCount++;

                switch (instruction.OpCode)
                {
                case OpCode.NOP:
                    break;

                case OpCode.ACC:
                    vmState.Acc += instruction.Value;
                    break;

                case OpCode.JMP:
                    vmState.Ip += (instruction.Value - 1);     // We need to take into account that the IP is auto incremented
                    break;
                }

                vmState.Ip++;
            }
        }

        long PatchAndExecute(Instruction[] program)
        {
            for (var i = 0; i < program.Length; i++)
            {
                var patchedInstruction = program[i];
                switch (patchedInstruction.OpCode)
                {
                case OpCode.NOP:
                    program[i] = new Instruction(OpCode.JMP, patchedInstruction.Value);
                    break;

                case OpCode.JMP:
                    program[i] = new Instruction(OpCode.NOP, patchedInstruction.Value);
                    break;

                default:
                    continue;
                }

                try
                {
                    var vmState = new VmState();
                    ExecuteUntilLoop(vmState, program);
                    return(vmState.Acc);
                }
                catch (Utils.VM.Halt) {} // Loop detected, so continue the search...

                // Restore the program
                program[i] = patchedInstruction;
            }
            throw new Expletive("Bugger");
        }

        long ExecutionGraph(Instruction[] program, HashSet <long> visited, long ip, long acc, bool branching)
        {
            if (ip >= program.Length)
            {
                return(acc);
            }
            if (visited.Contains(ip))
            {
                throw new Utils.VM.Halt();
            }
            visited.Add(ip);
            var instuction = program[ip];

            try
            {
                OpCodeCount++;
                switch (instuction.OpCode)
                {
                case OpCode.NOP:
                    try
                    {
                        return(ExecutionGraph(program, visited, ip + 1, acc, branching));
                    }
                    catch (Utils.VM.Halt)
                    {
                        if (!branching)
                        {
                            OpCodeCount++;
                            return(ExecutionGraph(program, visited, ip + instuction.Value, acc, true));
                        }
                        else
                        {
                            throw;
                        }
                    }

                case OpCode.JMP:
                    try
                    {
                        return(ExecutionGraph(program, visited, ip + instuction.Value, acc, branching));
                    }
                    catch (Utils.VM.Halt)
                    {
                        if (!branching)
                        {
                            OpCodeCount++;
                            return(ExecutionGraph(program, visited, ip + 1, acc, true));
                        }
                        else
                        {
                            throw;
                        }
                    }

                case OpCode.ACC:
                    return(ExecutionGraph(program, visited, ip + 1, acc + instuction.Value, branching));

                default:
                    throw new Expletive("Shit");
                }
            }
            finally
            {
                visited.Remove(ip);
            }
        }
Пример #31
0
 public void Execute(VmState state)
 {
     state.registers[result] = state.registers[target] >> (int) state.registers[source];
     state.registers[RegisterName.PC] += 4;
 }
Пример #32
0
        /// <summary>
        ///     Executes the <paramref name="entry" />.
        /// </summary>
        /// <param name="entry">Transaction entry to be executed inside the <see cref="VirtualMachine" />.</param>
        /// <param name="stateUpdate"><see cref="Delta" /> to be used for execution environment construction</param>
        /// <param name="txTracer">Tracer to extract the execution steps for debugging or analytics.</param>
        /// <param name="readOnly">Defines whether the state should be reverted after the execution.</param>
        /// <exception cref="TransactionCollisionException">Thrown when deployment address already has some code.</exception>
        /// <exception cref="OutOfGasException">Thrown when not enough gas is available for deposit.</exception>
        private void Execute(PublicEntry entry, StateUpdate stateUpdate, ITxTracer txTracer, bool readOnly)
        {
            var spec = _specProvider.GetSpec(stateUpdate.Number);

            var(sender, recipient) = ExtractSenderAndRecipient(entry);
            var isPrecompile = recipient.IsPrecompiled(spec);
            var env          = PrepareEnv(entry, sender, recipient, stateUpdate, isPrecompile);

            var gasLimit     = entry.GasLimit;
            var intrinsicGas = CalculateIntrinsicGas(entry, spec);

            if (_logger.IsEnabled(LogEventLevel.Verbose))
            {
                _logger.Verbose("Executing entry {entry}", entry);
            }

            if (!ValidateSender(entry, env, txTracer))
            {
                return;
            }

            if (!ValidateIntrinsicGas(entry, env, intrinsicGas, txTracer))
            {
                return;
            }

            if (!ValidateDeltaGasLimit(entry, env, txTracer))
            {
                return;
            }

            if (!_stateProvider.AccountExists(env.Sender))
            {
                if (env.GasPrice == UInt256.Zero)
                {
                    _stateProvider.CreateAccount(env.Sender, UInt256.Zero);
                }
            }

            if (!ValidateSenderBalance(entry, env, intrinsicGas, txTracer))
            {
                return;
            }

            if (!ValidateNonce(entry, env, txTracer))
            {
                return;
            }

            InitEntryExecution(env, gasLimit, spec, txTracer);

            // we prepare two fields to track the amount of gas spent / left
            var unspentGas = gasLimit - intrinsicGas;
            var spentGas   = gasLimit;

            // the snapshots are needed to revert the subroutine state changes in case of an VM exception
            var stateSnapshot   = _stateProvider.TakeSnapshot();
            var storageSnapshot = _storageProvider.TakeSnapshot();

            // we subtract value from sender
            // it will be added to recipient at the later stage (inside the VM)
            _stateProvider.SubtractFromBalance(sender, env.Value, spec);

            // we fail unless we succeed
            var statusCode = StatusCode.Failure;
            TransactionSubstate substate = null;

            try
            {
                if (entry.IsValidDeploymentEntry)
                {
                    PrepareContractAccount(env.CodeSource);
                }

                var executionType = entry.IsValidDeploymentEntry ? ExecutionType.Create : ExecutionType.Call;
                using (var state = new VmState((long)unspentGas, env, executionType, isPrecompile, true, false))
                {
                    substate   = _virtualMachine.Run(state, txTracer);
                    unspentGas = (ulong)state.GasAvailable;
                }

                if (substate.ShouldRevert || substate.IsError)
                {
                    if (_logger.IsEnabled(LogEventLevel.Verbose))
                    {
                        _logger.Verbose("Restoring state from before transaction");
                    }

                    _stateProvider.Restore(stateSnapshot);
                    _storageProvider.Restore(storageSnapshot);
                }
                else
                {
                    if (entry.IsValidDeploymentEntry)
                    {
                        DeployCode(env, substate, ref unspentGas, spec);
                    }

                    DestroyAccounts(substate);
                    statusCode = StatusCode.Success;
                }

                spentGas = Refund(gasLimit, unspentGas, substate, env, spec);
            }
            catch (Exception ex) when(ex is EvmException || ex is OverflowException)
            {
                if (_logger.IsEnabled(LogEventLevel.Verbose))
                {
                    _logger.Verbose($"EVM EXCEPTION: {ex.GetType().Name}");
                }

                _stateProvider.Restore(stateSnapshot);
                _storageProvider.Restore(storageSnapshot);
            }

            if (_logger.IsEnabled(LogEventLevel.Verbose))
            {
                _logger.Verbose("Gas spent: " + spentGas);
            }

            var gasBeneficiary = stateUpdate.GasBeneficiary;
            var wasBeneficiaryAccountDestroyed = statusCode != StatusCode.Failure &&
                                                 (substate?.DestroyList.Contains(gasBeneficiary) ?? false);

            if (!wasBeneficiaryAccountDestroyed)
            {
                if (!_stateProvider.AccountExists(gasBeneficiary))
                {
                    _stateProvider.CreateAccount(gasBeneficiary, spentGas * env.GasPrice);
                }
                else
                {
                    _stateProvider.AddToBalance(gasBeneficiary, spentGas * env.GasPrice, spec);
                }
            }

            if (!readOnly)
            {
                _storageProvider.Commit(txTracer.IsTracingState ? txTracer : null);
                _stateProvider.Commit(spec, txTracer.IsTracingState ? txTracer : null);
                stateUpdate.GasUsed += (long)spentGas;
            }
            else
            {
                _storageProvider.Reset();
                _stateProvider.Reset();
            }

            if (txTracer.IsTracingReceipt)
            {
                if (statusCode == StatusCode.Failure)
                {
                    txTracer.MarkAsFailed(env.CodeSource, (long)spentGas,
                                          substate?.ShouldRevert ?? false ? substate.Output : Bytes.Empty, substate?.Error);
                }
                else
                {
                    if (substate == null)
                    {
                        throw new InvalidOperationException("Substate should not be null after a successful VM run.");
                    }

                    txTracer.MarkAsSuccess(env.CodeSource, (long)spentGas, substate.Output,
                                           substate.Logs.Any() ? substate.Logs.ToArray() : LogEntry.EmptyLogs);
                }
            }
        }
Пример #33
0
 /// <summary>
 /// Overrid this method to handle vm state changes within the controller
 /// </summary>
 /// <param name="oldState">Old VM state</param>
 /// <param name="newState">New VM state</param>
 protected virtual void OnVmStateChanged(VmState oldState, VmState newState)
 {
 }
Пример #34
0
 private byte[] Resolve(VmState state, int length, RegisterName source)
 {
     var bytes = BitConverter.GetBytes(state.registers[source]);
     return bytes;
 }
 /// <summary>Initializes a new instance of the MessageBase class.</summary>
 public MachineStateChangedMessage(VmState oldState, VmState newState)
 {
     OldState = oldState;
     NewState = newState;
 }
        /// <summary>
        /// Overrid this method to handle vm state changes within the controller
        /// </summary>
        /// <param name="oldState">Old VM state</param>
        /// <param name="newState">New VM state</param>
        protected override void OnVmStateChanged(VmState oldState, VmState newState)
        {
            var pane = OutputWindow.GetPane <SpectrumVmOutputPane>();

            pane.WriteLine($"Machine state changed: {oldState} --> {newState}.");
        }
Пример #37
0
 public void Execute(VmState state)
 {
     state.registers[result] = state.registers[arg1] / state.registers[arg2];
     state.registers[RegisterName.PC] += 4;
 }
Пример #38
0
 /// <summary>
 /// Initializes the event arguments
 /// </summary>
 /// <param name="oldState">Old vm state</param>
 /// <param name="newState">New vm state</param>
 public VmStateChangedEventArgs(VmState oldState, VmState newState)
 {
     OldState = oldState;
     NewState = newState;
 }
Пример #39
0
 public void Execute(VmState state)
 {
     state.registers[destination] = toLoad;
     state.registers[RegisterName.PC] += 4;
 }
Пример #40
0
 public void UpdateStateForAssignment(VmState vmState, ResourceRetrievalResult?assetRetrievalResult = null,
                                      ResourceRetrievalResult?imageRetrievalResult = null, bool forceSave = false)
 {
 }
Пример #41
0
 private void Resolve(VmState state, byte[] value, RegisterName destination)
 {
     state.registers[destination] = BitConverter.ToUInt32(value, 0);
 }