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, "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, "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 (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.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 (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;
}
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);
}
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 (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 (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, "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;
}
protected virtual void ParseBlock(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var block = itemFactory.CreateSpecific<RuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
protected override void ParseBlock(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var block = itemFactory.CreateSpecific<KeyframeRuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
KeyframeList = block;
Children.Add(block);
}
}
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);
}
protected virtual void ParseBlock(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var block = itemFactory.CreateSpecific <RuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
protected override void ParseBlock(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var block = itemFactory.CreateSpecific <KeyframeRuleBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
KeyframeList = block;
Children.Add(block);
}
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var name = itemFactory.CreateSpecific<IdName>(this, text, stream);
if (name.Parse(itemFactory, text, stream))
{
Name = name;
Children.Add(name);
}
return Children.Count > 0;
}
protected override void ParseDirective(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Semicolon && stream.Peek(1).Type == TokenType.Identifier)
{
var selector = itemFactory.CreateSpecific <PseudoClassSelector>(this, text, stream);
if (selector.Parse(itemFactory, text, stream))
{
Selector = selector;
Children.Add(selector);
}
}
}
protected override void ParseBody(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsTerminator(stream.Current.Type))
{
var selector = itemFactory.CreateSpecific<KeyframeSelector>(this, text, stream);
if (!selector.Parse(itemFactory, text, stream))
break;
Children.Add(selector);
_Selectors.Add(selector);
}
}
protected override void ParseDirective(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Semicolon && stream.Peek(1).Type == TokenType.Identifier)
{
var selector = itemFactory.CreateSpecific<PseudoClassSelector>(this, text, stream);
if (selector.Parse(itemFactory, text, stream))
{
Selector = selector;
Children.Add(selector);
}
}
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var name = itemFactory.CreateSpecific <IdName>(this, text, stream);
if (name.Parse(itemFactory, text, stream))
{
Name = name;
Children.Add(name);
}
return(Children.Count > 0);
}
protected override void ParseBody(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsTerminator(stream.Current.Type))
{
var selector = itemFactory.CreateSpecific<KeyframeSelector>(this, text, stream);
if (!selector.Parse(itemFactory, text, stream))
break;
Children.Add(selector);
_Selectors.Add(selector);
}
}
protected virtual void ParseArguments(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific <FunctionArgument>(this, text, stream);
if (argument == null || !argument.Parse(itemFactory, text, stream))
{
break;
}
Arguments.Add(argument);
Children.Add(argument);
}
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.OpenInterpolation)
{
var interpolation = itemFactory.CreateSpecific <StringInterpolation>(this, text, stream);
if (interpolation.Parse(itemFactory, text, stream))
{
Interpolation = interpolation;
Children.Add(interpolation);
}
}
return(Children.Count > 0);
}
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.OpenInterpolation)
{
var interpolation = itemFactory.CreateSpecific<StringInterpolation>(this, text, stream);
if (interpolation.Parse(itemFactory, text, stream))
{
Interpolation = interpolation;
Children.Add(interpolation);
}
}
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.Function)
{
Prefix = Children.AddCurrentAndAdvance(stream);
var function = itemFactory.CreateSpecific <PseduoFunction>(this, text, stream);
if (function.Parse(itemFactory, text, stream))
{
Function = function;
Children.Add(function);
}
}
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.Function)
{
Prefix = Children.AddCurrentAndAdvance(stream);
var function = itemFactory.CreateSpecific<PseduoFunction>(this, text, stream);
if (function.Parse(itemFactory, text, stream))
{
Function = function;
Children.Add(function);
}
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "function"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
if (stream.Current.Type == TokenType.Function)
{
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.UserFunctionDefinition);
FunctionName = text.GetText(Name.Start, Name.Length);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
while (!IsArgumentTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific <FunctionArgumentDefinition>(this, text, stream);
if (argument == null || !argument.Parse(itemFactory, text, stream))
{
break;
}
Arguments.Add(argument);
Children.Add(argument);
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
var body = new UserFunctionBody();
if (body.Parse(itemFactory, text, stream))
{
Body = body;
Children.Add(body);
}
}
return(Children.Count > 0);
}
protected override void ParseImport(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsTerminator(stream.Current.Type))
{
if (stream.Current.Type == TokenType.NewLine)
{
Children.AddCurrentAndAdvance(stream);
continue;
}
var file = itemFactory.CreateSpecific<ImportFile>(this, text, stream) ?? new ImportFile();
if (!file.Parse(itemFactory, text, stream))
break;
Children.Add(file);
Files.Add(file);
}
}
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;
}
protected override void ParseImport(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsTerminator(stream.Current.Type))
{
if (stream.Current.Type == TokenType.NewLine)
{
Children.AddCurrentAndAdvance(stream);
continue;
}
var file = itemFactory.CreateSpecific <ImportFile>(this, text, stream) ?? new ImportFile();
if (!file.Parse(itemFactory, text, stream))
{
break;
}
Children.Add(file);
Files.Add(file);
}
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier && IsValidNamedRange(text.GetText(stream.Current.Start, stream.Current.Length)))
{
AnimationBegin = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
else if (stream.Current.Type == TokenType.Number && stream.Peek(1).Type == TokenType.PercentSign)
{
ParseItem begin = itemFactory.Create <PercentageUnit>(this, text, stream);
if (begin.Parse(itemFactory, text, stream))
{
AnimationBegin = begin;
Children.Add(begin);
if (stream.Current.Type == TokenType.Comma)
{
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
ParseItem end = itemFactory.Create <PercentageUnit>(this, text, stream);
if (end.Parse(itemFactory, text, stream))
{
AnimationEnd = end;
Children.Add(end);
}
}
}
if (AnimationBegin != null)
{
var block = itemFactory.CreateSpecific <RuleBlock>(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 (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 (AtRule.IsRule(text, stream, "mixin"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
Name = MixinName.CreateParsed(itemFactory, text, stream, SassClassifierType.MixinDefinition);
if (Name != null)
Children.Add(Name);
if (stream.Current.Type == TokenType.OpenFunctionBrace)
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
while (!IsArgumentTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific<FunctionArgumentDefinition>(this, text, stream);
if (argument == null || !argument.Parse(itemFactory, text, stream))
break;
_Arguments.Add(argument);
Children.Add(argument);
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
var body = new MixinDefinitionBody();
if (body.Parse(itemFactory, text, stream))
{
Body = body;
Children.Add(body);
}
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (stream.Current.Type == TokenType.Identifier && IsValidNamedRange(text.GetText(stream.Current.Start, stream.Current.Length)))
{
AnimationBegin = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
else if (stream.Current.Type == TokenType.Number && stream.Peek(1).Type == TokenType.PercentSign)
{
ParseItem begin = itemFactory.Create<PercentageUnit>(this, text, stream);
if (begin.Parse(itemFactory, text, stream))
{
AnimationBegin = begin;
Children.Add(begin);
if (stream.Current.Type == TokenType.Comma)
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
ParseItem end = itemFactory.Create<PercentageUnit>(this, text, stream);
if (end.Parse(itemFactory, text, stream))
{
AnimationEnd = end;
Children.Add(end);
}
}
}
if (AnimationBegin != null)
{
var block = itemFactory.CreateSpecific<RuleBlock>(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 ((IsConditionalDirective(text, stream) || IsConditionalContinuationDirective(text, stream)))
{
ParseRule(itemFactory, text, stream);
while (!IsConditionTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Children.Add(item);
ConditionStatements.Add(item);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
while (IsConditionalContinuationDirective(text, stream))
{
var subsequentConditional = itemFactory.CreateSpecific <ConditionalControlDirective>(this, text, stream);
if (!subsequentConditional.Parse(itemFactory, text, stream))
{
break;
}
ElseStatements.Add(subsequentConditional);
Children.Add(subsequentConditional);
}
}
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.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 ((IsConditionalDirective(text, stream) || IsConditionalContinuationDirective(text, stream)))
{
ParseRule(itemFactory, text, stream);
while (!IsConditionTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Children.Add(item);
ConditionStatements.Add(item);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
while (IsConditionalContinuationDirective(text, stream))
{
var subsequentConditional = itemFactory.CreateSpecific<ConditionalControlDirective>(this, text, stream);
if (!subsequentConditional.Parse(itemFactory, text, stream))
break;
ElseStatements.Add(subsequentConditional);
Children.Add(subsequentConditional);
}
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
//if (IsDeclaration(text, stream))
if (stream.Current.Type == TokenType.Identifier || stream.Current.Type == TokenType.OpenInterpolation)
{
var name = itemFactory.CreateSpecific<PropertyName>(this, text, stream);
if (name.Parse(itemFactory, text, stream))
{
Name = name;
Children.Add(name);
}
if (stream.Current.Type == TokenType.Colon)
Colon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
while (!IsValueTerminator(stream.Current.Type))
{
ParseItem value;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out value))
{
Values.Add(value);
Children.Add(value);
// bind all unknown values as property values
if (value.ClassifierType == SassClassifierType.Default && value is TokenItem)
value.ClassifierType = SassClassifierType.PropertyValue;
}
}
// nested property block support
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var block = itemFactory.CreateSpecific<NestedPropertyBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
Children.Add(block);
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new ImportanceModifier();
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 (IsDeclaration(text, stream))
if (stream.Current.Type == TokenType.Identifier || stream.Current.Type == TokenType.OpenInterpolation)
{
var name = itemFactory.CreateSpecific <PropertyName>(this, text, stream);
if (name.Parse(itemFactory, text, stream))
{
Name = name;
Children.Add(name);
}
if (stream.Current.Type == TokenType.Colon)
{
Colon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
while (!IsValueTerminator(stream.Current.Type))
{
ParseItem value;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out value))
{
Values.Add(value);
Children.Add(value);
// bind all unknown values as property values
if (value.ClassifierType == SassClassifierType.Default && value is TokenItem)
{
value.ClassifierType = SassClassifierType.PropertyValue;
}
}
}
// nested property block support
if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var block = itemFactory.CreateSpecific <NestedPropertyBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Children.Add(block);
}
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new ImportanceModifier();
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, "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;
}
protected virtual void ParseArguments(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
while (!IsTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific<FunctionArgument>(this, text, stream);
if (argument == null || !argument.Parse(itemFactory, text, stream))
break;
Arguments.Add(argument);
Children.Add(argument);
}
}
