Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ******************************************************************************
   * BEGIN LICENSE BLOCK *** Version: EPL 1.0/GPL 2.0/LGPL 2.1
   * 
   * The contents of this file are subject to the Eclipse 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/epl-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) 2006 Charles Oliver Nutter <headius@headius.com>
  * Copytight (C) 2006-2007 Thomas E Enebo <enebo@acm.org>
  * Copyright (C) 2007 Miguel Covarrubias <mlcovarrubias@gmail.com>
  * Copyright (C) 2007 Ola Bini <ola@ologix.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 EPL, 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 EPL, the GPL or the LGPL. END LICENSE BLOCK ****
  ******************************************************************************/
 
 package org.jruby.evaluator;
 
 import org.jruby.Ruby;
 
 public class ASTInterpreter {
     public static IRubyObject INTERPRET_METHOD(
             Ruby runtime,
             ThreadContext context,
             String file,
             int line,
             RubyModule implClass,
             Node nodeString name,
             IRubyObject self,
             Block block,
             boolean isTraceable) {
         try {
             ThreadContext.pushBacktrace(contextnamefileline);
             if (isTraceablemethodPreTrace(runtimecontextnameimplClass);
             return node.interpret(runtimecontextselfblock);
         } finally {
             if (isTraceable) {
                 try {methodPostTrace(runtimecontextnameimplClass);}
                 finally {ThreadContext.popBacktrace(context);}
             } else {
                 ThreadContext.popBacktrace(context);
             }
         }
     }
     public static IRubyObject INTERPRET_EVAL(Ruby runtimeThreadContext contextNode nodeString nameIRubyObject selfBlock block) {
         try {
             ThreadContext.pushBacktrace(contextnamenode.getPosition());
             return node.interpret(runtimecontextselfblock);
         } finally {
             ThreadContext.popBacktrace(context);
         }
     }
     public static IRubyObject INTERPRET_EVAL(Ruby runtimeThreadContext contextString fileint lineNode nodeString nameIRubyObject selfBlock block) {
         try {
             ThreadContext.pushBacktrace(contextnamefileline);
             return node.interpret(runtimecontextselfblock);
         } finally {
             ThreadContext.popBacktrace(context);
         }
     }
    public static IRubyObject INTERPRET_CLASS(Ruby runtimeThreadContext contextNode nodeString nameIRubyObject selfBlock block) {
        try {
            ThreadContext.pushBacktrace(contextnamenode.getPosition());
            return node.interpret(runtimecontextselfblock);
        } finally {
            ThreadContext.popBacktrace(context);
        }
    }
    public static IRubyObject INTERPRET_BLOCK(Ruby runtimeThreadContext contextString fileint lineNode nodeString nameIRubyObject selfBlock block) {
        try {
            ThreadContext.pushBacktrace(contextnamefileline);
            blockPreTrace(runtimecontextnameself.getType());
            return node.interpret(runtimecontextselfblock);
        } finally {
            blockPostTrace(runtimecontextnameself.getType());
            ThreadContext.popBacktrace(context);
        }
    }
    public static IRubyObject INTERPRET_ROOT(Ruby runtimeThreadContext contextNode nodeIRubyObject selfBlock block) {
        try {
            ThreadContext.pushBacktrace(context"(root)"node.getPosition());
            return node.interpret(runtimecontextselfblock);
        } finally {
            ThreadContext.popBacktrace(context);
        }
    }
    private static void methodPreTrace(Ruby runtimeThreadContext contextString nameRubyModule implClass) {
        if (runtime.hasEventHooks()) context.trace(.nameimplClass);
    }
    private static void methodPostTrace(Ruby runtimeThreadContext contextString nameRubyModule implClass) {
        if (runtime.hasEventHooks()) context.trace(.nameimplClass);
    }
    private static void blockPreTrace(Ruby runtimeThreadContext contextString nameRubyModule implClass) {
        if (runtime.hasEventHooks() && runtime.is2_0()) context.trace(.nameimplClass);
    }
    private static void blockPostTrace(Ruby runtimeThreadContext contextString nameRubyModule implClass) {
        if (runtime.hasEventHooks() && runtime.is2_0()) context.trace(.nameimplClass);
    }
    @Deprecated
    public static IRubyObject evalWithBinding(ThreadContext contextIRubyObject srcBinding binding) {
        return evalWithBinding(contextbinding.getSelf(), srcbinding);
    }
    
    
Evaluate the given string under the specified binding object. If the binding is not a Proc or Binding object (RubyProc or RubyBinding) throw an appropriate type error.

Parameters:
context the thread context for the current thread
self the self against which eval was called; used as self in the eval in 1.9 mode
src The string containing the text to be evaluated
binding The binding object under which to perform the evaluation
Returns:
An IRubyObject result from the evaluation
    public static IRubyObject evalWithBinding(ThreadContext contextIRubyObject selfIRubyObject srcBinding binding) {
        Ruby runtime = src.getRuntime();
        DynamicScope evalScope;
        if (runtime.is1_9()) {
            // in 1.9, eval scopes are local to the binding
            evalScope = binding.getEvalScope(runtime);
        } else {
            // in 1.8, eval scopes are local to the parent scope
            evalScope = binding.getDynamicScope().getEvalScope(runtime);
        }
        // FIXME:  This determine module is in a strange location and should somehow be in block
        evalScope.getStaticScope().determineModule();
        Frame lastFrame = context.preEvalWithBinding(binding);
        try {
            // Binding provided for scope, use it
            RubyString source = src.convertToString();
            Node node = runtime.parseEval(source.getByteList(), binding.getFile(), evalScopebinding.getLine());
            Block block = binding.getFrame().getBlock();
            if (runtime.getInstanceConfig().getCompileMode() == .) {
                // SSS FIXME: AST interpreter passed both a runtime (which comes from the source string)
                // and the thread-context rather than fetch one from the other.  Why is that?
                return Interpreter.interpretBindingEval(runtimebinding.getFile(), binding.getLine(), binding.getMethod(), nodeselfblock);
            } else {
                return INTERPRET_EVAL(runtimecontextbinding.getFile(), binding.getLine(), nodebinding.getMethod(), selfblock);
            }
        } catch (JumpException.BreakJump bj) {
            throw runtime.newLocalJumpError(.., (IRubyObject)bj.getValue(), "unexpected break");
        } catch (JumpException.RedoJump rj) {
            throw runtime.newLocalJumpError(.., (IRubyObject)rj.getValue(), "unexpected redo");
        } catch (StackOverflowError soe) {
            throw runtime.newSystemStackError("stack level too deep"soe);
        } finally {
            context.postEvalWithBinding(bindinglastFrame);
        }
    }

    
Evaluate the given string.

Parameters:
context the current thread's context
self the self to evaluate under
src The string containing the text to be evaluated
file The filename to use when reporting errors during the evaluation
lineNumber that the eval supposedly starts from
Returns:
An IRubyObject result from the evaluation
    public static IRubyObject evalSimple(ThreadContext contextIRubyObject selfRubyString srcString fileint lineNumber) {
        // this is ensured by the callers
        assert file != null;
        Ruby runtime = src.getRuntime();
        // no binding, just eval in "current" frame (caller's frame)
        RubyString source = src.convertToString();
        
        DynamicScope evalScope = context.getCurrentScope().getEvalScope(runtime);
        evalScope.getStaticScope().determineModule();
        
        try {
            Node node = runtime.parseEval(source.getByteList(), fileevalScopelineNumber);
            if (runtime.getInstanceConfig().getCompileMode() == .) {
                // SSS FIXME: AST interpreter passed both a runtime (which comes from the source string)
                // and the thread-context rather than fetch one from the other.  Why is that?
                return Interpreter.interpretSimpleEval(runtimefilelineNumber"(eval)"nodeself);
            } else {
                return INTERPRET_EVAL(runtimecontextfilelineNumbernode"(eval)"self.);
            }
        } catch (JumpException.BreakJump bj) {
            throw runtime.newLocalJumpError(.., (IRubyObject)bj.getValue(), "unexpected break");
        } catch (StackOverflowError soe) {
            throw runtime.newSystemStackError("stack level too deep"soe);
        }
    }
    public static void callTraceFunction(Ruby runtimeThreadContext contextRubyEvent event) {
        String name = context.getFrameName();
        RubyModule type = context.getFrameKlazz();
        runtime.callEventHooks(contexteventcontext.getFile(), context.getLine(), nametype);
    }
    
    public static IRubyObject pollAndReturn(ThreadContext contextIRubyObject result) {
        context.pollThreadEvents();
        return result;
    }
    
    public static IRubyObject multipleAsgnArrayNode(Ruby runtimeThreadContext contextMultipleAsgnNode iVisitedArrayNode nodeIRubyObject selfBlock aBlock) {
        IRubyObject[] array = new IRubyObject[node.size()];
        for (int i = 0; i < node.size(); i++) {
            array[i] = node.get(i).interpret(runtime,contextselfaBlock);
        }
        return AssignmentVisitor.multiAssign(runtimecontextselfiVisited, RubyArray.newArrayNoCopyLight(runtimearray), false);
    }

    
Evaluates the body in a class or module definition statement.
    public static IRubyObject evalClassDefinitionBody(Ruby runtimeThreadContext contextStaticScope scope
            Node bodyNodeRubyModule typeIRubyObject selfBlock block) {
        context.preClassEval(scopetype);
        try {
            if (runtime.hasEventHooks()) {
                callTraceFunction(runtimecontext.);
            }
            if (bodyNode == nullreturn runtime.getNil();
            String name = type.getBaseName();
            if (name == null) {
                if (type.isSingleton()) {
                    name = "__singleton__";
                } else if (type.isModule()) { // can these two happen?
                    name = "<anonymous module>";
                } else {
                    name = "<anonymous class>";
                }
            }
            return INTERPRET_CLASS(runtimecontextbodyNodenametypeblock);
        } finally {
            try {
                if (runtime.hasEventHooks()) {
                    callTraceFunction(runtimecontext.);
                }
            } finally {
                context.postClassEval();
            }
        }
    }
    public static RubyString getArgumentDefinition(Ruby runtimeThreadContext contextNode nodeRubyString typeIRubyObject selfBlock block) {
        if (node == nullreturn type;
            
        if (node instanceof ArrayNode) {
            ArrayNode list = (ArrayNodenode;
            int size = list.size();
            for (int i = 0; i < sizei++) {
                if (list.get(i).definition(runtimecontextselfblock) == nullreturn null;
            }
        } else if (node.definition(runtimecontextselfblock) == null) {
            return null;
        }
        return type;
    }
    
    public static Block getBlock(Ruby runtimeThreadContext contextIRubyObject selfBlock currentBlockNode blockNode) {
        if (blockNode == nullreturn .;
        
        if (blockNode instanceof IterNode) {
            return getIterNodeBlock(blockNodecontext,self);
        } else if (blockNode instanceof BlockPassNode) {
            return getBlockPassBlock(blockNoderuntime,contextselfcurrentBlock);
        }
         
        assert false"Trying to get block from something which cannot deliver";
        return null;
    }
    private static Block getBlockPassBlock(Node blockNodeRuby runtimeThreadContext contextIRubyObject selfBlock currentBlock) {
        Node bodyNode = ((BlockPassNodeblockNode).getBodyNode();
        IRubyObject proc;
        if (bodyNode == null) {
            proc = runtime.getNil();
        } else {
            proc = bodyNode.interpret(runtimecontextselfcurrentBlock);
        }
        return Helpers.getBlockFromBlockPassBody(proccurrentBlock);
    }
    private static Block getIterNodeBlock(Node blockNodeThreadContext contextIRubyObject self) {
        IterNode iterNode = (IterNodeblockNode;
        StaticScope scope = iterNode.getScope();
        scope.determineModule();
        // Create block for this iter node
        // FIXME: We shouldn't use the current scope if it's not actually from the same hierarchy of static scopes
        return InterpretedBlock.newInterpretedClosure(contextiterNode.getBlockBody(), self);
    }
    /* Something like cvar_cbase() from eval.c, factored out for the benefit
     * of all the classvar-related node evaluations */
    public static RubyModule getClassVariableBase(ThreadContext contextRuby runtime) {
        StaticScope scope = context.getCurrentScope().getStaticScope();
        return getClassVariableBase(runtimescope);
    }
    public static RubyModule getClassVariableBase(Ruby runtimeStaticScope scope) {
        RubyModule rubyClass = scope.getModule();
        while (rubyClass.isSingleton() || rubyClass == runtime.getDummy()) {
            // We ran out of scopes to check
            if (scope == nullreturn null;
            scope = scope.getPreviousCRefScope();
            rubyClass = scope.getModule();
            if (scope.getPreviousCRefScope() == null) {
                runtime.getWarnings().warn(."class variable access from toplevel singleton method");
            }
        }
        return rubyClass;
    }
    public static IRubyObject[] setupArgs(Ruby runtimeThreadContext contextNode nodeIRubyObject selfBlock aBlock) {
        if (node == nullreturn .;
        if (node instanceof ArrayNode) {
            ArrayNode argsArrayNode = (ArrayNodenode;
            String savedFile = context.getFile();
            int savedLine = context.getLine();
            int size = argsArrayNode.size();
            IRubyObject[] argsArray = new IRubyObject[size];
            for (int i = 0; i < sizei++) {
                argsArray[i] = argsArrayNode.get(i).interpret(runtimecontextselfaBlock);
            }
            context.setFileAndLine(savedFilesavedLine);
            return argsArray;
        }
        return ArgsUtil.convertToJavaArray(node.interpret(runtime,contextselfaBlock));
    }
New to GrepCode? Check out our FAQ X