/// <summary>
/// This must be called at the start of any @directive's Parse() function.
/// It fills in the "At" and "Keyword" variables.
/// "Keyword" could end up being null, but "At" is always set.
/// </summary>
protected virtual void ParseAtAndKeyword(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
Debug.Assert(tokens.CurrentToken.TokenType == CssTokenType.At);
At = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.AtDirectiveName);
if (tokens.CurrentToken.Start == At.AfterEnd &&
tokens.CurrentToken.TokenType == CssTokenType.At &&
AllowDoubleAt(text))
{
// Two @'s in a row (@@directive). Ignore the first one for Razor support.
At = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.AtDirectiveName);
}
// Check for the directive name
if (tokens.CurrentToken.Start == At.AfterEnd &&
tokens.CurrentToken.TokenType == CssTokenType.Identifier)
{
Keyword = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.AtDirectiveName);
}
else
{
At.AddParseError(ParseErrorType.AtDirectiveNameMissing, ParseErrorLocation.AfterItem);
}
}
protected override void ParseDirective(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier)
{
AnimationName = Children.AddCurrentAndAdvance(stream, SassClassifierType.Default);
}
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.XmlDocumentationComment)
{
Opening = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
// look for <reference
if (stream.Current.Type == TokenType.LessThan)
{
var tag = itemFactory.CreateSpecific <XmlDocumentationTag>(this, text, stream);
if (tag.Parse(itemFactory, text, stream))
{
Tag = tag;
Children.Add(tag);
}
else
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
}
}
else
{
while (!IsCommentTerminator(stream.Current.Type))
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
}
}
//if (stream.Current.Type == TokenType.NewLine)
// NewLine = Children.AddCurrentAndAdvance(stream);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (IsFunctionCall(stream) && IsFunctionNameValid(text, stream))
{
Name = Children.AddCurrentAndAdvance(stream, FunctionClassifierType);
if (Name != null)
{
FunctionName = text.GetText(Name.Start, Name.Length);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
ParseArguments(itemFactory, text, stream);
if (OpenBrace != null && stream.Current.Type == TokenType.CloseFunctionBrace)
{
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Comma)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
while (!IsSelectorTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsed <SimpleSelector>(this, text, stream, out item))
{
Children.Add(item);
if (item is SimpleSelector)
{
_SimpleSelectors.Add(item as SimpleSelector);
}
}
else
{
// swallow up unknown and keep going
Children.AddCurrentAndAdvance(stream);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "extend"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
var selector = itemFactory.CreateSpecific <SelectorGroup>(this, text, stream);
if (selector.Parse(itemFactory, text, stream))
{
Selector = selector;
Children.Add(selector);
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new OptionalModifier();
if (modifier.Parse(itemFactory, text, stream))
{
Modifier = modifier;
Children.Add(modifier);
}
}
if (stream.Current.Type == TokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsSelectorTerminator(stream.Current.Type))
{
var selector = itemFactory.CreateSpecific <SelectorGroup>(this, text, stream);
if (!selector.Parse(itemFactory, text, stream))
{
break;
}
_Selectors.Add(selector);
Children.Add(selector);
if (stream.Current.Type == TokenType.Comma)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
}
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var block = itemFactory.CreateSpecific <RuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Block = block;
Children.Add(block);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "each"))
{
ParseRule(itemFactory, text, stream);
while (!IsListTerminator(stream.Current.Type))
{
var item = itemFactory.CreateSpecific <ListItem>(this, text, stream);
if (item != null && item.Parse(itemFactory, text, stream))
{
_Items.Add(item);
Children.Add(item);
}
else
{
// bad news bears
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
}
return(Children.Count > 0);
}
protected virtual ParseItem ParseName(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
ParseItem name = null;
if (tokens.CurrentToken.TokenType == CssTokenType.Asterisk)
{
StarHackPropertyName customName = new StarHackPropertyName();
if (customName.Parse(itemFactory, text, tokens))
{
name = customName;
Children.Add(customName);
}
}
else if (tokens.CurrentToken.TokenType == CssTokenType.Identifier)
{
CssClassifierContextType contextType = CssClassifierContextType.PropertyName;
if (text.CompareTo(tokens.CurrentToken.Start, "--", true))
{
IsCustomProperty = true;
contextType = CssClassifierContextType.CustomPropertyName;
}
name = Children.AddCurrentAndAdvance(tokens, contextType);
}
return(name);
}
protected virtual void ParseAfterValues(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
if (tokens.CurrentToken.TokenType == CssTokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Punctuation);
}
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "media"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
while (!IsTerminator(stream.Current.Type))
{
var query = itemFactory.CreateSpecific <MediaQuery>(this, text, stream);
if (query.Parse(itemFactory, text, stream))
{
_Queries.Add(query);
Children.Add(query);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
var block = itemFactory.CreateSpecific <MediaQueryBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "for"))
{
ParseRule(itemFactory, text, stream);
var variable = new VariableName(SassClassifierType.VariableDefinition);
if (variable.Parse(itemFactory, text, stream))
{
Variable = variable;
Children.Add(Variable);
}
if (IsKeyword(text, stream, "from"))
{
FromKeyword = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
while (!(IsKeyword(text, stream, "to") || IsKeyword(text, stream, "through")))
{
ParseItem fromValue;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out fromValue))
{
FromExpressionValues.Add(fromValue);
Children.Add(fromValue);
}
}
}
bool isToKeyword = IsKeyword(text, stream, "to");
bool isThroughKeyword = !isToKeyword && IsKeyword(text, stream, "through");
if (isToKeyword || isThroughKeyword)
{
if (isToKeyword)
{
ToKeyword = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
if (isThroughKeyword)
{
ThroughKeyword = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
while (!IsRangeTerminator(stream.Current.Type))
{
ParseItem rangeValue;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out rangeValue))
{
RangeExpressionValues.Add(rangeValue);
Children.Add(rangeValue);
}
}
}
ParseBody(itemFactory, text, stream);
}
return(Children.Count > 0);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
FunctionName = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.FunctionName);
ParseArguments(itemFactory, text, tokens);
CheckCloseFunctionBrace(tokens);
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
{
Value = Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "include"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
Name = MixinName.CreateParsed(itemFactory, text, stream, SassClassifierType.MixinReference);
if (Name != null)
{
Children.Add(Name);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
while (!IsTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific <FunctionArgument>(this, text, stream);
if (argument != null && argument.Parse(itemFactory, text, stream))
{
_Arguments.Add(argument);
Children.Add(argument);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
{
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
if (stream.Current.Type == TokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(stream);
}
else if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var content = new MixinContentBlock();
if (content.Parse(itemFactory, text, stream))
{
Content = content;
Children.Add(content);
}
}
}
return(Children.Count > 0);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
// foo : bar rgb(1,2,3) "baz" url(quux) / moo goo ! important ;
// First item is property name. Allow -webkit and *foo - the latter is used for 'commenting out'
PropertyName = ParseName(itemFactory, text, tokens);
if (tokens.CurrentToken.TokenType == CssTokenType.Colon ||
tokens.CurrentToken.TokenType == CssTokenType.DoubleColon)
{
Colon = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Punctuation);
if (Colon.TokenType != CssTokenType.Colon)
{
Colon.AddParseError(ParseErrorType.UnexpectedToken, ParseErrorLocation.WholeItem);
}
}
// Parse values
while (KeepParsingValues(tokens))
{
switch (tokens.CurrentToken.TokenType)
{
case CssTokenType.Bang:
ParseBang(itemFactory, text, tokens);
break;
default:
ParseDefaultChild(itemFactory, text, tokens);
break;
}
}
ParseAfterValues(itemFactory, text, tokens);
// Add appropriate errors
if (PropertyName == null)
{
AddParseError(ParseErrorType.PropertyNameMissing, ParseErrorLocation.BeforeItem);
}
else if (Colon != null)
{
int semiColonIndex = (Semicolon != null) ? Children.IndexOf(Semicolon) : Children.Count;
if (Children.IndexOf(Colon) + 1 == semiColonIndex)
{
Colon.AddParseError(ParseErrorType.PropertyValueMissing, ParseErrorLocation.AfterItem);
}
}
else
{
AddColonMissingError();
}
return(Children.Count > 0);
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Ampersand)
{
Ampersand = Children.AddCurrentAndAdvance(stream, SassClassifierType.ParentReference);
}
return(Children.Count > 0);
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Asterisk)
{
Asterisk = Children.AddCurrentAndAdvance(stream);
}
return(Children.Count > 0);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
UnitType = UnitType.Unknown;
if (tokens.CurrentToken.TokenType == CssTokenType.Number)
{
if (!base.Parse(itemFactory, text, tokens))
{
return(false);
}
}
Debug.Assert(tokens.CurrentToken.TokenType == CssTokenType.Units);
UnitToken = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Units);
UnitType = UnitHelpers.GetUnitType(text, UnitToken.Start, UnitToken.Length);
CssClassifierContextType ct = CssClassifierContextType.Units;
switch (UnitType)
{
case UnitType.Angle:
ct = CssClassifierContextType.AngleUnits;
break;
case UnitType.Frequency:
ct = CssClassifierContextType.FrequencyUnits;
break;
case UnitType.Grid:
ct = CssClassifierContextType.GridUnits;
break;
case UnitType.Length:
ct = CssClassifierContextType.LengthUnits;
break;
case UnitType.Percentage:
ct = CssClassifierContextType.PercentUnits;
break;
case UnitType.Resolution:
ct = CssClassifierContextType.ResolutionUnits;
break;
case UnitType.Time:
ct = CssClassifierContextType.TimeUnits;
break;
case UnitType.Viewport:
ct = CssClassifierContextType.ViewUnits;
break;
}
UnitToken.Context = CssClassifierContextCache.FromTypeEnum(ct);
return(Children.Count > 0);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
if (tokens.CurrentToken.TokenType == CssTokenType.Bang)
{
Bang = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.SelectorOperator);
}
return(Children.Count > 0);
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier)
{
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.ElementName);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier || stream.Current.Type == TokenType.Function)
{
Name = Children.AddCurrentAndAdvance(stream, ClassifierType);
NameValue = text.GetText(Name.Start, Name.Length);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Bang && IsValidModifier(text, stream.Peek(1), FlagName))
{
Bang = Children.AddCurrentAndAdvance(stream);
Flag = Children.AddCurrentAndAdvance(stream);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Hash)
{
Hash = Children.AddCurrentAndAdvance(stream, SassClassifierType.Default);
Color = Children.AddCurrentAndAdvance(stream, SassClassifierType.Default);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.At && IsValidTokenType(stream.Peek(1).Type))
{
At = Children.AddCurrentAndAdvance(stream);
Name = Children.AddCurrentAndAdvance(stream);
}
return(Children.Count > 0);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
Debug.Assert(
tokens.CurrentToken.TokenType == CssTokenType.OpenHtmlComment ||
tokens.CurrentToken.TokenType == CssTokenType.CloseHtmlComment);
Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Default);
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.PercentSign && stream.Peek(1).Type == TokenType.Identifier)
{
Prefix = Children.AddCurrentAndAdvance(stream);
Name = Children.AddCurrentAndAdvance(stream);
}
return(Children.Count > 0);
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Colon && stream.Peek(1).Type == TokenType.Identifier)
{
Prefix = Children.AddCurrentAndAdvance(stream, SassClassifierType.PseudoClass);
ClassName = Children.AddCurrentAndAdvance(stream, SassClassifierType.PseudoClass);
}
return(Children.Count > 0);
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
if (tokens.CurrentToken.TokenType == CssTokenType.Dot)
{
Dot = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.ClassSelector);
ParseName(itemFactory, text, tokens);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (IsValidName(stream))
{
Dot = Children.AddCurrentAndAdvance(stream, ClassifierType);
Name = Children.AddCurrentAndAdvance(stream, ClassifierType);
}
return(Children.Count > 0);
}