fix: merge main into issue-22

Author: Julia Pham

pom.xml

@@ -79,7 +79,7 @@
         <dependency>
             <groupId>io.github.universal-variability-language</groupId>
             <artifactId>uvl-parser</artifactId>
-            <version>0.4.1</version>
+            <version>0.5.0</version>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>

src/main/java/de/vill/main/IterativeParseTreeWalker.java

@@ -0,0 +1,69 @@
+package de.vill.main;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.antlr.v4.runtime.tree.RuleNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * Iterative variant of ANTLR's ParseTreeWalker.
+ *
+ * ANTLR's default ParseTreeWalker recursively walks the parse tree.
+ * Deeply nested constraints such as F0 | F1 | ... | F6999 can therefore
+ * overflow the Java call stack before the UVL model is constructed.
+ */
+final class IterativeParseTreeWalker extends ParseTreeWalker {
+
+    @Override
+    public void walk(ParseTreeListener listener, ParseTree tree) {
+        final Deque<Frame> stack = new ArrayDeque<>();
+        stack.push(new Frame(tree));
+
+        while (!stack.isEmpty()) {
+            final Frame frame = stack.peek();
+            final ParseTree current = frame.tree;
+
+            if (current instanceof ErrorNode) {
+                listener.visitErrorNode((ErrorNode) current);
+                stack.pop();
+                continue;
+            }
+
+            if (current instanceof TerminalNode) {
+                listener.visitTerminal((TerminalNode) current);
+                stack.pop();
+                continue;
+            }
+
+            final RuleNode ruleNode = (RuleNode) current;
+
+            if (!frame.entered) {
+                enterRule(listener, ruleNode);
+                frame.entered = true;
+            }
+
+            if (frame.nextChildIndex < current.getChildCount()) {
+                stack.push(new Frame(current.getChild(frame.nextChildIndex)));
+                frame.nextChildIndex++;
+            } else {
+                exitRule(listener, ruleNode);
+                stack.pop();
+            }
+        }
+    }
+
+    private static final class Frame {
+        private final ParseTree tree;
+        private boolean entered;
+        private int nextChildIndex;
+
+        private Frame(ParseTree tree) {
+            this.tree = tree;
+        }
+    }
+}

src/main/java/de/vill/main/UVLListener.java

