File indexing completed on 2024-04-28 15:22:45

 /*
  * This file is part of the DOM implementation for KDE.
  *
  * Copyright 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
  *
  * 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.
  */
 #ifndef _CSS_cssparser_h_
 #define _CSS_cssparser_h_
 
 #include <QString>
 #include <QColor>
 #include <QVector>
 #include <dom/dom_string.h>
 #include <misc/htmlnames.h>
 #include <wtf/Vector.h>
 #include <xml/dom_docimpl.h>
 
 namespace khtml
 {
 class MediaQuery;
 }
 
 namespace DOM
 {
 class StyleListImpl;
 class CSSStyleSheetImpl;
 class CSSRuleImpl;
 class CSSStyleRuleImpl;
 class DocumentImpl;
 class CSSValueImpl;
 class CSSValueListImpl;
 class CSSPrimitiveValueImpl;
 class CSSStyleDeclarationImpl;
 class CSSFontFaceRuleImpl;
 class CSSProperty;
 class MediaListImpl;
 class CSSSelector;
 
 struct ParseString {
     unsigned short *string;
     int length;
 };
 
 struct Value;
 class ValueList;
 
 struct Function {
     ParseString name;
     ValueList *args;
 };
 
 struct Value {
     int id;
     bool isInt;
     union {
         double fValue;
         int iValue;
         ParseString string;
         struct Function *function;
     };
     enum {
         Operator = 0x100000,
         Function = 0x100001,
         Q_EMS     = 0x100002
     };
 
     int unit;
 };
 
 static inline QString qString(const ParseString &ps)
 {
     return QString((QChar *)ps.string, ps.length);
 }
 static inline DOMString domString(const ParseString &ps)
 {
     return DOMString((QChar *)ps.string, ps.length);
 }
 
 class ValueList
 {
 public:
     ValueList() : m_current(0) { }
     ~ValueList();
     void addValue(const Value &v)
     {
         m_values.append(v);
     }
     int size() const
     {
         return m_values.size();
     }
     Value *current()
     {
         return m_current < m_values.size() ? &m_values[m_current] : nullptr;
     }
     Value *next()
     {
         ++m_current;
         return current();
     }
 private:
     QVector<Value> m_values;
     int m_current;
 };
 
 class CSSParser
 {
 public:
     CSSParser(bool strictParsing = true);
     ~CSSParser();
 
     void parseSheet(DOM::CSSStyleSheetImpl *sheet, const DOM::DOMString &string);
     DOM::CSSRuleImpl *parseRule(DOM::CSSStyleSheetImpl *sheet, const DOM::DOMString &string);
     bool parseValue(DOM::CSSStyleDeclarationImpl *decls, int id, const DOM::DOMString &string,
                     bool _important);
     bool parseDeclaration(DOM::CSSStyleDeclarationImpl *decls, const DOM::DOMString &string);
     bool parseMediaQuery(DOM::MediaListImpl *queries, const DOM::DOMString &string);
     QList<DOM::CSSSelector *> parseSelectorList(DOM::DocumentImpl *doc, const DOM::DOMString &string);
     // Returns an empty list on parse error.
 
     static CSSParser *current()
     {
         return currentParser;
     }
 
     unsigned int getLocalNameId(const DOMString &str)
     {
         LocalName localname;
         DOM::DocumentImpl *doc = document();
         if (doc && doc->isHTMLDocument()) {
             localname = LocalName::fromString(str, khtml::IDS_NormalizeLower);
         } else {
             localname = LocalName::fromString(str);
         }
         boundLocalNames.append(localname);
         return localname.id();
     }
 
     DOM::DocumentImpl *document() const;
 
     unsigned int defaultNamespace();
 
     void addProperty(int propId, CSSValueImpl *value, bool important);
     void rollbackParsedProperties(int toNumParsedProperties);
     bool hasProperties() const
     {
         return numParsedProperties > 0;
     }
     CSSStyleDeclarationImpl *createStyleDeclaration(CSSStyleRuleImpl *rule);
     CSSStyleDeclarationImpl *createFontFaceStyleDeclaration(CSSFontFaceRuleImpl *rule);
     void clearProperties();
 
     bool parseValue(int propId, bool important);
     bool parseSVGValue(int propId, bool important);
     bool parseShortHand(int propId, const int *properties, const int numProperties, bool important);
     bool parse4Values(int propId, const int *properties, bool important);
     bool parseContent(int propId, bool important);
 
     CSSValueImpl *parseBackgroundColor();
     CSSValueImpl *parseBackgroundImage(bool &didParse);
 
     enum BackgroundPosKind {
         BgPos_X,
         BgPos_Y,
         BgPos_NonKW,
         BgPos_Center
     };
 
     CSSValueImpl *parseBackgroundPositionXY(BackgroundPosKind &kindOut);
     void parseBackgroundPosition(CSSValueImpl *&value1, CSSValueImpl *&value2);
     CSSValueImpl *parseBackgroundSize();
 
     bool parseBackgroundProperty(int propId, int &propId1, int &propId2, CSSValueImpl *&retValue1, CSSValueImpl *&retValue2);
     bool parseBackgroundShorthand(bool important);
 
     void addBackgroundValue(CSSValueImpl *&lval, CSSValueImpl *rval);
 
     bool parseShape(int propId, bool important);
     bool parseFontShorthand(bool important);
     bool parseFontFaceSrc();
     bool parseCounter(int propId, bool increment, bool important);
     bool parseListStyleShorthand(bool important);
 
     // returns parsed font-weight's css value id if valid, otherwise 0 (CSS_VAL_INVALID)
     int parseFontWeight(Value *val, bool strict);
 
     bool parseColorParameters(Value *, int *colorValues, bool parseAlpha);
     bool parseHSLParameters(Value *, double *colorValues, bool parseAlpha);
 
     // returns the found property
     // 0 if nothing found (or ok == false)
     // @param forward if true, it parses the next in the list
     CSSValueListImpl *parseFontFamily();
     CSSPrimitiveValueImpl *parseColor();
     CSSPrimitiveValueImpl *parseColorFromValue(Value *val);
     CSSValueImpl *parseCounterContent(ValueList *args, bool counters);
 
     // CSS3 Parsing Routines (for properties specific to CSS3)
     bool parseShadow(int propId, bool important);
 
     // SVG parsing:
     CSSValueImpl *parseSVGStrokeDasharray();
     CSSValueImpl *parseSVGPaint();
     CSSValueImpl *parseSVGColor();
 private:
     // defines units allowed for a certain property, used in parseUnit
     enum Units {
         FUnknown   = 0x0000,
         FInteger   = 0x0001,
         FNumber    = 0x0002,  // Real Numbers
         FPercent   = 0x0004,
         FLength    = 0x0008,
         FAngle     = 0x0010,
         FTime      = 0x0020,
         FFrequency = 0x0040,
         FRelative  = 0x0100,
         FNonNeg    = 0x0200
     };
 
     bool parseBorderImage(int propId, bool important);
     bool parseBorderRadius(bool important);
 
     static bool validUnit(Value *value, int unitflags, bool strict);
 
 public:
     bool strict;
     bool important;
     unsigned int id;
     DOM::StyleListImpl *styleElement;
     mutable DOM::DocumentImpl  *styleDocument; // cached document for styleElement,
     // or manually set one for special parses
 
     // Outputs for specialized parses.
     DOM::CSSRuleImpl *rule;
     khtml::MediaQuery *mediaQuery;
     QList<DOM::CSSSelector *> selectors;
 
     ValueList *valueList;
     CSSProperty **parsedProperties;
     int numParsedProperties;
     int maxParsedProperties;
 
     int m_inParseShorthand;
     int m_currentShorthand;
     bool m_implicitShorthand;
 
     static CSSParser *currentParser;
 
     // tokenizer methods and data
 public:
     int lex(void *yylval);
     int token()
     {
         return yyTok;
     }
     unsigned short *text(int *length);
     int lex();
 private:
     int yyparse();
     void runParser();
     void setupParser(const char *prefix, const DOMString &string, const char *suffix);
 
     bool inShorthand() const
     {
         return m_inParseShorthand;
     }
 
     unsigned short *data;
     unsigned short *yytext;
     unsigned short *yy_c_buf_p;
     unsigned short yy_hold_char;
     int yy_last_accepting_state;
     unsigned short *yy_last_accepting_cpos;
     int block_nesting;
     int yyleng;
     int yyTok;
     int yy_start;
     WTF::Vector<LocalName> boundLocalNames;
 };
 
 } // namespace
 #endif