1 /*
   2  * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.script.shell;
  27 
  28 import java.io.*;
  29 import java.net.*;
  30 import java.text.*;
  31 import java.util.*;
  32 import javax.script.*;
  33 
  34 /**
  35  * This is the main class for Java script shell.
  36  */
  37 public class Main {
  38     /**
  39      * main entry point to the command line tool
  40      * @param args command line argument array
  41      */
  42     public static void main(String[] args) {
  43         // parse command line options
  44         String[] scriptArgs = processOptions(args);
  45 
  46         // process each script command
  47         for (Command cmd : scripts) {
  48             cmd.run(scriptArgs);
  49         }
  50 
  51         System.exit(EXIT_SUCCESS);
  52     }
  53 
  54     // Each -e or -f or interactive mode is represented
  55     // by an instance of Command.
  56     private static interface Command {
  57         public void run(String[] arguments);
  58     }
  59 
  60     /**
  61      * Parses and processes command line options.
  62      * @param args command line argument array
  63      */
  64     private static String[] processOptions(String[] args) {
  65         // current scripting language selected
  66         String currentLanguage = DEFAULT_LANGUAGE;
  67         // current script file encoding selected
  68         String currentEncoding = null;
  69 
  70         // check for -classpath or -cp first
  71         checkClassPath(args);
  72 
  73         // have we seen -e or -f ?
  74         boolean seenScript = false;
  75         // have we seen -f - already?
  76         boolean seenStdin = false;
  77         for (int i=0; i < args.length; i++) {
  78             String arg = args[i];
  79             if (arg.equals("-classpath") ||
  80                     arg.equals("-cp")) {
  81                 // handled already, just continue
  82                 i++;
  83                 continue;
  84             }
  85 
  86             // collect non-option arguments and pass these as script arguments
  87             if (!arg.startsWith("-")) {
  88                 int numScriptArgs;
  89                 int startScriptArg;
  90                 if (seenScript) {
  91                     // if we have seen -e or -f already all non-option arguments
  92                     // are passed as script arguments
  93                     numScriptArgs = args.length - i;
  94                     startScriptArg = i;
  95                 } else {
  96                     // if we have not seen -e or -f, first non-option argument
  97                     // is treated as script file name and rest of the non-option
  98                     // arguments are passed to script as script arguments
  99                     numScriptArgs = args.length - i - 1;
 100                     startScriptArg = i + 1;
 101                     ScriptEngine se = getScriptEngine(currentLanguage);
 102                     addFileSource(se, args[i], currentEncoding);
 103                 }
 104                 // collect script arguments and return to main
 105                 String[] result = new String[numScriptArgs];
 106                 System.arraycopy(args, startScriptArg, result, 0, numScriptArgs);
 107                 return result;
 108             }
 109 
 110             if (arg.startsWith("-D")) {
 111                 String value = arg.substring(2);
 112                 int eq = value.indexOf('=');
 113                 if (eq != -1) {
 114                     System.setProperty(value.substring(0, eq),
 115                             value.substring(eq + 1));
 116                 } else {
 117                     if (!value.equals("")) {
 118                         System.setProperty(value, "");
 119                     } else {
 120                         // do not allow empty property name
 121                         usage(EXIT_CMD_NO_PROPNAME);
 122                     }
 123                 }
 124                 continue;
 125             } else if (arg.equals("-?") ||
 126                        arg.equals("-h") ||
 127                        arg.equals("--help") ||
 128                        // -help: legacy.
 129                        arg.equals("-help")) {
 130                 usage(EXIT_SUCCESS);
 131             } else if (arg.equals("-e")) {
 132                 seenScript = true;
 133                 if (++i == args.length)
 134                     usage(EXIT_CMD_NO_SCRIPT);
 135 
 136                 ScriptEngine se = getScriptEngine(currentLanguage);
 137                 addStringSource(se, args[i]);
 138                 continue;
 139             } else if (arg.equals("-encoding")) {
 140                 if (++i == args.length)
 141                     usage(EXIT_CMD_NO_ENCODING);
 142                 currentEncoding = args[i];
 143                 continue;
 144             } else if (arg.equals("-f")) {
 145                 seenScript = true;
 146                 if (++i == args.length)
 147                     usage(EXIT_CMD_NO_FILE);
 148                 ScriptEngine se = getScriptEngine(currentLanguage);
 149                 if (args[i].equals("-")) {
 150                     if (seenStdin) {
 151                         usage(EXIT_MULTIPLE_STDIN);
 152                     } else {
 153                         seenStdin = true;
 154                     }
 155                     addInteractiveMode(se);
 156                 } else {
 157                     addFileSource(se, args[i], currentEncoding);
 158                 }
 159                 continue;
 160             } else if (arg.equals("-l")) {
 161                 if (++i == args.length)
 162                     usage(EXIT_CMD_NO_LANG);
 163                 currentLanguage = args[i];
 164                 continue;
 165             } else if (arg.equals("-q")) {
 166                 listScriptEngines();
 167             }
 168             // some unknown option...
 169             usage(EXIT_UNKNOWN_OPTION);
 170         }
 171 
 172         if (! seenScript) {
 173             ScriptEngine se = getScriptEngine(currentLanguage);
 174             addInteractiveMode(se);
 175         }
 176         return new String[0];
 177     }
 178 
 179     /**
 180      * Adds interactive mode Command
 181      * @param se ScriptEngine to use in interactive mode.
 182      */
 183     private static void addInteractiveMode(final ScriptEngine se) {
 184         scripts.add(new Command() {
 185             public void run(String[] args) {
 186                 setScriptArguments(se, args);
 187                 processSource(se, "-", null);
 188             }
 189         });
 190     }
 191 
 192     /**
 193      * Adds script source file Command
 194      * @param se ScriptEngine used to evaluate the script file
 195      * @param fileName script file name
 196      * @param encoding script file encoding
 197      */
 198     private static void addFileSource(final ScriptEngine se,
 199             final String fileName,
 200             final String encoding) {
 201         scripts.add(new Command() {
 202             public void run(String[] args) {
 203                 setScriptArguments(se, args);
 204                 processSource(se, fileName, encoding);
 205             }
 206         });
 207     }
 208 
 209     /**
 210      * Adds script string source Command
 211      * @param se ScriptEngine to be used to evaluate the script string
 212      * @param source Script source string
 213      */
 214     private static void addStringSource(final ScriptEngine se,
 215             final String source) {
 216         scripts.add(new Command() {
 217             public void run(String[] args) {
 218                 setScriptArguments(se, args);
 219                 String oldFile = setScriptFilename(se, "<string>");
 220                 try {
 221                     evaluateString(se, source);
 222                 } finally {
 223                     setScriptFilename(se, oldFile);
 224                 }
 225             }
 226         });
 227     }
 228 
 229     /**
 230      * Prints list of script engines available and exits.
 231      */
 232     private static void listScriptEngines() {
 233         List<ScriptEngineFactory> factories = engineManager.getEngineFactories();
 234         for (ScriptEngineFactory factory: factories) {
 235             getError().println(getMessage("engine.info",
 236                     new Object[] { factory.getLanguageName(),
 237                             factory.getLanguageVersion(),
 238                             factory.getEngineName(),
 239                             factory.getEngineVersion()
 240             }));
 241         }
 242         System.exit(EXIT_SUCCESS);
 243     }
 244 
 245     /**
 246      * Processes a given source file or standard input.
 247      * @param se ScriptEngine to be used to evaluate
 248      * @param filename file name, can be null
 249      * @param encoding script file encoding, can be null
 250      */
 251     private static void processSource(ScriptEngine se, String filename,
 252             String encoding) {
 253         if (filename.equals("-")) {
 254             BufferedReader in = new BufferedReader
 255                     (new InputStreamReader(getIn()));
 256             boolean hitEOF = false;
 257             String prompt = getPrompt(se);
 258             se.put(ScriptEngine.FILENAME, "<STDIN>");
 259             while (!hitEOF) {
 260                 getError().print(prompt);
 261                 String source = "";
 262                 try {
 263                     source = in.readLine();
 264                 } catch (IOException ioe) {
 265                     getError().println(ioe.toString());
 266                 }
 267                 if (source == null) {
 268                     hitEOF = true;
 269                     break;
 270                 }
 271                 Object res = evaluateString(se, source, false);
 272                 if (res != null) {
 273                     res = res.toString();
 274                     if (res == null) {
 275                         res = "null";
 276                     }
 277                     getError().println(res);
 278                 }
 279             }
 280         } else {
 281             FileInputStream fis = null;
 282             try {
 283                 fis = new FileInputStream(filename);
 284             } catch (FileNotFoundException fnfe) {
 285                 getError().println(getMessage("file.not.found",
 286                         new Object[] { filename }));
 287                         System.exit(EXIT_FILE_NOT_FOUND);
 288             }
 289             evaluateStream(se, fis, filename, encoding);
 290         }
 291     }
 292 
 293     /**
 294      * Evaluates given script source
 295      * @param se ScriptEngine to evaluate the string
 296      * @param script Script source string
 297      * @param exitOnError whether to exit the process on script error
 298      */
 299     private static Object evaluateString(ScriptEngine se,
 300             String script, boolean exitOnError) {
 301         try {
 302             return se.eval(script);
 303         } catch (ScriptException sexp) {
 304             getError().println(getMessage("string.script.error",
 305                     new Object[] { sexp.getMessage() }));
 306                     if (exitOnError)
 307                         System.exit(EXIT_SCRIPT_ERROR);
 308         } catch (Exception exp) {
 309             exp.printStackTrace(getError());
 310             if (exitOnError)
 311                 System.exit(EXIT_SCRIPT_ERROR);
 312         }
 313 
 314         return null;
 315     }
 316 
 317     /**
 318      * Evaluate script string source and exit on script error
 319      * @param se ScriptEngine to evaluate the string
 320      * @param script Script source string
 321      */
 322     private static void evaluateString(ScriptEngine se, String script) {
 323         evaluateString(se, script, true);
 324     }
 325 
 326     /**
 327      * Evaluates script from given reader
 328      * @param se ScriptEngine to evaluate the string
 329      * @param reader Reader from which is script is read
 330      * @param name file name to report in error.
 331      */
 332     private static Object evaluateReader(ScriptEngine se,
 333             Reader reader, String name) {
 334         String oldFilename = setScriptFilename(se, name);
 335         try {
 336             return se.eval(reader);
 337         } catch (ScriptException sexp) {
 338             getError().println(getMessage("file.script.error",
 339                     new Object[] { name, sexp.getMessage() }));
 340                     System.exit(EXIT_SCRIPT_ERROR);
 341         } catch (Exception exp) {
 342             exp.printStackTrace(getError());
 343             System.exit(EXIT_SCRIPT_ERROR);
 344         } finally {
 345             setScriptFilename(se, oldFilename);
 346         }
 347         return null;
 348     }
 349 
 350     /**
 351      * Evaluates given input stream
 352      * @param se ScriptEngine to evaluate the string
 353      * @param is InputStream from which script is read
 354      * @param name file name to report in error
 355      */
 356     private static Object evaluateStream(ScriptEngine se,
 357             InputStream is, String name,
 358             String encoding) {
 359         BufferedReader reader = null;
 360         if (encoding != null) {
 361             try {
 362                 reader = new BufferedReader(new InputStreamReader(is,
 363                         encoding));
 364             } catch (UnsupportedEncodingException uee) {
 365                 getError().println(getMessage("encoding.unsupported",
 366                         new Object[] { encoding }));
 367                         System.exit(EXIT_NO_ENCODING_FOUND);
 368             }
 369         } else {
 370             reader = new BufferedReader(new InputStreamReader(is));
 371         }
 372         return evaluateReader(se, reader, name);
 373     }
 374 
 375     /**
 376      * Prints usage message and exits
 377      * @param exitCode process exit code
 378      */
 379     private static void usage(int exitCode) {
 380         getError().println(getMessage("main.usage",
 381                 new Object[] { PROGRAM_NAME }));
 382                 System.exit(exitCode);
 383     }
 384 
 385     /**
 386      * Gets prompt for interactive mode
 387      * @return prompt string to use
 388      */
 389     private static String getPrompt(ScriptEngine se) {
 390         List<String> names = se.getFactory().getNames();
 391         return names.get(0) + "> ";
 392     }
 393 
 394     /**
 395      * Get formatted, localized error message
 396      */
 397     private static String getMessage(String key, Object[] params) {
 398         return MessageFormat.format(msgRes.getString(key), params);
 399     }
 400 
 401     // input stream from where we will read
 402     private static InputStream getIn() {
 403         return System.in;
 404     }
 405 
 406     // stream to print error messages
 407     private static PrintStream getError() {
 408         return System.err;
 409     }
 410 
 411     // get current script engine
 412     private static ScriptEngine getScriptEngine(String lang) {
 413         ScriptEngine se = engines.get(lang);
 414         if (se == null) {
 415             se = engineManager.getEngineByName(lang);
 416             if (se == null) {
 417                 getError().println(getMessage("engine.not.found",
 418                         new Object[] { lang }));
 419                         System.exit(EXIT_ENGINE_NOT_FOUND);
 420             }
 421 
 422             // initialize the engine
 423             initScriptEngine(se);
 424             // to avoid re-initialization of engine, store it in a map
 425             engines.put(lang, se);
 426         }
 427         return se;
 428     }
 429 
 430     // initialize a given script engine
 431     private static void initScriptEngine(ScriptEngine se) {
 432         // put engine global variable
 433         se.put("engine", se);
 434 
 435         // load init.<ext> file from resource
 436         List<String> exts = se.getFactory().getExtensions();
 437         InputStream sysIn = null;
 438         ClassLoader cl = Thread.currentThread().getContextClassLoader();
 439         for (String ext : exts) {
 440             try {
 441                 sysIn = Main.class.getModule().getResourceAsStream("com/sun/tools/script/shell/init." + ext);
 442             } catch (IOException ioe) {
 443                 throw new RuntimeException(ioe);
 444             }
 445             if (sysIn != null) break;
 446         }
 447         if (sysIn != null) {
 448             evaluateStream(se, sysIn, "<system-init>", null);
 449         }
 450     }
 451 
 452     /**
 453      * Checks for -classpath, -cp in command line args. Creates a ClassLoader
 454      * and sets it as Thread context loader for current thread.
 455      *
 456      * @param args command line argument array
 457      */
 458     private static void checkClassPath(String[] args) {
 459         String classPath = null;
 460         for (int i = 0; i < args.length; i++) {
 461             if (args[i].equals("-classpath") ||
 462                     args[i].equals("-cp")) {
 463                 if (++i == args.length) {
 464                     // just -classpath or -cp with no value
 465                     usage(EXIT_CMD_NO_CLASSPATH);
 466                 } else {
 467                     classPath = args[i];
 468                 }
 469             }
 470         }
 471 
 472         if (classPath != null) {
 473             /* We create a class loader, configure it with specified
 474              * classpath values and set the same as context loader.
 475              * Note that ScriptEngineManager uses context loader to
 476              * load script engines. So, this ensures that user defined
 477              * script engines will be loaded. For classes referred
 478              * from scripts, Rhino engine uses thread context loader
 479              * but this is script engine dependent. We don't have
 480              * script engine independent solution anyway. Unless we
 481              * know the class loader used by a specific engine, we
 482              * can't configure correct loader.
 483              */
 484             URL[] urls = pathToURLs(classPath);
 485             URLClassLoader loader = new URLClassLoader(urls);
 486             Thread.currentThread().setContextClassLoader(loader);
 487         }
 488 
 489         // now initialize script engine manager. Note that this has to
 490         // be done after setting the context loader so that manager
 491         // will see script engines from user specified classpath
 492         engineManager = new ScriptEngineManager();
 493     }
 494 
 495     /**
 496      * Utility method for converting a search path string to an array
 497      * of directory and JAR file URLs.
 498      *
 499      * @param path the search path string
 500      * @return the resulting array of directory and JAR file URLs
 501      */
 502     private static URL[] pathToURLs(String path) {
 503         String[] components = path.split(File.pathSeparator);
 504         URL[] urls = new URL[components.length];
 505         int count = 0;
 506         while(count < components.length) {
 507             URL url = fileToURL(new File(components[count]));
 508             if (url != null) {
 509                 urls[count++] = url;
 510             }
 511         }
 512         if (urls.length != count) {
 513             URL[] tmp = new URL[count];
 514             System.arraycopy(urls, 0, tmp, 0, count);
 515             urls = tmp;
 516         }
 517         return urls;
 518     }
 519 
 520     /**
 521      * Returns the directory or JAR file URL corresponding to the specified
 522      * local file name.
 523      *
 524      * @param file the File object
 525      * @return the resulting directory or JAR file URL, or null if unknown
 526      */
 527     private static URL fileToURL(File file) {
 528         String name;
 529         try {
 530             name = file.getCanonicalPath();
 531         } catch (IOException e) {
 532             name = file.getAbsolutePath();
 533         }
 534         name = name.replace(File.separatorChar, '/');
 535         if (!name.startsWith("/")) {
 536             name = "/" + name;
 537         }
 538         // If the file does not exist, then assume that it's a directory
 539         if (!file.isFile()) {
 540             name = name + "/";
 541         }
 542         try {
 543             return new URL("file", "", name);
 544         } catch (MalformedURLException e) {
 545             throw new IllegalArgumentException("file");
 546         }
 547     }
 548 
 549     private static void setScriptArguments(ScriptEngine se, String[] args) {
 550         se.put("arguments", args);
 551         se.put(ScriptEngine.ARGV, args);
 552     }
 553 
 554     private static String setScriptFilename(ScriptEngine se, String name) {
 555         String oldName = (String) se.get(ScriptEngine.FILENAME);
 556         se.put(ScriptEngine.FILENAME, name);
 557         return oldName;
 558     }
 559 
 560     // exit codes
 561     private static final int EXIT_SUCCESS            = 0;
 562     private static final int EXIT_CMD_NO_CLASSPATH   = 1;
 563     private static final int EXIT_CMD_NO_FILE        = 2;
 564     private static final int EXIT_CMD_NO_SCRIPT      = 3;
 565     private static final int EXIT_CMD_NO_LANG        = 4;
 566     private static final int EXIT_CMD_NO_ENCODING    = 5;
 567     private static final int EXIT_CMD_NO_PROPNAME    = 6;
 568     private static final int EXIT_UNKNOWN_OPTION     = 7;
 569     private static final int EXIT_ENGINE_NOT_FOUND   = 8;
 570     private static final int EXIT_NO_ENCODING_FOUND  = 9;
 571     private static final int EXIT_SCRIPT_ERROR       = 10;
 572     private static final int EXIT_FILE_NOT_FOUND     = 11;
 573     private static final int EXIT_MULTIPLE_STDIN     = 12;
 574 
 575     // default scripting language
 576     private static final String DEFAULT_LANGUAGE = "js";
 577     // list of scripts to process
 578     private static List<Command> scripts;
 579     // the script engine manager
 580     private static ScriptEngineManager engineManager;
 581     // map of engines we loaded
 582     private static Map<String, ScriptEngine> engines;
 583     // error messages resource
 584     private static ResourceBundle msgRes;
 585     private static String BUNDLE_NAME = "com.sun.tools.script.shell.messages";
 586     private static String PROGRAM_NAME = "jrunscript";
 587 
 588     static {
 589         scripts = new ArrayList<Command>();
 590         engines = new HashMap<String, ScriptEngine>();
 591         msgRes = ResourceBundle.getBundle(BUNDLE_NAME, Locale.getDefault());
 592     }
 593 }