diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 000000000..4cb89c3fc --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,29 @@ +name: Build and publish + +on: + push: + branches: + - master + +permissions: + packages: write + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v2 + with: + fetch-depth: 0 + - name: Set up Java + uses: actions/setup-java@v2 + with: + java-version: 11 + cache: gradle + - name: Build and publish + run: ./gradlew publishAllPublicationsToGithubRepository + env: + PROGUARD_GITHUB_USERNAME: ${{ github.repository_owner }} + PROGUARD_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/base/build.gradle b/base/build.gradle index 1ecd2b754..6214a79fd 100644 --- a/base/build.gradle +++ b/base/build.gradle @@ -15,12 +15,8 @@ dependencies { api "org.jetbrains.kotlin:kotlin-stdlib-common:${kotlinVersion}" api "org.jetbrains.kotlin:kotlin-metadata-jvm:${kotlinVersion}" - implementation 'org.jetbrains:annotations:24.0.0' - implementation 'org.apache.logging.log4j:log4j-api:2.23.1' - implementation 'org.apache.logging.log4j:log4j-core:2.23.1' - testImplementation "org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}" testImplementation "org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}" testFixturesImplementation "org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}" @@ -137,7 +133,7 @@ publishing { repositories { maven { name = 'Github' - url = uri('https://maven.pkg.github.com/guardsquare/proguard-core') + url = uri('https://maven.pkg.github.com/run-slicer/proguard-core') credentials { username = project.findProperty('PROGUARD_GITHUB_USERNAME') password = project.findProperty('PROGUARD_GITHUB_TOKEN') diff --git a/base/src/main/java/proguard/analysis/CallResolver.java b/base/src/main/java/proguard/analysis/CallResolver.java index d40b6e3d8..55020894b 100644 --- a/base/src/main/java/proguard/analysis/CallResolver.java +++ b/base/src/main/java/proguard/analysis/CallResolver.java @@ -29,8 +29,6 @@ import java.util.function.Predicate; import java.util.function.Supplier; import java.util.stream.Collectors; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.Metrics.MetricType; import proguard.analysis.datastructure.CodeLocation; import proguard.analysis.datastructure.Location; @@ -76,6 +74,7 @@ import proguard.evaluation.value.TypedReferenceValue; import proguard.evaluation.value.Value; import proguard.evaluation.value.ValueFactory; +import proguard.util.Logger; import proguard.util.PartialEvaluatorUtils; /** @@ -103,7 +102,7 @@ */ public class CallResolver implements AttributeVisitor, ClassVisitor, InstructionVisitor { - private static final Logger log = LogManager.getLogger(CallResolver.class); + private static final Logger log = Logger.getLogger(CallResolver.class); /** Used to fill the {@link Call#controlFlowDependent} flag. */ private final DominatorCalculator dominatorCalculator; diff --git a/base/src/main/java/proguard/analysis/cpa/algorithms/CpaAlgorithm.java b/base/src/main/java/proguard/analysis/cpa/algorithms/CpaAlgorithm.java index 90c724852..04bc7e463 100644 --- a/base/src/main/java/proguard/analysis/cpa/algorithms/CpaAlgorithm.java +++ b/base/src/main/java/proguard/analysis/cpa/algorithms/CpaAlgorithm.java @@ -20,8 +20,6 @@ import java.util.LinkedHashSet; import java.util.Set; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.cpa.defaults.PrecisionAdjustmentResult; import proguard.analysis.cpa.interfaces.AbortOperator; import proguard.analysis.cpa.interfaces.AbstractState; @@ -34,6 +32,7 @@ import proguard.analysis.cpa.interfaces.StopOperator; import proguard.analysis.cpa.interfaces.TransferRelation; import proguard.analysis.cpa.interfaces.Waitlist; +import proguard.util.Logger; /** * This is the implements BamCache { - private static final Logger log = LogManager.getLogger(BamCacheImpl.class); + private static final Logger log = Logger.getLogger(BamCacheImpl.class); private final Map> cache = new HashMap<>(); private int size = 0; diff --git a/base/src/main/java/proguard/analysis/cpa/bam/BamTransferRelation.java b/base/src/main/java/proguard/analysis/cpa/bam/BamTransferRelation.java index 3da78b72e..12d13afd7 100644 --- a/base/src/main/java/proguard/analysis/cpa/bam/BamTransferRelation.java +++ b/base/src/main/java/proguard/analysis/cpa/bam/BamTransferRelation.java @@ -26,8 +26,6 @@ import java.util.Set; import java.util.Stack; import java.util.stream.Collectors; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.cpa.algorithms.CpaAlgorithm; import proguard.analysis.cpa.defaults.BreadthFirstWaitlist; import proguard.analysis.cpa.defaults.Cfa; @@ -49,6 +47,7 @@ import proguard.analysis.datastructure.callgraph.Call; import proguard.analysis.datastructure.callgraph.SymbolicCall; import proguard.classfile.Signature; +import proguard.util.Logger; /** * This {@link TransferRelation} extends an analysis inter-procedurally. The transfer relation @@ -67,7 +66,7 @@ public class BamTransferRelation< SignatureT extends Signature> implements TransferRelation { - private static final Logger log = LogManager.getLogger(BamTransferRelation.class); + private static final Logger log = Logger.getLogger(BamTransferRelation.class); private final CpaWithBamOperators wrappedCpa; // TODO: maybe we don't need the cfa private final Cfa cfa; diff --git a/base/src/main/java/proguard/analysis/cpa/jvm/cfa/visitors/JvmIntraproceduralCfaFillerAllInstructionVisitor.java b/base/src/main/java/proguard/analysis/cpa/jvm/cfa/visitors/JvmIntraproceduralCfaFillerAllInstructionVisitor.java index ac37ee651..68f3440ba 100644 --- a/base/src/main/java/proguard/analysis/cpa/jvm/cfa/visitors/JvmIntraproceduralCfaFillerAllInstructionVisitor.java +++ b/base/src/main/java/proguard/analysis/cpa/jvm/cfa/visitors/JvmIntraproceduralCfaFillerAllInstructionVisitor.java @@ -23,8 +23,6 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.cpa.jvm.cfa.JvmCfa; import proguard.analysis.cpa.jvm.cfa.edges.JvmAssumeCaseCfaEdge; import proguard.analysis.cpa.jvm.cfa.edges.JvmAssumeCfaEdge; @@ -51,6 +49,7 @@ import proguard.classfile.instruction.TableSwitchInstruction; import proguard.classfile.instruction.VariableInstruction; import proguard.classfile.instruction.visitor.InstructionVisitor; +import proguard.util.Logger; /** * This {@link AttributeVisitor} visits the {@link CodeAttribute} of a {@link Method} and performs @@ -79,7 +78,7 @@ public class JvmIntraproceduralCfaFillerAllInstructionVisitor implements Attribu private final JvmCfa cfa; private static final Logger log = - LogManager.getLogger(JvmIntraproceduralCfaFillerAllInstructionVisitor.class); + Logger.getLogger(JvmIntraproceduralCfaFillerAllInstructionVisitor.class); public JvmIntraproceduralCfaFillerAllInstructionVisitor(JvmCfa cfa) { this.cfa = cfa; diff --git a/base/src/main/java/proguard/analysis/cpa/jvm/domain/memory/JvmMemoryLocationTransferRelation.java b/base/src/main/java/proguard/analysis/cpa/jvm/domain/memory/JvmMemoryLocationTransferRelation.java index 1b4530b3d..e9edba0c9 100644 --- a/base/src/main/java/proguard/analysis/cpa/jvm/domain/memory/JvmMemoryLocationTransferRelation.java +++ b/base/src/main/java/proguard/analysis/cpa/jvm/domain/memory/JvmMemoryLocationTransferRelation.java @@ -26,8 +26,6 @@ import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.cpa.bam.BamCache; import proguard.analysis.cpa.bam.BamCpa; import proguard.analysis.cpa.bam.BlockAbstraction; @@ -74,6 +72,7 @@ import proguard.classfile.instruction.VariableInstruction; import proguard.classfile.instruction.visitor.InstructionVisitor; import proguard.classfile.util.ClassUtil; +import proguard.util.Logger; /** * The {@link JvmMemoryLocationTransferRelation} computes the backward successors of an {@link @@ -119,7 +118,7 @@ public class JvmMemoryLocationTransferRelation< AbstractStateT extends LatticeAbstractState> implements TransferRelation { - private static final Logger log = LogManager.getLogger(JvmMemoryLocationTransferRelation.class); + private static final Logger log = Logger.getLogger(JvmMemoryLocationTransferRelation.class); private final AbstractStateT threshold; private final JvmCfa cfa; private final BamCache cache; diff --git a/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/JvmValueAbstractState.java b/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/JvmValueAbstractState.java index 55135b8d4..e8071b3e0 100644 --- a/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/JvmValueAbstractState.java +++ b/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/JvmValueAbstractState.java @@ -22,8 +22,6 @@ import static proguard.classfile.util.ClassUtil.internalTypeFromClassName; import static proguard.classfile.util.ClassUtil.isExtendable; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.cpa.defaults.MapAbstractState; import proguard.analysis.cpa.jvm.cfa.nodes.JvmCfaNode; import proguard.analysis.cpa.jvm.state.JvmAbstractState; @@ -37,10 +35,11 @@ import proguard.evaluation.value.Value; import proguard.evaluation.value.ValueFactory; import proguard.evaluation.value.object.AnalyzedObjectFactory; +import proguard.util.Logger; /** */ public class JvmValueAbstractState extends JvmAbstractState { - private static final Logger logger = LogManager.getLogger(JvmValueAbstractState.class); + private static final Logger logger = Logger.getLogger(JvmValueAbstractState.class); private final ValueFactory valueFactory; diff --git a/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/ValueAbstractState.java b/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/ValueAbstractState.java index ada84e8c4..cbb3941c0 100644 --- a/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/ValueAbstractState.java +++ b/base/src/main/java/proguard/analysis/cpa/jvm/domain/value/ValueAbstractState.java @@ -24,13 +24,12 @@ import static proguard.evaluation.value.BasicValueFactory.UNKNOWN_VALUE; import java.util.Objects; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.cpa.defaults.LatticeAbstractState; import proguard.analysis.cpa.interfaces.AbstractState; import proguard.evaluation.value.IdentifiedReferenceValue; import proguard.evaluation.value.TypedReferenceValue; import proguard.evaluation.value.Value; +import proguard.util.Logger; /** * An {@link AbstractState} for tracking JVM values. @@ -39,7 +38,7 @@ */ public class ValueAbstractState implements LatticeAbstractState { - private static final Logger logger = LogManager.getLogger(ValueAbstractState.class); + private static final Logger logger = Logger.getLogger(ValueAbstractState.class); public static final ValueAbstractState UNKNOWN = new ValueAbstractState(UNKNOWN_VALUE); private Value value; diff --git a/base/src/main/java/proguard/analysis/cpa/jvm/state/heap/tree/JvmShallowHeapAbstractState.java b/base/src/main/java/proguard/analysis/cpa/jvm/state/heap/tree/JvmShallowHeapAbstractState.java index 0da189b2e..cd0cb7bed 100644 --- a/base/src/main/java/proguard/analysis/cpa/jvm/state/heap/tree/JvmShallowHeapAbstractState.java +++ b/base/src/main/java/proguard/analysis/cpa/jvm/state/heap/tree/JvmShallowHeapAbstractState.java @@ -21,12 +21,11 @@ import java.util.List; import java.util.Objects; import java.util.Set; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.cpa.defaults.LatticeAbstractState; import proguard.analysis.cpa.defaults.MapAbstractState; import proguard.analysis.cpa.jvm.cfa.nodes.JvmCfaNode; import proguard.analysis.cpa.jvm.state.heap.JvmHeapAbstractState; +import proguard.util.Logger; /** * A shallow heap models objects as atomic abstract states thus having only one level of depth. @@ -36,7 +35,7 @@ */ public class JvmShallowHeapAbstractState> implements JvmHeapAbstractState { - private static final Logger logger = LogManager.getLogger(JvmShallowHeapAbstractState.class); + private static final Logger logger = Logger.getLogger(JvmShallowHeapAbstractState.class); public final MapAbstractState referenceToObject; protected final Class referenceClass; diff --git a/base/src/main/java/proguard/analysis/datastructure/callgraph/Call.java b/base/src/main/java/proguard/analysis/datastructure/callgraph/Call.java index 657b3db2c..28a5ae47c 100644 --- a/base/src/main/java/proguard/analysis/datastructure/callgraph/Call.java +++ b/base/src/main/java/proguard/analysis/datastructure/callgraph/Call.java @@ -21,8 +21,6 @@ import java.util.Collections; import java.util.List; import java.util.Objects; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.CallResolver; import proguard.analysis.CallVisitor; import proguard.analysis.datastructure.CodeLocation; @@ -34,6 +32,7 @@ import proguard.classfile.visitor.MemberVisitor; import proguard.evaluation.value.IdentifiedReferenceValue; import proguard.evaluation.value.Value; +import proguard.util.Logger; /** * Represents a method call. If the call target is a {@link Method} that is present in the class @@ -44,7 +43,7 @@ */ public abstract class Call { - private static final Logger log = LogManager.getLogger(Call.class); + private static final Logger log = Logger.getLogger(Call.class); /** The location where the call was invoked. */ public final CodeLocation caller; /** diff --git a/base/src/main/java/proguard/analysis/datastructure/callgraph/CallGraph.java b/base/src/main/java/proguard/analysis/datastructure/callgraph/CallGraph.java index 308b5cc3c..98e860a0e 100644 --- a/base/src/main/java/proguard/analysis/datastructure/callgraph/CallGraph.java +++ b/base/src/main/java/proguard/analysis/datastructure/callgraph/CallGraph.java @@ -22,12 +22,11 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.function.Predicate; import java.util.stream.Collectors; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.ClassPool; import proguard.classfile.Clazz; import proguard.classfile.MethodSignature; import proguard.util.CallGraphWalker; +import proguard.util.Logger; /** * Collection of all {@link Call}s in a program, optimized for retrieval of incoming and outgoing @@ -37,7 +36,7 @@ */ public class CallGraph { - private static final transient Logger log = LogManager.getLogger(CallGraph.class); + private static final transient Logger log = Logger.getLogger(CallGraph.class); public final Map> incoming; public final Map> outgoing; diff --git a/base/src/main/java/proguard/classfile/attribute/visitor/MaxStackSizeComputer.java b/base/src/main/java/proguard/classfile/attribute/visitor/MaxStackSizeComputer.java index 7bc3a1455..40cbdd932 100644 --- a/base/src/main/java/proguard/classfile/attribute/visitor/MaxStackSizeComputer.java +++ b/base/src/main/java/proguard/classfile/attribute/visitor/MaxStackSizeComputer.java @@ -17,8 +17,6 @@ */ package proguard.classfile.attribute.visitor; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.Clazz; import proguard.classfile.Method; import proguard.classfile.attribute.Attribute; @@ -40,6 +38,7 @@ import proguard.exception.ProguardCoreException; import proguard.util.ArrayUtil; import proguard.util.CircularIntBuffer; +import proguard.util.Logger; /** * This {@link AttributeVisitor} computes the maximum stack size of the code attributes that it @@ -58,7 +57,7 @@ public class MaxStackSizeComputer private static boolean DEBUG = System.getProperty("ssc") != null; //*/ - private static final Logger logger = LogManager.getLogger(MaxStackSizeComputer.class); + private static final Logger logger = Logger.getLogger(MaxStackSizeComputer.class); private final StackSizeConsumer stackSizeConsumer; protected boolean[] evaluated = new boolean[ClassEstimates.TYPICAL_CODE_LENGTH]; diff --git a/base/src/main/java/proguard/classfile/editor/ClassReferenceFixer.java b/base/src/main/java/proguard/classfile/editor/ClassReferenceFixer.java index 9328f141d..3f15055e6 100644 --- a/base/src/main/java/proguard/classfile/editor/ClassReferenceFixer.java +++ b/base/src/main/java/proguard/classfile/editor/ClassReferenceFixer.java @@ -23,8 +23,6 @@ import static proguard.classfile.kotlin.KotlinConstants.TYPE_KOTLIN_JVM_JVMNAME; import static proguard.classfile.util.ClassUtil.internalSimpleClassName; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.ClassConstants; import proguard.classfile.Clazz; import proguard.classfile.Field; @@ -113,6 +111,7 @@ import proguard.classfile.visitor.MemberVisitor; import proguard.exception.ErrorId; import proguard.exception.ProguardCoreException; +import proguard.util.Logger; /** * This {@link ClassVisitor} fixes references of constant pool entries, fields, methods, attributes @@ -135,7 +134,7 @@ public class ClassReferenceFixer LocalVariableTypeInfoVisitor, AnnotationVisitor, ElementValueVisitor { - private static final Logger logger = LogManager.getLogger(ClassReferenceFixer.class); + private static final Logger logger = Logger.getLogger(ClassReferenceFixer.class); private NameGenerationStrategy newNameStrategy; diff --git a/base/src/main/java/proguard/classfile/editor/CodeAttributeEditor.java b/base/src/main/java/proguard/classfile/editor/CodeAttributeEditor.java index f7d205205..ec89c000b 100644 --- a/base/src/main/java/proguard/classfile/editor/CodeAttributeEditor.java +++ b/base/src/main/java/proguard/classfile/editor/CodeAttributeEditor.java @@ -22,8 +22,6 @@ import java.util.HashMap; import java.util.Map; import java.util.Objects; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.Clazz; import proguard.classfile.Method; import proguard.classfile.ProgramClass; @@ -74,6 +72,7 @@ import proguard.exception.ErrorId; import proguard.exception.ProguardCoreException; import proguard.util.ArrayUtil; +import proguard.util.Logger; /** * This {@link AttributeVisitor} accumulates specified changes to code, and then applies these @@ -149,7 +148,7 @@ public class CodeAttributeEditor private static final int LABEL_FLAG = 0x20000000; - private static final Logger logger = LogManager.getLogger(CodeAttributeEditor.class); + private static final Logger logger = Logger.getLogger(CodeAttributeEditor.class); private final boolean updateFrameSizes; private final boolean shrinkInstructions; diff --git a/base/src/main/java/proguard/classfile/util/WarningLogger.java b/base/src/main/java/proguard/classfile/util/WarningLogger.java index 1bed03edc..b36d1b89a 100644 --- a/base/src/main/java/proguard/classfile/util/WarningLogger.java +++ b/base/src/main/java/proguard/classfile/util/WarningLogger.java @@ -18,7 +18,7 @@ package proguard.classfile.util; import java.util.List; -import org.apache.logging.log4j.Logger; +import proguard.util.Logger; public class WarningLogger extends WarningPrinter { diff --git a/base/src/main/java/proguard/evaluation/ExecutingInvocationUnit.java b/base/src/main/java/proguard/evaluation/ExecutingInvocationUnit.java index 00789f27f..f3fe2d4b9 100644 --- a/base/src/main/java/proguard/evaluation/ExecutingInvocationUnit.java +++ b/base/src/main/java/proguard/evaluation/ExecutingInvocationUnit.java @@ -39,8 +39,6 @@ import java.util.List; import java.util.Objects; import java.util.Optional; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import proguard.analysis.datastructure.CodeLocation; @@ -76,6 +74,7 @@ import proguard.evaluation.value.object.AnalyzedObject; import proguard.evaluation.value.object.AnalyzedObjectFactory; import proguard.evaluation.value.object.Model; +import proguard.util.Logger; import proguard.util.PartialEvaluatorUtils; /** @@ -101,7 +100,7 @@ * StringReflectionExecutor} and adding other {@link Executor}s. */ public class ExecutingInvocationUnit extends BasicInvocationUnit { - private static final Logger log = LogManager.getLogger(ExecutingInvocationUnit.class); + private static final Logger log = Logger.getLogger(ExecutingInvocationUnit.class); @Nullable private Value[] parameters; private final boolean enableSameInstanceIdApproximation; diff --git a/base/src/main/java/proguard/evaluation/ExecutorLookup.java b/base/src/main/java/proguard/evaluation/ExecutorLookup.java index 44bef41fc..2d83833ea 100644 --- a/base/src/main/java/proguard/evaluation/ExecutorLookup.java +++ b/base/src/main/java/proguard/evaluation/ExecutorLookup.java @@ -5,8 +5,6 @@ import java.util.List; import java.util.Map; import java.util.Set; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import proguard.classfile.Clazz; @@ -15,6 +13,7 @@ import proguard.evaluation.executor.Executor; import proguard.evaluation.executor.MethodExecutionInfo; import proguard.evaluation.value.TypedReferenceValue; +import proguard.util.Logger; /** * Class for performing lookups of registered executors based on method signatures. @@ -28,7 +27,7 @@ */ final class ExecutorLookup { - private static final Logger log = LogManager.getLogger(ExecutorLookup.class); + private static final Logger log = Logger.getLogger(ExecutorLookup.class); private final Map executorFromSignature = new HashMap<>(); private final Set supportedClasses = new HashSet<>(); diff --git a/base/src/main/java/proguard/evaluation/PartialEvaluator.java b/base/src/main/java/proguard/evaluation/PartialEvaluator.java index acd74d780..577340bb7 100644 --- a/base/src/main/java/proguard/evaluation/PartialEvaluator.java +++ b/base/src/main/java/proguard/evaluation/PartialEvaluator.java @@ -18,8 +18,6 @@ package proguard.evaluation; import java.util.Arrays; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.Clazz; import proguard.classfile.Method; import proguard.classfile.attribute.Attribute; @@ -53,6 +51,7 @@ import proguard.exception.InstructionExceptionFormatter; import proguard.exception.ProguardCoreException; import proguard.util.CircularIntBuffer; +import proguard.util.Logger; /** * This {@link AttributeVisitor} performs partial evaluation on the code attributes that it visits. @@ -72,7 +71,7 @@ public class PartialEvaluator implements AttributeVisitor, ExceptionInfoVisitor public static boolean ENABLE_NEW_EXCEPTIONS = System.getProperty("proguard.pe.newexceptions") != null; - private static final Logger logger = LogManager.getLogger(PartialEvaluator.class); + private static final Logger logger = Logger.getLogger(PartialEvaluator.class); // The analysis will generalize stack/vars after visiting an instruction this many times. private static final int GENERALIZE_AFTER_N_EVALUATIONS = 5; diff --git a/base/src/main/java/proguard/evaluation/executor/StringReflectionExecutor.java b/base/src/main/java/proguard/evaluation/executor/StringReflectionExecutor.java index 335c6a766..c57d844b8 100644 --- a/base/src/main/java/proguard/evaluation/executor/StringReflectionExecutor.java +++ b/base/src/main/java/proguard/evaluation/executor/StringReflectionExecutor.java @@ -31,8 +31,6 @@ import java.util.Map; import java.util.Optional; import java.util.Set; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.ClassPool; import proguard.classfile.Clazz; import proguard.classfile.MethodSignature; @@ -46,6 +44,7 @@ import proguard.evaluation.value.object.AnalyzedObjectFactory; import proguard.util.ConstantMatcher; import proguard.util.FixedStringMatcher; +import proguard.util.Logger; import proguard.util.StringMatcher; /** @@ -54,7 +53,7 @@ */ public class StringReflectionExecutor extends ReflectionExecutor { - private static final Logger log = LogManager.getLogger(StringReflectionExecutor.class); + private static final Logger log = Logger.getLogger(StringReflectionExecutor.class); private final ClassPool libraryClassPool; diff --git a/base/src/main/java/proguard/evaluation/value/ReferenceValue.java b/base/src/main/java/proguard/evaluation/value/ReferenceValue.java index 2b88c8b35..a64ad5adf 100644 --- a/base/src/main/java/proguard/evaluation/value/ReferenceValue.java +++ b/base/src/main/java/proguard/evaluation/value/ReferenceValue.java @@ -17,16 +17,15 @@ */ package proguard.evaluation.value; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import org.jetbrains.annotations.NotNull; import proguard.classfile.Clazz; import proguard.evaluation.value.object.AnalyzedObject; import proguard.evaluation.value.object.AnalyzedObjectFactory; +import proguard.util.Logger; /** Representation of a partially evaluated reference value. */ public abstract class ReferenceValue extends Category1Value { - private static final Logger log = LogManager.getLogger(ReferenceValue.class); + private static final Logger log = Logger.getLogger(ReferenceValue.class); private static final boolean PRINT_ERRORS = System.getProperty("proguard.value.logerrors") != null; // Basic unary methods. diff --git a/base/src/main/java/proguard/exception/InstructionExceptionFormatter.java b/base/src/main/java/proguard/exception/InstructionExceptionFormatter.java index 813caf4c8..591b8dbf4 100644 --- a/base/src/main/java/proguard/exception/InstructionExceptionFormatter.java +++ b/base/src/main/java/proguard/exception/InstructionExceptionFormatter.java @@ -18,7 +18,6 @@ package proguard.exception; -import org.apache.logging.log4j.Logger; import proguard.classfile.Clazz; import proguard.classfile.Method; import proguard.classfile.instruction.Instruction; @@ -26,6 +25,7 @@ import proguard.evaluation.TracedStack; import proguard.evaluation.TracedVariables; import proguard.util.CircularIntBuffer; +import proguard.util.Logger; /** * This class is used to format an exception with the previous instructions. It is used by the diff --git a/base/src/main/java/proguard/io/DataEntryCopier.java b/base/src/main/java/proguard/io/DataEntryCopier.java index c16412a94..189077079 100644 --- a/base/src/main/java/proguard/io/DataEntryCopier.java +++ b/base/src/main/java/proguard/io/DataEntryCopier.java @@ -18,9 +18,8 @@ package proguard.io; import java.io.*; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.util.ExtensionMatcher; +import proguard.util.Logger; /** * This {@link DataEntryReader} writes the ZIP entries and files that it reads to a given {@link @@ -33,7 +32,7 @@ public class DataEntryCopier implements DataEntryReader { private static final int BUFFER_SIZE = 1024; - private static final Logger logger = LogManager.getLogger(DataEntryCopier.class); + private static final Logger logger = Logger.getLogger(DataEntryCopier.class); private final DataEntryWriter dataEntryWriter; private final byte[] buffer = new byte[BUFFER_SIZE]; diff --git a/base/src/main/java/proguard/preverify/CodePreverifier.java b/base/src/main/java/proguard/preverify/CodePreverifier.java index 47bcede9d..c5ed66b75 100644 --- a/base/src/main/java/proguard/preverify/CodePreverifier.java +++ b/base/src/main/java/proguard/preverify/CodePreverifier.java @@ -18,8 +18,6 @@ package proguard.preverify; import java.util.*; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.*; import proguard.classfile.attribute.*; import proguard.classfile.attribute.preverification.*; @@ -31,6 +29,7 @@ import proguard.evaluation.value.*; import proguard.exception.ErrorId; import proguard.exception.ProguardCoreException; +import proguard.util.Logger; /** * This {@link AttributeVisitor} adds preverification information (for Java Micro Edition or for @@ -45,7 +44,7 @@ public class CodePreverifier implements AttributeVisitor { private static boolean DEBUG = System.getProperty("cp") != null; //*/ - private static final Logger logger = LogManager.getLogger(CodePreverifier.class); + private static final Logger logger = Logger.getLogger(CodePreverifier.class); private static final int AT_METHOD_ENTRY = -1; diff --git a/base/src/main/java/proguard/preverify/CodeSubroutineInliner.java b/base/src/main/java/proguard/preverify/CodeSubroutineInliner.java index d838124e9..f5ded045b 100644 --- a/base/src/main/java/proguard/preverify/CodeSubroutineInliner.java +++ b/base/src/main/java/proguard/preverify/CodeSubroutineInliner.java @@ -17,8 +17,6 @@ */ package proguard.preverify; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.classfile.*; import proguard.classfile.attribute.*; import proguard.classfile.attribute.visitor.*; @@ -29,6 +27,7 @@ import proguard.classfile.visitor.*; import proguard.exception.ErrorId; import proguard.exception.ProguardCoreException; +import proguard.util.Logger; /** * This AttributeVisitor inlines local subroutines (jsr/ret) in the code attributes that it visits. @@ -43,7 +42,7 @@ public class CodeSubroutineInliner private static boolean DEBUG = System.getProperty("csi") != null; //*/ - private static final Logger logger = LogManager.getLogger(CodeSubroutineInliner.class); + private static final Logger logger = Logger.getLogger(CodeSubroutineInliner.class); private final BranchTargetFinder branchTargetFinder = new BranchTargetFinder(); private final CodeAttributeComposer codeAttributeComposer = diff --git a/base/src/main/java/proguard/util/CallGraphWalker.java b/base/src/main/java/proguard/util/CallGraphWalker.java index 00990f41d..de3ec76e4 100644 --- a/base/src/main/java/proguard/util/CallGraphWalker.java +++ b/base/src/main/java/proguard/util/CallGraphWalker.java @@ -25,8 +25,6 @@ import java.util.Set; import java.util.function.BiFunction; import java.util.function.Predicate; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import proguard.analysis.Metrics; import proguard.analysis.Metrics.MetricType; import proguard.analysis.datastructure.callgraph.Call; @@ -41,7 +39,7 @@ */ public class CallGraphWalker { - private static final Logger log = LogManager.getLogger(CallGraphWalker.class); + private static final Logger log = Logger.getLogger(CallGraphWalker.class); /** Call graph strands are no longer explored after a maximum distance from the original root. */ public static final int MAX_DEPTH_DEFAULT = 100; /** diff --git a/base/src/main/java/proguard/util/Logger.java b/base/src/main/java/proguard/util/Logger.java new file mode 100644 index 000000000..b5dbf6303 --- /dev/null +++ b/base/src/main/java/proguard/util/Logger.java @@ -0,0 +1,142 @@ +package proguard.util; + +import java.util.Objects; +import org.jetbrains.annotations.NotNull; + +/** + * A basic logger wrapper. + * + * @author Matouš Kučera + */ +public abstract class Logger { + private static Factory FACTORY = + ignored -> + new Logger() { + @Override + public void log(@NotNull Level level, Object msg, Object... args) { + // no-op + } + }; + + /** + * Logs a message with the {@link Level#TRACE} level. + * + * @param msg the message + * @param args the formatting arguments + */ + public void trace(Object msg, Object... args) { + this.log(Level.TRACE, msg, args); + } + + /** + * Logs a message with the {@link Level#DEBUG} level. + * + * @param msg the message + * @param args the formatting arguments + */ + public void debug(Object msg, Object... args) { + this.log(Level.DEBUG, msg, args); + } + + /** + * Logs a message with the {@link Level#INFO} level. + * + * @param msg the message + * @param args the formatting arguments + */ + public void info(Object msg, Object... args) { + this.log(Level.INFO, msg, args); + } + + /** + * Logs a message with the {@link Level#WARN} level. + * + * @param msg the message + * @param args the formatting arguments + */ + public void warn(Object msg, Object... args) { + this.log(Level.WARN, msg, args); + } + + /** + * Logs a message with the {@link Level#ERROR} level. + * + * @param msg the message + * @param args the formatting arguments + */ + public void error(Object msg, Object... args) { + this.log(Level.ERROR, msg, args); + } + + /** + * Logs a message with an arbitrary level. + * + * @param level the log level + * @param msg the message + * @param args the formatting arguments + */ + public abstract void log(@NotNull Level level, Object msg, Object... args); + + // static factories + + /** + * Creates a new named logger. + * + * @param name the logger name + * @return the logger + */ + public static @NotNull Logger getLogger(@NotNull String name) { + return FACTORY.create(Objects.requireNonNull(name, "name")); + } + + /** + * Creates a new named logger for a specific class. + * + * @param clazz the class + * @return the logger + */ + public static @NotNull Logger getLogger(@NotNull Class clazz) { + return FACTORY.create(Objects.requireNonNull(clazz, "clazz")); + } + + /** + * Sets a new {@link Factory}. + * + * @param factory the factory + */ + public static void setFactory(@NotNull Factory factory) { + FACTORY = Objects.requireNonNull(factory, "factory"); + } + + /** Log levels. */ + public enum Level { + TRACE, + DEBUG, + INFO, + WARN, + ERROR + } + + /** A logger factory. */ + @FunctionalInterface + public interface Factory { + /** + * Creates a new named logger. + * + * @param name the logger name + * @return the logger + */ + @NotNull + Logger create(@NotNull String name); + + /** + * Creates a new named logger for a specific class. + * + * @param clazz the class + * @return the logger + */ + default @NotNull Logger create(@NotNull Class clazz) { + return this.create(clazz.getName()); + } + } +} diff --git a/base/src/main/resources/log4j2.xml b/base/src/main/resources/log4j2.xml deleted file mode 100644 index 57e31010e..000000000 --- a/base/src/main/resources/log4j2.xml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - diff --git a/base/src/test/kotlin/proguard/LoggingTest.kt b/base/src/test/kotlin/proguard/LoggingTest.kt deleted file mode 100644 index e9b2f1393..000000000 --- a/base/src/test/kotlin/proguard/LoggingTest.kt +++ /dev/null @@ -1,48 +0,0 @@ -/* - * ProGuardCORE -- library to process Java bytecode. - * - * Copyright (c) 2002-2021 Guardsquare NV - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package proguard - -import io.kotest.core.spec.style.FreeSpec -import io.kotest.matchers.string.shouldContain -import org.apache.logging.log4j.core.LoggerContext -import org.apache.logging.log4j.core.appender.OutputStreamAppender -import java.io.ByteArrayOutputStream - -class LoggingTest : FreeSpec({ - - "Given a default logger" - { - // Add an appender writing to an OutputStream we can capture instead of stdout. - val loggerOutput = ByteArrayOutputStream() - val context = LoggerContext.getContext(false) - val config = context.configuration - // Grab the same config as the current appender. - val layout = config.rootLogger.appenders.values.first().layout - val appender = OutputStreamAppender.createAppender(layout, null, loggerOutput, "TestLogger", false, true) - appender.start() - config.addAppender(appender) - config.rootLogger.addAppender(appender, null, null) - - val testLogger = context.getLogger("TestLogger") - "When logging a warning" - { - testLogger.warn("Hello World") - val output = loggerOutput.toString() - "Then the log should contain the message" { output shouldContain "Hello World" } - } - } -}) diff --git a/base/src/test/kotlin/proguard/analysis/CallResolverExcessiveComplexityTest.kt b/base/src/test/kotlin/proguard/analysis/CallResolverExcessiveComplexityTest.kt index b896c77db..fabd1bbf7 100644 --- a/base/src/test/kotlin/proguard/analysis/CallResolverExcessiveComplexityTest.kt +++ b/base/src/test/kotlin/proguard/analysis/CallResolverExcessiveComplexityTest.kt @@ -20,13 +20,10 @@ package proguard.analysis import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.ints.shouldBeGreaterThan -import io.kotest.matchers.string.shouldNotContain import proguard.analysis.Metrics.MetricType.PARTIAL_EVALUATOR_EXCESSIVE_COMPLEXITY import proguard.analysis.datastructure.callgraph.CallGraph -import proguard.evaluation.exception.ExcessiveComplexityException import proguard.testutils.AssemblerSource import proguard.testutils.ClassPoolBuilder -import proguard.util.withTestLogger class CallResolverExcessiveComplexityTest : FunSpec({ test("Check that an excessively complex method does not print anything to the log") { @@ -70,10 +67,10 @@ class CallResolverExcessiveComplexityTest : FunSpec({ .setMaxPartialEvaluations(50) .build() - withTestLogger { outputStream -> - programClassPool.classesAccept(resolver) - (Metrics.counts[PARTIAL_EVALUATOR_EXCESSIVE_COMPLEXITY] ?: 0) shouldBeGreaterThan 0 - outputStream.toString() shouldNotContain ExcessiveComplexityException::class.java.name - } + // withTestLogger { outputStream -> + programClassPool.classesAccept(resolver) + (Metrics.counts[PARTIAL_EVALUATOR_EXCESSIVE_COMPLEXITY] ?: 0) shouldBeGreaterThan 0 + // outputStream.toString() shouldNotContain ExcessiveComplexityException::class.java.name + // } } }) diff --git a/base/src/test/kotlin/proguard/util/LoggerUtil.kt b/base/src/test/kotlin/proguard/util/LoggerUtil.kt deleted file mode 100644 index 994b7b613..000000000 --- a/base/src/test/kotlin/proguard/util/LoggerUtil.kt +++ /dev/null @@ -1,24 +0,0 @@ -package proguard.util - -import org.apache.logging.log4j.core.LoggerContext -import org.apache.logging.log4j.core.appender.OutputStreamAppender -import java.io.ByteArrayOutputStream -import java.io.OutputStream - -fun withTestLogger(block: (OutputStream) -> Unit) { - val context = LoggerContext.getContext(false) - val config = context.configuration - val loggerName = java.util.UUID.randomUUID().toString() - try { - val loggerOutput = ByteArrayOutputStream() - // Grab the same config as the current appender. - val layout = config.rootLogger.appenders.values.first().layout - val appender = OutputStreamAppender.createAppender(layout, null, loggerOutput, loggerName, false, true) - appender.start() - config.addAppender(appender) - config.rootLogger.addAppender(appender, null, null) - block(loggerOutput) - } finally { - config.removeLogger(loggerName) - } -} diff --git a/base/src/test/kotlin/proguard/util/kotlin/asserter/KotlinMetadataAsserterTest.kt b/base/src/test/kotlin/proguard/util/kotlin/asserter/KotlinMetadataAsserterTest.kt index f64c4e28d..32fd3c5a7 100644 --- a/base/src/test/kotlin/proguard/util/kotlin/asserter/KotlinMetadataAsserterTest.kt +++ b/base/src/test/kotlin/proguard/util/kotlin/asserter/KotlinMetadataAsserterTest.kt @@ -5,7 +5,6 @@ import io.kotest.matchers.shouldBe import io.kotest.matchers.shouldNotBe import io.mockk.spyk import io.mockk.verify -import org.apache.logging.log4j.LogManager import proguard.classfile.Clazz import proguard.classfile.ProgramClass import proguard.classfile.kotlin.KotlinClassKindMetadata @@ -19,9 +18,10 @@ import proguard.classfile.util.kotlin.KotlinMetadataInitializer import proguard.resources.file.ResourceFilePool import proguard.testutils.ClassPoolBuilder import proguard.testutils.KotlinSource +import proguard.util.Logger class KotlinMetadataAsserterTest : BehaviorSpec({ - val warningLogger = WarningLogger(LogManager.getLogger(KotlinMetadataAsserter::class.java)) + val warningLogger = WarningLogger(Logger.getLogger(KotlinMetadataAsserter::class.java)) Given("an interface with default implementation") { val (programClassPool, libraryClassPool) = ClassPoolBuilder.fromSource( KotlinSource( diff --git a/gradle.properties b/gradle.properties index e80026bdd..feac7be54 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,6 +1,6 @@ # Gradle build properties for ProGuard. -proguardCoreVersion = 9.1.6 +proguardCoreVersion = 9.1.6-SNAPSHOT kotlinVersion = 2.0.0 diff --git a/tools/build.gradle b/tools/build.gradle index 7469fc058..68c087873 100644 --- a/tools/build.gradle +++ b/tools/build.gradle @@ -59,7 +59,7 @@ publishing { repositories { maven { name = 'Github' - url = uri('https://maven.pkg.github.com/guardsquare/proguard-core') + url = uri('https://maven.pkg.github.com/run-slicer/proguard-core') credentials { username = project.findProperty('PROGUARD_GITHUB_USERNAME') password = project.findProperty('PROGUARD_GITHUB_TOKEN')