Java AccessFlags类代码示例

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
public TempClassInfo(String dexFilePath, ClassDefItem classDefItem) {
    this.dexFilePath = dexFilePath;

    classType = classDefItem.getClassType().getTypeDescriptor();

    isInterface = (classDefItem.getAccessFlags() & AccessFlags.INTERFACE.getValue()) != 0;

    TypeIdItem superclassType = classDefItem.getSuperclass();
    if (superclassType == null) {
        this.superclassType = null;
    } else {
        this.superclassType = superclassType.getTypeDescriptor();
    }

    interfaces = loadInterfaces(classDefItem);

    ClassDataItem classDataItem = classDefItem.getClassData();
    if (classDataItem != null) {
        virtualMethods = loadVirtualMethods(classDataItem);
        instanceFields = loadInstanceFields(classDataItem);
    } else {
        virtualMethods = null;
        instanceFields = null;
    }
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
/** {@inheritDoc} */
protected void writeItem(AnnotatedOutput out) {
    if (out.annotates()) {
        out.annotate(4, "class_type: " + classType.getTypeDescriptor());
        out.annotate(4, "access_flags: " + AccessFlags.formatAccessFlagsForClass(accessFlags));
        out.annotate(4, "superclass_type: " + (superType==null?"":superType.getTypeDescriptor()));
        out.annotate(4, "interfaces: " +
                (implementedInterfaces==null?"":implementedInterfaces.getTypeListString(" ")));
        out.annotate(4, "source_file: " + (sourceFile==null?"":sourceFile.getStringValue()));
        out.annotate(4, "annotations_off: " +
                (annotations==null?"":"0x"+Integer.toHexString(annotations.getOffset())));
        out.annotate(4, "class_data_off:" +
                (classData==null?"":"0x"+Integer.toHexString(classData.getOffset())));
        out.annotate(4, "static_values_off: " +
                (staticFieldInitializers==null?"":"0x"+Integer.toHexString(staticFieldInitializers.getOffset())));
    }
    out.writeInt(classType.getIndex());
    out.writeInt(accessFlags);
    out.writeInt(superType==null?-1:superType.getIndex());
    out.writeInt(implementedInterfaces==null?0:implementedInterfaces.getOffset());
    out.writeInt(sourceFile==null?-1:sourceFile.getIndex());
    out.writeInt(annotations==null?0:annotations.getOffset());
    out.writeInt(classData==null?0:classData.getOffset());
    out.writeInt(staticFieldInitializers==null?0:staticFieldInitializers.getOffset());
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
protected ClassDef(ClassDefItem classDefItem) {
    classType = classDefItem.getClassType().getTypeDescriptor();

    isInterface = (classDefItem.getAccessFlags() & AccessFlags.INTERFACE.getValue()) != 0;

    superclass = loadSuperclass(classDefItem);
    if (superclass == null) {
        classDepth = 0;
    } else {
        classDepth = superclass.classDepth + 1;
    }

    implementedInterfaces = loadAllImplementedInterfaces(classDefItem);

    vtable = loadVtable(classDefItem);
    virtualMethodLookup = new HashMap<String, Integer>((int)Math.ceil(vtable.length / .7f), .75f);
    for (int i=0; i<vtable.length; i++) {
        virtualMethodLookup.put(vtable[i], i);
    }

    instanceFields = loadFields(classDefItem);
    instanceFieldLookup = new HashMap<String, Integer>((int)Math.ceil(instanceFields.size() / .7f), .75f);
    for (int i=0; i<instanceFields.size(); i++) {
        instanceFieldLookup.put(instanceFields.get(i), i);
    }
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private String[] loadDirectMethods(ClassDataItem classDataItem, boolean[][] _staticMethods) {
    List<EncodedMethod> encodedMethods = classDataItem.getDirectMethods();
    if (encodedMethods.size() > 0) {
        boolean[] staticMethods = new boolean[encodedMethods.size()];
        String[] directMethods = new String[encodedMethods.size()];

        for (int i=0; i<encodedMethods.size(); i++) {
            EncodedMethod encodedMethod = encodedMethods.get(i);

            if ((encodedMethod.accessFlags & AccessFlags.STATIC.getValue()) != 0) {
                staticMethods[i] = true;
            }
            directMethods[i] = encodedMethod.method.getShortMethodString();
        }
        _staticMethods[0] = staticMethods;
        return directMethods;
    }
    return null;
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private static int getRegisterCount(ClassDataItem.EncodedMethod encodedMethod)
{
    int totalRegisters = encodedMethod.codeItem.getRegisterCount();
    if (baksmali.useLocalsDirective) {
        int parameterRegisters = encodedMethod.method.getPrototype().getParameterRegisterCount();
        if ((encodedMethod.accessFlags & AccessFlags.STATIC.getValue()) == 0) {
            parameterRegisters++;
        }
        return totalRegisters - parameterRegisters;
    }
    return totalRegisters;
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private static void writeAccessFlags(IndentingWriter writer, ClassDataItem.EncodedMethod encodedMethod)
                                                                                        throws IOException {
    for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForMethod(encodedMethod.accessFlags)) {
        writer.write(accessFlag.toString());
        writer.write(' ');
    }
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private void addParamRegs(BitSet registers, int registerCount) {
    ClassDataItem.EncodedMethod encodedMethod = methodAnalyzer.getMethod();
    int parameterRegisterCount = encodedMethod.method.getPrototype().getParameterRegisterCount();
    if ((encodedMethod.accessFlags & AccessFlags.STATIC.getValue()) == 0) {
        parameterRegisterCount++;
    }

    registers.set(registerCount-parameterRegisterCount, registerCount);
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
/**
 * Writes a register with the appropriate format. If baksmali.noParameterRegisters is true, then it will always
 * output a register in the v<n> format. If false, then it determines if the register is a parameter register,
 * and if so, formats it in the p<n> format instead.
 *
 * @param writer the <code>IndentingWriter</code> to write to
 * @param codeItem the <code>CodeItem</code> that the register is from
 * @param register the register number
 */
public static void writeTo(IndentingWriter writer, CodeItem codeItem, int register) throws IOException {
    if (!baksmali.noParameterRegisters) {
        int parameterRegisterCount = codeItem.getParent().method.getPrototype().getParameterRegisterCount()
                + (((codeItem.getParent().accessFlags & AccessFlags.STATIC.getValue())==0)?1:0);
        int registerCount = codeItem.getRegisterCount();
        if (register >= registerCount - parameterRegisterCount) {
            writer.write('p');
            writer.printIntAsDec((register - (registerCount - parameterRegisterCount)));
            return;
        }
    }
    writer.write('v');
    writer.printIntAsDec(register);
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
public static void writeTo(IndentingWriter writer, ClassDataItem.EncodedField encodedField,
                                            EncodedValue initialValue, AnnotationSetItem annotationSet,
                                            boolean setInStaticConstructor) throws IOException {

    String fieldTypeDescriptor = encodedField.field.getFieldType().getTypeDescriptor();

    if (setInStaticConstructor &&
        encodedField.isStatic() &&
        (encodedField.accessFlags & AccessFlags.FINAL.getValue()) != 0 &&
        initialValue != null &&
        (
            //it's a primitive type, or it's an array/reference type and the initial value isn't null
            fieldTypeDescriptor.length() == 1 ||
            initialValue != NullEncodedValue.NullValue
        )) {

        writer.write("#the value of this static final field might be set in the static constructor\n");
    }

    writer.write(".field ");
    writeAccessFlags(writer, encodedField);
    writer.write(encodedField.field.getFieldName().getStringValue());
    writer.write(':');
    writer.write(encodedField.field.getFieldType().getTypeDescriptor());
    if (initialValue != null) {
        writer.write(" = ");
        EncodedValueAdaptor.writeTo(writer, initialValue);
    }

    writer.write('\n');

    if (annotationSet != null) {
        writer.indent(4);
        AnnotationFormatter.writeTo(writer, annotationSet);
        writer.deindent(4);
        writer.write(".end field\n");
    }
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private static void writeAccessFlags(IndentingWriter writer, ClassDataItem.EncodedField encodedField)
                                                                                             throws IOException {
    for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForField(encodedField.accessFlags)) {
        writer.write(accessFlag.toString());
        writer.write(' ');
    }
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
public UnresolvedClassInfo(String dexFilePath, ClassDefItem classDefItem) {
    this.dexFilePath = dexFilePath;

    classType = classDefItem.getClassType().getTypeDescriptor();

    isPublic = (classDefItem.getAccessFlags() & AccessFlags.PUBLIC.getValue()) != 0;
    isInterface = (classDefItem.getAccessFlags() & AccessFlags.INTERFACE.getValue()) != 0;

    TypeIdItem superclassType = classDefItem.getSuperclass();
    if (superclassType == null) {
        this.superclassType = null;
    } else {
        this.superclassType = superclassType.getTypeDescriptor();
    }

    interfaces = loadInterfaces(classDefItem);

    ClassDataItem classDataItem = classDefItem.getClassData();
    if (classDataItem != null) {
        boolean[][] _staticMethods = new boolean[1][];
        directMethods = loadDirectMethods(classDataItem, _staticMethods);
        staticMethods = _staticMethods[0];
        virtualMethods = loadVirtualMethods(classDataItem);
        instanceFields = loadInstanceFields(classDataItem);
    } else {
        staticMethods = null;
        directMethods = null;
        virtualMethods = null;
        instanceFields = null;
    }
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
/**
 * Writes a register with the appropriate format. If baksmali.noParameterRegisters is true, then it will always
 * output a register in the v<n> format. If false, then it determines if the register is a parameter register,
 * and if so, formats it in the p<n> format instead.
 *
 * @param writer the <code>IndentingWriter</code> to write to
 * @param codeItem the <code>CodeItem</code> that the register is from
 * @param register the register number
 */
public static void writeTo(IndentingWriter writer, CodeItem codeItem, int register) throws IOException {
    if (!baksmali.noParameterRegisters) {
        int parameterRegisterCount = codeItem.getParent().method.getPrototype().getParameterRegisterCount()
                + (((codeItem.getParent().accessFlags & AccessFlags.STATIC.getValue())==0)?1:0);
        int registerCount = codeItem.getRegisterCount();
        if (register >= registerCount - parameterRegisterCount) {
            writer.write('p');
            writer.printSignedIntAsDec((register - (registerCount - parameterRegisterCount)));
            return;
        }
    }
    writer.write('v');
    writer.printSignedIntAsDec(register);
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private boolean isInstanceConstructor() {
    return (encodedMethod.accessFlags & AccessFlags.STATIC.getValue()) == 0 &&
           (encodedMethod.accessFlags & AccessFlags.CONSTRUCTOR.getValue()) != 0;
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private boolean isStaticConstructor() {
    return (encodedMethod.accessFlags & AccessFlags.STATIC.getValue()) != 0 &&
           (encodedMethod.accessFlags & AccessFlags.CONSTRUCTOR.getValue()) != 0;
}
 

import org.jf.dexlib.Util.AccessFlags; //导入依赖的package包/类
private void writeAccessFlags(IndentingWriter writer) throws IOException {
    for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForClass(classDefItem.getAccessFlags())) {
        writer.write(accessFlag.toString());
        writer.write(' ');
    }
}