private static string ConvertFileName(string fn)
{
ushort len = Str.GetLength(fn);
Registers.SI = (ushort)(StringPtr.Get(fn) + 1);
Registers.DI = (ushort)(StringPtr.Get(buffer) + 1);
for (ushort i = 0; i < 11; i++)
{
new Inline("mov byte [cs:di], ' '");
Registers.DI++;
}
Registers.DI = (ushort)(StringPtr.Get(buffer) + 1);
for (ushort i = 0; i < len; i++)
{
new Inline("mov al, [cs:si]");
Registers.AH = 0;
Registers.SI++;
char ch = (char)Registers.AX;
if (ch == '.')
{
Registers.DI = (ushort)(StringPtr.Get(buffer) + 9);
}
else
{
new Inline("mov [cs:di], al");
Registers.DI++;
}
}
return(buffer);
}
public static int WriteLine(StringPtr Str)
{
var len = Write(Str);
Write(Environment.NewLine.AsMemory());
return(len);
}
private static IntPtr sub_6F1CA210Hook(StringPtr cheat)
{
try
{
List <string> list = SplitCommandLine(cheat.AsString()).ToList();
if (list.Count >= 2 && list[0].Equals("SCDBG", StringComparison.OrdinalIgnoreCase))
{
switch (list[1].ToUpper())
{
case "FUNCDUMP": HandleFuncDump(list.Skip(2).ToList()); break;
case "GLOBALDUMP": HandleGlobalDump(list.Skip(2).ToList()); break;
case "LOCALDUMP": HandleLocalDump(list.Skip(2).ToList()); break;
case "VARDUMP": HandleVarDump(list.Skip(2).ToList()); break;
case "TEST": HandleTest(list.Skip(2).ToList()); break;
}
}
}
catch (Exception ex)
{
Trace.WriteLine(ex);
}
return(sub_6F1CA210(cheat));
}
private bool ParseCommaOrWhitespace(StringPtr ptr)
{
if (ptr.IsEnd)
{
return(false);
}
if (ptr.IsWhitespace())
{
++ptr;
ptr.AdvanceWhiteSpace();
if (ptr.Char == ',')
{
++ptr;
}
ptr.AdvanceWhiteSpace();
return(true);
}
else if (ptr.Char == ',')
{
++ptr;
ptr.AdvanceWhiteSpace();
return(true);
}
return(false);
}
internal static SvgAngle Parse(StringPtr ptr)
{
var begin = ptr.Index;
ptr.AdvanceNumber();
if (begin == ptr.Index)
{
throw new ArgumentException(nameof(ptr));
}
var value = float.Parse(ptr.Target.Substring(begin, ptr.Index - begin), System.Globalization.CultureInfo.InvariantCulture);
if (ptr.Index != ptr.Target.Length)
{
var unit = ptr.String;
if (unit.StartsWith("deg"))
{
ptr += 3;
return(new SvgAngle(SvgAngleType.Degree, value));
}
if (unit.StartsWith("rad"))
{
ptr += 3;
return(new SvgAngle(SvgAngleType.Radian, value));
}
if (unit.StartsWith("grad"))
{
ptr += 4;
return(new SvgAngle(SvgAngleType.Grade, value));
}
}
return(new SvgAngle(SvgAngleType.Degree, value));
}
public static ushort GetLength(string str1)
{
Registers.SI = StringPtr.Get(str1);
new Inline("mov al, [si]");
new Inline("mov ah, 0");
return(Registers.AX);
}
private void ParseCurveToArgumentSequence(StringPtr ptr, bool abs)
{
var coordinate = ParseCoordinatePair(ptr);
if (coordinate == null)
{
return;
}
this.ParseCommaOrWhitespace(ptr);
var coordinate2 = ParseCoordinatePair(ptr);
this.ParseCommaOrWhitespace(ptr);
var coordinate3 = ParseCoordinatePair(ptr);
this.Segments.Add(SvgPathSegmentCurveToCubicBase.Create(coordinate.Item1, coordinate.Item2, coordinate2.Item1, coordinate2.Item2, coordinate3.Item1, coordinate3.Item2, abs));
this.ParseCommaOrWhitespace(ptr);
if (ptr.IsEnd)
{
return;
}
this.ParseCurveToArgumentSequence(ptr, abs);
}
private void ParseSmoothQuadraticBezierCurveTo(StringPtr ptr)
{
var abs = ptr.Char == 'T';
++ptr;
ptr.AdvanceWhiteSpace();
this.ParseSmoothQuadraticBezierCurveToArgumentSequence(ptr, abs);
}
private void ParseCurveTo(StringPtr ptr)
{
var abs = ptr.Char == 'C';
++ptr;
ptr.AdvanceWhiteSpace();
this.ParseCurveToArgumentSequence(ptr, abs);
}
private void ParseHorizontalLineTo(StringPtr ptr)
{
var abs = ptr.Char == 'H';
++ptr;
ptr.AdvanceWhiteSpace();
this.ParseHorizontalLineToArgumentSequence(ptr, abs);
}
private void ParseQllipticalArc(StringPtr ptr)
{
var abs = ptr.Char == 'A';
++ptr;
ptr.AdvanceWhiteSpace();
this.ParseQllipticalArcArgumentSequence(ptr, abs);
}
private SvgPathSegmentParser(string pathData)
{
this.Segments = new Collection <SvgPathSegment>();
var ptr = new StringPtr(pathData);
ptr.AdvanceWhiteSpace();
this.ParseMoveToDrawToCommandGroups(ptr);
}
/// <summary>
/// Sets the text displayed
/// </summary>
/// <param name="Text"></param>
public void Set(StringPtr Text)
{
lock (Buffer)
{
Buffer = Text;
Dirt |= EDirtFlags.Text;
}
ChangeCallback?.Invoke(this);
}
private void ParseMoveToDrawToCommandGroup(StringPtr ptr)
{
this.ParseMoveTo(ptr);
ptr.AdvanceWhiteSpace();
if (!ptr.IsEnd)
{
this.ParseDrawToCommands(ptr);
}
}
public static bool StartsWith(string str1, ushort str2ptr)
{
Registers.SI = StringPtr.Get(str1);
new Inline("mov cl, [si]");
new Inline("mov ch, 0");
new Inline("inc si");
Registers.DI = str2ptr;
new Inline("rep cmpsb");
return(Flags.E);
}
public CSI_BLOCK(byte?cmdByte, int[] parameters, StringPtr text, int blockStart, int blockEnd, int textStart, bool hasControlChar)
{
CmdByte = cmdByte;
Parameters = parameters;
Text = text;
BlockStart = blockStart;
BlockEnd = blockEnd;
TextStart = textStart;
HasControlChar = hasControlChar;
}
public void Clear()
{
if (DisplayText?.AsMemory() == null || DisplayText?.AsMemory().Length <= 0)
{
return;
}
VirtualTerminal.Terminal.Blit(DisplayText.AsMemory().Length, Position.X, Position.Y);
DisplayText = null;
Dirt |= EDirtFlags.Text;
}
private bool ParseDrawToCommand(StringPtr ptr)
{
switch (ptr.Char)
{
case 'Z':
case 'z':
this.ParseClosePath(ptr);
break;
case 'L':
case 'l':
this.ParseLineTo(ptr);
break;
case 'H':
case 'h':
this.ParseHorizontalLineTo(ptr);
break;
case 'V':
case 'v':
this.ParseVerticalLineTo(ptr);
break;
case 'C':
case 'c':
this.ParseCurveTo(ptr);
break;
case 'S':
case 's':
this.ParseSmoothCurveTo(ptr);
break;
case 'Q':
case 'q':
this.ParseQuadraticBezierCurveTo(ptr);
break;
case 'T':
case 't':
this.ParseSmoothQuadraticBezierCurveTo(ptr);
break;
case 'A':
case 'a':
this.ParseQllipticalArc(ptr);
break;
default:
return(false);
}
return(true);
}
private bool ParseFlag(StringPtr ptr)
{
var flag = ptr.Char == '1';
if (!flag && ptr.Char != '0')
{
throw new ArgumentException("pathData");
}
++ptr;
return(flag);
}
private void ParseSmoothQuadraticBezierCurveToArgumentSequence(StringPtr ptr, bool abs)
{
var coordinate = ParseCoordinatePair(ptr);
this.Segments.Add(SvgPathSegmentCurveToQuadraticSmoothBase.Create(coordinate.Item1, coordinate.Item2, abs));
if (this.ParseCommaOrWhitespace(ptr))
{
this.ParseSmoothQuadraticBezierCurveToArgumentSequence(ptr, abs);
}
}
private void ParseMoveTo(StringPtr ptr)
{
if (char.ToLower(ptr.Char) == 'm')
{
var abs = ptr.Char == 'M';
++ptr;
ptr.AdvanceWhiteSpace();
this.ParseMoveToArgumentSequence(ptr, abs);
return;
}
throw new ArgumentException("pathData");
}
/// <summary>
/// Updates this text within it's terminal and returns a delta change size
/// </summary>
public int Update()
{
if (Disposed == 1)
{
return(0);
}
bool bUpdatedPos = false;
if (0 != (Dirt & EDirtFlags.Position))
{
/*if (Owner.TryGetTarget(out VirtualScreen Screen))
* {
* Position = new CursorPos(Screen.CursorLeft, Screen.CursorTop);
* bUpdatedPos = true;
* Dirt &= ~EDirtFlags.Position;
* }*/
Position = new CursorPos(Terminal.CursorLeft, Terminal.CursorTop);
bUpdatedPos = true;
Dirt &= ~EDirtFlags.Position;
}
if (bUpdatedPos)
{
Terminal.Push_Cursor();
Terminal.Set_Cursor(Position.X, Position.Y);
}
if (0 != (Dirt & EDirtFlags.Text) || bUpdatedPos)
{
/* Figure out which parts we need to reprint */
var Commands = DiffEngine.Compile_Transformations(DisplayText, Buffer);
foreach (TextChunk Command in Commands)
{
/* Translate the commands position (which is relative the this object position) into actual screen buffer coordinates */
var X = Position.X + Command.Offset;
Terminal.Set_Cursor(X % Terminal.Width, Position.Y + (X / Terminal.Width));
Terminal.Output(Command.Text);
}
//ANSI.Write(Buffer.AsMemory());
DisplayText = new string(Buffer.AsMemory().ToArray());
Dirt &= ~EDirtFlags.Text;
}
if (bUpdatedPos)
{
Terminal.Pop_Cursor();
}
return(0);
}
internal static int Output(StringPtr Str)
{
if (RequiresEmulation)
{
return(Emulate(Str));
}
else
{
Console.Write(Str);
return(ANSI.Strip(Str)?.Length ?? 0);
}
}
// Functions to help XBin
public void PushStringPtr(string Text)
{
// Create a Ptr struct for the string
StringPtr Ptr = new StringPtr();
Ptr.FileOffset = BaseStream.Position;
Ptr.RequiredString = Text;
// Push the Ptr to the array.
PtrsToFix.Add(Ptr);
// Write temporary -1
Write(-1);
}
private float?ParseNumber(StringPtr ptr)
{
var begin = ptr.Index;
ptr.AdvanceNumber();
if (begin == ptr.Index)
{
return(null);
}
var numberText = ptr.Target.Substring(begin, ptr.Index - begin);
return(float.Parse(numberText, System.Globalization.CultureInfo.InvariantCulture));
}
internal static bool TryParse(string numberText, out SvgNumber result)
{
var ptr = new StringPtr(numberText);
ptr.AdvanceNumber();
if (ptr.Index != numberText.Length)
{
result = 0.0F;
return(false);
}
result = float.Parse(numberText, System.Globalization.CultureInfo.InvariantCulture);
return(true);
}
internal static bool TryParse(string numberText, float min, float max, out SvgNumber result)
{
var ptr = new StringPtr(numberText);
ptr.AdvanceNumber();
if (ptr.Index != numberText.Length)
{
result = 0.0F;
return(false);
}
result = Math.Min(Math.Max(float.Parse(numberText), min), max);
return(true);
}
public static void Write(string s)
{
Registers.SI = StringPtr.Get(s);
new Inline("cs lodsb");
Registers.AH = 0;
ushort len = Registers.AX;
for (int i = 0; i < len; i++)
{
new Inline("cs lodsb");
Registers.AH = 0x0e;
Registers.BX = 0;
new Inline("int 0x10");
}
}
private void ParseLineToArgumentSequence(StringPtr ptr, bool abs)
{
var coordinate = ParseCoordinatePair(ptr);
if (coordinate == null)
{
return;
}
this.Segments.Add(SvgPathSegmentLineToBase.Create(coordinate.Item1, coordinate.Item2, abs));
if (this.ParseCommaOrWhitespace(ptr))
{
this.ParseLineToArgumentSequence(ptr, abs);
}
}
private void ParseVerticalLineToArgumentSequence(StringPtr ptr, bool abs)
{
var coordinate = ParseCoordinate(ptr);
if (!coordinate.HasValue)
{
return;
}
this.Segments.Add(SvgPathSegmentLineToVerticalBase.Create(coordinate.Value, abs));
if (this.ParseCommaOrWhitespace(ptr))
{
this.ParseVerticalLineToArgumentSequence(ptr, abs);
}
}
public NodeTracker(StringPtr p) { parent = p; }
// This switch follows more or less a DEA to this EBNF
// COMMAND-EBNF := COMMAND
// COMMAND := (!ARGUMENT \s+ (ARGUMENT|\s)*)
// ARGUMENT := COMMAND|FREESTRING|QUOTESTRING
// FREESTRING := [^)]+
// QUOTESTRING := "[<anything but ", \" is ok>]+"
public static ASTNode ParseCommandRequest(string request)
{
ASTCommand root = null;
var comAst = new Stack<ASTCommand>();
BuildStatus build = BuildStatus.ParseCommand;
var strb = new StringBuilder();
var strPtr = new StringPtr(request);
while (!strPtr.End)
{
ASTCommand buildCom;
switch (build)
{
case BuildStatus.ParseCommand:
// Got a command
buildCom = new ASTCommand();
// Consume CommandChar if left over
if (strPtr.Char == CommandChar)
strPtr.Next(CommandChar);
if (root == null) root = buildCom;
else comAst.Peek().Parameter.Add(buildCom);
comAst.Push(buildCom);
build = BuildStatus.SelectParam;
break;
case BuildStatus.SelectParam:
strPtr.SkipSpace();
if (strPtr.End)
build = BuildStatus.End;
else
{
switch (strPtr.Char)
{
case '"':
build = BuildStatus.ParseQuotedString;
break;
case '(':
if (!strPtr.HasNext)
build = BuildStatus.ParseFreeString;
else if (strPtr.IsNext(CommandChar))
{
strPtr.Next('(');
build = BuildStatus.ParseCommand;
}
else
build = BuildStatus.ParseFreeString;
break;
case ')':
if (!comAst.Any())
build = BuildStatus.End;
else
{
comAst.Pop();
if (!comAst.Any())
build = BuildStatus.End;
}
strPtr.Next();
break;
default:
build = BuildStatus.ParseFreeString;
break;
}
}
break;
case BuildStatus.ParseFreeString:
strb.Clear();
var valFreeAst = new ASTValue();
using (strPtr.TrackNode(valFreeAst))
{
for (; !strPtr.End; strPtr.Next())
{
if ((strPtr.Char == '(' && strPtr.HasNext && strPtr.IsNext(CommandChar))
|| strPtr.Char == ')'
|| char.IsWhiteSpace(strPtr.Char))
break;
strb.Append(strPtr.Char);
}
}
valFreeAst.Value = strb.ToString();
buildCom = comAst.Peek();
buildCom.Parameter.Add(valFreeAst);
build = BuildStatus.SelectParam;
break;
case BuildStatus.ParseQuotedString:
strb.Clear();
strPtr.Next('"');
var valQuoAst = new ASTValue();
using (strPtr.TrackNode(valQuoAst))
{
bool escaped = false;
for (; !strPtr.End; strPtr.Next())
{
if (strPtr.Char == '\\') escaped = true;
else if (strPtr.Char == '"')
{
if (escaped) strb.Length--;
else { strPtr.Next(); break; }
escaped = false;
}
else escaped = false;
strb.Append(strPtr.Char);
}
}
valQuoAst.Value = strb.ToString();
buildCom = comAst.Peek();
buildCom.Parameter.Add(valQuoAst);
build = BuildStatus.SelectParam;
break;
case BuildStatus.End:
strPtr.JumpToEnd();
break;
default: throw new InvalidOperationException();
}
}
return root;
}
