Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/hotspot/share/services/writeableFlags.cpp
changeset 49857 31e07291ae29
parent 49360 886acec3b4c6
child 49860 ca5216a2a2cc
equal deleted inserted replaced
49856:5f63af8f9d7f 49857:31e07291ae29 
    24 
    24 
    25 #include "precompiled.hpp"
 
    25 #include "precompiled.hpp"
 
    26 #include "classfile/javaClasses.hpp"
 
    26 #include "classfile/javaClasses.hpp"
 
    27 #include "memory/allocation.inline.hpp"
 
    27 #include "memory/allocation.inline.hpp"
 
    28 #include "runtime/arguments.hpp"
 
    28 #include "runtime/arguments.hpp"
 
    29 #include "runtime/commandLineFlagRangeList.hpp"
 
    29 #include "runtime/flags/jvmFlag.hpp"
 
       
    30 #include "runtime/flags/jvmFlagRangeList.hpp"
 
    30 #include "runtime/java.hpp"
 
    31 #include "runtime/java.hpp"
 
    31 #include "runtime/jniHandles.hpp"
 
    32 #include "runtime/jniHandles.hpp"
 
    32 #include "services/writeableFlags.hpp"
 
    33 #include "services/writeableFlags.hpp"
 
    33 
    34 
    34 #define TEMP_BUF_SIZE 80
 
    35 #define TEMP_BUF_SIZE 80
 
    36 static void buffer_concat(char* buffer, const char* src) {
 
    37 static void buffer_concat(char* buffer, const char* src) {
 
    37   strncat(buffer, src, TEMP_BUF_SIZE - 1 - strlen(buffer));
 
    38   strncat(buffer, src, TEMP_BUF_SIZE - 1 - strlen(buffer));
 
    38 }
 
    39 }
 
    39 
    40 
    40 static void print_flag_error_message_bounds(const char* name, char* buffer) {
 
    41 static void print_flag_error_message_bounds(const char* name, char* buffer) {
 
    41   CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
 
    42   JVMFlagRange* range = JVMFlagRangeList::find(name);
 
    42   if (range != NULL) {
 
    43   if (range != NULL) {
 
    43     buffer_concat(buffer, "must have value in range ");
 
    44     buffer_concat(buffer, "must have value in range ");
 
    44 
    45 
    45     stringStream stream;
 
    46     stringStream stream;
 
    46     range->print(&stream);
 
    47     range->print(&stream);
 
    56     }
 
    57     }
 
    57     buffer[j] = '\0';
 
    58     buffer[j] = '\0';
 
    58   }
 
    59   }
 
    59 }
 
    60 }
 
    60 
    61 
    61 static void print_flag_error_message_if_needed(Flag::Error error, const char* name, FormatBuffer<80>& err_msg) {
 
    62 static void print_flag_error_message_if_needed(JVMFlag::Error error, const char* name, FormatBuffer<80>& err_msg) {
 
    62   if (error == Flag::SUCCESS) {
 
    63   if (error == JVMFlag::SUCCESS) {
 
    63     return;
 
    64     return;
 
    64   }
 
    65   }
 
    65 
    66 
    66   char buffer[TEMP_BUF_SIZE] = {'\0'};
 
    67   char buffer[TEMP_BUF_SIZE] = {'\0'};
 
    67   if ((error != Flag::MISSING_NAME) && (name != NULL)) {
 
    68   if ((error != JVMFlag::MISSING_NAME) && (name != NULL)) {
 
    68     buffer_concat(buffer, name);
 
    69     buffer_concat(buffer, name);
 
    69     buffer_concat(buffer, " error: ");
 
    70     buffer_concat(buffer, " error: ");
 
    70   } else {
 
    71   } else {
 
    71     buffer_concat(buffer, "Error: ");
 
    72     buffer_concat(buffer, "Error: ");
 
    72   }
 
    73   }
 
    73   switch (error) {
 
    74   switch (error) {
 
    74     case Flag::MISSING_NAME:
 
    75     case JVMFlag::MISSING_NAME:
 
    75       buffer_concat(buffer, "flag name is missing."); break;
 
    76       buffer_concat(buffer, "flag name is missing."); break;
 
    76     case Flag::MISSING_VALUE:
 
    77     case JVMFlag::MISSING_VALUE:
 
    77       buffer_concat(buffer, "parsing the textual form of the value."); break;
 
    78       buffer_concat(buffer, "parsing the textual form of the value."); break;
 
    78     case Flag::NON_WRITABLE:
 
    79     case JVMFlag::NON_WRITABLE:
 
    79       buffer_concat(buffer, "flag is not writeable."); break;
 
    80       buffer_concat(buffer, "flag is not writeable."); break;
 
    80     case Flag::OUT_OF_BOUNDS:
 
    81     case JVMFlag::OUT_OF_BOUNDS:
 
    81       print_flag_error_message_bounds(name, buffer); break;
 
    82       print_flag_error_message_bounds(name, buffer); break;
 
    82     case Flag::VIOLATES_CONSTRAINT:
 
    83     case JVMFlag::VIOLATES_CONSTRAINT:
 
    83       buffer_concat(buffer, "value violates its flag's constraint."); break;
 
    84       buffer_concat(buffer, "value violates its flag's constraint."); break;
 
    84     case Flag::INVALID_FLAG:
 
    85     case JVMFlag::INVALID_FLAG:
 
    85       buffer_concat(buffer, "there is no flag with the given name."); break;
 
    86       buffer_concat(buffer, "there is no flag with the given name."); break;
 
    86     case Flag::ERR_OTHER:
 
    87     case JVMFlag::ERR_OTHER:
 
    87       buffer_concat(buffer, "other, unspecified error related to setting the flag."); break;
 
    88       buffer_concat(buffer, "other, unspecified error related to setting the flag."); break;
 
    88     case Flag::SUCCESS:
 
    89     case JVMFlag::SUCCESS:
 
    89       break;
 
    90       break;
 
    90     default:
 
    91     default:
 
    91       break;
 
    92       break;
 
    92   }
 
    93   }
 
    93 
    94 
    94   err_msg.print("%s", buffer);
 
    95   err_msg.print("%s", buffer);
 
    95 }
 
    96 }
 
    96 
    97 
    97 // set a boolean global flag
 
    98 // set a boolean global flag
 
    98 Flag::Error WriteableFlags::set_bool_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
    99 JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
    99   if ((strcasecmp(arg, "true") == 0) || (*arg == '1' && *(arg + 1) == 0)) {
 
   100   if ((strcasecmp(arg, "true") == 0) || (*arg == '1' && *(arg + 1) == 0)) {
 
   100     return set_bool_flag(name, true, origin, err_msg);
 
   101     return set_bool_flag(name, true, origin, err_msg);
 
   101   } else if ((strcasecmp(arg, "false") == 0) || (*arg == '0' && *(arg + 1) == 0)) {
 
   102   } else if ((strcasecmp(arg, "false") == 0) || (*arg == '0' && *(arg + 1) == 0)) {
 
   102     return set_bool_flag(name, false, origin, err_msg);
 
   103     return set_bool_flag(name, false, origin, err_msg);
 
   103   }
 
   104   }
 
   104   err_msg.print("flag value must be a boolean (1/0 or true/false)");
 
   105   err_msg.print("flag value must be a boolean (1/0 or true/false)");
 
   105   return Flag::WRONG_FORMAT;
 
   106   return JVMFlag::WRONG_FORMAT;
 
   106 }
 
   107 }
 
   107 
   108 
   108 Flag::Error WriteableFlags::set_bool_flag(const char* name, bool value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   109 JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, bool value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   109   Flag::Error err = CommandLineFlags::boolAtPut(name, &value, origin);
 
   110   JVMFlag::Error err = JVMFlag::boolAtPut(name, &value, origin);
 
   110   print_flag_error_message_if_needed(err, name, err_msg);
 
   111   print_flag_error_message_if_needed(err, name, err_msg);
 
   111   return err;
 
   112   return err;
 
   112 }
 
   113 }
 
   113 
   114 
   114 // set a int global flag
 
   115 // set a int global flag
 
   115 Flag::Error WriteableFlags::set_int_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   116 JVMFlag::Error WriteableFlags::set_int_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   116   int value;
 
   117   int value;
 
   117 
   118 
   118   if (sscanf(arg, "%d", &value)) {
 
   119   if (sscanf(arg, "%d", &value)) {
 
   119     return set_int_flag(name, value, origin, err_msg);
 
   120     return set_int_flag(name, value, origin, err_msg);
 
   120   }
 
   121   }
 
   121   err_msg.print("flag value must be an integer");
 
   122   err_msg.print("flag value must be an integer");
 
   122   return Flag::WRONG_FORMAT;
 
   123   return JVMFlag::WRONG_FORMAT;
 
   123 }
 
   124 }
 
   124 
   125 
   125 Flag::Error WriteableFlags::set_int_flag(const char* name, int value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   126 JVMFlag::Error WriteableFlags::set_int_flag(const char* name, int value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   126   Flag::Error err = CommandLineFlags::intAtPut(name, &value, origin);
 
   127   JVMFlag::Error err = JVMFlag::intAtPut(name, &value, origin);
 
   127   print_flag_error_message_if_needed(err, name, err_msg);
 
   128   print_flag_error_message_if_needed(err, name, err_msg);
 
   128   return err;
 
   129   return err;
 
   129 }
 
   130 }
 
   130 
   131 
   131 // set a uint global flag
 
   132 // set a uint global flag
 
   132 Flag::Error WriteableFlags::set_uint_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   133 JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   133   uint value;
 
   134   uint value;
 
   134 
   135 
   135   if (sscanf(arg, "%u", &value)) {
 
   136   if (sscanf(arg, "%u", &value)) {
 
   136     return set_uint_flag(name, value, origin, err_msg);
 
   137     return set_uint_flag(name, value, origin, err_msg);
 
   137   }
 
   138   }
 
   138   err_msg.print("flag value must be an unsigned integer");
 
   139   err_msg.print("flag value must be an unsigned integer");
 
   139   return Flag::WRONG_FORMAT;
 
   140   return JVMFlag::WRONG_FORMAT;
 
   140 }
 
   141 }
 
   141 
   142 
   142 Flag::Error WriteableFlags::set_uint_flag(const char* name, uint value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   143 JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, uint value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   143   Flag::Error err = CommandLineFlags::uintAtPut(name, &value, origin);
 
   144   JVMFlag::Error err = JVMFlag::uintAtPut(name, &value, origin);
 
   144   print_flag_error_message_if_needed(err, name, err_msg);
 
   145   print_flag_error_message_if_needed(err, name, err_msg);
 
   145   return err;
 
   146   return err;
 
   146 }
 
   147 }
 
   147 
   148 
   148 // set a intx global flag
 
   149 // set a intx global flag
 
   149 Flag::Error WriteableFlags::set_intx_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   150 JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   150   intx value;
 
   151   intx value;
 
   151 
   152 
   152   if (sscanf(arg, INTX_FORMAT, &value)) {
 
   153   if (sscanf(arg, INTX_FORMAT, &value)) {
 
   153     return set_intx_flag(name, value, origin, err_msg);
 
   154     return set_intx_flag(name, value, origin, err_msg);
 
   154   }
 
   155   }
 
   155   err_msg.print("flag value must be an integer");
 
   156   err_msg.print("flag value must be an integer");
 
   156   return Flag::WRONG_FORMAT;
 
   157   return JVMFlag::WRONG_FORMAT;
 
   157 }
 
   158 }
 
   158 
   159 
   159 Flag::Error WriteableFlags::set_intx_flag(const char* name, intx value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   160 JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, intx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   160   Flag::Error err = CommandLineFlags::intxAtPut(name, &value, origin);
 
   161   JVMFlag::Error err = JVMFlag::intxAtPut(name, &value, origin);
 
   161   print_flag_error_message_if_needed(err, name, err_msg);
 
   162   print_flag_error_message_if_needed(err, name, err_msg);
 
   162   return err;
 
   163   return err;
 
   163 }
 
   164 }
 
   164 
   165 
   165 // set a uintx global flag
 
   166 // set a uintx global flag
 
   166 Flag::Error WriteableFlags::set_uintx_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   167 JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   167   uintx value;
 
   168   uintx value;
 
   168 
   169 
   169   if (sscanf(arg, UINTX_FORMAT, &value)) {
 
   170   if (sscanf(arg, UINTX_FORMAT, &value)) {
 
   170     return set_uintx_flag(name, value, origin, err_msg);
 
   171     return set_uintx_flag(name, value, origin, err_msg);
 
   171   }
 
   172   }
 
   172   err_msg.print("flag value must be an unsigned integer");
 
   173   err_msg.print("flag value must be an unsigned integer");
 
   173   return Flag::WRONG_FORMAT;
 
   174   return JVMFlag::WRONG_FORMAT;
 
   174 }
 
   175 }
 
   175 
   176 
   176 Flag::Error WriteableFlags::set_uintx_flag(const char* name, uintx value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   177 JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, uintx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   177   Flag::Error err = CommandLineFlags::uintxAtPut(name, &value, origin);
 
   178   JVMFlag::Error err = JVMFlag::uintxAtPut(name, &value, origin);
 
   178   print_flag_error_message_if_needed(err, name, err_msg);
 
   179   print_flag_error_message_if_needed(err, name, err_msg);
 
   179   return err;
 
   180   return err;
 
   180 }
 
   181 }
 
   181 
   182 
   182 // set a uint64_t global flag
 
   183 // set a uint64_t global flag
 
   183 Flag::Error WriteableFlags::set_uint64_t_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   184 JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   184   uint64_t value;
 
   185   uint64_t value;
 
   185 
   186 
   186   if (sscanf(arg, UINT64_FORMAT, &value)) {
 
   187   if (sscanf(arg, UINT64_FORMAT, &value)) {
 
   187     return set_uint64_t_flag(name, value, origin, err_msg);
 
   188     return set_uint64_t_flag(name, value, origin, err_msg);
 
   188   }
 
   189   }
 
   189   err_msg.print("flag value must be an unsigned 64-bit integer");
 
   190   err_msg.print("flag value must be an unsigned 64-bit integer");
 
   190   return Flag::WRONG_FORMAT;
 
   191   return JVMFlag::WRONG_FORMAT;
 
   191 }
 
   192 }
 
   192 
   193 
   193 Flag::Error WriteableFlags::set_uint64_t_flag(const char* name, uint64_t value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   194 JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, uint64_t value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   194   Flag::Error err = CommandLineFlags::uint64_tAtPut(name, &value, origin);
 
   195   JVMFlag::Error err = JVMFlag::uint64_tAtPut(name, &value, origin);
 
   195   print_flag_error_message_if_needed(err, name, err_msg);
 
   196   print_flag_error_message_if_needed(err, name, err_msg);
 
   196   return err;
 
   197   return err;
 
   197 }
 
   198 }
 
   198 
   199 
   199 // set a size_t global flag
 
   200 // set a size_t global flag
 
   200 Flag::Error WriteableFlags::set_size_t_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   201 JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   201   size_t value;
 
   202   size_t value;
 
   202 
   203 
   203   if (sscanf(arg, SIZE_FORMAT, &value)) {
 
   204   if (sscanf(arg, SIZE_FORMAT, &value)) {
 
   204     return set_size_t_flag(name, value, origin, err_msg);
 
   205     return set_size_t_flag(name, value, origin, err_msg);
 
   205   }
 
   206   }
 
   206   err_msg.print("flag value must be an unsigned integer");
 
   207   err_msg.print("flag value must be an unsigned integer");
 
   207   return Flag::WRONG_FORMAT;
 
   208   return JVMFlag::WRONG_FORMAT;
 
   208 }
 
   209 }
 
   209 
   210 
   210 Flag::Error WriteableFlags::set_size_t_flag(const char* name, size_t value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   211 JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, size_t value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   211   Flag::Error err = CommandLineFlags::size_tAtPut(name, &value, origin);
 
   212   JVMFlag::Error err = JVMFlag::size_tAtPut(name, &value, origin);
 
   212   print_flag_error_message_if_needed(err, name, err_msg);
 
   213   print_flag_error_message_if_needed(err, name, err_msg);
 
   213   return err;
 
   214   return err;
 
   214 }
 
   215 }
 
   215 
   216 
   216 // set a string global flag using value from AttachOperation
 
   217 // set a string global flag using value from AttachOperation
 
   217 Flag::Error WriteableFlags::set_ccstr_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   218 JVMFlag::Error WriteableFlags::set_ccstr_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   218   Flag::Error err = CommandLineFlags::ccstrAtPut((char*)name, &value, origin);
 
   219   JVMFlag::Error err = JVMFlag::ccstrAtPut((char*)name, &value, origin);
 
   219   print_flag_error_message_if_needed(err, name, err_msg);
 
   220   print_flag_error_message_if_needed(err, name, err_msg);
 
   220   return err;
 
   221   return err;
 
   221 }
 
   222 }
 
   222 
   223 
   223 /* sets a writeable flag to the provided value
 
   224 /* sets a writeable flag to the provided value
 
   224  *
 
   225  *
 
   225  * - return status is one of the WriteableFlags::err enum values
 
   226  * - return status is one of the WriteableFlags::err enum values
 
   226  * - an eventual error message will be generated to the provided err_msg buffer
 
   227  * - an eventual error message will be generated to the provided err_msg buffer
 
   227  */
 
   228  */
 
   228 Flag::Error WriteableFlags::set_flag(const char* flag_name, const char* flag_value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   229 JVMFlag::Error WriteableFlags::set_flag(const char* flag_name, const char* flag_value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   229   return set_flag(flag_name, &flag_value, set_flag_from_char, origin, err_msg);
 
   230   return set_flag(flag_name, &flag_value, set_flag_from_char, origin, err_msg);
 
   230 }
 
   231 }
 
   231 
   232 
   232 /* sets a writeable flag to the provided value
 
   233 /* sets a writeable flag to the provided value
 
   233  *
 
   234  *
 
   234  * - return status is one of the WriteableFlags::err enum values
 
   235  * - return status is one of the WriteableFlags::err enum values
 
   235  * - an eventual error message will be generated to the provided err_msg buffer
 
   236  * - an eventual error message will be generated to the provided err_msg buffer
 
   236  */
 
   237  */
 
   237 Flag::Error WriteableFlags::set_flag(const char* flag_name, jvalue flag_value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   238 JVMFlag::Error WriteableFlags::set_flag(const char* flag_name, jvalue flag_value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   238   return set_flag(flag_name, &flag_value, set_flag_from_jvalue, origin, err_msg);
 
   239   return set_flag(flag_name, &flag_value, set_flag_from_jvalue, origin, err_msg);
 
   239 }
 
   240 }
 
   240 
   241 
   241 // a writeable flag setter accepting either 'jvalue' or 'char *' values
 
   242 // a writeable flag setter accepting either 'jvalue' or 'char *' values
 
   242 Flag::Error WriteableFlags::set_flag(const char* name, const void* value, Flag::Error(*setter)(Flag*,const void*,Flag::Flags,FormatBuffer<80>&), Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   243 JVMFlag::Error WriteableFlags::set_flag(const char* name, const void* value, JVMFlag::Error(*setter)(JVMFlag*,const void*,JVMFlag::Flags,FormatBuffer<80>&), JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   243   if (name == NULL) {
 
   244   if (name == NULL) {
 
   244     err_msg.print("flag name is missing");
 
   245     err_msg.print("flag name is missing");
 
   245     return Flag::MISSING_NAME;
 
   246     return JVMFlag::MISSING_NAME;
 
   246   }
 
   247   }
 
   247   if (value == NULL) {
 
   248   if (value == NULL) {
 
   248     err_msg.print("flag value is missing");
 
   249     err_msg.print("flag value is missing");
 
   249     return Flag::MISSING_VALUE;
 
   250     return JVMFlag::MISSING_VALUE;
 
   250   }
 
   251   }
 
   251 
   252 
   252   Flag* f = Flag::find_flag((char*)name, strlen(name));
 
   253   JVMFlag* f = JVMFlag::find_flag((char*)name, strlen(name));
 
   253   if (f) {
 
   254   if (f) {
 
   254     // only writeable flags are allowed to be set
 
   255     // only writeable flags are allowed to be set
 
   255     if (f->is_writeable()) {
 
   256     if (f->is_writeable()) {
 
   256       return setter(f, value, origin, err_msg);
 
   257       return setter(f, value, origin, err_msg);
 
   257     } else {
 
   258     } else {
 
   258       err_msg.print("only 'writeable' flags can be set");
 
   259       err_msg.print("only 'writeable' flags can be set");
 
   259       return Flag::NON_WRITABLE;
 
   260       return JVMFlag::NON_WRITABLE;
 
   260     }
 
   261     }
 
   261   }
 
   262   }
 
   262 
   263 
   263   err_msg.print("flag %s does not exist", name);
 
   264   err_msg.print("flag %s does not exist", name);
 
   264   return Flag::INVALID_FLAG;
 
   265   return JVMFlag::INVALID_FLAG;
 
   265 }
 
   266 }
 
   266 
   267 
   267 // a writeable flag setter accepting 'char *' values
 
   268 // a writeable flag setter accepting 'char *' values
 
   268 Flag::Error WriteableFlags::set_flag_from_char(Flag* f, const void* value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
 
   269 JVMFlag::Error WriteableFlags::set_flag_from_char(JVMFlag* f, const void* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
 
   269   char* flag_value = *(char**)value;
 
   270   char* flag_value = *(char**)value;
 
   270   if (flag_value == NULL) {
 
   271   if (flag_value == NULL) {
 
   271     err_msg.print("flag value is missing");
 
   272     err_msg.print("flag value is missing");
 
   272     return Flag::MISSING_VALUE;
 
   273     return JVMFlag::MISSING_VALUE;
 
   273   }
 
   274   }
 
   274   if (f->is_bool()) {
 
   275   if (f->is_bool()) {
 
   275     return set_bool_flag(f->_name, flag_value, origin, err_msg);
 
   276     return set_bool_flag(f->_name, flag_value, origin, err_msg);
 
   276   } else if (f->is_int()) {
 
   277   } else if (f->is_int()) {
 
   277     return set_int_flag(f->_name, flag_value, origin, err_msg);
 
   278     return set_int_flag(f->_name, flag_value, origin, err_msg);
 
   288   } else if (f->is_ccstr()) {
 
   289   } else if (f->is_ccstr()) {
 
   289     return set_ccstr_flag(f->_name, flag_value, origin, err_msg);
 
   290     return set_ccstr_flag(f->_name, flag_value, origin, err_msg);
 
   290   } else {
 
   291   } else {
 
   291     ShouldNotReachHere();
 
   292     ShouldNotReachHere();
 
   292   }
 
   293   }
 
   293   return Flag::ERR_OTHER;
 
   294   return JVMFlag::ERR_OTHER;
 
   294 }
 
   295 }
 
   295 
   296 
   296 // a writeable flag setter accepting 'jvalue' values
 
   297 // a writeable flag setter accepting 'jvalue' values
 
   297 Flag::Error WriteableFlags::set_flag_from_jvalue(Flag* f, const void* value, Flag::Flags origin,
 
   298 JVMFlag::Error WriteableFlags::set_flag_from_jvalue(JVMFlag* f, const void* value, JVMFlag::Flags origin,
 
   298                                                  FormatBuffer<80>& err_msg) {
 
   299                                                  FormatBuffer<80>& err_msg) {
 
   299   jvalue new_value = *(jvalue*)value;
 
   300   jvalue new_value = *(jvalue*)value;
 
   300   if (f->is_bool()) {
 
   301   if (f->is_bool()) {
 
   301     bool bvalue = (new_value.z == JNI_TRUE ? true : false);
 
   302     bool bvalue = (new_value.z == JNI_TRUE ? true : false);
 
   302     return set_bool_flag(f->_name, bvalue, origin, err_msg);
 
   303     return set_bool_flag(f->_name, bvalue, origin, err_msg);
 
   320     return set_size_t_flag(f->_name, svalue, origin, err_msg);
 
   321     return set_size_t_flag(f->_name, svalue, origin, err_msg);
 
   321   } else if (f->is_ccstr()) {
 
   322   } else if (f->is_ccstr()) {
 
   322     oop str = JNIHandles::resolve_external_guard(new_value.l);
 
   323     oop str = JNIHandles::resolve_external_guard(new_value.l);
 
   323     if (str == NULL) {
 
   324     if (str == NULL) {
 
   324       err_msg.print("flag value is missing");
 
   325       err_msg.print("flag value is missing");
 
   325       return Flag::MISSING_VALUE;
 
   326       return JVMFlag::MISSING_VALUE;
 
   326     }
 
   327     }
 
   327     ccstr svalue = java_lang_String::as_utf8_string(str);
 
   328     ccstr svalue = java_lang_String::as_utf8_string(str);
 
   328     Flag::Error ret = WriteableFlags::set_ccstr_flag(f->_name, svalue, origin, err_msg);
 
   329     JVMFlag::Error ret = WriteableFlags::set_ccstr_flag(f->_name, svalue, origin, err_msg);
 
   329     if (ret != Flag::SUCCESS) {
 
   330     if (ret != JVMFlag::SUCCESS) {
 
   330       FREE_C_HEAP_ARRAY(char, svalue);
 
   331       FREE_C_HEAP_ARRAY(char, svalue);
 
   331     }
 
   332     }
 
   332     return ret;
 
   333     return ret;
 
   333   } else {
 
   334   } else {
 
   334     ShouldNotReachHere();
 
   335     ShouldNotReachHere();
 
   335   }
 
   336   }
 
   336   return Flag::ERR_OTHER;
 
   337   return JVMFlag::ERR_OTHER;
 
   337 }
 
   338 }
jdk-sandbox