Merge pull request #162 from VariantSync/fix-marlin-macros

Fix marlin macro interpretation

Author: pmbittner

src/main/java/org/variantsync/diffdetective/datasets/predefined/Marlin.java

@@ -2,20 +2,19 @@
 
 import org.variantsync.diffdetective.datasets.PatchDiffParseOptions;
 import org.variantsync.diffdetective.datasets.Repository;
-import org.variantsync.diffdetective.feature.PreprocessorAnnotationParser;
+import org.variantsync.diffdetective.feature.AnnotationParser;
+import org.variantsync.diffdetective.feature.cpp.CPPAnnotationParser;
 
 import java.nio.file.Path;
 
 /**
  * Default repository for Marlin.
  *
- * @author Kevin Jedelhauser, Paul Maximilian Bittner
+ * @author Kevin Jedelhauser, Paul Maximilian Bittner, Benjamin Moosherr
  */
 public class Marlin {
-    public static final PreprocessorAnnotationParser ANNOTATION_PARSER =
-            PreprocessorAnnotationParser.CreateCppAnnotationParser(
-                    new MarlinCPPDiffLineFormulaExtractor()
-            );
+    public static final AnnotationParser ANNOTATION_PARSER =
+            new CPPAnnotationParser(new MarlinControllingCExpressionVisitor());
 
     /**
      * Clones Marlin from Github.

src/main/java/org/variantsync/diffdetective/datasets/predefined/MarlinCPPDiffLineFormulaExtractor.java

@@ -0,0 +1,40 @@
+package org.variantsync.diffdetective.datasets.predefined;
+
+import org.antlr.v4.runtime.tree.TerminalNode;
+import org.prop4j.Node;
+import org.variantsync.diffdetective.feature.antlr.CExpressionParser;
+import org.variantsync.diffdetective.feature.cpp.ControllingCExpressionVisitor;
+
+import java.util.List;
+
+import static org.variantsync.diffdetective.util.fide.FormulaUtils.negate;
+
+/**
+ * Parses C preprocessor annotations in the marlin firmware.
+ * <p>
+ * In contrast to {@link ControllingCExpressionVisitor},
+ * this class resolves the {@code ENABLED} and {@code DISABLED} macros
+ * that are used in Marlin to check for features being (de-)selected.
+ *
+ * @author Paul Bittner, Benjamin Moosherr
+ */
+public class MarlinControllingCExpressionVisitor extends ControllingCExpressionVisitor {
+    @Override
+    public Node visitPrimaryExpression(CExpressionParser.PrimaryExpressionContext ctx) {
+        if (ctx.macroExpression() != null) {
+            TerminalNode name = ctx.macroExpression().Identifier();
+            List<CExpressionParser.AssignmentExpressionContext> arguments = ctx.macroExpression().argumentExpressionList().assignmentExpression();
+
+            if (arguments.size() == 1) {
+                if (name.getText().equals("ENABLED")) {
+                    return abstractToLiteral(arguments.get(0));
+                }
+                if (name.getText().equals("DISABLED")) {
+                    return negate(abstractToLiteral(arguments.get(0)));
+                }
+            }
+        }
+
+        return super.visitPrimaryExpression(ctx);
+    }
+}

src/main/java/org/variantsync/diffdetective/datasets/predefined/MarlinControllingCExpressionVisitor.java

@@ -0,0 +1,38 @@
+package org.variantsync.diffdetective.feature;
+
+import org.prop4j.Node;
+
+/**
+ * Represents a new annotation (i.e., a change in the presence condition).
+ * This includes, {@link AnnotationType#If adding to the presence condition},
+ * {@link AnnotationType#Endif removing the most recent formula}
+ * and {@link AnnotationType others}.
+ *
+ * @param type the type of this annotation
+ * @param formula the formula associated to {@code type}.
+ * Non-null iff {@link AnnotationType#requiresFormula type.requiresFormula}.
+ */
+public record Annotation(
+    AnnotationType type,
+    Node formula
+) {
+    public Annotation(AnnotationType type, Node formula) {
+        this.type = type;
+        this.formula = formula;
+
+        if (type.requiresFormula && formula == null) {
+            throw new IllegalArgumentException("Annotations of type " + type.name + " but got null");
+        }
+        if (!type.requiresFormula && formula != null) {
+            throw new IllegalArgumentException("Annotations of type " + type.name + " do not accept a formula but it was given " + formula);
+        }
+    }
+
+    /**
+     * Equivalent to {@link #Annotation(AnnotationType, Node) Annotation(type, null)}.
+     * Hence, only useable iff {@link AnnotationType#requiresFormula !type.requiresFormula}.
+     */
+    public Annotation(AnnotationType type) {
+        this(type, null);
+    }
+}

src/main/java/org/variantsync/diffdetective/feature/Annotation.java

@@ -1,31 +1,23 @@
 package org.variantsync.diffdetective.feature;
 
-import org.prop4j.Node;
 import org.variantsync.diffdetective.error.UnparseableFormulaException;
 
 /**
  * Interface for a parser that analyzes annotations in parsed text. The parser is responsible for determining the type
- * of the annotation (see {@link AnnotationType}), and parsing the annotation into a {@link Node}.
+ * of the annotation (see {@link AnnotationType}), and parsing the annotation into a {@link org.prop4j.Node}.
  * <p>
  * See {@link PreprocessorAnnotationParser} for an example of how an implementation of AnnotationParser could look like.
  * </p>
  */
 public interface AnnotationParser {
     /**
-     * Determine the annotation type for the given piece of text (typically a line of source code).
+     * Parse the given line as an annotation.
+     * Note that {@code line} might also be a line in a diff (i.e., preceded by {@code -} or {@code +}).
      *
-     * @param text The text of which the type is determined.
-     * @return The annotation type of the piece of text.
+     * @param line that might contain an annotation
+     * @return the annotation type and the associated formula.
+     * If {@code line} doesn't contain an annotation, returns {@code Annotation(AnnotationType.NONE)}.
+     * @throws UnparseableFormulaException if an annotation is detected but it is malformed
      */
-    AnnotationType determineAnnotationType(String text);
-
-    /**
-     * Parse the condition of the given text containing an annotation (typically a line of source code).
-     *
-     * @param text The text containing a conditional annotation
-     * @return The formula of the condition in the given annotation.
-     * If no such formula could be extracted, returns a Literal with the line's condition as name.
-     * @throws UnparseableFormulaException if there is an error while parsing.
-     */
-    Node parseAnnotation(String text) throws UnparseableFormulaException;
+    Annotation parseAnnotation(String line) throws UnparseableFormulaException;
 }

src/main/java/org/variantsync/diffdetective/feature/AnnotationParser.java

@@ -9,34 +9,39 @@ public enum AnnotationType {
      * The piece of text (e.g., "#if ...") contains a conditional annotation that starts a new
      * annotated subtree in the variation tree.
      */
-    If("if"),
+    If("if", true),
 
     /**
      * The piece of text (e.g., "#elif ...") contains a conditional annotation which is only checked
      * if the conditions of all preceding annotations belonging to the same annotation chain are not fulfilled.
      */
-    Elif("elif"),
+    Elif("elif", true),
 
     /**
      * The piece of text (e.g., "#else") contains an annotation that marks a subtree as used alternative
      * if the condition of the preceding annotation in the same annotation chain is not fulfilled.
      */
-    Else("else"),
+    Else("else", false),
 
     /**
      * The piece of text (e.g., "#endif") marks the end of an annotation (chain).
      */
-    Endif("endif"),
+    Endif("endif", false),
 
     /**
      * The piece of text contains no annotation. This usually means that it contains an artifact.
      */
-    None("NONE");
+    None("NONE", false);
 
     public final String name;
+    /**
+     * Does this type of annotation require a formula?
+     */
+    public final boolean requiresFormula;
 
-    AnnotationType(String name) {
+    AnnotationType(String name, boolean requiresFormula) {
         this.name = name;
+        this.requiresFormula = requiresFormula;
     }
 
     /**