From 7f7f934fe6ad11df96906d009eec68583fd46660 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Tue, 5 Feb 2019 23:54:03 +0100 Subject: [Stochastic] Fault tree transformation langauge --- .../faulttree/components/CftLanguage.xtext | 82 ++++++++++++ .../components/CftLanguageRuntimeModule.xtend | 33 +++++ .../components/CftLanguageStandaloneSetup.xtend | 15 +++ .../faulttree/components/GenerateCftLanguage.mwe2 | 46 +++++++ .../generator/CftLanguageGenerator.xtend | 25 ++++ .../naming/CftLanguageQualifiedNameProvider.xtend | 27 ++++ .../components/naming/PackageNameProvider.xtend | 30 +++++ ...eImportedNamespaceAwareLocalScopeProvider.xtend | 45 +++++++ .../scoping/CftLanguageScopeProvider.xtend | 138 +++++++++++++++++++++ .../validation/CftLanguageValidator.xtend | 25 ++++ 10 files changed, 466 insertions(+) create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguage.xtext create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageRuntimeModule.xtend create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageStandaloneSetup.xtend create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/GenerateCftLanguage.mwe2 create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/generator/CftLanguageGenerator.xtend create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/CftLanguageQualifiedNameProvider.xtend create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/PackageNameProvider.xtend create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageImportedNamespaceAwareLocalScopeProvider.xtend create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageScopeProvider.xtend create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/validation/CftLanguageValidator.xtend (limited to 'Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme') diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguage.xtext b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguage.xtext new file mode 100644 index 00000000..3d82413f --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguage.xtext @@ -0,0 +1,82 @@ +grammar hu.bme.mit.inf.dslreasoner.faulttree.components.CftLanguage with org.eclipse.xtext.common.Terminals + +import "http://www.eclipse.org/emf/2002/Ecore" as ecore +import "http://www.eclipse.org/viatra/query/patternlanguage/emf/PatternLanguage" as vql + +generate cftLanguage "http://www.bme.hu/mit/inf/dslreasoner/faulttree/components/CftLanguage" + +CftModel: + "package" packageName=QualifiedName ";"? + imports+=ImportDeclaration* + (componentDefinitions+=ComponentDefinition | transformationDefinitions+=TransformationDefinition)*; + +ImportDeclaration: + "import" importedNamespace=QualifiedNameWithWildcard ";"?; + +ComponentDefinition: + "cft" name=ID "{" + (("in" inputEvents+=InputEvent* ";")? & ("out" outputEvents+=[EventDeclaration]* ";")?) + (eventDefinitions+=EventDefinition ";")* + "}"; + +EventDeclaration: + InputEvent | EventDefinition; + +InputEvent: + name=ID multiple?="[]"?; + +EventDefinition: + BasicEventDefinition | GateDefinition; + +BasicEventDefinition: + name=ID "lambda" "=" rate=DOULBE; + +GateDefinition: + AndGate | OrGate; + +AndGate: + name=ID "and" inputEvents+=[EventDeclaration]*; + +OrGate: + name=ID "or" inputEvents+=[EventDeclaration]*; + +TransformationDefinition: + "transformation" name=ID "{" + mappingDefinitions+=MappingDefinition* + "}"; + +MappingDefinition: + topLevel?="toplevel"? "mapping" pattern=[vql::Pattern|QualifiedName] + "(" parameters+=MappingParameter ("," parameters+=MappingParameter)* ")" + (componentInstance=ComponentInstance)? ("{" + ((lookupDefinitions+=LookupDefinition | assignments+=Assignment) ";")* + "}")?; + +MappingParameter: + name=ID; + +LookupDefinition: + "lookup" mapping=[MappingDefinition] + "(" arguments+=[MappingParameter] ("," arguments+=[MappingParameter])* ")" + "as" name=ID; + +Variable: + ComponentInstance | LookupDefinition; + +Assignment: + input=EventReference (multiple?="+=" | ":=") output=EventReference; + +EventReference: + component=[Variable] "." event=[EventDeclaration]; + +ComponentInstance: + "=>" componentType=[ComponentDefinition|QualifiedName] name=ID?; + +QualifiedName returns ecore::EString: + ID ("." ID)*; + +QualifiedNameWithWildcard returns ecore::EString: + QualifiedName ("." "*")?; + +terminal DOULBE returns ecore::EDouble: + ('0'..'9')+ ("." ('0'..'9')+ | ("." ('0'..'9')+)? ("e" | "E") ("+" | "-")? ('0'..'9')+); diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageRuntimeModule.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageRuntimeModule.xtend new file mode 100644 index 00000000..f780591d --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageRuntimeModule.xtend @@ -0,0 +1,33 @@ +/* + * generated by Xtext 2.16.0 + */ +package hu.bme.mit.inf.dslreasoner.faulttree.components + +import com.google.inject.Binder +import com.google.inject.name.Names +import hu.bme.mit.inf.dslreasoner.faulttree.components.naming.CftLanguageQualifiedNameProvider +import hu.bme.mit.inf.dslreasoner.faulttree.components.scoping.CftLanguageImportedNamespaceAwareLocalScopeProvider +import org.eclipse.xtext.scoping.IScopeProvider +import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider +import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider + +/** + * Use this class to register components to be used at runtime / without the Equinox extension registry. + */ +class CftLanguageRuntimeModule extends AbstractCftLanguageRuntimeModule { + + override bindIGlobalScopeProvider() { + DefaultGlobalScopeProvider + } + + override configureIScopeProviderDelegate(Binder binder) { + binder.bind(IScopeProvider).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to( + CftLanguageImportedNamespaceAwareLocalScopeProvider) + } + + + override bindIQualifiedNameProvider() { + CftLanguageQualifiedNameProvider + } + +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageStandaloneSetup.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageStandaloneSetup.xtend new file mode 100644 index 00000000..7ec57980 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/CftLanguageStandaloneSetup.xtend @@ -0,0 +1,15 @@ +/* + * generated by Xtext 2.16.0 + */ +package hu.bme.mit.inf.dslreasoner.faulttree.components + + +/** + * Initialization support for running Xtext languages without Equinox extension registry. + */ +class CftLanguageStandaloneSetup extends CftLanguageStandaloneSetupGenerated { + + def static void doSetup() { + new CftLanguageStandaloneSetup().createInjectorAndDoEMFRegistration() + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/GenerateCftLanguage.mwe2 b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/GenerateCftLanguage.mwe2 new file mode 100644 index 00000000..fa383404 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/GenerateCftLanguage.mwe2 @@ -0,0 +1,46 @@ +module hu.bme.mit.inf.dslreasoner.faulttree.components.GenerateCftLanguage + +import org.eclipse.xtext.xtext.generator.* +import org.eclipse.xtext.xtext.generator.model.project.* + +var rootPath = ".." + +Workflow { + + component = XtextGenerator { + configuration = { + project = StandardProjectConfig { + baseName = "hu.bme.mit.inf.dslreasoner.faulttree.components" + rootPath = rootPath + eclipsePlugin = { + enabled = true + } + createEclipseMetaData = true + } + code = { + encoding = "UTF-8" + lineDelimiter = "\n" + fileHeader = "/*\n * generated by Xtext \${version}\n */" + } + } + language = StandardLanguage { + name = "hu.bme.mit.inf.dslreasoner.faulttree.components.CftLanguage" + fileExtensions = "cft" + + referencedResource = "platform:/resource/org.eclipse.emf.ecore/model/Ecore.genmodel" + referencedResource = "platform:/resource/org.eclipse.viatra.query.patternlanguage.emf/model/PatternLanguage.genmodel" + + serializer = { + generateStub = false + } + validator = { + // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator" + // Generates checks for @Deprecated grammar annotations, an IssueProvider and a corresponding PropertyPage + generateDeprecationValidation = true + } + junitSupport = { + junitVersion = "5" + } + } + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/generator/CftLanguageGenerator.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/generator/CftLanguageGenerator.xtend new file mode 100644 index 00000000..d7ebace4 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/generator/CftLanguageGenerator.xtend @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.16.0 + */ +package hu.bme.mit.inf.dslreasoner.faulttree.components.generator + +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.generator.AbstractGenerator +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGeneratorContext + +/** + * Generates code from your model files on save. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation + */ +class CftLanguageGenerator extends AbstractGenerator { + + override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { +// fsa.generateFile('greetings.txt', 'People to greet: ' + +// resource.allContents +// .filter(Greeting) +// .map[name] +// .join(', ')) + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/CftLanguageQualifiedNameProvider.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/CftLanguageQualifiedNameProvider.xtend new file mode 100644 index 00000000..eb96901c --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/CftLanguageQualifiedNameProvider.xtend @@ -0,0 +1,27 @@ +package hu.bme.mit.inf.dslreasoner.faulttree.components.naming + +import com.google.inject.Inject +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.ComponentDefinition +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.TransformationDefinition +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider + +class CftLanguageQualifiedNameProvider extends DefaultDeclarativeQualifiedNameProvider { + @Inject PackageNameProvider packageNameProvider + + def qualifiedName(ComponentDefinition componentDefinition) { + computePackageQualifiedName(componentDefinition, componentDefinition.name) + } + + def qualifiedName(TransformationDefinition transformationDefinition) { + computePackageQualifiedName(transformationDefinition, transformationDefinition.name) + } + + private def computePackageQualifiedName(EObject eObj, String name) { + if (name === null) { + return null + } + val packageQualifier = packageNameProvider.getPackageName(eObj) + packageQualifier.append(name) + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/PackageNameProvider.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/PackageNameProvider.xtend new file mode 100644 index 00000000..a05c8138 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/naming/PackageNameProvider.xtend @@ -0,0 +1,30 @@ +package hu.bme.mit.inf.dslreasoner.faulttree.components.naming + +import com.google.inject.Inject +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.CftModel +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.naming.IQualifiedNameConverter +import org.eclipse.xtext.naming.QualifiedName + +class PackageNameProvider { + val IQualifiedNameConverter qualifiedNameConverter + + @FinalFieldsConstructor + @Inject + new() { + } + + def getPackageName(EObject eObj) { + if (eObj === null) { + return QualifiedName.EMPTY + } + val pacakgeName = EcoreUtil2.getContainerOfType(eObj, CftModel)?.packageName + if (pacakgeName.isNullOrEmpty) { + QualifiedName.EMPTY + } else { + qualifiedNameConverter.toQualifiedName(pacakgeName) + } + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageImportedNamespaceAwareLocalScopeProvider.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageImportedNamespaceAwareLocalScopeProvider.xtend new file mode 100644 index 00000000..39a6e5a5 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageImportedNamespaceAwareLocalScopeProvider.xtend @@ -0,0 +1,45 @@ +package hu.bme.mit.inf.dslreasoner.faulttree.components.scoping + +import com.google.inject.Inject +import com.google.inject.Singleton +import hu.bme.mit.inf.dslreasoner.faulttree.components.naming.PackageNameProvider +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.xtext.naming.IQualifiedNameConverter +import org.eclipse.xtext.naming.IQualifiedNameProvider +import org.eclipse.xtext.scoping.ICaseInsensitivityHelper +import org.eclipse.xtext.scoping.IGlobalScopeProvider +import org.eclipse.xtext.scoping.IScope +import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider + +@Singleton +class CftLanguageImportedNamespaceAwareLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider { + @Inject PackageNameProvider packageNameProvider + + @Inject + new() { + } + + new(IGlobalScopeProvider globalScopeProvider, IQualifiedNameProvider qualifiedNameProvider, + IQualifiedNameConverter qualifiedNameConverter, ICaseInsensitivityHelper caseInsensitivityHelper) { + super(globalScopeProvider, qualifiedNameProvider, qualifiedNameConverter, caseInsensitivityHelper) + packageNameProvider = new PackageNameProvider(qualifiedNameConverter) + } + + override protected internalGetImportedNamespaceResolvers(EObject context, boolean ignoreCase) { + val resolvers = super.internalGetImportedNamespaceResolvers(context, ignoreCase) + val packageName = packageNameProvider.getPackageName(context) + if (!packageName.empty) { + val packageNormalizer = doCreateImportNormalizer(packageName, true, ignoreCase) + resolvers.add(0, packageNormalizer) + } + resolvers + } + + def createImportNormalizedScope(IScope elements, EObject context, EReference reference) { + val ignoreCase = isIgnoreCase(reference) + val type = reference.EReferenceType + val namespaceResolvers = getImportedNamespaceResolvers(context, ignoreCase) + createImportScope(elements, namespaceResolvers, null, type, ignoreCase) + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageScopeProvider.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageScopeProvider.xtend new file mode 100644 index 00000000..ab708087 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/scoping/CftLanguageScopeProvider.xtend @@ -0,0 +1,138 @@ +/* + * generated by Xtext 2.16.0 + */ +package hu.bme.mit.inf.dslreasoner.faulttree.components.scoping + +import com.google.common.collect.Lists +import com.google.inject.Inject +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.ComponentDefinition +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.ComponentInstance +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.EventReference +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.LookupDefinition +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.MappingDefinition +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.TransformationDefinition +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.Variable +import org.eclipse.emf.common.notify.Notifier +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.xtext.EcoreUtil2 +import org.eclipse.xtext.resource.EObjectDescription +import org.eclipse.xtext.resource.IResourceDescriptions +import org.eclipse.xtext.resource.IResourceDescriptionsProvider +import org.eclipse.xtext.scoping.IScope +import org.eclipse.xtext.scoping.Scopes +import org.eclipse.xtext.scoping.impl.SimpleScope + +import static hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.CftLanguagePackage.Literals.* + +/** + * This class contains custom scoping description. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping + * on how and when to use it. + */ +class CftLanguageScopeProvider extends AbstractCftLanguageScopeProvider { + public static val SINGLETON_VARIABLE_PREFIX = "_" + + @Inject IResourceDescriptionsProvider resourceDescriptionsProvider + @Inject CftLanguageImportedNamespaceAwareLocalScopeProvider importedNamespaceProvider + + override getScope(EObject context, EReference reference) { + switch (reference) { + case LOOKUP_DEFINITION__MAPPING: + getRuleDefinitionsScope(context, reference) + case LOOKUP_DEFINITION__ARGUMENTS: + getMappingParametersScope(context) + case EVENT_REFERENCE__COMPONENT: + getComponentInstancesScope(context) + case EVENT_REFERENCE__EVENT: + getEventDeclarationsScope(context) + default: + super.getScope(context, reference) + } + } + + protected def getRuleDefinitionsScope(EObject context, EReference referece) { + val transformationDefinition = EcoreUtil2.getContainerOfType(context, TransformationDefinition) + if (transformationDefinition === null) { + return IScope.NULLSCOPE + } + val resourceDescriptions = getResourceDescriptions(transformationDefinition) + val mappingDefinitionDescriptions = toMappingDefinitionDescriptions(resourceDescriptions, + transformationDefinition.mappingDefinitions) + val ruleDefinitionsScope = new SimpleScope(IScope.NULLSCOPE, mappingDefinitionDescriptions) + importedNamespaceProvider.createImportNormalizedScope(ruleDefinitionsScope, context, referece) + } + + protected def toMappingDefinitionDescriptions(IResourceDescriptions resourceDescriptions, + Iterable ruleDefinitions) { + val mappingDefinitionDescriptions = Lists.newArrayListWithExpectedSize(ruleDefinitions.size) + for (ruleDefinition : ruleDefinitions) { + val pattern = ruleDefinition?.pattern + if (pattern !== null) { + val patternName = resourceDescriptions.getExportedObjectsByObject(pattern).head?.qualifiedName + if (patternName !== null) { + mappingDefinitionDescriptions += EObjectDescription.create(patternName, ruleDefinition) + } + } + + } + mappingDefinitionDescriptions + } + + private def getResourceDescriptions(Notifier notifier) { + val resourceSet = EcoreUtil2.getResourceSet(notifier) + if (resourceSet === null) { + new IResourceDescriptions.NullImpl + } else { + resourceDescriptionsProvider.getResourceDescriptions(resourceSet) + } + } + + protected def getMappingParametersScope(EObject context) { + val mappingDefinition = EcoreUtil2.getContainerOfType(context, MappingDefinition) + if (mappingDefinition === null) { + return IScope.NULLSCOPE + } + val variables = mappingDefinition.parameters.filter [ + !name.startsWith(SINGLETON_VARIABLE_PREFIX) + ] + Scopes.scopeFor(variables) + } + + protected def getComponentInstancesScope(EObject context) { + val mappingDefinition = EcoreUtil2.getContainerOfType(context, MappingDefinition) + if (mappingDefinition === null) { + return IScope.NULLSCOPE + } + val componentInstances = newArrayList + componentInstances.addAll(mappingDefinition.lookupDefinitions) + if (mappingDefinition.componentInstance !== null) { + componentInstances += mappingDefinition.componentInstance + } + Scopes.scopeFor(componentInstances) + } + + protected def getEventDeclarationsScope(EObject context) { + val variable = EcoreUtil2.getContainerOfType(context, EventReference)?.component + val events = switch (variable) { + ComponentInstance: + variable.componentType?.allEventDeclarations + LookupDefinition: + variable.mapping?.componentInstance?.componentType?.allEventDeclarations + default: + null + } + if (events === null) { + return IScope.NULLSCOPE + } + Scopes.scopeFor(events) + } + + private def getAllEventDeclarations(ComponentDefinition componentDefinition) { + val eventDeclarations = newArrayList + eventDeclarations.addAll(componentDefinition.inputEvents) + eventDeclarations.addAll(componentDefinition.eventDefinitions) + eventDeclarations + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/validation/CftLanguageValidator.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/validation/CftLanguageValidator.xtend new file mode 100644 index 00000000..f1da10bb --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src/hu/bme/mit/inf/dslreasoner/faulttree/components/validation/CftLanguageValidator.xtend @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.16.0 + */ +package hu.bme.mit.inf.dslreasoner.faulttree.components.validation + + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +class CftLanguageValidator extends AbstractCftLanguageValidator { + +// public static val INVALID_NAME = 'invalidName' +// +// @Check +// def checkGreetingStartsWithCapital(Greeting greeting) { +// if (!Character.isUpperCase(greeting.name.charAt(0))) { +// warning('Name should start with a capital', +// CftLanguagePackage.Literals.GREETING__NAME, +// INVALID_NAME) +// } +// } + +} -- cgit v1.2.3-70-g09d2