OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk
    from Rev 779 to Rev 780
    ↔ Reverse comparison
  •

Rev 779 → Rev 780

/gnu-dev/or1k-gcc/libjava/classpath/vm/Makefile.am
0,0 → 1,4
# used by automake to generate Makefile.in
 
 
SUBDIRS = reference
/gnu-dev/or1k-gcc/libjava/classpath/vm/.cvsignore
0,0 → 1,2
Makefile
Makefile.in
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMClassLoader.java
0,0 → 1,431
/* VMClassLoader.java -- Reference implementation of native interface
required by ClassLoader
Copyright (C) 1998, 2001, 2002, 2004, 2005, 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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 gnu.classpath.Configuration;
import gnu.classpath.SystemProperties;
import gnu.java.lang.InstrumentationImpl;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.instrument.Instrumentation;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.ProtectionDomain;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.zip.ZipFile;
 
/**
* java.lang.VMClassLoader is a package-private helper for VMs to implement
* on behalf of java.lang.ClassLoader.
*
* @author John Keiser
* @author Mark Wielaard (mark@klomp.org)
* @author Eric Blake (ebb9@email.byu.edu)
*/
final class VMClassLoader
{
 
 
/** packages loaded by the bootstrap class loader */
static final HashMap definedPackages = new HashMap();
 
/** jars from property java.boot.class.path */
static final HashMap bootjars = new HashMap();
 
 
/**
* Converts the array string of native package names to
* Packages. The packages are then put into the
* definedPackages hashMap
*/
static
{
String[] packages = getBootPackages();
 
if( packages != null)
{
String specName =
SystemProperties.getProperty("java.specification.name");
String vendor =
SystemProperties.getProperty("java.specification.vendor");
String version =
SystemProperties.getProperty("java.specification.version");
 
Package p;
 
for(int i = 0; i < packages.length; i++)
{
p = new Package(packages[i],
specName,
vendor,
version,
"GNU Classpath",
"GNU",
Configuration.CLASSPATH_VERSION,
null,
null);
 
definedPackages.put(packages[i], p);
}
}
}
 
 
/**
* Helper to define a class using a string of bytes. This assumes that
* the security checks have already been performed, if necessary.
*
* Implementations of this method are advised to consider the
* situation where user code modifies the byte array after it has
* been passed to defineClass. This can be handled by making a
* private copy of the array, or arranging to only read any given
* byte a single time.
*
* @param name the name to give the class, or null if unknown
* @param data the data representing the classfile, in classfile format
* @param offset the offset into the data where the classfile starts
* @param len the length of the classfile data in the array
* @param pd the protection domain
* @return the class that was defined
* @throws ClassFormatError if data is not in proper classfile format
*/
static final native Class defineClass(ClassLoader cl, String name,
byte[] data, int offset, int len,
ProtectionDomain pd)
throws ClassFormatError;
 
/**
* Helper to resolve all references to other classes from this class.
*
* @param c the class to resolve
*/
static final native void resolveClass(Class c);
 
/**
* Helper to load a class from the bootstrap class loader.
*
* @param name the class name to load
* @param resolve whether to resolve it
* @return the class, loaded by the bootstrap classloader or null
* if the class wasn't found. Returning null is equivalent to throwing
* a ClassNotFoundException (but a possible performance optimization).
*/
static final native Class loadClass(String name, boolean resolve)
throws ClassNotFoundException;
 
/**
* Helper to load a resource from the bootstrap class loader.
*
* @param name the resource to find
* @return the URL to the resource
*/
static URL getResource(String name)
{
Enumeration e = getResources(name);
if (e.hasMoreElements())
return (URL)e.nextElement();
return null;
}
/**
* Helper to get a list of resources from the bootstrap class loader.
*
* @param name the resource to find
* @return an enumeration of resources
*/
static Enumeration getResources(String name)
{
StringTokenizer st = new StringTokenizer(
SystemProperties.getProperty("java.boot.class.path", "."),
File.pathSeparator);
Vector v = new Vector();
while (st.hasMoreTokens())
{
File file = new File(st.nextToken());
if (file.isDirectory())
{
try
{
File f = new File(file, name);
if (!f.exists()) continue;
v.add(new URL("file://" + f.getAbsolutePath()));
}
catch (MalformedURLException e)
{
throw new Error(e);
}
}
else if (file.isFile())
{
ZipFile zip;
synchronized(bootjars)
{
zip = (ZipFile) bootjars.get(file.getName());
}
if(zip == null)
{
try
{
zip = new ZipFile(file);
synchronized(bootjars)
{
bootjars.put(file.getName(), zip);
}
}
catch (IOException e)
{
continue;
}
}
String zname = name.startsWith("/") ? name.substring(1) : name;
if (zip.getEntry(zname) == null)
continue;
try
{
v.add(new URL("jar:file://"
+ file.getAbsolutePath() + "!/" + zname));
}
catch (MalformedURLException e)
{
throw new Error(e);
}
}
}
return v.elements();
}
 
 
/**
* Returns a String[] of native package names. The default
* implementation tries to load a list of package from
* the META-INF/INDEX.LIST file in the boot jar file.
* If not found or if any exception is raised, it returns
* an empty array. You may decide this needs native help.
*/
private static String[] getBootPackages()
{
URL indexList = getResource("META-INF/INDEX.LIST");
if (indexList != null)
{
try
{
Set packageSet = new HashSet();
String line;
int lineToSkip = 3;
BufferedReader reader = new BufferedReader(
new InputStreamReader(
indexList.openStream()));
while ((line = reader.readLine()) != null)
{
if (lineToSkip == 0)
{
if (line.length() == 0)
lineToSkip = 1;
else
packageSet.add(line.replace('/', '.'));
}
else
lineToSkip--;
}
reader.close();
return (String[]) packageSet.toArray(new String[packageSet.size()]);
}
catch (IOException e)
{
return new String[0];
}
}
else
return new String[0];
}
 
 
/**
* Helper to get a package from the bootstrap class loader.
*
* @param name the name to find
* @return the named package, if it exists
*/
static Package getPackage(String name)
{
return (Package)definedPackages.get(name);
}
 
 
 
/**
* Helper to get all packages from the bootstrap class loader.
*
* @return all named packages, if any exist
*/
static Package[] getPackages()
{
Package[] packages = new Package[definedPackages.size()];
definedPackages.values().toArray(packages);
return packages;
}
 
/**
* Helper for java.lang.Integer, Byte, etc to get the TYPE class
* at initialization time. The type code is one of the chars that
* represents the primitive type as in JNI.
*
* <ul>
* <li>'Z' - boolean</li>
* <li>'B' - byte</li>
* <li>'C' - char</li>
* <li>'D' - double</li>
* <li>'F' - float</li>
* <li>'I' - int</li>
* <li>'J' - long</li>
* <li>'S' - short</li>
* <li>'V' - void</li>
* </ul>
*
* @param type the primitive type
* @return a "bogus" class representing the primitive type
*/
static final native Class getPrimitiveClass(char type);
 
/**
* The system default for assertion status. This is used for all system
* classes (those with a null ClassLoader), as well as the initial value for
* every ClassLoader's default assertion status.
*
* XXX - Not implemented yet; this requires native help.
*
* @return the system-wide default assertion status
*/
static final boolean defaultAssertionStatus()
{
return true;
}
 
/**
* The system default for package assertion status. This is used for all
* ClassLoader's packageAssertionStatus defaults. It must be a map of
* package names to Boolean.TRUE or Boolean.FALSE, with the unnamed package
* represented as a null key.
*
* XXX - Not implemented yet; this requires native help.
*
* @return a (read-only) map for the default packageAssertionStatus
*/
static final Map packageAssertionStatus()
{
return new HashMap();
}
 
/**
* The system default for class assertion status. This is used for all
* ClassLoader's classAssertionStatus defaults. It must be a map of
* class names to Boolean.TRUE or Boolean.FALSE
*
* XXX - Not implemented yet; this requires native help.
*
* @return a (read-only) map for the default classAssertionStatus
*/
static final Map classAssertionStatus()
{
return new HashMap();
}
 
static ClassLoader getSystemClassLoader()
{
return ClassLoader.defaultGetSystemClassLoader();
}
 
/**
* Find the class if this class loader previously defined this class
* or if this class loader has been recorded as the initiating class loader
* for this class.
*/
static native Class findLoadedClass(ClassLoader cl, String name);
 
/**
* The Instrumentation object created by the vm when agents are defined.
*/
static final Instrumentation instrumenter = null;
 
/**
* Call the transformers of the possible Instrumentation object. This
* implementation assumes the instrumenter is a
* <code>InstrumentationImpl</code> object. VM implementors would
* have to redefine this method if they provide their own implementation
* of the <code>Instrumentation</code> interface.
*
* @param loader the initiating loader
* @param name the name of the class
* @param data the data representing the classfile, in classfile format
* @param offset the offset into the data where the classfile starts
* @param len the length of the classfile data in the array
* @param pd the protection domain
* @return the new data representing the classfile
*/
static final Class defineClassWithTransformers(ClassLoader loader,
String name, byte[] data, int offset, int len, ProtectionDomain pd)
{
 
if (instrumenter != null)
{
byte[] modifiedData = new byte[len];
System.arraycopy(data, offset, modifiedData, 0, len);
String jvmName = name.replace('.', '/');
modifiedData =
((InstrumentationImpl)instrumenter).callTransformers(loader, jvmName,
null, pd, modifiedData);
 
return defineClass(loader, name, modifiedData, 0, modifiedData.length,
pd);
}
else
{
return defineClass(loader, name, data, offset, len, pd);
}
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMProcess.java
0,0 → 1,402
/* java.lang.VMProcess -- VM implementation of java.lang.Process
Copyright (C) 2004, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
/**
* Represents one external process. Each instance of this class is in
* one of three states: INITIAL, RUNNING, or TERMINATED. The instance
* is {@link Object#notifyAll notifyAll()}'d each time the state changes.
* The state of all instances is managed by a single dedicated thread
* which does the actual fork()/exec() and wait() system calls. User
* threads {@link Object#wait()} on the instance when creating the
* process or waiting for it to terminate.
*
* <p>
* See
* <a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11801">GCC bug
* #11801</a> for the motivation behind the design of this class.
*
* @author Archie Cobbs
* @see Process
* @see Runtime#exec(String)
*/
final class VMProcess extends Process
{
 
// Possible states for a VMProcess
private static final int INITIAL = 0;
private static final int RUNNING = 1;
private static final int TERMINATED = 2;
 
// Dedicated thread that does all the fork()'ing and wait()'ing.
static Thread processThread;
 
// New processes waiting to be spawned by processThread.
static final LinkedList workList = new LinkedList();
 
// Return values set by nativeReap() when a child is reaped.
// These are only accessed by processThread so no locking required.
static long reapedPid;
static int reapedExitValue;
 
// Information about this process
int state; // current state of process
final String[] cmd; // copied from Runtime.exec()
final String[] env; // copied from Runtime.exec()
final File dir; // copied from Runtime.exec()
Throwable exception; // if process failed to start
long pid; // process id
OutputStream stdin; // process input stream
InputStream stdout; // process output stream
InputStream stderr; // process error stream
int exitValue; // process exit value
boolean redirect; // redirect stderr -> stdout
 
//
// Dedicated thread that does all the fork()'ing and wait()'ing
// for external processes. This is needed because some systems like
// Linux use a process-per-thread model, which means the same thread
// that did the fork()/exec() must also do the wait().
//
private static class ProcessThread extends Thread
{
 
// Max time (in ms) we'll delay before trying to reap another child.
private static final int MAX_REAP_DELAY = 1000;
 
// Processes created but not yet terminated; maps Long(pid) -> VMProcess
// Only used in run() and spawn() method from this Thread, so no locking.
private final HashMap activeMap = new HashMap();
 
// We have an explicit constructor, because the default
// constructor will be private, which means the compiler will have
// to generate a second package-private constructor, which is
// bogus.
ProcessThread ()
{
}
 
public void run()
{
final LinkedList workList = VMProcess.workList;
while (true)
{
 
// Get the next process to spawn (if any) and spawn it. Spawn
// at most one at a time before checking for reapable children.
VMProcess process = null;
synchronized (workList)
{
if (!workList.isEmpty())
process = (VMProcess)workList.removeFirst();
}
 
if (process != null)
spawn(process);
 
 
// Check for termination of active child processes
while (!activeMap.isEmpty() && VMProcess.nativeReap())
{
long pid = VMProcess.reapedPid;
int exitValue = VMProcess.reapedExitValue;
process = (VMProcess)activeMap.remove(new Long(pid));
if (process != null)
{
synchronized (process)
{
process.exitValue = exitValue;
process.state = TERMINATED;
process.notify();
}
}
else
System.err.println("VMProcess WARNING reaped unknown process: "
+ pid);
}
 
 
// If there are more new processes to create, go do that now.
// If there is nothing left to do, exit this thread. Otherwise,
// sleep a little while, and then check again for reapable children.
// We will get woken up immediately if there are new processes to
// spawn, but not if there are new children to reap. So we only
// sleep a short time, in effect polling while processes are active.
synchronized (workList)
{
if (!workList.isEmpty())
continue;
if (activeMap.isEmpty())
{
processThread = null;
break;
}
 
try
{
workList.wait(MAX_REAP_DELAY);
}
catch (InterruptedException e)
{
/* ignore */
}
}
}
}
 
// Spawn a process
private void spawn(VMProcess process)
{
 
// Spawn the process and put it in our active map indexed by pid.
// If the spawn operation fails, store the exception with the process.
// In either case, wake up thread that created the process.
synchronized (process)
{
try
{
process.nativeSpawn(process.cmd, process.env, process.dir,
process.redirect);
process.state = RUNNING;
activeMap.put(new Long(process.pid), process);
}
catch (ThreadDeath death)
{
throw death;
}
catch (Throwable t)
{
process.state = TERMINATED;
process.exception = t;
}
process.notify();
}
}
}
 
// Constructor
private VMProcess(String[] cmd, String[] env, File dir, boolean redirect)
throws IOException
{
 
// Initialize this process
this.state = INITIAL;
this.cmd = cmd;
this.env = env;
this.dir = dir;
this.redirect = redirect;
 
// Add process to the new process work list and wakeup processThread
synchronized (workList)
{
workList.add(this);
if (processThread == null)
{
processThread = new ProcessThread();
processThread.setDaemon(true);
processThread.start();
}
else
{
workList.notify();
}
}
 
// Wait for processThread to spawn this process and update its state
synchronized (this)
{
while (state == INITIAL)
{
try
{
wait();
}
catch (InterruptedException e)
{
/* ignore */
}
}
}
 
// If spawning failed, rethrow the exception in this thread
if (exception != null)
{
exception.fillInStackTrace();
if (exception instanceof IOException)
throw (IOException)exception;
 
if (exception instanceof Error)
throw (Error)exception;
 
if (exception instanceof RuntimeException)
throw (RuntimeException)exception;
 
throw new RuntimeException(exception);
}
}
 
// Invoked by native code (from nativeSpawn()) to record process info.
private void setProcessInfo(OutputStream stdin,
InputStream stdout, InputStream stderr, long pid)
{
this.stdin = stdin;
this.stdout = stdout;
if (stderr == null)
this.stderr = new InputStream()
{
public int read() throws IOException
{
return -1;
}
};
else
this.stderr = stderr;
this.pid = pid;
}
 
/**
* Entry point from Runtime.exec().
*/
static Process exec(String[] cmd, String[] env, File dir) throws IOException
{
return new VMProcess(cmd, env, dir, false);
}
 
static Process exec(List cmd, Map env,
File dir, boolean redirect) throws IOException
{
String[] acmd = (String[]) cmd.toArray(new String[cmd.size()]);
String[] aenv = new String[env.size()];
 
int i = 0;
Iterator iter = env.entrySet().iterator();
while (iter.hasNext())
{
Map.Entry entry = (Map.Entry) iter.next();
aenv[i++] = entry.getKey() + "=" + entry.getValue();
}
 
return new VMProcess(acmd, aenv, dir, redirect);
}
 
public OutputStream getOutputStream()
{
return stdin;
}
 
public InputStream getInputStream()
{
return stdout;
}
 
public InputStream getErrorStream()
{
return stderr;
}
 
public synchronized int waitFor() throws InterruptedException
{
while (state != TERMINATED)
wait();
return exitValue;
}
 
public synchronized int exitValue()
{
if (state != TERMINATED)
throw new IllegalThreadStateException();
return exitValue;
}
 
public synchronized void destroy()
{
if (state == TERMINATED)
return;
 
nativeKill(pid);
 
while (state != TERMINATED)
{
try
{
wait();
}
catch (InterruptedException e)
{
/* ignore */
}
}
}
 
/**
* Does the fork()/exec() thing to create the O/S process.
* Must invoke setProcessInfo() before returning successfully.
* This method is only invoked by processThread.
*
* @throws IOException if the O/S process could not be created.
*/
native void nativeSpawn(String[] cmd, String[] env, File dir,
boolean redirect)
throws IOException;
 
/**
* Test for a reapable child process, and reap if so. Does not block.
* If a child was reaped, this method must set reapedPid and
* reapedExitValue appropriately before returning.
* This method is only invoked by processThread.
*
* @return true if a child was reaped, otherwise false
*/
// This is not private as it is called from an inner class.
static native boolean nativeReap();
 
/**
* Kill a process. This sends it a fatal signal but does not reap it.
*/
private static native void nativeKill(long pid);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/reflect/VMArray.java
0,0 → 1,65
/* java.lang.reflect.VMArray - VM class for array manipulation by reflection.
Copyright (C) 1998, 1999, 2001, 2003, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.reflect;
 
import gnu.classpath.Configuration;
 
class VMArray
{
 
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javalangreflect");
}
}
 
/**
* Dynamically create an array of objects.
*
* @param type guaranteed to be a valid object type
* @param dim the length of the array
* @return the new array
* @throws NegativeArraySizeException if dim is negative
* @throws OutOfMemoryError if memory allocation fails
*/
static native Object createObjectArray(Class type, int dim);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/reflect/VMMethod.java
0,0 → 1,208
/* java.lang.reflect.VMMethod - VM interface for reflection of Java methods
Copyright (C) 1998, 2001, 2002, 2005, 2007, 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.reflect;
 
import java.lang.annotation.Annotation;
 
import java.util.Arrays;
 
final class VMMethod
{
Class clazz;
String name;
int slot;
 
/**
* This field allows us to refer back to the main constructor instance.
* It is set by the constructor of Field.
*/
Method m;
 
public Class getDeclaringClass()
{
return clazz;
}
 
public String getName()
{
return name;
}
 
/**
* Return the raw modifiers for this method.
* @return the method's modifiers
*/
native int getModifiersInternal();
 
/**
* Gets the return type of this method.
* @return the type of this method
*/
native Class getReturnType();
 
/**
* Get the parameter list for this method, in declaration order. If the
* method takes no parameters, returns a 0-length array (not null).
*
* @return a list of the types of the method's parameters
*/
native Class[] getParameterTypes();
 
/**
* Get the exception types this method says it throws, in no particular
* order. If the method has no throws clause, returns a 0-length array
* (not null).
*
* @return a list of the types in the method's throws clause
*/
native Class[] getExceptionTypes();
 
native Object invoke(Object o, Object[] args)
throws IllegalAccessException, InvocationTargetException;
 
/**
* Return the String in the Signature attribute for this method. If there
* is no Signature attribute, return null.
*/
native String getSignature();
 
/**
* If this method is an annotation method, returns the default
* value for the method. If there is no default value, or if the
* method is not a member of an annotation type, returns null.
* Primitive types are wrapped.
*
* @throws TypeNotPresentException if the method returns a Class,
* and the class cannot be found
*
* @since 1.5
*/
native Object getDefaultValue();
 
/**
* <p>
* Return an array of arrays representing the annotations on each
* of the method's parameters. The outer array is aligned against
* the parameters of the method and is thus equal in length to
* the number of parameters (thus having a length zero if there are none).
* Each array element in the outer array contains an inner array which
* holds the annotations. This array has a length of zero if the parameter
* has no annotations.
* </p>
* <p>
* The returned annotations are serialized. Changing the annotations has
* no affect on the return value of future calls to this method.
* </p>
*
* @return an array of arrays which represents the annotations used on the
* parameters of this method. The order of the array elements
* matches the declaration order of the parameters.
* @since 1.5
*/
native Annotation[][] getParameterAnnotations();
 
/**
* Compare two objects to see if they are semantically equivalent.
* Two Methods are semantically equivalent if they have the same declaring
* class, name, parameter list, and return type.
*
* @param o the object to compare to
* @return <code>true</code> if they are equal; <code>false</code> if not
*/
public boolean equals(Object o)
{
// Implementation note:
// The following is a correct but possibly slow implementation.
//
// This class has a private field 'slot' that could be used by
// the VM implementation to "link" a particular method to a Class.
// In that case equals could be simply implemented as:
//
// if (o instanceof Method)
// {
// Method m = (Method)o;
// return m.declaringClass == this.declaringClass
// && m.slot == this.slot;
// }
// return false;
//
// If a VM uses the Method class as their native/internal representation
// then just using the following would be optimal:
//
// return this == o;
//
if (!(o instanceof Method))
return false;
Method that = (Method)o;
if (clazz != that.getDeclaringClass())
return false;
if (!name.equals(that.getName()))
return false;
if (getReturnType() != that.getReturnType())
return false;
if (!Arrays.equals(getParameterTypes(), that.getParameterTypes()))
return false;
return true;
}
 
/**
* Returns the element's annotation for the specified annotation type,
* or <code>null</code> if no such annotation exists.
*
* @param annotationClass the type of annotation to look for.
* @return this element's annotation for the specified type, or
* <code>null</code> if no such annotation exists.
* @throws NullPointerException if the annotation class is <code>null</code>.
*/
native Annotation getAnnotation(Class annotationClass);
 
/**
* Returns all annotations directly defined by the element. If there are
* no annotations directly associated with the element, then a zero-length
* array will be returned. The returned array may be modified by the client
* code, but this will have no effect on the annotation content of this
* class, and hence no effect on the return value of this method for
* future callers.
*
* @return the annotations directly defined by the element.
* @since 1.5
*/
native Annotation[] getDeclaredAnnotations();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/reflect/VMProxy.java
0,0 → 1,135
/* VMProxy.java -- VM interface for proxy class
Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.reflect;
 
final class VMProxy
{
/**
* Set to true if the VM provides a native method to implement
* Proxy.getProxyClass completely, including argument verification.
* If this is true, HAVE_NATIVE_GET_PROXY_DATA and
* HAVE_NATIVE_GENERATE_PROXY_CLASS should be false.
* @see java.lang.reflect.Proxy
*/
static boolean HAVE_NATIVE_GET_PROXY_CLASS = false;
 
/**
* Set to true if the VM provides a native method to implement
* the first part of Proxy.getProxyClass: generation of the array
* of methods to convert, and verification of the arguments.
* If this is true, HAVE_NATIVE_GET_PROXY_CLASS should be false.
* @see java.lang.reflect.Proxy
*/
static boolean HAVE_NATIVE_GET_PROXY_DATA = false;
 
/**
* Set to true if the VM provides a native method to implement
* the second part of Proxy.getProxyClass: conversion of an array of
* methods into an actual proxy class.
* If this is true, HAVE_NATIVE_GET_PROXY_CLASS should be false.
* @see java.lang.reflect.Proxy
*/
static boolean HAVE_NATIVE_GENERATE_PROXY_CLASS = false;
 
/**
* Optional native method to replace (and speed up) the pure Java
* implementation of getProxyClass. Only needed if
* VMProxy.HAVE_NATIVE_GET_PROXY_CLASS is true, this does the
* work of both getProxyData and generateProxyClass with no
* intermediate form in Java. The native code may safely assume that
* this class must be created, and does not already exist.
*
* @param loader the class loader to define the proxy class in; null
* implies the bootstrap class loader
* @param interfaces the interfaces the class will extend
* @return the generated proxy class
* @throws IllegalArgumentException if the constraints for getProxyClass
* were violated, except for problems with null
* @throws NullPointerException if `interfaces' is null or contains
* a null entry, or if handler is null
* @see #HAVE_NATIVE_GET_PROXY_CLASS
* @see #getProxyClass(ClassLoader, Class[])
* @see #getProxyData(ClassLoader, Class[])
* @see #generateProxyClass(ClassLoader, Proxy.ProxyData)
*/
static native Class getProxyClass(ClassLoader loader, Class[] interfaces);
 
/**
* Optional native method to replace (and speed up) the pure Java
* implementation of getProxyData. Only needed if
* Configuration.HAVE_NATIVE_GET_PROXY_DATA is true. The native code
* may safely assume that a new ProxyData object must be created which
* does not duplicate any existing ones.
*
* @param loader the class loader to define the proxy class in; null
* implies the bootstrap class loader
* @param interfaces the interfaces the class will extend
* @return all data that is required to make this proxy class
* @throws IllegalArgumentException if the constraints for getProxyClass
* were violated, except for problems with null
* @throws NullPointerException if `interfaces' is null or contains
* a null entry, or if handler is null
* @see #HAVE_NATIVE_GET_PROXY_DATA
* @see #getProxyClass(ClassLoader, Class[])
* @see #getProxyClass(ClassLoader, Class[])
* @see Proxy.ProxyData#getProxyData(Proxy.ProxyType)
*/
static native Proxy.ProxyData getProxyData(ClassLoader loader,
Class[] interfaces);
 
/**
* Optional native method to replace (and speed up) the pure Java
* implementation of generateProxyClass. Only needed if
* Configuration.HAVE_NATIVE_GENERATE_PROXY_CLASS is true. The native
* code may safely assume that a new Class must be created, and that
* the ProxyData object does not describe any existing class.
*
* @param loader the class loader to define the proxy class in; null
* implies the bootstrap class loader
* @param data the struct of information to convert to a Class. This
* has already been verified for all problems except exceeding
* VM limitations
* @return the newly generated class
* @throws IllegalArgumentException if VM limitations are exceeded
* @see #getProxyClass(ClassLoader, Class[])
* @see #getProxyClass(ClassLoader, Class[])
*/
static native Class generateProxyClass(ClassLoader loader,
Proxy.ProxyData data);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/reflect/VMField.java
0,0 → 1,549
/* java.lang.reflect.Field - VM interface for reflection of Java fields
Copyright (C) 1998, 2001, 2005, 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.reflect;
 
import java.lang.annotation.Annotation;
 
final class VMField
{
Class clazz;
String name;
int slot;
 
/**
* This field allows us to refer back to the main constructor instance.
* It is set by the constructor of Field.
*/
Field f;
 
VMField(Class clazz, String name, int slot)
{
this.clazz = clazz;
this.name = name;
this.slot = slot;
}
 
public Class getDeclaringClass()
{
return clazz;
}
 
public String getName()
{
return name;
}
 
/**
* Return the raw modifiers for this field.
* @return the field's modifiers
*/
native int getModifiersInternal();
 
/**
* Gets the type of this field.
* @return the type of this field
*/
native Class getType();
 
/**
* Get the value of this Field. If it is primitive, it will be wrapped
* in the appropriate wrapper type (boolean = java.lang.Boolean).<p>
*
* If the field is static, <code>o</code> will be ignored. Otherwise, if
* <code>o</code> is null, you get a <code>NullPointerException</code>,
* and if it is incompatible with the declaring class of the field, you
* get an <code>IllegalArgumentException</code>.<p>
*
* Next, if this Field enforces access control, your runtime context is
* evaluated, and you may have an <code>IllegalAccessException</code> if
* you could not access this field in similar compiled code. If the field
* is static, and its class is uninitialized, you trigger class
* initialization, which may end in a
* <code>ExceptionInInitializerError</code>.<p>
*
* Finally, the field is accessed, and primitives are wrapped (but not
* necessarily in new objects). This method accesses the field of the
* declaring class, even if the instance passed in belongs to a subclass
* which declares another field to hide this one.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if <code>o</code> is not an instance of
* the class or interface declaring this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #getBoolean(Object)
* @see #getByte(Object)
* @see #getChar(Object)
* @see #getShort(Object)
* @see #getInt(Object)
* @see #getLong(Object)
* @see #getFloat(Object)
* @see #getDouble(Object)
*/
native Object get(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this boolean Field. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a boolean field of
* <code>o</code>, or if <code>o</code> is not an instance of the
* declaring class of this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native boolean getBoolean(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this byte Field. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a byte field of
* <code>o</code>, or if <code>o</code> is not an instance of the
* declaring class of this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native byte getByte(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this Field as a char. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a char field of
* <code>o</code>, or if <code>o</code> is not an instance
* of the declaring class of this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native char getChar(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this Field as a short. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a byte or short
* field of <code>o</code>, or if <code>o</code> is not an instance
* of the declaring class of this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native short getShort(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this Field as an int. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a byte, short, char, or
* int field of <code>o</code>, or if <code>o</code> is not an
* instance of the declaring class of this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native int getInt(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this Field as a long. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a byte, short, char, int,
* or long field of <code>o</code>, or if <code>o</code> is not an
* instance of the declaring class of this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native long getLong(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this Field as a float. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a byte, short, char, int,
* long, or float field of <code>o</code>, or if <code>o</code> is
* not an instance of the declaring class of this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native float getFloat(Object o)
throws IllegalAccessException;
 
/**
* Get the value of this Field as a double. If the field is static,
* <code>o</code> will be ignored.
*
* @param o the object to get the value of this Field from
* @return the value of the Field
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a byte, short, char, int,
* long, float, or double field of <code>o</code>, or if
* <code>o</code> is not an instance of the declaring class of this
* field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #get(Object)
*/
native double getDouble(Object o)
throws IllegalAccessException;
 
/**
* Set the value of this Field. If it is a primitive field, the value
* will be unwrapped from the passed object (boolean = java.lang.Boolean).<p>
*
* If the field is static, <code>o</code> will be ignored. Otherwise, if
* <code>o</code> is null, you get a <code>NullPointerException</code>,
* and if it is incompatible with the declaring class of the field, you
* get an <code>IllegalArgumentException</code>.<p>
*
* Next, if this Field enforces access control, your runtime context is
* evaluated, and you may have an <code>IllegalAccessException</code> if
* you could not access this field in similar compiled code. This also
* occurs whether or not there is access control if the field is final.
* If the field is primitive, and unwrapping your argument fails, you will
* get an <code>IllegalArgumentException</code>; likewise, this error
* happens if <code>value</code> cannot be cast to the correct object type.
* If the field is static, and its class is uninitialized, you trigger class
* initialization, which may end in a
* <code>ExceptionInInitializerError</code>.<p>
*
* Finally, the field is set with the widened value. This method accesses
* the field of the declaring class, even if the instance passed in belongs
* to a subclass which declares another field to hide this one.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if <code>value</code> cannot be
* converted by a widening conversion to the underlying type of
* the Field, or if <code>o</code> is not an instance of the class
* declaring this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #setBoolean(Object, boolean)
* @see #setByte(Object, byte)
* @see #setChar(Object, char)
* @see #setShort(Object, short)
* @see #setInt(Object, int)
* @see #setLong(Object, long)
* @see #setFloat(Object, float)
* @see #setDouble(Object, double)
*/
native void set(Object o, Object value)
throws IllegalAccessException;
 
/**
* Set this boolean Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a boolean field, or if
* <code>o</code> is not an instance of the class declaring this
* field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setBoolean(Object o, boolean value)
throws IllegalAccessException;
 
/**
* Set this byte Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a byte, short, int, long,
* float, or double field, or if <code>o</code> is not an instance
* of the class declaring this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setByte(Object o, byte value)
throws IllegalAccessException;
 
/**
* Set this char Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a char, int, long,
* float, or double field, or if <code>o</code> is not an instance
* of the class declaring this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setChar(Object o, char value)
throws IllegalAccessException;
 
/**
* Set this short Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a short, int, long,
* float, or double field, or if <code>o</code> is not an instance
* of the class declaring this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setShort(Object o, short value)
throws IllegalAccessException;
 
/**
* Set this int Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not an int, long, float, or
* double field, or if <code>o</code> is not an instance of the
* class declaring this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setInt(Object o, int value)
throws IllegalAccessException;
 
/**
* Set this long Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a long, float, or double
* field, or if <code>o</code> is not an instance of the class
* declaring this field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setLong(Object o, long value)
throws IllegalAccessException;
 
/**
* Set this float Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a float or long field, or
* if <code>o</code> is not an instance of the class declaring this
* field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setFloat(Object o, float value)
throws IllegalAccessException;
 
/**
* Set this double Field. If the field is static, <code>o</code> will be
* ignored.
*
* @param o the object to set this Field on
* @param value the value to set this Field to
* @throws IllegalAccessException if you could not normally access this field
* (i.e. it is not public)
* @throws IllegalArgumentException if this is not a double field, or if
* <code>o</code> is not an instance of the class declaring this
* field
* @throws NullPointerException if <code>o</code> is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static field triggered
* class initialization, which then failed
* @see #set(Object, Object)
*/
native void setDouble(Object o, double value)
throws IllegalAccessException;
 
/**
* Return the String in the Signature attribute for this field. If there
* is no Signature attribute, return null.
*
*/
native String getSignature();
 
/**
* Compare two objects to see if they are semantically equivalent.
* Two Fields are semantically equivalent if they have the same declaring
* class, name, and type. Since you can't create a Field except through
* the VM, this is just the == relation.
*
* @param o the object to compare to
* @return <code>true</code> if they are equal; <code>false</code> if not
*/
public boolean equals(Object o)
{
if (!(o instanceof Field))
return false;
Field that = (Field)o;
if (clazz != that.getDeclaringClass())
return false;
if (!name.equals(that.getName()))
return false;
if (getType() != that.getType())
return false;
return true;
}
 
/**
* Returns the element's annotation for the specified annotation type,
* or <code>null</code> if no such annotation exists.
*
* @param annotationClass the type of annotation to look for.
* @return this element's annotation for the specified type, or
* <code>null</code> if no such annotation exists.
* @throws NullPointerException if the annotation class is <code>null</code>.
*/
native Annotation getAnnotation(Class annotationClass);
 
/**
* Returns all annotations directly defined by the element. If there are
* no annotations directly associated with the element, then a zero-length
* array will be returned. The returned array may be modified by the client
* code, but this will have no effect on the annotation content of this
* class, and hence no effect on the return value of this method for
* future callers.
*
* @return the annotations directly defined by the element.
* @since 1.5
*/
native Annotation[] getDeclaredAnnotations();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/reflect/VMConstructor.java
0,0 → 1,169
/* java.lang.reflect.VMConstructor - VM interface for reflection of Java constructors
Copyright (C) 1998, 2001, 2004, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.reflect;
 
import java.lang.annotation.Annotation;
 
import java.util.Arrays;
 
final class VMConstructor
{
Class clazz;
int slot;
 
/**
* This field allows us to refer back to the main constructor instance.
* It is set by the constructor of Constructor.
*/
Constructor cons;
 
VMConstructor(Class clazz, int slot)
{
this.clazz = clazz;
this.slot = slot;
}
 
public Class getDeclaringClass()
{
return clazz;
}
 
/**
* Return the raw modifiers for this constructor. In particular
* this will include the synthetic and varargs bits.
* @return the constructor's modifiers
*/
native int getModifiersInternal();
 
/**
* Get the parameter list for this constructor, in declaration order. If the
* constructor takes no parameters, returns a 0-length array (not null).
*
* @return a list of the types of the constructor's parameters
*/
native Class[] getParameterTypes();
 
/**
* Get the exception types this constructor says it throws, in no particular
* order. If the constructor has no throws clause, returns a 0-length array
* (not null).
*
* @return a list of the types in the constructor's throws clause
*/
native Class[] getExceptionTypes();
 
native Object construct(Object[] args)
throws InstantiationException, IllegalAccessException,
InvocationTargetException;
 
/**
* Return the String in the Signature attribute for this constructor. If there
* is no Signature attribute, return null.
*/
native String getSignature();
 
/**
* <p>
* Return an array of arrays representing the annotations on each
* of the constructor's parameters. The outer array is aligned against
* the parameters of the constructors and is thus equal in length to
* the number of parameters (thus having a length zero if there are none).
* Each array element in the outer array contains an inner array which
* holds the annotations. This array has a length of zero if the parameter
* has no annotations.
* </p>
* <p>
* The returned annotations are serialized. Changing the annotations has
* no affect on the return value of future calls to this method.
* </p>
*
* @return an array of arrays which represents the annotations used on the
* parameters of this constructor. The order of the array elements
* matches the declaration order of the parameters.
* @since 1.5
*/
native Annotation[][] getParameterAnnotations();
 
/**
* Compare two objects to see if they are semantically equivalent.
* Two Constructors are semantically equivalent if they have the same
* declaring class and the same parameter list. This ignores different
* exception clauses, but since you can't create a Method except through the
* VM, this is just the == relation.
*
* @param o the object to compare to
* @return <code>true</code> if they are equal; <code>false</code> if not.
*/
public boolean equals(Object o)
{
if (!(o instanceof Constructor))
return false;
Constructor that = (Constructor)o;
if (clazz != that.getDeclaringClass())
return false;
if (!Arrays.equals(getParameterTypes(), that.getParameterTypes()))
return false;
return true;
}
 
/**
* Returns the element's annotation for the specified annotation type,
* or <code>null</code> if no such annotation exists.
*
* @param annotationClass the type of annotation to look for.
* @return this element's annotation for the specified type, or
* <code>null</code> if no such annotation exists.
* @throws NullPointerException if the annotation class is <code>null</code>.
*/
native Annotation getAnnotation(Class annotationClass);
 
/**
* Returns all annotations directly defined by the element. If there are
* no annotations directly associated with the element, then a zero-length
* array will be returned. The returned array may be modified by the client
* code, but this will have no effect on the annotation content of this
* class, and hence no effect on the return value of this method for
* future callers.
*
* @return the annotations directly defined by the element.
* @since 1.5
*/
native Annotation[] getDeclaredAnnotations();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMRuntime.java
0,0 → 1,192
/* VMRuntime.java -- VM interface to Runtime
Copyright (C) 2003 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.File;
import java.io.IOException;
 
/**
* VMRuntime represents the interface to the Virtual Machine.
*
* @author Jeroen Frijters
*/
final class VMRuntime
{
/**
* No instance is ever created.
*/
private VMRuntime()
{
}
 
/**
* 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
*/
static 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
*/
static 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
*/
static 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
*/
static native long maxMemory();
 
/**
* Run the garbage collector. This method is more of a suggestion than
* anything. All this method guarantees is that the garbage collector will
* have "done its best" by the time it returns. Notice that garbage
* collection takes place even without calling this method.
*/
static native void gc();
 
/**
* Run finalization on all Objects that are waiting to be finalized. Again,
* a suggestion, though a stronger one than {@link #gc()}. This calls the
* <code>finalize</code> method of all objects waiting to be collected.
*
* @see #finalize()
*/
static native void runFinalization();
 
/**
* Run finalization on all finalizable Objects (even live ones). This
* should only be called immediately prior to VM termination.
*
* @see #finalize()
*/
static native void runFinalizationForExit();
 
/**
* 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
*/
static 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
*/
static native void traceMethodCalls(boolean on);
 
/**
* Native method that actually sets the finalizer setting.
*
* @param value whether to run finalizers on exit
*/
static native void runFinalizersOnExit(boolean value);
 
/**
* Native method that actually shuts down the virtual machine.
*
* @param status the status to end the process with
*/
static native void exit(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 loader class loader, or <code>null</code> for the boot loader
* @return 0 on failure, nonzero on success
*/
static native int nativeLoad(String filename, ClassLoader loader);
 
/**
* Map a system-independent "short name" to the full file name.
*
* @param libname the short version of the library name
* @return the full filename
*/
static native String mapLibraryName(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. If env is null, then the new process should inherit
* the environment of this process.
*
* @param cmd the non-null command tokens
* @param env the 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
*/
static Process exec(String[] cmd, String[] env, File dir)
throws IOException {
return VMProcess.exec(cmd, env, dir);
}
 
/**
* This method is called by Runtime.addShutdownHook() when it is
* called for the first time. It enables the VM to lazily setup
* an exit handler, should it so desire.
*/
static void enableShutdownHooks()
{
}
} // class VMRuntime
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMSystem.java
0,0 → 1,220
/* VMSystem.java -- helper for java.lang.system
Copyright (C) 1998, 2002, 2004 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.util.List;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
 
/**
* VMSystem is a package-private helper class for System that the
* VM must implement.
*
* @author John Keiser
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
*/
final class VMSystem
{
/**
* 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
*/
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
*/
static native int identityHashCode(Object o);
 
/**
* 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
* @XXX Add this method
static native String mapLibraryName(String libname);
*/
 
/**
* Set {@link System#in} to a new InputStream.
*
* @param in the new InputStream
* @see #setIn(InputStream)
*/
static native void setIn(InputStream in);
 
/**
* Set {@link System#out} to a new PrintStream.
*
* @param out the new PrintStream
* @see #setOut(PrintStream)
*/
static native void setOut(PrintStream out);
 
/**
* Set {@link System#err} to a new PrintStream.
*
* @param err the new PrintStream
* @see #setErr(PrintStream)
*/
static native void setErr(PrintStream err);
 
/**
* 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 long currentTimeMillis()
{
return nanoTime() / 1000000L;
}
 
/**
* <p>
* Returns the current value of a nanosecond-precise system timer.
* The value of the timer is an offset relative to some arbitrary fixed
* time, which may be in the future (making the value negative). This
* method is useful for timing events where nanosecond precision is
* required. This is achieved by calling this method before and after the
* event, and taking the difference betweent the two times:
* </p>
* <p>
* <code>long startTime = System.nanoTime();</code><br />
* <code>... <emph>event code</emph> ...</code><br />
* <code>long endTime = System.nanoTime();</code><br />
* <code>long duration = endTime - startTime;</code><br />
* </p>
* <p>
* Note that the value is only nanosecond-precise, and not accurate; there
* is no guarantee that the difference between two values is really a
* nanosecond. Also, the value is prone to overflow if the offset
* exceeds 2^63.
* </p>
*
* @return the time of a system timer in nanoseconds.
* @since 1.5
*/
public static native long nanoTime();
 
/**
* Returns a list of 'name=value' pairs representing the current environment
* variables.
*
* @return a list of 'name=value' pairs.
*/
static native List environ();
 
/**
* Helper method which creates the standard input stream.
* VM implementors may choose to construct these streams differently.
* This method can also return null if the stream is created somewhere
* else in the VM startup sequence.
*/
static InputStream makeStandardInputStream()
{
return new BufferedInputStream(new FileInputStream(FileDescriptor.in));
}
 
/**
* Helper method which creates the standard output stream.
* VM implementors may choose to construct these streams differently.
* This method can also return null if the stream is created somewhere
* else in the VM startup sequence.
*/
static PrintStream makeStandardOutputStream()
{
return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)), true);
}
 
/**
* Helper method which creates the standard error stream.
* VM implementors may choose to construct these streams differently.
* This method can also return null if the stream is created somewhere
* else in the VM startup sequence.
*/
static PrintStream makeStandardErrorStream()
{
return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err)), true);
}
 
/**
* Gets the value of an environment variable.
* Always returning null is a valid (but not very useful) implementation.
*
* @param name The name of the environment variable (will not be null).
* @return The string value of the variable or null when the
* environment variable is not defined.
*/
static native String getenv(String name);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMClass.java
0,0 → 1,469
/* VMClass.java -- VM Specific Class methods
Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
 
/*
* This class is a reference version, mainly for compiling a class library
* jar. It is likely that VM implementers replace this with their own
* version that can communicate effectively with the VM.
*/
 
/**
*
* @author Etienne Gagnon (etienne.gagnon@uqam.ca)
* @author Archie Cobbs (archie@dellroad.org)
* @author C. Brian Jones (cbj@gnu.org)
* @author Tom Tromey (tromey@cygnus.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
*/
final class VMClass
{
 
// Only static methods. Cannot be instantiated.
private VMClass()
{
}
 
/**
* Discover whether an Object is an instance of this Class. Think of it
* as almost like <code>o instanceof (this class)</code>.
*
* @param klass the Class object that's calling us
* @param o the Object to check
* @return whether o is an instance of this class
* @since 1.1
*/
static native boolean isInstance(Class klass, Object o);
 
/**
* Discover whether an instance of the Class parameter would be an
* instance of this Class as well. Think of doing
* <code>isInstance(c.newInstance())</code> or even
* <code>c.newInstance() instanceof (this class)</code>. While this
* checks widening conversions for objects, it must be exact for primitive
* types.
*
* @param klass the Class object that's calling us
* @param c the class to check
* @return whether an instance of c would be an instance of this class
* as well
* @throws NullPointerException if c is null
* @since 1.1
*/
static native boolean isAssignableFrom(Class klass, Class c);
 
/**
* Check whether this class is an interface or not. Array types are not
* interfaces.
*
* @param klass the Class object that's calling us
* @return whether this class is an interface or not
*/
static native boolean isInterface(Class klass);
 
/**
* Return whether this class is a primitive type. A primitive type class
* is a class representing a kind of "placeholder" for the various
* primitive types, or void. You can access the various primitive type
* classes through java.lang.Boolean.TYPE, java.lang.Integer.TYPE, etc.,
* or through boolean.class, int.class, etc.
*
* @param klass the Class object that's calling us
* @return whether this class is a primitive type
* @see Boolean#TYPE
* @see Byte#TYPE
* @see Character#TYPE
* @see Short#TYPE
* @see Integer#TYPE
* @see Long#TYPE
* @see Float#TYPE
* @see Double#TYPE
* @see Void#TYPE
* @since 1.1
*/
static native boolean isPrimitive(Class klass);
 
/**
* Get the name of this class, separated by dots for package separators.
* Primitive types and arrays are encoded as:
* <pre>
* boolean Z
* byte B
* char C
* short S
* int I
* long J
* float F
* double D
* void V
* array type [<em>element type</em>
* class or interface, alone: &lt;dotted name&gt;
* class or interface, as element type: L&lt;dotted name&gt;;
*
* @param klass the Class object that's calling us
* @return the name of this class
*/
static native String getName(Class klass);
 
/**
* Get the direct superclass of this class. If this is an interface,
* Object, a primitive type, or void, it will return null. If this is an
* array type, it will return Object.
*
* @param klass the Class object that's calling us
* @return the direct superclass of this class
*/
static native Class getSuperclass(Class klass);
 
/**
* Get the interfaces this class <EM>directly</EM> implements, in the
* order that they were declared. This returns an empty array, not null,
* for Object, primitives, void, and classes or interfaces with no direct
* superinterface. Array types return Cloneable and Serializable.
*
* @param klass the Class object that's calling us
* @return the interfaces this class directly implements
*/
static native Class[] getInterfaces(Class klass);
 
/**
* If this is an array, get the Class representing the type of array.
* Examples: "[[Ljava.lang.String;" would return "[Ljava.lang.String;", and
* calling getComponentType on that would give "java.lang.String". If
* this is not an array, returns null.
*
* @param klass the Class object that's calling us
* @return the array type of this class, or null
* @see Array
* @since 1.1
*/
static native Class getComponentType(Class klass);
 
/**
* Get the modifiers of this class. These can be decoded using Modifier,
* and is limited to one of public, protected, or private, and any of
* final, static, abstract, or interface. An array class has the same
* public, protected, or private modifier as its component type, and is
* marked final but not an interface. Primitive types and void are marked
* public and final, but not an interface.
*
* @param klass the Class object that's calling us
* @param ignoreInnerClassesAttrib if set, return the real modifiers, not
* the ones specified in the InnerClasses attribute.
* @return the modifiers of this class
* @see Modifier
* @since 1.1
*/
static native int getModifiers(Class klass, boolean ignoreInnerClassesAttrib);
 
/**
* If this is a nested or inner class, return the class that declared it.
* If not, return null.
*
* @param klass the Class object that's calling us
* @return the declaring class of this class
* @since 1.1
*/
static native Class getDeclaringClass(Class klass);
 
/**
* Like <code>getDeclaredClasses()</code> but without the security checks.
*
* @param klass the Class object that's calling us
* @param publicOnly Only public classes should be returned
*/
static native Class[] getDeclaredClasses(Class klass, boolean publicOnly);
 
/**
* Like <code>getDeclaredFields()</code> but without the security checks.
*
* @param klass the Class object that's calling us
* @param publicOnly Only public fields should be returned
*/
static native Field[] getDeclaredFields(Class klass, boolean publicOnly);
 
/**
* Like <code>getDeclaredMethods()</code> but without the security checks.
*
* @param klass the Class object that's calling us
* @param publicOnly Only public methods should be returned
*/
static native Method[] getDeclaredMethods(Class klass, boolean publicOnly);
 
/**
* Like <code>getDeclaredConstructors()</code> but without
* the security checks.
*
* @param klass the Class object that's calling us
* @param publicOnly Only public constructors should be returned
*/
static native Constructor[] getDeclaredConstructors(Class klass, boolean publicOnly);
 
/**
* Return the class loader of this class.
*
* @param klass the Class object that's calling us
* @return the class loader
*/
static native ClassLoader getClassLoader(Class klass);
 
/**
* Load the requested class and record the specified loader as the
* initiating class loader.
*
* @param name the name of the class to find
* @param initialize should the class initializer be run?
* @param loader the class loader to use (or null for the bootstrap loader)
* @return the Class object representing the class or null for noop
* @throws ClassNotFoundException if the class was not found by the
* class loader
* @throws LinkageError if linking the class fails
* @throws ExceptionInInitializerError if the class loads, but an exception
* occurs during initialization
*/
static native Class forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException;
 
/**
* Return whether this class is an array type.
*
* @param klass the Class object that's calling us
* @return true if this class is an array type
* operation
*/
static native boolean isArray(Class klass);
 
/**
* Throw a checked exception without declaring it.
*/
static native void throwException(Throwable t);
 
/**
* Returns the simple name for the specified class, as used in the source
* code. For normal classes, this is the content returned by
* <code>getName()</code> which follows the last ".". Anonymous
* classes have no name, and so the result of calling this method is
* "". The simple name of an array consists of the simple name of
* its component type, followed by "[]". Thus, an array with the
* component type of an anonymous class has a simple name of simply
* "[]".
*
* @param klass the class whose simple name should be returned.
* @return the simple name for this class.
*/
static String getSimpleName(Class klass)
{
if (isAnonymousClass(klass))
return "";
if (isArray(klass))
{
return getComponentType(klass).getSimpleName() + "[]";
}
String fullName = getName(klass);
int pos = fullName.lastIndexOf("$");
if (pos == -1)
pos = 0;
else
{
++pos;
while (Character.isDigit(fullName.charAt(pos)))
++pos;
}
int packagePos = fullName.lastIndexOf(".", pos);
if (packagePos == -1)
return fullName.substring(pos);
else
return fullName.substring(packagePos + 1);
}
 
/**
* Returns all annotations directly defined by the specified class. If
* there are no annotations associated with this class, then a zero-length
* array will be returned. The returned array may be modified by the client
* code, but this will have no effect on the annotation content of this
* class, and hence no effect on the return value of this method for
* future callers.
*
* @param klass the class whose annotations should be returned.
* @return the annotations directly defined by the specified class.
* @since 1.5
*/
static native Annotation[] getDeclaredAnnotations(Class klass);
 
/**
* <p>
* Returns the canonical name of the specified class, as defined by section
* 6.7 of the Java language specification. Each package, top-level class,
* top-level interface and primitive type has a canonical name. A member
* class has a canonical name, if its parent class has one. Likewise,
* an array type has a canonical name, if its component type does.
* Local or anonymous classes do not have canonical names.
* </p>
* <p>
* The canonical name for top-level classes, top-level interfaces and
* primitive types is always the same as the fully-qualified name.
* For array types, the canonical name is the canonical name of its
* component type with `[]' appended.
* </p>
* <p>
* The canonical name of a member class always refers to the place where
* the class was defined, and is composed of the canonical name of the
* defining class and the simple name of the member class, joined by `.'.
* For example, if a <code>Person</code> class has an inner class,
* <code>M</code>, then both its fully-qualified name and canonical name
* is <code>Person.M</code>. A subclass, <code>Staff</code>, of
* <code>Person</code> refers to the same inner class by the fully-qualified
* name of <code>Staff.M</code>, but its canonical name is still
* <code>Person.M</code>.
* </p>
* <p>
* Where no canonical name is present, <code>null</code> is returned.
* </p>
*
* @param klass the class whose canonical name should be retrieved.
* @return the canonical name of the class, or <code>null</code> if the
* class doesn't have a canonical name.
* @since 1.5
*/
static String getCanonicalName(Class klass)
{
if (isLocalClass(klass) || isAnonymousClass(klass))
return null;
if (isArray(klass))
{
String componentName = getComponentType(klass).getCanonicalName();
if (componentName != null)
return componentName + "[]";
}
if (isMemberClass(klass))
{
String memberName = getDeclaringClass(klass).getCanonicalName();
if (memberName != null)
return memberName + "." + getSimpleName(klass);
else
return memberName;
}
return getName(klass);
}
 
/**
* Returns the class which immediately encloses the specified class. If
* the class is a top-level class, this method returns <code>null</code>.
*
* @param klass the class whose enclosing class should be returned.
* @return the immediate enclosing class, or <code>null</code> if this is
* a top-level class.
* @since 1.5
*/
static native Class getEnclosingClass(Class klass);
 
/**
* Returns the constructor which immediately encloses the specified class.
* If the class is a top-level class, or a local or anonymous class
* immediately enclosed by a type definition, instance initializer
* or static initializer, then <code>null</code> is returned.
*
* @param klass the class whose enclosing constructor should be returned.
* @return the immediate enclosing constructor if the specified class is
* declared within a constructor. Otherwise, <code>null</code>
* is returned.
* @since 1.5
*/
static native Constructor getEnclosingConstructor(Class klass);
 
/**
* Returns the method which immediately encloses the specified class. If
* the class is a top-level class, or a local or anonymous class
* immediately enclosed by a type definition, instance initializer
* or static initializer, then <code>null</code> is returned.
*
* @param klass the class whose enclosing method should be returned.
* @return the immediate enclosing method if the specified class is
* declared within a method. Otherwise, <code>null</code>
* is returned.
* @since 1.5
*/
static native Method getEnclosingMethod(Class klass);
 
/**
* Returns the class signature as specified in Class File Format
* chapter in the VM specification, or null if the class is not
* generic.
*
* @param klass the klass to test.
* @return a ClassSignature string.
* @since 1.5
*/
static native String getClassSignature(Class klass);
 
/**
* Returns true if the specified class represents an anonymous class.
*
* @param klass the klass to test.
* @return true if the specified class represents an anonymous class.
* @since 1.5
*/
static native boolean isAnonymousClass(Class klass);
 
/**
* Returns true if the specified class represents an local class.
*
* @param klass the klass to test.
* @return true if the specified class represents an local class.
* @since 1.5
*/
static native boolean isLocalClass(Class klass);
 
/**
* Returns true if the specified class represents an member class.
*
* @param klass the klass to test.
* @return true if the specified class represents an member class.
* @since 1.5
*/
static native boolean isMemberClass(Class klass);
 
} // class VMClass
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMFloat.java
0,0 → 1,118
/* VMFloat.java -- VM Specific Float methods
Copyright (C) 2003 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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 gnu.classpath.Configuration;
 
/*
* This class is a reference version, mainly for compiling a class library
* jar. It is likely that VM implementers replace this with their own
* version that can communicate effectively with the VM.
*/
 
/**
* Code relocated from java.lang.Float by
* @author Dave Grove <groved@us.ibm.com>
*/
final class VMFloat
{
 
/**
* Load native routines necessary for this class.
*/
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javalang");
}
}
 
/**
* Convert the float to the IEEE 754 floating-point "single format" bit
* layout. Bit 31 (the most significant) is the sign bit, bits 30-23
* (masked by 0x7f800000) represent the exponent, and bits 22-0
* (masked by 0x007fffff) are the mantissa. This function leaves NaN alone,
* rather than collapsing to a canonical value. The result of this function
* can be used as the argument to <code>Float.intBitsToFloat(int)</code> to
* obtain the original <code>float</code> value.
*
* @param value the <code>float</code> to convert
* @return the bits of the <code>float</code>
* @see #intBitsToFloat(int)
*/
static native int floatToRawIntBits(float value);
 
/**
* Convert the argument in IEEE 754 floating-point "single format" bit
* layout to the corresponding float. Bit 31 (the most significant) is the
* sign bit, bits 30-23 (masked by 0x7f800000) represent the exponent, and
* bits 22-0 (masked by 0x007fffff) are the mantissa. This function leaves
* NaN alone, so that you can recover the bit pattern with
* <code>Float.floatToRawIntBits(float)</code>.
*
* @param bits the bits to convert
* @return the <code>float</code> represented by the bits
* @see #floatToIntBits(float)
* @see #floatToRawIntBits(float)
*/
static native float intBitsToFloat(int bits);
 
/**
* @param f the <code>float</code> to convert
* @return the <code>String</code> representing the <code>float</code>
*/
static String toString(float f)
{
return VMDouble.toString(f, true);
}
 
/**
* @param str the <code>String</code> to convert
* @return the <code>float</code> value of <code>s</code>
* @throws NumberFormatException if <code>str</code> cannot be parsed as a
* <code>float</code>
* @throws NullPointerException if <code>str</code> is null
*/
static float parseFloat(String str)
{
// XXX Rounding parseDouble() causes some errors greater than 1 ulp from
// the infinitely precise decimal.
return (float) Double.parseDouble(str);
}
} // class VMFloat
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMObject.java
0,0 → 1,105
/* VMObject.java -- Reference implementation for VM hooks used by Object
Copyright (C) 1998, 2002, 2005 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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;
 
/**
* Object is the ultimate superclass of every class (excepting interfaces).
* As such, it needs help from the VM.
*
* @author John Keiser
* @author Eric Blake (ebb9@email.byu.edu)
*/
final class VMObject
{
/**
* Returns the runtime {@link Class} of a given Object.
*
* @param obj the object to return the class for.
*
* @return the class of the Object.
*/
static native Class getClass(Object obj);
 
/**
* The VM is expected to make a field-for-field shallow copy of the
* argument. Thus, the copy has the same runtime type as the argument.
* Note, however, that the cloned object must still be finalizable, even
* if the original has already had finalize() invoked on it.
*
* @param c the Cloneable to clone
* @return the clone
*/
static native Object clone(Cloneable c);
 
/**
* Wakes up one of the threads that is waiting on this Object's monitor.
* Only the owner of a lock on the Object may call this method. The Thread
* to wake up is chosen arbitrarily.
*
* @param o the object doing the notify
* @throw IllegalMonitorStateException if this Thread does not own the
* lock on the Object
*/
static native void notify(Object o) throws IllegalMonitorStateException;
 
/**
* Wakes up all of the threads waiting on this Object's monitor. Only
* the owner of the lock on this Object may call this method.
*
* @param o the object doing the notifyAll
* @throws IllegalMonitorStateException if this Thread does not own the
* lock on the Object
*/
static native void notifyAll(Object o) throws IllegalMonitorStateException;
 
/**
* Waits a specified amount of time for notify() or notifyAll() to be
* called on this Object. The VM does not have to pay attention to the
* ns argument, if it does not have that much granularity.
*
* @param o the object to suspend on
* @param ms milliseconds to wait (1,000 milliseconds = 1 second)
* @param ns nanoseconds to wait beyond ms (1,000,000 nanoseconds
* == 1 millisecond)
* @throws IllegalMonitorStateException if this Thread does not own the
* lock on the Object
* @throws InterruptedException if some other Thread interrupts this Thread
*/
static native void wait(Object o, long ms, int ns)
throws IllegalMonitorStateException, InterruptedException;
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMString.java
0,0 → 1,91
/* VMString.java -- VM Specific String methods
Copyright (C) 2003 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.lang.ref.WeakReference;
import java.util.WeakHashMap;
 
/*
* This class is a reference version, mainly for compiling a class library
* jar. It is likely that VM implementers replace this with their own
* version that can communicate effectively with the VM.
*/
 
/**
* Code relocated from java.lang.String by
* @author Dave Grove <groved@us.ibm.com>
*/
final class VMString
{
 
/**
* Holds the references for each intern()'d String. If all references to
* the string disappear, and the VM properly supports weak references,
* the String will be GC'd.
*/
private static final WeakHashMap internTable = new WeakHashMap();
 
/**
* Fetches this String from the intern hashtable. If two Strings are
* considered equal, by the equals() method, then intern() will return the
* same String instance. ie. if (s1.equals(s2)) then
* (s1.intern() == s2.intern()). All string literals and string-valued
* constant expressions are already interned.
*
* @param str the String to intern
* @return the interned String
*/
static String intern(String str)
{
synchronized (internTable)
{
WeakReference ref = (WeakReference) internTable.get(str);
if (ref != null)
{
String s = (String) ref.get();
// If s is null, then no strong references exist to the String;
// the weak hash map will soon delete the key.
if (s != null)
return s;
}
internTable.put(str, new WeakReference(str));
}
return str;
}
 
} // class VMString
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMThrowable.java
0,0 → 1,82
/* java.lang.VMThrowable -- VM support methods for Throwable.
Copyright (C) 1998, 1999, 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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;
 
/**
* VM dependant state and support methods for Throwable.
* It is deliberately package local and final and should only be accessed
* by the Throwable class.
* <p>
* This is the GNU Classpath reference implementation, it should be adapted
* for a specific VM. The reference implementation does nothing.
*
* @author Mark Wielaard (mark@klomp.org)
*/
final class VMThrowable
{
/**
* VM private data.
*/
private transient Object vmdata;
 
/**
* Private contructor, create VMThrowables with fillInStackTrace();
*/
private VMThrowable() { }
 
/**
* Fill in the stack trace with the current execution stack.
* Called by <code>Throwable.fillInStackTrace()</code> to get the state of
* the VM. Can return null when the VM does not support caputing the VM
* execution state.
*
* @return a new VMThrowable containing the current execution stack trace.
* @see Throwable#fillInStackTrace()
*/
static native VMThrowable fillInStackTrace(Throwable t);
 
/**
* Returns an <code>StackTraceElement</code> array based on the execution
* state of the VM as captured by <code>fillInStackTrace</code>.
* Called by <code>Throwable.getStackTrace()</code>.
*
* @return a non-null but possible zero length array of StackTraceElement.
* @see Throwable#getStackTrace()
*/
native StackTraceElement[] getStackTrace(Throwable t);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMThread.java
0,0 → 1,461
/* VMThread -- VM interface for Thread of executable code
Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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;
 
/**
* VM interface for Thread of executable code. Holds VM dependent state.
* It is deliberately package local and final and should only be accessed
* by the Thread class.
* <p>
* This is the GNU Classpath reference implementation, it should be adapted
* for a specific VM.
* <p>
* The following methods must be implemented:
* <ul>
* <li>native void start(long stacksize);
* <li>native void interrupt();
* <li>native boolean isInterrupted();
* <li>native void suspend();
* <li>native void resume();
* <li>native void nativeSetPriority(int priority);
* <li>native void nativeStop(Throwable t);
* <li>native static Thread currentThread();
* <li>static native void yield();
* <li>static native boolean interrupted();
* </ul>
* All other methods may be implemented to make Thread handling more efficient
* or to implement some optional (and sometimes deprecated) behaviour. Default
* implementations are provided but it is highly recommended to optimize them
* for a specific VM.
*
* @author Jeroen Frijters (jeroen@frijters.net)
* @author Dalibor Topic (robilad@kaffe.org)
*/
final class VMThread
{
/**
* The Thread object that this VM state belongs to.
* Used in currentThread() and start().
* Note: when this thread dies, this reference is *not* cleared
*/
volatile Thread thread;
 
/**
* Flag that is set when the thread runs, used by stop() to protect against
* stop's getting lost.
*/
private volatile boolean running;
 
/**
* VM private data.
*/
private transient Object vmdata;
 
/**
* Private constructor, create VMThreads with the static create method.
*
* @param thread The Thread object that was just created.
*/
private VMThread(Thread thread)
{
this.thread = thread;
}
 
/**
* This method is the initial Java code that gets executed when a native
* thread starts. It's job is to coordinate with the rest of the VMThread
* logic and to start executing user code and afterwards handle clean up.
*/
private void run()
{
try
{
try
{
running = true;
synchronized(thread)
{
Throwable t = thread.stillborn;
if(t != null)
{
thread.stillborn = null;
throw t;
}
}
thread.run();
}
catch(Throwable t)
{
try
{
Thread.UncaughtExceptionHandler handler;
handler = thread.getUncaughtExceptionHandler();
handler.uncaughtException(thread, t);
}
catch(Throwable ignore)
{
}
}
}
finally
{
// Setting runnable to false is partial protection against stop
// being called while we're cleaning up. To be safe all code in
// VMThread be unstoppable.
running = false;
thread.die();
synchronized(this)
{
// release the threads waiting to join us
notifyAll();
}
}
}
 
/**
* Creates a native Thread. This is called from the start method of Thread.
* The Thread is started.
*
* @param thread The newly created Thread object
* @param stacksize Indicates the requested stacksize. Normally zero,
* non-zero values indicate requested stack size in bytes but it is up
* to the specific VM implementation to interpret them and may be ignored.
*/
static void create(Thread thread, long stacksize)
{
VMThread vmThread = new VMThread(thread);
vmThread.start(stacksize);
thread.vmThread = vmThread;
}
 
/**
* Gets the name of the thread. Usually this is the name field of the
* associated Thread object, but some implementation might choose to
* return the name of the underlying platform thread.
*/
String getName()
{
return thread.name;
}
 
/**
* Set the name of the thread. Usually this sets the name field of the
* associated Thread object, but some implementations might choose to
* set the name of the underlying platform thread.
* @param name The new name
*/
void setName(String name)
{
thread.name = name;
}
 
/**
* Set the thread priority field in the associated Thread object and
* calls the native method to set the priority of the underlying
* platform thread.
* @param priority The new priority
*/
void setPriority(int priority)
{
thread.priority = priority;
nativeSetPriority(priority);
}
 
/**
* Returns the priority. Usually this is the priority field from the
* associated Thread object, but some implementation might choose to
* return the priority of the underlying platform thread.
* @return this Thread's priority
*/
int getPriority()
{
return thread.priority;
}
 
/**
* Returns true if the thread is a daemon thread. Usually this is the
* daemon field from the associated Thread object, but some
* implementation might choose to return the daemon state of the underlying
* platform thread.
* @return whether this is a daemon Thread or not
*/
boolean isDaemon()
{
return thread.daemon;
}
 
/**
* Returns the number of stack frames in this Thread.
* Will only be called when when a previous call to suspend() returned true.
*
* @deprecated unsafe operation
*/
native int countStackFrames();
 
/**
* Wait the specified amount of time for the Thread in question to die.
*
* <p>Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do
* not offer that fine a grain of timing resolution. Besides, there is
* no guarantee that this thread can start up immediately when time expires,
* because some other thread may be active. So don't expect real-time
* performance.
*
* @param ms the number of milliseconds to wait, or 0 for forever
* @param ns the number of extra nanoseconds to sleep (0-999999)
* @throws InterruptedException if the Thread is interrupted; it's
* <i>interrupted status</i> will be cleared
*/
synchronized void join(long ms, int ns) throws InterruptedException
{
// Round up
ms += (ns != 0) ? 1 : 0;
 
// Compute end time, but don't overflow
long now = System.currentTimeMillis();
long end = now + ms;
if (end < now)
end = Long.MAX_VALUE;
 
// A VM is allowed to return from wait() without notify() having been
// called, so we loop to handle possible spurious wakeups.
while(thread.vmThread != null)
{
// We use the VMThread object to wait on, because this is a private
// object, so client code cannot call notify on us.
wait(ms);
if(ms != 0)
{
now = System.currentTimeMillis();
ms = end - now;
if(ms <= 0)
{
break;
}
}
}
}
 
/**
* Cause this Thread to stop abnormally and throw the specified exception.
* If you stop a Thread that has not yet started, the stop is ignored
* (contrary to what the JDK documentation says).
* <b>WARNING</b>This bypasses Java security, and can throw a checked
* exception which the call stack is unprepared to handle. Do not abuse
* this power.
*
* <p>This is inherently unsafe, as it can interrupt synchronized blocks and
* leave data in bad states.
*
* <p><b>NOTE</b> stop() should take care not to stop a thread if it is
* executing code in this class.
*
* @param t the Throwable to throw when the Thread dies
* @deprecated unsafe operation, try not to use
*/
void stop(Throwable t)
{
// Note: we assume that we own the lock on thread
// (i.e. that Thread.stop() is synchronized)
if(running)
nativeStop(t);
else
thread.stillborn = t;
}
 
/**
* Create a native thread on the underlying platform and start it executing
* on the run method of this object.
* @param stacksize the requested size of the native thread stack
*/
native void start(long stacksize);
 
/**
* Interrupt this thread.
*/
native void interrupt();
 
/**
* Determine whether this Thread has been interrupted, but leave
* the <i>interrupted status</i> alone in the process.
*
* @return whether the Thread has been interrupted
*/
native boolean isInterrupted();
 
/**
* Suspend this Thread. It will not come back, ever, unless it is resumed.
*/
native void suspend();
 
/**
* Resume this Thread. If the thread is not suspended, this method does
* nothing.
*/
native void resume();
 
/**
* Set the priority of the underlying platform thread.
*
* @param priority the new priority
*/
native void nativeSetPriority(int priority);
 
/**
* Asynchronously throw the specified throwable in this Thread.
*
* @param t the exception to throw
*/
native void nativeStop(Throwable t);
 
/**
* Return the Thread object associated with the currently executing
* thread.
*
* @return the currently executing Thread
*/
static native Thread currentThread();
 
/**
* Yield to another thread. The Thread will not lose any locks it holds
* during this time. There are no guarantees which thread will be
* next to run, and it could even be this one, but most VMs will choose
* the highest priority thread that has been waiting longest.
*/
static native void yield();
 
/**
* Suspend the current Thread's execution for the specified amount of
* time. The Thread will not lose any locks it has during this time. There
* are no guarantees which thread will be next to run, but most VMs will
* choose the highest priority thread that has been waiting longest.
*
* <p>Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do
* not offer that fine a grain of timing resolution. Besides, there is
* no guarantee that this thread can start up immediately when time expires,
* because some other thread may be active. So don't expect real-time
* performance.
*
* @param ms the number of milliseconds to sleep.
* @param ns the number of extra nanoseconds to sleep (0-999999)
* @throws InterruptedException if the Thread is (or was) interrupted;
* it's <i>interrupted status</i> will be cleared
*/
static void sleep(long ms, int ns) throws InterruptedException
{
// Note: JDK treats a zero length sleep is like Thread.yield(),
// without checking the interrupted status of the thread.
// It's unclear if this is a bug in the implementation or the spec.
// See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6213203
if (ms == 0 && ns == 0)
{
if (Thread.interrupted())
throw new InterruptedException();
return;
}
 
// Compute end time, but don't overflow
long now = System.currentTimeMillis();
long end = now + ms;
if (end < now)
end = Long.MAX_VALUE;
 
// A VM is allowed to return from wait() without notify() having been
// called, so we loop to handle possible spurious wakeups.
VMThread vt = Thread.currentThread().vmThread;
synchronized (vt)
{
while (true)
{
vt.wait(ms, ns);
now = System.currentTimeMillis();
if (now >= end)
break;
ms = end - now;
ns = 0;
}
}
}
 
/**
* Determine whether the current Thread has been interrupted, and clear
* the <i>interrupted status</i> in the process.
*
* @return whether the current Thread has been interrupted
*/
static native boolean interrupted();
 
/**
* Checks whether the current thread holds the monitor on a given object.
* This allows you to do <code>assert Thread.holdsLock(obj)</code>.
*
* @param obj the object to check
* @return true if the current thread is currently synchronized on obj
* @throws NullPointerException if obj is null
*/
static boolean holdsLock(Object obj)
{
/* Use obj.notify to check if the current thread holds
* the monitor of the object.
* If it doesn't, notify will throw an exception.
*/
try
{
obj.notify();
// okay, current thread holds lock
return true;
}
catch (IllegalMonitorStateException e)
{
// it doesn't hold the lock
return false;
}
}
 
/**
* Returns the current state of the thread.
* The value must be one of "BLOCKED", "NEW",
* "RUNNABLE", "TERMINATED", "TIMED_WAITING" or
* "WAITING".
*
* @return a string corresponding to one of the
* thread enumeration states specified above.
*/
native String getState();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/management/VMManagementFactory.java
0,0 → 1,75
/* VMManagementFactory.java - VM interface for obtaining system beans.
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.management;
 
/**
* Provides lists of resources required by the
* {@link java.lang.management.ManagementFactory} for
* creating beans.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMManagementFactory
{
 
/**
* Return a list of the names of the currently available
* memory pools within the virtual machine.
*
* @return a list of memory pool names.
*/
static native String[] getMemoryPoolNames();
 
/**
* Return a list of the names of the currently available
* memory managers within the virtual machine. This should
* not include the garbage collectors listed below.
*
* @return a list of memory manager names.
*/
static native String[] getMemoryManagerNames();
 
/**
* Return a list of the names of the currently available
* garbage collectors within the virtual machine.
*
* @return a list of garbage collector names.
*/
static native String[] getGarbageCollectorNames();
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMMath.java
0,0 → 1,493
/* VMMath.java -- Common mathematical functions.
Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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 gnu.classpath.Configuration;
 
class VMMath
{
 
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javalang");
}
}
 
/**
* The trigonometric function <em>sin</em>. The sine of NaN or infinity is
* NaN, and the sine of 0 retains its sign. This is accurate within 1 ulp,
* and is semi-monotonic.
*
* @param a the angle (in radians)
* @return sin(a)
*/
public static native double sin(double a);
 
/**
* The trigonometric function <em>cos</em>. The cosine of NaN or infinity is
* NaN. This is accurate within 1 ulp, and is semi-monotonic.
*
* @param a the angle (in radians)
* @return cos(a)
*/
public static native double cos(double a);
 
/**
* The trigonometric function <em>tan</em>. The tangent of NaN or infinity
* is NaN, and the tangent of 0 retains its sign. This is accurate within 1
* ulp, and is semi-monotonic.
*
* @param a the angle (in radians)
* @return tan(a)
*/
public static native double tan(double a);
 
/**
* The trigonometric function <em>arcsin</em>. The range of angles returned
* is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN or
* its absolute value is beyond 1, the result is NaN; and the arcsine of
* 0 retains its sign. This is accurate within 1 ulp, and is semi-monotonic.
*
* @param a the sin to turn back into an angle
* @return arcsin(a)
*/
public static native double asin(double a);
 
/**
* The trigonometric function <em>arccos</em>. The range of angles returned
* is 0 to pi radians (0 to 180 degrees). If the argument is NaN or
* its absolute value is beyond 1, the result is NaN. This is accurate
* within 1 ulp, and is semi-monotonic.
*
* @param a the cos to turn back into an angle
* @return arccos(a)
*/
public static native double acos(double a);
 
/**
* The trigonometric function <em>arcsin</em>. The range of angles returned
* is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN, the
* result is NaN; and the arctangent of 0 retains its sign. This is accurate
* within 1 ulp, and is semi-monotonic.
*
* @param a the tan to turn back into an angle
* @return arcsin(a)
* @see #atan2(double, double)
*/
public static native double atan(double a);
 
/**
* A special version of the trigonometric function <em>arctan</em>, for
* converting rectangular coordinates <em>(x, y)</em> to polar
* <em>(r, theta)</em>. This computes the arctangent of x/y in the range
* of -pi to pi radians (-180 to 180 degrees). Special cases:<ul>
* <li>If either argument is NaN, the result is NaN.</li>
* <li>If the first argument is positive zero and the second argument is
* positive, or the first argument is positive and finite and the second
* argument is positive infinity, then the result is positive zero.</li>
* <li>If the first argument is negative zero and the second argument is
* positive, or the first argument is negative and finite and the second
* argument is positive infinity, then the result is negative zero.</li>
* <li>If the first argument is positive zero and the second argument is
* negative, or the first argument is positive and finite and the second
* argument is negative infinity, then the result is the double value
* closest to pi.</li>
* <li>If the first argument is negative zero and the second argument is
* negative, or the first argument is negative and finite and the second
* argument is negative infinity, then the result is the double value
* closest to -pi.</li>
* <li>If the first argument is positive and the second argument is
* positive zero or negative zero, or the first argument is positive
* infinity and the second argument is finite, then the result is the
* double value closest to pi/2.</li>
* <li>If the first argument is negative and the second argument is
* positive zero or negative zero, or the first argument is negative
* infinity and the second argument is finite, then the result is the
* double value closest to -pi/2.</li>
* <li>If both arguments are positive infinity, then the result is the
* double value closest to pi/4.</li>
* <li>If the first argument is positive infinity and the second argument
* is negative infinity, then the result is the double value closest to
* 3*pi/4.</li>
* <li>If the first argument is negative infinity and the second argument
* is positive infinity, then the result is the double value closest to
* -pi/4.</li>
* <li>If both arguments are negative infinity, then the result is the
* double value closest to -3*pi/4.</li>
*
* </ul><p>This is accurate within 2 ulps, and is semi-monotonic. To get r,
* use sqrt(x*x+y*y).
*
* @param y the y position
* @param x the x position
* @return <em>theta</em> in the conversion of (x, y) to (r, theta)
* @see #atan(double)
*/
public static native double atan2(double y, double x);
 
/**
* Take <em>e</em><sup>a</sup>. The opposite of <code>log()</code>. If the
* argument is NaN, the result is NaN; if the argument is positive infinity,
* the result is positive infinity; and if the argument is negative
* infinity, the result is positive zero. This is accurate within 1 ulp,
* and is semi-monotonic.
*
* @param a the number to raise to the power
* @return the number raised to the power of <em>e</em>
* @see #log(double)
* @see #pow(double, double)
*/
public static native double exp(double a);
 
/**
* Take ln(a) (the natural log). The opposite of <code>exp()</code>. If the
* argument is NaN or negative, the result is NaN; if the argument is
* positive infinity, the result is positive infinity; and if the argument
* is either zero, the result is negative infinity. This is accurate within
* 1 ulp, and is semi-monotonic.
*
* <p>Note that the way to get log<sub>b</sub>(a) is to do this:
* <code>ln(a) / ln(b)</code>.
*
* @param a the number to take the natural log of
* @return the natural log of <code>a</code>
* @see #exp(double)
*/
public static native double log(double a);
 
/**
* Take a square root. If the argument is NaN or negative, the result is
* NaN; if the argument is positive infinity, the result is positive
* infinity; and if the result is either zero, the result is the same.
* This is accurate within the limits of doubles.
*
* <p>For other roots, use pow(a, 1 / rootNumber).
*
* @param a the numeric argument
* @return the square root of the argument
* @see #pow(double, double)
*/
public static native double sqrt(double a);
 
/**
* Raise a number to a power. Special cases:<ul>
* <li>If the second argument is positive or negative zero, then the result
* is 1.0.</li>
* <li>If the second argument is 1.0, then the result is the same as the
* first argument.</li>
* <li>If the second argument is NaN, then the result is NaN.</li>
* <li>If the first argument is NaN and the second argument is nonzero,
* then the result is NaN.</li>
* <li>If the absolute value of the first argument is greater than 1 and
* the second argument is positive infinity, or the absolute value of the
* first argument is less than 1 and the second argument is negative
* infinity, then the result is positive infinity.</li>
* <li>If the absolute value of the first argument is greater than 1 and
* the second argument is negative infinity, or the absolute value of the
* first argument is less than 1 and the second argument is positive
* infinity, then the result is positive zero.</li>
* <li>If the absolute value of the first argument equals 1 and the second
* argument is infinite, then the result is NaN.</li>
* <li>If the first argument is positive zero and the second argument is
* greater than zero, or the first argument is positive infinity and the
* second argument is less than zero, then the result is positive zero.</li>
* <li>If the first argument is positive zero and the second argument is
* less than zero, or the first argument is positive infinity and the
* second argument is greater than zero, then the result is positive
* infinity.</li>
* <li>If the first argument is negative zero and the second argument is
* greater than zero but not a finite odd integer, or the first argument is
* negative infinity and the second argument is less than zero but not a
* finite odd integer, then the result is positive zero.</li>
* <li>If the first argument is negative zero and the second argument is a
* positive finite odd integer, or the first argument is negative infinity
* and the second argument is a negative finite odd integer, then the result
* is negative zero.</li>
* <li>If the first argument is negative zero and the second argument is
* less than zero but not a finite odd integer, or the first argument is
* negative infinity and the second argument is greater than zero but not a
* finite odd integer, then the result is positive infinity.</li>
* <li>If the first argument is negative zero and the second argument is a
* negative finite odd integer, or the first argument is negative infinity
* and the second argument is a positive finite odd integer, then the result
* is negative infinity.</li>
* <li>If the first argument is less than zero and the second argument is a
* finite even integer, then the result is equal to the result of raising
* the absolute value of the first argument to the power of the second
* argument.</li>
* <li>If the first argument is less than zero and the second argument is a
* finite odd integer, then the result is equal to the negative of the
* result of raising the absolute value of the first argument to the power
* of the second argument.</li>
* <li>If the first argument is finite and less than zero and the second
* argument is finite and not an integer, then the result is NaN.</li>
* <li>If both arguments are integers, then the result is exactly equal to
* the mathematical result of raising the first argument to the power of
* the second argument if that result can in fact be represented exactly as
* a double value.</li>
*
* </ul><p>(In the foregoing descriptions, a floating-point value is
* considered to be an integer if and only if it is a fixed point of the
* method {@link #ceil(double)} or, equivalently, a fixed point of the
* method {@link #floor(double)}. A value is a fixed point of a one-argument
* method if and only if the result of applying the method to the value is
* equal to the value.) This is accurate within 1 ulp, and is semi-monotonic.
*
* @param a the number to raise
* @param b the power to raise it to
* @return a<sup>b</sup>
*/
public static native double pow(double a, double b);
 
/**
* Get the IEEE 754 floating point remainder on two numbers. This is the
* value of <code>x - y * <em>n</em></code>, where <em>n</em> is the closest
* double to <code>x / y</code> (ties go to the even n); for a zero
* remainder, the sign is that of <code>x</code>. If either argument is NaN,
* the first argument is infinite, or the second argument is zero, the result
* is NaN; if x is finite but y is infinite, the result is x. This is
* accurate within the limits of doubles.
*
* @param x the dividend (the top half)
* @param y the divisor (the bottom half)
* @return the IEEE 754-defined floating point remainder of x/y
* @see #rint(double)
*/
public static native double IEEEremainder(double x, double y);
 
/**
* Take the nearest integer that is that is greater than or equal to the
* argument. If the argument is NaN, infinite, or zero, the result is the
* same; if the argument is between -1 and 0, the result is negative zero.
* Note that <code>Math.ceil(x) == -Math.floor(-x)</code>.
*
* @param a the value to act upon
* @return the nearest integer &gt;= <code>a</code>
*/
public static native double ceil(double a);
 
/**
* Take the nearest integer that is that is less than or equal to the
* argument. If the argument is NaN, infinite, or zero, the result is the
* same. Note that <code>Math.ceil(x) == -Math.floor(-x)</code>.
*
* @param a the value to act upon
* @return the nearest integer &lt;= <code>a</code>
*/
public static native double floor(double a);
 
/**
* Take the nearest integer to the argument. If it is exactly between
* two integers, the even integer is taken. If the argument is NaN,
* infinite, or zero, the result is the same.
*
* @param a the value to act upon
* @return the nearest integer to <code>a</code>
*/
public static native double rint(double a);
 
/**
* <p>
* Take a cube root. If the argument is NaN, an infinity or zero, then
* the original value is returned. The returned result must be within 1 ulp
* of the exact result. For a finite value, <code>x</code>, the cube root
* of <code>-x</code> is equal to the negation of the cube root
* of <code>x</code>.
* </p>
* <p>
* For a square root, use <code>sqrt</code>. For other roots, use
* <code>pow(a, 1 / rootNumber)</code>.
* </p>
*
* @param a the numeric argument
* @return the cube root of the argument
* @see #sqrt(double)
* @see #pow(double, double)
*/
public static native double cbrt(double a);
 
/**
* <p>
* Returns the hyperbolic cosine of the given value. For a value,
* <code>x</code>, the hyperbolic cosine is <code>(e<sup>x</sup> +
* e<sup>-x</sup>)/2</code>
* with <code>e</code> being <a href="#E">Euler's number</a>. The returned
* result must be within 2.5 ulps of the exact result.
* </p>
* <p>
* If the supplied value is <code>NaN</code>, then the original value is
* returned. For either infinity, positive infinity is returned.
* The hyperbolic cosine of zero must be 1.0.
* </p>
*
* @param a the numeric argument
* @return the hyperbolic cosine of <code>a</code>.
* @since 1.5
*/
public static native double cosh(double a);
 
/**
* <p>
* Returns <code>e<sup>a</sup> - 1. For values close to 0, the
* result of <code>expm1(a) + 1</code> tend to be much closer to the
* exact result than simply <code>exp(x)</code>. The result must be within
* 1 ulp of the exact result, and results must be semi-monotonic. For finite
* inputs, the returned value must be greater than or equal to -1.0. Once
* a result enters within half a ulp of this limit, the limit is returned.
* </p>
* <p>
* For <code>NaN</code>, positive infinity and zero, the original value
* is returned. Negative infinity returns a result of -1.0 (the limit).
* </p>
*
* @param a the numeric argument
* @return <code>e<sup>a</sup> - 1</code>
* @since 1.5
*/
public static native double expm1(double a);
 
/**
* <p>
* Returns the hypotenuse, <code>a<sup>2</sup> + b<sup>2</sup></code>,
* without intermediate overflow or underflow. The returned result must be
* within 1 ulp of the exact result. If one parameter is held constant,
* then the result in the other parameter must be semi-monotonic.
* </p>
* <p>
* If either of the arguments is an infinity, then the returned result
* is positive infinity. Otherwise, if either argument is <code>NaN</code>,
* then <code>NaN</code> is returned.
* </p>
*
* @param a the first parameter.
* @param b the second parameter.
* @return the hypotenuse matching the supplied parameters.
* @since 1.5
*/
public static native double hypot(double a, double b);
 
/**
* <p>
* Returns the base 10 logarithm of the supplied value. The returned
* result must within 1 ulp of the exact result, and the results must be
* semi-monotonic.
* </p>
* <p>
* Arguments of either <code>NaN</code> or less than zero return
* <code>NaN</code>. An argument of positive infinity returns positive
* infinity. Negative infinity is returned if either positive or negative
* zero is supplied. Where the argument is the result of
* <code>10<sup>n</sup</code>, then <code>n</code> is returned.
* </p>
*
* @param a the numeric argument.
* @return the base 10 logarithm of <code>a</code>.
* @since 1.5
*/
public static native double log10(double a);
 
/**
* <p>
* Returns the natural logarithm resulting from the sum of the argument,
* <code>a</code> and 1. For values close to 0, the
* result of <code>log1p(a)</code> tend to be much closer to the
* exact result than simply <code>log(1.0+a)</code>. The returned
* result must be within 1 ulp of the exact result, and the results must be
* semi-monotonic.
* </p>
* <p>
* Arguments of either <code>NaN</code> or less than -1 return
* <code>NaN</code>. An argument of positive infinity or zero
* returns the original argument. Negative infinity is returned from an
* argument of -1.
* </p>
*
* @param a the numeric argument.
* @return the natural logarithm of <code>a</code> + 1.
* @since 1.5
*/
public static native double log1p(double a);
 
/**
* <p>
* Returns the hyperbolic sine of the given value. For a value,
* <code>x</code>, the hyperbolic sine is <code>(e<sup>x</sup> -
* e<sup>-x</sup>)/2</code>
* with <code>e</code> being <a href="#E">Euler's number</a>. The returned
* result must be within 2.5 ulps of the exact result.
* </p>
* <p>
* If the supplied value is <code>NaN</code>, an infinity or a zero, then the
* original value is returned.
* </p>
*
* @param a the numeric argument
* @return the hyperbolic sine of <code>a</code>.
* @since 1.5
*/
public static native double sinh(double a);
 
/**
* <p>
* Returns the hyperbolic tangent of the given value. For a value,
* <code>x</code>, the hyperbolic tangent is <code>(e<sup>x</sup> -
* e<sup>-x</sup>)/(e<sup>x</sup> + e<sup>-x</sup>)</code>
* (i.e. <code>sinh(a)/cosh(a)</code>)
* with <code>e</code> being <a href="#E">Euler's number</a>. The returned
* result must be within 2.5 ulps of the exact result. The absolute value
* of the exact result is always less than 1. Computed results are thus
* less than or equal to 1 for finite arguments, with results within
* half a ulp of either positive or negative 1 returning the appropriate
* limit value (i.e. as if the argument was an infinity).
* </p>
* <p>
* If the supplied value is <code>NaN</code> or zero, then the original
* value is returned. Positive infinity returns +1.0 and negative infinity
* returns -1.0.
* </p>
*
* @param a the numeric argument
* @return the hyperbolic tangent of <code>a</code>.
* @since 1.5
*/
public static native double tanh(double a);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMCompiler.java
0,0 → 1,112
/* VMClassLoader.java -- Reference implementation of compiler interface
Copyright (C) 2004 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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;
 
/**
* This class is just a per-VM reflection of java.lang.Compiler.
* All methods are defined identically.
*/
final class VMCompiler
{
/**
* Don't allow new `Compiler's to be made.
*/
private VMCompiler()
{
}
 
/**
* Compile the class named by <code>oneClass</code>.
*
* @param oneClass the class to compile
* @return <code>false</code> if no compiler is available or
* compilation failed, <code>true</code> if compilation succeeded
* @throws NullPointerException if oneClass is null
*/
public static boolean compileClass(Class oneClass)
{
// Never succeed.
return false;
}
 
/**
* Compile the classes whose name matches <code>classNames</code>.
*
* @param classNames the name of classes to compile
* @return <code>false</code> if no compiler is available or
* compilation failed, <code>true</code> if compilation succeeded
* @throws NullPointerException if classNames is null
*/
public static boolean compileClasses(String classNames)
{
// Note the incredibly lame interface. Always fail.
return false;
}
 
/**
* This method examines the argument and performs an operation
* according to the compilers documentation. No specific operation
* is required.
*
* @param arg a compiler-specific argument
* @return a compiler-specific value, including null
* @throws NullPointerException if the compiler doesn't like a null arg
*/
public static Object command(Object arg)
{
// Our implementation defines this to a no-op.
return null;
}
 
/**
* Calling <code>Compiler.enable()</code> will cause the compiler
* to resume operation if it was previously disabled; provided that a
* compiler even exists.
*/
public static void enable()
{
}
 
/**
* Calling <code>Compiler.disable()</code> will cause the compiler
* to be suspended; provided that a compiler even exists.
*/
public static void disable()
{
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/lang/VMDouble.java
0,0 → 1,115
/* VMDouble.java -- VM Specific Double methods
Copyright (C) 2003, 2005 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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 gnu.classpath.Configuration;
 
/*
* This class is a reference version, mainly for compiling a class library
* jar. It is likely that VM implementers replace this with their own
* version that can communicate effectively with the VM.
*/
 
/**
* Code relocated from java.lang.Double by
* @author Dave Grove (groved@us.ibm.com)
*/
final class VMDouble
{
 
/**
* Load native routines necessary for this class.
*/
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javalang");
}
 
initIDs();
}
 
/**
* Convert the double to the IEEE 754 floating-point "double format" bit
* layout. Bit 63 (the most significant) is the sign bit, bits 62-52
* (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0
* (masked by 0x000fffffffffffffL) are the mantissa. This function
* leaves NaN alone, rather than collapsing to a canonical value. The
* result of this function can be used as the argument to
* <code>Double.longBitsToDouble(long)</code> to obtain the original
* <code>double</code> value.
*
* @param value the <code>double</code> to convert
* @return the bits of the <code>double</code>
* @see #longBitsToDouble(long)
*/
public static native long doubleToRawLongBits(double value);
 
/**
* Convert the argument in IEEE 754 floating-point "double format" bit
* layout to the corresponding float. Bit 63 (the most significant) is the
* sign bit, bits 62-52 (masked by 0x7ff0000000000000L) represent the
* exponent, and bits 51-0 (masked by 0x000fffffffffffffL) are the mantissa.
* This function leaves NaN alone, so that you can recover the bit pattern
* with <code>Double.doubleToRawLongBits(double)</code>.
*
* @param bits the bits to convert
* @return the <code>double</code> represented by the bits
* @see #doubleToLongBits(double)
* @see #doubleToRawLongBits(double)
*/
public static native double longBitsToDouble(long bits);
 
/**
* Helper method to convert to string.
*
* @param d the double to convert
* @param isFloat true if the conversion is requested by Float (results in
* fewer digits)
*/
public static native String toString(double d, boolean isFloat);
 
/**
* Initialize JNI cache. This method is called only by the
* static initializer when using JNI.
*/
public static native void initIDs();
 
public static native double parseDouble(String str);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/nio/channels/VMChannels.java
0,0 → 1,116
/* VMChannels.java --
Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.nio.channels;
 
import gnu.java.nio.ChannelInputStream;
import gnu.java.nio.ChannelOutputStream;
import gnu.java.nio.FileChannelImpl;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
 
final class VMChannels
{
/**
* This class isn't intended to be instantiated.
*/
private VMChannels()
{
// Do nothing here.
}
 
private static Object createStream(Class streamClass, Channel ch)
{
try
{
Class[] argTypes = new Class[1];
argTypes[0] = FileChannelImpl.class;
Constructor constructor =
streamClass.getDeclaredConstructor(argTypes);
constructor.setAccessible(true);
Object[] args = new Object[1];
args[0] = ch;
return constructor.newInstance(args);
}
catch (IllegalAccessException e)
{
// Ignored.
}
catch (InstantiationException e)
{
// Ignored.
}
catch (InvocationTargetException e)
{
// Ignored.
}
catch (NoSuchMethodException e)
{
// Ignored.
}
 
return null;
}
 
/**
* Constructs a stream that reads bytes from the given channel.
*/
static InputStream newInputStream(ReadableByteChannel ch)
{
if (ch instanceof FileChannelImpl)
return (FileInputStream) createStream(FileInputStream.class, ch);
 
return new ChannelInputStream(ch);
}
 
/**
* Constructs a stream that writes bytes to the given channel.
*/
static OutputStream newOutputStream(WritableByteChannel ch)
{
if (ch instanceof FileChannelImpl)
return (FileOutputStream) createStream(FileOutputStream.class, ch);
 
return new ChannelOutputStream(ch);
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/nio/VMDirectByteBuffer.java
0,0 → 1,63
/* VMDirectByteBuffer.java --
Copyright (C) 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.nio;
 
import gnu.classpath.Configuration;
import gnu.classpath.Pointer;
 
final class VMDirectByteBuffer
{
static
{
// load the shared library needed for native methods.
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javanio");
}
}
 
static native Pointer allocate (int capacity);
static native void free(Pointer address);
static native byte get(Pointer address, int index);
static native void get(Pointer address, int index, byte[] dst, int offset, int length);
static native void put(Pointer address, int index, byte value);
static native void put(Pointer address, int index, byte[] src, int offset, int length);
static native Pointer adjustAddress(Pointer address, int offset);
static native void shiftDown(Pointer address, int dst_offset, int src_offset, int count);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/net/VMURLConnection.java
0,0 → 1,79
/* VMURLConnection - VM code for URLConnection
Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.net;
 
import gnu.classpath.Configuration;
 
import java.io.IOException;
import java.io.InputStream;
 
final class VMURLConnection
{
public static final int LENGTH = 1024;
 
static
{
if (Configuration.INIT_LOAD_LIBRARY)
System.loadLibrary("javanet");
init();
}
 
private static native void init();
 
private static native String guessContentTypeFromBuffer(byte[] b, int valid);
 
/**
* This is called from URLConnection to guess the mime type of a
* stream. This method may return null to indicate that it could
* not guess a type.
*/
static String guessContentTypeFromStream(InputStream is)
throws IOException
{
if (! is.markSupported())
return null;
is.mark(LENGTH);
byte[] bytes = new byte[LENGTH];
int r = is.read(bytes);
if (r < 0)
return null;
is.reset();
return guessContentTypeFromBuffer(bytes, r);
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/net/VMInetAddress.java
0,0 → 1,97
/* VMInetAddress.java -- Class to model an Internet address
Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.net;
 
import gnu.classpath.Configuration;
 
import java.io.Serializable;
 
class VMInetAddress implements Serializable
{
static
{
if (Configuration.INIT_LOAD_LIBRARY)
System.loadLibrary("javanet");
}
 
/**
* This method looks up the hostname of the local machine
* we are on. If the actual hostname cannot be determined, then the
* value "localhost" will be used. This native method wrappers the
* "gethostname" function.
*
* @return The local hostname.
*/
public static native String getLocalHostname();
 
/**
* Returns the value of the special address INADDR_ANY
*/
public static native byte[] lookupInaddrAny() throws UnknownHostException;
 
/**
* This method returns the hostname for a given IP address. It will
* throw an UnknownHostException if the hostname cannot be determined.
*
* @param ip The IP address as a byte array
*
* @return The hostname
*
* @exception UnknownHostException If the reverse lookup fails
*/
public static native String getHostByAddr(byte[] ip)
throws UnknownHostException;
 
/**
* Returns a list of all IP addresses for a given hostname. Will throw
* an UnknownHostException if the hostname cannot be resolved.
*/
public static native byte[][] getHostByName(String hostname)
throws UnknownHostException;
 
/**
* Return the IP address represented by a literal address.
* Will return null if the literal address is not valid.
*
* @param address the name of the host
*
* @return The IP address as a byte array
*/
public static native byte[] aton(String address);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/net/VMNetworkInterface.java
0,0 → 1,131
/* VMNetworkInterface.java --
Copyright (C) 2005, 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.net;
 
import gnu.classpath.Configuration;
 
import java.nio.ByteBuffer;
import java.util.HashSet;
import java.util.Set;
 
/**
* This class models a network interface on the host computer. A network
* interface contains a name (typically associated with a specific
* hardware adapter) and a list of addresses that are bound to it.
* For example, an ethernet interface may be named "eth0" and have the
* address 192.168.1.101 assigned to it.
*
* @author Michael Koch (konqueror@gmx.de)
* @since 1.4
*/
final class VMNetworkInterface
{
String name;
Set addresses;
 
VMNetworkInterface(String name)
{
this.name = name;
addresses = new HashSet();
}
 
/**
* Creates a dummy instance which represents any network
* interface.
*/
public VMNetworkInterface()
{
addresses = new HashSet();
try
{
addresses.add(InetAddress.getByName("0.0.0.0"));
}
catch (UnknownHostException _)
{
// Cannot happen.
}
}
 
static
{
if (Configuration.INIT_LOAD_LIBRARY)
System.loadLibrary("javanet");
 
initIds();
}
 
private static native void initIds();
 
/**
* Return a list of VM network interface objects.
*
* @return The list of network interfaces.
* @throws SocketException
*/
public static native VMNetworkInterface[] getVMInterfaces()
throws SocketException;
 
private void addAddress(ByteBuffer addr)
throws SocketException, UnknownHostException
{
if (addr.remaining() == 4)
{
byte[] ipv4 = new byte[4];
addr.get(ipv4);
addresses.add(Inet4Address.getByAddress(ipv4));
}
else if (addr.remaining() == 16)
{
byte[] ipv6 = new byte[16];
addr.get(ipv6);
addresses.add(Inet6Address.getByAddress(ipv6));
}
else
throw new SocketException("invalid interface address");
}
 
static native boolean isUp(String name) throws SocketException;
 
static native boolean isLoopback(String name) throws SocketException;
 
static native boolean isPointToPoint(String name) throws SocketException;
 
static native boolean supportsMulticast(String name) throws SocketException;
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/io/VMFile.java
0,0 → 1,367
/* VMFile.java -- Class for methods natively accessing files
Copyright (C) 2004, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.io;
 
import java.net.MalformedURLException;
import java.net.URL;
 
import gnu.classpath.Configuration;
import gnu.java.io.PlatformHelper;
 
 
/**
* @author Michael Koch (konqueror@gmx.de)
*/
final class VMFile
{
// FIXME: We support only case sensitive filesystems currently.
static final boolean IS_CASE_SENSITIVE = true;
static final boolean IS_DOS_8_3 = false;
 
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javaio");
}
}
 
/*
* This native method does the actual work of getting the last file
* modification time. It also does the existence check to avoid the
* overhead of a call to exists()
*/
static native long lastModified(String path);
 
/*
* This native method sets the permissions to make the file read only.
*/
static native boolean setReadOnly(String path);
 
/**
* This method is used to create a temporary file
*/
static native boolean create(String path) throws IOException;
 
/*
* This native function actually produces the list of files in this
* directory
*/
static native synchronized String[] list(String dirpath);
 
/*
* This native method actually performs the rename.
*/
static native boolean renameTo(String targetpath, String destpath);
 
/*
* This native method actually determines the length of the file and
* handles the existence check
*/
static native long length(String path);
 
/*
* This native method does the actual checking of file existence.
*/
static native boolean exists(String path);
 
/*
* This native method handles the actual deleting of the file
*/
static native boolean delete(String path);
 
/*
* This method does the actual setting of the modification time.
*/
static native boolean setLastModified(String path, long time);
 
/*
* This native method actually creates the directory
*/
static native boolean mkdir(String dirpath);
 
/**
* Gets the total bytes of the filesystem named by path.
*/
public static native long getTotalSpace(String path);
 
/**
* Gets the total free bytes of the filesystem named by path.
*/
public static native long getFreeSpace(String path);
 
/**
* Gets the available bytes of the filesystem named by path.
*/
public static native long getUsableSpace(String path);
 
/**
* Set the read permission of the file.
*/
public static synchronized native boolean setReadable(String path,
boolean readable,
boolean ownerOnly);
 
/**
* Set the write permission of the file.
*/
public static synchronized native boolean setWritable(String path,
boolean writable,
boolean ownerOnly);
 
/**
* Set the execute permission of the file.
*/
public static synchronized native boolean setExecutable(String path,
boolean executable,
boolean ownerOnly);
 
/*
* This native method does the actual check of whether or not a file
* is a plain file or not. It also handles the existence check to
* eliminate the overhead of a call to exists()
*/
static native boolean isFile(String path);
 
/**
* This native method checks file permissions for writing
*/
static synchronized native boolean canWrite(String path);
 
/**
* This methods checks if a directory can be written to.
*/
static native boolean canWriteDirectory(String path);
 
/**
* This native method checks file permissions for reading
*/
static synchronized native boolean canRead(String path);
 
/**
* This native method checks file permissions for execution
*/
static synchronized native boolean canExecute(String path);
 
/*
* This method does the actual check of whether or not a file is a
* directory or not. It also handle the existence check to eliminate
* the overhead of a call to exists()
*/
static native boolean isDirectory(String dirpath);
 
/**
* This methods checks if a directory can be written to.
*/
static boolean canWriteDirectory(File path)
{
return canWriteDirectory(path.getAbsolutePath());
}
 
/**
* This method returns an array of filesystem roots. Some operating systems
* have volume oriented filesystem. This method provides a mechanism for
* determining which volumes exist. GNU systems use a single hierarchical
* filesystem, so will have only one "/" filesystem root.
*
* @return An array of <code>File</code> objects for each filesystem root
* available.
*
* @since 1.2
*/
static File[] listRoots()
{
File[] roots = new File[1];
roots[0] = new File("/");
return roots;
}
 
/**
* This method tests whether or not this file represents a "hidden" file.
* On GNU systems, a file is hidden if its name begins with a "."
* character. Files with these names are traditionally not shown with
* directory listing tools.
*
* @return <code>true</code> if the file is hidden, <code>false</code>
* otherwise.
*
* @since 1.2
*/
static boolean isHidden(String path)
{
// FIXME: this only works on UNIX
return getName(path).startsWith(".");
}
 
/**
* This method returns the name of the file. This is everything in the
* complete path of the file after the last instance of the separator
* string.
*
* @return The file name
*/
static String getName(String path)
{
int pos = PlatformHelper.lastIndexOfSeparator(path);
if (pos == -1)
return path;
 
if (PlatformHelper.endWithSeparator(path))
return "";
 
return path.substring(pos + File.separator.length());
}
 
/**
* Returns the path as an absolute path name. The value returned is the
* current directory plus the separatory string plus the path of the file.
* The current directory is determined from the <code>user.dir</code> system
* property.
*
* @param path the path to convert to absolute path
*
* @return the absolute path that corresponds to <code>path</code>
*/
static String getAbsolutePath(String path)
{
if (File.separatorChar == '\\'
&& path.length() > 0 && path.charAt (0) == '\\')
{
// On Windows, even if the path starts with a '\\' it is not
// really absolute until we prefix the drive specifier from
// the current working directory to it.
return System.getProperty ("user.dir").substring (0, 2) + path;
}
else if (File.separatorChar == '\\'
&& path.length() > 1 && path.charAt (1) == ':'
&& ((path.charAt (0) >= 'a' && path.charAt (0) <= 'z')
|| (path.charAt (0) >= 'A' && path.charAt (0) <= 'Z')))
{
// On Windows, a process has a current working directory for
// each drive and a path like "G:foo\bar" would mean the
// absolute path "G:\wombat\foo\bar" if "\wombat" is the
// working directory on the G drive.
String drvDir = null;
try
{
drvDir = new File (path.substring (0, 2)).getCanonicalPath();
}
catch (IOException e)
{
drvDir = path.substring (0, 2) + "\\";
}
 
// Note: this would return "C:\\." for the path "C:.", if "\"
// is the working folder on the C drive, but this is
// consistent with what Sun's JRE 1.4.1.01 actually returns!
if (path.length() > 2)
return drvDir + '\\' + path.substring (2, path.length());
else
return drvDir;
}
else if (path.equals(""))
return System.getProperty ("user.dir");
else
return System.getProperty ("user.dir") + File.separatorChar + path;
}
 
/**
* This method returns true if the path represents an absolute file
* path and false if it does not. The definition of an absolute path varies
* by system. As an example, on GNU systems, a path is absolute if it starts
* with a "/".
*
* @param path the path to check
*
* @return <code>true</code> if path represents an absolute file name,
* <code>false</code> otherwise.
*/
static boolean isAbsolute(String path)
{
if (File.separatorChar == '\\')
return path.startsWith(File.separator + File.separator)
|| (path.length() > 2
&& ((path.charAt(0) >= 'a' && path.charAt(0) <= 'z')
|| (path.charAt(0) >= 'A' && path.charAt(0) <= 'Z'))
&& path.charAt(1) == ':'
&& path.charAt(2) == '\\');
else
return path.startsWith(File.separator);
}
 
/**
* Returns a <code>URL</code> with the <code>file:</code>
* protocol that represents this file. The exact form of this URL is
* system dependent.
*
* @param file the file to convert to URL
*
* @return a <code>URL</code> for this object.
*
* @throws MalformedURLException if the URL cannot be created
* successfully.
*/
static URL toURL(File file)
throws MalformedURLException
{
// On Win32, Sun's JDK returns URLs of the form "file:/c:/foo/bar.txt",
// while on UNIX, it returns URLs of the form "file:/foo/bar.txt".
if (File.separatorChar == '\\')
return new URL ("file:/" + file.getAbsolutePath().replace ('\\', '/')
+ (file.isDirectory() ? "/" : ""));
else
return new URL ("file:" + file.getAbsolutePath()
+ (file.isDirectory() ? "/" : ""));
}
 
/**
* This method returns a canonical representation of the pathname of
* this file. The actual form of the canonical representation is
* system-dependent. On the GNU system, conversion to canonical
* form involves the removal of redundant separators, references to
* "." and "..", and symbolic links.
* <p>
* Note that this method, unlike the other methods which return path
* names, can throw an IOException. This is because native method
* might be required in order to resolve the canonical path
*
* @exception IOException If an error occurs
*/
public static native String toCanonicalForm(String path) throws IOException;
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/io/VMObjectInputStream.java
0,0 → 1,64
/* ObjectInputStream.java -- Class used to read serialized objects
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005
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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.io;
 
import gnu.classpath.Configuration;
import java.lang.reflect.Constructor;
 
final class VMObjectInputStream
{
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javaio");
}
}
 
/**
* Allocates a new Object of type clazz but without running the
* default constructor on it. It then calls the given constructor on
* it. The given constructor method comes from the constr_clazz
* which is a super class of the given clazz.
*/
static native Object allocateObject(Class clazz, Class constr_clazz,
Constructor constructor)
throws InstantiationException;
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/io/VMObjectStreamClass.java
0,0 → 1,168
/* VMObjectStreamClass.java -- VM helper functions for ObjectStreamClass
Copyright (C) 2003, 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.io;
 
import gnu.classpath.Configuration;
import java.lang.reflect.Field;
 
final class VMObjectStreamClass
{
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javaio");
}
}
 
/**
* Returns true if CLAZZ has a static class initializer
* (a.k.a. <clinit>).
*/
static native boolean hasClassInitializer (Class clazz);
 
/**
* Sets the value of the specified field. This method handles "double".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setDoubleNative(Field field, Object obj, double val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "float".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setFloatNative(Field field, Object obj, float val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "long".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setLongNative(Field field, Object obj, long val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "int".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setIntNative(Field field, Object obj, int val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "short".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setShortNative(Field field, Object obj, short val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "char".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setCharNative(Field field, Object obj, char val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "byte".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setByteNative(Field field, Object obj, byte val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "boolean".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setBooleanNative(Field field, Object obj, boolean val)
throws InternalError;
 
/**
* Sets the value of the specified field. This method handles "object".
* Warning ! The types are not truely checked here and final values may be
* assigned.
*
* @param field Field to set the value.
* @param obj Instance which will have its field set.
* @param val Value to put in the field.
*/
static native void setObjectNative(Field field, Object obj, Object val)
throws InternalError;
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/security/VMAccessController.java
0,0 → 1,280
/* VMAccessController.java -- VM-specific access controller methods.
Copyright (C) 2004, 2005 Free Software Foundation, Inc.
 
This program 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 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 for more details.
 
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.security;
 
import java.util.HashSet;
import java.util.LinkedList;
 
final class VMAccessController
{
 
// Fields.
// -------------------------------------------------------------------------
 
/**
* This is a per-thread stack of AccessControlContext objects (which can
* be null) for each call to AccessController.doPrivileged in each thread's
* call stack. We use this to remember which context object corresponds to
* which call.
*/
private static final ThreadLocal contexts = new ThreadLocal();
 
/**
* This is a Boolean that, if set, tells getContext that it has already
* been called once, allowing us to handle recursive permission checks
* caused by methods getContext calls.
*/
private static final ThreadLocal inGetContext = new ThreadLocal();
 
/**
* And we return this all-permissive context to ensure that privileged
* methods called from getContext succeed.
*/
private static final AccessControlContext DEFAULT_CONTEXT;
static
{
CodeSource source = new CodeSource(null, null);
Permissions permissions = new Permissions();
permissions.add(new AllPermission());
ProtectionDomain[] domain = new ProtectionDomain[] {
new ProtectionDomain(source, permissions)
};
DEFAULT_CONTEXT = new AccessControlContext(domain);
}
 
private static final boolean DEBUG = gnu.classpath.Configuration.DEBUG;
private static void debug(String msg)
{
System.err.print(">>> VMAccessController: ");
System.err.println(msg);
}
 
// Constructors.
// -------------------------------------------------------------------------
 
private VMAccessController() { }
 
// Class methods.
// -------------------------------------------------------------------------
 
/**
* Relate a class (which should be an instance of {@link PrivilegedAction}
* with an access control context. This method is used by {@link
* AccessController#doPrivileged(java.security.PrivilegedAction,java.security.AccessControlContext)}
* to set up the context that will be returned by {@link #getContext()}.
* This method relates the class to the current thread, so contexts
* pushed from one thread will not be available to another.
*
* @param acc The access control context.
*/
static void pushContext (AccessControlContext acc)
{
if (DEBUG)
debug("pushing " + acc);
LinkedList stack = (LinkedList) contexts.get();
if (stack == null)
{
if (DEBUG)
debug("no stack... creating ");
stack = new LinkedList();
contexts.set(stack);
}
stack.addFirst(acc);
}
 
/**
* Removes the relation of a class to an {@link AccessControlContext}.
* This method is used by {@link AccessController} when exiting from a
* call to {@link
* AccessController#doPrivileged(java.security.PrivilegedAction,java.security.AccessControlContext)}.
*/
static void popContext()
{
if (DEBUG)
debug("popping context");
 
// Stack should never be null, nor should it be empty, if this method
// and its counterpart has been called properly.
LinkedList stack = (LinkedList) contexts.get();
if (stack != null)
{
stack.removeFirst();
if (stack.isEmpty())
contexts.set(null);
}
else if (DEBUG)
{
debug("no stack during pop?????");
}
}
 
/**
* Examine the method stack of the currently running thread, and create
* an {@link AccessControlContext} filled in with the appropriate {@link
* ProtectionDomain} objects given this stack.
*
* @return The context.
*/
static AccessControlContext getContext()
{
// If we are already in getContext, but called a method that needs
// a permission check, return the all-permissive context so methods
// called from here succeed.
//
// XXX is this necessary? We should verify if there are any calls in
// the stack below this method that require permission checks.
Boolean inCall = (Boolean) inGetContext.get();
if (inCall != null && inCall.booleanValue())
{
if (DEBUG)
debug("already in getContext");
return DEFAULT_CONTEXT;
}
 
inGetContext.set(Boolean.TRUE);
 
Object[][] stack = getStack();
Class[] classes = (Class[]) stack[0];
String[] methods = (String[]) stack[1];
 
if (DEBUG)
debug("got trace of length " + classes.length);
 
HashSet domains = new HashSet();
HashSet seenDomains = new HashSet();
AccessControlContext context = null;
int privileged = 0;
 
// We walk down the stack, adding each ProtectionDomain for each
// class in the call stack. If we reach a call to doPrivileged,
// we don't add any more stack frames. We skip the first three stack
// frames, since they comprise the calls to getStack, getContext,
// and AccessController.getContext.
for (int i = 3; i < classes.length && privileged < 2; i++)
{
Class clazz = classes[i];
String method = methods[i];
 
if (DEBUG)
{
debug("checking " + clazz + "." + method);
// subject to getClassLoader RuntimePermission
debug("loader = " + clazz.getClassLoader());
}
 
// If the previous frame was a call to doPrivileged, then this is
// the last frame we look at.
if (privileged == 1)
privileged = 2;
 
if (clazz.equals (AccessController.class)
&& method.equals ("doPrivileged"))
{
// If there was a call to doPrivileged with a supplied context,
// return that context. If using JAAS doAs*, it should be
// a context with a SubjectDomainCombiner
LinkedList l = (LinkedList) contexts.get();
if (l != null)
context = (AccessControlContext) l.getFirst();
privileged = 1;
}
 
// subject to getProtectionDomain RuntimePermission
ProtectionDomain domain = clazz.getProtectionDomain();
 
if (domain == null)
continue;
if (seenDomains.contains(domain))
continue;
seenDomains.add(domain);
 
// Create a static snapshot of this domain, which may change over time
// if the current policy changes.
domains.add(new ProtectionDomain(domain.getCodeSource(),
domain.getPermissions()));
}
 
if (DEBUG)
debug("created domains: " + domains);
 
ProtectionDomain[] result = (ProtectionDomain[])
domains.toArray(new ProtectionDomain[domains.size()]);
 
if (context != null)
{
DomainCombiner dc = context.getDomainCombiner ();
// If the supplied context had no explicit DomainCombiner, use
// our private version, which computes the intersection of the
// context's domains with the derived set.
if (dc == null)
context = new AccessControlContext
(IntersectingDomainCombiner.SINGLETON.combine
(result, context.getProtectionDomains ()));
// Use the supplied DomainCombiner. This should be secure,
// because only trusted code may create an
// AccessControlContext with a custom DomainCombiner.
else
context = new AccessControlContext (result, context, dc);
}
// No context was supplied. Return the derived one.
else
context = new AccessControlContext (result);
 
inGetContext.set(Boolean.FALSE);
return context;
}
 
/**
* Returns a snapshot of the current call stack as a pair of arrays:
* the first an array of classes in the call stack, the second an array
* of strings containing the method names in the call stack. The two
* arrays match up, meaning that method <i>i</i> is declared in class
* <i>i</i>. The arrays are clean; it will only contain Java methods,
* and no element of the list should be null.
*
* <p>The default implementation returns an empty stack, which will be
* interpreted as having no permissions whatsoever.
*
* @return A pair of arrays describing the current call stack. The first
* element is an array of Class objects, and the second is an array
* of Strings comprising the method names.
*/
private static Object[][] getStack()
{
return new Object[][] { new Class[0], new String[0] };
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/security/VMSecureRandom.java
0,0 → 1,129
/* VMSecureRandom.java -- random seed generator.
Copyright (C) 2006 Free Software Foundation, Inc.
 
This file is a 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 of the License, 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; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
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.security;
 
/**
* VM-specific methods for generating real (or almost real) random
* seeds. VM implementors should write a version of this class that
* reads random bytes from some system source.
*
* <p>The default implementation of this class runs eight threads that
* increment counters in a tight loop, and XORs each counter to
* produce one byte of seed data. This is not very efficient, and is
* not guaranteed to be random (the thread scheduler is probably
* deterministic, after all). If possible, VM implementors should
* reimplement this class so it obtains a random seed from a system
* facility, such as a system entropy gathering device or hardware
* random number generator.
*/
final class VMSecureRandom
{
 
/**
* Generate a random seed. Implementations are free to generate
* fewer random bytes than are requested, and leave the remaining
* bytes of the destination buffer as zeros. Implementations SHOULD,
* however, make a best-effort attempt to satisfy the request.
*
* @param buffer The destination buffer.
* @param offset The offset in the buffer to start putting bytes.
* @param length The number of random bytes to generate.
*/
static int generateSeed(byte[] buffer, int offset, int length)
{
if (length < 0)
throw new IllegalArgumentException("length must be nonnegative");
if (offset < 0 || offset + length > buffer.length)
throw new IndexOutOfBoundsException();
 
Spinner[] spinners = new Spinner[8];
int n = 0x1;
for (int i = 0; i < spinners.length; i++)
{
spinners[i] = new Spinner((byte) n);
Thread t = new Thread(spinners[i]);
t.start();
n <<= 1;
}
 
// Wait until at least one spinner has started.
while (!(spinners[0].running || spinners[1].running || spinners[2].running
|| spinners[3].running || spinners[4].running || spinners[5].running
|| spinners[6].running || spinners[7].running))
{
Thread.yield();
}
 
for (int i = offset; i < length; i++)
{
buffer[i] = (byte) (spinners[0].value ^ spinners[1].value ^ spinners[2].value
^ spinners[3].value ^ spinners[4].value ^ spinners[5].value
^ spinners[6].value ^ spinners[7].value);
Thread.yield();
}
 
for (int i = 0; i < spinners.length; i++)
spinners[i].stop();
 
return length;
}
 
static class Spinner implements Runnable
{
volatile byte value;
volatile boolean running;
 
Spinner(final byte initial)
{
value = initial;
}
 
public void run()
{
running = true;
while (running)
value++;
}
 
private void stop()
{
running = false;
}
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/java/util/VMTimeZone.java
0,0 → 1,300
/* java.util.VMTimeZone
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.util;
 
import gnu.classpath.Configuration;
import gnu.classpath.SystemProperties;
import gnu.java.util.ZoneInfo;
import java.util.TimeZone;
 
import java.io.*;
 
/**
*
*/
final class VMTimeZone
{
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javautil");
}
}
 
/**
* This method returns a time zone id string which is in the form
* (standard zone name) or (standard zone name)(GMT offset) or
* (standard zone name)(GMT offset)(daylight time zone name). The
* GMT offset can be in seconds, or where it is evenly divisible by
* 3600, then it can be in hours. The offset must be the time to
* add to the local time to get GMT. If a offset is given and the
* time zone observes daylight saving then the (daylight time zone
* name) must also be given (otherwise it is assumed the time zone
* does not observe any daylight savings).
* <p>
* The result of this method is given to the method
* TimeZone.getDefaultTimeZone(String) which tries to map the time
* zone id to a known TimeZone. See that method on how the returned
* String is mapped to a real TimeZone object.
* <p>
* The reference implementation which is made for GNU/Posix like
* systems calls <code>System.getenv("TZ")</code>,
* <code>readTimeZoneFile("/etc/timezone")</code>,
* <code>ZoneInfo.readTZFile((String)null, "/etc/localtime")</code>
* and finally <code>getSystemTimeZoneId()</code> till a supported
* TimeZone is found through
* <code>TimeZone.getDefaultTimeZone(String)</code>.
* If every method fails <code>null</code> is returned (which means
* the TimeZone code will fall back on GMT as default time zone).
* <p>
* Note that this method is called inside a
* <code>AccessController.doPrivileged()</code> block and runs with
* the priviliges of the java.util system classes. It will only be
* called when the default time zone is not yet set, the system
* property user.timezone isn't set and it is requested for the
* first time.
*/
static TimeZone getDefaultTimeZoneId()
{
TimeZone zone = null;
 
// See if TZ environment variable is set and accessible.
String tzid = System.getenv("TZ");
if (tzid != null && !tzid.equals(""))
zone = TimeZone.getDefaultTimeZone(tzid);
 
// Try to parse /etc/timezone.
if (zone == null)
{
tzid = readTimeZoneFile("/etc/timezone");
if (tzid != null && !tzid.equals(""))
zone = TimeZone.getDefaultTimeZone(tzid);
}
 
// Try to parse /etc/localtime
if (zone == null)
{
zone = ZoneInfo.readTZFile((String) null, "/etc/localtime");
if (zone != null)
{
// Try to find a more suitable ID for the /etc/localtime
// timezone.
// Sometimes /etc/localtime is a symlink to some
// /usr/share/zoneinfo/ file.
String id = null;
try
{
id = new File("/etc/localtime").getCanonicalPath();
if (id != null)
{
String zoneinfo_dir
= SystemProperties.getProperty("gnu.java.util.zoneinfo.dir");
if (zoneinfo_dir != null)
zoneinfo_dir
= new File(zoneinfo_dir
+ File.separatorChar).getCanonicalPath();
if (zoneinfo_dir != null && id.startsWith(zoneinfo_dir))
{
int pos = zoneinfo_dir.length();
while (pos < id.length()
&& id.charAt(pos) == File.separatorChar)
pos++;
if (pos < id.length())
id = id.substring(pos);
else
id = null;
}
else
id = null;
}
}
catch (IOException ioe)
{
id = null;
}
 
if (id == null)
id = readSysconfigClockFile("/etc/sysconfig/clock");
 
if (id != null)
zone.setID(id);
}
}
 
// Try some system specific way
if (zone == null)
{
tzid = getSystemTimeZoneId();
if (tzid != null && !tzid.equals(""))
zone = TimeZone.getDefaultTimeZone(tzid);
}
 
return zone;
}
 
/**
* Tries to read the time zone name from a file. Only the first
* consecutive letters, digits, slashes, dashes and underscores are
* read from the file. If the file cannot be read or an IOException
* occurs null is returned.
* <p>
* The /etc/timezone file is not standard, but a lot of systems have
* it. If it exist the first line always contains a string
* describing the timezone of the host of domain. Some systems
* contain a /etc/TIMEZONE file which is used to set the TZ
* environment variable (which is checked before /etc/timezone is
* read).
*/
private static String readTimeZoneFile(String file)
{
File f = new File(file);
if (!f.exists())
return null;
 
InputStreamReader isr = null;
try
{
FileInputStream fis = new FileInputStream(f);
BufferedInputStream bis = new BufferedInputStream(fis);
isr = new InputStreamReader(bis);
 
StringBuffer sb = new StringBuffer();
int i = isr.read();
while (i != -1)
{
char c = (char) i;
if (Character.isLetter(c) || Character.isDigit(c)
|| c == '/' || c == '-' || c == '_')
{
sb.append(c);
i = isr.read();
}
else
break;
}
return sb.toString();
}
catch (IOException ioe)
{
// Parse error, not a proper tzfile.
return null;
}
finally
{
try
{
if (isr != null)
isr.close();
}
catch (IOException ioe)
{
// Error while close, nothing we can do.
}
}
}
 
/**
* Tries to read the time zone name from a file.
* If the file cannot be read or an IOException occurs null is returned.
* <p>
* The /etc/sysconfig/clock file is not standard, but a lot of systems
* have it. The file is included by shell scripts and the timezone
* name is defined in ZONE variable.
* This routine should grok it with or without quotes:
* ZONE=America/New_York
* or
* ZONE="Europe/London"
*/
private static String readSysconfigClockFile(String file)
{
BufferedReader br = null;
try
{
FileInputStream fis = new FileInputStream(file);
BufferedInputStream bis = new BufferedInputStream(fis);
br = new BufferedReader(new InputStreamReader(bis));
 
for (String line = br.readLine(); line != null; line = br.readLine())
{
line = line.trim();
if (line.length() < 8 || !line.startsWith("ZONE="))
continue;
int posstart = 6;
int posend;
if (line.charAt(5) == '"')
posend = line.indexOf('"', 6);
else if (line.charAt(5) == '\'')
posend = line.indexOf('\'', 6);
else
{
posstart = 5;
posend = line.length();
}
if (posend < 0)
return null;
return line.substring(posstart, posend);
}
return null;
}
catch (IOException ioe)
{
// Parse error, not a proper tzfile.
return null;
}
finally
{
try
{
if (br != null)
br.close();
}
catch (IOException ioe)
{
// Error while close, nothing we can do.
}
}
}
 
/**
* Tries to get the system time zone id through native code.
*/
private static native String getSystemTimeZoneId();
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/sun/reflect/Reflection.java
0,0 → 1,51
/* Reflection.java - JSR 166 reflection hooks
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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 sun.reflect;
 
import gnu.classpath.VMStackWalker;
 
public class Reflection
{
/**
* A stack-walking wrapper method used by the JSR 166 RI.
*/
public static Class getCallerClass(int depth)
{
return VMStackWalker.getClassContext()[depth];
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/sun/reflect/misc/ReflectUtil.java
0,0 → 1,113
/* ReflectUtil.java - JSR 166 reflection hooks
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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 sun.reflect.misc;
 
import java.lang.reflect.Modifier;
 
public class ReflectUtil
{
// We use this inaccessible inner class as an argument type
// in verifyMemberAccess. All current users of this method
// in the JSR 166 RI pass 'null' for this argument, and
// consequently we don't know what it means. Using a funny
// type like this for the argument means that if the RI changes,
// we will see a compilation error.
private static class MustBeNull
{
}
 
/**
* Check if the current thread is allowed to access the package of
* the declaringClass.
*
* @param declaringClass class name to check access to
* @throws SecurityException if permission is denied
* @throws NullPointerException if declaringClass is null
*/
public static void checkPackageAccess(Class declaringClass)
{
SecurityManager sm;
if ((sm = System.getSecurityManager()) != null)
{
while (declaringClass.isArray())
declaringClass = declaringClass.getComponentType();
String name = declaringClass.getName();
int i = name.lastIndexOf('.');
if (i != -1) // if declaringClass is a member of a package
{
name = name.substring(0, i);
sm.checkPackageAccess(name);
}
}
}
 
/**
* Perform access checks on a member of a class. This API is
* derived from the public domain code in the JSR 166 reference
* implementation.
* @param caller the class requesting access to the member
* @param declarer the declaring class of the member
* @param ignored unknown parameter; always null
* @param modifiers the modifiers on the member
* @return true if access is granted, false otherwise
*/
public static void ensureMemberAccess(Class caller,
Class declarer,
MustBeNull ignored,
int modifiers)
{
// Same class, always ok.
if (caller == declarer)
return;
// Public access is ok.
if ((modifiers & Modifier.PUBLIC) != 0)
return;
// Protected access and request comes from
// a subclass of the declarer -- ok.
if ((modifiers & Modifier.PROTECTED) != 0
&& declarer.isAssignableFrom(caller))
return;
// Package-private access, or protected access,
// and the packages are the same --ok.
if ((modifiers & Modifier.PRIVATE) == 0
&& caller.getPackage() == declarer.getPackage())
return;
// Otherwise, no.
throw new IllegalAccessError();
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/sun/misc/Unsafe.java
0,0 → 1,328
/* Unsafe.java - Unsafe operations needed for concurrency
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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 sun.misc;
 
import java.lang.reflect.Field;
 
/**
* This class should provide access to low-level operations and its
* use should be limited to trusted code. Fields can be accessed using
* memory addresses, with undefined behaviour occurring if invalid memory
* addresses are given.
*
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
*/
public class Unsafe
{
// Singleton class.
private static Unsafe unsafe = new Unsafe();
 
/**
* Private default constructor to prevent creation of an arbitrary
* number of instances.
*/
private Unsafe()
{
}
 
/**
* Retrieve the singleton instance of <code>Unsafe</code>. The calling
* method should guard this instance from untrusted code, as it provides
* access to low-level operations such as direct memory access.
*
* @throws SecurityException if a security manager exists and prevents
* access to the system properties.
*/
public static Unsafe getUnsafe()
{
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPropertiesAccess();
return unsafe;
}
 
/**
* Returns the memory address offset of the given static field.
* The offset is merely used as a means to access a particular field
* in the other methods of this class. The value is unique to the given
* field and the same value should be returned on each subsequent call.
*
* @param field the field whose offset should be returned.
* @return the offset of the given field.
*/
public native long objectFieldOffset(Field field);
 
/**
* Compares the value of the integer field at the specified offset
* in the supplied object with the given expected value, and updates
* it if they match. The operation of this method should be atomic,
* thus providing an uninterruptible way of updating an integer field.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the integer field within <code>obj</code>.
* @param expect the expected value of the field.
* @param update the new value of the field if it equals <code>expect</code>.
* @return true if the field was changed.
*/
public native boolean compareAndSwapInt(Object obj, long offset,
int expect, int update);
 
/**
* Compares the value of the long field at the specified offset
* in the supplied object with the given expected value, and updates
* it if they match. The operation of this method should be atomic,
* thus providing an uninterruptible way of updating a long field.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the long field within <code>obj</code>.
* @param expect the expected value of the field.
* @param update the new value of the field if it equals <code>expect</code>.
* @return true if the field was changed.
*/
public native boolean compareAndSwapLong(Object obj, long offset,
long expect, long update);
 
/**
* Compares the value of the object field at the specified offset
* in the supplied object with the given expected value, and updates
* it if they match. The operation of this method should be atomic,
* thus providing an uninterruptible way of updating an object field.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the object field within <code>obj</code>.
* @param expect the expected value of the field.
* @param update the new value of the field if it equals <code>expect</code>.
* @return true if the field was changed.
*/
public native boolean compareAndSwapObject(Object obj, long offset,
Object expect, Object update);
 
/**
* Sets the value of the integer field at the specified offset in the
* supplied object to the given value. This is an ordered or lazy
* version of <code>putIntVolatile(Object,long,int)</code>, which
* doesn't guarantee the immediate visibility of the change to other
* threads. It is only really useful where the integer field is
* <code>volatile</code>, and is thus expected to change unexpectedly.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the integer field within <code>obj</code>.
* @param value the new value of the field.
* @see #putIntVolatile(Object,long,int)
*/
public native void putOrderedInt(Object obj, long offset, int value);
 
/**
* Sets the value of the long field at the specified offset in the
* supplied object to the given value. This is an ordered or lazy
* version of <code>putLongVolatile(Object,long,long)</code>, which
* doesn't guarantee the immediate visibility of the change to other
* threads. It is only really useful where the long field is
* <code>volatile</code>, and is thus expected to change unexpectedly.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the long field within <code>obj</code>.
* @param value the new value of the field.
* @see #putLongVolatile(Object,long,long)
*/
public native void putOrderedLong(Object obj, long offset, long value);
 
/**
* Sets the value of the object field at the specified offset in the
* supplied object to the given value. This is an ordered or lazy
* version of <code>putObjectVolatile(Object,long,Object)</code>, which
* doesn't guarantee the immediate visibility of the change to other
* threads. It is only really useful where the object field is
* <code>volatile</code>, and is thus expected to change unexpectedly.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the object field within <code>obj</code>.
* @param value the new value of the field.
*/
public native void putOrderedObject(Object obj, long offset, Object value);
 
/**
* Sets the value of the integer field at the specified offset in the
* supplied object to the given value, with volatile store semantics.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the integer field within <code>obj</code>.
* @param value the new value of the field.
*/
public native void putIntVolatile(Object obj, long offset, int value);
 
/**
* Retrieves the value of the integer field at the specified offset in the
* supplied object with volatile load semantics.
*
* @param obj the object containing the field to read.
* @param offset the offset of the integer field within <code>obj</code>.
*/
public native int getIntVolatile(Object obj, long offset);
 
/**
* Sets the value of the long field at the specified offset in the
* supplied object to the given value, with volatile store semantics.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the long field within <code>obj</code>.
* @param value the new value of the field.
* @see #putLong(Object,long,long)
*/
public native void putLongVolatile(Object obj, long offset, long value);
 
/**
* Sets the value of the long field at the specified offset in the
* supplied object to the given value.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the long field within <code>obj</code>.
* @param value the new value of the field.
* @see #putLongVolatile(Object,long,long)
*/
public native void putLong(Object obj, long offset, long value);
 
/**
* Retrieves the value of the long field at the specified offset in the
* supplied object with volatile load semantics.
*
* @param obj the object containing the field to read.
* @param offset the offset of the long field within <code>obj</code>.
* @see #getLong(Object,long)
*/
public native long getLongVolatile(Object obj, long offset);
 
/**
* Retrieves the value of the long field at the specified offset in the
* supplied object.
*
* @param obj the object containing the field to read.
* @param offset the offset of the long field within <code>obj</code>.
* @see #getLongVolatile(Object,long)
*/
public native long getLong(Object obj, long offset);
 
/**
* Sets the value of the object field at the specified offset in the
* supplied object to the given value, with volatile store semantics.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the object field within <code>obj</code>.
* @param value the new value of the field.
* @see #putObject(Object,long,Object)
*/
public native void putObjectVolatile(Object obj, long offset, Object value);
 
/**
* Sets the value of the object field at the specified offset in the
* supplied object to the given value.
*
* @param obj the object containing the field to modify.
* @param offset the offset of the object field within <code>obj</code>.
* @param value the new value of the field.
* @see #putObjectVolatile(Object,long,Object)
*/
public native void putObject(Object obj, long offset, Object value);
 
/**
* Retrieves the value of the object field at the specified offset in the
* supplied object with volatile load semantics.
*
* @param obj the object containing the field to read.
* @param offset the offset of the object field within <code>obj</code>.
*/
public native Object getObjectVolatile(Object obj, long offset);
 
/**
* Returns the offset of the first element for a given array class.
* To access elements of the array class, this value may be used along
* with that returned by
* <a href="#arrayIndexScale"><code>arrayIndexScale</code></a>,
* if non-zero.
*
* @param arrayClass the class for which the first element's address should
* be obtained.
* @return the offset of the first element of the array class.
* @see arrayIndexScale(Class)
*/
public native int arrayBaseOffset(Class arrayClass);
 
/**
* Returns the scale factor used for addressing elements of the supplied
* array class. Where a suitable scale factor can not be returned (e.g.
* for primitive types), zero should be returned. The returned value
* can be used with
* <a href="#arrayBaseOffset"><code>arrayBaseOffset</code></a>
* to access elements of the class.
*
* @param arrayClass the class whose scale factor should be returned.
* @return the scale factor, or zero if not supported for this array class.
*/
public native int arrayIndexScale(Class arrayClass);
 
/**
* Releases the block on a thread created by
* <a href="#park"><code>park</code></a>. This method can also be used
* to terminate a blockage caused by a prior call to <code>park</code>.
* This operation is unsafe, as the thread must be guaranteed to be
* live. This is true of Java, but not native code.
*
* @param thread the thread to unblock.
*/
public native void unpark(Object thread);
 
/**
* Blocks the thread until a matching
* <a href="#unpark"><code>unpark</code></a> occurs, the thread is
* interrupted or the optional timeout expires. If an <code>unpark</code>
* call has already occurred, this also counts. A timeout value of zero
* is defined as no timeout. When <code>isAbsolute</code> is
* <code>true</code>, the timeout is in milliseconds relative to the
* epoch. Otherwise, the value is the number of nanoseconds which must
* occur before timeout. This call may also return spuriously (i.e.
* for no apparent reason).
*
* @param isAbsolute true if the timeout is specified in milliseconds from
* the epoch.
* @param time either the number of nanoseconds to wait, or a time in
* milliseconds from the epoch to wait for.
*/
public native void park(boolean isAbsolute, long time);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/VMCPStringBuilder.java
0,0 → 1,112
/* VMCPStringBuilder.java -- Growable strings without locking or copying
Copyright (C) 2008 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
 
/**
* This class provides VM support for CPStringBuilder
* by allowing the package-private constructor
* of java.lang.String to be invoked. The default
* implementation uses reflection. VMs may replace
* this class with a more efficient version.
*/
final class VMCPStringBuilder
{
 
/**
* The package-private constructor for String objects without copying.
*/
private static final Constructor cons;
 
static
{
try
{
cons = String.class.getDeclaredConstructor(new Class[] { char[].class,
Integer.TYPE,
Integer.TYPE,
Boolean.TYPE });
cons.setAccessible(true);
}
catch (NoSuchMethodException e)
{
throw (Error)
new InternalError("Could not get no-copy String constructor").initCause(e);
}
}
 
/**
* Convert this <code>StringBuilder</code> to a <code>String</code>. The
* String is composed of the characters currently in this StringBuilder. Note
* that the result is not a copy, so the builder will allocate a new array
* if a further write operation is attempted.
*
* @param value the buffered characters.
* @param startIndex the index at which to start taking characters from the buffer.
* @param count the number of characters used in the buffer.
* @return the characters in this StringBuilder
*/
public static String toString(char[] value, int startIndex, int count)
{
try
{
return (String)
cons.newInstance(new Object[] { value, Integer.valueOf(startIndex),
Integer.valueOf(count),
Boolean.valueOf(true) });
}
catch (InstantiationException e)
{
throw (Error)
new InternalError("Could not instantiate no-copy String constructor").initCause(e);
}
catch (IllegalAccessException e)
{
throw (Error)
new InternalError("Could not access no-copy String constructor").initCause(e);
}
catch (InvocationTargetException e)
{
throw (Error)
new InternalError("Error calling no-copy String constructor").initCause(e);
}
}
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java
0,0 → 1,108
/* VMInstrumentationImpl.java -- interface for the GNU implementation
of InstrumentationImpl
Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.java.lang;
 
import java.lang.instrument.ClassDefinition;
import java.lang.instrument.Instrumentation;
 
/**
* @author Nicolas Geoffray (nicolas.geoffray@menlina.com)
* @since 1.5
*/
final class VMInstrumentationImpl
{
 
/**
* Returns if the current JVM supports class redefinition
*
* @return true if the current JVM supports class redefinition
*/
static native boolean isRedefineClassesSupported();
 
/**
* Redefines classes given as parameters. The method has to call
* the callTransformers from InstrumentationImpl
*
* @param inst an instrumentation object
* @param definitions an array of bytecode<->class correspondance
*
* @throws ClassNotFoundException if a class cannot be found
* @throws UnmodifiableClassException if a class cannot be modified
* @throws UnsupportedOperationException if the JVM does not support
* redefinition or the redefinition made unsupported changes
* @throws ClassFormatError if a class file is not valid
* @throws NoClassDefFoundError if a class name is not equal to the name
* in the class file specified
* @throws UnsupportedClassVersionError if the class file version numbers
* are unsupported
* @throws ClassCircularityError if circularity occured with the new
* classes
* @throws LinkageError if a linkage error occurs
*/
static native void redefineClasses(Instrumentation inst,
ClassDefinition[] definitions);
 
/**
* Get all the classes loaded by the JVM.
*
* @return an array containing all the classes loaded by the JVM. The array
* is empty if no class is loaded.
*/
static native Class[] getAllLoadedClasses();
 
/**
* Get all the classes loaded by a given class loader
*
* @param loader the loader
*
* @return an array containing all the classes loaded by the given loader.
* The array is empty if no class was loaded by the loader.
*/
static native Class[] getInitiatedClasses(ClassLoader loader);
 
/**
* Get the size of an object. The object is not null
*
* @param objectToSize the object
* @return the size of the object
*/
static native long getObjectSize(Object objectToSize);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMGarbageCollectorMXBeanImpl.java
0,0 → 1,80
/* VMGarbageCollectorMXBeanImpl.java - VM interface for a GC bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
/**
* Provides access to information about the garbage collectors
* of the virtual machine. Garbage collectors are responsible
* for removing unreferenced objects from memory. A garbage
* collector is a type of memory manager, so this interface
* is combined with that of generic memory managers. An instance
* of this bean for each garbage collector is obtained by calling
* {@link ManagementFactory#getGarbageCollectorMXBeans()}.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMGarbageCollectorMXBeanImpl
{
 
/**
* Returns the number of collections the garbage collector
* represented by this bean has made. -1 is returned if the
* collection count is undefined.
*
* @param name the name of the garbage collector.
* @return the number of collections made, or -1 if this is
* undefined.
*/
static native long getCollectionCount(String name);
 
/**
* Returns the accumulated number of milliseconds this garbage
* collector has spent freeing the memory used by unreferenced
* objects. -1 is returned if the collection time is undefined.
* Note that the accumulated time may not change, even when the
* collection count increases, if the time taken is sufficiently
* short; this depends on the resolution of the timer used.
*
* @param name the name of the garbage collector.
* @return the accumulated number of milliseconds spent collecting,
* or -1 if this is undefined.
*/
static native long getCollectionTime(String name);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryPoolMXBeanImpl.java
0,0 → 1,195
/* MemoryPoolMXBeanImpl.java - VM interface for memory pool beans
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
import java.lang.management.MemoryUsage;
 
/**
* Provides access to information on the memory resources or
* pools used by the current invocation of the virtual machine.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMMemoryPoolMXBeanImpl
{
 
/**
* Returns memory usage statistics for the specified pool
* just after a best-effort attempt to free memory. This
* is valid only for certain garbage collectors.
*
* @param name the name of the pool to obtain statistics on.
* @return a {@link java.lang.management.MemoryUsage} object
* containing the statistics or <code>null</code>
* if this pool does not support such statistics.
*/
static native MemoryUsage getCollectionUsage(String name);
 
/**
* Returns the collection usage threshold for the specified pool.
* This is only called if this functionality is supported
* by the virtual machine (i.e. the appropriate property,
* <code>gnu.java.lang.management.CollectionUsageThresholdSupport</code>,
* is defined). The value is initially zero.
*
* @param name the name of the pool to obtain statistics on.
* @return the collection usage threshold.
*/
static native long getCollectionUsageThreshold(String name);
 
/**
* Returns the number of times the collection usage threshold
* has been met or exceeded by the specified pool.
* This is only called if this functionality is supported
* by the virtual machine (i.e. the appropriate property,
* <code>gnu.java.lang.management.CollectionUsageThresholdSupport</code>,
* is defined).
*
* @param name the name of the pool to obtain statistics on.
* @return the collection usage threshold count.
*/
static native long getCollectionUsageThresholdCount(String name);
 
/**
* Returns an array of names of memory managers which manage
* the specified pool.
*
* @param name the name of the pool to obtain statistics on.
* @return a list of memory managers for the pool.
*/
static native String[] getMemoryManagerNames(String name);
 
/**
* Returns the peak usage level of the specified pool.
* This is only called if the pool is valid.
*
* @param name the name of the pool to obtain statistics on.
* @return a {@link java.lang.management.MemoryUsage} object
* containing the statistics.
*/
static native MemoryUsage getPeakUsage(String name);
 
/**
* Returns the type of memory used by the specified pool.
* The value must be either "HEAP" or "NON_HEAP".
*
* @param name the name of the pool to obtain statistics on.
* @return the type of the given pool.
*/
static native String getType(String name);
 
/**
* Returns the current usage level of the specified pool.
* This is only called if the pool is valid.
*
* @param name the name of the pool to obtain statistics on.
* @return a {@link java.lang.management.MemoryUsage} object
* containing the statistics.
*/
static native MemoryUsage getUsage(String name);
 
/**
* Returns the usage threshold for the specified pool.
* This is only called if this functionality is supported
* by the virtual machine (i.e. the appropriate property,
* <code>gnu.java.lang.management.UsageThresholdSupport</code>,
* is defined). The value is initially defined by the
* virtual machine.
*
* @param name the name of the pool to obtain statistics on.
* @return the usage threshold.
*/
static native long getUsageThreshold(String name);
 
/**
* Returns the number of times the usage threshold
* has been met or exceeded by the specified pool.
* This is only called if this functionality is supported
* by the virtual machine (i.e. the appropriate property,
* <code>gnu.java.lang.management.UsageThresholdSupport</code>,
* is defined).
*
* @param name the name of the pool to obtain statistics on.
* @return the usage threshold count.
*/
static native long getUsageThresholdCount(String name);
 
/**
* Returns true if the specified pool is still valid i.e.
* it is still in use by the virtual machine.
*
* @param name the name of the pool to check the validity of.
* @return true if the pool is valid.
*/
static native boolean isValid(String name);
 
/**
* Resets the peak usage level to the current usage level for
* the specified pool.
*
* @param name the name of the pool to reset the peak usage of.
*/
static native void resetPeakUsage(String name);
 
/**
* Sets the collection usage threshold for the specified
* pool to the supplied value.
* This is only called if this functionality is supported
* by the virtual machine (i.e. the appropriate property,
* <code>gnu.java.lang.management.CollectionUsageThresholdSupport</code>,
* is defined).
*
* @param name the name of the pool to set the threshold of.
* @param threshold the new threshold level.
*/
static native void setCollectionUsageThreshold(String name, long threshold);
 
/**
* Sets the usage threshold for the specified pool to the supplied value.
* This is only called if this functionality is supported
* by the virtual machine (i.e. the appropriate property,
* <code>gnu.java.lang.management.UsageThresholdSupport</code>,
* is defined).
*
* @param name the name of the pool to set the threshold of.
* @param threshold the new threshold level.
*/
static native void setUsageThreshold(String name, long threshold);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMRuntimeMXBeanImpl.java
0,0 → 1,89
/* VMRuntimeMXBeanImpl.java - VM implementation of an runtime bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
import gnu.classpath.SystemProperties;
 
/**
* Provides access to information about the virtual machine.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMRuntimeMXBeanImpl
{
 
/**
* Returns the command-line arguments supplied
* to the virtual machine, excluding those supplied
* to <code>main()</code>.
*
* @return the command-line arguments.
*/
static native String[] getInputArguments();
 
/**
* Returns a developer-chosen name for the virtual
* machine, which may differ over different running
* instances of the same virtual machine binary.
* For example, this may include the particular
* process identifier used by this instance or
* the host name of the machine on which it is
* running. The intention is that this name refers
* to the precise entity that the other data supplied
* by the bean refers to, rather than the VM in general.
*
* @return the custom name of the VM.
*/
static String getName()
{
return SystemProperties.getProperty("java.vm.name") + " " +
SystemProperties.getProperty("java.vm.version");
}
 
/**
* The time in milliseconds at which the virtual
* machine was started. This method is only executed
* once (for efficency), as the value is not expected
* to change.
*
* @return the VM start time.
*/
static native long getStartTime();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryManagerMXBeanImpl.java
0,0 → 1,95
/* VMMemoryManagerMXBeanImpl.java - VM interface for a memory manager bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
/**
* Provides access to information about the memory managers
* of the virtual machine. An instance of this bean for each
* memory manager is obtained by calling
* {@link ManagementFactory#getMemoryManagerMXBeans()}.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMMemoryManagerMXBeanImpl
{
 
/**
* Returns an array containing the names of the memory pools
* this memory manager manages.
*
* @param name the name of the memory manager.
* @return an array containing the name of each memory pool
* this manager is responsible for.
*/
static String[] getMemoryPoolNames(String name)
{
List managedPools = new ArrayList();
Iterator beans = ManagementFactory.getMemoryPoolMXBeans().iterator();
while (beans.hasNext())
{
MemoryPoolMXBean bean = (MemoryPoolMXBean) beans.next();
String[] managers = bean.getMemoryManagerNames();
for (int a = 0; a < managers.length; ++a)
if (managers[a].equals(name))
{
managedPools.add(bean.getName());
break;
}
}
return (String[]) managedPools.toArray(new String[managedPools.size()]);
}
 
/**
* Returns true if this memory manager is still valid. A memory
* manager becomes invalid when it is removed by the virtual machine
* and no longer used.
*
* @param name the name of the memory manager.
* @return true if this memory manager is valid.
*/
static native boolean isValid(String name);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMClassLoadingMXBeanImpl.java
0,0 → 1,89
/* VMClassLoadingMXBeanImpl.java - VM impl. of a class loading bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
/**
* Provides access to information about the class loading
* behaviour of the current invocation of the virtual
* machine. Instances of this bean are obtained by calling
* {@link ManagementFactory#getClassLoadingMXBean()}.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMClassLoadingMXBeanImpl
{
 
/**
* Returns the number of classes currently loaded by
* the virtual machine.
*
* @return the number of loaded classes.
*/
static native int getLoadedClassCount();
 
/**
* Returns the number of classes that have been unloaded
* by the virtual machine since it was started.
*
* @return the number of unloaded classes.
*/
static native long getUnloadedClassCount();
 
/**
* Returns true if the virtual machine will emit additional
* information when classes are loaded and unloaded. The
* format of the output is left up to the virtual machine.
*
* @return true if verbose class loading output is on.
*/
static native boolean isVerbose();
 
/**
* Turns on or off the emission of additional information
* when classes are loaded and unloaded. The format of the
* output is left up to the virtual machine. This method
* may be called by multiple threads concurrently, but there
* is only one global setting of verbosity that is affected.
*
* @param verbose the new setting for verbose class loading
* output.
*/
static native void setVerbose(boolean verbose);
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMThreadMXBeanImpl.java
0,0 → 1,236
/* VMThreadMXBeanImpl.java - VM impl. of a thread bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
import java.lang.management.ThreadInfo;
 
/**
* Provides access to information about the threads
* of the virtual machine. An instance of this bean is
* obtained by calling
* {@link ManagementFactory#getThreadMXBean()}.
* See {@link java.lang.management.ThreadMXBean} for
* full documentation.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMThreadMXBeanImpl
{
 
/**
* Cache of how many threads were found.
*/
private static int filled;
 
/**
* Returns the ids of cycles of deadlocked threads, occurring
* due to monitor ownership or ownable synchronizer ownership.
* This will only be called if ownable synchronizer monitoring
* is supported.
*
* @return the ids of the deadlocked threads.
*/
static native long[] findDeadlockedThreads();
 
/**
* Returns the ids of cycles of deadlocked threads, occurring
* due to monitor ownership.
*
* @return the ids of the deadlocked threads.
*/
static native long[] findMonitorDeadlockedThreads();
 
/* This is the same as in Thread.getAllStackTraces() */
static Thread[] getAllThreads()
{
ThreadGroup group = Thread.currentThread().getThreadGroup();
while (group.getParent() != null)
group = group.getParent();
int arraySize = group.activeCount();
Thread[] threadList = new Thread[arraySize];
filled = group.enumerate(threadList);
while (filled == arraySize)
{
arraySize *= 2;
threadList = new Thread[arraySize];
filled = group.enumerate(threadList);
}
return threadList;
}
 
/**
* Returns the id of all live threads at the time of execution.
*
* @return the live thread ids.
*/
static long[] getAllThreadIds()
{
Thread[] threadList = getAllThreads();
long[] ids = new long[filled];
for (int a = 0; a < filled; ++a)
ids[a] = threadList[a].getId();
return ids;
}
 
/**
* Returns the number of nanoseconds of CPU time
* the current thread has used in total. This is
* only called if this feature is enabled and
* supported.
*
* @return the nanoseconds of CPU time used by
* the current thread.
*/
static native long getCurrentThreadCpuTime();
 
/**
* Returns the number of nanoseconds of user time
* the current thread has used in total. This is
* only called if this feature is enabled and
* supported.
*
* @return the nanoseconds of user time used by
* the current thread.
*/
static native long getCurrentThreadUserTime();
 
/**
* Returns the number of live daemon threads.
*
* @return the number of live daemon threads.
*/
static int getDaemonThreadCount()
{
Thread[] threadList = getAllThreads();
int daemonCount = 0;
for (int a = 0; a < filled; ++a)
{
if (threadList[a].isDaemon())
++daemonCount;
}
return daemonCount;
}
 
/**
* Fill out the given {@link ThreadInfo} object
* with ownable synchronizer usage information.
* This is only called if ownable synchronizer
* usage monitoring is supported.
*
* @param info the {@link ThreadInfo} object to modify.
*/
static native void getLockInfo(ThreadInfo info);
 
/**
* Fill out the given {@link ThreadInfo} object
* with monitor usage information. This is only
* called if monitor usage monitoring is supported.
*
* @param info the {@link ThreadInfo} object to modify.
*/
static native void getMonitorInfo(ThreadInfo info);
 
/**
* Returns the current peak number of live threads.
*
* @return the peak number of live threads.
*/
static native int getPeakThreadCount();
 
/**
* Returns the number of live threads.
*
* @return the number of live threads.
*/
static int getThreadCount()
{
getAllThreads();
return filled;
}
 
/**
* Returns the number of nanoseconds of CPU time
* the specified thread has used in total. This is
* only called if this feature is enabled and
* supported.
*
* @param id the thread to obtain statistics on.
* @return the nanoseconds of CPU time used by
* the thread.
*/
static native long getThreadCpuTime(long id);
 
/**
* Returns the {@link java.lang.management.ThreadInfo}
* which corresponds to the specified id.
*
* @param id the id of the thread.
* @param maxDepth the depth of the stack trace.
* @return the corresponding <code>ThreadInfo</code>.
*/
static native ThreadInfo getThreadInfoForId(long id, int maxDepth);
 
/**
* Returns the number of nanoseconds of user time
* the specified thread has used in total. This is
* only called if this feature is enabled and
* supported.
*
* @param id the thread to obtain statistics on.
* @return the nanoseconds of user time used by
* the thread.
*/
static native long getThreadUserTime(long id);
 
/**
* Returns the total number of threads that have
* been started over the lifetime of the virtual
* machine.
*
* @return the total number of threads started.
*/
static native long getTotalStartedThreadCount();
 
/**
* Resets the peak thread count to the current
* number of live threads.
*/
static native void resetPeakThreadCount();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMMemoryMXBeanImpl.java
0,0 → 1,156
/* VMMemoryMXBeanImpl.java - VM impl. of a memory bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryType;
import java.lang.management.MemoryUsage;
 
import java.util.Iterator;
import java.util.List;
 
/**
* Provides access to information about the memory
* management of the current invocation of the virtual
* machine. Instances of this bean are obtained by calling
* {@link ManagementFactory#getMemoryMXBean()}.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMMemoryMXBeanImpl
{
 
/**
* Returns an instance of {@link java.lang.management.MemoryUsage}
* with appropriate initial, used, committed and maximum values
* for the heap. By default, this uses the methods of
* {@link java.lang.Runtime} to provide some of the values.
*
* @return an {@link java.lang.management.MemoryUsage} instance
* for the heap.
*/
static MemoryUsage getHeapMemoryUsage()
{
return getUsage(MemoryType.HEAP);
}
 
/**
* Returns an instance of {@link java.lang.management.MemoryUsage}
* with appropriate initial, used, committed and maximum values
* for non-heap memory.
*
* @return an {@link java.lang.management.MemoryUsage} instance
* for non-heap memory.
*/
static MemoryUsage getNonHeapMemoryUsage()
{
return getUsage(MemoryType.NON_HEAP);
}
 
/**
* Returns the number of objects ready to be garbage collected.
*
* @return the number of finalizable objects.
*/
static native int getObjectPendingFinalizationCount();
 
/**
* Returns true if the virtual machine will emit additional
* information when memory is allocated and deallocated. The
* format of the output is left up to the virtual machine.
*
* @return true if verbose memory usage output is on.
*/
static native boolean isVerbose();
 
/**
* Turns on or off the emission of additional information
* when memory is allocated and deallocated. The format of the
* output is left up to the virtual machine. This method
* may be called by multiple threads concurrently, but there
* is only one global setting of verbosity that is affected.
*
* @param verbose the new setting for verbose memory usage
* output.
*/
static native void setVerbose(boolean verbose);
 
/**
* Totals the memory usage from all the pools that match
* the given type.
*
* @param type the type of memory pools to accumulate
* (heap or non-heap).
* @return the memory usage overall.
*/
private static MemoryUsage getUsage(MemoryType type) {
long init = 0, committed = 0, used = 0, max = 0;
Iterator pools =
ManagementFactory.getMemoryPoolMXBeans().iterator();
while (pools.hasNext())
{
MemoryPoolMXBean pool = (MemoryPoolMXBean) pools.next();
if (pool.getType() == type)
{
MemoryUsage usage = pool.getUsage();
if (init != -1)
{
long poolInit = usage.getInit();
if (poolInit == -1)
init = -1;
else
init += poolInit;
}
committed += usage.getCommitted();
used += usage.getUsed();
if (max != -1)
{
long poolMax = usage.getMax();
if (poolMax == -1)
max = -1;
else
max += poolMax;
}
}
}
return new MemoryUsage(init, used, committed, max);
}
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMOperatingSystemMXBeanImpl.java
0,0 → 1,68
/* VMOperatingSystemMXBeanImpl.java - VM implementation of an OS bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
import gnu.classpath.Configuration;
 
/**
* Provides access to information about the operating system.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.6
*/
final class VMOperatingSystemMXBeanImpl
{
 
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javalangmanagement");
}
}
 
/**
* Returns the system load average from the last
* minute.
*
* @return the system load average from the last
* minute.
*/
static native double getSystemLoadAverage();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/lang/management/VMCompilationMXBeanImpl.java
0,0 → 1,66
/* VMCompilationMXBeanImpl.java - VM implementation of a compilation bean
Copyright (C) 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.lang.management;
 
/**
* Provides access to information about the JIT
* compiler of the virtual machine, if one exists.
* Instances of this bean are obtained by calling
* {@link ManagementFactory#getCompilationMXBean()},
* if this is the case.
*
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
final class VMCompilationMXBeanImpl
{
 
/**
* Returns the number of milliseconds the JIT
* compiler has spent compiling Java bytecode
* to native machine code. This is only called
* if a JIT compiler exists and the
* gnu.java.lang.management.CompilationTimeSupport
* property has been set.
*
* @return the number of milliseconds spent
* compiling.
*/
static native long getTotalCompilationTime();
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/nio/VMPipe.java
0,0 → 1,80
/* VMPipe.java -- Reference implementation for VM hooks used by PipeImpl
Copyright (C) 2004 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.nio;
 
import java.io.IOException;
import gnu.classpath.Configuration;
 
/**
* This class contains the native methods for gnu.java.nio.PipeImpl
* As such, it needs help from the VM.
*
* @author Patrik Reali
*/
final class VMPipe
{
 
static
{
// load the shared library needed for native methods.
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary ("javanio");
}
}
 
/**
* Create a pipe, consisting of a readable VMChannel and a writable
* VMChannel. The readable channel is returned is the first element
* of the array, and the writable in the second.
*
* @return A pair of VMChannels; the first readable, the second
* writable.
* @throws IOException If the pipe cannot be created.
*/
static VMChannel[] pipe() throws IOException
{
VMChannel[] pipe = new VMChannel[2];
int[] fds = pipe0();
pipe[0] = new VMChannel(fds[0]);
pipe[1] = new VMChannel(fds[1]);
return pipe;
}
 
private static native int[] pipe0() throws IOException;
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/nio/VMSelector.java
0,0 → 1,59
/* VMSelector.java --
Copyright (C) 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.nio;
 
import gnu.classpath.Configuration;
import java.io.IOException;
 
public final class VMSelector
{
static
{
// load the shared library needed for native methods.
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary ("javanio");
}
}
 
// A timeout value of 0 means block forever.
static native int select (int[] read, int[] write,
int[] except, long timeout)
throws IOException;
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/nio/VMChannel.java
0,0 → 1,749
/* VMChannel.java -- Native interface suppling channel operations.
Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.java.nio;
 
import gnu.classpath.Configuration;
 
import java.io.IOException;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
 
/**
* Native interface to support configuring of channel to run in a non-blocking
* manner and support scatter/gather io operations.
*
* @author Michael Barker <mike@middlesoft.co.uk>
*
*/
public final class VMChannel
{
/**
* Our reference implementation uses an integer to store the native
* file descriptor. Implementations without such support
*/
private final State nfd;
 
private Kind kind;
 
public VMChannel()
{
// XXX consider adding security check here, so only Classpath
// code may create instances.
this.nfd = new State();
kind = Kind.OTHER;
}
 
/**
* This constructor is used by the POSIX reference implementation;
* other virtual machines need not support it.
*
* <strong>Important:</strong> do not call this in library code that is
* not specific to Classpath's reference implementation.
*
* @param native_fd The native file descriptor integer.
* @throws IOException
*/
VMChannel(final int native_fd) throws IOException
{
this();
this.nfd.setNativeFD(native_fd);
}
 
public State getState()
{
return nfd;
}
 
static
{
// load the shared library needed for native methods.
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary ("javanio");
}
initIDs();
}
 
public static VMChannel getStdin() throws IOException
{
return new VMChannel(stdin_fd());
}
 
public static VMChannel getStdout() throws IOException
{
return new VMChannel(stdout_fd());
}
 
public static VMChannel getStderr() throws IOException
{
return new VMChannel(stderr_fd());
}
 
private static native int stdin_fd();
private static native int stdout_fd();
private static native int stderr_fd();
 
/**
* Set the file descriptor to have the required blocking
* setting.
*
* @param blocking The blocking flag to set.
*/
public void setBlocking(boolean blocking) throws IOException
{
setBlocking(nfd.getNativeFD(), blocking);
}
 
private static native void setBlocking(int fd, boolean blocking)
throws IOException;
 
public int available() throws IOException
{
return available(nfd.getNativeFD());
}
 
private static native int available(int native_fd) throws IOException;
 
/**
* Reads a byte buffer directly using the supplied file descriptor.
*
* @param dst Direct Byte Buffer to read to.
* @return Number of bytes read.
* @throws IOException If an error occurs or dst is not a direct buffers.
*/
public int read(ByteBuffer dst)
throws IOException
{
return read(nfd.getNativeFD(), dst);
}
 
private static native int read(int fd, ByteBuffer dst) throws IOException;
 
/**
* Read a single byte.
*
* @return The byte read, or -1 on end of file.
* @throws IOException
*/
public int read() throws IOException
{
return read(nfd.getNativeFD());
}
 
private static native int read(int fd) throws IOException;
 
/**
* Reads into byte buffers directly using the supplied file descriptor.
* Assumes that the buffer list contains DirectBuffers. Will perform a
* scattering read.
*
* @param dsts An array direct byte buffers.
* @param offset Index of the first buffer to read to.
* @param length The number of buffers to read to.
* @return Number of bytes read.
* @throws IOException If an error occurs or the dsts are not direct buffers.
*/
public long readScattering(ByteBuffer[] dsts, int offset, int length)
throws IOException
{
if (offset + length > dsts.length)
throw new IndexOutOfBoundsException("offset + length > dsts.length");
 
return readScattering(nfd.getNativeFD(), dsts, offset, length);
}
 
private static native long readScattering(int fd, ByteBuffer[] dsts,
int offset, int length)
throws IOException;
 
/**
* Receive a datagram on this channel, returning the host address
* that sent the datagram.
*
* @param dst Where to store the datagram.
* @return The host address that sent the datagram.
* @throws IOException
*/
public SocketAddress receive(ByteBuffer dst) throws IOException
{
if (kind != Kind.SOCK_DGRAM)
throw new SocketException("not a datagram socket");
ByteBuffer hostPort = ByteBuffer.allocateDirect(18);
int hostlen = receive(nfd.getNativeFD(), dst, hostPort);
if (hostlen == 0)
return null;
if (hostlen == 4) // IPv4
{
byte[] addr = new byte[4];
hostPort.get(addr);
int port = hostPort.getShort() & 0xFFFF;
return new InetSocketAddress(Inet4Address.getByAddress(addr), port);
}
if (hostlen == 16) // IPv6
{
byte[] addr = new byte[16];
hostPort.get(addr);
int port = hostPort.getShort() & 0xFFFF;
return new InetSocketAddress(Inet6Address.getByAddress(addr), port);
}
 
throw new SocketException("host address received with invalid length: "
+ hostlen);
}
 
private static native int receive (int fd, ByteBuffer dst, ByteBuffer address)
throws IOException;
 
/**
* Writes from a direct byte bufer using the supplied file descriptor.
* Assumes the buffer is a DirectBuffer.
*
* @param src The source buffer.
* @return Number of bytes written.
* @throws IOException
*/
public int write(ByteBuffer src) throws IOException
{
return write(nfd.getNativeFD(), src);
}
 
private native int write(int fd, ByteBuffer src) throws IOException;
 
/**
* Writes from byte buffers directly using the supplied file descriptor.
* Assumes the that buffer list constains DirectBuffers. Will perform
* as gathering write.
*
* @param srcs
* @param offset
* @param length
* @return Number of bytes written.
* @throws IOException
*/
public long writeGathering(ByteBuffer[] srcs, int offset, int length)
throws IOException
{
if (offset + length > srcs.length)
throw new IndexOutOfBoundsException("offset + length > srcs.length");
 
// A gathering write is limited to 16 buffers; when writing, ensure
// that we have at least one buffer with something in it in the 16
// buffer window starting at offset.
while (!srcs[offset].hasRemaining() && offset < srcs.length)
offset++;
 
// There are no buffers with anything to write.
if (offset == srcs.length)
return 0;
 
// If we advanced `offset' so far that we don't have `length'
// buffers left, reset length to only the remaining buffers.
if (length > srcs.length - offset)
length = srcs.length - offset;
 
return writeGathering(nfd.getNativeFD(), srcs, offset, length);
}
 
private native long writeGathering(int fd, ByteBuffer[] srcs,
int offset, int length)
throws IOException;
 
/**
* Send a datagram to the given address.
*
* @param src The source buffer.
* @param dst The destination address.
* @return The number of bytes written.
* @throws IOException
*/
public int send(ByteBuffer src, InetSocketAddress dst)
throws IOException
{
InetAddress addr = dst.getAddress();
if (addr == null)
throw new NullPointerException();
if (addr instanceof Inet4Address)
return send(nfd.getNativeFD(), src, addr.getAddress(), dst.getPort());
else if (addr instanceof Inet6Address)
return send6(nfd.getNativeFD(), src, addr.getAddress(), dst.getPort());
else
throw new SocketException("unrecognized inet address type");
}
 
// Send to an IPv4 address.
private static native int send(int fd, ByteBuffer src, byte[] addr, int port)
throws IOException;
 
// Send to an IPv6 address.
private static native int send6(int fd, ByteBuffer src, byte[] addr, int port)
throws IOException;
 
/**
* Write a single byte.
*
* @param b The byte to write.
* @throws IOException
*/
public void write(int b) throws IOException
{
write(nfd.getNativeFD(), b);
}
 
private static native void write(int fd, int b) throws IOException;
 
private native static void initIDs();
 
// Network (socket) specific methods.
 
/**
* Create a new socket. This method will initialize the native file
* descriptor state of this instance.
*
* @param stream Whether or not to create a streaming socket, or a datagram
* socket.
* @throws IOException If creating a new socket fails, or if this
* channel already has its native descriptor initialized.
*/
public void initSocket(boolean stream) throws IOException
{
if (nfd.isValid())
throw new IOException("native FD already initialized");
if (stream)
kind = Kind.SOCK_STREAM;
else
kind = Kind.SOCK_DGRAM;
nfd.setNativeFD(socket(stream));
}
 
/**
* Create a new socket, returning the native file descriptor.
*
* @param stream Set to true for streaming sockets; false for datagrams.
* @return The native file descriptor.
* @throws IOException If creating the socket fails.
*/
private static native int socket(boolean stream) throws IOException;
 
/**
* Connect the underlying socket file descriptor to the remote host.
*
* @param saddr The address to connect to.
* @param timeout The connect timeout to use for blocking connects.
* @return True if the connection succeeded; false if the file descriptor
* is in non-blocking mode and the connection did not immediately
* succeed.
* @throws IOException If an error occurs while connecting.
*/
public boolean connect(InetSocketAddress saddr, int timeout)
throws SocketException
{
int fd;
 
InetAddress addr = saddr.getAddress();
 
// Translates an IOException into a SocketException to conform
// to the throws clause.
try
{
fd = nfd.getNativeFD();
}
catch (IOException ioe)
{
throw new SocketException(ioe.getMessage());
}
 
if (addr instanceof Inet4Address)
return connect(fd, addr.getAddress(), saddr.getPort(),
timeout);
if (addr instanceof Inet6Address)
return connect6(fd, addr.getAddress(), saddr.getPort(),
timeout);
throw new SocketException("unsupported internet address");
}
 
private static native boolean connect(int fd, byte[] addr, int port, int timeout)
throws SocketException;
 
private static native boolean connect6(int fd, byte[] addr, int port, int timeout)
throws SocketException;
 
/**
* Disconnect this channel, if it is a datagram socket. Disconnecting
* a datagram channel will disassociate it from any address, so the
* socket will remain open, but can send and receive datagrams from
* any address.
*
* @throws IOException If disconnecting this channel fails, or if this
* channel is not a datagram channel.
*/
public void disconnect() throws IOException
{
if (kind != Kind.SOCK_DGRAM)
throw new IOException("can only disconnect datagram channels");
disconnect(nfd.getNativeFD());
}
 
private static native void disconnect(int fd) throws IOException;
 
public InetSocketAddress getLocalAddress() throws IOException
{
if (!nfd.isValid())
return null;
ByteBuffer name = ByteBuffer.allocateDirect(18);
int namelen = getsockname(nfd.getNativeFD(), name);
if (namelen == 0) // not bound
return null; // XXX return some wildcard?
if (namelen == 4)
{
byte[] addr = new byte[4];
name.get(addr);
int port = name.getShort() & 0xFFFF;
return new InetSocketAddress(Inet4Address.getByAddress(addr), port);
}
if (namelen == 16)
{
byte[] addr = new byte[16];
name.get(addr);
int port = name.getShort() & 0xFFFF;
return new InetSocketAddress(Inet6Address.getByAddress(addr), port);
}
throw new SocketException("invalid address length");
}
 
private static native int getsockname(int fd, ByteBuffer name)
throws IOException;
 
/**
* Returns the socket address of the remote peer this channel is connected
* to, or null if this channel is not yet connected.
*
* @return The peer address.
* @throws IOException
*/
public InetSocketAddress getPeerAddress() throws IOException
{
if (!nfd.isValid())
return null;
ByteBuffer name = ByteBuffer.allocateDirect(18);
int namelen = getpeername (nfd.getNativeFD(), name);
if (namelen == 0) // not connected yet
return null;
if (namelen == 4) // IPv4
{
byte[] addr = new byte[4];
name.get(addr);
int port = name.getShort() & 0xFFFF;
return new InetSocketAddress(Inet4Address.getByAddress(addr), port);
}
else if (namelen == 16) // IPv6
{
byte[] addr = new byte[16];
name.get(addr);
int port = name.getShort() & 0xFFFF;
return new InetSocketAddress(Inet6Address.getByAddress(addr), port);
}
throw new SocketException("invalid address length");
}
 
/*
* The format here is the peer address, followed by the port number.
* The returned value is the length of the peer address; thus, there
* will be LEN + 2 valid bytes put into NAME.
*/
private static native int getpeername(int fd, ByteBuffer name)
throws IOException;
 
/**
* Accept an incoming connection, returning a new VMChannel, or null
* if the channel is nonblocking and no connection is pending.
*
* @return The accepted connection, or null.
* @throws IOException If an IO error occurs.
*/
public VMChannel accept() throws IOException
{
int new_fd = accept(nfd.getNativeFD());
if (new_fd == -1) // non-blocking accept had no pending connection
return null;
return new VMChannel(new_fd);
}
 
private static native int accept(int native_fd) throws IOException;
 
// File-specific methods.
 
/**
* Open a file at PATH, initializing the native state to operate on
* that open file.
*
* @param path The absolute file path.
* @throws IOException If the file cannot be opened, or if this
* channel was previously initialized.
*/
public void openFile(String path, int mode) throws IOException
{
if (nfd.isValid() || nfd.isClosed())
throw new IOException("can't reinitialize this channel");
int fd = open(path, mode);
nfd.setNativeFD(fd);
kind = Kind.FILE;
}
 
private static native int open(String path, int mode) throws IOException;
 
public long position() throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
return position(nfd.getNativeFD());
}
 
private static native long position(int fd) throws IOException;
 
public void seek(long pos) throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
seek(nfd.getNativeFD(), pos);
}
 
private static native void seek(int fd, long pos) throws IOException;
 
public void truncate(long length) throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
truncate(nfd.getNativeFD(), length);
}
 
private static native void truncate(int fd, long len) throws IOException;
 
public boolean lock(long pos, long len, boolean shared, boolean wait)
throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
return lock(nfd.getNativeFD(), pos, len, shared, wait);
}
 
private static native boolean lock(int fd, long pos, long len,
boolean shared, boolean wait)
throws IOException;
 
public void unlock(long pos, long len) throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
unlock(nfd.getNativeFD(), pos, len);
}
 
private static native void unlock(int fd, long pos, long len) throws IOException;
 
public long size() throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
return size(nfd.getNativeFD());
}
 
private static native long size(int fd) throws IOException;
 
public MappedByteBuffer map(char mode, long position, int size)
throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
return map(nfd.getNativeFD(), mode, position, size);
}
 
private static native MappedByteBuffer map(int fd, char mode,
long position, int size)
throws IOException;
 
public boolean flush(boolean metadata) throws IOException
{
if (kind != Kind.FILE)
throw new IOException("not a file");
return flush(nfd.getNativeFD(), metadata);
}
 
private static native boolean flush(int fd, boolean metadata) throws IOException;
 
// Close.
 
/**
* Close this socket. The socket is also automatically closed when this
* object is finalized.
*
* @throws IOException If closing the socket fails, or if this object has
* no open socket.
*/
public void close() throws IOException
{
nfd.close();
}
 
static native void close(int native_fd) throws IOException;
 
/**
* <p>Provides a simple mean for the JNI code to find out whether the
* current thread was interrupted by a call to Thread.interrupt().</p>
*
* @return
*/
static boolean isThreadInterrupted()
{
return Thread.currentThread().isInterrupted();
}
 
// Inner classes.
 
/**
* A wrapper for a native file descriptor integer. This tracks the state
* of an open file descriptor, and ensures that
*
* This class need not be fully supported by virtual machines; if a
* virtual machine does not use integer file descriptors, or does and
* wishes to hide that, then the methods of this class may be stubbed out.
*
* System-specific classes that depend on access to native file descriptor
* integers SHOULD declare this fact.
*/
public final class State
{
private int native_fd;
private boolean valid;
private boolean closed;
 
State()
{
native_fd = -1;
valid = false;
closed = false;
}
 
public boolean isValid()
{
return valid;
}
 
public boolean isClosed()
{
return closed;
}
 
public int getNativeFD() throws IOException
{
if (!valid)
throw new IOException("invalid file descriptor");
return native_fd;
}
 
void setNativeFD(final int native_fd) throws IOException
{
if (valid)
throw new IOException("file descriptor already initialized");
this.native_fd = native_fd;
valid = true;
}
 
public void close() throws IOException
{
if (!valid)
throw new IOException("invalid file descriptor");
try
{
VMChannel.close(native_fd);
}
finally
{
valid = false;
closed = true;
}
}
 
public String toString()
{
if (closed)
return "<<closed>>";
if (!valid)
return "<<invalid>>";
return String.valueOf(native_fd);
}
 
protected void finalize() throws Throwable
{
try
{
if (valid)
close();
}
finally
{
super.finalize();
}
}
}
 
/**
* An enumeration of possible kinds of channel.
*/
static class Kind // XXX enum
{
/** A streaming (TCP) socket. */
static final Kind SOCK_STREAM = new Kind();
 
/** A datagram (UDP) socket. */
static final Kind SOCK_DGRAM = new Kind();
 
/** A file. */
static final Kind FILE = new Kind();
 
/** Something else; not a socket or file. */
static final Kind OTHER = new Kind();
 
private Kind() { }
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/net/VMPlainSocketImpl.java
0,0 → 1,511
/* VMPlainSocketImpl.java -- VM interface for default socket implementation
Copyright (C) 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.java.net;
 
import java.io.IOException;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.SocketOptions;
 
import gnu.classpath.Configuration;
import gnu.java.nio.VMChannel;
 
/**
* The VM interface for {@link gnu.java.net.PlainSocketImpl}.
*
* @author Ingo Proetel (proetel@aicas.com)
* @author Roman Kennke (kennke@aicas.com)
*/
public final class VMPlainSocketImpl
{
/** Option id for time to live
*/
private static final int CP_IP_TTL = 0x1E61;
 
private final State nfd;
 
/**
* Static initializer to load native library.
*/
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javanet");
}
}
 
public VMPlainSocketImpl()
{
// XXX consider adding security check here.
nfd = new State();
}
 
public VMPlainSocketImpl(VMChannel channel) throws IOException
{
this();
nfd.setChannelFD(channel.getState());
}
 
public State getState()
{
return nfd;
}
 
/** This method exists to hide the CP_IP_TTL value from
* higher levels.
*
* Always think of JNode ... :)
*/
public void setTimeToLive(int ttl)
throws SocketException
{
try
{
setOption(nfd.getNativeFD(), CP_IP_TTL, ttl);
}
catch (IOException ioe)
{
SocketException se = new SocketException();
se.initCause(ioe);
throw se;
}
}
 
public int getTimeToLive()
throws SocketException
{
try
{
return getOption(nfd.getNativeFD(), CP_IP_TTL);
}
catch (IOException ioe)
{
SocketException se = new SocketException();
se.initCause(ioe);
throw se;
}
}
 
public void setOption(int optionId, Object optionValue)
throws SocketException
{
int value;
if (optionValue instanceof Integer)
value = ((Integer) optionValue).intValue();
else if (optionValue instanceof Boolean)
// Switching off the linger behavior is done by setting
// the value to -1. This is how the Java API interprets
// it.
value = ((Boolean) optionValue).booleanValue()
? 1
: (optionId == SocketOptions.SO_LINGER)
? -1
: 0;
else
throw new IllegalArgumentException("option value type "
+ optionValue.getClass().getName());
 
try
{
setOption(nfd.getNativeFD(), optionId, value);
}
catch (IOException ioe)
{
SocketException se = new SocketException();
se.initCause(ioe);
throw se;
}
}
 
private static native void setOption(int fd, int id, int value)
throws SocketException;
 
public void setMulticastInterface(int optionId, InetAddress addr)
throws SocketException
{
try
{
if (addr instanceof Inet4Address)
setMulticastInterface(nfd.getNativeFD(), optionId, (Inet4Address) addr);
else if (addr instanceof Inet6Address)
{
NetworkInterface iface = NetworkInterface.getByInetAddress(addr);
setMulticastInterface6(nfd.getNativeFD(), optionId, iface.getName());
}
else
throw new SocketException("Unknown address format: " + addr);
}
catch (SocketException se)
{
throw se;
}
catch (IOException ioe)
{
SocketException se = new SocketException();
se.initCause(ioe);
throw se;
}
}
 
private static native void setMulticastInterface(int fd,
int optionId,
Inet4Address addr);
 
private static native void setMulticastInterface6(int fd,
int optionId,
String ifName);
 
/**
* Get a socket option. This implementation is only required to support
* socket options that are boolean values, which include:
*
* SocketOptions.IP_MULTICAST_LOOP
* SocketOptions.SO_BROADCAST
* SocketOptions.SO_KEEPALIVE
* SocketOptions.SO_OOBINLINE
* SocketOptions.SO_REUSEADDR
* SocketOptions.TCP_NODELAY
*
* and socket options that are integer values, which include:
*
* SocketOptions.IP_TOS
* SocketOptions.SO_LINGER
* SocketOptions.SO_RCVBUF
* SocketOptions.SO_SNDBUF
* SocketOptions.SO_TIMEOUT
*
* @param optionId The option ID to fetch.
* @return A {@link Boolean} or {@link Integer} containing the socket
* option.
* @throws SocketException
*/
public Object getOption(int optionId) throws SocketException
{
int value;
try
{
value = getOption(nfd.getNativeFD(), optionId);
}
catch (IOException ioe)
{
SocketException se = new SocketException();
se.initCause(ioe);
throw se;
}
 
switch (optionId)
{
case SocketOptions.IP_MULTICAST_LOOP:
case SocketOptions.SO_BROADCAST:
case SocketOptions.SO_KEEPALIVE:
case SocketOptions.SO_OOBINLINE:
case SocketOptions.SO_REUSEADDR:
case SocketOptions.TCP_NODELAY:
return Boolean.valueOf(value != 0);
 
case SocketOptions.IP_TOS:
case SocketOptions.SO_LINGER:
case SocketOptions.SO_RCVBUF:
case SocketOptions.SO_SNDBUF:
case SocketOptions.SO_TIMEOUT:
return new Integer(value);
 
default:
throw new SocketException("getting option " + optionId +
" not supported here");
}
}
 
private static native int getOption(int fd, int id) throws SocketException;
 
/**
* Returns an Inet4Address or Inet6Address instance belonging to the
* interface which is set as the multicast interface.
*
* The optionId is provided to make it possible that the native
* implementation may do something different depending on whether
* the value is SocketOptions.IP_MULTICAST_IF or
* SocketOptions.IP_MULTICAST_IF2.
*/
public InetAddress getMulticastInterface(int optionId)
throws SocketException
{
try
{
return getMulticastInterface(nfd.getNativeFD(), optionId);
}
catch (IOException ioe)
{
SocketException se = new SocketException();
se.initCause(ioe);
throw se;
}
}
 
private static native InetAddress getMulticastInterface(int fd,
int optionId);
 
/**
* Binds this socket to the given local address and port.
*
* @param address The address to bind to; the InetAddress is either
* an IPv4 or IPv6 address.
* @throws IOException If binding fails; for example, if the port
* in the given InetSocketAddress is privileged, and the current
* process has insufficient privileges.
*/
public void bind(InetSocketAddress address) throws IOException
{
InetAddress addr = address.getAddress();
if (addr instanceof Inet4Address)
{
bind (nfd.getNativeFD(), addr.getAddress(), address.getPort());
}
else if (addr instanceof Inet6Address)
bind6 (nfd.getNativeFD(), addr.getAddress(), address.getPort());
else
throw new SocketException ("unsupported address type");
}
 
/**
* Native bind function for IPv4 addresses. The addr array must be
* exactly four bytes long.
*
* VMs without native support need not implement this.
*
* @param fd The native file descriptor integer.
* @param addr The IPv4 address, in network byte order.
* @param port The port to bind to.
* @throws IOException
*/
private static native void bind(int fd, byte[] addr, int port)
throws IOException;
 
/**
* Native bind function for IPv6 addresses. The addr array must be
* exactly sixteen bytes long.
*
* VMs without native support need not implement this.
*
* @param fd The native file descriptor integer.
* @param addr The IPv6 address, in network byte order.
* @param port The port to bind to.
* @throws IOException
*/
private static native void bind6(int fd, byte[] addr, int port)
throws IOException;
 
/**
* Listen on this socket for incoming connections.
*
* @param backlog The backlog of connections.
* @throws IOException If listening fails.
* @see gnu.java.nio.VMChannel#accept()
*/
public void listen(int backlog) throws IOException
{
listen(nfd.getNativeFD(), backlog);
}
 
/**
* Native listen function. VMs without native support need not implement
* this.
*
* @param fd The file descriptor integer.
* @param backlog The listen backlog size.
* @throws IOException
*/
private static native void listen(int fd, int backlog) throws IOException;
 
public void join(InetAddress group) throws IOException
{
if (group instanceof Inet4Address)
join(nfd.getNativeFD(), group.getAddress());
else if (group instanceof Inet6Address)
join6(nfd.getNativeFD(), group.getAddress());
else
throw new IllegalArgumentException("unknown address type");
}
 
private static native void join(int fd, byte[] addr) throws IOException;
 
private static native void join6(int fd, byte[] addr) throws IOException;
 
public void leave(InetAddress group) throws IOException
{
if (group instanceof Inet4Address)
leave(nfd.getNativeFD(), group.getAddress());
else if (group instanceof Inet6Address)
leave6(nfd.getNativeFD(), group.getAddress());
else
throw new IllegalArgumentException("unknown address type");
}
 
private static native void leave(int fd, byte[] addr) throws IOException;
 
private static native void leave6(int fd, byte[] addr) throws IOException;
 
public void joinGroup(InetSocketAddress addr, NetworkInterface netif)
throws IOException
{
InetAddress address = addr.getAddress();
 
if (address instanceof Inet4Address)
joinGroup(nfd.getNativeFD(), address.getAddress(),
netif != null ? netif.getName() : null);
else if (address instanceof Inet6Address)
joinGroup6(nfd.getNativeFD(), address.getAddress(),
netif != null ? netif.getName() : null);
else
throw new IllegalArgumentException("unknown address type");
}
 
private static native void joinGroup(int fd, byte[] addr, String ifname)
throws IOException;
 
private static native void joinGroup6(int fd, byte[] addr, String ifname)
throws IOException;
 
public void leaveGroup(InetSocketAddress addr, NetworkInterface netif)
throws IOException
{
InetAddress address = addr.getAddress();
if (address instanceof Inet4Address)
leaveGroup(nfd.getNativeFD(), address.getAddress(),
netif != null ? netif.getName() : null);
else if (address instanceof Inet6Address)
leaveGroup6(nfd.getNativeFD(), address.getAddress(),
netif != null ? netif.getName() : null);
else
throw new IllegalArgumentException("unknown address type");
}
 
private static native void leaveGroup(int fd, byte[] addr, String ifname)
throws IOException;
 
private static native void leaveGroup6(int fd, byte[] addr, String ifname)
throws IOException;
 
 
public void shutdownInput() throws IOException
{
shutdownInput(nfd.getNativeFD());
}
 
private static native void shutdownInput(int native_fd) throws IOException;
 
public void shutdownOutput() throws IOException
{
shutdownOutput(nfd.getNativeFD());
}
 
private static native void shutdownOutput(int native_fd) throws IOException;
 
public void sendUrgentData(int data) throws IOException
{
sendUrgentData(nfd.getNativeFD(), data);
}
 
private static native void sendUrgentData(int natfive_fd, int data) throws IOException;
 
public void close() throws IOException
{
nfd.close();
}
 
// Inner classes.
 
/**
* Our wrapper for the native file descriptor. In this implementation,
* it is a simple wrapper around {@link VMChannel.State}, to simplify
* management of the native state.
*/
public final class State
{
private VMChannel.State channelFd;
 
State()
{
channelFd = null;
}
 
public boolean isValid()
{
if (channelFd != null)
return channelFd.isValid();
return false;
}
 
public int getNativeFD() throws IOException
{
return channelFd.getNativeFD();
}
 
public void setChannelFD(final VMChannel.State nfd) throws IOException
{
if (this.channelFd != null && this.channelFd.isValid())
throw new IOException("file descriptor already initialized");
this.channelFd = nfd;
}
 
public void close() throws IOException
{
if (channelFd == null)
throw new IOException("invalid file descriptor");
channelFd.close();
}
 
protected void finalize() throws Throwable
{
try
{
if (isValid())
close();
}
finally
{
super.finalize();
}
}
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/net/VMPlainDatagramSocketImpl.java
0,0 → 1,260
/* PlainDatagramSocketImpl.java -- VM interface for DatagramSocket impl
Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.java.net;
 
import gnu.classpath.Configuration;
 
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketAddress;
import java.net.SocketException;
 
/**
* The VM interface for {@link gnu.java.net.PlainDatagramSocketImpl}.
*
* @author Ingo Proetel (proetel@aicas.com)
* @author Roman Kennke (kennke@aicas.com)
*/
public final class VMPlainDatagramSocketImpl
{
/**
* Option id for the IP_TTL (time to live) value.
*/
static final int IP_TTL = 0x1E61; // 7777
 
 
// Static initializer to load native library
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javanet");
}
}
 
/**
* Binds this socket to a particular port and interface
*
* @param socket the socket object
* @param port the port to bind to
* @param addr the address to bind to
*
* @throws SocketException If an error occurs
*/
static native void bind(PlainDatagramSocketImpl socket, int port,
InetAddress addr)
throws SocketException;
 
/**
* Creates a new datagram socket.
*
* @param socket the socket object
*
* @throws SocketException If an error occurs
*/
static native void create(PlainDatagramSocketImpl socket)
throws SocketException;
 
/**
* Connects to the remote address and port specified as arguments.
*
* @param socket the socket object
* @param addr the remote address to connect to
* @param port the remote port to connect to
*
* @throws SocketException If an error occurs
*/
static native void connect(PlainDatagramSocketImpl socket, InetAddress addr,
int port)
throws SocketException;
 
/**
* Sends a packet of data to a remote host.
*
* @param socket the socket object
* @param packet the packet to send
*
* @throws IOException If an error occurs
*/
static void send(PlainDatagramSocketImpl socket, DatagramPacket packet)
throws IOException
{
nativeSendTo(socket, packet.getAddress(), packet.getPort(),
packet.getData(), packet.getOffset(), packet.getLength());
}
 
 
/**
* Sends a packet of data to a remote host.
*
* @param socket the socket object
* @param addr the address to send to
* @param port the port to send to
* @param buf the buffer to send
* @param offset the offset of the data in the buffer to send
* @param len the length of the data to send
*
* @throws IOException If an error occurs
*/
private static native void nativeSendTo(PlainDatagramSocketImpl socket,
InetAddress addr, int port,
byte[] buf, int offset, int len)
throws IOException;
 
/**
* Receives a UDP packet from the network
*
* @param socket the socket object
* @param packet the packet to fill in with the data received
*
* @throws IOException IOException If an error occurs
*/
static void receive(PlainDatagramSocketImpl socket, DatagramPacket packet)
throws IOException
{
byte[] receiveFromAddress = new byte[4];
int[] receiveFromPort = new int[1];
int[] receivedLength = new int[1];
 
nativeReceive(socket, packet.getData(), packet.getOffset(),
packet.getLength(),
receiveFromAddress, receiveFromPort, receivedLength);
 
packet.setAddress(InetAddress.getByAddress(receiveFromAddress));
packet.setPort(receiveFromPort[0]);
packet.setLength(receivedLength[0]);
}
 
private static native void nativeReceive(PlainDatagramSocketImpl socket,
byte[] buf, int offset, int len,
byte[] receiveFromAddress,
int[] receiveFromPort,
int[] receivedLength)
throws IOException;
 
/**
* Sets the value of an option on the socket
*
* @param socket the socket object
* @param optionId the identifier of the option to set
* @param value the value of the option to set
*
* @exception SocketException If an error occurs
*/
static native void setOption(PlainDatagramSocketImpl socket, int optionId,
Object value)
throws SocketException;
 
/**
* Retrieves the value of an option on the socket.
*
* @param socket the socket object
* @param optionId the identifier of the option to retrieve
*
* @return the value of the option
*
* @throws SocketException if an error occurs
*/
static native Object getOption(PlainDatagramSocketImpl socket, int optionId)
throws SocketException;
 
/**
* Closes the socket.
*
* @param socket the socket object
*/
static native void close(PlainDatagramSocketImpl socket);
 
/**
* Joins a multicast group
*
* @param addr The group to join
*
* @exception IOException If an error occurs
*/
static native void join(PlainDatagramSocketImpl socket, InetAddress addr)
throws IOException;
 
/**
* Leaves a multicast group
*
* @param addr The group to leave
*
* @exception IOException If an error occurs
*/
static native void leave(PlainDatagramSocketImpl socket, InetAddress addr)
throws IOException;
 
/**
* Joins a multicast group.
*
* @param socket the socket object
* @param address the socket address
* @param netIf the network interface
*
* @throws IOException if I/O errors occur
*/
static void joinGroup(PlainDatagramSocketImpl socket, SocketAddress address,
NetworkInterface netIf)
throws IOException
{
throw new InternalError
("PlainDatagramSocketImpl::joinGroup is not implemented");
}
 
/**
* Leaves a multicast group.
*
* @param socket the socket object
* @param address the socket address
* @param netIf the network interface
*
* @throws IOException if I/O errors occur
*/
static void leaveGroup(PlainDatagramSocketImpl socket, SocketAddress address,
NetworkInterface netIf)
throws IOException
{
throw new InternalError
("PlainDatagramSocketImpl::leaveGroup is not implemented");
}
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/java/security/jce/prng/VMSecureRandom.java
0,0 → 1,129
/* VMSecureRandom.java -- random seed generator.
Copyright (C) 2006 Free Software Foundation, Inc.
 
This file is a 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 of the License, 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; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
USA
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.java.security.jce.prng;
 
/**
* VM-specific methods for generating real (or almost real) random
* seeds. VM implementors should write a version of this class that
* reads random bytes from some system source.
*
* <p>The default implementation of this class runs eight threads that
* increment counters in a tight loop, and XORs each counter to
* produce one byte of seed data. This is not very efficient, and is
* not guaranteed to be random (the thread scheduler is probably
* deterministic, after all). If possible, VM implementors should
* reimplement this class so it obtains a random seed from a system
* facility, such as a system entropy gathering device or hardware
* random number generator.
*/
final class VMSecureRandom
{
 
/**
* Generate a random seed. Implementations are free to generate
* fewer random bytes than are requested, and leave the remaining
* bytes of the destination buffer as zeros. Implementations SHOULD,
* however, make a best-effort attempt to satisfy the request.
*
* @param buffer The destination buffer.
* @param offset The offset in the buffer to start putting bytes.
* @param length The number of random bytes to generate.
*/
static int generateSeed(byte[] buffer, int offset, int length)
{
if (length < 0)
throw new IllegalArgumentException("length must be nonnegative");
if (offset < 0 || offset + length > buffer.length)
throw new IndexOutOfBoundsException();
 
Spinner[] spinners = new Spinner[8];
int n = 0x1;
for (int i = 0; i < spinners.length; i++)
{
spinners[i] = new Spinner((byte) n);
Thread t = new Thread(spinners[i]);
t.start();
n <<= 1;
}
 
// Wait until at least one spinner has started.
while (!(spinners[0].running || spinners[1].running || spinners[2].running
|| spinners[3].running || spinners[4].running || spinners[5].running
|| spinners[6].running || spinners[7].running))
{
Thread.yield();
}
 
for (int i = offset; i < length; i++)
{
buffer[i] = (byte) (spinners[0].value ^ spinners[1].value ^ spinners[2].value
^ spinners[3].value ^ spinners[4].value ^ spinners[5].value
^ spinners[6].value ^ spinners[7].value);
Thread.yield();
}
 
for (int i = 0; i < spinners.length; i++)
spinners[i].stop();
 
return length;
}
 
static class Spinner implements Runnable
{
volatile byte value;
volatile boolean running;
 
Spinner(final byte initial)
{
value = initial;
}
 
public void run()
{
running = true;
while (running)
value++;
}
 
private void stop()
{
running = false;
}
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMMethod.java
0,0 → 1,189
/* VMMethod.java -- a method in a virtual machine
Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.classpath.jdwp;
 
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
 
import gnu.classpath.jdwp.exception.JdwpException;
import gnu.classpath.jdwp.util.LineTable;
import gnu.classpath.jdwp.util.VariableTable;
 
/**
* This class is really an amalgamation of two classes: one class
* represents a virtual machine method and the other represents
* the JDWP back-end's ID for the method.
*
* @author Keith Seitz (keiths@redhat.com)
*/
public class VMMethod
{
/**
* Returns the size of a JDWP method ID
* @see gnu.classpath.jdwp.id.JdwpId#SIZE
*/
public static final int SIZE = 8;
 
// The class in which this method is declared
private Class _class;
 
// The method's ID
private long _methodId;
 
/**
* Constructs a new VMMethod object. This constructor is protected
* so that only the factory methods of VMVirtualMachine can be used
* to create VMMethods.
*
* @param klass the method's containing class
* @param id method identifier, e.g., jmethodID
* @see gnu.classpath.jdwp.VMVirtualMachine#getAllClassMethods
* @see gnu.classpath.jdwp.VMVirtualMachine#getClassMethod
*/
protected VMMethod(Class klass, long id)
{
_class = klass;
_methodId = id;
}
 
/**
* Returns the internal method ID for this method
*/
public long getId()
{
return _methodId;
}
 
/**
* Returns the method's declaring class
*/
public Class getDeclaringClass()
{
return _class;
}
 
/**
* Returns the name of this method
*/
public native String getName();
 
/**
* Returns the signature of this method
*/
public native String getSignature();
 
/**
* Returns the method's modifier flags
*/
public native int getModifiers();
 
/**
* "Returns line number information for the method, if present. The line
* table maps source line numbers to the initial code index of the line.
* The line table is ordered by code index (from lowest to highest). The
* line number information is constant unless a new class definition is
* installed using RedefineClasses."
*
* @return the line table
* @throws JdwpException
*/
public native LineTable getLineTable()
throws JdwpException;
 
/**
* "Returns variable information for the method. The variable table
* includes arguments and locals declared within the method. For instance
* methods, the "this" reference is included in the table. Also, synthetic
* variables may be present."
*
* @return the variable table
* @throws JdwpException
*/
public native VariableTable getVariableTable()
throws JdwpException;
 
/**
* Returns a string representation of this method (not
* required but nice for debugging).
*/
public String toString()
{
return getDeclaringClass().getName() + "." + getName();
}
 
/**
* Writes the method's ID to the output stream
*
* @param ostream the output stream to which to write
* @throws IOException for any errors writing to the stream
* @see gnu.classpath.jdwp.id.JdwpId#write
*/
public void writeId(DataOutputStream ostream)
throws IOException
{
ostream.writeLong(getId());
}
 
/**
* Returns a VMMethod from the ID in the byte buffer
*
* @param klass the method's declaring class
* @param bb a ByteBuffer containing the method's ID
* @throws JdwpException for any errors creating the method
* @throws IOException for any errors reading from the buffer
*/
public static VMMethod readId(Class klass, ByteBuffer bb)
throws JdwpException, IOException
{
return VMVirtualMachine.getClassMethod(klass, bb.getLong());
}
 
public boolean equals(Object obj)
{
if (obj instanceof VMMethod)
{
VMMethod m = (VMMethod) obj;
return (getId() == m.getId());
}
 
return false;
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java
0,0 → 1,435
/* VMIdManager.java -- A reference/example implementation of a manager for
JDWP object/reference type IDs
 
Copyright (C) 2005, 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.classpath.jdwp;
 
import gnu.classpath.jdwp.exception.InvalidClassException;
import gnu.classpath.jdwp.exception.InvalidObjectException;
import gnu.classpath.jdwp.id.*;
 
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.nio.ByteBuffer;
import java.util.HashMap;
import java.util.Hashtable;
 
/**
* This class manages objects and referencetypes that are reported
* to the debugger. All objects and referencetypes reported to the
* debugger should go through this manager.
*
* A brief summary of what an <code>IdManager</code> must provide:
*
* <code>
* public ObjectId getObjectId (Object theObject);
* public ObjectId get (long id);
* public ObjectId readObjectId (ByteBuffer bb);
* public ReferenceTypeId getReferenceTypeId (Class clazz);
* public ReferenceTypeId getReferenceType (long id);
* public ReferenceTypeId readReferenceTypeId (ByteBuffer bb);
* </code>
*
* See the javadoc on these methods later in this file for more
* information on these functions.
*
* <b>NOTE:</b> All IDs handled by the ID manager (all object and reference
* type IDs) are assumed to be of type <code>long</code>.
*
* <b>NOTE:</b> This class does not manage virtual machine-specific types,
* like methods, fields, and frames. These already have unique IDs within
* the virtual machine and do not need further abstraction here.
*
* @author Keith Seitz (keiths@redhat.com)
*/
public class VMIdManager
{
// This factory generates ids for objects and types that may
// be sent to a debugger.
private static class IdFactory
{
// ID of last object / referencetype
private static Object _idLock = new Object ();
private static Object _ridLock = new Object ();
private static long _lastId = 0;
private static long _lastRid = 0;
 
// A list of all ID types
private static HashMap _idList = new HashMap ();
 
// Initialize the id list with known types
static
{
// ObjectId and ArrayId are special cases. See newObjectId.
_idList.put (ClassLoaderId.typeClass, ClassLoaderId.class);
_idList.put (ClassObjectId.typeClass, ClassObjectId.class);
_idList.put (StringId.typeClass, StringId.class);
_idList.put (ThreadId.typeClass, ThreadId.class);
_idList.put (ThreadGroupId.typeClass, ThreadGroupId.class);
}
 
/**
* Returns a new id for the given object
*
* @param obj SoftReference of the object for which an id is desired
* @returns a suitable object id
*/
public static ObjectId newObjectId (SoftReference obj)
{
ObjectId id = null;
Object object = obj.get ();
 
// Special case: arrays
if (object.getClass ().isArray ())
id = new ArrayId ();
else
{
// Loop through all classes until we hit baseclass
Class myClass;
for (myClass = object.getClass (); myClass != null;
myClass = myClass.getSuperclass ())
{
Class clz = (Class) _idList.get (myClass);
if (clz != null)
{
try
{
id = (ObjectId) clz.newInstance ();
synchronized (_idLock)
{
id.setId (++_lastId);
}
id.setReference (obj);
return id;
}
catch (InstantiationException ie)
{
// This really should not happen
throw new RuntimeException ("cannot create new ID", ie);
}
catch (IllegalAccessException iae)
{
// This really should not happen
throw new RuntimeException ("illegal access of ID", iae);
}
}
}
 
/* getSuperclass returned null and no matching ID type found.
So it must derive from Object. */
id = new ObjectId ();
}
 
synchronized (_idLock)
{
id.setId (++_lastId);
}
id.setReference (obj);
return id;
}
 
/**
* Returns a new reference type id for the given class
*
* @param ref SoftReference to the desired type
* @returns a suitable reference type id or null when the
* reference is cleared.
*/
public static ReferenceTypeId newReferenceTypeId (SoftReference ref)
{
ReferenceTypeId id;
Class clazz = (Class) ref.get ();
if (clazz == null)
return null;
 
if (clazz.isArray ())
id = new ArrayReferenceTypeId ();
else if (clazz.isInterface ())
id = new InterfaceReferenceTypeId ();
else
id = new ClassReferenceTypeId ();
id.setReference (ref);
synchronized (_ridLock)
{
id.setId (++_lastRid);
}
return id;
}
}
 
/**
* This class is a SoftReferenceIdentity type that is used by
* the ID manager.
*/
class ReferenceKey extends SoftReference
{
// Hash code of referent
private int _hash;
 
/**
* Constructs a new <code>ReferenceKey</code> object
* with the given referent.
*
* <p>This constructor should only be used for object lookups
* by the backend.
*
* @param referent the object to reference
*/
public ReferenceKey (Object referent)
{
super (referent);
_hash = referent.hashCode ();
}
 
/**
* Constructs a new <code>ReferenceKey</code> object
* with the given referent and reference queue.
*
* <p>The JDWP back-end stores a <code>ReferenceKey</code>
* with its corresponding <code>JdwpId</code>. This constructor
* is used by the back-end when adding new IDs to be managed.
*
* @param referent the object to reference
* @param queue the queue to which to report garbage collections
*/
public ReferenceKey (Object referent, ReferenceQueue queue)
{
super (referent, queue);
_hash = referent.hashCode ();
}
 
/**
* Returns the hash code of the referent.
* This seems hacky, but is required in order to use this class
* as a hash table key.
*
* @returns the hash code of the referent
*/
public int hashCode ()
{
return _hash;
}
 
/**
* Comparator for keys
*
* This method can be used in two ways:
*
* <ol>
* <li>For table lookups, where we want to compare referents</li>
* <li>For clearing GCd objects, where we want to compare the actual
* key object (not the referent)</li>
* </ol>
*/
public boolean equals (Object obj)
{
if (obj instanceof ReferenceKey)
{
ReferenceKey ref = (ReferenceKey) obj;
 
/* First check if the two references are the same.
If they are, that means we must be clearing GCd objects. */
if (this == obj)
return true;
 
return (ref.get () == get ());
}
 
return false;
}
}
 
// instance of VMIdManager
private static VMIdManager _idm = new VMIdManager ();
 
// A reference queue for our objects
private ReferenceQueue _refQueue;
 
// Mapping of objects (ReferenceKey) to IDs (ObjectId)
private Hashtable _oidTable;
 
// Mapping of ID numbers (Long) to IDs (ObjectId)
private Hashtable _idTable;
 
/* Mapping of class (ReferenceKey) to IDs (ReferenceTypeId) for reference
types. Unlike other types, reference id types are NEVER released. */
private Hashtable _classTable;
 
// Mapping of ID numbers (Long) to reference type IDs (ReferenceTypeId)
private Hashtable _ridTable;
 
/**
* Gets the instance of VMIdManager, constructing a new one
* if none currently exists.
*/
public static VMIdManager getDefault ()
{
return _idm;
}
 
// Constructs a new <code>IdManager</code>
private VMIdManager ()
{
_refQueue = new ReferenceQueue ();
_oidTable = new Hashtable (50);
_idTable = new Hashtable (50);
_classTable = new Hashtable (20);
_ridTable = new Hashtable (20);
}
 
// Updates the object ID table, removing IDs whose objects have
// been garbage collected.
private void _update ()
{
Reference ref;
while ((ref = _refQueue.poll ()) != null)
{
ObjectId id = (ObjectId) _oidTable.get (ref);
_oidTable.remove (ref);
_idTable.remove (new Long (id.getId ()));
}
}
 
/**
* Returns an id for the given object, adding it
* if it does not have an id.
*
* @param theObject the object to get an ID/add
* @returns the ID of the object
*/
public ObjectId getObjectId (Object theObject)
{
// Special case: null
if (theObject == null)
return new NullObjectId ();
 
ReferenceKey ref = new ReferenceKey (theObject, _refQueue);
ObjectId id = (ObjectId) _oidTable.get (ref);
if (id == null)
{
// update the tables -- this is an arbitrary place to put this
_update ();
 
// Object not found. Make new id for it
id = IdFactory.newObjectId (ref);
_oidTable.put (ref, id);
_idTable.put (new Long (id.getId ()), id);
}
 
return id;
}
 
/**
* Returns the <code>JdwpId</code> for a given ID. Unlike
* <code>getId</code>, it throws an exception if the ID is not
* known.
*
* @param id the numerical ID of the desired <code>JdwpId</code>
* @throws InvalidObjectException if the ID is not found
*/
public ObjectId get (long id)
throws InvalidObjectException
{
// Special case: null
if (id == 0)
return new NullObjectId ();
 
ObjectId oid = (ObjectId) _idTable.get (new Long (id));
if (oid == null)
throw new InvalidObjectException (id);
 
return oid;
}
 
public ObjectId readObjectId (ByteBuffer bb)
throws InvalidObjectException
{
long id = bb.getLong ();
return get (id);
}
 
/**
* Gets the reference type id for the given class, creating
* a new one if it does not already have an id
*
* @param clazz the class for which to get an ID
* @returns the ID of the class
*/
public ReferenceTypeId getReferenceTypeId (Class clazz)
{
ReferenceKey ref = new ReferenceKey (clazz);
ReferenceTypeId id = (ReferenceTypeId)_classTable.get (ref);
if (id == null)
{
// Object not found. Make new id for it
id = IdFactory.newReferenceTypeId (ref);
_classTable.put (ref, id);
_ridTable.put (new Long (id.getId ()), id);
}
 
return id;
}
 
/**
* Returns the <code>ReferenceTypeId</code> for a given ID. Unlike
* <code>getReferenceTypeId</code>, it throws an exception if the ID is not
* known.
*
* @param id the numerical ID of the desired reference type
* @throws InvalidClassException if the ID is not found
*/
public ReferenceTypeId getReferenceType (long id)
throws InvalidClassException
{
ReferenceTypeId rid = (ReferenceTypeId) _ridTable.get (new Long (id));
if (rid == null)
throw new InvalidClassException (id);
 
return rid;
}
 
public ReferenceTypeId readReferenceTypeId (ByteBuffer bb)
throws InvalidClassException
{
long id = bb.getLong ();
return getReferenceType (id);
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMFrame.java
0,0 → 1,135
/* VMFrame.java -- Reference implementation of VM hooks for JDWP Frame access.
Copyright (C) 2005, 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.classpath.jdwp;
 
import gnu.classpath.jdwp.util.Location;
import gnu.classpath.jdwp.value.Value;
 
/**
* Reference implementation of VM hooks for JDWP Frame access.
*
* @author aluchko
*/
 
public class VMFrame
{
/**
* Returns the size of a frame ID over JDWP
*/
public static final int SIZE = 8;
 
//The thread this frame resides in
private Thread thread;
 
// The object this frame resides in
private Object obj;
 
// The current location of this frame
private Location loc;
 
// id of this frame
private long id;
 
/**
* Create a new VMFrame object.
*
* @param thr a Thread, the thread this frame is in
* @param frame_id a long, the jframeID of this frame
* @param frame_loc a Location, the location of this frame
* @param frame_obj the "this" object of this frame
*/
public VMFrame(Thread thr, long frame_id, Location frame_loc,
Object frame_obj)
{
thread = thr;
id = frame_id;
loc = frame_loc;
obj = frame_obj;
}
 
/**
* Gets the current location of the frame.
*/
public Location getLocation()
{
return loc;
}
 
/**
* Returns the value of the variable in the given slot.
*
* @param slot the slot containing the variable
*/
public native Value getValue(int slot, byte sig);
 
/**
* Assigns the given variable to the given value.
* @param slot The slot which contains the variable
* @param value The value to assign the variable to
*/
public native void setValue(int slot, Value value);
 
/**
* Get the thread this frame is in.
*/
public Thread getThread()
{
return thread;
}
 
/**
* Get the object which is represented by 'this' in the context of the frame,
* returns null if the method is native or static.
*/
public Object getObject()
{
return obj;
}
 
/**
* Get the frameID
* @return an id which is unique within the scope of the VM
*/
public long getId()
{
return id;
}
 
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMVirtualMachine.java
0,0 → 1,425
/* VMVirtualMachine.java -- A reference implementation of a JDWP virtual
machine
 
Copyright (C) 2005, 2006, 2007 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.classpath.jdwp;
 
import gnu.classpath.jdwp.event.EventRequest;
import gnu.classpath.jdwp.exception.InvalidMethodException;
import gnu.classpath.jdwp.exception.JdwpException;
import gnu.classpath.jdwp.util.MethodResult;
import gnu.classpath.jdwp.util.MonitorInfo;
import gnu.classpath.jdwp.value.Value;
 
import java.util.ArrayList;
import java.util.Collection;
 
/**
* A virtual machine according to JDWP.
*
* @author Keith Seitz <keiths@redhat.com>
*/
public class VMVirtualMachine
{
// VM Capabilities
public static final boolean canWatchFieldModification = false;
public static final boolean canWatchFieldAccess = false;
public static final boolean canGetBytecodes = false;
public static final boolean canGetSyntheticAttribute = false;
public static final boolean canGetOwnedMonitorInfo = false;
public static final boolean canGetCurrentContendedMonitor = false;
public static final boolean canGetMonitorInfo = false;
public static final boolean canRedefineClasses = false;
public static final boolean canAddMethod = false;
public static final boolean canUnrestrictedlyRedefineClasses = false;
public static final boolean canPopFrames = false;
public static final boolean canUseInstanceFilters = false;
public static final boolean canGetSourceDebugExtension = false;
public static final boolean canRequestVMDeathEvent = false;
public static final boolean canSetDefaultStratum = false;
 
/**
* Suspend a thread
*
* @param thread the thread to suspend
*/
public static native void suspendThread(Thread thread)
throws JdwpException;
 
/**
* Suspend all threads
*/
public static void suspendAllThreads()
throws JdwpException
{
// Our JDWP thread group -- don't suspend any of those threads
Thread current = Thread.currentThread ();
ThreadGroup jdwpGroup = Jdwp.getDefault().getJdwpThreadGroup();
 
// Find the root ThreadGroup
ThreadGroup group = jdwpGroup;
ThreadGroup parent = group.getParent ();
while (parent != null)
{
group = parent;
parent = group.getParent ();
}
 
// Get all the threads in the system
int num = group.activeCount ();
Thread[] threads = new Thread[num];
group.enumerate (threads);
 
for (int i = 0; i < num; ++i)
{
Thread t = threads[i];
if (t != null)
{
if (t.getThreadGroup () == jdwpGroup || t == current)
{
// Don't suspend the current thread or any JDWP thread
continue;
}
else
suspendThread (t);
}
}
 
// Now suspend the current thread
if (current.getThreadGroup() != jdwpGroup)
suspendThread (current);
}
 
/**
* Resume a thread. A thread must be resumed as many times
* as it has been suspended.
*
* @param thread the thread to resume
*/
public static native void resumeThread(Thread thread)
throws JdwpException;
 
/**
* Resume all threads. This simply decrements the thread's
* suspend count. It can not be used to force the application
* to run.
*/
public static void resumeAllThreads()
throws JdwpException
{
// Our JDWP thread group -- don't resume
Thread current = Thread.currentThread ();
ThreadGroup jdwpGroup = current.getThreadGroup ();
 
// Find the root ThreadGroup
ThreadGroup group = jdwpGroup;
ThreadGroup parent = group.getParent ();
while (parent != null)
{
group = parent;
parent = group.getParent ();
}
 
// Get all the threads in the system
int num = group.activeCount ();
Thread[] threads = new Thread[num];
group.enumerate (threads);
 
for (int i = 0; i < num; ++i)
{
Thread t = threads[i];
if (t != null)
{
if (t.getThreadGroup () == jdwpGroup || t == current)
{
// Don't resume the current thread or any JDWP thread
continue;
}
else
resumeThread (t);
}
}
}
 
/**
* Get the suspend count for a give thread
*
* @param thread the thread whose suspend count is desired
* @return the number of times the thread has been suspended
*/
public static native int getSuspendCount(Thread thread)
throws JdwpException;
 
/**
* Returns a Collection of all classes loaded in the VM
*/
public static native Collection getAllLoadedClasses()
throws JdwpException;
 
/**
* Returns the status of the given class
*
* @param clazz the class whose status is desired
* @return a flag containing the class's status
* @see JdwpConstants.ClassStatus
*/
public static native int getClassStatus(Class clazz)
throws JdwpException;
 
/**
* Returns all of the methods defined in the given class. This
* includes all methods, constructors, and class initializers.
*
* @param klass the class whose methods are desired
* @return an array of virtual machine methods
*/
public static native VMMethod[] getAllClassMethods(Class klass)
{ return null; }
 
/**
* A factory method for getting valid virtual machine methods
* which may be passed to/from the debugger.
*
* @param klass the class in which the method is defined
* @param id the ID of the desired method
* @return the desired internal representation of the method
* @throws InvalidMethodException if the method is not defined
* in the class
* @throws JdwpException for any other error
*/
public static native VMMethod getClassMethod(Class klass, long id)
{ return null; }
 
/**
* Returns the thread's call stack
*
* @param thread thread for which to get call stack
* @param start index of first frame to return
* @param length number of frames to return (-1 for all frames)
* @return a list of frames
*/
public static native ArrayList getFrames(Thread thread, int start,
int length)
throws JdwpException;
 
/**
* Returns the frame for a given thread with the frame ID in
* the buffer
*
* I don't like this.
*
* @param thread the frame's thread
* @param bb buffer containing the frame's ID
* @return the desired frame
*/
public static native VMFrame getFrame(Thread thread, long frameID)
throws JdwpException;
 
/**
* Returns the number of frames in the thread's stack
*
* @param thread the thread for which to get a frame count
* @return the number of frames in the thread's stack
*/
public static native int getFrameCount(Thread thread)
throws JdwpException;
 
 
/**
* Returns the status of a thread
*
* @param thread the thread for which to get status
* @return integer status of the thread
* @see JdwpConstants.ThreadStatus
*/
public static native int getThreadStatus(Thread thread)
throws JdwpException;
 
/**
* Returns a list of all classes which this class loader has been
* requested to load
*
* @param cl the class loader
* @return a list of all visible classes
*/
public static native ArrayList getLoadRequests(ClassLoader cl)
throws JdwpException;
 
/**
* Executes a method in the virtual machine. The thread must already
* be suspended by a previous event. When the method invocation is
* complete, the thread (or all threads if INVOKE_SINGLE_THREADED is
* not set in options) must be suspended before this method returns.
*
* @param obj instance in which to invoke method (null for static)
* @param thread the thread in which to invoke the method
* @param clazz the class in which the method is defined
* @param method the method to invoke
* @param values arguments to pass to method
* @param options invocation options
* @return a result object containing the results of the invocation
*/
public static native MethodResult executeMethod (Object obj, Thread thread,
Class clazz, VMMethod method,
Value[] values,
int options)
throws JdwpException;
 
/**
* "Returns the name of source file in which a reference type was declared"
*
* @param clazz the class for which to return a source file
* @return a string containing the source file name; "no path information
* for the file is included"
*/
public static native String getSourceFile(Class clazz)
throws JdwpException;
 
/**
* Register a request from the debugger
*
* Virtual machines have two options. Either do nothing and allow
* the event manager to take care of the request (useful for broadcast-type
* events like class prepare/load/unload, thread start/end, etc.)
* or do some internal work to set up the event notification (useful for
* execution-related events like breakpoints, single-stepping, etc.).
*/
public static native void registerEvent(EventRequest request)
throws JdwpException;
 
/**
* Unregisters the given request
*
* @param request the request to unregister
*/
public static native void unregisterEvent(EventRequest request)
throws JdwpException;
 
 
/**
* Clear all events of the given kind
*
* @param kind the type of events to clear
*/
public static native void clearEvents(byte kind)
throws JdwpException;
 
/**
* Redefines the given types. VM must support canRedefineClasses
* capability (may also require canAddMethod and/or
* canUnrestrictedlyRedefineClasses capabilities)
*
* @param types the classes to redefine
* @param bytecodes the new bytecode definitions for the classes
*/
public static native void redefineClasses(Class[] types, byte[][] bytecodes)
throws JdwpException;
 
/**
* Sets the default stratum. VM must support the
* canSetDefaultStratum capability.
*
* @param stratum the new default stratum or empty string to
* use the reference default
*/
public static native void setDefaultStratum(String stratum)
throws JdwpException;
 
/**
* Returns the source debug extension. VM must support the
* canGetSourceDebugExtension capability.
*
* @param klass the class for which to return information
* @returns the source debug extension
*/
public static native String getSourceDebugExtension(Class klass)
throws JdwpException;
 
/**
* Returns the bytecode for the given method. VM must support the
* canGetBytecodes capability.
*
* @param method the method for which to get bytecodes
* @returns the bytecodes
*/
public static native byte[] getBytecodes(VMMethod method)
throws JdwpException;
 
/**
* Returns monitor information about an object. VM must support
* the canGetMonitorInformation capability.
*
* @param obj the object
* @returns monitor information (owner, entry count, waiters)
*/
public static native MonitorInfo getMonitorInfo(Object obj)
throws JdwpException;
 
/**
* Returns a list of owned monitors. VM must support the
* canGetOwnedMonitorInfo capability.
*
* @param thread a thread
* @returns the list of monitors owned by this thread
*/
public static native Object[] getOwnedMonitors(Thread thread)
throws JdwpException;
 
/**
* Returns the current contended monitor for a thread. VM must
* support canGetCurrentContendedMonitor capability.
*
* @param thread the thread
* @returns the contended monitor
*/
public static native Object getCurrentContendedMonitor(Thread thread)
throws JdwpException;
 
/**
* Pop all frames up to and including the given frame. VM must
* support canPopFrames capability. It is the responsibility
* of the VM to check if the thread is suspended. If it is not,
* the VM should throw ThreadNotSuspendedException.
*
* @param thread the thread
* @param frame the frame ID
*/
public static native void popFrames(Thread thread, long frameId);
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/classpath/VMSystemProperties.java
0,0 → 1,97
/* VMSystemProperties.java -- Allow the VM to set System properties.
Copyright (C) 2004 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.classpath;
 
import java.util.Properties;
 
class VMSystemProperties
{
/**
* 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
* <dt>gnu.cpu.endian <dd>"big" or "little"
* </dl>
*
* @param properties the Properties object to insert the system properties into
*/
static native void preInit(Properties properties);
 
/**
* Here you get a chance to overwrite some of the properties set by
* the common SystemProperties code. For example, it might be
* a good idea to process the properties specified on the command
* line here.
*/
static void postInit(Properties properties)
{
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/gnu/classpath/VMStackWalker.java
0,0 → 1,131
/* VMStackWalker.java -- Reference implementation of VM hooks for stack access
Copyright (C) 2005, 2006 Free Software Foundation
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
 
package gnu.classpath;
 
/**
* This class provides access to the classes on the Java stack
* for reflection and security purposes.
*
* <p>
* This class is only available to privileged code (i.e., code loaded
* by the bootstrap loader).
*
* @author John Keiser
* @author Eric Blake <ebb9@email.byu.edu>
* @author Archie Cobbs
*/
public final class VMStackWalker
{
/**
* Get a list of all the classes currently executing methods on the
* Java stack. <code>getClassContext()[0]</code> is the class associated
* with the currently executing method, i.e., the method that called
* <code>VMStackWalker.getClassContext()</code> (possibly through
* reflection). So you may need to pop off these stack frames from
* the top of the stack:
* <ul>
* <li><code>VMStackWalker.getClassContext()</code>
* <li><code>Method.invoke()</code>
* </ul>
*
* @return an array of the declaring classes of each stack frame
*/
public static native Class[] getClassContext();
 
/**
* Get the class associated with the method invoking the method
* invoking this method, or <code>null</code> if the stack is not
* that deep (e.g., invoked via JNI invocation API). This method
* is an optimization for the expression <code>getClassContext()[1]</code>
* and should return the same result.
*
* <p>
* VM implementers are encouraged to provide a more efficient
* version of this method.
*/
public static Class getCallingClass()
{
Class[] ctx = getClassContext();
if (ctx.length < 3)
return null;
return ctx[2];
}
 
/**
* Get the class loader associated with the Class returned by
* <code>getCallingClass()</code>, or <code>null</code> if no such class
* exists or it is the boot loader. This method is an optimization for the
* expression <code>VMStackWalker.getClassLoader(getClassContext()[1])</code>
* and should return the same result.
*
* <p>
* VM implementers are encouraged to provide a more efficient
* version of this method.
*/
public static ClassLoader getCallingClassLoader()
{
Class[] ctx = getClassContext();
if (ctx.length < 3)
return null;
return getClassLoader(ctx[2]);
}
 
/**
* Retrieve the class's ClassLoader, or <code>null</code> if loaded
* by the bootstrap loader. I.e., this should return the same thing
* as {@link java.lang.VMClass#getClassLoader}. This duplicate version
* is here to work around access permissions.
*/
public static native ClassLoader getClassLoader(Class cl);
 
/**
* Walk up the stack and return the first non-null class loader.
* If there aren't any non-null class loaders on the stack, return null.
*/
public static ClassLoader firstNonNullClassLoader()
{
Class[] stack = getClassContext();
for (int i = 0; i < stack.length; i++)
{
ClassLoader loader = getClassLoader(stack[i]);
if (loader != null)
return loader;
}
return null;
}
}
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/Makefile.am
0,0 → 1,3
# used by automake to generate Makefile.in
 
SUBDIRS = java gnu
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference/.cvsignore
0,0 → 1,2
Makefile
Makefile.in
/gnu-dev/or1k-gcc/libjava/classpath/vm/reference
gnu-dev/or1k-gcc/libjava/classpath/vm/reference Property changes : Added: svn:ignore ## -0,0 +1 ## +Makefile

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.