1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the QtXmlPatterns module of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 3 requirements |
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
24 | ** |
25 | ** GNU General Public License Usage |
26 | ** Alternatively, this file may be used under the terms of the GNU |
27 | ** General Public License version 2.0 or (at your option) the GNU General |
28 | ** Public license version 3 or any later version approved by the KDE Free |
29 | ** Qt Foundation. The licenses are as published by the Free Software |
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
31 | ** included in the packaging of this file. Please review the following |
32 | ** information to ensure the GNU General Public License requirements will |
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
35 | ** |
36 | ** $QT_END_LICENSE$ |
37 | ** |
38 | ****************************************************************************/ |
39 | |
40 | #include "qboolean_p.h" |
41 | #include "qcommonsequencetypes_p.h" |
42 | #include "qdynamiccontextstore_p.h" |
43 | #include "qliteral_p.h" |
44 | |
45 | #include "qletclause_p.h" |
46 | |
47 | QT_BEGIN_NAMESPACE |
48 | |
49 | using namespace QPatternist; |
50 | |
51 | LetClause::LetClause(const Expression::Ptr &operand1, |
52 | const Expression::Ptr &operand2, |
53 | const VariableDeclaration::Ptr &decl) : PairContainer(operand1, operand2) |
54 | , m_varDecl(decl) |
55 | { |
56 | Q_ASSERT(m_varDecl); |
57 | } |
58 | |
59 | DynamicContext::Ptr LetClause::bindVariable(const DynamicContext::Ptr &context) const |
60 | { |
61 | context->setExpressionVariable(slot: m_varDecl->slot, newValue: m_operand1); |
62 | return context; |
63 | } |
64 | |
65 | Item::Iterator::Ptr LetClause::evaluateSequence(const DynamicContext::Ptr &context) const |
66 | { |
67 | return m_operand2->evaluateSequence(context: bindVariable(context)); |
68 | } |
69 | |
70 | Item LetClause::evaluateSingleton(const DynamicContext::Ptr &context) const |
71 | { |
72 | return m_operand2->evaluateSingleton(context: bindVariable(context)); |
73 | } |
74 | |
75 | bool LetClause::evaluateEBV(const DynamicContext::Ptr &context) const |
76 | { |
77 | return m_operand2->evaluateEBV(context: bindVariable(context)); |
78 | } |
79 | |
80 | void LetClause::evaluateToSequenceReceiver(const DynamicContext::Ptr &context) const |
81 | { |
82 | m_operand2->evaluateToSequenceReceiver(context: bindVariable(context)); |
83 | } |
84 | |
85 | Expression::Ptr LetClause::typeCheck(const StaticContext::Ptr &context, |
86 | const SequenceType::Ptr &reqType) |
87 | { |
88 | /* Consider the following query: |
89 | * |
90 | * <tt>let $d := \<child type=""/> |
91 | * return $d//\*[let $i := @type |
92 | * return $d//\*[$i]]</tt> |
93 | * |
94 | * The node test <tt>@type</tt> is referenced from two different places, |
95 | * where each reference have a different focus. So, in the case of that the source |
96 | * uses the focus, we need to use a DynamicContextStore to ensure the variable |
97 | * is always evaluated with the correct focus, regardless of where it is referenced |
98 | * from. |
99 | * |
100 | * We miss out a lot of false positives. For instance, the case of where the focus |
101 | * is identical for everyone. One reason we cannot check this, is that Expression |
102 | * doesn't know about its parent. |
103 | */ |
104 | m_varDecl->canSourceRewrite = !m_operand1->deepProperties().testFlag(flag: RequiresFocus); |
105 | |
106 | if(m_varDecl->canSourceRewrite) |
107 | return m_operand2->typeCheck(context, reqType); |
108 | else |
109 | return PairContainer::typeCheck(context, reqType); |
110 | } |
111 | |
112 | Expression::Properties LetClause::properties() const |
113 | { |
114 | return m_varDecl->expression()->properties() & (Expression::RequiresFocus | Expression::IsEvaluated | Expression::DisableElimination); |
115 | } |
116 | |
117 | SequenceType::List LetClause::expectedOperandTypes() const |
118 | { |
119 | SequenceType::List result; |
120 | result.append(t: CommonSequenceTypes::ZeroOrMoreItems); |
121 | result.append(t: CommonSequenceTypes::ZeroOrMoreItems); |
122 | return result; |
123 | } |
124 | |
125 | SequenceType::Ptr LetClause::staticType() const |
126 | { |
127 | return m_operand2->staticType(); |
128 | } |
129 | |
130 | ExpressionVisitorResult::Ptr LetClause::accept(const ExpressionVisitor::Ptr &visitor) const |
131 | { |
132 | return visitor->visit(this); |
133 | } |
134 | |
135 | Expression::ID LetClause::id() const |
136 | { |
137 | return IDLetClause; |
138 | } |
139 | |
140 | QT_END_NAMESPACE |
141 | |