Page History

...

• Compositional Grammar v2.3.14,
• Template Syntax v1.1, and
• Expression Constraint Language v1.34.

As explained in 6. SNOMED CT Language Templates, references to the Template Syntax are also added into the Compositional Grammar rules to enable slots to be included within an expression template. Please note that rules that appear in both Compositional Grammar and the Expression Constraint Language (e.g. conceptId and term) are removed from the Expression Constraint Language (by commenting out) to avoid duplication.

; Compositional Grammar v2.3.1 4 with slot references (in blue)

expressionTemplate =  ws [ (definitionStatus / tokenReplacementSlot) ws] subExpression ws

subExpression = focusConcept [ws ":" ws refinement]

definitionStatus = equivalentTo / subtypeOf

equivalentTo = "===" 

subtypeOf = "<<<"

focusConcept = [templateInformationSlot ws] conceptReference *(ws "+" ws [templateInformationSlot ws] conceptReference) 

conceptReference = conceptReplacementSlot / expressionReplacementSlot / ( conceptId [ws "|" ws  term ws "|"] )

conceptId = sctId

term = nonwsNonPipe *( *SP nonwsNonPipe )

refinement = (attributeSet / attributeGroup) *( ws ["," ws] attributeGroup )

attributeGroup =   [ templateInformationSlot ws ] "{" ws attributeSet ws "}"

attributeSet = attribute *(ws "," ws attribute)

attribute = [ templateInformationSlot ws ] attributeName ws "=" ws attributeValue

attributeName = conceptReference

attributeValue = expressionValue / QM stringValue QM / "#" numericValue / booleanValue / concreteValueReplacementSlot

expressionValue = conceptReference / "(" ws subExpression ws ")"

stringValue = 1*(anyNonEscapedChar / escapedChar)

numericValue = ["-"/"+"] (decimalValue / integerValue)

integerValue =  digitNonZero *digit / zero

decimalValue = integerValue "." 1*digit

booleanValue = true / false

true = ("t"/"T") ("r"/"R") ("u"/"U") ("e"/"E")

false = ("f"/"F") ("a"/"A") ("l"/"L") ("s"/"S") ("e"/"E")

sctId = digitNonZero 5*17( digit )

ws = *( SP / HTAB / CR / LF ) ; optional white space

SP = %x20 ; space

HTAB = %x09 ; tab

CR = %x0D ; carriage return

LF = %x0A ; line feed

QM = %x22 ; quotation mark

BS = %x5C ; back slash

digit = %x30-39

zero = %x30

digitNonZero = %x31-39

nonwsNonPipe = %x21-7B / %x7D-7E / UTF8-2 / UTF8-3 / UTF8-4

anyNonEscapedChar = HTAB / CR / LF / %x20-21 / %x23-5B / %x5D-7E / UTF8-2 / UTF8-3 / UTF8-4

escapedChar = BS QM / BS BS

UTF8-2 = %xC2-DF UTF8-tail

UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) / %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )

UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) / %xF4 %x80-8F 2( UTF8-tail )

UTF8-tail = %x80-BF

; Template Syntax v1.1

templateSlot =  templateReplacementSlot / templateInformationSlot

templateReplacementSlot = conceptReplacementSlot / expressionReplacementSlot / tokenReplacementSlot / concreteValueReplacementSlot

conceptReplacementSlot conceptReplacementSlot = "[[" ws ws  "+" ws  "id" ws [ "(" ws expressionConstraint ws ")" ws] conceptReplacement [slotName ws] "]]"

expressionReplacementSlot = "[[" ws  "+" ws  expressionReplacement [slotName ws] "]]"

tokenReplacementSlot = "[[" ws  "+" ws  tokenReplacement [slotName ws] "]]"

expressionReplacementSlot concreteValueReplacementSlot = "[[" ws ws  "+" ws  concreteValueReplacement ["scgslotName ws] "]]"

conceptReplacement = "id" ws ]  [ "(" ws expressionConstraint slotExpressionConstraint ws ")" ws] [slotName ws] "]]

expressionReplacement = ["scg" ws] ["(" ws slotExpressionConstraint ws ")" ws]

tokenReplacement = "tokenReplacementSlot = "[[" ws "+" ws "tok" ws [ "(" ws slotTokenSet ws ")" ws] [slotName ws] "]]"

concreteValueReplacementSlotconcreteValueReplacement = stringReplacementSlot stringReplacement / integerReplacement / integerReplacementSlot decimalReplacement / decimalReplacementSlotbooleanReplacement

stringReplacementSlotstringReplacement =  "[[" ws "+" ws "str" ws [ "(" ws slotStringSet ws ")" ws] [slotName ws] "]]"

integerReplacementSlotintegerReplacement = "[[" ws "+" ws   = "int" ws [ "(" ws slotIntegerSet ws ")" ws] [slotName ws] "]]"decimalReplacementSlot

decimalReplacement =  "[[" ws "+" ws "dec" ws [ "(" ws slotDecimalSet ws ")" ws] [slotName ws] "]]" 

