117 lines
3.8 KiB
Plaintext
117 lines
3.8 KiB
Plaintext
use std::rc::Rc;
|
|
use std::str::FromStr;
|
|
use lalrpop_util::ParseError;
|
|
use crate::rsprocess::structure::{RSset, RSprocess, RSenvironment, RSassert, RSassertOp, RSBHML};
|
|
|
|
grammar;
|
|
|
|
// matches words (letter followed by numbers, letters or _)
|
|
Literal = { r"[[:alpha:]][[:word:]]*" };
|
|
|
|
// all numbers are i64
|
|
Num: i64 = {
|
|
r"[0-9]+" =>? i64::from_str(<>)
|
|
.map_err(|_| ParseError::User { error: "Number is too big" })
|
|
};
|
|
|
|
// macro for matching sequence of patterns with C as separator
|
|
Separeted<T, C>: Vec<T> = {
|
|
<mut v:(<T> C)+> <e:T?> => match e {
|
|
None => v,
|
|
Some(e) => {
|
|
v.push(e);
|
|
v
|
|
}
|
|
}
|
|
};
|
|
|
|
// ----- SetParser -----
|
|
pub Set: RSset<'input> = {
|
|
<s: Set_of_entities> => s
|
|
};
|
|
|
|
Set_of_entities: RSset<'input> = {
|
|
"{" "}" => RSset::from(vec![]),
|
|
"{" <t: Literal> "}" => RSset::from(vec![t]),
|
|
"{" <t: Separeted<Literal, ",">> "}" => RSset::from(t)
|
|
};
|
|
|
|
// ----- ContextParser -----
|
|
pub Context: Box<RSprocess<'input>> = {
|
|
// "[" "]" => Box::new(RSprocess::Nill),
|
|
// "[" <t: CTX_process> "]" => Box::new(t),
|
|
// "[" <t: Separeted<Boxed_CTX_process, ",">> "]" =>
|
|
// Box::new(RSprocess::NondeterministicChoice{ children: t })
|
|
|
|
"[" "]" => Box::new(RSprocess::NondeterministicChoice{ children: vec![] }),
|
|
"[" <t: CTX_process> "]" => Box::new(RSprocess::NondeterministicChoice{ children: vec![Rc::new(t)] }),
|
|
"[" <t: Separeted<Boxed_CTX_process, ",">> "]" =>
|
|
Box::new(RSprocess::NondeterministicChoice{ children: t })
|
|
};
|
|
|
|
Boxed_CTX_process: Rc<RSprocess<'input>> = {
|
|
<t: CTX_process> => Rc::new(t)
|
|
}
|
|
|
|
CTX_process: RSprocess<'input> = {
|
|
<c: Set_of_entities> "." <k: CTX_process> =>
|
|
RSprocess::EntitySet{ entities: c, next_process: Rc::new(k) },
|
|
"(" <k: CTX_process> ")" => k,
|
|
"(" <k: Separeted<CTX_process, "+">> ")" =>
|
|
RSprocess::Summation{ children: k },
|
|
"<" <n: Num> <k1: CTX_process> ">" "." <k: CTX_process> =>
|
|
RSprocess::WaitEntity{ repeat: n,
|
|
repeated_process: Rc::new(k1),
|
|
next_process: Rc::new(k)},
|
|
"nil" => RSprocess::Nill,
|
|
<identifier: Literal> =>
|
|
RSprocess::RecursiveIdentifier{ identifier }
|
|
};
|
|
|
|
// ----- EnvironmentParser -----
|
|
pub Environment: Box<RSenvironment<'input>> = {
|
|
"[" "]" => Box::new(RSenvironment::new()),
|
|
"[" <t: Separeted<Env_term, ",">> "]" => Box::new(RSenvironment::from(t))
|
|
};
|
|
|
|
Env_term: (&'input str, RSprocess<'input>) = {
|
|
<identifier: Literal> "=" <k: CTX_process> => (identifier, k)
|
|
};
|
|
|
|
// ----- AssertParser -----
|
|
pub Assert: Box<RSassert<'input>> = {
|
|
<f: Formula_Assert> => Box::new(f)
|
|
};
|
|
|
|
Formula_Assert: RSassert<'input> = {
|
|
"-" <f: Formula_Assert> => RSassert::Not(Box::new(f)),
|
|
"(" <f1: Formula_Assert> "^" <f2: Formula_Assert> ")" =>
|
|
RSassert::Xor(Box::new(f1), Box::new(f2)),
|
|
"(" <f: Separeted<Formula_Assert, "\\/">> ")" => RSassert::Or(f),
|
|
"(" <f: Separeted<Formula_Assert, "/\\">> ")" => RSassert::And(f),
|
|
<c: Set_of_entities> "inW" => RSassert::Sub(c, RSassertOp::InW),
|
|
<c: Set_of_entities> "inR" => RSassert::Sub(c, RSassertOp::InR),
|
|
<c: Set_of_entities> "inI" => RSassert::Sub(c, RSassertOp::InI),
|
|
<c: Set_of_entities> "inP" => RSassert::Sub(c, RSassertOp::InP),
|
|
"?" "inW" => RSassert::NonEmpty(RSassertOp::InW),
|
|
"?" "inR" => RSassert::NonEmpty(RSassertOp::InR),
|
|
"?" "inI" => RSassert::NonEmpty(RSassertOp::InI),
|
|
"?" "inP" => RSassert::NonEmpty(RSassertOp::InP),
|
|
};
|
|
|
|
// ----- BHMLParser -----
|
|
pub BHML: Box<RSBHML<'input>> = {
|
|
<g: Formula_BHML> => Box::new(g)
|
|
};
|
|
|
|
Formula_BHML: RSBHML<'input> = {
|
|
"true" => RSBHML::True,
|
|
"false" => RSBHML::False,
|
|
"(" <g: Separeted<Formula_BHML, "\\/">> ")" => RSBHML::Or(g),
|
|
"(" <g: Separeted<Formula_BHML, "/\\">> ")" => RSBHML::And(g),
|
|
"<" <f: Formula_Assert> ">" <g: Formula_BHML> =>
|
|
RSBHML::Diamond(Box::new(f), Box::new(g)),
|
|
"[" <f: Formula_Assert> "]" <g: Formula_BHML> =>
|
|
RSBHML::Box(Box::new(f), Box::new(g)),
|
|
};
|