/// <summary>
/// Parses an HTML DOCTYPE header tag. Assumes current position is just after tag name.
/// </summary>
/// <param name="parser">Parser object.</param>
private HtmlHeaderNode ParseHtmlHeader(TextParser parser)
{
HtmlHeaderNode node = new HtmlHeaderNode();
while (true)
{
parser.MovePastWhitespace();
char c = parser.Peek();
if (HtmlRules.IsQuoteChar(c))
{
node.Parameters.Add($"\"{parser.ParseQuotedText()}\"");
}
else if (HtmlRules.IsAttributeNameCharacter(c))
{
node.Parameters.Add(parser.ParseWhile(c2 => HtmlRules.IsAttributeNameCharacter(c2)));
}
else
{
break;
}
}
parser.MoveTo(HtmlRules.TagEnd);
parser.MoveAhead();
return(node);
}
/// <summary>
/// Parses the attributes of an element tag. When finished, the parser
/// position is at the next non-space character that follows the attributes.
/// </summary>
private HtmlAttributeCollection ParseAttributes(TextParser parser)
{
HtmlAttributeCollection attributes = new HtmlAttributeCollection();
// Parse tag attributes
parser.MovePastWhitespace();
while (HtmlRules.IsAttributeNameCharacter(parser.Peek()))
{
// Parse attribute name
HtmlAttribute attribute = new HtmlAttribute()
{
Name = parser.ParseWhile(c => HtmlRules.IsAttributeNameCharacter(c))
};
Debug.Assert(attribute.Name.Length > 0);
// Parse attribute value
parser.MovePastWhitespace();
if (parser.Peek() == '=')
{
parser.MoveAhead(); // Skip '='
parser.MovePastWhitespace();
if (HtmlRules.IsQuoteChar(parser.Peek()))
{
// Quoted attribute value
attribute.Value = parser.ParseQuotedText();
}
else
{
// Unquoted attribute value
attribute.Value = parser.ParseWhile(c => HtmlRules.IsAttributeValueCharacter(c));
Debug.Assert(attribute.Value.Length > 0);
}
}
else
{
// Null attribute value indicates no equals sign
attribute.Value = null;
}
// Add attribute to tag
attributes.Add(attribute.Name, attribute);
// Continue
parser.MovePastWhitespace();
}
return(attributes);
}
/// <summary>
/// Parses the given selector text and returns the corresponding data structures.
/// </summary>
/// <param name="selectorText">The selector text to be parsed.</param>
/// <remarks>
/// Returns multiple <see cref="Selector"/>s when the selector contains commas.
/// </remarks>
/// <returns>The parsed selector data structures.</returns>
public static SelectorCollection ParseSelector(string selectorText)
{
SelectorCollection selectors = new SelectorCollection();
if (!string.IsNullOrWhiteSpace(selectorText))
{
TextParser parser = new TextParser(selectorText);
parser.MovePastWhitespace();
while (!parser.EndOfText)
{
// Test next character
char ch = parser.Peek();
if (IsNameCharacter(ch) || ch == '*')
{
// Parse tag name
Selector selector = selectors.GetLast(true);
if (ch == '*')
{
selector.Tag = null; // Match all tags
}
else
{
selector.Tag = parser.ParseWhile(c => IsNameCharacter(c));
}
}
else if (SpecialCharacters.TryGetValue(ch, out string name))
{
// Parse special attributes
parser.MoveAhead();
string value = parser.ParseWhile(c => IsValueCharacter(c));
if (value.Length > 0)
{
SelectorAttribute attribute = new SelectorAttribute
{
Name = name,
Value = value,
Mode = SelectorAttributeMode.Contains
};
Selector selector = selectors.GetLast(true);
selector.Attributes.Add(attribute);
}
}
else if (ch == '[')
{
// Parse attribute selector
parser.MoveAhead();
parser.MovePastWhitespace();
name = parser.ParseWhile(c => IsNameCharacter(c));
if (name.Length > 0)
{
SelectorAttribute attribute = new SelectorAttribute
{
Name = name
};
// Parse attribute assignment operator
parser.MovePastWhitespace();
if (parser.Peek() == '=')
{
attribute.Mode = SelectorAttributeMode.Match;
parser.MoveAhead();
}
else if (parser.Peek() == ':' && parser.Peek(1) == '=')
{
attribute.Mode = SelectorAttributeMode.RegEx;
parser.MoveAhead(2);
}
else
{
attribute.Mode = SelectorAttributeMode.ExistsOnly;
}
// Parse attribute value
if (attribute.Mode != SelectorAttributeMode.ExistsOnly)
{
parser.MovePastWhitespace();
if (HtmlRules.IsQuoteChar(parser.Peek()))
{
attribute.Value = parser.ParseQuotedText();
}
else
{
attribute.Value = parser.ParseWhile(c => IsValueCharacter(c));
}
}
Selector selector = selectors.GetLast(true);
selector.Attributes.Add(attribute);
}
// Close out attribute selector
parser.MovePastWhitespace();
Debug.Assert(parser.Peek() == ']');
if (parser.Peek() == ']')
{
parser.MoveAhead();
}
}
else if (ch == ',')
{
// Multiple selectors
parser.MoveAhead();
parser.MovePastWhitespace();
selectors.Add(new Selector());
}
else if (ch == '>')
{
// Whitespace indicates child selector
parser.MoveAhead();
parser.MovePastWhitespace();
Debug.Assert(selectors.Any());
Selector selector = selectors.AddChildSelector();
selector.ImmediateChildOnly = true;
}
else if (char.IsWhiteSpace(ch))
{
// Handle whitespace
parser.MovePastWhitespace();
// ',' and '>' change meaning of whitespace
if (parser.Peek() != ',' && parser.Peek() != '>')
{
selectors.AddChildSelector();
}
}
else
{
// Unknown syntax
Debug.Assert(false);
parser.MoveAhead();
}
}
}
selectors.RemoveEmpty();
return(selectors);
}