procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

re PR libgcj/6389 (System.getProperty("") should always throw an IllegalArgumentException)

Browse source 
Fixes PR libgcj/6389:
	* Makefile.in: Rebuilt.
	* Makefile.am (nat_source_files): Added natTimeZone.cc.
	* java/util/natTimeZone.cc: New file.
	* java/util/TimeZone.java (getDefaultTimeZoneId): New method.
	* java/lang/System.java: Merged with Classpath.
	* java/lang/Runtime.java: Merged with Classpath.
	* java/lang/natSystem.cc (setErr0): Renamed from setErr; don't run
	security check.
	(setIn0): Renamed from setIn; don't run security check.
	(setOut0): Renamed from setOut; don't run security check.
	(file_encoding, getpwuid_adaptor, getSystemTimeZone,
	init_properties): Moved to natRuntime.cc.
	Moved many includes to natRuntime.cc.
	(isWordsBigEndian): New method.
	* java/lang/natRuntime.cc: Include Long.h, also other includes
	previously in natSystem.cc.
	(maxMemory): New function.
	(exitInternal): Renamed from `_exit'.
	(exit): Removed.
	(init): Don't set finalize_on_exit.
	(exitInternal): Use `finalizeOnExit'.
	(file_encoding, getpwuid_adaptor): New functions from
	natSystem.cc.
	(insertSystemProperties): New method, renamed from
	System::init_properties.  Don't set user.timezone.
	(_load): Don't call checkLink.
	(execInternal): New method.
	(availableProcessors): Likewise.
	(nativeGetLibname): Likewise.

From-SVN: r53429
This commit is contained in:
Tom Tromey 2002-05-13 20:10:37 +00:00 • committed by Tom Tromey
parent 16133d0058
commit 8639786815
9 changed files with 1881 additions and 725 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
libjava/ChangeLog
View file

@ -1,3 +1,36 @@
2002-05-13 Tom Tromey <tromey@redhat.com>
Fixes PR libgcj/6389:
* Makefile.in: Rebuilt.
* Makefile.am (nat_source_files): Added natTimeZone.cc.
* java/util/natTimeZone.cc: New file.
* java/util/TimeZone.java (getDefaultTimeZoneId): New method.
* java/lang/System.java: Merged with Classpath.
* java/lang/Runtime.java: Merged with Classpath.
* java/lang/natSystem.cc (setErr0): Renamed from setErr; don't run
security check.
(setIn0): Renamed from setIn; don't run security check.
(setOut0): Renamed from setOut; don't run security check.
(file_encoding, getpwuid_adaptor, getSystemTimeZone,
init_properties): Moved to natRuntime.cc.
Moved many includes to natRuntime.cc.
(isWordsBigEndian): New method.
* java/lang/natRuntime.cc: Include Long.h, also other includes
previously in natSystem.cc.
(maxMemory): New function.
(exitInternal): Renamed from `_exit'.
(exit): Removed.
(init): Don't set finalize_on_exit.
(exitInternal): Use `finalizeOnExit'.
(file_encoding, getpwuid_adaptor): New functions from
natSystem.cc.
(insertSystemProperties): New method, renamed from
System::init_properties. Don't set user.timezone.
(_load): Don't call checkLink.
(execInternal): New method.
(availableProcessors): Likewise.
(nativeGetLibname): Likewise.
2002-05-11 Mark Wielaard <mark@klomp.org>
* gnu/java/text/SentenceBreakIterator.java (next): Skip all java white

1
libjava/Makefile.am
View file

@ -1783,6 +1783,7 @@ java/net/natInetAddress.cc \
java/net/natPlainDatagramSocketImpl.cc \
java/net/natPlainSocketImpl.cc \
java/text/natCollator.cc \
java/util/natTimeZone.cc \
java/util/zip/natDeflater.cc \
java/util/zip/natInflater.cc

60
libjava/Makefile.in
View file

@ -129,13 +129,19 @@ mkinstalldirs = @mkinstalldirs@
tool_include_dir = @tool_include_dir@
AUTOMAKE_OPTIONS = foreign
@TESTSUBDIR_TRUE@SUBDIRS = @TESTSUBDIR_TRUE@$(DIRLTDL) testsuite gcj include
@TESTSUBDIR_FALSE@SUBDIRS = @TESTSUBDIR_FALSE@$(DIRLTDL) gcj include
@USE_LIBDIR_TRUE@toolexeclibdir = @USE_LIBDIR_TRUE@$(libdir)$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexeclibdir = @USE_LIBDIR_FALSE@$(toolexecdir)/lib$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexecdir = @USE_LIBDIR_FALSE@$(exec_prefix)/$(target_alias)
@XLIB_AWT_TRUE@cond_x_ltlibrary = @XLIB_AWT_TRUE@libgcjx.la
@XLIB_AWT_FALSE@cond_x_ltlibrary =
@TESTSUBDIR_TRUE@SUBDIRS = \
@TESTSUBDIR_TRUE@$(DIRLTDL) testsuite gcj include
@TESTSUBDIR_FALSE@SUBDIRS = \
@TESTSUBDIR_FALSE@$(DIRLTDL) gcj include
@USE_LIBDIR_TRUE@toolexeclibdir = \
@USE_LIBDIR_TRUE@$(libdir)$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexeclibdir = \
@USE_LIBDIR_FALSE@$(toolexecdir)/lib$(MULTISUBDIR)
@USE_LIBDIR_FALSE@toolexecdir = \
@USE_LIBDIR_FALSE@$(exec_prefix)/$(target_alias)
@XLIB_AWT_TRUE@cond_x_ltlibrary = \
@XLIB_AWT_TRUE@libgcjx.la
@XLIB_AWT_FALSE@cond_x_ltlibrary = \
toolexeclib_LTLIBRARIES = libgcj.la $(cond_x_ltlibrary)
toolexeclib_DATA = libgcj.spec
@ -145,14 +151,20 @@ jar_DATA = libgcj-@gcc_version@.jar
secdir = $(libdir)/security
@NATIVE_TRUE@bin_PROGRAMS = @NATIVE_TRUE@jv-convert gij rmic rmiregistry
@NATIVE_TRUE@bin_PROGRAMS = \
@NATIVE_TRUE@jv-convert gij rmic rmiregistry
bin_SCRIPTS = addr2name.awk
@CANADIAN_TRUE@@NULL_TARGET_TRUE@ZIP = @CANADIAN_TRUE@@NULL_TARGET_TRUE@$(MULTIBUILDTOP)../$(COMPPATH)/fastjar/jar$(EXEEXT)
@CANADIAN_TRUE@@NULL_TARGET_FALSE@ZIP = @CANADIAN_TRUE@@NULL_TARGET_FALSE@jar
@CANADIAN_FALSE@ZIP = @CANADIAN_FALSE@$(MULTIBUILDTOP)../$(COMPPATH)/fastjar/jar$(EXEEXT)
@CANADIAN_TRUE@GCJH = @CANADIAN_TRUE@gcjh
@CANADIAN_FALSE@GCJH = @CANADIAN_FALSE@$(MULTIBUILDTOP)../$(COMPPATH)/gcc/gcjh$(EXEEXT)
@CANADIAN_TRUE@@NULL_TARGET_TRUE@ZIP = \
@CANADIAN_TRUE@@NULL_TARGET_TRUE@$(MULTIBUILDTOP)../$(COMPPATH)/fastjar/jar$(EXEEXT)
@CANADIAN_TRUE@@NULL_TARGET_FALSE@ZIP = \
@CANADIAN_TRUE@@NULL_TARGET_FALSE@jar
@CANADIAN_FALSE@ZIP = \
@CANADIAN_FALSE@$(MULTIBUILDTOP)../$(COMPPATH)/fastjar/jar$(EXEEXT)
@CANADIAN_TRUE@GCJH = \
@CANADIAN_TRUE@gcjh
@CANADIAN_FALSE@GCJH = \
@CANADIAN_FALSE@$(MULTIBUILDTOP)../$(COMPPATH)/gcc/gcjh$(EXEEXT)
GCJ_WITH_FLAGS = $(GCJ) --encoding=UTF-8
@ -173,8 +185,10 @@ AM_CXXFLAGS = -fno-rtti -fnon-call-exceptions \
@LIBGCJ_CXXFLAGS@ @X_CFLAGS@ $(WARNINGS) -D_GNU_SOURCE \
-DPREFIX="\"$(prefix)\""
@USING_GCC_TRUE@AM_CFLAGS = @USING_GCC_TRUE@@LIBGCJ_CFLAGS@ $(WARNINGS)
@USING_GCC_FALSE@AM_CFLAGS = @USING_GCC_FALSE@@LIBGCJ_CFLAGS@
@USING_GCC_TRUE@AM_CFLAGS = \
@USING_GCC_TRUE@@LIBGCJ_CFLAGS@ $(WARNINGS)
@USING_GCC_FALSE@AM_CFLAGS = \
@USING_GCC_FALSE@@LIBGCJ_CFLAGS@
JCFLAGS = -g
JC1FLAGS = @LIBGCJ_JAVAFLAGS@ $(GCJFLAGS)
@ -257,7 +271,8 @@ extra_headers = java/lang/Object.h java/lang/Class.h
NM = nm
@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@noinst_PROGRAMS = @NATIVE_TRUE@@MAINTAINER_MODE_TRUE@gen-from-JIS
@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@noinst_PROGRAMS = \
@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@gen-from-JIS
CONVERT_DIR = gnu/gcj/convert
@ -1544,6 +1559,7 @@ java/net/natInetAddress.cc \
java/net/natPlainDatagramSocketImpl.cc \
java/net/natPlainSocketImpl.cc \
java/text/natCollator.cc \
java/util/natTimeZone.cc \
java/util/zip/natDeflater.cc \
java/util/zip/natInflater.cc
@ -1694,8 +1710,8 @@ java/lang/ref/natReference.lo java/lang/reflect/natArray.lo \
java/lang/reflect/natConstructor.lo java/lang/reflect/natField.lo \
java/lang/reflect/natMethod.lo java/net/natInetAddress.lo \
java/net/natPlainDatagramSocketImpl.lo java/net/natPlainSocketImpl.lo \
java/text/natCollator.lo java/util/zip/natDeflater.lo \
java/util/zip/natInflater.lo
java/text/natCollator.lo java/util/natTimeZone.lo \
java/util/zip/natDeflater.lo java/util/zip/natInflater.lo
libgcjx_la_OBJECTS = gnu/gcj/xlib/natClip.lo \
gnu/gcj/xlib/natColormap.lo gnu/gcj/xlib/natDisplay.lo \
gnu/gcj/xlib/natDrawable.lo gnu/gcj/xlib/natFont.lo \
@ -1739,7 +1755,7 @@ libgcj-test.spec.in libgcj.spec.in
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = gtar
TAR = tar
GZIP_ENV = --best
DIST_SUBDIRS = @DIRLTDL@ testsuite gcj include @DIRLTDL@ gcj include
DEP_FILES = .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
@ -2548,8 +2564,8 @@ DEP_FILES = .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
.deps/java/util/jar/JarException.P .deps/java/util/jar/JarFile.P \
.deps/java/util/jar/JarInputStream.P \
.deps/java/util/jar/JarOutputStream.P .deps/java/util/jar/Manifest.P \
.deps/java/util/zip/Adler32.P .deps/java/util/zip/CRC32.P \
.deps/java/util/zip/CheckedInputStream.P \
.deps/java/util/natTimeZone.P .deps/java/util/zip/Adler32.P \
.deps/java/util/zip/CRC32.P .deps/java/util/zip/CheckedInputStream.P \
.deps/java/util/zip/CheckedOutputStream.P \
.deps/java/util/zip/Checksum.P \
.deps/java/util/zip/DataFormatException.P \
@ -3040,7 +3056,7 @@ distdir: $(DISTFILES)
@for file in $(DISTFILES); do \
d=$(srcdir); \
if test -d $$d/$$file; then \
cp -pr $$d/$$file $(distdir)/$$file; \
cp -pr $$/$$file $(distdir)/$$file; \
else \
test -f $(distdir)/$$file \
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \

