Index: /ModelExtender/src/de/uni_hildesheim/sse/model_extender/convert/ModelExtender.java
===================================================================
--- /ModelExtender/src/de/uni_hildesheim/sse/model_extender/convert/ModelExtender.java	(revision 194)
+++ /ModelExtender/src/de/uni_hildesheim/sse/model_extender/convert/ModelExtender.java	(revision 195)
@@ -1,4 +1,5 @@
 package de.uni_hildesheim.sse.model_extender.convert;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -33,4 +34,6 @@
     private Map<String, AbstractVariable> variables;
     
+    private List<AbstractVariable> newVariables;
+    
     private VariablePool varPool;
     
@@ -44,4 +47,5 @@
         this.varPool = new VariablePool();
         this.variables = new HashMap<String, AbstractVariable>();
+        this.newVariables = new ArrayList<AbstractVariable>();
         
         DeclarationFinder declarationFinder = new DeclarationFinder(model, FilterType.ALL, null);
@@ -61,5 +65,4 @@
     public void addConstraint(String constraint) throws ParserException {
         ConstraintSyntaxTree tree = toCST(constraint);
-        
         Constraint tmp = new Constraint(null);
         try {
@@ -70,16 +73,171 @@
         ListMaxTermConverter converter = new ListMaxTermConverter();
         converter.convert(tmp);
-        
         for (ConstraintSyntaxTree cst : converter.getCSTs()) {
-            Constraint constr = new Constraint(model);
+            addConstraint(cst);
+        }
+        
+        for (AbstractVariable var : newVariables) {
+            String name = var.getName();
+            String baseName = null;
+            Comparator comp = null;
+            if (name.contains("<=")) {
+                baseName = name.substring(0, name.indexOf("<="));
+                final int value = Integer.parseInt(name.substring(name.indexOf("<=") + 2));
+                comp = new Comparator() {
+                    @Override
+                    public boolean checkExpressions(int other) {
+                        return other <= value;
+                    }
+                };
+            } else if (name.contains(">=")) {
+                baseName = name.substring(0, name.indexOf(">="));
+                final int value = Integer.parseInt(name.substring(name.indexOf(">=") + 2));
+                comp = new Comparator() {
+                    @Override
+                    public boolean checkExpressions(int other) {
+                        return other >= value;
+                    }
+                };
+            } else if (name.contains("=")) {
+                baseName = name.substring(0, name.indexOf("="));
+                final int value = Integer.parseInt(name.substring(name.indexOf("=") + 1));
+                comp = new Comparator() {
+                    @Override
+                    public boolean checkExpressions(int other) {
+                        return other == value;
+                    }
+                };
+            } else if (name.contains("<")) {
+                baseName = name.substring(0, name.indexOf("<"));
+                final int value = Integer.parseInt(name.substring(name.indexOf("<") + 1));
+                comp = new Comparator() {
+                    @Override
+                    public boolean checkExpressions(int other) {
+                        return other < value;
+                    }
+                };
+            } else if (name.contains(">")) {
+                baseName = name.substring(0, name.indexOf(">"));
+                final int value = Integer.parseInt(name.substring(name.indexOf(">") + 1));
+                comp = new Comparator() {
+                    @Override
+                    public boolean checkExpressions(int other) {
+                        return other > value;
+                    }
+                };
+            } else {
+                System.out.println("Warning: Added completly new variable to model: " + name);
+                continue;
+            }
+            addAdditionalConstraints(var, baseName, comp);
+        }
+    }
+    
+    /**
+     * Adds the given constraint to the model.
+     * 
+     * @param cst The {@link ConstraintSyntaxTree} to add to the model.
+     */
+    private void addConstraint(ConstraintSyntaxTree cst) {
+        Constraint constraint = new Constraint(model);
+        try {
+            constraint.setConsSyntax(cst);
+        } catch (CSTSemanticException e) {
+            e.printStackTrace(); // TODO
+        }
+        model.add(constraint);
+    }
+    
+    /**
+     * Searches all variables with the given basename. All variables in the returned list
+     * look like this: <code>&lt;basename&gt;=&lt;something&gt;</code>
+     * Does not return variables that are in the newVariables list.
+     * 
+     * @param baseName The beginning of the variable name.
+     * @return A list of {@link AbstractVariable}s.
+     */
+    private List<AbstractVariable> findAllVaraiblesWithBaseName(String baseName) {
+        List<AbstractVariable> list = new ArrayList<AbstractVariable>();
+        
+        for (AbstractVariable var : variables.values()) {
+            String name = var.getName();
+            if (name.startsWith(baseName) && !newVariables.contains(var)) {
+                char firstCharAfter = name.charAt(baseName.length());
+                if (firstCharAfter == '=') {
+                    list.add(var);
+                }
+            }
+        }
+        
+        return list; 
+    }
+    
+    /**
+     * Contains a single method to check if both conditions can be true.
+     */
+    private interface Comparator {
+        
+        /**
+         * Checks if the two values after the operator in the expressions can be
+         * true at the same time.
+         * E.g.:
+         * <pre>Assume we have the additional variable A>7
+         * If we encounter the variable A=6 it would result in a call of
+         * checkExpression(6);
+         * A correct implementation of this {@link Comparator} for A>7 would return false,
+         * since A>7 && A=6 (== 6>7) is false.
+         * </pre>
+         * 
+         * @param other The value of the other variable; this is the always the
+         * part after the = in the other variable.
+         * @return <code>true</code> if both can be true.
+         */
+        public boolean checkExpressions(int other);
+        
+    }
+    
+    /**
+     * Adds additional needed constraints for new variables that contain <, > or =.
+     * 
+     * @param variable The variable.
+     * @param baseName The baseName of the variable.
+     * @param comp The {@link Comparator} to check if two values can be true at the same time.
+     */
+    private void addAdditionalConstraints(AbstractVariable variable, String baseName, Comparator comp) {
+        List<AbstractVariable> vars = findAllVaraiblesWithBaseName(baseName);
+        
+        for (AbstractVariable var : vars) {
+            String name = var.getName();
+            int i = name.length() - 1;
+            for (; i >= 0; i--) {
+                if (name.charAt(i) < '0' || name.charAt(i) > '9')  {
+                    i++;
+                    break;
+                }
+            }
+            int value = 0;
             try {
-                constr.setConsSyntax(cst);
-            } catch (CSTSemanticException e) {
-                e.printStackTrace(); // TODO
-            }
-            model.add(constr);
-        }
-        
-        // TODO handle =, <=, >=, < and >
+                value = Integer.parseInt(name.substring(i));
+            } catch (NumberFormatException e) {
+                // probably =n
+                continue;
+            }
+            
+            Variable additional = varPool.obtainVariable(variable);
+            Variable original = varPool.obtainVariable(var);
+            OCLFeatureCall notAdditional = new OCLFeatureCall(additional, OclKeyWords.NOT);
+            OCLFeatureCall notOriginal = new OCLFeatureCall(original, OclKeyWords.NOT);
+            if (comp.checkExpressions(value)) {
+                // add original -> additional == additional || !original
+                OCLFeatureCall tree = new OCLFeatureCall(additional, OclKeyWords.OR, notOriginal);
+                addConstraint(tree);
+            } else {
+                // add additional xor original == (!additional || !original) && (additional || original)
+                OCLFeatureCall leftSide = new OCLFeatureCall(notAdditional, OclKeyWords.OR, notOriginal);
+                OCLFeatureCall rightSide = new OCLFeatureCall(additional, OclKeyWords.OR, original);
+                addConstraint(leftSide);
+                addConstraint(rightSide);
+            }
+        }
     }
     
@@ -261,4 +419,5 @@
             model.add(var);
             variables.put(name, var);
+            newVariables.add(var);
         }
         return var;