private bool ParseDocumentFunction(Block token) { SetParsingContext(ParsingContext.AfterDocumentFunction); if (token.GrammarSegment != GrammarSegment.String) return false; CastRuleSet<DocumentRule>().Conditions.Add(Tuple.Create(DocumentFunction.RegExp, ((StringBlock)token).Value)); return true; }
private bool ParseCharacterSet(Block token) { SetParsingContext(ParsingContext.AfterInstruction); if (token.GrammarSegment != GrammarSegment.String) { return ParsePostInstruction(token); } CastRuleSet<CharacterSetRule>().Encoding = ((StringBlock)token).Value; return true; }
private bool ParseCondition(Block token) { switch (token.GrammarSegment) { case GrammarSegment.CurlyBraceOpen: CastRuleSet<SupportsRule>().Condition = _buffer.ToString(); SetParsingContext(ParsingContext.DataBlock); break; default: _buffer.Append(token); break; } return true; }
private bool ParseDocumentFunctions(Block token) { if (token.GrammarSegment == GrammarSegment.Comma) { SetParsingContext(ParsingContext.BeforeDocumentFunction); return true; } if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen) { SetParsingContext(ParsingContext.DataBlock); return true; } SetParsingContext(ParsingContext.DataBlock); return false; }
private bool ParseDeclaration(Block token) { if (token.GrammarSegment == GrammarSegment.CurlyBracketClose) { FinalizeProperty(); SetParsingContext(CurrentRule is KeyframeRule ? ParsingContext.KeyframesData : ParsingContext.DataBlock); return FinalizeRule(); } if (token.GrammarSegment != GrammarSegment.Ident) { return false; } AddProperty(new Property(((SymbolBlock)token).Value)); SetParsingContext(ParsingContext.AfterProperty); return true; }
private bool ParseSelector(Block token) { switch (token.GrammarSegment) { case GrammarSegment.CurlyBraceOpen: { var rule = CurrentRule as ISupportsSelector; if (rule != null) { rule.Selector = _selectorFactory.GetSelector(); } SetParsingContext(CurrentRule is StyleRule ? ParsingContext.InDeclaration : ParsingContext.DataBlock); } break; case GrammarSegment.CurlyBracketClose: return false; default: _selectorFactory.Apply(token); break; } return true; }
private bool ParseSingleValue(Block token) { switch (token.GrammarSegment) { case GrammarSegment.Dimension: // "3px" return AddTerm(new PrimitiveTerm(((UnitBlock)token).Unit, ((UnitBlock)token).Value)); case GrammarSegment.Hash:// "#ffffff" return ParseSingleValueHexColor(((SymbolBlock)token).Value); case GrammarSegment.Delimiter: // "#" return ParseValueDelimiter((DelimiterBlock)token); case GrammarSegment.Ident: // "auto" return ParseSingleValueIdent((SymbolBlock)token); case GrammarSegment.String:// "'some value'" return AddTerm(new PrimitiveTerm(UnitType.String, ((StringBlock)token).Value)); case GrammarSegment.Url:// "url('http://....')" return AddTerm(new PrimitiveTerm(UnitType.Uri, ((StringBlock)token).Value)); case GrammarSegment.Percentage: // "10%" return AddTerm(new PrimitiveTerm(UnitType.Percentage, ((UnitBlock)token).Value)); case GrammarSegment.Number: // "123" return AddTerm(new PrimitiveTerm(UnitType.Number, ((NumericBlock)token).Value)); case GrammarSegment.Whitespace: // " " _terms.AddSeparator(GrammarSegment.Whitespace); SetParsingContext(ParsingContext.InValueList); return true; case GrammarSegment.Function: // rgba(...) _functionBuffers.Push(new FunctionBuffer(((SymbolBlock)token).Value)); SetParsingContext(ParsingContext.InFunction); return true; case GrammarSegment.Comma: // "," _terms.AddSeparator(GrammarSegment.Comma); SetParsingContext(ParsingContext.InValuePool); return true; case GrammarSegment.Colon: // ":" _terms.AddSeparator(GrammarSegment.Colon); return true; case GrammarSegment.Semicolon: // ";" case GrammarSegment.CurlyBracketClose: // "}" return ParsePostValue(token); case GrammarSegment.ParenClose: // ")" SetParsingContext(ParsingContext.AfterValue); return true; default: return false; } }
private bool ParseKeyframesData(Block token) { if (token.GrammarSegment == GrammarSegment.CurlyBracketClose) { SetParsingContext(ParsingContext.DataBlock); return FinalizeRule(); } _buffer = new StringBuilder(); return ParseKeyframeText(token); }
private bool ParsePreKeyframesData(Block token) { if (token.GrammarSegment != GrammarSegment.CurlyBraceOpen) { return false; } SetParsingContext(ParsingContext.BeforeKeyframesData); return true; }
private bool ParseValueFunction(Block token) { switch (token.GrammarSegment) { case GrammarSegment.ParenClose: { var functionBuffer = _functionBuffers.Pop().Done(); if (_functionBuffers.Any()) return AddTerm(functionBuffer); SetParsingContext(ParsingContext.InSingleValue); return AddTerm(functionBuffer); } case GrammarSegment.Whitespace: { if (!_functionBuffers.Any()) return AddTerm(new Whitespace()); var functionBuffer = _functionBuffers.Peek(); var lastTerm = functionBuffer.TermList.LastOrDefault(); if (lastTerm is Comma || lastTerm is Whitespace) return true; return AddTerm(new Whitespace()); } case GrammarSegment.Comma: return AddTerm(new Comma()); case GrammarSegment.Delimiter: return AddTerm(new EqualSign()); default: return ParseSingleValue(token); } }
private bool ParseValuePool(Block token) { if (token.GrammarSegment == GrammarSegment.Semicolon || token.GrammarSegment == GrammarSegment.CurlyBracketClose) { ParsePostValue(token); } else { SetParsingContext(ParsingContext.InSingleValue); return ParseSingleValue(token); } return false; }
private bool ParseKeyframesName(Block token) { //SetParsingContext(ParsingContext.BeforeKeyframesData); if (token.GrammarSegment == GrammarSegment.Ident) { CastRuleSet<KeyframesRule>().Identifier = ((SymbolBlock)token).Value; return true; } if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen) { SetParsingContext(ParsingContext.KeyframesData); return true; } return false; }
private bool ParseValue(Block token) { switch (token.GrammarSegment) { case GrammarSegment.Semicolon: SetParsingContext(ParsingContext.InDeclaration); break; case GrammarSegment.CurlyBracketClose: ParseDeclaration(token); break; default: SetParsingContext(ParsingContext.InSingleValue); return ParseSingleValue(token); } return false; }
private bool ParsePageSelector(Block token) { if (token.GrammarSegment == GrammarSegment.Colon || token.GrammarSegment == GrammarSegment.Whitespace) { return true; } if (token.GrammarSegment == GrammarSegment.Ident) { CastRuleSet<PageRule>().Selector = new SimpleSelector(token.ToString()); return true; } if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen) { SetParsingContext(ParsingContext.InDeclaration); return true; } return false; }
private bool ParseSymbol(Block token) { if (token.GrammarSegment == GrammarSegment.AtRule) { var value = ((SymbolBlock)token).Value; switch (value) { case RuleTypes.Media: { AddRuleSet(new MediaRule()); SetParsingContext(ParsingContext.InMediaList); break; } case RuleTypes.Page: { AddRuleSet(new PageRule()); //SetParsingContext(ParsingContext.InSelector); SetParsingContext(ParsingContext.BeforePageSelector); break; } case RuleTypes.Import: { AddRuleSet(new ImportRule()); SetParsingContext(ParsingContext.BeforeImport); break; } case RuleTypes.FontFace: { AddRuleSet(new FontFaceRule()); //SetParsingContext(ParsingContext.InDeclaration); SetParsingContext(ParsingContext.BeforeFontFace); break; } case RuleTypes.CharacterSet: { AddRuleSet(new CharacterSetRule()); SetParsingContext(ParsingContext.BeforeCharset); break; } case RuleTypes.Namespace: { AddRuleSet(new NamespaceRule()); SetParsingContext(ParsingContext.BeforeNamespacePrefix); break; } case RuleTypes.Supports: { _buffer = new StringBuilder(); AddRuleSet(new SupportsRule()); SetParsingContext(ParsingContext.InCondition); break; } case BrowserPrefixes.Microsoft + RuleTypes.Keyframes: case BrowserPrefixes.Mozilla + RuleTypes.Keyframes: case BrowserPrefixes.Opera + RuleTypes.Keyframes: case BrowserPrefixes.Webkit + RuleTypes.Keyframes: case RuleTypes.Keyframes: { AddRuleSet(new KeyframesRule(value)); SetParsingContext(ParsingContext.BeforeKeyframesName); break; } case RuleTypes.Document: { AddRuleSet(new DocumentRule()); SetParsingContext(ParsingContext.BeforeDocumentFunction); break; } default: { _buffer = new StringBuilder(); AddRuleSet(new GenericRule()); SetParsingContext(ParsingContext.InUnknown); ParseUnknown(token); break; } } return true; } if (token.GrammarSegment == GrammarSegment.CurlyBracketClose) { return FinalizeRule(); } if (token.GrammarSegment == GrammarSegment.Semicolon) { return true; } AddRuleSet(new StyleRule()); SetParsingContext(ParsingContext.InSelector); ParseSelector(token); return true; }
private bool ParseNamespace(Block token) { SetParsingContext(ParsingContext.AfterInstruction); if (token.GrammarSegment != GrammarSegment.String) { return ParsePostInstruction(token); } CastRuleSet<NamespaceRule>().Uri = ((StringBlock)token).Value; return true; }
private bool ParseMediaValue(Block token) { switch (token.GrammarSegment) { case GrammarSegment.CurlyBraceOpen: case GrammarSegment.Semicolon: { var container = CurrentRule as ISupportsMedia; var medium = _buffer.ToString(); if (container != null) { container.Media.AppendMedium(medium); } if (CurrentRule is ImportRule) { return ParsePostInstruction(token); } SetParsingContext(ParsingContext.DataBlock); return token.GrammarSegment == GrammarSegment.CurlyBraceOpen; } case GrammarSegment.Comma: { var container = CurrentRule as ISupportsMedia; if (container != null) { container.Media.AppendMedium(_buffer.ToString()); } _buffer.Clear(); return true; } case GrammarSegment.Whitespace: { _buffer.Append(' '); return true; } default: { _buffer.Append(token); return true; } } }
private bool ParseMediaList(Block token) { if (token.GrammarSegment == GrammarSegment.Semicolon) { FinalizeRule(); SetParsingContext(ParsingContext.DataBlock); return true; } _buffer = new StringBuilder(); SetParsingContext(ParsingContext.InMediaValue); return ParseMediaValue(token); }
private bool ParseLeadingPrefix(Block token) { if (token.GrammarSegment == GrammarSegment.Ident) { CastRuleSet<NamespaceRule>().Prefix = ((SymbolBlock)token).Value; SetParsingContext(ParsingContext.AfterNamespacePrefix); return true; } if (token.GrammarSegment == GrammarSegment.String || token.GrammarSegment == GrammarSegment.Url) { CastRuleSet<NamespaceRule>().Uri = ((StringBlock)token).Value; return true; } SetParsingContext(ParsingContext.AfterInstruction); return ParsePostInstruction(token); }
private bool ParseKeyframeText(Block token) { if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen) { _frame = null; SetParsingContext(ParsingContext.InDeclaration); return true; } if (token.GrammarSegment == GrammarSegment.CurlyBracketClose) { ParseKeyframesData(token); return false; } if (token.GrammarSegment == GrammarSegment.Comma) { return true; } if (_frame == null) { _frame = new KeyframeRule(); _frame.AddValue(token.ToString()); CastRuleSet<KeyframesRule>().Declarations.Add(_frame); _activeRuleSets.Push(_frame); } else { _frame.AddValue(token.ToString()); } return true; }
private bool ParseTokenBlock(Block token) { switch (_parsingContext) { case ParsingContext.DataBlock: return ParseSymbol(token); case ParsingContext.InSelector: return ParseSelector(token); case ParsingContext.InDeclaration: return ParseDeclaration(token); case ParsingContext.AfterProperty: return ParsePostProperty(token); case ParsingContext.BeforeValue: return ParseValue(token); case ParsingContext.InValuePool: return ParseValuePool(token); case ParsingContext.InValueList: return ParseValueList(token); case ParsingContext.InSingleValue: return ParseSingleValue(token); case ParsingContext.ValueImportant: return ParseImportant(token); case ParsingContext.AfterValue: return ParsePostValue(token); case ParsingContext.InMediaList: return ParseMediaList(token); case ParsingContext.InMediaValue: return ParseMediaValue(token); case ParsingContext.BeforeImport: return ParseImport(token); case ParsingContext.AfterInstruction: return ParsePostInstruction(token); case ParsingContext.BeforeCharset: return ParseCharacterSet(token); case ParsingContext.BeforeNamespacePrefix: return ParseLeadingPrefix(token); case ParsingContext.AfterNamespacePrefix: return ParseNamespace(token); case ParsingContext.InCondition: return ParseCondition(token); case ParsingContext.InUnknown: return ParseUnknown(token); case ParsingContext.InKeyframeText: return ParseKeyframeText(token); case ParsingContext.BeforePageSelector: return ParsePageSelector(token); case ParsingContext.BeforeDocumentFunction: return ParsePreDocumentFunction(token); case ParsingContext.InDocumentFunction: return ParseDocumentFunction(token); case ParsingContext.AfterDocumentFunction: return ParsePostDocumentFunction(token); case ParsingContext.BetweenDocumentFunctions: return ParseDocumentFunctions(token); case ParsingContext.BeforeKeyframesName: return ParseKeyframesName(token); case ParsingContext.BeforeKeyframesData: return ParsePreKeyframesData(token); case ParsingContext.KeyframesData: return ParseKeyframesData(token); case ParsingContext.BeforeFontFace: return ParseFontface(token); case ParsingContext.InHexValue: return ParseHexValue(token); case ParsingContext.InFunction: return ParseValueFunction(token); default: return false; } }
private bool ParsePostDocumentFunction(Block token) { SetParsingContext(ParsingContext.BetweenDocumentFunctions); return token.GrammarSegment == GrammarSegment.ParenClose; }
private bool ParseUnknown(Block token) { switch (token.GrammarSegment) { case GrammarSegment.Semicolon: CastRuleSet<GenericRule>().SetInstruction(_buffer.ToString()); SetParsingContext(ParsingContext.DataBlock); return FinalizeRule(); case GrammarSegment.CurlyBraceOpen: CastRuleSet<GenericRule>().SetCondition(_buffer.ToString()); SetParsingContext(ParsingContext.InDeclaration); break; default: _buffer.Append(token); break; } return true; }
private bool ParsePostInstruction(Block token) { if (token.GrammarSegment != GrammarSegment.Semicolon) { return false; } SetParsingContext(ParsingContext.DataBlock); return FinalizeRule(); }
private bool ParsePostProperty(Block token) { if (token.GrammarSegment == GrammarSegment.Colon) { _isFraction = false; SetParsingContext(ParsingContext.BeforeValue); return true; } if (token.GrammarSegment == GrammarSegment.Semicolon || token.GrammarSegment == GrammarSegment.CurlyBracketClose) { ParsePostValue(token); } return false; }
private bool ParsePostValue(Block token) { if (token.GrammarSegment == GrammarSegment.Semicolon) { FinalizeProperty(); SetParsingContext(ParsingContext.InDeclaration); return true; } if (token.GrammarSegment == GrammarSegment.CurlyBracketClose) { return ParseDeclaration(token); } return false; }
private bool ParseValueList(Block token) { switch (token.GrammarSegment) { case GrammarSegment.CurlyBracketClose: case GrammarSegment.Semicolon: ParsePostValue(token); break; case GrammarSegment.Comma: SetParsingContext(ParsingContext.InValuePool); break; default: SetParsingContext(ParsingContext.InSingleValue); return ParseSingleValue(token); } return true; }
private bool ParsePreDocumentFunction(Block token) { switch (token.GrammarSegment) { case GrammarSegment.Url: CastRuleSet<DocumentRule>().Conditions.Add(Tuple.Create(DocumentFunction.Url, ((StringBlock)token).Value)); break; case GrammarSegment.UrlPrefix: CastRuleSet<DocumentRule>().Conditions.Add(Tuple.Create(DocumentFunction.UrlPrefix, ((StringBlock)token).Value)); break; case GrammarSegment.Domain: CastRuleSet<DocumentRule>().Conditions.Add(Tuple.Create(DocumentFunction.Domain, ((StringBlock)token).Value)); break; case GrammarSegment.Function: if (string.Compare(((SymbolBlock)token).Value, "regexp", StringComparison.OrdinalIgnoreCase) == 0) { SetParsingContext(ParsingContext.InDocumentFunction); return true; } SetParsingContext(ParsingContext.AfterDocumentFunction); return false; default: SetParsingContext(ParsingContext.DataBlock); return false; } SetParsingContext(ParsingContext.BetweenDocumentFunctions); return true; }
private bool ParseFontface(Block token) { if (token.GrammarSegment == GrammarSegment.CurlyBraceOpen) { SetParsingContext(ParsingContext.InDeclaration); return true; } return false; }
private bool ParseImportant(Block token) { if (token.GrammarSegment != GrammarSegment.Ident || ((SymbolBlock)token).Value != "important") { return ParsePostValue(token); } SetParsingContext(ParsingContext.AfterValue); _property.Important = true; return true; }