master-2.x changes since Feb 2, 2018

.travis.yml

@@ -0,0 +1,25 @@
+language: csharp
+
+os:
+ - linux
+ - osx
+
+dist: bionic
+osx_image: xcode9.1
+
+mono: none
+dotnet: 2.1.300
+
+before_install:
+  - cd tests/neo-vm.Tests
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ulimit -n 2048; fi
+
+script:
+ - dotnet restore
+ - find * -name *.csproj | xargs -I % dotnet add % package coverlet.msbuild
+ - dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=opencover
+
+after_success:
+  # After all tests OK, Send CodeDov report
+  - echo "Test Success - Branch($TRAVIS_BRANCH) Pull Request($TRAVIS_PULL_REQUEST) Tag($TRAVIS_TAG)"
+  - bash <(curl -s https://codecov.io/bash) -v

README.md

@@ -1,3 +1,22 @@
+<p align="center">
+<img
+    src="https://neo-cdn.azureedge.net/images/neo_logo.svg"
+    width="250px">
+</p>
+
+<p align="center">
+  <a href='https://coveralls.io/github/neo-project/neo-vm?branch=master'>
+    <img src='https://coveralls.io/repos/github/neo-project/neo-vm/badge.svg?branch=master' alt='Coverage Status' />
+  </a>
+  <a href="https://travis-ci.org/neo-project/neo-vm">
+    <img src="https://travis-ci.org/neo-project/neo-vm.svg?branch=master">
+  </a>
+  <a href="https://github.com/neo-project/neo-vm/blob/master/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-blue.svg">
+  </a>
+
+</p>
+
 # NEO Virtual Machine
 
 This is the virtual machine of NEO: **NeoVM**.

neo-vm.sln

@@ -7,6 +7,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{0F08E36C-9F1
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "neo-vm", "src\neo-vm\neo-vm.csproj", "{6A621185-36A9-4E1A-8D3D-462D19503E32}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{210DA31B-019E-48CE-9498-D56A7987C4E6}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "neo-vm.Tests", "tests\neo-vm.Tests\neo-vm.Tests.csproj", "{56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -17,11 +21,19 @@ Global
 		{6A621185-36A9-4E1A-8D3D-462D19503E32}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6A621185-36A9-4E1A-8D3D-462D19503E32}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6A621185-36A9-4E1A-8D3D-462D19503E32}.Release|Any CPU.Build.0 = Release|Any CPU
+		{56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{6A621185-36A9-4E1A-8D3D-462D19503E32} = {0F08E36C-9F18-423D-8F8C-C8C2FACF00F7}
+		{56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC} = {210DA31B-019E-48CE-9498-D56A7987C4E6}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {F8AC7AA8-85DE-4A98-9B58-BA08AB813C99}
 	EndGlobalSection
 EndGlobal

src/neo-vm/Debugger.cs

@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+
+namespace Neo.VM
+{
+    public class Debugger
+    {
+        private readonly ExecutionEngine engine;
+        private readonly Dictionary<byte[], HashSet<uint>> break_points = new Dictionary<byte[], HashSet<uint>>(new HashComparer());
+
+        public Debugger(ExecutionEngine engine)
+        {
+            this.engine = engine;
+        }
+
+        public void AddBreakPoint(byte[] script_hash, uint position)
+        {
+            if (!break_points.TryGetValue(script_hash, out HashSet<uint> hashset))
+            {
+                hashset = new HashSet<uint>();
+                break_points.Add(script_hash, hashset);
+            }
+            hashset.Add(position);
+        }
+
+        public void Execute()
+        {
+            engine.State &= ~VMState.BREAK;
+            while (!engine.State.HasFlag(VMState.HALT) && !engine.State.HasFlag(VMState.FAULT) && !engine.State.HasFlag(VMState.BREAK))
+            {
+                ExecuteAndCheckBreakPoints();
+            }
+        }
+
+        private void ExecuteAndCheckBreakPoints()
+        {
+            engine.ExecuteNext();
+            if (engine.State == VMState.NONE && engine.InvocationStack.Count > 0 && break_points.Count > 0)
+            {
+                if (break_points.TryGetValue(engine.CurrentContext.ScriptHash, out HashSet<uint> hashset) && hashset.Contains((uint)engine.CurrentContext.InstructionPointer))
+                    engine.State = VMState.BREAK;
+            }
+        }
+
+        public bool RemoveBreakPoint(byte[] script_hash, uint position)
+        {
+            if (!break_points.TryGetValue(script_hash, out HashSet<uint> hashset)) return false;
+            if (!hashset.Remove(position)) return false;
+            if (hashset.Count == 0) break_points.Remove(script_hash);
+            return true;
+        }
+
+        public void StepInto()
+        {
+            if (engine.State.HasFlag(VMState.HALT) || engine.State.HasFlag(VMState.FAULT)) return;
+            engine.ExecuteNext();
+            if (engine.State == VMState.NONE)
+                engine.State = VMState.BREAK;
+        }
+
+        public void StepOut()
+        {
+            engine.State &= ~VMState.BREAK;
+            int c = engine.InvocationStack.Count;
+            while (!engine.State.HasFlag(VMState.HALT) && !engine.State.HasFlag(VMState.FAULT) && !engine.State.HasFlag(VMState.BREAK) && engine.InvocationStack.Count >= c)
+                ExecuteAndCheckBreakPoints();
+            if (engine.State == VMState.NONE)
+                engine.State = VMState.BREAK;
+        }
+
+        public void StepOver()
+        {
+            if (engine.State.HasFlag(VMState.HALT) || engine.State.HasFlag(VMState.FAULT)) return;
+            engine.State &= ~VMState.BREAK;
+            int c = engine.InvocationStack.Count;
+            do
+            {
+                ExecuteAndCheckBreakPoints();
+            }
+            while (!engine.State.HasFlag(VMState.HALT) && !engine.State.HasFlag(VMState.FAULT) && !engine.State.HasFlag(VMState.BREAK) && engine.InvocationStack.Count > c);
+            if (engine.State == VMState.NONE)
+                engine.State = VMState.BREAK;
+        }
+    }
+}

src/neo-vm/ExecutionContext.cs

@@ -1,62 +1,85 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.Runtime.CompilerServices;
 
 namespace Neo.VM
 {
-    public class ExecutionContext : IDisposable
+    public class ExecutionContext
     {
-        private ExecutionEngine engine;
-        public readonly byte[] Script;
-        public readonly bool PushOnly;
-        internal readonly BinaryReader OpReader;
-        internal readonly HashSet<uint> BreakPoints;
+        /// <summary>
+        /// Number of items to be returned
+        /// </summary>
+        public int RVCount { get; }
 
-        public int InstructionPointer
+        /// <summary>
+        /// Script
+        /// </summary>
+        public Script Script { get; }
+
+        /// <summary>
+        /// Evaluation stack
+        /// </summary>
+        public RandomAccessStack<StackItem> EvaluationStack { get; } = new RandomAccessStack<StackItem>();
+
+        /// <summary>
+        /// Alternative stack
+        /// </summary>
+        public RandomAccessStack<StackItem> AltStack { get; } = new RandomAccessStack<StackItem>();
+
+        /// <summary>
+        /// Instruction pointer
+        /// </summary>
+        public int InstructionPointer { get; set; }
+
+        public Instruction CurrentInstruction
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                return (int)OpReader.BaseStream.Position;
+                return GetInstruction(InstructionPointer);
             }
-            set
+        }
+
+        /// <summary>
+        /// Next instruction
+        /// </summary>
+        public Instruction NextInstruction
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
             {
-                OpReader.BaseStream.Seek(value, SeekOrigin.Begin);
+                return GetInstruction(InstructionPointer + CurrentInstruction.Size);
             }
         }
 
-        public OpCode NextInstruction => (OpCode)Script[OpReader.BaseStream.Position];
-
-        private byte[] _script_hash = null;
+        /// <summary>
+        /// Cached script hash
+        /// </summary>
         public byte[] ScriptHash
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                if (_script_hash == null)
-                    _script_hash = engine.Crypto.Hash160(Script);
-                return _script_hash;
+                return Script.ScriptHash;
             }
         }
 
-        internal ExecutionContext(ExecutionEngine engine, byte[] script, bool push_only, HashSet<uint> break_points = null)
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="script">Script</param>
+        /// <param name="rvcount">Number of items to be returned</param>
+        internal ExecutionContext(Script script, int rvcount)
         {
-            this.engine = engine;
+            this.RVCount = rvcount;
             this.Script = script;
-            this.PushOnly = push_only;
-            this.OpReader = new BinaryReader(new MemoryStream(script, false));
-            this.BreakPoints = break_points ?? new HashSet<uint>();
         }
 
-        public ExecutionContext Clone()
-        {
-            return new ExecutionContext(engine, Script, PushOnly, BreakPoints)
-            {
-                InstructionPointer = InstructionPointer
-            };
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private Instruction GetInstruction(int ip) => Script.GetInstruction(ip);
 
-        public void Dispose()
+        internal bool MoveNext()
         {
-            OpReader.Dispose();
+            InstructionPointer += CurrentInstruction.Size;
+            return InstructionPointer < Script.Length;
         }
     }
 }