%{

/*

 *  This file is part of the KDE libraries

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

 *  Copyright (C) 2004, 2005, 2006, 2007 Apple Inc.

 *  Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser 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

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include "config.h"

#include "CSSMediaRule.h"

#include "CSSParser.h"

#include "CSSPrimitiveValue.h"

#include "CSSRule.h"

#include "CSSRuleList.h"

#include "CSSSelector.h"

#include "CSSStyleSheet.h"

#include "Document.h"

#include "HTMLNames.h"

#include "MediaList.h"

#include "MediaQuery.h"

#include "MediaQueryExp.h"

#include "PlatformString.h"

#include <stdlib.h>

#include <string.h>

#if ENABLE(SVG)

#include "ksvgcssproperties.h"

#include "ksvgcssvalues.h"

#endif

using namespace WebCore;

using namespace HTMLNames;

// The following file defines the function

//     const struct props *findProp(const char *word, int len)

//

// with 'props->id' a CSS property in the range from CSS_PROP_MIN to

// (and including) CSS_PROP_TOTAL-1

#include "CSSPropertyNames.c"

#include "CSSValueKeywords.c"

namespace WebCore {

int getPropertyID(const char* tagStr, int len)

{

    DeprecatedString prop;

    if (len && tagStr[0] == '-') {

        prop = DeprecatedString(tagStr, len);

        if (prop.startsWith("-apple-")) {

            prop = "-webkit-" + prop.mid(7);

            tagStr = prop.ascii();

            len++;

        } else if (prop.startsWith("-khtml-")) {

            prop = "-webkit-" + prop.mid(7);

            len++;

            tagStr = prop.ascii();

        }

        // Honor the use of old-style opacity (for Safari 1.1).

        if (prop == "-webkit-opacity") {

            const char * const opacity = "opacity";

            tagStr = opacity;

            len = strlen(opacity);

        }

    }

    const struct props* propsPtr = findProp(tagStr, len);

    if (!propsPtr)

        return 0;

    return propsPtr->id;

}

} // namespace WebCore

static inline int getValueID(const char* tagStr, int len)

{

    DeprecatedString prop;

    if (len && tagStr[0] == '-') {

        prop = DeprecatedString(tagStr, len);

        if (prop.startsWith("-apple-")) {

            prop = "-webkit-" + prop.mid(7);

            tagStr = prop.ascii();

            len++;

        } else if (prop.startsWith("-khtml-")) {

            prop = "-webkit-" + prop.mid(7);

            len++;

            tagStr = prop.ascii();

        }

    }

    const struct css_value* val = findValue(tagStr, len);

    if (!val)

        return 0;

    return val->id;

}

#define YYENABLE_NLS 0

#define YYLTYPE_IS_TRIVIAL 1

#define YYMAXDEPTH 10000

#define YYDEBUG 0

#define YYPARSE_PARAM parser

%}

%pure_parser

%union {

    CSSRule* rule;

    CSSSelector* selector;

    bool ok;

    MediaList *mediaList;

    CSSMediaRule* mediaRule;

    CSSRuleList* ruleList;

    ParseString string;

    float val;

    int prop_id;

    int attribute;

    CSSSelector::Relation relation;

    bool b;

    int i;

    char tok;

    Value value;

    ValueList* valueList;

    MediaQuery* mediaQuery;

    MediaQueryExp* mediaQueryExp;

    Vector<MediaQueryExp*>* mediaQueryExpList;

    MediaQuery::Restrictor mediaQueryRestrictor;

}

%{

static inline int cssyyerror(const char*) { return 1; }

static int cssyylex(YYSTYPE* yylval) { return CSSParser::current()->lex(yylval); }

%}

//%expect 37

%left UNIMPORTANT_TOK

%token WHITESPACE SGML_CD

%token INCLUDES

%token DASHMATCH

%token BEGINSWITH

%token ENDSWITH

%token CONTAINS

%token <string> STRING

%right <string> IDENT

%nonassoc <string> HEX

%nonassoc <string> IDSEL

%nonassoc ':'

%nonassoc '.'

%nonassoc '['

%nonassoc <string> '*'

%nonassoc error

%left '|'

%token IMPORT_SYM

%token PAGE_SYM

%token MEDIA_SYM

%token FONT_FACE_SYM

%token CHARSET_SYM

%token NAMESPACE_SYM

%token WEBKIT_RULE_SYM

%token WEBKIT_DECLS_SYM

%token WEBKIT_VALUE_SYM

%token WEBKIT_MEDIAQUERY_SYM

%token IMPORTANT_SYM

%token MEDIA_ONLY

%token MEDIA_NOT

%token MEDIA_AND

%token <val> QEMS

%token <val> EMS

%token <val> EXS

%token <val> PXS

%token <val> CMS

%token <val> MMS

%token <val> INS

%token <val> PTS

%token <val> PCS

%token <val> DEGS

%token <val> RADS

%token <val> GRADS

%token <val> MSECS

%token <val> SECS

%token <val> HERZ

%token <val> KHERZ

%token <string> DIMEN

%token <val> PERCENTAGE

%token <val> FLOATTOKEN

%token <val> INTEGER

%token <string> URI

%token <string> FUNCTION

%token <string> NOTFUNCTION

%token <string> UNICODERANGE

%type <relation> combinator

%type <rule> charset

%type <rule> ruleset

%type <rule> ruleset_or_import

%type <rule> media

%type <rule> import

%type <rule> page

%type <rule> font_face

%type <rule> invalid_rule

%type <rule> invalid_at

%type <rule> invalid_import

%type <rule> rule

%type <string> maybe_ns_prefix

%type <string> namespace_selector

%type <string> string_or_uri

%type <string> ident_or_string

%type <string> medium

%type <string> hexcolor

%type <string> media_feature

%type <mediaList> media_list

%type <mediaList> maybe_media_list

%type <mediaQuery> media_query

%type <mediaQueryRestrictor> maybe_media_restrictor

%type <valueList> maybe_media_value

%type <mediaQueryExp> media_query_exp

%type <mediaQueryExpList> media_query_exp_list

%type <mediaQueryExpList> maybe_media_query_exp_list

%type <ruleList> ruleset_list

%type <prop_id> property

%type <selector> specifier

%type <selector> specifier_list

%type <selector> simple_selector

%type <selector> selector

%type <selector> selector_list

%type <selector> class

%type <selector> attrib

%type <selector> pseudo

%type <ok> declaration_list

%type <ok> decl_list

%type <ok> declaration

%type <b> prio

%type <i> match

%type <i> unary_operator

%type <tok> operator

%type <valueList> expr

%type <value> term

%type <value> unary_term

%type <value> function

%type <string> element_name

%type <string> attr_name

%%

stylesheet:

    maybe_charset maybe_sgml import_list namespace_list rule_list

  | webkit_rule maybe_space

  | webkit_decls maybe_space

  | webkit_value maybe_space

  | webkit_mediaquery maybe_space

  ;

ruleset_or_import:

   ruleset |

   import

;

webkit_rule:

    WEBKIT_RULE_SYM '{' maybe_space ruleset_or_import maybe_space '}' {

        static_cast<CSSParser*>(parser)->rule = $4;

    }

;

webkit_decls:

    WEBKIT_DECLS_SYM '{' maybe_space declaration_list '}' {

        /* can be empty */

    }

