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;
