public JavaEngine() 
{
        // Do compilation-possible check here??????????????
}

Constructor.

 public Object call(Object object,
    String method,
    Object[] args) throws BSFException 
{
        throw new BSFException (BSFException.REASON_UNSUPPORTED_FEATURE,
        "call() is not currently supported by JavaEngine");
}

 public  void compileScript(String source,
    int lineNo,
    int columnNo,
    Object script,
    CodeBuffer cb) throws BSFException 
{
        ObjInfo oldRet = cb.getFinalServiceMethodStatement ();
        if (oldRet != null && oldRet.isExecutable ()) {
            cb.addServiceMethodStatement (oldRet.objName + ";");
        }
        cb.addServiceMethodStatement (script.toString ());
        cb.setFinalServiceMethodStatement (null);
}

 public Object eval(String source,
    int lineNo,
    int columnNo,
    Object oscript) throws BSFException 
{
        Object retval = null;
        String classname = null;
        GeneratedFile gf = null;
        String basescript = oscript.toString();
        String script = basescript;	// May be altered by $$CLASSNAME$$ expansion
        try {
            // Do we already have a class exactly matching this code?
            javaclass = (Class)codeToClass.get(basescript);
            if(javaclass != null) {
                classname=javaclass.getName();
            } else {
                gf = openUniqueFile(tempDir, "BSFJava",".java");
                if( gf == null) {
                    throw new BSFException("couldn't create JavaEngine scratchfile");
                }
                // Obtain classname
                classname = gf.className;
                // Write the kluge header to the file.
                gf.fos.write(("import java.lang.*;"+
                        "import java.util.*;"+
                        "public class "+classname+" {\n" +
                "  static public Object BSFJavaEngineEntry(org.apache.bsf.BSFManager bsf) {\n")
                .getBytes());
                // Edit the script to replace placeholder with the generated
                // classname. Note that this occurs _after_ the cache was checked!
                int startpoint = script.indexOf(placeholder);
                int endpoint;
                if(startpoint  >= 0) {
                    StringBuffer changed = new StringBuffer();
                    for(; startpoint  >=0; startpoint = script.indexOf(placeholder,startpoint)) {
                        changed.setLength(0);	// Reset for 2nd pass or later
                        if(startpoint  > 0) {
                            changed.append(script.substring(0,startpoint));
                        }
                        changed.append(classname);
                        endpoint = startpoint+placeholder.length();
                        if(endpoint <  script.length()) {
                            changed.append(script.substring(endpoint));
                        }
                        script = changed.toString();
                    }
                }
                // MJD - debug
//              BSFDeclaredBean tempBean;
//              String          className;
//              
//              for (int i = 0; i <  declaredBeans.size (); i++) {
//              tempBean  = (BSFDeclaredBean) declaredBeans.elementAt (i);
//              className = StringUtils.getClassName (tempBean.bean.getClass ());
//              
//              gf.fos.write ((className + " " +
//              tempBean.name + " = (" + className +
//              ")bsf.lookupBean(\"" +
//              tempBean.name + "\");").getBytes ());
//              }
                // MJD - debug
                // Copy the input to the file.
                // Assumes all available -- probably mistake, but same as other engines.
                gf.fos.write(script.getBytes());
                // Close the method and class
                gf.fos.write(("\n  }\n}\n").getBytes());
                gf.fos.close();
                // Compile through Java to .class file
                // May not be threadsafe. Serialize access on static object:
                synchronized(serializeCompilation) {
                    JavaUtils.JDKcompile(gf.file.getPath(), classPath);
                }
                // Load class.
                javaclass = EngineUtils.loadClass(mgr, classname);
                // Stash class for reuse
                codeToClass.put(basescript, javaclass);
            }
            Object[] callArgs = {mgr};      
            retval = internalCall(this,"BSFJavaEngineEntry",callArgs);
        }
        catch(Exception e) {
            e.printStackTrace ();
            throw new BSFException (BSFException.REASON_IO_ERROR, e.getMessage ());
        } finally {
            // Cleanup: delete the .java and .class files
//          if(gf!=null && gf.file!=null && gf.file.exists())
//          gf.file.delete();  // .java file
            if(classname!=null) {
                // Generated class
                File file = new File(tempDir+File.separatorChar+classname+".class");
//              if(file.exists())
//              file.delete();
                // Search for and clean up minor classes, classname$xxx.class
                file = new File(tempDir);  // ***** Is this required?
                minorPrefix = classname+"$"; // Indirect arg to filter
                String[] minorClassfiles = file.list(new FilenameFilter()
                            {
                        // Starts with classname$ and ends with .class
                        public boolean accept(File dir,String name) {
                            return
                            (0 == name.indexOf(minorPrefix))
                            &&
                            (name.lastIndexOf(".class") == name.length()-6);
                        }
                            });
                for(int i = 0; i <  minorClassfiles.length; ++i) {
                    file = new File(minorClassfiles[i]);
//                  file.delete();
                }
            }
        }
        return retval;
}

This is used by an application to evaluate a string containing some expression. It should store the "bsf" handle where the script can get to it, for callback purposes.

Note that Java compilation imposes serious overhead, but in exchange you get full Java performance once the classes have been created (minus the cache lookup cost).

Nobody knows whether javac is threadsafe. I'm going to serialize access to protect it.

There is no published API for invoking javac as a class. There's a trick that seems to work for Java 1.1.x, but it stopped working in Java 1.2. We will attempt to use it, then if necessary fall back on invoking javac via the command line.

 public  void initialize(BSFManager mgr,
    String lang,
    Vector declaredBeans) throws BSFException 
{
        super.initialize (mgr, lang, declaredBeans);
}

 Object internalCall(Object object,
    String method,
    Object[] args) throws BSFException 
{
        //***** ISSUE: Only static methods are currently supported
        Object retval = null;
        try {
            if(javaclass != null) {
                //***** This should call the lookup used in BML, for typesafety
                Class[] argtypes = new Class[args.length];
                for(int i=0; i< args.length; ++i) {
                    argtypes[i]=args[i].getClass();
                }
                Method m = MethodUtils.getMethod(javaclass, method, argtypes);
                retval = m.invoke(null, args);
            }
        }
        catch(Exception e) {
            throw new BSFException (BSFException.REASON_IO_ERROR, e.getMessage ());
        }
        return retval;
}

Return an object from an extension.