Changeset 65 in default for v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.xtend

Timestamp:

05/07/14 16:02:46 (10 years ago)

Author:

hkaulbersch

Message:

fixed imports

File:

• v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.xtend (modified) (7 diffs)

v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.xtend

@@ -14 +14 @@
 import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList
 import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition
+import java.util.ArrayList
+
 //import java.util.HashMap
 //import java.util.Set
 //import java.util.HashSet
-
 //import org.eclipse.xtext.validation.Check
 /**
@@ -32 +33 @@
         public static final String equalAlternativeDescription = "The rule contains equal alternatives";
         public static final String duplicateRulesDescription = "The rule is a duplicate";
+
         //public  static final String duplicateSubRulesDescription = "A part the of rule is a duplicate";
         public static final String nonUniqueNameDescription = "The rule has the same Name as the Rule in Line ";
@@ -49 +51 @@
 
                 if (references.size() == 1 && rule.rulenumber != 1) {
-                        warning(ruleReferencedOneDescription, EbnfPackage$Literals::RULE__NAME,ruleReferencedOneDescription,rule.name);
+                        warning(ruleReferencedOneDescription, EbnfPackage$Literals::RULE__NAME, ruleReferencedOneDescription,
+                                rule.name);
                 }
         }
@@ -75 +78 @@
 
                 // run through all Rules
-                for (currentRule : allRules) {
-                        if (currentRule != rule) {
-                                var ICompositeNode currentRuleDefinitionList = NodeModelUtils.findActualNodeFor(
-                                        currentRule.getDefinitionList());
-                                var String currentRuleRightHandSideText = currentRuleDefinitionList.text.trim().replaceAll("[ \t\n\r]",
-                                        "");
-
-                                if (currentRuleRightHandSideText.equals(rightHandSideText)) {
-                                        var String description = duplicateRulesDescription + " with rule \"" + currentRule.getName() +
-                                                "\" (Line " + NodeModelUtils.findActualNodeFor(currentRule).getStartLine() + ")";
-                                        warning(description, EbnfPackage$Literals::RULE__NAME);
-                                }
-                        }
-                }
+                                                for (currentRule : allRules) {
+                                                        if (currentRule != rule) {
+                                                                var ICompositeNode currentRuleDefinitionList = NodeModelUtils.findActualNodeFor(
+                                                                        currentRule.getDefinitionList());
+                                                                var String currentRuleRightHandSideText = currentRuleDefinitionList.text.trim().replaceAll("[ \t\n\r]",
+                                                                        "");
+                                
+                                                                if (currentRuleRightHandSideText.equals(rightHandSideText)) {
+                                                                        var String description = duplicateRulesDescription + " with rule \"" + currentRule.getName() +
+                                                                                "\" (Line " + NodeModelUtils.findActualNodeFor(currentRule).getStartLine() + ")";
+                                                                        warning(description, EbnfPackage$Literals::RULE__NAME);
+                                                                }
+                                                        }
+                                                }
+                
+//              //get all Single Definitions as Trimmed Strings
+//              var List<String> singleDefsAsString = new ArrayList<String>();
+//
+//              for (SingleDefinition s : (rule.definitionList).singleDefinition) {
+//                      singleDefsAsString.add(NodeModelUtils.findActualNodeFor(s).text.trim().replaceAll("[ \t\n\r]", ""));
+//              }
+//
+//              // for every rule get the single definitions as Strings
+//              var int j = 0;
+//              while (j<allRules.size) {
+//                      var currentRule=allRules.get(j);
+//                      if (currentRule != rule) {
+//                              var List<String> singleDefsAsString1 = new ArrayList<String>();
+//
+//                              for (SingleDefinition s : ( currentRule.definitionList).singleDefinition) {
+//                                      singleDefsAsString1.add(NodeModelUtils.findActualNodeFor(s).text.trim().replaceAll("[ \t\n\r]", ""));
+//                              }
+//
+//                              //for every String SingleDefinition find a corresponding ind the current rule 
+//                              if (singleDefsAsString.size == singleDefsAsString1.size) {
+//                                      var List<String> singleDefsAsStringCpy = singleDefsAsString.clone;
+//                                      var boolean equal = true;
+//                                      while (equal) {
+//                                              var String momentaryString = singleDefsAsStringCpy.get(0);
+//                                              var int i = 0;
+//                                              var boolean found = false;
+//                                              while (i < singleDefsAsString1.size && !found) {
+//                                                      if (singleDefsAsString1.get(i).equals(momentaryString)) {
+//                                                              singleDefsAsStringCpy.remove(0);
+//                                                              singleDefsAsString1.remove(i);
+//                                                              found = true
+//                                                      }
+//                                                      i++;
+//                                              }
+//                                              if (!found) {
+//                                                      equal = false;
+//                                              }
+//                                              if (singleDefsAsStringCpy.empty) {
+//                                                      var String description = duplicateRulesDescription + " with rule \"" + currentRule.getName() +
+//                                                              "\" (Line " + NodeModelUtils.findActualNodeFor(currentRule).getStartLine() + ")";
+//                                                      warning(description, EbnfPackage$Literals::RULE__NAME)
+//                                              }
+//                                      }
+//                              }
+//
+//                      }
+//                      j++;
+//              }
         }
 
@@ -122 +174 @@
 
                 if ((references.size() == 0) && (rule.getRulenumber() != 1))
-                        warning(unusedRuleDescription, EbnfPackage$Literals::RULE__NAME,unusedRuleDescription,rule.name);
+                        warning(unusedRuleDescription, EbnfPackage$Literals::RULE__NAME, unusedRuleDescription, rule.name);
         }
 
@@ -144 +196 @@
 
                                         if (d1.equals(d2))
-                                                warning(equalAlternativeDescription, EbnfPackage$Literals::RULE__NAME,equalAlternativeDescription);
+                                                warning(equalAlternativeDescription, EbnfPackage$Literals::RULE__NAME,
+                                                        equalAlternativeDescription, rule.name);
                                 }
                         }
@@ -162 +215 @@
                 var List<RuleReference> references = EbnfAnalysisUtils.findReferences(rule);
 
-                if (EbnfAnalysisUtils.isPassthroughRule(rule)) {
+                if (EbnfAnalysisUtils.isPassthroughRule(rule) && rule.rulenumber != 1) {
                         if (references.size() == 0) {
                                 warning(unreferencedPassthroughRuleDescription, EbnfPackage$Literals::RULE__NAME);
                         } else {
-                                warning(passthroughRuleDescription, EbnfPackage$Literals::RULE__NAME,passthroughRuleDescription);
+                                warning(passthroughRuleDescription, EbnfPackage$Literals::RULE__NAME, passthroughRuleDescription,
+                                        rule.name);
                         }
                 }
         }
 
-
-        // ----------------------------------------------------------------------------------------------------
-        /* Checks if a subrule is used more then once, e.g.:
+// ----------------------------------------------------------------------------------------------------
+/* Checks if a subrule is used more then once, e.g.:
          * a ::= (a b) e
          * b ::= (a b) d