fix: Reinstantiate the macro handling for Marlin

Until 5056de8,
the Marlin macros `ENABLED` and `DISABLED` where handled specially to
extract more useful feature mappings.

Author: ibbem

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

@@ -10,13 +10,11 @@
 /**
  * Default repository for Marlin.
  *
- * @author Kevin Jedelhauser, Paul Maximilian Bittner
+ * @author Kevin Jedelhauser, Paul Maximilian Bittner, Benjamin Moosherr
  */
 public class Marlin {
     public static final AnnotationParser ANNOTATION_PARSER =
-            new CPPAnnotationParser(
-                    // TODO new MarlinCPPDiffLineFormulaExtractor()
-            );
+            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

@@ -31,8 +31,15 @@ public class CPPAnnotationParser extends PreprocessorAnnotationParser {
     private static final String CPP_ANNOTATION_REGEX = "^[+-]?\\s*#\\s*(?<directive>if|ifdef|ifndef|elif|elifdef|elifndef|else|endif)(?<formula>[\\s(].*)?$";
     private static final Pattern CPP_ANNOTATION_PATTERN = Pattern.compile(CPP_ANNOTATION_REGEX);
 
-    public CPPAnnotationParser() {
+    private ParseTreeVisitor<Node> formulaVisitor;
+
+    public CPPAnnotationParser(ParseTreeVisitor<Node> formulaVisitor) {
         super(CPP_ANNOTATION_PATTERN);
+        this.formulaVisitor = formulaVisitor;
+    }
+
+    public CPPAnnotationParser() {
+        this(new ControllingCExpressionVisitor());
     }
 
     @Override
@@ -45,7 +52,7 @@ public Node parseFormula(final String directive, final String formula) throws Un
             CExpressionParser parser = new CExpressionParser(tokens);
             parser.addErrorListener(new ParseErrorListener(formula));
 
-            parsedFormula = parser.expression().accept(new ControllingCExpressionVisitor());
+            parsedFormula = parser.expression().accept(formulaVisitor);
         } catch (UncheckedUnparseableFormulaException e) {
             throw e.inner();
         } catch (Exception e) {

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

@@ -275,7 +275,7 @@ public Node visitLogicalOperand(CExpressionParser.LogicalOperandContext ctx) {
     // logicalOrExpression
     //    :   logicalAndExpression ( '||' logicalAndExpression)*
     //    ;
-    private Node visitLogicalExpression(ParserRuleContext expressionContext, Function<Node[], Node> newLogicNode) {
+    protected Node visitLogicalExpression(ParserRuleContext expressionContext, Function<Node[], Node> newLogicNode) {
         if (expressionContext.getChildCount() == 1) {
             return expressionContext.getChild(0).accept(this);
         } else {
@@ -291,7 +291,7 @@ private Node visitLogicalExpression(ParserRuleContext expressionContext, Functio
         }
     }
 
-    private Node recurseOnSingleChild(ParserRuleContext ctx) {
+    protected Node recurseOnSingleChild(ParserRuleContext ctx) {
         if (ctx.getChildCount() > 1) {
             // We have to abstract the expression if there is more than one operand
             return abstractToLiteral(ctx);
@@ -301,7 +301,7 @@ private Node recurseOnSingleChild(ParserRuleContext ctx) {
         }
     }
 
-    private Node abstractToLiteral(ParserRuleContext ctx) {
+    protected Node abstractToLiteral(ParserRuleContext ctx) {
         return var(ctx.accept(abstractingVisitor).toString());
     }
 }

src/main/java/org/variantsync/diffdetective/feature/cpp/CPPAnnotationParser.java

@@ -1,6 +1,7 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.prop4j.Node;
+import org.variantsync.diffdetective.datasets.predefined.MarlinControllingCExpressionVisitor;
 import org.variantsync.diffdetective.error.UnparseableFormulaException;
 import org.variantsync.diffdetective.feature.Annotation;
 import org.variantsync.diffdetective.feature.AnnotationType;
@@ -140,6 +141,28 @@ private static List<TestCase> testCases() {
         );
     }
 
+    private static List<TestCase> nonMarlinTestCases() {
+        return List.of(
+                new TestCase("#if ENABLED(A)", var("ENABLED(A)")),
+                new TestCase("#if DISABLED(A)", var("DISABLED(A)")),
+                new TestCase("#if ENABLED(FEATURE_A) && DISABLED(FEATURE_B)", and(var("ENABLED(FEATURE_A)"), var("DISABLED(FEATURE_B)"))),
+                new TestCase("#if ENABLED(A, B)", var("ENABLED(A,B)")),
+                new TestCase("#if OTHER(A, B)", var("OTHER(A,B)")),
+                new TestCase("#if A", var("A"))
+        );
+    }
+
+    private static List<TestCase> marlinTestCases() {
+        return List.of(
+                new TestCase("#if ENABLED(A)", var("A")),
+                new TestCase("#if DISABLED(A)", negate(var("A"))),
+                new TestCase("#if ENABLED(FEATURE_A) && DISABLED(FEATURE_B)", and(var("FEATURE_A"), negate(var("FEATURE_B")))),
+                new TestCase("#if ENABLED(A, B)", var("ENABLED(A,B)")),
+                new TestCase("#if OTHER(A, B)", var("OTHER(A,B)")),
+                new TestCase("#if A", var("A"))
+        );
+    }
+
     private static List<ThrowingTestCase> throwingTestCases() {
         return List.of(
                 // Empty formula
@@ -150,14 +173,24 @@ private static List<ThrowingTestCase> throwingTestCases() {
     }
 
     @ParameterizedTest
-    @MethodSource("testCases")
+    @MethodSource({"testCases", "nonMarlinTestCases"})
     public void testCase(TestCase testCase) throws UnparseableFormulaException {
         assertEquals(
                 testCase.expectedAnnotation(),
                 new CPPAnnotationParser().parseAnnotation(testCase.formula())
         );
     }
 
+    @ParameterizedTest
+    @MethodSource({"testCases", "marlinTestCases"})
+    public void marlinTestCase(TestCase testCase) throws UnparseableFormulaException {
+        assertEquals(
+                testCase.expectedAnnotation(),
+                new CPPAnnotationParser(new MarlinControllingCExpressionVisitor()).parseAnnotation(testCase.formula())
+        );
+    }
+
+
     @ParameterizedTest
     @MethodSource("throwingTestCases")
     public void throwingTestCase(ThrowingTestCase testCase) {