private fun findReferencedClasses(referencingClass: Clazz, member: Member?, descriptor: String, owner: String,                                      name: String,  node: String): ArrayList? {        val enumeration = DescriptorClassEnumeration(descriptor)        val classCount = enumeration.classCount()        var referencedClasses :ArrayList? = null        if (classCount > 0) {            referencedClasses = ArrayList()            for (index in 0 until classCount) {                val fluff = enumeration.nextFluff()                val name = enumeration.nextClassName()                val referencedClass: Clazz? = findClass(referencingClass, member, name, node)                if (referencedClass != null) {                    referencedClasses.add(referencedClass)                }            }        }        val referencedClass: Clazz? = findClass(referencingClass, member, owner, node)        if (referencedClass != null) {            if (referencedClasses == null) {                referencedClasses = ArrayList()            }            referencedClasses.add(referencedClass)        }        return referencedClasses    }

复制

    public static class MethodInfo {        private int obfuscatedFirstLineNumber;        private int obfuscatedLastLineNumber;        private final String originalClassName;        private int originalFirstLineNumber;        private int originalLastLineNumber;        private final String originalType;        private final String originalName;        private final String originalArguments;
        private final String obfuscatedName;        private final String obfuscatedArguments;        public MethodInfo inlineToInfo;        public MethodInfo inlineByInfo;        //mapping文件中是否为:xxx:xxx[false], :xxx[true]        private boolean sameLineNumber; 
        private boolean markRemoved;}

复制

def spreadDiffClassMarker = new SpreadDiffClassVisitor(spreadDiffWriter, logWriter,                    configuration.classLoader, programClassPool)            programClassPool.classAccept(                    new ClassProcessingInfoFilter(Status.NodeStatusFlag.ADD.value |                                                  Status.NodeStatusFlag.CHANGE.value |                                                  Status.NodeStatusFlag.REPLACE.value, 0, 0,                            new MultiClassVisitor(                                    spreadDiffClassMarker,
                                    new MMAllMemberVisitor(                                            new MMemberProcessingInfoFilter(Status.NodeStatusFlag.ADD.value |                                                                            Status.NodeStatusFlag.CHANGE.value, 0, 0, spreadDiffClassMarker)))))}

复制

usageMarker.isAdded(programMethod) || usageMarker.isSpreadAdded(programMethod) -> {                    val exceptionsArray: Array? =                        if (programMethod.exceptions == null) null else programMethod.exceptions.toTypedArray()                    val correctMethodVisitor = outputClass.visitMethod(                        programMethod.access,                        programMethod.name,                        programMethod.desc,                        programMethod.signature,                        exceptionsArray                    ) as MMethodNode
                    processingFlagMarker.markCorrectAdd(correctMethodVisitor)
                    programMethod.accept(InnerProcessingMethodVisitor(                        programClass = inputProgramClass,                        inputMethodNode = programMethod,                        methodVisitor = correctMethodVisitor                    ))                }

复制

usageMarker.isChanged(inputMethodNode) || usageMarker.isSpreadChanged(inputMethodNode) -> {
                    val index = outputProgramClass.methods.indexOf(outputProgramMethod)                    val exceptionsArray: Array? =                if (outputProgramMethod.exceptions == null) null else outputProgramMethod.exceptions.toTypedArray()            val newProgramMethod = MMProgramMethodNode(outputProgramMethod.access,                                                       outputProgramMethod.name,                                                       outputProgramMethod.desc,                                                       outputProgramMethod.signature,                                                       exceptionsArray)            inputMethodNode.accept(                InnerProcessingMethodVisitor(                    programClass = inputProgramClass,                    inputMethodNode = inputMethodNode,                    methodVisitor = newProgramMethod                )            )            outputProgramClass.methods[index] = newProgramMethod
            processingFlagMarker.markCorrectChange(newProgramMethod)        }

复制

indexLineNumberOffsets = inputMethodNode.getLineNumberOffset(inputProgramClass)
                    val filterInputLineNumberNodes = inputMethodNode.filterLineNumberNodes()                    val filterOutputLineNumberNodes = outputProgramMethod.filterLineNumberNodes()                    if (filterInputLineNumberNodes.size == indexLineNumberOffsets?.size && filterOutputLineNumberNodes.size == indexLineNumberOffsets?.size ) {                        oldLineNumberArray = inputMethodNode.filterLineNumberNodes().mapIndexed { _index ,lineNumberNode -> lineNumberNode.line - indexLineNumberOffsets!![_index] }                        outputProgramMethod.insnsAccept(outputProgramClass, this, null)                    } else {                        logPrinter?.println("$TAG >>>>>>>>>>>>>> ERROR, lineNumberNodes is not same size!")                    }

