v4.1.4

Author: christoph-grimm

build.gradle.kts

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
  * - also set the value standalone according to your setup
  */
 group = "com.github.tukcps"
-version = "4.1.3" // must be number.number.number
+version = "4.1.4" // must be number.number.number
 val aaddVersion = "0.1.11"
 val sysmlapiVersion = "3.9.5"
 val useMavenAADD = true
@@ -36,7 +36,7 @@ plugins {
  id("com.github.ben-manes.versions") version "0.52.0"
  id("idea")
  kotlin("jvm") version "2.2.0"
- kotlin("plugin.serialization") version "2.2.0"
+ kotlin("plugin.serialization") version "2.2.10"
  id("org.springframework.boot") version "3.5.4"
  id("io.spring.dependency-management") version "1.1.7"
  alias(libs.plugins.jetbrainsCompose) apply true

gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-kotlin = "2.2.0"
+kotlin = "2.2.10"
 compose-plugin = "1.8.2"
 
 [plugins]

src/main/kotlin/com/github/tukcps/sysmd/compiler/KerML.kt

@@ -13,6 +13,11 @@ import com.github.tukcps.sysmd.compiler.semantics.ActionsContext
 import com.github.tukcps.sysmd.exceptions.Issue
 import com.github.tukcps.sysmd.exceptions.SyntaxError
 import com.github.tukcps.sysmd.exceptions.SysMDException
+import com.github.tukcps.sysmd.model.kerml.UnresolvedElement
+import com.github.tukcps.sysmd.model.kerml.UnresolvedFeature
+import com.github.tukcps.sysmd.model.kerml.UnresolvedFeatureChain
+import com.github.tukcps.sysmd.model.kerml.UnresolvedNamespace
+import com.github.tukcps.sysmd.model.kerml.UnresolvedType
 import com.github.tukcps.sysmd.model.util.QualifiedName
 import com.github.tukcps.sysmd.quantities.Quantity
 import com.github.tukcps.sysmd.services.session.Session
@@ -168,8 +173,8 @@ open class KerML(
  (token.kind != SEMICOLON || nested > 0)
  && token.kind != EOF
  && (token.kind != RCURBRACE || nested <= 0)) {
- if (token.kind == LCURBRACE) nested = nested+1
- if (token.kind == RCURBRACE) nested = nested-1
+ if (token.kind == LCURBRACE) nested += 1
+ if (token.kind == RCURBRACE) nested -= 1
  consume()
  }
  // If parser skips right curly brace, we need to also pop one from the owner stack.
@@ -189,8 +194,8 @@ open class KerML(
  && token.kind != EOF
  && (token.kind != RCURBRACE || nested <= 0)
  ) {
- if (token.kind == LCURBRACE) nested = nested+1
- if (token.kind == RCURBRACE) nested = nested-1
+ if (token.kind == LCURBRACE) nested += 1
+ if (token.kind == RCURBRACE) nested -= 1
  consume()
  }
  // If parser skips right curly brace, we need to also pop one from the owner stack.
@@ -213,4 +218,34 @@ open class KerML(
  this@KerML.rule()
  }
  }
+
+ fun unresolvedFeature(relativeName: String): UnresolvedFeature =
+ UnresolvedFeature(relativeName = relativeName).also {
+ it.input = input
+ it.indices = indices
+ }
+
+ fun unresolvedFeatureChain(relativeName: String): UnresolvedFeatureChain =
+ UnresolvedFeatureChain(relativeName = relativeName).also {
+ it.input = input
+ it.indices = indices
+ }
+
+ fun unresolvedType(relativeName: String): UnresolvedType =
+ UnresolvedType(relativeName = relativeName).also {
+ it.input = input
+ it.indices = indices
+ }
+
+ fun unresolvedElement(relativeName: String): UnresolvedElement =
+ UnresolvedElement(relativeName = relativeName).also {
+ it.input = input
+ it.indices = indices
+ }
+
+ fun unresolvedNamespace(relativeName: String): UnresolvedNamespace =
+ UnresolvedNamespace(relativeName = relativeName).also {
+ it.input = input
+ it.indices = indices
+ }
 }

src/main/kotlin/com/github/tukcps/sysmd/compiler/parser/kerml/KerMLCore.kt

