Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / xml / XPathGrammar.y
1 /*
2  * Copyright 2005 Frerich Raabe <raabe@kde.org>
3  * Copyright (C) 2006, 2013 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 "XPathFunctions.h"
33 #include "XPathParser.h"
34 #include "XPathPath.h"
35 #include "XPathVariableReference.h"
36
37 #define YYMALLOC fastMalloc
38 #define YYFREE fastFree
39
40 #define YYENABLE_NLS 0
41 #define YYLTYPE_IS_TRIVIAL 1
42 #define YYDEBUG 0
43 #define YYMAXDEPTH 10000
44
45 using namespace WebCore;
46 using namespace XPath;
47
48 %}
49
50 %pure-parser
51 %lex-param { parser }
52 %parse-param { Parser& parser }
53
54 %union { 
55     NumericOp::Opcode numericOpcode; 
56     EqTestOp::Opcode equalityTestOpcode;
57     StringImpl* string;
58     Step::Axis axis;
59     LocationPath* locationPath;
60     Step::NodeTest* nodeTest;
61     Vector<std::unique_ptr<Expression>>* expressionVector;
62     Step* step;
63     Expression* expression; 
64 }
65 %left <numericOpcode> MULOP
66
67 %left <equalityTestOpcode> EQOP RELOP
68
69 %left PLUS MINUS
70
71 %left OR AND
72
73 %token <string> FUNCTIONNAME LITERAL NAMETEST NUMBER NODETYPE VARIABLEREFERENCE
74 %destructor { if ($$) $$->deref(); } FUNCTIONNAME LITERAL NAMETEST NUMBER NODETYPE VARIABLEREFERENCE
75
76 %token <axis> AXISNAME
77 %type <axis> AxisSpecifier
78
79 %token COMMENT DOTDOT PI NODE SLASHSLASH TEXT XPATH_ERROR
80
81 %type <locationPath> LocationPath AbsoluteLocationPath RelativeLocationPath
82 %destructor { delete $$; } LocationPath AbsoluteLocationPath RelativeLocationPath
83
84 %type <nodeTest> NodeTest
85 %destructor { delete $$; } NodeTest
86
87 %type <expressionVector> ArgumentList PredicateList OptionalPredicateList
88 %destructor { delete $$; } ArgumentList PredicateList OptionalPredicateList
89
90 %type <step> Step AbbreviatedStep DescendantOrSelf
91 %destructor { delete $$; } Step AbbreviatedStep DescendantOrSelf
92
93 %type <expression> AdditiveExpr AndExpr Argument EqualityExpr Expr FilterExpr FunctionCall MultiplicativeExpr OrExpr PathExpr Predicate PrimaryExpr RelationalExpr UnaryExpr UnionExpr
94 %destructor { delete $$; } AdditiveExpr AndExpr Argument EqualityExpr Expr FilterExpr FunctionCall MultiplicativeExpr OrExpr PathExpr Predicate PrimaryExpr RelationalExpr UnaryExpr UnionExpr
95
96
97
98 %{
99
100 static int xpathyylex(YYSTYPE* yylval, Parser& parser) { return parser.lex(*yylval); }
101 static void xpathyyerror(Parser&, const char*) { }
102
103 %}
104
105 %%
106
107 Top:
108     Expr
109     {
110         parser.setParseResult(std::unique_ptr<Expression>($1));
111     }
112     ;
113
114 Expr:
115     OrExpr
116     ;
117
118 LocationPath:
119     AbsoluteLocationPath
120     {
121         $$ = $1;
122         $$->setAbsolute();
123     }
124     |
125     RelativeLocationPath
126     ;
127
128 AbsoluteLocationPath:
129     '/'
130     {
131         $$ = new LocationPath;
132     }
133     |
134     '/' RelativeLocationPath
135     {
136         $$ = $2;
137     }
138     |
139     DescendantOrSelf RelativeLocationPath
140     {
141         $$ = $2;
142         $$->prependStep(std::unique_ptr<Step>($1));
143     }
144     ;
145
146 RelativeLocationPath:
147     Step
148     {
149         $$ = new LocationPath;
150         $$->appendStep(std::unique_ptr<Step>($1));
151     }
152     |
153     RelativeLocationPath '/' Step
154     {
155         $$ = $1;
156         $$->appendStep(std::unique_ptr<Step>($3));
157     }
158     |
159     RelativeLocationPath DescendantOrSelf Step
160     {
161         $$ = $1;
162         $$->appendStep(std::unique_ptr<Step>($2));
163         $$->appendStep(std::unique_ptr<Step>($3));
164     }
165     ;
166
167 Step:
168     NodeTest OptionalPredicateList
169     {
170         std::unique_ptr<Step::NodeTest> nodeTest($1);
171         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList($2);
172         if (predicateList)
173             $$ = new Step(Step::ChildAxis, WTFMove(*nodeTest), WTFMove(*predicateList));
174         else
175             $$ = new Step(Step::ChildAxis, WTFMove(*nodeTest));
176     }
177     |
178     NAMETEST OptionalPredicateList
179     {
180         String nametest = adoptRef($1);
181         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList($2);
182
183         String localName;
184         String namespaceURI;
185         if (!parser.expandQualifiedName(nametest, localName, namespaceURI)) {
186             $$ = nullptr;
187             YYABORT;
188         }
189
190         if (predicateList)
191             $$ = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), WTFMove(*predicateList));
192         else
193             $$ = new Step(Step::ChildAxis, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
194     }
195     |
196     AxisSpecifier NodeTest OptionalPredicateList
197     {
198         std::unique_ptr<Step::NodeTest> nodeTest($2);
199         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList($3);
200
201         if (predicateList)
202             $$ = new Step($1, WTFMove(*nodeTest), WTFMove(*predicateList));
203         else
204             $$ = new Step($1, WTFMove(*nodeTest));
205     }
206     |
207     AxisSpecifier NAMETEST OptionalPredicateList
208     {
209         String nametest = adoptRef($2);
210         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList($3);
211
212         String localName;
213         String namespaceURI;
214         if (!parser.expandQualifiedName(nametest, localName, namespaceURI)) {
215             $$ = nullptr;
216             YYABORT;
217         }
218
219         if (predicateList)
220             $$ = new Step($1, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI), WTFMove(*predicateList));
221         else
222             $$ = new Step($1, Step::NodeTest(Step::NodeTest::NameTest, localName, namespaceURI));
223     }
224     |
225     AbbreviatedStep
226     ;
227
228 AxisSpecifier:
229     AXISNAME
230     |
231     '@'
232     {
233         $$ = Step::AttributeAxis;
234     }
235     ;
236
237 NodeTest:
238     NODE '(' ')'
239     {
240         $$ = new Step::NodeTest(Step::NodeTest::AnyNodeTest);
241     }
242     |
243     TEXT '(' ')'
244     {
245         $$ = new Step::NodeTest(Step::NodeTest::TextNodeTest);
246     }
247     |
248     COMMENT '(' ')'
249     {
250         $$ = new Step::NodeTest(Step::NodeTest::CommentNodeTest);
251     }
252     |
253     PI '(' ')'
254     {
255         $$ = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest);
256     }
257     |
258     PI '(' LITERAL ')'
259     {
260         String literal = adoptRef($3);
261         $$ = new Step::NodeTest(Step::NodeTest::ProcessingInstructionNodeTest, literal.stripWhiteSpace());
262     }
263     ;
264
265 OptionalPredicateList:
266     /* empty */
267     {
268         $$ = nullptr;
269     }
270     |
271     PredicateList
272     ;
273
274 PredicateList:
275     Predicate
276     {
277         $$ = new Vector<std::unique_ptr<Expression>>;
278         $$->append(std::unique_ptr<Expression>($1));
279     }
280     |
281     PredicateList Predicate
282     {
283         $$ = $1;
284         $$->append(std::unique_ptr<Expression>($2));
285     }
286     ;
287
288 Predicate:
289     '[' Expr ']'
290     {
291         $$ = $2;
292     }
293     ;
294
295 DescendantOrSelf:
296     SLASHSLASH
297     {
298         $$ = new Step(Step::DescendantOrSelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
299     }
300     ;
301
302 AbbreviatedStep:
303     '.'
304     {
305         $$ = new Step(Step::SelfAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
306     }
307     |
308     DOTDOT
309     {
310         $$ = new Step(Step::ParentAxis, Step::NodeTest(Step::NodeTest::AnyNodeTest));
311     }
312     ;
313
314 PrimaryExpr:
315     VARIABLEREFERENCE
316     {
317         String name = adoptRef($1);
318         $$ = new VariableReference(name);
319     }
320     |
321     '(' Expr ')'
322     {
323         $$ = $2;
324     }
325     |
326     LITERAL
327     {
328         String literal = adoptRef($1);
329         $$ = new StringExpression(WTFMove(literal));
330     }
331     |
332     NUMBER
333     {
334         String numeral = adoptRef($1);
335         $$ = new Number(numeral.toDouble());
336     }
337     |
338     FunctionCall
339     ;
340
341 FunctionCall:
342     FUNCTIONNAME '(' ')'
343     {
344         String name = adoptRef($1);
345         $$ = XPath::Function::create(name).release();
346         if (!$$)
347             YYABORT;
348     }
349     |
350     FUNCTIONNAME '(' ArgumentList ')'
351     {
352         String name = adoptRef($1);
353         std::unique_ptr<Vector<std::unique_ptr<Expression>>> argumentList($3);
354         $$ = XPath::Function::create(name, WTFMove(*argumentList)).release();
355         if (!$$)
356             YYABORT;
357     }
358     ;
359
360 ArgumentList:
361     Argument
362     {
363         $$ = new Vector<std::unique_ptr<Expression>>;
364         $$->append(std::unique_ptr<Expression>($1));
365     }
366     |
367     ArgumentList ',' Argument
368     {
369         $$ = $1;
370         $$->append(std::unique_ptr<Expression>($3));
371     }
372     ;
373
374 Argument:
375     Expr
376     ;
377
378 UnionExpr:
379     PathExpr
380     |
381     UnionExpr '|' PathExpr
382     {
383         $$ = new Union(std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
384     }
385     ;
386
387 PathExpr:
388     LocationPath
389     {
390         $$ = $1;
391     }
392     |
393     FilterExpr
394     |
395     FilterExpr '/' RelativeLocationPath
396     {
397         $3->setAbsolute();
398         $$ = new Path(std::unique_ptr<Expression>($1), std::unique_ptr<LocationPath>($3));
399     }
400     |
401     FilterExpr DescendantOrSelf RelativeLocationPath
402     {
403         $3->prependStep(std::unique_ptr<Step>($2));
404         $3->setAbsolute();
405         $$ = new Path(std::unique_ptr<Expression>($1), std::unique_ptr<LocationPath>($3));
406     }
407     ;
408
409 FilterExpr:
410     PrimaryExpr
411     |
412     PrimaryExpr PredicateList
413     {
414         std::unique_ptr<Vector<std::unique_ptr<Expression>>> predicateList($2);
415         $$ = new Filter(std::unique_ptr<Expression>($1), WTFMove(*predicateList));
416     }
417     ;
418
419 OrExpr:
420     AndExpr
421     |
422     OrExpr OR AndExpr
423     {
424         $$ = new LogicalOp(LogicalOp::OP_Or, std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
425     }
426     ;
427
428 AndExpr:
429     EqualityExpr
430     |
431     AndExpr AND EqualityExpr
432     {
433         $$ = new LogicalOp(LogicalOp::OP_And, std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
434     }
435     ;
436
437 EqualityExpr:
438     RelationalExpr
439     |
440     EqualityExpr EQOP RelationalExpr
441     {
442         $$ = new EqTestOp($2, std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
443     }
444     ;
445
446 RelationalExpr:
447     AdditiveExpr
448     |
449     RelationalExpr RELOP AdditiveExpr
450     {
451         $$ = new EqTestOp($2, std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
452     }
453     ;
454
455 AdditiveExpr:
456     MultiplicativeExpr
457     |
458     AdditiveExpr PLUS MultiplicativeExpr
459     {
460         $$ = new NumericOp(NumericOp::OP_Add, std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
461     }
462     |
463     AdditiveExpr MINUS MultiplicativeExpr
464     {
465         $$ = new NumericOp(NumericOp::OP_Sub, std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
466     }
467     ;
468
469 MultiplicativeExpr:
470     UnaryExpr
471     |
472     MultiplicativeExpr MULOP UnaryExpr
473     {
474         $$ = new NumericOp($2, std::unique_ptr<Expression>($1), std::unique_ptr<Expression>($3));
475     }
476     ;
477
478 UnaryExpr:
479     UnionExpr
480     |
481     MINUS UnaryExpr
482     {
483         $$ = new Negative(std::unique_ptr<Expression>($2));
484     }
485     ;
486
487 %%