public ReadResults ReadString(out JsonString result)
{
result = default;
string actualString = "";
if (!StringReader.CanRead() || StringReader.Peek() != STRING_CHARACTER)
{
return(ReadResults.Failure(JsonCommandError.MalformedJson().WithContext(StringReader)));
}
StringReader.Skip();
bool escaped = false;
while (StringReader.CanRead())
{
char c = StringReader.Read();
if (escaped)
{
if (c == UNICODE_CHARACTER)
{
if (!StringReader.CanRead(4))
{
return(ReadResults.Failure(JsonCommandError.UnterminatedEscapeSequence().WithContext(StringReader)));
}
string unicode = StringReader.Read(4);
if (!short.TryParse(unicode, NumberStyles.HexNumber, NumberFormatInfo.InvariantInfo, out _))
{
return(ReadResults.Failure(JsonCommandError.InvalidUnicodeCharacter(unicode).WithContext(StringReader)));
}
escaped = false;
actualString += c + unicode;
}
else if (ESCAPABLE_CHARACTERS.Contains(c))
{
escaped = false;
actualString += c;
}
else
{
return(ReadResults.Failure(JsonCommandError.InvalidEscapeSequence().WithContext(StringReader)));
}
}
else if (c == ESCAPE_CHARACTER)
{
escaped = true;
actualString += c;
}
else if (c == STRING_CHARACTER)
{
result = new JsonString(actualString);
return(ReadResults.Success());
}
else
{
actualString += c;
}
}
return(ReadResults.Failure(JsonCommandError.UnterminatedString().WithContext(StringReader)));
}
private IList <Function> ParseFunctions(BinaryReaderX br, Xq32Header header, IList <Jump> jumps, IList <Instruction> instructions)
{
var functionStream = Decompress(br.BaseStream, header.table0Offset << 2);
var functions = new BinaryReaderX(functionStream).ReadMultiple <Xq32Function>(header.table0EntryCount);
var result = new List <Function>();
foreach (var function in functions.OrderBy(x => x.instructionOffset))
{
var functionName = _stringReader.Read(function.nameOffset);
var functionInstructions = instructions
.Skip(function.instructionOffset)
.Take(function.instructionEndOffset - function.instructionOffset)
.ToArray();
var functionJumps = jumps
.Skip(function.jumpOffset)
.Take(function.jumpCount)
.ToArray();
var functionUnknowns = new int[] { function.unk1, function.unk2 };
result.Add(new Function(functionName, function.parameterCount, functionJumps, functionInstructions, functionUnknowns));
}
return(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('}'));
}
private ReadResults ReadArrayTag(out INbtTag result)
{
result = default;
ReadResults readResults = Reader.Expect('[');
if (!readResults.Successful)
{
return(readResults);
}
int start = Reader.GetCursor();
char type = Reader.Read();
Reader.Skip();
Reader.SkipWhitespace();
if (!Reader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedValue().WithContext(Reader)));
}
INbtCollectionTag list;
switch (type)
{
case 'B':
list = new ByteArrayNbtTag();
break;
case 'I':
list = new IntegerArrayNbtTag();
break;
case 'L':
list = new LongArrayNbtTag();
break;
default:
Reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidArrayType(type).WithContext(Reader)));
}
readResults = ReadListContents(ref list);
if (readResults.Successful)
{
result = list;
}
return(readResults);
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out HashSet <char> result)
{
result = new HashSet <char>();
int start = reader.GetCursor();
while (!reader.AtEndOfArgument())
{
char c = reader.Read();
if (!Characters.Contains(c) || result.Contains(c))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidSwizzle(Characters).WithContext(reader)));
}
result.Add(c);
}
return(ReadResults.Success());
}
public Line Read()
{
string value;
do
{
value = stringReader.Read();
if (value == null)
{
return(null);
}
index++;
} while (discardMatcher.Match(value));
return(new Line()
{
Value = value, Index = index - 1
});
}
public IList <T> Read()
{
if (xmlReader != null)
{
return(xs.Deserialize(xmlReader) as IList <T>);
}
if (textReader != null)
{
return(xs.Deserialize(textReader) as List <T>);
}
if (stringReader != null)
{
xml = stringReader.Read();
}
using (StringReader r = new StringReader(xml))
return(xs.Deserialize(r) as IList <T>);
}
public TextFileWriterBlock(IStringReader pathReader, Encoding encoding, Boolean isAppending)
{
this.filePathBuilder = new FilePathBuilderBlock(pathReader.Read());
this.encoding = encoding;
this.isAppending = isAppending;
}
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 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());
}
public string GetString(int subType, IStringReader stringReader)
{
string value;
switch (Type)
{
// Integer
case 1:
value = $"{Value}";
break;
// Unsigned Integer
case 2:
if (subType == 0x14 || subType == 0x1E || subType == 0x1F || subType == 0x21)
{
var foundString = stringReader.GetByHash((uint)Value);
if (foundString == null)
{
value = $"{Value}";
break;
}
value = $"\"{foundString}\"";
break;
}
value = $"{Value}";
break;
// Float
case 3:
value = $"{BitConverter.Int32BitsToSingle((int)Value).ToString(CultureInfo.GetCultureInfo("en-gb"))}";
break;
// Execution Context values
case 4:
// 4000+ ?
// Values 3000+ are input parameters to the method
// 2000+ ?
// Values 1000+ are stack values
value = "$";
if (Value >= 1000 && Value <= 1999)
{
value += $"v{Value - 1000}";
}
if (Value >= 2000 && Value <= 2999)
{
value += $"x{Value - 2000}";
}
if (Value >= 3000 && Value <= 3999)
{
value += $"p{Value - 3000}";
}
if (Value >= 4000 && Value <= 4999)
{
value += $"y{Value - 4000}";
}
break;
// String
case 24:
value = $"\"{stringReader.Read(Value)}\"";
break;
// Method Name
case 25:
value = $"\"{stringReader.Read(Value)}\"";
break;
default:
throw new InvalidOperationException($"Unknown type {Type}.");
}
return(value + $"<{Type}>");
}
