Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.runtime.callsite;
  
 
 public class SuperCallSite extends CallSite {
     protected volatile SuperTuple cache = .;
 
     private static class SuperTuple {
         static final SuperTuple NULL_CACHE = new SuperTuple("".);
         public final String name;
         public final CacheEntry cache;
 
         public SuperTuple(String nameCacheEntry cache) {
             this. = name;
             this. = cache;
         }
 
         public boolean cacheOk(String nameRubyClass klass) {
             return this..equals(name) && .typeOk(klass);
         }
     }
     
     public SuperCallSite() {
         super("super".);
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selflong fixnum) {
         return call(contextcallerself, RubyFixnum.newFixnum(context.runtimefixnum));
     }
     
     @Override
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfdouble flote) {
         return call(contextcallerself, RubyFloat.newFloat(context.runtimeflote));
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject... args) {
         RubyModule klazz = context.getFrameKlazz();
         String name = context.getFrameName();
         RubyClass selfType = pollAndGetClass(contextselfklazzname);
 
         SuperTuple myCache = ;
         if (selfType != null && myCache.cacheOk(nameselfType)) {
             return myCache.cache.method.call(contextselfselfTypenameargs);
         }
         return cacheAndCall(callerselfTypeargscontextselfname);
     }
 
     private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
         RubyModule klazz = context.getFrameKlazz();
         String name = context.getFrameName();
         RubyClass selfType = pollAndGetClass(contextselfklazzname);
 
         SuperTuple myCache = ;
         if (selfType != null && myCache.cacheOk(nameselfType)) {
             return myCache.cache.method.call(contextselfselfTypenameargsblock);
         }
         return cacheAndCall(callerselfTypeblockargscontextselfname);
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
         try {
             return callBlock(contextcallerselfargsblock);
         } catch (JumpException.BreakJump bj) {
             return handleBreakJump(contextbj);
         } catch (JumpException.RetryJump rj) {
             throw retryJumpError(context);
         }
     }
 
     public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
         try {
             return callBlock(contextcallerselfargsblock);
         } catch (JumpException.BreakJump bj) {
             return handleBreakJump(contextbj);
         } catch (JumpException.RetryJump rj) {
             throw retryJumpError(context);
         } finally {
             block.escape();
         }
     }
 
     public IRubyObject callVarargs(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject... args) {
         switch (args.length) {
             case 0: return call(contextcallerself);
             case 1: return call(contextcallerselfargs[0]);
             case 2: return call(contextcallerselfargs[0], args[1]);
            case 3: return call(contextcallerselfargs[0], args[1], args[2]);
            defaultreturn call(contextcallerselfargs);
        }
    }
    public IRubyObject callVarargs(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
        switch (args.length) {
            case 0: return call(contextcallerselfblock);
            case 1: return call(contextcallerselfargs[0], block);
            case 2: return call(contextcallerselfargs[0], args[1], block);
            case 3: return call(contextcallerselfargs[0], args[1], args[2], block);
            defaultreturn call(contextcallerselfargsblock);
        }
    }
    public IRubyObject callVarargsIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
        switch (args.length) {
            case 0: return callIter(contextcallerselfblock);
            case 1: return callIter(contextcallerselfargs[0], block);
            case 2: return callIter(contextcallerselfargs[0], args[1], block);
            case 3: return callIter(contextcallerselfargs[0], args[1], args[2], block);
            defaultreturn callIter(contextcallerselfargsblock);
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject self) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypename);
        }
        return cacheAndCall(callerselfTypecontextselfname);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfBlock block) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypenameblock);
        }
        return cacheAndCall(callerselfTypeblockcontextselfname);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfBlock block) {
        try {
            return callBlock(contextcallerselfblock);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        }
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfBlock block) {
        try {
            return callBlock(contextcallerselfblock);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypenamearg1);
        }
        return cacheAndCall(callerselfTypecontextselfnamearg1);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1Block block) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypenamearg1block);
        }
        return cacheAndCall(callerselfTypeblockcontextselfnamearg1);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1Block block) {
        try {
            return callBlock(contextcallerselfarg1block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        }
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1Block block) {
        try {
            return callBlock(contextcallerselfarg1block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypenamearg1arg2);
        }
        return cacheAndCall(callerselfTypecontextselfnamearg1arg2);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2Block block) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypenamearg1arg2block);
        }
        return cacheAndCall(callerselfTypeblockcontextselfnamearg1arg2);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2Block block) {
        try {
            return callBlock(contextcallerselfarg1arg2block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        }
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2Block block) {
        try {
            return callBlock(contextcallerselfarg1arg2block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypenamearg1arg2arg3);
        }
        return cacheAndCall(callerselfTypecontextselfnamearg1arg2arg3);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3Block block) {
        RubyModule klazz = context.getFrameKlazz();
        String name = context.getFrameName();
        RubyClass selfType = pollAndGetClass(contextselfklazzname);
        SuperTuple myCache = ;
        if (selfType != null && myCache.cacheOk(nameselfType)) {
            return myCache.cache.method.call(contextselfselfTypenamearg1arg2arg3block);
        }
        return cacheAndCall(callerselfTypeblockcontextselfnamearg1arg2arg3);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3Block block) {
        try {
            return callBlock(contextcallerselfarg1arg2arg3block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        }
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3Block block) {
        try {
            return callBlock(contextcallerselfarg1arg2arg3block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockIRubyObject[] argsThreadContext contextIRubyObject selfString name) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodargsblock);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenameargsblock);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeIRubyObject[] argsThreadContext contextIRubyObject selfString name) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodargs);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenameargs);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject selfString name) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethod);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypename);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject selfString name) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodblock);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenameblock);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject selfString nameIRubyObject arg) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodarg);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenamearg);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject selfString nameIRubyObject arg) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodargblock);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenameargblock);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject selfString nameIRubyObject arg1IRubyObject arg2) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodarg1arg2);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenamearg1arg2);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject selfString nameIRubyObject arg1IRubyObject arg2) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodarg1arg2block);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenamearg1arg2block);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject selfString nameIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodarg1arg2arg3);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenamearg1arg2arg3);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject selfString nameIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
        CacheEntry entry = selfType != null ? selfType.searchWithCache(name) : .;
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfnamemethodarg1arg2arg3block);
        }
         = new SuperTuple(nameentry);
        return method.call(contextselfselfTypenamearg1arg2arg3block);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject[] args) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), nameargs.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod method) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), name.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodBlock block) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), nameblock);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject arg) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), namearg.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject[] argsBlock block) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), nameargsblock);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject arg0Block block) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), namearg0block);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject arg0IRubyObject arg1) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), namearg0arg1.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject arg0IRubyObject arg1Block block) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), namearg0arg1block);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject arg0IRubyObject arg1IRubyObject arg3) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), namearg0arg1arg3.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfString nameDynamicMethod methodIRubyObject arg0IRubyObject arg1IRubyObject arg2Block block) {
        return Helpers.callMethodMissing(contextselfmethod.getVisibility(), namearg0arg1arg2block);
    }
    protected boolean methodMissing(DynamicMethod methodIRubyObject caller) {
        return method.isUndefined();
    }
    protected static RubyClass pollAndGetClass(ThreadContext contextIRubyObject selfRubyModule frameClassString frameName) {
        checkSuperDisabledOrOutOfMethod(contextframeClassframeName);
        RubyClass superClass = Helpers.findImplementerIfNecessary(self.getMetaClass(), frameClass).getSuperClass();
        return superClass;
    }
    protected static void checkSuperDisabledOrOutOfMethod(ThreadContext contextRubyModule frameClassString frameName) {
        if (frameClass == null) {
            if (frameName != null) {
                throw context.runtime.newNameError("superclass method '" + frameName + "' disabled"frameName);
            } else {
                throw context.runtime.newNoMethodError("super called outside of method"nullcontext.runtime.getNil());
            }
        }
    }
    protected static IRubyObject handleBreakJump(ThreadContext contextJumpException.BreakJump bjthrows JumpException.BreakJump {
        if (context.getFrameJumpTarget() == bj.getTarget()) {
            return (IRubyObjectbj.getValue();
        }
        throw bj;
    }
    protected static RaiseException retryJumpError(ThreadContext context) {
        return context.runtime.newLocalJumpError(..context.runtime.getNil(), "retry outside of rescue not supported");
    }
New to GrepCode? Check out our FAQ X