498 // Need to turn embedded '\n's back into separate arguments
499 // Not so efficient to print one character at a time,
500 // but the choice is to do the transformation to a buffer
501 // and print that. And this need not be efficient.
502 for (; *cp != '\0'; cp += 1) {
503 switch (*cp) {
504 default:
505 st->print("%c", *cp);
506 break;
507 case '\n':
508 st->print(" -XX:%s=", _name);
509 break;
510 }
511 }
512 }
513 } else {
514 ShouldNotReachHere();
515 }
516 }
517
518 // 4991491 do not "optimize out" the was_set false values: omitting them
519 // tickles a Microsoft compiler bug causing flagTable to be malformed
520
521 #define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name)
522
523 #define RUNTIME_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT) },
524 #define RUNTIME_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
525 #define RUNTIME_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC) },
526 #define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_EXPERIMENTAL) },
527 #define RUNTIME_MANAGEABLE_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_MANAGEABLE) },
528 #define RUNTIME_PRODUCT_RW_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_READ_WRITE) },
529 #define RUNTIME_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP) },
530 #define RUNTIME_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
531 #define RUNTIME_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_NOT_PRODUCT) },
532
533 #ifdef _LP64
534 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_LP64_PRODUCT) },
535 #else
536 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
537 #endif // _LP64
741 return f->is_command_line();
742 }
743
744 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
745 Flag* result = Flag::find_flag((char*)name, strlen(name));
746 if (result == NULL) return false;
747 *value = result->is_command_line();
748 return true;
749 }
750
751 template<class E, class T>
752 static void trace_flag_changed(const char* name, const T old_value, const T new_value, const Flag::Flags origin) {
753 E e;
754 e.set_name(name);
755 e.set_old_value(old_value);
756 e.set_new_value(new_value);
757 e.set_origin(origin);
758 e.commit();
759 }
760
761 static Flag::Error get_status_error(Flag::Error status_range, Flag::Error status_constraint) {
762 if (status_range != Flag::SUCCESS) {
763 return status_range;
764 } else if (status_constraint != Flag::SUCCESS) {
765 return status_constraint;
766 } else {
767 return Flag::SUCCESS;
768 }
769 }
770
771 static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool* new_value, bool verbose = true) {
772 Flag::Error status = Flag::SUCCESS;
773 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
774 if (constraint != NULL) {
775 status = constraint->apply_bool(new_value, verbose);
776 }
777 return status;
778 }
779
780 Flag::Error CommandLineFlags::boolAt(const char* name, size_t len, bool* value, bool allow_locked, bool return_flag) {
781 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
782 if (result == NULL) return Flag::INVALID_FLAG;
783 if (!result->is_bool()) return Flag::WRONG_FORMAT;
784 *value = result->get_bool();
785 return Flag::SUCCESS;
786 }
787
788 Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
789 Flag* result = Flag::find_flag(name, len);
790 if (result == NULL) return Flag::INVALID_FLAG;
791 if (!result->is_bool()) return Flag::WRONG_FORMAT;
792 Flag::Error check = apply_constraint_and_check_range_bool(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
793 if (check != Flag::SUCCESS) return check;
794 bool old_value = result->get_bool();
795 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
796 result->set_bool(*value);
797 *value = old_value;
798 result->set_origin(origin);
799 return Flag::SUCCESS;
800 }
801
802 Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
803 Flag* faddr = address_of_flag(flag);
804 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
805 Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, &value);
806 if (check != Flag::SUCCESS) return check;
807 trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
808 faddr->set_bool(value);
809 faddr->set_origin(origin);
810 return Flag::SUCCESS;
811 }
812
813 static Flag::Error apply_constraint_and_check_range_int(const char* name, int* new_value, bool verbose = true) {
814 Flag::Error range_status = Flag::SUCCESS;
815 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
816 if (range != NULL) {
817 range_status = range->check_int(*new_value, verbose);
818 }
819 Flag::Error constraint_status = Flag::SUCCESS;
820 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
821 if (constraint != NULL) {
822 constraint_status = constraint->apply_int(new_value, verbose);
823 }
824 return get_status_error(range_status, constraint_status);
825 }
826
827 Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
828 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
829 if (result == NULL) return Flag::INVALID_FLAG;
830 if (!result->is_int()) return Flag::WRONG_FORMAT;
831 *value = result->get_int();
832 return Flag::SUCCESS;
833 }
834
835 Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
836 Flag* result = Flag::find_flag(name, len);
837 if (result == NULL) return Flag::INVALID_FLAG;
838 if (!result->is_int()) return Flag::WRONG_FORMAT;
839 Flag::Error check = apply_constraint_and_check_range_int(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
840 if (check != Flag::SUCCESS) return check;
841 int old_value = result->get_int();
842 trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
843 result->set_int(*value);
844 *value = old_value;
845 result->set_origin(origin);
846 return Flag::SUCCESS;
847 }
848
849 Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
850 Flag* faddr = address_of_flag(flag);
851 guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
852 trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
853 faddr->set_int(value);
854 faddr->set_origin(origin);
855 return Flag::SUCCESS;
856 }
857
858 static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint* new_value, bool verbose = true) {
859 Flag::Error range_status = Flag::SUCCESS;
860 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
861 if (range != NULL) {
862 range_status = range->check_uint(*new_value, verbose);
863 }
864 Flag::Error constraint_status = Flag::SUCCESS;
865 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
866 if (constraint != NULL) {
867 constraint_status = constraint->apply_uint(new_value, verbose);
868 }
869 return get_status_error(range_status, constraint_status);
870 }
871
872 Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
873 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
874 if (result == NULL) return Flag::INVALID_FLAG;
875 if (!result->is_uint()) return Flag::WRONG_FORMAT;
876 *value = result->get_uint();
877 return Flag::SUCCESS;
878 }
879
880 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
881 Flag* result = Flag::find_flag(name, len);
882 if (result == NULL) return Flag::INVALID_FLAG;
883 if (!result->is_uint()) return Flag::WRONG_FORMAT;
884 Flag::Error check = apply_constraint_and_check_range_uint(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
885 if (check != Flag::SUCCESS) return check;
886 uint old_value = result->get_uint();
887 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
888 result->set_uint(*value);
889 *value = old_value;
890 result->set_origin(origin);
891 return Flag::SUCCESS;
892 }
893
894 Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
895 Flag* faddr = address_of_flag(flag);
896 guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
897 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
898 faddr->set_uint(value);
899 faddr->set_origin(origin);
900 return Flag::SUCCESS;
901 }
902
903 Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
904 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
905 if (result == NULL) return Flag::INVALID_FLAG;
906 if (!result->is_intx()) return Flag::WRONG_FORMAT;
907 *value = result->get_intx();
908 return Flag::SUCCESS;
909 }
910
911 static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx* new_value, bool verbose = true) {
912 Flag::Error range_status = Flag::SUCCESS;
913 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
914 if (range != NULL) {
915 range_status = range->check_intx(*new_value, verbose);
916 }
917 Flag::Error constraint_status = Flag::SUCCESS;
918 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
919 if (constraint != NULL) {
920 constraint_status = constraint->apply_intx(new_value, verbose);
921 }
922 return get_status_error(range_status, constraint_status);
923 }
924
925 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
926 Flag* result = Flag::find_flag(name, len);
927 if (result == NULL) return Flag::INVALID_FLAG;
928 if (!result->is_intx()) return Flag::WRONG_FORMAT;
929 Flag::Error check = apply_constraint_and_check_range_intx(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
930 if (check != Flag::SUCCESS) return check;
931 intx old_value = result->get_intx();
932 trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
933 result->set_intx(*value);
934 *value = old_value;
935 result->set_origin(origin);
936 return Flag::SUCCESS;
937 }
938
939 Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
940 Flag* faddr = address_of_flag(flag);
941 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
942 Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, &value);
943 if (check != Flag::SUCCESS) return check;
944 trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
945 faddr->set_intx(value);
946 faddr->set_origin(origin);
947 return Flag::SUCCESS;
948 }
949
950 Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
951 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
952 if (result == NULL) return Flag::INVALID_FLAG;
953 if (!result->is_uintx()) return Flag::WRONG_FORMAT;
954 *value = result->get_uintx();
955 return Flag::SUCCESS;
956 }
957
958 static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx* new_value, bool verbose = true) {
959 Flag::Error range_status = Flag::SUCCESS;
960 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
961 if (range != NULL) {
962 range_status = range->check_uintx(*new_value, verbose);
963 }
964 Flag::Error constraint_status = Flag::SUCCESS;
965 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
966 if (constraint != NULL) {
967 constraint_status = constraint->apply_uintx(new_value, verbose);
968 }
969 return get_status_error(range_status, constraint_status);
970 }
971
972 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
973 Flag* result = Flag::find_flag(name, len);
974 if (result == NULL) return Flag::INVALID_FLAG;
975 if (!result->is_uintx()) return Flag::WRONG_FORMAT;
976 Flag::Error check = apply_constraint_and_check_range_uintx(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
977 if (check != Flag::SUCCESS) return check;
978 uintx old_value = result->get_uintx();
979 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
980 result->set_uintx(*value);
981 *value = old_value;
982 result->set_origin(origin);
983 return Flag::SUCCESS;
984 }
985
986 Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
987 Flag* faddr = address_of_flag(flag);
988 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
989 Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, &value);
990 if (check != Flag::SUCCESS) return check;
991 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
992 faddr->set_uintx(value);
993 faddr->set_origin(origin);
994 return Flag::SUCCESS;
995 }
996
997 Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
998 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
999 if (result == NULL) return Flag::INVALID_FLAG;
1000 if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1001 *value = result->get_uint64_t();
1002 return Flag::SUCCESS;
1003 }
1004
1005 static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t* new_value, bool verbose = true) {
1006 Flag::Error range_status = Flag::SUCCESS;
1007 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1008 if (range != NULL) {
1009 range_status = range->check_uint64_t(*new_value, verbose);
1010 }
1011 Flag::Error constraint_status = Flag::SUCCESS;
1012 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1013 if (constraint != NULL) {
1014 constraint_status = constraint->apply_uint64_t(new_value, verbose);
1015 }
1016 return get_status_error(range_status, constraint_status);
1017 }
1018
1019 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
1020 Flag* result = Flag::find_flag(name, len);
1021 if (result == NULL) return Flag::INVALID_FLAG;
1022 if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1023 Flag::Error check = apply_constraint_and_check_range_uint64_t(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
1024 if (check != Flag::SUCCESS) return check;
1025 uint64_t old_value = result->get_uint64_t();
1026 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1027 result->set_uint64_t(*value);
1028 *value = old_value;
1029 result->set_origin(origin);
1030 return Flag::SUCCESS;
1031 }
1032
1033 Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
1034 Flag* faddr = address_of_flag(flag);
1035 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
1036 Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, &value);
1037 if (check != Flag::SUCCESS) return check;
1038 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
1039 faddr->set_uint64_t(value);
1040 faddr->set_origin(origin);
1041 return Flag::SUCCESS;
1042 }
1043
1044 Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
1045 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1046 if (result == NULL) return Flag::INVALID_FLAG;
1047 if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1048 *value = result->get_size_t();
1049 return Flag::SUCCESS;
1050 }
1051
1052 static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t* new_value, bool verbose = true) {
1053 Flag::Error range_status = Flag::SUCCESS;
1054 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1055 if (range != NULL) {
1056 range_status = range->check_size_t(*new_value, verbose);
1057 }
1058 Flag::Error constraint_status = Flag::SUCCESS;
1059 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1060 if (constraint != NULL) {
1061 constraint_status = constraint->apply_size_t(new_value, verbose);
1062 }
1063 return get_status_error(range_status, constraint_status);
1064 }
1065
1066 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
1067 Flag* result = Flag::find_flag(name, len);
1068 if (result == NULL) return Flag::INVALID_FLAG;
1069 if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1070 Flag::Error check = apply_constraint_and_check_range_size_t(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
1071 if (check != Flag::SUCCESS) return check;
1072 size_t old_value = result->get_size_t();
1073 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1074 result->set_size_t(*value);
1075 *value = old_value;
1076 result->set_origin(origin);
1077 return Flag::SUCCESS;
1078 }
1079
1080 Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
1081 Flag* faddr = address_of_flag(flag);
1082 guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
1083 Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, &value);
1084 if (check != Flag::SUCCESS) return check;
1085 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
1086 faddr->set_size_t(value);
1087 faddr->set_origin(origin);
1088 return Flag::SUCCESS;
1089 }
1090
1091 Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
1092 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1093 if (result == NULL) return Flag::INVALID_FLAG;
1094 if (!result->is_double()) return Flag::WRONG_FORMAT;
1095 *value = result->get_double();
1096 return Flag::SUCCESS;
1097 }
1098
1099 static Flag::Error apply_constraint_and_check_range_double(const char* name, double* new_value, bool verbose = true) {
1100 Flag::Error range_status = Flag::SUCCESS;
1101 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1102 if (range != NULL) {
1103 range_status = range->check_double(*new_value, verbose);
1104 }
1105 Flag::Error constraint_status = Flag::SUCCESS;
1106 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1107 if (constraint != NULL) {
1108 constraint_status = constraint->apply_double(new_value, verbose);
1109 }
1110 return get_status_error(range_status, constraint_status);
1111 }
1112
1113 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
1114 Flag* result = Flag::find_flag(name, len);
1115 if (result == NULL) return Flag::INVALID_FLAG;
1116 if (!result->is_double()) return Flag::WRONG_FORMAT;
1117 Flag::Error check = apply_constraint_and_check_range_double(name, value, !CommandLineFlagConstraintList::validated_after_ergo());
1118 if (check != Flag::SUCCESS) return check;
1119 double old_value = result->get_double();
1120 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
1121 result->set_double(*value);
1122 *value = old_value;
1123 result->set_origin(origin);
1124 return Flag::SUCCESS;
1125 }
1126
1127 Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
1128 Flag* faddr = address_of_flag(flag);
1129 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
1130 Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, &value);
1131 if (check != Flag::SUCCESS) return check;
1132 trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
1133 faddr->set_double(value);
1134 faddr->set_origin(origin);
1135 return Flag::SUCCESS;
1136 }
1137
1138 Flag::Error CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {
1139 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1140 if (result == NULL) return Flag::INVALID_FLAG;
1141 if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1142 *value = result->get_ccstr();
1143 return Flag::SUCCESS;
1144 }
1145
1146 Flag::Error CommandLineFlags::ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin) {
1147 Flag* result = Flag::find_flag(name, len);
1148 if (result == NULL) return Flag::INVALID_FLAG;
1149 if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1150 ccstr old_value = result->get_ccstr();
|
498 // Need to turn embedded '\n's back into separate arguments
499 // Not so efficient to print one character at a time,
500 // but the choice is to do the transformation to a buffer
501 // and print that. And this need not be efficient.
502 for (; *cp != '\0'; cp += 1) {
503 switch (*cp) {
504 default:
505 st->print("%c", *cp);
506 break;
507 case '\n':
508 st->print(" -XX:%s=", _name);
509 break;
510 }
511 }
512 }
513 } else {
514 ShouldNotReachHere();
515 }
516 }
517
518 const char* Flag::flag_error_str(Flag::Error error) {
519 switch (error) {
520 case Flag::MISSING_NAME: return "MISSING_NAME";
521 case Flag::MISSING_VALUE: return "MISSING_VALUE";
522 case Flag::NON_WRITABLE: return "NON_WRITABLE";
523 case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS";
524 case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT";
525 case Flag::INVALID_FLAG: return "INVALID_FLAG";
526 case Flag::ERR_OTHER: return "ERR_OTHER";
527 case Flag::SUCCESS: return "SUCCESS";
528 default: ShouldNotReachHere(); return "NULL";
529 }
530 }
531
532 // 4991491 do not "optimize out" the was_set false values: omitting them
533 // tickles a Microsoft compiler bug causing flagTable to be malformed
534
535 #define NAME(name) NOT_PRODUCT(&name) PRODUCT_ONLY(&CONST_##name)
536
537 #define RUNTIME_PRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT) },
538 #define RUNTIME_PD_PRODUCT_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_PLATFORM_DEPENDENT) },
539 #define RUNTIME_DIAGNOSTIC_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DIAGNOSTIC) },
540 #define RUNTIME_EXPERIMENTAL_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_EXPERIMENTAL) },
541 #define RUNTIME_MANAGEABLE_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_MANAGEABLE) },
542 #define RUNTIME_PRODUCT_RW_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_PRODUCT | Flag::KIND_READ_WRITE) },
543 #define RUNTIME_DEVELOP_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP) },
544 #define RUNTIME_PD_DEVELOP_FLAG_STRUCT( type, name, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_DEVELOP | Flag::KIND_PLATFORM_DEPENDENT) },
545 #define RUNTIME_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), NAME(name), NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_NOT_PRODUCT) },
546
547 #ifdef _LP64
548 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) { #type, XSTR(name), &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_LP64_PRODUCT) },
549 #else
550 #define RUNTIME_LP64_PRODUCT_FLAG_STRUCT(type, name, value, doc) /* flag is constant */
551 #endif // _LP64
755 return f->is_command_line();
756 }
757
758 bool CommandLineFlags::wasSetOnCmdline(const char* name, bool* value) {
759 Flag* result = Flag::find_flag((char*)name, strlen(name));
760 if (result == NULL) return false;
761 *value = result->is_command_line();
762 return true;
763 }
764
765 template<class E, class T>
766 static void trace_flag_changed(const char* name, const T old_value, const T new_value, const Flag::Flags origin) {
767 E e;
768 e.set_name(name);
769 e.set_old_value(old_value);
770 e.set_new_value(new_value);
771 e.set_origin(origin);
772 e.commit();
773 }
774
775 static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose = true) {
776 Flag::Error status = Flag::SUCCESS;
777 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
778 if (constraint != NULL) {
779 status = constraint->apply_bool(new_value, verbose);
780 }
781 return status;
782 }
783
784 Flag::Error CommandLineFlags::boolAt(const char* name, size_t len, bool* value, bool allow_locked, bool return_flag) {
785 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
786 if (result == NULL) return Flag::INVALID_FLAG;
787 if (!result->is_bool()) return Flag::WRONG_FORMAT;
788 *value = result->get_bool();
789 return Flag::SUCCESS;
790 }
791
792 Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
793 Flag* result = Flag::find_flag(name, len);
794 if (result == NULL) return Flag::INVALID_FLAG;
795 if (!result->is_bool()) return Flag::WRONG_FORMAT;
796 Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
797 if (check != Flag::SUCCESS) return check;
798 bool old_value = result->get_bool();
799 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
800 result->set_bool(*value);
801 *value = old_value;
802 result->set_origin(origin);
803 return Flag::SUCCESS;
804 }
805
806 Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
807 Flag* faddr = address_of_flag(flag);
808 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
809 Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, value);
810 if (check != Flag::SUCCESS) return check;
811 trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
812 faddr->set_bool(value);
813 faddr->set_origin(origin);
814 return Flag::SUCCESS;
815 }
816
817 static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose = true) {
818 Flag::Error status = Flag::SUCCESS;
819 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
820 if (range != NULL) {
821 status = range->check_int(new_value, verbose);
822 }
823 if (status == Flag::SUCCESS) {
824 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
825 if (constraint != NULL) {
826 status = constraint->apply_int(new_value, verbose);
827 }
828 }
829 return status;
830 }
831
832 Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
833 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
834 if (result == NULL) return Flag::INVALID_FLAG;
835 if (!result->is_int()) return Flag::WRONG_FORMAT;
836 *value = result->get_int();
837 return Flag::SUCCESS;
838 }
839
840 Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
841 Flag* result = Flag::find_flag(name, len);
842 if (result == NULL) return Flag::INVALID_FLAG;
843 if (!result->is_int()) return Flag::WRONG_FORMAT;
844 Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
845 if (check != Flag::SUCCESS) return check;
846 int old_value = result->get_int();
847 trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
848 result->set_int(*value);
849 *value = old_value;
850 result->set_origin(origin);
851 return Flag::SUCCESS;
852 }
853
854 Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
855 Flag* faddr = address_of_flag(flag);
856 guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
857 Flag::Error check = apply_constraint_and_check_range_int(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
858 if (check != Flag::SUCCESS) return check;
859 trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
860 faddr->set_int(value);
861 faddr->set_origin(origin);
862 return Flag::SUCCESS;
863 }
864
865 static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose = true) {
866 Flag::Error status = Flag::SUCCESS;
867 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
868 if (range != NULL) {
869 status = range->check_uint(new_value, verbose);
870 }
871 if (status == Flag::SUCCESS) {
872 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
873 if (constraint != NULL) {
874 status = constraint->apply_uint(new_value, verbose);
875 }
876 }
877 return status;
878 }
879
880 Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
881 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
882 if (result == NULL) return Flag::INVALID_FLAG;
883 if (!result->is_uint()) return Flag::WRONG_FORMAT;
884 *value = result->get_uint();
885 return Flag::SUCCESS;
886 }
887
888 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
889 Flag* result = Flag::find_flag(name, len);
890 if (result == NULL) return Flag::INVALID_FLAG;
891 if (!result->is_uint()) return Flag::WRONG_FORMAT;
892 Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
893 if (check != Flag::SUCCESS) return check;
894 uint old_value = result->get_uint();
895 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
896 result->set_uint(*value);
897 *value = old_value;
898 result->set_origin(origin);
899 return Flag::SUCCESS;
900 }
901
902 Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
903 Flag* faddr = address_of_flag(flag);
904 guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
905 Flag::Error check = apply_constraint_and_check_range_uint(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
906 if (check != Flag::SUCCESS) return check;
907 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
908 faddr->set_uint(value);
909 faddr->set_origin(origin);
910 return Flag::SUCCESS;
911 }
912
913 Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
914 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
915 if (result == NULL) return Flag::INVALID_FLAG;
916 if (!result->is_intx()) return Flag::WRONG_FORMAT;
917 *value = result->get_intx();
918 return Flag::SUCCESS;
919 }
920
921 static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose = true) {
922 Flag::Error status = Flag::SUCCESS;
923 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
924 if (range != NULL) {
925 status = range->check_intx(new_value, verbose);
926 }
927 if (status == Flag::SUCCESS) {
928 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
929 if (constraint != NULL) {
930 status = constraint->apply_intx(new_value, verbose);
931 }
932 }
933 return status;
934 }
935
936 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
937 Flag* result = Flag::find_flag(name, len);
938 if (result == NULL) return Flag::INVALID_FLAG;
939 if (!result->is_intx()) return Flag::WRONG_FORMAT;
940 Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
941 if (check != Flag::SUCCESS) return check;
942 intx old_value = result->get_intx();
943 trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
944 result->set_intx(*value);
945 *value = old_value;
946 result->set_origin(origin);
947 return Flag::SUCCESS;
948 }
949
950 Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
951 Flag* faddr = address_of_flag(flag);
952 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
953 Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, value);
954 if (check != Flag::SUCCESS) return check;
955 trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
956 faddr->set_intx(value);
957 faddr->set_origin(origin);
958 return Flag::SUCCESS;
959 }
960
961 Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
962 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
963 if (result == NULL) return Flag::INVALID_FLAG;
964 if (!result->is_uintx()) return Flag::WRONG_FORMAT;
965 *value = result->get_uintx();
966 return Flag::SUCCESS;
967 }
968
969 static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose = true) {
970 Flag::Error status = Flag::SUCCESS;
971 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
972 if (range != NULL) {
973 status = range->check_uintx(new_value, verbose);
974 }
975 if (status == Flag::SUCCESS) {
976 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
977 if (constraint != NULL) {
978 status = constraint->apply_uintx(new_value, verbose);
979 }
980 }
981 return status;
982 }
983
984 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
985 Flag* result = Flag::find_flag(name, len);
986 if (result == NULL) return Flag::INVALID_FLAG;
987 if (!result->is_uintx()) return Flag::WRONG_FORMAT;
988 Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
989 if (check != Flag::SUCCESS) return check;
990 uintx old_value = result->get_uintx();
991 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
992 result->set_uintx(*value);
993 *value = old_value;
994 result->set_origin(origin);
995 return Flag::SUCCESS;
996 }
997
998 Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
999 Flag* faddr = address_of_flag(flag);
1000 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
1001 Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, value);
1002 if (check != Flag::SUCCESS) return check;
1003 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
1004 faddr->set_uintx(value);
1005 faddr->set_origin(origin);
1006 return Flag::SUCCESS;
1007 }
1008
1009 Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
1010 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1011 if (result == NULL) return Flag::INVALID_FLAG;
1012 if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1013 *value = result->get_uint64_t();
1014 return Flag::SUCCESS;
1015 }
1016
1017 static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose = true) {
1018 Flag::Error status = Flag::SUCCESS;
1019 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1020 if (range != NULL) {
1021 status = range->check_uint64_t(new_value, verbose);
1022 }
1023 if (status == Flag::SUCCESS) {
1024 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1025 if (constraint != NULL) {
1026 status = constraint->apply_uint64_t(new_value, verbose);
1027 }
1028 }
1029 return status;
1030 }
1031
1032 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
1033 Flag* result = Flag::find_flag(name, len);
1034 if (result == NULL) return Flag::INVALID_FLAG;
1035 if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1036 Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1037 if (check != Flag::SUCCESS) return check;
1038 uint64_t old_value = result->get_uint64_t();
1039 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1040 result->set_uint64_t(*value);
1041 *value = old_value;
1042 result->set_origin(origin);
1043 return Flag::SUCCESS;
1044 }
1045
1046 Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
1047 Flag* faddr = address_of_flag(flag);
1048 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
1049 Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, value);
1050 if (check != Flag::SUCCESS) return check;
1051 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
1052 faddr->set_uint64_t(value);
1053 faddr->set_origin(origin);
1054 return Flag::SUCCESS;
1055 }
1056
1057 Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
1058 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1059 if (result == NULL) return Flag::INVALID_FLAG;
1060 if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1061 *value = result->get_size_t();
1062 return Flag::SUCCESS;
1063 }
1064
1065 static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose = true) {
1066 Flag::Error status = Flag::SUCCESS;
1067 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1068 if (range != NULL) {
1069 status = range->check_size_t(new_value, verbose);
1070 }
1071 if (status == Flag::SUCCESS) {
1072 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1073 if (constraint != NULL) {
1074 status = constraint->apply_size_t(new_value, verbose);
1075 }
1076 }
1077 return status;
1078 }
1079
1080 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
1081 Flag* result = Flag::find_flag(name, len);
1082 if (result == NULL) return Flag::INVALID_FLAG;
1083 if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1084 Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1085 if (check != Flag::SUCCESS) return check;
1086 size_t old_value = result->get_size_t();
1087 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1088 result->set_size_t(*value);
1089 *value = old_value;
1090 result->set_origin(origin);
1091 return Flag::SUCCESS;
1092 }
1093
1094 Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
1095 Flag* faddr = address_of_flag(flag);
1096 guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
1097 Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, value);
1098 if (check != Flag::SUCCESS) return check;
1099 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
1100 faddr->set_size_t(value);
1101 faddr->set_origin(origin);
1102 return Flag::SUCCESS;
1103 }
1104
1105 Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
1106 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1107 if (result == NULL) return Flag::INVALID_FLAG;
1108 if (!result->is_double()) return Flag::WRONG_FORMAT;
1109 *value = result->get_double();
1110 return Flag::SUCCESS;
1111 }
1112
1113 static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose = true) {
1114 Flag::Error status = Flag::SUCCESS;
1115 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1116 if (range != NULL) {
1117 status = range->check_double(new_value, verbose);
1118 }
1119 if (status == Flag::SUCCESS) {
1120 CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
1121 if (constraint != NULL) {
1122 status = constraint->apply_double(new_value, verbose);
1123 }
1124 }
1125 return status;
1126 }
1127
1128 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
1129 Flag* result = Flag::find_flag(name, len);
1130 if (result == NULL) return Flag::INVALID_FLAG;
1131 if (!result->is_double()) return Flag::WRONG_FORMAT;
1132 Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
1133 if (check != Flag::SUCCESS) return check;
1134 double old_value = result->get_double();
1135 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
1136 result->set_double(*value);
1137 *value = old_value;
1138 result->set_origin(origin);
1139 return Flag::SUCCESS;
1140 }
1141
1142 Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
1143 Flag* faddr = address_of_flag(flag);
1144 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
1145 Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, value);
1146 if (check != Flag::SUCCESS) return check;
1147 trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
1148 faddr->set_double(value);
1149 faddr->set_origin(origin);
1150 return Flag::SUCCESS;
1151 }
1152
1153 Flag::Error CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {
1154 Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1155 if (result == NULL) return Flag::INVALID_FLAG;
1156 if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1157 *value = result->get_ccstr();
1158 return Flag::SUCCESS;
1159 }
1160
1161 Flag::Error CommandLineFlags::ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin) {
1162 Flag* result = Flag::find_flag(name, len);
1163 if (result == NULL) return Flag::INVALID_FLAG;
1164 if (!result->is_ccstr()) return Flag::WRONG_FORMAT;
1165 ccstr old_value = result->get_ccstr();
|