elvis/ReactionSystems
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Context operation for positive

Browse Source
This commit is contained in:
elvis
2025-12-15 16:59:33 +01:00
parent bbd482e2ce
commit 35eb8d9a74
8 changed files with 411 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
grammar_separated/src/assert.lalrpop
View File

@ -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 = {
<q: AssertQualifierSystem> => relabel::Qualifier::System(q),
<q: AssertQualifierContext> => relabel::Qualifier::Context(q),
<q: AssertQualifierLabel> => relabel::Qualifier::Label(q),
<q: AssertQualifierRestricted> => relabel::Qualifier::Restricted(q),
<q: AssertQualifierEdge> => relabel::Qualifier::Edge(q),

37
grammar_separated/src/grouping.lalrpop
View File

@ -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 = {
<q: GroupQualifierSystem> => grouping::Qualifier::System(q),
<q: GroupQualifierContext> => grouping::Qualifier::Context(q),
<q: GroupQualifierLabel> => grouping::Qualifier::Label(q),
<q: GroupQualifierRestricted> => grouping::Qualifier::Restricted(q),
<q: GroupQualifierEdge> => grouping::Qualifier::Edge(q),

28
grammar_separated/src/positive_assert.lalrpop
View File

@ -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 = {
<q: AssertQualifierSystem> => positive_relabel::PositiveQualifier::System(q),
<q: AssertQualifierContext> => positive_relabel::PositiveQualifier::Context(q),
<q: AssertQualifierLabel> => positive_relabel::PositiveQualifier::Label(q),
<q: AssertQualifierRestricted> => positive_relabel::PositiveQualifier::Restricted(q),
<q: AssertQualifierEdge> => positive_relabel::PositiveQualifier::Edge(q),

28
grammar_separated/src/positive_grouping.lalrpop
View File

@ -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 = {
<q: GroupQualifierSystem> => positive_grouping::PositiveQualifier::System(q),
<q: GroupQualifierContext> => positive_grouping::PositiveQualifier::Context(q),
<q: GroupQualifierLabel> => positive_grouping::PositiveQualifier::Label(q),
<q: GroupQualifierRestricted> => positive_grouping::PositiveQualifier::Restricted(q),
<q: GroupQualifierEdge> => positive_grouping::PositiveQualifier::Edge(q),