842
libjava/java/lang/Runtime.java
View file

@ -1,147 +1,785 @@
// Runtime.java - Runtime class.
/* Runtime.java -- access to the VM process
Copyright (C) 1998, 2002 Free Software Foundation
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
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 java.lang;
import java.io.IOException;
import java.io.File;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date August 27, 1998
* Runtime represents the Virtual Machine.
*
* @author John Keiser
* @author Eric Blake <ebb9@email.byu.edu>
* @status still missing 1.4 functionality
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: All 1.1 methods exist. exec() is not fully implemented.
*/
// No idea why this class isn't final, since you can't build a subclass!
public class Runtime
{
public Process exec (String prog) throws IOException
/**
* The library path, to search when loading libraries. We can also safely use
* this as a lock for synchronization.
*/
private final String[] libpath;
/**
* The current security manager. This is located here instead of in
* Runtime, to avoid security problems, as well as bootstrap issues.
* Make sure to access it in a thread-safe manner; it is package visible
* to avoid overhead in java.lang.
*/
static SecurityManager securityManager;
/**
* The default properties defined by the system. This is likewise located
* here instead of in Runtime, to avoid bootstrap issues; it is package
* visible to avoid overhead in java.lang. Note that System will add a
* few more properties to this collection, but that after that, it is
* treated as read-only.
*
* No matter what class you start initialization with, it defers to the
* superclass, therefore Object.<clinit> will be the first Java code
* executed. From there, the bootstrap sequence, up to the point that
* native libraries are loaded (as of March 24, when I traced this
* manually) is as follows:
*
* Object.<clinit> uses a String literal, possibly triggering initialization
* String.<clinit> calls WeakHashMap.<init>, triggering initialization
* AbstractMap, WeakHashMap, WeakHashMap$1 have no dependencies
* String.<clinit> calls CaseInsensitiveComparator.<init>, triggering
* initialization
* CaseInsensitiveComparator has no dependencies
* Object.<clinit> calls System.loadLibrary, triggering initialization
* System.<clinit> calls System.loadLibrary
* System.loadLibrary calls Runtime.getRuntime, triggering initialization
* Runtime.<clinit> calls Properties.<init>, triggering initialization
* Dictionary, Hashtable, and Properties have no dependencies
* Runtime.<clinit> calls insertSystemProperties; the VM must make sure
* that there are not any harmful dependencies
* Runtime.<clinit> calls Runtime.<init>
* Runtime.<init> calls StringTokenizer.<init>, triggering initialization
* StringTokenizer has no dependencies
* System.loadLibrary calls Runtime.loadLibrary
* Runtime.loadLibrary should be able to load the library, although it
* will probably set off another string of initializations from
* ClassLoader first
*/
static Properties defaultProperties = new Properties();
static
{
return exec (prog, null);
insertSystemProperties(defaultProperties);
}
public Process exec (String prog, String[] envp) throws IOException
/**
* The thread that started the exit sequence. Access to this field must
* be thread-safe; lock on libpath to avoid deadlock with user code.
* <code>runFinalization()</code> may want to look at this to see if ALL
* finalizers should be run, because the virtual machine is about to halt.
*/
private Thread exitSequence;
/**
* All shutdown hooks. This is initialized lazily, and set to null once all
* shutdown hooks have run. Access to this field must be thread-safe; lock
* on libpath to avoid deadlock with user code.
*/
private Set shutdownHooks;
/** True if we should finalize on exit. */
private boolean finalizeOnExit;
/**
* The one and only runtime instance. This must appear after the default
* properties have been initialized by the VM.
*/
private static final Runtime current = new Runtime();
/**
* Not instantiable by a user, this should only create one instance.
*/
private Runtime()
{
StringTokenizer st = new StringTokenizer(prog);
String[] a = new String[st.countTokens ()];
for (int i = 0; i < a.length; i++)
a[i] = st.nextToken ();
return exec (a, envp);
if (current != null)
throw new InternalError("Attempt to recreate Runtime");
// We don't use libpath in the libgcj implementation. We still
// set it to something to allow the various synchronizations to
// work.
libpath = new String[0];
init ();
}
public Process exec (String[] progarray) throws IOException
/**
* Get the current Runtime object for this JVM. This is necessary to access
* the many instance methods of this class.
*
* @return the current Runtime object
*/
public static Runtime getRuntime()
{
return exec (progarray, null);
return current;
}
public Process exec (String[] progarray, String[] envp) throws IOException
/**
* Exit the Java runtime. This method will either throw a SecurityException
* or it will never return. The status code is returned to the system; often
* a non-zero status code indicates an abnormal exit. Of course, there is a
* security check, <code>checkExit(status)</code>.
*
* <p>First, all shutdown hooks are run, in unspecified order, and
* concurrently. Next, if finalization on exit has been enabled, all pending
* finalizers are run. Finally, the system calls <code>halt</code>.
*
* <p>If this is run a second time after shutdown has already started, there
* are two actions. If shutdown hooks are still executing, it blocks
* indefinitely. Otherwise, if the status is nonzero it halts immediately;
* if it is zero, it blocks indefinitely. This is typically called by
* <code>System.exit</code>.
*
* @param status the status to exit with
* @throws SecurityException if permission is denied
* @see #addShutdownHook(Thread)
* @see #runFinalizersOnExit(boolean)
* @see #runFinalization()
* @see #halt(int)
*/
public void exit(int status)
{
SecurityManager s = System.getSecurityManager();
if (s != null)
s.checkExec(progarray[0]);
return new ConcreteProcess (progarray, envp);
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkExit(status);
boolean first = false;
synchronized (libpath) // Synch on libpath, not this, to avoid deadlock.
{
if (exitSequence == null)
{
first = true;
exitSequence = Thread.currentThread();
if (shutdownHooks != null)
{
Iterator i = shutdownHooks.iterator();
while (i.hasNext()) // Start all shutdown hooks.
try
{
((Thread) i.next()).start();
}
catch (IllegalThreadStateException e)
{
i.remove();
}
}
}
}
if (first)
{
if (shutdownHooks != null)
{
// Check progress of all shutdown hooks. As a hook completes,
// remove it from the set. If a hook calls exit, it removes
// itself from the set, then waits indefinitely on the
// exitSequence thread. Once the set is empty, set it to null to
// signal all finalizer threads that halt may be called.
while (! shutdownHooks.isEmpty())
{
Thread[] hooks;
synchronized (libpath)
{
hooks = new Thread[shutdownHooks.size()];
shutdownHooks.toArray(hooks);
}
for (int i = hooks.length; --i >= 0; )
if (! hooks[i].isAlive())
synchronized (libpath)
{
shutdownHooks.remove(hooks[i]);
}
try
{
exitSequence.sleep(1); // Give other threads a chance.
}
catch (InterruptedException e)
{
// Ignore, the next loop just starts sooner.
}
}
synchronized (libpath)
{
shutdownHooks = null;
}
}
// XXX Right now, it is the VM that knows whether runFinalizersOnExit
// is true; so the VM must look at exitSequence to decide whether
// this should be run on every object.
runFinalization();
}
else
synchronized (libpath)
{
if (shutdownHooks != null)
{
shutdownHooks.remove(Thread.currentThread());
status = 0; // Change status to enter indefinite wait.
}
}
if (first || status > 0)
halt(status);
while (true)
try
{
exitSequence.join();
}
catch (InterruptedException e)
{
// Ignore, we've suspended indefinitely to let all shutdown
// hooks complete, and to let any non-zero exits through, because
// this is a duplicate call to exit(0).
}
}
private final static void checkExit (int status)
/**
* Register a new shutdown hook. This is invoked when the program exits
* normally (because all non-daemon threads ended, or because
* <code>System.exit</code> was invoked), or when the user terminates
* the virtual machine (such as by typing ^C, or logging off). There is
* a security check to add hooks,
* <code>RuntimePermission("shutdownHooks")<code>.
*
* <p>The hook must be an initialized, but unstarted Thread. The threads
* are run concurrently, and started in an arbitrary order; and user
* threads or daemons may still be running. Once shutdown hooks have
* started, they must all complete, or else you must use <code>halt</code>,
* to actually finish the shutdown sequence. Attempts to modify hooks
* after shutdown has started result in IllegalStateExceptions.
*
* <p>It is imperative that you code shutdown hooks defensively, as you
* do not want to deadlock, and have no idea what other hooks will be
* running concurrently. It is also a good idea to finish quickly, as the
* virtual machine really wants to shut down!
*
* <p>There are no guarantees that such hooks will run, as there are ways
* to forcibly kill a process. But in such a drastic case, shutdown hooks
* would do little for you in the first place.
*
* @param hook an initialized, unstarted Thread
* @throws IllegalArgumentException if the hook is already registered or run
* @throws IllegalStateException if the virtual machine is already in
* the shutdown sequence
* @throws SecurityException if permission is denied
* @since 1.3
* @see #removeShutdownHook(Thread)
* @see #exit(int)
* @see #halt(int)
*/
public void addShutdownHook(Thread hook)
{
SecurityManager s = System.getSecurityManager();
if (s != null)
s.checkExit(status);
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkPermission(new RuntimePermission("shutdownHooks"));
if (hook.isAlive() || hook.getThreadGroup() == null)
throw new IllegalArgumentException();
synchronized (libpath)
{
if (exitSequence != null)
throw new IllegalStateException();
if (shutdownHooks == null)
shutdownHooks = new HashSet(); // Lazy initialization.
if (! shutdownHooks.add(hook))
throw new IllegalArgumentException();
}
}
public native void exit (int status);
// Shutdown the runtime without a SecurityManager check. libgcj uses this
// exit function internally.
final native void _exit (int status);
/**
* De-register a shutdown hook. As when you registered it, there is a
* security check to remove hooks,
* <code>RuntimePermission("shutdownHooks")<code>.
*
* @param hook the hook to remove
* @return true if the hook was successfully removed, false if it was not
* registered in the first place
* @throws IllegalStateException if the virtual machine is already in
* the shutdown sequence
* @throws SecurityException if permission is denied
* @since 1.3
* @see #addShutdownHook(Thread)
* @see #exit(int)
* @see #halt(int)
*/
public boolean removeShutdownHook(Thread hook)
{
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkPermission(new RuntimePermission("shutdownHooks"));
synchronized (libpath)
{
if (exitSequence != null)
throw new IllegalStateException();
if (shutdownHooks != null)
return shutdownHooks.remove(hook);
}
return false;
}
public native long freeMemory ();
public native void gc ();
/**
* Forcibly terminate the virtual machine. This call never returns. It is
* much more severe than <code>exit</code>, as it bypasses all shutdown
* hooks and initializers. Use caution in calling this! Of course, there is
* a security check, <code>checkExit(status)</code>.
*
* @param status the status to exit with
* @throws SecurityException if permission is denied
* @since 1.3
* @see #exit(int)
* @see #addShutdownHook(Thread)
*/
public void halt(int status)
{
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkExit(status);
exitInternal(status);
}
// Deprecated in 1.1. We implement what the JCL book says.
public InputStream getLocalizedInputStream (InputStream in)
/**
* Tell the VM to run the finalize() method on every single Object before
* it exits. Note that the JVM may still exit abnormally and not perform
* this, so you still don't have a guarantee. And besides that, this is
* inherently unsafe in multi-threaded code, as it may result in deadlock
* as multiple threads compete to manipulate objects. This value defaults to
* <code>false</code>. There is a security check, <code>checkExit(0)</code>.
*
* @param finalizeOnExit whether to finalize all Objects on exit
* @throws SecurityException if permission is denied
* @see #exit(int)
* @see #gc()
* @since 1.1
* @deprecated never rely on finalizers to do a clean, thread-safe,
* mop-up from your code
*/
public static void runFinalizersOnExit(boolean finalizeOnExit)
{
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkExit(0);
current.finalizeOnExit = finalizeOnExit;
}
/**
* Create a new subprocess with the specified command line. Calls
* <code>exec(cmdline, null, null)<code>. A security check is performed,
* <code>checkExec</code>.
*
* @param cmdline the command to call
* @return the Process object
* @throws SecurityException if permission is denied
* @throws IOException if an I/O error occurs
* @throws NullPointerException if cmdline is null
* @throws IndexOutOfBoundsException if cmdline is ""
*/
public Process exec(String cmdline) throws IOException
{
return exec(cmdline, null, null);
}
/**
* Create a new subprocess with the specified command line and environment.
* If the environment is null, the process inherits the environment of
* this process. Calls <code>exec(cmdline, env, null)</code>. A security
* check is performed, <code>checkExec</code>.
*
* @param cmdline the command to call
* @param env the environment to use, in the format name=value
* @return the Process object
* @throws SecurityException if permission is denied
* @throws IOException if an I/O error occurs
* @throws NullPointerException if cmdline is null, or env has null entries
* @throws IndexOutOfBoundsException if cmdline is ""
*/
public Process exec(String cmdline, String[] env) throws IOException
{
return exec(cmdline, env, null);
}
/**
* Create a new subprocess with the specified command line, environment, and
* working directory. If the environment is null, the process inherits the
* environment of this process. If the directory is null, the process uses
* the current working directory. This splits cmdline into an array, using
* the default StringTokenizer, then calls
* <code>exec(cmdArray, env, dir)</code>. A security check is performed,
* <code>checkExec</code>.
*
* @param cmdline the command to call
* @param env the environment to use, in the format name=value
* @param dir the working directory to use
* @return the Process object
* @throws SecurityException if permission is denied
* @throws IOException if an I/O error occurs
* @throws NullPointerException if cmdline is null, or env has null entries
* @throws IndexOutOfBoundsException if cmdline is ""
* @since 1.3
*/
public Process exec(String cmdline, String[] env, File dir)
throws IOException
{
StringTokenizer t = new StringTokenizer(cmdline);
String[] cmd = new String[t.countTokens()];
for (int i = 0; i < cmd.length; i++)
cmd[i] = t.nextToken();
return exec(cmd, env, dir);
}
/**
* Create a new subprocess with the specified command line, already
* tokenized. Calls <code>exec(cmd, null, null)</code>. A security check
* is performed, <code>checkExec</code>.
*
* @param cmd the command to call
* @return the Process object
* @throws SecurityException if permission is denied
* @throws IOException if an I/O error occurs
* @throws NullPointerException if cmd is null, or has null entries
* @throws IndexOutOfBoundsException if cmd is length 0
*/
public Process exec(String[] cmd) throws IOException
{
return exec(cmd, null, null);
}
/**
* Create a new subprocess with the specified command line, already
* tokenized, and specified environment. If the environment is null, the
* process inherits the environment of this process. Calls
* <code>exec(cmd, env, null)</code>. A security check is performed,
* <code>checkExec</code>.
*
* @param cmd the command to call
* @param env the environment to use, in the format name=value
* @return the Process object
* @throws SecurityException if permission is denied
* @throws IOException if an I/O error occurs
* @throws NullPointerException if cmd is null, or cmd or env has null
* entries
* @throws IndexOutOfBoundsException if cmd is length 0
*/
public Process exec(String[] cmd, String[] env) throws IOException
{
return exec(cmd, env, null);
}
/**
* Create a new subprocess with the specified command line, already
* tokenized, and the specified environment and working directory. If the
* environment is null, the process inherits the environment of this
* process. If the directory is null, the process uses the current working
* directory. A security check is performed, <code>checkExec</code>.
*
* @param cmd the command to call
* @param env the environment to use, in the format name=value
* @param dir the working directory to use
* @return the Process object
* @throws SecurityException if permission is denied
* @throws IOException if an I/O error occurs
* @throws NullPointerException if cmd is null, or cmd or env has null
* entries
* @throws IndexOutOfBoundsException if cmd is length 0
* @since 1.3
* @XXX Ignores dir, for now
*/
public Process exec(String[] cmd, String[] env, File dir)
throws IOException
{
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkExec(cmd[0]);
if (env == null)
env = new String[0];
//XXX Should be: return execInternal(cmd, env, dir);
return execInternal(cmd, env);
}
/**
* Returns the number of available processors currently available to the
* virtual machine. This number may change over time; so a multi-processor
* program want to poll this to determine maximal resource usage.
*
* @return the number of processors available, at least 1
*/
public native int availableProcessors();
/**
* Find out how much memory is still free for allocating Objects on the heap.
*
* @return the number of bytes of free memory for more Objects
*/
public native long freeMemory();
/**
* Find out how much memory total is available on the heap for allocating
* Objects.
*
* @return the total number of bytes of memory for Objects
*/
public native long totalMemory();
/**
* Returns the maximum amount of memory the virtual machine can attempt to
* use. This may be <code>Long.MAX_VALUE</code> if there is no inherent
* limit (or if you really do have a 8 exabyte memory!).
*
* @return the maximum number of bytes the virtual machine will attempt
* to allocate
*/
public native long maxMemory();
/**
* Run the garbage collector. This method is more of a suggestion than
* anything. All this method guarantees is that the garbage collector will
* have "done its best" by the time it returns. Notice that garbage
* collection takes place even without calling this method.
*/
public native void gc();
/**
* Run finalization on all Objects that are waiting to be finalized. Again,
* a suggestion, though a stronger one than {@link #gc()}. This calls the
* <code>finalize</code> method of all objects waiting to be collected.
*
* @see #finalize()
*/
public native void runFinalization();
/**
* Tell the VM to trace every bytecode instruction that executes (print out
* a trace of it). No guarantees are made as to where it will be printed,
* and the VM is allowed to ignore this request.
*
* @param on whether to turn instruction tracing on
*/
public native void traceInstructions(boolean on);
/**
* Tell the VM to trace every method call that executes (print out a trace
* of it). No guarantees are made as to where it will be printed, and the
* VM is allowed to ignore this request.
*
* @param on whether to turn method tracing on
*/
public native void traceMethodCalls(boolean on);
/**
* Load a native library using the system-dependent filename. This is similar
* to loadLibrary, except the only name mangling done is inserting "_g"
* before the final ".so" if the VM was invoked by the name "java_g". There
* may be a security check, of <code>checkLink</code>.
*
* @param filename the file to load
* @throws SecurityException if permission is denied
* @throws UnsatisfiedLinkError if the library is not found
*/
public void load(String filename)
{
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkLink(filename);
_load(filename, false);
}
/**
* Load a native library using a system-independent "short name" for the
* library. It will be transformed to a correct filename in a
* system-dependent manner (for example, in Windows, "mylib" will be turned
* into "mylib.dll"). This is done as follows: if the context that called
* load has a ClassLoader cl, then <code>cl.findLibrary(libpath)</code> is
* used to convert the name. If that result was null, or there was no class
* loader, this searches each directory of the system property
* <code>java.library.path</code> for a file named
* <code>System.mapLibraryName(libname)</code>. There may be a security
* check, of <code>checkLink</code>.
*
* @param filename the file to load
* @throws SecurityException if permission is denied
* @throws UnsatisfiedLinkError if the library is not found
* @see System#mapLibraryName(String)
* @see ClassLoader#findLibrary(String)
*/
public void loadLibrary(String libname)
{
// This is different from the Classpath implementation, but I
// believe it is more correct.
SecurityManager sm = securityManager; // Be thread-safe!
if (sm != null)
sm.checkLink(libname);
_load(libname, false);
}
/**
* Return a localized version of this InputStream, meaning all characters
* are localized before they come out the other end.
*
* @param in the stream to localize
* @return the localized stream
* @deprecated <code>InputStreamReader</code> is the preferred way to read
* local encodings
*/
public InputStream getLocalizedInputStream(InputStream in)
{
return in;
}
// Deprecated in 1.1. We implement what the JCL book says.
public OutputStream getLocalizedOutputStream (OutputStream out)
/**
* Return a localized version of this OutputStream, meaning all characters
* are localized before they are sent to the other end.
*
* @param out the stream to localize
* @return the localized stream
* @deprecated <code>OutputStreamWriter</code> is the preferred way to write
* local encodings
*/
public OutputStream getLocalizedOutputStream(OutputStream out)
{
return out;
}
public static Runtime getRuntime ()
{
return self;
}
/**
* Native method that actually shuts down the virtual machine.
*
* @param status the status to end the process with
*/
native void exitInternal(int status);
private final void checkLink (String lib)
{
if (lib == null)
throw new NullPointerException ();
SecurityManager s = System.getSecurityManager();
if (s != null)
s.checkLink(lib);
}
/**
* Load a file. If it has already been loaded, do nothing. The name has
* already been mapped to a true filename.
*
* @param filename the file to load
* @param do_search True if we should search the load path for the file
*/
native void _load(String filename, boolean do_search);
private native void _load (String pathname, boolean do_search);
/**
*This is a helper function for the ClassLoader which can load
* compiled libraries. Returns true if library (which is just the
* base name -- path searching is done by this function) was loaded,
* false otherwise.
*/
native boolean loadLibraryInternal(String libname);
public void load (String pathname)
{
_load (pathname, false);
}
/**
* A helper for the constructor which does some internal native
* initialization.
*/
private native void init ();
public void loadLibrary (String libname)
{
_load (libname, true);
}
/**
* Map a system-independent "short name" to the full file name, and append
* it to the path.
* XXX This method is being replaced by System.mapLibraryName.
*
* @param pathname the path
* @param libname the short version of the library name
* @return the full filename
*/
static native String nativeGetLibname(String pathname, String libname);
// This is a helper function for the ClassLoader which can load
// compiled libraries. Returns true if library (which is just the
// base name -- path searching is done by this function) was loaded,
// false otherwise.
native boolean loadLibraryInternal (String libname);
/**
* Execute a process. The command line has already been tokenized, and
* the environment should contain name=value mappings. If directory is null,
* use the current working directory; otherwise start the process in that
* directory.
* XXX Add directory support.
*
* @param cmd the non-null command tokens
* @param env the non-null environment setup
* @param dir the directory to use, may be null
* @return the newly created process
* @throws NullPointerException if cmd or env have null elements
*/
// native Process execInternal(String[] cmd, String[] env, File dir);
native Process execInternal(String[] cmd, String[] env);
public native void runFinalization ();
// This method is static in JDK 1.1, but isn't listed as static in
// the books. It is marked as static in the 1.2 docs.
public static void runFinalizersOnExit (boolean run)
{
// The status we pass to the security check is unspecified.
checkExit (0);
self.finalize_on_exit = run;
}
public native long totalMemory ();
public native void traceInstructions (boolean on);
public native void traceMethodCalls (boolean on);
// A helper for the constructor.
private final native void init ();
// The sole constructor.
private Runtime ()
{
init ();
}
// Private data.
private static Runtime self = new Runtime ();
// FIXME: for now this can't be static. If it is, our compiler will
// mark it as local, and it will be inaccessible to natRuntime.cc.
private boolean finalize_on_exit;
}
/**
* Get the system properties. This is done here, instead of in System,
* because of the bootstrap sequence. Note that the native code should
* not try to use the Java I/O classes yet, as they rely on the properties
* already existing. The only safe method to use to insert these default
* system properties is {@link Properties#setProperty(String, String)}.
*
* <p>These properties MUST include:
* <dl>
* <dt>java.version <dd>Java version number
* <dt>java.vendor <dd>Java vendor specific string
* <dt>java.vendor.url <dd>Java vendor URL
* <dt>java.home <dd>Java installation directory
* <dt>java.vm.specification.version <dd>VM Spec version
* <dt>java.vm.specification.vendor <dd>VM Spec vendor
* <dt>java.vm.specification.name <dd>VM Spec name
* <dt>java.vm.version <dd>VM implementation version
* <dt>java.vm.vendor <dd>VM implementation vendor
* <dt>java.vm.name <dd>VM implementation name
* <dt>java.specification.version <dd>Java Runtime Environment version
* <dt>java.specification.vendor <dd>Java Runtime Environment vendor
* <dt>java.specification.name <dd>Java Runtime Environment name
* <dt>java.class.version <dd>Java class version number
* <dt>java.class.path <dd>Java classpath
* <dt>java.library.path <dd>Path for finding Java libraries
* <dt>java.io.tmpdir <dd>Default temp file path
* <dt>java.compiler <dd>Name of JIT to use
* <dt>java.ext.dirs <dd>Java extension path
* <dt>os.name <dd>Operating System Name
* <dt>os.arch <dd>Operating System Architecture
* <dt>os.version <dd>Operating System Version
* <dt>file.separator <dd>File separator ("/" on Unix)
* <dt>path.separator <dd>Path separator (":" on Unix)
* <dt>line.separator <dd>Line separator ("\n" on Unix)
* <dt>user.name <dd>User account name
* <dt>user.home <dd>User home directory
* <dt>user.dir <dd>User's current working directory
* </dl>
*
* @param p the Properties object to insert the system properties into
*/
static native void insertSystemProperties(Properties p);
} // class Runtime

