src/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 WebCore;
  50 using namespace XPath;
  51
  52 %}
  53
  54 %pure_parser
  55 %parse-param { WebCore::XPath::Parser* parser }
  56
  57 %union
  58 {
  59     Step::Axis axis;
  60     Step::NodeTest* nodeTest;
  61     NumericOp::Opcode numop;
  62     EqTestOp::Opcode eqop;
  63     String* str;
  64     Expression* expr;
  65     Vector<OwnPtr<Predicate> >* predList;
  66     Vector<OwnPtr<Expression> >* argList;
  67     Step* step;
  68     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         parser->registerParseNode($$);
 142     }
 143     |
 144     '/' RelativeLocationPath
 145     {
 146         $$ = $2;
 147     }
 148     |
 149     DescendantOrSelf RelativeLocationPath
 150     {
 151         $$ = $2;
 152         $$->insertFirstStep($1);
 153         parser->unregisterParseNode($1);
 154     }
 155     ;
 156
 157 RelativeLocationPath:
 158     Step
 159     {
 160         $$ = new LocationPath;
 161         $$->appendStep($1);
 162         parser->unregisterParseNode($1);
 163         parser->registerParseNode($$);
 164     }
 165     |
 166     RelativeLocationPath '/' Step
 167     {
 168         $$->appendStep($3);
 169         parser->unregisterParseNode($3);
 170     }
 171     |
 172     RelativeLocationPath DescendantOrSelf Step
 173     {
 174         $$->appendStep($2);
 175         $$->appendStep($3);
 176         parser->unregisterParseNode($2);
 177         parser->unregisterParseNode($3);
 178     }
 179     ;
 180
 181 Step:
 182     NodeTest OptionalPredicateList
 183     {
 184         if ($2) {
 185             $$ = new Step(Step::ChildAxis, *$1, *$2);
 186             parser->deletePredicateVector($2);
 187         } else
 188             $$ = new Step(Step::ChildAxis, *$1);
 189         parser->deleteNodeTest($1);
 190         parser->registerParseNode($$);
 191     }
 192     |
 193     NAMETEST OptionalPredicateList
 194     {
 195         AtomicString localName;
 196         AtomicString namespaceURI;
 197         if (!parser->expandQName(*$1, localName, namespaceURI)) {
 198             parser->m_gotNamespaceError = true;
 199             YYABORT;
 200         }
 201
 202         if ($2) {
 203             $$ = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), *$2);
 204             parser->deletePredicateVector($2);
 205         } else
 206             $$ = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
 207         parser->deleteString($1);
 208         parser->registerParseNode($$);
 209     }
 210     |
 211     AxisSpecifier NodeTest OptionalPredicateList
 212     {
 213         if ($3) {
 214             $$ = new Step($1, *$2, *$3);
 215             parser->deletePredicateVector($3);
 216         } else
 217             $$ = new Step($1, *$2);
 218         parser->deleteNodeTest($2);
 219         parser->registerParseNode($$);
 220     }
 221     |
 222     AxisSpecifier NAMETEST OptionalPredicateList
 223     {
 224         AtomicString localName;
 225         AtomicString namespaceURI;
 226         if (!parser->expandQName(*$2, localName, namespaceURI)) {
 227             parser->m_gotNamespaceError = true;
 228             YYABORT;
 229         }
 230
 231         if ($3) {
 232             $$ = new Step($1, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), *$3);
 233             parser->deletePredicateVector($3);
 234         } else
 235             $$ = new Step($1, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
 236         parser->deleteString($2);
 237         parser->registerParseNode($$);
 238     }
 239     |
 240     AbbreviatedStep
 241     ;
 242
 243 AxisSpecifier:
 244     AXISNAME
 245     |
 246     '@'
 247     {
 248         $$ = Step::AttributeAxis;
 249     }
 250     ;
 251
 252 NodeTest:
 253     NODETYPE '(' ')'
 254     {
 255         if (*$1 == "node")
 256             $$ = new Step::NodeTest(Step::NodeTest::AnyNodeTest);
 257         else if (*$1 == "text")
 258             $$ = new Step::NodeTest(Step::NodeTest::TextNodeTest);
 259         else if (*$1 == "comment")
 260             $$ = new Step::NodeTest(Step::NodeTest::CommentNodeTest);
 261
 262         parser->deleteString($1);
 263         parser->registerNodeTest($$);
 264     }
 265     |
 266     PI '(' ')'
 267     {
 268         $$ = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest);
 269         parser->deleteString($1);
 270         parser->registerNodeTest($$);
 271     }
 272     |
 273     PI '(' LITERAL ')'
 274     {
 275         $$ = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest, $3->stripWhiteSpace());
 276         parser->deleteString($1);
 277         parser->deleteString($3);
 278         parser->registerNodeTest($$);
 279     }
 280     ;
 281
 282 OptionalPredicateList:
 283     /* empty */
 284     {
 285         $$ = 0;
 286     }
 287     |
 288     PredicateList
 289     ;
 290
 291 PredicateList:
 292     Predicate
 293     {
 294         $$ = new Vector<OwnPtr<Predicate> >;
 295         $$->append(adoptPtr(new Predicate(adoptPtr($1))));
 296         parser->unregisterParseNode($1);
 297         parser->registerPredicateVector($$);
 298     }
 299     |
 300     PredicateList Predicate
 301     {
 302         $$->append(adoptPtr(new Predicate(adoptPtr($2))));
 303         parser->unregisterParseNode($2);
 304     }
 305     ;
 306
 307 Predicate:
 308     '[' Expr ']'
 309     {
 310         $$ = $2;
 311     }
 312     ;
 313
 314 DescendantOrSelf:
 315     SLASHSLASH
 316     {
 317         $$ = new Step(Step::DescendantOrSelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
 318         parser->registerParseNode($$);
 319     }
 320     ;
 321
 322 AbbreviatedStep:
 323     '.'
 324     {
 325         $$ = new Step(Step::SelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
 326         parser->registerParseNode($$);
 327     }
 328     |
 329     DOTDOT
 330     {
 331         $$ = new Step(Step::ParentAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
 332         parser->registerParseNode($$);
 333     }
 334     ;
 335
 336 PrimaryExpr:
 337     VARIABLEREFERENCE
 338     {
 339         $$ = new VariableReference(*$1);
 340         parser->deleteString($1);
 341         parser->registerParseNode($$);
 342     }
 343     |
 344     '(' Expr ')'
 345     {
 346         $$ = $2;
 347     }
 348     |
 349     LITERAL
 350     {
 351         $$ = new StringExpression(*$1);
 352         parser->deleteString($1);
 353         parser->registerParseNode($$);
 354     }
 355     |
 356     NUMBER
 357     {
 358         $$ = new Number($1->toDouble());
 359         parser->deleteString($1);
 360         parser->registerParseNode($$);
 361     }
 362     |
 363     FunctionCall
 364     ;
 365
 366 FunctionCall:
 367     FUNCTIONNAME '(' ')'
 368     {
 369         $$ = createFunction(*$1);
 370         if (!$$)
 371             YYABORT;
 372         parser->deleteString($1);
 373         parser->registerParseNode($$);
 374     }
 375     |
 376     FUNCTIONNAME '(' ArgumentList ')'
 377     {
 378         $$ = createFunction(*$1, *$3);
 379         if (!$$)
 380             YYABORT;
 381         parser->deleteString($1);
 382         parser->deleteExpressionVector($3);
 383         parser->registerParseNode($$);
 384     }
 385     ;
 386
 387 ArgumentList:
 388     Argument
 389     {
 390         $$ = new Vector<OwnPtr<Expression> >;
 391         $$->append(adoptPtr($1));
 392         parser->unregisterParseNode($1);
 393         parser->registerExpressionVector($$);
 394     }
 395     |
 396     ArgumentList ',' Argument
 397     {
 398         $$->append(adoptPtr($3));
 399         parser->unregisterParseNode($3);
 400     }
 401     ;
 402
 403 Argument:
 404     Expr
 405     ;
 406
 407 UnionExpr:
 408     PathExpr
 409     |
 410     UnionExpr '|' PathExpr
 411     {
 412         $$ = new Union;
 413         $$->addSubExpression(adoptPtr($1));
 414         $$->addSubExpression(adoptPtr($3));
 415         parser->unregisterParseNode($1);
 416         parser->unregisterParseNode($3);
 417         parser->registerParseNode($$);
 418     }
 419     ;
 420
 421 PathExpr:
 422     LocationPath
 423     {
 424         $$ = $1;
 425     }
 426     |
 427     FilterExpr
 428     |
 429     FilterExpr '/' RelativeLocationPath
 430     {
 431         $3->setAbsolute(true);
 432         $$ = new Path($1, $3);
 433         parser->unregisterParseNode($1);
 434         parser->unregisterParseNode($3);
 435         parser->registerParseNode($$);
 436     }
 437     |
 438     FilterExpr DescendantOrSelf RelativeLocationPath
 439     {
 440         $3->insertFirstStep($2);
 441         $3->setAbsolute(true);
 442         $$ = new Path($1, $3);
 443         parser->unregisterParseNode($1);
 444         parser->unregisterParseNode($2);
 445         parser->unregisterParseNode($3);
 446         parser->registerParseNode($$);
 447     }
 448     ;
 449
 450 FilterExpr:
 451     PrimaryExpr
 452     |
 453     PrimaryExpr PredicateList
 454     {
 455         $$ = new Filter(adoptPtr($1), *$2);
 456         parser->unregisterParseNode($1);
 457         parser->deletePredicateVector($2);
 458         parser->registerParseNode($$);
 459     }
 460     ;
 461
 462 OrExpr:
 463     AndExpr
 464     |
 465     OrExpr OR AndExpr
 466     {
 467         $$ = new LogicalOp(LogicalOp::OP_Or, adoptPtr($1), adoptPtr($3));
 468         parser->unregisterParseNode($1);
 469         parser->unregisterParseNode($3);
 470         parser->registerParseNode($$);
 471     }
 472     ;
 473
 474 AndExpr:
 475     EqualityExpr
 476     |
 477     AndExpr AND EqualityExpr
 478     {
 479         $$ = new LogicalOp(LogicalOp::OP_And, adoptPtr($1), adoptPtr($3));
 480         parser->unregisterParseNode($1);
 481         parser->unregisterParseNode($3);
 482         parser->registerParseNode($$);
 483     }
 484     ;
 485
 486 EqualityExpr:
 487     RelationalExpr
 488     |
 489     EqualityExpr EQOP RelationalExpr
 490     {
 491         $$ = new EqTestOp($2, adoptPtr($1), adoptPtr($3));
 492         parser->unregisterParseNode($1);
 493         parser->unregisterParseNode($3);
 494         parser->registerParseNode($$);
 495     }
 496     ;
 497
 498 RelationalExpr:
 499     AdditiveExpr
 500     |
 501     RelationalExpr RELOP AdditiveExpr
 502     {
 503         $$ = new EqTestOp($2, adoptPtr($1), adoptPtr($3));
 504         parser->unregisterParseNode($1);
 505         parser->unregisterParseNode($3);
 506         parser->registerParseNode($$);
 507     }
 508     ;
 509
 510 AdditiveExpr:
 511     MultiplicativeExpr
 512     |
 513     AdditiveExpr PLUS MultiplicativeExpr
 514     {
 515         $$ = new NumericOp(NumericOp::OP_Add, adoptPtr($1), adoptPtr($3));
 516         parser->unregisterParseNode($1);
 517         parser->unregisterParseNode($3);
 518         parser->registerParseNode($$);
 519     }
 520     |
 521     AdditiveExpr MINUS MultiplicativeExpr
 522     {
 523         $$ = new NumericOp(NumericOp::OP_Sub, adoptPtr($1), adoptPtr($3));
 524         parser->unregisterParseNode($1);
 525         parser->unregisterParseNode($3);
 526         parser->registerParseNode($$);
 527     }
 528     ;
 529
 530 MultiplicativeExpr:
 531     UnaryExpr
 532     |
 533     MultiplicativeExpr MULOP UnaryExpr
 534     {
 535         $$ = new NumericOp($2, adoptPtr($1), adoptPtr($3));
 536         parser->unregisterParseNode($1);
 537         parser->unregisterParseNode($3);
 538         parser->registerParseNode($$);
 539     }
 540     ;
 541
 542 UnaryExpr:
 543     UnionExpr
 544     |
 545     MINUS UnaryExpr
 546     {
 547         $$ = new Negative;
 548         $$->addSubExpression(adoptPtr($2));
 549         parser->unregisterParseNode($2);
 550         parser->registerParseNode($$);
 551     }
 552     ;
 553
 554 %%