Examples of com.android.dx.cf.iface.Method

com.android.dx.cf.iface.Method


    // Methods
    MethodList methods= classFile.getMethods();
    for (int i= 0; i < methods.size(); i++)
    {
      Method method= methods.get(i);
      // CstMethodRef methodRef = new
      // CstMethodRef(method.getDefiningClass(), method.getNat());
      // We shouldn't need to go through the signature. If the class is
      // not used in the code block, we can ignore it.
      // processSignature(methodRef, dependencies);
      processCode(getCode(method, classFile), classDeps.getMethodDeps(method.getName().toHuman()));
    }
  }

View Full Code Here

        CstType thisClass = cf.getThisClass();
        MethodList methods = cf.getMethods();
        int sz = methods.size();


        for (int i = 0; i < sz; i++) {
            Method one = methods.get(i);
            try {
                CstMethodRef meth = new CstMethodRef(thisClass, one.getNat());
                int accessFlags = one.getAccessFlags();
                boolean isStatic = AccessFlags.isStatic(accessFlags);
                boolean isPrivate = AccessFlags.isPrivate(accessFlags);
                boolean isNative = AccessFlags.isNative(accessFlags);
                boolean isAbstract = AccessFlags.isAbstract(accessFlags);
                boolean isConstructor = meth.isInstanceInit() ||
                    meth.isClassInit();
                DalvCode code;


                if (isNative || isAbstract) {
                    // There's no code for native or abstract methods.
                    code = null;
                } else {
                    ConcreteMethod concrete =
                        new ConcreteMethod(one, cf,
                                (args.positionInfo != PositionList.NONE),
                                args.localInfo);


                    TranslationAdvice advice;


                    advice = DexTranslationAdvice.THE_ONE;


                    RopMethod rmeth = Ropper.convert(concrete, advice);
                    RopMethod nonOptRmeth = null;
                    int paramSize;


                    paramSize = meth.getParameterWordCount(isStatic);
    
                    String canonicalName 
                            = thisClass.getClassType().getDescriptor()
                                + "." + one.getName().getString();


                    if (args.optimize &&
                            OptimizerOptions.shouldOptimize(canonicalName)) {
                        if (DEBUG) {
                            System.err.println("Optimizing " + canonicalName);
                        }


                        nonOptRmeth = rmeth;
                        rmeth = Optimizer.optimize(rmeth,
                                paramSize, isStatic, args.localInfo, advice);


                        if (DEBUG) {
                            OptimizerOptions.compareOptimizerStep(nonOptRmeth,
                                    paramSize, isStatic, args, advice, rmeth);
                        }


                        if (args.statistics) {
                            CodeStatistics.updateRopStatistics(
                                    nonOptRmeth, rmeth);
                        }
                    }


                    LocalVariableInfo locals = null;


                    if (args.localInfo) {
                        locals = LocalVariableExtractor.extract(rmeth);
                    }


                    code = RopTranslator.translate(rmeth, args.positionInfo,
                            locals, paramSize);


                    if (args.statistics && nonOptRmeth != null) {
                        updateDexStatistics(args, rmeth, nonOptRmeth, locals,
                                paramSize, concrete.getCode().size());
                    }
                }


                // Preserve the synchronized flag as its "declared" variant...
                if (AccessFlags.isSynchronized(accessFlags)) {
                    accessFlags |= AccessFlags.ACC_DECLARED_SYNCHRONIZED;


                    /*
                     * ...but only native methods are actually allowed to be
                     * synchronized.
                     */
                    if (!isNative) {
                        accessFlags &= ~AccessFlags.ACC_SYNCHRONIZED;
                    }
                }
                
                if (isConstructor) {
                    accessFlags |= AccessFlags.ACC_CONSTRUCTOR;
                }


                TypeList exceptions = AttributeTranslator.getExceptions(one);
                EncodedMethod mi =
                    new EncodedMethod(meth, accessFlags, code, exceptions);


                if (meth.isInstanceInit() || meth.isClassInit() ||
                    isStatic || isPrivate) {
                    out.addDirectMethod(mi);
                } else {
                    out.addVirtualMethod(mi);
                }


                Annotations annotations = 
                    AttributeTranslator.getMethodAnnotations(one);
                if (annotations.size() != 0) {
                    out.addMethodAnnotations(meth, annotations);
                }


                AnnotationsList list = 
                    AttributeTranslator.getParameterAnnotations(one);
                if (list.size() != 0) {
                    out.addParameterAnnotations(meth, list);
                }
            } catch (RuntimeException ex) {
                String msg = "...while processing " + one.getName().toHuman() +
                    " " + one.getDescriptor().toHuman();
                throw ExceptionWithContext.withContext(ex, msg);
            }
        }
    }

View Full Code Here

        Annotation result =
            new Annotation(thisClass, AnnotationVisibility.EMBEDDED);
        boolean any = false;


        for (int i = 0; i < sz; i++) {
            Method one = methods.get(i);
            AttributeList attribs = one.getAttributes();
            AttAnnotationDefault oneDefault = (AttAnnotationDefault)
                attribs.findFirst(AttAnnotationDefault.ATTRIBUTE_NAME);


            if (oneDefault != null) {
                NameValuePair pair = new NameValuePair(
                        one.getNat().getName(),
                        oneDefault.getValue());
                result.add(pair);
                any = true;
            }
        }

View Full Code Here

    MethodList methods= cf.getMethods();
    int sz= methods.size();


    for (int i= 0; i < sz; i++)
    {
      Method one= methods.get(i);


      if (hasAnnotation(one.getAttributes(), XMLVMIgnore.class))
      {
        // If this method has the @XMLVMIgnore annotation, we just
        // simply ignore it.
        continue;
      }


      if (skeletonOnly && (one.getAccessFlags() & (AccessFlags.ACC_PRIVATE | AccessFlags.ACC_SYNTHETIC)) != 0)
      {
        // We only want to generate skeletons. This method is private or
        // synthetic so simply ignore it.
        continue;
      }


      try
      {
        processMethod(one, cf, classElement, referencedTypes, skeletonOnly);
      }
      catch (RuntimeException ex)
      {
        String msg= "...while processing " + one.getName().toHuman() + " " + one.getDescriptor().toHuman();
        throw ExceptionWithContext.withContext(ex, msg);
      }
    }


    String className= classElement.getAttributeValue("name");

View Full Code Here

TOP

Related Classes of com.android.dx.cf.iface.Method

com.android.dx.dex.cf.AttributeTranslator

com.android.dx.dex.cf.CfTranslator

org.xmlvm.proc.out.DEXmlvmOutputProcess

org.xmlvm.util.analytics.JDKAnalyzer

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.