source: default/v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.xtend @ 61

/*
 * generated by Xtext
 */
package de.ugoe.cs.swe.bnftools.validation

import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage
import java.util.List
import org.eclipse.xtext.validation.Check
import de.ugoe.cs.swe.bnftools.ebnf.Rule
import org.eclipse.xtext.nodemodel.util.NodeModelUtils
import org.eclipse.xtext.nodemodel.ICompositeNode
import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf
import de.ugoe.cs.swe.bnftools.ebnf.RuleReference
import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList
import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition
//import java.util.HashMap
//import java.util.Set
//import java.util.HashSet

//import org.eclipse.xtext.validation.Check
/**
 * Custom validation rules. 
 *
 * see http://www.eclipse.org/Xtext/documentation.html#validation
 */
class EbnfValidator extends AbstractEbnfValidator {

        static final String ruleReferencedOneDescription = "The rule is only referenced by one other rule";
        static final String passthroughRuleDescription = "The rule is a passthrough rule";
        static final String unreferencedPassthroughRuleDescription = "The rule is an unreferenced passthrough rule";
        static final String unusedRuleDescription = "The rule is not referenced anywhere";
        static final String equalAlternativeDescription = "The rule contains equal alternatives";
        static final String duplicateRulesDescription = "The rule is a duplicate";
        //       static final String duplicateSubRulesDescription = "A part the of rule is a duplicate";
        static final String nonUniqueNameDescription = "The rule has the same Name as the Rule in Line ";

        // ----------------------------------------------------------------------------------------------------
        /* Checks if a rule is only referenced by one other Rule, e.g.:
                 * a ::= b
                 * b ::= "foo"
                 */
        @Check
        def void checkReferencedOnlyOnce(Rule rule) {

                if (EbnfAnalysisUtils.isTokenRule(rule))
                        return;

                var List<RuleReference> references = EbnfAnalysisUtils.findReferences(rule);

                if (references.size() == 1 && rule.rulenumber != 1) {
                        warning(ruleReferencedOneDescription, EbnfPackage$Literals::RULE__NAME);
                }
        }

        // ----------------------------------------------------------------------------------------------------
        /*Checks if a a rule has the same definition as another rule e.g.:
         * a ::= "test"
         * b ::= "test"
         * (Problem: does not check if there is a permutation)
         */
        @Check
        def void checkDuplicateRules(Rule rule) {

                //load bnf
                var EtsiBnf etsiBnf = rule.eContainer().eContainer() as EtsiBnf;

                // find the rule in the parsetree
                var ICompositeNode definitionList = NodeModelUtils.findActualNodeFor(rule.getDefinitionList());

                //get the definitionList as  formatted string
                var String rightHandSideText = definitionList.text.trim().replaceAll("[ \t\n\r]", "");

                //get All Rules
                var List<Rule> allRules = EbnfAnalysisUtils.getAllRules(etsiBnf);

                // 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);
                                }
                        }
                }
        }

        // ----------------------------------------------------------------------------------------------------
        /*Checks if a Rule got the same Name as another Rule, e.g.:
         * a ::= "foo"
         * a ::= "bar"
         */
        @Check
        def void checkNameIsUnique(Rule rule) {
                val EtsiBnf bnf = rule.eContainer.eContainer as EtsiBnf;
                for (r : EbnfAnalysisUtils.getAllRules(bnf)) {
                        if (rule.name.equals(r.name)) {
                                if (!r.equals(rule)) {
                                        error(nonUniqueNameDescription + NodeModelUtils.findActualNodeFor(r).startLine,
                                                EbnfPackage$Literals::RULE__NAME)

                                }
                        }
                }
        }

        // ----------------------------------------------------------------------------------------------------
        /*Checks if a Rule, except for the #1 is not referenced, e.g.:
         * a::= b
         * b::="foo"
         * c ::= "bar"
         */
        @Check
        def void checkUnusedRule(Rule rule) {

                var List<RuleReference> references = EbnfAnalysisUtils.findReferences(rule);

                if ((references.size() == 0) && (rule.getRulenumber() != 1))
                        warning(unusedRuleDescription, EbnfPackage$Literals::RULE__NAME);
        }

        // ----------------------------------------------------------------------------------------------------
        /*Checks if a rule got two equal alternatives, e.g.:
         * a ::= b | "foo" | b
         *(Problem:ignores whitespaces in literals)
         */
        @Check
        def void checkEqualAlternative(Rule rule) {

                var DefinitionList definitionList = rule.definitionList;

                var List<SingleDefinition> singleDefinitions = definitionList.singleDefinition;

                for (sDef1 : singleDefinitions) {
                        for (sDef2 : singleDefinitions) {
                                if (!sDef1.equals(sDef2)) {
                                        var String d1 = NodeModelUtils.findActualNodeFor(sDef1).text.trim.replaceAll("[ \t\n\r]", "");
                                        var String d2 = NodeModelUtils.findActualNodeFor(sDef2).text.trim.replaceAll("[ \t\n\r]", "");

                                        if (d1.equals(d2))
                                                warning(equalAlternativeDescription, EbnfPackage$Literals::RULE__NAME,equalAlternativeDescription);
                                }
                        }
                }

        }

        // ----------------------------------------------------------------------------------------------------
        /* Checks if a rule gets just passed through, e.g.:
         * a ::= b | "literal"
         * b ::= c 
         * c ::= "foo.bar"
         */
        @Check
        def void checkPassthroughRule(Rule rule) {

                var List<RuleReference> references = EbnfAnalysisUtils.findReferences(rule);

                if (EbnfAnalysisUtils.isPassthroughRule(rule)) {
                        if (references.size() == 0) {
                                warning(unreferencedPassthroughRuleDescription, EbnfPackage$Literals::RULE__NAME);
                        } else {
                                warning(passthroughRuleDescription, EbnfPackage$Literals::RULE__NAME,passthroughRuleDescription);
                        }
                }
        }


        // ----------------------------------------------------------------------------------------------------
        /* Checks if a subrule is used more then once, e.g.:
         * a ::= (a b) e
         * b ::= (a b) d
         *       _____
         * (Not working, under construction)
         */
//      @Check
//      def void checkSubruleDuplicates(EtsiBnf bnf){
//              var HashMap<String, DuplicateEntry> dupesMap = new HashMap<String, DuplicateEntry>();
//              var Set<String> taggedEntries = new HashSet<String>();
//              
//              var List<Rule> allRules = EbnfAnalysisUtils.getAllRules(bnf);
//              
//              for(rule: allRules){
//                      var List<SingleDefinition> subrules = rule.definitionList.singleDefinition
//                      for(subrule:subrules){
//                              var String subruleText = NodeModelUtils.findActualNodeFor(subrule).text.trim.replaceAll("[ \t\n\r]", "");
//                              
//                      }
//              }
//      }
}