cvm.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

                                           int[] dst, int dst_position,
                                           int length);
    public native static void copyFloatArray(float[] src, int src_position,
                                             float[] dst, int dst_position,
                                             int length);
    public native static void copyLongArray(long[] src, int src_position,
                                            long[] dst, int dst_position,
                                            int length);
    public native static void copyDoubleArray(double[] src, int src_position,
                                              double[] dst, int dst_position,
                                              int length);

    /* copyObjectArray() copies array elements from one array to another.
       Unlike System.arraycopy(), this method can only copy elements for
       non-primitive arrays with some restrictions.  The restrictions are that
       the src and dst array must be of the same type, or the dst array must
       be of type java.lang.Object[] (not just a compatible sub-type).  The
       caller is responsible for doing the appropriate null checks, bounds
       checks, array element type assignment checks if necessary, and ensure
       that the passed in arguments do violate any of these checks and
       restrictions.  If the condition of these checks and restrictions are
       not taken cared of by the caller, copyObjectArray() can fail in
       unpredictable ways.
    */
    public native static void copyObjectArray(Object[] src, int src_position,
                                              Object[] dst, int dst_position,
                                              int length);
    public static void copyArray(Object[] src, int src_position,
                                 Object[] dst, int dst_position,
                                 int length) {
        System.arraycopy(src, src_position, dst, dst_position, length);
    }

    /*
     * Used by Class.runStaticInitializers() to execute the <linit> method
     * of the specified class.
     */
    public native static void executeClinit(Class c);

    /*
     * Use by Class.runStaticInitializers() to free up the code for the 
     * specified class' <clinit> method.
     */
    public native static void freeClinit(Class c);

    /*
     * Used by Launcher.defineClassPrivate() to execute the 
     * Class.loadSuperClasses method in a way that avoids C recursion.
     */
    native static void executeLoadSuperClasses(Class c);

    /*
     * Manage remote exceptions 
     */
    public native static void disableRemoteExceptions();
    public native static void enableRemoteExceptions();
    // Should be invoked through Thread.stop() that ensures target's ee is alive
    public native static void throwRemoteException(Thread target, Throwable t);

    /*
     * Manage interrupts
     */
    // Returns true if interrupts were already masked.  No
    // internal nesting count is maintained.
    public native static boolean maskInterrupts();
    // Should only be called if maskInterrupts() returned false
    public native static void unmaskInterrupts();

    /*
     * Allows system methods to bypass compiler checks and throw
     * exceptions.  Useful for rewriting native methods in Java.
     */
    public native static Error throwLocalException(Throwable t);

    /*
     * Mark current context as artificial
     */
    public native static void setContextArtificial();


    /* CLDC/MIDP support */
    /*
     * Used to find out if the classloader of the caller's caller
     * is sun.misc.MIDletClassLoader or 
     * sun.misc.MIDPImplementationClassLoader.
     */
    public static native boolean callerCLIsMIDCLs();

    /*
     * Returns true if method is being called in a MIDP context.
     */
    public static native boolean isMIDPContext();

    // %begin lvm
    /*
     * Used to suppress initialization of Reference handler 
     * (java.lang.ref.Reference) in a child Logical VM.
     */
    public native static boolean inMainLVM();
    // %end lvm

    /*
     * Some heap dumping utilties.
     */
    public native static void gcDumpHeapSimple();
    public native static void gcDumpHeapVerbose();
    public native static void gcDumpHeapStats();

    public native static void trace(int i);

    public native static void setDebugEvents(boolean on);
    public native static void postThreadExit();

    /* Inflates an object's monitor and mark it sticky so it's never freed. */
    public native static boolean objectInflatePermanently(Object obj);

    /* enable/disable compilations by current thread */
    public static native void setThreadNoCompilationsFlag(boolean enable);
    /** Returns the class of the method <code>realFramesToSkip</code>
        frames up the stack (zero-based), ignoring frames associated
        with java.lang.reflect.Method.invoke() and its implementation.
        The first frame is that associated with this method, so
        <code>getCallerClass(0)</code> returns the Class object for
        sun.reflect.Reflection. Frames associated with
        java.lang.reflect.Method.invoke() and its implementation are
        completely ignored and do not count toward the number of "real"
        frames skipped. */
    public native static Class getCallerClass(int realFramesToSkip);

    //
    // True if JIT supported, false otherwise
    //
    public native static boolean isCompilerSupported();

    // Request a dump of the profiling data collected by the compiler if
    // available:
    public native static void dumpCompilerProfileData();
    //
    // Dump various stats
    //
    public native static void dumpStats();

    //
    // Mark the current location of the code buffer. Below this mark,
    // methods are supposed to be persistent.
    //
    public native static void markCodeBuffer();

    //
    // Enable compilation.
    //
    public native static void initializeJITPolicy();

    //
    // Initialize pre-compiled code.
    //
    public native static boolean initializeAOTCode();

    //
    // Re-parse the -Xverify option from the Java side
    //
    public native static boolean parseVerifyOptions(String verifyArg);

    //
    // Re-parse the -Xopt options from the Java side
    //
    public native static boolean parseXoptOptions(String xoptArg);

    //
    // Re-parse the -Xgc options from the Java side
    //
    public native static boolean parseXgcOptions(String xgcArg);

    //
    // Re-parse the -Xss options from the Java side
    //
    public native static boolean parseXssOption(String xssArg);

    //
    // Parse assertion options
    //
    public native static boolean parseAssertionOptions(String xgcArg);

    //
    // Is -agentlib, -agentpath supported?
    //
    public native static boolean agentlibSupported();

    //
    // Initialize agentlib processing
    //
    public native static boolean agentlibInitialize(int numOptions);

    //
    // Process agentlib option
    //
    public native static boolean agentlibProcess(String agentArg);

 
    //
    // Is -Xrun supported?
    //
    public native static boolean xrunSupported();

    //
    // Initialize Xrun processing
    //
    public native static boolean xrunInitialize(int numOptions);

    //
    // Process Xrun option
    //
    public native static boolean xrunProcess(String xrunArg);

    //
    // Enable debugging
    //
    public native static boolean xdebugSet();

    static class Preloader {
	//
	// Register ClassLoader for ROMized classes
	//
	public static boolean registerClassLoader(String name, ClassLoader cl) {
	    String preloadedClassLoaders = getClassLoaderNames();
	    if (preloadedClassLoaders == null) {
		return false;
	    }
	    int classLoaderIndex = 0;
	    StringTokenizer st = new StringTokenizer(preloadedClassLoaders, ",");
	    while (st.hasMoreTokens()) {
		if (name.equals(st.nextToken())) {
		    registerClassLoader0(classLoaderIndex, cl);
		    return true;
		}
		++classLoaderIndex;
	    }
	    return false;
	}

	private native static String getClassLoaderNames();
	private native static void registerClassLoader0(int clIndex,
	    ClassLoader cl);
    };

    //
    // Intrinsics for faster synchronization of simple methods. There
    // are strict limitations on how and when they used.
    //
    public native static boolean simpleLockGrab(Object lockObj);
    public native static void simpleLockRelease(Object lockObj);

    /**
     * Prints build options used for this build.
     * Called by "-XbuildOptions and -XshowBuildOptions command line options.
     */
    public static void printBuildOptions() {
	System.err.print(getBuildOptionString(null));
    }
    // NOTE: The dummy argument is just a convenient way to reserve space on
    // stack for the return value of this CNI method.
    private static native String getBuildOptionString(Object dummy);

    /*
     * Returns the current value of the most precise available system
     * timer, in nanoseconds.
     *
     * From J2SE System.nanoTime();
     *
     * <p>This method can only be used to measure elapsed time and is
     * not related to any other notion of system or wall-clock time.
     * The value returned represents nanoseconds since some fixed but
     * arbitrary time (perhaps in the future, so values may be
     * negative).  This method provides nanosecond precision, but not
     * necessarily nanosecond accuracy. No guarantees are made about
     * how frequently values change. Differences in successive calls
     * that span greater than approximately 292 years (2<sup>63</sup>
     * nanoseconds) will not accurately compute elapsed time due to
     * numerical overflow.
     *
     * <p> For example, to measure how long some code takes to execute:
     * <pre>
     *   long startTime = System.nanoTime();
     *   // ... the code being measured ...
     *   long estimatedTime = System.nanoTime() - startTime;
     * </pre>
     * 
     * @return The current value of the system timer, in nanoseconds.
     * @since 1.5
     */
    public static native long nanoTime();

    /*
     * Sets java.net.URLConnection.defaultUseCaches to the boolean
     * argument passed in.
     */
    public static native void setURLConnectionDefaultUseCaches(boolean b);

    /*
     * Clears the ucp field of the URLClassLoader passed in, which allows
     * the JarFiles opened by the URLClassLoader to be gc'd and closed,
     * even if the URLClassLoader is kept live.
     */
    public static native void clearURLClassLoaderUcpField(java.net.URLClassLoader cl);
}