%{

/*

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

 *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.

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

 *  Copyright (C) 2008 Eric Seidel <eric@webkit.org>

 *

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

#include "CSSRuleList.h"

#include "CSSSelector.h"

#include "CSSStyleSheet.h"

#include "Document.h"

#include "HTMLNames.h"

#include "MediaList.h"

#include "WebKitCSSKeyframeRule.h"

#include "WebKitCSSKeyframesRule.h"

#include <wtf/FastMalloc.h>

#include <stdlib.h>

#include <string.h>

using namespace WebCore;

using namespace HTMLNames;

#define YYMALLOC fastMalloc

#define YYFREE fastFree

#define YYENABLE_NLS 0

#define YYLTYPE_IS_TRIVIAL 1

#define YYMAXDEPTH 10000

#define YYDEBUG 0

// FIXME: Replace with %parse-param { CSSParser* parser } once we can depend on bison 2.x

#define YYPARSE_PARAM parser

#define YYLEX_PARAM parser

%}

%pure_parser

%union {

    bool boolean;

    char character;

    int integer;

    double number;

    CSSParserString string;

    CSSRule* rule;

    CSSRuleList* ruleList;

    CSSSelector* selector;

    Vector<CSSSelector*>* selectorList;

    CSSSelector::MarginBoxType marginBox;

    CSSSelector::Relation relation;

    MediaList* mediaList;

    MediaQuery* mediaQuery;

    MediaQuery::Restrictor mediaQueryRestrictor;

    MediaQueryExp* mediaQueryExp;

    CSSParserValue value;

    CSSParserValueList* valueList;

    Vector<MediaQueryExp*>* mediaQueryExpList;

    WebKitCSSKeyframeRule* keyframeRule;

    WebKitCSSKeyframesRule* keyframesRule;

    float val;

}

%{

static inline int cssyyerror(const char*)

{

    return 1;

}

static int cssyylex(YYSTYPE* yylval, void* parser)

{

    return static_cast<CSSParser*>(parser)->lex(yylval);

}

%}

%expect 55

%nonassoc LOWEST_PREC

%left UNIMPORTANT_TOK

%token WHITESPACE SGML_CD

%token TOKEN_EOF 0

%token INCLUDES

%token DASHMATCH

%token BEGINSWITH

%token ENDSWITH

%token CONTAINS

%token <string> STRING

%right <string> IDENT

%token <string> NTH

%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_KEYFRAME_RULE_SYM

%token WEBKIT_KEYFRAMES_SYM

%token WEBKIT_VALUE_SYM

%token WEBKIT_MEDIAQUERY_SYM

%token WEBKIT_SELECTOR_SYM

%token WEBKIT_VARIABLES_SYM

%token WEBKIT_DEFINE_SYM

%token VARIABLES_FOR

%token WEBKIT_VARIABLES_DECLS_SYM

%token <marginBox> TOPLEFTCORNER_SYM

%token <marginBox> TOPLEFT_SYM

%token <marginBox> TOPCENTER_SYM

%token <marginBox> TOPRIGHT_SYM

%token <marginBox> TOPRIGHTCORNER_SYM

%token <marginBox> BOTTOMLEFTCORNER_SYM

%token <marginBox> BOTTOMLEFT_SYM

%token <marginBox> BOTTOMCENTER_SYM

%token <marginBox> BOTTOMRIGHT_SYM

%token <marginBox> BOTTOMRIGHTCORNER_SYM

%token <marginBox> LEFTTOP_SYM

%token <marginBox> LEFTMIDDLE_SYM

%token <marginBox> LEFTBOTTOM_SYM

%token <marginBox> RIGHTTOP_SYM

%token <marginBox> RIGHTMIDDLE_SYM

%token <marginBox> RIGHTBOTTOM_SYM

%token ATKEYWORD

%token IMPORTANT_SYM

%token MEDIA_ONLY

%token MEDIA_NOT

%token MEDIA_AND

%token <number> REMS

%token <number> QEMS

%token <number> EMS

%token <number> EXS

%token <number> PXS

%token <number> CMS

%token <number> MMS

%token <number> INS

%token <number> PTS

%token <number> PCS

%token <number> DEGS

%token <number> RADS

%token <number> GRADS

%token <number> TURNS

%token <number> MSECS

%token <number> SECS

%token <number> HERZ

%token <number> KHERZ

%token <string> DIMEN

%token <number> PERCENTAGE

%token <number> FLOATTOKEN

%token <number> INTEGER

%token <string> URI

%token <string> FUNCTION

%token <string> NOTFUNCTION

%token <string> UNICODERANGE

%token <string> VARCALL

%type <relation> combinator

%type <rule> charset

%type <rule> ruleset

%type <rule> media

%type <rule> import

%type <rule> namespace

%type <rule> page

%type <rule> margin_box

%type <rule> font_face

%type <rule> keyframes

%type <rule> invalid_rule

%type <rule> save_block

%type <rule> invalid_at

%type <rule> rule

%type <rule> valid_rule

%type <ruleList> block_rule_list 

%type <rule> block_rule

%type <rule> block_valid_rule

%type <rule> variables_rule

%type <mediaList> variables_media_list

%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 <marginBox> margin_sym

%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_and_media_query_exp_list

%type <string> keyframe_name

%type <keyframeRule> keyframe_rule

%type <keyframesRule> keyframes_rule

%type <valueList> key_list

%type <value> key

%type <integer> property

%type <selector> specifier

%type <selector> specifier_list

%type <selector> simple_selector

%type <selector> selector

%type <selectorList> selector_list

%type <selector> selector_with_trailing_whitespace

%type <selector> class

%type <selector> attrib

%type <selector> pseudo

%type <selector> pseudo_page

%type <selector> page_selector

%type <boolean> declaration_list

%type <boolean> decl_list

%type <boolean> declaration

%type <boolean> declarations_and_margins

%type <boolean> prio

%type <integer> match

%type <integer> unary_operator

%type <integer> maybe_unary_operator

%type <character> operator

%type <valueList> expr

%type <value> term

%type <value> unary_term

%type <value> function

%type <string> element_name

%type <string> attr_name

%type <string> variable_name

%type <boolean> variables_declaration_list

%type <boolean> variables_decl_list

%type <boolean> variables_declaration

%type <value> variable_reference

%%

stylesheet:

    maybe_space maybe_charset maybe_sgml rule_list

  | webkit_rule maybe_space

  | webkit_decls maybe_space

  | webkit_value maybe_space

  | webkit_mediaquery maybe_space

  | webkit_selector maybe_space

  | webkit_variables_decls maybe_space

  | webkit_keyframe_rule maybe_space

  ;

webkit_rule:

    WEBKIT_RULE_SYM '{' maybe_space valid_rule maybe_space '}' {

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

    }

;

webkit_keyframe_rule:

    WEBKIT_KEYFRAME_RULE_SYM '{' maybe_space keyframe_rule maybe_space '}' {

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

    }

;

webkit_decls:

    WEBKIT_DECLS_SYM '{' maybe_space declaration_list '}' {

        /* can be empty */

    }

