public void Run(ICommandInteraction writer, PathToken path)
{
if (IncludeCommand.Run(writer, path))
{
EmulationManager.Instance.CurrentEmulation.StartAll();
}
}
public void Run(ICommandInteraction writer, PathToken path)
{
if(IncludeCommand.Run(writer, path))
{
EmulationManager.Instance.CurrentEmulation.StartAll();
}
}
public void Run(ICommandInteraction writer, LiteralToken variable, Token value)
{
var varName = variable.Value;
varName = GetVariableName(varName);
SetVariable(varName, value);
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine("- to trace only function call with a registered handler:");
writer.WriteLine("{0} {1} cpuName \"functionName\"".FormatWith(Name, TraceEnableCommand));
writer.WriteLine();
writer.WriteLine("- to trace function call and returned value with a registered handler:");
writer.WriteLine("{0} {1} cpuName \"functionName\" true".FormatWith(Name, TraceEnableCommand));
writer.WriteLine();
writer.WriteLine("- to trace function call without a handler, with or without return value:");
writer.WriteLine("{0} {1} cpuName \"functionName\" [true|false] [number of parameters]".FormatWith(Name, TraceEnableCommand));
writer.WriteLine();
writer.WriteLine("- to trace function call without a handler, with or without return value, with specified variable types:");
writer.WriteLine("{0} {1} cpuName \"functionName\" [true|false] [list of parameter types]".FormatWith(Name, TraceEnableCommand));
writer.WriteLine("(Note, that if return value is expected, the last parameter type must relate to return value.");
writer.WriteLine();
writer.WriteLine("- to disable tracing of a function:");
writer.WriteLine("{0} {1} cpuName \"functionName\"".FormatWith(Name, TraceDisableCommand));
writer.WriteLine();
writer.WriteLine("Handlers available for functions:");
writer.WriteLine(handlers.Keys.Select(x => "- " + x).Stringify("\r\n"));
writer.WriteLine();
writer.WriteLine("Possible values for parameter types:");
writer.WriteLine(Enum.GetNames(typeof(FunctionCallParameterType)).Where(x => !x.Contains("Array")).Select(x => "- " + x).Stringify("\r\n"));
}
public void Run(ICommandInteraction writer, [Values("Noisy", "Debug", "Info", "Warning", "Error")] StringToken level, LiteralToken backendName, LiteralToken peripheralName)
{
if (!SetLogLevel(LogLevel.Parse(level.Value), backendName.Value, peripheralName.Value))
{
writer.WriteError(string.Format("Could not find emulation element or backend"));
}
}
public void Run(ICommandInteraction writer)
{
var currentMachine = GetCurrentMachine();
if (currentMachine == null)
{
writer.WriteError("Select active machine.");
return;
}
writer.WriteLine("Available peripherals:");
writer.WriteLine();
var peripheralEntries = currentMachine.GetPeripheralsWithAllRegistrationPoints();
var sysbusEntry = peripheralEntries.First(x => x.Key.Name == Machine.SystemBusName);
var sysbusNode = new PeripheralNode(sysbusEntry);
var nodeQueue = new Queue <PeripheralNode>(peripheralEntries.Where(x => x.Key != sysbusEntry.Key).Select(x => new PeripheralNode(x)));
while (nodeQueue.Count > 0)
{
var x = nodeQueue.Dequeue();
// Adding nodes to sysbusNode is successful only if the current node's parent was already added.
// This code effectively sorts the nodes topologically.
if (!sysbusNode.AddChild(x))
{
nodeQueue.Enqueue(x);
}
}
sysbusNode.PrintTree(writer);
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine(String.Format("{0} <<message to log>> <<log level>>", Name));
}
public void Run(ICommandInteraction writer, StringToken command, DecimalIntegerToken delay)
{
var terminal = writer as CommandInteraction;
if (terminal == null)
{
writer.WriteError("Watch command can be used on a full-featured terminal only");
return;
}
var eater = new CommandInteractionEater();
while (!terminal.HasNewInput)
{
terminal.SaveCursor();
monitor.Parse(command.Value, eater);
writer.Write(eater.GetContents());
var error = eater.GetError();
if (error.Length > 0)
{
writer.WriteError(error);
break;
}
eater.Clear();
System.Threading.Thread.Sleep((int)delay.Value);
terminal.RestoreCursor();
terminal.ClearToEnd();
}
}
public void PrintTree(ICommandInteraction writer, TreeViewBlock[] pattern = null)
{
if (pattern == null)
{
pattern = new TreeViewBlock[0];
}
var indent = GetIndentString(pattern);
writer.WriteLine(String.Format("{0}{1} ({2})", indent, PeripheralEntry.Name, PeripheralEntry.Type.Name));
if (PeripheralEntry.Parent != null)
{
var newIndent = GetIndentString(UpdatePattern(pattern, Children.Count > 0 ? TreeViewBlock.Straight : TreeViewBlock.Empty));
if (!(PeripheralEntry.RegistrationPoint is ITheOnlyPossibleRegistrationPoint))
{
foreach (var registerPlace in RegistrationPoints)
{
writer.WriteLine(String.Format("{0}{1}", newIndent, registerPlace.PrettyString));
}
}
writer.WriteLine(newIndent);
}
else
{
writer.WriteLine(GetIndentString(new TreeViewBlock[] { TreeViewBlock.Straight }));
}
var lastChild = Children.LastOrDefault();
foreach (var child in Children)
{
child.PrintTree(writer, UpdatePattern(pattern, child != lastChild ? TreeViewBlock.Full : TreeViewBlock.End));
}
}
public bool ExecuteBuiltinCommand(Token[] command, ICommandInteraction writer)
{
var command_name = ((LiteralToken)command[0]).Value;
if (!Scope.ContainsVariable("mc_" + command_name))
{
return(false);
}
object comm = Scope.GetVariable("mc_" + command_name); // get a method
var parameters = command.Skip(1).Select(x => x.GetObjectValue()).ToArray();
ConfigureOutput(writer);
try
{
var result = Engine.Operations.Invoke(comm, parameters);
if (result != null && (!(result is bool) || !(bool)result))
{
writer.WriteError(String.Format("Command {0} failed, returning \"{1}\".", command_name, result));
}
}
catch (Exception e)
{
throw new RecoverableException(e);
}
return(true);
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine("\nUsage:");
writer.WriteLine("watch \"<command>\" <refresh period in ms>");
}
public void Run(ICommandInteraction writer)
{
var output = $"Current virtual time: {EmulationManager.Instance.CurrentEmulation.MasterTimeSource.ElapsedVirtualTime}\nCurrent real time: {EmulationManager.Instance.CurrentEmulation.MasterTimeSource.ElapsedHostTime}";
writer.WriteLine(output);
Logger.LogAs(monitor, LogLevel.Info, output);
}
public bool Run(ICommandInteraction writer, PathToken path)
{
if (!File.Exists(path.Value))
{
writer.WriteError(String.Format("No such file {0}.", path.Value));
return(false);
}
using (var progress = EmulationManager.Instance.ProgressMonitor.Start("Including script: " + path.Value))
{
bool result = false;
switch (Path.GetExtension(path.Value))
{
case ".py":
result = PythonExecutor(path.Value, writer);
break;
case ".cs":
result = CsharpExecutor(path.Value, writer);
break;
default:
result = ScriptExecutor(path.Value);
break;
}
return(result);
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine(String.Format("{0} \"name\"", Name));
}
public void Run(ICommandInteraction writer, [Values("set", "add", "rem")] LiteralToken action, StringToken name)
{
switch (action.Value)
{
case "add":
var machine = new Machine();
EmulationManager.Instance.CurrentEmulation.AddMachine(machine, name.Value);
if (GetCurrentMachine() == null)
{
SetCurrentMachine(machine);
}
break;
case "set":
try
{
SetCurrentMachine(EmulationManager.Instance.CurrentEmulation[name.Value]);
}
catch (KeyNotFoundException)
{
writer.WriteError(string.Format("Machine {0} not found.", name.Value));
}
break;
case "rem":
var machineToRemove = EmulationManager.Instance.CurrentEmulation[name.Value];
EmulationManager.Instance.CurrentEmulation.RemoveMachine(name.Value);
if (GetCurrentMachine() == machineToRemove)
{
SetCurrentMachine(null);
}
break;
}
}
public bool Run(ICommandInteraction writer, PathToken path)
{
if(!File.Exists(path.Value))
{
writer.WriteError(String.Format("No such file {0}.", path.Value));
return false;
}
using(var progress = EmulationManager.Instance.ProgressMonitor.Start("Including script: " + path.Value))
{
bool result = false;
switch(Path.GetExtension(path.Value))
{
case ".py":
result = PythonExecutor(path.Value, writer);
break;
case ".cs":
result = CsharpExecutor(path.Value, writer);
break;
default:
result = ScriptExecutor(path.Value);
break;
}
return result;
}
}
public void Run(ICommandInteraction writer, LiteralToken peripheralName)
{
var emu = EmulationManager.Instance.CurrentEmulation;
IPeripheral p;
try
{
p = (IPeripheral)monitor.ConvertValueOrThrowRecoverable(peripheralName.Value, typeof(IPeripheral));
}
catch (RecoverableException)
{
writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value));
return;
}
IAnalyzableBackend backend;
if (!emu.BackendManager.TryGetBackendFor(p, out backend))
{
writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value));
return;
}
var def = emu.BackendManager.GetPreferredAnalyzerFor(backend);
foreach (var a in emu.BackendManager.GetAvailableAnalyzersFor(backend))
{
writer.WriteLine(String.Format("{0}{1}", a, a == def ? " (default)" : String.Empty));
}
}
public void Run(ICommandInteraction writer, [Values("default")] LiteralToken @default, LiteralToken peripheralName)
{
var emu = EmulationManager.Instance.CurrentEmulation;
IPeripheral p;
string fake;
var m = monitor.Machine;
if (m == null || !m.TryGetByName(peripheralName.Value, out p, out fake))
{
writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value));
return;
}
IAnalyzableBackend backend;
if (!emu.BackendManager.TryGetBackendFor(p, out backend))
{
writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value));
return;
}
var def = emu.BackendManager.GetPreferredAnalyzerFor(backend);
writer.WriteLine(def ?? "No default analyzer found.");
}
private void PrintLastLogs(ICommandInteraction writer, int numberOfEntries = DefaultNumberOfEntries)
{
if (numberOfEntries > MemoryBackend.MaxCount)
{
throw new RecoverableException($"The number of entries cannot be larger than {MemoryBackend.MaxCount}");
}
if (!Logger.GetBackends().TryGetValue(MemoryBackend.Name, out var backend))
{
throw new RecoverableException("Could not get memory backend");
}
var memoryBackend = backend as MemoryBackend;
if (memoryBackend == null)
{
throw new RecoverableException("Memory backend of unexpected type");
}
foreach (var entry in ((MemoryBackend)memoryBackend).GetMemoryLogEntries(numberOfEntries))
{
var count = entry.Count > 1 ? $"({entry.Count})" : string.Empty;
writer.WriteLine($"{entry.DateTime:HH:mm:ss.ffff} [{entry.Type}] {entry.Message} {count}", entry.Type.Color);
}
}
public void Run(ICommandInteraction writer)
{
writer.WriteLine("Renode is quitting", ConsoleColor.Green);
SetCurrentMachine(null);
Quitted?.Invoke()?.Invoke();
writer.QuitEnvironment = true;
}
public void Run(ICommandInteraction writer, [Values("set", "add", "rem")] LiteralToken action, StringToken name)
{
switch(action.Value)
{
case "add":
var machine = new Machine();
EmulationManager.Instance.CurrentEmulation.AddMachine(machine, name.Value);
if(GetCurrentMachine() == null)
{
SetCurrentMachine(machine);
}
break;
case "set":
try
{
SetCurrentMachine(EmulationManager.Instance.CurrentEmulation[name.Value]);
}
catch(KeyNotFoundException)
{
writer.WriteError(string.Format("Machine {0} not found.", name.Value));
}
break;
case "rem":
var machineToRemove = EmulationManager.Instance.CurrentEmulation[name.Value];
EmulationManager.Instance.CurrentEmulation.RemoveMachine(name.Value);
if(GetCurrentMachine() == machineToRemove)
{
SetCurrentMachine(null);
}
break;
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine(String.Format("{0} \"name\"", Name));
}
public bool TryExecutePythonScript(string fileName, ICommandInteraction writer)
{
var script = Engine.CreateScriptSourceFromFile(fileName);
ExecutePythonScriptInner(script, writer);
return(true);
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
var currentMachine = GetCurrentMachine();
if (currentMachine == null)
{
writer.WriteError("No machine selected.");
}
else
{
writer.WriteLine(string.Format("Current machine: {0}", EmulationManager.Instance.CurrentEmulation[currentMachine]));
}
if (EmulationManager.Instance.CurrentEmulation.MachinesCount > 0)
{
writer.WriteLine("Available machines:");
var emu = EmulationManager.Instance.CurrentEmulation;
var longestNameLength = emu.Machines.Max(m => emu[m].Length);
var i = 0;
foreach (var machine in emu.Machines)
{
writer.WriteLine(string.Format("\t{2}: {0,-" + longestNameLength + "} {1}", emu[machine], machine.Platform != null ? string.Format("[{0}]", machine.Platform.Name) : string.Empty, i++));
}
}
writer.WriteLine();
writer.WriteLine("You can use the following commands:");
writer.WriteLine("'mach set [\"name\"|number]'\tto enable the given machine");
writer.WriteLine("'mach add \"name\"'\tto create a new machine with the specified name");
writer.WriteLine("'mach rem \"name\"'\tto remove a machine");
writer.WriteLine("'mach create'\tto create a new machine with generic name and switch to it");
writer.WriteLine("'mach clear'\tto clear the current selection");
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName, BooleanToken traceReturn, params LiteralToken[] types)
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
var handler = new DefaultFunctionHandler(cpu);
var paramList = new List <FunctionCallParameter>();
foreach (var parameter in types)
{
FunctionCallParameterType paramType;
if (!Enum.TryParse(parameter.Value, out paramType))
{
throw new RecoverableException("{0} is not a proper parameter type.".FormatWith(parameter.Value));
}
paramList.Add(new FunctionCallParameter {
Type = paramType
});
}
handler.CallParameters = paramList.Take(paramList.Count - (traceReturn.Value ? 1 : 0));
handler.ReturnParameter = traceReturn.Value ? paramList.Last() : (FunctionCallParameter?)null;
if (traceReturn.Value)
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler, handler.ReturnParameter, handler.ReturnHandler);
}
else
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler);
}
}
public void Run(ICommandInteraction writer, LiteralToken peripheralName)
{
var emu = EmulationManager.Instance.CurrentEmulation;
IPeripheral p;
string fake;
var m = monitor.Machine;
if(m == null || !m.TryGetByName(peripheralName.Value, out p, out fake))
{
writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value));
return;
}
IAnalyzableBackend backend;
if(!emu.BackendManager.TryGetBackendFor(p, out backend))
{
writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value));
return;
}
foreach(var a in emu.BackendManager.GetAvailableAnalyzersFor(backend))
{
writer.WriteLine(a);
}
}
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] DecimalIntegerToken level, LiteralToken backendName, LiteralToken peripheralName)
{
if (!SetLogLevel((LogLevel)level.Value, backendName.Value, peripheralName.Value))
{
writer.WriteError(string.Format("Could not find emulation element or backend"));
}
}
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] NumericToken level, LiteralToken backendName, LiteralToken peripheralName)
{
if(!SetLogLevel((LogLevel)level.Value, backendName.Value, peripheralName.Value))
{
writer.WriteError(string.Format("Could not find emulation element or backend"));
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
var currentMachine = GetCurrentMachine();
if(currentMachine == null)
{
writer.WriteError("No machine selected.");
}
else
{
writer.WriteLine(string.Format("Current machine: {0}", EmulationManager.Instance.CurrentEmulation[currentMachine]));
}
if(EmulationManager.Instance.CurrentEmulation.MachinesCount > 0)
{
writer.WriteLine("Available machines:");
var emu = EmulationManager.Instance.CurrentEmulation;
var longestNameLength = emu.Machines.Max(m => emu[m].Length);
var i = 0;
foreach(var machine in emu.Machines)
{
writer.WriteLine(string.Format("\t{2}: {0,-" + longestNameLength + "} {1}", emu[machine], machine.Platform != null ? string.Format("[{0}]", machine.Platform.Name) : string.Empty, i++));
}
}
writer.WriteLine();
writer.WriteLine("You can use the following commands:");
writer.WriteLine("'mach set [\"name\"|number]'\tto enable the given machine");
writer.WriteLine("'mach add \"name\"'\tto create a new machine with the specified name");
writer.WriteLine("'mach rem \"name\"'\tto remove a machine");
writer.WriteLine("'mach create'\tto create a new machine with generic name and switch to it");
writer.WriteLine("'mach clear'\tto clear the current selection");
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName, BooleanToken traceReturn, params LiteralToken[] types)
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
var handler = new DefaultFunctionHandler(cpu);
var paramList = new List<FunctionCallParameter>();
foreach(var parameter in types)
{
FunctionCallParameterType paramType;
if(!Enum.TryParse(parameter.Value, out paramType))
{
throw new RecoverableException("{0} is not a proper parameter type.".FormatWith(parameter.Value));
}
paramList.Add(new FunctionCallParameter{ Type = paramType });
}
handler.CallParameters = paramList.Take(paramList.Count - (traceReturn.Value ? 1 : 0));
handler.ReturnParameter = traceReturn.Value ? paramList.Last() : (FunctionCallParameter?)null;
if(traceReturn.Value)
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler, handler.ReturnParameter, handler.ReturnHandler);
}
else
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler);
}
}
public void Run(ICommandInteraction writer)
{
var currentMachine = GetCurrentMachine();
if (currentMachine == null)
{
writer.WriteError("Select active machine.");
return;
}
writer.WriteLine("Available peripherals:");
var peripheralEntries = currentMachine.GetPeripheralsWithAllRegistrationPoints();
foreach (var entry in peripheralEntries)
{
var isInMachine = entry.Key.Parent == null;
var description = (isInMachine || entry.Key.RegistrationPoint is ITheOnlyPossibleRegistrationPoint) ? "{0} ({1}) in {2}\n\r" : "{0} ({1}) in {2} at ";
var parentName = !isInMachine?peripheralEntries.First(x => x.Key.Peripheral == entry.Key.Parent).Key.Name
: EmulationManager.Instance.CurrentEmulation[currentMachine];
var peripheralName = entry.Key.Name ?? "<unnamed>";
var nameAndParent = string.Format(description, peripheralName, entry.Key.Type.Name, parentName);
writer.Write(nameAndParent);
if (!(entry.Key.RegistrationPoint is ITheOnlyPossibleRegistrationPoint || isInMachine))
{
writer.WriteLine(entry.Key.RegistrationPoint.PrettyString);
if (entry.Value.Count() > 1)
{
foreach (var otherEntry in entry.Value.Skip(1))
{
writer.WriteLine(String.Format("{1}and at {0}", otherEntry.PrettyString, " ".PadLeft(nameAndParent.Length - "and at".Length - 1)));
}
}
}
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine("- to trace only function call with a registered handler:");
writer.WriteLine("{0} {1} cpuName \"functionName\"".FormatWith(Name, TraceEnableCommand));
writer.WriteLine();
writer.WriteLine("- to trace function call and returned value with a registered handler:");
writer.WriteLine("{0} {1} cpuName \"functionName\" true".FormatWith(Name, TraceEnableCommand));
writer.WriteLine();
writer.WriteLine("- to trace function call without a handler, with or without return value:");
writer.WriteLine("{0} {1} cpuName \"functionName\" [true|false] [number of parameters]".FormatWith(Name, TraceEnableCommand));
writer.WriteLine();
writer.WriteLine("- to trace function call without a handler, with or without return value, with specified variable types:");
writer.WriteLine("{0} {1} cpuName \"functionName\" [true|false] [list of parameter types]".FormatWith(Name, TraceEnableCommand));
writer.WriteLine("(Note, that if return value is expected, the last parameter type must relate to return value.");
writer.WriteLine();
writer.WriteLine("- to disable tracing of a function:");
writer.WriteLine("{0} {1} cpuName \"functionName\"".FormatWith(Name, TraceDisableCommand));
writer.WriteLine();
writer.WriteLine("Handlers available for functions:");
writer.WriteLine(handlers.Keys.Select(x => "- " + x).Stringify("\r\n"));
writer.WriteLine();
writer.WriteLine("Possible values for parameter types:");
writer.WriteLine(Enum.GetNames(typeof(FunctionCallParameterType)).Where(x => !x.Contains("Array")).Select(x => "- " + x).Stringify("\r\n"));
}
public void Run(ICommandInteraction writer, LiteralToken variable, Token value)
{
var varName = variable.Value;
varName = GetVariableName(varName);
SetVariable(varName, value);
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine(String.Format("{0} <<message to log>> <<log level>>", Name));
}
public void Run(ICommandInteraction writer)
{
var currentMachine = GetCurrentMachine();
if( currentMachine == null)
{
writer.WriteError("Select active machine.");
return;
}
writer.WriteLine("Available peripherals:");
var peripheralEntries = currentMachine.GetPeripheralsWithAllRegistrationPoints();
foreach(var entry in peripheralEntries)
{
var isInMachine = entry.Key.Parent == null;
var description = (isInMachine || entry.Key.RegistrationPoint is ITheOnlyPossibleRegistrationPoint) ? "{0} ({1}) in {2}\n\r" : "{0} ({1}) in {2} at ";
var parentName = !isInMachine ? peripheralEntries.First(x => x.Key.Peripheral == entry.Key.Parent).Key.Name
: EmulationManager.Instance.CurrentEmulation[currentMachine];
var peripheralName = entry.Key.Name ?? "<unnamed>";
var nameAndParent = string.Format(description, peripheralName, entry.Key.Type.Name, parentName);
writer.Write(nameAndParent);
if(!(entry.Key.RegistrationPoint is ITheOnlyPossibleRegistrationPoint || isInMachine))
{
writer.WriteLine(entry.Key.RegistrationPoint.PrettyString);
if(entry.Value.Count() > 1)
{
foreach(var otherEntry in entry.Value.Skip(1))
{
writer.WriteLine(String.Format("{1}and at {0}", otherEntry.PrettyString, " ".PadLeft(nameAndParent.Length - "and at".Length-1 )));
}
}
}
}
}
public void Run(ICommandInteraction writer, [Values("Noisy", "Debug", "Info", "Warning", "Error")] StringToken level, LiteralToken backendName, LiteralToken peripheralName)
{
if(!SetLogLevel(LogLevel.Parse(level.Value), backendName.Value, peripheralName.Value))
{
writer.WriteError(string.Format("Could not find emulation element or backend"));
}
}
public void Run(ICommandInteraction writer, LiteralToken peripheralName)
{
var emu = EmulationManager.Instance.CurrentEmulation;
IPeripheral p;
string fake;
var m = monitor.Machine;
if (m == null || !m.TryGetByName(peripheralName.Value, out p, out fake))
{
writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value));
return;
}
IAnalyzableBackend backend;
if (!emu.BackendManager.TryGetBackendFor(p, out backend))
{
writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value));
return;
}
foreach (var a in emu.BackendManager.GetAvailableAnalyzersFor(backend))
{
writer.WriteLine(a);
}
}
private TokenizationResult Tokenize(string cmd, ICommandInteraction writer)
{
var result = tokenizer.Tokenize(cmd);
if (result.UnmatchedCharactersLeft != 0)
{
if (result.Tokens.Any(x => x is VariableToken))
{
var tokensAfter = ExpandVariables(result.Tokens);
var newString = tokensAfter.Select(x => x.OriginalValue).Stringify() + cmd.Substring(cmd.Length - result.UnmatchedCharactersLeft);
return(Tokenize(newString, writer));
}
var messages = new StringBuilder();
var message = "Could not tokenize here:";
writer.WriteError(message);
messages.AppendFormat("Monitor: {0}\n", message);
writer.WriteError(cmd);
messages.AppendLine(cmd);
var matchedLength = cmd.Length - result.UnmatchedCharactersLeft;
var padded = "^".PadLeft(matchedLength + 1);
writer.WriteError(padded);
messages.AppendLine(padded);
if (result.Exception != null)
{
messages.AppendFormat("Encountered exception: {0}\n", result.Exception.Message);
writer.WriteError(result.Exception.Message);
}
Logger.Log(LogLevel.Warning, messages.ToString());
return(null);
}
return(result);
}
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] DecimalIntegerToken level, LiteralToken peripheralOrBackendName)
{
if(!SetLogLevel((LogLevel)level.Value, null, peripheralOrBackendName.Value)
&& !SetLogLevel((LogLevel)level.Value, peripheralOrBackendName.Value, null))
{
writer.WriteError(string.Format("Could not find emulation element or backend named: {0}", peripheralOrBackendName.Value));
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("You must provide the name of the {0}.".FormatWith(noun));
writer.WriteLine();
writer.WriteLine(String.Format("Usage:\n\r\t{0} {1} \"value\"\n\r\n\r\t{0} {1}\n\r\t^^^\n\r\t[multiline value]\n\r\t^^^", Name, noun));
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("You must provide the name of the {0}.".FormatWith(noun));
writer.WriteLine();
writer.WriteLine(String.Format("Usage:\n\r\t{0} {1} \"value\"\n\r\n\r\t{0} {1}\n\r\t^^^\n\r\t[multiline value]\n\r\t^^^", Name, noun));
}
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] NumericToken level, LiteralToken peripheralOrBackendName)
{
if (!SetLogLevel((LogLevel)level.Value, null, peripheralOrBackendName.Value) &&
!SetLogLevel((LogLevel)level.Value, peripheralOrBackendName.Value, null))
{
writer.WriteError(string.Format("Could not find emulation element or backend named: {0}", peripheralOrBackendName.Value));
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine(Name);
writer.WriteLine($"{Name} <<numberOfEntries>>");
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
var allowed = (monitor.CurrentBindingFlags & BindingFlags.NonPublic) > 0;
writer.WriteLine();
writer.WriteLine(allowed ? "Private fields are available":"Private fields are not available");
return;
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine(String.Format("{0} - starts the current machine", Name));
writer.WriteLine(String.Format("{0} @path - executes the script and starts the emulation", Name));
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Usage:");
writer.WriteLine(String.Format("{0} - starts the whole emulation", Name));
writer.WriteLine(String.Format("{0} @path - executes the script and starts the emulation", Name));
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
var allowed = (monitor.CurrentBindingFlags & BindingFlags.NonPublic) > 0;
writer.WriteLine();
writer.WriteLine(allowed ? "Private fields are available":"Private fields are not available");
return;
}
public void Run(ICommandInteraction writer, [Values("Noisy", "Debug", "Info", "Warning", "Error")] StringToken level, LiteralToken peripheralOrBackendName)
{
var logLevel = LogLevel.Parse(level.Value);
if(!SetLogLevel(logLevel, null, peripheralOrBackendName.Value)
&& !SetLogLevel(logLevel, peripheralOrBackendName.Value, null))
{
writer.WriteError(string.Format("Could not find emulation element or backend named: {0}", peripheralOrBackendName.Value));
}
}
public override void PrintHelp(ICommandInteraction writer)
{
writer.WriteLine("Usage:");
writer.WriteLine("------");
writer.WriteLine("showAnalyzer ([externalName]) [peripheral] ([typeName])");
writer.WriteLine("\tshows analyzer for [peripheral]");
writer.WriteLine("");
writer.WriteLine("[externalName] (optional) - if set, command will create external named [externalName]; this can be used only for analyzers implementing IExternal interface");
writer.WriteLine("[typeName] (optional) - if set, command will select analyzer provided in class [typeName]; this must be used when there are more than one analyzers available and no default is set");
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine("\nOptions:");
writer.WriteLine("===========================");
foreach(var item in PlatformsProvider.GetAvailablePlatforms().OrderBy(x=>x.Name))
{
writer.WriteLine(item.Name);
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Available terminals:");
foreach(var key in console.Keys)
{
writer.WriteLine(string.Format("\t{0}", key));
}
}
public void CommandHelp(ICommandInteraction writer, LiteralToken commandName)
{
if(!GetCommands().Any(x => x.Name == commandName.Value))
{
writer.WriteError(String.Format("No such command: {0}.", commandName.Value));
return;
}
var command = GetCommands().First(x => x.Name == commandName.Value);
command.PrintHelp(writer);
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine("\nTo load a script you have to provide an existing file name.");
writer.WriteLine();
writer.WriteLine("Supported file formats:");
writer.WriteLine("*.cs - plugin file");
writer.WriteLine("*.py - python script");
writer.WriteLine("other - monitor script");
}
public void RunnableAttribute(ICommandInteraction writer, BooleanToken allow)
{
if(allow.Value)
{
monitor.CurrentBindingFlags |= BindingFlags.NonPublic;
}
else
{
monitor.CurrentBindingFlags &= ~BindingFlags.NonPublic;
}
}
public void Run(ICommandInteraction writer)
{
var currentMachine = GetCurrentMachine();
if(currentMachine == null)
{
writer.WriteError("Select active machine.");
return;
}
writer.WriteLine("Starting emulation...");
currentMachine.Start();
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine("Provide a command or {0} to execute.".FormatWith(noun));
writer.WriteLine();
writer.WriteLine("Available {0}s:".FormatWith(noun));
foreach(var variable in GetVariables())
{
writer.WriteLine("\t{0}".FormatWith(variable));
}
}
public override void PrintHelp(ICommandInteraction writer)
{
base.PrintHelp(writer);
writer.WriteLine();
writer.WriteLine(string.Format("Current mode: {0}", monitor.CurrentNumberFormat));
writer.WriteLine();
writer.WriteLine("Options:");
foreach(var item in typeof(Monitor.NumberModes).GetEnumNames())
{
writer.WriteLine(item);
}
}
public void GeneralHelp(ICommandInteraction writer)
{
writer.WriteLine("Available commands:");
writer.WriteLine(string.Format("{0,-18}| {1}", "Name", "Description"));
writer.WriteLine("================================================================================");
foreach(var item in GetCommands().OrderBy(x=>x.Name))
{
writer.WriteLine(string.Format("{0,-18}: {1}", item.Name, item.Description));
}
writer.WriteLine();
writer.WriteLine("You can also provide a device name to access its methods.");
writer.WriteLine("Use <TAB> for auto-completion.");
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand, TraceDisableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName)
{
if(enable.Value == TraceEnableCommand)
{
Execute(writer, cpuToken, functionName.Value, false, null);
}
else
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
cpuTracer.RemoveTracing(functionName.Value);
}
}
public void Run(ICommandInteraction writer, [Values("set")] LiteralToken action, DecimalIntegerToken number)
{
var machines = EmulationManager.Instance.CurrentEmulation.Machines.ToArray();
if(machines.Length > number.Value && number.Value >= 0)
{
SetCurrentMachine(machines[number.Value]);
}
else
{
writer.WriteError("Wrong machine number. Type {0} to show a list of available machines.".FormatWith(Name));
}
}
