Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ir.instructions;
  
  import org.jruby.Ruby;
 
 import java.util.Map;
 
 // Const search:
 // - looks up lexical scopes
 // - then inheritance hierarcy if lexical search fails
 // - then invokes const_missing if inheritance search fails
 public class SearchConstInstr extends Instr implements ResultInstr {
     private Operand  startingScope;
     private String   constName;
     private boolean  noPrivateConsts;
     private Variable result;
 
     // Constant caching 
     private volatile transient Object cachedConstant = null;
     private Object generation = -1;
 
     public SearchConstInstr(Variable resultString constNameOperand startingScopeboolean noPrivateConsts) {
         super(.);
         
         assert result != null"SearchConstInstr result is null";
         
         this.          = result;
         this.       = constName;
         this.   = startingScope;
         this. = noPrivateConsts;
     }
 
     public Operand[] getOperands() { 
         return new Operand[] {  };
     }
 
     @Override
     public void simplifyOperands(Map<OperandOperandvalueMapboolean force) {
          = .getSimplifiedOperand(valueMapforce);
     }
     
     public Variable getResult() {
         return ;
     }
 
     public void updateResult(Variable v) {
         this. = v;
     }
 
     public Instr cloneForInlining(InlinerInfo ii) {
     }
 
     @Override
     public String toString() { 
         return super.toString() + "(" +  + ", " +  + ", no-private-consts=" +  + ")";
     }
 
     private Object cache(ThreadContext contextDynamicScope currDynScopeIRubyObject selfObject[] tempRuby runtime) {
         // Lexical lookup
         RubyModule object = runtime.getObject();
         StaticScope staticScope = (StaticScope.retrieve(contextselfcurrDynScopetemp);
         Object constant = (staticScope == null) ? object.getConstant() : staticScope.getConstantInner(runtimeobject);
 
         // Inheritance lookup 
         RubyModule module = null;
         if (constant == null) {
             // SSS FIXME: Is this null check case correct?
             module = staticScope == null ? object : staticScope.getModule();
             constant =  ? module.getConstantFromNoConstMissing(false) : module.getConstantNoConstMissing();
         }
 
         // Call const_missing or cache
         if (constant == null) {
             constant = module.callMethod(context"const_missing"context.runtime.fastNewSymbol());
         } else {
             // recache
              = runtime.getConstantInvalidator().getData();
              = constant;
         }
 
         return constant;
     }
 
     private boolean isCached(Ruby runtimeObject value) {
         return value != null &&  == runtime.getConstantInvalidator().getData();
     }
     
     @Override
    public Object interpret(ThreadContext contextDynamicScope currDynScopeIRubyObject selfObject[] tempBlock block) {
        Ruby runtime = context.runtime;
        Object constant = // Store to temp so it does null out on us mid-stream
        if (!isCached(runtimeconstant)) constant = cache(contextcurrDynScopeselftempruntime);
        return constant;
    }
    @Override
    public void visit(IRVisitor visitor) {
        visitor.SearchConstInstr(this);
    }
    public Operand getStartingScope() {
        return ;
    }
    public String getConstName() {
        return ;
    }
    public boolean isNoPrivateConsts() {
        return ;
    }
New to GrepCode? Check out our FAQ X