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