;

webkit_variables_decls:

    WEBKIT_VARIABLES_DECLS_SYM '{' maybe_space variables_declaration_list '}' {

        /* can be empty */

    }

;

webkit_value:

    WEBKIT_VALUE_SYM '{' maybe_space expr '}' {

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

        if ($4) {

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

            int oldParsedProperties = p->m_numParsedProperties;

            if (!p->parseValue(p->m_id, p->m_important))

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

            delete p->m_valueList;

            p->m_valueList = 0;

        }

    }

;

webkit_mediaquery:

     WEBKIT_MEDIAQUERY_SYM WHITESPACE maybe_space media_query '}' {

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

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

     }

;

webkit_selector:

    WEBKIT_SELECTOR_SYM '{' maybe_space selector_list '}' {

        if ($4) {

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

            if (p->m_selectorListForParseSelector)

                p->m_selectorListForParseSelector->adoptSelectorVector(*$4);

        }

    }

;

maybe_space:

    /* empty */ %prec UNIMPORTANT_TOK

  | maybe_space WHITESPACE

  ;

maybe_sgml:

    /* empty */

  | maybe_sgml SGML_CD

  | maybe_sgml WHITESPACE

  ;

maybe_charset:

   /* empty */

  | charset {

  }

  ;

closing_brace:

    '}'

  | %prec LOWEST_PREC TOKEN_EOF

  ;

