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