;

webkit_value:

    WEBKIT_VALUE_SYM '{' maybe_space expr '}' {

        CSSParser* p = static_cast<CSSParser*>(parser);

        if ($4) {

            p->valueList = p->sinkFloatingValueList($4);

            int oldParsedProperties = p->numParsedProperties;

            if (!p->parseValue(p->id, p->important))

                p->rollbackLastProperties(p->numParsedProperties - oldParsedProperties);

            delete p->valueList;

            p->valueList = 0;

        }

    }

;

webkit_mediaquery:

     WEBKIT_MEDIAQUERY_SYM WHITESPACE maybe_space media_query '}' {

         CSSParser* p = static_cast<CSSParser*>(parser);

         p->mediaQuery = p->sinkFloatingMediaQuery($4);

     }

;

maybe_space:

    /* empty */ %prec UNIMPORTANT_TOK

  | maybe_space WHITESPACE

  ;

maybe_sgml:

    /* empty */

  | maybe_sgml SGML_CD

  | maybe_sgml WHITESPACE

  ;

maybe_charset:

   /* empty */

  | charset {

  }

;

charset:

  CHARSET_SYM maybe_space STRING maybe_space ';' {

     CSSParser* p = static_cast<CSSParser*>(parser);

     $$ = static_cast<CSSParser*>(parser)->createCharsetRule($3);

     if ($$ && p->styleElement && p->styleElement->isCSSStyleSheet())

         p->styleElement->append($$);

  }

  | CHARSET_SYM error invalid_block {

  }

  | CHARSET_SYM error ';' {

  }

;

