public Escape(Escape from)
{
Sequence = from.Sequence;
this.State = from.State;
this.BytesInCurrentBuffer = from.BytesInCurrentBuffer;
this.TotalBytes = from.TotalBytes;
this.ErrorMessage = from.ErrorMessage;
}
private static TerminalSequence ConsumeEscapeSequence(XTermInputBuffer stream)
{
stream.PushState();
var next = stream.Read();
switch (next)
{
case '[':
return(ConsumeCSI(stream));
case ']':
return(ConsumeOSC(stream));
case 'P':
return(ConsumeDeviceControlStringSequence(stream));
case '#':
return(ConsumeCharacterSize(stream));
case ' ':
return(ConsumeCompliance(stream));
case '%':
return(ConsumeUnicode(stream));
case '(':
case ')':
case '*':
case '+':
case '-':
case '.':
case '/':
return(ConsumeCharacterSet(next, stream));
case 'Y':
var vt52mc = new Vt52MoveCursorSequence
{
Row = stream.ReadRaw() - ' ',
Column = stream.ReadRaw() - ' '
};
stream.Commit();
System.Diagnostics.Debug.WriteLine(vt52mc.ToString());
return(vt52mc);
default:
var esc = new EscapeSequence
{
Command = next.ToString()
};
stream.Commit();
//System.Diagnostics.Debug.WriteLine(esc.ToString());
return(esc);
}
}
private static void PrintProperties(Printer printer)
{
string FormatPropertyValue(object obj)
{
var sb = new StringBuilder();
if (obj != null)
{
sb.Append(obj);
}
if (obj is Array array)
{
sb.AppendLine();
for (var i = 0; i < array.Length; i++)
{
sb.Append(" [");
sb.Append(i);
sb.Append("]: ");
sb.Append(array.GetValue(i));
if (i < array.Length - 1)
{
sb.AppendLine();
}
}
}
return(sb.ToString());
}
var document = new Document
{
Commands = new List <ICommand>()
};
foreach (var property in printer.Device.GetType().GetProperties())
{
document.Commands.Add(new Line
{
Text = $"{EscapeSequence.Bold()}{property.Name}: {EscapeSequence.Normal}{FormatPropertyValue(property.GetValue(printer.Device))}"
});
}
document.Commands.Add(new FeedAndPaperCut());
printer.PrintReceipt(document);
}
public void TestAllUnicodeEscapeCharacters()
{
Span <char> storage = stackalloc char[5];
storage[0] = 'u';
Span <char> innerStorage = storage.Slice(1);
ReadOnlySpan <char> format = "X4";
for (int i = 0; i <= char.MaxValue; i++)
{
i.TryFormat(innerStorage, out var charsWritten, format);
Assert.Equal((char)i, EscapeSequence.EscapeChar('u', storage, 1, out var adj));
;
}
}
public void TestVariableLengthUnicodeEscapeCharacters()
{
Span <char> storage = stackalloc char[5];
storage[0] = 'x';
Span <char> innerStorage = storage.Slice(1);
ReadOnlySpan <char> format = "X";
for (int i = 0; i <= char.MaxValue; i++)
{
i.TryFormat(innerStorage, out var charsWritten, format);
Span <char> writeStorage = storage.Slice(0, charsWritten + 1);
Assert.Equal((char)i, EscapeSequence.EscapeChar('x', writeStorage, 1, out var adj));
Assert.Equal(charsWritten, adj);
;
}
}
private static void PrintProperties(Printer printer)
{
var lines = new List <Line>();
var t = printer.Device.GetType();
var p = t.GetProperties();
foreach (var propertyInfo in p)
{
lines.Add(new Line
{
Alignment = Alignment.Left,
Text = $"{EscapeSequence.Bold()}{propertyInfo.Name}: {EscapeSequence.Normal}{Format(propertyInfo.GetValue(printer.Device))}",
CharactersPerLine = 56
});
}
printer.ExecuteAll(lines);
printer.Execute(new FeedAndPaperCut());
}
public void TestAllInvalidEscapesFail()
{
char[] valid = new char[]
{
'\'', '\"', '\\',
'0', 'a', 'b', 'f', 'n',
'r', 't', 'v',
'u', 'x', 'U',
};
char i = (char)0;
// Don't want to N^2 for all characters
// Just ones we know are in ASCII
for (; i < 256; i++)
{
if (valid.Contains(i))
{
continue;
}
Assert.Throws <UnrecognizedEscapeException>(() =>
{
EscapeSequence.EscapeChar(i, ReadOnlySpan <char> .Empty, 0, out var _);
});
}
for (; i < char.MaxValue; i++)
{
Assert.Throws <UnrecognizedEscapeException>(() =>
{
EscapeSequence.EscapeChar(i, ReadOnlySpan <char> .Empty, 0, out var _);
});
}
// Handle max value
Assert.Throws <UnrecognizedEscapeException>(() =>
{
EscapeSequence.EscapeChar(i, ReadOnlySpan <char> .Empty, 0, out var _);
});
}
public void TestSurragePairEscapeSequenceThrows()
{
Assert.Throws <UnsupportedSurrogatePairEscapeException>(() => EscapeSequence.EscapeChar('U', "U12345678", 1, out var _));
}
public void TestInvalidVariableLengthUnicodeEscapeSequenceThrows()
{
Assert.Throws <UnrecognizedEscapeException>(() => EscapeSequence.EscapeChar('x', "x-", 1, out var adj));
}
public void TestTooShortVariableLengthUnicodeEscapeSequenceThrows()
{
Assert.Throws <OutOfCharactersException>(() => EscapeSequence.EscapeChar('x', "x", 1, out var adj));
}
public void TestTooShortUnicodeEscapeSequenceThrows()
{
Assert.Throws <OutOfCharactersException>(() => EscapeSequence.EscapeChar('u', "u123", 1, out var adj));
}
public void TestInvalidUnicodeEscapeSequenceThrows()
{
Assert.Throws <UnrecognizedEscapeException>(() => EscapeSequence.EscapeChar('u', "u123-", 1, out var adj));
}
public void TestPrimaryEscapeSequencesWork(char input, char output)
{
Assert.Equal(output, EscapeSequence.EscapeChar(input, ReadOnlySpan <char> .Empty, 0, out var _));
}
public void Reset()
{
Sequence = EscapeSequence.None;
this.State = EscapeState.Begin;
this.BytesInCurrentBuffer = 0;
this.TotalBytes = 0;
this.ErrorMessage = null;
}
public void TestInvalidUnicodeEscape()
{
Assert.Throws <UnrecognizedEscapeException>(() => EscapeSequence.EscapeUnicodeChar('n', "", 0, out var o));
}
public void TestNormalAdjustment()
{
EscapeSequence.EscapeChar('a', ReadOnlySpan <char> .Empty, 0, out var adj);
Assert.Equal(0, adj);
}
public void TestUnicodeAdjustment()
{
EscapeSequence.EscapeChar('u', "u1234", 1, out var adj);
Assert.Equal(4, adj);
}
