src/share/vm/runtime/globals.cpp

*** 513,522 ****
--- 513,536 ----
    } else {
      ShouldNotReachHere();
    }
  }
  
+ const char* Flag::flag_error_str(Flag::Error error) {
+   switch (error) {
+     case Flag::MISSING_NAME: return "MISSING_NAME";
+     case Flag::MISSING_VALUE: return "MISSING_VALUE";
+     case Flag::NON_WRITABLE: return "NON_WRITABLE";
+     case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS";
+     case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT";
+     case Flag::INVALID_FLAG: return "INVALID_FLAG";
+     case Flag::ERR_OTHER: return "ERR_OTHER";
+     case Flag::SUCCESS: return "SUCCESS";
+     default: ShouldNotReachHere(); return "NULL";
+   }
+ }
+ 
  // 4991491 do not "optimize out" the was_set false values: omitting them
  // tickles a Microsoft compiler bug causing flagTable to be malformed
  
  #define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name)
  
*** 756,776 ****
    e.set_new_value(new_value);
    e.set_origin(origin);
    e.commit();
  }
  
! static Flag::Error get_status_error(Flag::Error status_range, Flag::Error status_constraint) {
!   if (status_range != Flag::SUCCESS) {
!     return status_range;
!   } else if (status_constraint != Flag::SUCCESS) {
!     return status_constraint;
!   } else {
!     return Flag::SUCCESS;
!   }
! }
! 
! static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool* new_value, bool verbose = true) {
    Flag::Error status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
      status = constraint->apply_bool(new_value, verbose);
    }
--- 770,780 ----
    e.set_new_value(new_value);
    e.set_origin(origin);
    e.commit();
  }
  
! static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose = true) {
    Flag::Error status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
      status = constraint->apply_bool(new_value, verbose);
    }
*** 787,797 ****
  
  Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_bool()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_bool(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    bool old_value = result->get_bool();
    trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
    result->set_bool(*value);
    *value = old_value;
--- 791,801 ----
  
  Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_bool()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    bool old_value = result->get_bool();
    trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
    result->set_bool(*value);
    *value = old_value;
*** 800,829 ****
  }
  
  Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, &value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
    faddr->set_bool(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_int(const char* name, int* new_value, bool verbose = true) {
!   Flag::Error range_status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     range_status = range->check_int(*new_value, verbose);
    }
!   Flag::Error constraint_status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
!     constraint_status = constraint->apply_int(new_value, verbose);
    }
!   return get_status_error(range_status, constraint_status);
  }
  
  Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
    Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
    if (result == NULL) return Flag::INVALID_FLAG;
--- 804,834 ----
  }
  
  Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
    faddr->set_bool(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose = true) {
!   Flag::Error status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     status = range->check_int(new_value, verbose);
    }
!   if (status == Flag::SUCCESS) {
      CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
      if (constraint != NULL) {
!       status = constraint->apply_int(new_value, verbose);
!     }
    }
!   return status;
  }
  
  Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
    Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
    if (result == NULL) return Flag::INVALID_FLAG;
*** 834,844 ****
  
  Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_int()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_int(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    int old_value = result->get_int();
    trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
    result->set_int(*value);
    *value = old_value;
--- 839,849 ----
  
  Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_int()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    int old_value = result->get_int();
    trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
    result->set_int(*value);
    *value = old_value;
*** 847,874 ****
  }
  
  Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
    trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
    faddr->set_int(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint* new_value, bool verbose = true) {
!   Flag::Error range_status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     range_status = range->check_uint(*new_value, verbose);
    }
!   Flag::Error constraint_status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
!     constraint_status = constraint->apply_uint(new_value, verbose);
    }
!   return get_status_error(range_status, constraint_status);
  }
  
  Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
    Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
    if (result == NULL) return Flag::INVALID_FLAG;
--- 852,882 ----
  }
  
  Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