booleanReplacement = "bool" ws [ "(" ws slotBooleanSet ws ")" ws]

slotTokenSet = slotToken *(mws slotToken)

slotStringSet = slotString *(mws slotString)

slotIntegerSet = ( "#" integerValue slotIntegerValue / slotIntegerRange) *(mws ("#" integerValue slotIntegerValue / slotIntegerRange))

slotDecimalSet = ( "#" decimalValue slotDecimalValue / slotDecimalRange) *(mws ("#" decimalValue slotDecimalValue / slotDecimalRange))

slotBooleanSet = slotBooleanValue *(mws slotBooleanValue)

slotIntegerRange = ( slotIntegerMinimum to [ slotIntegerMaximum ] ) / ( to slotIntegerMaximum )

slotIntegerMinimum = [ exclusiveMinimum ] "#" integerValueslotIntegerValue

slotIntegerMaximum = [ exclusiveMaximum ] slotIntegerValue

slotIntegerValue = "#" digitNonZero *digit / "#" integerValuezero

slotDecimalRange = ( slotDecimalMinimum to [ slotDecimalMaximum ] ) / ( to slotDecimalMaximum )

slotDecimalMinimum = [ exclusiveMinimum ] "#" DecimalValueslotDecimalValue

slotDecimalMaximum = [ exclusiveMaximum ] slotDecimalValue

slotDecimalValue = "#" DecimalValue" integerValue "." 1*digit

exclusiveMinimum = ">"

exclusiveMaximum = "<"

slotBooleanValue = true / false

; true = ("t"/"T") ("r"/"R") ("u"/"U") ("e"/"E")

; false = ("f"/"F") ("a"/"A") ("l"/"L") ("s"/"S") ("e"/"E")

slotName = "@" (nonQuoteStringValue / slotString)

slotToken = definitionStatus / memberOf / constraintOperator / conjunction / disjunction / exclusion / reverseFlag / expressionComparisonOperator / numericComparisonOperator / stringComparisonOperator / stringComparisonOperatorbooleanComparisonOperator

slotString = QM stringValue slotStringValue QM

nonQuoteStringValue   = *(%x21 / %x23-26 / %x28%x2A-3F / %x41-5A / %x5C / %x5E-7E)   ; string with no ws, quotes, at, square brackets or square round brackets

templateInformationSlot   = "[[" ws slotInformation ws "]]"

slotInformation = [cardinality ws] [slotName ws] 

; Expression Constraint Language v1.3 4 - Note that some rules are commented out because they are repeated in the Compositional Grammar rules above.

expressionConstraintslotExpressionConstraint = ws ( refinedExpressionConstraint slotRefinedExpressionConstraint / compoundExpressionConstraint slotCompoundExpressionConstraint / dottedExpressionConstraint slotDottedExpressionConstraint / subExpressionConstraint slotSubExpressionConstraint ) ws

refinedExpressionConstraintslotRefinedExpressionConstraint = subExpressionConstraint slotSubExpressionConstraint ws ":" ws eclRefinementslotEclRefinement

compoundExpressionConstraintslotCompoundExpressionConstraint = conjunctionExpressionConstraint slotConjunctionExpressionConstraint / disjunctionExpressionConstraint slotDisjunctionExpressionConstraint / exclusionExpressionConstraintslotExclusionExpressionConstraint

conjunctionExpressionConstraintslotConjunctionExpressionConstraint = subExpressionConstraint slotSubExpressionConstraint 1*(ws conjunction ws subExpressionConstraintslotSubExpressionConstraint)

disjunctionExpressionConstraintslotDisjunctionExpressionConstraint = subExpressionConstraint slotSubExpressionConstraint 1*(ws disjunction ws subExpressionConstraintslotSubExpressionConstraint)

exclusionExpressionConstraintslotExclusionExpressionConstraint = subExpressionConstraint slotSubExpressionConstraint ws exclusion ws subExpressionConstraintslotSubExpressionConstraint

dottedExpressionConstraintslotDottedExpressionConstraint = subExpressionConstraint slotSubExpressionConstraint 1*(ws dottedExpressionAttributeslotDottedExpressionAttribute)

dottedExpressionAttributeslotDottedExpressionAttribute =  dot dot ws eclAttributeNameslotEclAttributeName

subExpressionConstraintslotSubExpressionConstraint = [constraintOperator ws] [memberOf ws] (eclFocusConcept slotEclFocusConcept /   "(" ws expressionConstraint slotExpressionConstraint ws ")")

eclFocusConceptslotEclFocusConcept = eclConceptReference slotEclConceptReference / wildCard

dot = "."

memberOf = "^"

eclConceptReferenceslotEclConceptReference = conceptId [ws "|" ws term ws "|"]

; conceptId = sctId

; term = 1*nonwsNonPipe *( 1*SP 1*nonwsNonPipe )

wildCardwildcard = "*"

constraintOperator = childOf / descendantOrSelfOf / descendantOf / parentOf / ancestorOrSelfOf / ancestorOf