719
libjava/java/lang/System.java
View file

@ -1,252 +1,563 @@
// System.java - System-specific info.
/* System.java -- useful methods to interface with the system
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.lang;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilterInputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.*;
import java.util.Properties;
import java.util.PropertyPermission;
import java.util.TimeZone;
import gnu.classpath.Configuration;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date August 27, 1998
* System represents system-wide resources; things that represent the
* general environment. As such, all methods are static.
*
* @author John Keiser
* @author Eric Blake <ebb9@email.byu.edu>
* @since 1.0
* @status still missing 1.4 functionality
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: 1.1. Some 1.2 methods missing. Properties code not fully
* implemented.
*/
public final class System
{
public static native void arraycopy (Object src, int srcOffset,
Object dst, int dstOffset,
int count);
// WARNING: System is a CORE class in the bootstrap cycle. See the comments
// in vm/reference/java/lang/Runtime for implications of this fact.
public static native long currentTimeMillis ();
// FIXME: When merging with Classpath, remember to remove the call to
// getDefaultTimeZoneId from java.util.Timezone.
private static native String getSystemTimeZone ();
// Get the System Timezone as reported by the OS. It should be in
// the form PST8PDT so we'll need to parse it and check that it's valid.
// The result is used to set the user.timezone property in init_properties.
// FIXME: Using the code from Classpath for generating the System
// Timezone IMO is suboptimal because it ignores whether the rules for
// DST match up.
private static String getDefaultTimeZoneId ()
/**
* Add to the default properties. The field is stored in Runtime, because
* of the bootstrap sequence; but this adds several useful properties to
* the defaults. Once the default is stabilized, it should not be modified;
* instead it is passed as a parent properties for fast setup of the
* defaults when calling <code>setProperties(null)</code>.
*/
static
{
String sysTimeZoneId = getSystemTimeZone ();
// Note that this loadLibrary() takes precedence over the one in Object,
// since Object.<clinit> is waiting for System.<clinit> to complete
// first; but loading a library twice is harmless.
if (Configuration.INIT_LOAD_LIBRARY)
loadLibrary("javalang");
// Check if this is a valid timezone. Make sure the IDs match
// since getTimeZone returns GMT if no match is found.
TimeZone tz = TimeZone.getTimeZone (sysTimeZoneId);
if (tz.getID ().equals (sysTimeZoneId))
return sysTimeZoneId;
Properties defaultProperties = Runtime.defaultProperties;
defaultProperties.put("gnu.cpu.endian",
isWordsBigEndian() ? "big" : "little");
// Check if the base part of sysTimeZoneId is a valid timezone that
// matches with daylight usage and rawOffset. Make sure the IDs match
// since getTimeZone returns GMT if no match is found.
// First find start of GMT offset info and any Daylight zone name.
int startGMToffset = 0;
int sysTimeZoneIdLength = sysTimeZoneId.length();
for (int i = 0; i < sysTimeZoneIdLength && startGMToffset == 0; i++)
{
if (Character.isDigit (sysTimeZoneId.charAt (i)))
startGMToffset = i;
}
// 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"));
}
/**
* 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
= new Properties(Runtime.defaultProperties);
int startDaylightZoneName = 0;
boolean usesDaylight = false;
for (int i = sysTimeZoneIdLength - 1;
i >= 0 && !Character.isDigit (sysTimeZoneId.charAt (i)); --i)
{
startDaylightZoneName = i;
}
if (startDaylightZoneName > 0)
usesDaylight = true;
/**
* The standard InputStream. This is assigned at startup and starts its
* life perfectly valid. Although it is marked final, you can change it
* using {@link #setIn(InputStream)} through some hefty VM magic.
*
* <p>This corresponds to the C stdin and C++ cin variables, which
* typically input from the keyboard, but may be used to pipe input from
* other processes or files. That should all be transparent to you,
* however.
*/
public static final InputStream in
= new BufferedInputStream (new FileInputStream(FileDescriptor.in));
/**
* The standard output PrintStream. This is assigned at startup and
* starts its life perfectly valid. Although it is marked final, you can
* change it using {@link #setOut(PrintStream)} through some hefty VM magic.
*
* <p>This corresponds to the C stdout and C++ cout variables, which
* typically output normal messages to the screen, but may be used to pipe
* output to other processes or files. That should all be transparent to
* you, however.
*/
public static final PrintStream out
= new PrintStream(new BufferedOutputStream (new FileOutputStream(FileDescriptor.out)), true);
/**
* The standard output PrintStream. This is assigned at startup and
* starts its life perfectly valid. Although it is marked final, you can
* change it using {@link #setOut(PrintStream)} through some hefty VM magic.
*
* <p>This corresponds to the C stderr and C++ cerr variables, which
* typically output error messages to the screen, but may be used to pipe
* output to other processes or files. That should all be transparent to
* you, however.
*/
public static final PrintStream err
= new PrintStream(new BufferedOutputStream (new FileOutputStream(FileDescriptor.err)), true);
int GMToffset = Integer.parseInt (startDaylightZoneName == 0 ?
sysTimeZoneId.substring (startGMToffset) :
sysTimeZoneId.substring (startGMToffset, startDaylightZoneName));
// Offset could be in hours or seconds. Convert to millis.
if (GMToffset < 24)
GMToffset *= 60 * 60;
GMToffset *= -1000;
String tzBasename = sysTimeZoneId.substring (0, startGMToffset);
tz = TimeZone.getTimeZone (tzBasename);
if (tz.getID ().equals (tzBasename) && tz.getRawOffset () == GMToffset)
{
boolean tzUsesDaylight = tz.useDaylightTime ();
if (usesDaylight && tzUsesDaylight || !usesDaylight && !tzUsesDaylight)
return tzBasename;
}
// If no match, see if a valid timezone has the same attributes as this
// and then use it instead.
String[] IDs = TimeZone.getAvailableIDs (GMToffset);
for (int i = 0; i < IDs.length; ++i)
{
// FIXME: The daylight savings rules may not match the rules
// for the desired zone.
boolean IDusesDaylight =
TimeZone.getTimeZone (IDs[i]).useDaylightTime ();
if (usesDaylight && IDusesDaylight || !usesDaylight && !IDusesDaylight)
return IDs[i];
}
// If all else fails, return null.
return null;
/**
* This class is uninstantiable.
*/
private System()
{
}
public static void exit (int status)
/**
* Set {@link #in} to a new InputStream. This uses some VM magic to change
* a "final" variable, so naturally there is a security check,
* <code>RuntimePermission("setIO")</code>.
*
* @param in the new InputStream
* @throws SecurityException if permission is denied
* @since 1.1
*/
public static void setIn(InputStream in)
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPermission(new RuntimePermission("setIO"));
setIn0(in);
}
/**
* Set {@link #out} to a new PrintStream. This uses some VM magic to change
* a "final" variable, so naturally there is a security check,
* <code>RuntimePermission("setIO")</code>.
*
* @param out the new PrintStream
* @throws SecurityException if permission is denied
* @since 1.1
*/
public static void setOut(PrintStream out)
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPermission(new RuntimePermission("setIO"));
setOut0(out);
}
/**
* Set {@link #err} to a new PrintStream. This uses some VM magic to change
* a "final" variable, so naturally there is a security check,
* <code>RuntimePermission("setIO")</code>.
*
* @param err the new PrintStream
* @throws SecurityException if permission is denied
* @since 1.1
*/
public static void setErr(PrintStream err)
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPermission(new RuntimePermission("setIO"));
setErr0(err);
}
/**
* Set the current SecurityManager. If a security manager already exists,
* then <code>RuntimePermission("setSecurityManager")</code> is checked
* first. Since this permission is denied by the default security manager,
* setting the security manager is often an irreversible action.
*
* <STRONG>Spec Note:</STRONG> Don't ask me, I didn't write it. It looks
* pretty vulnerable; whoever gets to the gate first gets to set the policy.
* There is probably some way to set the original security manager as a
* command line argument to the VM, but I don't know it.
*
* @param sm the new SecurityManager
* @throws SecurityException if permission is denied
*/
public synchronized static void setSecurityManager(SecurityManager sm)
{
// Implementation note: the field lives in Runtime because of bootstrap
// initialization issues. This method is synchronized so that no other
// thread changes it to null before this thread makes the change.
if (Runtime.securityManager != null)
Runtime.securityManager.checkPermission
(new RuntimePermission("setSecurityManager"));
Runtime.securityManager = sm;
}
/**
* Get the current SecurityManager. If the SecurityManager has not been
* set yet, then this method returns null.
*
* @return the current SecurityManager, or null
*/
public static SecurityManager getSecurityManager()
{
// Implementation note: the field lives in Runtime because of bootstrap
// initialization issues.
return Runtime.securityManager;
}
/**
* Get the current time, measured in the number of milliseconds from the
* beginning of Jan. 1, 1970. This is gathered from the system clock, with
* any attendant incorrectness (it may be timezone dependent).
*
* @return the current time
* @see java.util.Date
*/
public static native long currentTimeMillis();
/**
* Copy one array onto another from <code>src[srcStart]</code> ...
* <code>src[srcStart+len-1]</code> to <code>dest[destStart]</code> ...
* <code>dest[destStart+len-1]</code>. First, the arguments are validated:
* neither array may be null, they must be of compatible types, and the
* start and length must fit within both arrays. Then the copying starts,
* and proceeds through increasing slots. If src and dest are the same
* array, this will appear to copy the data to a temporary location first.
* An ArrayStoreException in the middle of copying will leave earlier
* elements copied, but later elements unchanged.
*
* @param src the array to copy elements from
* @param srcStart the starting position in src
* @param dest the array to copy elements to
* @param destStart the starting position in dest
* @param len the number of elements to copy
* @throws NullPointerException if src or dest is null
* @throws ArrayStoreException if src or dest is not an array, if they are
* not compatible array types, or if an incompatible runtime type
* is stored in dest
* @throws IndexOutOfBoundsException if len is negative, or if the start or
* end copy position in either array is out of bounds
*/
public static native void arraycopy(Object src, int srcStart,
Object dest, int destStart, int len);
/**
* Get a hash code computed by the VM for the Object. This hash code will
* be the same as Object's hashCode() method. It is usually some
* convolution of the pointer to the Object internal to the VM. It
* follows standard hash code rules, in that it will remain the same for a
* given Object for the lifetime of that Object.
*
* @param o the Object to get the hash code for
* @return the VM-dependent hash code for this Object
* @since 1.1
*/
public static native int identityHashCode(Object o);
/**
* Get all the system properties at once. A security check may be performed,
* <code>checkPropertiesAccess</code>. Note that a security manager may
* allow getting a single property, but not the entire group.
*
* <p>The required properties include:
* <dl>
* <dt>java.version <dd>Java version number
* <dt>java.vendor <dd>Java vendor specific string
* <dt>java.vendor.url <dd>Java vendor URL
* <dt>java.home <dd>Java installation directory
* <dt>java.vm.specification.version <dd>VM Spec version
* <dt>java.vm.specification.vendor <dd>VM Spec vendor
* <dt>java.vm.specification.name <dd>VM Spec name
* <dt>java.vm.version <dd>VM implementation version
* <dt>java.vm.vendor <dd>VM implementation vendor
* <dt>java.vm.name <dd>VM implementation name
* <dt>java.specification.version <dd>Java Runtime Environment version
* <dt>java.specification.vendor <dd>Java Runtime Environment vendor
* <dt>java.specification.name <dd>Java Runtime Environment name
* <dt>java.class.version <dd>Java class version number
* <dt>java.class.path <dd>Java classpath
* <dt>java.library.path <dd>Path for finding Java libraries
* <dt>java.io.tmpdir <dd>Default temp file path
* <dt>java.compiler <dd>Name of JIT to use
* <dt>java.ext.dirs <dd>Java extension path
* <dt>os.name <dd>Operating System Name
* <dt>os.arch <dd>Operating System Architecture
* <dt>os.version <dd>Operating System Version
* <dt>file.separator <dd>File separator ("/" on Unix)
* <dt>path.separator <dd>Path separator (":" on Unix)
* <dt>line.separator <dd>Line separator ("\n" on Unix)
* <dt>user.name <dd>User account name
* <dt>user.home <dd>User home directory
* <dt>user.dir <dd>User's current working directory
* </dl>
*
* In addition, gnu defines several other properties, where ? stands for
* each character in '0' through '9':
* <dl>
* <dt> gnu.cpu.endian <dd>big or little
* <dt> gnu.java.io.encoding_scheme_alias.ISO-8859-? <dd>8859_?
* <dt> gnu.java.io.encoding_scheme_alias.iso-8859-? <dd>8859_?
* <dt> gnu.java.io.encoding_scheme_alias.iso8859_? <dd>8859_?
* <dt> gnu.java.io.encoding_scheme_alias.iso-latin-_? <dd>8859_?
* <dt> gnu.java.io.encoding_scheme_alias.latin? <dd>8859_?
* <dt> gnu.java.io.encoding_scheme_alias.UTF-8 <dd>UTF8
* <dt> gnu.java.io.encoding_scheme_alias.utf-8 <dd>UTF8
* </dl>
*
* @return the system properties, will never be null
* @throws SecurityException if permission is denied
*/
public static Properties getProperties()
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPropertiesAccess();
return properties;
}
/**
* Set all the system properties at once. A security check may be performed,
* <code>checkPropertiesAccess</code>. Note that a security manager may
* allow setting a single property, but not the entire group. An argument
* of null resets the properties to the startup default.
*
* @param properties the new set of system properties
* @throws SecurityException if permission is denied
*/
public static void setProperties(Properties properties)
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPropertiesAccess();
if (properties == null)
properties = new Properties(Runtime.defaultProperties);
System.properties = properties;
}
/**
* Get a single system property by name. A security check may be performed,
* <code>checkPropertyAccess(key)</code>.
*
* @param key the name of the system property to get
* @return the property, or null if not found
* @throws SecurityException if permission is denied
* @throws NullPointerException if key is null
* @throws IllegalArgumentException if key is ""
*/
public static String getProperty(String key)
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPropertyAccess(key);
else if (key.length() == 0)
throw new IllegalArgumentException("key can't be empty");
return properties.getProperty(key);
}
/**
* Get a single system property by name. A security check may be performed,
* <code>checkPropertyAccess(key)</code>.
*
* @param key the name of the system property to get
* @param def the default
* @return the property, or def if not found
* @throws SecurityException if permission is denied
* @throws NullPointerException if key is null
* @throws IllegalArgumentException if key is ""
*/
public static String getProperty(String key, String def)
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPropertyAccess(key);
return properties.getProperty(key, def);
}
/**
* Set a single system property by name. A security check may be performed,
* <code>checkPropertyAccess(key, "write")</code>.
*
* @param key the name of the system property to set
* @param value the new value
* @return the previous value, or null
* @throws SecurityException if permission is denied
* @throws NullPointerException if key is null
* @throws IllegalArgumentException if key is ""
* @since 1.2
*/
public static String setProperty(String key, String value)
{
SecurityManager sm = Runtime.securityManager; // Be thread-safe.
if (sm != null)
sm.checkPermission(new PropertyPermission(key, "write"));
return (String) properties.setProperty(key, value);
}
/**
* This used to get an environment variable, but following Sun's lead,
* it now throws an Error. Use <code>getProperty</code> instead.
*
* @param name the name of the environment variable
* @return this does not return
* @throws Error this is not supported
* @deprecated use {@link #getProperty(String)}; getenv is not supported
*/
public static String getenv(String name)
{
throw new Error("getenv no longer supported, use properties instead: "
+ name);
}
/**
* Terminate the Virtual Machine. This just calls
* <code>Runtime.getRuntime().exit(status)</code>, and never returns.
* Obviously, a security check is in order, <code>checkExit</code>.
*
* @param status the exit status; by convention non-zero is abnormal
* @throws SecurityException if permission is denied
* @see Runtime#exit(int)
*/
public static void exit(int status)
{
Runtime.getRuntime().exit(status);
}
public static void gc ()
/**
* Calls the garbage collector. This is only a hint, and it is up to the
* implementation what this hint suggests, but it usually causes a
* best-effort attempt to reclaim unused memory from discarded objects.
* This calls <code>Runtime.getRuntime().gc()</code>.
*
* @see Runtime#gc()
*/
public static void gc()
{
Runtime.getRuntime().gc();
}
// Marked deprecated in 1.1. We implement what the JCL book says.
public static String getenv (String name)
{
throw new Error ();
}
private static native void init_properties ();
public static Properties getProperties ()
{
if (secman != null)
secman.checkPropertiesAccess();
if (properties == null)
init_properties ();
return properties;
}
public static String getProperty (String property)
{
if (secman != null)
secman.checkPropertyAccess(property);
if (properties == null)
init_properties ();
return properties.getProperty(property);
}
public static String getProperty (String property, String defval)
{
if (secman != null)
secman.checkPropertyAccess(property);
if (properties == null)
init_properties ();
return properties.getProperty(property, defval);
}
public static SecurityManager getSecurityManager ()
{
return secman;
}
public static native int identityHashCode (Object obj);
public static void load (String pathname)
{
Runtime.getRuntime().load(pathname);
}
public static void loadLibrary (String libname)
{
Runtime.getRuntime().loadLibrary(libname);
}
public static void runFinalization ()
/**
* Runs object finalization on pending objects. This is only a hint, and
* it is up to the implementation what this hint suggests, but it usually
* causes a best-effort attempt to run finalizers on all objects ready
* to be reclaimed. This calls
* <code>Runtime.getRuntime().runFinalization()</code>.
*
* @see Runtime#runFinalization()
*/
public static void runFinalization()
{
Runtime.getRuntime().runFinalization();
}
// Marked as deprecated in 1.2.
public static void runFinalizersOnExit (boolean run)
/**
* Tell the Runtime whether to run finalization before exiting the
* JVM. This is inherently unsafe in multi-threaded applications,
* since it can force initialization on objects which are still in use
* by live threads, leading to deadlock; therefore this is disabled by
* default. There may be a security check, <code>checkExit(0)</code>. This
* calls <code>Runtime.getRuntime().runFinalizersOnExit()</code>.
*
* @param finalizeOnExit whether to run finalizers on exit
* @throws SecurityException if permission is denied
* @see Runtime#runFinalizersOnExit()
* @since 1.1
* @deprecated never rely on finalizers to do a clean, thread-safe,
* mop-up from your code
*/
public static void runFinalizersOnExit(boolean finalizeOnExit)
{
Runtime.getRuntime().runFinalizersOnExit(run);
Runtime.getRuntime().runFinalizersOnExit(finalizeOnExit);
}
private static void checkSetIO ()
/**
* Load a code file using its explicit system-dependent filename. A security
* check may be performed, <code>checkLink</code>. This just calls
* <code>Runtime.getRuntime().load(filename)</code>.
*
* @param filename the code file to load
* @throws SecurityException if permission is denied
* @throws UnsatisfiedLinkError if the file cannot be loaded
* @see Runtime#load(String)
*/
public static void load(String filename)
{
// In 1.1, we are supposed to call checkExec, but the argument is
// not specified. In 1.2, we are supposed to use checkPermission,
// which doesn't exist in 1.1.
if (secman != null)
secman.checkExec("");
Runtime.getRuntime().load(filename);
}
public static native void setErr (PrintStream newErr);
public static native void setIn (InputStream newIn);
public static native void setOut (PrintStream newOut);
public static void setProperties (Properties props)
/**
* Load a library using its explicit system-dependent filename. A security
* check may be performed, <code>checkLink</code>. This just calls
* <code>Runtime.getRuntime().load(filename)</code>.
*
* @param libname the library file to load
* @throws SecurityException if permission is denied
* @throws UnsatisfiedLinkError if the file cannot be loaded
* @see Runtime#load(String)
*/
public static void loadLibrary(String libname)
{
if (secman != null)
secman.checkPropertiesAccess();
synchronized (System.class)
{
properties = props;
}
Runtime.getRuntime().loadLibrary(libname);
}
public static String setProperty (String key, String value)
/**
* Convert a library name to its platform-specific variant.
*
* @param libname the library name, as used in <code>loadLibrary</code>
* @return the platform-specific mangling of the name
* @since 1.2
*/
public static String mapLibraryName(String libname)
{
if (secman != null)
secman.checkPermission (new PropertyPermission (key, "write"));
if (properties == null)
init_properties ();
return (String) properties.setProperty (key, value);
// XXX Fix this!!!!
return Runtime.nativeGetLibname("", libname);
}
// TODO 1.2.
// public static String mapLibraryName (String libname);
/**
* Detect big-endian systems.
*
* @return true if the system is big-endian.
*/
static native boolean isWordsBigEndian();
public static void setSecurityManager (SecurityManager s)
{
if (secman != null)
secman.checkPermission(new RuntimePermission("setSecurityManager"));
secman = s;
}
/**
* Set {@link #in} to a new InputStream.
*
* @param in the new InputStream
* @see #setIn(InputStream)
*/
private static native void setIn0(InputStream in);
// Public data.
public static final InputStream in = new BufferedInputStream (new FileInputStream (FileDescriptor.in));
/**
* Set {@link #out} to a new PrintStream.
*
* @param out the new PrintStream
* @see #setOut(PrintStream)
*/
private static native void setOut0(PrintStream out);
public static final PrintStream out = new PrintStream (new BufferedOutputStream (new FileOutputStream (FileDescriptor.out)), true);
public static final PrintStream err = new PrintStream (new BufferedOutputStream (new FileOutputStream (FileDescriptor.err)), true);
// Don't allow System objects to be made.
private System ()
{
}
// Private data.
private static SecurityManager secman = null;
private static Properties properties = null;
}
/**
* Set {@link #err} to a new PrintStream.
*
* @param err the new PrintStream
* @see #setErr(PrintStream)
*/
private static native void setErr0(PrintStream err);
} // class System

