Improved parse error handling for CSSMQ.

Source/core/css/CSSParser.h

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 - 2010  Torch Mobile (Beijing) Co. Ltd. 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 44 matching lines @@
 class StyleRuleBase;
 class StyleRuleKeyframes;
 class StyleKeyframe;
 class StyleSheetContents;
 class StyledElement;
 
 class WebKitCSSArrayFunctionValue;
 class WebKitCSSMixFunctionValue;
 class WebKitCSSShaderValue;
 
+// Keep track of matching parentheses using a stack of opening brackets.
+// Needed for correct error recovery.
+class BracketStack {
+public:
+    inline void push(int bracket) { m_stack.append(bracket); }
+
+    inline void pop(int bracket)
+    {
+        if (m_stack.size() > 0) {
+            switch (bracket) {
+            case '}':
+                if (m_stack.last() == '{')
+                    m_stack.removeLast();
+                break;
+            case ')':
+                if (m_stack.last() == '(')
+                    m_stack.removeLast();
+                break;
+            case ']':
+                if (m_stack.last() == '[')
+                    m_stack.removeLast();
+                break;
+            default:
+                ASSERT_NOT_REACHED();
+                break;
+            }
+        }
+    }
+
+    inline int pop()
+    {
+        if (!m_stack.size())
+            return 0;
+
+        int ret = 0;
+        switch (top()) {
+        case '{':
+            ret = '}';
+            break;
+        case '(':
+            ret = ')';
+            break;
+        case '[':
+            ret = ']';
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            break;
+        }
+        m_stack.removeLast();
+        return ret;
+    }
+
+    int top() const { return m_stack.last(); }
+
+    inline size_t level() const { return m_stack.size(); }
+
+private:
+    // Make room for 16 levels deep nesting of parentheses initially.
+    Vector<int, 16> m_stack;
+};
+
 class CSSParser {
     friend inline int cssyylex(void*, CSSParser*);
 
 public:
     struct Location;
     class SourceDataHandler;
     enum SyntaxErrorType {
         NoSyntaxError,
         PropertyDeclarationError,
         GeneralSyntaxError
@@ skipping 318 matching lines @@
 #if ENABLE(CSS_DEVICE_ADAPTATION)
     void markViewportRuleBodyStart() { m_inViewport = true; }
     void markViewportRuleBodyEnd() { m_inViewport = false; }
     StyleRuleBase* createViewportRule();
 #endif
 
     PassRefPtr<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue*);
     PassRefPtr<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue*);
     PassRefPtr<CSSPrimitiveValue> createPrimitiveVariableNameValue(CSSParserValue*);
 
+    // Store block level.
+    void markMediaListStart();
+
+    // Error token reached while parsing a media_query, synchronized at current token.
+    MediaQuery* recoverMediaQuery();
+
     static KURL completeURL(const CSSParserContext&, const String& url);
 
     Location currentLocation();
 
 private:
     bool is8BitSource() { return m_is8BitSource; }
 
     template <typename SourceCharacterType>
     int realLex(void* yylval);
 
@@ skipping 128 matching lines @@
     bool m_allowNamespaceDeclarations;
 
 #if ENABLE(CSS_DEVICE_ADAPTATION)
     bool parseViewportProperty(CSSPropertyID propId, bool important);
     bool parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second, bool important);
 
     bool inViewport() const { return m_inViewport; }
     bool m_inViewport;
 #endif
 
+    enum ReEmissionState {
+        DontEmit,
+        ReEmit,
+        DidReEmit
+    };
+
+    inline void markCurrentTokenForReEmission();
+
+    ReEmissionState m_reEmissionState;
+    BracketStack m_brackets;
+    size_t m_storedBlockLevel;
+
     int (CSSParser::*m_lexFunc)(void*);
 
     Vector<RefPtr<StyleRuleBase> > m_parsedRules;
     Vector<RefPtr<StyleKeyframe> > m_parsedKeyframes;
     Vector<RefPtr<MediaQuerySet> > m_parsedMediaQuerySets;
     Vector<OwnPtr<RuleList> > m_parsedRuleLists;
     HashSet<CSSParserSelector*> m_floatingSelectors;
     HashSet<Vector<OwnPtr<CSSParserSelector> >*> m_floatingSelectorVectors;
     HashSet<CSSParserValueList*> m_floatingValueLists;
     HashSet<CSSParserFunction*> m_floatingFunctions;
@@ skipping 132 matching lines @@
     if (is8BitSource())
         return *m_tokenStart.ptr8;
     return *m_tokenStart.ptr16;
 }
 
 inline int cssyylex(void* yylval, CSSParser* parser)
 {
     return parser->lex(yylval);
 }
 
+inline void CSSParser::markCurrentTokenForReEmission()
+{
+    // Sanity check.
+    // Re-emitting a token which has just been re-emitted may cause an infinite
+    // loop. Also, marking a token for re-emit twice also doesn't make sense.
+    ASSERT(m_reEmissionState == DontEmit);
+
+    // Make sure we don't enter an infinite loop if the assert triggers.
+    if (m_reEmissionState == DontEmit)
+        m_reEmissionState = ReEmit;
+}
+
 } // namespace WebCore
 
 #endif // CSSParser_h