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 (stream.Current.Type == TokenType.Identifier && IsModifier(text.GetText(stream.Current.Start, stream.Current.Length)))
Modifier = Children.AddCurrentAndAdvance(stream);
ParseItem mediaType;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out mediaType))
{
MediaType = mediaType;
Children.Add(mediaType);
}
while (!IsTerminator(text, stream))
{
var expression = itemFactory.CreateSpecific<MediaQueryExpression>(this, text, stream);
if (expression.Parse(itemFactory, text, stream))
{
_Expressions.Add(expression);
Children.Add(expression);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (stream.Current.Type == TokenType.Comma)
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
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)
{
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)
{
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 (stream.Current.Type == TokenType.LessThan)
{
OpenTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
if (stream.Current.Type == TokenType.Identifier)
{
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
while (!IsTagTerminator(stream.Current.Type))
{
var attribute = itemFactory.CreateSpecific<XmlAttribute>(this, text, stream);
if (!attribute.Parse(itemFactory, text, stream))
break;
Children.Add(attribute);
_Attributes.Add(attribute);
OnAttributeParsed(attribute, text);
}
}
if (stream.Current.Type == TokenType.Slash)
CloseSlash = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
if (stream.Current.Type == TokenType.GreaterThan)
CloseTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
}
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 TokenItem AddCurrentAndAdvance(ITokenStream stream, SassClassifierType classifierType = SassClassifierType.Default)
{
var item = new TokenItem(stream.Current, classifierType);
Add(item);
stream.Advance();
return(item);
}
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;
}
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(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.Number)
Value = Children.AddCurrentAndAdvance(stream);
if (stream.Current.Type == TokenType.PercentSign)
PercentSign = Children.AddCurrentAndAdvance(stream);
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(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.PercentSign && stream.Peek(1).Type == TokenType.Identifier)
{
Prefix = Children.AddCurrentAndAdvance(stream);
Name = Children.AddCurrentAndAdvance(stream);
}
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);
}
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;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
OpenCurlyBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.CurlyBrace);
ParseBody(itemFactory, text, stream);
if (OpenCurlyBrace != null && stream.Current.Type == TokenType.CloseCurlyBrace)
CloseCurlyBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.CurlyBrace);
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Number)
{
Value = Children.AddCurrentAndAdvance(stream);
}
if (stream.Current.Type == TokenType.PercentSign)
{
PercentSign = Children.AddCurrentAndAdvance(stream);
}
return(Children.Count > 0);
}
public bool TryCreateParsedOrDefault(ComplexItem parent, ITextProvider text, ITokenStream stream, out ParseItem item)
{
if (!TryCreate(parent, text, stream, out item))
{
item = new TokenItem();
}
if (!item.Parse(this, text, stream))
{
item = null;
}
return(item != null);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "content"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
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)
{
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
OpenCurlyBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.CurlyBrace);
ParseBody(itemFactory, text, stream);
if (OpenCurlyBrace != null && stream.Current.Type == TokenType.CloseCurlyBrace)
{
CloseCurlyBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.CurlyBrace);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier && text.CompareOrdinal(stream.Current.Start, "and"))
{
Combinator = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
ParseItem feature;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out feature))
{
Feature = feature;
Children.Add(feature);
}
if (stream.Current.Type == TokenType.Colon)
{
Colon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
// dump all values
while (!IsExpressionTerminator(stream.Current.Type))
{
ParseItem value;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out value))
{
FeatureValues.Add(value);
Children.Add(value);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (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)
{
var variable = new VariableDefinition(ExpresionMode.Argument);
if (variable.Parse(itemFactory, text, stream))
{
Variable = variable;
Children.Add(variable);
}
if (stream.Current.Type == TokenType.Comma)
{
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Value = item;
Children.Add(item);
}
if (stream.Current.Type == TokenType.Comma)
{
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "content"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
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)
{
if (stream.Current.Type == TokenType.OpenInterpolation)
{
OpenInterpolation = Children.AddCurrentAndAdvance(stream, SassClassifierType.Interpolation);
while (!IsTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
Children.Add(item);
}
if (stream.Current.Type == TokenType.CloseInterpolation)
CloseInterpolation = Children.AddCurrentAndAdvance(stream, SassClassifierType.Interpolation);
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (IsNamedArgument(text, stream))
{
var variable = itemFactory.CreateSpecific <VariableReference>(this, text, stream);
if (variable.Parse(itemFactory, text, stream))
{
Variable = variable;
Children.Add(variable);
}
if (stream.Current.Type == TokenType.Colon)
{
Colon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
base.Parse(itemFactory, text, stream);
return(true);
}
return(false);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier && text.CompareOrdinal(stream.Current.Start, "and"))
Combinator = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
if (stream.Current.Type == TokenType.OpenFunctionBrace)
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
ParseItem feature;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out feature))
{
Feature = feature;
Children.Add(feature);
}
if (stream.Current.Type == TokenType.Colon)
Colon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
// dump all values
while (!IsExpressionTerminator(stream.Current.Type))
{
ParseItem value;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out value))
{
FeatureValues.Add(value);
Children.Add(value);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (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.String || stream.Current.Type == TokenType.BadString)
{
Filename = itemFactory.CreateSpecificParsed <StringValue>(this, text, stream);
if (Filename != null)
{
Children.Add(Filename);
}
if (stream.Current.Type == TokenType.NewLine)
{
Children.AddCurrentAndAdvance(stream);
}
if (stream.Current.Type == TokenType.Comma)
{
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.OpenInterpolation)
{
OpenInterpolation = Children.AddCurrentAndAdvance(stream, SassClassifierType.Interpolation);
while (!IsTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Children.Add(item);
}
}
if (stream.Current.Type == TokenType.CloseInterpolation)
{
CloseInterpolation = Children.AddCurrentAndAdvance(stream, SassClassifierType.Interpolation);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (IsUrl(text, stream.Current))
{
Function = Children.AddCurrentAndAdvance(stream, SassClassifierType.SystemFunction);
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
if ((stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString))
{
Url = itemFactory.CreateSpecificParsed <StringValue>(this, text, stream);
if (Url != null)
{
Children.Add(Url);
}
}
else
{
// not using string, so just consume everything until close of url()
while (!IsUrlTerminator(stream.Current.Type))
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
}
}
if (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.Identifier && IsModifier(text.GetText(stream.Current.Start, stream.Current.Length)))
{
Modifier = Children.AddCurrentAndAdvance(stream);
}
ParseItem mediaType;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out mediaType))
{
MediaType = mediaType;
Children.Add(mediaType);
}
while (!IsTerminator(text, stream))
{
var expression = itemFactory.CreateSpecific <MediaQueryExpression>(this, text, stream);
if (expression.Parse(itemFactory, text, stream))
{
_Expressions.Add(expression);
Children.Add(expression);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
if (stream.Current.Type == TokenType.Comma)
{
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
return(Children.Count > 0);
}
public bool TryCreate(ComplexItem parent, ITextProvider text, ITokenStream stream, out ParseItem item)
{
item = null;
switch (stream.Current.Type)
{
case TokenType.EndOfFile:
item = null;
return(false);
case TokenType.StartOfFile:
item = Create <Stylesheet>(parent, text, stream);
break;
case TokenType.NewLine:
item = new TokenItem();
break;
case TokenType.String:
case TokenType.BadString:
item = new StringValue();
break;
case TokenType.OpenCssComment:
item = new CssComment();
break;
case TokenType.CppComment:
item = new CppComment();
break;
case TokenType.OpenHtmlComment:
item = new HtmlComment();
break;
case TokenType.At:
item = CreateAtRule(parent, text, stream);
break;
case TokenType.Dollar:
item = CreateVariableDefinitionOrReference(parent, text, stream);
break;
case TokenType.Bang:
item = CreateBang(parent, text, stream);
break;
case TokenType.Function:
item = CreateFunction(parent, text, stream);
break;
case TokenType.XmlDocumentationComment:
item = new XmlDocumentationComment();
break;
case TokenType.Asterisk:
case TokenType.GreaterThan:
case TokenType.Tilde:
case TokenType.Colon:
case TokenType.DoubleColon:
case TokenType.Ampersand:
case TokenType.OpenBrace:
case TokenType.Hash:
case TokenType.Period:
case TokenType.Identifier:
case TokenType.OpenInterpolation:
item = CreateBestFittingItem(parent, text, stream);
break;
}
return(item != null);
}
static bool AllowsExpresion(ITextProvider text, TokenItem statement)
{
var name = text.GetText(statement.Start, statement.Length);
return name == "if" || name == "else if";
}
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;
}
