+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
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
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
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
@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)
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
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
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 \
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 \
.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 \
@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 \
-// 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)
{
- return in;
+ SecurityManager sm = securityManager; // Be thread-safe!
+ if (sm != null)
+ sm.checkExit(0);
+ current.finalizeOnExit = finalizeOnExit;
}
- // Deprecated in 1.1. We implement what the JCL book says.
- public OutputStream getLocalizedOutputStream (OutputStream out)
+ /**
+ * 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 out;
+ return exec(cmdline, null, null);
}
- public static Runtime getRuntime ()
+ /**
+ * 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 self;
+ return exec(cmdline, env, null);
}
- private final void checkLink (String lib)
+ /**
+ * 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
{
- if (lib == null)
- throw new NullPointerException ();
- SecurityManager s = System.getSecurityManager();
- if (s != null)
- s.checkLink(lib);
+ 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);
}
- private native void _load (String pathname, boolean do_search);
+ /**
+ * 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);
+ }
- public void load (String pathname)
+ /**
+ * 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
{
- _load (pathname, false);
+ return exec(cmd, env, null);
}
- public void loadLibrary (String libname)
+ /**
+ * 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
{
- _load (libname, true);
+ 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);
}
- // 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);
+ /**
+ * 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();
- public native void runFinalization ();
+ /**
+ * 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();
- // 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)
+ /**
+ * 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)
{
- // The status we pass to the security check is unspecified.
- checkExit (0);
- self.finalize_on_exit = run;
+ SecurityManager sm = securityManager; // Be thread-safe!
+ if (sm != null)
+ sm.checkLink(filename);
+ _load(filename, false);
}
- public native long totalMemory ();
- public native void traceInstructions (boolean on);
- public native void traceMethodCalls (boolean on);
+ /**
+ * 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);
+ }
- // A helper for the constructor.
- private final native void init ();
+ /**
+ * 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;
+ }
- // The sole constructor.
- private Runtime ()
+ /**
+ * 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)
{
- init ();
+ return out;
}
- // 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;
-}
+ /**
+ * Native method that actually shuts down the virtual machine.
+ *
+ * @param status the status to end the process with
+ */
+ native void exitInternal(int status);
+
+ /**
+ * 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);
+
+ /**
+ *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);
+
+ /**
+ * A helper for the constructor which does some internal native
+ * initialization.
+ */
+ private native void init ();
+
+ /**
+ * 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);
+
+ /**
+ * 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);
+
+ /**
+ * 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
-// 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.
+
+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. */
-/* Copyright (C) 1998, 1999, 2000, 2001 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. */
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
- */
-
-/* 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.
+ * 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
*/
-
public final class System
{
- public static native void arraycopy (Object src, int srcOffset,
- Object dst, int dstOffset,
- int count);
-
- 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 ()
- {
- String sysTimeZoneId = getSystemTimeZone ();
-
- // 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;
- boolean 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;
-
- 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;
- }
-
- public static void exit (int status)
+ // WARNING: System is a CORE class in the bootstrap cycle. See the comments
+ // in vm/reference/java/lang/Runtime for implications of this fact.
+
+ /**
+ * 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
{
- Runtime.getRuntime().exit(status);
+ // 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");
+
+ Properties defaultProperties = Runtime.defaultProperties;
+ 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"));
}
-
- public static void gc ()
+
+ /**
+ * 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);
+
+ /**
+ * 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);
+
+ /**
+ * This class is uninstantiable.
+ */
+ private System()
{
- Runtime.getRuntime().gc();
}
- // Marked deprecated in 1.1. We implement what the JCL book says.
- public static String getenv (String name)
+ /**
+ * 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)
{
- throw new Error ();
+ SecurityManager sm = Runtime.securityManager; // Be thread-safe.
+ if (sm != null)
+ sm.checkPermission(new RuntimePermission("setIO"));
+ setIn0(in);
}
- private static native void init_properties ();
-
- public static Properties getProperties ()
+ /**
+ * 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)
{
- if (secman != null)
- secman.checkPropertiesAccess();
- if (properties == null)
- init_properties ();
- return properties;
+ SecurityManager sm = Runtime.securityManager; // Be thread-safe.
+ if (sm != null)
+ sm.checkPermission(new RuntimePermission("setIO"));
+ setOut0(out);
}
- public static String getProperty (String property)
+ /**
+ * 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)
{
- if (secman != null)
- secman.checkPropertyAccess(property);
- if (properties == null)
- init_properties ();
- return properties.getProperty(property);
+ SecurityManager sm = Runtime.securityManager; // Be thread-safe.
+ if (sm != null)
+ sm.checkPermission(new RuntimePermission("setIO"));
+ setErr0(err);
}
- public static String getProperty (String property, String defval)
+ /**
+ * 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)
{
- if (secman != null)
- secman.checkPropertyAccess(property);
- if (properties == null)
- init_properties ();
- return properties.getProperty(property, defval);
+ // 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;
}
- public static SecurityManager getSecurityManager ()
+ /**
+ * 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()
{
- return secman;
+ // Implementation note: the field lives in Runtime because of bootstrap
+ // initialization issues.
+ return Runtime.securityManager;
}
- public static native int identityHashCode (Object obj);
-
- public static void load (String pathname)
+ /**
+ * 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()
{
- Runtime.getRuntime().load(pathname);
+ SecurityManager sm = Runtime.securityManager; // Be thread-safe.
+ if (sm != null)
+ sm.checkPropertiesAccess();
+ return properties;
}
- public static void loadLibrary (String libname)
+ /**
+ * 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)
{
- Runtime.getRuntime().loadLibrary(libname);
+ SecurityManager sm = Runtime.securityManager; // Be thread-safe.
+ if (sm != null)
+ sm.checkPropertiesAccess();
+ if (properties == null)
+ properties = new Properties(Runtime.defaultProperties);
+ System.properties = properties;
}
- public static void runFinalization ()
+ /**
+ * 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)
{
- Runtime.getRuntime().runFinalization();
+ 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);
}
- // Marked as deprecated in 1.2.
- public static void runFinalizersOnExit (boolean run)
+ /**
+ * 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)
{
- Runtime.getRuntime().runFinalizersOnExit(run);
+ SecurityManager sm = Runtime.securityManager; // Be thread-safe.
+ if (sm != null)
+ sm.checkPropertyAccess(key);
+ return properties.getProperty(key, def);
}
- private static void checkSetIO ()
+ /**
+ * 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)
{
- // 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("");
+ SecurityManager sm = Runtime.securityManager; // Be thread-safe.
+ if (sm != null)
+ sm.checkPermission(new PropertyPermission(key, "write"));
+ return (String) properties.setProperty(key, value);
}
- 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)
+ /**
+ * 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)
{
- if (secman != null)
- secman.checkPropertiesAccess();
- synchronized (System.class)
- {
- properties = props;
- }
+ throw new Error("getenv no longer supported, use properties instead: "
+ + name);
}
- public static String setProperty (String key, String value)
+ /**
+ * 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)
{
- if (secman != null)
- secman.checkPermission (new PropertyPermission (key, "write"));
- if (properties == null)
- init_properties ();
- return (String) properties.setProperty (key, value);
+ Runtime.getRuntime().exit(status);
}
- // TODO 1.2.
- // public static String mapLibraryName (String libname);
+ /**
+ * 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();
+ }
- public static void setSecurityManager (SecurityManager s)
+ /**
+ * 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()
{
- if (secman != null)
- secman.checkPermission(new RuntimePermission("setSecurityManager"));
- secman = s;
+ Runtime.getRuntime().runFinalization();
}
- // Public data.
- public static final InputStream in = new BufferedInputStream (new FileInputStream (FileDescriptor.in));
+ /**
+ * 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(finalizeOnExit);
+ }
- public static final PrintStream out = new PrintStream (new BufferedOutputStream (new FileOutputStream (FileDescriptor.out)), true);
+ /**
+ * 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)
+ {
+ Runtime.getRuntime().load(filename);
+ }
- public static final PrintStream err = new PrintStream (new BufferedOutputStream (new FileOutputStream (FileDescriptor.err)), true);
+ /**
+ * 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)
+ {
+ Runtime.getRuntime().loadLibrary(libname);
+ }
- // Don't allow System objects to be made.
- private System ()
+ /**
+ * 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)
{
+ // XXX Fix this!!!!
+ return Runtime.nativeGetLibname("", libname);
}
- // Private data.
- private static SecurityManager secman = null;
- private static Properties properties = null;
-}
+ /**
+ * Detect big-endian systems.
+ *
+ * @return true if the system is big-endian.
+ */
+ static native boolean isWordsBigEndian();
+
+ /**
+ * Set {@link #in} to a new InputStream.
+ *
+ * @param in the new InputStream
+ * @see #setIn(InputStream)
+ */
+ private static native void setIn0(InputStream in);
+
+ /**
+ * Set {@link #out} to a new PrintStream.
+ *
+ * @param out the new PrintStream
+ * @see #setOut(PrintStream)
+ */
+ private static native void setOut0(PrintStream out);
+
+ /**
+ * Set {@link #err} to a new PrintStream.
+ *
+ * @param err the new PrintStream
+ * @see #setErr(PrintStream)
+ */
+ private static native void setErr0(PrintStream err);
+} // class System
#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
+
+\f
+
#ifdef USE_LTDL
#include <ltdl.h>
#endif /* USE_LTDL */
-void
-java::lang::Runtime::exit (jint status)
-{
- checkExit (status);
- _exit (status);
-}
+\f
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()
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);
void
java::lang::Runtime::init (void)
{
- finalize_on_exit = false;
#ifdef USE_LTDL
lt_dlinit ();
lt_dlhandle self = lt_dlopen (NULL);
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)
{
{
// 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();
+}
#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"
+
\f
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;
}
return _Jv_HashCode (obj);
}
-#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
-
-/*
- * 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(¤t_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)
+jboolean
+java::lang::System::isWordsBigEndian (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;
}
/* 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.
package java.util;
import java.text.DateFormatSymbols;
+import gnu.classpath.Configuration;
/**
* This class represents a time zone offset and handles daylight savings.
/* 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
--- /dev/null
+// 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(¤t_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;
+}
OSDN Git Service
