/*

 * This file is part of the DOM implementation for KDE.

 *

 * Copyright (C) 2003 Lars Knoll (knoll@kde.org)

 * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)

 * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. 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.

 *

 * 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 "CSSBorderImageValue.h"

#include "CSSCharsetRule.h"

#include "CSSCursorImageValue.h"

#include "CSSHelper.h"

#include "CSSImageValue.h"

#include "CSSImportRule.h"

#include "CSSInheritedValue.h"

#include "CSSInitialValue.h"

#include "CSSMediaRule.h"

#include "CSSMutableStyleDeclaration.h"

#include "CSSPrimitiveValue.h"

#include "CSSProperty.h"

#include "CSSPropertyNames.h"

#include "CSSQuirkPrimitiveValue.h"

#include "CSSRuleList.h"

#include "CSSSelector.h"

#include "CSSStyleRule.h"

#include "CSSStyleSheet.h"

#include "CSSValueKeywords.h"

#include "CSSValueList.h"

#include "Counter.h"

#include "DashboardRegion.h"

#include "Document.h"

#include "FontFamilyValue.h"

#include "FontValue.h"

#include "KURL.h"

#include "MediaList.h"

#include "MediaQueryExp.h"

#include "Pair.h"

#include "ShadowValue.h"

#define YYDEBUG 0

#if YYDEBUG > 0

extern int cssyydebug;

#endif

extern int cssyyparse(void* parser);

using namespace std;

using namespace WTF;

namespace WebCore {

ValueList::~ValueList()

{

     size_t numValues = m_values.size();

     for (size_t i = 0; i < numValues; i++)

         if (m_values[i].unit == Value::Function)

             delete m_values[i].function;

}

namespace {

    class ShorthandScope {

    public:

        ShorthandScope(CSSParser* parser, int propId) : m_parser(parser)

        {

            if (!(m_parser->m_inParseShorthand++))

                m_parser->m_currentShorthand = propId;

        }

        ~ShorthandScope()

        {

            if (!(--m_parser->m_inParseShorthand))

                m_parser->m_currentShorthand = 0;

        }

    private:

        CSSParser* m_parser;

    };

}

CSSParser* CSSParser::currentParser = 0;

CSSParser::CSSParser(bool strictParsing)

    : m_floatingMediaQuery(0)

    , m_floatingMediaQueryExp(0)

    , m_floatingMediaQueryExpList(0)

{

#ifdef CSS_DEBUG

    kdDebug(6080) << "CSSParser::CSSParser this=" << this << endl;

#endif

    strict = strictParsing;

    parsedProperties = (CSSProperty **)fastMalloc(32 * sizeof(CSSProperty *));

    numParsedProperties = 0;

    maxParsedProperties = 32;

    data = 0;

    valueList = 0;

    id = 0;

    important = false;

    m_inParseShorthand = 0;

    m_currentShorthand = 0;

    m_implicitShorthand = false;

    defaultNamespace = starAtom;

    yy_start = 1;

#if YYDEBUG > 0

    cssyydebug = 1;

#endif

}

CSSParser::~CSSParser()

{

    clearProperties();

    fastFree(parsedProperties);

    delete valueList;

    fastFree(data);

    if (m_floatingMediaQueryExpList) {

        deleteAllValues(*m_floatingMediaQueryExpList);

        delete m_floatingMediaQueryExpList;

    }

    delete m_floatingMediaQueryExp;

    delete m_floatingMediaQuery;

    deleteAllValues(m_floatingSelectors);

    deleteAllValues(m_floatingValueLists);

    deleteAllValues(m_floatingFunctions);

}

void ParseString::lower()

{

    // Fast case for all-ASCII.

    UChar ored = 0;

    for (int i = 0; i < length; i++)

        ored |= characters[i];

    if (ored & ~0x7F)

        for (int i = 0; i < length; i++)

            characters[i] = Unicode::toLower(characters[i]);

    else

        for (int i = 0; i < length; i++)

            characters[i] = tolower(characters[i]);

}

void CSSParser::setupParser(const char* prefix, const String& string, const char* suffix)

{

    int length = string.length() + strlen(prefix) + strlen(suffix) + 2;

    if (data)

        fastFree(data);

    data = static_cast<UChar*>(fastMalloc(length * sizeof(UChar)));

    for (unsigned i = 0; i < strlen(prefix); i++)

        data[i] = prefix[i];

    memcpy(data + 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++)

        data[i] = suffix[i - start];

    data[length - 1] = 0;

    data[length - 2] = 0;

    yy_hold_char = 0;

    yyleng = 0;

    yytext = yy_c_buf_p = data;

    yy_hold_char = *yy_c_buf_p;

}

void CSSParser::parseSheet(CSSStyleSheet* sheet, const String& string)

{

    styleElement = sheet;

    defaultNamespace = starAtom; // Reset the default namespace.

    setupParser("", string, "");

    CSSParser* old = currentParser;

    currentParser = this;

    cssyyparse(this);

    currentParser = old;

    rule = 0;

}

PassRefPtr<CSSRule> CSSParser::parseRule(CSSStyleSheet *sheet, const String &string)

{

    styleElement = sheet;

    setupParser("@-webkit-rule{", string, "} ");

    CSSParser* old = currentParser;

    currentParser = this;

    cssyyparse(this);

    currentParser = old;

    return rule.release();

}

bool CSSParser::parseValue(CSSMutableStyleDeclaration *declaration, int _id, const String &string, bool _important)

{

    styleElement = declaration->stylesheet();

    setupParser("@-webkit-value{", string, "} ");

    id = _id;

    important = _important;

    CSSParser* old = currentParser;

    currentParser = this;

    cssyyparse(this);

    currentParser = old;

    rule = 0;

    bool ok = false;

    if (numParsedProperties) {

        ok = true;

        declaration->addParsedProperties(parsedProperties, numParsedProperties);

        clearProperties();

    }

    return ok;

}

RGBA32 CSSParser::parseColor(const String &string, bool strict)

{

    RGBA32 color = 0;

    RefPtr<CSSMutableStyleDeclaration>dummyStyleDeclaration = new CSSMutableStyleDeclaration;

    CSSParser parser(true);

    // First try creating a color specified by name or the "#" syntax.

    if (!parser.parseColor(string, color, strict)) {

        // Now try to create a color from the rgb() or rgba() syntax.

        if (parser.parseColor(dummyStyleDeclaration.get(), string)) {

            CSSValue* value = parser.parsedProperties[0]->value();

            if (value->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {

                CSSPrimitiveValue *primitiveValue = static_cast<CSSPrimitiveValue *>(value);

                color = primitiveValue->getRGBColorValue();

            }

        }

    }

    return color;

}

bool CSSParser::parseColor(CSSMutableStyleDeclaration *declaration, const String &string)

{

    styleElement = declaration->stylesheet();

    setupParser("@-webkit-decls{color:", string, "} ");

    CSSParser* old = currentParser;

    currentParser = this;

    cssyyparse(this);

    currentParser = old;

    rule = 0;

    bool ok = false;

    if (numParsedProperties && parsedProperties[0]->m_id == CSS_PROP_COLOR)

        ok = true;

    return ok;

}

bool CSSParser::parseDeclaration(CSSMutableStyleDeclaration *declaration, const String &string)

{

    styleElement = declaration->stylesheet();

    setupParser("@-webkit-decls{", string, "} ");

    CSSParser* old = currentParser;

    currentParser = this;

    cssyyparse(this);

    currentParser = old;

    rule = 0;

    bool ok = false;

    if (numParsedProperties) {

        ok = true;

        declaration->addParsedProperties(parsedProperties, numParsedProperties);

        clearProperties();

    }

    return ok;

}

bool CSSParser::parseMediaQuery(MediaList* queries, const String& string)

{

    if (string.isEmpty() || string.isNull()) {

        return true;

    }

    mediaQuery = 0;

    // 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, "} ");

    CSSParser* old = currentParser;

    currentParser = this;

    cssyyparse(this);

    currentParser = old;

    bool ok = false;

    if (mediaQuery) {

        ok = true;

        queries->appendMediaQuery(mediaQuery);

        mediaQuery = 0;

    }

    return ok;

}

void CSSParser::addProperty(int propId, PassRefPtr<CSSValue> value, bool important)

{

    CSSProperty *prop = new CSSProperty(propId, value, important, m_currentShorthand, m_implicitShorthand);

    if (numParsedProperties >= maxParsedProperties) {

        maxParsedProperties += 32;

        parsedProperties = (CSSProperty **)fastRealloc(parsedProperties,

                                                       maxParsedProperties*sizeof(CSSProperty *));

    }

    parsedProperties[numParsedProperties++] = prop;

}

void CSSParser::rollbackLastProperties(int num)

{

    ASSERT(num >= 0);

    ASSERT(numParsedProperties >= num);

    for (int i = 0; i < num; ++i)

        delete parsedProperties[--numParsedProperties];

}

void CSSParser::clearProperties()

{

    for (int i = 0; i < numParsedProperties; i++)

        delete parsedProperties[i];

    numParsedProperties = 0;

}

Document *CSSParser::document() const

{

    StyleBase *root = styleElement;

    Document *doc = 0;

    while (root->parent())

        root = root->parent();

    if (root->isCSSStyleSheet())

        doc = static_cast<CSSStyleSheet*>(root)->doc();

    return doc;

}

bool CSSParser::validUnit(Value* value, Units unitflags, bool strict)

{

    if (unitflags & FNonNeg && value->fValue < 0)

        return false;

    bool b = false;

    switch(value->unit) {

    case CSSPrimitiveValue::CSS_NUMBER:

        b = (unitflags & FNumber);

        if (!b && ((unitflags & FLength) && (value->fValue == 0 || !strict))) {

            value->unit = CSSPrimitiveValue::CSS_PX;

            b = true;

        }

        if (!b && (unitflags & FInteger) && value->isInt)

            b = true;

        break;

    case CSSPrimitiveValue::CSS_PERCENTAGE:

        b = (unitflags & FPercent);

        break;

    case Value::Q_EMS:

    case CSSPrimitiveValue::CSS_EMS:

    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_HZ:

    case CSSPrimitiveValue::CSS_KHZ:

    case CSSPrimitiveValue::CSS_DIMENSION:

    default:

        break;

    }

    return b;

}

static int unitFromString(Value* value)

{

    if (value->unit != CSSPrimitiveValue::CSS_IDENT || value->id)

        return 0;

    String str = domString(value->string);

    if (str == "em")

        return CSSPrimitiveValue::CSS_EMS;

    if (str == "ex")

        return CSSPrimitiveValue::CSS_EXS;

    if (str == "px")

        return CSSPrimitiveValue::CSS_PX;

    if (str == "cm")

        return CSSPrimitiveValue::CSS_CM;

    if (str == "mm")

        return CSSPrimitiveValue::CSS_MM;

    if (str == "in")

        return CSSPrimitiveValue::CSS_IN;

    if (str == "pt")

        return CSSPrimitiveValue::CSS_PT;

    if (str == "pc")

        return CSSPrimitiveValue::CSS_PC;

    if (str == "deg")

        return CSSPrimitiveValue::CSS_DEG;

    if (str == "rad")

        return CSSPrimitiveValue::CSS_RAD;

    if (str == "grad")

        return CSSPrimitiveValue::CSS_GRAD;

    if (str == "ms")

        return CSSPrimitiveValue::CSS_MS;

    if (str == "s")

        return CSSPrimitiveValue::CSS_S;

    if (str == "Hz")

        return CSSPrimitiveValue::CSS_HZ;

    if (str == "kHz")

        return CSSPrimitiveValue::CSS_KHZ;

    return 0;

}

void CSSParser::checkForOrphanedUnits()

{

    if (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.

    Value* numericVal = 0;

    unsigned size = valueList->size();

    for (unsigned i = 0; i < size; i++) {

        Value* value = 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.

                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;

    }

}

bool CSSParser::parseValue(int propId, bool important)

{

    if (!valueList)

        return false;

    Value *value = valueList->current();

    if (!value)

        return false;

    int id = value->id;

    int num = inShorthand() ? 1 : valueList->size();

    if (id == CSS_VAL_INHERIT) {

        if (num != 1)

            return false;

        addProperty(propId, new CSSInheritedValue(), important);

        return true;

    }

    else if (id == CSS_VAL_INITIAL) {

        if (num != 1)

            return false;

        addProperty(propId, new CSSInitialValue(false), important);

        return true;

    }

    bool valid_primitive = false;

    CSSValue *parsedValue = 0;

    // 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();

    switch (static_cast<CSSPropertyID>(propId)) {