| --@atlcompiler atl2006 |
| |
| --/******************************************************************************* |
| -- * Copyright (c) 2009 Ecole des Mines de Nantes. |
| |
| -- * All rights reserved. This program and the accompanying materials |
| -- * are made available under the terms of the Eclipse Public License v2.0 |
| -- * which accompanies this distribution, and is available at |
| -- * https://www.eclipse.org/legal/epl-2.0/ |
| -- * |
| -- * Contributors: |
| -- * Kelly Garces - initial implementation and/or initial documentation |
| -- *******************************************************************************/ |
| |
| module AML2ATL; -- Module Template |
| create OUT : ATL from IN : AML; |
| |
| uses AMLLibrary; |
| |
| |
| helper context AML!LocatedElement def: summationContainer : AML!SummationExp = |
| if self.refImmediateComposite().oclIsUndefined() or |
| self.refImmediateComposite().oclIsTypeOf(AML!SummationExp) then |
| self.refImmediateComposite() |
| else |
| self.refImmediateComposite().summationContainer |
| endif; |
| |
| helper context AML!LocatedElement def: isSummationContainer : Boolean = |
| if self.summationContainer.oclIsUndefined() then |
| false |
| else |
| true |
| endif; |
| |
| helper def: seqAsTuples (seq : OrderedSet(OclAny)) : OrderedSet(TupleType(first : OclAny, second : OclAny)) = |
| if seq.isEmpty() then |
| OrderedSet{} |
| else |
| if seq.size() = 1 then |
| OrderedSet{Tuple {first = seq->at(1), |
| second = OclUndefined}} |
| else |
| if seq.size() = 2 then |
| OrderedSet{Tuple {first = seq->at(1), |
| second = seq->at(2)}} |
| else |
| OrderedSet{Tuple {first = seq->at(1), |
| second = seq->at(2)}} |
| ->including(thisModule.seqAsTuples(seq.excluding(seq.at(1)).excluding(seq.at(2)))) |
| endif |
| endif |
| endif; |
| |
| helper def : seqAsTuplesFlatten (seq : OrderedSet(OclAny)) : OrderedSet(TupleType (first : OclAny, second : OclAny)) = |
| thisModule.seqAsTuples(seq)->flatten(); |
| |
| -- this method takes all the arguments corresponding to equal models and arranges them in pairs |
| helper context AML!MethodCall def : inputEqualModelTuples : OrderedSet(TupleType(first : AML!ModelFlowExpression, second : AML!ModelFlowExpression)) = |
| self.equalModelArgs->iterate(e; acc : OclAny = Tuple {previous = OclUndefined, ret = OrderedSet {}} | |
| Tuple { |
| previous = e, |
| ret = |
| if acc.previous.oclIsUndefined() then |
| acc.ret |
| else |
| acc.ret->including(Tuple {first = acc.previous, second = e}) |
| endif |
| } |
| ).ret; |
| |
| |
| helper context AML!MethodCall def : asTuples : OrderedSet(TupleType (first : AML!ModelFlowExpression, second : AML!ModelFlowExpression)) = |
| thisModule.seqAsTuplesFlatten(self.equalModelArgs); |
| |
| |
| -- extracts NavExp with source ThisNodeExp and contained by a method self |
| helper context AML!MethodCall def : methodThisNodeExp : OrderedSet(AML!NavigationOrAttributeCallExp) = |
| AML!NavigationOrAttributeCallExp.allInstances() |
| ->select(e | if e.source.oclIsKindOf(AML!ThisNodeExp) then |
| --if e.inPatternSimRVDContainer().oclIsTypeOf(AML!InPattern) then |
| if e.inPatternSimRVDContainer().method = self.method then |
| true |
| else |
| false |
| endif |
| --else |
| --false |
| --endif |
| else |
| false |
| endif); |
| |
| helper context AML!MethodCall def : navExpThisNodeAsTuples : OrderedSet(TupleType (first : AML!NavigationOrAttributeCallExp, second : AML!NavigationOrAttributeCallExp)) = |
| thisModule.seqAsTuplesFlatten(self.methodThisNodeExp); |
| |
| -- defines SIP type of creation matching strategies |
| helper def : mapCreationSIPType : Map(String, String) = |
| Map { |
| (thisModule.KM3(), 'ModelElement'), |
| (thisModule.Ecore(), 'EModelElement') |
| } |
| ; |
| |
| rule InputModel { |
| from |
| m : AML!MethodCall, |
| tm : AML!InputModel |
| ( |
| m.method.arguments.includes(tm) |
| ) |
| to |
| sm : ATL!OclModel ( |
| name <- tm.name, |
| metamodel <- Tuple{tm=m, s=tm.referenceModel} |
| ) |
| } |
| |
| rule MappingModel { |
| from |
| m : AML!MethodCall, |
| tm : AML!MappingModel |
| ( |
| m.method.arguments.includes(tm) |
| ) |
| to |
| sm : ATL!OclModel ( |
| name <- tm.name, |
| metamodel <- equalMetamodel |
| ), |
| equalMetamodel : ATL!OclModel ( |
| name <- thisModule.equalMetamodelName |
| ) |
| } |
| |
| rule WeavingModel { |
| from |
| m : AML!MethodCall, |
| tm : AML!WeavingModel |
| ( |
| m.method.arguments.includes(tm) |
| ) |
| to |
| sm : ATL!OclModel ( |
| name <- tm.name, |
| metamodel <- Tuple {tm = m, s= tm.referenceModel} |
| ) |
| } |
| |
| unique |
| lazy abstract rule ModelFlowExpSIP { |
| from |
| tm : AML!ModelFlowExpression |
| to |
| equalSIP : ATL!SimpleInPatternElement ( |
| models <- OrderedSet {thisModule.ModelFlowExpModel(tm)}, |
| type <- thisEqualType |
| ), |
| thisEqualType : ATL!OclModelElement ( |
| model <- thisModule.ModelFlowExpModel_equalMetamodel(tm), |
| name <- 'Equal' |
| ) |
| |
| } |
| |
| lazy rule ModelFlowExpModel_equalMetamodel { |
| from |
| tm : AML!ModelFlowExpression |
| to |
| equalMetamodel : ATL!OclModel ( |
| name <- thisModule.equalMetamodelName |
| ) |
| } |
| |
| unique |
| lazy rule MappingModelSIP extends ModelFlowExpSIP { |
| from |
| tm : AML!MappingModelRefExp |
| to |
| equalSIP : ATL!SimpleInPatternElement ( |
| varName <- tm.referredMappingModel.name + 'Var' |
| ) |
| } |
| |
| unique |
| lazy rule MethodCallExpSIP extends ModelFlowExpSIP { |
| from |
| tm : AML!MethodCall |
| to |
| equalSIP : ATL!SimpleInPatternElement ( |
| varName <- tm.method.name + 'Var' |
| ) |
| } |
| |
| unique |
| lazy rule WeightedModelExpSIP extends ModelFlowExpSIP { |
| from |
| tm : AML!WeightedModelExp |
| to |
| equalSIP : ATL!SimpleInPatternElement ( |
| varName <- tm.modelFlowName() + 'Var' |
| ) |
| } |
| |
| unique |
| lazy abstract rule ModelFlowExpModel { |
| from |
| tm : AML!ModelFlowExpression |
| to |
| equalModel : ATL!OclModel( |
| metamodel <- equalMetamodel |
| ), |
| equalMetamodel : ATL!OclModel ( |
| name <- thisModule.equalMetamodelName |
| ) |
| } |
| |
| unique |
| lazy rule MappingModelExp extends ModelFlowExpModel { |
| from |
| tm : AML!MappingModelRefExp |
| to |
| equalModel : ATL!OclModel( |
| name <- tm.referredMappingModel.name --+ 'Equal' |
| ) |
| } |
| |
| unique |
| lazy rule MethodCallExpModel extends ModelFlowExpModel { |
| from |
| tm : AML!MethodCall |
| to |
| equalModel : ATL!OclModel( |
| name <- tm.method.name --+ 'Equal' |
| ) |
| } |
| |
| unique |
| lazy rule WeightedModelExpSIP extends ModelFlowExpModel { |
| from |
| tm : AML!WeightedModelExp |
| to |
| equalModel : ATL!OclModel( |
| name <- tm.modelFlowName() |
| ) |
| } |
| |
| rule LibraryRef { |
| from |
| m : AML!MethodCall, |
| s : AML!ATLLibraryRef ( |
| m.method = s.method |
| ) |
| to |
| t : ATL!LibraryRef ( |
| name <- s.name |
| --, |
| --unit <- m |
| ) |
| } |
| |
| lazy rule ModelFromRef { |
| from |
| tm : AML!MethodCall, |
| s : AML!InputModel |
| to |
| |
| leftModel : ATL!OclModel ( |
| name <- s.name, |
| metamodel <- thisModule.ReferenceModelOfInputModel(tm, s.referenceModel) |
| ) |
| } |
| |
| lazy rule ReferenceModelOfInputModel { |
| from |
| tm : AML!MethodCall, |
| s : AML!ReferenceModel |
| to |
| |
| leftModel : ATL!OclModel ( |
| name <- s.defRefModel.name |
| ) |
| } |
| |
| rule MethodCall { |
| from |
| tm : AML!MethodCall |
| ( |
| not tm.method.inPattern.oclIsUndefined() |
| ) |
| to |
| m : ATL!Module ( |
| commentsBefore <- Set {'-- @atlcompiler atl2006'}, |
| name <- tm.method.name + tm.ID, -- Ask how to get only the class name |
| isRefining <- false, |
| inModels <- tm.method.arguments->collect(e | Tuple{m=tm, tm=e}) |
| -- add ModelRef of weaving models |
| -> union (tm.methodWovenModels->collect(e | thisModule.ModelFromRef(tm, e))) |
| |
| -> union (tm.mappingModelAsArguments->collect(e | thisModule.ModelFromRef(tm, tm.method.matcher.mapMappingRefModel().get(e).leftModel))) |
| -> union (tm.mappingModelAsArguments->collect(e | thisModule.ModelFromRef(tm, tm.method.matcher.mapMappingRefModel().get(e).rightModel))) |
| |
| -> union (tm.equalModelArgs->collect(e | thisModule.ModelFlowExpModel(e))) |
| -> union (tm.equalModelArgs->collect(e | thisModule.ModelFromRef(tm, tm.method.matcher.mapMappingRefModel().get(e).leftModel))) |
| -> union (tm.equalModelArgs->collect(e | thisModule.ModelFromRef(tm, tm.method.matcher.mapMappingRefModel().get(e).rightModel))) |
| , |
| outModels <- OrderedSet{outModel}, |
| elements <- OrderedSet{t2, matchModelMR, modelRefMR, leftElementMR, rightElementMR, ElementRefMR}, |
| libraries <- OrderedSet{equalLibrary, mmmLibrary, custom_mmmLibrary} |
| ->union(tm.method.ATLLibraries->collect(e | Tuple{m = tm, s = e})) |
| ), |
| |
| outModel : ATL!OclModel ( |
| name <- tm.method.name + 'Equal', |
| metamodel <- equalMetamodel |
| ), |
| |
| equalMetamodel : ATL!OclModel ( |
| name <- thisModule.equalMetamodelName |
| ), |
| |
| metametamodel : ATL!OclModel ( |
| name <- thisModule.metametamodelName |
| ), |
| |
| -- libraries |
| equalLibrary : ATL!LibraryRef( |
| name <- thisModule.equalMetamodelName |
| ), |
| mmmLibrary : ATL!LibraryRef( |
| name <- thisModule.metametamodelName |
| ), |
| custom_mmmLibrary : ATL!LibraryRef( |
| name <- thisModule.metametamodelLibName --thisModule.mapMetametamodelName.get(tm.method.matcher.metametamodel()).displayedName |
| ), |
| |
| -- main matched rule |
| t2 : ATL!MatchedRule ( |
| isAbstract <- false, |
| isRefining <- false, |
| name <- tm.method.oclType().name + tm.method.name, |
| superRule <- OclUndefined, |
| inPattern <- inPattern, |
| outPattern <- outPattern, |
| variables <- tm.method.variables->collect(e | Tuple{m=tm, s=e}) --TODO the variables can have primitypes types |
| ), |
| |
| inPattern : ATL!InPattern ( |
| elements <- tm.equalModelArgs->collect(e | thisModule.ModelFlowExpSIP(e)) |
| ->union (tm.method.inPattern.elements->collect(e | Tuple{m=tm, s=e})), |
| filter <- -- inPattern or simExp includes thisNodeExp and then it is necessary add a condition |
| -- validating nodesByName is not OclUndefined |
| -- if tm.navExpThisNodeAsTuples.notEmpty() then |
| -- thisModule.createCondition(tm) |
| -- else |
| if tm.method.inPattern.filter.oclIsUndefined() then |
| OclUndefined |
| else |
| Tuple {m = tm, s = tm.method.inPattern.filter} |
| endif |
| -- endif |
| ), |
| |
| outPattern : ATL!OutPattern ( |
| elements <- OrderedSet {sop} |
| ), |
| sop : ATL!SimpleOutPatternElement ( |
| varName <- 'e', |
| type <- equalType, |
| bindings <- OrderedSet{eName, eLeftB, eRightB, eSimB, eModelB} --,eNameB, |
| ), |
| equalType : ATL!OclModelElement ( |
| model <- equalMetamodel, |
| name <- 'Equal' |
| ), |
| |
| eModelB : ATL!Binding ( |
| propertyName <- 'model',--We need to create a entrypoint rule creating the model containing equal elements |
| value <- eModelBValue |
| ), |
| eModelBValue : ATL!OperationCallExp ( |
| operationName <- 'equalModel', |
| source <- eModelBVE, |
| arguments <- modelNameSE |
| ), |
| eModelBVE : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| thisModuleVar : ATL!VariableDeclaration ( |
| varName <- 'thisModule' |
| ), |
| |
| modelNameSE : ATL!StringExp( |
| stringSymbol <- thisModule.ModelFlowExpSIP(tm.equalModelArgs.first()).models->first().name |
| ), |
| |
| eLeftB : ATL!Binding ( |
| propertyName <- 'left' |
| , |
| value <- eLeftBValue |
| ), |
| eLeftBValue : ATL!NavigationOrAttributeCallExp ( |
| name <- 'left', |
| source <- eLeftBVE |
| ), |
| eLeftBVE : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(tm.equalModelArgs.first()) |
| ), |
| eRightB : ATL!Binding ( |
| propertyName <- 'right', |
| value <- eRightBValue |
| ) |
| , |
| eRightBValue : ATL!NavigationOrAttributeCallExp ( |
| name <- 'right', |
| source <- eRightBVE |
| ), |
| eRightBVE : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(tm.equalModelArgs.first()) |
| ), |
| eSimB : ATL!Binding ( |
| propertyName <- 'similarity' |
| ), |
| eName : ATL!Binding ( |
| propertyName <- 'name', |
| value <- eNameNA |
| ), |
| eNameNA : ATL!NavigationOrAttributeCallExp ( |
| name <- 'name', |
| source <- eNameBVE |
| ), |
| eNameBVE : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(tm.equalModelArgs.first()) |
| ), |
| |
| -- complementary matched rules |
| |
| -- ojo falta colocarle un outputpattern que referencia a method, ver transfo Propagation linea 100 |
| matchModelMR : ATL!MatchedRule ( |
| name <- 'matchModel', |
| inPattern <- matchModelMRInPattern, |
| outPattern <- matchModelMROutPattern |
| ), |
| matchModelMRInPattern : ATL!InPattern ( |
| elements <- OrderedSet{matchModelMRSimpleInPattern} |
| ), |
| matchModelMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| varName <- 'mmw', |
| type <- matchModelMRSimpleInPatternType, |
| models <- if tm.equalModelArgs.notEmpty() then |
| OrderedSet {thisModule.ModelFlowExpModel(tm.equalModelArgs->first())} |
| else |
| OrderedSet{} |
| endif |
| ), |
| matchModelMRSimpleInPatternType : ATL!OclModelElement ( |
| name <- 'MatchModel', |
| model <- equalMetamodel |
| ), |
| matchModelMROutPattern : ATL!OutPattern ( |
| elements <- OrderedSet{matchModelMRSimpleOutPattern} |
| ), |
| matchModelMRSimpleOutPattern : ATL!SimpleOutPatternElement ( |
| varName <- 'out', |
| type <- matchModelMRSimpleOutPatternType, |
| bindings <- OrderedSet {matchModelBName, matchModelBleftM, matchModelBrightM} |
| ), |
| matchModelMRSimpleOutPatternType : ATL!OclModelElement ( |
| name <- 'MatchModel', |
| model <- equalMetamodel |
| ), |
| matchModelBName : ATL!Binding ( |
| propertyName <- 'name', |
| value <- matchModelBNameV |
| ), |
| matchModelBNameV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'name', |
| source <- matchModelBNameVarExp |
| ), |
| matchModelBNameVarExp : ATL!VariableExp ( |
| referredVariable <- matchModelMRSimpleInPattern |
| ), |
| matchModelBleftM : ATL!Binding ( |
| propertyName <- 'leftM', |
| value <- matchModelBleftMV |
| ), |
| matchModelBleftMV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'leftM', |
| source <- matchModelBleftMVarExp |
| ), |
| matchModelBleftMVarExp : ATL!VariableExp ( |
| referredVariable <- matchModelMRSimpleInPattern |
| ), |
| matchModelBrightM : ATL!Binding ( |
| propertyName <- 'rightM', |
| value <- matchModelBrightMV |
| ), |
| matchModelBrightMV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'rightM', |
| source <- matchModelBrightMVarExp |
| ), |
| matchModelBrightMVarExp : ATL!VariableExp ( |
| referredVariable <- matchModelMRSimpleInPattern |
| ), |
| |
| modelRefMR : ATL!MatchedRule ( |
| name <- 'modelRef', |
| inPattern <- modelRefMRInPattern, |
| outPattern <- modelRefMROutPattern |
| ), |
| modelRefMRInPattern : ATL!InPattern ( |
| elements <- OrderedSet{modelRefMRSimpleInPattern} |
| ), |
| modelRefMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| varName <- 'mmw', |
| type <- modelRefMRSimpleInPatternType, |
| models <- if tm.equalModelArgs.notEmpty() then |
| OrderedSet {thisModule.ModelFlowExpModel(tm.equalModelArgs->first())} |
| else |
| OrderedSet{} |
| endif |
| ), |
| modelRefMRSimpleInPatternType : ATL!OclModelElement ( |
| name <- 'ModelRef', |
| model <- equalMetamodel |
| ), |
| modelRefMROutPattern : ATL!OutPattern ( |
| elements <- OrderedSet{modelRefMRSimpleOutPattern} |
| ), |
| modelRefMRSimpleOutPattern : ATL!SimpleOutPatternElement ( |
| varName <- 'out', |
| type <- modelRefMRSimpleOutPatternType, |
| bindings <- OrderedSet {modelRefBName, modelRefBRef} |
| ), |
| modelRefMRSimpleOutPatternType : ATL!OclModelElement ( |
| name <- 'ModelRef', |
| model <- equalMetamodel |
| ), |
| modelRefBName : ATL!Binding ( |
| propertyName <- 'name', |
| value <- modelRefBNameV |
| ), |
| modelRefBNameV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'name', |
| source <- modelRefBNameVarExp |
| ), |
| modelRefBNameVarExp : ATL!VariableExp ( |
| referredVariable <- modelRefMRSimpleInPattern |
| ), |
| modelRefBRef : ATL!Binding ( |
| propertyName <- 'ref', |
| value <- modelRefBRefV |
| ), |
| modelRefBRefV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'ref', |
| source <- modelRefBRefVarExp |
| ), |
| modelRefBRefVarExp : ATL!VariableExp ( |
| referredVariable <- modelRefMRSimpleInPattern |
| ), |
| |
| |
| leftElementMR : ATL!MatchedRule ( |
| name <- 'leftElement', |
| inPattern <- leftElementMRInPattern, |
| outPattern <- leftElementMROutPattern |
| ), |
| leftElementMRInPattern : ATL!InPattern ( |
| elements <- OrderedSet{leftElementMRSimpleInPattern} |
| ), |
| leftElementMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| varName <- 'mmw', |
| type <- leftElementMRSimpleInPatternType, |
| models <- if tm.equalModelArgs.notEmpty() then |
| OrderedSet {thisModule.ModelFlowExpModel(tm.equalModelArgs->first())} |
| else |
| OrderedSet{} |
| endif |
| ), |
| leftElementMRSimpleInPatternType : ATL!OclModelElement ( |
| name <- 'LeftElement', |
| model <- equalMetamodel |
| ), |
| leftElementMROutPattern : ATL!OutPattern ( |
| elements <- OrderedSet{leftElementMRSimpleOutPattern} |
| ), |
| leftElementMRSimpleOutPattern : ATL!SimpleOutPatternElement ( |
| varName <- 'out', |
| type <- leftElementMRSimpleOutPatternType, |
| bindings <- OrderedSet {leftElementBName, leftElementBElement} |
| ), |
| leftElementMRSimpleOutPatternType : ATL!OclModelElement ( |
| name <- 'LeftElement', |
| model <- equalMetamodel |
| ), |
| leftElementBName : ATL!Binding ( |
| propertyName <- 'name', |
| value <- leftElementBNameV |
| ), |
| leftElementBNameV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'name', |
| source <- leftElementBNameVarExp |
| ), |
| leftElementBNameVarExp : ATL!VariableExp ( |
| referredVariable <- leftElementMRSimpleInPattern |
| ), |
| leftElementBElement : ATL!Binding ( |
| propertyName <- 'element', |
| value <- leftElementBElementV |
| ), |
| leftElementBElementV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'element', |
| source <- leftElementBElementVarExp |
| ), |
| leftElementBElementVarExp : ATL!VariableExp ( |
| referredVariable <- leftElementMRSimpleInPattern |
| ) |
| , |
| |
| rightElementMR : ATL!MatchedRule ( |
| name <- 'rightElement', |
| inPattern <- rightElementMRInPattern, |
| outPattern <- rightElementMROutPattern |
| ), |
| rightElementMRInPattern : ATL!InPattern ( |
| elements <- OrderedSet{rightElementMRSimpleInPattern} |
| ), |
| rightElementMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| varName <- 'mmw', |
| type <- rightElementMRSimpleInPatternType, |
| models <- if tm.equalModelArgs.notEmpty() then |
| OrderedSet {thisModule.ModelFlowExpModel(tm.equalModelArgs->first())} |
| else |
| OrderedSet{} |
| endif |
| ), |
| rightElementMRSimpleInPatternType : ATL!OclModelElement ( |
| name <- 'RightElement', |
| model <- equalMetamodel |
| ), |
| rightElementMROutPattern : ATL!OutPattern ( |
| elements <- OrderedSet{rightElementMRSimpleOutPattern} |
| ), |
| rightElementMRSimpleOutPattern : ATL!SimpleOutPatternElement ( |
| varName <- 'out', |
| type <- rightElementMRSimpleOutPatternType, |
| bindings <- OrderedSet {rightElementBName, rightElementBElement} |
| ), |
| rightElementMRSimpleOutPatternType : ATL!OclModelElement ( |
| name <- 'RightElement', |
| model <- equalMetamodel |
| ), |
| rightElementBName : ATL!Binding ( |
| propertyName <- 'name', |
| value <- rightElementBNameV |
| ), |
| rightElementBNameV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'name', |
| source <- rightElementBNameVarExp |
| ), |
| rightElementBNameVarExp : ATL!VariableExp ( |
| referredVariable <- rightElementMRSimpleInPattern |
| ), |
| rightElementBElement : ATL!Binding ( |
| propertyName <- 'element', |
| value <- rightElementBElementV |
| ), |
| rightElementBElementV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'element', |
| source <- rightElementBElementVarExp |
| ), |
| rightElementBElementVarExp : ATL!VariableExp ( |
| referredVariable <- rightElementMRSimpleInPattern |
| ), |
| |
| ElementRefMR : ATL!MatchedRule ( |
| name <- 'ElementRef', |
| inPattern <- ElementRefMRInPattern, |
| outPattern <- ElementRefMROutPattern |
| ), |
| ElementRefMRInPattern : ATL!InPattern ( |
| elements <- OrderedSet{ElementRefMRSimpleInPattern} |
| ), |
| ElementRefMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| varName <- 'mmw', |
| type <- ElementRefMRSimpleInPatternType, |
| models <- if tm.equalModelArgs.notEmpty() then |
| OrderedSet {thisModule.ModelFlowExpModel(tm.equalModelArgs->first())} |
| else |
| OrderedSet{} |
| endif |
| ), |
| ElementRefMRSimpleInPatternType : ATL!OclModelElement ( |
| name <- 'ElementRef', |
| model <- equalMetamodel |
| ), |
| ElementRefMROutPattern : ATL!OutPattern ( |
| elements <- OrderedSet{ElementRefMRSimpleOutPattern} |
| ), |
| ElementRefMRSimpleOutPattern : ATL!SimpleOutPatternElement ( |
| varName <- 'out', |
| type <- ElementRefMRSimpleOutPatternType, |
| bindings <- OrderedSet {ElementRefBName, ElementRefBElement, ElementRefBModelRef} |
| ), |
| ElementRefMRSimpleOutPatternType : ATL!OclModelElement ( |
| name <- 'ElementRef', |
| model <- equalMetamodel |
| ), |
| ElementRefBName : ATL!Binding ( |
| propertyName <- 'name', |
| value <- ElementRefBNameV |
| ), |
| ElementRefBNameV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'name', |
| source <- ElementRefBNameVarExp |
| ), |
| ElementRefBNameVarExp : ATL!VariableExp ( |
| referredVariable <- ElementRefMRSimpleInPattern |
| ), |
| ElementRefBElement : ATL!Binding ( |
| propertyName <- 'ref', |
| value <- ElementRefBElementV |
| ), |
| ElementRefBElementV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'ref', |
| source <- ElementRefBElementVarExp |
| ), |
| ElementRefBElementVarExp : ATL!VariableExp ( |
| referredVariable <- ElementRefMRSimpleInPattern |
| ), |
| ElementRefBModelRef : ATL!Binding ( |
| propertyName <- 'modelRef', |
| value <- ElementRefBModelRefV |
| ), |
| ElementRefBModelRefV : ATL!NavigationOrAttributeCallExp ( |
| name <- 'modelRef', |
| source <- ElementRefBModelRefVarExp |
| ), |
| ElementRefBModelRefVarExp : ATL!VariableExp ( |
| referredVariable <- ElementRefMRSimpleInPattern |
| ) |
| } |
| |
| lazy rule createCondition { |
| from |
| tm : AML!MethodCall |
| using { |
| seq : OrderedSet(TupleType (first : AML!NavigationOrAttributeCallExp, second : AML!NavigationOrAttributeCallExp)) = |
| tm.navExpThisNodeAsTuples; |
| } |
| to |
| t : ATL!IfExp ( |
| condition <- if seq.size() = 1 then |
| thisModule.operationCall3(tm, seq.first().first, seq.first().second) |
| else |
| thisModule.operatorCall3(tm, seq) |
| endif, |
| thenExpression <- thenExpression, |
| elseExpression <- if tm.method.inPattern.filter.oclIsUndefined() then |
| thisModule.trueExp(tm) |
| else |
| Tuple {m = tm, s = tm.method.inPattern.filter} |
| endif |
| ), |
| thenExpression : ATL!BooleanExp( |
| booleanSymbol <- false |
| ) |
| } |
| |
| rule ReferenceModel2OclModel { |
| from |
| tm : AML!MethodCall, |
| s : AML!ReferenceModel |
| to |
| t : ATL!OclModel ( |
| name <- s.name, |
| elements <- s.elements->collect(e | Tuple{m = tm, s = e}) |
| --, |
| --model <- s.models |
| ) |
| } |
| |
| |
| |
| rule AggrEqual extends MethodCall { -- TODO implements the merging operator. We have already implemented a merging version by using the aggr operator, howver this could not work when the mapping models to merge contain a common mapping, this would be stored once instead of twice |
| from |
| tm : AML!MethodCall ( |
| tm.method.oclIsTypeOf(AML!AggrEqual) |
| ) |
| using { |
| equalInPattern2 : ATL!SimpleInPatternElement = thisModule.ModelFlowExpSIP(tm.equalModelArgs.first()); |
| } |
| to |
| m : ATL!Module( |
| elements <- OrderedSet{t2, matchModelMR, modelRefMR, leftElementMR, rightElementMR, ElementRefMR, helperMapWeights} |
| ), |
| inPattern : ATL!InPattern ( |
| elements <- OrderedSet{equalInPattern}, |
| filter <- filterAggr |
| ), |
| |
| equalInPattern : ATL!SimpleInPatternElement ( |
| varName <- equalInPattern2.varName, |
| type <- equalInPatternType |
| ), |
| equalInPatternType : ATL!OclModelElement ( |
| name <- 'Equal', |
| model <- equalMetamodel |
| ), |
| |
| filterAggr : ATL!OperatorCallExp ( |
| operationName <- '=', |
| source <- oGet, |
| arguments <- equalIPVE |
| ), |
| equalIPVE : ATL!VariableExp ( |
| referredVariable <- equalInPattern |
| ), |
| oGet : ATL!OperationCallExp ( |
| operationName <- 'get', |
| source <- navMap, |
| arguments <- navXMIID |
| ), |
| navMap : ATL!NavigationOrAttributeCallExp ( |
| name <- 'map', |
| source <- navMapVE |
| ), |
| navMapVE : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| navXMIID : ATL!NavigationOrAttributeCallExp ( |
| name <- 'xmiIDs_Equal', |
| source <- navXMIIDVE |
| ), |
| navXMIIDVE : ATL!VariableExp ( |
| referredVariable <- equalInPattern |
| ), |
| |
| -- name, left and right taken from equalVar |
| |
| eNameBVE : ATL!VariableExp ( |
| referredVariable <- equalInPattern |
| ), |
| |
| eLeftBVE : ATL!VariableExp ( |
| referredVariable <- equalInPattern |
| ), |
| |
| eRightBVE : ATL!VariableExp ( |
| referredVariable <- equalInPattern |
| ), |
| |
| -- Calling lazy rules to initialize left and right |
| eLeftB : ATL!Binding ( |
| value <- eLeftBValueOC |
| ), |
| eLeftBValueOC : ATL!OperationCallExp ( |
| operationName <- 'leftElement', |
| source <- eLeftBValueOCVar, |
| arguments <- eLeftBValue |
| ), |
| eLeftBValueOCVar : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| eRightB : ATL!Binding ( |
| value <- eRightBValueOC |
| ), |
| eRightBValueOC : ATL!OperationCallExp ( |
| operationName <- 'rightElement', |
| source <- eRightBValueOCVar, |
| arguments <- eRightBValue |
| ), |
| eRightBValueOCVar : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| leftElementMR : ATL!LazyMatchedRule, |
| leftElementMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| models <- OrderedSet{} |
| ), |
| -- calling the lazy rule ElementRef |
| leftElementBElement : ATL!Binding ( |
| value <- leftElementBElementV2 |
| ), |
| leftElementBElementV2 : ATL!OperationCallExp ( |
| operationName <- 'ElementRef', |
| source <- leftElementBElementV2VE, |
| arguments <- leftElementBElementV |
| ), |
| leftElementBElementV2VE : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| rightElementMR : ATL!LazyMatchedRule, |
| rightElementMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| models <- OrderedSet{} |
| ), |
| -- calling the lazy rule ElementRef |
| rightElementBElement : ATL!Binding ( |
| value <- rightElementBElementV2 |
| ), |
| rightElementBElementV2 : ATL!OperationCallExp ( |
| operationName <- 'ElementRef', |
| source <- rightElementBElementV2VE, |
| arguments <- rightElementBElementV |
| ), |
| rightElementBElementV2VE : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| -- ElementRef is a lazy rule |
| ElementRefMR : ATL!LazyMatchedRule, |
| ElementRefMRSimpleInPattern : ATL!SimpleInPatternElement ( |
| models <- OrderedSet{} |
| ), |
| |
| -- calling a helper that links the ElementRef to the correct ModelRef |
| |
| ElementRefBModelRef : ATL!Binding ( |
| value <- ElementRefBModelRefV2 |
| ), |
| ElementRefBModelRefV2 : ATL!OperationCallExp ( |
| source <- ElementRefBModelRefVarExp2, |
| operationName <- 'getModelRef', |
| arguments <- getModelRefArgs |
| ), |
| getModelRefArgs : ATL!StringExp ( |
| stringSymbol <- thisModule.ModelFlowExpSIP(tm.equalModelArgs.first()).models->first().name |
| ), |
| ElementRefBModelRefVarExp2 : ATL!VariableExp ( |
| referredVariable <- ElementRefMRSimpleInPattern |
| ), |
| |
| eSimB : ATL!Binding ( |
| value <- Tuple{m=tm, s=tm.method.sim.value} |
| ), |
| |
| helperMapWeights : ATL!Helper ( |
| definition <- definition |
| ), |
| definition : ATL!OclFeatureDefinition ( |
| feature <- feature |
| ), |
| feature : ATL!Operation ( |
| name <- 'modelWeight', |
| returnType <- returnType, |
| body <- body |
| ), |
| returnType : ATL!MapType ( |
| valueType <- realType, |
| keyType <- matchModelType |
| ), |
| matchModelType : ATL!OclModelElement( |
| name <- 'MatchModel', |
| model <- equalMetamodel |
| ), |
| realType : ATL!RealType(), |
| body : ATL!MapExp ( |
| elements <- tm.equalModelArgs->collect(e | thisModule.createEntryMap(e)) |
| ) |
| -- do { |
| -- inPattern.elements.first().models <- OclUndefined; |
| -- } |
| |
| } |
| |
| rule summation { |
| from |
| m : AML!MethodCall, |
| s : AML!SummationExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!NavigationOrAttributeCallExp ( |
| name <- 'sum', |
| source <- equalVar |
| ), |
| equalVar : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(m.equalModelArgs.first()) |
| ), |
| "helper" : ATL!Helper ( |
| definition <- definition, |
| module <- m-- thisModule.resolveTemp(m, 'm') -- 'm' by module |
| ), |
| definition : ATL!OclFeatureDefinition( |
| feature <- feature, |
| context_ <- context_ |
| ), |
| |
| feature : ATL!Attribute( |
| name <- 'sum', |
| initExpression <- initExpression, |
| type <- featureType |
| ), |
| initExpression : ATL!IterateExp ( |
| source <- oGet, |
| body <- body, |
| result <- result, |
| iterators <- iteratorE |
| ), |
| selfVar : ATL!VariableDeclaration ( |
| varName <- 'self' |
| ), |
| oGet : ATL!OperationCallExp ( |
| operationName <- 'get', |
| source <- navMap, |
| arguments <- navXMIID |
| ), |
| navMap : ATL!NavigationOrAttributeCallExp ( |
| name <- 'mapEqual', |
| source <- navMapVE |
| ), |
| navMapVE : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| thisModuleVar : ATL!VariableDeclaration ( |
| varName <- 'thisModule' |
| ), |
| navXMIID : ATL!NavigationOrAttributeCallExp ( |
| name <- 'xmiIDs_Equal', |
| source <- navXMIIDVE |
| ), |
| navXMIIDVE : ATL!VariableExp ( |
| referredVariable <- selfVar |
| ), |
| body : ATL!OperatorCallExp ( |
| operationName <- '+', |
| source <- resultVarExp, |
| arguments <- Tuple{m = m, s=s.sumExpression} |
| ), |
| resultVarExp : ATL!VariableExp ( |
| referredVariable <- result |
| ), |
| iteratorE : ATL!Iterator ( |
| varName <- 'e' |
| |
| ), |
| result : ATL!VariableDeclaration ( |
| varName <- 'acc', |
| type <- type, |
| initExpression <- accInitExpression |
| ), |
| type : ATL!RealType, |
| accInitExpression : ATL!IntegerExp ( |
| integerSymbol <- 0 |
| ), |
| featureType : ATL!RealType, |
| context_ : ATL!OclContextDefinition ( |
| context_ <- oclContext |
| ), |
| oclContext : ATL!OclModelElement ( |
| name <- 'Equal', |
| model <- equalMetamodel |
| ), |
| equalMetamodel : ATL!OclModel ( |
| name <- thisModule.equalMetamodelName |
| ) |
| |
| } |
| |
| lazy rule createEntryMap { |
| from |
| wE : AML!WeightedModelExp |
| to |
| |
| t : ATL!MapElement ( |
| key <- key, |
| value <- value |
| ), |
| |
| key : ATL!OperationCallExp( |
| operationName <- 'equalModel', |
| source <- modelVarExp, |
| arguments <- modelName |
| ), |
| modelVarExp : ATL!VariableExp ( |
| referredVariable <- varThisModule |
| ), |
| varThisModule : ATL!VariableDeclaration ( |
| varName <- 'thisModule' |
| ), |
| |
| modelName : ATL!StringExp ( |
| stringSymbol <- wE.modelFlowName() |
| ), |
| |
| value : ATL!RealExp( |
| realSymbol <- wE.weight |
| ) |
| } |
| |
| rule operatorCall (tuples : OrderedSet(TupleType(first : AML!ModelFlowExpression, second : AML!ModelFlowExpression))) { |
| using { |
| tuple : TupleType(first : AML!ModelFlowExpression, second : AML!ModelFlowExpression) = tuples.first(); |
| tuplesNext : OrderedSet(TupleType(first : AML!ModelFlowExpression, second : AML!ModelFlowExpression)) |
| = tuples.excluding(tuple); |
| } |
| |
| to |
| t : ATL!OperatorCallExp ( |
| operationName <- 'and', |
| source <- if tuplesNext.size() > 1 then |
| thisModule.operatorCall(tuplesNext) |
| else |
| thisModule.operationCall(tuplesNext.first().first, tuplesNext.first().second) |
| endif, |
| arguments <- thisModule.operationCall(tuple.first, tuple.second) |
| ) |
| do { |
| t; |
| } |
| } |
| |
| rule operatorCall2 (oclExp : AML!OclExpression, tuples : OrderedSet(TupleType(first : AML!ModelFlowExpression, second : AML!ModelFlowExpression))) { |
| using { |
| tuple : TupleType(first : AML!ModelFlowExpression, second : AML!ModelFlowExpression) = tuples.first(); |
| tuplesNext : OrderedSet(TupleType(first : AML!ModelFlowExpression, second : AML!ModelFlowExpression)) |
| = tuples.excluding(tuple); |
| } |
| |
| to |
| t : ATL!OperatorCallExp ( |
| operationName <- '+', |
| source <- if tuplesNext.size() > 1 then |
| thisModule.operatorCall2(oclExp, tuplesNext) |
| else |
| thisModule.operationCall2(oclExp, tuplesNext.first().first, tuplesNext.first().second) |
| endif, |
| arguments <- thisModule.operationCall2(oclExp, tuple.first, tuple.second) |
| ) |
| do { |
| t; |
| } |
| } |
| |
| rule operatorCall3 (methodCall : AML!MethodCall, tuples : OrderedSet(TupleType(first : AML!NavigationOrAttributeCallExp, second : AML!NavigationOrAttributeCallExp))) { |
| using { |
| tuple : TupleType(first : AML!NavigationOrAttributeCallExp, second : AML!NavigationOrAttributeCallExp) = tuples.first(); |
| tuplesNext : OrderedSet(TupleType(first : AML!NavigationOrAttributeCallExp, second : AML!NavigationOrAttributeCallExp)) |
| = tuples.excluding(tuple); |
| } |
| to |
| t : ATL!OperatorCallExp ( |
| operationName <- 'or', |
| source <- if tuplesNext.size() > 1 then |
| thisModule.operatorCall3(methodCall, tuplesNext) |
| else |
| thisModule.operationCall3(methodCall, tuplesNext.first().first, tuplesNext.first().second) |
| endif, |
| arguments <- thisModule.operationCall3(methodCall, tuple.first, tuple.second) |
| ) |
| do { |
| t; |
| } |
| |
| } |
| |
| lazy rule simNavigationEqualElement { |
| from |
| m : AML!ModelFlowExpression |
| to |
| nav : ATL!NavigationOrAttributeCallExp ( |
| name <- 'similarity', |
| source <- variableExp |
| ), |
| variableExp : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(m) |
| ) |
| } |
| |
| lazy rule operationCall { |
| from |
| m1 : AML!ModelFlowExpression, |
| m2 : AML!ModelFlowExpression |
| to |
| operationEqual : ATL!OperationCallExp ( |
| operationName <- 'equal', |
| source <- varExp, |
| arguments <- OrderedSet {varExpThisEqual1, varExpThisEqual2} |
| ), |
| varExp : ATL!VariableExp( |
| referredVariable <- thisModuleVar |
| ), |
| thisModuleVar : ATL!VariableDeclaration ( |
| varName <- 'thisModule' |
| ), |
| varExpThisEqual1 : ATL!VariableExp( |
| referredVariable <- thisModule.ModelFlowExpSIP(m1) |
| ), |
| varExpThisEqual2 : ATL!VariableExp( |
| referredVariable <- thisModule.ModelFlowExpSIP(m2) |
| ) |
| } |
| |
| lazy rule operationCall2 { |
| from |
| o : AML!OclExpression, |
| m1 : AML!ModelFlowExpression, |
| m2 : AML!ModelFlowExpression |
| to |
| operationEqual : ATL!OperationCallExp ( |
| operationName <- '+', |
| source <- thisModule.OclExpressionAggr(m1, o), |
| arguments <- if m2.oclIsUndefined() then |
| thisModule.zeroExpression(o) |
| else |
| OrderedSet {thisModule.OclExpressionAggr(m2, o)} |
| endif |
| ) |
| } |
| |
| lazy rule zeroExpression { |
| from |
| o : AML!OclExpression |
| to |
| zero : ATL!RealExp ( |
| realSymbol <- 0 |
| ) |
| } |
| |
| lazy rule operationCall3 { |
| from |
| m : AML!MethodCall, |
| s1 : AML!NavigationOrAttributeCallExp, |
| s2 : AML!NavigationOrAttributeCallExp |
| to |
| operatorOr : ATL!OperatorCallExp ( |
| operationName <- 'or', |
| source <- thisModule.createNodesByNameCall(m, s1), |
| arguments <- if s2.oclIsUndefined() then |
| thisModule.trueExp(m) |
| else |
| thisModule.createNodesByNameCall(m, s2) |
| endif |
| ) |
| } |
| |
| lazy rule trueExp { |
| from |
| m : AML!MethodCall |
| to |
| trueExp : ATL!BooleanExp ( |
| booleanSymbol <- true |
| ) |
| } |
| |
| lazy rule createNodesByNameCall { |
| from |
| m : AML!MethodCall, |
| s : AML!NavigationOrAttributeCallExp |
| to |
| oclUndExp : ATL!OperationCallExp( |
| operationName <- 'oclIsUndefined', |
| source <- thisNode |
| ), |
| thisNode : ATL!OperationCallExp ( |
| operationName <- 'nodesByName', |
| source <- if m.method.oclIsTypeOf(AML!CreateEqual) then |
| thisModule.createVar(m, s) |
| else |
| thisModule.createVar2(m,s) |
| endif, |
| arguments <- OrderedSet{arguments} |
| ), |
| arguments : ATL!StringExp ( |
| stringSymbol <- s.name |
| ) |
| } |
| |
| |
| rule SimEqual extends MethodCall { |
| from |
| tm : AML!MethodCall (tm.method.oclIsTypeOf(AML!SimEqual)) |
| -- using { |
| -- methodAsArg : AML!MethodCall = tm.inputModelArgumentMethod().debug('Method'); |
| -- } |
| to |
| m : ATL!Module, |
| thisModuleVar : ATL!VariableDeclaration, |
| |
| eLeftB : ATL!Binding ( |
| value <- eLeftBValueOC |
| ), |
| eLeftBValueOC : ATL!OperationCallExp ( |
| operationName <- 'leftElement', |
| source <- eLeftBValueOCVar, |
| arguments <- eLeftBValue |
| ), |
| eLeftBValueOCVar : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| eRightB : ATL!Binding ( |
| value <- eRightBValueOC |
| ), |
| eRightBValueOC : ATL!OperationCallExp ( |
| operationName <- 'rightElement', |
| source <- eRightBValueOCVar, |
| arguments <- eRightBValue |
| ), |
| eRightBValueOCVar : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| leftElementMR : ATL!LazyMatchedRule, |
| rightElementMR : ATL!LazyMatchedRule, |
| eSimB : ATL!Binding ( |
| value <- Tuple {m = tm, s = tm.method.sim.value} |
| ) |
| } |
| |
| rule SelEqual extends MethodCall { |
| from |
| tm : AML!MethodCall (tm.method.oclIsTypeOf(AML!SelEqual)) |
| to |
| m : ATL!Module, |
| |
| thisModuleVar : ATL!VariableDeclaration, |
| |
| eLeftB : ATL!Binding ( |
| value <- eLeftBValueOC |
| ), |
| eLeftBValueOC : ATL!OperationCallExp ( |
| operationName <- 'leftElement', |
| source <- eLeftBValueOCVar, |
| arguments <- eLeftBValue |
| ), |
| eLeftBValueOCVar : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| eRightB : ATL!Binding ( |
| value <- eRightBValueOC |
| ), |
| eRightBValueOC : ATL!OperationCallExp ( |
| operationName <- 'rightElement', |
| source <- eRightBValueOCVar, |
| arguments <- eRightBValue |
| ), |
| eRightBValueOCVar : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| leftElementMR : ATL!LazyMatchedRule, |
| rightElementMR : ATL!LazyMatchedRule, |
| inPattern : ATL!InPattern, |
| eSimB : ATL!Binding ( |
| value <- eSimBValue |
| ), |
| eSimBValue : ATL!NavigationOrAttributeCallExp ( |
| name <- 'similarity', |
| source <- eSimBVE |
| ), |
| eSimBVE : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(tm.equalModelArgs.first()) --inPattern.elements.first() |
| ) |
| } |
| |
| rule ThisModel { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisEqualModelExp |
| -- ( |
| -- |
| -- s.inPatternSimRVDContainer() = m.method |
| -- |
| -- |
| -- ) |
| to |
| navThisModel : ATL!NavigationOrAttributeCallExp ( |
| name <- 'model', |
| source <- varThisEqual |
| ), |
| varThisEqual : ATL!VariableExp( |
| referredVariable <- thisModule.ModelFlowExpSIP(m.equalModelArgs.first()) |
| ) |
| } |
| |
| rule CreateEqual extends MethodCall { |
| from |
| tm : AML!MethodCall ( |
| tm.method.oclIsTypeOf(AML!CreateEqual) |
| ) |
| |
| to |
| m : ATL!Module, |
| |
| |
| inPattern : ATL!InPattern( |
| elements <- OrderedSet{leftNode, rightNode} |
| -> union (tm.method.inPattern.elements->collect(e | Tuple{m=tm, s=e})) |
| ), |
| leftNode : ATL!SimpleInPatternElement ( |
| models <- tm.equalModelArgs->collect(e | thisModule.ModelFromRef(tm, tm.method.matcher.mapMappingRefModel().get(e).leftModel)), |
| varName <- 'left', |
| type <- leftNodeT |
| ), |
| leftNodeT : ATL!OclModelElement ( |
| |
| name <- thisModule.mapCreationSIPType.get(tm.method.matcher.metametamodel()), |
| model <- metametamodel |
| ), |
| rightNode : ATL!SimpleInPatternElement ( |
| models <- tm.equalModelArgs->collect(e | thisModule.ModelFromRef(tm, tm.method.matcher.mapMappingRefModel().get(e).rightModel)), |
| varName <- 'right', |
| type <- rightNodeT |
| ), |
| rightNodeT : ATL!OclModelElement ( |
| |
| name <- thisModule.mapCreationSIPType.get(tm.method.matcher.metametamodel()), |
| model <- metametamodel |
| ), |
| |
| -- modifying name, left and right of Equal |
| |
| |
| eLeftB : ATL!Binding ( |
| propertyName <- 'left', |
| value <- eLeftBVarExp |
| ), |
| eLeftBVarExp : ATL!VariableExp ( |
| referredVariable <- eLeftBOP |
| ), |
| |
| eRightB : ATL!Binding ( |
| propertyName <- 'right', |
| value <- eRightBVarExp |
| ), |
| eRightBVarExp : ATL!VariableExp ( |
| referredVariable <- eRightBOP |
| ), |
| |
| eName : ATL!Binding ( |
| value <- eNameOC |
| ), |
| |
| eNameOC : ATL!OperationCallExp ( |
| operationName <- 'leftName_rightName', |
| source <- leftNodeVE, |
| arguments <- rightNodeVE |
| ), |
| leftNodeVE : ATL!VariableExp ( |
| referredVariable <- leftNode |
| ), |
| |
| rightNodeVE : ATL!VariableExp ( |
| referredVariable <- rightNode |
| ), |
| |
| -- creating the rest of SOPs |
| |
| eLeftB : ATL!Binding ( |
| value <- eLeftBValue |
| ), |
| eLeftBVE : ATL!VariableExp ( |
| referredVariable <- eLeftBOP |
| ), |
| eLeftBOP : ATL!SimpleOutPatternElement ( |
| outPattern <- outPattern, |
| varName <- 'eLeft', |
| type <- eLeftEType, |
| bindings <- OrderedSet{eLeftElementB} |
| ), |
| eLeftEType : ATL!OclModelElement ( |
| name <- 'LeftElement', |
| model <- equalMetamodel |
| ), |
| eLeftElementB : ATL!Binding ( |
| propertyName <- 'element', |
| value <- eLeftElementBValue |
| ), |
| eLeftElementBValue : ATL!VariableExp ( |
| referredVariable <- eLeftRef |
| ), |
| eLeftRef : ATL!SimpleOutPatternElement ( |
| outPattern <- outPattern, |
| varName <- 'eLeftRef', |
| type <- eLeftRType, |
| bindings <- OrderedSet {eLeftRefB, eLeftModelRefB} |
| ), |
| eLeftRType : ATL!OclModelElement ( |
| model <- equalMetamodel, |
| name <- 'ElementRef' |
| --, |
| --model <- targetModel |
| ), |
| eLeftRefB : ATL!Binding( |
| propertyName <- 'ref', |
| value <- eLeftRefBValue |
| ), |
| eLeftRefBValue : ATL!NavigationOrAttributeCallExp( |
| name <- '__xmiID__', |
| source <- eLeftRefBVar |
| ), |
| eLeftRefBVar : ATL!VariableExp( |
| referredVariable <- leftNode |
| ), |
| |
| eLeftModelRefB : ATL!Binding ( |
| propertyName <- 'modelRef', |
| value <- eLeftModelRefBN |
| ), |
| |
| eLeftModelRefBN : ATL!NavigationOrAttributeCallExp ( |
| name <- 'leftM', |
| source <- eLeftModelRefBOC |
| ), |
| eLeftModelRefBOC : ATL!OperationCallExp ( |
| operationName <- 'equalModel', |
| source <- eLeftModelRefBVE, |
| arguments <- eLeftModelRefBVESE |
| ), |
| eLeftModelRefBVE : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| |
| eLeftModelRefBVESE : ATL!StringExp ( |
| stringSymbol <- thisModule.ModelFlowExpModel(tm.equalModelArgs->first()).name |
| ), |
| |
| eRightB : ATL!Binding ( |
| value <- eRightBValue |
| ), |
| eRightBVE : ATL!VariableExp ( |
| referredVariable <- eRightBOP |
| ), |
| eRightBOP : ATL!SimpleOutPatternElement ( |
| outPattern <- outPattern, |
| varName <- 'eRight', |
| type <- eRightEType, |
| bindings <- OrderedSet{eRightElementB} |
| ), |
| eRightEType : ATL!OclModelElement ( |
| name <- 'RightElement', |
| model <- equalMetamodel |
| ), |
| eRightElementB : ATL!Binding ( |
| propertyName <- 'element', |
| value <- eRightElementBValue |
| ), |
| eRightElementBValue : ATL!VariableExp ( |
| referredVariable <- eRightRef |
| ), |
| eRightRef : ATL!SimpleOutPatternElement ( |
| outPattern <- outPattern, |
| varName <- 'eRightRef', |
| type <- eRightRType, |
| bindings <- OrderedSet {eRightRefB, erightModelRefB} |
| ), |
| eRightRType : ATL!OclModelElement ( |
| name <- 'ElementRef', |
| model <- equalMetamodel |
| ), |
| eRightRefB : ATL!Binding( |
| propertyName <- 'ref', |
| value <- eRightRefBValue |
| ), |
| eRightRefBValue : ATL!NavigationOrAttributeCallExp( |
| name <- '__xmiID__', |
| source <- eRightRefBVar |
| ), |
| eRightRefBVar : ATL!VariableExp( |
| referredVariable <- rightNode |
| ), |
| |
| erightModelRefB : ATL!Binding ( |
| propertyName <- 'modelRef', |
| value <- erightModelRefBN |
| ), |
| |
| erightModelRefBN : ATL!NavigationOrAttributeCallExp ( |
| name <- 'rightM', |
| source <- erightModelRefBOC |
| ), |
| erightModelRefBOC : ATL!OperationCallExp ( |
| operationName <- 'equalModel', |
| source <- erightModelRefBVE, |
| arguments <- eRightModelRefBVESE |
| ), |
| erightModelRefBVE : ATL!VariableExp ( |
| referredVariable <- thisModuleVar |
| ), |
| eRightModelRefBVESE : ATL!StringExp ( |
| stringSymbol <- thisModule.ModelFlowExpModel(tm.equalModelArgs->first()).name |
| ), |
| |
| eSimB : ATL!Binding ( |
| value <- eSimBValue |
| ), |
| eSimBValue : ATL!RealExp ( |
| realSymbol <- 0 |
| ) |
| } |
| |
| |
| rule UserEqual extends MethodCall { |
| from |
| tm : AML!MethodCall (tm.method.oclIsTypeOf(AML!UserEqual)) |
| to |
| m : ATL!Module, |
| |
| t2 : ATL!MatchedRule ( |
| outPattern <- tm.outPattern--Tuple{m=tm, s=tm.outPattern} |
| ) |
| } |
| |
| rule VariableDeclaration { |
| from |
| m : AML!MethodCall, |
| s : AML!VariableDeclaration |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!VariableDeclaration ( |
| varName <- s.varName, |
| type <- if s.type.oclIsUndefined() then |
| OclUndefined |
| else |
| Tuple{m=m, s=s.type} |
| endif, |
| initExpression <- if s.initExpression.oclIsUndefined() then |
| s.initExpression |
| else |
| Tuple{m = m, s=s.initExpression} |
| endif |
| |
| ) |
| } |
| |
| rule RuleVariableDeclaration extends VariableDeclaration { |
| from |
| m : AML!MethodCall, |
| s : AML!RuleVariableDeclaration |
| -- ( |
| -- s.refImmediateComposite() = m.method |
| -- ) |
| to |
| t : ATL!RuleVariableDeclaration |
| } |
| |
| rule SimpleInPattern extends VariableDeclaration { |
| from |
| m : AML!MethodCall, |
| s : AML!SimpleInPatternElement |
| -- ( |
| -- |
| -- ) |
| to |
| t : ATL!SimpleInPatternElement ( |
| varName <- s.varName + 'Var', |
| |
| models <- s.models->collect(e | Tuple{m=m , tm=e}) |
| ) |
| } |
| |
| rule OutPattern { |
| from |
| m : AML!MethodCall, |
| s : AML!OutPattern |
| to |
| t : ATL!OutPattern ( |
| elements <- s.elements->collect(e | Tuple{m=m,s=e}) |
| ) |
| } |
| |
| rule SimpleOutPatternElement extends VariableDeclaration { |
| from |
| m : AML!MethodCall, |
| s : AML!SimpleOutPatternElement |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!SimpleOutPatternElement ( |
| bindings <- s.bindings->collect(e | Tuple{m=m,s=e}) |
| ) |
| } |
| |
| rule Binding { |
| from |
| m : AML!MethodCall, |
| s : AML!Binding |
| to |
| t : ATL!Binding ( |
| value <- s.value, |
| propertyName <- s.propertyName |
| ) |
| } |
| |
| rule EnumLiteralExp extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!EnumLiteralExp |
| to |
| t : ATL!EnumLiteralExp ( |
| name <- s.name |
| ) |
| } |
| |
| rule LetExp extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!LetExp |
| to |
| t : ATL!LetExp ( |
| variable <- Tuple {m=m, s=s.variable}, |
| "in" <- Tuple {m=m, s=s."in"} |
| ) |
| } |
| |
| abstract rule PropertyCallExp extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!PropertyCallExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| ---- and |
| ---- not s.summationContainer |
| -- ) |
| to |
| t : ATL!PropertyCallExp ( |
| source <- Tuple {m = m, s = s.source} |
| ) |
| } |
| |
| abstract rule LoopExp extends PropertyCallExp { |
| from |
| m : AML!MethodCall, |
| s : AML!LoopExp |
| to |
| t : ATL!LoopExp( |
| body <- Tuple{m=m,s=s.body}, |
| iterators <- s.iterators->collect(e | Tuple{m=m, s=e}) |
| ) |
| } |
| |
| rule OperationCallExp extends PropertyCallExp { |
| from |
| m : AML!MethodCall, |
| s : AML!OperationCallExp |
| to |
| t : ATL!OperationCallExp( |
| operationName <- s.operationName, |
| arguments <- s.arguments->collect(e | Tuple {m = m, s = e}) |
| ) |
| } |
| |
| rule OperatorCallExp extends OperationCallExp { |
| from |
| m : AML!MethodCall, |
| s : AML!OperatorCallExp |
| to |
| t : ATL!OperatorCallExp |
| } |
| |
| rule CollectionOpCallExp extends OperationCallExp { |
| from |
| m : AML!MethodCall, |
| s : AML!CollectionOperationCallExp |
| to |
| t : ATL!CollectionOperationCallExp |
| } |
| |
| lazy abstract rule OclExpressionAggr { |
| from |
| m : AML!ModelFlowExpression, |
| s : AML!OclExpression |
| to |
| t : ATL!OclExpression |
| } |
| |
| lazy rule PropertyCallAggr extends OclExpressionAggr { |
| from |
| m : AML!ModelFlowExpression, |
| s : AML!PropertyCallExp |
| to |
| t : ATL!PropertyCallExp ( |
| source <- thisModule.OclExpressionAggr(m, s.source) |
| ) |
| } |
| |
| lazy rule NavigationOrAttrAggr extends PropertyCallAggr { |
| from |
| m : AML!ModelFlowExpression, |
| s : AML!NavigationOrAttributeCallExp |
| to |
| t : ATL!NavigationOrAttributeCallExp ( |
| name <- s.name |
| ) |
| } |
| |
| lazy rule OperationCallAggr extends PropertyCallAggr { |
| from |
| m : AML!ModelFlowExpression, |
| s : AML!OperationCallExp |
| to |
| t : ATL!OperationCallExp ( |
| operationName <- s.operationName, |
| arguments <- s.arguments->collect(e | thisModule.OclExpressionAggr(m, e)) |
| ) |
| } |
| |
| lazy rule VariableExpAggr extends OclExpressionAggr { |
| from |
| m : AML!ModelFlowExpression, |
| s : AML!VariableExp |
| to |
| t : ATL!VariableExp ( |
| referredVariable <- thisModule.OclExpressionAggr(s.referredVariable) |
| ) |
| } |
| |
| lazy rule VariableDeclarationAggr extends OclExpressionAggr { |
| from |
| m : AML!ModelFlowExpression, |
| s : AML!VariableDeclaration |
| to |
| t : ATL!VariableDeclaration ( |
| varName <- s.varName, |
| type <- s.type, |
| initExpression <- thisModule.OclExpressionAggr(s.initExpression) |
| ) |
| } |
| |
| |
| |
| abstract rule ThisNodeExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisNodeExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| |
| to |
| t : ATL!OclExpression |
| } |
| |
| rule ThisNodeExp_Creation extends ThisNodeExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisNodeExp ( |
| m.method.oclIsTypeOf(AML!CreateEqual) |
| ) |
| |
| to |
| t : ATL!VariableExp( |
| referredVariable <- if s.oclIsTypeOf(AML!ThisRightExp) then |
| thisModule.resolveTemp(m, 'rightNode') |
| else |
| thisModule.resolveTemp(m, 'leftNode') |
| endif |
| ) |
| } |
| |
| rule ThisNodeExp_NotCreation extends ThisNodeExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisNodeExp |
| to |
| t : ATL!NavigationOrAttributeCallExp ( |
| name <- if s.oclIsTypeOf(AML!ThisLeftExp) then |
| 'leftE' |
| else |
| 'rightE' |
| endif, |
| source <- equalE |
| -- , |
| -- arguments <- OrderedSet{modelName} |
| ) |
| , |
| equalE : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(m.equalModelArgs->first()) |
| ) |
| |
| } |
| |
| |
| rule NavigationOrAttributeCallExp extends PropertyCallExp { |
| from |
| m : AML!MethodCall, |
| s : AML!NavigationOrAttributeCallExp |
| to |
| t : ATL!NavigationOrAttributeCallExp ( |
| |
| name <- s.name |
| ) |
| } |
| |
| |
| |
| |
| |
| lazy rule createVar { |
| from |
| m : AML!MethodCall, |
| s : AML!PropertyCallExp |
| to |
| t : ATL!VariableExp( |
| referredVariable <- if s.source.oclIsTypeOf(AML!ThisRightExp) then |
| thisModule.resolveTemp(m, 'rightNode') |
| else |
| thisModule.resolveTemp(m, 'leftNode') |
| endif |
| ) |
| } |
| |
| lazy rule createVar2 { |
| from |
| m : AML!MethodCall, |
| s : AML!PropertyCallExp |
| to |
| refElement : ATL!OperationCallExp ( |
| operationName <- if s.source.oclIsTypeOf(AML!ThisLeftExp) then |
| 'leftE' |
| else |
| 'rightE' |
| endif, |
| source <- equalE, |
| arguments <- OrderedSet{modelName} |
| ), |
| equalE : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(m.equalModelArgs->first()) |
| ), |
| modelName : ATL!StringExp ( |
| stringSymbol <- if s.source.oclIsTypeOf(AML!ThisLeftExp) then |
| m.method.matcher.mapMappingRefModel().get(m.equalModelArgs->first()).leftModel.name |
| else |
| m.method.matcher.mapMappingRefModel().get(m.equalModelArgs->first()).rightModel.name |
| endif |
| ) |
| } |
| |
| rule IterateExp extends LoopExp { |
| from |
| m : AML!MethodCall, |
| s : AML!IterateExp |
| to |
| t : ATL!IterateExp ( |
| result <- if s.result.oclIsUndefined() then |
| OclUndefined |
| else |
| Tuple{m=m, s=s.result} |
| endif |
| ) |
| } |
| |
| |
| rule IteratorExp extends LoopExp { |
| from |
| m : AML!MethodCall, |
| s : AML!IteratorExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!IteratorExp ( |
| name <- s.name |
| -- , |
| -- source <- Tuple {m = m, s = s.source}, |
| -- body <- Tuple {m = m, s = s.body}, |
| -- iterators <- s.iterators->collect(e | Tuple {m = m, s = e}) |
| ) |
| } |
| |
| rule Iterator extends VariableDeclaration { |
| from |
| m : AML!MethodCall, |
| s : AML!Iterator |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!Iterator ( |
| varName <- s.varName, |
| variableExp <- Tuple {m = m, s = s.variableExp.first()} |
| ) |
| } |
| |
| rule VariableExp extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!VariableExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!VariableExp ( |
| referredVariable <- Tuple{m=m, s=s.referredVariable} |
| ) |
| } |
| |
| |
| rule ThisWeightAggr { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisWeightExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!OperationCallExp ( |
| operationName <- 'get', |
| source <- source, |
| arguments <- OrderedSet{argument} |
| ), |
| source : ATL!OperationCallExp ( |
| operationName <- 'modelWeight', |
| source <- modelVarExp |
| ), |
| modelVarExp : ATL!VariableExp ( |
| referredVariable <- varThisModule |
| ), |
| varThisModule : ATL!VariableDeclaration ( |
| varName <- 'thisModule' |
| ), |
| argument : ATL!NavigationOrAttributeCallExp ( |
| name <- 'model', |
| source <- modelVarExp2 |
| ), |
| modelVarExp2: ATL!VariableExp ( |
| referredVariable <- thisModule.resolveTemp(Tuple{m=m, s=s.summationContainer}, 'iteratorE') |
| ) |
| |
| } |
| |
| |
| |
| rule ThisEqualExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisEqualExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!VariableExp ( |
| referredVariable <- m.equalModelArgs->collect(e | thisModule.ModelFlowExpSIP(e))->first() |
| ) |
| } |
| |
| rule ThisInstancesExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisInstancesExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!OperationCallExp ( |
| operationName <- 'instancesEqual', |
| source <- varExp, |
| arguments <- Tuple {m = m, s = s.instancesOp} --OrderedSet{modelName, lMName, rMName, lMMName, rMMName} |
| ) |
| , |
| varExp : ATL!VariableExp ( |
| referredVariable <- m.equalModelArgs->collect(e | thisModule.ModelFlowExpSIP(e))->first() |
| ) |
| |
| } |
| |
| lazy rule ThisSimExpAggr extends OclExpressionAggr { --extends ThisEqualExp { |
| from |
| m : AML!ModelFlowExpression, |
| s : AML!ThisSimExp |
| to |
| t : ATL!NavigationOrAttributeCallExp ( |
| name <- 'similarity', |
| source <- var |
| ), |
| var : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(m) |
| ) |
| |
| |
| } |
| |
| abstract rule ThisSimExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisSimExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!NavigationOrAttributeCallExp ( |
| name <- 'similarity', |
| source <- var |
| ), |
| var : ATL!VariableExp |
| } |
| |
| rule ThisSimExp_summationContainer extends ThisSimExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisSimExp ( |
| s.isSummationContainer |
| ) |
| to |
| t : ATL!NavigationOrAttributeCallExp, |
| var : ATL!VariableExp ( |
| referredVariable <- thisModule.resolveTemp(Tuple{m=m, s=s.summationContainer}, 'iteratorE') |
| ) |
| } |
| |
| rule ThisSimExp_notSummationContainer extends ThisSimExp { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisSimExp |
| to |
| t : ATL!NavigationOrAttributeCallExp, |
| var : ATL!VariableExp ( |
| referredVariable <- thisModule.ModelFlowExpSIP(m.equalModelArgs.first()) |
| ) |
| } |
| |
| abstract rule PrimitiveExp extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!PrimitiveExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!PrimitiveExp |
| } |
| |
| rule StringExp extends PrimitiveExp { |
| from |
| m : AML!MethodCall, |
| s : AML!StringExp |
| to |
| t : ATL!StringExp ( |
| stringSymbol <- s.stringSymbol |
| ) |
| } |
| |
| abstract rule NumericExp extends PrimitiveExp { |
| from |
| m : AML!MethodCall, |
| s : AML!NumericExp |
| to |
| t : ATL!NumericExp |
| } |
| |
| rule RealExp extends NumericExp { |
| from |
| m : AML!MethodCall, |
| s : AML!RealExp |
| to |
| t : ATL!RealExp ( |
| realSymbol <- s.realSymbol |
| ) |
| } |
| |
| rule IntegerExp extends NumericExp { |
| from |
| m : AML!MethodCall, |
| s : AML!IntegerExp |
| to |
| t : ATL!IntegerExp ( |
| integerSymbol <- s.integerSymbol |
| ) |
| } |
| |
| abstract rule Primitive extends "OclType" { |
| from |
| m : AML!MethodCall, |
| s : AML!Primitive |
| to |
| t : ATL!Primitive |
| } |
| |
| abstract rule NumericType extends Primitive { |
| from |
| m : AML!MethodCall, |
| s : AML!NumericType |
| to |
| t : ATL!NumericType ( |
| name <- s.name |
| ) |
| } |
| |
| rule StringType extends Primitive { |
| from |
| m : AML!MethodCall, |
| s : AML!StringType |
| to |
| t : ATL!StringType |
| } |
| |
| rule BooleanType extends Primitive { |
| from |
| m : AML!MethodCall, |
| s : AML!BooleanType |
| to |
| t : ATL!BooleanType |
| } |
| rule IntegerType extends NumericType { |
| from |
| m : AML!MethodCall, |
| s : AML!IntegerType |
| to |
| t : ATL!IntegerType |
| } |
| |
| rule RealType extends NumericType { |
| from |
| m : AML!MethodCall, |
| s : AML!RealType |
| to |
| t : ATL!RealType |
| } |
| |
| abstract rule "OclType" extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!"OclType" |
| to |
| t : ATL!"OclType" ( |
| name <- s.name |
| ) |
| } |
| |
| rule OclAnyType extends "OclType" { |
| from |
| m : AML!MethodCall, |
| s : AML!OclAnyType |
| to |
| t : ATL!OclAnyType |
| } |
| |
| rule OrderedSetType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!OrderedSetType |
| to |
| t : ATL!OrderedSetType |
| } |
| |
| rule SequenceType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!SequenceType |
| to |
| t : ATL!SequenceType |
| } |
| |
| rule SetType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!SetType |
| to |
| t : ATL!SetType |
| } |
| |
| rule BagType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!BagType |
| to |
| t : ATL!BagType |
| } |
| |
| rule OrderedSetType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!OrderedSetType |
| to |
| t : ATL!OrderedSetType |
| } |
| |
| rule BooleanExp extends PrimitiveExp { |
| from |
| m : AML!MethodCall, |
| s : AML!BooleanExp |
| to |
| t : ATL!BooleanExp ( |
| booleanSymbol <- s.booleanSymbol |
| ) |
| } |
| |
| rule IfExp { |
| from |
| m : AML!MethodCall, |
| s : AML!IfExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!IfExp ( |
| thenExpression <- Tuple {m = m, s = s.thenExpression}, |
| condition <- Tuple {m = m, s = s.condition}, |
| elseExpression <- Tuple {m = m, s = s.elseExpression} |
| ) |
| } |
| |
| abstract rule OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!OclExpression |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!OclExpression |
| |
| } |
| |
| rule MapExp extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s: AML!MapExp |
| to |
| t : ATL!MapExp ( |
| elements <- s.elements->collect(e | Tuple{m=m, s=e}) |
| ) |
| } |
| |
| rule MapElement { |
| from |
| m : AML!MethodCall, |
| s : AML!MapElement |
| to |
| t : ATL!MapElement ( |
| key <- s.key, |
| value <- s.value |
| ) |
| } |
| |
| rule OclUndefinedExp extends OclExpression { |
| from |
| m : AML!MethodCall, |
| s : AML!OclUndefinedExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!OclUndefinedExp |
| |
| |
| } |
| |
| abstract rule CollectionType extends "OclType" { |
| from |
| m : AML!MethodCall, |
| s : AML!CollectionType |
| to |
| t : ATL!CollectionType( |
| elementType <- Tuple{m=m, s=s.elementType} |
| ) |
| } |
| |
| rule BagType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!BagType |
| to |
| t : ATL!BagType |
| } |
| |
| rule OrderedSetType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!OrderedSetType |
| to |
| t : ATL!OrderedSetType |
| } |
| |
| rule SetType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!SetType |
| to |
| t : ATL!SetType |
| } |
| |
| rule OrderedSetType extends CollectionType { |
| from |
| m : AML!MethodCall, |
| s : AML!OrderedSetType |
| to |
| t : ATL!OrderedSetType |
| } |
| |
| rule "TupleType" extends "OclType" { |
| from |
| m : AML!MethodCall, |
| s : AML!"TupleType" |
| to |
| t : ATL!"TupleType"( |
| attributes <- s.attributes->collect(e | Tuple{m=m, s=e}) |
| ) |
| } |
| |
| rule TupleTypeAttribute { |
| from |
| m : AML!MethodCall, |
| s : AML!TupleTypeAttribute |
| to |
| t : ATL!TupleTypeAttribute( |
| type <- Tuple{m=m, s=s.type}, |
| name <- s.name |
| ) |
| } |
| |
| rule MapType extends "OclType" { |
| from |
| m : AML!MethodCall, |
| s : AML!MapType |
| to |
| t : ATL!MapType( |
| valueType <- Tuple{m=m, s=s.valueType}, |
| keyType <- Tuple{m=m, s=s.keyType} |
| ) |
| } |
| |
| abstract rule CollectionExp extends "OclExpression" { |
| from |
| m : AML!MethodCall, |
| s : AML!CollectionExp |
| to |
| t : ATL!CollectionExp( |
| elements <- s.elements -> collect(e | Tuple{m=m, s=e}) |
| ) |
| } |
| |
| rule BagExp extends CollectionExp { |
| from |
| m : AML!MethodCall, |
| s : AML!BagExp |
| to |
| t : ATL!BagExp |
| } |
| |
| rule OrderedSetExp extends CollectionExp { |
| from |
| m : AML!MethodCall, |
| s : AML!OrderedSetExp |
| to |
| t : ATL!OrderedSetExp |
| } |
| |
| rule SequenceExp extends CollectionExp { |
| from |
| m : AML!MethodCall, |
| s : AML!SequenceExp |
| to |
| t : ATL!SequenceExp |
| } |
| |
| rule SetExp extends CollectionExp { |
| from |
| m : AML!MethodCall, |
| s : AML!SetExp |
| to |
| t : ATL!SetExp |
| } |
| |
| rule OrderedSetExp extends CollectionExp { |
| from |
| m : AML!MethodCall, |
| s : AML!OrderedSetExp |
| to |
| t : ATL!OrderedSetExp |
| } |
| |
| rule "TupleExp" extends "OclExpression" { |
| from |
| m : AML!MethodCall, |
| s : AML!"TupleExp" |
| to |
| t : ATL!"TupleExp" ( |
| tuplePart <- s.tuplePart->collect(e | Tuple{m=m, s=e}) |
| ) |
| } |
| |
| rule TuplePart extends VariableDeclaration { |
| from |
| m : AML!MethodCall, |
| s : AML!"TuplePart" |
| to |
| t : ATL!"TuplePart" |
| } |
| |
| rule MetaElement { |
| from |
| m : AML!MethodCall, |
| s : AML!MetaElement |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!OclModelElement ( |
| name <- s.name |
| --, |
| --model <- Tuple{tm = m, s = s.referenceModel} |
| ) |
| } |
| |
| rule ThisModule { |
| from |
| m : AML!MethodCall, |
| s : AML!ThisModuleExp |
| -- ( |
| -- s.inPatternSimRVDContainer() = m.method |
| -- ) |
| to |
| t : ATL!VariableExp ( |
| referredVariable <- var |
| ), |
| |
| var : ATL!VariableDeclaration ( |
| varName <- 'thisModule' |
| ) |
| } |
| |
| |
| |
| |