third_party/WebKit/Source/core/xml/XPathGrammar.y

   1 /*
   2  * Copyright 2005 Frerich Raabe <raabe@kde.org>
   3  * Copyright (C) 2006 Apple Inc. All rights reserved.
   4  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 %{
  29
  30 #include "config.h"
  31
  32 #include "core/xml/XPathFunctions.h"
  33 #include "core/xml/XPathNSResolver.h"
  34 #include "core/xml/XPathParser.h"
  35 #include "core/xml/XPathPath.h"
  36 #include "core/xml/XPathPredicate.h"
  37 #include "core/xml/XPathStep.h"
  38 #include "core/xml/XPathVariableReference.h"
  39 #include "wtf/FastMalloc.h"
  40
  41 #define YYMALLOC fastMalloc
  42 #define YYFREE fastFree
  43
  44 #define YYENABLE_NLS 0
  45 #define YYLTYPE_IS_TRIVIAL 1
  46 #define YYDEBUG 0
  47 #define YYMAXDEPTH 10000
  48
  49 using namespace blink;
  50 using namespace XPath;
  51
  52 %}
  53
  54 %pure-parser
  55 %parse-param { blink::XPath::Parser* parser }
  56
  57 %union
  58 {
  59     blink::XPath::Step::Axis axis;
  60     blink::XPath::Step::NodeTest* nodeTest;
  61     blink::XPath::NumericOp::Opcode numop;
  62     blink::XPath::EqTestOp::Opcode eqop;
  63     String* str;
  64     blink::XPath::Expression* expr;
  65     blink::HeapVector<blink::Member<blink::XPath::Predicate>>* predList;
  66     blink::HeapVector<blink::Member<blink::XPath::Expression>>* argList;
  67     blink::XPath::Step* step;
  68     blink::XPath::LocationPath* locationPath;
  69 }
  70
  71 %{
  72
  73 static int xpathyylex(YYSTYPE* yylval) { return Parser::current()->lex(yylval); }
  74 static void xpathyyerror(void*, const char*) { }
  75
  76 %}
  77
  78 %left <numop> MULOP
  79 %left <eqop> EQOP RELOP
  80 %left PLUS MINUS
  81 %left OR AND
  82 %token <axis> AXISNAME
  83 %token <str> NODETYPE PI FUNCTIONNAME LITERAL
  84 %token <str> VARIABLEREFERENCE NUMBER
  85 %token DOTDOT SLASHSLASH
  86 %token <str> NAMETEST
  87 %token XPATH_ERROR
  88
  89 %type <locationPath> LocationPath
  90 %type <locationPath> AbsoluteLocationPath
  91 %type <locationPath> RelativeLocationPath
  92 %type <step> Step
  93 %type <axis> AxisSpecifier
  94 %type <step> DescendantOrSelf
  95 %type <nodeTest> NodeTest
  96 %type <expr> Predicate
  97 %type <predList> OptionalPredicateList
  98 %type <predList> PredicateList
  99 %type <step> AbbreviatedStep
 100 %type <expr> Expr
 101 %type <expr> PrimaryExpr
 102 %type <expr> FunctionCall
 103 %type <argList> ArgumentList
 104 %type <expr> Argument
 105 %type <expr> UnionExpr
 106 %type <expr> PathExpr
 107 %type <expr> FilterExpr
 108 %type <expr> OrExpr
 109 %type <expr> AndExpr
 110 %type <expr> EqualityExpr
 111 %type <expr> RelationalExpr
 112 %type <expr> AdditiveExpr
 113 %type <expr> MultiplicativeExpr
 114 %type <expr> UnaryExpr
 115
 116 %%
 117
 118 Expr:
 119     OrExpr
 120     {
 121         parser->m_topExpr = $1;
 122     }
 123     ;
 124
 125 LocationPath:
 126     RelativeLocationPath
 127     {
 128         $$->setAbsolute(false);
 129     }
 130     |
 131     AbsoluteLocationPath
 132     {
 133         $$->setAbsolute(true);
 134     }
 135     ;
 136
 137 AbsoluteLocationPath:
 138     '/'
 139     {
 140         $$ = new LocationPath;
 141     }
 142     |
 143     '/' RelativeLocationPath
 144     {
 145         $$ = $2;
 146     }
 147     |
 148     DescendantOrSelf RelativeLocationPath
 149     {
 150         $$ = $2;
 151         $$->insertFirstStep($1);
 152     }
 153     ;
 154
 155 RelativeLocationPath:
 156     Step
 157     {
 158         $$ = new LocationPath;
 159         $$->appendStep($1);
 160     }
 161     |
 162     RelativeLocationPath '/' Step
 163     {
 164         $$->appendStep($3);
 165     }
 166     |
 167     RelativeLocationPath DescendantOrSelf Step
 168     {
 169         $$->appendStep($2);
 170         $$->appendStep($3);
 171     }
 172     ;
 173
 174 Step:
 175     NodeTest OptionalPredicateList
 176     {
 177         if ($2)
 178             $$ = new Step(Step::ChildAxis, *$1, *$2);
 179         else
 180             $$ = new Step(Step::ChildAxis, *$1);
 181     }
 182     |
 183     NAMETEST OptionalPredicateList
 184     {
 185         AtomicString localName;
 186         AtomicString namespaceURI;
 187         if (!parser->expandQName(*$1, localName, namespaceURI)) {
 188             parser->m_gotNamespaceError = true;
 189             YYABORT;
 190         }
 191
 192         if ($2)
 193             $$ = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), *$2);
 194         else
 195             $$ = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
 196         parser->deleteString($1);
 197     }
 198     |
 199     AxisSpecifier NodeTest OptionalPredicateList
 200     {
 201         if ($3)
 202             $$ = new Step($1, *$2, *$3);
 203         else
 204             $$ = new Step($1, *$2);
 205     }
 206     |
 207     AxisSpecifier NAMETEST OptionalPredicateList
 208     {
 209         AtomicString localName;
 210         AtomicString namespaceURI;
 211         if (!parser->expandQName(*$2, localName, namespaceURI)) {
 212             parser->m_gotNamespaceError = true;
 213             YYABORT;
 214         }
 215
 216         if ($3)
 217             $$ = new Step($1, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), *$3);
 218         else
 219             $$ = new Step($1, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
 220         parser->deleteString($2);
 221     }
 222     |
 223     AbbreviatedStep
 224     ;
 225
 226 AxisSpecifier:
 227     AXISNAME
 228     |
 229     '@'
 230     {
 231         $$ = Step::AttributeAxis;
 232     }
 233     ;
 234
 235 NodeTest:
 236     NODETYPE '(' ')'
 237     {
 238         if (*$1 == "node")
 239             $$ = new Step::NodeTest(Step::NodeTest::AnyNodeTest);
 240         else if (*$1 == "text")
 241             $$ = new Step::NodeTest(Step::NodeTest::TextNodeTest);
 242         else if (*$1 == "comment")
 243             $$ = new Step::NodeTest(Step::NodeTest::CommentNodeTest);
 244
 245         parser->deleteString($1);
 246     }
 247     |
 248     PI '(' ')'
 249     {
 250         $$ = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest);
 251         parser->deleteString($1);
 252     }
 253     |
 254     PI '(' LITERAL ')'
 255     {
 256         $$ = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest, $3->stripWhiteSpace());
 257         parser->deleteString($1);
 258         parser->deleteString($3);
 259     }
 260     ;
 261
 262 OptionalPredicateList:
 263     /* empty */
 264     {
 265         $$ = 0;
 266     }
 267     |
 268     PredicateList
 269     ;
 270
 271 PredicateList:
 272     Predicate
 273     {
 274         $$ = new blink::HeapVector<blink::Member<Predicate>>;
 275         $$->append(new Predicate($1));
 276     }
 277     |
 278     PredicateList Predicate
 279     {
 280         $$->append(new Predicate($2));
 281     }
 282     ;
 283
 284 Predicate:
 285     '[' Expr ']'
 286     {
 287         $$ = $2;
 288     }
 289     ;
 290
 291 DescendantOrSelf:
 292     SLASHSLASH
 293     {
 294         $$ = new Step(Step::DescendantOrSelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
 295     }
 296     ;
 297
 298 AbbreviatedStep:
 299     '.'
 300     {
 301         $$ = new Step(Step::SelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
 302     }
 303     |
 304     DOTDOT
 305     {
 306         $$ = new Step(Step::ParentAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
 307     }
 308     ;
 309
 310 PrimaryExpr:
 311     VARIABLEREFERENCE
 312     {
 313         $$ = new VariableReference(*$1);
 314         parser->deleteString($1);
 315     }
 316     |
 317     '(' Expr ')'
 318     {
 319         $$ = $2;
 320     }
 321     |
 322     LITERAL
 323     {
 324         $$ = new StringExpression(*$1);
 325         parser->deleteString($1);
 326     }
 327     |
 328     NUMBER
 329     {
 330         $$ = new Number($1->toDouble());
 331         parser->deleteString($1);
 332     }
 333     |
 334     FunctionCall
 335     ;
 336
 337 FunctionCall:
 338     FUNCTIONNAME '(' ')'
 339     {
 340         $$ = createFunction(*$1);
 341         if (!$$)
 342             YYABORT;
 343         parser->deleteString($1);
 344     }
 345     |
 346     FUNCTIONNAME '(' ArgumentList ')'
 347     {
 348         $$ = createFunction(*$1, *$3);
 349         if (!$$)
 350             YYABORT;
 351         parser->deleteString($1);
 352     }
 353     ;
 354
 355 ArgumentList:
 356     Argument
 357     {
 358         $$ = new blink::HeapVector<blink::Member<Expression>>;
 359         $$->append($1);
 360     }
 361     |
 362     ArgumentList ',' Argument
 363     {
 364         $$->append($3);
 365     }
 366     ;
 367
 368 Argument:
 369     Expr
 370     ;
 371
 372 UnionExpr:
 373     PathExpr
 374     |
 375     UnionExpr '|' PathExpr
 376     {
 377         $$ = new Union;
 378         $$->addSubExpression($1);
 379         $$->addSubExpression($3);
 380     }
 381     ;
 382
 383 PathExpr:
 384     LocationPath
 385     {
 386         $$ = $1;
 387     }
 388     |
 389     FilterExpr
 390     |
 391     FilterExpr '/' RelativeLocationPath
 392     {
 393         $3->setAbsolute(true);
 394         $$ = new Path($1, $3);
 395     }
 396     |
 397     FilterExpr DescendantOrSelf RelativeLocationPath
 398     {
 399         $3->insertFirstStep($2);
 400         $3->setAbsolute(true);
 401         $$ = new Path($1, $3);
 402     }
 403     ;
 404
 405 FilterExpr:
 406     PrimaryExpr
 407     |
 408     PrimaryExpr PredicateList
 409     {
 410         $$ = new Filter($1, *$2);
 411     }
 412     ;
 413
 414 OrExpr:
 415     AndExpr
 416     |
 417     OrExpr OR AndExpr
 418     {
 419         $$ = new LogicalOp(LogicalOp::OP_Or, $1, $3);
 420     }
 421     ;
 422
 423 AndExpr:
 424     EqualityExpr
 425     |
 426     AndExpr AND EqualityExpr
 427     {
 428         $$ = new LogicalOp(LogicalOp::OP_And, $1, $3);
 429     }
 430     ;
 431
 432 EqualityExpr:
 433     RelationalExpr
 434     |
 435     EqualityExpr EQOP RelationalExpr
 436     {
 437         $$ = new EqTestOp($2, $1, $3);
 438     }
 439     ;
 440
 441 RelationalExpr:
 442     AdditiveExpr
 443     |
 444     RelationalExpr RELOP AdditiveExpr
 445     {
 446         $$ = new EqTestOp($2, $1, $3);
 447     }
 448     ;
 449
 450 AdditiveExpr:
 451     MultiplicativeExpr
 452     |
 453     AdditiveExpr PLUS MultiplicativeExpr
 454     {
 455         $$ = new NumericOp(NumericOp::OP_Add, $1, $3);
 456     }
 457     |
 458     AdditiveExpr MINUS MultiplicativeExpr
 459     {
 460         $$ = new NumericOp(NumericOp::OP_Sub, $1, $3);
 461     }
 462     ;
 463
 464 MultiplicativeExpr:
 465     UnaryExpr
 466     |
 467     MultiplicativeExpr MULOP UnaryExpr
 468     {
 469         $$ = new NumericOp($2, $1, $3);
 470     }
 471     ;
 472
 473 UnaryExpr:
 474     UnionExpr
 475     |
 476     MINUS UnaryExpr
 477     {
 478         $$ = new Negative;
 479         $$->addSubExpression($2);
 480     }
 481     ;
 482
 483 %%