yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[multiple changes]

Browse Source 
2005-04-25  Archie Cobbs  <archie@dellroad.org>

	* java/lang/Throwable.java: simplify initializing cause in constructor

2005-04-25  Michael Koch  <konqueror@gmx.de>

	* gnu/classpath/SystemProperties.java: New file.
	* gnu/classpath/natSystemProperties.cc: New file.
	* java/lang/Runtime.java
	(defaultProperties): Removed.
	(static): Likewise.
	(): Made thrown exceptions more verbose.
	(insertSystemProperties): Removed.
	* java/lang/System.java
	(static): Likewise.
	(properties): Likewise.
	(setSecurityManager): Reordered modifiers.
	(getenv): Improved javadoc.
	(): Likewise.
	(isWordsBigEndian): Removed.
	* java/lang/natRuntime.cc
	(_Jv_SetDLLSearchPath): Likewise.
	(file_encoding): Likewise.
	(default_file_encoding): Likewise.
	(getpwuid_adaptor): Likewise.
	(insertSystemProperties): Likewise.
	* java/lang/natSystem.cc
	(isWordsBigEndian): Likewise.
	* Makefile.am
	(ordinary_java_source_files):
	Added gnu/classpath/SystemProperties.java.
	(nat_source_files): Added gnu/classpath/natSystemProperties.cc.
	* Makefile.in: Regenerated.