descendantOf = "<"

descendantOrSelfOf = "<<"

childOf = "<!"

ancestorOf = ">"

ancestorOrSelfOf = ">>"

parentOf = ">!"

conjunction = (("a"/"A") ("n"/"N") ("d"/"D") mws) / ","

disjunction = ("o"/"O") ("r"/"R") mws

exclusion = ("m"/"M") ("i"/"I") ("n"/"N") ("u"/"U") ("s"/"S") mws

eclRefinementslotEclRefinement = subRefinement slotSubRefinement ws [conjunctionRefinementSet slotConjunctionRefinementSet / disjunctionRefinementSetslotDisjunctionRefinementSet]

conjunctionRefinementSetslotConjunctionRefinementSet = 1*(ws conjunction ws subRefinementslotSubRefinement)

disjunctionRefinementSetslotDisjunctionRefinementSet = 1*(ws disjunction ws subRefinementslotSubRefinement)

subRefinementslotSubRefinement = eclAttributeSet slotEclAttributeSet / eclAttributeGroup slotEclAttributeGroup / "(" ws eclRefinement slotEclRefinement ws ")"

eclAttributeSetslotEclAttributeSet = subAttributeSet slotSubAttributeSet ws [conjunctionAttributeSet slotConjunctionAttributeSet / disjunctionAttributeSetslotDisjunctionAttributeSet]

conjunctionAttributeSetslotConjunctionAttributeSet = 1*(ws conjunction ws subAttributeSetslotSubAttributeSet)

disjunctionAttributeSetslotDisjunctionAttributeSet = 1*(ws disjunction ws subAttributeSetslotSubAttributeSet)

subAttributeSetslotSubAttributeSet = eclAttribute slotEclAttribute / "(" ws eclAttributeSet slotEclAttributeSet ws ")"

eclAttributeGroupslotEclAttributeGroup = ["[" cardinality "]" ws] "{" ws eclAttributeSet slotEclAttributeSet ws "}"

eclAttributeslotEclAttribute = ["[" cardinality "]" ws] [reverseFlag ws] eclAttributeName slotEclAttributeName ws (expressionComparisonOperator ws subExpressionConstraint slotSubExpressionConstraint / numericComparisonOperator ws "#" numericValue slotNumericValue / stringComparisonOperator ws QM stringValue QMws slotStringValue / booleanComparisonOperator ws booleanValue)

cardinality = minValue to maxValue

minValue = nonNegativeIntegerValue

to = ".."

maxValue = nonNegativeIntegerValue / many

many = "*"

reverseFlag = "R"

eclAttributeNameslotEclAttributeName =  subExpressionConstraintslotSubExpressionConstraint

expressionComparisonOperator = "=" / "!="

numericComparisonOperator = "=" / "!=" / "<=" / "<" / ">=" / ">"

stringComparisonOperator = "=" / "!="

booleanComparisonOperator = "=" / "!="

; numericValueslotNumericValue = "#" ["-"/"+"] (decimalValue slotDecimalValue / integerValueslotIntegerValue)

; stringValueslotStringValue = QM 1*(anyNonEscapedChar / escapedChar) QM

; integerValue =  digitNonZero digitNonZero *digit / zero

; decimalValue = integerValue integerValue "."  1*digit1*digit

; booleanValue = true / false

; true = ("t"/"T") ("r"/"R") ("u"/"U") ("e"/"E")

; false = ("f"/"F") ("a"/"A") ("l"/"L") ("s"/"S") ("e"/"E")

nonNegativeIntegerValue = (digitNonZero *digit ) / zero

; sctId = digitNonZero 5*17( digit )

; ws = *( SP / HTAB / CR / LF / comment ) ; optional white space

mws = 1*( SP / HTAB / CR / LF / comment ) ; mandatory white space

comment = "/*" *(nonStarChar / starWithNonFSlash) "*/"

nonStarChar = SP / HTAB / CR / LF / %x21-29 / %x2B-7E /UTF8-2 / UTF8-3 / UTF8-4

starWithNonFSlash = %x2A nonFSlash

nonFSlash = SP / HTAB / CR / LF / %x21-2E / %x30-7E /UTF8-2 / UTF8-3 / UTF8-4

; SP = %x20 ; space

; HTAB = %x09 ; tab

; CR = %x0D ; carriage return

; LF = %x0A ; line feed

; QM = %x22 ; quotation mark

; BS = %x5C ; back slash

; digit = %x30-39

; zero = %x30

; digitNonZero = %x31-39

; nonwsNonPipe = %x21-7B / %x7D-7E / UTF8-2 / UTF8-3 / UTF8-4

; anyNonEscapedChar = SP / HTAB / CR / LF / %x20-21 / %x23-5B / %x5D-7E / UTF8-2 / UTF8-3 / UTF8-4

; escapedChar = BS QM / BS BS

; UTF8-2 = %xC2-DF UTF8-tail

; UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) / %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )

; UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) / %xF4 %x80-8F 2( UTF8-tail )

; UTF8-tail = %x80-BF

...