/// handles data in title, textarea etc internal override void Read(Tokeniser t, CharacterReader r) { switch (r.Current()) { case '&': t.AdvanceTransition(TokeniserState.CharacterReferenceInRcdata); break; case '<': t.AdvanceTransition(TokeniserState.RcdataLessthanSign); break; case TokeniserState.nullChar: t.Error(this); r.Advance(); t.Emit(TokeniserState.replacementChar); break; case TokeniserState.eof: t.Emit(new Token.EOF()); break; default: string data = r.ConsumeToAny('&', '<', TokeniserState.nullChar); t.Emit(data); break; } }
// in data state, gather characters until a character reference or tag is found internal override void Read(Tokeniser t, CharacterReader r) { switch (r.Current()) { case '&': t.AdvanceTransition(TokeniserState.CharacterReferenceInData); break; case '<': t.AdvanceTransition(TokeniserState.TagOpen); break; case TokeniserState.nullChar: t.Error(this); // NOT replacement character (oddly?) t.Emit(r.Consume()); break; case TokeniserState.eof: t.Emit(new Token.EOF()); break; default: string data = r.ConsumeToAny('&', '<', TokeniserState.nullChar); t.Emit(data); break; } }
public void consumeToString() { CharacterReader r = new CharacterReader("One Two Two Four"); Assert.AreEqual("One ", r.ConsumeTo("Two")); Assert.AreEqual('T', r.Consume()); Assert.AreEqual("wo ", r.ConsumeTo("Two")); Assert.AreEqual('T', r.Consume()); Assert.AreEqual("wo Four", r.ConsumeTo("Qux")); }
/// <summary> /// Asynchronously reads the JSON value (array, object, or primitive value) from this <see cref="StreamReaderWithResizableBuffer"/>, with a help of given <see cref="CharacterReader"/>. /// Tries to keep the buffer of this stream as little as possible, and allocating as little as possible any other extra objects than created JSON objects (currently parsing a <see cref="Double"/> needs to allocate string). /// </summary> /// <param name="stream">This <see cref="StreamReaderWithResizableBuffer"/>.</param> /// <param name="reader">The <see cref="CharacterReader"/> used to read characters from this <see cref="StreamReaderWithResizableBuffer"/>.</param> /// <returns>A task which will contain deserialized <see cref="JToken"/> on its completion.</returns> /// <exception cref="NullReferenceException">If this <see cref="StreamReaderWithResizableBuffer"/> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">If <paramref name="reader"/> is <c>null</c>.</exception> public static ValueTask <JToken> ReadJSONTTokenAsync( this StreamReaderWithResizableBuffer stream, CharacterReader reader ) { return(PerformReadJSONTTokenAsync( ArgumentValidator.ValidateNotNullReference(stream), ArgumentValidator.ValidateNotNull(nameof(reader), reader) )); }
private static (State, ISyntax) ParseNext(ref CharacterReader r) { r.SkipWhitespace(); if (r.End) { return(State.End, null); } return(ParseStart(ref r)); }
public void Fails_With_Leading_Whitespace() { var target = new PropertyParser(); var reader = new CharacterReader(" Foo"); var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader)); Assert.Equal(0, ex.Column); Assert.Equal("Unexpected ' '.", ex.Message); }
public void Fails_With_Trailing_Junk() { var target = new PropertyParser(); var reader = new CharacterReader("Foo%"); var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader)); Assert.Equal(3, ex.Column); Assert.Equal("Unexpected '%'.", ex.Message); }
public void Fails_With_Invalid_Property_Name_After_Owner() { var target = new PropertyParser(); var reader = new CharacterReader("Foo.123"); var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader)); Assert.Equal(4, ex.Column); Assert.Equal("Unexpected '1'.", ex.Message); }
public void Fails_With_Whitespace_Between_Owner_And_Name() { var target = new PropertyParser(); var reader = new CharacterReader("Foo. Bar"); var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader)); Assert.Equal(4, ex.Column); Assert.Equal("Unexpected ' '.", ex.Message); }
public void Fails_With_Too_Many_Namespaces() { var target = new PropertyParser(); var reader = new CharacterReader("foo:bar:Baz"); var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader)); Assert.Equal(8, ex.Column); Assert.Equal("Unexpected ':'.", ex.Message); }
public void Fails_With_Parens_And_Namespace_But_No_Owner() { var target = new PropertyParser(); var reader = new CharacterReader("(foo:Bar)"); var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader)); Assert.Equal(1, ex.Column); Assert.Equal("Expected property owner.", ex.Message); }
public void Fails_With_Unexpected_Close_Parens() { var target = new PropertyParser(); var reader = new CharacterReader("Foo.Bar)"); var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader)); Assert.Equal(7, ex.Column); Assert.Equal("Unexpected ')'.", ex.Message); }
public void UpdateGeneral() { if (characterReader == null) { characterReader = FindObjectOfType <GameManager>().GetComponent <GameManager>().characterReader; } currentMonster = menu.currentMonster; nameText.text = currentMonster.Name; lifeText.text = currentMonster.currentHP + "/" + currentMonster.GetMaxHP(); if ((sprite = Resources.Load("Image/character/" + currentMonster.Name, typeof(Sprite)) as Sprite) != null) { characterImg.sprite = sprite; } else { int lv = currentMonster.GetLevel(); while ((sprite = Resources.Load("Image/character/" + currentMonster.Name + lv, typeof(Sprite)) as Sprite) == null && lv > 1) { lv--; } if ((sprite = Resources.Load("Image/character/" + currentMonster.Name + lv, typeof(Sprite)) as Sprite) != null) { characterImg.sprite = sprite; } } skill = characterReader.GetMonsterSkillUI(currentMonster.monsterType.ToString(), 1); if (skill != null) { skillIcon1.sprite = skill.sprite; } skill = characterReader.GetMonsterSkillUI(currentMonster.monsterType.ToString(), currentMonster.GetEquippedSkill()); if (skill != null) { if (currentMonster.GetLevel() >= 3) { skillIcon2.sprite = skill.sprite; } else { skillIcon2.sprite = Resources.Load("UI/skill/NoSkill", typeof(Sprite)) as Sprite; } } if (currentMonster.monsterType == MonsterType.boss) { dismissBtn.gameObject.SetActive(false); } else { dismissBtn.gameObject.SetActive(true); } }
public void test_EmptyWordList() { //arrange Stream stream = new FileStream("EmptyTxt.txt", FileMode.Open); //act CharacterReader cr = new CharacterReader(stream); //assert CollectionAssert.AreEqual(null, cr.MyListOfWords); }
public void Parses_Owner_And_Name() { var target = new PropertyParser(); var reader = new CharacterReader("Foo.Bar"); var(ns, owner, name) = target.Parse(reader); Assert.Null(ns); Assert.Equal("Foo", owner); Assert.Equal("Bar", name); }
private static State ParseRelativeSource(ref CharacterReader r, List <INode> nodes) { var mode = r.ParseIdentifier(); if (mode.SequenceEqual("self".AsSpan())) { nodes.Add(new SelfNode()); } else if (mode.SequenceEqual("parent".AsSpan())) { string ancestorNamespace = null; string ancestorType = null; var ancestorLevel = 0; if (PeekOpenBracket(ref r)) { var args = r.ParseArguments('[', ']', ';'); if (args.Count > 2 || args.Count == 0) { throw new ExpressionParseException(r.Position, "Too many arguments in RelativeSource syntax sugar"); } else if (args.Count == 1) { if (int.TryParse(args[0], out int level)) { ancestorType = null; ancestorLevel = level; } else { var reader = new CharacterReader(args[0].AsSpan()); (ancestorNamespace, ancestorType) = ParseTypeName(ref reader); } } else { var reader = new CharacterReader(args[0].AsSpan()); (ancestorNamespace, ancestorType) = ParseTypeName(ref reader); ancestorLevel = int.Parse(args[1]); } } nodes.Add(new AncestorNode { Namespace = ancestorNamespace, TypeName = ancestorType, Level = ancestorLevel }); } else { throw new ExpressionParseException(r.Position, "Unknown RelativeSource mode."); } return(State.AfterMember); }
public void Parses_Owner_And_Name_With_Parentheses() { var target = new PropertyParser(); var reader = new CharacterReader("(Foo.Bar)".AsSpan()); var(ns, owner, name) = target.Parse(reader); Assert.Null(ns); Assert.Equal("Foo", owner); Assert.Equal("Bar", name); }
private static void Expect(ref CharacterReader r, char c) { if (r.End) { throw new ExpressionParseException(r.Position, $"Expected '{c}', got end of selector."); } else if (!r.TakeIf(')')) { throw new ExpressionParseException(r.Position, $"Expected '{c}', got '{r.Peek}'."); } }
public void Parses_Namespace_Owner_And_Name_With_Parentheses() { var target = new PropertyParser(); var reader = new CharacterReader("(foo:Bar.Baz)".AsSpan()); var(ns, owner, name) = target.Parse(reader); Assert.Equal("foo", ns); Assert.Equal("Bar", owner); Assert.Equal("Baz", name); }
public void MatchesAny() { char[] scan = { ' ', '\n', '\t' }; CharacterReader r = new CharacterReader("One\nTwo\tThree"); Assert.IsFalse(r.MatchesAny(scan)); Assert.AreEqual("One", r.ConsumeToAny(scan)); Assert.IsTrue(r.MatchesAny(scan)); Assert.AreEqual('\n', r.Consume()); Assert.IsFalse(r.MatchesAny(scan)); }
public void ConsumeToChar() { CharacterReader r = new CharacterReader("One Two Three"); Assert.AreEqual("One ", r.ConsumeTo('T')); Assert.AreEqual("", r.ConsumeTo('T')); // on Two Assert.AreEqual('T', r.Consume()); Assert.AreEqual("wo ", r.ConsumeTo('T')); Assert.AreEqual('T', r.Consume()); Assert.AreEqual("hree", r.ConsumeTo('T')); // consume to end }
public (ExpressionNode Node, SourceMode Mode) Parse(ref CharacterReader r) { var nodes = new List <ExpressionNode>(); var state = State.Start; var mode = SourceMode.Data; while (!r.End && state != State.End) { switch (state) { case State.Start: state = ParseStart(ref r, nodes); break; case State.AfterMember: state = ParseAfterMember(ref r, nodes); break; case State.BeforeMember: state = ParseBeforeMember(ref r, nodes); break; case State.AttachedProperty: state = ParseAttachedProperty(ref r, nodes); break; case State.Indexer: state = ParseIndexer(ref r, nodes); break; case State.ElementName: state = ParseElementName(ref r, nodes); mode = SourceMode.Control; break; case State.RelativeSource: state = ParseRelativeSource(ref r, nodes); mode = SourceMode.Control; break; } } if (state == State.BeforeMember) { throw new ExpressionParseException(r.Position, "Unexpected end of expression."); } for (int n = 0; n < nodes.Count - 1; ++n) { nodes[n].Next = nodes[n + 1]; } return(nodes.FirstOrDefault(), mode); }
public void Parses_Name() { var target = new PropertyParser(); var reader = new CharacterReader("Foo".AsSpan()); var(ns, owner, name) = target.Parse(reader); Assert.Null(ns); Assert.Null(owner); Assert.Equal("Foo", name); }
public static (List <INode> Nodes, SourceMode Mode) Parse(ref CharacterReader r) { var nodes = new List <INode>(); var state = State.Start; var mode = SourceMode.Data; while (!r.End && state != State.End) { switch (state) { case State.Start: state = ParseStart(ref r, nodes); break; case State.AfterMember: state = ParseAfterMember(ref r, nodes); break; case State.BeforeMember: state = ParseBeforeMember(ref r, nodes); break; case State.AttachedProperty: state = ParseAttachedProperty(ref r, nodes); break; case State.Indexer: state = ParseIndexer(ref r, nodes); break; case State.TypeCast: state = ParseTypeCast(ref r, nodes); break; case State.ElementName: state = ParseElementName(ref r, nodes); mode = SourceMode.Control; break; case State.RelativeSource: state = ParseRelativeSource(ref r, nodes); mode = SourceMode.Control; break; } } if (state == State.BeforeMember) { throw new ExpressionParseException(r.Position, "Unexpected end of expression."); } return(nodes, mode); }
public void TestTryReadTo(bool expectedReturn, string expectedString, string expectedRest, string text, char readTo, int skip) { var reader = new CharacterReader(text); reader.Skip(skip); Assert.AreEqual(expectedReturn, reader.TryReadTo(readTo, out string str)); Assert.AreEqual(expectedString, str); reader.TryReadString(1000, out string rest); Assert.AreEqual(expectedRest, rest); }
public void NextIndexOfString() { string @in = "One Two something Two Three Four"; CharacterReader r = new CharacterReader(@in); Assert.AreEqual(-1, r.NextIndexOf("Foo")); Assert.AreEqual(4, r.NextIndexOf("Two")); Assert.AreEqual("One Two ", r.ConsumeTo("something")); Assert.AreEqual(10, r.NextIndexOf("Two")); Assert.AreEqual("something Two Three Four", r.ConsumeToEnd()); Assert.AreEqual(-1, r.NextIndexOf("Two")); }
public void ConsumeToAny() { CharacterReader r = new CharacterReader("One &bar; qux"); Assert.AreEqual("One ", r.ConsumeToAny('&', ';')); Assert.IsTrue(r.Matches('&')); Assert.IsTrue(r.Matches("&bar;")); Assert.AreEqual('&', r.Consume()); Assert.AreEqual("bar", r.ConsumeToAny('&', ';')); Assert.AreEqual(';', r.Consume()); Assert.AreEqual(" qux", r.ConsumeToAny('&', ';')); }
private static (State, ISyntax) ParseName(ref CharacterReader r) { var name = r.ParseIdentifier(); if (name.IsEmpty) { throw new ExpressionParseException(r.Position, $"Expected a name after '#'."); } return(State.CanHaveType, new NameSyntax { Name = name.ToString() }); }
private State ParseIndexer(ref CharacterReader r, List <ExpressionNode> nodes) { var args = r.ParseArguments('[', ']'); if (args.Count == 0) { throw new ExpressionParseException(r.Position, "Indexer may not be empty."); } nodes.Add(new StringIndexerNode(args)); return(State.AfterMember); }
private State ParseElementName(ref CharacterReader r, List <ExpressionNode> nodes) { var name = r.ParseIdentifier(); if (name == null) { throw new ExpressionParseException(r.Position, "Element name expected after '#'."); } nodes.Add(new ElementNameNode(name.ToString())); return(State.AfterMember); }
static string GetMessage(CharacterReader cr, string message) { if (cr is InputReader) { var ir = cr as InputReader; return message + String.Format(" on line {0} character {1} (position {2})", ir.SourceInfo.LineNumber+1, ir.SourceInfo.Index, ir.SourceInfo.Position); } else { return message + String.Format(" on character position {0}", cr.Index); } }
public void Mark() { CharacterReader r = new CharacterReader("one"); r.Consume(); r.Mark(); Assert.AreEqual('n', r.Consume()); Assert.AreEqual('e', r.Consume()); Assert.IsTrue(r.IsEmpty()); r.RewindToMark(); Assert.AreEqual('n', r.Consume()); }
// from & in data internal override void Read(Tokeniser t, CharacterReader r) { char[] c = t.ConsumeCharacterReference(null, false); if (c == null) { t.Emit('&'); } else { t.Emit(c); } t.Transition(TokeniserState.Data); }
private static (State, ISyntax) ParseClass(ref CharacterReader r) { var @class = r.ParseIdentifier(); if (@class.IsEmpty) { throw new ExpressionParseException(r.Position, $"Expected a class name after '.'."); } return(State.CanHaveType, new ClassSyntax { Class = @class.ToString() }); }
static EdnReader() { _macros['"'] = new StringReader(); _macros[';'] = new CommentReader(); _macros['^'] = new MetaReader(); _macros['('] = new ListReader(); _macros[')'] = new UnmatchedDelimiterReader(); _macros['['] = new VectorReader(); _macros[']'] = new UnmatchedDelimiterReader(); _macros['{'] = new MapReader(); _macros['}'] = new UnmatchedDelimiterReader(); _macros['\\'] = new CharacterReader(); _macros['#'] = new DispatchReader(); _dispatchMacros['^'] = new MetaReader(); //_dispatchMacros['"'] = new RegexReader(); _dispatchMacros['{'] = new SetReader(); _dispatchMacros['<'] = new UnreadableReader(); _dispatchMacros['_'] = new DiscardReader(); }
internal override void Read(Tokeniser t, CharacterReader r) { TokeniserState.HandleDataDoubleEscapeTag(t, r, TokeniserState.ScriptDataDoubleEscaped, TokeniserState.ScriptDataEscaped); }
// NOT force quirks internal override void Read(Tokeniser t, CharacterReader r) { char c = r.Consume(); switch (c) { case '>': t.EmitDoctypePending(); t.Transition(TokeniserState.Data); break; case TokeniserState.eof: t.EmitDoctypePending(); t.Transition(TokeniserState.Data); break; default: // ignore char break; } }
// from < or </ in data, will have start or end tag pending internal override void Read(Tokeniser t, CharacterReader r) { // previous TagOpen state did NOT consume, will have a letter char in current string tagName = r.ConsumeToAny('\t', '\n', '\r', '\f', ' ', '/', '>', TokeniserState.nullChar).ToLower(); t.tagPending.AppendTagName(tagName); switch (r.Consume()) { case '\t': case '\n': case '\r': case '\f': case ' ': t.Transition(TokeniserState.BeforeAttributeName); break; case '/': t.Transition(TokeniserState.SelfClosingStartTag); break; case '>': t.EmitTagPending(); t.Transition(TokeniserState.Data); break; case TokeniserState.nullChar: // replacement t.tagPending.AppendTagName(TokeniserState.replacementStr); break; case TokeniserState.eof: // should emit pending tag? t.EofError(this); t.Transition(TokeniserState.Data); break; } }
internal override void Read(Tokeniser t, CharacterReader r) { char c = r.Current(); switch (c) { case '-': t.Emit(c); t.AdvanceTransition(TokeniserState.ScriptDataDoubleEscapedDash); break; case '<': t.Emit(c); t.AdvanceTransition(TokeniserState.ScriptDataDoubleEscapedLessthanSign ); break; case TokeniserState.nullChar: t.Error(this); r.Advance(); t.Emit(TokeniserState.replacementChar); break; case TokeniserState.eof: t.EofError(this); t.Transition(TokeniserState.Data); break; default: string data = r.ConsumeToAny('-', '<', TokeniserState.nullChar); t.Emit(data); break; } }
internal override void Read(Tokeniser t, CharacterReader r) { if (r.IsEmpty()) { t.EofError(this); t.Transition(TokeniserState.Data); return; } char c = r.Consume(); switch (c) { case '-': t.Emit(c); t.Transition(TokeniserState.ScriptDataEscapedDashDash); break; case '<': t.Transition(TokeniserState.ScriptDataEscapedLessthanSign); break; case TokeniserState.nullChar: t.Error(this); t.Emit(TokeniserState.replacementChar); t.Transition(TokeniserState.ScriptDataEscaped); break; default: t.Emit(c); t.Transition(TokeniserState.ScriptDataEscaped); break; } }
internal override void Read(Tokeniser t, CharacterReader r) { TokeniserState.HandleDataEndTag(t, r, TokeniserState.ScriptData); }
internal override void Read(Tokeniser t, CharacterReader r) { if (r.MatchesLetter()) { string name = r.ConsumeLetterSequence(); t.tagPending.AppendTagName(name.ToLower()); t.dataBuffer.Append(name); return; } char c = r.Consume(); switch (c) { case '\t': case '\n': case '\r': case '\f': case ' ': if (t.IsAppropriateEndTagToken()) { t.Transition(TokeniserState.BeforeAttributeName); } else { this.AnythingElse(t, r); } break; case '/': if (t.IsAppropriateEndTagToken()) { t.Transition(TokeniserState.SelfClosingStartTag); } else { this.AnythingElse(t, r); } break; case '>': if (t.IsAppropriateEndTagToken()) { t.EmitTagPending(); t.Transition(TokeniserState.Data); } else { this.AnythingElse(t, r); } break; default: this.AnythingElse(t, r); break; } }
internal override void Read(Tokeniser t, CharacterReader r) { char c = r.Consume(); switch (c) { case '\t': case '\n': case '\r': case '\f': case ' ': break; case '>': t.EmitDoctypePending(); t.Transition(TokeniserState.Data); break; case TokeniserState.eof: t.EofError(this); t.doctypePending.forceQuirks = true; t.EmitDoctypePending(); t.Transition(TokeniserState.Data); break; default: t.Error(this); t.Transition(TokeniserState.BogusDoctype); break; } }
// no default, as covered with above consumeToAny // from < in rcdata internal override void Read(Tokeniser t, CharacterReader r) { if (r.Matches('/')) { t.CreateTempBuffer(); t.AdvanceTransition(TokeniserState.RCDATAEndTagOpen); } else if (r.MatchesLetter() && t.AppropriateEndTagName() != null && !r.ContainsIgnoreCase("</" + t.AppropriateEndTagName())) { // diverge from spec: got a start tag, but there's no appropriate end tag (</title>), so rather than // consuming to EOF; break out here t.tagPending = new Token.EndTag(t.AppropriateEndTagName()); t.EmitTagPending(); r.Unconsume(); // undo "<" t.Transition(TokeniserState.Data); } else { t.Emit("<"); t.Transition(TokeniserState.Rcdata); } }
public ParserException(CharacterReader reader, string message) : base(GetMessage(reader,message)) { Reader = reader; }
internal override void Read(Tokeniser t, CharacterReader r) { string data = r.ConsumeTo("]]>"); t.Emit(data); r.MatchConsume("]]>"); t.Transition(TokeniserState.Data); }
internal abstract void Read(Tokeniser t, CharacterReader r);
internal override void Read(Tokeniser t, CharacterReader r) { if (r.MatchesLetter()) { t.CreateTagPending(false); t.Transition(TokeniserState.ScriptDataEndTagName); } else { t.Emit("</"); t.Transition(TokeniserState.ScriptData); } }
internal override void Read(Tokeniser t, CharacterReader r) { if (r.MatchesLetter()) { t.CreateTagPending(false); t.tagPending.AppendTagName(System.Char.ToLower(r.Current())); t.dataBuffer.Append(r.Current()); t.AdvanceTransition(TokeniserState.ScriptDataEscapedEndTagName); } else { t.Emit("</"); t.Transition(TokeniserState.ScriptDataEscaped); } }
private void AnythingElse(Tokeniser t, CharacterReader r) { t.Emit("</" + t.dataBuffer.ToString()); r.Unconsume(); t.Transition(TokeniserState.Rcdata); }
internal override void Read(Tokeniser t, CharacterReader r) { if (r.MatchesLetter()) { t.CreateTempBuffer(); t.dataBuffer.Append(System.Char.ToLower(r.Current())); t.Emit("<" + r.Current()); t.AdvanceTransition(TokeniserState.ScriptDataDoubleEscapeStart); } else if (r.Matches('/')) { t.CreateTempBuffer(); t.AdvanceTransition(TokeniserState.ScriptDataEscapedEndTagOpen); } else { t.Emit('<'); t.Transition(TokeniserState.ScriptDataEscaped); } }
internal override void Read(Tokeniser t, CharacterReader r) { if (r.Matches('/')) { t.CreateTempBuffer(); t.AdvanceTransition(TokeniserState.RawtextEndTagOpen); } else { t.Emit('<'); t.Transition(TokeniserState.Rawtext); } }
internal override void Read(Tokeniser t, CharacterReader r) { if (r.Matches('-')) { t.Emit('-'); t.AdvanceTransition(TokeniserState.ScriptDataEscapedDashDash); } else { t.Transition(TokeniserState.ScriptData); } }
internal override void Read(Tokeniser t, CharacterReader r) { char c = r.Consume(); switch (c) { case '-': t.Emit(c); break; case '<': t.Emit(c); t.Transition(TokeniserState.ScriptDataDoubleEscapedLessthanSign); break; case '>': t.Emit(c); t.Transition(TokeniserState.ScriptData); break; case TokeniserState.nullChar: t.Error(this); t.Emit(TokeniserState.replacementChar); t.Transition(TokeniserState.ScriptDataDoubleEscaped); break; case TokeniserState.eof: t.EofError(this); t.Transition(TokeniserState.Data); break; default: t.Emit(c); t.Transition(TokeniserState.ScriptDataDoubleEscaped); break; } }
private static void HandleDataDoubleEscapeTag(Tokeniser t, CharacterReader r, TokeniserState primary, TokeniserState fallback) { if (r.MatchesLetter()) { string name = r.ConsumeLetterSequence(); t.dataBuffer.Append(name.ToLower()); t.Emit(name); return; } char c = r.Consume(); switch (c) { case '\t': case '\n': case '\r': case '\f': case ' ': case '/': case '>': { if (t.dataBuffer.ToString().Equals("script")) { t.Transition(primary); } else { t.Transition(fallback); } t.Emit(c); break; } default: { r.Unconsume(); t.Transition(fallback); break; } } }
internal override void Read(Tokeniser t, CharacterReader r) { if (r.IsEmpty()) { t.EofError(this); t.Emit("</"); t.Transition(TokeniserState.Data); } else if (r.MatchesLetter()) { t.CreateTagPending(false); t.Transition(TokeniserState.TagName); } else if (r.Matches('>')) { t.Error(this); t.AdvanceTransition(TokeniserState.Data); } else { t.Error(this); t.AdvanceTransition(TokeniserState.BogusComment); } }
/// <summary> /// Handles RawtextEndTagName, ScriptDataEndTagName, and ScriptDataEscapedEndTagName. /// </summary> /// <remarks> /// Handles RawtextEndTagName, ScriptDataEndTagName, and ScriptDataEscapedEndTagName. Same body impl, just /// different else exit transitions. /// </remarks> private static void HandleDataEndTag(Tokeniser t, CharacterReader r, TokeniserState elseTransition) { if (r.MatchesLetter()) { string name = r.ConsumeLetterSequence(); t.tagPending.AppendTagName(name.ToLower()); t.dataBuffer.Append(name); return; } bool needsExitTransition = false; if (t.IsAppropriateEndTagToken() && !r.IsEmpty()) { char c = r.Consume(); switch (c) { case '\t': case '\n': case '\r': case '\f': case ' ': { t.Transition(BeforeAttributeName); break; } case '/': { t.Transition(SelfClosingStartTag); break; } case '>': { t.EmitTagPending(); t.Transition(Data); break; } default: { t.dataBuffer.Append(c); needsExitTransition = true; break; } } } else { needsExitTransition = true; } if (needsExitTransition) { t.Emit("</" + t.dataBuffer.ToString()); t.Transition(elseTransition); } }
internal override void Read(Tokeniser t, CharacterReader r) { switch (r.Consume()) { case '/': t.CreateTempBuffer(); t.Transition(TokeniserState.ScriptDataEndTagOpen); break; case '!': t.Emit("<!"); t.Transition(TokeniserState.ScriptDataEscapeStart); break; default: t.Emit("<"); r.Unconsume(); t.Transition(TokeniserState.ScriptData); break; } }
static LispReader() { _macros['"'] = new StringReader(); _macros[';'] = new CommentReader(); _macros['\''] = new WrappingReader(QUOTE); _macros['@'] = new WrappingReader(DEREF);//new DerefReader(); _macros['^'] = new WrappingReader(META); _macros['`'] = new SyntaxQuoteReader(); _macros['~'] = new UnquoteReader(); _macros['('] = new ListReader(); _macros[')'] = new UnmatchedDelimiterReader(); _macros['['] = new VectorReader(); _macros[']'] = new UnmatchedDelimiterReader(); _macros['{'] = new MapReader(); _macros['}'] = new UnmatchedDelimiterReader(); //// macros['|'] = new ArgVectorReader(); _macros['\\'] = new CharacterReader(); _macros['%'] = new ArgReader(); _macros['#'] = new DispatchReader(); _dispatchMacros['^'] = new MetaReader(); _dispatchMacros['\''] = new VarReader(); _dispatchMacros['"'] = new RegexReader(); _dispatchMacros['('] = new FnReader(); _dispatchMacros['{'] = new SetReader(); _dispatchMacros['='] = new EvalReader(); _dispatchMacros['!'] = new CommentReader(); _dispatchMacros['<'] = new UnreadableReader(); _dispatchMacros['_'] = new DiscardReader(); }
private void TestIdempotent(string str, Normalization norm) { bool isForm = NormalizerInput.IsNormalized(str, norm); string newStr = NormalizerInput.Normalize(str, norm); ICharacterInput sci = new CharacterReader(str, false, true); bool isForm2 = NormalizerInput.IsNormalized(sci, norm); if (isForm) { AssertEqual(str, newStr, EncodingTest.EscapeString(str)); } Assert.AreEqual(isForm, isForm2); if (!NormalizerInput.IsNormalized(newStr, norm)) { Assert.Fail(EncodingTest.EscapeString(str)); } if (!isForm) { string newStr2 = NormalizerInput.Normalize(newStr, norm); AssertEqual(newStr, newStr2, EncodingTest.EscapeString(str)); } }