Examples of clojure.asm.commons.Method

clojure.asm.commons.Method
A named method descriptor. @author Juozas Baliuka @author Chris Nokleberg @author Eric Bruneton

      if(context == C.RETURN)
        {
        ObjMethod method = (ObjMethod) METHOD.deref();
        method.emitClearLocals(gen);
        }
      Method m = new Method(methodName, Type.getReturnType(method), Type.getArgumentTypes(method));
      if(method.getDeclaringClass().isInterface())
        gen.invokeInterface(type, m);
      else
        gen.invokeVirtual(type, m);
      //if(context != C.STATEMENT || method.getReturnType() == Void.TYPE)

View Full Code Here

          gen.visitInsn((Integer) ops);
        }
      else
        {
        Type type = Type.getType(c);
        Method m = new Method(methodName, Type.getReturnType(method), Type.getArgumentTypes(method));
        gen.invokeStatic(type, m);
        }
      }
    else
      throw new UnsupportedOperationException("Unboxed emit of unknown member");

View Full Code Here

        {
        ObjMethod method = (ObjMethod) METHOD.deref();
        method.emitClearLocals(gen);
        }
      Type type = Type.getType(c);
      Method m = new Method(methodName, Type.getReturnType(method), Type.getArgumentTypes(method));
      gen.invokeStatic(type, m);
      //if(context != C.STATEMENT || method.getReturnType() == Void.TYPE)
      Class retClass = method.getReturnType();
      if(context == C.STATEMENT)
        {

View Full Code Here

      cv.visitField(ACC_PRIVATE, cachedProtoFnName(i), AFUNCTION_TYPE.getDescriptor(), null, null);
      cv.visitField(ACC_PRIVATE, cachedProtoImplName(i), IFN_TYPE.getDescriptor(), null, null);      
      }


     //ctor that takes closed-overs and inits base + fields
    Method m = new Method("<init>", Type.VOID_TYPE, ctorTypes());
    GeneratorAdapter ctorgen = new GeneratorAdapter(ACC_PUBLIC,
                                                    m,
                                                    null,
                                                    null,
                                                    cv);
    Label start = ctorgen.newLabel();
    Label end = ctorgen.newLabel();
    ctorgen.visitCode();
    ctorgen.visitLineNumber(line, ctorgen.mark());
    ctorgen.visitLabel(start);
    ctorgen.loadThis();
//    if(superName != null)
      ctorgen.invokeConstructor(Type.getObjectType(superName), voidctor);
//    else if(isVariadic()) //RestFn ctor takes reqArity arg
//      {
//      ctorgen.push(variadicMethod.reqParms.count());
//      ctorgen.invokeConstructor(restFnType, restfnctor);
//      }
//    else
//      ctorgen.invokeConstructor(aFnType, voidctor);


