private IfCommand ParseIfCommand(ICharReader reader)
{
string left;
if (!TryReadString(reader, out left))
{
return(new IfCommand("", IfOperation.Equals, "", new ParseException("Unable to parse <left>")));
}
string op;
if (!TryReadString(reader, out op))
{
return(new IfCommand(left, IfOperation.Equals, "", new ParseException("Unable to parse <operation>")));
}
IfOperation operation;
if (!TryReadIfOperation(op, out operation))
{
return(new IfCommand(left, IfOperation.Equals, "", new ParseException("Unable to parse <operation>")));
}
string right;
if (TryReadString(reader, out right))
{
return(new IfCommand(left, operation, right));
}
else
{
return(new IfCommand(left, operation, "", new ParseException("Unable to parse <right>")));
}
}
private char?GetUnicodeSymbol(ICharReader charReader)
{
var sb = new StringBuilder(8);
for (var i = 0; i < 4; i++)
{
var c = charReader.Read();
if (!c.HasValue)
{
throw new JsonException("Unterminated string");
}
if (char.IsDigit(c.Value) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
{
sb.Append(c.Value);
}
else
{
throw new JsonException($"Invalid character '{c.Value}' in hexidecimal unicode notation");
}
}
var hexString = sb.ToString();
var sChar = (ushort)(Convert.ToUInt16(hexString.Substring(0, 2), 16) << 8);
sChar += Convert.ToUInt16(hexString.Substring(2, 2), 16);
return(Convert.ToChar(sChar));
}
public static bool TryReadUntilAny(this ICharReader reader, out string result, ISet <char> charset)
{
while (true)
{
if (!reader.HasNext())
{
result = string.Empty;
return(false);
}
var next = reader.PeekNext();
if (!charset.Contains(next))
{
break;
}
reader.ReadNext();
}
var builder = new StringBuilder();
while (reader.HasNext())
{
var next = reader.ReadNext();
if (charset.Contains(next))
{
break;
}
builder.Append(next);
}
result = builder.ToString();
return(true);
}
private JsonValue ParseObject(ICharReader charReader)
{
var members = new List <JsonObjectMember>();
if (!charReader.TrimRead('{'))
{
throw new JsonException("Expected '{' when parsing json object.");
}
var peek = charReader.TrimThenPeek();
if (!peek.HasValue)
{
throw new JsonException("Unterminated object");
}
while (peek.Value != '}')
{
if (members.Any())
{
if (!charReader.TrimRead(','))
{
throw new JsonException("Missing comma separater between array items.");
}
}
members.Add(ParseObjectMember(charReader));
peek = charReader.TrimThenPeek();
if (!peek.HasValue)
{
throw new JsonException("Unterminated object");
}
}
charReader.Read(); // }
return(new JsonObject(members));
}
private SetImageCommand ParseSetImageCommand(ICharReader reader)
{
string path;
if (!TryReadString(reader, out path))
{
return(new SetImageCommand("", 0, 0, new ParseException("Unable to parse <path>")));
}
int x;
if (!TryReadInt(reader, out x))
{
return(new SetImageCommand(path, x, 0, new ParseException("Unable to parse <x>")));
}
int y;
if (!TryReadInt(reader, out y))
{
return(new SetImageCommand(path, x, y, new ParseException("Unable to parse <y>")));
}
return(new SetImageCommand(path, x, y));
}
private SoundCommand ParseSoundCommand(ICharReader reader)
{
string path;
if (!TryReadString(reader, out path))
{
return(new PlaySoundCommand(path, new ParseException("Unable to parse <path>")));
}
if (path.Trim() == "~")
{
return(new StopSoundCommand());
}
int repeats;
if (TryReadInt(reader, out repeats))
{
return(new PlaySoundCommand(path, repeats));
}
else
{
return(new PlaySoundCommand(path));
}
}
public static string ReadUntilAny(this ICharReader reader, ISet <char> charset)
{
while (true)
{
if (!reader.HasNext())
{
return(null);
}
var next = reader.PeekNext();
if (!charset.Contains(next))
{
break;
}
reader.ReadNext();
}
var result = new StringBuilder();
while (reader.HasNext())
{
var next = reader.ReadNext();
if (charset.Contains(next))
{
break;
}
result.Append(next);
}
return(result.ToString());
}
private RandomCommand ParseRandomCommand(ICharReader reader)
{
string variable;
if (!TryReadString(reader, out variable))
{
return(new RandomCommand("", 0, 0, new ParseException("Unable to parse <variable>")));
}
int low;
if (!TryReadInt(reader, out low))
{
return(new RandomCommand(variable, low, 0, new ParseException("Unable to parse <low>")));
}
int high;
if (!TryReadInt(reader, out high))
{
return(new RandomCommand(variable, low, high, new ParseException("Unable to parse <low>")));
}
return(new RandomCommand(variable, low, high));
}
private static void AdvanceWhitespace(ICharReader charReader)
{
var peek = charReader.Peek();
while (peek.HasValue && char.IsWhiteSpace(peek.Value))
{
charReader.Read();
peek = charReader.Peek();
}
}
private GoToCommand ParseGoToCommand(ICharReader reader)
{
string label;
if (!TryReadString(reader, out label))
{
return(new GoToCommand("", new ParseException("Unable to parse <label>")));
}
return(new GoToCommand(label));
}
private DelayCommand ParseDelayCommand(ICharReader reader)
{
int delay;
if (!TryReadInt(reader, out delay))
{
return(new DelayCommand(0, new ParseException("Unable to parse <delay>")));
}
return(new DelayCommand(delay));
}
private ChoiceCommand ParseChoiceCommand(ICharReader reader)
{
var choices = new List <string>();
for (var choice = reader.ReadUntilAny('|'); choice != null; choice = reader.ReadUntilAny('|'))
{
choices.Add(choice);
}
return(new ChoiceCommand(choices));
}
private JsonValue ParseFalse(ICharReader charReader)
{
foreach (var c in _false)
{
if (c != charReader.Read())
{
throw new JsonException($"Unexpected character '{c}' whilst parsing 'false'");
}
}
return(new JsonFalse());
}
private JsonValue ParseNull(ICharReader charReader)
{
foreach (var c in _null)
{
if (c != charReader.Read())
{
throw new JsonException($"Unexpected character '{c}' whilst parsing 'null'");
}
}
return(new JsonNull());
}
private JsonObjectMember ParseObjectMember(ICharReader charReader)
{
var name = ParseString(charReader);
if (!charReader.TrimRead(':'))
{
throw new JsonException("expected ':' after member name.");
}
var value = ParseJsonValue(charReader);
return(new JsonObjectMember(name.Value, value));
}
private static bool TryReadInt(ICharReader reader, out int result)
{
string text;
if (!TryReadString(reader, out text))
{
result = 0;
return(false);
}
return(int.TryParse(text, out result));
}
private JsonValue ParseNumber(ICharReader charReader)
{
var sb = new StringBuilder();
var peek = charReader.Peek();
while (peek.HasValue && Numerics.Contains(peek.Value))
{
sb.Append(charReader.Read());
peek = charReader.Peek();
}
return(new JsonNumber(sb.ToString()));
}
private MusicCommand ParseMusicCommand(ICharReader reader)
{
string path;
if (!TryReadString(reader, out path))
{
return(new PlayMusicCommand(path, new ParseException("Unable to parse <path>")));
}
if (path.Trim() == "~")
{
return(new StopMusicCommand());
}
else
{
return(new PlayMusicCommand(path));
}
}
private JsonString ParseString(ICharReader charReader)
{
var delimiter = charReader.TrimRead();
if (delimiter != '\'' && delimiter != '"')
{
throw new JsonException("Strings must be delimiated with either single or double quotes");
}
var sb = new StringBuilder();
var c = GetNextStringCharacter(charReader, delimiter);
while (c.HasValue)
{
sb.Append(c);
c = GetNextStringCharacter(charReader, delimiter);
}
return(new JsonString(sb.ToString()));
}
private JumpCommand ParseJumpCommand(ICharReader reader)
{
string path;
if (!TryReadString(reader, out path))
{
return(new JumpCommand(path, new ParseException("Unable to parse <path>")));
}
string label;
if (TryReadString(reader, out label))
{
return(new JumpCommand(path, label));
}
else
{
return(new JumpCommand(path));
}
}
private BackgroundLoadCommand ParseBackgroundLoadCommand(ICharReader reader)
{
string path;
if (!TryReadString(reader, out path))
{
return(new BackgroundLoadCommand(path, new ParseException("Unable to parse <path>")));
}
int fadeTime;
if (TryReadInt(reader, out fadeTime))
{
return(new BackgroundLoadCommand(path, fadeTime));
}
else
{
return(new BackgroundLoadCommand(path));
}
}
private char?GetNextStringCharacter(ICharReader charReader, char?delimiter)
{
var c = charReader.Read();
if (!c.HasValue)
{
throw new JsonException("Unterminated string");
}
if (c == delimiter)
{
return(null);
}
if (CharRequiresEscapeInString(c.Value))
{
throw new JsonException($"Unescaped '{c}' in string");
}
if (c != '\\')
{
return(c);
}
c = charReader.Read();
if (!c.HasValue)
{
throw new JsonException("Unterminated string");
}
char fromShortCode;
if (ShortEscapeDecodables.TryGetValue(c.Value, out fromShortCode))
{
return(fromShortCode);
}
if (c == 'u')
{
return(GetUnicodeSymbol(charReader));
}
throw new JsonException($"Unrecognised escape sequence '\\{c}'");
}
private JsonValue ParseArray(ICharReader charReader)
{
charReader.TrimRead(); // [
var items = new List <JsonValue>();
while (charReader.TrimThenPeek() != ']')
{
if (items.Any())
{
if (!charReader.TrimRead(','))
{
throw new JsonException("Missing comma separater between array items.");
}
}
items.Add(ParseJsonValue(charReader));
}
charReader.Read(); // ]
return(new JsonArray(items));
}
private JsonValue ParseJsonValue(ICharReader charReader)
{
var leadingCharacter = charReader.TrimThenPeek();
if (!leadingCharacter.HasValue)
{
throw new JsonException("Unexpected end of stream");
}
var valueType = IdentifyValueType(leadingCharacter.Value);
switch (valueType)
{
case JsonValueType.String:
return(ParseString(charReader));
case JsonValueType.Number:
return(ParseNumber(charReader));
case JsonValueType.Object:
return(ParseObject(charReader));
case JsonValueType.Array:
return(ParseArray(charReader));
case JsonValueType.True:
return(ParseTrue(charReader));
case JsonValueType.False:
return(ParseFalse(charReader));
case JsonValueType.Null:
return(ParseNull(charReader));
case JsonValueType.Unrecognised:
throw new JsonException($"Unexpected character '{leadingCharacter.Value}'");
default:
throw new ArgumentOutOfRangeException(nameof(valueType), valueType, null);
}
}
private GlobalVariableCommand ParseGlobalVariableCommand(ICharReader reader)
{
string left;
if (!TryReadString(reader, out left))
{
return(new SetGlobalVariableCommand("", SetOperation.Add, "", new ParseException("Unable to parse <left>")));
}
string op;
if (!TryReadString(reader, out op))
{
return(new SetGlobalVariableCommand(left, SetOperation.Add, "", new ParseException("Unable to parse <operation>")));
}
if (op.Trim() == "~")
{
return(new ClearGlobalVariablesCommand());
}
SetOperation operation;
if (!TryReadSetOperation(op, out operation))
{
return(new SetGlobalVariableCommand(left, SetOperation.Add, "", new ParseException("Unable to parse <operation>")));
}
string right;
if (TryReadString(reader, out right))
{
return(new SetGlobalVariableCommand(left, operation, right));
}
else
{
return(new SetGlobalVariableCommand(left, operation, "", new ParseException("Unable to parse <right>")));
}
}
private Command ParseTextCommand(ICharReader reader)
{
string text = reader.ReadUntilAny('\n');
if (text == null)
{
return(new TextCommand("", TextOptions.AwaitInput));
}
switch (text[0])
{
case '~':
return(new TextCommand("", TextOptions.None));
case '!':
return(new AwaitInputCommand());
case '@':
return(new TextCommand(text.Substring(1), TextOptions.None));
}
return(new TextCommand(text, TextOptions.AwaitInput));
}
public TokenMatch Read(ICharReader Reader)
{
char input;
int? index;
IState currentState;
StringBuilder sb;
IRule reductionRule;
string lastGoodValue = null;
long lastGoodPosition = 0;
IRule lastGoodRule = null;
TokenMatch result;
if (Reader == null)
{
throw new ArgumentNullException("Reader");
}
sb = new StringBuilder();
currentState = states[0];
while (true)
{
if (Reader.EOF)
{
if (lastGoodPosition != 0)
{
break;
}
throw new Exceptions.EndOfStreamException(Reader.Position);
}
else
{
input = Reader.Read();
index = currentState.GetNextStateIndex(input);
}
if (index == null)
{
if (lastGoodPosition != 0)
{
break;
}
throw new InvalidInputException(Reader.Position, input);
}
sb.Append(input);
currentState = states[index.Value];
reductionRule = currentState.Reductions.FirstOrDefault();
if (reductionRule != null)
{
lastGoodPosition = Reader.Position;
lastGoodRule = reductionRule;
lastGoodValue = sb.ToString();
}
}
Reader.Seek(lastGoodPosition);
result = new TokenMatch();
result.Success = true;
result.Token = new Token(lastGoodRule.Name, lastGoodValue);
result.Tags = lastGoodRule.Tags.ToArray();
return(result);
}
internal Encrypt(ICharReader charReader, ICharWriter charWriter)
{
this.charReader = charReader;
this.charWriter = charWriter;
}
public static bool TrimRead(this ICharReader charReader, char c)
{
AdvanceWhitespace(charReader);
return(charReader.Read(c));
}
public static char?TrimRead(this ICharReader charReader)
{
AdvanceWhitespace(charReader);
return(charReader.Read());
}