@@ -53,7 +53,15 @@
 import org.antlr.v4.runtime.Token;
 
 public class UVLListener extends UVLJavaParserBaseListener {
-    public FeatureModelBuilder fmBuilder = new FeatureModelBuilder();
+    public FeatureModelBuilder fmBuilder;
+
+    public UVLListener() {
+        this(new FeatureModelBuilder());
+    }
+
+    public UVLListener(FeatureModelBuilder fmBuilder) {
+        this.fmBuilder = fmBuilder;
+    }
     private Set<LanguageLevel> importedLanguageLevels = new HashSet<>(Arrays.asList(LanguageLevel.BOOLEAN_LEVEL));
     private Stack<Feature> featureStack = new Stack<>();
     private Stack<Group> groupStack = new Stack<>();
@@ -407,7 +415,13 @@ public void exitNotConstraint(UVLJavaParser.NotConstraintContext ctx) {
     public void exitAndConstraint(UVLJavaParser.AndConstraintContext ctx) {
         Constraint rightConstraint = constraintStack.pop();
         Constraint leftConstraint = constraintStack.pop();
-        Constraint constraint = new AndConstraint(leftConstraint, rightConstraint);
+        Constraint constraint;
+        if (leftConstraint instanceof AndConstraint) {
+            ((AndConstraint) leftConstraint).addChild(rightConstraint);
+            constraint = leftConstraint;
+        } else {
+            constraint = new AndConstraint(leftConstraint, rightConstraint);
+        }
         constraintStack.push(constraint);
         Token t = ctx.getStart();
         int line = t.getLine();
@@ -418,7 +432,13 @@ public void exitAndConstraint(UVLJavaParser.AndConstraintContext ctx) {
     public void exitOrConstraint(UVLJavaParser.OrConstraintContext ctx) {
         Constraint rightConstraint = constraintStack.pop();
         Constraint leftConstraint = constraintStack.pop();
-        Constraint constraint = new OrConstraint(leftConstraint, rightConstraint);
+        Constraint constraint;
+        if (leftConstraint instanceof OrConstraint) {
+            ((OrConstraint) leftConstraint).addChild(rightConstraint);
+            constraint = leftConstraint;
+        } else {
+            constraint = new OrConstraint(leftConstraint, rightConstraint);
+        }
         constraintStack.push(constraint);
         Token t = ctx.getStart();
         int line = t.getLine();

src/main/java/de/vill/main/UVLModelFactory.java

@@ -1,6 +1,9 @@
 package de.vill.main;
 
 import de.vill.model.*;
+import de.vill.model.building.AbstractUVLElementFactory;
+import de.vill.model.building.DefaultUVLElementFactory;
+import de.vill.model.building.FeatureModelBuilder;
 import de.vill.model.building.VariableReference;
 import de.vill.model.constraint.*;
 import de.vill.model.expression.*;
@@ -34,7 +37,6 @@
 import org.antlr.v4.runtime.ConsoleErrorListener;
 import org.antlr.v4.runtime.RecognitionException;
 import org.antlr.v4.runtime.Recognizer;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 
 import java.io.IOException;
 import java.nio.file.FileSystems;
@@ -47,10 +49,16 @@ public class UVLModelFactory {
 
     private final Map<LanguageLevel, Class<? extends IConversionStrategy>> conversionStrategiesDrop;
     private final Map<LanguageLevel, Class<? extends IConversionStrategy>> conversionStrategiesConvert;
+    private final AbstractUVLElementFactory elementFactory;
 
     private final List<ParseError> errorList = new LinkedList<>();
 
     public UVLModelFactory() {
+        this(new DefaultUVLElementFactory());
+    }
+
+    public UVLModelFactory(AbstractUVLElementFactory elementFactory) {
+        this.elementFactory = elementFactory;
         this.conversionStrategiesDrop = new HashMap<>();
         this.conversionStrategiesDrop.put(LanguageLevel.GROUP_CARDINALITY, DropGroupCardinality.class);
         this.conversionStrategiesDrop.put(LanguageLevel.FEATURE_CARDINALITY, DropFeatureCardinality.class);
@@ -119,8 +127,9 @@ public Constraint parseConstraint(String constraintString) throws ParseError {
         UVLJavaLexer.addErrorListener(listener);
         UVLJavaParser.addErrorListener(listener);
 
-        UVLListener uvlListener = new UVLListener();
-        ParseTreeWalker walker = new ParseTreeWalker();
+        UVLListener uvlListener = createUVLListener();
+        IterativeParseTreeWalker walker = new IterativeParseTreeWalker();
+       
         walker.walk(uvlListener, UVLJavaParser.constraintLine());
 
         return uvlListener.getConstraint();
@@ -267,6 +276,10 @@ private List<LanguageLevel> getActualLanguageLevelsToRemoveInOrder(FeatureModel
         return completeOrderedLevelsToRemove;
     }
 
+    private UVLListener createUVLListener() {
+        return new UVLListener(new FeatureModelBuilder(elementFactory));
+    }
+
     private String getPath(String rootPath, Import referencedImport) {
         return rootPath + FileSystems.getDefault().getSeparator() + referencedImport.getNamespace().replace(".", FileSystems.getDefault().getSeparator()) + ".uvl";
     }
@@ -285,8 +298,10 @@ private FeatureModel parseFeatureModelWithImports(String text, String rootPath,
         UVLJavaParser.addErrorListener(listener);
 
 
-        UVLListener uvlListener = new UVLListener();
-        ParseTreeWalker walker = new ParseTreeWalker();
+    
+        UVLListener uvlListener = createUVLListener();
+        IterativeParseTreeWalker walker = new IterativeParseTreeWalker();
+        
         walker.walk(uvlListener, UVLJavaParser.featureModel());
         FeatureModel featureModel = null;
 
@@ -378,42 +393,55 @@ private FeatureModel parseFeatureModelWithImports(String text, String rootPath,
     }
 
     private void resolveImportPlaceholders(Constraint constraint, FeatureModel featureModel) {
-        if (constraint instanceof AndConstraint || constraint instanceof OrConstraint || constraint instanceof NotConstraint || constraint instanceof ImplicationConstraint || constraint instanceof ParenthesisConstraint || constraint instanceof EquivalenceConstraint) {
-            for (Constraint subPart : constraint.getConstraintSubParts()) {
-                resolveImportPlaceholders(subPart, featureModel);
+        final Deque<Constraint> stack = new ArrayDeque<>();
+        stack.push(constraint);
+
+        while (!stack.isEmpty()) {
+            final Constraint current = stack.pop();
+
+            if (current instanceof ExpressionConstraint) {
+                ExpressionConstraint expressionConstraint = (ExpressionConstraint) current;
+                resolveImportPlaceholders(expressionConstraint.getLeft(), featureModel);
+                resolveImportPlaceholders(expressionConstraint.getRight(), featureModel);
+            } else if (current instanceof LiteralConstraint) {
+                LiteralConstraint literalConstraint = (LiteralConstraint) current;
+                if (literalConstraint.getReference() instanceof ImportedVariablePlaceholder) {
+                    ImportedVariablePlaceholder placeholder = (ImportedVariablePlaceholder) literalConstraint.getReference();
+                    literalConstraint.setReference(resolvePlaceholder(placeholder, featureModel));
+                }
             }
-        }  else if (constraint instanceof ExpressionConstraint) {
-            ExpressionConstraint expressionConstraint = (ExpressionConstraint) constraint;
-            resolveImportPlaceholders(expressionConstraint.getLeft(), featureModel);
-            resolveImportPlaceholders(expressionConstraint.getRight(), featureModel);
-        } else if (constraint instanceof LiteralConstraint) {
-            LiteralConstraint literalConstraint = (LiteralConstraint) constraint;
-            if (literalConstraint.getReference() instanceof ImportedVariablePlaceholder) {
-                ImportedVariablePlaceholder placeholder = (ImportedVariablePlaceholder) literalConstraint.getReference();
-                literalConstraint.setReference(resolvePlaceholder(placeholder, featureModel));
+
+            final List<Constraint> subConstraints = current.getConstraintSubParts();
+            for (int i = subConstraints.size() - 1; i >= 0; i--) {
+                stack.push(subConstraints.get(i));
             }
         }
     }
 
     private void resolveImportPlaceholders(Expression expression, FeatureModel featureModel) {
-        if (expression instanceof BinaryExpression) {
-            BinaryExpression binaryExpression = (BinaryExpression) expression;
-            resolveImportPlaceholders(binaryExpression.getLeft(), featureModel);
-            resolveImportPlaceholders(binaryExpression.getRight(), featureModel);
-        } else if (expression instanceof ParenthesisExpression) {
-            ParenthesisExpression parenthesisExpression = (ParenthesisExpression) expression;
-            resolveImportPlaceholders(parenthesisExpression.getContent(), featureModel);
-        } else if (expression instanceof LengthAggregateFunctionExpression) {
-            LengthAggregateFunctionExpression lengthAggregateFunctionExpression = (LengthAggregateFunctionExpression) expression;
-            if (lengthAggregateFunctionExpression.getReference() instanceof ImportedVariablePlaceholder) {
-                ImportedVariablePlaceholder placeholder = (ImportedVariablePlaceholder) lengthAggregateFunctionExpression.getReference();
-                lengthAggregateFunctionExpression.setReference(resolvePlaceholder(placeholder, featureModel));
+        final Deque<Expression> stack = new ArrayDeque<>();
+        stack.push(expression);
+
+        while (!stack.isEmpty()) {
+            final Expression current = stack.pop();
+
+            if (current instanceof LengthAggregateFunctionExpression) {
+                LengthAggregateFunctionExpression lengthAggregateFunctionExpression = (LengthAggregateFunctionExpression) current;
+                if (lengthAggregateFunctionExpression.getReference() instanceof ImportedVariablePlaceholder) {
+                    ImportedVariablePlaceholder placeholder = (ImportedVariablePlaceholder) lengthAggregateFunctionExpression.getReference();
+                    lengthAggregateFunctionExpression.setReference(resolvePlaceholder(placeholder, featureModel));
+                }
+            } else if (current instanceof LiteralExpression) {
+                LiteralExpression literalExpression = (LiteralExpression) current;
+                if (literalExpression.getContent() instanceof ImportedVariablePlaceholder) {
+                    ImportedVariablePlaceholder placeholder = (ImportedVariablePlaceholder) literalExpression.getContent();
+                    literalExpression.setContent(resolvePlaceholder(placeholder, featureModel));
+                }
             }
-        } else if (expression instanceof LiteralExpression) {
-            LiteralExpression literalExpression = (LiteralExpression) expression;
-            if (literalExpression.getContent() instanceof ImportedVariablePlaceholder) {
-                ImportedVariablePlaceholder placeholder = (ImportedVariablePlaceholder) literalExpression.getContent();
-                literalExpression.setContent(resolvePlaceholder(placeholder, featureModel));
+
+            final List<Expression> subExpressions = current.getExpressionSubParts();
+            for (int i = subExpressions.size() - 1; i >= 0; i--) {
+                stack.push(subExpressions.get(i));
             }
         }
     }
@@ -537,28 +565,38 @@ private void validateTypeLevelConstraints(final FeatureModel featureModel) {
     }
 
     private boolean validateTypeLevelConstraint(final Constraint constraint) {
-        boolean result = true;
-        if (constraint instanceof ExpressionConstraint) {
-            String leftReturnType = ((ExpressionConstraint) constraint).getLeft().getReturnType();
-            String rightReturnType = ((ExpressionConstraint) constraint).getRight().getReturnType();
+        final Deque<Constraint> stack = new ArrayDeque<>();
+        stack.push(constraint);
 
-            if (!(leftReturnType.equalsIgnoreCase(Constants.TRUE) || rightReturnType.equalsIgnoreCase(Constants.TRUE))) {
-                // if not attribute constraint
-                result = result && ((ExpressionConstraint) constraint).getLeft().getReturnType().equalsIgnoreCase(((ExpressionConstraint) constraint).getRight().getReturnType());
-            }
-            if (!result) {
-                return false;
-            }
-            for (final Expression expr: ((ExpressionConstraint) constraint).getExpressionSubParts()) {
-                result = result && validateTypeLevelExpression(expr);
+        while (!stack.isEmpty()) {
+            final Constraint current = stack.pop();
+
+            if (current instanceof ExpressionConstraint) {
+                final ExpressionConstraint expressionConstraint = (ExpressionConstraint) current;
+
+                final String leftReturnType = expressionConstraint.getLeft().getReturnType();
+                final String rightReturnType = expressionConstraint.getRight().getReturnType();
+
+                if (!(leftReturnType.equalsIgnoreCase(Constants.TRUE) || rightReturnType.equalsIgnoreCase(Constants.TRUE))) {
+                    if (!leftReturnType.equalsIgnoreCase(rightReturnType)) {
+                        return false;
+                    }
+                }
+
+                for (final Expression expr : expressionConstraint.getExpressionSubParts()) {
+                    if (!validateTypeLevelExpression(expr)) {
+                        return false;
+                    }
+                }
             }
-        }
 
-        for (final Constraint subCons: constraint.getConstraintSubParts()) {
-            result = result && validateTypeLevelConstraint(subCons);
+            final List<Constraint> subConstraints = current.getConstraintSubParts();
+            for (int i = subConstraints.size() - 1; i >= 0; i--) {
+                stack.push(subConstraints.get(i));
+            }
         }
 
-        return result;
+        return true;
     }
 
     private boolean validateTypeLevelExpression(final Expression expression) {

src/main/java/de/vill/model/building/AbstractUVLElementFactory.java

@@ -0,0 +1,15 @@
+package de.vill.model.building;
+
+import de.vill.exception.ParseError;
+import de.vill.model.*;
+import de.vill.model.constraint.LiteralConstraint;
+
+public abstract class AbstractUVLElementFactory {
+
+    public abstract Feature createFeature(String name);
+
+    public abstract <T> Attribute<T> createAttribute(String name, T value, Feature correspondingFeature);
+
+    public abstract GlobalAttribute createGlobalAttribute(String identifier, FeatureModel featureModel);
+
+}

src/main/java/de/vill/model/building/DefaultUVLElementFactory.java

@@ -0,0 +1,23 @@
+package de.vill.model.building;
+
+import de.vill.exception.ParseError;
+import de.vill.model.*;
+import de.vill.model.constraint.LiteralConstraint;
+
+public class DefaultUVLElementFactory extends AbstractUVLElementFactory {
+
+    @Override
+    public Feature createFeature(String name) {
+        return new Feature(name);
+    }
+
+    @Override
+    public <T> Attribute<T> createAttribute(String name, T value, Feature correspondingFeature) {
+        return new Attribute<>(name, value, correspondingFeature);
+    }
+
+    @Override
+    public GlobalAttribute createGlobalAttribute(String identifier, FeatureModel featureModel) {
+        return new GlobalAttribute(identifier, featureModel);
+    }
+}