Java Doc for Interpreter.java in  » Scripting » beanshell » bsh » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Here are some examples:

 Interpeter bsh = new Interpreter();
 // Evaluate statements and expressions
 bsh.eval("foo=Math.sin(0.5)");
 bsh.eval("bar=foo*5; bar=Math.cos(bar);");
 bsh.eval("for(i=0; i<10; i++) { print(\"hello\"); }");
 // same as above using java syntax and apis only
 bsh.eval("for(int i=0; i<10; i++) { System.out.println(\"hello\"); }");
 // Source from files or streams
 bsh.source("myscript.bsh");  // or bsh.eval("source(\"myscript.bsh\")");
 // Use set() and get() to pass objects in and out of variables
 bsh.set( "date", new Date() );
 Date date = (Date)bsh.get( "date" );
 // This would also work:
 Date date = (Date)bsh.eval( "date" );
 bsh.eval("year = date.getYear()");
 Integer year = (Integer)bsh.get("year");  // primitives use wrappers
 // With Java1.3+ scripts can implement arbitrary interfaces...
 // Script an awt event handler (or source it from a file, more likely)
 bsh.eval( "actionPerformed( e ) { print( e ); }");
 // Get a reference to the script object (implementing the interface)
 ActionListener scriptedHandler = 
 (ActionListener)bsh.eval("return (ActionListener)this");
 // Use the scripted event handler normally...
 new JButton.addActionListener( script );
 

In the above examples we showed a single interpreter instance, however you may wish to use many instances, depending on the application and how you structure your scripts. Interpreter instances are very light weight to create, however if you are going to execute the same script repeatedly and require maximum performance you should consider scripting the code as a method and invoking the scripted method each time on the same interpreter instance (using eval()).

See the BeanShell User's Manual for more information.

Note: This is here for completeness.

Note: This is here for completeness.

For example:

 Interpreter interpreter = new Interpreter();
 // define a method called run()
 interpreter.eval("run() { ... }");
 // Fetch a reference to the interpreter as a Runnable
 Runnable runnable = 
 (Runnable)interpreter.getInterface( Runnable.class );
 

Note that the interpreter does *not* require that any or all of the methods of the interface be defined at the time the interface is generated. However if you attempt to invoke one that is not defined you will get a runtime exception.

Note also that this convenience method has exactly the same effect as evaluating the script:

 (Type)this;
 

For example, the following is identical to the previous example:

 // Fetch a reference to the interpreter as a Runnable
 Runnable runnable = 
 (Runnable)interpreter.eval( "(Runnable)this" );
 

Version requirement Although standard Java interface types are always available, to be used with arbitrary interfaces this feature requires that you are using Java 1.3 or greater.

throws:
  EvalError - if the interface cannot be generated because theversion of Java does not support the proxy mechanism.

Note: This is here for completeness. If you're using this a lot it may be an indication that you are doing more work than you have to. For example, caching the interpreter instance rather than the namespace should not add a significant overhead. No state other than the debug status is stored in the interpreter.

All features of the namespace can also be accessed using the interpreter via eval() and the script variable 'this.namespace' (or global.namespace as necessary).

BeanShell will use this at the same point it would otherwise use the plain Class.forName(). i.e. if no explicit classpath management is done from the script (addClassPath(), setClassPath(), reloadClasses()) then BeanShell will only use the supplied classloader. If additional classpath management is done then BeanShell will perform that in addition to the supplied external classloader. However BeanShell is not currently able to reload classes supplied through the external classloader.

See Also:   BshClassManager.setClassLoader(ClassLoader)

Note: if you wish to cause an EOF externally you can try closing the input stream. This is not guaranteed to work in older versions of Java due to Java limitations, but should work in newer JDK/JREs. (That was the motivation for the Java NIO package).

Note: This is here for completeness. If you're using this a lot it may be an indication that you are doing more work than you have to. For example, caching the interpreter instance rather than the namespace should not add a significant overhead. No state other than the debug status is stored in the interpreter.

All features of the namespace can also be accessed using the interpreter via eval() and the script variable 'this.namespace' (or global.namespace as necessary).

This mode will become more strict in a future release when classes are interpreted and there is an alternative to scripting objects as method closures.