**** BEGIN LICENSE BLOCK *****

* Version: CPL 1.0/GPL 2.0/LGPL 2.1

*

* The contents of this file are subject to the Common Public

* License Version 1.0 (the "License"); you may not use this file

* except in compliance with the License. You may obtain a copy of

* the License at http://www.eclipse.org/legal/cpl-v10.html

*

* Software distributed under the License is distributed on an "AS

* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

* implied. See the License for the specific language governing

* rights and limitations under the License.

*

* Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com>

* Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>

* Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr>

* Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>

* Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>

* Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>

* Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com>

* Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>

* Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com>

* Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com>

* Copyright (C) 2006 Ola Bini <ola@ologix.com>

* Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com>

*

* Alternatively, the contents of this file may be used under the terms of

* either of the GNU General Public License Version 2 or later (the "GPL"),

* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

* in which case the provisions of the GPL or the LGPL are applicable instead

* of those above. If you wish to allow use of your version of this file only

* under the terms of either the GPL or the LGPL, and not to allow others to

* use your version of this file under the terms of the CPL, indicate your

* decision by deleting the provisions above and replace them with the notice

* and other provisions required by the GPL or the LGPL. If you do not delete

* the provisions above, a recipient may use your version of this file under

* the terms of any one of the CPL, the GPL or the LGPL.

***** END LICENSE BLOCK *****/

* The Ruby object represents the top-level of a JRuby "instance" in a given VM.

* JRuby supports spawning multiple instances in the same JVM. Generally, objects

* created under these instances are tied to a given runtime, for such details

* as identity and type, because multiple Ruby instances means there are

* multiple instances of each class. This means that in multi-runtime mode

* (or really, multi-VM mode, where each JRuby instance is a ruby "VM"), objects

* generally can't be transported across runtimes without marshaling.

*

* This class roots everything that makes the JRuby runtime function, and

* provides a number of utility methods for constructing global types and

* accessing global runtime structures.

