public override void DetachFrom(IUART uart)
{
lock (internalLock)
{
base.DetachFrom(uart);
machine = null;
}
}
public void AttachTo(IUART uart, Machine machine)
{
lock (internalLock)
{
this.machine = machine;
base.AttachTo(uart);
}
}
public UartFileBackend(SequencedFilePath path, IUART uart, bool immediateFlush = false)
{
this.uart = uart;
this.immediateFlush = immediateFlush;
// SequencedFilePath asserts that file in given path doesn't exist
writer = new BinaryWriter(File.Open(path, FileMode.CreateNew));
uart.CharReceived += WriteChar;
}
public static void WriteLine(this IUART uart, string text, LineEnding lineEnding = LineEnding.CR)
{
foreach (var chr in text)
{
uart.WriteChar((byte)chr);
}
WriteLineEnding(uart, lineEnding);
}
public static void AddCharHook(this IUART uart, Func <byte, bool> predicate, Action <byte> hook)
{
uart.CharReceived += x =>
{
if (predicate(x))
{
hook(x);
}
};
}
public override void AttachTo(IUART uart)
{
machine = uart.GetMachine();
if (machine == null)
{
throw new ArgumentException("Could not find machine for UART");
}
base.AttachTo(uart);
HandleSuccess("Attached to UART", matchingLineId: NoLine);
}
public override void AttachTo(IUART uart)
{
lock (internalLock)
{
if (!EmulationManager.Instance.CurrentEmulation.TryGetMachineForPeripheral(uart, out machine))
{
throw new ArgumentException("Could not find machine for uart");
}
base.AttachTo(uart);
}
}
public static void CreateFileBackend(this IUART uart, string path, bool immediateFlush = false)
{
var emulation = EmulationManager.Instance.CurrentEmulation;
var name = ExternalNamePrefix + Path.GetFullPath(path);
((IHasChildren <IExternal>)emulation.ExternalsManager).TryGetByName(name, out var found);
if (found)
{
throw new RecoverableException($"The {path} is alredy used as UART file backend. Please close it using 'CloseFileBackend' before re-using");
}
emulation.ExternalsManager.AddExternal(new UartFileBackend(path, uart, immediateFlush), name);
}
public static void WriteLine(this IUART uart, string text, bool appendCarriageReturn = true)
{
const byte CarriageReturn = 0xD;
foreach (var chr in text)
{
uart.WriteChar((byte)chr);
}
if (appendCarriageReturn)
{
uart.WriteChar(CarriageReturn);
}
}
public UartFileBackend(string path, IUART uart, bool immediateFlush = false)
{
if (Misc.AllocateFile(path, out var id))
{
Logger.LogAs(uart, LogLevel.Warning, "Previous UART output file renamed to: {0}.{1}", path, id);
}
this.uart = uart;
this.immediateFlush = immediateFlush;
writer = new BinaryWriter(File.Open(path, FileMode.Open));
uart.CharReceived += WriteChar;
}
public UartPythonEngine(Machine machine, IUART uart, string script)
{
Script = script;
Uart = uart;
Machine = machine;
InnerInit();
Hook = line =>
{
Scope.SetVariable("line", line);
Source.Value.Execute(Scope);
};
}
public UartPythonEngine(Machine machine, IUART uart, string script)
{
Script = script;
Uart = uart;
Machine = machine;
InnerInit();
Hook = line =>
{
Scope.SetVariable("line", line);
Source.Value.Execute(Scope);
};
}
public static void CloseFileBackend(this IUART uart, string path)
{
var emulation = EmulationManager.Instance.CurrentEmulation;
var name = ExternalNamePrefix + Path.GetFullPath(path);
var external = (UartFileBackend)((IHasChildren <IExternal>)emulation.ExternalsManager).TryGetByName(name, out var success);
if (!success)
{
throw new RecoverableException($"Couldn't find active {path} file backend for the UART");
}
emulation.ExternalsManager.RemoveExternal(external);
external.Dispose();
}
public static string DumpHistoryBuffer(this IUART uart, int limit = 0)
{
var emu = EmulationManager.Instance.CurrentEmulation;
if (!emu.BackendManager.TryGetBackendFor(uart, out var backend))
{
throw new RecoverableException($"No backend found for {uart}");
}
if (backend is UARTBackend uartBackend)
{
return(uartBackend.DumpHistoryBuffer(limit));
}
throw new RecoverableException($"Unsupported type of backend for {uart}: {backend.GetType()}");
}
public UartPythonEngine(Machine machine, IUART uart, string script)
{
Script = script;
Uart = uart;
Machine = machine;
InnerInit();
Hook = line =>
{
Scope.SetVariable("line", line);
Execute(code, error =>
{
Uart.Log(LogLevel.Error, "Python runtime error: {0}", error);
});
};
}
public static void AddLineHook(this IUART uart, Func <string, bool> predicate, Action <string> hook)
{
var currentLine = string.Empty;
uart.CharReceived += x =>
{
if ((x == 10 || x == 13))
{
if (predicate(currentLine))
{
hook(currentLine);
}
currentLine = string.Empty;
return;
}
currentLine += (char)x;
};
}
private static void WriteLineEnding(IUART uart, LineEnding lineEnding)
{
const byte CarriageReturn = (byte)'\r';
const byte LineFeed = (byte)'\n';
switch (lineEnding)
{
case LineEnding.CR:
uart.WriteChar(CarriageReturn);
break;
case LineEnding.CRLF:
uart.WriteChar(CarriageReturn);
uart.WriteChar(LineFeed);
break;
case LineEnding.LF:
uart.WriteChar(LineFeed);
break;
}
;
}
public static void WriteLine(this IUART uart, string text, bool appendCarriageReturn = true)
{
uart.WriteLine(text, appendCarriageReturn ? LineEnding.CR : LineEnding.None);
}
public static void AddLineHook(this IUART uart, [AutoParameter] Machine machine, string contains, string pythonScript)
{
var engine = new UartPythonEngine(machine, uart, pythonScript);
uart.AddLineHook(x => x.Contains(contains), engine.Hook);
}