charset:

  CHARSET_SYM maybe_space STRING maybe_space ';' {

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

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

     if ($$ && p->m_styleSheet)

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

  }

  | CHARSET_SYM error invalid_block {

  }

  | CHARSET_SYM error ';' {

  }

;

rule_list:

   /* empty */

 | rule_list rule maybe_sgml {

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

     if ($2 && p->m_styleSheet)

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

 }

 ;

valid_rule:

    ruleset

  | media

  | page

  | font_face

  | keyframes

  | namespace

  | import

  | variables_rule

  ;

rule:

    valid_rule {

        static_cast<CSSParser*>(parser)->m_hadSyntacticallyValidCSSRule = true;

    }

  | invalid_rule

  | invalid_at

  ;

block_rule_list: 

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

  | block_rule_list block_rule maybe_sgml {

      $$ = $1;

      if ($2) {

          if (!$$)

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

          $$->append($2);

      }

  }

  ;

block_valid_rule:

    ruleset

  | page

  | font_face

  | keyframes

  ;

block_rule:

    block_valid_rule

  | invalid_rule

  | invalid_at

  | namespace

  | import

  | variables_rule

  | media

  ;

import:

    IMPORT_SYM maybe_space string_or_uri maybe_space maybe_media_list ';' {

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

    }

  | IMPORT_SYM maybe_space string_or_uri maybe_space maybe_media_list invalid_block {

        $$ = 0;

    }

  | IMPORT_SYM error ';' {

        $$ = 0;

    }

  | IMPORT_SYM error invalid_block {

        $$ = 0;

    }

  ;

variables_rule:

    WEBKIT_VARIABLES_SYM maybe_space maybe_media_list '{' maybe_space variables_declaration_list '}' {

        $$ = static_cast<CSSParser*>(parser)->createVariablesRule($3, true);

    }

    |

    WEBKIT_DEFINE_SYM maybe_space variables_media_list '{' maybe_space variables_declaration_list '}' {

        $$ = static_cast<CSSParser*>(parser)->createVariablesRule($3, false);

    }

    ;

variables_media_list:

    /* empty */ {

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

    }

    |

    VARIABLES_FOR WHITESPACE media_list {

        $$ = $3;

    }

    ;

variables_declaration_list:

    variables_declaration {

        $$ = $1;

    }

    | variables_decl_list variables_declaration {

        $$ = $1;

        if ($2)

            $$ = $2;

    }

    | variables_decl_list {

        $$ = $1;

    }

    | error invalid_block_list error {

        $$ = false;

    }

    | error {

        $$ = false;

    }

    | variables_decl_list error {

        $$ = $1;

    }

    ;

variables_decl_list:

    variables_declaration ';' maybe_space {

        $$ = $1;

    }

    | variables_declaration invalid_block_list ';' maybe_space {

        $$ = false;

    }

    | error ';' maybe_space {

        $$ = false;

    }

    | error invalid_block_list error ';' maybe_space {

        $$ = false;

    }

    | variables_decl_list variables_declaration ';' maybe_space {

        $$ = $1;

        if ($2)

            $$ = $2;

    }

    | variables_decl_list error ';' maybe_space {

        $$ = $1;

    }