···

       
1555
       
 
       
      assert(var->definitions().back() == con);

     

       
1556
       
 
       
      var->_definitions.pop_back();

     

       
1557
       
 
       
    } else {

     

       
1558
       
-
       
      assert(false);

     

       
1559
       
 
       
    }

     

       
1560
       
 
       
    def_trail.pop_back();

     

       
1561
       
 
       
  }

     

···

       
1555
       
 
       
      assert(var->definitions().back() == con);

     

       
1556
       
 
       
      var->_definitions.pop_back();

     

       
1557
       
 
       
    } else {

     

       
1558
       
+
       
      var->_definitions.push_back(con);

     

       
1559
       
 
       
    }

     

       
1560
       
 
       
    def_trail.pop_back();

     

       
1561
       
 
       
  }

     

···

       
346
       
 
       
  _subscriptions.clear();

     

       
347
       
 
       


     

       
348
       
 
       
  // Set Alias

     

       
349
       
-
       
  interpreter->trail.trail_alias(interpreter, this);

     

       
350
       
 
       
  _aliased = true;

     

       
351
       
 
       
  _domain = v;

     

       
352
       
 
       
  v.addRef(interpreter);

     

       
0
       
 
       

     

       
353
       
 
       
}

     

       
354
       
 
       


     

       
355
       
 
       
void Variable::unalias(Interpreter* interpreter, Val dom) {

     

···

       
346
       
 
       
  _subscriptions.clear();

     

       
347
       
 
       


     

       
348
       
 
       
  // Set Alias

     

       
0
       
 
       

     

       
349
       
 
       
  _aliased = true;

     

       
350
       
 
       
  _domain = v;

     

       
351
       
 
       
  v.addRef(interpreter);

     

       
352
       
+
       
  interpreter->trail.trail_alias(interpreter, this);

     

       
353
       
 
       
}

     

       
354
       
 
       


     

       
355
       
 
       
void Variable::unalias(Interpreter* interpreter, Val dom) {

     

···

       
817
       
 
       
  }

     

       
818
       
 
       
  flatten_time = tm01.s();

     

       
819
       
 
       
  // FIXME: Global registers should not be removed, merely hidden

     

       
820
       
-
       
  interpreter->clear_globals();

     

       
821
       
 
       
  if (verbose) {

     

       
822
       
 
       
    std::cerr << "Status: " << Interpreter::status_to_string[interpreter->status()] << std::endl;

     

       
823
       
 
       
    if (interpreter->status() == Interpreter::ROGER) {

     

···

       
817
       
 
       
  }

     

       
818
       
 
       
  flatten_time = tm01.s();

     

       
819
       
 
       
  // FIXME: Global registers should not be removed, merely hidden

     

       
820
       
+
       
  // interpreter->clear_globals();

     

       
821
       
 
       
  if (verbose) {

     

       
822
       
 
       
    std::cerr << "Status: " << Interpreter::status_to_string[interpreter->status()] << std::endl;

     

       
823
       
 
       
    if (interpreter->status() == Interpreter::ROGER) {

     

···

       
38
       
 
       
      gi._current_space->iv_defined.push_back(!var->definitions().empty());

     

       
39
       
 
       
    }

     

       
40
       
 
       
  } else {

     

       
41
       
-
       
    IntVar intVar(*gi._current_space, Gecode::Int::Limits::min, Gecode::Int::Limits::max);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
42
       
 
       
    gi._current_space->iv.push_back(intVar);

     

       
43
       
 
       
    gi.insertVar(var, GecodeVariable(GecodeVariable::INT_TYPE, gi._current_space->iv.size() - 1));

     

       
44
       
 
       
    std::cerr << "% GecodeSolverInstance::processFlatZinc: Warning: Unbounded variable "

     

···

       
38
       
 
       
      gi._current_space->iv_defined.push_back(!var->definitions().empty());

     

       
39
       
 
       
    }

     

       
40
       
 
       
  } else {

     

       
41
       
+
       
    IntVar intVar(*gi._current_space,

     

       
42
       
+
       
                  var->lb().isFinite() ? var->lb().toInt() : Gecode::Int::Limits::min,

     

       
43
       
+
       
                  var->ub().isFinite() ? var->ub().toInt() : Gecode::Int::Limits::max);

     

       
44
       
 
       
    gi._current_space->iv.push_back(intVar);

     

       
45
       
 
       
    gi.insertVar(var, GecodeVariable(GecodeVariable::INT_TYPE, gi._current_space->iv.size() - 1));

     

       
46
       
 
       
    std::cerr << "% GecodeSolverInstance::processFlatZinc: Warning: Unbounded variable "

     

···

       
1152
       
 
       
    if (val.isInt() && val >= 0 && val <= 1) {

     

       
1153
       
 
       
      continue;

     

       
1154
       
 
       
    } else if (val.isVar()) {

     

       
1155
       
-
       
      if (val.lb().toInt() >= 0 && val.ub().toInt() <= 1) {

     

       
1156
       
 
       
        continue;

     

       
1157
       
 
       
      }

     

       
1158
       
 
       
      return false;

     

···

       
1152
       
 
       
    if (val.isInt() && val >= 0 && val <= 1) {

     

       
1153
       
 
       
      continue;

     

       
1154
       
 
       
    } else if (val.isVar()) {

     

       
1155
       
+
       
      if (val.lb() >= Val(int(0)) && val.ub() <= Val(int(1))) {

     

       
1156
       
 
       
        continue;

     

       
1157
       
 
       
      }

     

       
1158
       
 
       
      return false;