public static DiffRange Parse(IStringReader reader)
{
var range = new DiffRange();
reader.Skip("@@");
reader.SkipWhitespace();
reader.Skip('-');
range.LeftFrom = reader.ReadInt();
if (reader.Skip(','))
{
range.LeftTo = range.LeftFrom + reader.ReadInt();
}
else
{
range.LeftTo = range.LeftFrom;
}
reader.SkipWhitespace();
reader.Skip('+');
range.RightFrom = reader.ReadInt();
if (reader.Skip(','))
{
range.RightTo = range.RightFrom + reader.ReadInt();
}
else
{
range.RightTo = range.RightFrom;
}
reader.SkipWhitespace();
reader.Skip("@@");
return(range);
}
internal static IEnumerable <FileStatus> ParseStatus(IStringReader reader)
{
reader.SkipWhitespace();
while (!reader.Done)
{
var subReader = reader.ReadLine().AsReader();
string status = subReader.ReadUntilWhitespace().Trim();
string path = subReader.ReadLine().Trim();
yield return(new FileStatus(path, ConvertStatus(status)));
reader.SkipWhitespace();
}
}
public ReadResults Parse(out ICoordinates result)
{
result = default;
ReadResults readResults = ReadDouble(out double left);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = ReadDouble(out double up);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = ReadDouble(out double forwards);
if (readResults.Successful)
{
result = new LocalCoordinates(left, up, forwards);
}
return(readResults);
}
internal static void ParseSummary(IStringReader reader, ChangeSetDetail detail)
{
reader.SkipWhitespace();
while (!reader.Done)
{
string line = reader.ReadLine();
if (ParserHelpers.IsSingleNewLine(line))
{
break;
}
else if (line.Contains('\t'))
{
// n n path
string[] parts = line.Split('\t');
int insertions;
Int32.TryParse(parts[0], out insertions);
int deletions;
Int32.TryParse(parts[1], out deletions);
string path = parts[2].TrimEnd();
detail.Files[path] = new FileInfo {
Insertions = insertions,
Deletions = deletions,
Binary = parts[0] == "-" && parts[1] == "-"
};
}
else
{
// n files changed, n insertions(+), n deletions(-)
ParserHelpers.ParseSummaryFooter(line, detail);
}
}
}
public ReadResults ReadValue(out INbtTag result)
{
result = default;
Reader.SkipWhitespace();
if (!Reader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedValue().WithContext(Reader)));
}
char c = Reader.Peek();
if (c == '{')
{
return(ReadCompound(out result));
}
if (c == '[')
{
return(ReadList(out result));
}
return(ReadTypedValue(out result));
}
private static ReadResults ReadScores(EntitySelectorParser parser, IStringReader reader)
{
ReadResults readResults = reader.Expect('{');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
while (reader.CanRead() && reader.Peek() != '}')
{
reader.SkipWhitespace();
readResults = reader.ReadUnquotedString(out _);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.Expect('=');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = new RangeParser <int>(reader).Read(int.TryParse, CommandError.InvalidInteger, int.MinValue, int.MaxValue, false, out Range <int> range);
if (!readResults.Successful)
{
return(readResults);
}
parser.AddArgument(new ParsedArgument <Range <int> >(range, false));
reader.SkipWhitespace();
if (reader.CanRead())
{
char c = reader.Read();
if (c == ',')
{
continue;
}
if (c == '}')
{
return(ReadResults.Success());
}
}
return(ReadResults.Failure(CommandError.ExpectedCharacter('}').WithContext(reader)));
}
reader.SkipWhitespace();
return(reader.Expect('}'));
}
public ReadResults ParseInteger(out ICoordinates result)
{
result = default;
WorldCoordinateParser worldCoordinateParser = new WorldCoordinateParser(StringReader, UseBedrock);
ReadResults readResults = worldCoordinateParser.ReadInteger(out WorldCoordinate x);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = worldCoordinateParser.ReadInteger(out WorldCoordinate y);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = worldCoordinateParser.ReadInteger(out WorldCoordinate z);
if (readResults.Successful)
{
result = new WorldCoordinates(x, y, z);
}
return(readResults);
}
internal static ChangeSet ParseCommit(IStringReader reader)
{
// commit hash
reader.ReadUntilWhitespace();
reader.SkipWhitespace();
string id = reader.ReadUntilWhitespace();
// Merges will have (from hash) so we're skipping that
reader.ReadLine();
string author = null;
string email = null;
string date = null;
while (!reader.Done)
{
string line = reader.ReadLine();
if (ParserHelpers.IsSingleNewLine(line))
{
break;
}
var subReader = line.AsReader();
string key = subReader.ReadUntil(':');
// Skip :
subReader.Skip();
subReader.SkipWhitespace();
string value = subReader.ReadToEnd().Trim();
if (key.Equals("Author", StringComparison.OrdinalIgnoreCase))
{
// Author <email>
var authorReader = value.AsReader();
author = authorReader.ReadUntil('<').Trim();
authorReader.Skip();
email = authorReader.ReadUntil('>');
}
else if (key.Equals("Date", StringComparison.OrdinalIgnoreCase))
{
date = value;
}
}
var messageBuilder = new StringBuilder();
while (!reader.Done)
{
string line = reader.ReadLine();
if (ParserHelpers.IsSingleNewLine(line))
{
break;
}
messageBuilder.Append(line);
}
string message = messageBuilder.ToString().Trim();
return(new ChangeSet(id, author, email, message, DateTimeOffset.ParseExact(date, "ddd MMM d HH:mm:ss yyyy zzz", CultureInfo.InvariantCulture)));
}
public static DiffRange Parse(IStringReader reader)
{
var range = new DiffRange();
reader.Skip("@@");
reader.SkipWhitespace();
reader.Skip('-');
range.LeftFrom = reader.ReadInt();
if (reader.Skip(','))
{
range.LeftTo = range.LeftFrom + reader.ReadInt();
}
else
{
range.LeftTo = range.LeftFrom;
}
reader.SkipWhitespace();
reader.Skip('+');
range.RightFrom = reader.ReadInt();
if (reader.Skip(','))
{
range.RightTo = range.RightFrom + reader.ReadInt();
}
else
{
range.RightTo = range.RightFrom;
}
reader.SkipWhitespace();
reader.Skip("@@");
return range;
}
internal static void ParseSummary(IStringReader reader, ChangeSetDetail detail)
{
reader.SkipWhitespace();
while (!reader.Done)
{
string line = reader.ReadLine();
if (ParserHelpers.IsSingleNewLine(line))
{
break;
}
else if (line.Contains('\t'))
{
// n n path
string[] parts = line.Split('\t');
int insertions;
Int32.TryParse(parts[0], out insertions);
int deletions;
Int32.TryParse(parts[1], out deletions);
string path = parts[2].TrimEnd();
detail.Files[path] = new FileInfo
{
Insertions = insertions,
Deletions = deletions,
Binary = parts[0] == "-" && parts[1] == "-"
};
}
else
{
// n files changed, n insertions(+), n deletions(-)
ParserHelpers.ParseSummaryFooter(line, detail);
}
}
}
internal static IEnumerable<FileStatus> ParseStatus(IStringReader reader)
{
reader.SkipWhitespace();
while (!reader.Done)
{
var subReader = reader.ReadLine().AsReader();
string status = subReader.ReadUntilWhitespace().Trim();
string path = subReader.ReadLine().Trim();
yield return new FileStatus(path, ConvertStatus(status));
reader.SkipWhitespace();
}
}
internal static ChangeSet ParseCommit(IStringReader reader)
{
// commit hash
reader.ReadUntilWhitespace();
reader.SkipWhitespace();
string id = reader.ReadUntilWhitespace();
// Merges will have (from hash) so we're skipping that
reader.ReadLine();
string author = null;
string email = null;
string date = null;
while (!reader.Done)
{
string line = reader.ReadLine();
if (ParserHelpers.IsSingleNewLine(line))
{
break;
}
var subReader = line.AsReader();
string key = subReader.ReadUntil(':');
// Skip :
subReader.Skip();
subReader.SkipWhitespace();
string value = subReader.ReadToEnd().Trim();
if (key.Equals("Author", StringComparison.OrdinalIgnoreCase))
{
// Author <email>
var authorReader = value.AsReader();
author = authorReader.ReadUntil('<').Trim();
authorReader.Skip();
email = authorReader.ReadUntil('>');
}
else if (key.Equals("Date", StringComparison.OrdinalIgnoreCase))
{
date = value;
}
}
var messageBuilder = new StringBuilder();
while (!reader.Done)
{
string line = reader.ReadLine();
if (ParserHelpers.IsSingleNewLine(line))
{
break;
}
messageBuilder.Append(line);
}
string message = messageBuilder.ToString();
return new ChangeSet(id, author, email, message, DateTimeOffset.ParseExact(date, "ddd MMM d HH:mm:ss yyyy zzz", CultureInfo.InvariantCulture));
}
private static ReadResults ReadAdvancements(EntitySelectorParser parser, IStringReader reader)
{
ReadResults readResults = reader.Expect('{');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
while (reader.CanRead() && reader.Peek() != '}')
{
reader.SkipWhitespace();
readResults = ResourceLocation.TryRead(reader, out ResourceLocation advancement);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.Expect('=');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
if (reader.CanRead() && reader.Peek() == '{')
{
reader.Skip();
reader.SkipWhitespace();
while (reader.CanRead() && reader.Peek() != '}')
{
reader.SkipWhitespace();
readResults = reader.ReadUnquotedString(out _);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.Expect('=');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.ReadBoolean(out _);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
if (reader.CanRead())
{
char c = reader.Read();
if (c == ',')
{
continue;
}
if (c == '}')
{
break;
}
}
}
}
else
{
readResults = reader.ReadBoolean(out _);
if (!readResults.Successful)
{
return(readResults);
}
}
parser.AddArgument(new ParsedArgument <Advancement>(new Advancement(advancement), false));
reader.SkipWhitespace();
if (reader.CanRead())
{
char c = reader.Read();
if (c == ',')
{
continue;
}
if (c == '}')
{
return(ReadResults.Success());
}
}
return(ReadResults.Failure(CommandError.ExpectedCharacter('}').WithContext(reader)));
}
reader.SkipWhitespace();
return(reader.Expect('}'));
}
private ReadResults ReadBlockStates(out Dictionary <string, string> result)
{
result = new Dictionary <string, string>();
ReadResults readResults = StringReader.Expect('[');
if (!readResults.Successful)
{
return(readResults);
}
StringReader.SkipWhitespace();
while (StringReader.CanRead() && StringReader.Peek() != ']')
{
StringReader.SkipWhitespace();
int start = StringReader.GetCursor();
readResults = StringReader.ReadString(out string property);
if (!readResults.Successful)
{
return(readResults);
}
if (result.ContainsKey(property))
{
StringReader.SetCursor(start);
return(ReadResults.Failure(CommandError.DuplicateBlockProperty(Block, property).WithContext(StringReader)));
}
if (!IsTag && !Resources.Blocks.ContainsProperty(Block, property))
{
StringReader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownBlockProperty(Block, property).WithContext(StringReader)));
}
StringReader.SkipWhitespace();
start = StringReader.GetCursor();
if (!StringReader.CanRead() || StringReader.Peek() != '=')
{
return(ReadResults.Failure(CommandError.ExpectedValueForBlockProperty(Block, property)));
}
StringReader.Skip();
StringReader.SkipWhitespace();
readResults = StringReader.ReadString(out string value);
if (!readResults.Successful)
{
return(readResults);
}
if (!IsTag && !Resources.Blocks.PropertyContainsValue(Block, property, value))
{
StringReader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownBlockPropertyValue(Block, property, value).WithContext(StringReader)));
}
result.Add(property, value);
StringReader.SkipWhitespace();
if (StringReader.CanRead() && StringReader.Peek() == ',')
{
StringReader.Skip();
continue;
}
break;
}
if (!StringReader.CanRead() || StringReader.Peek() != ']')
{
return(ReadResults.Failure(CommandError.UnclosedBlockStateProperties().WithContext(StringReader)));
}
StringReader.Skip();
return(ReadResults.Success());
}
private ReadResults ParseSelector()
{
if (!Reader.CanRead())
{
Reader.SetCursor(Start);
return(ReadResults.Failure(CommandError.MissingSelectorType().WithContext(Reader)));
}
int currentPosition = Reader.GetCursor();
char c = Reader.Read();
switch (c)
{
case 'p':
MaxResults = 1;
IncludesEntities = false;
IsSelf = false;
SelectorType = SelectorType.NearestPlayer;
TypeLimited = true;
Sorted = false;
break;
case 'a':
MaxResults = int.MaxValue;
IncludesEntities = false;
IsSelf = false;
SelectorType = SelectorType.AllPlayers;
TypeLimited = true;
Sorted = false;
break;
case 'r':
MaxResults = 1;
IncludesEntities = false;
IsSelf = false;
SelectorType = SelectorType.RandomPlayer;
TypeLimited = true;
Sorted = false;
break;
case 's':
MaxResults = 1;
IncludesEntities = false;
IsSelf = true;
SelectorType = SelectorType.Self;
TypeLimited = false;
Sorted = true;
break;
case 'e':
MaxResults = int.MaxValue;
IncludesEntities = true;
IsSelf = false;
SelectorType = SelectorType.AllEntities;
TypeLimited = false;
Sorted = false;
break;
default:
Reader.SetCursor(currentPosition);
return(ReadResults.Failure(CommandError.UnknownSelectorType(c).WithContext(Reader)));
}
if (UseBedrock)
{
currentPosition = Reader.GetCursor();
Reader.SkipWhitespace();
if (!Reader.CanRead() || Reader.Peek() != '[')
{
Reader.SetCursor(currentPosition);
}
}
if (Reader.CanRead() && Reader.Peek() == '[')
{
Reader.Skip();
ReadResults readResults = ParseOptions();
if (!readResults.Successful)
{
return(readResults);
}
}
return(ReadResults.Success());
}