From-SVN: r98734
This commit is contained in:
Michael Koch
2005-04-25 19:48:35 +00:00
parent 8efae6bbfa
commit ee141b8822
10 changed files with 641 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/gnu/classpath/SystemProperties.java
+154
View File
@@ -0,0 +1,154 @@
/* SystemProperties.java -- Manage the System properties.
Copyright (C) 2004, 2005 Free Software Foundation
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.classpath;
import java.util.Properties;
/**
* The class manages the System properties. This class is only available to
* privileged code (i.e. code loaded by the bootstrap class loader) and
* therefore doesn't do any security checks.
* This class is separated out from java.lang.System to simplify bootstrap
* dependencies and to allow trusted code a simple and efficient mechanism
* to access the system properties.
*/
public class SystemProperties
{
/**
* Stores the current system properties. This can be modified by
* {@link #setProperties(Properties)}, but will never be null, because
* setProperties(null) sucks in the default properties.
*/
private static Properties properties;
/**
* The default properties. Once the default is stabilized,
* it should not be modified;
* instead it is cloned when calling <code>setProperties(null)</code>.
*/
private static final Properties defaultProperties = new Properties();
private static native void insertSystemProperties(Properties properties);
static
{
insertSystemProperties(defaultProperties);
// Set base URL if not already set.
if (defaultProperties.get("gnu.classpath.home.url") == null)
defaultProperties.put("gnu.classpath.home.url",
"file://"
+ defaultProperties.get("gnu.classpath.home")
+ "/lib");
// Set short name if not already set.
if (defaultProperties.get("gnu.classpath.vm.shortname") == null)
{
String value = defaultProperties.getProperty("java.vm.name");
int index = value.lastIndexOf(' ');
if (index != -1)
value = value.substring(index + 1);
defaultProperties.put("gnu.classpath.vm.shortname", value);
}
// Network properties
if (defaultProperties.get("http.agent") == null)
{
String userAgent = ("gnu-classpath/"
+ defaultProperties.getProperty("gnu.classpath.version")
+ " ("
+ defaultProperties.getProperty("gnu.classpath.vm.shortname")
+ "/"
+ defaultProperties.getProperty("java.vm.version")
+ ")");
defaultProperties.put("http.agent", userAgent);
}
defaultProperties.put("gnu.cpu.endian",
isWordsBigEndian() ? "big" : "little");
// XXX FIXME - Temp hack for old systems that set the wrong property
if (defaultProperties.get("java.io.tmpdir") == null)
defaultProperties.put("java.io.tmpdir",
defaultProperties.get("java.tmpdir"));
// Note that we use clone here and not new. Some programs assume
// that the system properties do not have a parent.
properties = (Properties) defaultProperties.clone();
}
public static String getProperty(String name)
{
return properties.getProperty(name);
}
public static String getProperty(String name, String defaultValue)
{
return properties.getProperty(name, defaultValue);
}
public static String setProperty(String name, String value)
{
return (String) properties.setProperty(name, value);
}
public static Properties getProperties()
{
return properties;
}
public static void setProperties(Properties properties)
{
if (properties == null)
{
// Note that we use clone here and not new. Some programs
// assume that the system properties do not have a parent.
properties = (Properties)defaultProperties.clone();
}
SystemProperties.properties = properties;
}
/**
* Detect big-endian systems.
*
* @return true if the system is big-endian.
*/
private static native boolean isWordsBigEndian();
}
libjava/gnu/classpath/natSystemProperties.cc
+390
View File
@@ -0,0 +1,390 @@
// natSystemProperties.cc - Implementation of native side of
// SystemProperties class.
/* Copyright (C) 2005 Free Software Foundation
This file is part of libgcj.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
#include <config.h>
#include <platform.h>
#include <stdlib.h>
#include <errno.h>
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#ifdef HAVE_UNAME
#include <sys/utsname.h>
#endif
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif
#ifdef HAVE_LANGINFO_H
#include <langinfo.h>
#endif
#include <gcj/cni.h>
#include <jvm.h>
#include <java-props.h>
#include <gnu/classpath/SystemProperties.h>
#include <java/lang/String.h>
#include <jni.h>
#ifdef USE_LTDL
#include <ltdl.h>
void
_Jv_SetDLLSearchPath (const char *path)
{
lt_dlsetsearchpath (path);
}
#else
void
_Jv_SetDLLSearchPath (const char *)
{
// Nothing.
}
#endif /* USE_LTDL */
#if ! defined (DEFAULT_FILE_ENCODING) && defined (HAVE_ICONV) \
&& defined (HAVE_NL_LANGINFO)
static char *
file_encoding ()
{
setlocale (LC_CTYPE, "");
char *e = nl_langinfo (CODESET);
if (e == NULL || *e == '\0')
e = "8859_1";
return e;
}
#define DEFAULT_FILE_ENCODING file_encoding ()
#endif
#ifndef DEFAULT_FILE_ENCODING
#define DEFAULT_FILE_ENCODING "8859_1"
#endif
static char *default_file_encoding = DEFAULT_FILE_ENCODING;
#if HAVE_GETPWUID_R
/* Use overload resolution to find out the signature of getpwuid_r. */
/* This is Posix getpwuid_r. */
template <typename T_uid, typename T_passwd, typename T_buf, typename T_len>
static inline int
getpwuid_adaptor(int (*getpwuid_r)(T_uid user_id, T_passwd *pwd_r,
T_buf *buf_r, T_len len_r,
T_passwd **pwd_entry_ptr),
uid_t user_id, struct passwd *pwd_r,
char *buf_r, size_t len_r, struct passwd **pwd_entry)
{
return getpwuid_r (user_id, pwd_r, buf_r, len_r, pwd_entry);
}
/* This is used on HPUX 10.20 */
template <typename T_uid, typename T_passwd, typename T_buf, typename T_len>
static inline int
getpwuid_adaptor(int (*getpwuid_r)(T_uid user_id, T_passwd *pwd_r,
T_buf *buf_r, T_len len_r),
uid_t user_id, struct passwd *pwd_r,
char *buf_r, size_t len_r, struct passwd **pwd_entry)
{
return getpwuid_r (user_id, pwd_r, buf_r, len_r);
}
/* This is used on IRIX 5.2. */
template <typename T_uid, typename T_passwd, typename T_buf, typename T_len>
static inline int
getpwuid_adaptor(T_passwd * (*getpwuid_r)(T_uid user_id, T_passwd *pwd_r,
T_buf *buf_r, T_len len_r),
uid_t user_id, struct passwd *pwd_r,
char *buf_r, size_t len_r, struct passwd **pwd_entry)
{
*pwd_entry = getpwuid_r (user_id, pwd_r, buf_r, len_r);
return (*pwd_entry == NULL) ? errno : 0;
}
#endif
void
gnu::classpath::SystemProperties::insertSystemProperties (java::util::Properties *newprops)
{
// A convenience define.
#define SET(Prop,Val) \
newprops->put(JvNewStringLatin1 (Prop), JvNewStringLatin1 (Val))
// A mixture of the Java Product Versioning Specification
// (introduced in 1.2), and earlier versioning properties. Some
// programs rely on seeing values that they expect, so we claim to
// be a 1.4-ish VM for their sake.
SET ("java.version", JV_VERSION);
SET ("java.runtime.version", JV_VERSION);
SET ("java.vendor", "Free Software Foundation, Inc.");
SET ("java.vendor.url", "http://gcc.gnu.org/java/");
SET ("java.class.version", "46.0");
SET ("java.vm.specification.version", "1.0");
SET ("java.vm.specification.name", "Java(tm) Virtual Machine Specification");
SET ("java.vm.specification.vendor", "Sun Microsystems Inc.");
SET ("java.vm.version", __VERSION__);
SET ("java.vm.vendor", "Free Software Foundation, Inc.");
SET ("java.vm.name", "GNU libgcj");
SET ("java.specification.version", JV_API_VERSION);
SET ("java.specification.name", "Java(tm) Platform API Specification");
SET ("java.specification.vendor", "Sun Microsystems Inc.");
char value[100];
#define NAME "GNU libgcj "
strcpy (value, NAME);
strncpy (value + sizeof (NAME) - 1, __VERSION__,
sizeof(value) - sizeof(NAME));
value[sizeof (value) - 1] = '\0';
jstring version = JvNewStringLatin1 (value);
newprops->put (JvNewStringLatin1 ("java.fullversion"), version);
newprops->put (JvNewStringLatin1 ("java.vm.info"), version);
// This definition is rather arbitrary: we choose $(prefix). In
// part we do this because most people specify only --prefix and
// nothing else when installing gcj. Plus, people are free to
// redefine `java.home' with `-D' if necessary.
SET ("java.home", JAVA_HOME);
SET ("gnu.classpath.home", PREFIX);
// This is set to $(libdir) because we use this to find .security
// files at runtime.
char val2[sizeof ("file://") + sizeof (LIBDIR) + 1];
strcpy (val2, "file://");
strcat (val2, LIBDIR);
SET ("gnu.classpath.home.url", val2);
SET ("file.encoding", default_file_encoding);
#ifdef HAVE_UNAME
struct utsname u;
if (! uname (&u))
{
SET ("os.name", u.sysname);
SET ("os.version", u.release);
// Normalize x86 architecture names to "i386" (except on Windows, which
// is handled in win32.cc).
if (u.machine[0] == 'i'
&& u.machine[1] != 0
&& u.machine[2] == '8'
&& u.machine[3] == '6'
&& u.machine[4] == 0)
SET ("os.arch", "i386");
else
SET ("os.arch", u.machine);
}
else
{
SET ("os.name", "unknown");
SET ("os.arch", "unknown");
SET ("os.version", "unknown");
}
#endif /* HAVE_UNAME */
#ifndef NO_GETUID
#ifdef HAVE_PWD_H
uid_t user_id = getuid ();
struct passwd *pwd_entry;
#ifdef HAVE_GETPWUID_R
struct passwd pwd_r;
size_t len_r = 200;
char *buf_r = (char *) _Jv_AllocBytes (len_r);
while (buf_r != NULL)
{
int r = getpwuid_adaptor (getpwuid_r, user_id, &pwd_r,
buf_r, len_r, &pwd_entry);
if (r == 0)
break;
else if (r != ERANGE)
{
pwd_entry = NULL;
break;
}
len_r *= 2;
buf_r = (char *) _Jv_AllocBytes (len_r);
}
#else
pwd_entry = getpwuid (user_id);
#endif /* HAVE_GETPWUID_R */
if (pwd_entry != NULL)
{
SET ("user.name", pwd_entry->pw_name);
SET ("user.home", pwd_entry->pw_dir);
}
#endif /* HAVE_PWD_H */
#endif /* NO_GETUID */
#ifdef HAVE_GETCWD
#ifdef HAVE_UNISTD_H
/* Use getcwd to set "user.dir". */
int buflen = 250;
char *buffer = (char *) malloc (buflen);
while (buffer != NULL)
{
if (getcwd (buffer, buflen) != NULL)
{
SET ("user.dir", buffer);
break;
}
if (errno != ERANGE)
break;
buflen = 2 * buflen;
buffer = (char *) realloc (buffer, buflen);
}
if (buffer != NULL)
free (buffer);
#endif /* HAVE_UNISTD_H */
#endif /* HAVE_GETCWD */
// Set user locale properties based on setlocale()
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
// We let the user choose the locale. However, since Java differs
// from POSIX, we arbitrarily pick LC_MESSAGES as determining the
// Java locale. We can't use LC_ALL because it might return a full
// list of all the settings. If we don't have LC_MESSAGES then we
// just default to `en_US'.
setlocale (LC_ALL, "");
char *locale = setlocale (LC_MESSAGES, "");
if (locale && strlen (locale) >= 2)
{
char buf[3];
buf[2] = '\0';
// copy the first two chars to user.language
strncpy (buf, locale, 2);
SET ("user.language", buf);
// if the next char is a '_', copy the two after that to user.region
locale += 2;
if (locale[0] == '_')
{
locale++;
strncpy (buf, locale, 2);
SET ("user.region", buf);
}
}
else
#endif /* HAVE_SETLOCALE and HAVE_LC_MESSAGES */
{
SET ("user.language", "en");
SET ("user.region", "US");
}
// The java extensions directory.
SET ("java.ext.dirs", JAVA_EXT_DIRS);
// The endorsed directories that libgcj knows about by default.
// This is a way to get other jars into the boot class loader
// without overriding java.endorsed.dirs.
SET ("gnu.gcj.runtime.endorsed.dirs", GCJ_ENDORSED_DIRS);
// The path to libgcj's boot classes
SET ("sun.boot.class.path", BOOT_CLASS_PATH);
// If there is a default system database, set it.
SET ("gnu.gcj.precompiled.db.path", LIBGCJ_DEFAULT_DATABASE);
// Set some properties according to whatever was compiled in with
// `-D'. Important: after this point, the only properties that
// should be set are those which either the user cannot meaningfully
// override, or which augment whatever value the user has provided.
for (int i = 0; i < _Jv_Properties_Count; ++i)
{
const char *s, *p;
// Find the `='.
for (s = p = _Jv_Compiler_Properties[i]; *s && *s != '='; ++s)
;
jstring name = JvNewStringLatin1 (p, s - p);
jstring val = JvNewStringLatin1 (*s == '=' ? s + 1 : s);
newprops->put (name, val);
}
// Set the system properties from the user's environment.
#ifndef DISABLE_GETENV_PROPERTIES
if (_Jv_Environment_Properties)
{
size_t i = 0;
while (_Jv_Environment_Properties[i].key)
{
SET (_Jv_Environment_Properties[i].key,
_Jv_Environment_Properties[i].value);
i++;
}
}
#endif
// The name used to invoke this process (argv[0] in C).
SET ("gnu.gcj.progname", _Jv_GetSafeArg (0));
// Allow platform specific settings and overrides.
_Jv_platform_initProperties (newprops);
// If java.library.path is set, tell libltdl so we search the new
// directories as well. FIXME: does this work properly on Windows?
::java::lang::String *path = newprops->getProperty(JvNewStringLatin1("java.library.path"));
if (path)
{
char *val = (char *) _Jv_Malloc (JvGetStringUTFLength (path) + 1);
jsize total = JvGetStringUTFRegion (path, 0, path->length(), val);
val[total] = '\0';
_Jv_SetDLLSearchPath (val);
_Jv_Free (val);
}
else
{
// Set a value for user code to see.
// FIXME: JDK sets this to the actual path used, including
// LD_LIBRARY_PATH, etc.
SET ("java.library.path", "");
}
// If java.class.path is still not set then set it according to the
// CLASSPATH environment variable if given. See gij.cc main () and
// prims.cc _Jv_CreateJavaVM () for all the ways this could have
// been set much earlier.
// If CLASSPATH isn't set or if the path is empty fall back to "."
path = newprops->getProperty(JvNewStringLatin1("java.class.path"));
if (!path)
{
char *classpath = getenv("CLASSPATH");
if (classpath && classpath[0] != 0)
{
path = JvNewStringLatin1 (classpath);
newprops->put(JvNewStringLatin1 ("java.class.path"), path);
}
}
if (!path || path->length() == 0)
SET ("java.class.path", ".");
}
jboolean
gnu::classpath::SystemProperties::isWordsBigEndian (void)
{
union
{
long lval;
char cval;
} u;
u.lval = 1;
return u.cval == 0;
}