复制

  // Process mapping  def mappingProcessor = new ProcessingMappingVisitor(mappingRemapper, logPrinter, outputProgramPool)  outputProgramPool.classAccept(new MultiClassVisitor(                                          // Update class mapping                                          new ClassProcessingFlagFilter(ProcessingFlag.CORRECTED_CHANGE.value |                                                                        ProcessingFlag.CORRECTED_ADD.value |                                                                        ProcessingFlag.CORRECTED_REPLACED.value,                                                  0,0, mappingProcessor),
                                          new MMAllMemberVisitor(                                                  // Update methods/fields mapping                                                  new MMemberProcessingFlagFilter(ProcessingFlag.CORRECTED_CHANGE.value |                                                                                  ProcessingFlag.CORRECTED_ADD.value|                                                                                  ProcessingFlag.CORRECTED_REPLACED.value,                                                          0, 0, mappingProcessor)),  ))

复制

if (typeInsnNode.opcode == Opcodes.NEW ||    typeInsnNode.opcode == Opcodes.ANEWARRAY ||    typeInsnNode.opcode == Opcodes.CHECKCAST ||    typeInsnNode.opcode == Opcodes.INSTANCEOF) {    typeInsnNode.desc = obfuscatedDescriptor(typeInsnNode.desc, mapper, logPrinter)    logPrinter?.println("$TAG, >>>>>>>> process typeInsn desc: ${typeInsnNode.desc}" +            " -> obfuscate desc: ${typeInsnNode.desc}")}

复制

fun obfuscatedDescriptor(originalInternalDescriptor: String, mappingRemapper: FrameRemapper?,                         logPrinter: PrintWriter?, fixClassInfo: ProgramClassFixInfo? = null): String {    val startIndex = originalInternalDescriptor.indexOf(TypeConstants.CLASS_START)    val endIndex = originalInternalDescriptor.lastIndexOf(TypeConstants.CLASS_END)    if (startIndex < 0 || endIndex <= 0) {        return obfuscatedInternalClass(ClassUtil.externalClassName(originalInternalDescriptor), mappingRemapper, fixClassInfo)    }    try {        val newDescriptorBuffer = StringBuffer(originalInternalDescriptor.length)        val enumeration = DescriptorClassEnumeration(originalInternalDescriptor)        if (enumeration.classCount() < 2) {            return obfuscatedInnerDescriptor(originalInternalDescriptor, startIndex, endIndex, mappingRemapper, logPrinter, fixClassInfo)        }        newDescriptorBuffer.append(enumeration.nextFluff())        while (enumeration.hasMoreClassNames()) {            val internalClassName = enumeration.nextClassName()            val obfuscatedClassName = obfuscatedInternalClass(ClassUtil.externalClassName(internalClassName), mappingRemapper, fixClassInfo)            newDescriptorBuffer.append(obfuscatedClassName)            newDescriptorBuffer.append(enumeration.nextFluff())        }        return newDescriptorBuffer.toString()    } catch (ex: Exception) {        logPrinter?.println("process obfuscatedDescriptor error, originalDescriptor: $originalInternalDescriptor")        ex.printStackTrace()    }    return obfuscatedInnerDescriptor(originalInternalDescriptor, startIndex, endIndex, mappingRemapper, logPrinter, fixClassInfo)}

复制

...if (!methodInfo.isInlineInfo()) {      if (methodInfo.originalFirstLineNumber > 0) {          // Print out the line number range of the method,          // ignoring line numbers of any inlined methods.          pw.println("    " +                  methodInfo.originalFirstLineNumber + ":" +                  methodInfo.originalLastLineNumber + ":" +                  methodInfo.originalType + " " +                  methodInfo.originalName + JavaTypeConstants.METHOD_ARGUMENTS_OPEN +                  methodInfo.originalArguments + JavaTypeConstants.METHOD_ARGUMENTS_CLOSE +                  " -> " +                  obfuscatedMethodName);      } else {          // Print out the method mapping without line numbers.          pw.println("    " +                  methodInfo.originalType + " " +                  methodInfo.originalName + JavaTypeConstants.METHOD_ARGUMENTS_OPEN +                  methodInfo.originalArguments + JavaTypeConstants.METHOD_ARGUMENTS_CLOSE +                  " -> " +                  obfuscatedMethodName);      }  } else {    ...                        }

复制

...ExtensionUtil.isDir(outputFile.absolutePath) -> {          classNameSets?.forEach { name ->              val programClass = outputProgramPool.getClass(name) as MMClassNode              IncrementalDirProcessor(                  logPrinter,                  classLoader,                  ignoreCheckClass,                  outputProgramPool, programClass,                  processFlagsMarker,                  outputFile.toPath(),                  outputFile.toPath()              ).proceed()          }      } ...

复制