@@ -244,8 +244,8 @@ fun KerML.SpecificType() =
 
 fun KerML.GeneralType(): Feature =
  when(nextToken.kind) {
- DOT -> FeatureChain().let { return UnresolvedFeatureChain(it) }
- else -> QualifiedName().let { return UnresolvedFeature(it) }
+ DOT -> FeatureChain().let { return unresolvedFeatureChain(it) }
+ else -> QualifiedName().let { return unresolvedFeature(it) }
  }
 
 /**
@@ -279,9 +279,9 @@ fun KerML.Conjugation() {
  Identification().also { conjugation.create(it) }
  } else conjugation.create(null)
  CONJUGATE.consume()
- QualifiedName().also { conjugation.created.conjugatedType = UnresolvedType(it) }
+ QualifiedName().also { conjugation.created.conjugatedType = unresolvedType(it) }
  CONJUGATES.consume()
- QualifiedName().also { conjugation.created.originalType = UnresolvedType(it) }
+ QualifiedName().also { conjugation.created.originalType = unresolvedType(it) }
  RelationshipBody()
 }
 

src/main/kotlin/com/github/tukcps/sysmd/compiler/parser/kerml/KerMLExpression.kt

@@ -39,7 +39,7 @@ fun KerML.BooleanExpression(): AstNode {
 /**
  * conditionalExpression :- IF expression ? expression ELSE expression
  */
