Java CfTranslator类代码示例

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Class<?> defineClass(String name, byte[] data) {
    try {
        DexOptions dexOptions = new DexOptions();
        DexFile dexFile = new DexFile(dexOptions);
        DirectClassFile classFile = new DirectClassFile(data, name.replace('.', '/') + ".class", true);
        classFile.setAttributeFactory(StdAttributeFactory.THE_ONE);
        classFile.getMagic();
        dexFile.add(CfTranslator.translate(classFile, null, new CfOptions(), dexOptions, dexFile));
        Dex dex = new Dex(dexFile.toDex(null, false));
        Dex oldDex = getLastDex();
        if (oldDex != null) {
            dex = new DexMerger(new Dex[]{dex, oldDex}, CollisionPolicy.KEEP_FIRST).merge();
        }
        return loadClass(dex, name);
    } catch (IOException | ClassNotFoundException e) {
        throw new FatalLoadingException(e);
    }
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
/**
 * Processes one classfile.
 *
 * @param name {@code non-null;} name of the file, clipped such that it
 * <i>should</i> correspond to the name of the class it contains
 * @param bytes {@code non-null;} contents of the file
 * @return whether processing was successful
 */
private static boolean processClass(String name, byte[] bytes) {
    if (! args.coreLibrary) {
        checkClassName(name);
    }

    try {
        ClassDefItem clazz =
            CfTranslator.translate(name, bytes, args.cfOptions, args.dexOptions);
        synchronized (outputDex) {
            outputDex.add(clazz);
        }
        return true;
    } catch (ParseException ex) {
        DxConsole.err.println("\ntrouble processing:");
        if (args.debug) {
            ex.printStackTrace(DxConsole.err);
        } else {
            ex.printContext(DxConsole.err);
        }
    }

    warnings++;
    return false;
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
private static final byte[] dex(String className, byte[] classData) throws ClassFormatError {
    try {
        DexOptions dexOptions = new DexOptions();
        DexFile dxFile = new DexFile(dexOptions);
        CfOptions cfOptions = new CfOptions();
        dxFile.add(CfTranslator.translate(className.replace('.', '/') + ".class", classData, cfOptions, dexOptions));
        StringWriter out = BridJ.debug ? new StringWriter() : null;
        byte[] dexData = dxFile.toDex(out, false);
        if (BridJ.debug) {
            BridJ.info("Dex output for class " + className + " : " + out);
        }
        return dexData;
    } catch (IOException ex) {
        throw new ClassFormatError("Unable to convert class data to Dalvik code using Dex : " + ex);
    }
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
private ClassDefItem translateClass(byte[] bytes, DirectClassFile cf) {
    try {
        return CfTranslator.translate(cf, bytes, cfOptions, dexOptions, outputDex);
    } catch (ParseException e) {
        e.printStackTrace();
        errors.incrementAndGet();
        return null;
    }
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
private static ClassDefItem translateClass(byte[] bytes, DirectClassFile cf) {
    try {
        return CfTranslator.translate(cf, bytes, args.cfOptions,
                args.dexOptions, outputDex);
    } catch (ParseException ex) {
        System.err.println("\ntrouble processing:");
        if (args.debug) {
            ex.printStackTrace(System.err);
        } else {
            ex.printContext(System.err);
        }
    }
    errors.incrementAndGet();
    return null;
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
private static ClassDefItem translateClass(byte[] bytes, DirectClassFile cf) {
    try {
        return CfTranslator.translate(cf, bytes, args.cfOptions,
                args.dexOptions, outputDex);
    } catch (ParseException ex) {
        DxConsole.err.println("\ntrouble processing:");
        if (args.debug) {
            ex.printStackTrace(DxConsole.err);
        } else {
            ex.printContext(DxConsole.err);
        }
    }
    errors.incrementAndGet();
    return null;
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
private OutputFile generateDexFile(OutputFile classFile) {
    if (!classFile.getFullPath().startsWith(arguments.option_out())) {
        Log.error("DexOutputProcess: Something is wrong with the class output path.");
        return null;
    }
    String relativePath = classFile.getFullPath()
            .substring(arguments.option_out().length() + 1);

    // Remove a starting slash or backslash.
    if (relativePath.startsWith("/") || relativePath.startsWith("\\")) {
        relativePath = relativePath.substring(1);
    }
    Log.debug("DExing:" + relativePath);

    CfOptions options = new CfOptions();
    options.strictNameCheck = false;
    ClassDefItem item = CfTranslator.translate(relativePath, classFile.getDataAsBytes(),
            options);
    DexFile dexFile = new DexFile();
    dexFile.add(item);
    try {
        byte[] rawDex = dexFile.toDex(null, false);
        OutputFile result = new OutputFile(rawDex);
        result.setLocation(classFile.getLocation());
        result.setFileName(classFile.getFileName().replace(ClassFile.CLASS_ENDING, DEX_ENDING));
        return result;
    } catch (IOException e) {
        e.printStackTrace();
        Log.error("Could not generate DEX file.");
    }
    return null;
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
public ClassDefItem addToDexFile(DexFile dest, DirectClassFile classFile) {
  ClassDefItem result = CfTranslator.translate(
      context,
      classFile,
      (byte[]) null /*ignored*/,
      cfOptions,
      dest.getDexOptions(),
      dest);
  dest.add(result);
  return result;
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
@Override
public void register(String name, byte[] binaryRepresentation) {
    DirectClassFile directClassFile = new DirectClassFile(binaryRepresentation, name.replace('.', '/') + CLASS_FILE_EXTENSION, NON_STRICT);
    directClassFile.setAttributeFactory(new StdAttributeFactory());
    dexFile.add(CfTranslator.translate(directClassFile,
            binaryRepresentation,
            dexCompilerOptions,
            dexFileOptions,
            new DexFile(dexFileOptions)));
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
private ClassDefItem translateClass(byte[] bytes, DirectClassFile cf) {
    try {
        return CfTranslator.translate(context, cf, bytes, args.cfOptions,
            args.dexOptions, outputDex);
    } catch (ParseException ex) {
        context.err.println("\ntrouble processing:");
        if (args.debug) {
            ex.printStackTrace(context.err);
        } else {
            ex.printContext(context.err);
        }
    }
    errors.incrementAndGet();
    return null;
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
public void addClass(String nameClass, byte[] byteClass) {
    final CfOptions cf_options = new CfOptions();
    //System.out.println(nameClass);
    final ClassDefItem cdi = CfTranslator.translate(nameClass, byteClass, cf_options, dex_options);
    file.add(cdi);
}
 

import com.android.dx.dex.cf.CfTranslator; //导入依赖的package包/类
/**
 * Processes one classfile.
 *
 * @param name {@code non-null;} name of the file, clipped such that it
 * <i>should</i> correspond to the name of the class it contains
 * @param bytes {@code non-null;} contents of the file
 * @return whether processing was successful
 */
private boolean processClass(String name, byte[] bytes) {
    if (! args.coreLibrary) {
        checkClassName(name);
    }

    DirectClassFile cf =
        new DirectClassFile(bytes, name, args.cfOptions.strictNameCheck);

    cf.setAttributeFactory(StdAttributeFactory.THE_ONE);
    cf.getMagic();

    int numMethodIds = outputDex.getMethodIds().items().size();
    int numFieldIds = outputDex.getFieldIds().items().size();
    int numTypeIds = outputDex.getTypeIds().items().size();
    int constantPoolSize = cf.getConstantPool().size();

    if (args.multiDex && ((numMethodIds + constantPoolSize > args.maxNumberOfIdxPerDex) ||
        (numFieldIds + constantPoolSize > args.maxNumberOfIdxPerDex) ||
        (numTypeIds + constantPoolSize
                /* annotation added by dx are not counted in numTypeIds */
                + AnnotationUtils.DALVIK_ANNOTATION_NUMBER
                > args.maxNumberOfIdxPerDex))) {
      createDexFile();
    }

    try {
        ClassDefItem clazz =
            CfTranslator.translate(cf, bytes, args.cfOptions, args.dexOptions, args.optimizerOptions, outputDex);
        synchronized (outputDex) {
            outputDex.add(clazz);
        }
        return true;

    } catch (ParseException ex) {
        dxConsole.err.println("\ntrouble processing:");
        if (args.debug) {
            ex.printStackTrace(dxConsole.err);
        } else {
            ex.printContext(dxConsole.err);
        }
    }
    errors++;
    return false;
}