1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package org.jbpm.pvm.internal.script;
 
import javax.script.*;
import java.util.List;
import java.util.Arrays;
 
public class BshScriptEngineFactory implements
    javax.script.ScriptEngineFactory
{
    // Begin impl ScriptEnginInfo
    
    final List<String> extensions = Arrays.asList( "bsh", "java" );
 
    final List<String> mimeTypes = Arrays.asList(
        "application/x-beanshell", 
        "application/x-bsh",
        "application/x-java-source" 
    );
 
    final List<String> names = Arrays.asList( "beanshell", "bsh", "java" );
 
    public String getEngineName() {
        return "BeanShell Engine";
    }
 
    public String getEngineVersion() {
        return "1.0";
    }
 
    public List<String> getExtensions() {
        return extensions;
    }
 
    public List<String> getMimeTypes() {
        return mimeTypes;
    }
 
    public List<String> getNames() {
        return names;
    }
 
    public String getLanguageName() {
        return "BeanShell";
    }
 
    public String getLanguageVersion() {
        return bsh.Interpreter.VERSION + "";
    }
 
    public Object getParameter( String param ) {
        if ( param.equals( ScriptEngine.ENGINE ) )
            return getEngineName();
        if ( param.equals( ScriptEngine.ENGINE_VERSION ) )
            return getEngineVersion();
        if ( param.equals( ScriptEngine.NAME ) )
            return getEngineName();
        if ( param.equals( ScriptEngine.LANGUAGE ) )
            return getLanguageName();
        if ( param.equals( ScriptEngine.LANGUAGE_VERSION ) )
            return getLanguageVersion();
        if ( param.equals( "THREADING" ) )
            return "MULTITHREADED";
 
        return null;
    }
 
    public String getMethodCallSyntax( 
        String objectName, String methodName, String ... args ) 
    {
        // Note: this is very close to the bsh.StringUtil.methodString()
        // method, which constructs a method signature from arg *types*.  Maybe
        // combine these later.
 
        StringBuilder sb = new StringBuilder();
        if ( objectName != null )
            sb.append( objectName + "." );
        sb.append( methodName + "(" );
        if ( args.length > 0 )
            sb.append(" ");
        for( int i=0; i<args.length; i++ )
            sb.append( ( (args[i] == null) ? "null" : args[i] ) 
                + ( i < (args.length-1) ? ", " : " " ) );
        sb.append(")");
        return sb.toString();
    }
 
    public String getOutputStatement( String message ) {
        return "print( \"" + message + "\" );";
    }
 
    public String getProgram( String ... statements )
    {
        StringBuilder sb = new StringBuilder();
        for( int i=0; i< statements.length; i++ )
        {
            sb.append( statements[i] );
            if ( !statements[i].endsWith(";") )
                sb.append( ";" );
            sb.append("\n");
        }
        return sb.toString();
    }
 
    // End impl ScriptEngineInfo
 
    // Begin impl ScriptEngineFactory
 
    public ScriptEngine getScriptEngine() 
    {
        return new BshScriptEngine();
    }
        
    // End impl ScriptEngineFactory
}