Expression::Ptr OrderBy::typeCheck(const StaticContext::Ptr &context, const SequenceType::Ptr &reqType) { m_returnOrderBy->setStay(true); /* It's important we do the typeCheck() before calling OrderSpec::prepare(), since * atomizers must first be inserted. */ const Expression::Ptr me(SingleContainer::typeCheck(context, reqType)); const Expression::List ops(m_returnOrderBy->operands()); const int len = ops.count(); Q_ASSERT(ops.count() > 1); Q_ASSERT(m_orderSpecs.count() == ops.count() - 1); for(int i = 1; i < len; ++i) m_orderSpecs[i - 1].prepare(ops.at(i), context); return me; /* It's not meaningful to sort a single item or less, so rewrite ourselves * away if that is the case. This is an optimization. */ /* TODO: How do we remove ReturnOrderBy? if(Cardinality::zeroOrOne().isMatch(m_operand->staticType()->cardinality())) return m_operand->typeCheck(context, reqType); else return SingleContainer::typeCheck(context, reqType); */ }
Expression::Ptr ElementConstructor::typeCheck(const StaticContext::Ptr &context, const SequenceType::Ptr &reqType) { /* What does this code do? When type checking our children, our namespace * bindings, which are also children of the form of NamespaceConstructor * instances, must be statically in-scope for them, so find them and * shuffle their bindings into the StaticContext. */ m_staticBaseURI = context->baseURI(); /* Namespace declarations changes the in-scope bindings, so let's * first lookup our child NamespaceConstructors. */ const ID operandID = m_operand2->id(); NamespaceResolver::Bindings overrides; if(operandID == IDExpressionSequence) { const Expression::List operands(m_operand2->operands()); const int len = operands.count(); for(int i = 0; i < len; ++i) { if(operands.at(i)->is(IDNamespaceConstructor)) { const QXmlName &nb = operands.at(i)->as<NamespaceConstructor>()->namespaceBinding(); overrides.insert(nb.prefix(), nb.namespaceURI()); } } } const NamespaceResolver::Ptr newResolver(new DelegatingNamespaceResolver(context->namespaceBindings(), overrides)); const StaticContext::Ptr augmented(new StaticNamespaceContext(newResolver, context)); return PairContainer::typeCheck(augmented, reqType); }
void TripleContainer::setOperands(const Expression::List &ops) { Q_ASSERT(ops.count() == 3); m_operand1 = ops.first(); m_operand2 = ops.at(1); m_operand3 = ops.at(2); }
Expression::Ptr ElementConstructor::typeCheck(const StaticContext::Ptr &context, const SequenceType::Ptr &reqType) { m_staticBaseURI = context->baseURI(); /* Namespace declarations changes the in-scope bindings, so let's * first lookup our child NamespaceConstructors. */ const ID operandID = m_operand2->id(); NamespaceResolver::Bindings overrides; if(operandID == IDExpressionSequence) { const Expression::List operands(m_operand2->operands()); const int len = operands.count(); for(int i = 0; i < len; ++i) { if(operands.at(i)->is(IDNamespaceConstructor)) { const QXmlName &nb = operands.at(i)->as<NamespaceConstructor>()->namespaceBinding(); overrides.insert(nb.prefix(), nb.namespaceURI()); } } } const NamespaceResolver::Ptr newResolver(new DelegatingNamespaceResolver(context->namespaceBindings(), overrides)); const StaticContext::Ptr augmented(new StaticNamespaceContext(newResolver, context)); return PairContainer::typeCheck(augmented, reqType); }
void PairContainer::setOperands(const Expression::List &ops) { Q_ASSERT(ops.count() == 2); m_operand1 = ops.first(); m_operand2 = ops.last(); Q_ASSERT(m_operand1); Q_ASSERT(m_operand2); }
Expression::Ptr ExpressionSequence::compress(const StaticContext::Ptr &context) { const Expression::Ptr me(UnlimitedContainer::compress(context)); if(me != this) return me; Expression::List::const_iterator it(m_operands.constBegin()); const Expression::List::const_iterator end(m_operands.constEnd()); Expression::List result; for(; it != end; ++it) { const ID Id = (*it)->id(); /* Remove empty sequences. This is rather important because we have some steps in the parser that * intentionally, unconditionally and for temporary reasons create expressions like (expr, ()). Of course, * empty sequences also occur as part of optimizations. * * User function call sites that are of type empty-sequence() must be avoided since * they may contain calls to fn:error(), which we would rewrite away otherwise. */ if(Id != IDUserFunctionCallsite && (*it)->staticType()->cardinality().isEmpty()) { /* Rewrite "(1, (), 2)" into "(1, 2)" by not * adding (*it) to result. */ continue; } else if(Id == IDExpressionSequence) { /* Rewrite "(1, (2, 3), 4)" into "(1, 2, 3, 4)" */ Expression::List::const_iterator seqIt((*it)->operands().constBegin()); const Expression::List::const_iterator seqEnd((*it)->operands().constEnd()); for(; seqIt != seqEnd; ++seqIt) result.append(*seqIt); } else result.append(*it); } if(result.isEmpty()) return EmptySequence::create(this, context); else if(result.count() == 1) return result.first(); else { m_operands = result; return me; } }
Expression::Ptr AbstractFunctionFactory::createFunctionCall(const QXmlName name, const Expression::List &args, const StaticContext::Ptr &context, const SourceLocationReflection *const r) { const FunctionSignature::Ptr sign(retrieveFunctionSignature(context->namePool(), name)); if(!sign) /* The function doesn't exist(at least not in this factory). */ return Expression::Ptr(); /* May throw. */ verifyArity(sign, context, args.count(), r); /* Ok, the function does exist and the arity is correct. */ return retrieveExpression(name, args, sign); }
void SingleContainer::setOperands(const Expression::List &ops) { Q_ASSERT(ops.count() == 1); m_operand = ops.first(); }
ExpressionSequence::ExpressionSequence(const Expression::List &ops) : UnlimitedContainer(ops) { Q_ASSERT_X(1 < ops.count(), Q_FUNC_INFO, "It makes no sense to have an ExpressionSequence containing less than two expressions."); }
Expression::Ptr Expression::invokeOptimizers(const Expression::Ptr &expr, const StaticContext::Ptr &context) { Q_ASSERT(expr); const OptimizationPass::List opts(expr->optimizationPasses()); if(opts.isEmpty()) /* Early exit. */ { return expr; } const OptimizationPass::List::const_iterator passEnd(opts.constEnd()); const OptimizationPass::List::const_iterator end(opts.constEnd()); OptimizationPass::List::const_iterator passIt(opts.constBegin()); for(; passIt != passEnd; ++passIt) /* Invoke each optimization pass. */ { const OptimizationPass::Ptr pass(*passIt); /* Alias, for readability. */ OptimizationPass::ExpressionMarker sourceMarker(pass->sourceExpression); if(pass->startIdentifier && !pass->startIdentifier->matches(expr)) { /* This pass specified a start identifier and it did * not match -- let's try the next OptimizationPass. */ continue; } const ExpressionIdentifier::List::const_iterator idEnd(pass->operandIdentifiers.constEnd()); ExpressionIdentifier::List::const_iterator idIt(pass->operandIdentifiers.constBegin()); const Expression::List ops(expr->operands()); const Expression::List::const_iterator opEnd(ops.constEnd()); Expression::List::const_iterator opIt(ops.constBegin()); switch(pass->operandsMatchMethod) { case OptimizationPass::Sequential: { for(; opIt != opEnd; ++opIt) { const Expression::Ptr operand(*opIt); /* Alias, for readability. */ const ExpressionIdentifier::Ptr opIdentifier(*idIt); /* Alias, for readability. */ if(opIdentifier && !opIdentifier->matches(operand)) { break; } ++idIt; } if(opIt == opEnd) break; /* All operands matched, so this pass matched. */ else { /* The loop above did not finish which means all operands did not match. Therefore, this OptimizationPass did not match -- let's try the next one. */ continue; } } case OptimizationPass::AnyOrder: { Q_ASSERT_X(ops.count() == 2, Q_FUNC_INFO, "AnyOrder is currently only supported for Expressions with two operands."); if(pass->operandIdentifiers.first()->matches(ops.first()) && pass->operandIdentifiers.last()->matches(ops.last())) { break; } else if(pass->operandIdentifiers.first()->matches(ops.last()) && pass->operandIdentifiers.last()->matches(ops.first())) { sourceMarker.first() = 1; sourceMarker[1] = 0; break; /* This pass matched. */ } else continue; /* This pass didn't match, let's loop through the next pass. */ } } /* Figure out the source Expression, if any. */ Expression::List operands; Expression::Ptr sourceExpr; if(!sourceMarker.isEmpty()) { const OptimizationPass::ExpressionMarker::const_iterator mEnd(sourceMarker.constEnd()); OptimizationPass::ExpressionMarker::const_iterator mIt(sourceMarker.constBegin()); sourceExpr = expr; for(; mIt != mEnd; ++mIt) { Q_ASSERT(*mIt >= 0); sourceExpr = sourceExpr->operands().at(*mIt); } operands.append(sourceExpr); } if(operands.isEmpty()) { Q_ASSERT(pass->resultCreator); return pass->resultCreator->create(Expression::List(), context, expr.data())->compress(context); } else if(pass->resultCreator) return pass->resultCreator->create(operands, context, expr.data())->compress(context); else { return sourceExpr; } } return expr; }