src/jdk/nashorn/api/scripting/NashornScriptEngineFactory.java

Print this page




 124         }
 125     }
 126 
 127     @Override
 128     public String getProgram(final String... statements) {
 129         final StringBuilder sb = new StringBuilder();
 130 
 131         for (final String statement : statements) {
 132             sb.append(statement).append(';');
 133         }
 134 
 135         return sb.toString();
 136     }
 137 
 138     @Override
 139     public ScriptEngine getScriptEngine() {
 140         return new NashornScriptEngine(this, getAppClassLoader());
 141     }
 142 
 143     /**










 144      * Create a new Script engine initialized by given arguments.
 145      *
 146      * @param args arguments array passed to script engine.
 147      * @return newly created script engine.
 148      */
 149     public ScriptEngine getScriptEngine(final String[] args) {
 150         return new NashornScriptEngine(this, args, getAppClassLoader());
 151     }
 152 











 153     // -- Internals only below this point
 154 
 155     private static final List<String> names;
 156     private static final List<String> mimeTypes;
 157     private static final List<String> extensions;
 158 
 159     static {
 160         names = immutableList(
 161                     "nashorn", "Nashorn",
 162                     "js", "JS",
 163                     "JavaScript", "javascript",
 164                     "ECMAScript", "ecmascript"
 165                 );
 166 
 167         mimeTypes = immutableList(
 168                         "application/javascript",
 169                         "application/ecmascript",
 170                         "text/javascript",
 171                         "text/ecmascript"
 172                     );
 173 
 174         extensions = immutableList("js");
 175     }
 176 
 177     private static List<String> immutableList(final String... elements) {
 178         return Collections.unmodifiableList(Arrays.asList(elements));
 179     }
 180 
 181     private static ClassLoader getAppClassLoader() {
 182         if (System.getSecurityManager() == null) {
 183             return ClassLoader.getSystemClassLoader();
 184         }
 185 
 186         // Try to determine the caller class loader. Use that if it can be
 187         // found. If not, use the class loader of nashorn itself as the
 188         // "application" class loader for scripts.
 189 
 190         // User could have called ScriptEngineFactory.getScriptEngine()
 191         //
 192         // <caller>
 193         //  <factory.getScriptEngine()>
 194         //   <factory.getAppClassLoader()>
 195         //    <Reflection.getCallerClass()>
 196         //
 197         // or used one of the getEngineByABC methods of ScriptEngineManager.
 198         //
 199         // <caller>
 200         //  <ScriptEngineManager.getEngineByName()>
 201         //   <factory.getScriptEngine()>
 202         //    <factory.getAppClassLoader()>
 203         //     <Reflection.getCallerClass()>


 124         }
 125     }
 126 
 127     @Override
 128     public String getProgram(final String... statements) {
 129         final StringBuilder sb = new StringBuilder();
 130 
 131         for (final String statement : statements) {
 132             sb.append(statement).append(';');
 133         }
 134 
 135         return sb.toString();
 136     }
 137 
 138     @Override
 139     public ScriptEngine getScriptEngine() {
 140         return new NashornScriptEngine(this, getAppClassLoader());
 141     }
 142 
 143     /**
 144      * Create a new Script engine initialized by given class loader.
 145      *
 146      * @param appLoader class loader to be used as script "app" class loader.
 147      * @return newly created script engine.
 148      */
 149     public ScriptEngine getScriptEngine(final ClassLoader appLoader) {
 150         return new NashornScriptEngine(this, appLoader);
 151     }
 152 
 153     /**
 154      * Create a new Script engine initialized by given arguments.
 155      *
 156      * @param args arguments array passed to script engine.
 157      * @return newly created script engine.
 158      */
 159     public ScriptEngine getScriptEngine(final String[] args) {
 160         return new NashornScriptEngine(this, args, getAppClassLoader());
 161     }
 162 
 163     /**
 164      * Create a new Script engine initialized by given arguments.
 165      *
 166      * @param args arguments array passed to script engine.
 167      * @param appLoader class loader to be used as script "app" class loader.
 168      * @return newly created script engine.
 169      */
 170     public ScriptEngine getScriptEngine(final String[] args, final ClassLoader appLoader) {
 171         return new NashornScriptEngine(this, args, appLoader);
 172     }
 173 
 174     // -- Internals only below this point
 175 
 176     private static final List<String> names;
 177     private static final List<String> mimeTypes;
 178     private static final List<String> extensions;
 179 
 180     static {
 181         names = immutableList(
 182                     "nashorn", "Nashorn",
 183                     "js", "JS",
 184                     "JavaScript", "javascript",
 185                     "ECMAScript", "ecmascript"
 186                 );
 187 
 188         mimeTypes = immutableList(
 189                         "application/javascript",
 190                         "application/ecmascript",
 191                         "text/javascript",
 192                         "text/ecmascript"
 193                     );
 194 
 195         extensions = immutableList("js");
 196     }
 197 
 198     private static List<String> immutableList(final String... elements) {
 199         return Collections.unmodifiableList(Arrays.asList(elements));
 200     }
 201 
 202     private static ClassLoader getAppClassLoader() {
 203         if (System.getSecurityManager() == null) {
 204             return Thread.currentThread().getContextClassLoader();
 205         }
 206 
 207         // Try to determine the caller class loader. Use that if it can be
 208         // found. If not, use the class loader of nashorn itself as the
 209         // "application" class loader for scripts.
 210 
 211         // User could have called ScriptEngineFactory.getScriptEngine()
 212         //
 213         // <caller>
 214         //  <factory.getScriptEngine()>
 215         //   <factory.getAppClassLoader()>
 216         //    <Reflection.getCallerClass()>
 217         //
 218         // or used one of the getEngineByABC methods of ScriptEngineManager.
 219         //
 220         // <caller>
 221         //  <ScriptEngineManager.getEngineByName()>
 222         //   <factory.getScriptEngine()>
 223         //    <factory.getAppClassLoader()>
 224         //     <Reflection.getCallerClass()>