Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ast.executable;
  
  import java.util.Arrays;
  import org.jruby.Ruby;
 
 public class RuntimeCache {
 
     public RuntimeCache() {
     }
 
     public final StaticScope getScope(ThreadContext contextString varNamesDescriptorint index) {
         StaticScope scope = [index];
         if (scope == null) {
             [index] = scope = RuntimeHelpers.createScopeForClass(contextvarNamesDescriptor);
         }
         return scope;
     }
 
     public final StaticScope getScope(int index) {
         return [index];
     }
 
     public final CallSite getCallSite(int index) {
         return [index];
     }

    
descriptor format is closure_method_name,arity,varname1;varname2;varname3,has_multi_args_head,arg_type,light

Parameters:
context
index
descriptor
Returns:
 
     public final BlockBody getBlockBody(Object scriptObjectThreadContext contextint indexString descriptor) {
         BlockBody body = [index];
         if (body == null) {
             return createBlockBody(scriptObjectcontextindexdescriptor);
         }
         return body;
     }

    
descriptor format is closure_method_name,arity,varname1;varname2;varname3,has_multi_args_head,arg_type,light

Parameters:
context
index
descriptor
Returns:
 
     public final BlockBody getBlockBody19(Object scriptObjectThreadContext contextint indexString descriptor) {
         BlockBody body = [index];
         if (body == null) {
             return createBlockBody19(scriptObjectcontextindexdescriptor);
         }
         return body;
     }
 
     public final CompiledBlockCallback getBlockCallback(Object scriptObjectint indexString method) {
         CompiledBlockCallback callback = [index];
         if (callback == null) {
             return createCompiledBlockCallback(scriptObjectindexmethod);
         }
         return callback;
     }
 
     public final RubySymbol getSymbol(ThreadContext contextint indexString name) {
         RubySymbol symbol = [index];
         if (symbol == null) {
            return [index] = context.runtime.newSymbol(name);
        }
        return symbol;
    }
    public final RubyString getString(ThreadContext contextint indexint codeRange) {
        return RubyString.newStringShared(context.runtimegetByteList(index), codeRange);
    }
    public final ByteList getByteList(int index) {
        return [index];
    }
    public final Encoding getEncoding(int index) {
        return [index];
    }
    public final RubyFixnum getFixnum(ThreadContext contextint indexint value) {
        RubyFixnum fixnum = [index];
        if (fixnum == null) {
            return [index] = RubyFixnum.newFixnum(context.runtimevalue);
        }
        return fixnum;
    }
    public final RubyFixnum getFixnum(ThreadContext contextint indexlong value) {
        RubyFixnum fixnum = [index];
        if (fixnum == null) {
            return [index] = RubyFixnum.newFixnum(context.runtimevalue);
        }
        return fixnum;
    }
    public final RubyFloat getFloat(ThreadContext contextint indexdouble value) {
        RubyFloat flote = [index];
        if (flote == null) {
            return [index] = RubyFloat.newFloat(context.runtimevalue);
        }
        return flote;
    }
    public final RubyRegexp getRegexp(ThreadContext contextint indexByteList patternint options) {
        RubyRegexp regexp = [index];
        if (regexp == null || context.runtime.getKCode() != regexp.getKCode()) {
            regexp = RubyRegexp.newRegexp(context.runtimepattern, RegexpOptions.fromEmbeddedOptions(options));
            regexp.setLiteral();
            [index] = regexp;
        }
        return regexp;
    }
    public final RubyRegexp getRegexp(int index) {
        return [index];
    }
    public final RubyRegexp cacheRegexp(int indexRubyString patternint options) {
        RubyRegexp regexp = [index];
        Ruby runtime = pattern.getRuntime();
        if (regexp == null || runtime.getKCode() != regexp.getKCode()) {
            regexp = RubyRegexp.newRegexp(runtimepattern.getByteList(), RegexpOptions.fromEmbeddedOptions(options));
            [index] = regexp;
        }
        return regexp;
    }
    public final RubyRegexp cacheRegexp(int indexRubyRegexp regexp) {
        [index] = regexp;
        return regexp;
    }
    public final BigInteger getBigInteger(int indexString pattern) {
        BigInteger bigint = [index];
        if (bigint == null) {
            return [index] = new BigInteger(pattern, 16);
        }
        return bigint;
    }
    public final IRubyObject getVariable(ThreadContext contextint indexString nameIRubyObject object) {
        IRubyObject value = getValue(contextindexnameobject);
        if (value != nullreturn value;
        Ruby runtime = context.runtime;
        if (runtime.isVerbose()) {
            warnAboutUninitializedIvar(runtimename);
        }
        return runtime.getNil();
    }
    public final IRubyObject getVariableDefined(ThreadContext contextint indexString nameIRubyObject object) {
        return getValue(contextindexnameobject) == null ? null : context.runtime.getDefinedMessage(.);
    }
    private final IRubyObject getValue(ThreadContext contextint indexString nameIRubyObject object) {
        VariableAccessor variableAccessor = [index];
        RubyClass cls = object.getMetaClass().getRealClass();
        if (variableAccessor.getClassId() != cls.hashCode()) {
            [index] = variableAccessor = cls.getVariableAccessorForRead(name);
        }
        return (IRubyObject)variableAccessor.get(object);
    }
    private void warnAboutUninitializedIvar(Ruby runtimeString name) {
        runtime.getWarnings().warning(."instance variable " + name + " not initialized");
    }
    public final IRubyObject setVariable(int indexString nameIRubyObject objectIRubyObject value) {
        VariableAccessor variableAccessor = [index];
        RubyClass cls = object.getMetaClass().getRealClass();
        if (variableAccessor.getClassId() != cls.hashCode()) {
            [index] = variableAccessor = cls.getVariableAccessorForWrite(name);
        }
        variableAccessor.set(objectvalue);
        return value;
    }
    public final void initScopes(int size) {
         = new StaticScope[size];
    }
    public final void initCallSites(int size) {
         = new CallSite[size];
    }

    
Given a packed descriptor listing methods and their type, populate the call site cache. The format of the methods portion of the descriptor is name1;type1;name2;type2 where type1 and type2 are a single capital letter N, F, V, or S for the four main call types. After the method portion, the other cache sizes are provided as a packed String of char values representing the numeric sizes.

Parameters:
descriptor The descriptor to use for populating call sites and caches
See also:
RuntimeCache.initOthers.
    public final void initFromDescriptor(String descriptor) {
        String[] pieces = descriptor.split("\uFFFF");
        CallSite[] sites = new CallSite[pieces.length - 1 / 2];
        // if there's no call sites, don't process it
        if (pieces[0].length() != 0) {
            for (int i = 0; i < pieces.length - 1; i+=2) {
                switch (pieces[i + 1].charAt(0)) {
                case 'N':
                    sites[i/2] = MethodIndex.getCallSite(pieces[i]);
                    break;
                case 'F':
                    sites[i/2] = MethodIndex.getFunctionalCallSite(pieces[i]);
                    break;
                case 'V':
                    sites[i/2] = MethodIndex.getVariableCallSite(pieces[i]);
                    break;
                case 'S':
                    sites[i/2] = MethodIndex.getSuperCallSite();
                    break;
                default:
                    throw new RuntimeException("Unknown call type: " + pieces[i + 1] + " for method " + pieces[i]);
                }
            }
            this. = sites;
        }
        initOthers(pieces[pieces.length - 1]);
    }
    private static final int SCOPE = 0;
    private static final int SYMBOL =  + 1;
    private static final int FIXNUM =  + 1;
    private static final int FLOAT =  + 1;
    private static final int CONSTANT =  + 1;
    private static final int REGEXP =  + 1;
    private static final int BIGINTEGER =  + 1;
    private static final int VARIABLEREADER =  + 1;
    private static final int VARIABLEWRITER =  + 1;
    private static final int BLOCKBODY =  + 1;
    private static final int BLOCKCALLBACK =  + 1;
    private static final int METHOD =  + 1;
    private static final int STRING =  + 1;
    private static final int ENCODING =  + 1;

    
Given a packed descriptor of other cache sizes, construct the cache arrays The format of the descriptor is the actual size cast to char in this order:
  1. scopeCount
  2. inheritedSymbolCount
  3. inheritedFixnumCount
  4. inheritedConstantCount
  5. inheritedRegexpCount
  6. inheritedBigIntegerCount
  7. inheritedVariableReaderCount
  8. inheritedVariableWriterCount
  9. inheritedBlockBodyCount
  10. inheritedBlockCallbackCount
  11. inheritedMethodCount
  12. inheritedStringCount
  13. Parameters:
    descriptor The descriptor to use for preparing caches
    public final void initOthers(String descriptor) {
        int scopeCount = getDescriptorValue(descriptor);
        if (scopeCount > 0) initScopes(scopeCount);
        int symbolCount = getDescriptorValue(descriptor);
        if (symbolCount > 0) initSymbols(symbolCount);
        int fixnumCount = getDescriptorValue(descriptor);
        if (fixnumCount > 0) initFixnums(fixnumCount);
        int floatCount = getDescriptorValue(descriptor);
        if (floatCount > 0) initFloats(floatCount);
        int constantCount = getDescriptorValue(descriptor);
        if (constantCount > 0) initConstants(constantCount);
        int regexpCount = getDescriptorValue(descriptor);
        if (regexpCount > 0) initRegexps(regexpCount);
        int bigIntegerCount = getDescriptorValue(descriptor);
        if (bigIntegerCount > 0) initBigIntegers(bigIntegerCount);
        int variableReaderCount = getDescriptorValue(descriptor);
        if (variableReaderCount > 0) initVariableReaders(variableReaderCount);
        int variableWriterCount = getDescriptorValue(descriptor);
        if (variableWriterCount > 0) initVariableWriters(variableWriterCount);
        int blockBodyCount = getDescriptorValue(descriptor);
        if (blockBodyCount > 0) initBlockBodies(blockBodyCount);
        int blockCallbackCount = getDescriptorValue(descriptor);
        if (blockCallbackCount > 0) initBlockCallbacks(blockCallbackCount);
        int methodCount = getDescriptorValue(descriptor);
        if (methodCount > 0) initMethodCache(methodCount);
        int stringCount = getDescriptorValue(descriptor);
        if (stringCount > 0) initStrings(stringCount);
        int encodingCount = getDescriptorValue(descriptor);
        if (encodingCount > 0) initEncodings(encodingCount);
    }
    private static int getDescriptorValue(String descriptorint type) {
        return descriptor.charAt(type);
    }
    public final void initBlockBodies(int size) {
         = new BlockBody[size];
    }
    public final void initBlockCallbacks(int size) {
         = new CompiledBlockCallback[size];
    }
    public final void initSymbols(int size) {
         = new RubySymbol[size];
    }
    public final ByteList[] initStrings(int size) {
        return  = new ByteList[size];
    }
    public final Encoding[] initEncodings(int size) {
        return  = new Encoding[size];
    }
    public final void initFixnums(int size) {
         = new RubyFixnum[size];
    }
    public final void initFloats(int size) {
         = new RubyFloat[size];
    }
    public final void initRegexps(int size) {
         = new RubyRegexp[size];
    }
    public final void initBigIntegers(int size) {
         = new BigInteger[size];
    }
    public final void initConstants(int size) {
         = new IRubyObject[size];
         = new int[size];
         = new Object[size];
        Arrays.fill(, -1);
        Arrays.fill(, -1);
    }
    public final void initVariableReaders(int size) {
         = new VariableAccessor[size];
    }
    public final void initVariableWriters(int size) {
         = new VariableAccessor[size];
    }
    public final void initMethodCache(int size) {
         = new CacheEntry[size];
        Arrays.fill(.);
    }
    public final IRubyObject getConstant(ThreadContext contextString nameint index) {
        IRubyObject value = getValue(contextnameindex);
        // We can callsite cache const_missing if we want
        return value != null ? value : context.getCurrentScope().getStaticScope().getModule().callMethod(context"const_missing"context.runtime.fastNewSymbol(name));
    }
    public final IRubyObject getConstantDefined(ThreadContext contextString nameint index) {
        IRubyObject value = getValue(contextnameindex);
        return value == null ? null : context.runtime.getDefinedMessage(.);
    }
    public IRubyObject getValue(ThreadContext contextString nameint index) {
        IRubyObject value = [index]; // Store to temp so it does null out on us mid-stream
        return isCached(contextvalueindex) ? value : reCache(contextnameindex);
    }
    private boolean isCached(ThreadContext contextIRubyObject valueint index) {
        return value != null && [index] == context.runtime.getConstantInvalidator().getData();
    }
    public IRubyObject reCache(ThreadContext contextString nameint index) {
        Object newGeneration = context.runtime.getConstantInvalidator().getData();
        IRubyObject value = context.getConstant(name);
        [index] = value;
        if (value != null) {
            [index] = newGeneration;
        }
        return value;
    }
    public final IRubyObject getConstantFrom(RubyModule targetThreadContext contextString nameint index) {
        IRubyObject value = getValueFrom(targetcontextnameindex);
        // We can callsite cache const_missing if we want
        return value != null ? value : target.getConstantFromConstMissing(name);
    }
    public IRubyObject getValueFrom(RubyModule targetThreadContext contextString nameint index) {
        IRubyObject value = [index]; // Store to temp so it does null out on us mid-stream
        return isCachedFrom(targetcontextvalueindex) ? value : reCacheFrom(targetcontextnameindex);
    }
    private boolean isCachedFrom(RubyModule targetThreadContext contextIRubyObject valueint index) {
        return value != null && [index] == context.runtime.getConstantInvalidator().getData() && [index] == target.hashCode();
    }
    public IRubyObject reCacheFrom(RubyModule targetThreadContext contextString nameint index) {
        Object newGeneration = context.runtime.getConstantInvalidator().getData();
        IRubyObject value = target.getConstantFromNoConstMissing(namefalse);
        [index] = value;
        if (value != null) {
            [index] = newGeneration;
            [index] = target.hashCode();
        }
        return value;
    }
    private BlockBody createBlockBody(Object scriptObjectThreadContext contextint indexString descriptorthrows NumberFormatException {
        BlockBody body = RuntimeHelpers.createCompiledBlockBody(contextscriptObjectdescriptor);
        return [index] = body;
    }
    private BlockBody createBlockBody19(Object scriptObjectThreadContext contextint indexString descriptorthrows NumberFormatException {
        BlockBody body = RuntimeHelpers.createCompiledBlockBody19(contextscriptObjectdescriptor);
        return [index] = body;
    }
    private CompiledBlockCallback createCompiledBlockCallback(Object scriptObjectint indexString method) {
        CompiledBlockCallback callback = RuntimeHelpers.createBlockCallback(scriptObjectmethod"(internal)", -1);
        return [index] = callback;
    }
    public DynamicMethod getMethod(ThreadContext contextRubyClass selfTypeint indexString methodName) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method;
        }
        return cacheAndGet(contextselfTypeindexmethodName);
    }
    public DynamicMethod getMethod(ThreadContext contextIRubyObject selfint indexString methodName) {
        return getMethod(contextpollAndGetClass(contextself), indexmethodName);
    }
    private DynamicMethod cacheAndGet(ThreadContext contextRubyClass selfTypeint indexString methodName) {
        CacheEntry entry = selfType.searchWithCache(methodName);
        DynamicMethod method = entry.method;
        if (method.isUndefined()) {
            return RuntimeHelpers.selectMethodMissing(contextselfTypemethod.getVisibility(), methodName.);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return RuntimeHelpers.selectMethodMissing(clazzmethod.getVisibility(), name1.);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1String name2) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return searchWithCache(clazzindexname2);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1String name2String name3) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return searchWithCache(clazzindexname2name3);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1String name2String name3String name4) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return searchWithCache(clazzindexname2name3name4);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1String name2String name3String name4String name5) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return searchWithCache(clazzindexname2name3name4name5);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1String name2String name3String name4String name5String name6) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return searchWithCache(clazzindexname2name3name4name5name6);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1String name2String name3String name4String name5String name6String name7) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return searchWithCache(clazzindexname2name3name4name5name6name7);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(RubyClass clazzint indexString name1String name2String name3String name4String name5String name6String name7String name8) {
        CacheEntry entry = clazz.searchWithCache(name1);
        DynamicMethod method = entry.method;
        if (entry.method == .) {
            return searchWithCache(clazzindexname2name3name4name5name6name7name8);
        }
        [index] = entry;
        return method;
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1);
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1String name2) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1name2);
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1String name2String name3) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1name2name3);
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1String name2String name3String name4) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1name2name3name4);
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1String name2String name3String name4String name5) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1name2name3name4name5);
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1String name2String name3String name4String name5String name6) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1name2name3name4name5name6);
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1String name2String name3String name4String name5String name6String name7) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1name2name3name4name5name6name7);
    }
    public DynamicMethod searchWithCache(IRubyObject objint indexString name1String name2String name3String name4String name5String name6String name7String name8) {
        CacheEntry myCache = getCacheEntry(index);
        if (CacheEntry.typeOk(myCacheobj.getMetaClass())) {
            return myCache.method;
        }
        return searchWithCache(obj.getMetaClass(), indexname1name2name3name4name5name6name7name8);
    }
    private static RubyClass pollAndGetClass(ThreadContext contextIRubyObject self) {
        context.callThreadPoll();
        RubyClass selfType = self.getMetaClass();
        return selfType;
    }
    private CacheEntry getCacheEntry(int index) {
        return [index];
    }
    private static final StaticScope[] EMPTY_SCOPES = {};
    public StaticScope[] scopes = ;
    private static final CallSite[] EMPTY_CALLSITES = {};
    public CallSite[] callSites = ;
    private static final CacheEntry[] EMPTY_CACHEENTRIES = {};
    private static final BlockBody[] EMPTY_BLOCKBODIES = {};
    private static final CompiledBlockCallback[] EMPTY_COMPILEDBLOCKCALLBACKS = {};
    private static final RubySymbol[] EMPTY_RUBYSYMBOLS = {};
    public RubySymbol[] symbols = ;
    private static final ByteList[] EMPTY_BYTELISTS = {};
    public ByteList[] byteLists = ;
    private static final Encoding[] EMPTY_ENCODINGS = {};
    public Encoding[] encodings = ;
    private static final RubyFixnum[] EMPTY_FIXNUMS = {};
    public RubyFixnum[] fixnums = ;
    private static final RubyFloat[] EMPTY_FLOATS = {};
    public RubyFloat[] floats = ;
    private static final RubyRegexp[] EMPTY_RUBYREGEXPS = {};
    public RubyRegexp[] regexps = ;
    private static final BigInteger[] EMPTY_BIGINTEGERS = {};
    private static final VariableAccessor[] EMPTY_VARIABLE_ACCESSORS = {};
    private static final int[] EMPTY_INTS = {};
    private static final Object[] EMPTY_OBJS = {};
    public Object[] constantGenerations = ;
    public int[] constantTargetHashes = ;
New to GrepCode? Check out our FAQ X