*/

    /**

     * Returns a new instance of the JRuby runtime configured with defaults.

     *

     * @return the JRuby runtime

     * @see org.jruby.RubyInstanceConfig

     */

    public static Ruby newInstance() {

        return newInstance(new RubyInstanceConfig());

    }

    /**

     * Returns a new instance of the JRuby runtime configured as specified.

     *

     * @param config The instance configuration

     * @return The JRuby runtime

     * @see org.jruby.RubyInstanceConfig

     */

    public static Ruby newInstance(RubyInstanceConfig config) {

        Ruby ruby = new Ruby(config);

        ruby.init();

        return ruby;

    }

    /**

     * Returns a new instance of the JRuby runtime configured with the given

     * input, output and error streams and otherwise default configuration

     * (except where specified system properties alter defaults).

     *

     * @param in the custom input stream

     * @param out the custom output stream

     * @param err the custom error stream

     * @return the JRuby runtime

     * @see org.jruby.RubyInstanceConfig

     */

    public static Ruby newInstance(InputStream in, PrintStream out, PrintStream err) {

        RubyInstanceConfig config = new RubyInstanceConfig();

        config.setInput(in);

        config.setOutput(out);

        config.setError(err);

        return newInstance(config);

    }

   

    /**

     * Create and initialize a new JRuby runtime. The properties of the

     * specified RubyInstanceConfig will be used to determine various JRuby

     * runtime characteristics.

     *

     * @param config The configuration to use for the new instance

     * @see org.jruby.RubyInstanceConfig

     */

    private Ruby(RubyInstanceConfig config) {

        this.config             = config;

        this.threadService      = new ThreadService(this);

        if(config.isSamplingEnabled()) {

            org.jruby.util.SimpleSampler.registerThreadContext(threadService.getCurrentContext());

        }

        this.in                 = config.getInput();

        this.out                = config.getOutput();

        this.err                = config.getError();

        this.objectSpaceEnabled = config.isObjectSpaceEnabled();

        this.profile            = config.getProfile();

        this.currentDirectory   = config.getCurrentDirectory();

        this.kcode              = config.getKCode();

        this.beanManager        = new BeanManager(this, config.isManagementEnabled());

        this.jitCompiler        = new JITCompiler(this);

        this.parserStats        = new ParserStats(this);

       

        this.beanManager.register(new Config(this));

        this.beanManager.register(parserStats);

        this.beanManager.register(new ClassCache(this));

    }

   

    /**

     * Evaluates a script under the current scope (perhaps the top-level

     * scope) and returns the result (generally the last value calculated).

     * This version goes straight into the interpreter, bypassing compilation

     * and runtime preparation typical to normal script runs.

     *

     * @param script The scriptlet to run

     * @returns The result of the eval

     */

    public IRubyObject evalScriptlet(String script) {

        ThreadContext context = getCurrentContext();

        DynamicScope currentScope = context.getCurrentScope();

        ManyVarsDynamicScope newScope = new ManyVarsDynamicScope(new EvalStaticScope(currentScope.getStaticScope()), currentScope);

        Node node = parseEval(script, "<script>", newScope, 0);

       

        try {

            context.preEvalScriptlet(newScope);

            return node.interpret(this, context, context.getFrameSelf(), Block.NULL_BLOCK);

        } catch (JumpException.ReturnJump rj) {

            throw newLocalJumpError(RubyLocalJumpError.Reason.RETURN, (IRubyObject)rj.getValue(), "unexpected return");

        } catch (JumpException.BreakJump bj) {

            throw newLocalJumpError(RubyLocalJumpError.Reason.BREAK, (IRubyObject)bj.getValue(), "unexpected break");

        } catch (JumpException.RedoJump rj) {

            throw newLocalJumpError(RubyLocalJumpError.Reason.REDO, (IRubyObject)rj.getValue(), "unexpected redo");

        } finally {

            context.postEvalScriptlet();

        }

    }

   

    /**

     * Parse and execute the specified script

     * This differs from the other methods in that it accepts a string-based script and

     * parses and runs it as though it were loaded at a command-line. This is the preferred

     * way to start up a new script when calling directly into the Ruby object (which is

     * generally *dis*couraged.

     *

     * @param script The contents of the script to run as a normal, root script

     * @return The last value of the script

     */

    public IRubyObject executeScript(String script, String filename) {

        byte[] bytes;

       

        try {

            bytes = script.getBytes(KCode.NONE.getKCode());

        } catch (UnsupportedEncodingException e) {

            bytes = script.getBytes();

        }

        Node node = parseInline(new ByteArrayInputStream(bytes), filename, null);

        ThreadContext context = getCurrentContext();

       

        String oldFile = context.getFile();

        int oldLine = context.getLine();

        try {

            context.setFile(node.getPosition().getFile());

            context.setLine(node.getPosition().getStartLine());

            return runNormally(node, false);

        } finally {

            context.setFile(oldFile);

            context.setLine(oldLine);

        }

    }

   

    /**

     * Run the script contained in the specified input stream, using the

     * specified filename as the name of the script being executed. The stream

     * will be read fully before being parsed and executed. The given filename

     * will be used for the ruby $PROGRAM_NAME and $0 global variables in this

     * runtime.

     *

     * This method is intended to be called once per runtime, generally from

     * Main or from main-like top-level entry points.

     *

     * As part of executing the script loaded from the input stream, various

     * RubyInstanceConfig properties will be used to determine whether to

     * compile the script before execution or run with various wrappers (for

     * looping, printing, and so on, see jruby -help).

     *

     * @param inputStream The InputStream from which to read the script contents

     * @param filename The filename to use when parsing, and for $PROGRAM_NAME

     * and $0 ruby global variables.

     */

    public void runFromMain(InputStream inputStream, String filename) {

        IAccessor d = new ValueAccessor(newString(filename));

        getGlobalVariables().define("$PROGRAM_NAME", d);

        getGlobalVariables().define("$0", d);

        for (Iterator i = config.getOptionGlobals().entrySet().iterator(); i.hasNext();) {

            Map.Entry entry = (Map.Entry) i.next();

            Object value = entry.getValue();

            IRubyObject varvalue;

            if (value != null) {

                varvalue = newString(value.toString());

            } else {

                varvalue = getTrue();

            }

            getGlobalVariables().set("$" + entry.getKey().toString(), varvalue);

        }

       

        if(config.isYARVEnabled()) {

            if (config.isShowBytecode()) System.err.print("error: bytecode printing only works with JVM bytecode");

            new YARVCompiledRunner(this, inputStream, filename).run();

        } else if(config.isRubiniusEnabled()) {

            if (config.isShowBytecode()) System.err.print("error: bytecode printing only works with JVM bytecode");

            new RubiniusRunner(this, inputStream, filename).run();

        } else {

            Node scriptNode = parseFromMain(inputStream, filename);

            ThreadContext context = getCurrentContext();

            String oldFile = context.getFile();

            int oldLine = context.getLine();

            try {

                context.setFile(scriptNode.getPosition().getFile());

                context.setLine(scriptNode.getPosition().getStartLine());

                if (config.isAssumePrinting() || config.isAssumeLoop()) {

                    runWithGetsLoop(scriptNode, config.isAssumePrinting(), config.isProcessLineEnds(),

                            config.isSplit(), config.isYARVCompileEnabled());

                } else {

                    runNormally(scriptNode, config.isYARVCompileEnabled());

                }

            } finally {

                context.setFile(oldFile);

                context.setLine(oldLine);

            }

        }

    }

    /**

     * Parse the script contained in the given input stream, using the given

     * filename as the name of the script, and return the root Node. This

     * is used to verify that the script syntax is valid, for jruby -c. The

     * current scope (generally the top-level scope) is used as the parent

     * scope for parsing.

     *

     * @param inputStream The input stream from which to read the script

     * @param filename The filename to use for parsing

     * @returns The root node of the parsed script

     */

    public Node parseFromMain(InputStream inputStream, String filename) {

        if (config.isInlineScript()) {

            return parseInline(inputStream, filename, getCurrentContext().getCurrentScope());

        } else {

            return parseFile(inputStream, filename, getCurrentContext().getCurrentScope());

        }

    }

   

    /**

     * Run the given script with a "while gets; end" loop wrapped around it.

     * This is primarily used for the -n command-line flag, to allow writing

     * a short script that processes input lines using the specified code.

     *

     * @param scriptNode The root node of the script to execute

     * @param printing Whether $_ should be printed after each loop (as in the

     * -p command-line flag)

     * @param processLineEnds Whether line endings should be processed by

     * setting $\ to $/ and <code>chop!</code>ing every line read

     * @param split Whether to split each line read using <code>String#split</code>

     * @param yarvCompile Whether to compile the target script to YARV (Ruby 1.9)

     * bytecode before executing.

     * @return The result of executing the specified script

     */

    public IRubyObject runWithGetsLoop(Node scriptNode, boolean printing, boolean processLineEnds, boolean split, boolean yarvCompile) {

        ThreadContext context = getCurrentContext();

       

        Script script = null;

        YARVCompiledRunner runner = null;

        boolean compile = getInstanceConfig().getCompileMode().shouldPrecompileCLI();

        if (compile || !yarvCompile) {

            script = tryCompile(scriptNode);

            if (compile && script == null) {

                // terminate; tryCompile will have printed out an error and we're done

                return getNil();

            }

        } else if (yarvCompile) {

            runner = tryCompileYarv(scriptNode);

        }

       

        if (processLineEnds) {

            getGlobalVariables().set("$\\", getGlobalVariables().get("$/"));

        }

       

        while (RubyKernel.gets(context, getTopSelf(), IRubyObject.NULL_ARRAY).isTrue()) {

            loop: while (true) { // Used for the 'redo' command

                try {

                    if (processLineEnds) {

                        getGlobalVariables().get("$_").callMethod(context, "chop!");

                    }

                   

                    if (split) {

                        getGlobalVariables().set("$F", getGlobalVariables().get("$_").callMethod(context, "split"));

                    }

                   

                    if (script != null) {

                        runScript(script);

                    } else if (runner != null) {

                        runYarv(runner);

                    } else {

                        runInterpreter(scriptNode);

                    }

                   

                    if (printing) RubyKernel.print(context, getKernel(), new IRubyObject[] {getGlobalVariables().get("$_")});

                    break loop;

                } catch (JumpException.RedoJump rj) {

                    // do nothing, this iteration restarts

                } catch (JumpException.NextJump nj) {

                    // recheck condition

                    break loop;

                } catch (JumpException.BreakJump bj) {

                    // end loop

                    return (IRubyObject) bj.getValue();

                }

            }

        }

       

        return getNil();

    }

   

    /**

     * Run the specified script without any of the loop-processing wrapper

     * code.

     *

     * @param scriptNode The root node of the script to be executed

     * @param yarvCompile Whether to compile the script to YARV (Ruby 1.9)

     * bytecode before execution

     * @return The result of executing the script

     */

    public IRubyObject runNormally(Node scriptNode, boolean yarvCompile) {

        Script script = null;

        YARVCompiledRunner runner = null;

        boolean compile = getInstanceConfig().getCompileMode().shouldPrecompileCLI();

        boolean forceCompile = getInstanceConfig().getCompileMode().shouldPrecompileAll();

        if (yarvCompile) {

            runner = tryCompileYarv(scriptNode);

        } else if (compile) {

            script = tryCompile(scriptNode);

            if (forceCompile && script == null) {

                return getNil();

            }

        }

       

        if (script != null) {

            if (config.isShowBytecode()) {

                return nilObject;

            } else {

                return runScript(script);

            }

        } else if (runner != null) {

            return runYarv(runner);

        } else {

            if (config.isShowBytecode()) System.err.print("error: bytecode printing only works with JVM bytecode");

            return runInterpreter(scriptNode);

        }

    }

   

    private Script tryCompile(Node node) {

        return tryCompile(node, new JRubyClassLoader(getJRubyClassLoader()));

    }

   

    private Script tryCompile(Node node, JRubyClassLoader classLoader) {

        Script script = null;

        try {

            String filename = node.getPosition().getFile();

            String classname = JavaNameMangler.mangledFilenameForStartupClasspath(filename);

            ASTInspector inspector = new ASTInspector();

            inspector.inspect(node);

            StandardASMCompiler asmCompiler = new StandardASMCompiler(classname, filename);

            ASTCompiler compiler = new ASTCompiler();

            if (config.isShowBytecode()) {

                compiler.compileRoot(node, asmCompiler, inspector, false, false);

                asmCompiler.dumpClass(System.out);

            } else {

                compiler.compileRoot(node, asmCompiler, inspector, true, false);

            }

            script = (Script)asmCompiler.loadClass(classLoader).newInstance();

            if (config.isJitLogging()) {

                System.err.println("compiled: " + node.getPosition().getFile());

            }

        } catch (NotCompilableException nce) {

            if (config.isJitLoggingVerbose() || config.isDebug()) {

                System.err.println("Error -- Not compileable: " + nce.getMessage());

                nce.printStackTrace();

            } else {

                System.err.println("Error, could not compile; pass -d or -J-Djruby.jit.logging.verbose=true for more details");

            }

        } catch (ClassNotFoundException e) {

            if (config.isJitLoggingVerbose() || config.isDebug()) {

                System.err.println("Error -- Not compileable: " + e.getMessage());

                e.printStackTrace();

            } else {

                System.err.println("Error, could not compile; pass -d or -J-Djruby.jit.logging.verbose=true for more details");