--- /dev/null
+//{{{ Banner
+
+//============================================================================
+//
+// infer.cxx
+//
+// Inference for common conflicts.
+//
+//============================================================================
+//####COPYRIGHTBEGIN####
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 1999, 2000, 2001 Red Hat, Inc.
+//
+// This file is part of the eCos host tools.
+//
+// This program is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 2 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// ----------------------------------------------------------------------------
+//
+//####COPYRIGHTEND####
+//============================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s): bartv
+// Contact(s): bartv
+// Date: 1999/11/1
+// Version: 0.01
+//
+//####DESCRIPTIONEND####
+//============================================================================
+
+//}}}
+//{{{ #include's
+
+// ----------------------------------------------------------------------------
+#include "cdlconfig.h"
+
+// Get the infrastructure types, assertions, tracing and similar
+// facilities.
+#include <cyg/infra/cyg_ass.h>
+#include <cyg/infra/cyg_trac.h>
+
+// <cdlcore.hxx> defines everything implemented in this module.
+// It implicitly supplies <string>, <vector> and <map> because
+// the class definitions rely on these headers.
+#include <cdlcore.hxx>
+
+//}}}
+
+//{{{ CdlInfer class
+
+//{{{ Description
+
+// ----------------------------------------------------------------------------
+// The following functions provide the main entry points for inference.
+//
+// 1) bool CdlInfer::make_active(CdlTransaction, CdlValuable, level)
+// Do whatever it takes to make the valuable active in
+// a clean sub-transaction, if possible.
+// 2) bool CdlInfer::make_inactive(CdlTransaction, CdlValuable, level)
+// Do whatever it takes to make the valuable inactive.
+// 3) bool CdlInfer::set_valuable_value(CdlTransaction, CdlValuable, CdlSimpleValue&, level)
+// Try to set the valuable to the specified value, taking into
+// account the different flavors.
+// 4) bool CdlInfer::set_valuable_bool(CdlTransaction, CdlValuable, bool, level)
+// Similar to (3) but deals with the boolean aspect of the valuable
+// rather than the data part.
+// 5) bool CdlInfer::subexpr(CdlTransaction, CdlExpression, int index, CdlSimpleValue& goal, level)
+// Process a sub-expression and try to make it evaluate to the
+// goal.
+// 6) bool CdlInfer::subexpr_bool(CdlTransaction, CdlExpression, int index, bool goal, level)
+// Ditto but only deal with boolean goals. If the expression starts to
+// involve arithmetic etc. then we need to move to CdlInfer::subexpr()
+//
+// As might be expected, the sub-expression handlers contain a big
+// switch statement and calls into various auxiliary functions when
+// necessary.
+//
+// For convenience the various entry points check whether or not the
+// desired condition is already satisfied.
+
+//}}}
+//{{{ Forward declarations
+
+// ----------------------------------------------------------------------------
+
+static bool infer_handle_interface_value(CdlTransaction, CdlInterface, CdlSimpleValue&, int);
+static bool infer_handle_reference_bool(CdlTransaction, CdlValuable, bool, int);
+
+//}}}
+//{{{ CdlInfer::make_active()
+
+// ----------------------------------------------------------------------------
+// Making a node active. This requires the following conditions to be
+// satisfied:
+// 1) the parent must be made active
+// 2) if the parent has flavor bool or booldata, it must be enabled
+// 3) any active_if properties
+
+bool
+CdlInfer::make_active(CdlTransaction transaction, CdlNode node, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlInfer::make_active", "result %d");
+ CYG_REPORT_FUNCARG3XV(transaction, node, level);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(node);
+
+ bool result = false;
+ if (transaction->is_active(node)) {
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ CdlContainer parent = node->get_parent();
+ CYG_ASSERT_CLASSC(parent);
+ if (!transaction->is_active(parent)) {
+ if (!CdlInfer::make_active(transaction, parent, level)) {
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ }
+ // The parent is now active. Does it have to be enabled as well?
+ CdlValuable parent_valuable = dynamic_cast<CdlValuable>(static_cast<CdlNode>(parent));
+ if (0 != parent_valuable) {
+ CdlValueFlavor flavor = parent_valuable->get_flavor();
+ if (((CdlValueFlavor_Bool == flavor) || (CdlValueFlavor_BoolData == flavor)) &&
+ !parent_valuable->is_enabled(transaction)) {
+ if (!CdlInfer::set_valuable_bool(transaction, parent_valuable, true, level)) {
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ }
+ }
+ // The parent is now active and enabled. Are there any active_if properties to worry about?
+ CdlValuable valuable = dynamic_cast<CdlValuable>(node);
+ if (0 != valuable) {
+ std::vector<CdlProperty_GoalExpression> active_if_goals;
+ std::vector<CdlProperty_GoalExpression>::iterator goal_i;
+ valuable->get_active_if_conditions(active_if_goals);
+ for (goal_i = active_if_goals.begin(); goal_i != active_if_goals.end(); goal_i++) {
+
+ CdlEvalContext context(transaction, valuable, *goal_i);
+ try {
+ if (!(*goal_i)->eval(context)) {
+ CdlExpression expr = (*goal_i)->get_expression();
+ if (!CdlInfer::subexpr_bool(transaction, expr, expr->first_subexpression, true, level)) {
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ }
+ } catch(...) {
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ }
+
+ }
+
+ result = transaction->is_active(node);
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ CdlInfer::make_inactive()
+
+// ----------------------------------------------------------------------------
+// Making a node inactive can be done in three ways:
+// 1) if the parent is boolean, try disabling it
+// 2) otherwise if the parent can be made inactive, that will do
+// fine.
+// 3) if there are any active_if properties, they could be considered
+// as well. For now this possibility is ignored.
+
+bool
+CdlInfer::make_inactive(CdlTransaction transaction, CdlNode node, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlInfer::make_inactive", "result %d");
+ CYG_REPORT_FUNCARG3XV(transaction, node, level);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(node);
+
+ bool result = false;
+ if (!transaction->is_active(node)) {
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ CdlContainer parent = node->get_parent();
+ if (0 == parent) {
+ // No point in trying to disable the entire configuration.
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ CdlValuable parent_valuable = dynamic_cast<CdlValuable>(parent);
+ if (0 != parent_valuable) {
+ CdlValueFlavor flavor = parent_valuable->get_flavor();
+ if ((CdlValueFlavor_Bool == flavor) || (CdlValueFlavor_BoolData == flavor)) {
+ // Since the current node is active the parent must currently be enabled.
+ // A sub-transaction is needed because an alternative approach is
+ // possible later on.
+ CdlTransaction subtransaction = transaction->make(transaction->get_conflict());
+ if (CdlInfer::set_valuable_bool(subtransaction, parent_valuable, false, level)) {
+ subtransaction->commit();
+ delete subtransaction;
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ } else {
+ subtransaction->cancel();
+ delete subtransaction;
+ }
+ }
+ }
+
+ // It is not possible to disable the parent. How about making it inactive?
+ if (CdlInfer::make_inactive(transaction, parent, level)) {
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ // For now do not try to mess about with active_if conditions.
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ CdlInfer::set_valuable_value()
+
+// ----------------------------------------------------------------------------
+// Deal with the value part of a valuable. The valuable is known to exist
+// and be active, so this code only deals with the actual value part.
+
+bool
+CdlInfer::set_valuable_value(CdlTransaction transaction, CdlValuable valuable, CdlSimpleValue& goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlInfer::set_valuable_value", "result %d");
+ CYG_REPORT_FUNCARG3XV(transaction, valuable, level);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(valuable);
+ CYG_PRECONDITIONC(transaction->is_active(valuable));
+
+ bool result = false;
+
+ const CdlValue& current_value = transaction->get_whole_value(valuable);
+ CdlValueFlavor flavor = current_value.get_flavor();
+ bool bool_goal = goal.get_bool_value();
+
+ switch(flavor) {
+ default :
+ case CdlValueFlavor_None :
+ break;
+
+ case CdlValueFlavor_Bool :
+ if (bool_goal == current_value.is_enabled()) {
+ result = true;
+ } else {
+ if (valuable->is_modifiable() &&
+ (0 == dynamic_cast<CdlLoadable>(valuable)) &&
+ !transaction->changed_by_user(valuable)) {
+
+ valuable->set_enabled(transaction, bool_goal, CdlValueSource_Inferred);
+ valuable->set_source(transaction, CdlValueSource_Inferred);
+ result = transaction->resolve_recursion(level);
+ }
+
+ }
+ break;
+
+ case CdlValueFlavor_BoolData :
+ if (!bool_goal && !current_value.is_enabled()) {
+ result = true;
+ } else if (bool_goal && current_value.is_enabled() && (goal == current_value.get_simple_value())) {
+ result = true;
+ } else {
+ if (valuable->is_modifiable() &&
+ (0 == dynamic_cast<CdlLoadable>(valuable)) &&
+ !transaction->changed_by_user(valuable)) {
+
+ if (!bool_goal) {
+ valuable->disable(transaction, CdlValueSource_Inferred);
+ } else {
+ valuable->enable_and_set_value(transaction, goal, CdlValueSource_Inferred);
+ }
+ valuable->set_source(transaction, CdlValueSource_Inferred);
+ result = transaction->resolve_recursion(level);
+ } else if (0 != dynamic_cast<CdlInterface>(valuable)) {
+ // Interfaces are not directly modifiable, but their implementors are.
+ result = infer_handle_interface_value(transaction, dynamic_cast<CdlInterface>(valuable), goal, level);
+ }
+ }
+ break;
+
+ case CdlValueFlavor_Data:
+ // Now check whether or not the valuable already has the desired value
+ if (goal == current_value.get_simple_value()) {
+ result = true;
+ } else {
+ if (valuable->is_modifiable() &&
+ (0 == dynamic_cast<CdlLoadable>(valuable)) &&
+ !transaction->changed_by_user(valuable)) {
+
+ // Make the change, propagate, and perform further resolution.
+ valuable->set_value(transaction, goal, CdlValueSource_Inferred);
+ valuable->set_source(transaction, CdlValueSource_Inferred);
+ result = transaction->resolve_recursion(level);
+ } else if (0 != dynamic_cast<CdlInterface>(valuable)) {
+ // Interfaces are not directly modifiable, but their implementors are.
+ result = infer_handle_interface_value(transaction, dynamic_cast<CdlInterface>(valuable), goal, level);
+ }
+ }
+ break;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ CdlInfer::set_valuable_bool()
+
+// ----------------------------------------------------------------------------
+// Deal with the boolean part of a valuable. It is assumed that active vs.
+// inactive is dealt with elsewhere so this code only needs to worry
+// about the valuable itself.
+
+bool
+CdlInfer::set_valuable_bool(CdlTransaction transaction, CdlValuable valuable, bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlInfer::set_valuable_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, valuable, goal, level);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(valuable);
+
+ bool result = false;
+
+ // Examine the current flavor. If None or Data then the valuable
+ // is always enabled. If BoolData or Boolean then the condition
+ // may be satisfied already, otherwise an attempt must be made
+ // to change the value and see what happens.
+ CdlValueFlavor flavor = valuable->get_flavor();
+ if (CdlValueFlavor_None == flavor) {
+ if (goal) {
+ result = true;
+ }
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ if (CdlValueFlavor_Data == flavor) {
+ std::string value = valuable->get_value(transaction);
+ if (goal) {
+ if (("" != value) && ("0" != value)) {
+ result = true;
+ }
+ } else {
+ if (("" == value) || ("0" == value)) {
+ result = true;
+ }
+ }
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ CYG_ASSERTC((CdlValueFlavor_Bool == flavor) || (CdlValueFlavor_BoolData == flavor));
+ bool enabled = valuable->is_enabled(transaction);
+ if (enabled == goal) {
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ // enabled != goal, and we have a boolean or booldata item.
+ // Before we actually try making any changes, is this sensible?
+ if (!valuable->is_modifiable() ||
+ (0 != dynamic_cast<CdlLoadable>(valuable)) ||
+ transaction->changed_by_user(valuable)) {
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ // If we are about to disable a container, better check that this would
+ // not annoy the user either
+ if (!goal) {
+ CdlContainer container = dynamic_cast<CdlContainer>(valuable);
+ if ((0 != container) && transaction->subnode_changed_by_user(container)) {
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ }
+
+ // Try to change the state, propagate, and perform further resolution.
+ valuable->set_enabled(transaction, goal, CdlValueSource_Inferred);
+ valuable->set_source(transaction, CdlValueSource_Inferred);
+ result = transaction->resolve_recursion(level);
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ infer_choose()
+
+// ----------------------------------------------------------------------------
+// Given two sub-transactions which may or may not have succeeded, pick the
+// preferred one. This happens for many binary operators.
+
+static bool
+infer_lhs_preferable(CdlTransaction lhs_transaction, bool lhs_result, CdlTransaction rhs_transaction, bool rhs_result)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_choose2", "result %d");
+ CYG_REPORT_FUNCARG4XV(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+ CYG_PRECONDITIONC(lhs_result || rhs_result);
+
+ bool result = true;
+
+ if (lhs_result && !rhs_result) {
+ // Only the lhs succeeded.
+ result = true;
+ } else if (!lhs_result && rhs_result) {
+ // Only the rhs succeeded.
+ result = false;
+ } else if (lhs_result && rhs_result) {
+ // Both sides succeeded. Next check for user_confirmation.
+ bool lhs_confirm_needed = lhs_transaction->user_confirmation_required();
+ bool rhs_confirm_needed = rhs_transaction->user_confirmation_required();
+ if (lhs_confirm_needed && !rhs_confirm_needed) {
+ result = false;
+ } else if (!lhs_confirm_needed && rhs_confirm_needed) {
+ result = true;
+ } else {
+ // Neither or both of the two sides need user confirmation, so they
+ // are equal in that respect
+ if (lhs_transaction->is_preferable_to(rhs_transaction)) {
+ result = true;
+ } else {
+ result = false;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// A variant which will actually do the commits and cancels. This is
+// commonly required when doing inferences of binary operators.
+static bool
+infer_choose2(CdlTransaction lhs_transaction, bool lhs_result, CdlTransaction rhs_transaction, bool rhs_result)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_choose2", "result %d");
+ CYG_REPORT_FUNCARG4XV(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+ bool result = false;
+
+ if (lhs_result || rhs_result) {
+ bool lhs_preferable = infer_lhs_preferable(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+ if (lhs_preferable) {
+ rhs_transaction->cancel();
+ lhs_transaction->commit();
+ } else {
+ lhs_transaction->cancel();
+ rhs_transaction->commit();
+ }
+ result = true;
+ } else {
+ // Neither side succeeded.
+ lhs_transaction->cancel();
+ rhs_transaction->cancel();
+ }
+
+ // Zero or one of these transactions will have been committed,
+ // neither is still necessary.
+ delete lhs_transaction;
+ delete rhs_transaction;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ infer_handle_interface()
+
+// ----------------------------------------------------------------------------
+// Set an interface to a specific value, which should be some number n.
+// If (n == 0) then all implementers must be disabled or made inactive.
+// If (n == 1) then exactly one of the implementers must be active and enabled.
+// Other combinations are not considered here, they could lead to an
+// exponential explosion.
+
+static bool
+infer_handle_interface_value(CdlTransaction transaction, CdlInterface interface, CdlSimpleValue& goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_reference_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, interface, &goal, level);
+ bool result = false;
+
+ if (goal.has_integer_value()) {
+ cdl_int real_goal = goal.get_integer_value();
+ if (real_goal == interface->get_integer_value(transaction)) {
+ result = true;
+ } else if (0 == real_goal) {
+ // All implementers must be disabled or made inactive. This
+ // can be achieved by creating a sub-transaction and calling
+ // infer_handle_reference_bool() on all of the implementers.
+ //
+ // However there are no guarantees that the result is what
+ // is intended. Updating a later implementer may as a side
+ // effect cause an earlier one to become active again. Also
+ // there may be confusion with valuables with the data
+ // flavor being given a value of 0. Hence a final check is
+ // needed that the new interface value really is the desired goal.
+ CdlTransaction sub_transaction;
+ std::vector<CdlValuable> implementers;
+ std::vector<CdlValuable>::const_iterator impl_i;
+
+ sub_transaction = transaction->make(transaction->get_conflict());
+ try {
+ interface->get_implementers(implementers);
+ for (impl_i = implementers.begin(); impl_i != implementers.end(); impl_i++) {
+ (void) infer_handle_reference_bool(sub_transaction, *impl_i, false, level);
+ }
+ if (0 == interface->get_integer_value(sub_transaction)) {
+ sub_transaction->commit();
+ result = true;
+ } else {
+ sub_transaction->cancel();
+ }
+ } catch (...) {
+ delete sub_transaction;
+ throw;
+ }
+ delete sub_transaction;
+ sub_transaction = 0;
+
+ } else if (1 == real_goal) {
+ // This is a bit trickier than the above. We need n
+ // sub-transactions, one per implementer. In each
+ // sub-transaction we try to set exactly one of the
+ // implementers to enabled and the rest to disabled.
+ std::vector<CdlValuable> implementers;
+ unsigned int impl_count;
+ unsigned int i, j;
+
+ interface->get_implementers(implementers);
+ impl_count = implementers.size();
+ std::vector<CdlTransaction> sub_transactions;
+ std::vector<bool> results;
+
+ try {
+ for (i = 0; i < impl_count; i++) {
+ CdlTransaction sub_transaction = transaction->make(transaction->get_conflict());
+ sub_transactions.push_back(sub_transaction);
+ results.push_back(false);
+ results[i] = false;
+ }
+ for (i = 0; i < impl_count; i++) {
+ for (j = 0; j < impl_count; j++) {
+ (void) infer_handle_reference_bool(sub_transactions[i], implementers[j], (i == j), level);
+ }
+ if (1 == interface->get_integer_value(sub_transactions[i])) {
+ results[i] = true;
+ }
+ }
+
+ // At this point we may have some combination of successful and unsucessful
+ // sub-transactions, and it is time to choose the best one.
+ CdlTransaction preferred = 0;
+ for (i = 0; i < impl_count; i++) {
+ if (results[i]) {
+ preferred = sub_transactions[i];
+ break;
+ }
+ }
+
+ for (j = i + 1; j < impl_count; j++) {
+ if (results[j]) {
+ if (!infer_lhs_preferable(preferred, true, sub_transactions[j], true)) {
+ preferred = sub_transactions[j];
+ }
+ }
+ }
+
+ // Now either preferred == 0, i.e. all
+ // sub-transactions failed and we want to cancel them
+ // all. Or we have a viable sub-transaction.
+ for (i = 0; i < impl_count; i++) {
+ if (preferred == sub_transactions[i]) {
+ sub_transactions[i]->commit();
+ result = true;
+ } else {
+ sub_transactions[i]->cancel();
+ }
+ delete sub_transactions[i];
+ sub_transactions[i] = 0;
+ }
+
+ } catch(...) {
+ for (i = 0; i < sub_transactions.size(); i++) {
+ if (0 != sub_transactions[i]) {
+ sub_transactions[i]->cancel();
+ delete sub_transactions[i];
+ sub_transactions[i] = 0;
+ }
+ }
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ infer_handle_reference()
+
+// ----------------------------------------------------------------------------
+// We are processing an expression and have reached a point where we
+// need <reference>, !<reference> or <reference>==<value>. The
+// reference may currently be unbound, in which case 0 is the only
+// goal that can be satisfied. If the reference is bound then it may
+// be possible to satisfy the goal by setting the value. In addition
+// it is necessary to worry about active vs. inactive state.
+
+static bool
+infer_handle_reference_bool(CdlTransaction transaction, CdlValuable valuable, bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_reference_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, valuable, goal, level);
+
+ bool result = false;
+ if (0 == valuable) {
+ if (!goal) {
+ result = true;
+ }
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ // If the valuable should evaluate to true then it must be both active
+ // and be either enabled or have a non-zero value.
+ if (goal) {
+ if (!transaction->is_active(valuable)) {
+ if (!CdlInfer::make_active(transaction, valuable, level)) {
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ }
+ if (CdlInfer::set_valuable_bool(transaction, valuable, true, level)) {
+ result = true;
+ }
+
+ } else {
+ // If the valuable should evaluate to false then it must be either
+ // inactive or it must be disabled or have a zero value.
+ if (!transaction->is_active(valuable)) {
+ // The goal is already satisfied, no need to proceed
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ // There is a choice to be made so two sub-transactions are
+ // needed. Disabling is generally preferred to making inactive.
+ CdlTransaction value_transaction = transaction->make(transaction->get_conflict());
+ CdlTransaction inactive_transaction = 0;
+ bool value_result = CdlInfer::set_valuable_bool(value_transaction, valuable, false, level);
+ if (value_result && !value_transaction->user_confirmation_required()) {
+ value_transaction->commit();
+ delete value_transaction;
+ value_transaction = 0;
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ inactive_transaction = transaction->make(transaction->get_conflict());
+ bool inactive_result = CdlInfer::make_inactive(inactive_transaction, valuable, level);
+ if (!inactive_result) {
+ if (value_result) {
+ // Changing the value is the only solution.
+ inactive_transaction->cancel();
+ value_transaction->commit();
+ result = true;
+ } else {
+ inactive_transaction->cancel();
+ value_transaction->cancel();
+ result = false;
+ }
+ } else {
+ if (!value_result) {
+ // Making the valuable inactive is the only solution.
+ value_transaction->cancel();
+ inactive_transaction->commit();
+ result = true;
+ } else if (!inactive_transaction->user_confirmation_required()) {
+ // Disabling the valuable would require user confirmation, making it inactive does not
+ value_transaction->cancel();
+ inactive_transaction->commit();
+ result = true;
+ } else {
+ // Both approaches are valid but would require user confirmation.
+ // Pick the preferred one.
+ if (value_transaction->is_preferable_to(inactive_transaction)) {
+ inactive_transaction->cancel();
+ value_transaction->commit();
+ result = true;
+ } else {
+ value_transaction->cancel();
+ inactive_transaction->commit();
+ result = true;
+ }
+ }
+ }
+
+ delete value_transaction;
+ delete inactive_transaction;
+ value_transaction = 0;
+ inactive_transaction = 0;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// Try to set a valuable to a particular value. Of course the reference
+// may not be bound yet.
+//
+// First check whether or not the valuable is currently active. If it is
+// inactive and the goal is 0 then we have succeeded. If it is active and
+// the goal is 0 then we could try to make the valuable inactive, but
+// this possibility is ignored for now in case it leads to unexpected
+// behaviour. If it is active then we try to set the value, using
+// CdlInfer::set_valuable_value().
+
+static bool
+infer_handle_reference_value(CdlTransaction transaction, CdlValuable valuable, CdlSimpleValue& goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_reference", "result %d");
+ CYG_REPORT_FUNCARG3XV(transaction, valuable, level);
+
+ bool result = false;
+
+ if (0 == valuable) {
+ if (goal == (cdl_int) 0) {
+ result = true;
+ }
+ } else {
+
+ bool active = transaction->is_active(valuable);
+ if (!active) {
+ if (goal == (cdl_int) 0) {
+ result = true;
+ }
+ } else {
+ result = CdlInfer::set_valuable_value(transaction, valuable, goal, level);
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ infer_handle_xxx_constant()
+
+// ----------------------------------------------------------------------------
+// Somewhere in the expression processing we have encountered a string
+// constant. The expression cannot be changed, so either the goal matches
+// the constant or it does not.
+static bool
+infer_handle_string_constant_bool(CdlSimpleValue& constant, bool goal)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_string_constant_bool", "result %d");
+ bool result = false;
+
+ if (goal) {
+ if (("" != constant.get_value()) && ("0" != constant.get_value())) {
+ result = true;
+ }
+ } else {
+ if (("" == constant.get_value()) || ("0" == constant.get_value())) {
+ result = true;
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+static bool
+infer_handle_string_constant_value(CdlSimpleValue& constant, CdlSimpleValue& goal)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_string_constant_value", "result %d");
+ bool result = false;
+
+ if (constant.get_value() == goal.get_value()) {
+ result = true;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// Integers are also fairly straightforward.
+static bool
+infer_handle_integer_constant_bool(CdlSimpleValue& constant, bool goal)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_integer_constant_bool", "result %d");
+ CYG_PRECONDITIONC(constant.has_integer_value());
+ bool result = false;
+
+ if (goal) {
+ if (0 != constant.get_integer_value()) {
+ result = true;
+ }
+ } else {
+ if (0 == constant.get_integer_value()) {
+ result = true;
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+static bool
+infer_handle_integer_constant_value(CdlSimpleValue& constant, CdlSimpleValue& goal)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_integer_constant_value", "result %d");
+ CYG_PRECONDITIONC(constant.has_integer_value());
+ bool result = false;
+
+ if (goal.has_integer_value() && (constant.get_integer_value() == goal.get_integer_value())) {
+ result = true;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// Doubles are also straightforward, except than an exact comparision may
+// be too strict. There is not a lot that can be done about this right now.
+// Future enhancements to CDL may support tolerances.
+static bool
+infer_handle_double_constant_bool(CdlSimpleValue& constant, bool goal)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_double_constant_bool", "result %d");
+ CYG_PRECONDITIONC(constant.has_double_value());
+ bool result = false;
+
+ if (goal) {
+ if (0.0 != constant.get_double_value()) {
+ result = true;
+ }
+ } else {
+ if (0.0 == constant.get_double_value()) {
+ result = true;
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+static bool
+infer_handle_double_constant_value(CdlSimpleValue& constant, CdlSimpleValue& goal)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_double_constant_value", "result %d");
+ CYG_PRECONDITIONC(constant.has_double_value());
+ bool result = false;
+
+ if (goal.has_double_value() && (constant.get_double_value() == goal.get_double_value())) {
+ result = true;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ infer_handle_logical_xxx()
+
+// ----------------------------------------------------------------------------
+// Logical not simply involves inverting the goal and then trying to infer
+// the rest of the sub-expression. There is little point in touching
+// the other arguments.
+static bool
+infer_handle_logical_NOT_bool(CdlTransaction transaction, CdlExpression expr, unsigned int index, bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_logical_NOT_bool", "result %d");
+
+ bool result = CdlInfer::subexpr_bool(transaction, expr, index, !goal, level);
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// Depending on the goal, we want either both sides of the AND to evaluate to
+// true, or we want one of the sides to evaluate to false.
+static bool
+infer_handle_AND_bool(CdlTransaction transaction, CdlExpression expr, unsigned int lhs, unsigned int rhs,
+ bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_AND_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, lhs, rhs);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC(lhs != rhs);
+
+ bool result = false;
+
+ if (goal) {
+ // Both sides must be true in the same transaction, in case
+ // the solutions overlap in conflicting ways. A sub-transaction
+ // is still used to avoid polluting current values if the lhs
+ // can be inferred but not the rhs.
+ CdlTransaction sub_transaction = transaction->make(transaction->get_conflict());
+ if (CdlInfer::subexpr_bool(sub_transaction, expr, lhs, true, level) &&
+ CdlInfer::subexpr_bool(sub_transaction, expr, rhs, true, level)) {
+ sub_transaction->commit();
+ result = true;
+ } else {
+ sub_transaction->cancel();
+ }
+ delete sub_transaction;
+ } else {
+ // We need to try out both sides of the OR and see which one is preferable.
+ // An optimization would be to only try the LHS, but trying both allows
+ // for a more informed choice.
+ CdlTransaction lhs_transaction = transaction->make(transaction->get_conflict());
+ CdlTransaction rhs_transaction = transaction->make(transaction->get_conflict());
+ bool lhs_result = CdlInfer::subexpr_bool(lhs_transaction, expr, lhs, false, level);
+ bool rhs_result = CdlInfer::subexpr_bool(rhs_transaction, expr, rhs, false, level);
+
+ result = infer_choose2(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// The support for the other logical operations involves basically minor
+// variants of the above.
+
+static bool
+infer_handle_OR_bool(CdlTransaction transaction, CdlExpression expr, unsigned int lhs, unsigned int rhs,
+ bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_OR_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, lhs, rhs);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC(lhs != rhs);
+
+
+ bool result = false;
+
+ if (goal) {
+ // We need to try out both sides of the OR and see which one is preferable.
+ // An optimization would be to only try the LHS, but trying both allows
+ // for a more informed choice.
+ CdlTransaction lhs_transaction = transaction->make(transaction->get_conflict());
+ CdlTransaction rhs_transaction = transaction->make(transaction->get_conflict());
+ bool lhs_result = CdlInfer::subexpr_bool(lhs_transaction, expr, lhs, true, level);
+ bool rhs_result = CdlInfer::subexpr_bool(rhs_transaction, expr, rhs, true, level);
+
+ result = infer_choose2(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+ } else {
+
+ // !(A || B) -> !A && !B
+ CdlTransaction sub_transaction = transaction->make(transaction->get_conflict());
+ if (CdlInfer::subexpr_bool(sub_transaction, expr, lhs, false, level) &&
+ CdlInfer::subexpr_bool(sub_transaction, expr, rhs, false, level)) {
+ sub_transaction->commit();
+ result = true;
+ } else {
+ sub_transaction->cancel();
+ }
+ delete sub_transaction;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+
+static bool
+infer_handle_IMPLIES_bool(CdlTransaction transaction, CdlExpression expr, unsigned int lhs, unsigned int rhs,
+ bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_implies_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, lhs, rhs);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC(lhs != rhs);
+
+
+ bool result = false;
+
+ if (goal) {
+ // A implies B -> !A || B
+ // Given a choice between !A or B, arguably the "implies"
+ // operator has the connotation that B is preferred. All other
+ // things being equal, infer_choose2() will prefer the rhs
+ // over the lhs so this is achieved automagically.
+
+ CdlTransaction lhs_transaction = transaction->make(transaction->get_conflict());
+ CdlTransaction rhs_transaction = transaction->make(transaction->get_conflict());
+ bool lhs_result = CdlInfer::subexpr_bool(lhs_transaction, expr, lhs, false, level);
+ bool rhs_result = CdlInfer::subexpr_bool(rhs_transaction, expr, rhs, true, level);
+
+ result = infer_choose2(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+
+ } else {
+
+ // !(A implies B) -> !(!A || B) -> (A && !B)
+ CdlTransaction sub_transaction = transaction->make(transaction->get_conflict());
+ if (CdlInfer::subexpr_bool(sub_transaction, expr, lhs, true, level) &&
+ CdlInfer::subexpr_bool(sub_transaction, expr, rhs, false, level)) {
+ sub_transaction->commit();
+ result = true;
+ } else {
+ sub_transaction->cancel();
+ }
+ delete sub_transaction;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+
+static bool
+infer_handle_XOR_bool(CdlTransaction transaction, CdlExpression expr, unsigned int lhs, unsigned int rhs,
+ bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_XOR_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, lhs, rhs);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC(lhs != rhs);
+
+
+ bool result = false;
+
+ if (goal) {
+ // (A xor B) -> (A && !B) || (!A && B)
+
+ CdlTransaction sub1 = transaction->make(transaction->get_conflict());
+ CdlTransaction sub2 = transaction->make(transaction->get_conflict());
+ bool result1 = (CdlInfer::subexpr_bool(sub1, expr, lhs, true, level) &&
+ CdlInfer::subexpr_bool(sub1, expr, rhs, false, level));
+ bool result2 = (CdlInfer::subexpr_bool(sub2, expr, lhs, false, level) &&
+ CdlInfer::subexpr_bool(sub2, expr, rhs, true, level));
+
+ result = infer_choose2(sub1, result1, sub2, result2);
+
+ } else {
+
+ // !(A xor B) -> (!A && !B) || (A && B)
+ CdlTransaction sub1 = transaction->make(transaction->get_conflict());
+ CdlTransaction sub2 = transaction->make(transaction->get_conflict());
+ bool result1 = (CdlInfer::subexpr_bool(sub1, expr, lhs, false, level) &&
+ CdlInfer::subexpr_bool(sub1, expr, rhs, false, level));
+ bool result2 = (CdlInfer::subexpr_bool(sub2, expr, lhs, true, level) &&
+ CdlInfer::subexpr_bool(sub2, expr, rhs, true, level));
+
+ result = infer_choose2(sub1, result1, sub2, result2);
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+
+static bool
+infer_handle_EQV_bool(CdlTransaction transaction, CdlExpression expr, unsigned int lhs, unsigned int rhs,
+ bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_EQV_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, lhs, rhs);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC(lhs != rhs);
+
+
+ bool result = false;
+
+ if (goal) {
+ // (A eqv B) -> (A && B) || (!A && !B)
+
+ CdlTransaction sub1 = transaction->make(transaction->get_conflict());
+ CdlTransaction sub2 = transaction->make(transaction->get_conflict());
+ bool result1 = (CdlInfer::subexpr_bool(sub1, expr, lhs, true, level) &&
+ CdlInfer::subexpr_bool(sub1, expr, rhs, true, level));
+ bool result2 = (CdlInfer::subexpr_bool(sub2, expr, lhs, false, level) &&
+ CdlInfer::subexpr_bool(sub2, expr, rhs, false, level));
+
+ result = infer_choose2(sub1, result1, sub2, result2);
+ } else {
+ // !(A eqv B) -> (A && !B) || (!A && B)
+
+ CdlTransaction sub1 = transaction->make(transaction->get_conflict());
+ CdlTransaction sub2 = transaction->make(transaction->get_conflict());
+ bool result1 = (CdlInfer::subexpr_bool(sub1, expr, lhs, true, level) &&
+ CdlInfer::subexpr_bool(sub1, expr, rhs, false, level));
+ bool result2 = (CdlInfer::subexpr_bool(sub2, expr, lhs, false, level) &&
+ CdlInfer::subexpr_bool(sub2, expr, rhs, true, level));
+
+ result = infer_choose2(sub1, result1, sub2, result2);
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ infer_handle_Equal()
+
+// ----------------------------------------------------------------------------
+// Handle expressions of the form A == B. This can be achieved either by
+// evaluating B and trying to assign the result to A, or vice versa. There
+// is a problem if assigning to one side has a side effect on the other, e.g.
+//
+// requires { xyzzy == (xyzzy + 3) }
+//
+// This has to be guarded against by reevaluating the expression.
+//
+// At present this code only copes with equality, not inequality.
+
+static bool
+infer_handle_equal_bool(CdlTransaction transaction, CdlExpression expr, unsigned int lhs, unsigned int rhs, bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_equal_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, lhs, rhs);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC(lhs != rhs);
+
+ bool result = false;
+ if (goal) {
+
+ // We need two sub-transactions, The lhs_transaction is for evaluating the lhs
+ // and trying to update the rhs.
+ CdlTransaction lhs_transaction = transaction->make(transaction->get_conflict());
+ bool lhs_result = false;
+ try {
+ CdlSimpleValue lhs_value;
+ CdlEvalContext lhs_context(lhs_transaction);
+ expr->eval_subexpression(lhs_context, lhs, lhs_value);
+ lhs_result = CdlInfer::subexpr_value(lhs_transaction, expr, rhs, lhs_value, level);
+ if (lhs_result) {
+ CdlSimpleValue check;
+ expr->eval_subexpression(lhs_context, lhs, check);
+ if (lhs_value != check) {
+ lhs_result = false;
+ }
+ }
+ } catch (...) {
+ lhs_result = false;
+ }
+
+ CdlTransaction rhs_transaction = transaction->make(transaction->get_conflict());
+ bool rhs_result = false;
+ try {
+ CdlSimpleValue rhs_value;
+ CdlEvalContext rhs_context(rhs_transaction);
+ expr->eval_subexpression(rhs_context, rhs, rhs_value);
+ rhs_result = CdlInfer::subexpr_value(rhs_transaction, expr, lhs, rhs_value, level);
+ if (rhs_result) {
+ CdlSimpleValue check;
+ expr->eval_subexpression(rhs_context, rhs, check);
+ if (rhs_value != check) {
+ rhs_result = false;
+ }
+ }
+ } catch (...) {
+ rhs_result = false;
+ }
+
+ result = infer_choose2(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ infer_handle_numerical_equal()
+
+// ----------------------------------------------------------------------------
+// Handle expressions of the form A == B, where the comparison has to be
+// numerical in basis. This is used primarily for operators like <=
+// and >.
+
+static bool
+infer_handle_numerical_equal_bool(CdlTransaction transaction, CdlExpression expr, unsigned int lhs, unsigned int rhs, bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("infer_handle_numerical_equal_bool", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, lhs, rhs);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC(lhs != rhs);
+
+ bool result = false;
+ if (goal) {
+
+ // We need two sub-transactions, The lhs_transaction is for evaluating the lhs
+ // and trying to update the rhs.
+ CdlTransaction lhs_transaction = transaction->make(transaction->get_conflict());
+ bool lhs_result = false;
+ try {
+ CdlSimpleValue lhs_value;
+ CdlEvalContext lhs_context(lhs_transaction);
+ expr->eval_subexpression(lhs_context, lhs, lhs_value);
+ if (lhs_value.has_integer_value() || lhs_value.has_double_value()) {
+ lhs_result = CdlInfer::subexpr_value(lhs_transaction, expr, rhs, lhs_value, level);
+ if (lhs_result) {
+ CdlSimpleValue check;
+ expr->eval_subexpression(lhs_context, lhs, check);
+ if (lhs_value != check) {
+ lhs_result = false;
+ }
+ }
+ }
+ } catch (...) {
+ lhs_result = false;
+ }
+
+ CdlTransaction rhs_transaction = transaction->make(transaction->get_conflict());
+ bool rhs_result = false;
+ try {
+ CdlSimpleValue rhs_value;
+ CdlEvalContext rhs_context(rhs_transaction);
+ expr->eval_subexpression(rhs_context, rhs, rhs_value);
+ if (rhs_value.has_integer_value() || rhs_value.has_double_value()) {
+ rhs_result = CdlInfer::subexpr_value(rhs_transaction, expr, lhs, rhs_value, level);
+ if (rhs_result) {
+ CdlSimpleValue check;
+ expr->eval_subexpression(rhs_context, rhs, check);
+ if (rhs_value != check) {
+ rhs_result = false;
+ }
+ }
+ }
+ } catch (...) {
+ rhs_result = false;
+ }
+
+ result = infer_choose2(lhs_transaction, lhs_result, rhs_transaction, rhs_result);
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ CdlInfer::subexpr_bool()
+
+// ----------------------------------------------------------------------------
+bool
+CdlInfer::subexpr_bool(CdlTransaction transaction, CdlExpression expr, unsigned int index, bool goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlInfer::subexpr_bool", "result %d");
+ CYG_REPORT_FUNCARG5XV(transaction, expr, index, goal, level);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC((0 <= index) && (index < expr->sub_expressions.size()));
+
+ bool result = false;
+ CdlSubexpression& subexpr = expr->sub_expressions[index];
+
+ switch(subexpr.op) {
+
+ case CdlExprOp_Reference :
+ // The most common case. Follow the reference, and call the appropriate function.
+ // Note that the reference may be unbound.
+ {
+ CdlNode node = expr->references[subexpr.reference_index].get_destination();
+ CdlValuable valuable = 0;
+ if (0 != node) {
+ valuable = dynamic_cast<CdlValuable>(node);
+ }
+ result = infer_handle_reference_bool(transaction, valuable, goal, level);
+ break;
+ }
+
+ case CdlExprOp_StringConstant :
+ result = infer_handle_string_constant_bool(subexpr.constants, goal);
+ break;
+
+ case CdlExprOp_IntegerConstant :
+ result = infer_handle_integer_constant_bool(subexpr.constants, goal);
+ break;
+
+ case CdlExprOp_DoubleConstant :
+ result = infer_handle_double_constant_bool(subexpr.constants, goal);
+ break;
+
+ case CdlExprOp_LogicalNot :
+ result = infer_handle_logical_NOT_bool(transaction, expr, subexpr.lhs_index, goal, level);
+ break;
+
+ case CdlExprOp_And :
+ result = infer_handle_AND_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, goal, level);
+ break;
+
+ case CdlExprOp_Or :
+ result = infer_handle_OR_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, goal, level);
+ break;
+
+ case CdlExprOp_Implies :
+ result = infer_handle_IMPLIES_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, goal, level);
+ break;
+
+ case CdlExprOp_Xor :
+ result = infer_handle_XOR_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, goal, level);
+ break;
+
+ case CdlExprOp_Eqv :
+ result = infer_handle_EQV_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, goal, level);
+ break;
+
+ case CdlExprOp_Equal :
+ result = infer_handle_equal_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, goal, level);
+ break;
+
+ case CdlExprOp_NotEqual :
+ result = infer_handle_equal_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, !goal, level);
+ break;
+
+ // <= is satisfied by a numerical equality. However the inverse relation > cannot be handled that way
+ // The other comparison operators are much the same.
+ case CdlExprOp_LessEqual :
+ case CdlExprOp_GreaterEqual :
+ if (goal) {
+ result = infer_handle_numerical_equal_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, true, level);
+ }
+ break;
+
+ case CdlExprOp_LessThan :
+ case CdlExprOp_GreaterThan :
+ if (!goal) {
+ result = infer_handle_numerical_equal_bool(transaction, expr, subexpr.lhs_index, subexpr.rhs_index, true, level);
+ }
+ break;
+
+ case CdlExprOp_Function :
+ result = CdlFunction::infer_bool(transaction, expr, index, goal, level);
+ break;
+
+ default:
+ // No other inferences are implemented at this stage.
+ break;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ CdlInfer::subexpr_value()
+
+bool
+CdlInfer::subexpr_value(CdlTransaction transaction, CdlExpression expr, unsigned int index, CdlSimpleValue& goal, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlInfer::subexpr_value", "result %d");
+ CYG_REPORT_FUNCARG4XV(transaction, expr, index, level);
+ CYG_PRECONDITION_CLASSC(transaction);
+ CYG_PRECONDITION_CLASSC(expr);
+ CYG_PRECONDITIONC((0 <= index) && (index < expr->sub_expressions.size()));
+
+ bool result = false;
+ CdlSubexpression& subexpr = expr->sub_expressions[index];
+
+ switch(subexpr.op) {
+
+ case CdlExprOp_Reference :
+ // The most common case. Follow the reference, and call the appropriate function.
+ // Note that the reference may be unbound.
+ {
+ CdlNode node = expr->references[subexpr.reference_index].get_destination();
+ CdlValuable valuable = 0;
+ if (0 != node) {
+ valuable = dynamic_cast<CdlValuable>(node);
+ }
+ result = infer_handle_reference_value(transaction, valuable, goal, level);
+ break;
+ }
+
+ case CdlExprOp_StringConstant :
+ result = infer_handle_string_constant_value(subexpr.constants, goal);
+ break;
+
+ case CdlExprOp_IntegerConstant :
+ result = infer_handle_integer_constant_value(subexpr.constants, goal);
+ break;
+
+ case CdlExprOp_DoubleConstant :
+ result = infer_handle_double_constant_value(subexpr.constants, goal);
+ break;
+
+ case CdlExprOp_LogicalNot :
+ case CdlExprOp_And :
+ case CdlExprOp_Or :
+ case CdlExprOp_Implies :
+ case CdlExprOp_Xor :
+ case CdlExprOp_Eqv :
+ {
+ bool new_goal = true;
+ if (("0" == goal.get_value()) || ("" == goal.get_value())) {
+ new_goal = false;
+ }
+ result = CdlInfer::subexpr_bool(transaction, expr, index, new_goal, level);
+ break;
+ }
+
+ case CdlExprOp_Function :
+ result = CdlFunction::infer_value(transaction, expr, index, goal, level);
+ break;
+
+ default:
+ // No other inferences are implemented at this stage.
+ break;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+
+//}}}
+//{{{ Illegal value resolution
+
+// ----------------------------------------------------------------------------
+// This is not yet implemented.
+
+bool
+CdlConflict_IllegalValueBody::inner_resolve(CdlTransaction transaction, int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlConflict_IllegalValue::inner_resolve", "result %d");
+ CYG_REPORT_FUNCARG3XV(this, transaction, level);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(transaction);
+
+ CYG_UNUSED_PARAM(CdlTransaction, transaction);
+
+ CYG_REPORT_RETVAL(false);
+ return false;
+}
+
+//}}}
+//{{{ Requires resolution
+
+// ----------------------------------------------------------------------------
+// The entry point for this code is
+// CdlConflict_RequiresBody::resolve(). "this" is a requires conflict
+// that needs to be resolved, if possible. There are twos argument: a
+// sub-transaction, which should be filled in with the solution if
+// possible; and a recursion level indicator, 0 if this is a top-level
+// inference engine invocation rather than a recursive one. There are
+// additional static parameters inference_recursion_limit and
+// inference_override which control details of the inference process.
+//
+// As an example of what is involved in an inference, consider the
+// simple case of a "requires XXX" property. This constraint may not
+// be satisfied because XXX is disabled, because XXX is inactive,
+// or both.
+//
+// Assume for simplicity that XXX is already active. The inference
+// engine can now figure out that XXX must be enabled (it must be
+// of type bool or booldata, or else the conflict would not have
+// arisen). This is achieved by creating a sub-transaction,
+// enabling XXX in that sub-transaction, propagating the
+// sub-transaction and performing further inference. The inference
+// is successfull if no new conflicts are introduced.
+//
+// However, even if a solution is found it is not necessarily
+// acceptable without user confirmation, subject to
+// inference_override. This is handled in part by the transaction
+// class itself, in the resolve() and user_confirmation_required()
+// members. In cases where the inference engine can choose between
+// several alternatives it needs to consider this issue for each one.
+// Resolving a requires conflict. There are three ways of tackling
+// this problem, in order of preference:
+//
+// 1) change the terms in the expression to make it evaluate to
+// true.
+// 2) disable the source so that the requires property is no longer
+// relevant.
+// 3) make the source inactive, with the same effect.
+//
+// The first one should always be tried. If it is entirely successful
+// then there is no point in looking any further. If user confirmation
+// is required then the second approach should be tried. If that is
+// entirely successful then there is no point in looking further.
+// If user confirmation is required then the third approach should
+// be tried.
+
+bool
+CdlConflict_RequiresBody::inner_resolve(CdlTransaction transaction, int level)
+{
+ CYG_REPORT_FUNCNAME("CdlConflict_Requires::inner_resolve");
+ CYG_REPORT_FUNCARG3XV(this, transaction, level);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(transaction);
+
+ bool result = false;
+
+ CdlProperty_GoalExpression gexpr = dynamic_cast<CdlProperty_GoalExpression>(this->get_property());
+ CdlExpression expr = gexpr->get_expression();
+
+ // Only create the sub-transactions when needed.
+ CdlTransaction expr_transaction = 0;
+ CdlTransaction disable_transaction = 0;
+ CdlTransaction inactive_transaction = 0;
+
+ // Keep track of the preferred solution found to date.
+ CdlTransaction preferred_transaction = 0;
+
+ expr_transaction = transaction->make(this);
+ if (!CdlInfer::subexpr_bool(expr_transaction, expr, expr->first_subexpression, true, level)) {
+ // No luck here.
+ expr_transaction->cancel();
+ delete expr_transaction;
+ expr_transaction = 0;
+ } else {
+ // We have a possible solution. How acceptable is it?
+ if (!expr_transaction->user_confirmation_required()) {
+ // Whoopee.
+ expr_transaction->commit();
+ delete expr_transaction;
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ } else {
+ // Maybe we can do better.
+ preferred_transaction = expr_transaction;
+ expr_transaction = 0;
+ }
+ }
+
+ // Disabling the source only makes sense if we have a bool or booldata item.
+ CdlValuable valuable = dynamic_cast<CdlValuable>(this->get_node());
+ CYG_ASSERT_CLASSC(valuable);
+
+ if ((CdlValueFlavor_Bool == valuable->get_flavor()) || (CdlValueFlavor_BoolData == valuable->get_flavor())) {
+ disable_transaction = transaction->make(this);
+ if (!CdlInfer::set_valuable_bool(disable_transaction, valuable, false, level)) {
+ // No luck here either.
+ disable_transaction->cancel();
+ delete disable_transaction;
+ disable_transaction = 0;
+ } else {
+ if (!disable_transaction->user_confirmation_required()) {
+ disable_transaction->commit();
+ delete disable_transaction;
+ if (0 != preferred_transaction) {
+ preferred_transaction->cancel();
+ delete preferred_transaction;
+ preferred_transaction = 0;
+ }
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ } else if (0 == preferred_transaction) {
+ preferred_transaction = disable_transaction;
+ } else if (!preferred_transaction->is_preferable_to(disable_transaction)) {
+ preferred_transaction->cancel();
+ delete preferred_transaction;
+ preferred_transaction = disable_transaction;
+ disable_transaction = 0;
+ } else {
+ disable_transaction->cancel();
+ delete disable_transaction;
+ disable_transaction = 0;
+ }
+ }
+ }
+
+ // Now try for the inactive approach. This may work in cases where the disable
+ // approach does not if e.g. there are dependencies between two nodes in the
+ // same container, or if the source of the conflict is not boolean.
+ inactive_transaction = transaction->make(this);
+ if (!CdlInfer::make_inactive(inactive_transaction, valuable, level)) {
+ inactive_transaction->cancel();
+ delete inactive_transaction;
+ inactive_transaction = 0;
+ } else {
+ if (!inactive_transaction->user_confirmation_required()) {
+ inactive_transaction->commit();
+ delete inactive_transaction;
+ if (0 != preferred_transaction) {
+ preferred_transaction->cancel();
+ delete preferred_transaction;
+ preferred_transaction = 0;
+ }
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ } else if (0 == preferred_transaction) {
+ preferred_transaction = inactive_transaction;
+ } else if (!preferred_transaction->is_preferable_to(inactive_transaction)) {
+ preferred_transaction->cancel();
+ delete preferred_transaction;
+ preferred_transaction = inactive_transaction;
+ inactive_transaction = 0;
+ } else {
+ inactive_transaction->cancel();
+ delete inactive_transaction;
+ inactive_transaction = 0;
+ }
+ }
+
+ // Is there any solution at all? If so then use the currently-preferred one.
+ if (0 != preferred_transaction) {
+ preferred_transaction->commit();
+ delete preferred_transaction;
+ preferred_transaction = 0;
+ result = true;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
projects / karo-tx-redboot.git / blobdiff