//    if(vars.count() > 0)
//      {
//      ctorgen.loadThis();
//      ctorgen.getStatic(VAR_TYPE,"rev",Type.INT_TYPE);
//      ctorgen.push(-1);
//      ctorgen.visitInsn(Opcodes.IADD);
//      ctorgen.putField(objtype, "__varrev__", Type.INT_TYPE);
//      }


    if(supportsMeta())
      {
      ctorgen.loadThis();
      ctorgen.visitVarInsn(IPERSISTENTMAP_TYPE.getOpcode(Opcodes.ILOAD), 1);
      ctorgen.putField(objtype, "__meta", IPERSISTENTMAP_TYPE);
      }


    int a = supportsMeta()?2:1;
    for(ISeq s = RT.keys(closes); s != null; s = s.next(), ++a)
      {
      LocalBinding lb = (LocalBinding) s.first();
      ctorgen.loadThis();
      Class primc = lb.getPrimitiveType();
      if(primc != null)
        {
        ctorgen.visitVarInsn(Type.getType(primc).getOpcode(Opcodes.ILOAD), a);
        ctorgen.putField(objtype, lb.name, Type.getType(primc));
        if(primc == Long.TYPE || primc == Double.TYPE)
          ++a;
        }
      else
        {
        ctorgen.visitVarInsn(OBJECT_TYPE.getOpcode(Opcodes.ILOAD), a);
        ctorgen.putField(objtype, lb.name, OBJECT_TYPE);
        }
            closesExprs = closesExprs.cons(new LocalBindingExpr(lb, null));
      }




    ctorgen.visitLabel(end);


    ctorgen.returnValue();


    ctorgen.endMethod();


    if(altCtorDrops > 0)
      {
          //ctor that takes closed-overs and inits base + fields
      Type[] ctorTypes = ctorTypes();
      Type[] altCtorTypes = new Type[ctorTypes.length-altCtorDrops];
      for(int i=0;i<altCtorTypes.length;i++)
        altCtorTypes[i] = ctorTypes[i];
      Method alt = new Method("<init>", Type.VOID_TYPE, altCtorTypes);
      ctorgen = new GeneratorAdapter(ACC_PUBLIC,
                              alt,
                              null,
                              null,
                              cv);
      ctorgen.visitCode();
      ctorgen.loadThis();
      ctorgen.loadArgs();
      for(int i=0;i<altCtorDrops;i++)
        ctorgen.visitInsn(Opcodes.ACONST_NULL);


      ctorgen.invokeConstructor(objtype, new Method("<init>", Type.VOID_TYPE, ctorTypes));


      ctorgen.returnValue();
      ctorgen.endMethod();
      }


    if(supportsMeta())
      {
      //ctor that takes closed-overs but not meta
      Type[] ctorTypes = ctorTypes();
      Type[] noMetaCtorTypes = new Type[ctorTypes.length-1];
      for(int i=1;i<ctorTypes.length;i++)
        noMetaCtorTypes[i-1] = ctorTypes[i];
      Method alt = new Method("<init>", Type.VOID_TYPE, noMetaCtorTypes);
      ctorgen = new GeneratorAdapter(ACC_PUBLIC,
                              alt,
                              null,
                              null,
                              cv);
      ctorgen.visitCode();
      ctorgen.loadThis();
      ctorgen.visitInsn(Opcodes.ACONST_NULL);  //null meta
      ctorgen.loadArgs();
      ctorgen.invokeConstructor(objtype, new Method("<init>", Type.VOID_TYPE, ctorTypes));


      ctorgen.returnValue();
      ctorgen.endMethod();


      //meta()
      Method meth = Method.getMethod("clojure.lang.IPersistentMap meta()");


      GeneratorAdapter gen = new GeneratorAdapter(ACC_PUBLIC,
                        meth,
                        null,
                        null,
                        cv);
      gen.visitCode();
      gen.loadThis();
      gen.getField(objtype,"__meta",IPERSISTENTMAP_TYPE);


      gen.returnValue();
      gen.endMethod();


      //withMeta()
      meth = Method.getMethod("clojure.lang.IObj withMeta(clojure.lang.IPersistentMap)");


      gen = new GeneratorAdapter(ACC_PUBLIC,
                        meth,
                        null,
                        null,
                        cv);
      gen.visitCode();
      gen.newInstance(objtype);
      gen.dup();
      gen.loadArg(0);


      for(ISeq s = RT.keys(closes); s != null; s = s.next(), ++a)
        {
        LocalBinding lb = (LocalBinding) s.first();
        gen.loadThis();
        Class primc = lb.getPrimitiveType();
        if(primc != null)
          {
          gen.getField(objtype, lb.name, Type.getType(primc));
          }
        else
          {
          gen.getField(objtype, lb.name, OBJECT_TYPE);
          }
        }


      gen.invokeConstructor(objtype, new Method("<init>", Type.VOID_TYPE, ctorTypes));
      gen.returnValue();
      gen.endMethod();
      }


    emitStatics(cv);
    emitMethods(cv);


    if(keywordCallsites.count() > 0)
      {
      Method meth = Method.getMethod("void swapThunk(int,clojure.lang.ILookupThunk)");


      GeneratorAdapter gen = new GeneratorAdapter(ACC_PUBLIC,
                        meth,
                        null,
                        null,

View Full Code Here

      gen.push(var.sym.toString());
      gen.invokeStatic(RT_TYPE, Method.getMethod("clojure.lang.Var var(String,String)"));
      }
    else if(value instanceof IType)
      {
      Method ctor = new Method("<init>", Type.getConstructorDescriptor(value.getClass().getConstructors()[0]));
      gen.newInstance(Type.getType(value.getClass()));
      gen.dup();
      IPersistentVector fields = (IPersistentVector) Reflector.invokeStaticMethod(value.getClass(), "getBasis", new Object[]{});
      for(ISeq s = RT.seq(fields); s != null; s = s.next())
        {
        Symbol field = (Symbol) s.first();
        Class k = tagClass(tagOf(field));
        Object val = Reflector.getInstanceField(value, field.name);
        emitValue(val, gen);


        if(k.isPrimitive())
          {
          Type b = Type.getType(boxClass(k));
          String p = Type.getType(k).getDescriptor();
          String n = k.getName();


          gen.invokeVirtual(b, new Method(n+"Value", "()"+p));
          }
        }
      gen.invokeConstructor(Type.getType(value.getClass()), ctor);
      }
    else if(value instanceof IRecord)
      {
      Method createMethod = Method.getMethod(value.getClass().getName() + " create(clojure.lang.IPersistentMap)");
            emitValue(PersistentArrayMap.create((java.util.Map) value), gen);
      gen.invokeStatic(getType(value.getClass()), createMethod);
      }
    else if(value instanceof IPersistentMap)
      {

View Full Code Here

        if(lb.getPrimitiveType() != null)
          objx.emitUnboxedLocal(gen, lb);
        else
          objx.emitLocal(gen, lb, lbe.shouldClear);
        }
      gen.invokeConstructor(objtype, new Method("<init>", Type.VOID_TYPE, ctorTypes()));
      }
    if(context == C.STATEMENT)
      gen.pop();
  }

