source: default/trunk/de.ugoe.cs.swe.bnftools.ebnf.generator/src/extensions/SimpleBnf.ext @ 60

import ebnf;
import emf;

create List transform(List s):
        this.addAll(s.typeSelect(EtsiBnf).createEtsiBnf())
;

create EtsiBnf createEtsiBnf(EtsiBnf bnf):
//      corebnf.addAll(bnf.corebnf)-> //TODO: checken, ob auskommentierung sinnvoll war
        extRule.addAll(bnf.extRule)->
        imports.addAll(bnf.imports)->
        mergeRule.addAll(bnf.mergeRule)->
//      package.addAll(bnf.package)-> //TODO: checken, ob auskommentierung sinnvoll war
        rule.addAll(bnf.rule.createRule(this))->
        setName(bnf.name)
;

create Rule createRule(Rule r, EtsiBnf bnf):
        setName(r.name)->
        r.definitionList.singleDefinition.size > 0 ? setDefinitionList(r.definitionList.createDefinitionList(bnf, this)) : null->
        setRulenumber(r.rulenumber)->
        setRulevariant(r.rulevariant)
;

create DefinitionList createDefinitionList(DefinitionList d, EtsiBnf bnf, Rule refRule):
        setSingleDefinition(d.singleDefinition.createSingleDefinition(bnf, refRule))
;

create SingleDefinition createSingleDefinition(SingleDefinition s, EtsiBnf bnf, Rule refRule):
        let termsList = {}:
        s.terms.processTerms(termsList, bnf, refRule)->
        setTerms(termsList)
;

create SingleDefinition createSingleDefinitionLeftRepetition(SingleDefinition s, Rule repeatRule, EtsiBnf bnf, Rule refRule, String id):
        let termsList = {}:
        termsList.add(createRuleReferenceTerm(repeatRule, id))->
        s.terms.processTerms(termsList, bnf, refRule)->
        setTerms(termsList)
;

create Atom createAtom(Atom a, EtsiBnf bnf, Rule refRule):
        a.atomStringRule != null ? setAtomStringRule(a.atomStringRule) : null->
        a.atomRuleReference != null ? setAtomRuleReference(a.atomRuleReference) : null
;

create GroupedSequence createGroupedSequence(GroupedSequence g, EtsiBnf bnf, Rule refRule):
        setDefinitionList(g.definitionList)
;

create OptionalSequence createOptionalSequence(OptionalSequence g, EtsiBnf bnf, Rule refRule):
        setDefinitionList(g.definitionList)
;

create RepeatedSequence createRepeatedSequence(RepeatedSequence r, EtsiBnf bnf, Rule refRule):
        setDefinitions(r.definitions)->
        setMorethanonce(r.morethanonce)
;

// ----------------------------------------------------------------------------------------------------
// non-create rules
// ----------------------------------------------------------------------------------------------------

Term processTerms(Term t, List termsList, EtsiBnf bnf, Rule refRule):
        let newTerm = new Term:
        t.termAtom != null ? newTerm.setTermAtom(t.termAtom.createAtom(bnf, refRule)) : null->
        t.termAtom != null ? termsList.add(newTerm) : null->
        t.termGroupedSequence != null ? processGroupedSequence(t.termGroupedSequence, bnf, refRule, termsList) : null->
        t.termOptionalSequence != null ? processOptionalSequence(t.termOptionalSequence, bnf, refRule, termsList) : null->
        t.termRepeatedSequence != null ? processRepeatedSequence(t.termRepeatedSequence, bnf, refRule, termsList) : null
;

GroupedSequence processGroupedSequence(GroupedSequence o, EtsiBnf bnf, Rule refRule, List termsList):
        listToHash(o.definitionList).existsRule() ? insertRuleReferenceInTermsList(getReplacementRule(refRule, o, bnf), termsList) : insertRuleReferenceInTermsList(addGroupedSequenceReplacementRule(refRule, o, bnf), termsList)
;

OptionalSequence processOptionalSequence(OptionalSequence o, EtsiBnf bnf, Rule refRule, List termsList):
        listToHash(o.definitionList).existsRule() ? insertRuleReferenceInTermsList(getReplacementRule(refRule, o, bnf), termsList) : insertRuleReferenceInTermsList(addOptionalSequenceReplacementRule(refRule, o, bnf), termsList)
;

OptionalSequence processRepeatedSequence(RepeatedSequence o, EtsiBnf bnf, Rule refRule, List termsList):
        listToHash(o.definitions).existsRule() ? insertRuleReferenceInTermsList(getReplacementRule(refRule, o, bnf), termsList) : insertRuleReferenceInTermsList(addRepeatedSequenceReplacementRule(refRule, o, bnf), termsList)
;

Rule getReplacementRule(Rule superRule, GroupedSequence o, EtsiBnf bnf):
        getRule(listToHash(o.definitionList))
;

