Unprefix CSS Variables

Source/core/css/CSSParser.cpp

 /*
  * 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, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 3045 matching lines @@
     m_implicitShorthand = false;
     return true;
 }
 
 void CSSParser::storeVariableDeclaration(const CSSParserString& name, PassOwnPtr<CSSParserValueList> value, bool important)
 {
     // When CSSGrammar.y encounters an invalid declaration it passes null for the CSSParserValueList, just bail.
     if (!value)
         return;
 
-    static const unsigned prefixLength = sizeof("-webkit-var-") - 1;
+    static const unsigned prefixLength = sizeof("var-") - 1;
 
     ASSERT(name.length() > prefixLength);
     AtomicString variableName = name.atomicSubstring(prefixLength, name.length() - prefixLength);
 
     StringBuilder builder;
     for (unsigned i = 0, size = value->size(); i < size; i++) {
         if (i)
             builder.append(' ');
         RefPtr<CSSValue> cssValue = value->valueAt(i)->createCSSValue();
         if (!cssValue)
@@ skipping 6712 matching lines @@
             return true;
         }
         if (isASCIIAlphaCaselessEqual(name[0], 'u') && isASCIIAlphaCaselessEqual(name[1], 'r') && isASCIIAlphaCaselessEqual(name[2], 'l')) {
             m_token = URI;
             return true;
         }
         if (isASCIIAlphaCaselessEqual(name[0], 'c') && isASCIIAlphaCaselessEqual(name[1], 'u') && isASCIIAlphaCaselessEqual(name[2], 'e')) {
             m_token = CUEFUNCTION;
             return true;
         }
+        if (RuntimeEnabledFeatures::cssVariablesEnabled() && isASCIIAlphaCaselessEqual(name[0], 'v') && isASCIIAlphaCaselessEqual(name[1], 'a') && isASCIIAlphaCaselessEqual(name[2], 'r')) {

[Mike Lawther (Google), 2013/05/29 04:54:13]

This is a job for a new patch, but this looks like it would work with eg "VaR"?
The spec text currently says: "The "var-" prefix must be written in
lower-case.".

[alancutter (OOO until 2018), 2013/05/29 06:41:51]

I was unsure whether I should tackle that in this patch or not. I decided it
would be prudent to keep the case sensitivity of var as a separate patch.

[Mike Lawther (Google), 2013/05/29 08:23:00]

I agree - post a new patch for this.

+            m_token = VARFUNCTION;
+            return true;
+        }
         return false;
 
     case 4:
         if (isEqualToCSSIdentifier(name, "calc")) {
             m_token = CALCFUNCTION;
             return true;
         }
         return false;
 
     case 9:
@@ skipping 176 matching lines @@
 {
     CharacterType* name = tokenStart<CharacterType>();
 
     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 (RuntimeEnabledFeatures::cssVariablesEnabled() && isASCIIAlphaCaselessEqual(name[10], 'r') && isEqualToCSSIdentifier(name + 1, "webkit-va"))
-            m_token = VARFUNCTION;
     } else if (length == 12 && isEqualToCSSIdentifier(name + 1, "webkit-calc"))
         m_token = CALCFUNCTION;
     else if (length == 19 && isEqualToCSSIdentifier(name + 1, "webkit-distributed"))
         m_token = DISTRIBUTEDFUNCTION;
 }
 
 template <typename CharacterType>
 inline void CSSParser::detectAtToken(int length, bool hasEscape)
 {
     CharacterType* name = tokenStart<CharacterType>();
@@ skipping 230 matching lines @@
             m_token = SUPPORTS_OR;
     } else if (length == 3) {
         if (isASCIIAlphaCaselessEqual(name[0], 'a') && isASCIIAlphaCaselessEqual(name[1], 'n') && isASCIIAlphaCaselessEqual(name[2], 'd'))
             m_token = SUPPORTS_AND;
         else if (isASCIIAlphaCaselessEqual(name[0], 'n') && isASCIIAlphaCaselessEqual(name[1], 'o') && isASCIIAlphaCaselessEqual(name[2], 't'))
             m_token = SUPPORTS_NOT;
     }
 }
 
 template <typename CharacterType>
-inline bool CSSParser::detectCSSVariablesToken(int length)
+inline void CSSParser::detectCSSVariableDeclarationToken(int length)
 {
-    ASSERT(tokenStart<CharacterType>()[0] == '-');
-    if (length < sizeof("-webkit-var-*") - 1)
-        return false;
+    static const unsigned prefixLength = sizeof("var-") - 1;
+    if (length <= prefixLength)
+        return;
     CharacterType* name = tokenStart<CharacterType>();
-    return name[11] == '-' && isIdentifierStartAfterDash(name + 12) && isEqualToCSSIdentifier(name + 1, "webkit-var");
+    if (name[3] == '-' && isIdentifierStartAfterDash(name + 4) && isEqualToCSSIdentifier(name, "var"))

[Mike Lawther (Google), 2013/05/29 04:54:13]

You can get rid of these magic numbers with something like
static const char* token = "var";
const unsigned tokenLength = sizeof(token) - 1;
const unsigned prefixLength = tokenLength + (sizeof("-") - 1);

Now you can replace '3' with 'tokenLength', and replace '4' with 'prefixLength'.

[alancutter (OOO until 2018), 2013/05/29 06:41:51]

I would prefer to have the entire "var-" as a string for searchability.
The token is really the entire thing rather than just the "var" bit. It's hard
to label that as anything other than prefixWithoutDash.
Would it be okay to just have:

ASSERT(prefixLength > 0)
if (name[prefixLength - 1] == '-' && ...

?

[Mike Lawther (Google), 2013/05/29 08:23:00]

Can you make that a COMPILE_ASSERT? No need to have a runtime check for what is
a compile time problem :)

+        m_token = VAR_DEFINITION;
 }
 
-
 template <typename SrcCharacterType>
 int CSSParser::realLex(void* yylvalWithoutType)
 {
     YYSTYPE* yylval = static_cast<YYSTYPE*>(yylvalWithoutType);
     // Write pointer for the next character.
     SrcCharacterType* result;
     CSSParserString resultString;
     bool hasEscape;
 
     // The input buffer is terminated by a \0 character, so
@@ skipping 77 matching lines @@
                     currentCharacter<SrcCharacterType>() = tokenStart<SrcCharacterType>() + 1;
                     if (parseNthChildExtra<SrcCharacterType>()) {
                         m_token = NTH;
                         yylval->string.setLength(currentCharacter<SrcCharacterType>() - tokenStart<SrcCharacterType>());
                     } else {
                         // Revert the change to currentCharacter if unsuccessful.
                         currentCharacter<SrcCharacterType>() = nextCharacter;
                     }
                 }
             }
+        } else if (UNLIKELY(RuntimeEnabledFeatures::cssVariablesEnabled())) {
+            detectCSSVariableDeclarationToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
         }
         break;
 
     case CharacterDot:
         if (!isASCIIDigit(currentCharacter<SrcCharacterType>()[0]))
             break;
         // Fall through to CharacterNumber.
 
     case CharacterNumber: {
         bool dotSeen = (m_token == '.');
@@ skipping 66 matching lines @@
             m_token = dotSeen ? FLOATTOKEN : INTEGER;
         break;
     }
 
     case CharacterDash:
         if (isIdentifierStartAfterDash(currentCharacter<SrcCharacterType>())) {
             --currentCharacter<SrcCharacterType>();
             parseIdentifier(result, resultString, hasEscape);
             m_token = IDENT;
 
-            if (RuntimeEnabledFeatures::cssVariablesEnabled() && detectCSSVariablesToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>()))
-                m_token = VAR_DEFINITION;
-            else if (*currentCharacter<SrcCharacterType>() == '(') {
+            if (*currentCharacter<SrcCharacterType>() == '(') {
                 m_token = FUNCTION;
                 if (!hasEscape)
                     detectDashToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
                 ++currentCharacter<SrcCharacterType>();
                 ++result;
             } else if (UNLIKELY(m_parsingMode == NthChildMode) && !hasEscape && isASCIIAlphaCaselessEqual(tokenStart<SrcCharacterType>()[1], 'n')) {
                 if (result - tokenStart<SrcCharacterType>() == 2) {
                     // String "-n" is IDENT but "-n+1" is NTH.
                     if (parseNthChildExtra<SrcCharacterType>()) {
                         m_token = NTH;
@@ skipping 1286 matching lines @@
 {
     // 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");
 }
 
 }