ArgumentProcessor.java

  1. /***** BEGIN LICENSE BLOCK *****
  2.  * Version: EPL 1.0/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Eclipse Public
  5.  * License Version 1.0 (the "License"); you may not use this file
  6.  * except in compliance with the License. You may obtain a copy of
  7.  * the License at http://www.eclipse.org/legal/epl-v10.html
  8.  *
  9.  * Software distributed under the License is distributed on an "AS
  10.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11.  * implied. See the License for the specific language governing
  12.  * rights and limitations under the License.
  13.  *
  14.  * Copyright (C) 2007-2011 Nick Sieger <nicksieger@gmail.com>
  15.  * Copyright (C) 2009 Joseph LaFata <joe@quibb.org>
  16.  *
  17.  * Alternatively, the contents of this file may be used under the terms of
  18.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  19.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  20.  * in which case the provisions of the GPL or the LGPL are applicable instead
  21.  * of those above. If you wish to allow use of your version of this file only
  22.  * under the terms of either the GPL or the LGPL, and not to allow others to
  23.  * use your version of this file under the terms of the EPL, indicate your
  24.  * decision by deleting the provisions above and replace them with the notice
  25.  * and other provisions required by the GPL or the LGPL. If you do not delete
  26.  * the provisions above, a recipient may use your version of this file under
  27.  * the terms of any one of the EPL, the GPL or the LGPL.
  28.  ***** END LICENSE BLOCK *****/
  29. package org.jruby.util.cli;

  31. import org.jruby.Ruby;
  32. import org.jruby.RubyInstanceConfig;
  33. import org.jruby.exceptions.MainExitException;
  34. import org.jruby.runtime.profile.builtin.ProfileOutput;
  35. import org.jruby.util.JRubyFile;
  36. import org.jruby.util.KCode;
  37. import org.jruby.util.SafePropertyAccessor;

  39. import java.io.File;
  40. import java.io.FileNotFoundException;
  41. import java.io.IOException;
  42. import java.util.ArrayList;
  43. import java.util.Arrays;
  44. import java.util.List;
  45. import java.util.Set;
  46. import java.util.HashSet;

  48. /**
  49.  * Encapsulated logic for processing JRuby's command-line arguments.
  50.  * 
  51.  * This class holds the processing logic for JRuby's non-JVM command-line arguments.
  52.  * All standard Ruby options are processed here, as well as nonstandard JRuby-
  53.  * specific options.
  54.  * 
  55.  * Options passed directly to the JVM are processed separately, by either a launch
  56.  * script or by a native executable.
  57.  */
  58. public class ArgumentProcessor {
  59.     private final class Argument {
  60.         public final String originalValue;
  61.         public final String dashedValue;
  62.         public Argument(String value, boolean dashed) {
  63.             this.originalValue = value;
  64.             this.dashedValue = dashed && !value.startsWith("-") ? "-" + value : value;
  65.         }

  67.         public String toString() {
  68.             return dashedValue;
  69.         }
  70.     }

  72.     private List<Argument> arguments;
  73.     private int argumentIndex = 0;
  74.     private boolean processArgv;
  75.     private final boolean rubyOpts;
  76.     RubyInstanceConfig config;
  77.     private boolean endOfArguments = false;
  78.     private int characterIndex = 0;

  80.     public ArgumentProcessor(String[] arguments, RubyInstanceConfig config) {
  81.         this(arguments, true, false, false, config);
  82.     }

  84.     public ArgumentProcessor(String[] arguments, boolean processArgv, boolean dashed, boolean rubyOpts, RubyInstanceConfig config) {
  85.         this.config = config;
  86.         this.arguments = new ArrayList<Argument>();
  87.         if (arguments != null && arguments.length > 0) {
  88.             for (String argument : arguments) {
  89.                 this.arguments.add(new Argument(argument, dashed));
  90.             }
  91.         }
  92.         this.processArgv = processArgv;
  93.         this.rubyOpts = rubyOpts;
  94.     }

  96.     public void processArguments() {
  97.         processArguments(true);
  98.     }

  100.     public void processArguments(boolean inline) {
  101.         checkProperties();

  103.         while (argumentIndex < arguments.size() && isInterpreterArgument(arguments.get(argumentIndex).originalValue)) {
  104.             processArgument();
  105.             argumentIndex++;
  106.         }
  107.         if (inline && !config.isInlineScript() && config.getScriptFileName() == null && !config.isForceStdin()) {
  108.             if (argumentIndex < arguments.size()) {
  109.                 config.setScriptFileName(arguments.get(argumentIndex).originalValue); //consume the file name
  110.                 argumentIndex++;
  111.             }
  112.         }
  113.         if (processArgv) {
  114.             processArgv();
  115.         }
  116.     }

  118.     private void processArgv() {
  119.         List<String> arglist = new ArrayList<String>();
  120.         for (; argumentIndex < arguments.size(); argumentIndex++) {
  121.             String arg = arguments.get(argumentIndex).originalValue;
  122.             if (config.isArgvGlobalsOn() && arg.startsWith("-")) {
  123.                 arg = arg.substring(1);
  124.                 if (arg.indexOf('=') > 0) {
  125.                     String[] keyvalue = arg.split("=", 2);

  127.                     // argv globals getService their dashes replaced with underscores
  128.                     String globalName = keyvalue[0].replaceAll("-", "_");
  129.                     config.getOptionGlobals().put(globalName, keyvalue[1]);
  130.                 } else {
  131.                     config.getOptionGlobals().put(arg, null);
  132.                 }
  133.             } else {
  134.                 config.setArgvGlobalsOn(false);
  135.                 arglist.add(arg);
  136.             }
  137.         }
  138.         // Remaining arguments are for the script itself
  139.         arglist.addAll(Arrays.asList(config.getArgv()));
  140.         config.setArgv(arglist.toArray(new String[arglist.size()]));
  141.     }

  143.     private boolean isInterpreterArgument(String argument) {
  144.         return argument.length() > 0 && (argument.charAt(0) == '-' || argument.charAt(0) == '+') && !endOfArguments;
  145.     }

  147.     private String getArgumentError(String additionalError) {
  148.         return "jruby: invalid argument\n" + additionalError + "\n";
  149.     }

  151.     private void processArgument() {
  152.         String argument = arguments.get(argumentIndex).dashedValue;

  154.         if (argument.length() == 1) {
  155.             // sole "-" means read from stdin and pass remaining args as ARGV
  156.             endOfArguments = true;
  157.             config.setForceStdin(true);
  158.             return;
  159.         }

  161.         FOR:
  162.         for (characterIndex = 1; characterIndex < argument.length(); characterIndex++) {
  163.             switch (argument.charAt(characterIndex)) {
  164.                 case '0':
  165.                     {
  166.                         disallowedInRubyOpts(argument);
  167.                         String temp = grabOptionalValue();
  168.                         if (null == temp) {
  169.                             config.setRecordSeparator("\u0000");
  170.                         } else if (temp.equals("0")) {
  171.                             config.setRecordSeparator("\n\n");
  172.                         } else if (temp.equals("777")) {
  173.                             config.setRecordSeparator("\uffff"); // Specify something that can't separate
  174.                         } else {
  175.                             try {
  176.                                 int val = Integer.parseInt(temp, 8);
  177.                                 config.setRecordSeparator("" + (char) val);
  178.                             } catch (Exception e) {
  179.                                 MainExitException mee = new MainExitException(1, getArgumentError(" -0 must be followed by either 0, 777, or a valid octal value"));
  180.                                 mee.setUsageError(true);
  181.                                 throw mee;
  182.                             }
  183.                         }
  184.                         break FOR;
  185.                     }
  186.                 case 'a':
  187.                     disallowedInRubyOpts(argument);
  188.                     config.setSplit(true);
  189.                     break;
  190.                 case 'c':
  191.                     disallowedInRubyOpts(argument);
  192.                     config.setShouldCheckSyntax(true);
  193.                     break;
  194.                 case 'C':
  195.                     disallowedInRubyOpts(argument);
  196.                     try {
  197.                         String saved = grabValue(getArgumentError(" -C must be followed by a directory expression"));
  198.                         File base = new File(config.getCurrentDirectory());
  199.                         File newDir = new File(saved);
  200.                         if (newDir.isAbsolute()) {
  201.                             config.setCurrentDirectory(newDir.getCanonicalPath());
  202.                         } else {
  203.                             config.setCurrentDirectory(new File(base, newDir.getPath()).getCanonicalPath());
  204.                         }
  205.                         if (!(new File(config.getCurrentDirectory()).isDirectory())) {
  206.                             MainExitException mee = new MainExitException(1, "jruby: Can't chdir to " + saved + " (fatal)");
  207.                             throw mee;
  208.                         }
  209.                     } catch (IOException e) {
  210.                         MainExitException mee = new MainExitException(1, getArgumentError(" -C must be followed by a valid directory"));
  211.                         throw mee;
  212.                     }
  213.                     break FOR;
  214.                 case 'd':
  215.                     config.setDebug(true);
  216.                     config.setVerbosity(RubyInstanceConfig.Verbosity.TRUE);
  217.                     break;
  218.                 case 'e':
  219.                     disallowedInRubyOpts(argument);
  220.                     config.getInlineScript().append(grabValue(getArgumentError(" -e must be followed by an expression to report")));
  221.                     config.getInlineScript().append('\n');
  222.                     config.setHasInlineScript(true);
  223.                     break FOR;
  224.                 case 'E':
  225.                     processEncodingOption(grabValue(getArgumentError("unknown encoding name")));
  226.                     break FOR;
  227.                 case 'F':
  228.                     disallowedInRubyOpts(argument);
  229.                     config.setInputFieldSeparator(grabValue(getArgumentError(" -F must be followed by a pattern for input field separation")));
  230.                     break FOR;
  231.                 case 'h':
  232.                     disallowedInRubyOpts(argument);
  233.                     config.setShouldPrintUsage(true);
  234.                     config.setShouldRunInterpreter(false);
  235.                     break;
  236.                 case 'i':
  237.                     disallowedInRubyOpts(argument);
  238.                     config.setInPlaceBackupExtension(grabOptionalValue());
  239.                     if (config.getInPlaceBackupExtension() == null) {
  240.                         config.setInPlaceBackupExtension("");
  241.                     }
  242.                     break FOR;
  243.                 case 'I':
  244.                     String s = grabValue(getArgumentError("-I must be followed by a directory name to add to lib path"));
  245.                     String[] ls = s.split(java.io.File.pathSeparator);
  246.                     config.getLoadPaths().addAll(Arrays.asList(ls));
  247.                     break FOR;
  248.                 case 'J':
  249.                     grabOptionalValue();
  250.                     config.getError().println("warning: " + argument + " argument ignored (launched in same VM?)");
  251.                     break FOR;
  252.                 case 'K':
  253.                     // FIXME: No argument seems to work for -K in MRI plus this should not
  254.                     // siphon off additional args 'jruby -K ~/scripts/foo'.  Also better error
  255.                     // processing.
  256.                     String eArg = grabValue(getArgumentError("provide a value for -K"));

  258.                     config.setKCode(KCode.create(null, eArg));

  260.                     // source encoding
  261.                     config.setSourceEncoding(config.getKCode().getEncoding().toString());

  263.                     // set external encoding if not already specified
  264.                     if (config.getExternalEncoding() == null) {
  265.                         config.setExternalEncoding(config.getKCode().getEncoding().toString());
  266.                     }

  268.                     break;
  269.                 case 'l':
  270.                     disallowedInRubyOpts(argument);
  271.                     config.setProcessLineEnds(true);
  272.                     break;
  273.                 case 'n':
  274.                     disallowedInRubyOpts(argument);
  275.                     config.setAssumeLoop(true);
  276.                     config.setKernelGsubDefined(true);
  277.                     break;
  278.                 case 'p':
  279.                     disallowedInRubyOpts(argument);
  280.                     config.setAssumePrinting(true);
  281.                     config.setAssumeLoop(true);
  282.                     config.setKernelGsubDefined(true);
  283.                     break;
  284.                 case 'r':
  285.                     config.getRequiredLibraries().add(grabValue(getArgumentError("-r must be followed by a package to require")));
  286.                     break FOR;
  287.                 case 's':
  288.                     disallowedInRubyOpts(argument);
  289.                     config.setArgvGlobalsOn(true);
  290.                     break;
  291.                 case 'G':
  292.                     config.setLoadGemfile(true);
  293.                     break;
  294.                 case 'S':
  295.                     disallowedInRubyOpts(argument);
  296.                     runBinScript();
  297.                     break FOR;
  298.                 case 'T':
  299.                     {
  300.                         String temp = grabOptionalValue();
  301.                         break FOR;
  302.                     }
  303.                 case 'U':
  304.                     config.setInternalEncoding("UTF-8");
  305.                     break;
  306.                 case 'v':
  307.                     config.setVerbosity(RubyInstanceConfig.Verbosity.TRUE);
  308.                     config.setShowVersion(true);
  309.                     break;
  310.                 case 'w':
  311.                     config.setVerbosity(RubyInstanceConfig.Verbosity.TRUE);
  312.                     break;
  313.                 case 'W':
  314.                     {
  315.                         String temp = grabOptionalValue();
  316.                         if (temp == null) {
  317.                             config.setVerbosity(RubyInstanceConfig.Verbosity.TRUE);
  318.                         } else {
  319.                             if (temp.equals("0")) {
  320.                                 config.setVerbosity(RubyInstanceConfig.Verbosity.NIL);
  321.                             } else if (temp.equals("1")) {
  322.                                 config.setVerbosity(RubyInstanceConfig.Verbosity.FALSE);
  323.                             } else if (temp.equals("2")) {
  324.                                 config.setVerbosity(RubyInstanceConfig.Verbosity.TRUE);
  325.                             } else {
  326.                                 MainExitException mee = new MainExitException(1, getArgumentError(" -W must be followed by either 0, 1, 2 or nothing"));
  327.                                 mee.setUsageError(true);
  328.                                 throw mee;
  329.                             }
  330.                         }
  331.                         break FOR;
  332.                     }
  333.                 case 'x':
  334.                     disallowedInRubyOpts(argument);
  335.                     try {
  336.                         String saved = grabOptionalValue();
  337.                         if (saved != null) {
  338.                             File base = new File(config.getCurrentDirectory());
  339.                             File newDir = new File(saved);
  340.                             if (newDir.isAbsolute()) {
  341.                                 config.setCurrentDirectory(newDir.getCanonicalPath());
  342.                             } else {
  343.                                 config.setCurrentDirectory(new File(base, newDir.getPath()).getCanonicalPath());
  344.                             }
  345.                             if (!(new File(config.getCurrentDirectory()).isDirectory())) {
  346.                                 MainExitException mee = new MainExitException(1, "jruby: Can't chdir to " + saved + " (fatal)");
  347.                                 throw mee;
  348.                             }
  349.                         }
  350.                         config.setXFlag(true);
  351.                     } catch (IOException e) {
  352.                         MainExitException mee = new MainExitException(1, getArgumentError(" -x must be followed by a valid directory"));
  353.                         throw mee;
  354.                     }
  355.                     break FOR;
  356.                 case 'X':
  357.                     disallowedInRubyOpts(argument);
  358.                     String extendedOption = grabOptionalValue();
  359.                     if (extendedOption == null) {
  360.                         if (SafePropertyAccessor.getBoolean("jruby.launcher.nopreamble", false)) {
  361.                             throw new MainExitException(0, OutputStrings.getExtendedHelp());
  362.                         } else {
  363.                             throw new MainExitException(0, "jruby: missing argument\n" + OutputStrings.getExtendedHelp());
  364.                         }
  365.                     } else if (extendedOption.equals("-O")) {
  366.                         config.setObjectSpaceEnabled(false);
  367.                     } else if (extendedOption.equals("+O")) {
  368.                         config.setObjectSpaceEnabled(true);
  369.                     } else if (extendedOption.equals("-C") || extendedOption.equals("-CIR")) {
  370.                         config.setCompileMode(RubyInstanceConfig.CompileMode.OFF);
  371.                     } else if (extendedOption.equals("+C") || extendedOption.equals("+CIR")) {
  372.                         config.setCompileMode(RubyInstanceConfig.CompileMode.FORCE);
  373.                     } else if (extendedOption.equals("+T")) {
  374.                         checkGraalVersion();
  375.                         config.setCompileMode(RubyInstanceConfig.CompileMode.TRUFFLE);
  376.                         config.setDisableGems(true);
  377.                         Options.PARSER_DETAILED_SOURCE_POSITIONS.force(Boolean.toString(true));
  378.                     } else if (extendedOption.endsWith("...")) {
  379.                         Options.listPrefix(extendedOption.substring(0, extendedOption.length() - "...".length()));
  380.                         config.setShouldRunInterpreter(false);
  381.                     } else if (extendedOption.endsWith("?")) {
  382.                         Options.listContains(extendedOption.substring(0, extendedOption.length() - 1));
  383.                         config.setShouldRunInterpreter(false);
  384.                     } else {
  385.                         MainExitException mee = new MainExitException(1, "jruby: invalid extended option " + extendedOption + " (-X will list valid options)\n");
  386.                         mee.setUsageError(true);
  387.                         throw mee;
  388.                     }
  389.                     break FOR;
  390.                 case 'y':
  391.                     disallowedInRubyOpts(argument);
  392.                     config.setParserDebug(true);
  393.                     break FOR;
  394.                 case '-':
  395.                     if (argument.equals("--command") || argument.equals("--bin")) {
  396.                         characterIndex = argument.length();
  397.                         runBinScript();
  398.                         break;
  399.                     } else if (argument.equals("--compat")) {
  400.                         characterIndex = argument.length();
  401.                         grabValue(getArgumentError("--compat takes an argument, but will be ignored"));
  402.                         config.getError().println("warning: " + argument + " ignored");
  403.                         break FOR;
  404.                     } else if (argument.equals("--copyright")) {
  405.                         disallowedInRubyOpts(argument);
  406.                         config.setShowCopyright(true);
  407.                         config.setShouldRunInterpreter(false);
  408.                         break FOR;
  409.                     } else if (argument.equals("--debug")) {
  410.                         disallowedInRubyOpts(argument);
  411.                         RubyInstanceConfig.FULL_TRACE_ENABLED = true;
  412.                         config.setCompileMode(RubyInstanceConfig.CompileMode.OFF);
  413.                         break FOR;
  414.                     } else if (argument.equals("--jdb")) {
  415.                         config.setDebug(true);
  416.                         config.setVerbosity(RubyInstanceConfig.Verbosity.TRUE);
  417.                         break;
  418.                     } else if (argument.equals("--help")) {
  419.                         disallowedInRubyOpts(argument);
  420.                         config.setShouldPrintUsage(true);
  421.                         config.setShouldRunInterpreter(false);
  422.                         break;
  423.                     } else if (argument.equals("--properties")) {
  424.                         config.setShouldPrintProperties(true);
  425.                         config.setShouldRunInterpreter(false);
  426.                         break;
  427.                     } else if (argument.equals("--version")) {
  428.                         disallowedInRubyOpts(argument);
  429.                         config.setShowVersion(true);
  430.                         config.setShouldRunInterpreter(false);
  431.                         break FOR;
  432.                     } else if (argument.equals("--bytecode")) {
  433.                         config.setShowBytecode(true);
  434.                         break FOR;
  435.                     } else if (argument.equals("--fast")) {
  436.                         config.setCompileMode(RubyInstanceConfig.CompileMode.FORCE);
  437.                         break FOR;
  438.                     } else if (argument.startsWith("--profile")) {
  439.                         characterIndex = argument.length();
  440.                         int dotIndex = argument.indexOf(".");
  441.                         
  442.                         if (dotIndex == -1) {
  443.                             config.setProfilingMode(RubyInstanceConfig.ProfilingMode.FLAT);
  444.                             
  445.                         } else {
  446.                             String profilingMode = argument.substring(dotIndex + 1, argument.length());
  447.                             
  448.                             if (profilingMode.equals("out")) {
  449.                                 // output file for profiling results
  450.                                 String outputFile = grabValue(getArgumentError("--profile.out requires an output file argument"));
  451.                                 
  452.                                 try {
  453.                                     config.setProfileOutput(new ProfileOutput(new File(outputFile)));
  454.                                 } catch (FileNotFoundException e) {
  455.                                     throw new MainExitException(1, String.format("jruby: %s", e.getMessage()));
  456.                                 }

  458.                             } else if (profilingMode.equals("service")) {
  459.                                 // service class name
  460.                                 String service = grabValue(getArgumentError("--profile.service requires an class name argument"));

  462.                                 config.setProfilingMode( RubyInstanceConfig.ProfilingMode.SERVICE);
  463.                                 config.setProfilingService(service);

  465.                             } else {
  466.                                 try {
  467.                                     config.setProfilingMode(RubyInstanceConfig.ProfilingMode.valueOf(profilingMode.toUpperCase()));
  468.                                 } catch (IllegalArgumentException e) {
  469.                                     throw new MainExitException(1, String.format("jruby: unknown profiler mode \"%s\"", profilingMode));
  470.                                 }
  471.                             }
  472.                         }
  473.                         
  474.                         break FOR;
  475.                     } else if (argument.equals("--1.8")) {
  476.                         config.getError().println("warning: " + argument + " ignored");
  477.                         break FOR;
  478.                     } else if (argument.equals("--1.9")) {
  479.                         config.getError().println("warning: " + argument + " ignored");
  480.                         break FOR;
  481.                     } else if (argument.equals("--2.0")) {
  482.                         config.getError().println("warning: " + argument + " ignored");
  483.                         break FOR;
  484.                     } else if (argument.equals("--2.1")) {
  485.                         // keep the switch for consistency 
  486.                         break FOR;
  487.                     } else if (argument.equals("--disable-gems")) {
  488.                         config.setDisableGems(true);
  489.                         break FOR;
  490.                     } else if (argument.equals("--disable")) {
  491.                         errorMissingDisable();
  492.                     } else if (argument.startsWith("--disable=")) {
  493.                         String disablesStr = argument.substring("--disable=".length());
  494.                         String[] disables = disablesStr.split(",");

  496.                         if (disables.length == 0) errorMissingDisable();

  498.                         for (String disable : disables) {
  499.                             boolean all = disable.equals("all");
  500.                             if (disable.equals("gems") || all) {
  501.                                 config.setDisableGems(true);
  502.                                 continue;
  503.                             }
  504.                             if (disable.equals("rubyopt") || all) {
  505.                                 config.setDisableRUBYOPT(true);
  506.                                 continue;
  507.                             }

  509.                             config.getError().println("warning: unknown argument for --disable: `" + disable + "'");
  510.                         }
  511.                         break FOR;
  512.                     } else if (argument.equals("--gemfile")) {
  513.                         config.setLoadGemfile(true);
  514.                         break FOR;
  515.                     } else if (argument.equals("--dump")) {
  516.                         characterIndex = argument.length();
  517.                         String error = "--dump only supports [version, copyright, usage, yydebug, syntax, insns] on JRuby";
  518.                         String dumpArg = grabValue(getArgumentError(error));
  519.                         if (dumpArg.equals("version")) {
  520.                             config.setShowVersion(true);
  521.                             config.setShouldRunInterpreter(false);
  522.                             break FOR;
  523.                         } else if (dumpArg.equals("copyright")) {
  524.                             config.setShowCopyright(true);
  525.                             config.setShouldRunInterpreter(false);
  526.                             break FOR;
  527.                         } else if (dumpArg.equals("usage")) {
  528.                             config.setShouldPrintUsage(true);
  529.                             config.setShouldRunInterpreter(false);
  530.                             break FOR;
  531.                         } else if (dumpArg.equals("yydebug")) {
  532.                             config.setParserDebug(true);
  533.                             break FOR;
  534.                         } else if (dumpArg.equals("syntax")) {
  535.                             config.setShouldCheckSyntax(true);
  536.                         } else if (dumpArg.equals("insns")) {
  537.                             config.setShowBytecode(true);
  538.                         } else {
  539.                             MainExitException mee = new MainExitException(1, error);
  540.                             mee.setUsageError(true);
  541.                             throw mee;
  542.                         }
  543.                         break;
  544.                     } else if (argument.equals("--dev")) {
  545.                         // most we can do after JVM boot
  546.                         Options.COMPILE_INVOKEDYNAMIC.force("false");
  547.                         config.setCompileMode(RubyInstanceConfig.CompileMode.OFF);
  548.                         break FOR;
  549.                     } else if (argument.equals("--server")) {
  550.                         // ignore this...can't do anything with it after boot
  551.                         break FOR;
  552.                     } else if (argument.equals("--client")) {
  553.                         // ignore this...can't do anything with it after boot
  554.                         break FOR;
  555.                     } else if (argument.equals("--yydebug")) {
  556.                         disallowedInRubyOpts(argument);
  557.                         config.setParserDebug(true);
  558.                     } else {
  559.                         if (argument.equals("--")) {
  560.                             // ruby interpreter compatibilty
  561.                             // Usage: ruby [switches] [--] [programfile] [arguments])
  562.                             endOfArguments = true;
  563.                             break;
  564.                         }
  565.                     }
  566.                 default:
  567.                     throw new MainExitException(1, "jruby: unknown option " + argument);
  568.             }
  569.         }
  570.     }

  572.     private void disallowedInRubyOpts(String option) {
  573.         if (rubyOpts) {
  574.             throw new MainExitException(1, "jruby: invalid switch in RUBYOPT: " + option + " (RuntimeError)");
  575.         }
  576.     }

  578.     private void errorMissingDisable() {
  579.         MainExitException mee;
  580.         mee = new MainExitException(1, "missing argument for --disable\n");
  581.         mee.setUsageError(true);
  582.         throw mee;
  583.     }

  585.     private void processEncodingOption(String value) {
  586.         String[] encodings = value.split(":", 3);
  587.         switch (encodings.length) {
  588.             case 3:
  589.                 throw new MainExitException(1, "extra argument for -E: " + encodings[2]);
  590.             case 2:
  591.                 config.setInternalEncoding(encodings[1]);
  592.             case 1:
  593.                 config.setExternalEncoding(encodings[0]);
  594.                 // Zero is impossible
  595.         }
  596.     }

  598.     private void runBinScript() {
  599.         String scriptName = grabValue("jruby: provide a bin script to execute");
  600.         if (scriptName.equals("irb")) {
  601.             scriptName = "jirb";
  602.         }
  603.         config.setScriptFileName(resolveScript(scriptName));
  604.         // run as a command if we couldn't find a script
  605.         if (config.getScriptFileName() == null) {
  606.             config.setScriptFileName(scriptName);
  607.             config.getRequiredLibraries().add("jruby/commands");
  608.             config.getInlineScript().append("JRuby::Commands.").append(scriptName);
  609.             config.getInlineScript().append("\n");
  610.             config.setHasInlineScript(true);
  611.         }
  612.         endOfArguments = true;
  613.     }

  615.     private String resolveScript(String scriptName) {
  616.         // These try/catches are to allow failing over to the "commands" logic
  617.         // when running from within a jruby-complete jar file, which has
  618.         // jruby.home = a jar file URL that does not resolve correctly with
  619.         // JRubyFile.create.
  620.         File fullName = null;
  621.         try {
  622.             // try cwd first
  623.             fullName = JRubyFile.create(config.getCurrentDirectory(), scriptName);
  624.             if (fullName.exists() && fullName.isFile()) {
  625.                 logScriptResolutionSuccess(fullName.getAbsolutePath());
  626.                 return scriptName;
  627.             } else {
  628.                 logScriptResolutionFailure(config.getCurrentDirectory());
  629.             }
  630.         } catch (Exception e) {
  631.             // keep going, try bin/#{scriptName}
  632.         }
  633.         try {
  634.             fullName = JRubyFile.create(config.getJRubyHome(), "bin/" + scriptName);
  635.             if (fullName.exists() && fullName.isFile()) {
  636.                 logScriptResolutionSuccess(fullName.getAbsolutePath());
  637.                 return fullName.getAbsolutePath();
  638.             } else {
  639.                 logScriptResolutionFailure(config.getJRubyHome() + "/bin");
  640.             }
  641.         } catch (Exception e) {
  642.             // keep going, try PATH
  643.         }
  644.         if(Ruby.getClassLoader().getResourceAsStream("bin/" + scriptName) != null){
  645.             return "classpath:bin/" + scriptName;
  646.         }
  647.         try {
  648.             Object pathObj = config.getEnvironment().get("PATH");
  649.             String path = pathObj.toString();
  650.             if (path != null) {
  651.                 String[] paths = path.split(System.getProperty("path.separator"));
  652.                 for (int i = 0; i < paths.length; i++) {
  653.                     fullName = JRubyFile.create(new File(paths[i]).getAbsolutePath(), scriptName);
  654.                     if (fullName.exists() && fullName.isFile()) {
  655.                         logScriptResolutionSuccess(fullName.getAbsolutePath());
  656.                         return fullName.getAbsolutePath();
  657.                     }
  658.                 }
  659.                 logScriptResolutionFailure("PATH=" + path);
  660.             }
  661.         } catch (Exception e) {
  662.             // will fall back to JRuby::Commands
  663.         }
  664.         if (config.isDebug() || RubyInstanceConfig.DEBUG_SCRIPT_RESOLUTION) {
  665.             config.getError().println("warning: could not resolve -S script on filesystem: " + scriptName);
  666.         }
  667.         return null;
  668.     }

  670.     private String grabValue(String errorMessage) {
  671.         String optValue = grabOptionalValue();
  672.         if (optValue != null) {
  673.             return optValue;
  674.         }
  675.         argumentIndex++;
  676.         if (argumentIndex < arguments.size()) {
  677.             return arguments.get(argumentIndex).originalValue;
  678.         }
  679.         MainExitException mee = new MainExitException(1, errorMessage);
  680.         mee.setUsageError(true);
  681.         throw mee;
  682.     }

  684.     private String grabOptionalValue() {
  685.         characterIndex++;
  686.         String argValue = arguments.get(argumentIndex).originalValue;
  687.         if (characterIndex < argValue.length()) {
  688.             return argValue.substring(characterIndex);
  689.         }
  690.         return null;
  691.     }

  693.     private void logScriptResolutionSuccess(String path) {
  694.         if (RubyInstanceConfig.DEBUG_SCRIPT_RESOLUTION) {
  695.             config.getError().println("Found: " + path);
  696.         }
  697.     }

  699.     private void logScriptResolutionFailure(String path) {
  700.         if (RubyInstanceConfig.DEBUG_SCRIPT_RESOLUTION) {
  701.             config.getError().println("Searched: " + path);
  702.         }
  703.     }

  705.     public static void checkGraalVersion() {
  706.         if (Options.TRUFFLE_RUNTIME_VERSION_CHECK.load()) {
  707.             final String graalVersion = System.getProperty("graal.version", "unknown");
  708.             final String expectedGraalVersion = "0.6";

  710.             if (graalVersion.equals("unknown")) {
  711.                 return;
  712.             } else if (!graalVersion.equals(expectedGraalVersion)) {
  713.                 throw new RuntimeException("This version of JRuby is built against Graal " + expectedGraalVersion + " but you are using it with version " + graalVersion + " - either update Graal or use with (-J)-original to disable Graal and ignore this error");
  714.             }
  715.         }
  716.     }

  718.     private void checkProperties() {
  719.         final Set<String> propertyNames = new HashSet<>();
  720.         propertyNames.addAll(Options.getPropertyNames());
  721.         propertyNames.add("jruby.home");
  722.         propertyNames.add("jruby.script");
  723.         propertyNames.add("jruby.shell");
  724.         propertyNames.add("jruby.lib");
  725.         propertyNames.add("jruby.bindir");
  726.         propertyNames.add("jruby.jar");
  727.         propertyNames.add("jruby.compat.version");
  728.         propertyNames.add("jruby.reflection");
  729.         propertyNames.add("jruby.thread.pool.enabled");

  731.         for (String propertyName : System.getProperties().stringPropertyNames()) {
  732.             if (propertyName.startsWith("jruby.")) {
  733.                 if (!propertyNames.contains(propertyName)) {
  734.                     System.err.println("jruby: warning: unknown property " + propertyName);
  735.                 }
  736.             }
  737.         }
  738.     }

  740. }
Created with JaCoCo 0.7.3.201501050207