import_list:

 /* empty */

 | import_list import maybe_sgml {

     CSSParser* p = static_cast<CSSParser*>(parser);

     if ($2 && p->styleElement && p->styleElement->isCSSStyleSheet())

         p->styleElement->append($2);

 }

 ;

namespace_list:

/* empty */

| namespace_list namespace maybe_sgml

;

rule_list:

   /* empty */

 | rule_list rule maybe_sgml {

     CSSParser* p = static_cast<CSSParser*>(parser);

     if ($2 && p->styleElement && p->styleElement->isCSSStyleSheet())

         p->styleElement->append($2);

 }

 ;

rule:

    ruleset

  | media

  | page

  | font_face

  | invalid_rule

  | invalid_at

  | invalid_import

    ;

import:

    IMPORT_SYM maybe_space string_or_uri maybe_space maybe_media_list ';' {

        $$ = static_cast<CSSParser*>(parser)->createImportRule($3, $5);

    }

  | IMPORT_SYM error invalid_block {

        $$ = 0;

    }

  | IMPORT_SYM error ';' {

        $$ = 0;

    }

  ;

namespace:

NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space ';' {

    CSSParser* p = static_cast<CSSParser*>(parser);

    if (p->styleElement && p->styleElement->isCSSStyleSheet())

        static_cast<CSSStyleSheet*>(p->styleElement)->addNamespace(p, atomicString($3), atomicString($4));

}

| NAMESPACE_SYM error invalid_block

| NAMESPACE_SYM error ';'

;

maybe_ns_prefix:

/* empty */ { $$.characters = 0; }

| IDENT WHITESPACE { $$ = $1; }

;

string_or_uri:

STRING

| URI

;

media_feature:

    IDENT maybe_space {

        $$ = $1;

    }

    ;

maybe_media_value:

    /*empty*/ {

        $$ = 0;

    }

    | ':' maybe_space expr maybe_space {

        $$ = $3;

    }

    ;

media_query_exp:

    MEDIA_AND maybe_space '(' maybe_space media_feature maybe_space maybe_media_value ')' maybe_space {

        $5.lower();

        $$ = static_cast<CSSParser*>(parser)->createFloatingMediaQueryExp(atomicString($5), $7);

    }

    ;

media_query_exp_list:

    media_query_exp {

      CSSParser* p = static_cast<CSSParser*>(parser);

      $$ = p->createFloatingMediaQueryExpList();

      $$->append(p->sinkFloatingMediaQueryExp($1));

    }

    | media_query_exp_list media_query_exp {

      $$ = $1;

      $$->append(static_cast<CSSParser*>(parser)->sinkFloatingMediaQueryExp($2));

    }

    ;

maybe_media_query_exp_list:

    /*empty*/ {

        $$ = static_cast<CSSParser*>(parser)->createFloatingMediaQueryExpList();

    }

    | media_query_exp_list

    ;

maybe_media_restrictor:

    /*empty*/ {

        $$ = MediaQuery::None;

    }

    | MEDIA_ONLY {

        $$ = MediaQuery::Only;

    }

    | MEDIA_NOT {

        $$ = MediaQuery::Not;

    }

    ;

media_query:

    maybe_media_restrictor maybe_space medium maybe_media_query_exp_list {

        CSSParser* p = static_cast<CSSParser*>(parser);

        $3.lower();

        $$ = p->createFloatingMediaQuery($1, domString($3), p->sinkFloatingMediaQueryExpList($4));

    }

    ;

maybe_media_list:

     /* empty */ {

        $$ = static_cast<CSSParser*>(parser)->createMediaList();

     }

     | media_list

     ;

media_list:

    media_query {

        CSSParser* p = static_cast<CSSParser*>(parser);

        $$ = p->createMediaList();

        $$->appendMediaQuery(p->sinkFloatingMediaQuery($1));

    }

    | media_list ',' maybe_space media_query {

        $$ = $1;

        if ($$)

            $$->appendMediaQuery(static_cast<CSSParser*>(parser)->sinkFloatingMediaQuery($4));

    }

    | media_list error {

        $$ = 0;

    }

    ;

media:

    MEDIA_SYM maybe_space media_list '{' maybe_space ruleset_list '}' {

        $$ = static_cast<CSSParser*>(parser)->createMediaRule($3, $6);

    }

    | MEDIA_SYM maybe_space '{' maybe_space ruleset_list '}' {

        $$ = static_cast<CSSParser*>(parser)->createMediaRule(0, $5);

    }

    ;

ruleset_list:

    /* empty */ { $$ = 0; }