On Jul 5, 4:23 pm, Roedy Green <see_webs...@mindprod.com.invalid>
wrote:

That sounds like it might be useful for having blistering fast
scripting capabilities in an app. Scripts can be compiled into actual
Java class files implementing some interface, and then potentially
into native code via Hotspot's JIT. On a server VM, and assuming
dynamically defined classes are eligible for JITting (and I don't see
why not or even how they'd be distinguished, if ALL class loading goes
eventually through this one defineClass method!), user-written scripts
would easily run as fast as natively compiled C code, if not faster
due to optimizations available only due to the optimizer having
knowledge only available at runtime (such as baking in branch
prediction into a lopsided tree structure?)...

This would be useful for spreadsheets (formula cell calculations at
native speed! Beat the crap out of excel and probably even openoffice
in speed!), math-geek software (write your own math function and use
it, and it runs as fast as C compiled with gcc -O3...make Maple and
Mathematica look like they're standing still gawping!) ...

On Jul 5, 4:23 pm, Roedy Green <see_webs...@mindprod.com.invalid>
wrote:

Thanks for the input. I understand the idea behind a custom class
loader and defineClass. As an example I'm writing a simple test case
that, given a jar file on the cmd line, will load all .class files
into the virtual machine. The idea is basically:

1) open jar
2) enumerate jar entries
3) for each non-directory entry that ends in .class, load it

My test loader overrides no methods, and provides an addJar method for
adding jar files. addjar calls loadJarClasses:

    protected void loadJarClasses(JarFile jf) {
        List<String> loaded = new ArrayList<String>();
        List<String> notLoaded = new ArrayList<String>();
        for(Enumeration<JarEntry> jEntries = jf.entries();
jEntries.hasMoreElements();) {
            JarEntry je = jEntries.nextElement();
            String jeName = je.getName();
            if(! je.isDirectory() && jeName.endsWith(".class")) {
                String fullName = jeName.substring(0, jeName.length() -
".class".length()).replace('/', '.');
                try {
                    InputStream in = jf.getInputStream(je);
                    byte[] cbytes = new byte[ (int)je.getSize() /*in.available()*/];
                    int bread = in.read(cbytes);
                    in.close();
                    defineClass(fullName, cbytes, 0, cbytes.length);
                    loaded.add(fullName);
                } catch (Throwable e) {
                    notLoaded.add(fullName);
                    e.printStackTrace();
                }
            }
        }

        System.out.println("\n----------------------------------");
        for(String s : notLoaded) {
            System.out.println("JarClassLoader.loadJarClasses() -- " + s);
        }

        System.out.println("\nJarClassLoader.loadJarClasses() -- loaded " +
loaded.size() + ", failed on " + notLoaded.size());
    }

You'll notice i've added some debugging. The method is supposed to
load all classes in a jar when called, but as it happens, only some
get loaded. For example, when I supply js-1.6R5.jar as the jar to load
(mozilla rhino's jar), 188 classes load and 64 fail to load, with
mysterious java.lang.NoClassDefFoundError errors. The errors provide
no message save for the path name of the class and a stack trace. Any
idea as to what may be going on? I realize my example is simplistic
(currently thats the point), but I may be overlooking something.
There's really no other code that does anything useful so I didn't
include the rest.

thanks again for your input