/*

 * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_arguments.cpp.incl"

#define DEFAULT_VENDOR_URL_BUG "http://java.sun.com/webapps/bugreport/crash.jsp"

#define DEFAULT_JAVA_LAUNCHER  "generic"

char**  Arguments::_jvm_flags_array             = NULL;

int     Arguments::_num_jvm_flags               = 0;

char**  Arguments::_jvm_args_array              = NULL;

int     Arguments::_num_jvm_args                = 0;

char*  Arguments::_java_command                 = NULL;

SystemProperty* Arguments::_system_properties   = NULL;

const char*  Arguments::_gc_log_filename        = NULL;

bool   Arguments::_has_profile                  = false;

bool   Arguments::_has_alloc_profile            = false;

uintx  Arguments::_initial_heap_size            = 0;

uintx  Arguments::_min_heap_size                = 0;

Arguments::Mode Arguments::_mode                = _mixed;

bool   Arguments::_java_compiler                = false;

bool   Arguments::_xdebug_mode                  = false;

const char*  Arguments::_java_vendor_url_bug    = DEFAULT_VENDOR_URL_BUG;

const char*  Arguments::_sun_java_launcher      = DEFAULT_JAVA_LAUNCHER;

int    Arguments::_sun_java_launcher_pid        = -1;

// These parameters are reset in method parse_vm_init_args(JavaVMInitArgs*)

bool   Arguments::_AlwaysCompileLoopMethods     = AlwaysCompileLoopMethods;

bool   Arguments::_UseOnStackReplacement        = UseOnStackReplacement;

bool   Arguments::_BackgroundCompilation        = BackgroundCompilation;

bool   Arguments::_ClipInlining                 = ClipInlining;

intx   Arguments::_Tier2CompileThreshold        = Tier2CompileThreshold;

char*  Arguments::SharedArchivePath             = NULL;

AgentLibraryList Arguments::_libraryList;

AgentLibraryList Arguments::_agentList;

abort_hook_t     Arguments::_abort_hook         = NULL;

exit_hook_t      Arguments::_exit_hook          = NULL;

vfprintf_hook_t  Arguments::_vfprintf_hook      = NULL;

SystemProperty *Arguments::_java_ext_dirs = NULL;

SystemProperty *Arguments::_java_endorsed_dirs = NULL;

SystemProperty *Arguments::_sun_boot_library_path = NULL;

SystemProperty *Arguments::_java_library_path = NULL;

SystemProperty *Arguments::_java_home = NULL;

SystemProperty *Arguments::_java_class_path = NULL;

SystemProperty *Arguments::_sun_boot_class_path = NULL;

char* Arguments::_meta_index_path = NULL;

char* Arguments::_meta_index_dir = NULL;

static bool force_client_mode = false;

// Check if head of 'option' matches 'name', and sets 'tail' remaining part of option string

static bool match_option(const JavaVMOption *option, const char* name,

                         const char** tail) {

  int len = (int)strlen(name);

  if (strncmp(option->optionString, name, len) == 0) {

    *tail = option->optionString + len;

    return true;

  } else {

    return false;

  }

}

static void logOption(const char* opt) {

  if (PrintVMOptions) {

    jio_fprintf(defaultStream::output_stream(), "VM option '%s'\n", opt);

  }

}

// Process java launcher properties.

void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {

  // See if sun.java.launcher or sun.java.launcher.pid is defined.

  // Must do this before setting up other system properties,

  // as some of them may depend on launcher type.

  for (int index = 0; index < args->nOptions; index++) {

    const JavaVMOption* option = args->options + index;

    const char* tail;

    if (match_option(option, "-Dsun.java.launcher=", &tail)) {

      process_java_launcher_argument(tail, option->extraInfo);

      continue;

    }

    if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) {

      _sun_java_launcher_pid = atoi(tail);

      continue;

    }

  }

}

// Initialize system properties key and value.

void Arguments::init_system_properties() {

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.version", "1.0", false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name",

                                                                 "Java Virtual Machine Specification",  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.vendor",

                                                                 "Sun Microsystems Inc.",  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(),  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(),  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(),  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(),  true));

  // following are JVMTI agent writeable properties.

  // Properties values are set to NULL and they are

  // os specific they are initialized in os::init_system_properties_values().

  _java_ext_dirs = new SystemProperty("java.ext.dirs", NULL,  true);

  _java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL,  true);

  _sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL,  true);

  _java_library_path = new SystemProperty("java.library.path", NULL,  true);

  _java_home =  new SystemProperty("java.home", NULL,  true);

  _sun_boot_class_path = new SystemProperty("sun.boot.class.path", NULL,  true);

  _java_class_path = new SystemProperty("java.class.path", "",  true);

  // Add to System Property list.

  PropertyList_add(&_system_properties, _java_ext_dirs);

  PropertyList_add(&_system_properties, _java_endorsed_dirs);

  PropertyList_add(&_system_properties, _sun_boot_library_path);

  PropertyList_add(&_system_properties, _java_library_path);

  PropertyList_add(&_system_properties, _java_home);

  PropertyList_add(&_system_properties, _java_class_path);

  PropertyList_add(&_system_properties, _sun_boot_class_path);

  // Set OS specific system properties values

  os::init_system_properties_values();

}

// String containing commands that will be ignored and cause a

// warning to be issued.  These commands should be accepted

// for 1.6 but not 1.7.  The string should be cleared at the

// beginning of 1.7.

static const char*  obsolete_jvm_flags_1_5_0[] = {

                                           "UseTrainGC",

                                           "UseSpecialLargeObjectHandling",

                                           "UseOversizedCarHandling",

                                           "TraceCarAllocation",

                                           "PrintTrainGCProcessingStats",

                                           "LogOfCarSpaceSize",

                                           "OversizedCarThreshold",

                                           "MinTickInterval",

                                           "DefaultTickInterval",

                                           "MaxTickInterval",

                                           "DelayTickAdjustment",

                                           "ProcessingToTenuringRatio",

                                           "MinTrainLength",

                                           0};

bool Arguments::made_obsolete_in_1_5_0(const char *s) {

  int i = 0;

  while (obsolete_jvm_flags_1_5_0[i] != NULL) {

    // <flag>=xxx form

    // [-|+]<flag> form

    if ((strncmp(obsolete_jvm_flags_1_5_0[i], s,

               strlen(obsolete_jvm_flags_1_5_0[i])) == 0) ||

        ((s[0] == '+' || s[0] == '-') &&

        (strncmp(obsolete_jvm_flags_1_5_0[i], &s[1],

               strlen(obsolete_jvm_flags_1_5_0[i])) == 0))) {

      return true;

    }

    i++;

  }

  return false;

}

// Constructs the system class path (aka boot class path) from the following

// components, in order:

//

//     prefix           // from -Xbootclasspath/p:...

//     endorsed         // the expansion of -Djava.endorsed.dirs=...

//     base             // from os::get_system_properties() or -Xbootclasspath=

//     suffix           // from -Xbootclasspath/a:...

//

// java.endorsed.dirs is a list of directories; any jar or zip files in the

// directories are added to the sysclasspath just before the base.

//

// This could be AllStatic, but it isn't needed after argument processing is

// complete.

class SysClassPath: public StackObj {

public:

  SysClassPath(const char* base);

  ~SysClassPath();

  inline void set_base(const char* base);

  inline void add_prefix(const char* prefix);

  inline void add_suffix(const char* suffix);

  inline void reset_path(const char* base);

  // Expand the jar/zip files in each directory listed by the java.endorsed.dirs

  // property.  Must be called after all command-line arguments have been

  // processed (in particular, -Djava.endorsed.dirs=...) and before calling

  // combined_path().

  void expand_endorsed();

  inline const char* get_base()     const { return _items[_scp_base]; }

  inline const char* get_prefix()   const { return _items[_scp_prefix]; }

  inline const char* get_suffix()   const { return _items[_scp_suffix]; }

  inline const char* get_endorsed() const { return _items[_scp_endorsed]; }

  // Combine all the components into a single c-heap-allocated string; caller

  // must free the string if/when no longer needed.

  char* combined_path();

private:

  // Utility routines.

  static char* add_to_path(const char* path, const char* str, bool prepend);

  static char* add_jars_to_path(char* path, const char* directory);

  inline void reset_item_at(int index);

  // Array indices for the items that make up the sysclasspath.  All except the

  // base are allocated in the C heap and freed by this class.

  enum {

    _scp_prefix,        // from -Xbootclasspath/p:...

    _scp_endorsed,      // the expansion of -Djava.endorsed.dirs=...

    _scp_base,          // the default sysclasspath

    _scp_suffix,        // from -Xbootclasspath/a:...

    _scp_nitems         // the number of items, must be last.

  };

  const char* _items[_scp_nitems];

  DEBUG_ONLY(bool _expansion_done;)

};

SysClassPath::SysClassPath(const char* base) {

  memset(_items, 0, sizeof(_items));

  _items[_scp_base] = base;

  DEBUG_ONLY(_expansion_done = false;)

}

SysClassPath::~SysClassPath() {

  // Free everything except the base.

  for (int i = 0; i < _scp_nitems; ++i) {

    if (i != _scp_base) reset_item_at(i);

  }

  DEBUG_ONLY(_expansion_done = false;)

}

inline void SysClassPath::set_base(const char* base) {

  _items[_scp_base] = base;

}

inline void SysClassPath::add_prefix(const char* prefix) {

  _items[_scp_prefix] = add_to_path(_items[_scp_prefix], prefix, true);

}

inline void SysClassPath::add_suffix(const char* suffix) {

  _items[_scp_suffix] = add_to_path(_items[_scp_suffix], suffix, false);

}

inline void SysClassPath::reset_item_at(int index) {

  assert(index < _scp_nitems && index != _scp_base, "just checking");

  if (_items[index] != NULL) {

    FREE_C_HEAP_ARRAY(char, _items[index]);

    _items[index] = NULL;

  }

}

inline void SysClassPath::reset_path(const char* base) {

  // Clear the prefix and suffix.

  reset_item_at(_scp_prefix);

  reset_item_at(_scp_suffix);

  set_base(base);

}

//------------------------------------------------------------------------------

void SysClassPath::expand_endorsed() {

  assert(_items[_scp_endorsed] == NULL, "can only be called once.");

  const char* path = Arguments::get_property("java.endorsed.dirs");

  if (path == NULL) {

    path = Arguments::get_endorsed_dir();

    assert(path != NULL, "no default for java.endorsed.dirs");

  }

  char* expanded_path = NULL;

  const char separator = *os::path_separator();

  const char* const end = path + strlen(path);

  while (path < end) {

    const char* tmp_end = strchr(path, separator);

    if (tmp_end == NULL) {

      expanded_path = add_jars_to_path(expanded_path, path);

      path = end;

    } else {

      char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1);

      memcpy(dirpath, path, tmp_end - path);

      dirpath[tmp_end - path] = '\0';

      expanded_path = add_jars_to_path(expanded_path, dirpath);

      FREE_C_HEAP_ARRAY(char, dirpath);

      path = tmp_end + 1;

    }

  }

  _items[_scp_endorsed] = expanded_path;

  DEBUG_ONLY(_expansion_done = true;)

}

// Combine the bootclasspath elements, some of which may be null, into a single

// c-heap-allocated string.

char* SysClassPath::combined_path() {

  assert(_items[_scp_base] != NULL, "empty default sysclasspath");

  assert(_expansion_done, "must call expand_endorsed() first.");

  size_t lengths[_scp_nitems];

  size_t total_len = 0;

  const char separator = *os::path_separator();

  // Get the lengths.

  int i;

  for (i = 0; i < _scp_nitems; ++i) {

    if (_items[i] != NULL) {

      lengths[i] = strlen(_items[i]);

      // Include space for the separator char (or a NULL for the last item).

      total_len += lengths[i] + 1;

    }

  }

  assert(total_len > 0, "empty sysclasspath not allowed");

  // Copy the _items to a single string.

  char* cp = NEW_C_HEAP_ARRAY(char, total_len);

  char* cp_tmp = cp;

  for (i = 0; i < _scp_nitems; ++i) {

    if (_items[i] != NULL) {

      memcpy(cp_tmp, _items[i], lengths[i]);

      cp_tmp += lengths[i];

      *cp_tmp++ = separator;

    }

  }

  *--cp_tmp = '\0';     // Replace the extra separator.

  return cp;

}

// Note:  path must be c-heap-allocated (or NULL); it is freed if non-null.

char*

SysClassPath::add_to_path(const char* path, const char* str, bool prepend) {

  char *cp;

  assert(str != NULL, "just checking");

  if (path == NULL) {

    size_t len = strlen(str) + 1;

    cp = NEW_C_HEAP_ARRAY(char, len);

    memcpy(cp, str, len);                       // copy the trailing null

  } else {

    const char separator = *os::path_separator();

    size_t old_len = strlen(path);

    size_t str_len = strlen(str);

    size_t len = old_len + str_len + 2;

    if (prepend) {

      cp = NEW_C_HEAP_ARRAY(char, len);

      char* cp_tmp = cp;

      memcpy(cp_tmp, str, str_len);

      cp_tmp += str_len;

      *cp_tmp = separator;

      memcpy(++cp_tmp, path, old_len + 1);      // copy the trailing null

      FREE_C_HEAP_ARRAY(char, path);

    } else {

      cp = REALLOC_C_HEAP_ARRAY(char, path, len);

      char* cp_tmp = cp + old_len;

      *cp_tmp = separator;

      memcpy(++cp_tmp, str, str_len + 1);       // copy the trailing null

    }

  }

  return cp;

}

// Scan the directory and append any jar or zip files found to path.

// Note:  path must be c-heap-allocated (or NULL); it is freed if non-null.

char* SysClassPath::add_jars_to_path(char* path, const char* directory) {

  DIR* dir = os::opendir(directory);

  if (dir == NULL) return path;

  char dir_sep[2] = { '\0', '\0' };

  size_t directory_len = strlen(directory);

  const char fileSep = *os::file_separator();

  if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep;

  /* Scan the directory for jars/zips, appending them to path. */

  struct dirent *entry;

  char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory));

  while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) {

    const char* name = entry->d_name;

    const char* ext = name + strlen(name) - 4;

    bool isJarOrZip = ext > name &&

      (os::file_name_strcmp(ext, ".jar") == 0 ||

       os::file_name_strcmp(ext, ".zip") == 0);

    if (isJarOrZip) {

      char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name));

      sprintf(jarpath, "%s%s%s", directory, dir_sep, name);

      path = add_to_path(path, jarpath, false);

      FREE_C_HEAP_ARRAY(char, jarpath);

    }

  }

  FREE_C_HEAP_ARRAY(char, dbuf);

  os::closedir(dir);

  return path;

}

