void CallTargetDescription::checkArgumentsCircularity(CallTargetDescription::List &signList, const Expression::Ptr callsite) { /* Check the arguments. */ const Expression::List ops(callsite->operands()); const Expression::List::const_iterator end(ops.constEnd()); Expression::List::const_iterator it(ops.constBegin()); for(; it != end; ++it) checkCallsiteCircularity(signList, *it); }
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; }