Improved parse error handling for CSSMQ.

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.
+ * Copyright (C) 2013 Opera Software ASA. All rights reserved.
  *
  * 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.
@@ skipping 292 matching lines @@
     , m_length(0)
     , m_token(0)
     , m_lineNumber(0)
     , m_tokenStartLineNumber(0)
     , m_lastSelectorLineNumber(0)
     , m_allowImportRules(true)
     , m_allowNamespaceDeclarations(true)
 #if ENABLE(CSS_DEVICE_ADAPTATION)
     , m_inViewport(false)
 #endif
+    , m_reEmissionState(DontEmit)
+    , m_storedBlockLevel(0)
 {
 #if YYDEBUG > 0
     cssyydebug = 1;
 #endif
     m_tokenStart.ptr8 = 0;
     CSSPropertySourceData::init();
 }
 
 CSSParser::~CSSParser()
 {
@@ skipping 1098 matching lines @@
     return ok;
 }
 
 PassOwnPtr<MediaQuery> CSSParser::parseMediaQuery(const String& string)
 {
     if (string.isEmpty())
         return nullptr;
 
     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, "} ");
+    // 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). Also, can't use } because of error handling.
+    setupParser("@-webkit-mediaquery ", string, "");
     cssyyparse(this);
 
     return m_mediaQuery.release();
 }
 
 static inline void filterProperties(bool important, const CSSParser::ParsedPropertyVector& input, Vector<CSSProperty, 256>& output, size_t& unusedEntries, BitArray<numCSSProperties>& seenProperties, HashSet<AtomicString>& seenVariables)
 {
     // Add properties in reverse order so that highest priority definitions are reached first. Duplicate definitions can then be ignored when found.
     for (int i = input.size() - 1; i >= 0; --i) {
         const CSSProperty& property = input[i];
@@ skipping 7782 matching lines @@
     CharacterAsterisk,
     CharacterPlus,
     CharacterDot,
     CharacterSlash,
     CharacterLess,
     CharacterAt,
     CharacterBackSlash,
     CharacterXor,
     CharacterVerticalBar,
     CharacterTilde,
+    CharacterOpeningBracket,
+    CharacterClosingBracket
 };
 
 // 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,
@@ skipping 24 matching lines @@
 /*  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,
+/*  40 - (                  */ CharacterOpeningBracket,
 /*  41 - )                  */ CharacterEndNthChild,
 /*  42 - *                  */ CharacterAsterisk,
 /*  43 - +                  */ CharacterPlus,
 /*  44 - ,                  */ CharacterOther,
 /*  45 - -                  */ CharacterDash,
 /*  46 - .                  */ CharacterDot,
 /*  47 - /                  */ CharacterSlash,
 /*  48 - 0                  */ CharacterNumber,
 /*  49 - 1                  */ CharacterNumber,
 /*  50 - 2                  */ CharacterNumber,
@@ skipping 30 matching lines @@
 /*  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,
+/*  91 - [                  */ CharacterOpeningBracket,
 /*  92 - \                  */ CharacterBackSlash,
-/*  93 - ]                  */ CharacterOther,
+/*  93 - ]                  */ CharacterClosingBracket,
 /*  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,
@@ skipping 11 matching lines @@
 /* 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,
+/* 125 - }                  */ CharacterClosingBracket,
 /* 126 - ~                  */ CharacterTilde,
 /* 127 - Delete             */ CharacterOther,
 };
 
 // Utility functions for the CSS tokenizer.
 
 template <typename CharacterType>
 static inline bool isCSSLetter(CharacterType character)
 {
     return character >= 128 || typesOfASCIICharacters[character] <= CharacterDash;
@@ skipping 939 matching lines @@
         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 SrcCharacterType>
 int CSSParser::realLex(void* yylvalWithoutType)
 {
+    if (m_reEmissionState == ReEmit) {
+        m_reEmissionState = DidReEmit;
+        return token();
+    }
+
+    if (m_reEmissionState == DidReEmit)
+        m_reEmissionState = DontEmit;
+
     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
     // it is safe to read one character ahead of a known non-null.
 #ifndef NDEBUG
     // In debug we check with an ASSERT that the length is > 0 for string types.
@@ skipping 23 matching lines @@
         m_token = IDENT;
 
         if (UNLIKELY(*currentCharacter<SrcCharacterType>() == '(')) {
             if (m_parsingMode == SupportsMode && !hasEscape) {
                 detectSupportsToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
                 if (m_token != IDENT)
                     break;
             }
 
             m_token = FUNCTION;
-            bool shouldSkipParenthesis = true;
-            if (!hasEscape) {
-                bool detected = detectFunctionTypeToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
-                if (!detected && m_parsingMode == MediaQueryMode) {
-                    // ... and(max-width: 480px) ... looks like a function, but in fact it is not,
-                    // so run more detection code in the MediaQueryMode.
-                    detectMediaQueryToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
-                    shouldSkipParenthesis = false;
-                }
-            }
 
-            if (LIKELY(shouldSkipParenthesis)) {
-                ++currentCharacter<SrcCharacterType>();
-                ++result;
-                ++yylval->string.m_length;
-            }
+            if (!hasEscape)
+                detectFunctionTypeToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
+            ++currentCharacter<SrcCharacterType>();
+            ++result;
+            ++yylval->string.m_length;
 
             if (token() == URI) {
                 m_token = FUNCTION;
                 // Check whether it is really an URI.
                 if (yylval->string.is8Bit())
                     parseURI<LChar>(yylval->string);
                 else
                     parseURI<UChar>(yylval->string);
             }
+
+            // URI consumes the ')'. For other function tokens, push the
+            // opening parenthesis to match the closing one when it comes.
+            if (token() != URI)
+                m_brackets.push('(');
+
         } else if (UNLIKELY(m_parsingMode != NormalMode) && !hasEscape) {
             if (m_parsingMode == MediaQueryMode)
                 detectMediaQueryToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
             else if (m_parsingMode == SupportsMode)
                 detectSupportsToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
             else if (m_parsingMode == NthChildMode && isASCIIAlphaCaselessEqual(tokenStart<SrcCharacterType>()[0], 'n')) {
                 if (result - tokenStart<SrcCharacterType>() == 1) {
                     // String "n" is IDENT but "n+1" is NTH.
                     if (parseNthChildExtra<SrcCharacterType>()) {
                         m_token = NTH;
@@ skipping 97 matching lines @@
     case CharacterDash:
         if (isIdentifierStartAfterDash(currentCharacter<SrcCharacterType>())) {
             --currentCharacter<SrcCharacterType>();
             parseIdentifier(result, resultString, hasEscape);
             m_token = IDENT;
 
             if (cssVariablesEnabled() && isEqualToCSSIdentifier(tokenStart<SrcCharacterType>() + 1, "webkit-var") && tokenStart<SrcCharacterType>()[11] == '-' && isIdentifierStartAfterDash(tokenStart<SrcCharacterType>() + 12))
                 m_token = VAR_DEFINITION;
             else if (*currentCharacter<SrcCharacterType>() == '(') {
                 m_token = FUNCTION;
+                m_brackets.push('(');
                 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;
                         result = currentCharacter<SrcCharacterType>();
@@ skipping 25 matching lines @@
                 yylval->string.init(tokenStart<SrcCharacterType>(), currentCharacter<SrcCharacterType>() - tokenStart<SrcCharacterType>());
             }
         }
         break;
 
     case CharacterOther:
         // m_token is simply the current character.
         break;
 
     case CharacterNull:
+        if (m_brackets.level() > 0)
+            m_token = m_brackets.pop();
         // Do not advance pointer at the end of input.
         --currentCharacter<SrcCharacterType>();
         break;
 
     case CharacterWhiteSpace:
         m_token = WHITESPACE;
         // Might start with a '\n'.
         --currentCharacter<SrcCharacterType>();
         do {
             if (*currentCharacter<SrcCharacterType>() == '\n')
                 ++m_lineNumber;
             ++currentCharacter<SrcCharacterType>();
         } while (*currentCharacter<SrcCharacterType>() <= ' ' && (typesOfASCIICharacters[*currentCharacter<SrcCharacterType>()] == CharacterWhiteSpace));
         break;
 
     case CharacterEndMediaQuery:
         if (m_parsingMode == MediaQueryMode)
             m_parsingMode = NormalMode;
+        if (m_token == '{')
+            m_brackets.push('{');
         break;
 
     case CharacterEndNthChild:
         if (m_parsingMode == NthChildMode)
             m_parsingMode = NormalMode;
+        m_brackets.pop(')');
         break;
 
     case CharacterQuote:
         if (checkAndSkipString(currentCharacter<SrcCharacterType>(), m_token)) {
             ++result;
             parseString<SrcCharacterType>(result, yylval->string, m_token);
             m_token = STRING;
         }
         break;
 
@@ skipping 127 matching lines @@
         }
         break;
 
     case CharacterTilde:
         if (*currentCharacter<SrcCharacterType>() == '=') {
             ++currentCharacter<SrcCharacterType>();
             m_token = INCLUDES;
         }
         break;
 
+    case CharacterOpeningBracket:
+        m_brackets.push(m_token);
+        break;
+
+    case CharacterClosingBracket:
+        m_brackets.pop(m_token);
+        break;
+
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 
     return token();
 }
 
 CSSParserSelector* CSSParser::createFloatingSelectorWithTagName(const QualifiedName& tagQName)
 {
@@ skipping 728 matching lines @@
 
     // If just one value is supplied, the second value
     // is implicitly initialized with the first value.
     if (numValues == 1)
         m_valueList->previous();
 
     return parseViewportProperty(second, important);
 }
 #endif
 
+void CSSParser::markMediaListStart()
+{
+    m_storedBlockLevel = m_brackets.level();
+    if (m_storedBlockLevel > 0 && token() == m_brackets.top()) {
+        // Don't take the currently pushed lookahead token into account.
+        // This could happen for "@media{}", "@media()", etc.
+        --m_storedBlockLevel;
+    }
+}
+
+MediaQuery* CSSParser::recoverMediaQuery()
+{
+    size_t blockLevel = m_brackets.level();
+    if (blockLevel >= m_storedBlockLevel) {
+        YYSTYPE yyval;
+
+        while (token() != TOKEN_EOF) {
+            // End media query at ',', ';', or '{' at the same block level as the
+            // media list started.
+            if (blockLevel == m_storedBlockLevel && (token() == ',' || token() == ';'))
+                break;
+            // The '{' token will have increased the block level by 1 already.
+            if (blockLevel == m_storedBlockLevel + 1 && token() == '{')
+                break;
+
+            lex(&yyval);
+            blockLevel = m_brackets.level();
+        }
+    } else {
+        // Recovering from error token when we are at a block level above the
+        // block level where the media list started. That should only happen
+        // when synchronizing on a closing '}' just one level above the stored
+        // level. Typically happens when an @media rule is terminated
+        // prematurely:
+        //
+        // "@supports (color: red) { @media all and }"
+        ASSERT(token() == '}' && blockLevel == m_storedBlockLevel - 1);
+    }
+
+    markCurrentTokenForReEmission();
+
+    return createFloatingMediaQuery(MediaQuery::Not, "all", sinkFloatingMediaQueryExpList(createFloatingMediaQueryExpList()));
+}
+
 template <typename CharacterType>
 static CSSPropertyID cssPropertyID(const CharacterType* propertyName, unsigned length)
 {
     char buffer[maxCSSPropertyNameLength + 1 + 1]; // 1 to turn "apple"/"khtml" into "webkit", 1 for null character
 
     for (unsigned i = 0; i != length; ++i) {
         CharacterType c = propertyName[i];
         if (c == 0 || c >= 0x7F)
             return CSSPropertyInvalid; // illegal character
         buffer[i] = toASCIILower(c);
@@ skipping 235 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");
 }
 
 }