From 35eb8d9a749284040e1a0b0280c14da922b55a7f Mon Sep 17 00:00:00 2001 From: elvis Date: Mon, 15 Dec 2025 16:59:33 +0100 Subject: [PATCH] Context operation for positive --- assert/src/dsl.rs | 3 +- assert/src/positivedsl.rs | 243 ++++++++++++++++++ assert/src/positivefmt.rs | 46 ++++ assert/src/rsassert.rs | 6 + grammar_separated/src/assert.lalrpop | 41 ++- grammar_separated/src/grouping.lalrpop | 37 ++- grammar_separated/src/positive_assert.lalrpop | 28 +- .../src/positive_grouping.lalrpop | 28 +- 8 files changed, 411 insertions(+), 21 deletions(-) diff --git a/assert/src/dsl.rs b/assert/src/dsl.rs index 5e36d8d..b588d22 100644 --- a/assert/src/dsl.rs +++ b/assert/src/dsl.rs @@ -1320,7 +1320,8 @@ where | Range::IterateOverSet(exp) => { let type_exp = typecheck_expression(exp, c)?; match type_exp { - | AssertionTypes::Set => Ok(AssertionTypes::RangeSet), + | AssertionTypes::Set => + Ok(AssertionTypes::RangeSet), | AssertionTypes::RangeNeighbours => Ok(AssertionTypes::RangeNeighbours), | AssertionTypes::RangeContexts => diff --git a/assert/src/positivedsl.rs b/assert/src/positivedsl.rs index 4471c85..e000ffd 100644 --- a/assert/src/positivedsl.rs +++ b/assert/src/positivedsl.rs @@ -126,6 +126,25 @@ pub enum QualifierSystem { Context, } +#[derive(Clone, Copy, Serialize, Deserialize, Hash)] +pub enum QualifierContext { + IsNill, + IsIdentifier, + IsSet, + IsGuarded, + IsRepeated, + IsSummation, + IsNondeterministicChoice, + + GetSet, + GetGuardReactants, + GetGuardProducts, + GetRepeatedCounter, + GetRepeatedProcess, + + GetNextProcesses, +} + #[derive(Clone, Copy, Serialize, Deserialize, Hash)] pub enum QualifierEdge { Source, @@ -142,6 +161,7 @@ pub enum QualifierNode { #[derive(Clone, Copy, Serialize, Deserialize, Hash)] pub enum PositiveQualifier { System(QualifierSystem), + Context(QualifierContext), Label(QualifierLabel), Restricted(QualifierRestricted), Edge(QualifierEdge), @@ -187,6 +207,7 @@ pub(super) enum PositiveAssertionTypes { RangeInteger, RangeSet, RangeNeighbours, + RangeContexts, Node, Edge, @@ -205,6 +226,7 @@ pub enum PositiveAssertReturnValue { Neighbours(petgraph::graph::NodeIndex), System(system::PositiveSystem), Context(process::PositiveProcess), + RangeContext(process::PositiveProcess), } // ----------------------------------------------------------------------------- @@ -290,6 +312,105 @@ impl QualifierSystem { } } +impl QualifierContext { + pub(super) fn get(&self, l: &process::PositiveProcess) -> PositiveAssertReturnValue { + use process::PositiveProcess::*; + match self { + | Self::IsNill => PositiveAssertReturnValue::Boolean(matches!(l, Nill)), + | Self::IsIdentifier => + PositiveAssertReturnValue::Boolean(matches!(l, RecursiveIdentifier { + identifier: _, + })), + | Self::IsSet => + PositiveAssertReturnValue::Boolean(matches!(l, EntitySet { + entities: _, + next_process: _, + })), + | Self::IsGuarded => + PositiveAssertReturnValue::Boolean(matches!(l, Guarded { + reaction: _, + next_process: _, + })), + | Self::IsRepeated => + PositiveAssertReturnValue::Boolean(matches!(l, WaitEntity { + repeat: _, + repeated_process: _, + next_process: _, + })), + | Self::IsSummation => + PositiveAssertReturnValue::Boolean(matches!(l, Summation { + children: _, + })), + | Self::IsNondeterministicChoice => PositiveAssertReturnValue::Boolean( + matches!(l, NondeterministicChoice { children: _ }), + ), + + | Self::GetSet => PositiveAssertReturnValue::Set( + if let EntitySet { + entities, + next_process: _, + } = l + { + entities.clone() + } else { + Default::default() + }, + ), + | Self::GetGuardReactants => PositiveAssertReturnValue::Set( + if let Guarded { + reaction, + next_process: _, + } = l + { + reaction.reactants.clone() + } else { + Default::default() + }, + ), + | Self::GetGuardProducts => PositiveAssertReturnValue::Set( + if let Guarded { + reaction, + next_process: _, + } = l + { + reaction.products.clone() + } else { + Default::default() + }, + ), + | Self::GetRepeatedCounter => PositiveAssertReturnValue::Integer( + if let WaitEntity { + repeat, + repeated_process: _, + next_process: _, + } = l + { + *repeat + } else { + 0 + }, + ), + | Self::GetRepeatedProcess => { + PositiveAssertReturnValue::Context( + if let WaitEntity { + repeat: _, + repeated_process, + next_process: _, + } = l + { + (**repeated_process).clone() + } else { + Default::default() // nill + }, + ) + }, + + | Self::GetNextProcesses => + PositiveAssertReturnValue::RangeContext(l.clone()), + } + } +} + impl PositiveUnary { pub(super) fn is_prefix(&self) -> bool { match self { @@ -381,6 +502,78 @@ impl PositiveUnary { )), PositiveAssertionTypes::System, ) => Ok(PositiveAssertionTypes::Context), + | ( + Self::Qualifier(PositiveQualifier::Context(QualifierContext::IsNill)), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Boolean), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::IsIdentifier, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Boolean), + | ( + Self::Qualifier(PositiveQualifier::Context(QualifierContext::IsSet)), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Boolean), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::IsGuarded, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Boolean), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::IsRepeated, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Boolean), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::IsSummation, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Boolean), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::IsNondeterministicChoice, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Boolean), + | ( + Self::Qualifier(PositiveQualifier::Context(QualifierContext::GetSet)), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Set), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::GetGuardReactants, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Set), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::GetGuardProducts, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Set), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::GetRepeatedCounter, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Integer), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::GetRepeatedProcess, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::Context), + | ( + Self::Qualifier(PositiveQualifier::Context( + QualifierContext::GetNextProcesses, + )), + PositiveAssertionTypes::Context, + ) => Ok(PositiveAssertionTypes::RangeContexts), | ( Self::Qualifier(PositiveQualifier::Node(QualifierNode::System)), PositiveAssertionTypes::Node, @@ -809,6 +1002,10 @@ impl TypeContext { self.data.insert(v.clone(), PositiveAssertionTypes::Edge); Ok(()) }, + | PositiveAssertionTypes::RangeContexts => { + self.data.insert(v.clone(), PositiveAssertionTypes::Context); + Ok(()) + }, | _ => Err(format!("Range has incorrect type {ty:?}.")), } } @@ -1032,6 +1229,10 @@ impl PositiveAssertReturnValue { PositiveAssertReturnValue::System(sys), PositiveUnary::Qualifier(PositiveQualifier::System(q)), ) => Ok(q.get(&sys)), + | ( + PositiveAssertReturnValue::Context(c), + PositiveUnary::Qualifier(PositiveQualifier::Context(q)), + ) => Ok(q.get(&c)), | (val, u) => Err(format!( "Incompatible unary operation {u:?} on value \ {val:?}." @@ -1290,6 +1491,8 @@ where Ok(PositiveAssertionTypes::RangeSet), | PositiveAssertionTypes::RangeNeighbours => Ok(PositiveAssertionTypes::RangeNeighbours), + | PositiveAssertionTypes::RangeContexts => + Ok(PositiveAssertionTypes::RangeContexts), | _ => Err(format!( "Expressions in range is not a set or \ neighbours of a node, but is: {type_exp:?}." @@ -1381,6 +1584,46 @@ where .map(|x| PositiveAssertReturnValue::Edge(x.id())) .collect::>() .into_iter()), + | PositiveAssertReturnValue::RangeContext(ctxs) => { + use process::PositiveProcess::*; + Ok(match ctxs { + | Nill => vec![].into_iter(), + | RecursiveIdentifier { identifier: _ } => + vec![].into_iter(), + | EntitySet { + entities: _, + next_process, + } => vec![PositiveAssertReturnValue::Context( + (*next_process).clone(), + )] + .into_iter(), + | Guarded { + reaction: _, + next_process, + } => vec![PositiveAssertReturnValue::Context( + (*next_process).clone(), + )] + .into_iter(), + | WaitEntity { + repeat: _, + repeated_process, + next_process: _, + } => vec![PositiveAssertReturnValue::Context( + (*repeated_process).clone(), + )] + .into_iter(), + | Summation { children } => children + .iter() + .map(|c| PositiveAssertReturnValue::Context((**c).clone())) + .collect::>() + .into_iter(), + | NondeterministicChoice { children } => children + .iter() + .map(|c| PositiveAssertReturnValue::Context((**c).clone())) + .collect::>() + .into_iter(), + }) + } | _ => Err(format!("{val:?} is not a set in for cycle.")), } }, diff --git a/assert/src/positivefmt.rs b/assert/src/positivefmt.rs index a546793..b51f099 100644 --- a/assert/src/positivefmt.rs +++ b/assert/src/positivefmt.rs @@ -176,6 +176,29 @@ impl fmt::Debug for QualifierSystem { } } +impl fmt::Debug for QualifierContext { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + | Self::IsNill => write!(f, "isNill"), + | Self::IsIdentifier => write!(f, "isIdentifier"), + | Self::IsSet => write!(f, "isSet"), + | Self::IsGuarded => write!(f, "isGuarded"), + | Self::IsRepeated => write!(f, "isRepeated"), + | Self::IsSummation => write!(f, "isSummation"), + | Self::IsNondeterministicChoice => + write!(f, "isNondeterministicChoice"), + + | Self::GetSet => write!(f, "getSet"), + | Self::GetGuardReactants => write!(f, "getGuardReactants"), + | Self::GetGuardProducts => write!(f, "getGuardProducts"), + | Self::GetRepeatedCounter => write!(f, "getRepeatedCounter"), + | Self::GetRepeatedProcess => write!(f, "getRepeatedProcess"), + + | Self::GetNextProcesses => write!(f, "getNextProcesses"), + } + } +} + impl fmt::Debug for QualifierEdge { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { @@ -201,6 +224,7 @@ impl fmt::Debug for PositiveQualifier { | Self::Label(q) => write!(f, "{q:?}"), | Self::Restricted(q) => write!(f, "{q:?}"), | Self::System(q) => write!(f, "{q:?}"), + | Self::Context(q) => write!(f, "{q:?}"), | Self::Edge(q) => write!(f, "{q:?}"), | Self::Node(q) => write!(f, "{q:?}"), } @@ -250,6 +274,7 @@ impl fmt::Debug for PositiveAssertReturnValue { }, | Self::System(sys) => write!(f, "{{debug: {sys:?}}}"), | Self::Context(ctx) => write!(f, "{{debug: {ctx:?}}}"), + | Self::RangeContext(ctx) => write!(f, "{{debug: {ctx:?}}}"), } } } @@ -269,6 +294,7 @@ impl fmt::Debug for PositiveAssertionTypes { | Self::RangeInteger => write!(f, "range of integers"), | Self::RangeSet => write!(f, "range of set"), | Self::RangeNeighbours => write!(f, "range of edges"), + | Self::RangeContexts => write!(f, "range of contexts"), | Self::Edge => write!(f, "edge"), | Self::Node => write!(f, "node"), } @@ -523,6 +549,16 @@ impl PrintableWithTranslator for QualifierSystem { } } +impl PrintableWithTranslator for QualifierContext { + fn print( + &self, + f: &mut fmt::Formatter, + _translator: &Translator, + ) -> fmt::Result { + write!(f, "{self:?}") + } +} + impl PrintableWithTranslator for QualifierEdge { fn print( &self, @@ -557,6 +593,9 @@ impl PrintableWithTranslator for PositiveQualifier { | Self::System(q) => { write!(f, "{}", Formatter::from(translator, q)) }, + | Self::Context(q) => { + write!(f, "{}", Formatter::from(translator, q)) + }, | Self::Edge(q) => write!(f, "{}", Formatter::from(translator, q)), | Self::Node(q) => write!(f, "{}", Formatter::from(translator, q)), } @@ -601,6 +640,13 @@ impl PrintableWithTranslator for PositiveAssertReturnValue { | Self::Context(ctx) => { write!(f, "{}", Formatter::from(translator, ctx)) }, + | Self::RangeContext(ctx) => { + write!( + f, + "{{next processes of: {}}}", + Formatter::from(translator, ctx) + ) + }, } } } diff --git a/assert/src/rsassert.rs b/assert/src/rsassert.rs index 5e5593d..630f19a 100644 --- a/assert/src/rsassert.rs +++ b/assert/src/rsassert.rs @@ -38,6 +38,7 @@ pub mod useful_types_edge_relabeler { QualifierRestricted, QualifierLabel, QualifierSystem, + QualifierContext, QualifierEdge, QualifierNode, Qualifier, @@ -211,6 +212,7 @@ pub mod useful_types_node_relabeler { QualifierRestricted, QualifierLabel, QualifierSystem, + QualifierContext, QualifierEdge, QualifierNode, Qualifier, @@ -395,6 +397,7 @@ pub mod useful_types_positive_edge_relabeler { QualifierRestricted, QualifierLabel, QualifierSystem, + QualifierContext, QualifierEdge, QualifierNode, PositiveQualifier, @@ -510,6 +513,7 @@ impl positivedsl::PositiveAssert { .into()), | positivedsl::PositiveAssertionTypes::RangeInteger | positivedsl::PositiveAssertionTypes::RangeSet + | positivedsl::PositiveAssertionTypes::RangeContexts | positivedsl::PositiveAssertionTypes::RangeNeighbours => Err(format!("Returned type {ty:?} is not a valid return type.")), } @@ -579,6 +583,7 @@ pub mod useful_types_positive_node_relabeler { QualifierRestricted, QualifierLabel, QualifierSystem, + QualifierContext, QualifierEdge, QualifierNode, PositiveQualifier, @@ -704,6 +709,7 @@ impl positivedsl::PositiveAssert { .into()), | positivedsl::PositiveAssertionTypes::RangeInteger | positivedsl::PositiveAssertionTypes::RangeSet + | positivedsl::PositiveAssertionTypes::RangeContexts | positivedsl::PositiveAssertionTypes::RangeNeighbours => Err(format!("Returned type {ty:?} is not a valid return type.")), } diff --git a/grammar_separated/src/assert.lalrpop b/grammar_separated/src/assert.lalrpop index 94852cf..df81c38 100644 --- a/grammar_separated/src/assert.lalrpop +++ b/grammar_separated/src/assert.lalrpop @@ -18,14 +18,18 @@ extern { // order match { - "!", "!=", "%", "&&", "'", "(", ")", "*", "+", ",", "-", "..", "/", ":", - "::", ";", "<", "<=", "=", "==", ">", ">=", "AllInhibitors", "AllReactants", - "AvailableEntities", "Context", "Entities", "Inhibitors", - "InhibitorsPresent", "Products", "Reactants", "ReactantsAbsent", - "SystemContext", "SystemEntities", "[", "\"", "]", "^", "^^", "edge", - "else", "empty", "false", "for", "if", "in", "label", "length", "let", - "neighbours", "not", "rand", "return", "source", "system", "target", "then", - "toel", "tostr", "true", "{", "||", "}", + "!", "!=", "%", "&&", "'", "(", ")", "*", "+", ",", "-", "..", "/", ":", + "::", ";", "<", "<=", "=", "==", ">", ">=", "AllInhibitors", + "AllReactants", "AvailableEntities", "Context", "Entities", + "GetGuardInhibitors", "GetGuardProducts", "GetGuardReactants", + "GetIdentifier", "GetNextProcesses", "GetRepeatedCounter", + "GetRepeatedProcess", "GetSet", "Inhibitors", "InhibitorsPresent", + "IsGuarded", "IsIdentifier", "IsNill", "IsNondeterministicChoice", + "IsRepeated", "IsSet", "IsSummation", "Products", "Reactants", + "ReactantsAbsent", "SystemContext", "SystemEntities", "[", "\"", "]", "^", + "^^", "edge", "else", "empty", "false", "for", "if", "in", "label", + "length", "let", "neighbours", "not", "rand", "return", "source", + "system", "target", "then", "toel", "tostr", "true", "{", "||", "}", } else { r"[0-9]+" => NUMBER } else { @@ -248,6 +252,26 @@ AssertQualifierSystem: relabel::QualifierSystem = { "SystemContext" => relabel::QualifierSystem::Context, } +AssertQualifierContext: relabel::QualifierContext = { + "isNill" => relabel::QualifierContext::IsNill, + "isIdentifier" => relabel::QualifierContext::IsIdentifier, + "isSet" => relabel::QualifierContext::IsSet, + "isGuarded" => relabel::QualifierContext::IsGuarded, + "isRepeated" => relabel::QualifierContext::IsRepeated, + "isSummation" => relabel::QualifierContext::IsSummation, + "isNondeterministicChoice" => relabel::QualifierContext::IsNondeterministicChoice, + + "getIdentifier" => relabel::QualifierContext::GetIdentifier, + "getSet" => relabel::QualifierContext::GetSet, + "getGuardReactants" => relabel::QualifierContext::GetGuardReactants, + "getGuardInhibitors" => relabel::QualifierContext::GetGuardInhibitors, + "getGuardProducts" => relabel::QualifierContext::GetGuardProducts, + "getRepeatedCounter" => relabel::QualifierContext::GetRepeatedCounter, + "getRepeatedProcess" => relabel::QualifierContext::GetRepeatedProcess, + + "getNextProcesses" => relabel::QualifierContext::GetNextProcesses, +} + AssertQualifierEdge: relabel::QualifierEdge = { "source" => relabel::QualifierEdge::Source, "target" => relabel::QualifierEdge::Target, @@ -261,6 +285,7 @@ AssertQualifierNode: relabel::QualifierNode = { AssertQualifier: relabel::Qualifier = { => relabel::Qualifier::System(q), + => relabel::Qualifier::Context(q), => relabel::Qualifier::Label(q), => relabel::Qualifier::Restricted(q), => relabel::Qualifier::Edge(q), diff --git a/grammar_separated/src/grouping.lalrpop b/grammar_separated/src/grouping.lalrpop index 4ca65d5..fa82daf 100644 --- a/grammar_separated/src/grouping.lalrpop +++ b/grammar_separated/src/grouping.lalrpop @@ -21,12 +21,16 @@ extern { match { "!", "!=", "%", "&&", "'", "(", ")", "*", "+", ",", "-", "..", "/", ":", "::", ";", "<", "<=", "=", "==", ">", ">=", "AllInhibitors", "AllReactants", - "AvailableEntities", "Context", "Entities", "Inhibitors", - "InhibitorsPresent", "Products", "Reactants", "ReactantsAbsent", - "SystemContext", "SystemEntities", "[", "\"", "]", "^", "^^", "edge", - "else", "empty", "false", "for", "if", "in", "label", "length", "let", - "neighbours", "not", "rand", "return", "source", "system", "target", "then", - "toel", "tostr", "true", "{", "||", "}", "node", "entities", + "AvailableEntities", "Context", "Entities", "getGuardInhibitors", + "getGuardProducts", "getGuardReactants", "getIdentifier", + "getNextProcesses", "getRepeatedCounter", "getRepeatedProcess", "getSet", + "Inhibitors", "InhibitorsPresent", "isGuarded", "isIdentifier", "isNill", + "isNondeterministicChoice", "isRepeated", "isSet", "isSummation", + "Products", "Reactants", "ReactantsAbsent", "SystemContext", + "SystemEntities", "[", "\"", "]", "^", "^^", "edge", "else", "empty", + "entities", "false", "for", "if", "in", "label", "length", "let", + "neighbours", "node", "not", "rand", "return", "source", "system", "target", + "then", "toel", "tostr", "true", "{", "||", "}", } else { r"[0-9]+" => NUMBER } else { @@ -249,6 +253,26 @@ GroupQualifierSystem: grouping::QualifierSystem = { "SystemContext" => grouping::QualifierSystem::Context, } +GroupQualifierContext: grouping::QualifierContext = { + "isNill" => grouping::QualifierContext::IsNill, + "isIdentifier" => grouping::QualifierContext::IsIdentifier, + "isSet" => grouping::QualifierContext::IsSet, + "isGuarded" => grouping::QualifierContext::IsGuarded, + "isRepeated" => grouping::QualifierContext::IsRepeated, + "isSummation" => grouping::QualifierContext::IsSummation, + "isNondeterministicChoice" => grouping::QualifierContext::IsNondeterministicChoice, + + "getIdentifier" => grouping::QualifierContext::GetIdentifier, + "getSet" => grouping::QualifierContext::GetSet, + "getGuardReactants" => grouping::QualifierContext::GetGuardReactants, + "getGuardInhibitors" => grouping::QualifierContext::GetGuardInhibitors, + "getGuardProducts" => grouping::QualifierContext::GetGuardProducts, + "getRepeatedCounter" => grouping::QualifierContext::GetRepeatedCounter, + "getRepeatedProcess" => grouping::QualifierContext::GetRepeatedProcess, + + "getNextProcesses" => grouping::QualifierContext::GetNextProcesses, +} + GroupQualifierEdge: grouping::QualifierEdge = { "source" => grouping::QualifierEdge::Source, "target" => grouping::QualifierEdge::Target, @@ -262,6 +286,7 @@ GroupQualifierNode: grouping::QualifierNode = { GroupQualifier: grouping::Qualifier = { => grouping::Qualifier::System(q), + => grouping::Qualifier::Context(q), => grouping::Qualifier::Label(q), => grouping::Qualifier::Restricted(q), => grouping::Qualifier::Edge(q), diff --git a/grammar_separated/src/positive_assert.lalrpop b/grammar_separated/src/positive_assert.lalrpop index 213772f..db93133 100644 --- a/grammar_separated/src/positive_assert.lalrpop +++ b/grammar_separated/src/positive_assert.lalrpop @@ -23,9 +23,12 @@ match { "AvailableEntities", "Context", "Entities", "Inhibitors", "InhibitorsPresent", "Products", "Reactants", "ReactantsAbsent", "SystemContext", "SystemEntities", "[", "\"", "]", "^", "^^", "edge", - "else", "empty", "false", "for", "if", "in", "label", "length", "let", - "neighbours", "not", "rand", "return", "source", "system", "target", "then", - "toel", "tostr", "true", "{", "||", "}", + "else", "empty", "false", "for", "getGuardProducts", "getGuardReactants", + "getNextProcesses", "getRepeatedCounter", "getRepeatedProcess", "getSet", + "if", "in", "isGuarded", "isIdentifier", "isNill", + "isNondeterministicChoice", "isRepeated", "isSet", "isSummation", "label", + "length", "let", "neighbours", "not", "rand", "return", "source", "system", + "target", "then", "toel", "tostr", "true", "{", "||", "}", } else { r"[0-9]+" => NUMBER } else { @@ -252,6 +255,24 @@ AssertQualifierSystem: positive_relabel::QualifierSystem = { "SystemContext" => positive_relabel::QualifierSystem::Context, } +AssertQualifierContext: positive_relabel::QualifierContext = { + "isNill" => positive_relabel::QualifierContext::IsNill, + "isIdentifier" => positive_relabel::QualifierContext::IsIdentifier, + "isSet" => positive_relabel::QualifierContext::IsSet, + "isGuarded" => positive_relabel::QualifierContext::IsGuarded, + "isRepeated" => positive_relabel::QualifierContext::IsRepeated, + "isSummation" => positive_relabel::QualifierContext::IsSummation, + "isNondeterministicChoice" => positive_relabel::QualifierContext::IsNondeterministicChoice, + + "getSet" => positive_relabel::QualifierContext::GetSet, + "getGuardReactants" => positive_relabel::QualifierContext::GetGuardReactants, + "getGuardProducts" => positive_relabel::QualifierContext::GetGuardProducts, + "getRepeatedCounter" => positive_relabel::QualifierContext::GetRepeatedCounter, + "getRepeatedProcess" => positive_relabel::QualifierContext::GetRepeatedProcess, + + "getNextProcesses" => positive_relabel::QualifierContext::GetNextProcesses, +} + AssertQualifierEdge: positive_relabel::QualifierEdge = { "source" => positive_relabel::QualifierEdge::Source, "target" => positive_relabel::QualifierEdge::Target, @@ -265,6 +286,7 @@ AssertQualifierNode: positive_relabel::QualifierNode = { AssertQualifier: positive_relabel::PositiveQualifier = { => positive_relabel::PositiveQualifier::System(q), + => positive_relabel::PositiveQualifier::Context(q), => positive_relabel::PositiveQualifier::Label(q), => positive_relabel::PositiveQualifier::Restricted(q), => positive_relabel::PositiveQualifier::Edge(q), diff --git a/grammar_separated/src/positive_grouping.lalrpop b/grammar_separated/src/positive_grouping.lalrpop index 6d94a23..b1e6d0b 100644 --- a/grammar_separated/src/positive_grouping.lalrpop +++ b/grammar_separated/src/positive_grouping.lalrpop @@ -24,9 +24,12 @@ match { "AvailableEntities", "Context", "Entities", "Inhibitors", "InhibitorsPresent", "Products", "Reactants", "ReactantsAbsent", "SystemContext", "SystemEntities", "[", "\"", "]", "^", "^^", "edge", - "else", "empty", "false", "for", "if", "in", "label", "length", "let", - "neighbours", "not", "rand", "return", "source", "system", "target", "then", - "toel", "tostr", "true", "{", "||", "}", "node", + "else", "empty", "false", "for", "getGuardProducts", "getGuardReactants", + "getNextProcesses", "getRepeatedCounter", "getRepeatedProcess", "getSet", + "if", "in", "isGuarded", "isIdentifier", "isNill", + "isNondeterministicChoice", "isRepeated", "isSet", "isSummation", "label", + "length", "let", "neighbours", "node", "not", "rand", "return", "source", + "system", "target", "then", "toel", "tostr", "true", "{", "||", "}", } else { r"[0-9]+" => NUMBER } else { @@ -253,6 +256,24 @@ GroupQualifierSystem: positive_grouping::QualifierSystem = { "SystemContext" => positive_grouping::QualifierSystem::Context, } +GroupQualifierContext: positive_grouping::QualifierContext = { + "isNill" => positive_grouping::QualifierContext::IsNill, + "isIdentifier" => positive_grouping::QualifierContext::IsIdentifier, + "isSet" => positive_grouping::QualifierContext::IsSet, + "isGuarded" => positive_grouping::QualifierContext::IsGuarded, + "isRepeated" => positive_grouping::QualifierContext::IsRepeated, + "isSummation" => positive_grouping::QualifierContext::IsSummation, + "isNondeterministicChoice" => positive_grouping::QualifierContext::IsNondeterministicChoice, + + "getSet" => positive_grouping::QualifierContext::GetSet, + "getGuardReactants" => positive_grouping::QualifierContext::GetGuardReactants, + "getGuardProducts" => positive_grouping::QualifierContext::GetGuardProducts, + "getRepeatedCounter" => positive_grouping::QualifierContext::GetRepeatedCounter, + "getRepeatedProcess" => positive_grouping::QualifierContext::GetRepeatedProcess, + + "getNextProcesses" => positive_grouping::QualifierContext::GetNextProcesses, +} + GroupQualifierEdge: positive_grouping::QualifierEdge = { "source" => positive_grouping::QualifierEdge::Source, "target" => positive_grouping::QualifierEdge::Target, @@ -266,6 +287,7 @@ GroupQualifierNode: positive_grouping::QualifierNode = { GroupQualifier: positive_grouping::PositiveQualifier = { => positive_grouping::PositiveQualifier::System(q), + => positive_grouping::PositiveQualifier::Context(q), => positive_grouping::PositiveQualifier::Label(q), => positive_grouping::PositiveQualifier::Restricted(q), => positive_grouping::PositiveQualifier::Edge(q),