This is an automated email from the git hooks/post-receive script. ebourg-guest pushed a commit to branch master in repository lombok-ast.
commit 4b6bfcd13fe6017ed7577fe3958d4f28334a72c3 Author: Emmanuel Bourg <[email protected]> Date: Fri Sep 29 17:14:38 2017 +0200 Build with libasm-java (>= 5.0) instead of libasm3-java/libasm4-java --- debian/changelog | 7 + debian/control | 3 +- debian/patches/asm-compatibility.patch | 311 +++++++++++++++++++++++++++++++++ debian/patches/series | 1 + 4 files changed, 320 insertions(+), 2 deletions(-) diff --git a/debian/changelog b/debian/changelog index e702368..a742cbd 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,10 @@ +lombok-ast (0.2+ds-3) UNRELEASED; urgency=medium + + * Team upload. + * Build with libasm-java (>= 5.0) instead of libasm3-java/libasm4-java + + -- Emmanuel Bourg <[email protected]> Fri, 29 Sep 2017 09:31:04 +0200 + lombok-ast (0.2+ds-2) unstable; urgency=medium * Drop liblombok-ast-java.jlibs and use maven-repo-helper to install diff --git a/debian/control b/debian/control index eced85f..96a67db 100644 --- a/debian/control +++ b/debian/control @@ -12,8 +12,7 @@ Build-Depends: default-jdk, ivyplusplus, javahelper, - libasm4-java, - libasm3-java, + libasm-java (>= 5.0), libintellij-annotations-java, libecj-java, libguava-java, diff --git a/debian/patches/asm-compatibility.patch b/debian/patches/asm-compatibility.patch new file mode 100644 index 0000000..0ba9d9e --- /dev/null +++ b/debian/patches/asm-compatibility.patch @@ -0,0 +1,311 @@ +Description: Build with the latest version of ASM in Debian. + The changes were imported from the parboiled package. +Author: Emmanuel Bourg <[email protected]> +Forwarded: no +--- a/src/main/org/parboiled/transform/InstructionGroupPreparer.java ++++ b/src/main/org/parboiled/transform/InstructionGroupPreparer.java +@@ -21,7 +21,7 @@ + import org.objectweb.asm.Label; + import org.objectweb.asm.Opcodes; + import org.objectweb.asm.Type; +-import org.objectweb.asm.commons.EmptyVisitor; ++import org.objectweb.asm.MethodVisitor; + import org.objectweb.asm.tree.AbstractInsnNode; + import org.objectweb.asm.tree.FieldNode; + import org.objectweb.asm.tree.VarInsnNode; +@@ -116,13 +116,14 @@ + } + } + +- private static class MD5Digester extends EmptyVisitor { ++ private static class MD5Digester extends MethodVisitor { + private static MessageDigest digest; + private static ByteBuffer buffer; + private final List<Label> labels = new ArrayList<Label>(); + private final String parserClassName; + + public MD5Digester(String parserClassName) { ++ super(Opcodes.ASM4); + this.parserClassName = parserClassName; + if (digest == null) { + try { +@@ -251,6 +252,12 @@ + update(type); + } + ++ public void visitField(FieldNode field) { ++ update(field.name); ++ update(field.desc); ++ update(field.signature); ++ } ++ + private void update(int i) { + ensureRemaining(4); + buffer.putInt(i); +@@ -293,4 +300,4 @@ + } + } + +-} +\ No newline at end of file ++} +--- a/src/main/org/parboiled/transform/ClassNodeInitializer.java ++++ b/src/main/org/parboiled/transform/ClassNodeInitializer.java +@@ -24,19 +24,20 @@ + + import org.jetbrains.annotations.NotNull; + import org.objectweb.asm.*; +-import org.objectweb.asm.commons.EmptyVisitor; ++import org.objectweb.asm.ClassVisitor; + import org.objectweb.asm.tree.MethodNode; + import org.parboiled.support.Checks; + + import java.io.IOException; + ++import static org.objectweb.asm.Opcodes.*; + import static org.parboiled.transform.AsmUtils.createClassReader; + import static org.parboiled.transform.AsmUtils.getExtendedParserClassName; + + /** + * Initializes the basic ParserClassNode fields and collects all methods. + */ +-class ClassNodeInitializer extends EmptyVisitor implements Opcodes, Types { ++class ClassNodeInitializer extends ClassVisitor { + + private ParserClassNode classNode; + private Class<?> ownerClass; +@@ -44,6 +45,10 @@ + private boolean hasDontLabelAnnotation; + private boolean hasSkipActionsInPredicates; + ++ public ClassNodeInitializer() { ++ super(Opcodes.ASM4); ++ } ++ + public void process(@NotNull ParserClassNode classNode) throws IOException { + this.classNode = classNode; + +@@ -90,16 +95,16 @@ + + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { +- if (EXPLICIT_ACTIONS_ONLY_DESC.equals(desc)) { ++ if (Types.EXPLICIT_ACTIONS_ONLY_DESC.equals(desc)) { + hasExplicitActionOnlyAnnotation = true; + return null; + } +- if (DONT_LABEL_DESC.equals(desc)) { ++ if (Types.DONT_LABEL_DESC.equals(desc)) { + hasDontLabelAnnotation = true; + return null; + } + +- if (SKIP_ACTIONS_IN_PREDICATES_DESC.equals(desc)) { ++ if (Types.SKIP_ACTIONS_IN_PREDICATES_DESC.equals(desc)) { + hasSkipActionsInPredicates = true; + return null; + } +@@ -127,7 +132,7 @@ + } + + // only add non-native, non-abstract methods returning Rules +- if (!Type.getReturnType(desc).equals(RULE) || (access & (ACC_NATIVE | ACC_ABSTRACT)) > 0) { ++ if (!Type.getReturnType(desc).equals(Types.RULE) || (access & (ACC_NATIVE | ACC_ABSTRACT)) > 0) { + return null; + } + +--- a/src/main/org/parboiled/transform/InstructionGraphNode.java ++++ b/src/main/org/parboiled/transform/InstructionGraphNode.java +@@ -27,7 +27,7 @@ + import org.objectweb.asm.tree.AbstractInsnNode; + import org.objectweb.asm.tree.analysis.BasicValue; + import org.objectweb.asm.tree.analysis.Value; +-import org.objectweb.asm.util.AbstractVisitor; ++import org.objectweb.asm.util.Printer; + + import java.util.ArrayList; + import java.util.Collection; +@@ -36,7 +36,7 @@ + /** + * A node in the instruction dependency graph. + */ +-class InstructionGraphNode implements Value, Opcodes { ++class InstructionGraphNode extends BasicValue { + + private AbstractInsnNode instruction; + private final BasicValue resultValue; +@@ -52,6 +52,7 @@ + private InstructionGroup group; + + public InstructionGraphNode(AbstractInsnNode instruction, BasicValue resultValue) { ++ super(null); + this.instruction = instruction; + this.resultValue = resultValue; + this.isActionRoot = AsmUtils.isActionRoot(instruction); +@@ -60,8 +61,8 @@ + this.isContextSwitch = AsmUtils.isContextSwitch(instruction); + this.isCallOnContextAware = AsmUtils.isCallOnContextAware(instruction); + this.isCaptureGet = AsmUtils.isCaptureGet(instruction); +- this.isXLoad = ILOAD <= instruction.getOpcode() && instruction.getOpcode() < IALOAD; +- this.isXStore = ISTORE <= instruction.getOpcode() && instruction.getOpcode() < IASTORE; ++ this.isXLoad = Opcodes.ILOAD <= instruction.getOpcode() && instruction.getOpcode() < Opcodes.IALOAD; ++ this.isXStore = Opcodes.ISTORE <= instruction.getOpcode() && instruction.getOpcode() < Opcodes.IASTORE; + } + + public int getSize() { +@@ -136,8 +137,8 @@ + return isXStore; + } + +- public void addPredecessors(@NotNull Collection<Value> preds) { +- for (Value pred : preds) { ++ public void addPredecessors(@NotNull Collection<BasicValue> preds) { ++ for (BasicValue pred : preds) { + if (pred instanceof InstructionGraphNode) { + addPredecessor(((InstructionGraphNode) pred)); + } +@@ -152,7 +153,7 @@ + + @Override + public String toString() { +- return instruction.getOpcode() != -1 ? AbstractVisitor.OPCODES[instruction.getOpcode()] : super.toString(); ++ return instruction.getOpcode() != -1 ? Printer.OPCODES[instruction.getOpcode()] : super.toString(); + } + + } +--- a/src/main/org/parboiled/transform/RuleMethodInterpreter.java ++++ b/src/main/org/parboiled/transform/RuleMethodInterpreter.java +@@ -29,14 +29,13 @@ + import org.objectweb.asm.tree.analysis.AnalyzerException; + import org.objectweb.asm.tree.analysis.BasicInterpreter; + import org.objectweb.asm.tree.analysis.BasicValue; +-import org.objectweb.asm.tree.analysis.Value; + import org.parboiled.support.Checks; + + import java.util.ArrayList; + import java.util.Arrays; + import java.util.List; + +-class RuleMethodInterpreter extends BasicInterpreter implements Types { ++class RuleMethodInterpreter extends BasicInterpreter { + + private final RuleMethod method; + private final List<Edge> additionalEdges = new ArrayList<Edge>(); +@@ -46,8 +45,8 @@ + } + + @Override +- public Value newValue(Type type) { +- BasicValue basicValue = (BasicValue) super.newValue(type); ++ public BasicValue newValue(Type type) { ++ BasicValue basicValue = super.newValue(type); + if (basicValue == BasicValue.REFERENCE_VALUE) { + basicValue = new BasicValue(type); // record the exact type and not just "Ljava/lang/Object" + } +@@ -55,27 +54,27 @@ + } + + @Override +- public Value newOperation(AbstractInsnNode insn) throws AnalyzerException { ++ public BasicValue newOperation(AbstractInsnNode insn) throws AnalyzerException { + return createNode(insn, super.newOperation(insn)); + } + + @Override +- public Value copyOperation(AbstractInsnNode insn, Value value) throws AnalyzerException { ++ public BasicValue copyOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { + return createNode(insn, super.copyOperation(insn, value), value); + } + + @Override +- public Value unaryOperation(AbstractInsnNode insn, Value value) throws AnalyzerException { ++ public BasicValue unaryOperation(AbstractInsnNode insn, BasicValue value) throws AnalyzerException { + return createNode(insn, super.unaryOperation(insn, null), value); + } + + @Override +- public Value binaryOperation(AbstractInsnNode insn, Value value1, Value value2) throws AnalyzerException { ++ public BasicValue binaryOperation(AbstractInsnNode insn, BasicValue value1, BasicValue value2) throws AnalyzerException { + return createNode(insn, super.binaryOperation(insn, null, null), value1, value2); + } + + @Override +- public Value ternaryOperation(AbstractInsnNode insn, Value v1, Value v2, Value v3) throws AnalyzerException { ++ public BasicValue ternaryOperation(AbstractInsnNode insn, BasicValue v1, BasicValue v2, BasicValue v3) throws AnalyzerException { + // this method is only called for xASTORE instructions, parameter v1 is the value corresponding to the + // NEWARRAY, ANEWARRAY or MULTIANEWARRAY instruction having created the array, we need to insert a special + // dependency edge from the array creator to this xSTORE instruction +@@ -85,25 +84,25 @@ + + @Override + @SuppressWarnings({"unchecked"}) +- public Value naryOperation(AbstractInsnNode insn, List values) throws AnalyzerException { +- return createNode(insn, super.naryOperation(insn, null), (Value[]) values.toArray(new Value[values.size()])); ++ public BasicValue naryOperation(AbstractInsnNode insn, List values) throws AnalyzerException { ++ return createNode(insn, super.naryOperation(insn, null), (BasicValue[]) values.toArray(new BasicValue[values.size()])); + } + + @Override +- public void returnOperation(AbstractInsnNode insn, Value value, Value expected) throws AnalyzerException { ++ public void returnOperation(AbstractInsnNode insn, BasicValue value, BasicValue expected) throws AnalyzerException { + Preconditions.checkState(insn.getOpcode() == Opcodes.ARETURN); +- Preconditions.checkState(unwrap(value).getType().equals(RULE)); +- Preconditions.checkState(unwrap(expected).getType().equals(RULE)); ++ Preconditions.checkState(unwrap(value).getType().equals(Types.RULE)); ++ Preconditions.checkState(unwrap(expected).getType().equals(Types.RULE)); + Preconditions.checkState(method.getReturnInstructionNode() == null); + method.setReturnInstructionNode(createNode(insn, null, value)); + } + +- private InstructionGraphNode createNode(AbstractInsnNode insn, Value resultValue, Value... prevNodes) { ++ private InstructionGraphNode createNode(AbstractInsnNode insn, BasicValue resultValue, BasicValue... prevNodes) { + return method.setGraphNode(insn, unwrap(resultValue), Arrays.asList(prevNodes)); + } + + @Override +- public Value merge(Value v, Value w) { ++ public BasicValue merge(BasicValue v, BasicValue w) { + // we don't actually merge values but use the control flow detection to deal with conditionals + return v; + } +@@ -117,7 +116,7 @@ + } + } + +- private AbstractInsnNode findArrayCreatorPredecessor(Value value) { ++ private AbstractInsnNode findArrayCreatorPredecessor(BasicValue value) { + String errorMessage = "Internal error during analysis of rule method '" + method.name + + "', please report this error to [email protected]! Thank you!"; + Checks.ensure(value instanceof InstructionGraphNode, errorMessage); +@@ -146,9 +145,9 @@ + return method.getGraphNodes().get(method.instructions.indexOf(insn)); + } + +- private BasicValue unwrap(Value resultValue) { +- return resultValue == null || resultValue instanceof BasicValue ? +- (BasicValue) resultValue : ((InstructionGraphNode) resultValue).getResultValue(); ++ private BasicValue unwrap(BasicValue resultValue) { ++ return (resultValue != null && resultValue instanceof InstructionGraphNode) ? ++ ((InstructionGraphNode) resultValue).getResultValue() : resultValue; + } + + private class Edge { +--- a/src/main/org/parboiled/transform/RuleMethod.java ++++ b/src/main/org/parboiled/transform/RuleMethod.java +@@ -33,7 +33,6 @@ + import org.objectweb.asm.tree.LocalVariableNode; + import org.objectweb.asm.tree.MethodNode; + import org.objectweb.asm.tree.analysis.BasicValue; +-import org.objectweb.asm.tree.analysis.Value; + import org.parboiled.BaseParser; + import org.parboiled.common.StringUtils; + import org.parboiled.support.Var; +@@ -185,7 +184,7 @@ + return name.charAt(0) == '$'; + } + +- public InstructionGraphNode setGraphNode(AbstractInsnNode insn, BasicValue resultValue, List<Value> predecessors) { ++ public InstructionGraphNode setGraphNode(AbstractInsnNode insn, BasicValue resultValue, List<BasicValue> predecessors) { + if (graphNodes == null) { + // initialize with a list of null values + graphNodes = new ArrayList<InstructionGraphNode>( diff --git a/debian/patches/series b/debian/patches/series index 5879227..9f6185a 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -1 +1,2 @@ build.patch +asm-compatibility.patch -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/lombok-ast.git _______________________________________________ pkg-java-commits mailing list [email protected] http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-java-commits
