958       return real_name;
 959     case 1: {
 960       if (warn) {
 961         char version[256];
 962         since.to_string(version, sizeof(version));
 963         if (real_name != arg) {
 964           warning("Option %s was deprecated in version %s and will likely be removed in a future release. Use option %s instead.",
 965                   arg, version, real_name);
 966         } else {
 967           warning("Option %s was deprecated in version %s and will likely be removed in a future release.",
 968                   arg, version);
 969         }
 970       }
 971       return real_name;
 972     }
 973   }
 974   ShouldNotReachHere();
 975   return NULL;
 976 }
 977 
 978 AliasedLoggingFlag Arguments::catch_logging_aliases(const char* name){























 979   for (size_t i = 0; aliased_logging_flags[i].alias_name != NULL; i++) {
 980     const AliasedLoggingFlag& alf = aliased_logging_flags[i];
 981     if (strcmp(alf.alias_name, name) == 0) {

 982       return alf;
 983     }
 984   }
 985   AliasedLoggingFlag a = {NULL, LogLevel::Off, false, LOG_TAGS(_NO_TAG)};
 986   return a;
 987 }
 988 
 989 bool Arguments::parse_argument(const char* arg, Flag::Flags origin) {
 990 
 991   // range of acceptable characters spelled out for portability reasons
 992 #define NAME_RANGE  "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]"
 993 #define BUFLEN 255
 994   char name[BUFLEN+1];
 995   char dummy;
 996   const char* real_name;
 997   bool warn_if_deprecated = true;
 998 
 999   if (sscanf(arg, "-%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) {
1000     AliasedLoggingFlag alf = catch_logging_aliases(name);
1001     if (alf.alias_name != NULL){
1002       LogConfiguration::configure_stdout(LogLevel::Off, alf.exactMatch, alf.tag0, alf.tag1, alf.tag2, alf.tag3, alf.tag4, alf.tag5);
1003       return true;
1004     }
1005     real_name = handle_aliases_and_deprecation(name, warn_if_deprecated);
1006     if (real_name == NULL) {
1007       return false;
1008     }
1009     return set_bool_flag(real_name, false, origin);
1010   }
1011   if (sscanf(arg, "+%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) {
1012     AliasedLoggingFlag alf = catch_logging_aliases(name);
1013     if (alf.alias_name != NULL){
1014       LogConfiguration::configure_stdout(alf.level, alf.exactMatch, alf.tag0, alf.tag1, alf.tag2, alf.tag3, alf.tag4, alf.tag5);
1015       return true;
1016     }
1017     real_name = handle_aliases_and_deprecation(name, warn_if_deprecated);
1018     if (real_name == NULL) {
1019       return false;
1020     }
1021     return set_bool_flag(real_name, true, origin);
1022   }
1023 
1024   char punct;
1025   if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "%c", name, &punct) == 2 && punct == '=') {
1026     const char* value = strchr(arg, '=') + 1;
1027     Flag* flag;
1028 
1029     // this scanf pattern matches both strings (handled here) and numbers (handled later))
1030     real_name = handle_aliases_and_deprecation(name, warn_if_deprecated);
1031     if (real_name == NULL) {
1032       return false;

1208   } else {
1209     arg_len = equal_sign - argname;
1210   }
1211 
1212   // Only make the obsolete check for valid arguments.
1213   if (arg_len <= BUFLEN) {
1214     // Construct a string which consists only of the argument name without '+', '-', or '='.
1215     char stripped_argname[BUFLEN+1];
1216     strncpy(stripped_argname, argname, arg_len);
1217     stripped_argname[arg_len] = '\0';  // strncpy may not null terminate.
1218     if (is_obsolete_flag(stripped_argname, &since)) {
1219       char version[256];
1220       since.to_string(version, sizeof(version));
1221       warning("Ignoring option %s; support was removed in %s", stripped_argname, version);
1222       return true;
1223     }
1224 #ifndef PRODUCT
1225     else {
1226       const char* replacement;
1227       if ((replacement = removed_develop_logging_flag_name(stripped_argname)) != NULL){
1228         jio_fprintf(defaultStream::error_stream(),
1229                   "%s has been removed. Please use %s instead.\n", stripped_argname, replacement);

1230         return false;
1231       }
1232     }
1233 #endif //PRODUCT
1234   }
1235 
1236   // For locked flags, report a custom error message if available.
1237   // Otherwise, report the standard unrecognized VM option.
1238   Flag* found_flag = Flag::find_flag((const char*)argname, arg_len, true, true);
1239   if (found_flag != NULL) {
1240     char locked_message_buf[BUFLEN];
1241     Flag::MsgType msg_type = found_flag->get_locked_message(locked_message_buf, BUFLEN);
1242     if (strlen(locked_message_buf) == 0) {
1243       if (found_flag->is_bool() && !has_plus_minus) {
1244         jio_fprintf(defaultStream::error_stream(),
1245           "Missing +/- setting for VM option '%s'\n", argname);
1246       } else if (!found_flag->is_bool() && has_plus_minus) {
1247         jio_fprintf(defaultStream::error_stream(),
1248           "Unexpected +/- setting in VM option '%s'\n", argname);
1249       } else {

 958       return real_name;
 959     case 1: {
 960       if (warn) {
 961         char version[256];
 962         since.to_string(version, sizeof(version));
 963         if (real_name != arg) {
 964           warning("Option %s was deprecated in version %s and will likely be removed in a future release. Use option %s instead.",
 965                   arg, version, real_name);
 966         } else {
 967           warning("Option %s was deprecated in version %s and will likely be removed in a future release.",
 968                   arg, version);
 969         }
 970       }
 971       return real_name;
 972     }
 973   }
 974   ShouldNotReachHere();
 975   return NULL;
 976 }
 977 
 978 void log_deprecated_flag( const char* name, const char* pref, AliasedLoggingFlag alf) {
 979   LogTagType tagSet[] = {alf.tag0, alf.tag1, alf.tag2, alf.tag3, alf.tag4, alf.tag5};
 980   // Set tagset string buffer at max size of 256, large enough for any alias tagset
 981   int max_tagset_size = 256;
 982   char tagset_buffer[max_tagset_size];
 983   tagset_buffer[0] = '\0';
 984 
 985   // Write tag-set for aliased logging option, in string list form
 986   int max_tags = sizeof(tagSet)/sizeof(tagSet[0]);
 987   for (int i = 0; i < max_tags && tagSet[i] != LogTag::__NO_TAG; i++) {
 988     if (i > 0) {
 989       strncat(tagset_buffer, ",", 1);
 990     }
 991     strncat(tagset_buffer, LogTag::name(tagSet[i]), max_tagset_size - strlen(tagset_buffer) - 1);
 992   }
 993 
 994   log_warning(arguments)("-XX:%s%s is deprecated. Will use -Xlog:%s=%s instead.",
 995                          pref,
 996                          name,
 997                          tagset_buffer,
 998                          (pref == "-") ? "off" : LogLevel::name(alf.level));
 999 }
1000 
1001 AliasedLoggingFlag Arguments::catch_logging_aliases(const char* name, const char* pref){
1002   for (size_t i = 0; aliased_logging_flags[i].alias_name != NULL; i++) {
1003     const AliasedLoggingFlag& alf = aliased_logging_flags[i];
1004     if (strcmp(alf.alias_name, name) == 0) {
1005       log_deprecated_flag(name, pref, alf);
1006       return alf;
1007     }
1008   }
1009   AliasedLoggingFlag a = {NULL, LogLevel::Off, false, LOG_TAGS(_NO_TAG)};
1010   return a;
1011 }
1012 
1013 bool Arguments::parse_argument(const char* arg, Flag::Flags origin) {
1014 
1015   // range of acceptable characters spelled out for portability reasons
1016 #define NAME_RANGE  "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]"
1017 #define BUFLEN 255
1018   char name[BUFLEN+1];
1019   char dummy;
1020   const char* real_name;
1021   bool warn_if_deprecated = true;
1022 
1023   if (sscanf(arg, "-%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) {
1024     AliasedLoggingFlag alf = catch_logging_aliases(name, "-");
1025     if (alf.alias_name != NULL){
1026       LogConfiguration::configure_stdout(LogLevel::Off, alf.exactMatch, alf.tag0, alf.tag1, alf.tag2, alf.tag3, alf.tag4, alf.tag5);
1027       return true;
1028     }
1029     real_name = handle_aliases_and_deprecation(name, warn_if_deprecated);
1030     if (real_name == NULL) {
1031       return false;
1032     }
1033     return set_bool_flag(real_name, false, origin);
1034   }
1035   if (sscanf(arg, "+%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) {
1036     AliasedLoggingFlag alf = catch_logging_aliases(name, "+");
1037     if (alf.alias_name != NULL){
1038       LogConfiguration::configure_stdout(alf.level, alf.exactMatch, alf.tag0, alf.tag1, alf.tag2, alf.tag3, alf.tag4, alf.tag5);
1039       return true;
1040     }
1041     real_name = handle_aliases_and_deprecation(name, warn_if_deprecated);
1042     if (real_name == NULL) {
1043       return false;
1044     }
1045     return set_bool_flag(real_name, true, origin);
1046   }
1047 
1048   char punct;
1049   if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "%c", name, &punct) == 2 && punct == '=') {
1050     const char* value = strchr(arg, '=') + 1;
1051     Flag* flag;
1052 
1053     // this scanf pattern matches both strings (handled here) and numbers (handled later))
1054     real_name = handle_aliases_and_deprecation(name, warn_if_deprecated);
1055     if (real_name == NULL) {
1056       return false;

1232   } else {
1233     arg_len = equal_sign - argname;
1234   }
1235 
1236   // Only make the obsolete check for valid arguments.
1237   if (arg_len <= BUFLEN) {
1238     // Construct a string which consists only of the argument name without '+', '-', or '='.
1239     char stripped_argname[BUFLEN+1];
1240     strncpy(stripped_argname, argname, arg_len);
1241     stripped_argname[arg_len] = '\0';  // strncpy may not null terminate.
1242     if (is_obsolete_flag(stripped_argname, &since)) {
1243       char version[256];
1244       since.to_string(version, sizeof(version));
1245       warning("Ignoring option %s; support was removed in %s", stripped_argname, version);
1246       return true;
1247     }
1248 #ifndef PRODUCT
1249     else {
1250       const char* replacement;
1251       if ((replacement = removed_develop_logging_flag_name(stripped_argname)) != NULL){
1252         log_warning(arguments)("%s has been removed. Please use %s instead.",
1253                                stripped_argname,
1254                                replacement);
1255         return false;
1256       }
1257     }
1258 #endif //PRODUCT
1259   }
1260 
1261   // For locked flags, report a custom error message if available.
1262   // Otherwise, report the standard unrecognized VM option.
1263   Flag* found_flag = Flag::find_flag((const char*)argname, arg_len, true, true);
1264   if (found_flag != NULL) {
1265     char locked_message_buf[BUFLEN];
1266     Flag::MsgType msg_type = found_flag->get_locked_message(locked_message_buf, BUFLEN);
1267     if (strlen(locked_message_buf) == 0) {
1268       if (found_flag->is_bool() && !has_plus_minus) {
1269         jio_fprintf(defaultStream::error_stream(),
1270           "Missing +/- setting for VM option '%s'\n", argname);
1271       } else if (!found_flag->is_bool() && has_plus_minus) {
1272         jio_fprintf(defaultStream::error_stream(),
1273           "Unexpected +/- setting in VM option '%s'\n", argname);
1274       } else {