+   Flag::Error check = apply_constraint_and_check_range_int(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
+   if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
    faddr->set_int(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose = true) {
!   Flag::Error status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     status = range->check_uint(new_value, verbose);
    }
!   if (status == Flag::SUCCESS) {
      CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
      if (constraint != NULL) {
!       status = constraint->apply_uint(new_value, verbose);
!     }
    }
!   return status;
  }
  
  Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
    Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
    if (result == NULL) return Flag::INVALID_FLAG;
*** 879,889 ****
  
  Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_uint()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_uint(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    uint old_value = result->get_uint();
    trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
    result->set_uint(*value);
    *value = old_value;
--- 887,897 ----
  
  Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_uint()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    uint old_value = result->get_uint();
    trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
    result->set_uint(*value);
    *value = old_value;
*** 892,901 ****
--- 900,911 ----
  }
  
  Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
+   Flag::Error check = apply_constraint_and_check_range_uint(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
+   if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
    faddr->set_uint(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
  }
*** 906,934 ****
    if (!result->is_intx()) return Flag::WRONG_FORMAT;
    *value = result->get_intx();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx* new_value, bool verbose = true) {
!   Flag::Error range_status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     range_status = range->check_intx(*new_value, verbose);
    }
!   Flag::Error constraint_status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
!     constraint_status = constraint->apply_intx(new_value, verbose);
    }
!   return get_status_error(range_status, constraint_status);
  }
  
  Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_intx()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_intx(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    intx old_value = result->get_intx();
    trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
    result->set_intx(*value);
    *value = old_value;
--- 916,945 ----
    if (!result->is_intx()) return Flag::WRONG_FORMAT;
    *value = result->get_intx();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose = true) {
!   Flag::Error status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     status = range->check_intx(new_value, verbose);
    }
!   if (status == Flag::SUCCESS) {
      CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
      if (constraint != NULL) {
!       status = constraint->apply_intx(new_value, verbose);
!     }
    }
!   return status;
  }
  
  Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_intx()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    intx old_value = result->get_intx();
    trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
    result->set_intx(*value);
    *value = old_value;
*** 937,947 ****
  }
  
  Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, &value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
    faddr->set_intx(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
--- 948,958 ----
  }
  
  Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
    faddr->set_intx(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
*** 953,981 ****
    if (!result->is_uintx()) return Flag::WRONG_FORMAT;
    *value = result->get_uintx();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx* new_value, bool verbose = true) {
!   Flag::Error range_status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     range_status = range->check_uintx(*new_value, verbose);
    }
!   Flag::Error constraint_status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
!     constraint_status = constraint->apply_uintx(new_value, verbose);
    }
!   return get_status_error(range_status, constraint_status);
  }
  
  Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_uintx()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_uintx(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    uintx old_value = result->get_uintx();
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
    result->set_uintx(*value);
    *value = old_value;
--- 964,993 ----
    if (!result->is_uintx()) return Flag::WRONG_FORMAT;
    *value = result->get_uintx();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose = true) {
!   Flag::Error status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     status = range->check_uintx(new_value, verbose);
    }
!   if (status == Flag::SUCCESS) {
      CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
      if (constraint != NULL) {
!       status = constraint->apply_uintx(new_value, verbose);
      }
!   }
!   return status;
  }
  
  Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_uintx()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    uintx old_value = result->get_uintx();
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
    result->set_uintx(*value);
    *value = old_value;
*** 984,994 ****
  }
  
  Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, &value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
    faddr->set_uintx(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
--- 996,1006 ----
  }
  
  Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
    faddr->set_uintx(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
*** 1000,1028 ****
    if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
    *value = result->get_uint64_t();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t* new_value, bool verbose = true) {
!   Flag::Error range_status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     range_status = range->check_uint64_t(*new_value, verbose);
    }
!   Flag::Error constraint_status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
!     constraint_status = constraint->apply_uint64_t(new_value, verbose);
    }
