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.
  * 
  * 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.compiler.impl;
 
 import java.util.List;
 import java.util.Map;
 import org.jruby.Ruby;
 import  org.objectweb.asm.Label;
 import static org.jruby.util.CodegenUtils.*;

Author(s):
headius
 
 public class InheritedCacheCompiler implements CacheCompiler {
     protected StandardASMCompiler scriptCompiler;
     int scopeCount = 0;
     int callSiteCount = 0;
     List<StringcallSiteList = new ArrayList<String>();
     List<CallTypecallTypeList = new ArrayList<CallType>();
     Map<StringIntegerstringIndices = new HashMap<StringInteger>();
     Map<StringIntegersymbolIndices = new HashMap<StringInteger>();
     Map<LongIntegerfixnumIndices = new HashMap<LongInteger>();
     Map<DoubleIntegerfloatIndices = new HashMap<DoubleInteger>();
     int inheritedSymbolCount = 0;
     int inheritedStringCount = 0;
     int inheritedEncodingCount = 0;
     int inheritedRegexpCount = 0;
     int inheritedBigIntegerCount = 0;
     int inheritedVariableReaderCount = 0;
     int inheritedVariableWriterCount = 0;
     int inheritedFixnumCount = 0;
     int inheritedFloatCount = 0;
     int inheritedConstantCount = 0;
     int inheritedBlockBodyCount = 0;
     int inheritedBlockCallbackCount = 0;
     int inheritedMethodCount = 0;
 
     boolean runtimeCacheInited = false;
     
     public InheritedCacheCompiler(StandardASMCompiler scriptCompiler) {
         this. = scriptCompiler;
    }
    public int reserveStaticScope() {
        int index = ;
        ++;
        return index;
    }
    public int cacheStaticScope(BaseBodyCompiler methodStaticScope scope) {
        String scopeString = Helpers.encodeScope(scope);
        
        int index = ;
        ++;
        // retrieve scope from scopes array
        method.loadThis();
        method.loadThreadContext();
        method.loadStaticScope();
        method.method.ldc(scopeString);
        if (index < .) {
            // use numbered access method
            method.method.invokevirtual(.getClassname(), "getScope" + indexsig(StaticScope.classThreadContext.classStaticScope.classString.class));
        } else {
            method.method.pushInt(index);
            method.method.invokevirtual(.getClassname(), "getScope"sig(StaticScope.classThreadContext.classStaticScope.classString.classint.class));
        }
        return index;
    }
    
    public void loadStaticScope(BaseBodyCompiler methodint index) {
        method.loadThis();
            // use numbered access method
            method.method.invokevirtual(.getClassname(), "getScope" + indexsig(StaticScope.class));
        } else {
            method.method.pushInt(index);
            method.method.invokevirtual(.getClassname(), "getScope"sig(StaticScope.classint.class));
        }
    }
    
    public void cacheCallSite(BaseBodyCompiler methodString nameCallType callType) {
        // retrieve call site from sites array
        method.loadThis();
            // use numbered access method
            method.method.invokevirtual(.getClassname(), "getCallSite" + sig(CallSite.class));
        } else {
            method.method.pushInt();
            method.method.invokevirtual(.getClassname(), "getCallSite"sig(CallSite.classint.class));
        }
        // add name to call site list
        .add(name);
        .add(callType);
        
        ++;
    }
    
    public void cacheSymbol(BaseBodyCompiler methodString symbol) {
        Integer index = .get(symbol);
        if (index == null) {
            index = Integer.valueOf(++);
            .put(symbolindex);
        }
        method.loadThis();
        method.loadThreadContext();
        if (index < .) {
            method.method.ldc(symbol);
            method.method.invokevirtual(.getClassname(), "getSymbol" + indexsig(RubySymbol.classThreadContext.classString.class));
        } else {
            method.method.ldc(index.intValue());
            method.method.ldc(symbol);
            method.method.invokevirtual(.getClassname(), "getSymbol"sig(RubySymbol.classThreadContext.classint.classString.class));
        }
    }
    public void cacheRegexp(BaseBodyCompiler methodByteList patternint options) {
        method.loadThis();
        method.loadThreadContext();
        int index = ++;
        if (index < .) {
            cacheByteList(methodpattern);
            method.method.ldc(options);
            method.method.invokevirtual(.getClassname(), "getRegexp" + indexsig(RubyRegexp.classThreadContext.classByteList.classint.class));
        } else {
            method.method.pushInt(index);
            cacheByteList(methodpattern);
            method.method.ldc(options);
            method.method.invokevirtual(.getClassname(), "getRegexp"sig(RubyRegexp.classThreadContext.classint.classByteList.classint.class));
        }
    }
    public void cacheDRegexp(BaseBodyCompiler methodCompilerCallback createStringCallbackint options) {
        int index = ++;
        Label alreadyCompiled = new Label();
        method.loadThis();
        method.method.getfield(.getClassname(), "runtimeCache"ci(RuntimeCache.class));
        method.method.pushInt(index);
        method.method.invokevirtual(p(RuntimeCache.class), "getRegexp"sig(RubyRegexp.classint.class));
        method.method.dup();
        method.ifNotNull(alreadyCompiled);
        method.method.pop();
        method.loadThis();
        method.method.getfield(.getClassname(), "runtimeCache"ci(RuntimeCache.class));
        method.method.pushInt(index);
        createStringCallback.call(method);
        method.method.ldc(options);
        method.method.invokevirtual(p(RuntimeCache.class), "cacheRegexp"sig(RubyRegexp.classint.classRubyString.classint.class));
        method.method.label(alreadyCompiled);
    }
    public void cacheDRegexp19(BaseBodyCompiler methodArrayCallback arrayCallbackObject[] sourceArrayint options) {
        int index = ++;
        Label alreadyCompiled = new Label();
        method.loadThis();
        method.method.getfield(.getClassname(), "runtimeCache"ci(RuntimeCache.class));
        method.method.pushInt(index);
        method.method.invokevirtual(p(RuntimeCache.class), "getRegexp"sig(RubyRegexp.classint.class));
        method.method.dup();
        method.ifNotNull(alreadyCompiled);
        method.method.pop();
        method.loadThis();
        method.method.getfield(.getClassname(), "runtimeCache"ci(RuntimeCache.class));
        method.method.pushInt(index);
        method.loadRuntime();
        method.createObjectArray(sourceArrayarrayCallback);
        method.method.ldc(options);
        method.method.invokestatic(p(RubyRegexp.class), "newDRegexpEmbedded19"sig(RubyRegexp.classparams(Ruby.classIRubyObject[].classint.class))); //[reg]
        method.method.invokevirtual(p(RuntimeCache.class), "cacheRegexp"sig(RubyRegexp.classint.classRubyRegexp.class));
        method.method.label(alreadyCompiled);
    }
    
    public void cacheFixnum(BaseBodyCompiler methodlong value) {
        if (value <= 5 && value >= -1) {
            method.loadRuntime();
            switch ((int)value) {
            case -1:
                method.method.invokestatic(p(RubyFixnum.class), "minus_one"sig(RubyFixnum.classRuby.class));
                break;
            case 0:
                method.method.invokestatic(p(RubyFixnum.class), "zero"sig(RubyFixnum.classRuby.class));
                break;
            case 1:
                method.method.invokestatic(p(RubyFixnum.class), "one"sig(RubyFixnum.classRuby.class));
                break;
            case 2:
                method.method.invokestatic(p(RubyFixnum.class), "two"sig(RubyFixnum.classRuby.class));
                break;
            case 3:
                method.method.invokestatic(p(RubyFixnum.class), "three"sig(RubyFixnum.classRuby.class));
                break;
            case 4:
                method.method.invokestatic(p(RubyFixnum.class), "four"sig(RubyFixnum.classRuby.class));
                break;
            case 5:
                method.method.invokestatic(p(RubyFixnum.class), "five"sig(RubyFixnum.classRuby.class));
                break;
            default:
                throw new RuntimeException("wtf?");
            }
        } else {
            Integer index = .get(value);
            if (index == null) {
                index =  Integer.valueOf(++);
                .put(valueindex);
            }
            
            method.loadThis();
            method.loadThreadContext();
            if (value <= . && value >= .) {
                if (index < .) {
                    method.method.pushInt((int)value);
                    method.method.invokevirtual(.getClassname(), "getFixnum" + indexsig(RubyFixnum.classThreadContext.classint.class));
                } else {
                    method.method.pushInt(index.intValue());
                    method.method.pushInt((int)value);
                    method.method.invokevirtual(.getClassname(), "getFixnum"sig(RubyFixnum.classThreadContext.classint.classint.class));
                }
            } else {
                method.method.pushInt(index.intValue());
                method.method.ldc(value);
                method.method.invokevirtual(.getClassname(), "getFixnum"sig(RubyFixnum.classThreadContext.classint.classlong.class));
            }
        }
    }
    
    public void cacheFloat(BaseBodyCompiler methoddouble value) {
        Integer index = Integer.valueOf(++);
        .put(valueindex);
        method.loadThis();
        method.loadThreadContext();
        if (index < .) {
            method.method.ldc(value);
            method.method.invokevirtual(.getClassname(), "getFloat" + indexsig(RubyFloat.classThreadContext.classdouble.class));
        } else {
            method.method.pushInt(index.intValue());
            method.method.ldc(value);
            method.method.invokevirtual(.getClassname(), "getFloat"sig(RubyFloat.classThreadContext.classint.classdouble.class));
        }
    }
    public void cacheConstant(BaseBodyCompiler methodString constantName) {
        method.loadThis();
        method.loadThreadContext();
        method.loadStaticScope();
        method.method.ldc(constantName);
            method.method.invokevirtual(.getClassname(), "getConstant" + sig(IRubyObject.classThreadContext.classStaticScope.classString.class));
        } else {
            method.method.pushInt();
            method.method.invokevirtual(.getClassname(), "getConstant"sig(IRubyObject.classThreadContext.classStaticScope.classString.classint.class));
        }
        ++;
    }
    public void cacheConstantBoolean(BaseBodyCompiler methodString constantName) {
        cacheConstant(methodconstantName);
        method.method.invokeinterface(p(IRubyObject.class), "isTrue"sig(boolean.class));
    }
    public void cacheConstantDefined(BaseBodyCompiler methodString constantName) {
        method.loadThis();
        method.loadThreadContext();
        method.loadStaticScope();
        method.method.ldc(constantName);
            method.method.invokevirtual(.getClassname(), "getConstantDefined" + sig(IRubyObject.classThreadContext.classStaticScope.classString.class));
        } else {
            method.method.pushInt();
            method.method.invokevirtual(.getClassname(), "getConstantDefined"sig(IRubyObject.classThreadContext.classStaticScope.classString.classint.class));
        }
        ++;
    }
    public void cacheConstantFrom(BaseBodyCompiler methodString constantName) {
        // module is on top of stack
        method.loadThis();
        method.method.swap();
        method.loadThreadContext();
        method.method.ldc(constantName);
            method.method.invokevirtual(.getClassname(), "getConstantFrom" + sig(IRubyObject.classRubyModule.classThreadContext.classString.class));
        } else {
            method.method.pushInt();
            method.method.invokevirtual(.getClassname(), "getConstantFrom"sig(IRubyObject.classRubyModule.classThreadContext.classString.classint.class));
        }
        ++;
    }
    public void cacheString(BaseBodyCompiler methodByteList contentsint codeRange) {
        String asString = Helpers.rawBytesToString(contents.bytes());
        String key = asString + contents.getEncoding();
        
        Integer index = .get(key);
        if (index == null) {
            index = Integer.valueOf(++);
            .put(keyasString);
            .put(keyindex);
            .put(keycacheEncodingInternal(contents.getEncoding()));
        }
        method.loadThis();
        method.loadThreadContext();
        if (index < .) {
            method.method.pushInt(codeRange);
            method.method.invokevirtual(.getClassname(), "getString" + indexsig(RubyString.classThreadContext.classint.class));
        } else {
            method.method.pushInt(index.intValue());
            method.method.pushInt(codeRange);
            method.method.invokevirtual(.getClassname(), "getString"sig(RubyString.classThreadContext.classint.classint.class));
        }
    }
    public void cacheByteList(BaseBodyCompiler methodByteList contents) {
        String asString = Helpers.rawBytesToString(contents.bytes());
        String key = asString + contents.getEncoding();
        Integer index = .get(key);
        if (index == null) {
            index = Integer.valueOf(++);
            .put(keyasString);
            .put(keyindex);
            .put(keycacheEncodingInternal(contents.getEncoding()));
        }
        method.loadThis();
        if (index < .) {
            method.method.invokevirtual(.getClassname(), "getByteList" + indexsig(ByteList.class));
        } else {
            method.method.pushInt(index.intValue());
            method.method.invokevirtual(.getClassname(), "getByteList"sig(ByteList.classint.class));
        }
    }
    public void cacheRubyEncoding(BaseBodyCompiler methodEncoding encoding) {
        // split into three methods since ByteList depends on two parts in different places
        cacheEncoding(methodencoding);
        createRubyEncoding(method);
    }
    
    public int cacheEncoding(BaseBodyCompiler methodEncoding encoding) {
        int index = cacheEncodingInternal(encoding);
        loadEncoding(method.methodindex);
        return index;
    }
    private int cacheEncodingInternal(Encoding encoding) {
        String encodingName = new String(encoding.getName());
        Integer index = .get(encodingName);
        if (index == null) {
            index = Integer.valueOf(++);
            .put(encodingNameindex);
        }
        return index;
    }
    private void loadEncoding(SkinnyMethodAdapter methodint encodingIndex) {
        method.aload(0);
        if (encodingIndex < .) {
            method.invokevirtual(.getClassname(), "getEncoding" + encodingIndexsig(Encoding.class));
        } else {
            method.pushInt(encodingIndex);
            method.invokevirtual(.getClassname(), "getEncoding"sig(Encoding.classint.class));
        }
    }
    private void createRubyEncoding(BaseBodyCompiler method) {
        method.loadRuntime();
        method.invokeRuby("getEncodingService"sig(EncodingService.class));
        method.method.swap();
        method.method.invokevirtual(p(EncodingService.class), "getEncoding"sig(RubyEncoding.classEncoding.class));
    }
    public void cacheBigInteger(BaseBodyCompiler methodBigInteger bigint) {
        method.loadThis();
        int index = ++;
        if (index < .) {
            method.method.ldc(bigint.toString(16));
            method.method.invokevirtual(.getClassname(), "getBigInteger" + indexsig(BigInteger.classString.class));
        } else {
            method.method.pushInt(index);
            method.method.ldc(bigint.toString(16));
            method.method.invokevirtual(.getClassname(), "getBigInteger"sig(BigInteger.classint.classString.class));
        }
    }
    public void cachedGetVariable(BaseBodyCompiler methodString name) {
        method.loadThis();
        method.loadThreadContext();
        int index = ++;
        if (index < .) {
            method.method.ldc(name);
            method.loadSelf();
            method.method.invokevirtual(.getClassname(), "getVariable" + indexsig(IRubyObject.classThreadContext.classString.classIRubyObject.class));
        } else {
            method.method.pushInt(index);
            method.method.ldc(name);
            method.loadSelf();
            method.method.invokevirtual(.getClassname(), "getVariable"sig(IRubyObject.classThreadContext.classint.classString.classIRubyObject.class));
        }
    }
    public void cachedGetVariableDefined(BaseBodyCompiler methodString name) {
        method.loadThis();
        method.loadThreadContext();
        int index = ++;
        if (index < .) {
            method.method.ldc(name);
            method.loadSelf();
            method.method.invokevirtual(.getClassname(), "getVariableDefined" + indexsig(IRubyObject.classThreadContext.classString.classIRubyObject.class));
        } else {
            method.method.pushInt(index);
            method.method.ldc(name);
            method.loadSelf();
            method.method.invokevirtual(.getClassname(), "getVariableDefined"sig(IRubyObject.classThreadContext.classint.classString.classIRubyObject.class));
        }
    }
    public void cachedSetVariable(BaseBodyCompiler methodString nameCompilerCallback valueCallback) {
        method.loadThis();
        int index = ++;
        if (index < .) {
            method.method.ldc(name);
            method.loadSelf();
            valueCallback.call(method);
            method.method.invokevirtual(.getClassname(), "setVariable" + indexsig(IRubyObject.classString.classIRubyObject.classIRubyObject.class));
        } else {
            method.method.pushInt(index);
            method.method.ldc(name);
            method.loadSelf();
            valueCallback.call(method);
            method.method.invokevirtual(.getClassname(), "setVariable"sig(IRubyObject.classint.classString.classIRubyObject.classIRubyObject.class));
        }
    }
    public int cacheClosure(BaseBodyCompiler methodString closureMethodint arityStaticScope scopeString fileint lineboolean hasMultipleArgsHeadNodeType argsNodeIdASTInspector inspector) {
        String descriptor = Helpers.buildBlockDescriptor(
                closureMethod,
                arity,
                file,
                line,
                hasMultipleArgsHead,
                argsNodeId,
                inspector);
        method.loadThis();
        method.loadThreadContext();
        int scopeIndex = cacheStaticScope(methodscope);
            method.method.ldc(descriptor);
            method.method.invokevirtual(.getClassname(), "getBlockBody" + sig(BlockBody.classThreadContext.classStaticScope.classString.class));
        } else {
            method.method.pushInt();
            method.method.ldc(descriptor);
            method.method.invokevirtual(.getClassname(), "getBlockBody"sig(BlockBody.classThreadContext.classStaticScope.classint.classString.class));
        }
        ++;
        return scopeIndex;
    }
    public int cacheClosure19(BaseBodyCompiler methodString closureMethodint arityStaticScope scopeString fileint lineboolean hasMultipleArgsHeadNodeType argsNodeIdString parameterListASTInspector inspector) {
        String descriptor = Helpers.buildBlockDescriptor19(
                closureMethod,
                arity,
                file,
                line,
                hasMultipleArgsHead,
                argsNodeId,
                parameterList,
                inspector);
        method.loadThis();
        method.loadThreadContext();
        int scopeIndex = cacheStaticScope(methodscope);
            method.method.ldc(descriptor);
            method.method.invokevirtual(.getClassname(), "getBlockBody19" + sig(BlockBody.classThreadContext.classStaticScope.classString.class));
        } else {
            method.method.pushInt();
            method.method.ldc(descriptor);
            method.method.invokevirtual(.getClassname(), "getBlockBody19"sig(BlockBody.classThreadContext.classStaticScope.classint.classString.class));
        }
        ++;
        return scopeIndex;
    }
    public void cacheSpecialClosure(BaseBodyCompiler methodString closureMethod) {
        method.loadThis();
        
            method.method.ldc(closureMethod);
            method.method.invokevirtual(.getClassname(), "getBlockCallback" + sig(CompiledBlockCallback.classString.class));
        } else {
            method.method.pushInt();
            method.method.ldc(closureMethod);
            method.method.invokevirtual(.getClassname(), "getBlockCallback"sig(CompiledBlockCallback.classint.classString.class));
        }
    }
    public void cacheMethod(BaseBodyCompiler methodString methodName) {
        method.loadThis();
        method.loadThreadContext();
        method.loadSelf();
            method.method.ldc(methodName);
            method.method.invokevirtual(.getClassname(), "getMethod" + sig(DynamicMethod.classThreadContext.classIRubyObject.classString.class));
        } else {
            method.method.pushInt();
            method.method.ldc(methodName);
            method.method.invokevirtual(.getClassname(), "getMethod"sig(DynamicMethod.classThreadContext.classIRubyObject.classint.classString.class));
        }
        ++;
    }
    public void cacheMethod(BaseBodyCompiler methodString methodNameint receiverLocal) {
        method.loadThis();
        method.loadThreadContext();
        method.method.aload(receiverLocal);
            method.method.ldc(methodName);
            method.method.invokevirtual(.getClassname(), "getMethod" + sig(DynamicMethod.classThreadContext.classIRubyObject.classString.class));
        } else {
            method.method.pushInt();
            method.method.ldc(methodName);
            method.method.invokevirtual(.getClassname(), "getMethod"sig(DynamicMethod.classThreadContext.classIRubyObject.classint.classString.class));
        }
        ++;
    }
    
    public void cacheGlobal(BaseBodyCompiler methodString globalName) {
        method.loadRuntime();
        method.method.ldc(globalName);
        method.invokeUtilityMethod("getGlobalVariable"sig(IRubyObject.classRuby.classString.class));
    }
    
    public void cacheGlobalBoolean(BaseBodyCompiler methodString globalName) {
        cacheGlobal(methodglobalName);
        method.method.invokeinterface(p(IRubyObject.class), "isTrue"sig(boolean.class));
    }
    
    public void cacheBoolean(BaseBodyCompiler methodboolean tru) {
        // no savings to cache under non-indy
        method.loadRuntime();
        method.invokeRuby(tru ? "getTrue" : "getFalse"sig(RubyBoolean.class));
    }
    public void finish() {
        SkinnyMethodAdapter initMethod = .getInitMethod();
        // generate call sites portion of descriptor
        int callSiteListSize = .size();
        int otherCount = 
                + 
                + 
                + 
                + 
                + 
                + 
                + 
                + 
                + 
                + 
                + 
                + 
                + ;
        if (callSiteListSize + otherCount != 0) {
            ensureRuntimeCacheInited(initMethod);
            StringBuffer descriptor = new StringBuffer(callSiteListSize * 5 + 12); // rough guess of total size
            for (int i = 0; i < callSiteListSizei++) {
                String name = .get(i);
                CallType callType = .get(i);
                
                if (i > 0) descriptor.append('\uFFFF');
                
                if (callType.equals(.)) {
                    descriptor.append(name).append("\uFFFFN");
                } else if (callType.equals(.)) {
                    descriptor.append(name).append("\uFFFFF");
                } else if (callType.equals(.)) {
                    descriptor.append(name).append("\uFFFFV");
                } else if (callType.equals(.)) {
                    descriptor.append("super").append("\uFFFFS");
                }
            }
            // generate "others" part of descriptor
            descriptor.append('\uFFFF');
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            descriptor.append((char));
            // init from descriptor
            initMethod.aload(0);
            initMethod.ldc(descriptor.toString());
            initMethod.invokevirtual(p(AbstractScript.class), "initFromDescriptor"sig(void.classString.class));
            
            if ( > 0) {
                // init all encodings
                for (Map.Entry<StringIntegerentry : .entrySet()) {
                    initMethod.aload(0);
                    initMethod.ldc(entry.getValue());
                    initMethod.ldc(entry.getKey());
                    initMethod.invokevirtual(p(AbstractScript.class), "setEncoding"sig(void.classint.classString.class));
                }
            }
            if ( > 0) {
                // init all strings
                for (Map.Entry<StringIntegerentry : .entrySet()) {
                    initMethod.aload(0);
                    initMethod.ldc(entry.getValue());
                    String key = entry.getKey();
                    initMethod.ldc(.get(key));
                    loadEncoding(initMethod.get(entry.getKey()));
                    initMethod.invokevirtual(p(AbstractScript.class), "setByteList"sig(void.classint.classString.classEncoding.class));
                }
            }
        }
    }
    private void ensureRuntimeCacheInited(SkinnyMethodAdapter initMethod) {
        if (!) {
            initMethod.aload(0);
            initMethod.newobj(p(RuntimeCache.class));
            initMethod.dup();
            initMethod.invokespecial(p(RuntimeCache.class), "<init>"sig(void.class));
            initMethod.putfield(p(AbstractScript.class), "runtimeCache"ci(RuntimeCache.class));
             = true;
        }
    }
New to GrepCode? Check out our FAQ X