void CheckItem(ExecutionEngineBase engine, StackItemBase item) { int c = engine.ResultStack.Count; engine.ResultStack.Push(item); Assert.AreEqual(engine.ResultStack.Count, c + 1); Assert.IsTrue(engine.ResultStack.TryPeek(0, out StackItemBase obj)); // PEEK obj.Dispose(); obj = engine.ResultStack.Peek(0); Assert.IsNotNull(obj); Assert.AreEqual(obj.Type, item.Type); Assert.IsTrue(obj.Equals(item)); // POP obj.Dispose(); obj = engine.ResultStack.Pop(); Assert.AreEqual(engine.ResultStack.Count, c); Assert.IsNotNull(obj); Assert.AreEqual(obj.Type, item.Type); Assert.IsTrue(obj.Equals(item)); obj.Dispose(); }
private StackItemBase DeserializeStackItem(ExecutionEngineBase engine, BinaryReader reader) { EStackItemType type = (EStackItemType)reader.ReadByte(); switch (type) { case EStackItemType.ByteArray: return(engine.CreateByteArray(reader.ReadVarBytes())); case EStackItemType.Bool: return(engine.CreateBool(reader.ReadBoolean())); case EStackItemType.Integer: return(engine.CreateInteger(new BigInteger(reader.ReadVarBytes()))); case EStackItemType.Array: case EStackItemType.Struct: { ArrayStackItemBase array; if (type == EStackItemType.Struct) { array = engine.CreateStruct(); } else { array = engine.CreateArray(); } ulong count = reader.ReadVarInt(); while (count-- > 0) { array.Add(DeserializeStackItem(engine, reader)); } return(array); } case EStackItemType.Map: { var map = engine.CreateMap(); ulong count = reader.ReadVarInt(); while (count-- > 0) { StackItemBase key = DeserializeStackItem(engine, reader); StackItemBase value = DeserializeStackItem(engine, reader); map[key] = value; key.Dispose(); value.Dispose(); } return(map); } default: throw new FormatException(); } }
private JToken ItemToJson(StackItemBase item) { if (item == null) { return(null); } JToken value; using (item) { switch (item.Type) { case EStackItemType.Bool: value = new JValue((bool)item.ToObject()); break; case EStackItemType.Integer: value = new JValue(item.ToObject().ToString()); break; case EStackItemType.ByteArray: value = new JValue((byte[])item.ToObject()); break; case EStackItemType.Interop: value = new JValue(item.ToObject().ToString()); break; case EStackItemType.Struct: case EStackItemType.Array: { var array = (ArrayStackItemBase)item; var jarray = new JArray(); foreach (var entry in array) { jarray.Add(ItemToJson(entry)); } value = jarray; break; } case EStackItemType.Map: { var dic = (MapStackItemBase)item; var jdic = new JObject(); foreach (var entry in dic) { jdic.Add(entry.Key.ToByteArray().ToHexString(true), ItemToJson(entry.Value)); } value = jdic; break; } default: throw new NotImplementedException(); } return(new JObject { ["type"] = item.Type.ToString(), ["value"] = value }); } }
public List <StackItemBase> ParseInputString(string input) { if (input == null) { throw new ArgumentNullException(nameof(input)); } List <StackItemBase> result = new List <StackItemBase>(); int pos = 1; var items = input.Split(' '); foreach (var item in items) { StackItemBase stackItem = null; stackItem = TryGetOperatorFromString(item, pos); if (stackItem == null) { stackItem = TryGetNumberFromString(item); } if (stackItem == null) { throw new ArgumentOutOfRangeException(); } result.Add(stackItem); pos += item.Length + 1; // count space as well } return(result); }
public override void Set(StackItemBase key, StackItemBase value) => NeoVM.MapStackItem_Set ( _handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle, value == null ? IntPtr.Zero : ((INativeStackItem)value).Handle );
public override bool ContainsKey(StackItemBase key) { if (!(key is INativeStackItemContainer nkey)) { throw new ArgumentException(nameof(key)); } return(_item.ContainsKey(nkey.NativeStackItem)); }
public override bool Remove(StackItemBase key) { if (!(key is INativeStackItemContainer nitem)) { throw new ArgumentException(nameof(key)); } return(_item.Remove(nitem.NativeStackItem)); }
public override void Push(StackItemBase item) { if (!(item is INativeStackItemContainer nitem)) { throw new ArgumentException(nameof(item)); } _stack.Push(nitem.NativeStackItem); }
/// <summary> /// Push object to the stack /// </summary> /// <param name="item">Object</param> public override void Push(StackItemBase item) { if (_engine.IsDisposed) { throw new ObjectDisposedException(nameof(ExecutionEngine)); } NeoVM.StackItems_Push(_handle, ((INativeStackItem)item).Handle); }
public override bool TryPop(out StackItemBase item) { if (_stack.Count < 1) { item = null; return(false); } item = _stack.Pop()?.ConvertFromNative(); return(item != null); }
public override bool TryPeek(int index, out StackItemBase item) { if (_stack.Count <= index) { item = null; return(false); } item = _stack.Peek(index)?.ConvertFromNative(); return(item != null); }
public override void Set(StackItemBase key, StackItemBase value) { if (!(key is INativeStackItemContainer nkey)) { throw new ArgumentException(nameof(key)); } if (!(value is INativeStackItemContainer nvalue)) { throw new ArgumentException(nameof(value)); } _item[nkey.NativeStackItem] = nvalue.NativeStackItem; }
public override bool TryGetValue(StackItemBase key, out StackItemBase value) { var ret = NeoVM.MapStackItem_Get(_handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle); if (ret == IntPtr.Zero) { value = null; return(false); } value = NativeEngine.ConvertFromNative(ret); return(true); }
public override bool TryGetValue(StackItemBase key, out StackItemBase value) { if (!(key is INativeStackItemContainer nkey)) { throw new ArgumentException(nameof(key)); } if (_item.TryGetValue(nkey.NativeStackItem, out var nvalue)) { value = nvalue.ConvertFromNative(); return(true); } value = null; return(false); }
private bool Runtime_Deserialize(ExecutionEngineBase engine) { var context = engine.CurrentContext; { if (context == null) { return(false); } if (!context.EvaluationStack.TryPop(out StackItemBase it)) { return(false); } var data = it.ToByteArray(); it.Dispose(); using (MemoryStream ms = new MemoryStream(data, false)) using (BinaryReader reader = new BinaryReader(ms)) { StackItemBase item = null; try { item = DeserializeStackItem(engine, reader); } catch { if (item != null) { item.Dispose(); } return(false); } context.EvaluationStack.Push(item); if (item != null) { item.Dispose(); } } } return(true); }
private void CheckValue(StackItemBase it, object ret) { if (ret is BigInteger bi) { Assert.IsTrue(it is IntegerStackItem); Assert.AreEqual(bi, ((IntegerStackItem)it).Value); } else if (ret is byte[] bf) { Assert.IsTrue(it is ByteArrayStackItem); CollectionAssert.AreEqual(bf, ((ByteArrayStackItem)it).Value); } else if (ret is bool bl) { Assert.IsTrue(it is BooleanStackItem); Assert.AreEqual(bl, ((BooleanStackItem)it).Value); } }
/// <summary> /// Try to obtain the element at `index` position, without consume them /// -1=Last , -2=Last-1 , -3=Last-2 /// </summary> /// <param name="index">Index</param> /// <param name="obj">Object</param> /// <returns>Return tru eif object exists</returns> public override bool TryPeek(int index, out StackItemBase obj) { if (_engine.IsDisposed) { throw new ObjectDisposedException(nameof(ExecutionEngine)); } var ptr = NeoVM.StackItems_Peek(_handle, index); if (ptr == IntPtr.Zero) { obj = null; return(false); } obj = _engine.ConvertFromNative(ptr); return(true); }
public void TestArrayStackItem() { using (var engine = CreateEngine(null)) { for (int x = 0; x < 2; x++) { bool isStruct = x == 1; // First test for array, second for Struct using (var ar = isStruct ? engine.CreateStruct() : engine.CreateArray()) { Assert.AreEqual(isStruct, ar.IsStruct); // Create two random integer types foreach (var bi in TestBigIntegers) { using (var btest = engine.CreateInteger(bi)) { // Check contains Assert.IsFalse(ar.Contains(btest)); // Check empty Assert.AreEqual(0, ar.Count); // Add and check count ar.Add(btest); Assert.AreEqual(1, ar.Count); // Check item by position using (var iau = (IntegerStackItem)ar[0]) Assert.AreEqual(iau.Value, btest.Value); // Remove Assert.IsTrue(ar.Remove(btest)); } } // Clear ar.Clear(); Assert.AreEqual(0, ar.Count); // Add bool and check contains using (var bkill = engine.CreateBool(true)) { Assert.AreEqual(ar.IndexOf(bkill), -1); ar.Add(bkill); Assert.AreEqual(ar.IndexOf(ar), -1); Assert.IsTrue(ar.Contains(bkill)); } // Create new array ArrayStackItemBase ar2; { var art = new StackItemBase[] { engine.CreateBool(true), engine.CreateBool(false) }; ar2 = engine.CreateArray(art); foreach (var it in art) { it.Dispose(); } } Assert.IsFalse(ar.Contains(ar2)); // Replace bool with array ar[0] = ar2; // Check IndexOf Assert.AreEqual(ar.IndexOf(ar2), 0); // Check count Assert.AreEqual(1, ar.Count); // Remove first element ar.RemoveAt(0); // Check count Assert.AreEqual(0, ar.Count); // Add 1,2,3 { var art = new StackItemBase[] { engine.CreateInteger(1), engine.CreateInteger(2), engine.CreateInteger(3) }; ar.Add(art); foreach (var it in art) { it.Dispose(); } } // Remove 2 ar.RemoveAt(1); // Check count Assert.AreEqual(2, ar.Count); // Check values 1 and 3 using (var iau = (IntegerStackItem)ar[0]) Assert.AreEqual(iau.Value, 1); using (var iau = (IntegerStackItem)ar[1]) Assert.AreEqual(iau.Value, 3); // Insert bool using (var inte = engine.CreateBool(true)) ar.Insert(1, inte); // Check values using (var iau = (IntegerStackItem)ar[0]) Assert.AreEqual(iau.Value, 1); using (var iau = (BooleanStackItem)ar[1]) Assert.IsTrue(iau.Value); using (var iau = (IntegerStackItem)ar[2]) Assert.AreEqual(iau.Value, 3); } } } }
public override bool ContainsKey(StackItemBase key) => NeoVM.MapStackItem_Get(_handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle) != IntPtr.Zero;
public override void Set(int index, StackItemBase item) => NeoVM.ArrayStackItem_Set(Handle, ((INativeStackItem)item).Handle, index);
public override bool TryPeek(int index, out StackItemBase item) { throw new NotImplementedException(); }
public override void Push(StackItemBase item) { throw new NotImplementedException(); }
public override int IndexOf(StackItemBase item) => NeoVM.ArrayStackItem_IndexOf(Handle, ((INativeStackItem)item).Handle);
public override void Add(StackItemBase item) => NeoVM.ArrayStackItem_Add(Handle, ((INativeStackItem)item).Handle);
private void SerializeStackItem(StackItemBase item, BinaryWriter writer) { switch (item) { case ByteArrayStackItem _: { writer.Write((byte)EStackItemType.ByteArray); writer.WriteVarBytes(item.ToByteArray()); break; } case BooleanStackItem bl: { writer.Write((byte)EStackItemType.Bool); writer.Write(bl.Value); break; } case IntegerStackItem _: { writer.Write((byte)EStackItemType.Integer); writer.WriteVarBytes(item.ToByteArray()); break; } case ArrayStackItem array: { if (array.IsStruct) { writer.Write((byte)EStackItemType.Struct); } else { writer.Write((byte)EStackItemType.Array); } writer.WriteVarInt(array.Count); foreach (StackItemBase subitem in array) { SerializeStackItem(subitem, writer); } break; } case MapStackItem map: { writer.Write((byte)EStackItemType.Map); writer.WriteVarInt(map.Count); foreach (var pair in map) { SerializeStackItem(pair.Key, writer); SerializeStackItem(pair.Value, writer); } break; } default: throw new NotSupportedException(); } }
public override bool TryPop(out StackItemBase item) { throw new NotImplementedException(); }
public override bool Remove(StackItemBase key) => NeoVM.MapStackItem_Remove(_handle, key == null ? IntPtr.Zero : ((INativeStackItem)key).Handle) == NeoVM.TRUE;