void SetLocalVariableToBottomValueOfStack(IProgramCounter programCounter, IVariableManager localVariables)
{
var value = _stack.PopValue();
var variableName = programCounter.GetNullTerminatedString();
localVariables.SetVariable(variableName, value);
}
public bool Run(IProgramCounter programCounter, IVariableManager localVariables)
{
while (RunScriptCommand(programCounter, localVariables))
{
}
return(programCounter.Eof);
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
var method = debugInfo?.GetMethod(context.InstructionPointer);
var args = EnumerateSlot("arg", context.Arguments, method?.Parameters);
var locals = EnumerateSlot("local", context.LocalVariables, method?.Variables);
// TODO: statics
return(args.Concat(locals));
IEnumerable <Variable> EnumerateSlot(string prefix, IReadOnlyList <StackItem>?slot, IReadOnlyList <(string name, string type)>?variableInfo = null)
{
variableInfo ??= new List <(string name, string type)>();
slot ??= new List <StackItem>();
for (int i = 0; i < variableInfo.Count; i++)
{
var(name, type) = variableInfo[i];
if (name.Contains(':'))
{
continue;
}
var v = i < slot.Count
? slot[i].ToVariable(manager, name, type)
: StackItem.Null.ToVariable(manager, name, type);
yield return(v.ForEvaluation());
}
}
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
var method = debugInfo?.GetMethod(context.InstructionPointer);
var args = EnumerateSlot(DebugSession.ARG_SLOTS_PREFIX, context.Arguments, method?.Parameters);
var locals = EnumerateSlot(DebugSession.LOCAL_SLOTS_PREFIX, context.LocalVariables, method?.Variables);
var statics = EnumerateSlot(DebugSession.STATIC_SLOTS_PREFIX, context.StaticFields, debugInfo?.StaticVariables);
return(args.Concat(locals).Concat(statics));
IEnumerable <Variable> EnumerateSlot(string prefix, IReadOnlyList <StackItem>?slot, IReadOnlyList <DebugInfo.SlotVariable>?variableList = null)
{
variableList ??= ImmutableList <DebugInfo.SlotVariable> .Empty;
slot ??= ImmutableList <StackItem> .Empty;
for (int i = 0; i < variableList.Count; i++)
{
var slotIndex = variableList[i].Index;
var type = Enum.TryParse <ContractParameterType>(variableList[i].Type, out var _type)
? _type
: ContractParameterType.Any;
var item = slotIndex < slot.Count ? slot[slotIndex] : StackItem.Null;
var variable = item.ToVariable(manager, variableList[i].Name, type);
variable.EvaluateName = variable.Name;
yield return(variable);
}
}
}
void PushLocalVariableOnToTheStack(IProgramCounter programCounter, IVariableManager localVariables)
{
var variableName = programCounter.GetNullTerminatedString();
var value = localVariables.GetVariable(variableName);
_stack.PushValue(value);
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
for (int i = 0; i < array.Count; i++)
{
yield return(array[i].ToVariable(manager, $"{i}"));
}
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
for (int i = 0; i < slot.Count; i++)
{
var v = slot[i].ToVariable(manager, $"{prefix}{i}");
yield return(v.ForEvaluation("#"));
}
}
public OperandManager(IMemoryManager memoryManager,
IZStack stack,
IVariableManager variableManager)
{
_memoryManager = memoryManager;
_variableManager = variableManager;
_stack = stack;
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
yield return(new Variable
{
Name = nameof(IApplicationEngine.GasConsumed),
Value = engine.GasConsumedAsBigDecimal.ToString(),
});
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
for (int i = 0; i < evalStack.Count; i++)
{
var v = evalStack[i].ToVariable(manager, $"eval{evalStack.Count - i - 1}");
yield return(v.ForEvaluation("#"));
}
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
for (int i = 0; i < slot.Count; i++)
{
var v = slot[i].ToVariable(manager, $"{prefix}{i}");
v.EvaluateName = v.Name;
yield return(v);
}
}
public SchemeDeclarator(
[NotNull] List <StatementSyntax> statements,
[NotNull] IVariableManager variableManager,
[NotNull] IdentifierNameSyntax builder)
{
myStatements = statements.NotNull();
myVariableManager = variableManager.NotNull();
myBuilder = builder.NotNull();
}
static Variable ToVariable(IVariableManager manager, ByteArrayContainer container, string name, string type)
{
return(new Variable()
{
Name = name,
Value = $"{type}[{container.memory.Length}]",
VariablesReference = manager.Add(container),
IndexedVariables = container.memory.Length,
});
}
void ProcessFnRoutine(IProgramCounter programCounter, IVariableManager localVariables)
{
var parameterCount = programCounter.GetInteger();
var fnRoutineName = programCounter.GetNullTerminatedString();
var parameters = GetStackParametersIfRequired(parameterCount);
var result = _fnRoutinesCaller.CallFnRoutine(localVariables, fnRoutineName, parameters);
_stack.PushValue(result);
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
for (int i = 0; i < memory.Length; i++)
{
yield return(new Variable()
{
Name = i.ToString(),
Value = "0x" + memory.Span[i].ToString("x"),
Type = "Byte"
});
}
}
public int CallFnRoutine(IVariableManager localVariables, string fnRoutineName, List <object> parameters)
{
if (FunctionListContainsFunctionToCall(fnRoutineName))
{
return(CallFunctionWithParameters(fnRoutineName, parameters));
}
var paramlist = string.Join(",", parameters.Select(p => p.ToString()));
Console.WriteLine($"fn routine {fnRoutineName} with ({paramlist})");
return(0);
}
public static Variable Create(IVariableManager manager, NeoMap map, string name)
{
var container = new NeoMapContainer(map);
return(new Variable()
{
Name = name,
Value = $"Map[{map.Count}]",
VariablesReference = manager.Add(container),
NamedVariables = map.Count
});
}
public static Variable Create(IVariableManager manager, NeoArray array, string name)
{
var typeName = array is NeoStruct ? "Struct" : "Array";
var container = new NeoArrayContainer(array);
return(new Variable()
{
Name = name,
Value = $"{typeName}[{array.Count}]",
VariablesReference = manager.Add(container),
IndexedVariables = array.Count,
});
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
yield return(ForEvaluation(key.ToVariable(manager, "key")));
yield return(ForEvaluation(item.Value.ToVariable(manager, "item")));
yield return(ForEvaluation(item.IsConstant.ToVariable(manager, "isConstant")));
Variable ForEvaluation(Variable variable)
{
variable.EvaluateName = $"#storage[{hashCode}].{variable.Name}";
return(variable);
}
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
foreach (var key in map.Keys)
{
var keyString = key switch
{
Neo.VM.Types.Boolean @bool => @bool.GetBoolean().ToString(),
Neo.VM.Types.ByteString byteString => byteString.GetSpan().ToHexString(),
Neo.VM.Types.Integer @int => @int.GetInteger().ToString(),
_ => throw new NotImplementedException($"Unknown primitive type {key.GetType()}"),
};
yield return(map[key].ToVariable(manager, keyString));
}
}
private void _eventNotifier_PviServiceConnected(object sender, PviApplicationEventArgs e)
{
_cpuManager = e.CpuManager;
_variableManager = e.VariableManager;
_log.Info(e.Message);
if (_cpuManager == null)
{
_log.Error($"_eventNotifier_PviServiceConnected CpuManager is null");
}
else
{
_cpuManager.LoadCpus();
}
}
public IEnumerable <Variable> Enumerate(IVariableManager manager)
{
var storages = GetStorages();
foreach (var(key, item) in storages)
{
var keyHashCode = key.Span.GetSequenceHashCode().ToString("x8");
var kvp = new KvpContainer(key, item, keyHashCode);
yield return(new Variable()
{
Name = keyHashCode,
Value = string.Empty,
VariablesReference = manager.Add(kvp),
NamedVariables = 2
});
}
}
public ScriptInterpreter(
IFnRoutinesCaller fnRoutinesCaller,
IVariableManager variableManager,
IValueStack stack
)
{
if (fnRoutinesCaller == null)
{
throw new ArgumentNullException();
}
_fnRoutinesCaller = fnRoutinesCaller;
if (stack == null)
{
throw new ArgumentNullException();
}
_stack = stack;
if (variableManager == null)
{
throw new ArgumentNullException();
}
_variableManager = variableManager;
}
public BashInterpreter()
{
executer = new Executer();
variableManager = new VariableManager();
logger = new Logger();
}
bool RunScriptCommand(IProgramCounter programCounter, IVariableManager localVariables)
{
if (programCounter.Eof)
{
throw new Exception($"Unexpected end of script found in '{programCounter.GetScriptName()}'");
}
var command = programCounter.GetCommand();
switch ((ScriptToken)command)
{
case ScriptToken.PushIntValue:
_stack.PushValue(programCounter.GetInteger());
break;
case ScriptToken.PushStringValue:
_stack.PushValue(programCounter.GetNullTerminatedString());
break;
case ScriptToken.PushGlobalVariable: // 4
PushGlobalVariableOnToTheStack(programCounter);
break;
case ScriptToken.PopGlobalVariable: // 5
SetGlobalVariableToBottomValueOfStack(programCounter);
break;
case ScriptToken.Jfalse: // 6
MoveScriptPointerIfStackValueIsZero(programCounter);
break;
case ScriptToken.Jtrue: // 7
MoveScriptPointerIfStackValueIsNotZero(programCounter);
break;
case ScriptToken.Jall: // 8
MoveScriptPointerAlways(programCounter);
break;
case ScriptToken.Add: // 9
_stack.Add();
break;
case ScriptToken.Subtract: // 10
_stack.Subtract();
break;
case ScriptToken.Multiply: // 11
_stack.Multiply();
break;
case ScriptToken.Divide: // 12
_stack.Divide();
break;
case ScriptToken.Negate: // 13
_stack.Negate();
break;
case ScriptToken.LogicalNot: // 14
_stack.LogicalNot();
break;
case ScriptToken.Lt: // 15
_stack.Lt();
break;
case ScriptToken.Gt: // 16
_stack.Gt();
break;
case ScriptToken.Lte: // 17
_stack.Lte();
break;
case ScriptToken.Gte: // 18
_stack.Gte();
break;
case ScriptToken.VariableEquals: // 19
_stack.VariableEquals();
break;
case ScriptToken.LogicalAnd: // 20
_stack.LogicalAnd();
break;
case ScriptToken.LogicalOr: // 21
_stack.LogicalOr();
break;
case ScriptToken.CallFnRoutine: // 22
ProcessFnRoutine(programCounter, localVariables);
break;
case ScriptToken.DropStackValue: // 23
return(_stack.PopValue() == 0);
case ScriptToken.EndScript: // 24
return(false);
case ScriptToken.DropSkipPauseNotZero: // 25
return(ProcessDropSkipPauseNotZero(programCounter));
case ScriptToken.PauseScript: // 26
return(false);
case ScriptToken.PushLocalVariable: // 27
PushLocalVariableOnToTheStack(programCounter, localVariables);
break;
case ScriptToken.PopLocalVariable: // 28
SetLocalVariableToBottomValueOfStack(programCounter, localVariables);
break;
default:
throw new InvalidOperationException($"Invalid Script Command {command}");
}
return(true);
}
public CommandManager(IList <Command> commands, IVariableManager variableManager, ITwitchClient twitchClient)
{
_commands = commands;
_variableManager = variableManager;
_twitchClient = twitchClient;
}
public static Variable Create(IVariableManager manager, Buffer buffer, string name)
{
var container = new ByteArrayContainer(buffer.InnerBuffer);
return(ToVariable(manager, container, name, "Buffer"));
}
public static Variable Create(IVariableManager manager, ByteString byteString, string name)
{
var container = new ByteArrayContainer(byteString);
return(ToVariable(manager, container, name, "ByteString"));
}
public static Variable Create(IVariableManager manager, byte[] array, string name)
{
var container = new ByteArrayContainer(array.AsMemory());
return(ToVariable(manager, container, name, "ByteArray"));
}
public NodeConnector([NotNull] List <StatementSyntax> statements, [NotNull] IVariableManager variableManager)
{
myStatements = statements.NotNull();
myVariableManager = variableManager.NotNull();
}