// Parses a memory size specification string.

static bool atomll(const char *s, jlong* result) {

  jlong n = 0;

  int args_read = sscanf(s, os::jlong_format_specifier(), &n);

  if (args_read != 1) {

    return false;

  }

  while (*s != '\0' && isdigit(*s)) {

    s++;

  }

  // 4705540: illegal if more characters are found after the first non-digit

  if (strlen(s) > 1) {

    return false;

  }

  switch (*s) {

    case 'T': case 't':

      *result = n * G * K;

      return true;

    case 'G': case 'g':

      *result = n * G;

      return true;

    case 'M': case 'm':

      *result = n * M;

      return true;

    case 'K': case 'k':

      *result = n * K;

      return true;

    case '\0':

      *result = n;

      return true;

    default:

      return false;

  }

}

Arguments::ArgsRange Arguments::check_memory_size(jlong size, jlong min_size) {

  if (size < min_size) return arg_too_small;

  // Check that size will fit in a size_t (only relevant on 32-bit)

  if ((julong) size > max_uintx) return arg_too_big;

  return arg_in_range;

}

// Describe an argument out of range error

void Arguments::describe_range_error(ArgsRange errcode) {

  switch(errcode) {

  case arg_too_big:

    jio_fprintf(defaultStream::error_stream(),

                "The specified size exceeds the maximum "

                "representable size.\n");

    break;

  case arg_too_small:

  case arg_unreadable:

  case arg_in_range:

    // do nothing for now

    break;

  default:

    ShouldNotReachHere();

  }

}

static bool set_bool_flag(char* name, bool value, FlagValueOrigin origin) {

  return CommandLineFlags::boolAtPut(name, &value, origin);

}

static bool set_fp_numeric_flag(char* name, char* value, FlagValueOrigin origin) {

  double v;

  if (sscanf(value, "%lf", &v) != 1) {

    return false;

  }

  if (CommandLineFlags::doubleAtPut(name, &v, origin)) {

    return true;

  }

  return false;

}

static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) {

  jlong v;

  intx intx_v;

  bool is_neg = false;

  // Check the sign first since atomll() parses only unsigned values.

  if (*value == '-') {

    if (!CommandLineFlags::intxAt(name, &intx_v)) {

      return false;

    }

    value++;

    is_neg = true;

  }

  if (!atomll(value, &v)) {

    return false;

  }

  intx_v = (intx) v;

  if (is_neg) {

    intx_v = -intx_v;

  }

  if (CommandLineFlags::intxAtPut(name, &intx_v, origin)) {

    return true;

  }

  uintx uintx_v = (uintx) v;

  if (!is_neg && CommandLineFlags::uintxAtPut(name, &uintx_v, origin)) {