View Full Code Here

      if(context == C.RETURN)
        {
        ObjMethod method = (ObjMethod) METHOD.deref();
        method.emitClearLocals(gen);
        }
      gen.invokeConstructor(type, new Method("<init>", Type.getConstructorDescriptor(ctor)));
      }
    else
      {
      gen.push(destubClassName(c.getName()));
      gen.invokeStatic(CLASS_TYPE, forNameMethod);

View Full Code Here

  public boolean canEmitPrimitive(){
    return retClass.isPrimitive();
  }


  public void emitUnboxed(C context, ObjExpr objx, GeneratorAdapter gen){
    Method ms = new Method("invokeStatic", getReturnType(), paramtypes);
    if(variadic)
      {
      for(int i = 0; i < paramclasses.length - 1; i++)
        {
        Expr e = (Expr) args.nth(i);

View Full Code Here

  abstract String getMethodName();
  abstract Type getReturnType();
  abstract Type[] getArgTypes();


  public void emit(ObjExpr fn, ClassVisitor cv){
    Method m = new Method(getMethodName(), getReturnType(), getArgTypes());


    GeneratorAdapter gen = new GeneratorAdapter(ACC_PUBLIC,
                                                m,
                                                null,
                                                //todo don't hardwire this

View Full Code Here

        cv.visitField(access
            , lb.name, OBJECT_TYPE.getDescriptor(), null, null);
      }


    //ctor that takes closed-overs and does nothing
    Method m = new Method("<init>", Type.VOID_TYPE, ret.ctorTypes());
    GeneratorAdapter ctorgen = new GeneratorAdapter(ACC_PUBLIC,
                                                    m,
                                                    null,
                                                    null,
                                                    cv);
    ctorgen.visitCode();
    ctorgen.loadThis();
    ctorgen.invokeConstructor(Type.getObjectType(superName), voidctor);
    ctorgen.returnValue();
    ctorgen.endMethod();


    if(ret.altCtorDrops > 0)
      {
      Type[] ctorTypes = ret.ctorTypes();
      Type[] altCtorTypes = new Type[ctorTypes.length-ret.altCtorDrops];
      for(int i=0;i<altCtorTypes.length;i++)
        altCtorTypes[i] = ctorTypes[i];
      Method alt = new Method("<init>", Type.VOID_TYPE, altCtorTypes);
      ctorgen = new GeneratorAdapter(ACC_PUBLIC,
                              alt,
                              null,
                              null,
                              cv);
      ctorgen.visitCode();
      ctorgen.loadThis();
      ctorgen.loadArgs();
      for(int i=0;i<ret.altCtorDrops;i++)
        ctorgen.visitInsn(Opcodes.ACONST_NULL);


      ctorgen.invokeConstructor(Type.getObjectType(COMPILE_STUB_PREFIX + "/" + ret.internalName),
                                new Method("<init>", Type.VOID_TYPE, ctorTypes));


      ctorgen.returnValue();
      ctorgen.endMethod();
      }
    //end of class

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of clojure.asm.commons.Method

clojure.lang.Compiler$FnExpr

clojure.lang.Compiler$FnMethod

clojure.lang.Compiler$HostExpr

clojure.lang.Compiler$InstanceMethodExpr

clojure.lang.Compiler$InvokeExpr

clojure.lang.Compiler$KeywordInvokeExpr

clojure.lang.Compiler$NewExpr

clojure.lang.Compiler$NewInstanceExpr

clojure.lang.Compiler$NewInstanceMethod

clojure.lang.Compiler$ObjExpr

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.