375
libjava/java/lang/natRuntime.cc
View file

@ -14,14 +14,53 @@ details. */
#include <gcj/cni.h>
#include <jvm.h>
#include <java-props.h>
#include <java/lang/Long.h>
#include <java/lang/Runtime.h>
#include <java/lang/UnknownError.h>
#include <java/lang/UnsatisfiedLinkError.h>
#include <gnu/gcj/runtime/FileDeleter.h>
#include <gnu/gcj/runtime/FinalizerThread.h>
#include <java/util/Properties.h>
#include <java/util/TimeZone.h>
#include <java/lang/StringBuffer.h>
#include <java/lang/Process.h>
#include <java/lang/ConcreteProcess.h>
#include <jni.h>
#include "platform.h"
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#include <errno.h>
#ifdef HAVE_UNAME
#include <sys/utsname.h>
#endif
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif
#ifdef HAVE_LANGINFO_H
#include <langinfo.h>
#endif
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#ifdef USE_LTDL
#include <ltdl.h>
@ -83,21 +122,16 @@ _Jv_FindSymbolInExecutable (const char *symname)
#endif /* USE_LTDL */
void
java::lang::Runtime::exit (jint status)
{
checkExit (status);
_exit (status);
}
void
java::lang::Runtime::_exit (jint status)
java::lang::Runtime::exitInternal (jint status)
{
// Make status right for Unix. This is perhaps strange.
if (status < 0 || status > 255)
status = 255;
if (finalize_on_exit)
if (finalizeOnExit)
_Jv_RunAllFinalizers ();
// Delete all files registered with File.deleteOnExit()
@ -122,7 +156,6 @@ void
java::lang::Runtime::_load (jstring path, jboolean do_search)
{
JvSynchronize sync (this);
checkLink (path);
using namespace java::lang;
#ifdef USE_LTDL
jint len = _Jv_GetStringUTFLength (path);
@ -205,7 +238,6 @@ java::lang::Runtime::loadLibraryInternal (jstring lib)
void
java::lang::Runtime::init (void)
{
finalize_on_exit = false;
#ifdef USE_LTDL
lt_dlinit ();
lt_dlhandle self = lt_dlopen (NULL);
@ -226,6 +258,14 @@ java::lang::Runtime::totalMemory (void)
return _Jv_GCTotalMemory ();
}
jlong
java::lang::Runtime::maxMemory (void)
{
// We don't have a maximum. FIXME: we might if we ask the GC for
// one.
return Long::MAX_VALUE;
}
void
java::lang::Runtime::traceInstructions (jboolean)
{
@ -237,3 +277,318 @@ java::lang::Runtime::traceMethodCalls (jboolean)
{
// Do nothing.
}
#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
java::lang::Runtime::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.
SET ("java.version", GCJVERSION);
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", "1.3");
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", PREFIX);
SET ("file.encoding", default_file_encoding);
#ifdef HAVE_UNAME
struct utsname u;
if (! uname (&u))
{
SET ("os.name", u.sysname);
SET ("os.arch", u.machine);
SET ("os.version", u.release);
}
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");
}
// Set some properties according to whatever was compiled in with
// `-D'.
for (int i = 0; _Jv_Compiler_Properties[i]; ++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
if (_Jv_Jar_Class_Path)
newprops->put(JvNewStringLatin1 ("java.class.path"),
JvNewStringLatin1 (_Jv_Jar_Class_Path));
else
{
// FIXME: find libgcj.zip and append its path?
char *classpath = ::getenv("CLASSPATH");
jstring cp = newprops->getProperty (JvNewStringLatin1("java.class.path"));
java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
if (classpath)
{
sb->append (JvNewStringLatin1 (classpath));
#ifdef WIN32
sb->append ((jchar) ';');
#else
sb->append ((jchar) ':');
#endif
}
if (cp != NULL)
sb->append (cp);
else
sb->append ((jchar) '.');
newprops->put(JvNewStringLatin1 ("java.class.path"),
sb->toString ());
}
// Allow platform specific settings and overrides.
_Jv_platform_initProperties (newprops);
}
java::lang::Process *
java::lang::Runtime::execInternal (jstringArray cmd,
jstringArray env)
{
return new java::lang::ConcreteProcess (cmd, env);
}
jint
java::lang::Runtime::availableProcessors (void)
{
// FIXME: find the real value.
return 1;
}
jstring
java::lang::Runtime::nativeGetLibname (jstring pathname, jstring libname)
{
java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
sb->append(pathname);
if (pathname->length() > 0)
{
// FIXME: use platform function here.
#ifdef WIN32
sb->append ((jchar) '\\');
#else
sb->append ((jchar) '/');
#endif
}
// FIXME: use platform function here.
#ifndef WIN32
sb->append (JvNewStringLatin1 ("lib"));
#endif
sb->append(libname);
// FIXME: use platform function here.
#ifdef WIN32
sb->append (JvNewStringLatin1 ("dll"));
else
sb->append (JvNewStringLatin1 ("so"));
#endif
return sb->toString();
}

399
libjava/java/lang/natSystem.cc
View file

@ -14,73 +14,35 @@ details. */
#include <string.h>
#include <stdlib.h>
#include "platform.h"
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#include <errno.h>
#ifdef HAVE_UNAME
#include <sys/utsname.h>
#endif
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif
#ifdef HAVE_LANGINFO_H
#include <langinfo.h>
#endif
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#include <gcj/cni.h>
#include <jvm.h>
#include <java-props.h>
#include <java/lang/System.h>
#include <java/lang/Class.h>
#include <java/lang/ArrayStoreException.h>
#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/NullPointerException.h>
#include <java/lang/StringBuffer.h>
#include <java/util/Properties.h>
#include <java/util/TimeZone.h>
#include <java/io/PrintStream.h>
#include <java/io/InputStream.h>
#include "platform.h"
void
java::lang::System::setErr (java::io::PrintStream *newErr)
java::lang::System::setErr0 (java::io::PrintStream *newErr)
{
checkSetIO ();
// This violates `final' semantics. Oh well.
err = newErr;
}
void
java::lang::System::setIn (java::io::InputStream *newIn)
java::lang::System::setIn0 (java::io::InputStream *newIn)
{
checkSetIO ();
// This violates `final' semantics. Oh well.
in = newIn;
}
void
java::lang::System::setOut (java::io::PrintStream *newOut)
java::lang::System::setOut0 (java::io::PrintStream *newOut)
{
checkSetIO ();
// This violates `final' semantics. Oh well.
out = newOut;
}
@ -167,346 +129,15 @@ java::lang::System::identityHashCode (jobject obj)
return _Jv_HashCode (obj);
}
#if ! defined (DEFAULT_FILE_ENCODING) && defined (HAVE_ICONV) \
&& defined (HAVE_NL_LANGINFO)
static char *
file_encoding ()
jboolean
java::lang::System::isWordsBigEndian (void)
{
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
/*
* This method returns a time zone string that is used by init_properties
* to set the default timezone property 'user.timezone'. That value is
* used by default as a key into the timezone table used by the
* java::util::TimeZone class.
*/
jstring
java::lang::System::getSystemTimeZone (void)
{
struct tm *tim;
time_t current_time;
long tzoffset;
const char *tz1, *tz2;
char *tzid;
current_time = time(0);
mktime(tim = localtime(&current_time));
#ifdef STRUCT_TM_HAS_GMTOFF
// tm_gmtoff is secs EAST of UTC.
tzoffset = -(tim->tm_gmtoff) + tim->tm_isdst * 3600L;
#elif HAVE_UNDERSCORE_TIMEZONE
tzoffset = _timezone;
#elif HAVE_TIMEZONE
// timezone is secs WEST of UTC.
tzoffset = timezone;
#else
// FIXME: there must be another global if neither tm_gmtoff nor timezone
// is available, esp. if tzname is valid.
// Richard Earnshaw <rearnsha@arm.com> has suggested using difftime to
// calculate between gmtime and localtime (and accounting for possible
// daylight savings time) as an alternative.
tzoffset = 0L;
#endif
#ifdef HAVE_TM_ZONE
tz1 = tim->tm_zone;
tz2 = "";
#elif defined (HAVE_TZNAME)
tz1 = tzname[0];
tz2 = strcmp (tzname[0], tzname[1]) ? tzname[1] : "";
#else
// Some targets have no concept of timezones.
tz1 = "???";
tz2 = tz1;
#endif
if ((tzoffset % 3600) == 0)
tzoffset = tzoffset / 3600;
tzid = (char*) _Jv_Malloc (strlen(tz1) + strlen(tz2) + 6);
sprintf(tzid, "%s%ld%s", tz1, tzoffset, tz2);
jstring retval = JvNewStringUTF (tzid);
_Jv_Free (tzid);
return retval;
}
void
java::lang::System::init_properties (void)
{
JvSynchronize sync (&java::lang::System::class$);
if (properties != NULL)
return;
java::util::Properties* newprops = new java::util::Properties ();
// 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.
SET ("java.version", GCJVERSION);
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", "1.3");
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", PREFIX);
SET ("file.encoding", default_file_encoding);
#ifdef HAVE_UNAME
struct utsname u;
if (! uname (&u))
{
SET ("os.name", u.sysname);
SET ("os.arch", u.machine);
SET ("os.version", u.release);
}
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");
}
// Set the "user.timezone" property.
jstring timezone = getDefaultTimeZoneId ();
if (timezone != NULL)
newprops->put (JvNewStringLatin1 ("user.timezone"), timezone);
// Set some properties according to whatever was compiled in with
// `-D'.
for (int i = 0; _Jv_Compiler_Properties[i]; ++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
if (_Jv_Jar_Class_Path)
newprops->put(JvNewStringLatin1 ("java.class.path"),
JvNewStringLatin1 (_Jv_Jar_Class_Path));
else
{
// FIXME: find libgcj.zip and append its path?
char *classpath = ::getenv("CLASSPATH");
jstring cp = newprops->getProperty (JvNewStringLatin1("java.class.path"));
java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
if (classpath)
{
sb->append (JvNewStringLatin1 (classpath));
#ifdef WIN32
sb->append ((jchar) ';');
#else
sb->append ((jchar) ':');
#endif
}
if (cp != NULL)
sb->append (cp);
else
sb->append ((jchar) '.');
newprops->put(JvNewStringLatin1 ("java.class.path"),
sb->toString ());
}
// Allow platform specific settings and overrides.
_Jv_platform_initProperties (newprops);
// Finally, set the field. This ensures that concurrent getProperty()
// calls will return initialized values without requiring them to be
// synchronized in the common case.
properties = newprops;
union
{
long lval;
char cval;
} u;
u.lval = 1;
return u.cval == 0;
}

23
libjava/java/util/TimeZone.java
View file

@ -1,5 +1,5 @@
/* java.util.TimeZone
Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -38,6 +38,7 @@ exception statement from your version. */
package java.util;
import java.text.DateFormatSymbols;
import gnu.classpath.Configuration;
/**
* This class represents a time zone offset and handles daylight savings.
@ -753,16 +754,32 @@ public abstract class TimeZone implements java.io.Serializable, Cloneable
/* Look up default timezone */
static
{
// System.loadLibrary("javautil");
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javautil");
}
String tzid = System.getProperty("user.timezone");
if (tzid == null)
tzid = getDefaultTimeZoneId();
if (tzid == null)
tzid = "GMT";
defaultZone = getTimeZone(tzid);
}
/* This method returns us a time zone id string which is in the
form <standard zone name><GMT offset><daylight time zone name>.
The GMT offset is in seconds, except where it is evenly divisible
by 3600, then it is in hours. If the zone does not observe
daylight time, then the daylight zone name is omitted. Examples:
in Chicago, the timezone would be CST6CDT. In Indianapolis
(which does not have Daylight Savings Time) the string would
be EST5
*/
private static native String getDefaultTimeZoneId();
/**
* Gets the time zone offset, for current date, modified in case of
* daylight savings. This is the offset to add to UTC to get the local

154
libjava/java/util/natTimeZone.cc Normal file
View file

@ -0,0 +1,154 @@
// natTimeZone.cc -- Native side of TimeZone class.
/* Copyright (C) 1998, 1999, 2000, 2001, 2002 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 <gcj/cni.h>
#include <jvm.h>
#include <java/util/TimeZone.h>
#include <java/lang/Character.h>
#include <java/lang/Integer.h>
/*
* This method returns a time zone string that is used by init_properties
* to set the default timezone property 'user.timezone'. That value is
* used by default as a key into the timezone table used by the
* java::util::TimeZone class.
*/
static jstring
getSystemTimeZone (void)
{
struct tm *tim;
time_t current_time;
long tzoffset;
const char *tz1, *tz2;
char *tzid;
current_time = time(0);
mktime(tim = localtime(&current_time));
#ifdef STRUCT_TM_HAS_GMTOFF
// tm_gmtoff is secs EAST of UTC.
tzoffset = -(tim->tm_gmtoff) + tim->tm_isdst * 3600L;
#elif HAVE_UNDERSCORE_TIMEZONE
tzoffset = _timezone;
#elif HAVE_TIMEZONE
// timezone is secs WEST of UTC.
tzoffset = timezone;
#else
// FIXME: there must be another global if neither tm_gmtoff nor timezone
// is available, esp. if tzname is valid.
// Richard Earnshaw <rearnsha@arm.com> has suggested using difftime to
// calculate between gmtime and localtime (and accounting for possible
// daylight savings time) as an alternative.
tzoffset = 0L;
#endif
#ifdef HAVE_TM_ZONE
tz1 = tim->tm_zone;
tz2 = "";
#elif defined (HAVE_TZNAME)
tz1 = tzname[0];
tz2 = strcmp (tzname[0], tzname[1]) ? tzname[1] : "";
#else
// Some targets have no concept of timezones.
tz1 = "???";
tz2 = tz1;
#endif
if ((tzoffset % 3600) == 0)
tzoffset = tzoffset / 3600;
tzid = (char*) _Jv_Malloc (strlen(tz1) + strlen(tz2) + 6);
sprintf(tzid, "%s%ld%s", tz1, tzoffset, tz2);
jstring retval = JvNewStringUTF (tzid);
_Jv_Free (tzid);
return retval;
}
// Get the System Timezone as reported by the OS. It should be in
// the form PST8PDT so we'll need to parse it and check that it's valid.
// FIXME: Using the code from Classpath for generating the System
// Timezone IMO is suboptimal because it ignores whether the rules for
// DST match up.
jstring
java::util::TimeZone::getDefaultTimeZoneId ()
{
jstring sysTimeZoneId = getSystemTimeZone ();
using namespace java::lang;
// Check if this is a valid timezone. Make sure the IDs match
// since getTimeZone returns GMT if no match is found.
TimeZone *tz = TimeZone::getTimeZone (sysTimeZoneId);
if (tz->getID ()->equals (sysTimeZoneId))
return sysTimeZoneId;
// Check if the base part of sysTimeZoneId is a valid timezone that
// matches with daylight usage and rawOffset. Make sure the IDs match
// since getTimeZone returns GMT if no match is found.
// First find start of GMT offset info and any Daylight zone name.
int startGMToffset = 0;
int sysTimeZoneIdLength = sysTimeZoneId->length();
for (int i = 0; i < sysTimeZoneIdLength && startGMToffset == 0; i++)
{
if (Character::isDigit (sysTimeZoneId->charAt (i)))
startGMToffset = i;
}
int startDaylightZoneName = 0;
jboolean usesDaylight = false;
for (int i = sysTimeZoneIdLength - 1;
i >= 0 && !Character::isDigit (sysTimeZoneId->charAt (i)); --i)
{
startDaylightZoneName = i;
}
if (startDaylightZoneName > 0)
usesDaylight = true;
int GMToffset
= Integer::parseInt (startDaylightZoneName == 0 ?
sysTimeZoneId->substring (startGMToffset) :
sysTimeZoneId->substring (startGMToffset,
startDaylightZoneName));
// Offset could be in hours or seconds. Convert to millis.
if (GMToffset < 24)
GMToffset *= 60 * 60;
GMToffset *= -1000;
jstring tzBasename = sysTimeZoneId->substring (0, startGMToffset);
tz = TimeZone::getTimeZone (tzBasename);
if (tz->getID ()->equals (tzBasename) && tz->getRawOffset () == GMToffset)
{
jboolean tzUsesDaylight = tz->useDaylightTime ();
if (usesDaylight && tzUsesDaylight || !usesDaylight && !tzUsesDaylight)
return tzBasename;
}
// If no match, see if a valid timezone has the same attributes as this
// and then use it instead.
jstringArray IDs = TimeZone::getAvailableIDs (GMToffset);
jstring *elts = elements (IDs);
for (int i = 0; i < IDs->length; ++i)
{
// FIXME: The daylight savings rules may not match the rules
// for the desired zone.
jboolean IDusesDaylight =
TimeZone::getTimeZone (elts[i])->useDaylightTime ();
if (usesDaylight && IDusesDaylight || !usesDaylight && !IDusesDaylight)
return elts[i];
}
// If all else fails, return null.
return NULL;
}