Rule getReplacementRule(Rule superRule, OptionalSequence o, EtsiBnf bnf):
        getRule(listToHash(o.definitionList))
;

Rule getReplacementRule(Rule superRule, RepeatedSequence o, EtsiBnf bnf):
        getRule(listToHash(o.definitions))
;

Rule addRepeatedSequenceReplacementRule(Rule superRule, RepeatedSequence o, EtsiBnf bnf):
        let repetitionRule = addRepeatedSequenceReplacementRuleWithRepetition(superRule, o, bnf):
        let plainRule = addRepeatedSequenceReplacementRuleWithoutRepetition(superRule, o, bnf):
        let mainRule = addRepeatedSequenceReplacementRuleMain(superRule, plainRule, repetitionRule, o, bnf):
        let hashValue = listToHash(o.definitions):
        o.morethanonce ? addMoreThanOnceRepetitionRules(repetitionRule, plainRule, mainRule, bnf, hashValue): addNormalRepetitionRule(repetitionRule, bnf, hashValue)
;

Rule addNormalRepetitionRule(Rule repetitionRule, EtsiBnf bnf, String hashValue):
        bnf.rule.add(repetitionRule)->
        storeRule(hashValue, repetitionRule)->
        repetitionRule
;

Rule addMoreThanOnceRepetitionRules(Rule repetitionRule, Rule plainRule, Rule mainRule, EtsiBnf bnf, String hashValue):
        bnf.rule.add(repetitionRule)->
        bnf.rule.add(plainRule)->
        bnf.rule.add(mainRule)->
        storeRule(hashValue, mainRule)->
        mainRule
;

create Rule addRepeatedSequenceReplacementRuleWithRepetition(Rule superRule, RepeatedSequence o, EtsiBnf bnf):
        let emptySingleDefinition = new SingleDefinition:
        let newDefinitionList = new DefinitionList:
        let singleDefinitions = {}:
        let hashValue = listToHash(o.definitions):
        let rsCopy = new RepeatedSequence:
        rsCopy.setDefinitions(copyEObjectList(o.definitions))->
        rsCopy.setMorethanonce(o.morethanonce)->
        setName(superRule.name + "_gen_" + hashValue + "_rep")->
        singleDefinitions.addAll(rsCopy.definitions.singleDefinition.createSingleDefinitionLeftRepetition(this, bnf, superRule, this.name))->
        singleDefinitions.add(emptySingleDefinition)->
        newDefinitionList.setSingleDefinition(singleDefinitions)->
        setDefinitionList(newDefinitionList)
;

create Rule addRepeatedSequenceReplacementRuleWithoutRepetition(Rule superRule, RepeatedSequence o, EtsiBnf bnf):
        let singleDefinitions = {}:
        let newDefinitionList = new DefinitionList:
        let hashValue = listToHash(o.definitions):
        let rsCopy = new RepeatedSequence:
        rsCopy.setDefinitions(copyEObjectList(o.definitions))->
        rsCopy.setMorethanonce(o.morethanonce)->
        setName(superRule.name + "_gen_" + hashValue + "_plain")->
        singleDefinitions.addAll(rsCopy.definitions.singleDefinition.createSingleDefinition(bnf, superRule))->
        newDefinitionList.setSingleDefinition(singleDefinitions)->
        setDefinitionList(newDefinitionList)
;

create Rule this addRepeatedSequenceReplacementRuleMain(Rule superRule, Rule plainRule, Rule repetitionRule, RepeatedSequence o, EtsiBnf bnf):
        let newDefinitionList = new DefinitionList:
        let singleDefinitionList = {}:
        let singleDefinition = new SingleDefinition:
        let definitionsList = {}:
        let hashValue = listToHash(o.definitions):
        this.setName(superRule.name + "_gen_" + hashValue + "_main")->
        singleDefinition.terms.add(plainRule.createRuleReferenceTerm(this.name))->
        singleDefinition.terms.add(repetitionRule.createRuleReferenceTerm(this.name))->
        newDefinitionList.singleDefinition.add(singleDefinition)->      
        this.setDefinitionList(newDefinitionList)       
;

create Term this createRuleReferenceTerm(Rule rule, String id):
        let newAtom = new Atom:
        let newRuleReference = new RuleReference:
        newRuleReference.setRuleref(rule)->
        newAtom.setAtomRuleReference(newRuleReference)->
        this.setTermAtom(newAtom)       
;

create SingleDefinition createRuleReferenceSingleDefinition(Rule rule, String id):
        let newTerms = {}:
        newTerms.add(createRuleReferenceTerm(rule, id))->
        setTerms(newTerms)      
;

create Rule addGroupedSequenceReplacementRule(Rule superRule, GroupedSequence o, EtsiBnf bnf):
        let newDefinitionList = new DefinitionList:
        let singleDefinitions = {}:
        let hashValue = listToHash(o.definitionList):
        setName(superRule.name + "_gen_" + hashValue + "_group")->
        singleDefinitions.addAll(o.definitionList.singleDefinition.createSingleDefinition(bnf, superRule))->
        newDefinitionList.setSingleDefinition(singleDefinitions)->
        setDefinitionList(newDefinitionList)->  
        storeRule(hashValue, this)->
        bnf.rule.add(this)
