706 
 707   if (!(match->is_unlocked() || match->is_unlocker())) {
 708     if (!allow_locked) {
 709       return NULL;
 710     }
 711   }
 712 
 713   if (max_score < VMOptionsFuzzyMatchSimilarity) {
 714     return NULL;
 715   }
 716 
 717   return match;
 718 }
 719 
 720 // Returns the address of the index'th element
 721 static Flag* address_of_flag(CommandLineFlagWithType flag) {
 722   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 723   return &Flag::flags[flag];
 724 }
 725 














 726 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
 727   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 728   Flag* f = &Flag::flags[flag];
 729   return f->is_default();
 730 }
 731 
 732 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
 733   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 734   Flag* f = &Flag::flags[flag];
 735   return f->is_ergonomic();
 736 }
 737 
 738 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
 739   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 740   Flag* f = &Flag::flags[flag];
 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(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;

 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(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, !CommandLineFlags::finishedInitializing());
 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(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, !CommandLineFlags::finishedInitializing());
 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;

 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(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, !CommandLineFlags::finishedInitializing());
 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(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, !CommandLineFlags::finishedInitializing());
 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(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, !CommandLineFlags::finishedInitializing());
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(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, !CommandLineFlags::finishedInitializing());
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(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, !CommandLineFlags::finishedInitializing());
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, !CommandLineFlags::finishedInitializing());

 706 
 707   if (!(match->is_unlocked() || match->is_unlocker())) {
 708     if (!allow_locked) {
 709       return NULL;
 710     }
 711   }
 712 
 713   if (max_score < VMOptionsFuzzyMatchSimilarity) {
 714     return NULL;
 715   }
 716 
 717   return match;
 718 }
 719 
 720 // Returns the address of the index'th element
 721 static Flag* address_of_flag(CommandLineFlagWithType flag) {
 722   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 723   return &Flag::flags[flag];
 724 }
 725 
 726 const char* Flag::flag_error_str(Flag::Error error) {
 727   switch (error) {
 728     case Flag::MISSING_NAME: return "MISSING_NAME";
 729     case Flag::MISSING_VALUE: return "MISSING_VALUE";
 730     case Flag::NON_WRITABLE: return "NON_WRITABLE";
 731     case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS";
 732     case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT";
 733     case Flag::INVALID_FLAG: return "INVALID_FLAG";
 734     case Flag::ERR_OTHER: return "ERR_OTHER";
 735     case Flag::SUCCESS: return "SUCCESS";
 736     default: return "NULL";
 737   }
 738 }
 739 
 740 bool CommandLineFlagsEx::is_default(CommandLineFlag flag) {
 741   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 742   Flag* f = &Flag::flags[flag];
 743   return f->is_default();
 744 }
 745 
 746 bool CommandLineFlagsEx::is_ergo(CommandLineFlag flag) {
 747   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 748   Flag* f = &Flag::flags[flag];
 749   return f->is_ergonomic();
 750 }
 751 
 752 bool CommandLineFlagsEx::is_cmdline(CommandLineFlag flag) {
 753   assert((size_t)flag < Flag::numFlags, "bad command line flag index");
 754   Flag* f = &Flag::flags[flag];
 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(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;

 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(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, !CommandLineFlags::finishedInitializing());
 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   trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
 858   faddr->set_int(value);
 859   faddr->set_origin(origin);
 860   return Flag::SUCCESS;
 861 }
 862 
 863 static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint* new_value, bool verbose = true) {
 864   Flag::Error status = Flag::SUCCESS;
 865   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 866   if (range != NULL) {
 867     status = range->check_uint(*new_value, verbose);
 868   }
 869   if (status == Flag::SUCCESS) {
 870     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 871     if (constraint != NULL) {
 872       status = constraint->apply_uint(new_value, verbose);
 873     }
 874   }
 875   return status;
 876 }
 877 
 878 Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
 879   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 880   if (result == NULL) return Flag::INVALID_FLAG;
 881   if (!result->is_uint()) return Flag::WRONG_FORMAT;
 882   *value = result->get_uint();
 883   return Flag::SUCCESS;
 884 }
 885 
 886 Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
 887   Flag* result = Flag::find_flag(name, len);
 888   if (result == NULL) return Flag::INVALID_FLAG;
 889   if (!result->is_uint()) return Flag::WRONG_FORMAT;
 890   Flag::Error check = apply_constraint_and_check_range_uint(name, value, !CommandLineFlags::finishedInitializing());
 891   if (check != Flag::SUCCESS) return check;
 892   uint old_value = result->get_uint();
 893   trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
 894   result->set_uint(*value);
 895   *value = old_value;

 898 }
 899 
 900 Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
 901   Flag* faddr = address_of_flag(flag);
 902   guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
 903   trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
 904   faddr->set_uint(value);
 905   faddr->set_origin(origin);
 906   return Flag::SUCCESS;
 907 }
 908 
 909 Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
 910   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 911   if (result == NULL) return Flag::INVALID_FLAG;
 912   if (!result->is_intx()) return Flag::WRONG_FORMAT;
 913   *value = result->get_intx();
 914   return Flag::SUCCESS;
 915 }
 916 
 917 static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx* new_value, bool verbose = true) {
 918   Flag::Error status = Flag::SUCCESS;
 919   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 920   if (range != NULL) {
 921     status = range->check_intx(*new_value, verbose);
 922   }
 923   if (status == Flag::SUCCESS) {
 924     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 925     if (constraint != NULL) {
 926       status = constraint->apply_intx(new_value, verbose);
 927     }
 928   }
 929   return status;
 930 }
 931 
 932 Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
 933   Flag* result = Flag::find_flag(name, len);
 934   if (result == NULL) return Flag::INVALID_FLAG;
 935   if (!result->is_intx()) return Flag::WRONG_FORMAT;
 936   Flag::Error check = apply_constraint_and_check_range_intx(name, value, !CommandLineFlags::finishedInitializing());
 937   if (check != Flag::SUCCESS) return check;
 938   intx old_value = result->get_intx();
 939   trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
 940   result->set_intx(*value);
 941   *value = old_value;
 942   result->set_origin(origin);
 943   return Flag::SUCCESS;
 944 }
 945 
 946 Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
 947   Flag* faddr = address_of_flag(flag);
 948   guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
 949   Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, &value);
 950   if (check != Flag::SUCCESS) return check;
 951   trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
 952   faddr->set_intx(value);
 953   faddr->set_origin(origin);
 954   return Flag::SUCCESS;
 955 }
 956 
 957 Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
 958   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
 959   if (result == NULL) return Flag::INVALID_FLAG;
 960   if (!result->is_uintx()) return Flag::WRONG_FORMAT;
 961   *value = result->get_uintx();
 962   return Flag::SUCCESS;
 963 }
 964 
 965 static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx* new_value, bool verbose = true) {
 966   Flag::Error status = Flag::SUCCESS;
 967   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 968   if (range != NULL) {
 969     status = range->check_uintx(*new_value, verbose);
 970   }
 971   if (status == Flag::SUCCESS) {
 972     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
 973     if (constraint != NULL) {
 974       status = constraint->apply_uintx(new_value, verbose);
 975     }
 976   }
 977   return status;
 978 }
 979 
 980 Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
 981   Flag* result = Flag::find_flag(name, len);
 982   if (result == NULL) return Flag::INVALID_FLAG;
 983   if (!result->is_uintx()) return Flag::WRONG_FORMAT;
 984   Flag::Error check = apply_constraint_and_check_range_uintx(name, value, !CommandLineFlags::finishedInitializing());
 985   if (check != Flag::SUCCESS) return check;
 986   uintx old_value = result->get_uintx();
 987   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
 988   result->set_uintx(*value);
 989   *value = old_value;
 990   result->set_origin(origin);
 991   return Flag::SUCCESS;
 992 }
 993 
 994 Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
 995   Flag* faddr = address_of_flag(flag);
 996   guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
 997   Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, &value);
 998   if (check != Flag::SUCCESS) return check;
 999   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
