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