!   return get_status_error(range_status, constraint_status);
  }
  
  Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_uint64_t(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    uint64_t old_value = result->get_uint64_t();
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
    result->set_uint64_t(*value);
    *value = old_value;
--- 1012,1041 ----
    if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
    *value = result->get_uint64_t();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose = true) {
!   Flag::Error status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     status = range->check_uint64_t(new_value, verbose);
    }
!   if (status == Flag::SUCCESS) {
      CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
      if (constraint != NULL) {
!       status = constraint->apply_uint64_t(new_value, verbose);
!     }
    }
!   return status;
  }
  
  Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    uint64_t old_value = result->get_uint64_t();
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
    result->set_uint64_t(*value);
    *value = old_value;
*** 1031,1041 ****
  }
  
  Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, &value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
    faddr->set_uint64_t(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
--- 1044,1054 ----
  }
  
  Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
    faddr->set_uint64_t(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
*** 1047,1075 ****
    if (!result->is_size_t()) return Flag::WRONG_FORMAT;
    *value = result->get_size_t();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t* new_value, bool verbose = true) {
!   Flag::Error range_status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     range_status = range->check_size_t(*new_value, verbose);
    }
!   Flag::Error constraint_status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
!     constraint_status = constraint->apply_size_t(new_value, verbose);
    }
!   return get_status_error(range_status, constraint_status);
  }
  
  Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_size_t()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_size_t(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    size_t old_value = result->get_size_t();
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
    result->set_size_t(*value);
    *value = old_value;
--- 1060,1089 ----
    if (!result->is_size_t()) return Flag::WRONG_FORMAT;
    *value = result->get_size_t();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose = true) {
!   Flag::Error status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     status = range->check_size_t(new_value, verbose);
    }
!   if (status == Flag::SUCCESS) {
      CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
      if (constraint != NULL) {
!       status = constraint->apply_size_t(new_value, verbose);
      }
!   }
!   return status;
  }
  
  Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_size_t()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    size_t old_value = result->get_size_t();
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
    result->set_size_t(*value);
    *value = old_value;
*** 1078,1088 ****
  }
  
  Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, &value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
    faddr->set_size_t(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
--- 1092,1102 ----
  }
  
  Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
    faddr->set_size_t(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
*** 1094,1122 ****
    if (!result->is_double()) return Flag::WRONG_FORMAT;
    *value = result->get_double();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_double(const char* name, double* new_value, bool verbose = true) {
!   Flag::Error range_status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     range_status = range->check_double(*new_value, verbose);
    }
!   Flag::Error constraint_status = Flag::SUCCESS;
    CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
    if (constraint != NULL) {
!     constraint_status = constraint->apply_double(new_value, verbose);
    }
!   return get_status_error(range_status, constraint_status);
  }
  
  Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_double()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_double(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    double old_value = result->get_double();
    trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
    result->set_double(*value);
    *value = old_value;
--- 1108,1137 ----
    if (!result->is_double()) return Flag::WRONG_FORMAT;
    *value = result->get_double();
    return Flag::SUCCESS;
  }
  
! static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose = true) {
!   Flag::Error status = Flag::SUCCESS;
    CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
    if (range != NULL) {
!     status = range->check_double(new_value, verbose);
    }
!   if (status == Flag::SUCCESS) {
      CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
      if (constraint != NULL) {
!       status = constraint->apply_double(new_value, verbose);
!     }
    }
!   return status;
  }
  
  Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
    Flag* result = Flag::find_flag(name, len);
    if (result == NULL) return Flag::INVALID_FLAG;
    if (!result->is_double()) return Flag::WRONG_FORMAT;
!   Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
    if (check != Flag::SUCCESS) return check;
    double old_value = result->get_double();
    trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
    result->set_double(*value);
    *value = old_value;
*** 1125,1135 ****
  }
  
  Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, &value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
    faddr->set_double(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;
--- 1140,1150 ----
  }
  
  Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
    Flag* faddr = address_of_flag(flag);
    guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
!   Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, value);
    if (check != Flag::SUCCESS) return check;
    trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
    faddr->set_double(value);
    faddr->set_origin(origin);
    return Flag::SUCCESS;