/*
*
*
* Copyright 1990-2009 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version
* 2 only, as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License version 2 for more details (a copy is
* included at /legal/license.txt).
*
* You should have received a copy of the GNU General Public License
* version 2 along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 or visit www.sun.com if you need additional
* information or have any questions.
*/
package java.lang;
import com.jopdesign.sys.Const;
import com.jopdesign.sys.GC;
import com.jopdesign.sys.Native;
import com.jopdesign.sys.Startup;
import java.io.*;
//import com.sun.cldchi.io.*;
/**
* The <code>System</code> class contains several useful class fields
* and methods. It cannot be instantiated.
*
* @version 12/17/01 (CLDC 1.1)
* @since JDK1.0, CLDC 1.0
*/
public final class System {
/** Don't let anyone instantiate this class */
private System() { }
/**
* The "standard" input stream. This stream is already
* open and ready to supply input data. Typically this stream
* corresponds to keyboard input or another input source specified by
* the host environment or user.
*/
// public final static InputStream in = getConsoleInput();
// private static InputStream getConsoleInput() {
// return new ConsoleInputStream();
// }
/**
* The "standard" output stream. This stream is already
* open and ready to accept output data. Typically this stream
* corresponds to display output or another output destination
* specified by the host environment or user.
* <p>
* For simple stand-alone Java applications, a typical way to write
* a line of output data is:
* <blockquote><pre>
* System.out.println(data)
* </pre></blockquote>
* <p>
* See the <code>println</code> methods in class <code>PrintStream</code>.
*
* @see java.io.PrintStream#println()
* @see java.io.PrintStream#println(boolean)
* @see java.io.PrintStream#println(char)
* @see java.io.PrintStream#println(char[])
* @see java.io.PrintStream#println(int)
* @see java.io.PrintStream#println(long)
* @see java.io.PrintStream#println(java.lang.Object)
* @see java.io.PrintStream#println(java.lang.String)
*/
public final static PrintStream out = new JOPPrintStream();
// This is not a part of CLDC 1.1
public final static InputStream in = new JOPInputStream();
/**
* The "standard" error output stream. This stream is already
* open and ready to accept output data.
* <p>
* Typically this stream corresponds to display output or another
* output destination specified by the host environment or user. By
* convention, this output stream is used to display error messages
* or other information that should come to the immediate attention
* of a user even if the principal output stream, the value of the
* variable <code>out</code>, has been redirected to a file or other
* destination that is typically not continuously monitored.
*/
public final static PrintStream err = out;
/**
* Returns the current time in milliseconds.
*
* @return the difference, measured in milliseconds, between the current
* time and midnight, January 1, 1970 UTC.
*/
// public static native long currentTimeMillis();
public static long currentTimeMillis() {
return (long) (Native.rd(Const.IO_US_CNT)/1000);
}
/**
* Copies an array from the specified source array, beginning at the
* specified position, to the specified position of the destination array.
* A subsequence of array components are copied from the source
* array referenced by <code>src</code> to the destination array
* referenced by <code>dst</code>. The number of components copied is
* equal to the <code>length</code> argument. The components at
* positions <code>srcOffset</code> through
* <code>srcOffset+length-1</code> in the source array are copied into
* positions <code>dstOffset</code> through
* <code>dstOffset+length-1</code>, respectively, of the destination
* array.
* <p>
* If the <code>src</code> and <code>dst</code> arguments refer to the
* same array object, then the copying is performed as if the
* components at positions <code>srcOffset</code> through
* <code>srcOffset+length-1</code> were first copied to a temporary
* array with <code>length</code> components and then the contents of
* the temporary array were copied into positions
* <code>dstOffset</code> through <code>dstOffset+length-1</code> of the
* destination array.
* <p>
* If <code>dst</code> is <code>null</code>, then a
* <code>NullPointerException</code> is thrown.
* <p>
* If <code>src</code> is <code>null</code>, then a
* <code>NullPointerException</code> is thrown and the destination
* array is not modified.
* <p>
* Otherwise, if any of the following is true, an
* <code>ArrayStoreException</code> is thrown and the destination is
* not modified:
* <ul>
* <li>The <code>src</code> argument refers to an object that is not an
* array.
* <li>The <code>dst</code> argument refers to an object that is not an
* array.
* <li>The <code>src</code> argument and <code>dst</code> argument refer to
* arrays whose component types are different primitive types.
* <li>The <code>src</code> argument refers to an array with a primitive
* component type and the <code>dst</code> argument refers to an array
* with a reference component type.
* <li>The <code>src</code> argument refers to an array with a reference
* component type and the <code>dst</code> argument refers to an array
* with a primitive component type.
* </ul>
* <p>
* Otherwise, if any of the following is true, an
* <code>IndexOutOfBoundsException</code> is
* thrown and the destination is not modified:
* <ul>
* <li>The <code>srcOffset</code> argument is negative.
* <li>The <code>dstOffset</code> argument is negative.
* <li>The <code>length</code> argument is negative.
* <li><code>srcOffset+length</code> is greater than
* <code>src.length</code>, the length of the source array.
* <li><code>dstOffset+length</code> is greater than
* <code>dst.length</code>, the length of the destination array.
* </ul>
* <p>
* Otherwise, if any actual component of the source array from
* position <code>srcOffset</code> through
* <code>srcOffset+length-1</code> cannot be converted to the component
* type of the destination array by assignment conversion, an
* <code>ArrayStoreException</code> is thrown. In this case, let
* <i>k</i> be the smallest nonnegative integer less than
* length such that <code>src[srcOffset+</code><i>k</i><code>]</code>
* cannot be converted to the component type of the destination
* array; when the exception is thrown, source array components from
* positions <code>srcOffset</code> through
* <code>srcOffset+</code><i>k</i><code>-1</code>
* will already have been copied to destination array positions
* <code>dstOffset</code> through
* <code>dstOffset+</code><i>k</I><code>-1</code> and no other
* positions of the destination array will have been modified.
* (Because of the restrictions already itemized, this
* paragraph effectively applies only to the situation where both
* arrays have component types that are reference types.)
*
* @param src the source array.
* @param srcOffset start position in the source array.
* @param dst the destination array.
* @param dstOffset start position in the destination data.
* @param length the number of array elements to be copied.
* @exception IndexOutOfBoundsException if copying would cause
* access of data outside array bounds.
* @exception ArrayStoreException if an element in the <code>src</code>
* array could not be stored into the <code>dest</code> array
* because of a type mismatch.
* @exception NullPointerException if either <code>src</code> or
* <code>dst</code> is <code>null</code>.
*/
// public static native void arraycopy(Object src, int srcOffset,
// Object dst, int dstOffset,
// int length);
public static void arraycopy(Object src, int srcOffset, Object dst,
int dstOffset, int length) {
long srcEnd, dstEnd;
if ((src == null) || (dst == null)) {
throw new NullPointerException();
}
srcEnd = length + srcOffset;
dstEnd = length + dstOffset;
int srcHandle = Native.toInt(src);
int dstHandle = Native.toInt(dst);
// the type field from the handle - see GC.java
int src_type = Native.rdMem(srcHandle+GC.OFF_TYPE);
int dst_type = Native.rdMem(dstHandle+GC.OFF_TYPE);
// 0 means it's a plain object
if (src_type==0 || dst_type==0) {
throw new ArrayStoreException();
}
// should be the same, right?
if (src_type!=dst_type) {
throw new ArrayStoreException();
}
// TODO: should we check the object types?
// TODO: synchronized with GC
synchronized (GC.getMutex()) {
int srcPtr = Native.rdMem(srcHandle);
int dstPtr = Native.rdMem(dstHandle);
int srcLen = Native.rdMem(srcHandle+1);
int dstLen = Native.rdMem(dstHandle+1);
if ((srcOffset < 0) || (dstOffset < 0) || (length < 0)
|| (srcEnd > srcLen) || (dstEnd > dstLen))
throw new IndexOutOfBoundsException();
if (src==dst && srcOffset<dstOffset) {
for (int i=length-1; i>=0; --i) {
Native.wrMem(Native.rdMem(srcPtr + srcOffset + i), dstPtr
+ dstOffset + i);
}
} else {
for (int i = 0; i < length; i++) {
Native.wrMem(Native.rdMem(srcPtr + srcOffset + i), dstPtr
+ dstOffset + i);
}
}
}
}
/**
* Returns the same hashcode for the given object as
* would be returned by the default method hashCode(),
* whether or not the given object's class overrides
* hashCode().
* The hashcode for the null reference is zero.
*
* @param x object for which the hashCode is to be calculated
* @return the hashCode
* @since JDK1.1
*/
// public static native int identityHashCode(Object x);
public static int identityHashCode(Object x)
{
return Native.toInt(x);
}
/**
* Gets the system property indicated by the specified key.
*
* @param key the name of the system property.
* @return the string value of the system property,
* or <code>null</code> if there is no property with that key.
*
* @exception NullPointerException if <code>key</code> is
* <code>null</code>.
* @exception IllegalArgumentException if <code>key</code> is empty.
*/
public static String getProperty(String key) {
if (key == null) {
throw new NullPointerException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "key can't be null"
/* #endif */
);
}
if (key.equals("")) {
throw new IllegalArgumentException(
/* #ifdef VERBOSE_EXCEPTIONS */
/// skipped "key can't be empty"
/* #endif */
);
}
return getProperty0(key);
}
// private native static String getProperty0(String key);
private static String getProperty0(String key)
{
// no property in embedded system
return null;
}
/**
* Terminates the currently running Java application. The
* argument serves as a status code; by convention, a nonzero
* status code indicates abnormal termination.
* <p>
* This method calls the <code>exit</code> method in class
* <code>Runtime</code>. This method never returns normally.
* <p>
* The call <code>System.exit(n)</code> is effectively equivalent
* to the call:
* <blockquote><pre>
* Runtime.getRuntime().exit(n)
* </pre></blockquote>
*
* @param status exit status.
* @see java.lang.Runtime#exit(int)
*/
// public static void exit(int status) {
// Runtime.getRuntime().exit(status);
// }
public static void exit(int status) {
Startup.exit();
}
/**
* Runs the garbage collector.
* <p>
* Calling the <code>gc</code> method suggests that the Java Virtual
* Machine expend effort toward recycling unused objects in order to
* make the memory they currently occupy available for quick reuse.
* When control returns from the method call, the Java Virtual
* Machine has made a best effort to reclaim space from all discarded
* objects.
* <p>
* The call <code>System.gc()</code> is effectively equivalent to the
* call:
* <blockquote><pre>
* Runtime.getRuntime().gc()
* </pre></blockquote>
*
* @see java.lang.Runtime#gc()
*/
// public static void gc() {
// Runtime.getRuntime().gc();
// }
public static void gc() {
GC.gc();
}
/*
* This method is called by compiled code to throw null pointer exceptions.
*/
// private static void throwNullPointerException() throws Throwable {
// throw new NullPointerException();
// }
/*
* This method is called by compiled code to throw aioob exceptions.
*/
// private static void throwArrayIndexOutOfBoundsException()
// throws Throwable
// {
// throw new ArrayIndexOutOfBoundsException();
// }
/*
* This is a special VM method used for throwing exceptions inside
* quick native methods.
*/
// private static native void quickNativeThrow();
}