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; }