-fun KerML.ConditionalExpression(): AstNode? {
+fun KerML.ConditionalExpression(): AstNode {
  val action = ConditionalExpressionActions(semantics)
  IF.consume()
  Expression().also { action.condExpr = it }

src/main/kotlin/com/github/tukcps/sysmd/compiler/parser/kerml/KerMLRoot.kt

@@ -8,7 +8,7 @@ import com.github.tukcps.sysmd.compiler.scanner.Token.Kind.*
 import com.github.tukcps.sysmd.compiler.semantics.Identification
 import com.github.tukcps.sysmd.compiler.semantics.kerml.*
 import com.github.tukcps.sysmd.model.kerml.Dependency
-import com.github.tukcps.sysmd.model.kerml.UnresolvedElement
+import com.github.tukcps.sysmd.model.kerml.Import
 import com.github.tukcps.sysmd.model.kerml.implementation.*
 
 /**
@@ -76,9 +76,9 @@ fun KerML.Dependency() {
  FROM.consume()
  } else
  dependency.create(Identification(null, null))
- QualifiedNameList().forEach { dependency.created.source.add(UnresolvedElement(it)) }
+ QualifiedNameList().forEach { dependency.created.source.add(unresolvedElement(it)) }
  TO.consume()
- QualifiedNameList().forEach { dependency.created.target.add(UnresolvedElement(it)) }
+ QualifiedNameList().forEach { dependency.created.target.add(unresolvedElement(it)) }
  RelationshipBody()
 }
 
@@ -116,13 +116,13 @@ fun KerML.OwnedRelatedElement() {
  */
 fun KerML.MemberPrefix() {
  alternatives {
- PUBLIC starts { PUBLIC.consume(); semantics.visibilityKind = PUBLIC }
- PRIVATE starts { PRIVATE.consume(); semantics.visibilityKind = PRIVATE }
- PROTECTED starts { PROTECTED.consume(); semantics.visibilityKind = PROTECTED }
+ PUBLIC starts { PUBLIC.consume(); semantics.visibility = Import.VisibilityKind.Public }
+ PRIVATE starts { PRIVATE.consume(); semantics.visibility = Import.VisibilityKind.Private }
+ PROTECTED starts { PROTECTED.consume(); semantics.visibility = Import.VisibilityKind.Protected }
  others { }
  }
  ABSTRACT.optional { semantics.prefixes.add(ABSTRACT) }
- INDIVIDUAL.optional { semantics.prefixes.add(INDIVIDUAL) }
+ // INDIVIDUAL.optional { semantics.prefixes.add(INDIVIDUAL) }
 }
 
 /**
@@ -164,18 +164,17 @@ fun KerML.NamespaceBodyElement() {
  * ( 'locale' STRING_VALUE )?
  * REGULAR_COMMENT
  */
-internal fun KerML.Comment() {
- val comment = CommentActions(semantics, ::CommentImplementation)
- comment.create()
+internal fun KerML.Comment() = CommentActions(semantics, ::CommentImplementation).parse {
+ create()
  COMMENT.optional {
  optional(NAME_LIT) {
- Identification().also { comment.setIdentification(it) }
+ Identification().also { setIdentification(it) }
  }
  ABOUT.optional {
- QualifiedNameList().also { comment.addAbout(it) }
+ QualifiedNameList().also { (this as CommentActions).addAbout(it) }
  }
  }
- REGULAR_COMMENT.consume().also { comment.created.body = consumedToken.string.trimIndent().trim() }
+ REGULAR_COMMENT.consume().also { created.body = consumedToken.string.trimIndent().trim() }
 }
 
 /**
@@ -184,11 +183,10 @@ internal fun KerML.Comment() {
  * ( 'locale' STRING_VALUE )?
  * REGULAR_COMMENT
  */
-internal fun KerML.Documentation() {
- val doc = DocumentationActions(semantics)
+internal fun KerML.Documentation() = DocumentationActions(semantics).parse {
  DOC.consume()
- Identification().also { doc.create(it) }
- REGULAR_COMMENT.consume().also { doc.created.body = consumedToken.string.trim() }
+ Identification().also { create(it) }
+ REGULAR_COMMENT.consume().also { created.body = consumedToken.string.trim() }
 }
 
 /**
@@ -197,16 +195,15 @@ internal fun KerML.Documentation() {
  * 'language' STRING_VALUE
  * REGULAR_COMMENT
  */
-internal fun KerML.TextualRepresentation() {
- val rep = AnnotatingElementActions(semantics, ::TextualRepresentationImplementation)
- rep.create()
+internal fun KerML.TextualRepresentation() = AnnotatingElementActions(semantics, ::TextualRepresentationImplementation).parse {
+ create()
  optional(REP) {
  REP.consume()
- Identification().also { rep.setIdentification(it) }
+ Identification().also { setIdentification(it) }
  }
  LANGUAGE.consume()
- NAME_LIT.consume().also { rep.created.language = consumedToken.string }
- REGULAR_COMMENT.consume().also { rep.created.body = consumedToken.string.trim(' ') }
+ NAME_LIT.consume().also { created.language = consumedToken.string }
+ REGULAR_COMMENT.consume().also { created.body = consumedToken.string.trim(' ') }
 }
 
 /**
@@ -244,33 +241,52 @@ internal fun KerML.NamespaceBody() {
  *
  * Import = ( VisibilityIndicator )?
  * 'import' 'all'? ImportDeclaration RelationshipBody
- *
+ */
+internal fun KerML.Import() = ImportActions(semantics).parseImport {
+ IMPORT.consume()
+ ALL.optional { isImportAll = true }
+ ImportDeclaration(this)
+ RelationshipBody()
+}
+
+/**
  * ImportDeclaration = MembershipImport | NamespaceImport
- *
- * MembershipImport = [QualifiedName] ( '::' '**'? )?
- *
- * NamespaceImport = [QualifiedName] '::' '*' ( '::' '**'? )?
+ */
+internal fun KerML.ImportDeclaration(actions: ImportActions) {
+ QualifiedName().also { actions.importQualifiedName = it }
+ alternatives {
+ DPDP then TIMES starts { NamespaceImport(actions) }
+ others { MembershipImport(actions) }
+ }
+}
+
+/**
+ * MembershipImport = [QualifiedName] ('::' '**'?)?
+ */
+internal fun KerML.MembershipImport(actions: ImportActions) {
+ DPDP.optional {
+ STARSTAR.optional().also { actions.isRecursive = true }
+ }
+ actions.createMembershipImport()
+}
+
+/**
+ * NamespaceImport = [QualifiedName] '::' '*' ('::' '**'?)?
  * | FilterPackage
  *
- * FilterPackage =
- * ImportDeclaration ( FilterPackageMember )+
+ * FilterPackage = ImportDeclaration ( FilterPackageMember )+
  *
  * FilterPackageMember = '[' OwnedExpression ']'
  */
-internal fun KerML.Import() {
- val import = ImportActions(semantics)
- IMPORT.consume().also { import.create() }
- ALL.optional { import.all = true }
-
- QualifiedName().also { import.setImportedNamespace(it) }
- optional(DPDP, consume = true) {
- alternatives {
- STARSTAR starts { import.isRecursive = true; STARSTAR.consume() }
- TIMES starts { TIMES.consume() }
+internal fun KerML.NamespaceImport(actions: ImportActions) {
+ DPDP.consume()
+ TIMES.optional {
+ DPDP.optional {
+ actions.isRecursive = true
+ STARSTAR.consume()
  }
  }
- RelationshipBody()
- import.finish()
+ actions.createNamespaceImport()
 }
 
 /**
@@ -288,7 +304,7 @@ internal fun KerML.AliasMember() {
  aliasMember.created.membershipOwningNamespace = semantics.element()
  }
  FOR.consume()
- QualifiedName().also { aliasMember.created.target = mutableListOf(UnresolvedElement(it)) }
+ QualifiedName().also { aliasMember.created.target = mutableListOf(unresolvedElement(it)) }
  RelationshipBody()
 }
 

src/main/kotlin/com/github/tukcps/sysmd/compiler/parser/sysmlv2/Attribute.kt

@@ -15,7 +15,7 @@ import com.github.tukcps.sysmd.model.sysml.implementation.AttributeDefinitionImp
  *
  * AttributeDefinition = DefinitionPrefix 'attribute' 'def' Definition
  */
-fun SysMLv2.AttributeDefinition() = AttributeDefinitionActions<AttributeDefinition>(this.semantics, ::AttributeDefinitionImplementation).parse {
+fun SysMLv2.AttributeDefinition() = AttributeDefinitionActions(this.semantics, ::AttributeDefinitionImplementation).parse {
  ATTRIBUTE.consume()
  DEF.consume()
  DefinitionDeclaration()

src/main/kotlin/com/github/tukcps/sysmd/compiler/parser/sysmlv2/Occurrence.kt

@@ -3,6 +3,8 @@
 package com.github.tukcps.sysmd.compiler.parser.sysmlv2
 
 import com.github.tukcps.sysmd.compiler.SysMLv2
+import com.github.tukcps.sysmd.compiler.parser.kerml.FeatureSpecializationPart
+import com.github.tukcps.sysmd.compiler.parser.kerml.OwnedReferenceSubsetting
 import com.github.tukcps.sysmd.compiler.scanner.Token.Kind.*
 import com.github.tukcps.sysmd.compiler.semantics.kerml.FeatureActions
 import com.github.tukcps.sysmd.compiler.semantics.sysmlv2.OccurrenceDefinitionActions
@@ -18,16 +20,25 @@ import com.github.tukcps.sysmd.model.kerml.implementation.FeatureImplementation
  * 8.2.2.9.1 Occurrence Definitions
  *
  * OccurrenceDefinitionPrefix = BasicDefinitionPrefix? ( 'individual' )? DefinitionExtensionKeyword*
+ * OccurrenceDefinition = OccurrenceDefinitionPrefix 'occurrence' 'def' Definition
  *
- * OccurrenceDefinition = OccurrenceDefinitionPrefix 'occurrence' 'def' Definition
- *
- * IndividualDefinition = BasicDefinitionPrefix? 'individual' DefinitionExtensionKeyword* 'def' Definition
  */
 fun SysMLv2.OccurrenceDefinition() = OccurrenceDefinitionActions(semantics).parse {
+ INDIVIDUAL.optional()
+ // DefinitionExtensionKeyword
  OCCURRENCE.consume()
  DEF.consume()
- DefinitionDeclaration()
- DefinitionBody()
+ Definition()
+}
+
+/**
+ * IndividualDefinition = BasicDefinitionPrefix? 'individual' DefinitionExtensionKeyword* 'def' Definition
+ */
+fun SysMLv2.IndividualDefinition() = OccurrenceDefinitionActions(semantics).parse {
+ INDIVIDUAL.consume()
+ // DefinitionExtensionKeyword
+ DEF.consume()
+ Definition()
 }
 
 
@@ -64,9 +75,10 @@ fun SysMLv2.OccurrenceUsage() = OccurrenceUsageActions(semantics).parse {
  */
 fun SysMLv2.PortionUsage() = FeatureActions<Feature>(semantics, defaultType = "Occurrences::Occurrence", creator = ::FeatureImplementation).parse {
  INDIVIDUAL.optional()
- alternatives { // PortionKind
- SNAPSHOT starts { consume(); }
- TIMESLICE starts { consume(); }
+ when(token.kind) { // PortionKind
+ SNAPSHOT -> { consume(); }
+ TIMESLICE -> { consume(); }
+ else -> { handleSyntaxError("Expected a portion kind (snapshot, timeslice)")}
  }
  UsageExtensionKeyword()
  Usage()
@@ -81,13 +93,16 @@ fun SysMLv2.PortionUsage() = FeatureActions<Feature>(semantics, defaultType = "O
  */
 fun SysMLv2.EventOccurrenceUsage() = FeatureActions<Feature>(semantics, ::FeatureImplementation, "Occurrences::Occurrence").parse {
  EVENT.consume()
- alternatives {
- OCCURRENCE starts {
+ when(token.kind) {
+ OCCURRENCE -> {
  OCCURRENCE.consume().also { semantics.prefixes.add(OUT) }
  UsageDeclaration()
  }
- // OwnedReferenceSubsetting()
- // FeatureSpecializationPart(eventOccurrenceUsage)
+ NAME_LIT -> {
+ OwnedReferenceSubsetting()
+ FeatureSpecializationPart()
+ }
+ else -> { handleSyntaxError("Expected occurrence, reference subsetting, or feature specification")}
  }
  UsageCompletion()
 }