1000   faddr->set_uintx(value);
1001   faddr->set_origin(origin);
1002   return Flag::SUCCESS;
1003 }
1004 
1005 Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
1006   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1007   if (result == NULL) return Flag::INVALID_FLAG;
1008   if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1009   *value = result->get_uint64_t();
1010   return Flag::SUCCESS;
1011 }
1012 
1013 static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t* new_value, bool verbose = true) {
1014   Flag::Error status = Flag::SUCCESS;
1015   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1016   if (range != NULL) {
1017     status = range->check_uint64_t(*new_value, verbose);
1018   }
1019   if (status == Flag::SUCCESS) {
1020     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
1021     if (constraint != NULL) {
1022       status = constraint->apply_uint64_t(new_value, verbose);
1023     }
1024   }
1025   return status;
1026 }
1027 
1028 Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
1029   Flag* result = Flag::find_flag(name, len);
1030   if (result == NULL) return Flag::INVALID_FLAG;
1031   if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
1032   Flag::Error check = apply_constraint_and_check_range_uint64_t(name, value, !CommandLineFlags::finishedInitializing());
1033   if (check != Flag::SUCCESS) return check;
1034   uint64_t old_value = result->get_uint64_t();
1035   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1036   result->set_uint64_t(*value);
1037   *value = old_value;
1038   result->set_origin(origin);
1039   return Flag::SUCCESS;
1040 }
1041 
1042 Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
1043   Flag* faddr = address_of_flag(flag);
1044   guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
1045   Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, &value);
1046   if (check != Flag::SUCCESS) return check;
1047   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
1048   faddr->set_uint64_t(value);
1049   faddr->set_origin(origin);
1050   return Flag::SUCCESS;
1051 }
1052 
1053 Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
1054   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1055   if (result == NULL) return Flag::INVALID_FLAG;
1056   if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1057   *value = result->get_size_t();
1058   return Flag::SUCCESS;
1059 }
1060 
1061 static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t* new_value, bool verbose = true) {
1062   Flag::Error status = Flag::SUCCESS;
1063   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1064   if (range != NULL) {
1065     status = range->check_size_t(*new_value, verbose);
1066   }
1067   if (status == Flag::SUCCESS) {
1068     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
1069     if (constraint != NULL) {
1070       status = constraint->apply_size_t(new_value, verbose);
1071     }
1072   }
1073   return status;
1074 }
1075 
1076 Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
1077   Flag* result = Flag::find_flag(name, len);
1078   if (result == NULL) return Flag::INVALID_FLAG;
1079   if (!result->is_size_t()) return Flag::WRONG_FORMAT;
1080   Flag::Error check = apply_constraint_and_check_range_size_t(name, value, !CommandLineFlags::finishedInitializing());
1081   if (check != Flag::SUCCESS) return check;
1082   size_t old_value = result->get_size_t();
1083   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
1084   result->set_size_t(*value);
1085   *value = old_value;
1086   result->set_origin(origin);
1087   return Flag::SUCCESS;
1088 }
1089 
1090 Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
1091   Flag* faddr = address_of_flag(flag);
1092   guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
1093   Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, &value);
1094   if (check != Flag::SUCCESS) return check;
1095   trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
1096   faddr->set_size_t(value);
1097   faddr->set_origin(origin);
1098   return Flag::SUCCESS;
1099 }
1100 
1101 Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
1102   Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
1103   if (result == NULL) return Flag::INVALID_FLAG;
1104   if (!result->is_double()) return Flag::WRONG_FORMAT;
1105   *value = result->get_double();
1106   return Flag::SUCCESS;
1107 }
1108 
1109 static Flag::Error apply_constraint_and_check_range_double(const char* name, double* new_value, bool verbose = true) {
1110   Flag::Error status = Flag::SUCCESS;
1111   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
1112   if (range != NULL) {
1113     status = range->check_double(*new_value, verbose);
1114   }
1115   if (status == Flag::SUCCESS) {
1116     CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find(name);
1117     if (constraint != NULL) {
1118       status = constraint->apply_double(new_value, verbose);
1119     }
1120   }
1121   return status;
1122 }
1123 
1124 Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
1125   Flag* result = Flag::find_flag(name, len);
1126   if (result == NULL) return Flag::INVALID_FLAG;
1127   if (!result->is_double()) return Flag::WRONG_FORMAT;
1128   Flag::Error check = apply_constraint_and_check_range_double(name, value, !CommandLineFlags::finishedInitializing());
1129   if (check != Flag::SUCCESS) return check;
1130   double old_value = result->get_double();
1131   trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
1132   result->set_double(*value);
1133   *value = old_value;
1134   result->set_origin(origin);
1135   return Flag::SUCCESS;
1136 }
1137 
1138 Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
1139   Flag* faddr = address_of_flag(flag);
1140   guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
1141   Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, &value, !CommandLineFlags::finishedInitializing());