/* * Copyright (C) 2003 Lars Knoll (knoll@kde.org) * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com) * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. * Copyright (C) 2007 Nicholas Shanks * Copyright (C) 2008 Eric Seidel * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this library; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include "config.h" #include "CSSParser.h" #include "CSSAspectRatioValue.h" #include "CSSBorderImage.h" #include "CSSCanvasValue.h" #include "CSSCharsetRule.h" #include "CSSCrossfadeValue.h" #include "CSSCursorImageValue.h" #include "CSSFlexValue.h" #include "CSSFontFaceRule.h" #include "CSSFontFaceSrcValue.h" #include "CSSFunctionValue.h" #include "CSSGradientValue.h" #include "CSSImageValue.h" #include "CSSImportRule.h" #include "CSSInheritedValue.h" #include "CSSInitialValue.h" #include "CSSLineBoxContainValue.h" #include "CSSMediaRule.h" #include "CSSPageRule.h" #include "CSSPrimitiveValue.h" #include "CSSProperty.h" #include "CSSPropertyNames.h" #include "CSSPropertySourceData.h" #include "CSSReflectValue.h" #include "CSSRuleList.h" #include "CSSSelector.h" #include "CSSStyleRule.h" #include "CSSStyleSheet.h" #include "CSSTimingFunctionValue.h" #include "CSSUnicodeRangeValue.h" #include "CSSValueKeywords.h" #include "CSSValueList.h" #include "CSSValuePool.h" #include "CSSWrapShapes.h" #include "Counter.h" #include "Document.h" #include "FloatConversion.h" #include "FontFamilyValue.h" #include "FontFeatureValue.h" #include "FontValue.h" #include "HTMLParserIdioms.h" #include "HashTools.h" #include "MediaList.h" #include "MediaQueryExp.h" #include "Page.h" #include "Pair.h" #include "Rect.h" #include "RenderTheme.h" #include "Settings.h" #include "ShadowValue.h" #include "StylePropertySet.h" #if ENABLE(CSS_FILTERS) #include "WebKitCSSFilterValue.h" #endif #include "WebKitCSSKeyframeRule.h" #include "WebKitCSSKeyframesRule.h" #include "WebKitCSSRegionRule.h" #include "WebKitCSSTransformValue.h" #if ENABLE(CSS_SHADERS) #include "WebKitCSSShaderValue.h" #endif #include #include #include #include #include #if ENABLE(DASHBOARD_SUPPORT) #include "DashboardRegion.h" #endif #define YYDEBUG 0 #if YYDEBUG > 0 extern int cssyydebug; #endif extern int cssyyparse(void* parser); using namespace std; using namespace WTF; namespace { enum PropertyType { PropertyExplicit, PropertyImplicit }; class ImplicitScope { WTF_MAKE_NONCOPYABLE(ImplicitScope); public: ImplicitScope(WebCore::CSSParser* parser, PropertyType propertyType) : m_parser(parser) { m_parser->m_implicitShorthand = propertyType == PropertyImplicit; } ~ImplicitScope() { m_parser->m_implicitShorthand = false; } private: WebCore::CSSParser* m_parser; }; } // namespace namespace WebCore { static const unsigned INVALID_NUM_PARSED_PROPERTIES = UINT_MAX; static const double MAX_SCALE = 1000000; static bool equal(const CSSParserString& a, const char* b) { for (int i = 0; i < a.length; ++i) { if (!b[i]) return false; if (a.characters[i] != b[i]) return false; } return !b[a.length]; } static bool equalIgnoringCase(const CSSParserString& a, const char* b) { for (int i = 0; i < a.length; ++i) { if (!b[i]) return false; ASSERT(!isASCIIUpper(b[i])); if (toASCIILower(a.characters[i]) != b[i]) return false; } return !b[a.length]; } static bool hasPrefix(const char* string, unsigned length, const char* prefix) { for (unsigned i = 0; i < length; ++i) { if (!prefix[i]) return true; if (string[i] != prefix[i]) return false; } return false; } inline void CSSParser::ensureCSSValuePool() { if (!m_cssValuePool) m_cssValuePool = CSSValuePool::create(); } // FIXME: Can m_parsedProperties just be a Vector? CSSParser::CSSParser(bool strictParsing) : m_strict(strictParsing) , m_important(false) , m_id(0) , m_styleSheet(0) , m_parsedProperties(static_cast(fastMalloc(32 * sizeof(CSSProperty*)))) , m_numParsedProperties(0) , m_maxParsedProperties(32) , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES) , m_inParseShorthand(0) , m_currentShorthand(0) , m_implicitShorthand(false) , m_hasFontFaceOnlyValues(false) , m_hadSyntacticallyValidCSSRule(false) , m_defaultNamespace(starAtom) , m_inStyleRuleOrDeclaration(false) , m_selectorListRange(0, 0) , m_ruleBodyRange(0, 0) , m_propertyRange(UINT_MAX, UINT_MAX) , m_ruleRangeMap(0) , m_currentRuleData(0) , m_parsingMode(NormalMode) , m_currentCharacter(0) , m_token(0) , m_lineNumber(0) , m_lastSelectorLineNumber(0) , m_allowImportRules(true) , m_allowNamespaceDeclarations(true) { #if YYDEBUG > 0 cssyydebug = 1; #endif CSSPropertySourceData::init(); } CSSParser::~CSSParser() { clearProperties(); fastFree(m_parsedProperties); fastDeleteAllValues(m_floatingSelectors); deleteAllValues(m_floatingSelectorVectors); deleteAllValues(m_floatingValueLists); deleteAllValues(m_floatingFunctions); } void CSSParserString::lower() { // FIXME: If we need Unicode lowercasing here, then we probably want the real kind // that can potentially change the length of the string rather than the character // by character kind. If we don't need Unicode lowercasing, it would be good to // simplify this function. if (charactersAreAllASCII(characters, length)) { // Fast case for all-ASCII. for (int i = 0; i < length; i++) characters[i] = toASCIILower(characters[i]); } else { for (int i = 0; i < length; i++) characters[i] = Unicode::toLower(characters[i]); } } void CSSParser::setupParser(const char* prefix, const String& string, const char* suffix) { int length = string.length() + strlen(prefix) + strlen(suffix) + 1; m_dataStart = adoptArrayPtr(new UChar[length]); for (unsigned i = 0; i < strlen(prefix); i++) m_dataStart[i] = prefix[i]; memcpy(m_dataStart.get() + strlen(prefix), string.characters(), string.length() * sizeof(UChar)); unsigned start = strlen(prefix) + string.length(); unsigned end = start + strlen(suffix); for (unsigned i = start; i < end; i++) m_dataStart[i] = suffix[i - start]; m_dataStart[length - 1] = 0; m_currentCharacter = m_tokenStart = m_dataStart.get(); resetRuleBodyMarks(); } void CSSParser::parseSheet(CSSStyleSheet* sheet, const String& string, int startLineNumber, StyleRuleRangeMap* ruleRangeMap) { setStyleSheet(sheet); m_defaultNamespace = starAtom; // Reset the default namespace. m_ruleRangeMap = ruleRangeMap; if (ruleRangeMap) { m_currentRuleData = CSSRuleSourceData::create(); m_currentRuleData->styleSourceData = CSSStyleSourceData::create(); } m_lineNumber = startLineNumber; setupParser("", string, ""); cssyyparse(this); m_ruleRangeMap = 0; m_currentRuleData = 0; m_rule = 0; } PassRefPtr CSSParser::parseRule(CSSStyleSheet* sheet, const String& string) { setStyleSheet(sheet); m_allowNamespaceDeclarations = false; setupParser("@-webkit-rule{", string, "} "); cssyyparse(this); return m_rule.release(); } PassRefPtr CSSParser::parseKeyframeRule(CSSStyleSheet *sheet, const String &string) { setStyleSheet(sheet); setupParser("@-webkit-keyframe-rule{ ", string, "} "); cssyyparse(this); return m_keyframe.release(); } static inline bool isColorPropertyID(int propertyId) { switch (propertyId) { case CSSPropertyColor: case CSSPropertyBackgroundColor: case CSSPropertyBorderBottomColor: case CSSPropertyBorderLeftColor: case CSSPropertyBorderRightColor: case CSSPropertyBorderTopColor: case CSSPropertyOutlineColor: case CSSPropertyTextLineThroughColor: case CSSPropertyTextOverlineColor: case CSSPropertyTextUnderlineColor: case CSSPropertyWebkitBorderAfterColor: case CSSPropertyWebkitBorderBeforeColor: case CSSPropertyWebkitBorderEndColor: case CSSPropertyWebkitBorderStartColor: case CSSPropertyWebkitColumnRuleColor: case CSSPropertyWebkitTextEmphasisColor: case CSSPropertyWebkitTextFillColor: case CSSPropertyWebkitTextStrokeColor: return true; default: return false; } } static bool parseColorValue(StylePropertySet* declaration, int propertyId, const String& string, bool important, bool strict, CSSStyleSheet* contextStyleSheet = 0) { if (!string.length()) return false; if (!isColorPropertyID(propertyId)) return false; CSSParserString cssString; cssString.characters = const_cast(string.characters()); cssString.length = string.length(); int valueID = cssValueKeywordID(cssString); bool validPrimitive = false; if (valueID == CSSValueWebkitText) validPrimitive = true; else if (valueID == CSSValueCurrentcolor) validPrimitive = true; else if ((valueID >= CSSValueAqua && valueID <= CSSValueWindowtext) || valueID == CSSValueMenu || (valueID >= CSSValueWebkitFocusRingColor && valueID < CSSValueWebkitText && !strict)) { validPrimitive = true; } CSSStyleSheet* styleSheet = contextStyleSheet ? contextStyleSheet : declaration->contextStyleSheet(); if (!styleSheet) return false; Document* document = styleSheet->findDocument(); if (!document) return false; if (validPrimitive) { CSSProperty property(propertyId, document->cssValuePool()->createIdentifierValue(valueID), important); declaration->addParsedProperty(property); return true; } RGBA32 color; if (!CSSParser::fastParseColor(color, string, strict && string[0] != '#')) return false; CSSProperty property(propertyId, document->cssValuePool()->createColorValue(color), important); declaration->addParsedProperty(property); return true; } static inline bool isSimpleLengthPropertyID(int propertyId, bool& acceptsNegativeNumbers) { switch (propertyId) { case CSSPropertyFontSize: case CSSPropertyHeight: case CSSPropertyWidth: case CSSPropertyMinHeight: case CSSPropertyMinWidth: case CSSPropertyPaddingBottom: case CSSPropertyPaddingLeft: case CSSPropertyPaddingRight: case CSSPropertyPaddingTop: case CSSPropertyWebkitLogicalWidth: case CSSPropertyWebkitLogicalHeight: case CSSPropertyWebkitMinLogicalWidth: case CSSPropertyWebkitMinLogicalHeight: case CSSPropertyWebkitPaddingAfter: case CSSPropertyWebkitPaddingBefore: case CSSPropertyWebkitPaddingEnd: case CSSPropertyWebkitPaddingStart: case CSSPropertyWebkitWrapMargin: case CSSPropertyWebkitWrapPadding: acceptsNegativeNumbers = false; return true; case CSSPropertyBottom: case CSSPropertyLeft: case CSSPropertyMarginBottom: case CSSPropertyMarginLeft: case CSSPropertyMarginRight: case CSSPropertyMarginTop: case CSSPropertyRight: case CSSPropertyTextIndent: case CSSPropertyTop: case CSSPropertyWebkitMarginAfter: case CSSPropertyWebkitMarginBefore: case CSSPropertyWebkitMarginEnd: case CSSPropertyWebkitMarginStart: acceptsNegativeNumbers = true; return true; default: return false; } } static bool parseSimpleLengthValue(StylePropertySet* declaration, int propertyId, const String& string, bool important, bool strict) { bool acceptsNegativeNumbers; unsigned length = string.length(); if (!length) return false; double number; bool ok; CSSPrimitiveValue::UnitTypes unit = CSSPrimitiveValue::CSS_NUMBER; if (string.is8Bit()) { const LChar* characters8 = string.characters8(); if (!characters8) return false; if (!isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers)) return false; if (length > 2 && (characters8[length - 2] | 0x20) == 'p' && (characters8[length - 1] | 0x20) == 'x') { length -= 2; unit = CSSPrimitiveValue::CSS_PX; } else if (length > 1 && characters8[length - 1] == '%') { length -= 1; unit = CSSPrimitiveValue::CSS_PERCENTAGE; } // We rely on charactersToDouble for validation as well. The function // will set "ok" to "false" if the entire passed-in character range does // not represent a double. number = charactersToDouble(characters8, length, &ok); } else { const UChar* characters16 = string.characters16(); if (!characters16) return false; if (!isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers)) return false; if (length > 2 && (characters16[length - 2] | 0x20) == 'p' && (characters16[length - 1] | 0x20) == 'x') { length -= 2; unit = CSSPrimitiveValue::CSS_PX; } else if (length > 1 && characters16[length - 1] == '%') { length -= 1; unit = CSSPrimitiveValue::CSS_PERCENTAGE; } // We rely on charactersToDouble for validation as well. The function // will set "ok" to "false" if the entire passed-in character range does // not represent a double. number = charactersToDouble(characters16, length, &ok); } if (!ok) return false; if (unit == CSSPrimitiveValue::CSS_NUMBER) { if (number && strict) return false; unit = CSSPrimitiveValue::CSS_PX; } if (number < 0 && !acceptsNegativeNumbers) return false; CSSStyleSheet* styleSheet = declaration->contextStyleSheet(); if (!styleSheet) return false; Document* document = styleSheet->findDocument(); if (!document) return false; CSSProperty property(propertyId, document->cssValuePool()->createValue(number, unit), important); declaration->addParsedProperty(property); return true; } bool CSSParser::parseValue(StylePropertySet* declaration, int propertyId, const String& string, bool important, bool strict) { if (parseSimpleLengthValue(declaration, propertyId, string, important, strict)) return true; if (parseColorValue(declaration, propertyId, string, important, strict)) return true; CSSParser parser(strict); return parser.parseValue(declaration, propertyId, string, important); } bool CSSParser::parseValue(StylePropertySet* declaration, int propertyId, const String& string, bool important, CSSStyleSheet* contextStyleSheet) { if (contextStyleSheet) setStyleSheet(contextStyleSheet); else setStyleSheet(declaration->contextStyleSheet()); setupParser("@-webkit-value{", string, "} "); m_id = propertyId; m_important = important; cssyyparse(this); m_rule = 0; bool ok = false; if (m_hasFontFaceOnlyValues) deleteFontFaceOnlyValues(); if (m_numParsedProperties) { ok = true; declaration->addParsedProperties(m_parsedProperties, m_numParsedProperties); clearProperties(); } return ok; } // The color will only be changed when string contains a valid CSS color, so callers // can set it to a default color and ignore the boolean result. bool CSSParser::parseColor(RGBA32& color, const String& string, bool strict) { // First try creating a color specified by name, rgba(), rgb() or "#" syntax. if (fastParseColor(color, string, strict)) return true; CSSParser parser(true); // In case the fast-path parser didn't understand the color, try the full parser. if (!parser.parseColor(string)) return false; CSSValue* value = parser.m_parsedProperties[0]->value(); if (!value->isPrimitiveValue()) return false; CSSPrimitiveValue* primitiveValue = static_cast(value); if (!primitiveValue->isRGBColor()) return false; color = primitiveValue->getRGBA32Value(); return true; } bool CSSParser::parseColor(const String& string) { // This function may be called without a stylesheet set on the parser, so we need to // make sure that we have a CSSValuePool or we'll crash below cssyyparse(). ensureCSSValuePool(); setupParser("@-webkit-decls{color:", string, "} "); cssyyparse(this); m_rule = 0; return (m_numParsedProperties && m_parsedProperties[0]->m_id == CSSPropertyColor); } bool CSSParser::parseSystemColor(RGBA32& color, const String& string, Document* document) { if (!document || !document->page()) return false; CSSParserString cssColor; cssColor.characters = const_cast(string.characters()); cssColor.length = string.length(); int id = cssValueKeywordID(cssColor); if (id <= 0) return false; color = document->page()->theme()->systemColor(id).rgb(); return true; } void CSSParser::parseSelector(const String& string, Document* doc, CSSSelectorList& selectorList) { RefPtr dummyStyleSheet = CSSStyleSheet::create(doc); setStyleSheet(dummyStyleSheet.get()); m_selectorListForParseSelector = &selectorList; setupParser("@-webkit-selector{", string, "}"); cssyyparse(this); m_selectorListForParseSelector = 0; // The style sheet will be deleted right away, so it won't outlive the document. ASSERT(dummyStyleSheet->hasOneRef()); } bool CSSParser::parseDeclaration(StylePropertySet* declaration, const String& string, RefPtr* styleSourceData, CSSStyleSheet* contextStyleSheet) { // Length of the "@-webkit-decls{" prefix. static const unsigned prefixLength = 15; if (contextStyleSheet) setStyleSheet(contextStyleSheet); else setStyleSheet(declaration->contextStyleSheet()); if (styleSourceData) { m_currentRuleData = CSSRuleSourceData::create(); m_currentRuleData->styleSourceData = CSSStyleSourceData::create(); m_inStyleRuleOrDeclaration = true; } setupParser("@-webkit-decls{", string, "} "); cssyyparse(this); m_rule = 0; bool ok = false; if (m_hasFontFaceOnlyValues) deleteFontFaceOnlyValues(); if (m_numParsedProperties) { ok = true; declaration->addParsedProperties(m_parsedProperties, m_numParsedProperties); clearProperties(); } if (m_currentRuleData) { m_currentRuleData->styleSourceData->styleBodyRange.start = 0; m_currentRuleData->styleSourceData->styleBodyRange.end = string.length(); for (Vector::iterator it = m_currentRuleData->styleSourceData->propertyData.begin(), endIt = m_currentRuleData->styleSourceData->propertyData.end(); it != endIt; ++it) { (*it).range.start -= prefixLength; (*it).range.end -= prefixLength; } } if (styleSourceData) { *styleSourceData = m_currentRuleData->styleSourceData.release(); m_currentRuleData = 0; m_inStyleRuleOrDeclaration = false; } return ok; } bool CSSParser::parseMediaQuery(MediaList* queries, const String& string) { if (string.isEmpty()) return true; ASSERT(!m_mediaQuery); // can't use { because tokenizer state switches from mediaquery to initial state when it sees { token. // instead insert one " " (which is WHITESPACE in CSSGrammar.y) setupParser("@-webkit-mediaquery ", string, "} "); cssyyparse(this); bool ok = false; if (m_mediaQuery) { ok = true; queries->appendMediaQuery(m_mediaQuery.release()); } return ok; } void CSSParser::addProperty(int propId, PassRefPtr value, bool important, bool implicit) { OwnPtr prop(adoptPtr(new CSSProperty(propId, value, important, m_currentShorthand, m_implicitShorthand || implicit))); if (m_numParsedProperties >= m_maxParsedProperties) { if (m_numParsedProperties > (UINT_MAX / sizeof(CSSProperty*)) - 32) CRASH(); // Avoid inconsistencies with rollbackLastProperties. m_maxParsedProperties += 32; m_parsedProperties = static_cast(fastRealloc(m_parsedProperties, m_maxParsedProperties * sizeof(CSSProperty*))); } m_parsedProperties[m_numParsedProperties++] = prop.leakPtr(); } void CSSParser::rollbackLastProperties(int num) { ASSERT(num >= 0); ASSERT(m_numParsedProperties >= static_cast(num)); for (int i = 0; i < num; ++i) delete m_parsedProperties[--m_numParsedProperties]; } void CSSParser::clearProperties() { for (unsigned i = 0; i < m_numParsedProperties; i++) delete m_parsedProperties[i]; m_numParsedProperties = 0; m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES; m_hasFontFaceOnlyValues = false; } void CSSParser::setStyleSheet(CSSStyleSheet* styleSheet) { m_styleSheet = styleSheet; Document* document = findDocument(); m_cssValuePool = document ? document->cssValuePool() : CSSValuePool::create(); } Document* CSSParser::findDocument() const { if (!m_styleSheet) return 0; return m_styleSheet->findDocument(); } bool CSSParser::validCalculationUnit(CSSParserValue* value, Units unitflags) { if (!parseCalculation(value)) return false; bool b = false; switch (m_parsedCalculation->category()) { case CalcLength: b = (unitflags & FLength); break; case CalcPercent: b = (unitflags & FPercent); // FIXME calc (http://webkit.org/b/16662): test FNonNeg here, eg // if (b && (unitflags & FNonNeg) && m_parsedCalculation->doubleValue() < 0) // b = false; break; case CalcNumber: b = (unitflags & FNumber); if (!b && (unitflags & FInteger) && m_parsedCalculation->isInt()) b = true; // FIXME calc (http://webkit.org/b/16662): test FNonNeg here, eg // if (b && (unitflags & FNonNeg) && m_parsedCalculation->doubleValue() < 0) // b = false; break; case CalcPercentLength: b = (unitflags & FPercent) && (unitflags & FLength); break; case CalcPercentNumber: b = (unitflags & FPercent) && (unitflags & FNumber); break; case CalcOther: break; } if (!b) m_parsedCalculation.release(); return b; } bool CSSParser::validUnit(CSSParserValue* value, Units unitflags, bool strict) { if (isCalculation(value)) return validCalculationUnit(value, unitflags); bool b = false; switch (value->unit) { case CSSPrimitiveValue::CSS_NUMBER: b = (unitflags & FNumber); if (!b && ((unitflags & (FLength | FAngle | FTime)) && (!value->fValue || !strict))) { value->unit = (unitflags & FLength) ? CSSPrimitiveValue::CSS_PX : ((unitflags & FAngle) ? CSSPrimitiveValue::CSS_DEG : CSSPrimitiveValue::CSS_MS); b = true; } if (!b && (unitflags & FInteger) && value->isInt) b = true; break; case CSSPrimitiveValue::CSS_PERCENTAGE: b = (unitflags & FPercent); break; case CSSParserValue::Q_EMS: case CSSPrimitiveValue::CSS_EMS: case CSSPrimitiveValue::CSS_REMS: case CSSPrimitiveValue::CSS_EXS: case CSSPrimitiveValue::CSS_PX: case CSSPrimitiveValue::CSS_CM: case CSSPrimitiveValue::CSS_MM: case CSSPrimitiveValue::CSS_IN: case CSSPrimitiveValue::CSS_PT: case CSSPrimitiveValue::CSS_PC: b = (unitflags & FLength); break; case CSSPrimitiveValue::CSS_MS: case CSSPrimitiveValue::CSS_S: b = (unitflags & FTime); break; case CSSPrimitiveValue::CSS_DEG: case CSSPrimitiveValue::CSS_RAD: case CSSPrimitiveValue::CSS_GRAD: case CSSPrimitiveValue::CSS_TURN: b = (unitflags & FAngle); break; case CSSPrimitiveValue::CSS_HZ: case CSSPrimitiveValue::CSS_KHZ: case CSSPrimitiveValue::CSS_DIMENSION: default: break; } if (b && unitflags & FNonNeg && value->fValue < 0) b = false; return b; } inline PassRefPtr CSSParser::createPrimitiveNumericValue(CSSParserValue* value) { if (m_parsedCalculation) { ASSERT(isCalculation(value)); // FIXME calc() http://webkit.org/b/16662: create a CSSPrimitiveValue here, ie // return CSSPrimitiveValue::create(m_parsedCalculation.release()); m_parsedCalculation.release(); return 0; } ASSERT((value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ) || (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_REMS)); return cssValuePool()->createValue(value->fValue, static_cast(value->unit)); } inline PassRefPtr CSSParser::createPrimitiveStringValue(CSSParserValue* value) { ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT); return cssValuePool()->createValue(value->string, CSSPrimitiveValue::CSS_STRING); } static int unitFromString(CSSParserValue* value) { if (value->unit != CSSPrimitiveValue::CSS_IDENT || value->id) return 0; if (equal(value->string, "em")) return CSSPrimitiveValue::CSS_EMS; if (equal(value->string, "rem")) return CSSPrimitiveValue::CSS_REMS; if (equal(value->string, "ex")) return CSSPrimitiveValue::CSS_EXS; if (equal(value->string, "px")) return CSSPrimitiveValue::CSS_PX; if (equal(value->string, "cm")) return CSSPrimitiveValue::CSS_CM; if (equal(value->string, "mm")) return CSSPrimitiveValue::CSS_MM; if (equal(value->string, "in")) return CSSPrimitiveValue::CSS_IN; if (equal(value->string, "pt")) return CSSPrimitiveValue::CSS_PT; if (equal(value->string, "pc")) return CSSPrimitiveValue::CSS_PC; if (equal(value->string, "deg")) return CSSPrimitiveValue::CSS_DEG; if (equal(value->string, "rad")) return CSSPrimitiveValue::CSS_RAD; if (equal(value->string, "grad")) return CSSPrimitiveValue::CSS_GRAD; if (equal(value->string, "turn")) return CSSPrimitiveValue::CSS_TURN; if (equal(value->string, "ms")) return CSSPrimitiveValue::CSS_MS; if (equal(value->string, "s")) return CSSPrimitiveValue::CSS_S; if (equal(value->string, "Hz")) return CSSPrimitiveValue::CSS_HZ; if (equal(value->string, "kHz")) return CSSPrimitiveValue::CSS_KHZ; return 0; } void CSSParser::checkForOrphanedUnits() { if (m_strict || inShorthand()) return; // The purpose of this code is to implement the WinIE quirk that allows unit types to be separated from their numeric values // by whitespace, so e.g., width: 20 px instead of width:20px. This is invalid CSS, so we don't do this in strict mode. CSSParserValue* numericVal = 0; unsigned size = m_valueList->size(); for (unsigned i = 0; i < size; i++) { CSSParserValue* value = m_valueList->valueAt(i); if (numericVal) { // Change the unit type of the numeric val to match. int unit = unitFromString(value); if (unit) { numericVal->unit = unit; numericVal = 0; // Now delete the bogus unit value. m_valueList->deleteValueAt(i); i--; // We're safe even though |i| is unsigned, since we only hit this code if we had a previous numeric value (so |i| is always > 0 here). size--; continue; } } numericVal = (value->unit == CSSPrimitiveValue::CSS_NUMBER) ? value : 0; } } inline PassRefPtr CSSParser::parseValidPrimitive(int id, CSSParserValue* value) { if (id) return cssValuePool()->createIdentifierValue(id); if (value->unit == CSSPrimitiveValue::CSS_STRING) return createPrimitiveStringValue(value); if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ) return createPrimitiveNumericValue(value); if (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_REMS) return createPrimitiveNumericValue(value); if (value->unit >= CSSParserValue::Q_EMS) return CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS); if (isCalculation(value)) // FIXME calc() http://webkit.org/b/16662: create a primitive value here, ie // return CSSPrimitiveValue::create(m_parsedCalculation.release()); m_parsedCalculation.release(); return 0; } bool CSSParser::parseValue(int propId, bool important) { if (!m_valueList) return false; CSSParserValue* value = m_valueList->current(); if (!value) return false; // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function. // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers. ASSERT(!m_parsedCalculation); int id = value->id; // In quirks mode, we will look for units that have been incorrectly separated from the number they belong to // by a space. We go ahead and associate the unit with the number even though it is invalid CSS. checkForOrphanedUnits(); int num = inShorthand() ? 1 : m_valueList->size(); if (id == CSSValueInherit) { if (num != 1) return false; addProperty(propId, cssValuePool()->createInheritedValue(), important); return true; } else if (id == CSSValueInitial) { if (num != 1) return false; addProperty(propId, cssValuePool()->createExplicitInitialValue(), important); return true; } bool validPrimitive = false; RefPtr parsedValue; switch (static_cast(propId)) { /* The comment to the left defines all valid value of this properties as defined * in CSS 2, Appendix F. Property index */ /* All the CSS properties are not supported by the renderer at the moment. * Note that all the CSS2 Aural properties are only checked, if CSS_AURAL is defined * (see parseAuralValues). As we don't support them at all this seems reasonable. */ case CSSPropertySize: // {1,2} | auto | [ || [ portrait | landscape] ] return parseSize(propId, important); case CSSPropertyQuotes: // [ ]+ | none | inherit if (id) validPrimitive = true; else return parseQuotes(propId, important); break; case CSSPropertyUnicodeBidi: // normal | embed | bidi-override | isolate | plaintext | inherit if (id == CSSValueNormal || id == CSSValueEmbed || id == CSSValueBidiOverride || id == CSSValueWebkitIsolate || id == CSSValueWebkitPlaintext) validPrimitive = true; break; case CSSPropertyPosition: // static | relative | absolute | fixed | inherit if (id == CSSValueStatic || id == CSSValueRelative || id == CSSValueAbsolute || id == CSSValueFixed) validPrimitive = true; break; case CSSPropertyPageBreakAfter: // auto | always | avoid | left | right | inherit case CSSPropertyPageBreakBefore: case CSSPropertyWebkitColumnBreakAfter: case CSSPropertyWebkitColumnBreakBefore: case CSSPropertyWebkitRegionBreakAfter: case CSSPropertyWebkitRegionBreakBefore: if (id == CSSValueAuto || id == CSSValueAlways || id == CSSValueAvoid || id == CSSValueLeft || id == CSSValueRight) validPrimitive = true; break; case CSSPropertyPageBreakInside: // avoid | auto | inherit case CSSPropertyWebkitColumnBreakInside: case CSSPropertyWebkitRegionBreakInside: if (id == CSSValueAuto || id == CSSValueAvoid) validPrimitive = true; break; case CSSPropertyEmptyCells: // show | hide | inherit if (id == CSSValueShow || id == CSSValueHide) validPrimitive = true; break; case CSSPropertyContent: // [ | | | attr(X) | open-quote | // close-quote | no-open-quote | no-close-quote ]+ | inherit return parseContent(propId, important); case CSSPropertyWhiteSpace: // normal | pre | nowrap | inherit if (id == CSSValueNormal || id == CSSValuePre || id == CSSValuePreWrap || id == CSSValuePreLine || id == CSSValueNowrap) validPrimitive = true; break; case CSSPropertyClip: // | auto | inherit if (id == CSSValueAuto) validPrimitive = true; else if (value->unit == CSSParserValue::Function) return parseShape(propId, important); break; /* Start of supported CSS properties with validation. This is needed for parseShorthand to work * correctly and allows optimization in WebCore::applyRule(..) */ case CSSPropertyCaptionSide: // top | bottom | left | right | inherit if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueTop || id == CSSValueBottom) validPrimitive = true; break; case CSSPropertyBorderCollapse: // collapse | separate | inherit if (id == CSSValueCollapse || id == CSSValueSeparate) validPrimitive = true; break; case CSSPropertyVisibility: // visible | hidden | collapse | inherit if (id == CSSValueVisible || id == CSSValueHidden || id == CSSValueCollapse) validPrimitive = true; break; case CSSPropertyOverflow: { ShorthandScope scope(this, propId); if (num != 1 || !parseValue(CSSPropertyOverflowX, important)) return false; CSSValue* value = m_parsedProperties[m_numParsedProperties - 1]->value(); addProperty(CSSPropertyOverflowY, value, important); return true; } case CSSPropertyOverflowX: case CSSPropertyOverflowY: // visible | hidden | scroll | auto | marquee | overlay | inherit if (id == CSSValueVisible || id == CSSValueHidden || id == CSSValueScroll || id == CSSValueAuto || id == CSSValueOverlay || id == CSSValueWebkitMarquee) validPrimitive = true; break; case CSSPropertyListStylePosition: // inside | outside | inherit if (id == CSSValueInside || id == CSSValueOutside) validPrimitive = true; break; case CSSPropertyListStyleType: // See section CSS_PROP_LIST_STYLE_TYPE of file CSSValueKeywords.in // for the list of supported list-style-types. if ((id >= CSSValueDisc && id <= CSSValueKatakanaIroha) || id == CSSValueNone) validPrimitive = true; break; case CSSPropertyDisplay: // inline | block | list-item | run-in | inline-block | table | // inline-table | table-row-group | table-header-group | table-footer-group | table-row | // table-column-group | table-column | table-cell | table-caption | -webkit-box | -webkit-inline-box | none | inherit // -webkit-flexbox | -webkit-inline-flexbox | -webkit-grid | -webkit-inline-grid if ((id >= CSSValueInline && id <= CSSValueWebkitInlineFlexbox) || id == CSSValueNone) validPrimitive = true; #if ENABLE(CSS_GRID_LAYOUT) if (id == CSSValueWebkitGrid || id == CSSValueWebkitInlineGrid) validPrimitive = true; #endif break; case CSSPropertyDirection: // ltr | rtl | inherit if (id == CSSValueLtr || id == CSSValueRtl) validPrimitive = true; break; case CSSPropertyTextTransform: // capitalize | uppercase | lowercase | none | inherit if ((id >= CSSValueCapitalize && id <= CSSValueLowercase) || id == CSSValueNone) validPrimitive = true; break; case CSSPropertyFloat: // left | right | none | positioned | center (for buggy CSS, maps to none) if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueNone || id == CSSValueCenter || id == CSSValueWebkitPositioned) validPrimitive = true; break; case CSSPropertyClear: // none | left | right | both | inherit if (id == CSSValueNone || id == CSSValueLeft || id == CSSValueRight || id == CSSValueBoth) validPrimitive = true; break; case CSSPropertyTextAlign: // left | right | center | justify | webkit_left | webkit_right | webkit_center | webkit_match_parent | // start | end | | inherit if ((id >= CSSValueWebkitAuto && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd || value->unit == CSSPrimitiveValue::CSS_STRING) validPrimitive = true; break; case CSSPropertyOutlineStyle: // ( except hidden) | auto | inherit if (id == CSSValueAuto || id == CSSValueNone || (id >= CSSValueInset && id <= CSSValueDouble)) validPrimitive = true; break; case CSSPropertyBorderTopStyle: //// | inherit case CSSPropertyBorderRightStyle: // Defined as: none | hidden | dotted | dashed | case CSSPropertyBorderBottomStyle: // solid | double | groove | ridge | inset | outset case CSSPropertyBorderLeftStyle: case CSSPropertyWebkitBorderStartStyle: case CSSPropertyWebkitBorderEndStyle: case CSSPropertyWebkitBorderBeforeStyle: case CSSPropertyWebkitBorderAfterStyle: case CSSPropertyWebkitColumnRuleStyle: if (id >= CSSValueNone && id <= CSSValueDouble) validPrimitive = true; break; case CSSPropertyFontWeight: // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit return parseFontWeight(important); case CSSPropertyBorderSpacing: { const int properties[2] = { CSSPropertyWebkitBorderHorizontalSpacing, CSSPropertyWebkitBorderVerticalSpacing }; if (num == 1) { ShorthandScope scope(this, CSSPropertyBorderSpacing); if (!parseValue(properties[0], important)) return false; CSSValue* value = m_parsedProperties[m_numParsedProperties-1]->value(); addProperty(properties[1], value, important); return true; } else if (num == 2) { ShorthandScope scope(this, CSSPropertyBorderSpacing); if (!parseValue(properties[0], important) || !parseValue(properties[1], important)) return false; return true; } return false; } case CSSPropertyWebkitBorderHorizontalSpacing: case CSSPropertyWebkitBorderVerticalSpacing: validPrimitive = validUnit(value, FLength | FNonNeg, m_strict); break; case CSSPropertyOutlineColor: // | invert | inherit // Outline color has "invert" as additional keyword. // Also, we want to allow the special focus color even in strict parsing mode. if (id == CSSValueInvert || id == CSSValueWebkitFocusRingColor) { validPrimitive = true; break; } /* nobreak */ case CSSPropertyBackgroundColor: // | inherit case CSSPropertyBorderTopColor: // | inherit case CSSPropertyBorderRightColor: case CSSPropertyBorderBottomColor: case CSSPropertyBorderLeftColor: case CSSPropertyWebkitBorderStartColor: case CSSPropertyWebkitBorderEndColor: case CSSPropertyWebkitBorderBeforeColor: case CSSPropertyWebkitBorderAfterColor: case CSSPropertyColor: // | inherit case CSSPropertyTextLineThroughColor: // CSS3 text decoration colors case CSSPropertyTextUnderlineColor: case CSSPropertyTextOverlineColor: case CSSPropertyWebkitColumnRuleColor: case CSSPropertyWebkitTextEmphasisColor: case CSSPropertyWebkitTextFillColor: case CSSPropertyWebkitTextStrokeColor: if (id == CSSValueWebkitText) validPrimitive = true; // Always allow this, even when strict parsing is on, // since we use this in our UA sheets. else if (id == CSSValueCurrentcolor) validPrimitive = true; else if ((id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || (id >= CSSValueWebkitFocusRingColor && id < CSSValueWebkitText && !m_strict)) { validPrimitive = true; } else { parsedValue = parseColor(); if (parsedValue) m_valueList->next(); } break; case CSSPropertyCursor: { // [,]* [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize | // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize | // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help | // vertical-text | cell | context-menu | alias | copy | no-drop | not-allowed | -webkit-zoom-in // -webkit-zoom-out | all-scroll | -webkit-grab | -webkit-grabbing ] ] | inherit RefPtr list; while (value && value->unit == CSSPrimitiveValue::CSS_URI) { if (!list) list = CSSValueList::createCommaSeparated(); String uri = value->string; Vector coords; value = m_valueList->next(); while (value && value->unit == CSSPrimitiveValue::CSS_NUMBER) { coords.append(int(value->fValue)); value = m_valueList->next(); } IntPoint hotSpot(-1, -1); int nrcoords = coords.size(); if (nrcoords > 0 && nrcoords != 2) return false; if (nrcoords == 2) hotSpot = IntPoint(coords[0], coords[1]); if (!uri.isNull() && m_styleSheet) { // FIXME: The completeURL call should be done when using the CSSCursorImageValue, // not when creating it. list->append(CSSCursorImageValue::create(m_styleSheet->completeURL(uri), hotSpot)); } if ((m_strict && !value) || (value && !(value->unit == CSSParserValue::Operator && value->iValue == ','))) return false; value = m_valueList->next(); // comma } if (list) { if (!value) { // no value after url list (MSIE 5 compatibility) if (list->length() != 1) return false; } else if (!m_strict && value->id == CSSValueHand) // MSIE 5 compatibility :/ list->append(cssValuePool()->createIdentifierValue(CSSValuePointer)); else if (value && ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitGrabbing) || value->id == CSSValueCopy || value->id == CSSValueNone)) list->append(cssValuePool()->createIdentifierValue(value->id)); m_valueList->next(); parsedValue = list.release(); break; } id = value->id; if (!m_strict && value->id == CSSValueHand) { // MSIE 5 compatibility :/ id = CSSValuePointer; validPrimitive = true; } else if ((value->id >= CSSValueAuto && value->id <= CSSValueWebkitGrabbing) || value->id == CSSValueCopy || value->id == CSSValueNone) validPrimitive = true; break; } case CSSPropertyBackgroundAttachment: case CSSPropertyBackgroundClip: case CSSPropertyWebkitBackgroundClip: case CSSPropertyWebkitBackgroundComposite: case CSSPropertyBackgroundImage: case CSSPropertyBackgroundOrigin: case CSSPropertyWebkitBackgroundOrigin: case CSSPropertyBackgroundPosition: case CSSPropertyBackgroundPositionX: case CSSPropertyBackgroundPositionY: case CSSPropertyBackgroundSize: case CSSPropertyWebkitBackgroundSize: case CSSPropertyBackgroundRepeat: case CSSPropertyBackgroundRepeatX: case CSSPropertyBackgroundRepeatY: case CSSPropertyWebkitMaskAttachment: case CSSPropertyWebkitMaskClip: case CSSPropertyWebkitMaskComposite: case CSSPropertyWebkitMaskImage: case CSSPropertyWebkitMaskOrigin: case CSSPropertyWebkitMaskPosition: case CSSPropertyWebkitMaskPositionX: case CSSPropertyWebkitMaskPositionY: case CSSPropertyWebkitMaskSize: case CSSPropertyWebkitMaskRepeat: case CSSPropertyWebkitMaskRepeatX: case CSSPropertyWebkitMaskRepeatY: { RefPtr val1; RefPtr val2; int propId1, propId2; bool result = false; if (parseFillProperty(propId, propId1, propId2, val1, val2)) { OwnPtr shorthandScope; if (propId == CSSPropertyBackgroundPosition || propId == CSSPropertyBackgroundRepeat || propId == CSSPropertyWebkitMaskPosition || propId == CSSPropertyWebkitMaskRepeat) { shorthandScope = adoptPtr(new ShorthandScope(this, propId)); } addProperty(propId1, val1.release(), important); if (val2) addProperty(propId2, val2.release(), important); result = true; } m_implicitShorthand = false; return result; } case CSSPropertyListStyleImage: // | none | inherit case CSSPropertyBorderImageSource: case CSSPropertyWebkitMaskBoxImageSource: if (id == CSSValueNone) { parsedValue = CSSImageValue::create(); m_valueList->next(); } else if (value->unit == CSSPrimitiveValue::CSS_URI) { if (m_styleSheet) { // FIXME: The completeURL call should be done when using the CSSImageValue, // not when creating it. parsedValue = CSSImageValue::create(m_styleSheet->completeURL(value->string)); m_valueList->next(); } } else if (isGeneratedImageValue(value)) { if (parseGeneratedImage(m_valueList.get(), parsedValue)) m_valueList->next(); else return false; } break; case CSSPropertyWebkitTextStrokeWidth: case CSSPropertyOutlineWidth: // | inherit case CSSPropertyBorderTopWidth: //// | inherit case CSSPropertyBorderRightWidth: // Which is defined as case CSSPropertyBorderBottomWidth: // thin | medium | thick | case CSSPropertyBorderLeftWidth: case CSSPropertyWebkitBorderStartWidth: case CSSPropertyWebkitBorderEndWidth: case CSSPropertyWebkitBorderBeforeWidth: case CSSPropertyWebkitBorderAfterWidth: case CSSPropertyWebkitColumnRuleWidth: if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick) validPrimitive = true; else validPrimitive = validUnit(value, FLength | FNonNeg, m_strict); break; case CSSPropertyLetterSpacing: // normal | | inherit case CSSPropertyWordSpacing: // normal | | inherit if (id == CSSValueNormal) validPrimitive = true; else validPrimitive = validUnit(value, FLength, m_strict); break; case CSSPropertyWordBreak: // normal | break-all | break-word (this is a custom extension) if (id == CSSValueNormal || id == CSSValueBreakAll || id == CSSValueBreakWord) validPrimitive = true; break; case CSSPropertyWordWrap: // normal | break-word if (id == CSSValueNormal || id == CSSValueBreakWord) validPrimitive = true; break; case CSSPropertySpeak: // none | normal | spell-out | digits | literal-punctuation | no-punctuation | inherit if (id == CSSValueNone || id == CSSValueNormal || id == CSSValueSpellOut || id == CSSValueDigits || id == CSSValueLiteralPunctuation || id == CSSValueNoPunctuation) validPrimitive = true; break; case CSSPropertyTextIndent: // | | inherit validPrimitive = (!id && validUnit(value, FLength | FPercent, m_strict)); break; case CSSPropertyPaddingTop: //// | inherit case CSSPropertyPaddingRight: // Which is defined as case CSSPropertyPaddingBottom: // | case CSSPropertyPaddingLeft: //// case CSSPropertyWebkitPaddingStart: case CSSPropertyWebkitPaddingEnd: case CSSPropertyWebkitPaddingBefore: case CSSPropertyWebkitPaddingAfter: validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg, m_strict)); break; case CSSPropertyMaxHeight: // | | none | inherit case CSSPropertyMaxWidth: // | | none | inherit case CSSPropertyWebkitMaxLogicalWidth: case CSSPropertyWebkitMaxLogicalHeight: if (id == CSSValueNone) { validPrimitive = true; break; } /* nobreak */ case CSSPropertyMinHeight: // | | inherit case CSSPropertyMinWidth: // | | inherit case CSSPropertyWebkitMinLogicalWidth: case CSSPropertyWebkitMinLogicalHeight: if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic) validPrimitive = true; else validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg, m_strict)); break; case CSSPropertyFontSize: // | | | | inherit if (id >= CSSValueXxSmall && id <= CSSValueLarger) validPrimitive = true; else validPrimitive = (validUnit(value, FLength | FPercent | FNonNeg, m_strict)); break; case CSSPropertyFontStyle: // normal | italic | oblique | inherit return parseFontStyle(important); case CSSPropertyFontVariant: // normal | small-caps | inherit return parseFontVariant(important); case CSSPropertyVerticalAlign: // baseline | sub | super | top | text-top | middle | bottom | text-bottom | // | | inherit if (id >= CSSValueBaseline && id <= CSSValueWebkitBaselineMiddle) validPrimitive = true; else validPrimitive = (!id && validUnit(value, FLength | FPercent, m_strict)); break; case CSSPropertyHeight: // | | auto | inherit case CSSPropertyWidth: // | | auto | inherit case CSSPropertyWebkitLogicalWidth: case CSSPropertyWebkitLogicalHeight: if (id == CSSValueAuto || id == CSSValueIntrinsic || id == CSSValueMinIntrinsic) validPrimitive = true; else if (!id && validUnit(value, FLength | FPercent | FNonNeg, m_strict)) // ### handle multilength case where we allow relative units validPrimitive = true; else if (value->unit == CSSParserValue::Function) return parseFlex(propId, important); break; case CSSPropertyBottom: // | | auto | inherit case CSSPropertyLeft: // | | auto | inherit case CSSPropertyRight: // | | auto | inherit case CSSPropertyTop: // | | auto | inherit case CSSPropertyMarginTop: //// | inherit case CSSPropertyMarginRight: // Which is defined as case CSSPropertyMarginBottom: // | | auto | inherit case CSSPropertyMarginLeft: //// case CSSPropertyWebkitMarginStart: case CSSPropertyWebkitMarginEnd: case CSSPropertyWebkitMarginBefore: case CSSPropertyWebkitMarginAfter: if (id == CSSValueAuto) validPrimitive = true; else validPrimitive = (!id && validUnit(value, FLength | FPercent, m_strict)); break; case CSSPropertyZIndex: // auto | | inherit if (id == CSSValueAuto) { validPrimitive = true; break; } /* nobreak */ case CSSPropertyOrphans: // | inherit case CSSPropertyWidows: // | inherit // ### not supported later on validPrimitive = (!id && validUnit(value, FInteger, false)); break; case CSSPropertyLineHeight: // normal | | | | inherit if (id == CSSValueNormal) validPrimitive = true; else validPrimitive = (!id && validUnit(value, FNumber | FLength | FPercent | FNonNeg, m_strict)); break; case CSSPropertyCounterIncrement: // [ ? ]+ | none | inherit if (id != CSSValueNone) return parseCounter(propId, 1, important); validPrimitive = true; break; case CSSPropertyCounterReset: // [ ? ]+ | none | inherit if (id != CSSValueNone) return parseCounter(propId, 0, important); validPrimitive = true; break; case CSSPropertyFontFamily: // [[ | ],]* [ | ] | inherit { parsedValue = parseFontFamily(); break; } case CSSPropertyTextDecoration: case CSSPropertyWebkitTextDecorationsInEffect: // none | [ underline || overline || line-through || blink ] | inherit if (id == CSSValueNone) { validPrimitive = true; } else { RefPtr list = CSSValueList::createSpaceSeparated(); bool isValid = true; while (isValid && value) { switch (value->id) { case CSSValueBlink: break; case CSSValueUnderline: case CSSValueOverline: case CSSValueLineThrough: list->append(cssValuePool()->createIdentifierValue(value->id)); break; default: isValid = false; } value = m_valueList->next(); } if (list->length() && isValid) { parsedValue = list.release(); m_valueList->next(); } } break; case CSSPropertyZoom: // normal | reset | document | | | inherit if (id == CSSValueNormal || id == CSSValueReset || id == CSSValueDocument) validPrimitive = true; else validPrimitive = (!id && validUnit(value, FNumber | FPercent | FNonNeg, true)); break; case CSSPropertyTableLayout: // auto | fixed | inherit if (id == CSSValueAuto || id == CSSValueFixed) validPrimitive = true; break; case CSSPropertySrc: // Only used within @font-face, so cannot use inherit | initial or be !important. This is a list of urls or local references. return parseFontFaceSrc(); case CSSPropertyUnicodeRange: return parseFontFaceUnicodeRange(); /* CSS3 properties */ case CSSPropertyWebkitAppearance: if ((id >= CSSValueCheckbox && id <= CSSValueTextarea) || id == CSSValueNone) validPrimitive = true; break; case CSSPropertyBorderImage: { RefPtr result; return parseBorderImage(propId, result, important); } case CSSPropertyWebkitBorderImage: case CSSPropertyWebkitMaskBoxImage: { RefPtr result; if (parseBorderImage(propId, result)) { addProperty(propId, result, important); return true; } break; } case CSSPropertyBorderImageOutset: case CSSPropertyWebkitMaskBoxImageOutset: { RefPtr result; if (parseBorderImageOutset(result)) { addProperty(propId, result, important); return true; } break; } case CSSPropertyBorderImageRepeat: case CSSPropertyWebkitMaskBoxImageRepeat: { RefPtr result; if (parseBorderImageRepeat(result)) { addProperty(propId, result, important); return true; } break; } case CSSPropertyBorderImageSlice: case CSSPropertyWebkitMaskBoxImageSlice: { RefPtr result; if (parseBorderImageSlice(propId, result)) { addProperty(propId, result, important); return true; } break; } case CSSPropertyBorderImageWidth: case CSSPropertyWebkitMaskBoxImageWidth: { RefPtr result; if (parseBorderImageWidth(result)) { addProperty(propId, result, important); return true; } break; } case CSSPropertyBorderTopRightRadius: case CSSPropertyBorderTopLeftRadius: case CSSPropertyBorderBottomLeftRadius: case CSSPropertyBorderBottomRightRadius: { if (num != 1 && num != 2) return false; validPrimitive = validUnit(value, FLength | FPercent | FNonNeg, m_strict); if (!validPrimitive) return false; RefPtr parsedValue1 = createPrimitiveNumericValue(value); RefPtr parsedValue2; if (num == 2) { value = m_valueList->next(); validPrimitive = validUnit(value, FLength | FPercent | FNonNeg, m_strict); if (!validPrimitive) return false; parsedValue2 = createPrimitiveNumericValue(value); } else parsedValue2 = parsedValue1; RefPtr pair = Pair::create(parsedValue1.release(), parsedValue2.release()); RefPtr val = cssValuePool()->createValue(pair.release()); addProperty(propId, val.release(), important); return true; } case CSSPropertyWebkitAspectRatio: return parseAspectRatio(important); case CSSPropertyBorderRadius: case CSSPropertyWebkitBorderRadius: return parseBorderRadius(propId, important); case CSSPropertyOutlineOffset: validPrimitive = validUnit(value, FLength | FPercent, m_strict); break; case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3 case CSSPropertyBoxShadow: case CSSPropertyWebkitBoxShadow: if (id == CSSValueNone) validPrimitive = true; else { RefPtr shadowValueList = parseShadow(m_valueList.get(), propId); if (shadowValueList) { addProperty(propId, shadowValueList.release(), important); m_valueList->next(); return true; } return false; } break; case CSSPropertyWebkitBoxReflect: if (id == CSSValueNone) validPrimitive = true; else return parseReflect(propId, important); break; case CSSPropertyOpacity: validPrimitive = validUnit(value, FNumber, m_strict); break; case CSSPropertyWebkitBoxAlign: if (id == CSSValueStretch || id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueBaseline) validPrimitive = true; break; case CSSPropertyWebkitBoxDirection: if (id == CSSValueNormal || id == CSSValueReverse) validPrimitive = true; break; case CSSPropertyWebkitBoxLines: if (id == CSSValueSingle || id == CSSValueMultiple) validPrimitive = true; break; case CSSPropertyWebkitBoxOrient: if (id == CSSValueHorizontal || id == CSSValueVertical || id == CSSValueInlineAxis || id == CSSValueBlockAxis) validPrimitive = true; break; case CSSPropertyWebkitBoxPack: if (id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueJustify) validPrimitive = true; break; case CSSPropertyWebkitBoxFlex: validPrimitive = validUnit(value, FNumber, m_strict); break; case CSSPropertyWebkitBoxFlexGroup: case CSSPropertyWebkitBoxOrdinalGroup: validPrimitive = validUnit(value, FInteger | FNonNeg, true); break; case CSSPropertyBoxSizing: validPrimitive = id == CSSValueBorderBox || id == CSSValueContentBox; break; case CSSPropertyWebkitColorCorrection: validPrimitive = id == CSSValueSrgb || id == CSSValueDefault; break; #if ENABLE(CSS_FILTERS) case CSSPropertyWebkitFilter: if (id == CSSValueNone) validPrimitive = true; else { RefPtr val = parseFilter(); if (val) { addProperty(propId, val, important); return true; } return false; } break; #endif case CSSPropertyWebkitFlexOrder: if (validUnit(value, FInteger, true)) { // We restrict the smallest value to int min + 2 because we use int min and int min + 1 as special values in a hash set. parsedValue = cssValuePool()->createValue(max(static_cast(std::numeric_limits::min() + 2), value->fValue), static_cast(value->unit)); m_valueList->next(); } break; case CSSPropertyWebkitFlexPack: validPrimitive = id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueJustify || id == CSSValueDistribute; break; case CSSPropertyWebkitFlexAlign: validPrimitive = id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueBaseline || id == CSSValueStretch; break; case CSSPropertyWebkitFlexItemAlign: validPrimitive = id == CSSValueAuto || id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueBaseline || id == CSSValueStretch; break; case CSSPropertyWebkitFlexDirection: validPrimitive = id == CSSValueRow || id == CSSValueRowReverse || id == CSSValueColumn || id == CSSValueColumnReverse; break; case CSSPropertyWebkitFlexWrap: validPrimitive = id == CSSValueNowrap || id == CSSValueWrap || id == CSSValueWrapReverse; break; case CSSPropertyWebkitMarquee: { const int properties[5] = { CSSPropertyWebkitMarqueeDirection, CSSPropertyWebkitMarqueeIncrement, CSSPropertyWebkitMarqueeRepetition, CSSPropertyWebkitMarqueeStyle, CSSPropertyWebkitMarqueeSpeed }; return parseShorthand(propId, properties, 5, important); } case CSSPropertyWebkitMarqueeDirection: if (id == CSSValueForwards || id == CSSValueBackwards || id == CSSValueAhead || id == CSSValueReverse || id == CSSValueLeft || id == CSSValueRight || id == CSSValueDown || id == CSSValueUp || id == CSSValueAuto) validPrimitive = true; break; case CSSPropertyWebkitMarqueeIncrement: if (id == CSSValueSmall || id == CSSValueLarge || id == CSSValueMedium) validPrimitive = true; else validPrimitive = validUnit(value, FLength | FPercent, m_strict); break; case CSSPropertyWebkitMarqueeStyle: if (id == CSSValueNone || id == CSSValueSlide || id == CSSValueScroll || id == CSSValueAlternate) validPrimitive = true; break; case CSSPropertyWebkitMarqueeRepetition: if (id == CSSValueInfinite) validPrimitive = true; else validPrimitive = validUnit(value, FInteger | FNonNeg, m_strict); break; case CSSPropertyWebkitMarqueeSpeed: if (id == CSSValueNormal || id == CSSValueSlow || id == CSSValueFast) validPrimitive = true; else validPrimitive = validUnit(value, FTime | FInteger | FNonNeg, m_strict); break; case CSSPropertyWebkitFlowInto: return parseFlowThread(propId, important); case CSSPropertyWebkitFlowFrom: return parseRegionThread(propId, important); case CSSPropertyWebkitRegionOverflow: if (id == CSSValueAuto || id == CSSValueBreak) validPrimitive = true; break; case CSSPropertyWebkitUserDrag: // auto | none | element if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueElement) validPrimitive = true; break; case CSSPropertyWebkitUserModify: // read-only | read-write if (id == CSSValueReadOnly || id == CSSValueReadWrite || id == CSSValueReadWritePlaintextOnly) validPrimitive = true; break; case CSSPropertyWebkitUserSelect: // auto | none | text if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueText) validPrimitive = true; break; case CSSPropertyTextOverflow: // clip | ellipsis if (id == CSSValueClip || id == CSSValueEllipsis) validPrimitive = true; break; case CSSPropertyWebkitTransform: if (id == CSSValueNone) validPrimitive = true; else { PassRefPtr val = parseTransform(); if (val) { addProperty(propId, val, important); return true; } return false; } break; case CSSPropertyWebkitTransformOrigin: case CSSPropertyWebkitTransformOriginX: case CSSPropertyWebkitTransformOriginY: case CSSPropertyWebkitTransformOriginZ: { RefPtr val1; RefPtr val2; RefPtr val3; int propId1, propId2, propId3; if (parseTransformOrigin(propId, propId1, propId2, propId3, val1, val2, val3)) { addProperty(propId1, val1.release(), important); if (val2) addProperty(propId2, val2.release(), important); if (val3) addProperty(propId3, val3.release(), important); return true; } return false; } case CSSPropertyWebkitTransformStyle: if (value->id == CSSValueFlat || value->id == CSSValuePreserve3d) validPrimitive = true; break; case CSSPropertyWebkitBackfaceVisibility: if (value->id == CSSValueVisible || value->id == CSSValueHidden) validPrimitive = true; break; case CSSPropertyWebkitPrintColorAdjust: if (value->id == CSSValueExact || value->id == CSSValueEconomy) validPrimitive = true; break; case CSSPropertyWebkitPerspective: if (id == CSSValueNone) validPrimitive = true; else { // Accepting valueless numbers is a quirk of the -webkit prefixed version of the property. if (validUnit(value, FNumber | FLength | FNonNeg, m_strict)) { RefPtr val = createPrimitiveNumericValue(value); if (val) { addProperty(propId, val.release(), important); return true; } return false; } } break; case CSSPropertyWebkitPerspectiveOrigin: case CSSPropertyWebkitPerspectiveOriginX: case CSSPropertyWebkitPerspectiveOriginY: { RefPtr val1; RefPtr val2; int propId1, propId2; if (parsePerspectiveOrigin(propId, propId1, propId2, val1, val2)) { addProperty(propId1, val1.release(), important); if (val2) addProperty(propId2, val2.release(), important); return true; } return false; } case CSSPropertyWebkitAnimationDelay: case CSSPropertyWebkitAnimationDirection: case CSSPropertyWebkitAnimationDuration: case CSSPropertyWebkitAnimationFillMode: case CSSPropertyWebkitAnimationName: case CSSPropertyWebkitAnimationPlayState: case CSSPropertyWebkitAnimationIterationCount: case CSSPropertyWebkitAnimationTimingFunction: case CSSPropertyWebkitTransitionDelay: case CSSPropertyWebkitTransitionDuration: case CSSPropertyWebkitTransitionTimingFunction: case CSSPropertyWebkitTransitionProperty: { RefPtr val; if (parseAnimationProperty(propId, val)) { addProperty(propId, val.release(), important); return true; } return false; } #if ENABLE(CSS_GRID_LAYOUT) case CSSPropertyWebkitGridColumns: case CSSPropertyWebkitGridRows: return parseGridTrackList(propId, important); #endif case CSSPropertyWebkitMarginCollapse: { const int properties[2] = { CSSPropertyWebkitMarginBeforeCollapse, CSSPropertyWebkitMarginAfterCollapse }; if (num == 1) { ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse); if (!parseValue(properties[0], important)) return false; CSSValue* value = m_parsedProperties[m_numParsedProperties-1]->value(); addProperty(properties[1], value, important); return true; } else if (num == 2) { ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse); if (!parseValue(properties[0], important) || !parseValue(properties[1], important)) return false; return true; } return false; } case CSSPropertyWebkitMarginBeforeCollapse: case CSSPropertyWebkitMarginAfterCollapse: case CSSPropertyWebkitMarginTopCollapse: case CSSPropertyWebkitMarginBottomCollapse: if (id == CSSValueCollapse || id == CSSValueSeparate || id == CSSValueDiscard) validPrimitive = true; break; case CSSPropertyTextLineThroughMode: case CSSPropertyTextOverlineMode: case CSSPropertyTextUnderlineMode: if (id == CSSValueContinuous || id == CSSValueSkipWhiteSpace) validPrimitive = true; break; case CSSPropertyTextLineThroughStyle: case CSSPropertyTextOverlineStyle: case CSSPropertyTextUnderlineStyle: if (id == CSSValueNone || id == CSSValueSolid || id == CSSValueDouble || id == CSSValueDashed || id == CSSValueDotDash || id == CSSValueDotDotDash || id == CSSValueWave) validPrimitive = true; break; case CSSPropertyTextRendering: // auto | optimizeSpeed | optimizeLegibility | geometricPrecision if (id == CSSValueAuto || id == CSSValueOptimizespeed || id == CSSValueOptimizelegibility || id == CSSValueGeometricprecision) validPrimitive = true; break; case CSSPropertyTextLineThroughWidth: case CSSPropertyTextOverlineWidth: case CSSPropertyTextUnderlineWidth: if (id == CSSValueAuto || id == CSSValueNormal || id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick) validPrimitive = true; else validPrimitive = !id && validUnit(value, FNumber | FLength | FPercent, m_strict); break; case CSSPropertyResize: // none | both | horizontal | vertical | auto if (id == CSSValueNone || id == CSSValueBoth || id == CSSValueHorizontal || id == CSSValueVertical || id == CSSValueAuto) validPrimitive = true; break; case CSSPropertyWebkitColumnCount: if (id == CSSValueAuto) validPrimitive = true; else validPrimitive = !id && validUnit(value, FInteger | FNonNeg, false); break; case CSSPropertyWebkitColumnGap: // normal | if (id == CSSValueNormal) validPrimitive = true; else validPrimitive = validUnit(value, FLength | FNonNeg, m_strict); break; case CSSPropertyWebkitColumnAxis: if (id == CSSValueHorizontal || id == CSSValueVertical || id == CSSValueAuto) validPrimitive = true; break; case CSSPropertyWebkitColumnSpan: // all | 1 if (id == CSSValueAll) validPrimitive = true; else validPrimitive = validUnit(value, FNumber | FNonNeg, m_strict) && value->fValue == 1; break; case CSSPropertyWebkitColumnWidth: // auto | if (id == CSSValueAuto) validPrimitive = true; else // Always parse this property in strict mode, since it would be ambiguous otherwise when used in the 'columns' shorthand property. validPrimitive = validUnit(value, FLength, true); break; case CSSPropertyPointerEvents: // none | visiblePainted | visibleFill | visibleStroke | visible | // painted | fill | stroke | auto | all | inherit if (id == CSSValueVisible || id == CSSValueNone || id == CSSValueAll || id == CSSValueAuto || (id >= CSSValueVisiblepainted && id <= CSSValueStroke)) validPrimitive = true; break; case CSSPropertyImageRendering: // auto | optimizeContrast if (id == CSSValueAuto || id == CSSValueWebkitOptimizeContrast) validPrimitive = true; break; // End of CSS3 properties // Apple specific properties. These will never be standardized and are purely to // support custom WebKit-based Apple applications. case CSSPropertyWebkitLineClamp: // When specifying number of lines, don't allow 0 as a valid value // When specifying either type of unit, require non-negative integers validPrimitive = (!id && (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE || value->fValue) && validUnit(value, FInteger | FPercent | FNonNeg, false)); break; case CSSPropertyWebkitTextSizeAdjust: if (id == CSSValueAuto || id == CSSValueNone) validPrimitive = true; break; case CSSPropertyWebkitRtlOrdering: if (id == CSSValueLogical || id == CSSValueVisual) validPrimitive = true; break; case CSSPropertyWebkitFontSizeDelta: // validPrimitive = validUnit(value, FLength, m_strict); break; case CSSPropertyWebkitNbspMode: // normal | space if (id == CSSValueNormal || id == CSSValueSpace) validPrimitive = true; break; case CSSPropertyWebkitLineBreak: // normal | after-white-space if (id == CSSValueNormal || id == CSSValueAfterWhiteSpace) validPrimitive = true; break; case CSSPropertyWebkitMatchNearestMailBlockquoteColor: // normal | match if (id == CSSValueNormal || id == CSSValueMatch) validPrimitive = true; break; case CSSPropertyWebkitHighlight: if (id == CSSValueNone || value->unit == CSSPrimitiveValue::CSS_STRING) validPrimitive = true; break; case CSSPropertyWebkitHyphens: if (id == CSSValueNone || id == CSSValueManual || id == CSSValueAuto) validPrimitive = true; break; case CSSPropertyWebkitHyphenateCharacter: if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING) validPrimitive = true; break; case CSSPropertyWebkitHyphenateLimitBefore: case CSSPropertyWebkitHyphenateLimitAfter: if (id == CSSValueAuto || validUnit(value, FInteger | FNonNeg, true)) validPrimitive = true; break; case CSSPropertyWebkitHyphenateLimitLines: if (id == CSSValueNoLimit || validUnit(value, FInteger | FNonNeg, true)) validPrimitive = true; break; case CSSPropertyWebkitLineGrid: if (id == CSSValueNone) validPrimitive = true; else if (value->unit == CSSPrimitiveValue::CSS_IDENT) { String lineGridValue = String(value->string); if (!lineGridValue.isEmpty()) { addProperty(propId, cssValuePool()->createValue(lineGridValue, CSSPrimitiveValue::CSS_STRING), important); return true; } } break; case CSSPropertyWebkitLineGridSnap: if (id == CSSValueNone || id == CSSValueBaseline || id == CSSValueContain) validPrimitive = true; break; case CSSPropertyWebkitLocale: if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING) validPrimitive = true; break; case CSSPropertyWebkitBorderFit: if (id == CSSValueBorder || id == CSSValueLines) validPrimitive = true; break; case CSSPropertyWebkitTextSecurity: // disc | circle | square | none | inherit if (id == CSSValueDisc || id == CSSValueCircle || id == CSSValueSquare|| id == CSSValueNone) validPrimitive = true; break; case CSSPropertyWebkitFontSmoothing: if (id == CSSValueAuto || id == CSSValueNone || id == CSSValueAntialiased || id == CSSValueSubpixelAntialiased) validPrimitive = true; break; #if ENABLE(DASHBOARD_SUPPORT) case CSSPropertyWebkitDashboardRegion: // | if (value->unit == CSSParserValue::Function || id == CSSValueNone) return parseDashboardRegions(propId, important); break; #endif // End Apple-specific properties #if ENABLE(TOUCH_EVENTS) case CSSPropertyWebkitTapHighlightColor: if ((id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || (id >= CSSValueWebkitFocusRingColor && id < CSSValueWebkitText && !m_strict)) { validPrimitive = true; } else { parsedValue = parseColor(); if (parsedValue) m_valueList->next(); } break; #endif /* shorthand properties */ case CSSPropertyBackground: { // Position must come before color in this array because a plain old "0" is a legal color // in quirks mode but it's usually the X coordinate of a position. // FIXME: Add CSSPropertyBackgroundSize to the shorthand. const int properties[] = { CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat, CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition, CSSPropertyBackgroundOrigin, CSSPropertyBackgroundClip, CSSPropertyBackgroundColor }; return parseFillShorthand(propId, properties, 7, important); } case CSSPropertyWebkitMask: { const int properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat, CSSPropertyWebkitMaskAttachment, CSSPropertyWebkitMaskPosition, CSSPropertyWebkitMaskOrigin, CSSPropertyWebkitMaskClip }; return parseFillShorthand(propId, properties, 6, important); } case CSSPropertyBorder: // [ 'border-width' || 'border-style' || ] | inherit { const int properties[3] = { CSSPropertyBorderWidth, CSSPropertyBorderStyle, CSSPropertyBorderColor }; if (parseShorthand(propId, properties, 3, important)) { // The CSS3 Borders and Backgrounds specification says that border also resets border-image. It's as // though a value of none was specified for the image. addProperty(CSSPropertyBorderImage, cssValuePool()->createImplicitInitialValue(), important); return true; } return false; } case CSSPropertyBorderTop: // [ 'border-top-width' || 'border-style' || ] | inherit { const int properties[3] = { CSSPropertyBorderTopWidth, CSSPropertyBorderTopStyle, CSSPropertyBorderTopColor}; return parseShorthand(propId, properties, 3, important); } case CSSPropertyBorderRight: // [ 'border-right-width' || 'border-style' || ] | inherit { const int properties[3] = { CSSPropertyBorderRightWidth, CSSPropertyBorderRightStyle, CSSPropertyBorderRightColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyBorderBottom: // [ 'border-bottom-width' || 'border-style' || ] | inherit { const int properties[3] = { CSSPropertyBorderBottomWidth, CSSPropertyBorderBottomStyle, CSSPropertyBorderBottomColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyBorderLeft: // [ 'border-left-width' || 'border-style' || ] | inherit { const int properties[3] = { CSSPropertyBorderLeftWidth, CSSPropertyBorderLeftStyle, CSSPropertyBorderLeftColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyWebkitBorderStart: { const int properties[3] = { CSSPropertyWebkitBorderStartWidth, CSSPropertyWebkitBorderStartStyle, CSSPropertyWebkitBorderStartColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyWebkitBorderEnd: { const int properties[3] = { CSSPropertyWebkitBorderEndWidth, CSSPropertyWebkitBorderEndStyle, CSSPropertyWebkitBorderEndColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyWebkitBorderBefore: { const int properties[3] = { CSSPropertyWebkitBorderBeforeWidth, CSSPropertyWebkitBorderBeforeStyle, CSSPropertyWebkitBorderBeforeColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyWebkitBorderAfter: { const int properties[3] = { CSSPropertyWebkitBorderAfterWidth, CSSPropertyWebkitBorderAfterStyle, CSSPropertyWebkitBorderAfterColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyOutline: // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit { const int properties[3] = { CSSPropertyOutlineWidth, CSSPropertyOutlineStyle, CSSPropertyOutlineColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyBorderColor: // {1,4} | inherit { const int properties[4] = { CSSPropertyBorderTopColor, CSSPropertyBorderRightColor, CSSPropertyBorderBottomColor, CSSPropertyBorderLeftColor }; return parse4Values(propId, properties, important); } case CSSPropertyBorderWidth: // {1,4} | inherit { const int properties[4] = { CSSPropertyBorderTopWidth, CSSPropertyBorderRightWidth, CSSPropertyBorderBottomWidth, CSSPropertyBorderLeftWidth }; return parse4Values(propId, properties, important); } case CSSPropertyBorderStyle: // {1,4} | inherit { const int properties[4] = { CSSPropertyBorderTopStyle, CSSPropertyBorderRightStyle, CSSPropertyBorderBottomStyle, CSSPropertyBorderLeftStyle }; return parse4Values(propId, properties, important); } case CSSPropertyMargin: // {1,4} | inherit { const int properties[4] = { CSSPropertyMarginTop, CSSPropertyMarginRight, CSSPropertyMarginBottom, CSSPropertyMarginLeft }; return parse4Values(propId, properties, important); } case CSSPropertyPadding: // {1,4} | inherit { const int properties[4] = { CSSPropertyPaddingTop, CSSPropertyPaddingRight, CSSPropertyPaddingBottom, CSSPropertyPaddingLeft }; return parse4Values(propId, properties, important); } case CSSPropertyWebkitFlexFlow: { const int properties[] = { CSSPropertyWebkitFlexDirection, CSSPropertyWebkitFlexWrap }; return parseShorthand(propId, properties, 2, important); } case CSSPropertyFont: // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]? // 'font-family' ] | caption | icon | menu | message-box | small-caption | status-bar | inherit if (id >= CSSValueCaption && id <= CSSValueStatusBar) validPrimitive = true; else return parseFont(important); break; case CSSPropertyListStyle: { const int properties[3] = { CSSPropertyListStyleType, CSSPropertyListStylePosition, CSSPropertyListStyleImage }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyWebkitColumns: { const int properties[2] = { CSSPropertyWebkitColumnWidth, CSSPropertyWebkitColumnCount }; return parseShorthand(propId, properties, 2, important); } case CSSPropertyWebkitColumnRule: { const int properties[3] = { CSSPropertyWebkitColumnRuleWidth, CSSPropertyWebkitColumnRuleStyle, CSSPropertyWebkitColumnRuleColor }; return parseShorthand(propId, properties, 3, important); } case CSSPropertyWebkitTextStroke: { const int properties[2] = { CSSPropertyWebkitTextStrokeWidth, CSSPropertyWebkitTextStrokeColor }; return parseShorthand(propId, properties, 2, important); } case CSSPropertyWebkitAnimation: return parseAnimationShorthand(important); case CSSPropertyWebkitTransition: return parseTransitionShorthand(important); case CSSPropertyInvalid: return false; case CSSPropertyPage: return parsePage(propId, important); case CSSPropertyFontStretch: case CSSPropertyTextLineThrough: case CSSPropertyTextOverline: case CSSPropertyTextUnderline: return false; // CSS Text Layout Module Level 3: Vertical writing support case CSSPropertyWebkitWritingMode: if (id >= CSSValueHorizontalTb && id <= CSSValueHorizontalBt) validPrimitive = true; break; case CSSPropertyWebkitTextCombine: if (id == CSSValueNone || id == CSSValueHorizontal) validPrimitive = true; break; case CSSPropertyWebkitTextEmphasis: { const int properties[] = { CSSPropertyWebkitTextEmphasisStyle, CSSPropertyWebkitTextEmphasisColor }; return parseShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important); } case CSSPropertyWebkitTextEmphasisPosition: if (id == CSSValueOver || id == CSSValueUnder) validPrimitive = true; break; case CSSPropertyWebkitTextEmphasisStyle: return parseTextEmphasisStyle(important); case CSSPropertyWebkitTextOrientation: // FIXME: For now just support upright and vertical-right. if (id == CSSValueVerticalRight || id == CSSValueUpright) validPrimitive = true; break; case CSSPropertyWebkitLineBoxContain: if (id == CSSValueNone) validPrimitive = true; else return parseLineBoxContain(important); break; case CSSPropertyWebkitFontFeatureSettings: if (id == CSSValueNormal) validPrimitive = true; else return parseFontFeatureSettings(important); break; case CSSPropertyWebkitFontKerning: if (id == CSSValueAuto || id == CSSValueNormal || id == CSSValueNone) validPrimitive = true; break; case CSSPropertyWebkitFontVariantLigatures: if (id == CSSValueNormal) validPrimitive = true; else return parseFontVariantLigatures(important); break; case CSSPropertyWebkitWrapShapeInside: case CSSPropertyWebkitWrapShapeOutside: if (id == CSSValueAuto) validPrimitive = true; else if (value->unit == CSSParserValue::Function) return parseWrapShape((propId == CSSPropertyWebkitWrapShapeInside), important); break; case CSSPropertyWebkitWrapFlow: if (id == CSSValueAuto || id == CSSValueBoth || id == CSSValueLeft || id == CSSValueRight || id == CSSValueMaximum || id == CSSValueClear) validPrimitive = true; break; case CSSPropertyWebkitWrapThrough: if (id == CSSValueWrap || id == CSSValueNone) validPrimitive = true; break; case CSSPropertyWebkitWrapMargin: case CSSPropertyWebkitWrapPadding: validPrimitive = (!id && validUnit(value, FLength | FNonNeg, m_strict)); break; case CSSPropertyWebkitWrap: { const int properties[] = { CSSPropertyWebkitWrapFlow, CSSPropertyWebkitWrapMargin, CSSPropertyWebkitWrapPadding }; return parseShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important); } #if ENABLE(SVG) default: return parseSVGValue(propId, important); #endif } if (validPrimitive) { parsedValue = parseValidPrimitive(id, value); m_valueList->next(); } ASSERT(!m_parsedCalculation); if (parsedValue) { if (!m_valueList->current() || inShorthand()) { addProperty(propId, parsedValue.release(), important); return true; } } return false; } void CSSParser::addFillValue(RefPtr& lval, PassRefPtr rval) { if (lval) { if (lval->isValueList()) static_cast(lval.get())->append(rval); else { PassRefPtr oldlVal(lval.release()); PassRefPtr list = CSSValueList::createCommaSeparated(); list->append(oldlVal); list->append(rval); lval = list; } } else lval = rval; } static bool parseBackgroundClip(CSSParserValue* parserValue, RefPtr& cssValue, CSSValuePool* cssValuePool) { if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox || parserValue->id == CSSValueContentBox || parserValue->id == CSSValueWebkitText) { cssValue = cssValuePool->createIdentifierValue(parserValue->id); return true; } return false; } const int cMaxFillProperties = 9; bool CSSParser::parseFillShorthand(int propId, const int* properties, int numProperties, bool important) { ASSERT(numProperties <= cMaxFillProperties); if (numProperties > cMaxFillProperties) return false; ShorthandScope scope(this, propId); bool parsedProperty[cMaxFillProperties] = { false }; RefPtr values[cMaxFillProperties]; RefPtr clipValue; RefPtr positionYValue; RefPtr repeatYValue; bool foundClip = false; int i; while (m_valueList->current()) { CSSParserValue* val = m_valueList->current(); if (val->unit == CSSParserValue::Operator && val->iValue == ',') { // We hit the end. Fill in all remaining values with the initial value. m_valueList->next(); for (i = 0; i < numProperties; ++i) { if (properties[i] == CSSPropertyBackgroundColor && parsedProperty[i]) // Color is not allowed except as the last item in a list for backgrounds. // Reject the entire property. return false; if (!parsedProperty[i] && properties[i] != CSSPropertyBackgroundColor) { addFillValue(values[i], cssValuePool()->createImplicitInitialValue()); if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition) addFillValue(positionYValue, cssValuePool()->createImplicitInitialValue()); if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat) addFillValue(repeatYValue, cssValuePool()->createImplicitInitialValue()); if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) { // If background-origin wasn't present, then reset background-clip also. addFillValue(clipValue, cssValuePool()->createImplicitInitialValue()); } } parsedProperty[i] = false; } if (!m_valueList->current()) break; } bool found = false; for (i = 0; !found && i < numProperties; ++i) { if (!parsedProperty[i]) { RefPtr val1; RefPtr val2; int propId1, propId2; CSSParserValue* parserValue = m_valueList->current(); if (parseFillProperty(properties[i], propId1, propId2, val1, val2)) { parsedProperty[i] = found = true; addFillValue(values[i], val1.release()); if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition) addFillValue(positionYValue, val2.release()); if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat) addFillValue(repeatYValue, val2.release()); if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) { // Reparse the value as a clip, and see if we succeed. if (parseBackgroundClip(parserValue, val1, cssValuePool())) addFillValue(clipValue, val1.release()); // The property parsed successfully. else addFillValue(clipValue, cssValuePool()->createImplicitInitialValue()); // Some value was used for origin that is not supported by clip. Just reset clip instead. } if (properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) { // Update clipValue addFillValue(clipValue, val1.release()); foundClip = true; } } } } // if we didn't find at least one match, this is an // invalid shorthand and we have to ignore it if (!found) return false; } // Fill in any remaining properties with the initial value. for (i = 0; i < numProperties; ++i) { if (!parsedProperty[i]) { addFillValue(values[i], cssValuePool()->createImplicitInitialValue()); if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition) addFillValue(positionYValue, cssValuePool()->createImplicitInitialValue()); if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat) addFillValue(repeatYValue, cssValuePool()->createImplicitInitialValue()); if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) { // If background-origin wasn't present, then reset background-clip also. addFillValue(clipValue, cssValuePool()->createImplicitInitialValue()); } } } // Now add all of the properties we found. for (i = 0; i < numProperties; i++) { if (properties[i] == CSSPropertyBackgroundPosition) { addProperty(CSSPropertyBackgroundPositionX, values[i].release(), important); // it's OK to call positionYValue.release() since we only see CSSPropertyBackgroundPosition once addProperty(CSSPropertyBackgroundPositionY, positionYValue.release(), important); } else if (properties[i] == CSSPropertyWebkitMaskPosition) { addProperty(CSSPropertyWebkitMaskPositionX, values[i].release(), important); // it's OK to call positionYValue.release() since we only see CSSPropertyWebkitMaskPosition once addProperty(CSSPropertyWebkitMaskPositionY, positionYValue.release(), important); } else if (properties[i] == CSSPropertyBackgroundRepeat) { addProperty(CSSPropertyBackgroundRepeatX, values[i].release(), important); // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once addProperty(CSSPropertyBackgroundRepeatY, repeatYValue.release(), important); } else if (properties[i] == CSSPropertyWebkitMaskRepeat) { addProperty(CSSPropertyWebkitMaskRepeatX, values[i].release(), important); // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once addProperty(CSSPropertyWebkitMaskRepeatY, repeatYValue.release(), important); } else if ((properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) && !foundClip) // Value is already set while updating origin continue; else addProperty(properties[i], values[i].release(), important); // Add in clip values when we hit the corresponding origin property. if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip) addProperty(CSSPropertyBackgroundClip, clipValue.release(), important); else if (properties[i] == CSSPropertyWebkitMaskOrigin && !foundClip) addProperty(CSSPropertyWebkitMaskClip, clipValue.release(), important); } return true; } void CSSParser::addAnimationValue(RefPtr& lval, PassRefPtr rval) { if (lval) { if (lval->isValueList()) static_cast(lval.get())->append(rval); else { PassRefPtr oldVal(lval.release()); PassRefPtr list = CSSValueList::createCommaSeparated(); list->append(oldVal); list->append(rval); lval = list; } } else lval = rval; } bool CSSParser::parseAnimationShorthand(bool important) { const int properties[] = { CSSPropertyWebkitAnimationName, CSSPropertyWebkitAnimationDuration, CSSPropertyWebkitAnimationTimingFunction, CSSPropertyWebkitAnimationDelay, CSSPropertyWebkitAnimationIterationCount, CSSPropertyWebkitAnimationDirection, CSSPropertyWebkitAnimationFillMode }; const int numProperties = WTF_ARRAY_LENGTH(properties); ShorthandScope scope(this, CSSPropertyWebkitAnimation); bool parsedProperty[numProperties] = { false }; // compiler will repeat false as necessary RefPtr values[numProperties]; int i; while (m_valueList->current()) { CSSParserValue* val = m_valueList->current(); if (val->unit == CSSParserValue::Operator && val->iValue == ',') { // We hit the end. Fill in all remaining values with the initial value. m_valueList->next(); for (i = 0; i < numProperties; ++i) { if (!parsedProperty[i]) addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue()); parsedProperty[i] = false; } if (!m_valueList->current()) break; } bool found = false; for (i = 0; !found && i < numProperties; ++i) { if (!parsedProperty[i]) { RefPtr val; if (parseAnimationProperty(properties[i], val)) { parsedProperty[i] = found = true; addAnimationValue(values[i], val.release()); } } } // if we didn't find at least one match, this is an // invalid shorthand and we have to ignore it if (!found) return false; } // Fill in any remaining properties with the initial value. for (i = 0; i < numProperties; ++i) { if (!parsedProperty[i]) addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue()); } // Now add all of the properties we found. for (i = 0; i < numProperties; i++) addProperty(properties[i], values[i].release(), important); return true; } bool CSSParser::parseTransitionShorthand(bool important) { const int properties[] = { CSSPropertyWebkitTransitionProperty, CSSPropertyWebkitTransitionDuration, CSSPropertyWebkitTransitionTimingFunction, CSSPropertyWebkitTransitionDelay }; const int numProperties = WTF_ARRAY_LENGTH(properties); ShorthandScope scope(this, CSSPropertyWebkitTransition); bool parsedProperty[numProperties] = { false }; // compiler will repeat false as necessary RefPtr values[numProperties]; int i; while (m_valueList->current()) { CSSParserValue* val = m_valueList->current(); if (val->unit == CSSParserValue::Operator && val->iValue == ',') { // We hit the end. Fill in all remaining values with the initial value. m_valueList->next(); for (i = 0; i < numProperties; ++i) { if (!parsedProperty[i]) addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue()); parsedProperty[i] = false; } if (!m_valueList->current()) break; } bool found = false; for (i = 0; !found && i < numProperties; ++i) { if (!parsedProperty[i]) { RefPtr val; if (parseAnimationProperty(properties[i], val)) { parsedProperty[i] = found = true; addAnimationValue(values[i], val.release()); } } } // if we didn't find at least one match, this is an // invalid shorthand and we have to ignore it if (!found) return false; } // Fill in any remaining properties with the initial value. for (i = 0; i < numProperties; ++i) { if (!parsedProperty[i]) addAnimationValue(values[i], cssValuePool()->createImplicitInitialValue()); } // Now add all of the properties we found. for (i = 0; i < numProperties; i++) addProperty(properties[i], values[i].release(), important); return true; } bool CSSParser::parseShorthand(int propId, const int *properties, int numProperties, bool important) { // We try to match as many properties as possible // We set up an array of booleans to mark which property has been found, // and we try to search for properties until it makes no longer any sense. ShorthandScope scope(this, propId); bool found = false; bool fnd[6]; // Trust me ;) for (int i = 0; i < numProperties; i++) fnd[i] = false; while (m_valueList->current()) { found = false; for (int propIndex = 0; !found && propIndex < numProperties; ++propIndex) { if (!fnd[propIndex]) { if (parseValue(properties[propIndex], important)) fnd[propIndex] = found = true; } } // if we didn't find at least one match, this is an // invalid shorthand and we have to ignore it if (!found) return false; } // Fill in any remaining properties with the initial value. ImplicitScope implicitScope(this, PropertyImplicit); for (int i = 0; i < numProperties; ++i) { if (!fnd[i]) addProperty(properties[i], cssValuePool()->createImplicitInitialValue(), important); } return true; } bool CSSParser::parse4Values(int propId, const int *properties, bool important) { /* From the CSS 2 specs, 8.3 * If there is only one value, it applies to all sides. If there are two values, the top and * bottom margins are set to the first value and the right and left margins are set to the second. * If there are three values, the top is set to the first value, the left and right are set to the * second, and the bottom is set to the third. If there are four values, they apply to the top, * right, bottom, and left, respectively. */ int num = inShorthand() ? 1 : m_valueList->size(); ShorthandScope scope(this, propId); // the order is top, right, bottom, left switch (num) { case 1: { if (!parseValue(properties[0], important)) return false; CSSValue *value = m_parsedProperties[m_numParsedProperties-1]->value(); ImplicitScope implicitScope(this, PropertyImplicit); addProperty(properties[1], value, important); addProperty(properties[2], value, important); addProperty(properties[3], value, important); break; } case 2: { if (!parseValue(properties[0], important) || !parseValue(properties[1], important)) return false; CSSValue *value = m_parsedProperties[m_numParsedProperties-2]->value(); ImplicitScope implicitScope(this, PropertyImplicit); addProperty(properties[2], value, important); value = m_parsedProperties[m_numParsedProperties-2]->value(); addProperty(properties[3], value, important); break; } case 3: { if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important)) return false; CSSValue *value = m_parsedProperties[m_numParsedProperties-2]->value(); ImplicitScope implicitScope(this, PropertyImplicit); addProperty(properties[3], value, important); break; } case 4: { if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important) || !parseValue(properties[3], important)) return false; break; } default: { return false; } } return true; } // auto | bool CSSParser::parsePage(int propId, bool important) { ASSERT(propId == CSSPropertyPage); if (m_valueList->size() != 1) return false; CSSParserValue* value = m_valueList->current(); if (!value) return false; if (value->id == CSSValueAuto) { addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important); return true; } else if (value->id == 0 && value->unit == CSSPrimitiveValue::CSS_IDENT) { addProperty(propId, createPrimitiveStringValue(value), important); return true; } return false; } // {1,2} | auto | [ || [ portrait | landscape] ] bool CSSParser::parseSize(int propId, bool important) { ASSERT(propId == CSSPropertySize); if (m_valueList->size() > 2) return false; CSSParserValue* value = m_valueList->current(); if (!value) return false; RefPtr parsedValues = CSSValueList::createSpaceSeparated(); // First parameter. SizeParameterType paramType = parseSizeParameter(parsedValues.get(), value, None); if (paramType == None) return false; // Second parameter, if any. value = m_valueList->next(); if (value) { paramType = parseSizeParameter(parsedValues.get(), value, paramType); if (paramType == None) return false; } addProperty(propId, parsedValues.release(), important); return true; } CSSParser::SizeParameterType CSSParser::parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType) { switch (value->id) { case CSSValueAuto: if (prevParamType == None) { parsedValues->append(cssValuePool()->createIdentifierValue(value->id)); return Auto; } return None; case CSSValueLandscape: case CSSValuePortrait: if (prevParamType == None || prevParamType == PageSize) { parsedValues->append(cssValuePool()->createIdentifierValue(value->id)); return Orientation; } return None; case CSSValueA3: case CSSValueA4: case CSSValueA5: case CSSValueB4: case CSSValueB5: case CSSValueLedger: case CSSValueLegal: case CSSValueLetter: if (prevParamType == None || prevParamType == Orientation) { // Normalize to Page Size then Orientation order by prepending. // This is not specified by the CSS3 Paged Media specification, but for simpler processing later (CSSStyleSelector::applyPageSizeProperty). parsedValues->prepend(cssValuePool()->createIdentifierValue(value->id)); return PageSize; } return None; case 0: if (validUnit(value, FLength | FNonNeg, m_strict) && (prevParamType == None || prevParamType == Length)) { parsedValues->append(createPrimitiveNumericValue(value)); return Length; } return None; default: return None; } } // [ ]+ | inherit | none // inherit and none are handled in parseValue. bool CSSParser::parseQuotes(int propId, bool important) { RefPtr values = CSSValueList::createCommaSeparated(); while (CSSParserValue* val = m_valueList->current()) { RefPtr parsedValue; if (val->unit == CSSPrimitiveValue::CSS_STRING) parsedValue = CSSPrimitiveValue::create(val->string, CSSPrimitiveValue::CSS_STRING); else break; values->append(parsedValue.release()); m_valueList->next(); } if (values->length()) { addProperty(propId, values.release(), important); m_valueList->next(); return true; } return false; } // [ | | | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit // in CSS 2.1 this got somewhat reduced: // [ | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit bool CSSParser::parseContent(int propId, bool important) { RefPtr values = CSSValueList::createCommaSeparated(); while (CSSParserValue* val = m_valueList->current()) { RefPtr parsedValue; if (val->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) { // url // FIXME: The completeURL call should be done when using the CSSImageValue, // not when creating it. parsedValue = CSSImageValue::create(m_styleSheet->completeURL(val->string)); } else if (val->unit == CSSParserValue::Function) { // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...) CSSParserValueList* args = val->function->args.get(); if (!args) return false; if (equalIgnoringCase(val->function->name, "attr(")) { parsedValue = parseAttr(args); if (!parsedValue) return false; } else if (equalIgnoringCase(val->function->name, "counter(")) { parsedValue = parseCounterContent(args, false); if (!parsedValue) return false; } else if (equalIgnoringCase(val->function->name, "counters(")) { parsedValue = parseCounterContent(args, true); if (!parsedValue) return false; } else if (isGeneratedImageValue(val)) { if (!parseGeneratedImage(m_valueList.get(), parsedValue)) return false; } else return false; } else if (val->unit == CSSPrimitiveValue::CSS_IDENT) { // open-quote // close-quote // no-open-quote // no-close-quote // inherit // FIXME: These are not yet implemented (http://bugs.webkit.org/show_bug.cgi?id=6503). // none // normal switch (val->id) { case CSSValueOpenQuote: case CSSValueCloseQuote: case CSSValueNoOpenQuote: case CSSValueNoCloseQuote: case CSSValueNone: case CSSValueNormal: parsedValue = cssValuePool()->createIdentifierValue(val->id); } } else if (val->unit == CSSPrimitiveValue::CSS_STRING) { parsedValue = createPrimitiveStringValue(val); } if (!parsedValue) break; values->append(parsedValue.release()); m_valueList->next(); } if (values->length()) { addProperty(propId, values.release(), important); m_valueList->next(); return true; } return false; } PassRefPtr CSSParser::parseAttr(CSSParserValueList* args) { if (args->size() != 1) return 0; CSSParserValue* a = args->current(); if (a->unit != CSSPrimitiveValue::CSS_IDENT) return 0; String attrName = a->string; // CSS allows identifiers with "-" at the start, like "-webkit-mask-image". // But HTML attribute names can't have those characters, and we should not // even parse them inside attr(). if (attrName[0] == '-') return 0; Document* document = findDocument(); if (document && document->isHTMLDocument()) attrName = attrName.lower(); return cssValuePool()->createValue(attrName, CSSPrimitiveValue::CSS_ATTR); } PassRefPtr CSSParser::parseBackgroundColor() { int id = m_valueList->current()->id; if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor || (id >= CSSValueGrey && id < CSSValueWebkitText && !m_strict)) return cssValuePool()->createIdentifierValue(id); return parseColor(); } bool CSSParser::parseFillImage(CSSParserValueList* valueList, RefPtr& value) { if (valueList->current()->id == CSSValueNone) { value = CSSImageValue::create(); return true; } if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) { // FIXME: The completeURL call should be done when using the CSSImageValue, // not when creating it. if (m_styleSheet) value = CSSImageValue::create(m_styleSheet->completeURL(valueList->current()->string)); return true; } if (isGeneratedImageValue(valueList->current())) return parseGeneratedImage(valueList, value); return false; } PassRefPtr CSSParser::parseFillPositionX(CSSParserValueList* valueList) { int id = valueList->current()->id; if (id == CSSValueLeft || id == CSSValueRight || id == CSSValueCenter) { int percent = 0; if (id == CSSValueRight) percent = 100; else if (id == CSSValueCenter) percent = 50; return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE); } if (validUnit(valueList->current(), FPercent | FLength, m_strict)) return createPrimitiveNumericValue(valueList->current()); return 0; } PassRefPtr CSSParser::parseFillPositionY(CSSParserValueList* valueList) { int id = valueList->current()->id; if (id == CSSValueTop || id == CSSValueBottom || id == CSSValueCenter) { int percent = 0; if (id == CSSValueBottom) percent = 100; else if (id == CSSValueCenter) percent = 50; return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE); } if (validUnit(valueList->current(), FPercent | FLength, m_strict)) return createPrimitiveNumericValue(valueList->current()); return 0; } PassRefPtr CSSParser::parseFillPositionComponent(CSSParserValueList* valueList, unsigned& cumulativeFlags, FillPositionFlag& individualFlag) { int id = valueList->current()->id; if (id == CSSValueLeft || id == CSSValueTop || id == CSSValueRight || id == CSSValueBottom || id == CSSValueCenter) { int percent = 0; if (id == CSSValueLeft || id == CSSValueRight) { if (cumulativeFlags & XFillPosition) return 0; cumulativeFlags |= XFillPosition; individualFlag = XFillPosition; if (id == CSSValueRight) percent = 100; } else if (id == CSSValueTop || id == CSSValueBottom) { if (cumulativeFlags & YFillPosition) return 0; cumulativeFlags |= YFillPosition; individualFlag = YFillPosition; if (id == CSSValueBottom) percent = 100; } else if (id == CSSValueCenter) { // Center is ambiguous, so we're not sure which position we've found yet, an x or a y. percent = 50; cumulativeFlags |= AmbiguousFillPosition; individualFlag = AmbiguousFillPosition; } return cssValuePool()->createValue(percent, CSSPrimitiveValue::CSS_PERCENTAGE); } if (validUnit(valueList->current(), FPercent | FLength, m_strict)) { if (!cumulativeFlags) { cumulativeFlags |= XFillPosition; individualFlag = XFillPosition; } else if (cumulativeFlags & (XFillPosition | AmbiguousFillPosition)) { cumulativeFlags |= YFillPosition; individualFlag = YFillPosition; } else { if (m_parsedCalculation) m_parsedCalculation.release(); return 0; } return createPrimitiveNumericValue(valueList->current()); } return 0; } void CSSParser::parseFillPosition(CSSParserValueList* valueList, RefPtr& value1, RefPtr& value2) { CSSParserValue* value = valueList->current(); // Parse the first value. We're just making sure that it is one of the valid keywords or a percentage/length. unsigned cumulativeFlags = 0; FillPositionFlag value1Flag = InvalidFillPosition; FillPositionFlag value2Flag = InvalidFillPosition; value1 = parseFillPositionComponent(valueList, cumulativeFlags, value1Flag); if (!value1) return; // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we // can assume that any other values belong to the rest of the shorthand). If we're not parsing a shorthand, though, the // value was explicitly specified for our property. value = valueList->next(); // First check for the comma. If so, we are finished parsing this value or value pair. if (value && value->unit == CSSParserValue::Operator && value->iValue == ',') value = 0; if (value) { value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag); if (value2) valueList->next(); else { if (!inShorthand()) { value1.clear(); return; } } } if (!value2) // Only one value was specified. If that value was not a keyword, then it sets the x position, and the y position // is simply 50%. This is our default. // For keywords, the keyword was either an x-keyword (left/right), a y-keyword (top/bottom), or an ambiguous keyword (center). // For left/right/center, the default of 50% in the y is still correct. value2 = cssValuePool()->createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE); if (value1Flag == YFillPosition || value2Flag == XFillPosition) value1.swap(value2); } void CSSParser::parseFillRepeat(RefPtr& value1, RefPtr& value2) { CSSParserValue* value = m_valueList->current(); int id = m_valueList->current()->id; if (id == CSSValueRepeatX) { m_implicitShorthand = true; value1 = cssValuePool()->createIdentifierValue(CSSValueRepeat); value2 = cssValuePool()->createIdentifierValue(CSSValueNoRepeat); m_valueList->next(); return; } if (id == CSSValueRepeatY) { m_implicitShorthand = true; value1 = cssValuePool()->createIdentifierValue(CSSValueNoRepeat); value2 = cssValuePool()->createIdentifierValue(CSSValueRepeat); m_valueList->next(); return; } if (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace) value1 = cssValuePool()->createIdentifierValue(id); else { value1 = 0; return; } value = m_valueList->next(); // First check for the comma. If so, we are finished parsing this value or value pair. if (value && value->unit == CSSParserValue::Operator && value->iValue == ',') value = 0; if (value) id = m_valueList->current()->id; if (value && (id == CSSValueRepeat || id == CSSValueNoRepeat || id == CSSValueRound || id == CSSValueSpace)) { value2 = cssValuePool()->createIdentifierValue(id); m_valueList->next(); } else { // If only one value was specified, value2 is the same as value1. m_implicitShorthand = true; value2 = cssValuePool()->createIdentifierValue(static_cast(value1.get())->getIdent()); } } PassRefPtr CSSParser::parseFillSize(int propId, bool& allowComma) { allowComma = true; CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueContain || value->id == CSSValueCover) return cssValuePool()->createIdentifierValue(value->id); RefPtr parsedValue1; if (value->id == CSSValueAuto) parsedValue1 = cssValuePool()->createIdentifierValue(CSSValueAuto); else { if (!validUnit(value, FLength | FPercent, m_strict)) return 0; parsedValue1 = createPrimitiveNumericValue(value); } CSSPropertyID property = static_cast(propId); RefPtr parsedValue2; if ((value = m_valueList->next())) { if (value->unit == CSSParserValue::Operator && value->iValue == ',') allowComma = false; else if (value->id != CSSValueAuto) { if (!validUnit(value, FLength | FPercent, m_strict)) return 0; parsedValue2 = createPrimitiveNumericValue(value); } } else if (!parsedValue2 && property == CSSPropertyWebkitBackgroundSize) { // For backwards compatibility we set the second value to the first if it is omitted. // We only need to do this for -webkit-background-size. It should be safe to let masks match // the real property. parsedValue2 = parsedValue1; } if (!parsedValue2) return parsedValue1; return cssValuePool()->createValue(Pair::create(parsedValue1.release(), parsedValue2.release())); } bool CSSParser::parseFillProperty(int propId, int& propId1, int& propId2, RefPtr& retValue1, RefPtr& retValue2) { RefPtr values; RefPtr values2; CSSParserValue* val; RefPtr value; RefPtr value2; bool allowComma = false; retValue1 = retValue2 = 0; propId1 = propId; propId2 = propId; if (propId == CSSPropertyBackgroundPosition) { propId1 = CSSPropertyBackgroundPositionX; propId2 = CSSPropertyBackgroundPositionY; } else if (propId == CSSPropertyWebkitMaskPosition) { propId1 = CSSPropertyWebkitMaskPositionX; propId2 = CSSPropertyWebkitMaskPositionY; } else if (propId == CSSPropertyBackgroundRepeat) { propId1 = CSSPropertyBackgroundRepeatX; propId2 = CSSPropertyBackgroundRepeatY; } else if (propId == CSSPropertyWebkitMaskRepeat) { propId1 = CSSPropertyWebkitMaskRepeatX; propId2 = CSSPropertyWebkitMaskRepeatY; } while ((val = m_valueList->current())) { RefPtr currValue; RefPtr currValue2; if (allowComma) { if (val->unit != CSSParserValue::Operator || val->iValue != ',') return false; m_valueList->next(); allowComma = false; } else { allowComma = true; switch (propId) { case CSSPropertyBackgroundColor: currValue = parseBackgroundColor(); if (currValue) m_valueList->next(); break; case CSSPropertyBackgroundAttachment: case CSSPropertyWebkitMaskAttachment: if (val->id == CSSValueScroll || val->id == CSSValueFixed || val->id == CSSValueLocal) { currValue = cssValuePool()->createIdentifierValue(val->id); m_valueList->next(); } break; case CSSPropertyBackgroundImage: case CSSPropertyWebkitMaskImage: if (parseFillImage(m_valueList.get(), currValue)) m_valueList->next(); break; case CSSPropertyWebkitBackgroundClip: case CSSPropertyWebkitBackgroundOrigin: case CSSPropertyWebkitMaskClip: case CSSPropertyWebkitMaskOrigin: // The first three values here are deprecated and do not apply to the version of the property that has // the -webkit- prefix removed. if (val->id == CSSValueBorder || val->id == CSSValuePadding || val->id == CSSValueContent || val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox || ((propId == CSSPropertyWebkitBackgroundClip || propId == CSSPropertyWebkitMaskClip) && (val->id == CSSValueText || val->id == CSSValueWebkitText))) { currValue = cssValuePool()->createIdentifierValue(val->id); m_valueList->next(); } break; case CSSPropertyBackgroundClip: if (parseBackgroundClip(val, currValue, cssValuePool())) m_valueList->next(); break; case CSSPropertyBackgroundOrigin: if (val->id == CSSValueBorderBox || val->id == CSSValuePaddingBox || val->id == CSSValueContentBox) { currValue = cssValuePool()->createIdentifierValue(val->id); m_valueList->next(); } break; case CSSPropertyBackgroundPosition: case CSSPropertyWebkitMaskPosition: parseFillPosition(m_valueList.get(), currValue, currValue2); // parseFillPosition advances the m_valueList pointer break; case CSSPropertyBackgroundPositionX: case CSSPropertyWebkitMaskPositionX: { currValue = parseFillPositionX(m_valueList.get()); if (currValue) m_valueList->next(); break; } case CSSPropertyBackgroundPositionY: case CSSPropertyWebkitMaskPositionY: { currValue = parseFillPositionY(m_valueList.get()); if (currValue) m_valueList->next(); break; } case CSSPropertyWebkitBackgroundComposite: case CSSPropertyWebkitMaskComposite: if ((val->id >= CSSValueClear && val->id <= CSSValuePlusLighter) || val->id == CSSValueHighlight) { currValue = cssValuePool()->createIdentifierValue(val->id); m_valueList->next(); } break; case CSSPropertyBackgroundRepeat: case CSSPropertyWebkitMaskRepeat: parseFillRepeat(currValue, currValue2); // parseFillRepeat advances the m_valueList pointer break; case CSSPropertyBackgroundSize: case CSSPropertyWebkitBackgroundSize: case CSSPropertyWebkitMaskSize: { currValue = parseFillSize(propId, allowComma); if (currValue) m_valueList->next(); break; } } if (!currValue) return false; if (value && !values) { values = CSSValueList::createCommaSeparated(); values->append(value.release()); } if (value2 && !values2) { values2 = CSSValueList::createCommaSeparated(); values2->append(value2.release()); } if (values) values->append(currValue.release()); else value = currValue.release(); if (currValue2) { if (values2) values2->append(currValue2.release()); else value2 = currValue2.release(); } } // When parsing any fill shorthand property, we let it handle building up the lists for all // properties. if (inShorthand()) break; } if (values && values->length()) { retValue1 = values.release(); if (values2 && values2->length()) retValue2 = values2.release(); return true; } if (value) { retValue1 = value.release(); retValue2 = value2.release(); return true; } return false; } PassRefPtr CSSParser::parseAnimationDelay() { CSSParserValue* value = m_valueList->current(); if (validUnit(value, FTime, m_strict)) return createPrimitiveNumericValue(value); return 0; } PassRefPtr CSSParser::parseAnimationDirection() { CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueNormal || value->id == CSSValueAlternate || value->id == CSSValueReverse || value->id == CSSValueAlternateReverse) return cssValuePool()->createIdentifierValue(value->id); return 0; } PassRefPtr CSSParser::parseAnimationDuration() { CSSParserValue* value = m_valueList->current(); if (validUnit(value, FTime | FNonNeg, m_strict)) return createPrimitiveNumericValue(value); return 0; } PassRefPtr CSSParser::parseAnimationFillMode() { CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueNone || value->id == CSSValueForwards || value->id == CSSValueBackwards || value->id == CSSValueBoth) return cssValuePool()->createIdentifierValue(value->id); return 0; } PassRefPtr CSSParser::parseAnimationIterationCount() { CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueInfinite) return cssValuePool()->createIdentifierValue(value->id); if (validUnit(value, FInteger | FNonNeg, m_strict)) return createPrimitiveNumericValue(value); return 0; } PassRefPtr CSSParser::parseAnimationName() { CSSParserValue* value = m_valueList->current(); if (value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT) { if (value->id == CSSValueNone || (value->unit == CSSPrimitiveValue::CSS_STRING && equalIgnoringCase(value->string, "none"))) { return cssValuePool()->createIdentifierValue(CSSValueNone); } else { return createPrimitiveStringValue(value); } } return 0; } PassRefPtr CSSParser::parseAnimationPlayState() { CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueRunning || value->id == CSSValuePaused) return cssValuePool()->createIdentifierValue(value->id); return 0; } PassRefPtr CSSParser::parseAnimationProperty() { CSSParserValue* value = m_valueList->current(); if (value->unit != CSSPrimitiveValue::CSS_IDENT) return 0; int result = cssPropertyID(value->string); if (result) return cssValuePool()->createIdentifierValue(result); if (equalIgnoringCase(value->string, "all")) return cssValuePool()->createIdentifierValue(CSSValueAll); if (equalIgnoringCase(value->string, "none")) return cssValuePool()->createIdentifierValue(CSSValueNone); return 0; } bool CSSParser::parseTransformOriginShorthand(RefPtr& value1, RefPtr& value2, RefPtr& value3) { parseFillPosition(m_valueList.get(), value1, value2); // now get z if (m_valueList->current()) { if (validUnit(m_valueList->current(), FLength, m_strict)) { value3 = createPrimitiveNumericValue(m_valueList->current()); m_valueList->next(); return true; } return false; } return true; } bool CSSParser::parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result) { CSSParserValue* v = args->current(); if (!validUnit(v, FNumber, m_strict)) return false; result = v->fValue; v = args->next(); if (!v) // The last number in the function has no comma after it, so we're done. return true; if (v->unit != CSSParserValue::Operator && v->iValue != ',') return false; v = args->next(); return true; } PassRefPtr CSSParser::parseAnimationTimingFunction() { CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueEase || value->id == CSSValueLinear || value->id == CSSValueEaseIn || value->id == CSSValueEaseOut || value->id == CSSValueEaseInOut || value->id == CSSValueStepStart || value->id == CSSValueStepEnd) return cssValuePool()->createIdentifierValue(value->id); // We must be a function. if (value->unit != CSSParserValue::Function) return 0; CSSParserValueList* args = value->function->args.get(); if (equalIgnoringCase(value->function->name, "steps(")) { // For steps, 1 or 2 params must be specified (comma-separated) if (!args || (args->size() != 1 && args->size() != 3)) return 0; // There are two values. int numSteps; bool stepAtStart = false; CSSParserValue* v = args->current(); if (!validUnit(v, FInteger, m_strict)) return 0; numSteps = clampToInteger(v->fValue); if (numSteps < 1) return 0; v = args->next(); if (v) { // There is a comma so we need to parse the second value if (v->unit != CSSParserValue::Operator && v->iValue != ',') return 0; v = args->next(); if (v->id != CSSValueStart && v->id != CSSValueEnd) return 0; stepAtStart = v->id == CSSValueStart; } return CSSStepsTimingFunctionValue::create(numSteps, stepAtStart); } if (equalIgnoringCase(value->function->name, "cubic-bezier(")) { // For cubic bezier, 4 values must be specified. if (!args || args->size() != 7) return 0; // There are two points specified. The values must be between 0 and 1. double x1, y1, x2, y2; if (!parseCubicBezierTimingFunctionValue(args, x1)) return 0; if (!parseCubicBezierTimingFunctionValue(args, y1)) return 0; if (!parseCubicBezierTimingFunctionValue(args, x2)) return 0; if (!parseCubicBezierTimingFunctionValue(args, y2)) return 0; return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2); } return 0; } bool CSSParser::parseAnimationProperty(int propId, RefPtr& result) { RefPtr values; CSSParserValue* val; RefPtr value; bool allowComma = false; result = 0; while ((val = m_valueList->current())) { RefPtr currValue; if (allowComma) { if (val->unit != CSSParserValue::Operator || val->iValue != ',') return false; m_valueList->next(); allowComma = false; } else { switch (propId) { case CSSPropertyWebkitAnimationDelay: case CSSPropertyWebkitTransitionDelay: currValue = parseAnimationDelay(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitAnimationDirection: currValue = parseAnimationDirection(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitAnimationDuration: case CSSPropertyWebkitTransitionDuration: currValue = parseAnimationDuration(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitAnimationFillMode: currValue = parseAnimationFillMode(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitAnimationIterationCount: currValue = parseAnimationIterationCount(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitAnimationName: currValue = parseAnimationName(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitAnimationPlayState: currValue = parseAnimationPlayState(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitTransitionProperty: currValue = parseAnimationProperty(); if (currValue) m_valueList->next(); break; case CSSPropertyWebkitAnimationTimingFunction: case CSSPropertyWebkitTransitionTimingFunction: currValue = parseAnimationTimingFunction(); if (currValue) m_valueList->next(); break; } if (!currValue) return false; if (value && !values) { values = CSSValueList::createCommaSeparated(); values->append(value.release()); } if (values) values->append(currValue.release()); else value = currValue.release(); allowComma = true; } // When parsing the 'transition' shorthand property, we let it handle building up the lists for all // properties. if (inShorthand()) break; } if (values && values->length()) { result = values.release(); return true; } if (value) { result = value.release(); return true; } return false; } #if ENABLE(CSS_GRID_LAYOUT) bool CSSParser::parseGridTrackList(int propId, bool important) { CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueNone) { if (m_valueList->next()) return false; addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important); return true; } RefPtr values = CSSValueList::createSpaceSeparated(); while (value) { bool valid = validUnit(value, FLength | FPercent, m_strict) || value->id == CSSValueAuto; if (!valid) return false; RefPtr primitiveValue = value->id == CSSValueAuto ? cssValuePool()->createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(value); values->append(primitiveValue.release()); value = m_valueList->next(); } addProperty(propId, values.release(), important); return true; } #endif #if ENABLE(DASHBOARD_SUPPORT) #define DASHBOARD_REGION_NUM_PARAMETERS 6 #define DASHBOARD_REGION_SHORT_NUM_PARAMETERS 2 static CSSParserValue* skipCommaInDashboardRegion(CSSParserValueList *args) { if (args->size() == (DASHBOARD_REGION_NUM_PARAMETERS*2-1) || args->size() == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) { CSSParserValue* current = args->current(); if (current->unit == CSSParserValue::Operator && current->iValue == ',') return args->next(); } return args->current(); } bool CSSParser::parseDashboardRegions(int propId, bool important) { bool valid = true; CSSParserValue* value = m_valueList->current(); if (value->id == CSSValueNone) { if (m_valueList->next()) return false; addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important); return valid; } RefPtr firstRegion = DashboardRegion::create(); DashboardRegion* region = 0; while (value) { if (region == 0) { region = firstRegion.get(); } else { RefPtr nextRegion = DashboardRegion::create(); region->m_next = nextRegion; region = nextRegion.get(); } if (value->unit != CSSParserValue::Function) { valid = false; break; } // Commas count as values, so allow: // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l) // dashboard-region(label, type, t, r, b, l) or dashboard-region(label type t r b l) // also allow // dashboard-region(label, type) or dashboard-region(label type) // dashboard-region(label, type) or dashboard-region(label type) CSSParserValueList* args = value->function->args.get(); if (!equalIgnoringCase(value->function->name, "dashboard-region(") || !args) { valid = false; break; } int numArgs = args->size(); if ((numArgs != DASHBOARD_REGION_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_NUM_PARAMETERS*2-1)) && (numArgs != DASHBOARD_REGION_SHORT_NUM_PARAMETERS && numArgs != (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1))) { valid = false; break; } // First arg is a label. CSSParserValue* arg = args->current(); if (arg->unit != CSSPrimitiveValue::CSS_IDENT) { valid = false; break; } region->m_label = arg->string; // Second arg is a type. arg = args->next(); arg = skipCommaInDashboardRegion(args); if (arg->unit != CSSPrimitiveValue::CSS_IDENT) { valid = false; break; } if (equalIgnoringCase(arg->string, "circle")) region->m_isCircle = true; else if (equalIgnoringCase(arg->string, "rectangle")) region->m_isRectangle = true; else { valid = false; break; } region->m_geometryType = arg->string; if (numArgs == DASHBOARD_REGION_SHORT_NUM_PARAMETERS || numArgs == (DASHBOARD_REGION_SHORT_NUM_PARAMETERS*2-1)) { // This originally used CSSValueInvalid by accident. It might be more logical to use something else. RefPtr amount = cssValuePool()->createIdentifierValue(CSSValueInvalid); region->setTop(amount); region->setRight(amount); region->setBottom(amount); region->setLeft(amount); } else { // Next four arguments must be offset numbers int i; for (i = 0; i < 4; i++) { arg = args->next(); arg = skipCommaInDashboardRegion(args); valid = arg->id == CSSValueAuto || validUnit(arg, FLength, m_strict); if (!valid) break; RefPtr amount = arg->id == CSSValueAuto ? cssValuePool()->createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(arg); if (i == 0) region->setTop(amount); else if (i == 1) region->setRight(amount); else if (i == 2) region->setBottom(amount); else region->setLeft(amount); } } if (args->next()) return false; value = m_valueList->next(); } if (valid) addProperty(propId, cssValuePool()->createValue(firstRegion.release()), important); return valid; } #endif /* ENABLE(DASHBOARD_SUPPORT) */ PassRefPtr CSSParser::parseCounterContent(CSSParserValueList* args, bool counters) { unsigned numArgs = args->size(); if (counters && numArgs != 3 && numArgs != 5) return 0; if (!counters && numArgs != 1 && numArgs != 3) return 0; CSSParserValue* i = args->current(); if (i->unit != CSSPrimitiveValue::CSS_IDENT) return 0; RefPtr identifier = createPrimitiveStringValue(i); RefPtr separator; if (!counters) separator = cssValuePool()->createValue(String(), CSSPrimitiveValue::CSS_STRING); else { i = args->next(); if (i->unit != CSSParserValue::Operator || i->iValue != ',') return 0; i = args->next(); if (i->unit != CSSPrimitiveValue::CSS_STRING) return 0; separator = createPrimitiveStringValue(i); } RefPtr listStyle; i = args->next(); if (!i) // Make the list style default decimal listStyle = cssValuePool()->createIdentifierValue(CSSValueDecimal); else { if (i->unit != CSSParserValue::Operator || i->iValue != ',') return 0; i = args->next(); if (i->unit != CSSPrimitiveValue::CSS_IDENT) return 0; int listStyleID = 0; if (i->id == CSSValueNone || (i->id >= CSSValueDisc && i->id <= CSSValueKatakanaIroha)) listStyleID = i->id; else return 0; listStyle = cssValuePool()->createIdentifierValue(listStyleID); } return cssValuePool()->createValue(Counter::create(identifier.release(), listStyle.release(), separator.release())); } bool CSSParser::parseShape(int propId, bool important) { CSSParserValue* value = m_valueList->current(); CSSParserValueList* args = value->function->args.get(); if (!equalIgnoringCase(value->function->name, "rect(") || !args) return false; // rect(t, r, b, l) || rect(t r b l) if (args->size() != 4 && args->size() != 7) return false; RefPtr rect = Rect::create(); bool valid = true; int i = 0; CSSParserValue* a = args->current(); while (a) { valid = a->id == CSSValueAuto || validUnit(a, FLength, m_strict); if (!valid) break; RefPtr length = a->id == CSSValueAuto ? cssValuePool()->createIdentifierValue(CSSValueAuto) : createPrimitiveNumericValue(a); if (i == 0) rect->setTop(length); else if (i == 1) rect->setRight(length); else if (i == 2) rect->setBottom(length); else rect->setLeft(length); a = args->next(); if (a && args->size() == 7) { if (a->unit == CSSParserValue::Operator && a->iValue == ',') { a = args->next(); } else { valid = false; break; } } i++; } if (valid) { addProperty(propId, cssValuePool()->createValue(rect.release()), important); m_valueList->next(); return true; } return false; } PassRefPtr CSSParser::parseWrapShapeRect(CSSParserValueList* args) { ASSERT(args); // rect(x, y, width, height, [[rx], ry]) if (args->size() != 7 && args->size() != 9 && args->size() != 11) return 0; RefPtr shape = CSSWrapShapeRect::create(); unsigned argumentNumber = 0; CSSParserValue* argument = args->current(); while (argument) { if (!validUnit(argument, FLength, m_strict)) return 0; RefPtr length = createPrimitiveNumericValue(argument); ASSERT(argumentNumber < 6); switch (argumentNumber) { case 0: shape->setLeft(length); break; case 1: shape->setTop(length); break; case 2: shape->setWidth(length); break; case 3: shape->setHeight(length); break; case 4: shape->setRadiusX(length); break; case 5: shape->setRadiusY(length); break; } argument = args->next(); if (argument) { if (argument->unit != CSSParserValue::Operator || argument->iValue != ',') return 0; argument = args->next(); } argumentNumber++; } if (argumentNumber < 4) return 0; return shape; } PassRefPtr CSSParser::parseWrapShapeCircle(CSSParserValueList* args) { ASSERT(args); // circle(x, y, r) if (args->size() != 5) return 0; RefPtr shape = CSSWrapShapeCircle::create(); unsigned argumentNumber = 0; CSSParserValue* argument = args->current(); while (argument) { if (!validUnit(argument, FLength, m_strict)) return 0; RefPtr length = createPrimitiveNumericValue(argument); ASSERT(argumentNumber < 3); switch (argumentNumber) { case 0: shape->setLeft(length); break; case 1: shape->setTop(length); break; case 2: shape->setRadius(length); break; } argument = args->next(); if (argument) { if (argument->unit != CSSParserValue::Operator || argument->iValue != ',') return 0; argument = args->next(); } argumentNumber++; } if (argumentNumber < 3) return 0; return shape; } PassRefPtr CSSParser::parseWrapShapeEllipse(CSSParserValueList* args) { ASSERT(args); // ellipse(x, y, rx, ry) if (args->size() != 7) return 0; RefPtr shape = CSSWrapShapeEllipse::create(); unsigned argumentNumber = 0; CSSParserValue* argument = args->current(); while (argument) { if (!validUnit(argument, FLength, m_strict)) return 0; RefPtr length = createPrimitiveNumericValue(argument); ASSERT(argumentNumber < 4); switch (argumentNumber) { case 0: shape->setLeft(length); break; case 1: shape->setTop(length); break; case 2: shape->setRadiusX(length); break; case 3: shape->setRadiusY(length); break; } argument = args->next(); if (argument) { if (argument->unit != CSSParserValue::Operator || argument->iValue != ',') return 0; argument = args->next(); } argumentNumber++; } if (argumentNumber < 4) return 0; return shape; } PassRefPtr CSSParser::parseWrapShapePolygon(CSSParserValueList* args) { ASSERT(args); unsigned size = args->size(); if (!size) return 0; RefPtr shape = CSSWrapShapePolygon::create(); CSSParserValue* argument = args->current(); if (argument->id == CSSValueEvenodd || argument->id == CSSValueNonzero) { shape->setWindRule(argument->id == CSSValueEvenodd ? RULE_EVENODD : RULE_NONZERO); CSSParserValue* comma = args->next(); if (!comma || comma->unit != CSSParserValue::Operator || comma->iValue != ',') return 0; argument = args->next(); size -= 2; } // , ... , -> each pair has 3 elements if (!size || (size % 3)) return 0; CSSParserValue* argumentX = argument; while (argumentX) { if (!validUnit(argumentX, FLength, m_strict)) return 0; CSSParserValue* comma = args->next(); if (!comma || comma->unit != CSSParserValue::Operator || comma->iValue != ',') return 0; CSSParserValue* argumentY = args->next(); if (!argumentY || !validUnit(argumentY, FLength, m_strict)) return 0; RefPtr xLength = createPrimitiveNumericValue(argumentX); RefPtr yLength = createPrimitiveNumericValue(argumentY); shape->appendPoint(xLength.release(), yLength.release()); argumentX = args->next(); } return shape; } bool CSSParser::parseWrapShape(bool shapeInside, bool important) { CSSParserValue* value = m_valueList->current(); CSSParserValueList* args = value->function->args.get(); if (!args) return false; RefPtr shape; if (equalIgnoringCase(value->function->name, "rect(")) shape = parseWrapShapeRect(args); else if (equalIgnoringCase(value->function->name, "circle(")) shape = parseWrapShapeCircle(args); else if (equalIgnoringCase(value->function->name, "ellipse(")) shape = parseWrapShapeEllipse(args); else if (equalIgnoringCase(value->function->name, "polygon(")) shape = parseWrapShapePolygon(args); if (shape) { addProperty(shapeInside ? CSSPropertyWebkitWrapShapeInside : CSSPropertyWebkitWrapShapeOutside, cssValuePool()->createValue(shape.release()), important); m_valueList->next(); return true; } return false; } // [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]? 'font-family' bool CSSParser::parseFont(bool important) { bool valid = true; bool styleImplicit = true; bool variantImplicit = true; bool weightImplicit = true; bool lineHeightImplicit = true; int valueOrdinal = 0; CSSParserValue *value = m_valueList->current(); RefPtr font = FontValue::create(); // Optional font-style, font-variant and font-weight. while (value) { int id = value->id; if (id) { if (id == CSSValueNormal) { // It's the initial value for all three, so mark the corresponding longhand as explicit. switch (valueOrdinal) { case 0: styleImplicit = false; break; case 1: variantImplicit = false; break; case 2: weightImplicit = false; break; } } else if (id == CSSValueItalic || id == CSSValueOblique) { if (font->style) return false; font->style = cssValuePool()->createIdentifierValue(id); styleImplicit = false; } else if (id == CSSValueSmallCaps) { if (font->variant) return false; font->variant = cssValuePool()->createIdentifierValue(id); variantImplicit = false; } else if (id >= CSSValueBold && id <= CSSValueLighter) { if (font->weight) return false; font->weight = cssValuePool()->createIdentifierValue(id); weightImplicit = false; } else valid = false; } else if (!font->weight && validUnit(value, FInteger | FNonNeg, true)) { int weight = static_cast(value->fValue); int val = 0; if (weight == 100) val = CSSValue100; else if (weight == 200) val = CSSValue200; else if (weight == 300) val = CSSValue300; else if (weight == 400) val = CSSValue400; else if (weight == 500) val = CSSValue500; else if (weight == 600) val = CSSValue600; else if (weight == 700) val = CSSValue700; else if (weight == 800) val = CSSValue800; else if (weight == 900) val = CSSValue900; if (val) { font->weight = cssValuePool()->createIdentifierValue(val); weightImplicit = false; } else valid = false; } else { valid = false; } if (!valid) break; value = m_valueList->next(); ++valueOrdinal; } if (!value) return false; // Set undefined values to default. if (!font->style) font->style = cssValuePool()->createIdentifierValue(CSSValueNormal); if (!font->variant) font->variant = cssValuePool()->createIdentifierValue(CSSValueNormal); if (!font->weight) font->weight = cssValuePool()->createIdentifierValue(CSSValueNormal); // Now a font size _must_ come. // | | | | inherit if (value->id >= CSSValueXxSmall && value->id <= CSSValueLarger) font->size = cssValuePool()->createIdentifierValue(value->id); else if (validUnit(value, FLength | FPercent | FNonNeg, m_strict)) font->size = createPrimitiveNumericValue(value); value = m_valueList->next(); if (!font->size || !value) return false; if (value->unit == CSSParserValue::Operator && value->iValue == '/') { // The line-height property. value = m_valueList->next(); if (!value) return false; if (value->id == CSSValueNormal) { // Default value, just mark the property as explicit. lineHeightImplicit = false; } else if (validUnit(value, FNumber | FLength | FPercent | FNonNeg, m_strict)) { font->lineHeight = createPrimitiveNumericValue(value); lineHeightImplicit = false; } else return false; value = m_valueList->next(); if (!value) return false; } if (!font->lineHeight) font->lineHeight = cssValuePool()->createIdentifierValue(CSSValueNormal); // Font family must come now. font->family = parseFontFamily(); if (m_valueList->current() || !font->family) return false; ShorthandScope scope(this, CSSPropertyFont); addProperty(CSSPropertyFontFamily, font->family, important); addProperty(CSSPropertyFontSize, font->size, important); addProperty(CSSPropertyFontStyle, font->style, important, styleImplicit); addProperty(CSSPropertyFontVariant, font->variant, important, variantImplicit); addProperty(CSSPropertyFontWeight, font->weight, important, weightImplicit); addProperty(CSSPropertyLineHeight, font->lineHeight, important, lineHeightImplicit); // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20110324/#font-prop requires that // "font-stretch", "font-size-adjust", and "font-kerning" be reset to their initial values // but we don't seem to support them at the moment. They should also be added here once implemented. return true; } PassRefPtr CSSParser::parseFontFamily() { RefPtr list = CSSValueList::createCommaSeparated(); CSSParserValue* value = m_valueList->current(); FontFamilyValue* currFamily = 0; while (value) { CSSParserValue* nextValue = m_valueList->next(); bool nextValBreaksFont = !nextValue || (nextValue->unit == CSSParserValue::Operator && nextValue->iValue == ','); bool nextValIsFontName = nextValue && ((nextValue->id >= CSSValueSerif && nextValue->id <= CSSValueWebkitBody) || (nextValue->unit == CSSPrimitiveValue::CSS_STRING || nextValue->unit == CSSPrimitiveValue::CSS_IDENT)); if (value->id >= CSSValueSerif && value->id <= CSSValueWebkitBody) { if (currFamily) currFamily->appendSpaceSeparated(value->string.characters, value->string.length); else if (nextValBreaksFont || !nextValIsFontName) list->append(cssValuePool()->createIdentifierValue(value->id)); else { RefPtr newFamily = FontFamilyValue::create(value->string); currFamily = newFamily.get(); list->append(newFamily.release()); } } else if (value->unit == CSSPrimitiveValue::CSS_STRING) { // Strings never share in a family name. currFamily = 0; list->append(FontFamilyValue::create(value->string)); } else if (value->unit == CSSPrimitiveValue::CSS_IDENT) { if (currFamily) currFamily->appendSpaceSeparated(value->string.characters, value->string.length); else if (nextValBreaksFont || !nextValIsFontName) list->append(FontFamilyValue::create(value->string)); else { RefPtr newFamily = FontFamilyValue::create(value->string); currFamily = newFamily.get(); list->append(newFamily.release()); } } else { break; } if (!nextValue) break; if (nextValBreaksFont) { value = m_valueList->next(); currFamily = 0; } else if (nextValIsFontName) value = nextValue; else break; } if (!list->length()) list = 0; return list.release(); } bool CSSParser::parseFontStyle(bool important) { RefPtr values; if (m_valueList->size() > 1) values = CSSValueList::createCommaSeparated(); CSSParserValue* val; bool expectComma = false; while ((val = m_valueList->current())) { RefPtr parsedValue; if (!expectComma) { expectComma = true; if (val->id == CSSValueNormal || val->id == CSSValueItalic || val->id == CSSValueOblique) parsedValue = cssValuePool()->createIdentifierValue(val->id); else if (val->id == CSSValueAll && !values) { // 'all' is only allowed in @font-face and with no other values. Make a value list to // indicate that we are in the @font-face case. values = CSSValueList::createCommaSeparated(); parsedValue = cssValuePool()->createIdentifierValue(val->id); } } else if (val->unit == CSSParserValue::Operator && val->iValue == ',') { expectComma = false; m_valueList->next(); continue; } if (!parsedValue) return false; m_valueList->next(); if (values) values->append(parsedValue.release()); else { addProperty(CSSPropertyFontStyle, parsedValue.release(), important); return true; } } if (values && values->length()) { m_hasFontFaceOnlyValues = true; addProperty(CSSPropertyFontStyle, values.release(), important); return true; } return false; } bool CSSParser::parseFontVariant(bool important) { RefPtr values; if (m_valueList->size() > 1) values = CSSValueList::createCommaSeparated(); CSSParserValue* val; bool expectComma = false; while ((val = m_valueList->current())) { RefPtr parsedValue; if (!expectComma) { expectComma = true; if (val->id == CSSValueNormal || val->id == CSSValueSmallCaps) parsedValue = cssValuePool()->createIdentifierValue(val->id); else if (val->id == CSSValueAll && !values) { // 'all' is only allowed in @font-face and with no other values. Make a value list to // indicate that we are in the @font-face case. values = CSSValueList::createCommaSeparated(); parsedValue = cssValuePool()->createIdentifierValue(val->id); } } else if (val->unit == CSSParserValue::Operator && val->iValue == ',') { expectComma = false; m_valueList->next(); continue; } if (!parsedValue) return false; m_valueList->next(); if (values) values->append(parsedValue.release()); else { addProperty(CSSPropertyFontVariant, parsedValue.release(), important); return true; } } if (values && values->length()) { m_hasFontFaceOnlyValues = true; addProperty(CSSPropertyFontVariant, values.release(), important); return true; } return false; } bool CSSParser::parseFontWeight(bool important) { RefPtr values; if (m_valueList->size() > 1) values = CSSValueList::createCommaSeparated(); CSSParserValue* val; bool expectComma = false; while ((val = m_valueList->current())) { RefPtr parsedValue; if (!expectComma) { expectComma = true; if (val->unit == CSSPrimitiveValue::CSS_IDENT) { if (val->id >= CSSValueNormal && val->id <= CSSValue900) parsedValue = cssValuePool()->createIdentifierValue(val->id); else if (val->id == CSSValueAll && !values) { // 'all' is only allowed in @font-face and with no other values. Make a value list to // indicate that we are in the @font-face case. values = CSSValueList::createCommaSeparated(); parsedValue = cssValuePool()->createIdentifierValue(val->id); } } else if (validUnit(val, FInteger | FNonNeg, false)) { int weight = static_cast(val->fValue); if (!(weight % 100) && weight >= 100 && weight <= 900) parsedValue = cssValuePool()->createIdentifierValue(CSSValue100 + weight / 100 - 1); } } else if (val->unit == CSSParserValue::Operator && val->iValue == ',') { expectComma = false; m_valueList->next(); continue; } if (!parsedValue) return false; m_valueList->next(); if (values) values->append(parsedValue.release()); else { addProperty(CSSPropertyFontWeight, parsedValue.release(), important); return true; } } if (values && values->length()) { m_hasFontFaceOnlyValues = true; addProperty(CSSPropertyFontWeight, values.release(), important); return true; } return false; } bool CSSParser::parseFontFaceSrcURI(CSSValueList* valueList) { // FIXME: The completeURL call should be done when using the CSSFontFaceSrcValue, // not when creating it. RefPtr uriValue(CSSFontFaceSrcValue::create(m_styleSheet->completeURL(m_valueList->current()->string))); CSSParserValue* value = m_valueList->next(); if (!value) { valueList->append(uriValue.release()); return true; } if (value->unit == CSSParserValue::Operator && value->iValue == ',') { m_valueList->next(); valueList->append(uriValue.release()); return true; } if (value->unit != CSSParserValue::Function || !equalIgnoringCase(value->function->name, "format(")) return false; // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20111004/ says that format() contains a comma-separated list of strings, // but CSSFontFaceSrcValue stores only one format. Allowing one format for now. CSSParserValueList* args = value->function->args.get(); if (!args || args->size() != 1 || (args->current()->unit != CSSPrimitiveValue::CSS_STRING && args->current()->unit != CSSPrimitiveValue::CSS_IDENT)) return false; uriValue->setFormat(args->current()->string); valueList->append(uriValue.release()); value = m_valueList->next(); if (value && value->unit == CSSParserValue::Operator && value->iValue == ',') m_valueList->next(); return true; } bool CSSParser::parseFontFaceSrcLocal(CSSValueList* valueList) { CSSParserValueList* args = m_valueList->current()->function->args.get(); if (!args || !args->size()) return false; if (args->size() == 1 && args->current()->unit == CSSPrimitiveValue::CSS_STRING) valueList->append(CSSFontFaceSrcValue::createLocal(args->current()->string)); else if (args->current()->unit == CSSPrimitiveValue::CSS_IDENT) { StringBuilder builder; for (CSSParserValue* localValue = args->current(); localValue; localValue = args->next()) { if (localValue->unit != CSSPrimitiveValue::CSS_IDENT) return false; if (!builder.isEmpty()) builder.append(' '); builder.append(localValue->string); } valueList->append(CSSFontFaceSrcValue::createLocal(builder.toString())); } else return false; if (CSSParserValue* value = m_valueList->next()) { if (value->unit == CSSParserValue::Operator && value->iValue == ',') m_valueList->next(); } return true; } bool CSSParser::parseFontFaceSrc() { RefPtr values(CSSValueList::createCommaSeparated()); while (CSSParserValue* value = m_valueList->current()) { if (value->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) { if (!parseFontFaceSrcURI(values.get())) return false; } else if (value->unit == CSSParserValue::Function && equalIgnoringCase(value->function->name, "local(")) { if (!parseFontFaceSrcLocal(values.get())) return false; } else return false; } if (!values->length()) return false; addProperty(CSSPropertySrc, values.release(), m_important); m_valueList->next(); return true; } bool CSSParser::parseFontFaceUnicodeRange() { RefPtr values = CSSValueList::createCommaSeparated(); bool failed = false; bool operatorExpected = false; for (; m_valueList->current(); m_valueList->next(), operatorExpected = !operatorExpected) { if (operatorExpected) { if (m_valueList->current()->unit == CSSParserValue::Operator && m_valueList->current()->iValue == ',') continue; failed = true; break; } if (m_valueList->current()->unit != CSSPrimitiveValue::CSS_UNICODE_RANGE) { failed = true; break; } String rangeString = m_valueList->current()->string; UChar32 from = 0; UChar32 to = 0; unsigned length = rangeString.length(); if (length < 3) { failed = true; break; } unsigned i = 2; while (i < length) { UChar c = rangeString[i]; if (c == '-' || c == '?') break; from *= 16; if (c >= '0' && c <= '9') from += c - '0'; else if (c >= 'A' && c <= 'F') from += 10 + c - 'A'; else if (c >= 'a' && c <= 'f') from += 10 + c - 'a'; else { failed = true; break; } i++; } if (failed) break; if (i == length) to = from; else if (rangeString[i] == '?') { unsigned span = 1; while (i < length && rangeString[i] == '?') { span *= 16; from *= 16; i++; } if (i < length) failed = true; to = from + span - 1; } else { if (length < i + 2) { failed = true; break; } i++; while (i < length) { UChar c = rangeString[i]; to *= 16; if (c >= '0' && c <= '9') to += c - '0'; else if (c >= 'A' && c <= 'F') to += 10 + c - 'A'; else if (c >= 'a' && c <= 'f') to += 10 + c - 'a'; else { failed = true; break; } i++; } if (failed) break; } if (from <= to) values->append(CSSUnicodeRangeValue::create(from, to)); } if (failed || !values->length()) return false; addProperty(CSSPropertyUnicodeRange, values.release(), m_important); return true; } // Returns the number of characters which form a valid double // and are terminated by the given terminator character static int checkForValidDouble(const UChar* string, const UChar* end, const char terminator) { int length = end - string; if (length < 1) return 0; bool decimalMarkSeen = false; int processedLength = 0; for (int i = 0; i < length; ++i) { if (string[i] == terminator) { processedLength = i; break; } if (!isASCIIDigit(string[i])) { if (!decimalMarkSeen && string[i] == '.') decimalMarkSeen = true; else return 0; } } if (decimalMarkSeen && processedLength == 1) return 0; return processedLength; } // Returns the number of characters consumed for parsing a valid double // terminated by the given terminator character static int parseDouble(const UChar* string, const UChar* end, const char terminator, double& value) { int length = checkForValidDouble(string, end, terminator); if (!length) return 0; int position = 0; double localValue = 0; // The consumed characters here are guaranteed to be // ASCII digits with or without a decimal mark for (; position < length; ++position) { if (string[position] == '.') break; localValue = localValue * 10 + string[position] - '0'; } if (++position == length) { value = localValue; return length; } double fraction = 0; double scale = 1; while (position < length && scale < MAX_SCALE) { fraction = fraction * 10 + string[position++] - '0'; scale *= 10; } value = localValue + fraction / scale; return length; } static bool parseColorIntOrPercentage(const UChar*& string, const UChar* end, const char terminator, CSSPrimitiveValue::UnitTypes& expect, int& value) { const UChar* current = string; double localValue = 0; bool negative = false; while (current != end && isHTMLSpace(*current)) current++; if (current != end && *current == '-') { negative = true; current++; } if (current == end || !isASCIIDigit(*current)) return false; while (current != end && isASCIIDigit(*current)) { double newValue = localValue * 10 + *current++ - '0'; if (newValue >= 255) { // Clamp values at 255. localValue = 255; while (current != end && isASCIIDigit(*current)) ++current; break; } localValue = newValue; } if (current == end) return false; if (expect == CSSPrimitiveValue::CSS_NUMBER && (*current == '.' || *current == '%')) return false; if (*current == '.') { // We already parsed the integral part, try to parse // the fraction part of the percentage value. double percentage = 0; int numCharactersParsed = parseDouble(current, end, '%', percentage); if (!numCharactersParsed) return false; current += numCharactersParsed; if (*current != '%') return false; localValue += percentage; } if (expect == CSSPrimitiveValue::CSS_PERCENTAGE && *current != '%') return false; if (*current == '%') { expect = CSSPrimitiveValue::CSS_PERCENTAGE; localValue = localValue / 100.0 * 256.0; // Clamp values at 255 for percentages over 100% if (localValue > 255) localValue = 255; current++; } else expect = CSSPrimitiveValue::CSS_NUMBER; while (current != end && isHTMLSpace(*current)) current++; if (current == end || *current++ != terminator) return false; // Clamp negative values at zero. value = negative ? 0 : static_cast(localValue); string = current; return true; } static inline bool isTenthAlpha(const UChar* string, const int length) { // "0.X" if (length == 3 && string[0] == '0' && string[1] == '.' && isASCIIDigit(string[2])) return true; // ".X" if (length == 2 && string[0] == '.' && isASCIIDigit(string[1])) return true; return false; } static inline bool parseAlphaValue(const UChar*& string, const UChar* end, const char terminator, int& value) { while (string != end && isHTMLSpace(*string)) string++; bool negative = false; if (string != end && *string == '-') { negative = true; string++; } value = 0; int length = end - string; if (length < 2) return false; if (string[length - 1] != terminator) return false; if (string[0] != '0' && string[0] != '1' && string[0] != '.') { if (checkForValidDouble(string, end, terminator)) { value = negative ? 0 : 255; string = end; return true; } return false; } if (length == 2 && string[0] != '.') { value = !negative && string[0] == '1' ? 255 : 0; string = end; return true; } if (isTenthAlpha(string, length - 1)) { static const int tenthAlphaValues[] = { 0, 25, 51, 76, 102, 127, 153, 179, 204, 230 }; value = negative ? 0 : tenthAlphaValues[string[length - 2] - '0']; string = end; return true; } double alpha = 0; if (!parseDouble(string, end, terminator, alpha)) return false; value = negative ? 0 : static_cast(alpha * nextafter(256.0, 0.0)); string = end; return true; } static inline bool mightBeRGBA(const UChar* characters, unsigned length) { if (length < 5) return false; return characters[4] == '(' && isASCIIAlphaCaselessEqual(characters[0], 'r') && isASCIIAlphaCaselessEqual(characters[1], 'g') && isASCIIAlphaCaselessEqual(characters[2], 'b') && isASCIIAlphaCaselessEqual(characters[3], 'a'); } static inline bool mightBeRGB(const UChar* characters, unsigned length) { if (length < 4) return false; return characters[3] == '(' && isASCIIAlphaCaselessEqual(characters[0], 'r') && isASCIIAlphaCaselessEqual(characters[1], 'g') && isASCIIAlphaCaselessEqual(characters[2], 'b'); } bool CSSParser::fastParseColor(RGBA32& rgb, const String& name, bool strict) { const UChar* characters = name.characters(); unsigned length = name.length(); CSSPrimitiveValue::UnitTypes expect = CSSPrimitiveValue::CSS_UNKNOWN; if (!strict && length >= 3) { if (name[0] == '#') { if (Color::parseHexColor(characters + 1, length - 1, rgb)) return true; } else { if (Color::parseHexColor(characters, length, rgb)) return true; } } // Try rgba() syntax. if (mightBeRGBA(characters, length)) { const UChar* current = characters + 5; const UChar* end = characters + length; int red; int green; int blue; int alpha; if (!parseColorIntOrPercentage(current, end, ',', expect, red)) return false; if (!parseColorIntOrPercentage(current, end, ',', expect, green)) return false; if (!parseColorIntOrPercentage(current, end, ',', expect, blue)) return false; if (!parseAlphaValue(current, end, ')', alpha)) return false; if (current != end) return false; rgb = makeRGBA(red, green, blue, alpha); return true; } // Try rgb() syntax. if (mightBeRGB(characters, length)) { const UChar* current = characters + 4; const UChar* end = characters + length; int red; int green; int blue; if (!parseColorIntOrPercentage(current, end, ',', expect, red)) return false; if (!parseColorIntOrPercentage(current, end, ',', expect, green)) return false; if (!parseColorIntOrPercentage(current, end, ')', expect, blue)) return false; if (current != end) return false; rgb = makeRGB(red, green, blue); return true; } // Try named colors. Color tc; tc.setNamedColor(name); if (tc.isValid()) { rgb = tc.rgb(); return true; } return false; } inline double CSSParser::parsedDouble(CSSParserValue *v, ReleaseParsedCalcValueCondition releaseCalc) { const double result = m_parsedCalculation ? m_parsedCalculation->doubleValue() : v->fValue; if (releaseCalc == ReleaseParsedCalcValue) m_parsedCalculation.release(); return result; } bool CSSParser::isCalculation(CSSParserValue* value) { return (value->unit == CSSParserValue::Function) && (equalIgnoringCase(value->function->name, "-webkit-calc(") || equalIgnoringCase(value->function->name, "-webkit-min(") || equalIgnoringCase(value->function->name, "-webkit-max(")); } inline int CSSParser::colorIntFromValue(CSSParserValue* v) { bool isPercent; if (m_parsedCalculation) isPercent = m_parsedCalculation->category() == CalcPercent; else isPercent = v->unit == CSSPrimitiveValue::CSS_PERCENTAGE; const double value = parsedDouble(v, ReleaseParsedCalcValue); if (value <= 0.0) return 0; if (isPercent) { if (value >= 100.0) return 255; return static_cast(value * 256.0 / 100.0); } if (value >= 255.0) return 255; return static_cast(value); } bool CSSParser::parseColorParameters(CSSParserValue* value, int* colorArray, bool parseAlpha) { CSSParserValueList* args = value->function->args.get(); CSSParserValue* v = args->current(); Units unitType = FUnknown; // Get the first value and its type if (validUnit(v, FInteger, true)) unitType = FInteger; else if (validUnit(v, FPercent, true)) unitType = FPercent; else return false; colorArray[0] = colorIntFromValue(v); for (int i = 1; i < 3; i++) { v = args->next(); if (v->unit != CSSParserValue::Operator && v->iValue != ',') return false; v = args->next(); if (!validUnit(v, unitType, true)) return false; colorArray[i] = colorIntFromValue(v); } if (parseAlpha) { v = args->next(); if (v->unit != CSSParserValue::Operator && v->iValue != ',') return false; v = args->next(); if (!validUnit(v, FNumber, true)) return false; const double value = parsedDouble(v, ReleaseParsedCalcValue); // Convert the floating pointer number of alpha to an integer in the range [0, 256), // with an equal distribution across all 256 values. colorArray[3] = static_cast(max(0.0, min(1.0, value)) * nextafter(256.0, 0.0)); } return true; } // The CSS3 specification defines the format of a HSL color as // hsl(, , ) // and with alpha, the format is // hsla(, , , ) // The first value, HUE, is in an angle with a value between 0 and 360 bool CSSParser::parseHSLParameters(CSSParserValue* value, double* colorArray, bool parseAlpha) { CSSParserValueList* args = value->function->args.get(); CSSParserValue* v = args->current(); // Get the first value if (!validUnit(v, FNumber, true)) return false; // normalize the Hue value and change it to be between 0 and 1.0 colorArray[0] = (((static_cast(parsedDouble(v, ReleaseParsedCalcValue)) % 360) + 360) % 360) / 360.0; for (int i = 1; i < 3; i++) { v = args->next(); if (v->unit != CSSParserValue::Operator && v->iValue != ',') return false; v = args->next(); if (!validUnit(v, FPercent, true)) return false; colorArray[i] = max(0.0, min(100.0, parsedDouble(v, ReleaseParsedCalcValue))) / 100.0; // needs to be value between 0 and 1.0 } if (parseAlpha) { v = args->next(); if (v->unit != CSSParserValue::Operator && v->iValue != ',') return false; v = args->next(); if (!validUnit(v, FNumber, true)) return false; colorArray[3] = max(0.0, min(1.0, parsedDouble(v, ReleaseParsedCalcValue))); } return true; } PassRefPtr CSSParser::parseColor(CSSParserValue* value) { RGBA32 c = Color::transparent; if (!parseColorFromValue(value ? value : m_valueList->current(), c)) return 0; return cssValuePool()->createColorValue(c); } bool CSSParser::parseColorFromValue(CSSParserValue* value, RGBA32& c) { if (!m_strict && value->unit == CSSPrimitiveValue::CSS_NUMBER && value->fValue >= 0. && value->fValue < 1000000.) { String str = String::format("%06d", static_cast((value->fValue+.5))); if (!fastParseColor(c, str, m_strict)) return false; } else if (value->unit == CSSPrimitiveValue::CSS_PARSER_HEXCOLOR || value->unit == CSSPrimitiveValue::CSS_IDENT || (!m_strict && value->unit == CSSPrimitiveValue::CSS_DIMENSION)) { if (!fastParseColor(c, value->string, m_strict && value->unit == CSSPrimitiveValue::CSS_IDENT)) return false; } else if (value->unit == CSSParserValue::Function && value->function->args != 0 && value->function->args->size() == 5 /* rgb + two commas */ && equalIgnoringCase(value->function->name, "rgb(")) { int colorValues[3]; if (!parseColorParameters(value, colorValues, false)) return false; c = makeRGB(colorValues[0], colorValues[1], colorValues[2]); } else { if (value->unit == CSSParserValue::Function && value->function->args != 0 && value->function->args->size() == 7 /* rgba + three commas */ && equalIgnoringCase(value->function->name, "rgba(")) { int colorValues[4]; if (!parseColorParameters(value, colorValues, true)) return false; c = makeRGBA(colorValues[0], colorValues[1], colorValues[2], colorValues[3]); } else if (value->unit == CSSParserValue::Function && value->function->args != 0 && value->function->args->size() == 5 /* hsl + two commas */ && equalIgnoringCase(value->function->name, "hsl(")) { double colorValues[3]; if (!parseHSLParameters(value, colorValues, false)) return false; c = makeRGBAFromHSLA(colorValues[0], colorValues[1], colorValues[2], 1.0); } else if (value->unit == CSSParserValue::Function && value->function->args != 0 && value->function->args->size() == 7 /* hsla + three commas */ && equalIgnoringCase(value->function->name, "hsla(")) { double colorValues[4]; if (!parseHSLParameters(value, colorValues, true)) return false; c = makeRGBAFromHSLA(colorValues[0], colorValues[1], colorValues[2], colorValues[3]); } else return false; } return true; } // This class tracks parsing state for shadow values. If it goes out of scope (e.g., due to an early return) // without the allowBreak bit being set, then it will clean up all of the objects and destroy them. struct ShadowParseContext { ShadowParseContext(CSSPropertyID prop, CSSParser* parser) : property(prop) , m_parser(parser) , allowX(true) , allowY(false) , allowBlur(false) , allowSpread(false) , allowColor(true) , allowStyle(prop == CSSPropertyWebkitBoxShadow || prop == CSSPropertyBoxShadow) , allowBreak(true) { } bool allowLength() { return allowX || allowY || allowBlur || allowSpread; } void commitValue() { // Handle the ,, case gracefully by doing nothing. if (x || y || blur || spread || color || style) { if (!values) values = CSSValueList::createCommaSeparated(); // Construct the current shadow value and add it to the list. values->append(ShadowValue::create(x.release(), y.release(), blur.release(), spread.release(), style.release(), color.release())); } // Now reset for the next shadow value. x = 0; y = 0; blur = 0; spread = 0; style = 0; color = 0; allowX = true; allowColor = true; allowBreak = true; allowY = false; allowBlur = false; allowSpread = false; allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow; } void commitLength(CSSParserValue* v) { RefPtr val = m_parser->createPrimitiveNumericValue(v); if (allowX) { x = val.release(); allowX = false; allowY = true; allowColor = false; allowStyle = false; allowBreak = false; } else if (allowY) { y = val.release(); allowY = false; allowBlur = true; allowColor = true; allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow; allowBreak = true; } else if (allowBlur) { blur = val.release(); allowBlur = false; allowSpread = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow; } else if (allowSpread) { spread = val.release(); allowSpread = false; } } void commitColor(PassRefPtr val) { color = val; allowColor = false; if (allowX) { allowStyle = false; allowBreak = false; } else { allowBlur = false; allowSpread = false; allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow; } } void commitStyle(CSSParserValue* v) { style = m_parser->cssValuePool()->createIdentifierValue(v->id); allowStyle = false; if (allowX) allowBreak = false; else { allowBlur = false; allowSpread = false; allowColor = false; } } CSSPropertyID property; CSSParser* m_parser; RefPtr values; RefPtr x; RefPtr y; RefPtr blur; RefPtr spread; RefPtr style; RefPtr color; bool allowX; bool allowY; bool allowBlur; bool allowSpread; bool allowColor; bool allowStyle; // inset or not. bool allowBreak; }; PassRefPtr CSSParser::parseShadow(CSSParserValueList* valueList, int propId) { ShadowParseContext context(static_cast(propId), this); CSSParserValue* val; while ((val = valueList->current())) { // Check for a comma break first. if (val->unit == CSSParserValue::Operator) { if (val->iValue != ',' || !context.allowBreak) // Other operators aren't legal or we aren't done with the current shadow // value. Treat as invalid. return 0; #if ENABLE(SVG) // -webkit-svg-shadow does not support multiple values. if (static_cast(propId) == CSSPropertyWebkitSvgShadow) return 0; #endif // The value is good. Commit it. context.commitValue(); } else if (validUnit(val, FLength, true)) { // We required a length and didn't get one. Invalid. if (!context.allowLength()) return 0; // A length is allowed here. Construct the value and add it. context.commitLength(val); } else if (val->id == CSSValueInset) { if (!context.allowStyle) return 0; context.commitStyle(val); } else { // The only other type of value that's ok is a color value. RefPtr parsedColor; bool isColor = ((val->id >= CSSValueAqua && val->id <= CSSValueWindowtext) || val->id == CSSValueMenu || (val->id >= CSSValueWebkitFocusRingColor && val->id <= CSSValueWebkitText && !m_strict) || val->id == CSSValueCurrentcolor); if (isColor) { if (!context.allowColor) return 0; parsedColor = cssValuePool()->createIdentifierValue(val->id); } if (!parsedColor) // It's not built-in. Try to parse it as a color. parsedColor = parseColor(val); if (!parsedColor || !context.allowColor) return 0; // This value is not a color or length and is invalid or // it is a color, but a color isn't allowed at this point. context.commitColor(parsedColor.release()); } valueList->next(); } if (context.allowBreak) { context.commitValue(); if (context.values && context.values->length()) return context.values.release(); } return 0; } bool CSSParser::parseReflect(int propId, bool important) { // box-reflect: // Direction comes first. CSSParserValue* val = m_valueList->current(); CSSReflectionDirection direction; switch (val->id) { case CSSValueAbove: direction = ReflectionAbove; break; case CSSValueBelow: direction = ReflectionBelow; break; case CSSValueLeft: direction = ReflectionLeft; break; case CSSValueRight: direction = ReflectionRight; break; default: return false; } // The offset comes next. val = m_valueList->next(); RefPtr offset; if (!val) offset = cssValuePool()->createValue(0, CSSPrimitiveValue::CSS_PX); else { if (!validUnit(val, FLength | FPercent, m_strict)) return false; offset = createPrimitiveNumericValue(val); } // Now for the mask. RefPtr mask; val = m_valueList->next(); if (val) { if (!parseBorderImage(propId, mask)) return false; } RefPtr reflectValue = CSSReflectValue::create(direction, offset.release(), mask.release()); addProperty(propId, reflectValue.release(), important); m_valueList->next(); return true; } bool CSSParser::parseFlex(int propId, bool important) { CSSParserValue* value = m_valueList->current(); CSSParserValueList* args = value->function->args.get(); if (!equalIgnoringCase(value->function->name, "-webkit-flex(") || !args || !args->size() || args->size() > 3 || m_valueList->next()) return false; static const double unsetValue = -1; double positiveFlex = unsetValue; double negativeFlex = unsetValue; RefPtr preferredSize; while (CSSParserValue* arg = args->current()) { if (validUnit(arg, FNumber | FNonNeg, m_strict)) { if (positiveFlex == unsetValue) positiveFlex = arg->fValue; else if (negativeFlex == unsetValue) negativeFlex = arg->fValue; else if (!arg->fValue) { // flex() only allows a preferred size of 0 (sans units) if the positive and negative flex values have already been set. preferredSize = cssValuePool()->createValue(0, CSSPrimitiveValue::CSS_PX); } else { // We only allow 3 numbers without units if the last value is 0. E.g., flex(1 1 1) is invalid. return false; } } else if (!preferredSize && (arg->id == CSSValueAuto || validUnit(arg, FLength | FPercent | FNonNeg, m_strict))) preferredSize = parseValidPrimitive(arg->id, arg); else { // Not a valid arg for flex(). return false; } args->next(); } if (positiveFlex == unsetValue) positiveFlex = 1; if (negativeFlex == unsetValue) negativeFlex = 0; if (!preferredSize) preferredSize = cssValuePool()->createValue(0, CSSPrimitiveValue::CSS_PX); RefPtr flex = CSSFlexValue::create(clampToFloat(positiveFlex), clampToFloat(negativeFlex), preferredSize); addProperty(propId, flex.release(), important); return true; } struct BorderImageParseContext { BorderImageParseContext() : m_canAdvance(false) , m_allowCommit(true) , m_allowImage(true) , m_allowImageSlice(true) , m_allowRepeat(true) , m_allowSlash(false) , m_requireWidth(false) , m_requireOutset(false) {} bool canAdvance() const { return m_canAdvance; } void setCanAdvance(bool canAdvance) { m_canAdvance = canAdvance; } bool allowCommit() const { return m_allowCommit; } bool allowImage() const { return m_allowImage; } bool allowImageSlice() const { return m_allowImageSlice; } bool allowRepeat() const { return m_allowRepeat; } bool allowSlash() const { return m_allowSlash; } bool requireWidth() const { return m_requireWidth; } bool requireOutset() const { return m_requireOutset; } void commitImage(PassRefPtr image) { m_image = image; m_canAdvance = true; m_allowCommit = true; m_allowImage = m_allowSlash = m_requireWidth = m_requireOutset = false; m_allowImageSlice = !m_imageSlice; m_allowRepeat = !m_repeat; } void commitImageSlice(PassRefPtr slice) { m_imageSlice = slice; m_canAdvance = true; m_allowCommit = m_allowSlash = true; m_allowImageSlice = m_requireWidth = m_requireOutset = false; m_allowImage = !m_image; m_allowRepeat = !m_repeat; } void commitSlash() { m_canAdvance = true; m_allowCommit = m_allowImage = m_allowImageSlice = m_allowRepeat = m_allowSlash = false; if (!m_borderSlice) { m_requireWidth = true; m_requireOutset = false; } else { m_requireOutset = true; m_requireWidth = false; } } void commitBorderWidth(PassRefPtr slice) { m_borderSlice = slice; m_canAdvance = true; m_allowCommit = m_allowSlash = true; m_allowImageSlice = m_requireWidth = m_requireOutset = false; m_allowImage = !m_image; m_allowRepeat = !m_repeat; } void commitBorderOutset(PassRefPtr outset) { m_outset = outset; m_canAdvance = true; m_allowCommit = true; m_allowImageSlice = m_allowSlash = m_requireWidth = m_requireOutset = false; m_allowImage = !m_image; m_allowRepeat = !m_repeat; } void commitRepeat(PassRefPtr repeat) { m_repeat = repeat; m_canAdvance = true; m_allowCommit = true; m_allowRepeat = m_allowSlash = m_requireWidth = m_requireOutset = false; m_allowImageSlice = !m_imageSlice; m_allowImage = !m_image; } PassRefPtr commitWebKitBorderImage() { return createBorderImageValue(m_image, m_imageSlice, m_borderSlice, m_outset, m_repeat); } void commitBorderImage(CSSParser* parser, bool important) { commitBorderImageProperty(CSSPropertyBorderImageSource, parser, m_image, important); commitBorderImageProperty(CSSPropertyBorderImageSlice, parser, m_imageSlice, important); commitBorderImageProperty(CSSPropertyBorderImageWidth, parser, m_borderSlice, important); commitBorderImageProperty(CSSPropertyBorderImageOutset, parser, m_outset, important); commitBorderImageProperty(CSSPropertyBorderImageRepeat, parser, m_repeat, important); } void commitBorderImageProperty(int propId, CSSParser* parser, PassRefPtr value, bool important) { if (value) parser->addProperty(propId, value, important); else parser->addProperty(propId, parser->cssValuePool()->createImplicitInitialValue(), important, true); } bool m_canAdvance; bool m_allowCommit; bool m_allowImage; bool m_allowImageSlice; bool m_allowRepeat; bool m_allowSlash; bool m_requireWidth; bool m_requireOutset; RefPtr m_image; RefPtr m_imageSlice; RefPtr m_borderSlice; RefPtr m_outset; RefPtr m_repeat; }; bool CSSParser::parseBorderImage(int propId, RefPtr& result, bool important) { ShorthandScope scope(this, propId); BorderImageParseContext context; while (CSSParserValue* val = m_valueList->current()) { context.setCanAdvance(false); if (!context.canAdvance() && context.allowSlash() && val->unit == CSSParserValue::Operator && val->iValue == '/') context.commitSlash(); if (!context.canAdvance() && context.allowImage()) { if (val->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) { // FIXME: The completeURL call should be done when using the CSSImageValue, // not when creating it. context.commitImage(CSSImageValue::create(m_styleSheet->completeURL(val->string))); } else if (isGeneratedImageValue(val)) { RefPtr value; if (parseGeneratedImage(m_valueList.get(), value)) context.commitImage(value); else return false; } else if (val->id == CSSValueNone) context.commitImage(CSSImageValue::create()); } if (!context.canAdvance() && context.allowImageSlice()) { RefPtr imageSlice; if (parseBorderImageSlice(propId, imageSlice)) context.commitImageSlice(imageSlice.release()); } if (!context.canAdvance() && context.allowRepeat()) { RefPtr repeat; if (parseBorderImageRepeat(repeat)) context.commitRepeat(repeat); } if (!context.canAdvance() && context.requireWidth()) { RefPtr borderSlice; if (parseBorderImageWidth(borderSlice)) context.commitBorderWidth(borderSlice.release()); } if (!context.canAdvance() && context.requireOutset()) { RefPtr borderOutset; if (parseBorderImageOutset(borderOutset)) context.commitBorderOutset(borderOutset.release()); } if (!context.canAdvance()) return false; m_valueList->next(); } if (context.allowCommit()) { if (propId == CSSPropertyBorderImage) context.commitBorderImage(this, important); else // Need to fully commit as a single value. result = context.commitWebKitBorderImage(); return true; } return false; } static bool isBorderImageRepeatKeyword(int id) { return id == CSSValueStretch || id == CSSValueRepeat || id == CSSValueSpace || id == CSSValueRound; } bool CSSParser::parseBorderImageRepeat(RefPtr& result) { RefPtr firstValue; RefPtr secondValue; CSSParserValue* val = m_valueList->current(); if (isBorderImageRepeatKeyword(val->id)) firstValue = cssValuePool()->createIdentifierValue(val->id); else return false; val = m_valueList->next(); if (val) { if (isBorderImageRepeatKeyword(val->id)) secondValue = cssValuePool()->createIdentifierValue(val->id); else if (!inShorthand()) { // If we're not parsing a shorthand then we are invalid. return false; } else { // We need to rewind the value list, so that when its advanced we'll // end up back at this value. m_valueList->previous(); } } else secondValue = firstValue; result = cssValuePool()->createValue(Pair::create(firstValue, secondValue)); return true; } class BorderImageSliceParseContext { public: BorderImageSliceParseContext(CSSParser* parser) : m_parser(parser) , m_allowNumber(true) , m_allowFill(false) , m_allowFinalCommit(false) , m_fill(false) { } bool allowNumber() const { return m_allowNumber; } bool allowFill() const { return m_allowFill; } bool allowFinalCommit() const { return m_allowFinalCommit; } CSSPrimitiveValue* top() const { return m_top.get(); } void commitNumber(CSSParserValue* v) { RefPtr val = m_parser->createPrimitiveNumericValue(v); if (!m_top) m_top = val; else if (!m_right) m_right = val; else if (!m_bottom) m_bottom = val; else { ASSERT(!m_left); m_left = val; } m_allowNumber = !m_left; m_allowFill = true; m_allowFinalCommit = true; } void commitFill() { m_fill = true; m_allowFill = false; m_allowNumber = false; } void setAllowFinalCommit() { m_allowFinalCommit = true; } void setTop(PassRefPtr val) { m_top = val; } PassRefPtr commitBorderImageSlice() { // We need to clone and repeat values for any omissions. ASSERT(m_top); if (!m_right) { m_right = m_top; m_bottom = m_top; m_left = m_top; } if (!m_bottom) { m_bottom = m_top; m_left = m_right; } if (!m_left) m_left = m_right; // Now build a rect value to hold all four of our primitive values. RefPtr quad = Quad::create(); quad->setTop(m_top); quad->setRight(m_right); quad->setBottom(m_bottom); quad->setLeft(m_left); // Make our new border image value now. return CSSBorderImageSliceValue::create(m_parser->cssValuePool()->createValue(quad.release()), m_fill); } private: CSSParser* m_parser; bool m_allowNumber; bool m_allowFill; bool m_allowFinalCommit; RefPtr m_top; RefPtr m_right; RefPtr m_bottom; RefPtr m_left; bool m_fill; }; bool CSSParser::parseBorderImageSlice(int propId, RefPtr& result) { BorderImageSliceParseContext context(this); CSSParserValue* val; while ((val = m_valueList->current())) { // FIXME calc() http://webkit.org/b/16662 : calc is parsed but values are not created yet. if (context.allowNumber() && !isCalculation(val) && validUnit(val, FInteger | FNonNeg | FPercent, true)) { context.commitNumber(val); } else if (context.allowFill() && val->id == CSSValueFill) context.commitFill(); else if (!inShorthand()) { // If we're not parsing a shorthand then we are invalid. return false; } else { if (context.allowFinalCommit()) { // We're going to successfully parse, but we don't want to consume this token. m_valueList->previous(); } break; } m_valueList->next(); } if (context.allowFinalCommit()) { // FIXME: For backwards compatibility, -webkit-border-image, -webkit-mask-box-image and -webkit-box-reflect have to do a fill by default. // FIXME: What do we do with -webkit-box-reflect and -webkit-mask-box-image? Probably just have to leave them filling... if (propId == CSSPropertyWebkitBorderImage || propId == CSSPropertyWebkitMaskBoxImage || propId == CSSPropertyWebkitBoxReflect) context.commitFill(); // Need to fully commit as a single value. result = context.commitBorderImageSlice(); return true; } return false; } class BorderImageQuadParseContext { public: BorderImageQuadParseContext(CSSParser* parser) : m_parser(parser) , m_allowNumber(true) , m_allowFinalCommit(false) { } bool allowNumber() const { return m_allowNumber; } bool allowFinalCommit() const { return m_allowFinalCommit; } CSSPrimitiveValue* top() const { return m_top.get(); } void commitNumber(CSSParserValue* v) { RefPtr val; if (v->id == CSSValueAuto) val = m_parser->cssValuePool()->createIdentifierValue(v->id); else val = m_parser->createPrimitiveNumericValue(v); if (!m_top) m_top = val; else if (!m_right) m_right = val; else if (!m_bottom) m_bottom = val; else { ASSERT(!m_left); m_left = val; } m_allowNumber = !m_left; m_allowFinalCommit = true; } void setAllowFinalCommit() { m_allowFinalCommit = true; } void setTop(PassRefPtr val) { m_top = val; } PassRefPtr commitBorderImageQuad() { // We need to clone and repeat values for any omissions. ASSERT(m_top); if (!m_right) { m_right = m_top; m_bottom = m_top; m_left = m_top; } if (!m_bottom) { m_bottom = m_top; m_left = m_right; } if (!m_left) m_left = m_right; // Now build a quad value to hold all four of our primitive values. RefPtr quad = Quad::create(); quad->setTop(m_top); quad->setRight(m_right); quad->setBottom(m_bottom); quad->setLeft(m_left); // Make our new value now. return m_parser->cssValuePool()->createValue(quad.release()); } private: CSSParser* m_parser; bool m_allowNumber; bool m_allowFinalCommit; RefPtr m_top; RefPtr m_right; RefPtr m_bottom; RefPtr m_left; }; bool CSSParser::parseBorderImageQuad(Units validUnits, RefPtr& result) { BorderImageQuadParseContext context(this); CSSParserValue* val; while ((val = m_valueList->current())) { if (context.allowNumber() && (validUnit(val, validUnits, true) || val->id == CSSValueAuto)) { context.commitNumber(val); } else if (!inShorthand()) { // If we're not parsing a shorthand then we are invalid. return false; } else { if (context.allowFinalCommit()) m_valueList->previous(); // The shorthand loop will advance back to this point. break; } m_valueList->next(); } if (context.allowFinalCommit()) { // Need to fully commit as a single value. result = context.commitBorderImageQuad(); return true; } return false; } bool CSSParser::parseBorderImageWidth(RefPtr& result) { return parseBorderImageQuad(FLength | FInteger | FNonNeg | FPercent, result); } bool CSSParser::parseBorderImageOutset(RefPtr& result) { return parseBorderImageQuad(FLength | FInteger | FNonNeg, result); } static void completeBorderRadii(RefPtr radii[4]) { if (radii[3]) return; if (!radii[2]) { if (!radii[1]) radii[1] = radii[0]; radii[2] = radii[0]; } radii[3] = radii[1]; } bool CSSParser::parseBorderRadius(int propId, bool important) { unsigned num = m_valueList->size(); if (num > 9) return false; ShorthandScope scope(this, propId); RefPtr radii[2][4]; unsigned indexAfterSlash = 0; for (unsigned i = 0; i < num; ++i) { CSSParserValue* value = m_valueList->valueAt(i); if (value->unit == CSSParserValue::Operator) { if (value->iValue != '/') return false; if (!i || indexAfterSlash || i + 1 == num || num > i + 5) return false; indexAfterSlash = i + 1; completeBorderRadii(radii[0]); continue; } if (i - indexAfterSlash >= 4) return false; if (!validUnit(value, FLength | FPercent | FNonNeg, m_strict)) return false; RefPtr radius = createPrimitiveNumericValue(value); if (!indexAfterSlash) { radii[0][i] = radius; // Legacy syntax: -webkit-border-radius: l1 l2; is equivalent to border-radius: l1 / l2; if (num == 2 && propId == CSSPropertyWebkitBorderRadius) { indexAfterSlash = 1; completeBorderRadii(radii[0]); } } else radii[1][i - indexAfterSlash] = radius.release(); } if (!indexAfterSlash) { completeBorderRadii(radii[0]); for (unsigned i = 0; i < 4; ++i) radii[1][i] = radii[0][i]; } else completeBorderRadii(radii[1]); ImplicitScope implicitScope(this, PropertyImplicit); addProperty(CSSPropertyBorderTopLeftRadius, cssValuePool()->createValue(Pair::create(radii[0][0].release(), radii[1][0].release())), important); addProperty(CSSPropertyBorderTopRightRadius, cssValuePool()->createValue(Pair::create(radii[0][1].release(), radii[1][1].release())), important); addProperty(CSSPropertyBorderBottomRightRadius, cssValuePool()->createValue(Pair::create(radii[0][2].release(), radii[1][2].release())), important); addProperty(CSSPropertyBorderBottomLeftRadius, cssValuePool()->createValue(Pair::create(radii[0][3].release(), radii[1][3].release())), important); return true; } bool CSSParser::parseAspectRatio(bool important) { unsigned num = m_valueList->size(); if (num == 1 && m_valueList->valueAt(0)->id == CSSValueNone) { addProperty(CSSPropertyWebkitAspectRatio, cssValuePool()->createIdentifierValue(CSSValueNone), important); return true; } if (num != 3) return false; CSSParserValue* lvalue = m_valueList->valueAt(0); CSSParserValue* op = m_valueList->valueAt(1); CSSParserValue* rvalue = m_valueList->valueAt(2); if (op->unit != CSSParserValue::Operator || op->iValue != '/') return false; if (!validUnit(lvalue, FNumber | FNonNeg, m_strict) || !validUnit(rvalue, FNumber | FNonNeg, m_strict)) return false; if (!lvalue->fValue || !rvalue->fValue) return false; addProperty(CSSPropertyWebkitAspectRatio, CSSAspectRatioValue::create(narrowPrecisionToFloat(lvalue->fValue), narrowPrecisionToFloat(rvalue->fValue)), important); return true; } bool CSSParser::parseCounter(int propId, int defaultValue, bool important) { enum { ID, VAL } state = ID; RefPtr list = CSSValueList::createCommaSeparated(); RefPtr counterName; while (true) { CSSParserValue* val = m_valueList->current(); switch (state) { case ID: if (val && val->unit == CSSPrimitiveValue::CSS_IDENT) { counterName = createPrimitiveStringValue(val); state = VAL; m_valueList->next(); continue; } break; case VAL: { int i = defaultValue; if (val && val->unit == CSSPrimitiveValue::CSS_NUMBER) { i = clampToInteger(val->fValue); m_valueList->next(); } list->append(cssValuePool()->createValue(Pair::create(counterName.release(), cssValuePool()->createValue(i, CSSPrimitiveValue::CSS_NUMBER)))); state = ID; continue; } } break; } if (list->length() > 0) { addProperty(propId, list.release(), important); return true; } return false; } // This should go away once we drop support for -webkit-gradient static PassRefPtr parseDeprecatedGradientPoint(CSSParserValue* a, bool horizontal, CSSValuePool* cssValuePool) { RefPtr result; if (a->unit == CSSPrimitiveValue::CSS_IDENT) { if ((equalIgnoringCase(a->string, "left") && horizontal) || (equalIgnoringCase(a->string, "top") && !horizontal)) result = cssValuePool->createValue(0., CSSPrimitiveValue::CSS_PERCENTAGE); else if ((equalIgnoringCase(a->string, "right") && horizontal) || (equalIgnoringCase(a->string, "bottom") && !horizontal)) result = cssValuePool->createValue(100., CSSPrimitiveValue::CSS_PERCENTAGE); else if (equalIgnoringCase(a->string, "center")) result = cssValuePool->createValue(50., CSSPrimitiveValue::CSS_PERCENTAGE); } else if (a->unit == CSSPrimitiveValue::CSS_NUMBER || a->unit == CSSPrimitiveValue::CSS_PERCENTAGE) result = cssValuePool->createValue(a->fValue, static_cast(a->unit)); return result; } static bool parseDeprecatedGradientColorStop(CSSParser* p, CSSParserValue* a, CSSGradientColorStop& stop) { if (a->unit != CSSParserValue::Function) return false; if (!equalIgnoringCase(a->function->name, "from(") && !equalIgnoringCase(a->function->name, "to(") && !equalIgnoringCase(a->function->name, "color-stop(")) return false; CSSParserValueList* args = a->function->args.get(); if (!args) return false; if (equalIgnoringCase(a->function->name, "from(") || equalIgnoringCase(a->function->name, "to(")) { // The "from" and "to" stops expect 1 argument. if (args->size() != 1) return false; if (equalIgnoringCase(a->function->name, "from(")) stop.m_position = p->cssValuePool()->createValue(0, CSSPrimitiveValue::CSS_NUMBER); else stop.m_position = p->cssValuePool()->createValue(1, CSSPrimitiveValue::CSS_NUMBER); int id = args->current()->id; if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu) stop.m_color = p->cssValuePool()->createIdentifierValue(id); else stop.m_color = p->parseColor(args->current()); if (!stop.m_color) return false; } // The "color-stop" function expects 3 arguments. if (equalIgnoringCase(a->function->name, "color-stop(")) { if (args->size() != 3) return false; CSSParserValue* stopArg = args->current(); if (stopArg->unit == CSSPrimitiveValue::CSS_PERCENTAGE) stop.m_position = p->cssValuePool()->createValue(stopArg->fValue / 100, CSSPrimitiveValue::CSS_NUMBER); else if (stopArg->unit == CSSPrimitiveValue::CSS_NUMBER) stop.m_position = p->cssValuePool()->createValue(stopArg->fValue, CSSPrimitiveValue::CSS_NUMBER); else return false; stopArg = args->next(); if (stopArg->unit != CSSParserValue::Operator || stopArg->iValue != ',') return false; stopArg = args->next(); int id = stopArg->id; if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu) stop.m_color = p->cssValuePool()->createIdentifierValue(id); else stop.m_color = p->parseColor(stopArg); if (!stop.m_color) return false; } return true; } bool CSSParser::parseDeprecatedGradient(CSSParserValueList* valueList, RefPtr& gradient) { // Walk the arguments. CSSParserValueList* args = valueList->current()->function->args.get(); if (!args || args->size() == 0) return false; // The first argument is the gradient type. It is an identifier. CSSGradientType gradientType; CSSParserValue* a = args->current(); if (!a || a->unit != CSSPrimitiveValue::CSS_IDENT) return false; if (equalIgnoringCase(a->string, "linear")) gradientType = CSSLinearGradient; else if (equalIgnoringCase(a->string, "radial")) gradientType = CSSRadialGradient; else return false; RefPtr result; switch (gradientType) { case CSSLinearGradient: result = CSSLinearGradientValue::create(NonRepeating, true); break; case CSSRadialGradient: result = CSSRadialGradientValue::create(NonRepeating, true); break; } // Comma. a = args->next(); if (!a || a->unit != CSSParserValue::Operator || a->iValue != ',') return false; // Next comes the starting point for the gradient as an x y pair. There is no // comma between the x and the y values. // First X. It can be left, right, number or percent. a = args->next(); if (!a) return false; RefPtr point = parseDeprecatedGradientPoint(a, true, cssValuePool()); if (!point) return false; result->setFirstX(point.release()); // First Y. It can be top, bottom, number or percent. a = args->next(); if (!a) return false; point = parseDeprecatedGradientPoint(a, false, cssValuePool()); if (!point) return false; result->setFirstY(point.release()); // Comma after the first point. a = args->next(); if (!a || a->unit != CSSParserValue::Operator || a->iValue != ',') return false; // For radial gradients only, we now expect a numeric radius. if (gradientType == CSSRadialGradient) { a = args->next(); if (!a || a->unit != CSSPrimitiveValue::CSS_NUMBER) return false; static_cast(result.get())->setFirstRadius(createPrimitiveNumericValue(a)); // Comma after the first radius. a = args->next(); if (!a || a->unit != CSSParserValue::Operator || a->iValue != ',') return false; } // Next is the ending point for the gradient as an x, y pair. // Second X. It can be left, right, number or percent. a = args->next(); if (!a) return false; point = parseDeprecatedGradientPoint(a, true, cssValuePool()); if (!point) return false; result->setSecondX(point.release()); // Second Y. It can be top, bottom, number or percent. a = args->next(); if (!a) return false; point = parseDeprecatedGradientPoint(a, false, cssValuePool()); if (!point) return false; result->setSecondY(point.release()); // For radial gradients only, we now expect the second radius. if (gradientType == CSSRadialGradient) { // Comma after the second point. a = args->next(); if (!a || a->unit != CSSParserValue::Operator || a->iValue != ',') return false; a = args->next(); if (!a || a->unit != CSSPrimitiveValue::CSS_NUMBER) return false; static_cast(result.get())->setSecondRadius(createPrimitiveNumericValue(a)); } // We now will accept any number of stops (0 or more). a = args->next(); while (a) { // Look for the comma before the next stop. if (a->unit != CSSParserValue::Operator || a->iValue != ',') return false; // Now examine the stop itself. a = args->next(); if (!a) return false; // The function name needs to be one of "from", "to", or "color-stop." CSSGradientColorStop stop; if (!parseDeprecatedGradientColorStop(this, a, stop)) return false; result->addStop(stop); // Advance a = args->next(); } gradient = result.release(); return true; } static PassRefPtr valueFromSideKeyword(CSSParserValue* a, bool& isHorizontal, CSSValuePool* cssValuePool) { if (a->unit != CSSPrimitiveValue::CSS_IDENT) return 0; switch (a->id) { case CSSValueLeft: case CSSValueRight: isHorizontal = true; break; case CSSValueTop: case CSSValueBottom: isHorizontal = false; break; default: return 0; } return cssValuePool->createIdentifierValue(a->id); } static PassRefPtr parseGradientColorOrKeyword(CSSParser* p, CSSParserValue* value) { int id = value->id; if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor) return p->cssValuePool()->createIdentifierValue(id); return p->parseColor(value); } bool CSSParser::parseLinearGradient(CSSParserValueList* valueList, RefPtr& gradient, CSSGradientRepeat repeating) { RefPtr result = CSSLinearGradientValue::create(repeating); // Walk the arguments. CSSParserValueList* args = valueList->current()->function->args.get(); if (!args || !args->size()) return false; CSSParserValue* a = args->current(); if (!a) return false; bool expectComma = false; // Look for angle. if (validUnit(a, FAngle, true)) { result->setAngle(createPrimitiveNumericValue(a)); a = args->next(); expectComma = true; } else { // Look one or two optional keywords that indicate a side or corner. RefPtr startX, startY; RefPtr location; bool isHorizontal = false; if ((location = valueFromSideKeyword(a, isHorizontal, cssValuePool()))) { if (isHorizontal) startX = location; else startY = location; a = args->next(); if (a) { if ((location = valueFromSideKeyword(a, isHorizontal, cssValuePool()))) { if (isHorizontal) { if (startX) return false; startX = location; } else { if (startY) return false; startY = location; } a = args->next(); } } expectComma = true; } if (!startX && !startY) startY = cssValuePool()->createIdentifierValue(CSSValueTop); result->setFirstX(startX.release()); result->setFirstY(startY.release()); } if (!parseGradientColorStops(args, result.get(), expectComma)) return false; Vector& stops = result->stops(); if (stops.isEmpty()) return false; gradient = result.release(); return true; } bool CSSParser::parseRadialGradient(CSSParserValueList* valueList, RefPtr& gradient, CSSGradientRepeat repeating) { RefPtr result = CSSRadialGradientValue::create(repeating); // Walk the arguments. CSSParserValueList* args = valueList->current()->function->args.get(); if (!args || !args->size()) return false; CSSParserValue* a = args->current(); if (!a) return false; bool expectComma = false; // Optional background-position RefPtr centerX; RefPtr centerY; // parseFillPosition advances the args next pointer. parseFillPosition(args, centerX, centerY); a = args->current(); if (!a) return false; if (centerX || centerY) { // Comma if (a->unit != CSSParserValue::Operator || a->iValue != ',') return false; a = args->next(); if (!a) return false; } ASSERT(!centerX || centerX->isPrimitiveValue()); ASSERT(!centerY || centerY->isPrimitiveValue()); result->setFirstX(static_cast(centerX.get())); result->setSecondX(static_cast(centerX.get())); // CSS3 radial gradients always share the same start and end point. result->setFirstY(static_cast(centerY.get())); result->setSecondY(static_cast(centerY.get())); RefPtr shapeValue; RefPtr sizeValue; // Optional shape and/or size in any order. for (int i = 0; i < 2; ++i) { if (a->unit != CSSPrimitiveValue::CSS_IDENT) break; bool foundValue = false; switch (a->id) { case CSSValueCircle: case CSSValueEllipse: shapeValue = cssValuePool()->createIdentifierValue(a->id); foundValue = true; break; case CSSValueClosestSide: case CSSValueClosestCorner: case CSSValueFarthestSide: case CSSValueFarthestCorner: case CSSValueContain: case CSSValueCover: sizeValue = cssValuePool()->createIdentifierValue(a->id); foundValue = true; break; } if (foundValue) { a = args->next(); if (!a) return false; expectComma = true; } } result->setShape(shapeValue); result->setSizingBehavior(sizeValue); // Or, two lengths or percentages RefPtr horizontalSize; RefPtr verticalSize; if (!shapeValue && !sizeValue) { if (validUnit(a, FLength | FPercent, m_strict)) { horizontalSize = createPrimitiveNumericValue(a); a = args->next(); if (!a) return false; expectComma = true; } if (validUnit(a, FLength | FPercent, m_strict)) { verticalSize = createPrimitiveNumericValue(a); a = args->next(); if (!a) return false; expectComma = true; } } // Must have neither or both. if (!horizontalSize != !verticalSize) return false; result->setEndHorizontalSize(horizontalSize); result->setEndVerticalSize(verticalSize); if (!parseGradientColorStops(args, result.get(), expectComma)) return false; gradient = result.release(); return true; } bool CSSParser::parseGradientColorStops(CSSParserValueList* valueList, CSSGradientValue* gradient, bool expectComma) { CSSParserValue* a = valueList->current(); // Now look for color stops. while (a) { // Look for the comma before the next stop. if (expectComma) { if (a->unit != CSSParserValue::Operator || a->iValue != ',') return false; a = valueList->next(); if (!a) return false; } // = [ | ]? CSSGradientColorStop stop; stop.m_color = parseGradientColorOrKeyword(this, a); if (!stop.m_color) return false; a = valueList->next(); if (a) { if (validUnit(a, FLength | FPercent, m_strict)) { stop.m_position = createPrimitiveNumericValue(a); a = valueList->next(); } } gradient->addStop(stop); expectComma = true; } // Must have 2 or more stops to be valid. return gradient->stops().size() > 1; } bool CSSParser::isGeneratedImageValue(CSSParserValue* val) const { if (val->unit != CSSParserValue::Function) return false; return equalIgnoringCase(val->function->name, "-webkit-gradient(") || equalIgnoringCase(val->function->name, "-webkit-linear-gradient(") || equalIgnoringCase(val->function->name, "-webkit-repeating-linear-gradient(") || equalIgnoringCase(val->function->name, "-webkit-radial-gradient(") || equalIgnoringCase(val->function->name, "-webkit-repeating-radial-gradient(") || equalIgnoringCase(val->function->name, "-webkit-canvas(") || equalIgnoringCase(val->function->name, "-webkit-cross-fade("); } bool CSSParser::parseGeneratedImage(CSSParserValueList* valueList, RefPtr& value) { CSSParserValue* val = valueList->current(); if (val->unit != CSSParserValue::Function) return false; if (equalIgnoringCase(val->function->name, "-webkit-gradient(")) return parseDeprecatedGradient(valueList, value); if (equalIgnoringCase(val->function->name, "-webkit-linear-gradient(")) return parseLinearGradient(valueList, value, NonRepeating); if (equalIgnoringCase(val->function->name, "-webkit-repeating-linear-gradient(")) return parseLinearGradient(valueList, value, Repeating); if (equalIgnoringCase(val->function->name, "-webkit-radial-gradient(")) return parseRadialGradient(valueList, value, NonRepeating); if (equalIgnoringCase(val->function->name, "-webkit-repeating-radial-gradient(")) return parseRadialGradient(valueList, value, Repeating); if (equalIgnoringCase(val->function->name, "-webkit-canvas(")) return parseCanvas(valueList, value); if (equalIgnoringCase(val->function->name, "-webkit-cross-fade(")) return parseCrossfade(valueList, value); return false; } bool CSSParser::parseCrossfade(CSSParserValueList* valueList, RefPtr& crossfade) { RefPtr result; // Walk the arguments. CSSParserValueList* args = valueList->current()->function->args.get(); if (!args || args->size() != 5) return false; CSSParserValue* a = args->current(); RefPtr fromImageValue; RefPtr toImageValue; // The first argument is the "from" image. It is a fill image. if (!a || !parseFillImage(args, fromImageValue)) return false; a = args->next(); // Skip a comma if (a->unit != CSSParserValue::Operator || a->iValue != ',') return false; a = args->next(); // The second argument is the "to" image. It is a fill image. if (!a || !parseFillImage(args, toImageValue)) return false; a = args->next(); // Skip a comma if (a->unit != CSSParserValue::Operator || a->iValue != ',') return false; a = args->next(); // The third argument is the crossfade value. It is a percentage or a fractional number. RefPtr percentage; if (!a) return false; if (a->unit == CSSPrimitiveValue::CSS_PERCENTAGE) percentage = cssValuePool()->createValue(clampTo(a->fValue / 100, 0, 1), CSSPrimitiveValue::CSS_NUMBER); else if (a->unit == CSSPrimitiveValue::CSS_NUMBER) percentage = cssValuePool()->createValue(clampTo(a->fValue, 0, 1), CSSPrimitiveValue::CSS_NUMBER); else return false; result = CSSCrossfadeValue::create(fromImageValue, toImageValue); result->setPercentage(percentage); crossfade = result; return true; } bool CSSParser::parseCanvas(CSSParserValueList* valueList, RefPtr& canvas) { // Walk the arguments. CSSParserValueList* args = valueList->current()->function->args.get(); if (!args || args->size() != 1) return false; // The first argument is the canvas name. It is an identifier. CSSParserValue* value = args->current(); if (!value || value->unit != CSSPrimitiveValue::CSS_IDENT) return false; canvas = CSSCanvasValue::create(value->string); return true; } class TransformOperationInfo { public: TransformOperationInfo(const CSSParserString& name) : m_type(WebKitCSSTransformValue::UnknownTransformOperation) , m_argCount(1) , m_allowSingleArgument(false) , m_unit(CSSParser::FUnknown) { if (equalIgnoringCase(name, "scale(") || equalIgnoringCase(name, "scalex(") || equalIgnoringCase(name, "scaley(") || equalIgnoringCase(name, "scalez(")) { m_unit = CSSParser::FNumber; if (equalIgnoringCase(name, "scale(")) m_type = WebKitCSSTransformValue::ScaleTransformOperation; else if (equalIgnoringCase(name, "scalex(")) m_type = WebKitCSSTransformValue::ScaleXTransformOperation; else if (equalIgnoringCase(name, "scaley(")) m_type = WebKitCSSTransformValue::ScaleYTransformOperation; else m_type = WebKitCSSTransformValue::ScaleZTransformOperation; } else if (equalIgnoringCase(name, "scale3d(")) { m_type = WebKitCSSTransformValue::Scale3DTransformOperation; m_argCount = 5; m_unit = CSSParser::FNumber; } else if (equalIgnoringCase(name, "rotate(")) { m_type = WebKitCSSTransformValue::RotateTransformOperation; m_unit = CSSParser::FAngle; } else if (equalIgnoringCase(name, "rotatex(") || equalIgnoringCase(name, "rotatey(") || equalIgnoringCase(name, "rotatez(")) { m_unit = CSSParser::FAngle; if (equalIgnoringCase(name, "rotatex(")) m_type = WebKitCSSTransformValue::RotateXTransformOperation; else if (equalIgnoringCase(name, "rotatey(")) m_type = WebKitCSSTransformValue::RotateYTransformOperation; else m_type = WebKitCSSTransformValue::RotateZTransformOperation; } else if (equalIgnoringCase(name, "rotate3d(")) { m_type = WebKitCSSTransformValue::Rotate3DTransformOperation; m_argCount = 7; m_unit = CSSParser::FNumber; } else if (equalIgnoringCase(name, "skew(") || equalIgnoringCase(name, "skewx(") || equalIgnoringCase(name, "skewy(")) { m_unit = CSSParser::FAngle; if (equalIgnoringCase(name, "skew(")) m_type = WebKitCSSTransformValue::SkewTransformOperation; else if (equalIgnoringCase(name, "skewx(")) m_type = WebKitCSSTransformValue::SkewXTransformOperation; else m_type = WebKitCSSTransformValue::SkewYTransformOperation; } else if (equalIgnoringCase(name, "translate(") || equalIgnoringCase(name, "translatex(") || equalIgnoringCase(name, "translatey(") || equalIgnoringCase(name, "translatez(")) { m_unit = CSSParser::FLength | CSSParser::FPercent; if (equalIgnoringCase(name, "translate(")) m_type = WebKitCSSTransformValue::TranslateTransformOperation; else if (equalIgnoringCase(name, "translatex(")) m_type = WebKitCSSTransformValue::TranslateXTransformOperation; else if (equalIgnoringCase(name, "translatey(")) m_type = WebKitCSSTransformValue::TranslateYTransformOperation; else m_type = WebKitCSSTransformValue::TranslateZTransformOperation; } else if (equalIgnoringCase(name, "translate3d(")) { m_type = WebKitCSSTransformValue::Translate3DTransformOperation; m_argCount = 5; m_unit = CSSParser::FLength | CSSParser::FPercent; } else if (equalIgnoringCase(name, "matrix(")) { m_type = WebKitCSSTransformValue::MatrixTransformOperation; m_argCount = 11; m_unit = CSSParser::FNumber; } else if (equalIgnoringCase(name, "matrix3d(")) { m_type = WebKitCSSTransformValue::Matrix3DTransformOperation; m_argCount = 31; m_unit = CSSParser::FNumber; } else if (equalIgnoringCase(name, "perspective(")) { m_type = WebKitCSSTransformValue::PerspectiveTransformOperation; m_unit = CSSParser::FNumber; } if (equalIgnoringCase(name, "scale(") || equalIgnoringCase(name, "skew(") || equalIgnoringCase(name, "translate(")) { m_allowSingleArgument = true; m_argCount = 3; } } WebKitCSSTransformValue::TransformOperationType type() const { return m_type; } unsigned argCount() const { return m_argCount; } CSSParser::Units unit() const { return m_unit; } bool unknown() const { return m_type == WebKitCSSTransformValue::UnknownTransformOperation; } bool hasCorrectArgCount(unsigned argCount) { return m_argCount == argCount || (m_allowSingleArgument && argCount == 1); } private: WebKitCSSTransformValue::TransformOperationType m_type; unsigned m_argCount; bool m_allowSingleArgument; CSSParser::Units m_unit; }; PassRefPtr CSSParser::parseTransform() { if (!m_valueList) return 0; // The transform is a list of functional primitives that specify transform operations. // We collect a list of WebKitCSSTransformValues, where each value specifies a single operation. RefPtr list = CSSValueList::createSpaceSeparated(); for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) { if (value->unit != CSSParserValue::Function || !value->function) return 0; // Every primitive requires at least one argument. CSSParserValueList* args = value->function->args.get(); if (!args) return 0; // See if the specified primitive is one we understand. TransformOperationInfo info(value->function->name); if (info.unknown()) return 0; if (!info.hasCorrectArgCount(args->size())) return 0; // Create the new WebKitCSSTransformValue for this operation and add it to our list. RefPtr transformValue = WebKitCSSTransformValue::create(info.type()); list->append(transformValue); // Snag our values. CSSParserValue* a = args->current(); unsigned argNumber = 0; while (a) { CSSParser::Units unit = info.unit(); if (info.type() == WebKitCSSTransformValue::Rotate3DTransformOperation && argNumber == 3) { // 4th param of rotate3d() is an angle rather than a bare number, validate it as such if (!validUnit(a, FAngle, true)) return 0; } else if (info.type() == WebKitCSSTransformValue::Translate3DTransformOperation && argNumber == 2) { // 3rd param of translate3d() cannot be a percentage if (!validUnit(a, FLength, true)) return 0; } else if (info.type() == WebKitCSSTransformValue::TranslateZTransformOperation && argNumber == 0) { // 1st param of translateZ() cannot be a percentage if (!validUnit(a, FLength, true)) return 0; } else if (info.type() == WebKitCSSTransformValue::PerspectiveTransformOperation && argNumber == 0) { // 1st param of perspective() must be a non-negative number (deprecated) or length. if (!validUnit(a, FNumber | FLength | FNonNeg, true)) return 0; } else if (!validUnit(a, unit, true)) return 0; // Add the value to the current transform operation. transformValue->append(createPrimitiveNumericValue(a)); a = args->next(); if (!a) break; if (a->unit != CSSParserValue::Operator || a->iValue != ',') return 0; a = args->next(); argNumber++; } } return list.release(); } #if ENABLE(CSS_FILTERS) static void filterInfoForName(const CSSParserString& name, WebKitCSSFilterValue::FilterOperationType& filterType, unsigned& maximumArgumentCount) { if (equalIgnoringCase(name, "grayscale(")) filterType = WebKitCSSFilterValue::GrayscaleFilterOperation; else if (equalIgnoringCase(name, "sepia(")) filterType = WebKitCSSFilterValue::SepiaFilterOperation; else if (equalIgnoringCase(name, "saturate(")) filterType = WebKitCSSFilterValue::SaturateFilterOperation; else if (equalIgnoringCase(name, "hue-rotate(")) filterType = WebKitCSSFilterValue::HueRotateFilterOperation; else if (equalIgnoringCase(name, "invert(")) filterType = WebKitCSSFilterValue::InvertFilterOperation; else if (equalIgnoringCase(name, "opacity(")) filterType = WebKitCSSFilterValue::OpacityFilterOperation; else if (equalIgnoringCase(name, "brightness(")) filterType = WebKitCSSFilterValue::BrightnessFilterOperation; else if (equalIgnoringCase(name, "contrast(")) filterType = WebKitCSSFilterValue::ContrastFilterOperation; else if (equalIgnoringCase(name, "blur(")) filterType = WebKitCSSFilterValue::BlurFilterOperation; else if (equalIgnoringCase(name, "drop-shadow(")) { filterType = WebKitCSSFilterValue::DropShadowFilterOperation; maximumArgumentCount = 4; // x-offset, y-offset, blur-radius, color -- spread and inset style not allowed. } #if ENABLE(CSS_SHADERS) else if (equalIgnoringCase(name, "custom(")) filterType = WebKitCSSFilterValue::CustomFilterOperation; #endif } #if ENABLE(CSS_SHADERS) static bool acceptCommaOperator(CSSParserValueList* argsList) { if (CSSParserValue* arg = argsList->current()) { if (arg->unit != CSSParserValue::Operator || arg->iValue != ',') return false; argsList->next(); } return true; } PassRefPtr CSSParser::parseCustomFilter(CSSParserValue* value) { CSSParserValueList* argsList = value->function->args.get(); if (!argsList) return 0; RefPtr filterValue = WebKitCSSFilterValue::create(WebKitCSSFilterValue::CustomFilterOperation); // Custom filter syntax: // // vertexShader: | none // fragmentShader: | none // // box: filter-box | border-box | padding-box | content-box // vertexMesh: +{1,2}[wsp][wsp'detached'] // // param-value: true|false[wsp+true|false]{0-3} | // [wsp+]{0-3} | // | // | // )> // array: 'array('[wsp]*')' // css-3d-transform: ;[]* // transform: | // mat: 'mat2('(,){3}')' | // 'mat3('(,){8}')' | // 'mat4('(,){15}')' ) // param-def: wsp // param-name: // params: [[,*]] // // custom([wsp][,][,]) // 1. Parse the shader URLs: [wsp] RefPtr shadersList = CSSValueList::createSpaceSeparated(); bool hadAtLeastOneCustomShader = false; CSSParserValue* arg; while ((arg = argsList->current())) { RefPtr value; if (arg->id == CSSValueNone) value = cssValuePool()->createIdentifierValue(CSSValueNone); else if (arg->unit == CSSPrimitiveValue::CSS_URI) { KURL shaderURL = m_styleSheet ? m_styleSheet->completeURL(arg->string) : KURL(); value = WebKitCSSShaderValue::create(shaderURL.string()); hadAtLeastOneCustomShader = true; } if (!value) break; shadersList->append(value.release()); argsList->next(); } if (!shadersList->length() || !hadAtLeastOneCustomShader || shadersList->length() > 2 || !acceptCommaOperator(argsList)) return 0; filterValue->append(shadersList.release()); // 2. Parse the mesh size RefPtr meshSizeList = CSSValueList::createSpaceSeparated(); while ((arg = argsList->current())) { if (!validUnit(arg, FInteger | FNonNeg, true)) break; int integerValue = clampToInteger(arg->fValue); // According to the specification we can only accept positive non-zero values. if (integerValue < 1) return 0; meshSizeList->append(cssValuePool()->createValue(integerValue, CSSPrimitiveValue::CSS_NUMBER)); argsList->next(); } if (meshSizeList->length() > 2) return 0; if ((arg = argsList->current()) && (arg->id == CSSValueBorderBox || arg->id == CSSValuePaddingBox || arg->id == CSSValueContentBox || arg->id == CSSValueFilterBox)) { meshSizeList->append(cssValuePool()->createIdentifierValue(arg->id)); argsList->next(); } if ((arg = argsList->current()) && arg->id == CSSValueDetached) { meshSizeList->append(cssValuePool()->createIdentifierValue(arg->id)); argsList->next(); } if (meshSizeList->length()) { if (!acceptCommaOperator(argsList)) return 0; filterValue->append(meshSizeList.release()); } // 3. Parser the parameters. RefPtr paramList = CSSValueList::createCommaSeparated(); while ((arg = argsList->current())) { if (arg->id || arg->unit != CSSPrimitiveValue::CSS_IDENT) return 0; RefPtr parameter = CSSValueList::createSpaceSeparated(); parameter->append(createPrimitiveStringValue(arg)); argsList->next(); if (!(arg = argsList->current())) return 0; // TODO: Implement other parameters types parsing. // textures: https://bugs.webkit.org/show_bug.cgi?id=71442 // 3d-transforms: https://bugs.webkit.org/show_bug.cgi?id=71443 // mat2, mat3, mat4: https://bugs.webkit.org/show_bug.cgi?id=71444 RefPtr paramValueList = CSSValueList::createSpaceSeparated(); while ((arg = argsList->current())) { // If we hit a comma it means we finished this parameter's values. if (arg->unit == CSSParserValue::Operator && arg->iValue == ',') break; if (!validUnit(arg, FNumber, true)) return 0; paramValueList->append(cssValuePool()->createValue(arg->fValue, CSSPrimitiveValue::CSS_NUMBER)); argsList->next(); } if (!paramValueList->length() || paramValueList->length() > 4) return 0; parameter->append(paramValueList.release()); paramList->append(parameter.release()); if (!acceptCommaOperator(argsList)) return 0; } if (paramList->length()) filterValue->append(paramList.release()); return filterValue; } #endif PassRefPtr CSSParser::parseBuiltinFilterArguments(CSSParserValueList* args, WebKitCSSFilterValue::FilterOperationType filterType) { RefPtr filterValue = WebKitCSSFilterValue::create(filterType); ASSERT(args); switch (filterType) { case WebKitCSSFilterValue::GrayscaleFilterOperation: case WebKitCSSFilterValue::SepiaFilterOperation: case WebKitCSSFilterValue::SaturateFilterOperation: case WebKitCSSFilterValue::InvertFilterOperation: case WebKitCSSFilterValue::OpacityFilterOperation: case WebKitCSSFilterValue::ContrastFilterOperation: { // One optional argument, 0-1 or 0%-100%, if missing use 100%. if (args->size() > 1) return 0; if (args->size()) { CSSParserValue* value = args->current(); if (!validUnit(value, FNumber | FPercent | FNonNeg, true)) return 0; double amount = value->fValue; // Saturate and Contrast allow values over 100%. if (filterType != WebKitCSSFilterValue::SaturateFilterOperation && filterType != WebKitCSSFilterValue::ContrastFilterOperation) { double maxAllowed = value->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 100.0 : 1.0; if (amount > maxAllowed) return 0; } filterValue->append(cssValuePool()->createValue(amount, static_cast(value->unit))); } break; } case WebKitCSSFilterValue::BrightnessFilterOperation: { // One optional argument, -1 to +1 or -100% to +100%, if missing use 0, if (args->size() > 1) return 0; if (args->size()) { CSSParserValue* value = args->current(); if (!validUnit(value, FNumber | FPercent, true)) return 0; double amount = value->fValue; double minAllowed = value->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? -100.0 : -1.0; double maxAllowed = value->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 100.0 : 1.0; if (amount < minAllowed || amount > maxAllowed) return 0; filterValue->append(cssValuePool()->createValue(amount, static_cast(value->unit))); } break; } case WebKitCSSFilterValue::HueRotateFilterOperation: { // hue-rotate() takes one optional angle. if (args->size() > 1) return 0; if (args->size()) { CSSParserValue* argument = args->current(); if (!validUnit(argument, FAngle, true)) return 0; filterValue->append(createPrimitiveNumericValue(argument)); } break; } case WebKitCSSFilterValue::BlurFilterOperation: { // Blur takes a single length. Zero parameters are allowed. if (args->size() > 1) return 0; if (args->size()) { CSSParserValue* argument = args->current(); if (!validUnit(argument, FLength | FNonNeg, true)) return 0; filterValue->append(createPrimitiveNumericValue(argument)); } break; } case WebKitCSSFilterValue::DropShadowFilterOperation: { // drop-shadow() takes a single shadow. RefPtr shadowValueList = parseShadow(args, CSSPropertyWebkitFilter); if (!shadowValueList || shadowValueList->length() != 1) return 0; filterValue->append((shadowValueList.release())->itemWithoutBoundsCheck(0)); break; } default: ASSERT_NOT_REACHED(); } return filterValue.release(); } PassRefPtr CSSParser::parseFilter() { if (!m_valueList) return 0; // The filter is a list of functional primitives that specify individual operations. RefPtr list = CSSValueList::createSpaceSeparated(); for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) { if (value->unit != CSSPrimitiveValue::CSS_URI && (value->unit != CSSParserValue::Function || !value->function)) return 0; WebKitCSSFilterValue::FilterOperationType filterType = WebKitCSSFilterValue::UnknownFilterOperation; // See if the specified primitive is one we understand. if (value->unit == CSSPrimitiveValue::CSS_URI) { RefPtr referenceFilterValue = WebKitCSSFilterValue::create(WebKitCSSFilterValue::ReferenceFilterOperation); list->append(referenceFilterValue); referenceFilterValue->append(cssValuePool()->createValue(value->string, CSSPrimitiveValue::CSS_STRING)); } else { const CSSParserString name = value->function->name; unsigned maximumArgumentCount = 1; filterInfoForName(name, filterType, maximumArgumentCount); if (filterType == WebKitCSSFilterValue::UnknownFilterOperation) return 0; #if ENABLE(CSS_SHADERS) if (filterType == WebKitCSSFilterValue::CustomFilterOperation) { // Make sure parsing fails if custom filters are disabled. if (Document* document = findDocument()) { Settings* settings = document->settings(); if (!settings || !settings->isCSSCustomFilterEnabled()) return 0; } RefPtr filterValue = parseCustomFilter(value); if (!filterValue) return 0; list->append(filterValue.release()); continue; } #endif CSSParserValueList* args = value->function->args.get(); if (!args) return 0; RefPtr filterValue = parseBuiltinFilterArguments(args, filterType); if (!filterValue) return 0; list->append(filterValue); } } return list.release(); } #endif static bool validFlowName(const String& flowName) { if (equalIgnoringCase(flowName, "auto") || equalIgnoringCase(flowName, "default") || equalIgnoringCase(flowName, "inherit") || equalIgnoringCase(flowName, "initial") || equalIgnoringCase(flowName, "none")) return false; return true; } // auto | bool CSSParser::parseFlowThread(int propId, bool important) { ASSERT(propId == CSSPropertyWebkitFlowInto); if (m_valueList->size() != 1) return false; CSSParserValue* value = m_valueList->current(); if (!value) return false; if (value->unit != CSSPrimitiveValue::CSS_IDENT) return false; if (value->id == CSSValueAuto) { addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important); return true; } String inputProperty = String(value->string); if (!inputProperty.isEmpty()) { if (!validFlowName(inputProperty)) return false; addProperty(propId, cssValuePool()->createValue(inputProperty, CSSPrimitiveValue::CSS_STRING), important); } else addProperty(propId, cssValuePool()->createIdentifierValue(CSSValueAuto), important); return true; } // -webkit-flow-from: none | bool CSSParser::parseRegionThread(int propId, bool important) { ASSERT(propId == CSSPropertyWebkitFlowFrom); if (m_valueList->size() != 1) return false; CSSParserValue* value = m_valueList->current(); if (!value) return false; if (value->unit != CSSPrimitiveValue::CSS_IDENT) return false; if (value->id == CSSValueNone) addProperty(propId, cssValuePool()->createIdentifierValue(value->id), important); else { String inputProperty = String(value->string); if (!inputProperty.isEmpty()) { if (!validFlowName(inputProperty)) return false; addProperty(propId, cssValuePool()->createValue(inputProperty, CSSPrimitiveValue::CSS_STRING), important); } else addProperty(propId, cssValuePool()->createIdentifierValue(CSSValueNone), important); } return true; } bool CSSParser::parseTransformOrigin(int propId, int& propId1, int& propId2, int& propId3, RefPtr& value, RefPtr& value2, RefPtr& value3) { propId1 = propId; propId2 = propId; propId3 = propId; if (propId == CSSPropertyWebkitTransformOrigin) { propId1 = CSSPropertyWebkitTransformOriginX; propId2 = CSSPropertyWebkitTransformOriginY; propId3 = CSSPropertyWebkitTransformOriginZ; } switch (propId) { case CSSPropertyWebkitTransformOrigin: if (!parseTransformOriginShorthand(value, value2, value3)) return false; // parseTransformOriginShorthand advances the m_valueList pointer break; case CSSPropertyWebkitTransformOriginX: { value = parseFillPositionX(m_valueList.get()); if (value) m_valueList->next(); break; } case CSSPropertyWebkitTransformOriginY: { value = parseFillPositionY(m_valueList.get()); if (value) m_valueList->next(); break; } case CSSPropertyWebkitTransformOriginZ: { if (validUnit(m_valueList->current(), FLength, m_strict)) value = createPrimitiveNumericValue(m_valueList->current()); if (value) m_valueList->next(); break; } } return value; } bool CSSParser::parsePerspectiveOrigin(int propId, int& propId1, int& propId2, RefPtr& value, RefPtr& value2) { propId1 = propId; propId2 = propId; if (propId == CSSPropertyWebkitPerspectiveOrigin) { propId1 = CSSPropertyWebkitPerspectiveOriginX; propId2 = CSSPropertyWebkitPerspectiveOriginY; } switch (propId) { case CSSPropertyWebkitPerspectiveOrigin: parseFillPosition(m_valueList.get(), value, value2); break; case CSSPropertyWebkitPerspectiveOriginX: { value = parseFillPositionX(m_valueList.get()); if (value) m_valueList->next(); break; } case CSSPropertyWebkitPerspectiveOriginY: { value = parseFillPositionY(m_valueList.get()); if (value) m_valueList->next(); break; } } return value; } bool CSSParser::parseTextEmphasisStyle(bool important) { unsigned valueListSize = m_valueList->size(); RefPtr fill; RefPtr shape; for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) { if (value->unit == CSSPrimitiveValue::CSS_STRING) { if (fill || shape || (valueListSize != 1 && !inShorthand())) return false; addProperty(CSSPropertyWebkitTextEmphasisStyle, createPrimitiveStringValue(value), important); m_valueList->next(); return true; } if (value->id == CSSValueNone) { if (fill || shape || (valueListSize != 1 && !inShorthand())) return false; addProperty(CSSPropertyWebkitTextEmphasisStyle, cssValuePool()->createIdentifierValue(CSSValueNone), important); m_valueList->next(); return true; } if (value->id == CSSValueOpen || value->id == CSSValueFilled) { if (fill) return false; fill = cssValuePool()->createIdentifierValue(value->id); } else if (value->id == CSSValueDot || value->id == CSSValueCircle || value->id == CSSValueDoubleCircle || value->id == CSSValueTriangle || value->id == CSSValueSesame) { if (shape) return false; shape = cssValuePool()->createIdentifierValue(value->id); } else if (!inShorthand()) return false; else break; } if (fill && shape) { RefPtr parsedValues = CSSValueList::createSpaceSeparated(); parsedValues->append(fill.release()); parsedValues->append(shape.release()); addProperty(CSSPropertyWebkitTextEmphasisStyle, parsedValues.release(), important); return true; } if (fill) { addProperty(CSSPropertyWebkitTextEmphasisStyle, fill.release(), important); return true; } if (shape) { addProperty(CSSPropertyWebkitTextEmphasisStyle, shape.release(), important); return true; } return false; } bool CSSParser::parseLineBoxContain(bool important) { LineBoxContain lineBoxContain = LineBoxContainNone; for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) { if (value->id == CSSValueBlock) { if (lineBoxContain & LineBoxContainBlock) return false; lineBoxContain |= LineBoxContainBlock; } else if (value->id == CSSValueInline) { if (lineBoxContain & LineBoxContainInline) return false; lineBoxContain |= LineBoxContainInline; } else if (value->id == CSSValueFont) { if (lineBoxContain & LineBoxContainFont) return false; lineBoxContain |= LineBoxContainFont; } else if (value->id == CSSValueGlyphs) { if (lineBoxContain & LineBoxContainGlyphs) return false; lineBoxContain |= LineBoxContainGlyphs; } else if (value->id == CSSValueReplaced) { if (lineBoxContain & LineBoxContainReplaced) return false; lineBoxContain |= LineBoxContainReplaced; } else if (value->id == CSSValueInlineBox) { if (lineBoxContain & LineBoxContainInlineBox) return false; lineBoxContain |= LineBoxContainInlineBox; } else return false; } if (!lineBoxContain) return false; addProperty(CSSPropertyWebkitLineBoxContain, CSSLineBoxContainValue::create(lineBoxContain), important); return true; } bool CSSParser::parseFontFeatureTag(CSSValueList* settings) { // Feature tag name consists of 4-letter characters. static const int tagNameLength = 4; CSSParserValue* value = m_valueList->current(); // Feature tag name comes first if (value->unit != CSSPrimitiveValue::CSS_STRING && value->unit != CSSPrimitiveValue::CSS_IDENT) return false; if (value->string.length != tagNameLength) return false; for (int i = 0; i < tagNameLength; ++i) { // Limits the range of characters to 0x20-0x7E, following the tag name rules defiend in the OpenType specification. UChar character = value->string.characters[i]; if (character < 0x20 || character > 0x7E) return false; } String tag = value->string; int tagValue = 1; // Feature tag values could follow: | on | off value = m_valueList->next(); if (value) { if (value->unit == CSSPrimitiveValue::CSS_NUMBER && value->isInt && value->fValue >= 0) { tagValue = clampToInteger(value->fValue); if (tagValue < 0) return false; m_valueList->next(); } else if (value->id == CSSValueOn || value->id == CSSValueOff) { tagValue = value->id == CSSValueOn; m_valueList->next(); } } settings->append(FontFeatureValue::create(tag, tagValue)); return true; } bool CSSParser::parseFontFeatureSettings(bool important) { if (m_valueList->size() == 1 && m_valueList->current()->id == CSSValueNormal) { RefPtr normalValue = cssValuePool()->createIdentifierValue(CSSValueNormal); m_valueList->next(); addProperty(CSSPropertyWebkitFontFeatureSettings, normalValue.release(), important); return true; } RefPtr settings = CSSValueList::createCommaSeparated(); for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) { if (!parseFontFeatureTag(settings.get())) return false; // If the list isn't parsed fully, the current value should be comma. value = m_valueList->current(); if (value && !(value->unit == CSSParserValue::Operator && value->iValue == ',')) return false; } if (settings->length()) { addProperty(CSSPropertyWebkitFontFeatureSettings, settings.release(), important); return true; } return false; } bool CSSParser::parseFontVariantLigatures(bool important) { RefPtr ligatureValues = CSSValueList::createSpaceSeparated(); bool sawCommonLigaturesValue = false; bool sawDiscretionaryLigaturesValue = false; bool sawHistoricalLigaturesValue = false; for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) { if (value->unit != CSSPrimitiveValue::CSS_IDENT) return false; switch (value->id) { case CSSValueNoCommonLigatures: case CSSValueCommonLigatures: if (sawCommonLigaturesValue) return false; sawCommonLigaturesValue = true; ligatureValues->append(cssValuePool()->createIdentifierValue(value->id)); break; case CSSValueNoDiscretionaryLigatures: case CSSValueDiscretionaryLigatures: if (sawDiscretionaryLigaturesValue) return false; sawDiscretionaryLigaturesValue = true; ligatureValues->append(cssValuePool()->createIdentifierValue(value->id)); break; case CSSValueNoHistoricalLigatures: case CSSValueHistoricalLigatures: if (sawHistoricalLigaturesValue) return false; sawHistoricalLigaturesValue = true; ligatureValues->append(cssValuePool()->createIdentifierValue(value->id)); break; default: return false; } } if (!ligatureValues->length()) return false; addProperty(CSSPropertyWebkitFontVariantLigatures, ligatureValues.release(), important); return true; } bool CSSParser::parseCalculation(CSSParserValue* value) { ASSERT(isCalculation(value)); CSSParserValueList* args = value->function->args.get(); if (!args || !args->size()) return false; ASSERT(!m_parsedCalculation); m_parsedCalculation = CSSCalcValue::create(value->function->name, args); if (!m_parsedCalculation) return false; return true; } #define END_TOKEN 0 #include "CSSGrammar.h" enum CharacterType { // Types for the main switch. // The first 4 types must be grouped together, as they // represent the allowed chars in an identifier. CharacterCaselessU, CharacterIdentifierStart, CharacterNumber, CharacterDash, CharacterOther, CharacterNull, CharacterWhiteSpace, CharacterEndMediaQuery, CharacterEndNthChild, CharacterQuote, CharacterExclamationMark, CharacterHashmark, CharacterDollar, CharacterAsterisk, CharacterPlus, CharacterDot, CharacterSlash, CharacterLess, CharacterAt, CharacterBackSlash, CharacterXor, CharacterVerticalBar, CharacterTilde, }; // 128 ASCII codes static const CharacterType typesOfASCIICharacters[128] = { /* 0 - Null */ CharacterNull, /* 1 - Start of Heading */ CharacterOther, /* 2 - Start of Text */ CharacterOther, /* 3 - End of Text */ CharacterOther, /* 4 - End of Transm. */ CharacterOther, /* 5 - Enquiry */ CharacterOther, /* 6 - Acknowledgment */ CharacterOther, /* 7 - Bell */ CharacterOther, /* 8 - Back Space */ CharacterOther, /* 9 - Horizontal Tab */ CharacterWhiteSpace, /* 10 - Line Feed */ CharacterWhiteSpace, /* 11 - Vertical Tab */ CharacterOther, /* 12 - Form Feed */ CharacterWhiteSpace, /* 13 - Carriage Return */ CharacterWhiteSpace, /* 14 - Shift Out */ CharacterOther, /* 15 - Shift In */ CharacterOther, /* 16 - Data Line Escape */ CharacterOther, /* 17 - Device Control 1 */ CharacterOther, /* 18 - Device Control 2 */ CharacterOther, /* 19 - Device Control 3 */ CharacterOther, /* 20 - Device Control 4 */ CharacterOther, /* 21 - Negative Ack. */ CharacterOther, /* 22 - Synchronous Idle */ CharacterOther, /* 23 - End of Transmit */ CharacterOther, /* 24 - Cancel */ CharacterOther, /* 25 - End of Medium */ CharacterOther, /* 26 - Substitute */ CharacterOther, /* 27 - Escape */ CharacterOther, /* 28 - File Separator */ CharacterOther, /* 29 - Group Separator */ CharacterOther, /* 30 - Record Separator */ CharacterOther, /* 31 - Unit Separator */ CharacterOther, /* 32 - Space */ CharacterWhiteSpace, /* 33 - ! */ CharacterExclamationMark, /* 34 - " */ CharacterQuote, /* 35 - # */ CharacterHashmark, /* 36 - $ */ CharacterDollar, /* 37 - % */ CharacterOther, /* 38 - & */ CharacterOther, /* 39 - ' */ CharacterQuote, /* 40 - ( */ CharacterOther, /* 41 - ) */ CharacterEndNthChild, /* 42 - * */ CharacterAsterisk, /* 43 - + */ CharacterPlus, /* 44 - , */ CharacterOther, /* 45 - - */ CharacterDash, /* 46 - . */ CharacterDot, /* 47 - / */ CharacterSlash, /* 48 - 0 */ CharacterNumber, /* 49 - 1 */ CharacterNumber, /* 50 - 2 */ CharacterNumber, /* 51 - 3 */ CharacterNumber, /* 52 - 4 */ CharacterNumber, /* 53 - 5 */ CharacterNumber, /* 54 - 6 */ CharacterNumber, /* 55 - 7 */ CharacterNumber, /* 56 - 8 */ CharacterNumber, /* 57 - 9 */ CharacterNumber, /* 58 - : */ CharacterOther, /* 59 - ; */ CharacterEndMediaQuery, /* 60 - < */ CharacterLess, /* 61 - = */ CharacterOther, /* 62 - > */ CharacterOther, /* 63 - ? */ CharacterOther, /* 64 - @ */ CharacterAt, /* 65 - A */ CharacterIdentifierStart, /* 66 - B */ CharacterIdentifierStart, /* 67 - C */ CharacterIdentifierStart, /* 68 - D */ CharacterIdentifierStart, /* 69 - E */ CharacterIdentifierStart, /* 70 - F */ CharacterIdentifierStart, /* 71 - G */ CharacterIdentifierStart, /* 72 - H */ CharacterIdentifierStart, /* 73 - I */ CharacterIdentifierStart, /* 74 - J */ CharacterIdentifierStart, /* 75 - K */ CharacterIdentifierStart, /* 76 - L */ CharacterIdentifierStart, /* 77 - M */ CharacterIdentifierStart, /* 78 - N */ CharacterIdentifierStart, /* 79 - O */ CharacterIdentifierStart, /* 80 - P */ CharacterIdentifierStart, /* 81 - Q */ CharacterIdentifierStart, /* 82 - R */ CharacterIdentifierStart, /* 83 - S */ CharacterIdentifierStart, /* 84 - T */ CharacterIdentifierStart, /* 85 - U */ CharacterCaselessU, /* 86 - V */ CharacterIdentifierStart, /* 87 - W */ CharacterIdentifierStart, /* 88 - X */ CharacterIdentifierStart, /* 89 - Y */ CharacterIdentifierStart, /* 90 - Z */ CharacterIdentifierStart, /* 91 - [ */ CharacterOther, /* 92 - \ */ CharacterBackSlash, /* 93 - ] */ CharacterOther, /* 94 - ^ */ CharacterXor, /* 95 - _ */ CharacterIdentifierStart, /* 96 - ` */ CharacterOther, /* 97 - a */ CharacterIdentifierStart, /* 98 - b */ CharacterIdentifierStart, /* 99 - c */ CharacterIdentifierStart, /* 100 - d */ CharacterIdentifierStart, /* 101 - e */ CharacterIdentifierStart, /* 102 - f */ CharacterIdentifierStart, /* 103 - g */ CharacterIdentifierStart, /* 104 - h */ CharacterIdentifierStart, /* 105 - i */ CharacterIdentifierStart, /* 106 - j */ CharacterIdentifierStart, /* 107 - k */ CharacterIdentifierStart, /* 108 - l */ CharacterIdentifierStart, /* 109 - m */ CharacterIdentifierStart, /* 110 - n */ CharacterIdentifierStart, /* 111 - o */ CharacterIdentifierStart, /* 112 - p */ CharacterIdentifierStart, /* 113 - q */ CharacterIdentifierStart, /* 114 - r */ CharacterIdentifierStart, /* 115 - s */ CharacterIdentifierStart, /* 116 - t */ CharacterIdentifierStart, /* 117 - u */ CharacterCaselessU, /* 118 - v */ CharacterIdentifierStart, /* 119 - w */ CharacterIdentifierStart, /* 120 - x */ CharacterIdentifierStart, /* 121 - y */ CharacterIdentifierStart, /* 122 - z */ CharacterIdentifierStart, /* 123 - { */ CharacterEndMediaQuery, /* 124 - | */ CharacterVerticalBar, /* 125 - } */ CharacterOther, /* 126 - ~ */ CharacterTilde, /* 127 - Delete */ CharacterOther, }; // Utility functions for the CSS tokenizer. static inline bool isCSSLetter(UChar character) { return character >= 128 || typesOfASCIICharacters[character] <= CharacterDash; } static inline bool isCSSEscape(UChar character) { return character >= ' ' && character != 127; } static inline bool isURILetter(UChar character) { return (character >= '*' && character != 127) || (character >= '#' && character <= '&') || character == '!'; } static inline bool isIdentifierStartAfterDash(UChar* currentCharacter) { return isASCIIAlpha(currentCharacter[0]) || currentCharacter[0] == '_' || currentCharacter[0] >= 128 || (currentCharacter[0] == '\\' && isCSSEscape(currentCharacter[1])); } static inline bool isEqualToCSSIdentifier(UChar* cssString, const char* constantString) { // Compare an UChar memory data with a zero terminated string. do { // The input must be part of an identifier if constantChar or constString // contains '-'. Otherwise toASCIILowerUnchecked('\r') would be equal to '-'. ASSERT((*constantString >= 'a' && *constantString <= 'z') || *constantString == '-'); ASSERT(*constantString != '-' || isCSSLetter(*cssString)); if (toASCIILowerUnchecked(*cssString++) != (*constantString++)) return false; } while (*constantString); return true; } static UChar* checkAndSkipEscape(UChar* currentCharacter) { // Returns with 0, if escape check is failed. Otherwise // it returns with the following character. ASSERT(*currentCharacter == '\\'); ++currentCharacter; if (!isCSSEscape(*currentCharacter)) return 0; if (isASCIIHexDigit(*currentCharacter)) { int length = 6; do { ++currentCharacter; } while (isASCIIHexDigit(*currentCharacter) && --length); // Optional space after the escape sequence. if (isHTMLSpace(*currentCharacter)) ++currentCharacter; return currentCharacter; } return currentCharacter + 1; } static inline UChar* skipWhiteSpace(UChar* currentCharacter) { while (isHTMLSpace(*currentCharacter)) ++currentCharacter; return currentCharacter; } // Main CSS tokenizer functions. inline bool CSSParser::isIdentifierStart() { // Check whether an identifier is started. return isIdentifierStartAfterDash((*m_currentCharacter != '-') ? m_currentCharacter : m_currentCharacter + 1); } inline UChar* CSSParser::checkAndSkipString(UChar* currentCharacter, UChar quote) { // Returns with 0, if string check is failed. Otherwise // it returns with the following character. This is necessary // since we cannot revert escape sequences, thus strings // must be validated before parsing. while (true) { if (UNLIKELY(*currentCharacter == quote)) { // String parsing is successful. return currentCharacter + 1; } if (UNLIKELY(*currentCharacter <= '\r' && (!*currentCharacter || *currentCharacter == '\n' || (*currentCharacter | 0x1) == '\r'))) { // String parsing is failed for character '\0', '\n', '\f' or '\r'. return 0; } if (LIKELY(currentCharacter[0] != '\\')) ++currentCharacter; else if (currentCharacter[1] == '\n' || currentCharacter[1] == '\f') currentCharacter += 2; else if (currentCharacter[1] == '\r') currentCharacter += currentCharacter[2] == '\n' ? 3 : 2; else { currentCharacter = checkAndSkipEscape(currentCharacter); if (!currentCharacter) return 0; } } } void CSSParser::parseEscape(UChar*& result) { ASSERT(*m_currentCharacter == '\\' && isCSSEscape(m_currentCharacter[1])); ++m_currentCharacter; if (isASCIIHexDigit(*m_currentCharacter)) { unsigned unicode = 0; int length = 6; do { unicode = (unicode << 4) + toASCIIHexValue(*m_currentCharacter++); } while (--length && isASCIIHexDigit(*m_currentCharacter)); // Characters above 0xffff are not handled. if (unicode > 0xffff) unicode = 0xfffd; // Optional space after the escape sequence. if (isHTMLSpace(*m_currentCharacter)) ++m_currentCharacter; *result = unicode; } else *result = *m_currentCharacter++; ++result; } inline void CSSParser::parseIdentifier(UChar*& result, bool& hasEscape) { // If a valid identifier start is found, we can safely // parse the identifier until the next invalid character. ASSERT(isIdentifierStart()); hasEscape = false; do { if (LIKELY(*m_currentCharacter != '\\')) *result++ = *m_currentCharacter++; else { hasEscape = true; parseEscape(result); } } while (isCSSLetter(m_currentCharacter[0]) || (m_currentCharacter[0] == '\\' && isCSSEscape(m_currentCharacter[1]))); } inline void CSSParser::parseString(UChar*& result, UChar quote) { while (true) { if (UNLIKELY(*m_currentCharacter == quote)) { // String parsing is done. ++m_currentCharacter; return; } ASSERT(*m_currentCharacter > '\r' || (*m_currentCharacter < '\n' && *m_currentCharacter) || *m_currentCharacter == '\v'); if (LIKELY(m_currentCharacter[0] != '\\')) *result++ = *m_currentCharacter++; else if (m_currentCharacter[1] == '\n' || m_currentCharacter[1] == '\f') m_currentCharacter += 2; else if (m_currentCharacter[1] == '\r') m_currentCharacter += m_currentCharacter[2] == '\n' ? 3 : 2; else parseEscape(result); } } inline void CSSParser::parseURI(UChar*& start, UChar*& result) { UChar* uriStart = skipWhiteSpace(m_currentCharacter); if (*uriStart == '"' || *uriStart == '\'') { UChar quote = *uriStart; ++uriStart; UChar* stringEnd = checkAndSkipString(uriStart, quote); if (!stringEnd) return; stringEnd = skipWhiteSpace(stringEnd); if (*stringEnd != ')') return; start = result = m_currentCharacter = uriStart; parseString(result, quote); m_currentCharacter = stringEnd + 1; m_token = URI; } else { UChar* stringEnd = uriStart; while (isURILetter(*stringEnd)) { if (*stringEnd != '\\') ++stringEnd; else { stringEnd = checkAndSkipEscape(stringEnd); if (!stringEnd) return; } } stringEnd = skipWhiteSpace(stringEnd); if (*stringEnd != ')') return; start = result = m_currentCharacter = uriStart; while (isURILetter(*m_currentCharacter)) { if (LIKELY(*m_currentCharacter != '\\')) *result++ = *m_currentCharacter++; else parseEscape(result); } m_currentCharacter = stringEnd + 1; m_token = URI; } } inline bool CSSParser::parseUnicodeRange() { UChar* currentCharacter = m_currentCharacter + 1; int length = 6; ASSERT(*m_currentCharacter == '+'); while (isASCIIHexDigit(*currentCharacter) && length) { ++currentCharacter; --length; } if (length && *currentCharacter == '?') { // At most 5 hex digit followed by a question mark. do { ++currentCharacter; --length; } while (*currentCharacter == '?' && length); m_currentCharacter = currentCharacter; return true; } if (length < 6) { // At least one hex digit. if (currentCharacter[0] == '-' && isASCIIHexDigit(currentCharacter[1])) { // Followed by a dash and a hex digit. ++currentCharacter; length = 6; do { ++currentCharacter; } while (--length && isASCIIHexDigit(*currentCharacter)); } m_currentCharacter = currentCharacter; return true; } return false; } bool CSSParser::parseNthChild() { UChar* currentCharacter = m_currentCharacter; while (isASCIIDigit(*currentCharacter)) ++currentCharacter; if (isASCIIAlphaCaselessEqual(*currentCharacter, 'n')) { m_currentCharacter = currentCharacter + 1; return true; } return false; } bool CSSParser::parseNthChildExtra() { UChar* currentCharacter = skipWhiteSpace(m_currentCharacter); if (*currentCharacter != '+' && *currentCharacter != '-') return false; currentCharacter = skipWhiteSpace(currentCharacter + 1); if (!isASCIIDigit(*currentCharacter)) return false; do { ++currentCharacter; } while (isASCIIDigit(*currentCharacter)); m_currentCharacter = currentCharacter; return true; } inline void CSSParser::detectFunctionTypeToken(int length) { ASSERT(length > 0); UChar* name = m_tokenStart; switch (length) { case 3: if (isASCIIAlphaCaselessEqual(name[0], 'n') && isASCIIAlphaCaselessEqual(name[1], 'o') && isASCIIAlphaCaselessEqual(name[2], 't')) m_token = NOTFUNCTION; else if (isASCIIAlphaCaselessEqual(name[0], 'u') && isASCIIAlphaCaselessEqual(name[1], 'r') && isASCIIAlphaCaselessEqual(name[2], 'l')) m_token = URI; return; case 9: if (isEqualToCSSIdentifier(name, "nth-child")) m_parsingMode = NthChildMode; return; case 11: if (isEqualToCSSIdentifier(name, "nth-of-type")) m_parsingMode = NthChildMode; return; case 14: if (isEqualToCSSIdentifier(name, "nth-last-child")) m_parsingMode = NthChildMode; return; case 16: if (isEqualToCSSIdentifier(name, "nth-last-of-type")) m_parsingMode = NthChildMode; return; } } inline void CSSParser::detectMediaQueryToken(int length) { ASSERT(m_parsingMode == MediaQueryMode); UChar* name = m_tokenStart; if (length == 3) { if (isASCIIAlphaCaselessEqual(name[0], 'a') && isASCIIAlphaCaselessEqual(name[1], 'n') && isASCIIAlphaCaselessEqual(name[2], 'd')) m_token = MEDIA_AND; else if (isASCIIAlphaCaselessEqual(name[0], 'n') && isASCIIAlphaCaselessEqual(name[1], 'o') && isASCIIAlphaCaselessEqual(name[2], 't')) m_token = MEDIA_NOT; } else if (length == 4) { if (isASCIIAlphaCaselessEqual(name[0], 'o') && isASCIIAlphaCaselessEqual(name[1], 'n') && isASCIIAlphaCaselessEqual(name[2], 'l') && isASCIIAlphaCaselessEqual(name[3], 'y')) m_token = MEDIA_ONLY; } } inline void CSSParser::detectNumberToken(UChar* type, int length) { ASSERT(length > 0); switch (toASCIILowerUnchecked(type[0])) { case 'c': if (length == 2 && isASCIIAlphaCaselessEqual(type[1], 'm')) m_token = CMS; return; case 'd': if (length == 3 && isASCIIAlphaCaselessEqual(type[1], 'e') && isASCIIAlphaCaselessEqual(type[2], 'g')) m_token = DEGS; return; case 'e': if (length == 2) { if (isASCIIAlphaCaselessEqual(type[1], 'm')) m_token = EMS; else if (isASCIIAlphaCaselessEqual(type[1], 'x')) m_token = EXS; } return; case 'g': if (length == 4 && isASCIIAlphaCaselessEqual(type[1], 'r') && isASCIIAlphaCaselessEqual(type[2], 'a') && isASCIIAlphaCaselessEqual(type[3], 'd')) m_token = GRADS; return; case 'h': if (length == 2 && isASCIIAlphaCaselessEqual(type[1], 'z')) m_token = HERTZ; return; case 'i': if (length == 2 && isASCIIAlphaCaselessEqual(type[1], 'n')) m_token = INS; return; case 'k': if (length == 3 && isASCIIAlphaCaselessEqual(type[1], 'h') && isASCIIAlphaCaselessEqual(type[2], 'z')) m_token = KHERTZ; return; case 'm': if (length == 2) { if (isASCIIAlphaCaselessEqual(type[1], 'm')) m_token = MMS; else if (isASCIIAlphaCaselessEqual(type[1], 's')) m_token = MSECS; } return; case 'p': if (length == 2) { if (isASCIIAlphaCaselessEqual(type[1], 'x')) m_token = PXS; else if (isASCIIAlphaCaselessEqual(type[1], 't')) m_token = PTS; else if (isASCIIAlphaCaselessEqual(type[1], 'c')) m_token = PCS; } return; case 'r': if (length == 3) { if (isASCIIAlphaCaselessEqual(type[1], 'a') && isASCIIAlphaCaselessEqual(type[2], 'd')) m_token = RADS; else if (isASCIIAlphaCaselessEqual(type[1], 'e') && isASCIIAlphaCaselessEqual(type[2], 'm')) m_token = REMS; } return; case 's': if (length == 1) m_token = SECS; return; case 't': if (length == 4 && isASCIIAlphaCaselessEqual(type[1], 'u') && isASCIIAlphaCaselessEqual(type[2], 'r') && isASCIIAlphaCaselessEqual(type[3], 'n')) m_token = TURNS; return; default: if (type[0] == '_' && length == 5 && type[1] == '_' && isASCIIAlphaCaselessEqual(type[2], 'q') && isASCIIAlphaCaselessEqual(type[3], 'e') && isASCIIAlphaCaselessEqual(type[4], 'm')) m_token = QEMS; return; } } inline void CSSParser::detectDashToken(int length) { UChar* name = m_tokenStart; if (length == 11) { if (isASCIIAlphaCaselessEqual(name[10], 'y') && isEqualToCSSIdentifier(name + 1, "webkit-an")) m_token = ANYFUNCTION; else if (isASCIIAlphaCaselessEqual(name[10], 'n') && isEqualToCSSIdentifier(name + 1, "webkit-mi")) m_token = MINFUNCTION; else if (isASCIIAlphaCaselessEqual(name[10], 'x') && isEqualToCSSIdentifier(name + 1, "webkit-ma")) m_token = MAXFUNCTION; } else if (length == 12 && isEqualToCSSIdentifier(name + 1, "webkit-calc")) m_token = CALCFUNCTION; } inline void CSSParser::detectAtToken(int length, bool hasEscape) { UChar* name = m_tokenStart; ASSERT(name[0] == '@' && length >= 2); // charset, font-face, import, media, namespace, page, // -webkit-keyframes, and -webkit-mediaquery are not affected by hasEscape. switch (toASCIILowerUnchecked(name[1])) { case 'b': if (hasEscape) return; switch (length) { case 12: if (isEqualToCSSIdentifier(name + 2, "ottom-left")) m_token = BOTTOMLEFT_SYM; return; case 13: if (isEqualToCSSIdentifier(name + 2, "ottom-right")) m_token = BOTTOMRIGHT_SYM; return; case 14: if (isEqualToCSSIdentifier(name + 2, "ottom-center")) m_token = BOTTOMCENTER_SYM; return; case 19: if (isEqualToCSSIdentifier(name + 2, "ottom-left-corner")) m_token = BOTTOMLEFTCORNER_SYM; return; case 20: if (isEqualToCSSIdentifier(name + 2, "ottom-right-corner")) m_token = BOTTOMRIGHTCORNER_SYM; return; } return; case 'c': if (length == 8 && isEqualToCSSIdentifier(name + 2, "harset")) m_token = CHARSET_SYM; return; case 'f': if (length == 10 && isEqualToCSSIdentifier(name + 2, "ont-face")) m_token = FONT_FACE_SYM; return; case 'i': if (length == 7 && isEqualToCSSIdentifier(name + 2, "mport")) { m_parsingMode = MediaQueryMode; m_token = IMPORT_SYM; } return; case 'l': if (hasEscape) return; if (length == 9) { if (isEqualToCSSIdentifier(name + 2, "eft-top")) m_token = LEFTTOP_SYM; } else if (length == 12) { // Checking the last character first could further reduce the possibile cases. if (isASCIIAlphaCaselessEqual(name[11], 'e') && isEqualToCSSIdentifier(name + 2, "eft-middl")) m_token = LEFTMIDDLE_SYM; else if (isASCIIAlphaCaselessEqual(name[11], 'm') && isEqualToCSSIdentifier(name + 2, "eft-botto")) m_token = LEFTBOTTOM_SYM; } return; case 'm': if (length == 6 && isEqualToCSSIdentifier(name + 2, "edia")) { m_parsingMode = MediaQueryMode; m_token = MEDIA_SYM; } return; case 'n': if (length == 10 && isEqualToCSSIdentifier(name + 2, "amespace")) m_token = NAMESPACE_SYM; return; case 'p': if (length == 5 && isEqualToCSSIdentifier(name + 2, "age")) m_token = PAGE_SYM; return; case 'r': if (hasEscape) return; if (length == 10) { if (isEqualToCSSIdentifier(name + 2, "ight-top")) m_token = RIGHTTOP_SYM; } else if (length == 13) { // Checking the last character first could further reduce the possibile cases. if (isASCIIAlphaCaselessEqual(name[12], 'e') && isEqualToCSSIdentifier(name + 2, "ight-middl")) m_token = RIGHTMIDDLE_SYM; else if (isASCIIAlphaCaselessEqual(name[12], 'm') && isEqualToCSSIdentifier(name + 2, "ight-botto")) m_token = RIGHTBOTTOM_SYM; } return; case 't': if (hasEscape) return; switch (length) { case 9: if (isEqualToCSSIdentifier(name + 2, "op-left")) m_token = TOPLEFT_SYM; return; case 10: if (isEqualToCSSIdentifier(name + 2, "op-right")) m_token = TOPRIGHT_SYM; return; case 11: if (isEqualToCSSIdentifier(name + 2, "op-center")) m_token = TOPCENTER_SYM; return; case 16: if (isEqualToCSSIdentifier(name + 2, "op-left-corner")) m_token = TOPLEFTCORNER_SYM; return; case 17: if (isEqualToCSSIdentifier(name + 2, "op-right-corner")) m_token = TOPRIGHTCORNER_SYM; return; } return; case '-': switch (length) { case 13: if (!hasEscape && isEqualToCSSIdentifier(name + 2, "webkit-rule")) m_token = WEBKIT_RULE_SYM; return; case 14: if (hasEscape) return; // Checking the last character first could further reduce the possibile cases. if (isASCIIAlphaCaselessEqual(name[13], 's') && isEqualToCSSIdentifier(name + 2, "webkit-decl")) m_token = WEBKIT_DECLS_SYM; else if (isASCIIAlphaCaselessEqual(name[13], 'e') && isEqualToCSSIdentifier(name + 2, "webkit-valu")) m_token = WEBKIT_VALUE_SYM; return; case 15: if (!hasEscape && isEqualToCSSIdentifier(name + 2, "webkit-region")) m_token = WEBKIT_REGION_RULE_SYM; return; case 17: if (!hasEscape && isEqualToCSSIdentifier(name + 2, "webkit-selector")) m_token = WEBKIT_SELECTOR_SYM; return; case 18: if (isEqualToCSSIdentifier(name + 2, "webkit-keyframes")) m_token = WEBKIT_KEYFRAMES_SYM; return; case 19: if (isEqualToCSSIdentifier(name + 2, "webkit-mediaquery")) { m_parsingMode = MediaQueryMode; m_token = WEBKIT_MEDIAQUERY_SYM; } return; case 22: if (!hasEscape && isEqualToCSSIdentifier(name + 2, "webkit-keyframe-rule")) m_token = WEBKIT_KEYFRAME_RULE_SYM; return; } } } int CSSParser::lex(void* yylvalWithoutType) { YYSTYPE* yylval = static_cast(yylvalWithoutType); // Write pointer for the next character. UChar* result; bool hasEscape; // The input buffer is terminated by two \0, so // it is safe to read two characters ahead anytime. #ifndef NDEBUG // In debug we check with an ASSERT that the length is > 0 for string types. yylval->string.characters = 0; yylval->string.length = 0; #endif restartAfterComment: m_tokenStart = result = m_currentCharacter; m_token = *m_currentCharacter; ++m_currentCharacter; switch ((m_token <= 127) ? typesOfASCIICharacters[m_token] : CharacterIdentifierStart) { case CharacterCaselessU: if (UNLIKELY(*m_currentCharacter == '+')) if (parseUnicodeRange()) { m_token = UNICODERANGE; yylval->string.characters = m_tokenStart; yylval->string.length = m_currentCharacter - m_tokenStart; break; } // Fall through to CharacterIdentifierStart. case CharacterIdentifierStart: --m_currentCharacter; parseIdentifier(result, hasEscape); m_token = IDENT; yylval->string.characters = m_tokenStart; yylval->string.length = result - m_tokenStart; if (UNLIKELY(*m_currentCharacter == '(')) { m_token = FUNCTION; if (!hasEscape) detectFunctionTypeToken(result - m_tokenStart); ++m_currentCharacter; ++result; ++yylval->string.length; if (token() == URI) { m_token = FUNCTION; // Check whether it is really an URI. parseURI(yylval->string.characters, result); yylval->string.length = result - yylval->string.characters; } } else if (UNLIKELY(m_parsingMode != NormalMode) && !hasEscape) { if (m_parsingMode == MediaQueryMode) detectMediaQueryToken(result - m_tokenStart); else if (m_parsingMode == NthChildMode && isASCIIAlphaCaselessEqual(m_tokenStart[0], 'n')) { if (result - m_tokenStart == 1) { // String "n" is IDENT but "n+1" is NTH. if (parseNthChildExtra()) { m_token = NTH; yylval->string.length = m_currentCharacter - m_tokenStart; } } else if (result - m_tokenStart == 2 && m_tokenStart[1] == '-') { // String "n-" is IDENT but "n-1" is NTH. // Speculatively decrease m_currentCharacter to detect an nth-child token. m_currentCharacter--; if (parseNthChildExtra()) { m_token = NTH; yylval->string.length = m_currentCharacter - m_tokenStart; } else { // Revert the change to m_currentCharacter if unsuccessful. m_currentCharacter++; } } } } break; case CharacterDot: if (!isASCIIDigit(m_currentCharacter[0])) break; // Fall through to CharacterNumber. case CharacterNumber: { bool dotSeen = (m_token == '.'); while (true) { if (!isASCIIDigit(m_currentCharacter[0])) { // Only one dot is allowed for a number, // and it must be followed by a digit. if (m_currentCharacter[0] != '.' || dotSeen || !isASCIIDigit(m_currentCharacter[1])) break; dotSeen = true; } ++m_currentCharacter; } if (UNLIKELY(m_parsingMode == NthChildMode) && !dotSeen && isASCIIAlphaCaselessEqual(*m_currentCharacter, 'n')) { // "[0-9]+n" is always an NthChild. ++m_currentCharacter; parseNthChildExtra(); m_token = NTH; yylval->string.characters = m_tokenStart; yylval->string.length = m_currentCharacter - m_tokenStart; break; } yylval->number = charactersToDouble(m_tokenStart, m_currentCharacter - m_tokenStart); // Type of the function. if (isIdentifierStart()) { UChar* type = m_currentCharacter; result = m_currentCharacter; parseIdentifier(result, hasEscape); if (*m_currentCharacter == '+') { // Any identifier followed by a '+' sign is an invalid dimension. ++m_currentCharacter; m_token = INVALIDDIMEN; } else { m_token = DIMEN; if (!hasEscape) detectNumberToken(type, m_currentCharacter - type); if (m_token == DIMEN) { // The decoded number is overwritten, but this is intentional. yylval->string.characters = m_tokenStart; yylval->string.length = m_currentCharacter - m_tokenStart; } } } else if (*m_currentCharacter == '%') { // Although the CSS grammar says {num}% we follow // webkit at the moment which uses {num}%+. do { ++m_currentCharacter; } while (*m_currentCharacter == '%'); m_token = PERCENTAGE; } else m_token = dotSeen ? FLOATTOKEN : INTEGER; break; } case CharacterDash: if (isIdentifierStartAfterDash(m_currentCharacter)) { --m_currentCharacter; parseIdentifier(result, hasEscape); m_token = IDENT; if (*m_currentCharacter == '(') { m_token = FUNCTION; if (!hasEscape) detectDashToken(result - m_tokenStart); ++m_currentCharacter; ++result; } else if (UNLIKELY(m_parsingMode == NthChildMode) && !hasEscape && isASCIIAlphaCaselessEqual(m_tokenStart[1], 'n')) { if (result - m_tokenStart == 2) { // String "-n" is IDENT but "-n+1" is NTH. if (parseNthChildExtra()) { m_token = NTH; result = m_currentCharacter; } } else if (result - m_tokenStart == 3 && m_tokenStart[2] == '-') { // String "-n-" is IDENT but "-n-1" is NTH. // Speculatively decrease m_currentCharacter to detect an nth-child token. m_currentCharacter--; if (parseNthChildExtra()) { m_token = NTH; yylval->string.length = m_currentCharacter - m_tokenStart; } else { // Revert the change to m_currentCharacter if unsuccessful. m_currentCharacter++; } } } yylval->string.characters = m_tokenStart; yylval->string.length = result - m_tokenStart; } else if (m_currentCharacter[0] == '-' && m_currentCharacter[1] == '>') { m_currentCharacter += 2; m_token = SGML_CD; } else if (UNLIKELY(m_parsingMode == NthChildMode)) { // "-[0-9]+n" is always an NthChild. if (parseNthChild()) { parseNthChildExtra(); m_token = NTH; yylval->string.characters = m_tokenStart; yylval->string.length = m_currentCharacter - m_tokenStart; } } break; case CharacterOther: // m_token is simply the current character. break; case CharacterNull: // Do not advance pointer at the end of input. --m_currentCharacter; break; case CharacterWhiteSpace: m_token = WHITESPACE; // Might start with a '\n'. --m_currentCharacter; do { if (*m_currentCharacter == '\n') ++m_lineNumber; ++m_currentCharacter; } while (*m_currentCharacter <= ' ' && (typesOfASCIICharacters[*m_currentCharacter] == CharacterWhiteSpace)); break; case CharacterEndMediaQuery: if (m_parsingMode == MediaQueryMode) m_parsingMode = NormalMode; break; case CharacterEndNthChild: if (m_parsingMode == NthChildMode) m_parsingMode = NormalMode; break; case CharacterQuote: if (checkAndSkipString(m_currentCharacter, m_token)) { ++result; parseString(result, m_token); m_token = STRING; yylval->string.characters = m_tokenStart + 1; yylval->string.length = result - (m_tokenStart + 1); } break; case CharacterExclamationMark: { UChar* start = skipWhiteSpace(m_currentCharacter); if (isEqualToCSSIdentifier(start, "important")) { m_token = IMPORTANT_SYM; m_currentCharacter = start + 9; } break; } case CharacterHashmark: { UChar* start = m_currentCharacter; result = m_currentCharacter; if (isASCIIDigit(*m_currentCharacter)) { // This must be a valid hex number token. do { ++m_currentCharacter; } while (isASCIIHexDigit(*m_currentCharacter)); m_token = HEX; yylval->string.characters = start; yylval->string.length = m_currentCharacter - start; } else if (isIdentifierStart()) { m_token = IDSEL; parseIdentifier(result, hasEscape); if (!hasEscape) { // Check whether the identifier is also a valid hex number. UChar* current = start; m_token = HEX; do { if (!isASCIIHexDigit(*current)) { m_token = IDSEL; break; } ++current; } while (current < result); } yylval->string.characters = start; yylval->string.length = result - start; } break; } case CharacterSlash: // Ignore comments. They are not even considered as white spaces. if (*m_currentCharacter == '*') { ++m_currentCharacter; while (m_currentCharacter[0] != '*' || m_currentCharacter[1] != '/') { if (m_currentCharacter[0] == '\n') ++m_lineNumber; if (m_currentCharacter[0] == '\0' && m_currentCharacter[1] == '\0') { // Unterminated comments are simply ignored. m_currentCharacter -= 2; break; } ++m_currentCharacter; } m_currentCharacter += 2; goto restartAfterComment; } break; case CharacterDollar: if (*m_currentCharacter == '=') { ++m_currentCharacter; m_token = ENDSWITH; } break; case CharacterAsterisk: if (*m_currentCharacter == '=') { ++m_currentCharacter; m_token = CONTAINS; } break; case CharacterPlus: if (UNLIKELY(m_parsingMode == NthChildMode)) { // Simplest case. "+[0-9]*n" is always NthChild. if (parseNthChild()) { parseNthChildExtra(); m_token = NTH; yylval->string.characters = m_tokenStart; yylval->string.length = m_currentCharacter - m_tokenStart; } } break; case CharacterLess: if (m_currentCharacter[0] == '!' && m_currentCharacter[1] == '-' && m_currentCharacter[2] == '-') { m_currentCharacter += 3; m_token = SGML_CD; } break; case CharacterAt: if (isIdentifierStart()) { m_token = ATKEYWORD; ++result; parseIdentifier(result, hasEscape); detectAtToken(result - m_tokenStart, hasEscape); } break; case CharacterBackSlash: if (isCSSEscape(*m_currentCharacter)) { --m_currentCharacter; parseIdentifier(result, hasEscape); m_token = IDENT; yylval->string.characters = m_tokenStart; yylval->string.length = result - m_tokenStart; } break; case CharacterXor: if (*m_currentCharacter == '=') { ++m_currentCharacter; m_token = BEGINSWITH; } break; case CharacterVerticalBar: if (*m_currentCharacter == '=') { ++m_currentCharacter; m_token = DASHMATCH; } break; case CharacterTilde: if (*m_currentCharacter == '=') { ++m_currentCharacter; m_token = INCLUDES; } break; default: ASSERT_NOT_REACHED(); break; } #ifndef NDEBUG switch (token()) { case STRING: ASSERT(yylval->string.characters == m_tokenStart + 1); break; case IDENT: case NTH: case DIMEN: case UNICODERANGE: case FUNCTION: case ANYFUNCTION: case NOTFUNCTION: case CALCFUNCTION: case MINFUNCTION: case MAXFUNCTION: ASSERT(yylval->string.characters == m_tokenStart && yylval->string.length > 0); break; case URI: ASSERT(yylval->string.characters && yylval->string.characters != m_tokenStart); break; case HEX: case IDSEL: ASSERT(yylval->string.characters == m_tokenStart + 1 && yylval->string.length > 0); break; } #endif return token(); } CSSParserSelector* CSSParser::createFloatingSelector() { CSSParserSelector* selector = new CSSParserSelector; m_floatingSelectors.add(selector); return selector; } PassOwnPtr CSSParser::sinkFloatingSelector(CSSParserSelector* selector) { if (selector) { ASSERT(m_floatingSelectors.contains(selector)); m_floatingSelectors.remove(selector); } return adoptPtr(selector); } Vector >* CSSParser::createFloatingSelectorVector() { Vector >* selectorVector = new Vector >; m_floatingSelectorVectors.add(selectorVector); return selectorVector; } PassOwnPtr > > CSSParser::sinkFloatingSelectorVector(Vector >* selectorVector) { if (selectorVector) { ASSERT(m_floatingSelectorVectors.contains(selectorVector)); m_floatingSelectorVectors.remove(selectorVector); } return adoptPtr(selectorVector); } CSSParserValueList* CSSParser::createFloatingValueList() { CSSParserValueList* list = new CSSParserValueList; m_floatingValueLists.add(list); return list; } PassOwnPtr CSSParser::sinkFloatingValueList(CSSParserValueList* list) { if (list) { ASSERT(m_floatingValueLists.contains(list)); m_floatingValueLists.remove(list); } return adoptPtr(list); } CSSParserFunction* CSSParser::createFloatingFunction() { CSSParserFunction* function = new CSSParserFunction; m_floatingFunctions.add(function); return function; } PassOwnPtr CSSParser::sinkFloatingFunction(CSSParserFunction* function) { if (function) { ASSERT(m_floatingFunctions.contains(function)); m_floatingFunctions.remove(function); } return adoptPtr(function); } CSSParserValue& CSSParser::sinkFloatingValue(CSSParserValue& value) { if (value.unit == CSSParserValue::Function) { ASSERT(m_floatingFunctions.contains(value.function)); m_floatingFunctions.remove(value.function); } return value; } MediaQueryExp* CSSParser::createFloatingMediaQueryExp(const AtomicString& mediaFeature, CSSParserValueList* values) { m_floatingMediaQueryExp = MediaQueryExp::create(mediaFeature, values); return m_floatingMediaQueryExp.get(); } PassOwnPtr CSSParser::sinkFloatingMediaQueryExp(MediaQueryExp* expression) { ASSERT_UNUSED(expression, expression == m_floatingMediaQueryExp); return m_floatingMediaQueryExp.release(); } Vector >* CSSParser::createFloatingMediaQueryExpList() { m_floatingMediaQueryExpList = adoptPtr(new Vector >); return m_floatingMediaQueryExpList.get(); } PassOwnPtr > > CSSParser::sinkFloatingMediaQueryExpList(Vector >* list) { ASSERT_UNUSED(list, list == m_floatingMediaQueryExpList); return m_floatingMediaQueryExpList.release(); } MediaQuery* CSSParser::createFloatingMediaQuery(MediaQuery::Restrictor restrictor, const String& mediaType, PassOwnPtr > > expressions) { m_floatingMediaQuery = adoptPtr(new MediaQuery(restrictor, mediaType, expressions)); return m_floatingMediaQuery.get(); } MediaQuery* CSSParser::createFloatingMediaQuery(PassOwnPtr > > expressions) { return createFloatingMediaQuery(MediaQuery::None, "all", expressions); } PassOwnPtr CSSParser::sinkFloatingMediaQuery(MediaQuery* query) { ASSERT_UNUSED(query, query == m_floatingMediaQuery); return m_floatingMediaQuery.release(); } MediaList* CSSParser::createMediaList() { RefPtr list = MediaList::create(); MediaList* result = list.get(); m_parsedMediaLists.append(list.release()); return result; } CSSRule* CSSParser::createCharsetRule(const CSSParserString& charset) { if (!m_styleSheet) return 0; RefPtr rule = CSSCharsetRule::create(m_styleSheet, charset); CSSCharsetRule* result = rule.get(); m_parsedRules.append(rule.release()); return result; } CSSRule* CSSParser::createImportRule(const CSSParserString& url, MediaList* media) { if (!media || !m_styleSheet || !m_allowImportRules) return 0; RefPtr rule = CSSImportRule::create(m_styleSheet, url, media); CSSImportRule* result = rule.get(); m_parsedRules.append(rule.release()); return result; } CSSRule* CSSParser::createMediaRule(MediaList* media, CSSRuleList* rules) { if (!media || !rules || !m_styleSheet) return 0; m_allowImportRules = m_allowNamespaceDeclarations = false; RefPtr rule = CSSMediaRule::create(m_styleSheet, media, rules); CSSMediaRule* result = rule.get(); m_parsedRules.append(rule.release()); return result; } CSSRuleList* CSSParser::createRuleList() { RefPtr list = CSSRuleList::create(); CSSRuleList* listPtr = list.get(); m_parsedRuleLists.append(list.release()); return listPtr; } WebKitCSSKeyframesRule* CSSParser::createKeyframesRule() { m_allowImportRules = m_allowNamespaceDeclarations = false; RefPtr rule = WebKitCSSKeyframesRule::create(m_styleSheet); WebKitCSSKeyframesRule* rulePtr = rule.get(); m_parsedRules.append(rule.release()); return rulePtr; } CSSRule* CSSParser::createStyleRule(Vector >* selectors) { CSSStyleRule* result = 0; markRuleBodyEnd(); if (selectors) { m_allowImportRules = m_allowNamespaceDeclarations = false; RefPtr rule = CSSStyleRule::create(m_styleSheet, m_lastSelectorLineNumber); rule->adoptSelectorVector(*selectors); if (m_hasFontFaceOnlyValues) deleteFontFaceOnlyValues(); rule->setDeclaration(StylePropertySet::create(rule.get(), m_parsedProperties, m_numParsedProperties)); result = rule.get(); m_parsedRules.append(rule.release()); if (m_ruleRangeMap) { ASSERT(m_currentRuleData); m_currentRuleData->styleSourceData->styleBodyRange = m_ruleBodyRange; m_currentRuleData->selectorListRange = m_selectorListRange; m_ruleRangeMap->set(result, m_currentRuleData.release()); m_currentRuleData = CSSRuleSourceData::create(); m_currentRuleData->styleSourceData = CSSStyleSourceData::create(); m_inStyleRuleOrDeclaration = false; } } resetSelectorListMarks(); resetRuleBodyMarks(); clearProperties(); return result; } CSSRule* CSSParser::createFontFaceRule() { m_allowImportRules = m_allowNamespaceDeclarations = false; for (unsigned i = 0; i < m_numParsedProperties; ++i) { CSSProperty* property = m_parsedProperties[i]; int id = property->id(); if ((id == CSSPropertyFontWeight || id == CSSPropertyFontStyle || id == CSSPropertyFontVariant) && property->value()->isPrimitiveValue()) { RefPtr value = property->m_value.release(); property->m_value = CSSValueList::createCommaSeparated(); static_cast(property->value())->append(value.release()); } else if (id == CSSPropertyFontFamily && (!property->value()->isValueList() || static_cast(property->value())->length() != 1)) { // Unlike font-family property, font-family descriptor in @font-face rule // has to be a value list with exactly one family name. It cannot have a // have 'initial' value and cannot 'inherit' from parent. // See http://dev.w3.org/csswg/css3-fonts/#font-family-desc clearProperties(); return 0; } } RefPtr rule = CSSFontFaceRule::create(m_styleSheet); rule->setDeclaration(StylePropertySet::create(rule.get(), m_parsedProperties, m_numParsedProperties)); clearProperties(); CSSFontFaceRule* result = rule.get(); m_parsedRules.append(rule.release()); return result; } void CSSParser::addNamespace(const AtomicString& prefix, const AtomicString& uri) { if (!m_styleSheet || !m_allowNamespaceDeclarations) return; m_allowImportRules = false; m_styleSheet->addNamespace(this, prefix, uri); } void CSSParser::updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector* specifiers) { AtomicString determinedNamespace = namespacePrefix != nullAtom && m_styleSheet ? m_styleSheet->determineNamespace(namespacePrefix) : m_defaultNamespace; QualifiedName tag = QualifiedName(namespacePrefix, elementName, determinedNamespace); if (!specifiers->isUnknownPseudoElement()) { specifiers->setTag(tag); return; } CSSParserSelector* lastShadowDescendant = specifiers; CSSParserSelector* history = specifiers; while (history->tagHistory()) { history = history->tagHistory(); if (history->hasShadowDescendant()) lastShadowDescendant = history; } if (lastShadowDescendant->tagHistory()) { lastShadowDescendant->tagHistory()->setTag(tag); return; } // For shadow-ID pseudo-elements to be correctly matched, the ShadowDescendant combinator has to be used. // We therefore create a new Selector with that combinator here in any case, even if matching any (host) element in any namespace (i.e. '*'). OwnPtr elementNameSelector = adoptPtr(new CSSParserSelector); elementNameSelector->setTag(tag); lastShadowDescendant->setTagHistory(elementNameSelector.release()); lastShadowDescendant->setRelation(CSSSelector::ShadowDescendant); } CSSParserSelector* CSSParser::updateSpecifiers(CSSParserSelector* specifiers, CSSParserSelector* newSpecifier) { if (newSpecifier->isUnknownPseudoElement()) { // Unknown pseudo element always goes at the top of selector chain. newSpecifier->appendTagHistory(CSSSelector::ShadowDescendant, sinkFloatingSelector(specifiers)); return newSpecifier; } if (specifiers->isUnknownPseudoElement()) { // Specifiers for unknown pseudo element go right behind it in the chain. specifiers->insertTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(newSpecifier), CSSSelector::ShadowDescendant); return specifiers; } specifiers->appendTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(newSpecifier)); return specifiers; } CSSRule* CSSParser::createPageRule(PassOwnPtr pageSelector) { // FIXME: Margin at-rules are ignored. m_allowImportRules = m_allowNamespaceDeclarations = false; CSSPageRule* pageRule = 0; if (pageSelector) { RefPtr rule = CSSPageRule::create(m_styleSheet, m_lastSelectorLineNumber); Vector > selectorVector; selectorVector.append(pageSelector); rule->adoptSelectorVector(selectorVector); rule->setDeclaration(StylePropertySet::create(rule.get(), m_parsedProperties, m_numParsedProperties)); pageRule = rule.get(); m_parsedRules.append(rule.release()); } clearProperties(); return pageRule; } void CSSParser::setReusableRegionSelectorVector(Vector >* selectors) { if (selectors) m_reusableRegionSelectorVector.swap(*selectors); } CSSRule* CSSParser::createRegionRule(Vector >* regionSelector, CSSRuleList* rules) { if (!regionSelector || !rules) return 0; m_allowImportRules = m_allowNamespaceDeclarations = false; RefPtr regionRule = WebKitCSSRegionRule::create(m_styleSheet, regionSelector, rules); WebKitCSSRegionRule* result = regionRule.get(); m_parsedRules.append(regionRule.release()); return result; } CSSRule* CSSParser::createMarginAtRule(CSSSelector::MarginBoxType /* marginBox */) { // FIXME: Implement margin at-rule here, using: // - marginBox: margin box // - m_parsedProperties: properties at [m_numParsedPropertiesBeforeMarginBox, m_numParsedProperties) are for this at-rule. // Don't forget to also update the action for page symbol in CSSGrammar.y such that margin at-rule data is cleared if page_selector is invalid. endDeclarationsForMarginBox(); return 0; // until this method is implemented. } void CSSParser::startDeclarationsForMarginBox() { m_numParsedPropertiesBeforeMarginBox = m_numParsedProperties; } void CSSParser::endDeclarationsForMarginBox() { ASSERT(m_numParsedPropertiesBeforeMarginBox != INVALID_NUM_PARSED_PROPERTIES); rollbackLastProperties(m_numParsedProperties - m_numParsedPropertiesBeforeMarginBox); m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES; } void CSSParser::deleteFontFaceOnlyValues() { ASSERT(m_hasFontFaceOnlyValues); int deletedProperties = 0; for (unsigned i = 0; i < m_numParsedProperties; ++i) { CSSProperty* property = m_parsedProperties[i]; int id = property->id(); if ((id == CSSPropertyFontWeight || id == CSSPropertyFontStyle || id == CSSPropertyFontVariant) && property->value()->isValueList()) { delete property; deletedProperties++; } else if (deletedProperties) m_parsedProperties[i - deletedProperties] = m_parsedProperties[i]; } m_numParsedProperties -= deletedProperties; } WebKitCSSKeyframeRule* CSSParser::createKeyframeRule(CSSParserValueList* keys) { // Create a key string from the passed keys String keyString; for (unsigned i = 0; i < keys->size(); ++i) { float key = static_cast(keys->valueAt(i)->fValue); if (i != 0) keyString += ","; keyString += String::number(key); keyString += "%"; } RefPtr keyframe = WebKitCSSKeyframeRule::create(m_styleSheet); keyframe->setKeyText(keyString); keyframe->setDeclaration(StylePropertySet::create(keyframe.get(), m_parsedProperties, m_numParsedProperties)); clearProperties(); WebKitCSSKeyframeRule* keyframePtr = keyframe.get(); m_parsedRules.append(keyframe.release()); return keyframePtr; } void CSSParser::invalidBlockHit() { if (m_styleSheet && !m_hadSyntacticallyValidCSSRule) m_styleSheet->setHasSyntacticallyValidCSSHeader(false); } void CSSParser::updateLastSelectorLineAndPosition() { m_lastSelectorLineNumber = m_lineNumber; markRuleBodyStart(); } void CSSParser::updateLastMediaLine(MediaList* media) { media->setLastLine(m_lineNumber); } void CSSParser::markSelectorListStart() { m_selectorListRange.start = m_tokenStart - m_dataStart.get(); } void CSSParser::markSelectorListEnd() { if (!m_currentRuleData) return; UChar* listEnd = m_tokenStart; while (listEnd > m_dataStart.get() + 1) { if (isHTMLSpace(*(listEnd - 1))) --listEnd; else break; } m_selectorListRange.end = listEnd - m_dataStart.get(); } void CSSParser::markRuleBodyStart() { unsigned offset = m_tokenStart - m_dataStart.get(); if (*m_tokenStart == '{') ++offset; // Skip the rule body opening brace. if (offset > m_ruleBodyRange.start) m_ruleBodyRange.start = offset; m_inStyleRuleOrDeclaration = true; } void CSSParser::markRuleBodyEnd() { unsigned offset = m_tokenStart - m_dataStart.get(); if (offset > m_ruleBodyRange.end) m_ruleBodyRange.end = offset; } void CSSParser::markPropertyStart() { if (!m_inStyleRuleOrDeclaration) return; m_propertyRange.start = m_tokenStart - m_dataStart.get(); } void CSSParser::markPropertyEnd(bool isImportantFound, bool isPropertyParsed) { if (!m_inStyleRuleOrDeclaration) return; unsigned offset = m_tokenStart - m_dataStart.get(); if (*m_tokenStart == ';') // Include semicolon into the property text. ++offset; m_propertyRange.end = offset; if (m_propertyRange.start != UINT_MAX && m_currentRuleData) { // This stuff is only executed when the style data retrieval is requested by client. const unsigned start = m_propertyRange.start; const unsigned end = m_propertyRange.end; ASSERT(start < end); String propertyString = String(m_dataStart.get() + start, end - start).stripWhiteSpace(); if (propertyString.endsWith(";", true)) propertyString = propertyString.left(propertyString.length() - 1); size_t colonIndex = propertyString.find(":"); ASSERT(colonIndex != notFound); String name = propertyString.left(colonIndex).stripWhiteSpace(); String value = propertyString.substring(colonIndex + 1, propertyString.length()).stripWhiteSpace(); // The property range is relative to the declaration start offset. m_currentRuleData->styleSourceData->propertyData.append( CSSPropertySourceData(name, value, isImportantFound, isPropertyParsed, SourceRange(start - m_ruleBodyRange.start, end - m_ruleBodyRange.start))); } resetPropertyMarks(); } static int cssPropertyID(const UChar* propertyName, unsigned length) { if (!length) return 0; if (length > maxCSSPropertyNameLength) return 0; char buffer[maxCSSPropertyNameLength + 1 + 1]; // 1 to turn "apple"/"khtml" into "webkit", 1 for null character for (unsigned i = 0; i != length; ++i) { UChar c = propertyName[i]; if (c == 0 || c >= 0x7F) return 0; // illegal character buffer[i] = toASCIILower(c); } buffer[length] = '\0'; const char* name = buffer; if (buffer[0] == '-') { // If the prefix is -apple- or -khtml-, change it to -webkit-. // This makes the string one character longer. if (hasPrefix(buffer, length, "-apple-") || hasPrefix(buffer, length, "-khtml-")) { memmove(buffer + 7, buffer + 6, length + 1 - 6); memcpy(buffer, "-webkit", 7); ++length; } #if PLATFORM(IOS) if (!strcmp(buffer, "-webkit-hyphenate-locale")) { // Worked in iOS 4.2. const char* const webkitLocale = "-webkit-locale"; name = webkitLocale; length = strlen(webkitLocale); } #endif } const Property* hashTableEntry = findProperty(name, length); return hashTableEntry ? hashTableEntry->id : 0; } int cssPropertyID(const String& string) { return cssPropertyID(string.characters(), string.length()); } int cssPropertyID(const CSSParserString& string) { return cssPropertyID(string.characters, string.length); } int cssValueKeywordID(const CSSParserString& string) { unsigned length = string.length; if (!length) return 0; if (length > maxCSSValueKeywordLength) return 0; char buffer[maxCSSValueKeywordLength + 1 + 1]; // 1 to turn "apple"/"khtml" into "webkit", 1 for null character for (unsigned i = 0; i != length; ++i) { UChar c = string.characters[i]; if (c == 0 || c >= 0x7F) return 0; // illegal character buffer[i] = WTF::toASCIILower(c); } buffer[length] = '\0'; if (buffer[0] == '-') { // If the prefix is -apple- or -khtml-, change it to -webkit-. // This makes the string one character longer. if (hasPrefix(buffer, length, "-apple-") || hasPrefix(buffer, length, "-khtml-")) { memmove(buffer + 7, buffer + 6, length + 1 - 6); memcpy(buffer, "-webkit", 7); ++length; } } const Value* hashTableEntry = findValue(buffer, length); return hashTableEntry ? hashTableEntry->id : 0; } // "ident" from the CSS tokenizer, minus backslash-escape sequences static bool isCSSTokenizerIdentifier(const String& string) { const UChar* p = string.characters(); const UChar* end = p + string.length(); // -? if (p != end && p[0] == '-') ++p; // {nmstart} if (p == end || !(p[0] == '_' || p[0] >= 128 || isASCIIAlpha(p[0]))) return false; ++p; // {nmchar}* for (; p != end; ++p) { if (!(p[0] == '_' || p[0] == '-' || p[0] >= 128 || isASCIIAlphanumeric(p[0]))) return false; } return true; } // "url" from the CSS tokenizer, minus backslash-escape sequences static bool isCSSTokenizerURL(const String& string) { const UChar* p = string.characters(); const UChar* end = p + string.length(); for (; p != end; ++p) { UChar c = p[0]; switch (c) { case '!': case '#': case '$': case '%': case '&': break; default: if (c < '*') return false; if (c <= '~') break; if (c < 128) return false; } } return true; } // We use single quotes for now because markup.cpp uses double quotes. String quoteCSSString(const String& string) { // For efficiency, we first pre-calculate the length of the quoted string, then we build the actual one. // Please see below for the actual logic. unsigned quotedStringSize = 2; // Two quotes surrounding the entire string. bool afterEscape = false; for (unsigned i = 0; i < string.length(); ++i) { UChar ch = string[i]; if (ch == '\\' || ch == '\'') { quotedStringSize += 2; afterEscape = false; } else if (ch < 0x20 || ch == 0x7F) { quotedStringSize += 2 + (ch >= 0x10); afterEscape = true; } else { quotedStringSize += 1 + (afterEscape && (isASCIIHexDigit(ch) || ch == ' ')); afterEscape = false; } } StringBuffer buffer(quotedStringSize); unsigned index = 0; buffer[index++] = '\''; afterEscape = false; for (unsigned i = 0; i < string.length(); ++i) { UChar ch = string[i]; if (ch == '\\' || ch == '\'') { buffer[index++] = '\\'; buffer[index++] = ch; afterEscape = false; } else if (ch < 0x20 || ch == 0x7F) { // Control characters. buffer[index++] = '\\'; placeByteAsHexCompressIfPossible(ch, buffer, index, Lowercase); afterEscape = true; } else { // Space character may be required to separate backslash-escape sequence and normal characters. if (afterEscape && (isASCIIHexDigit(ch) || ch == ' ')) buffer[index++] = ' '; buffer[index++] = ch; afterEscape = false; } } buffer[index++] = '\''; ASSERT(quotedStringSize == index); return String::adopt(buffer); } String quoteCSSStringIfNeeded(const String& string) { return isCSSTokenizerIdentifier(string) ? string : quoteCSSString(string); } String quoteCSSURLIfNeeded(const String& string) { return isCSSTokenizerURL(string) ? string : quoteCSSString(string); } bool isValidNthToken(const CSSParserString& token) { // The tokenizer checks for the construct of an+b. // However, since the {ident} rule precedes the {nth} rule, some of those // tokens are identified as string literal. Furthermore we need to accept // "odd" and "even" which does not match to an+b. return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even") || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n"); } }