;

create Rule addOptionalSequenceReplacementRule(Rule superRule, OptionalSequence o, EtsiBnf bnf):
        let newDefinitionList = new DefinitionList:
        let emptySingleDefinition = new SingleDefinition:
        let singleDefinitions = {}:
        let hashValue = listToHash(o.definitionList):
        setName(superRule.name + "_gen_" + hashValue + "_opt")->
        singleDefinitions.addAll(o.definitionList.singleDefinition.createSingleDefinition(bnf, superRule))->
        singleDefinitions.add(emptySingleDefinition)->
        newDefinitionList.setSingleDefinition(singleDefinitions)->
        setDefinitionList(newDefinitionList)->  
        storeRule(hashValue, this)->
        bnf.rule.add(this)
;

Void insertRuleReferenceInTermsList(Rule refRule, List termsList):
        let newTerm = new Term: 
        let newRuleRef = new RuleReference:
        let newAtom = new Atom: 
        newRuleRef.setRuleref(refRule)->
        newAtom.setAtomRuleReference(newRuleRef)->
        newTerm.setTermAtom(newAtom)->
        termsList.add(newTerm)
;

// ----------------------------------------------------------------------------------------------------
// Java Extensions
// ----------------------------------------------------------------------------------------------------

Void dump(String s):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.dump(java.lang.String)
;

String definitionListToString(DefinitionList l):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.definitionListToString(de.ugoe.cs.swe.bnftools.ebnf.DefinitionList)
;

String listToString(List l):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.listToString(java.util.List)
;

String listToString(EObject l):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.eobjectToString(org.eclipse.emf.ecore.EObject)
;

String listToHash(List l):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.listToHash(java.util.List)
;

Void storeRule(String k, Rule r):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.storeRule(java.lang.String, de.ugoe.cs.swe.bnftools.ebnf.Rule)
;

Boolean existsRule(String s):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.existsRule(java.lang.String)
;

Rule getRule(String s):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.getRule(java.lang.String)
;

EObject copyEObject(EObject o):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.copyEObject(org.eclipse.emf.ecore.EObject)
;

List copyEObjectList(List l):
        JAVA de.ugoe.cs.swe.bnftools.ebnf.javaextensions.SimpleBNFHelper.copyEObjectList(java.util.List)
;

// ----------------------------------------------------------------------------------------------------
// duplication rules
// ----------------------------------------------------------------------------------------------------

create DefinitionList duplicateDefinitionList(DefinitionList d, EtsiBnf bnf, Rule refRule):
        setSingleDefinition(d.singleDefinition.duplicateSingleDefinition(bnf, refRule))
;

create SingleDefinition duplicateSingleDefinition(SingleDefinition s, EtsiBnf bnf, Rule refRule):
        setTerms(s.terms.duplicateTerms(bnf, refRule))
;

create Term duplicateTerms(Term t, EtsiBnf bnf, Rule refRule):
        t.termAtom != null ? setTermAtom(t.termAtom.duplicateAtom(bnf, refRule)) : null->
        t.termGroupedSequence != null ? setTermGroupedSequence(t.termGroupedSequence.duplicateGroupedSequence(bnf, refRule)) : null->
        t.termOptionalSequence != null ? setTermOptionalSequence(t.termOptionalSequence.duplicateOptionalSequence(bnf, refRule)) : null->
        t.termRepeatedSequence != null ? setTermRepeatedSequence(t.termRepeatedSequence.duplicateRepeatedSequence(bnf, refRule)) : null
;

create GroupedSequence duplicateGroupedSequence(GroupedSequence g, EtsiBnf bnf, Rule refRule):
        setDefinitionList(g.definitionList)
;

create OptionalSequence duplicateOptionalSequence(OptionalSequence g, EtsiBnf bnf, Rule refRule):
        setDefinitionList(g.definitionList)
;

create RepeatedSequence duplicateRepeatedSequence(RepeatedSequence r, EtsiBnf bnf, Rule refRule):
        setDefinitions(r.definitions)->
        setMorethanonce(r.morethanonce)
;

create Atom duplicateAtom(Atom a, EtsiBnf bnf, Rule refRule):
        a.atomStringRule != null ? setAtomStringRule(a.atomStringRule) : null->
        a.atomRuleReference != null ? setAtomRuleReference(a.atomRuleReference) : null
;

// ----------------------------------------------------------------------------------------------------
// Extensions for templates
// ----------------------------------------------------------------------------------------------------

Rule firstNonGeneratedRule(EtsiBnf bnf):
        bnf.rule.selectFirst(e|!e.name.contains("_gen_") )
;