ccs 0.1.0

A simple implementation of the Calculus of Communicating Systems by Robin Milner
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::collections::HashMap;
use std::rc::Rc;

use pest::{iterators::Pair, Parser};
use pest_derive::Parser;

use crate::ccs::*;
use crate::ccs::Process;
use crate::error::{CCSError, CCSResult};

#[derive(Parser)]
#[grammar = "grammar.pest"]
struct CCSParser;

fn parse_process(pair: Pair<Rule>) -> CCSResult<Process> {
    match pair.as_rule() {
        Rule::deadlock => Ok(Process::Deadlock()),
        Rule::process => parse_process(pair.into_inner().next().unwrap()),
        Rule::action => {
            let mut inner = pair.into_inner();
            let action = inner.next().unwrap().as_span().as_str().to_owned();
            let process = Box::new(parse_process(inner.next().unwrap())?);

            if action == "tau" {
                Ok(Process::Action(String::from("τ").into(), process))
            } else {
                Ok(Process::Action(action.into(), process))
            }
        },
        Rule::summation => {
            let mut inner = pair.into_inner();
            let left = Box::new(parse_process(inner.next().unwrap())?);
            let right = Box::new(parse_process(inner.next().unwrap())?);
            Ok(Process::NonDetChoice(left, right))
        },
        Rule::parallel => {
            let mut inner = pair.into_inner();
            let left = Box::new(parse_process(inner.next().unwrap())?);
            let right = Box::new(parse_process(inner.next().unwrap())?);
            Ok(Process::Parallel(left, right))
        },
        Rule::rename => {
            let mut inner = pair.into_inner();
            let process = Box::new(parse_process(inner.next().unwrap())?);
            let b = inner.next().unwrap().as_span().as_str().to_owned();
            let a = inner.next().unwrap().as_span().as_str().to_owned();
            Ok(Process::Rename(process, b.into(), a.into()))
        },
        Rule::restriction => {
            let mut inner = pair.into_inner();
            let process = Box::new(parse_process(inner.next().unwrap())?);
            let first_label = inner.next().unwrap().as_span().as_str().to_owned();
            let mut restriction = Process::Restriction(process, first_label.into());
            for label in inner.map(|p| p.as_span().as_str().to_owned()) {
                restriction = Process::Restriction(Box::new(restriction), label.into())
            }
            Ok(restriction)
        },
        Rule::process_name => {
            let name: Rc<_> = pair.as_span().as_str().to_owned().into();
            if *name == "_" {
                Err(CCSError::parsing_anonymous_process(&pair.as_span()))
            } else {
                Ok(Process::ProcessName(name))
            }
        },
        _ => Err(CCSError::parsing_unexpected_rule(pair.as_rule(), &pair.as_span())),
    }
}

fn parse_specification(pair: Pair<Rule>) -> CCSResult<(ProcessName, Process)> {
    if pair.as_rule() != Rule::specification {
        return Err(CCSError::parsing_unexpected_rule(pair.as_rule(), &pair.as_span()));
    }

    let mut inner = pair.into_inner();

    let name_pair = inner.next().ok_or(CCSError::parsing_rule_not_found(Rule::process_name))?;
    if name_pair.as_rule() != Rule::process_name  && name_pair.as_rule() != Rule::anonymous_process_name {
        return Err(CCSError::parsing_unexpected_rule(name_pair.as_rule(), &name_pair.as_span()));
    }
    let name = name_pair.as_span().as_str().to_owned();

    let process_pair = inner.next().ok_or(CCSError::parsing_rule_not_found(Rule::process))?;
    if process_pair.as_rule() != Rule::process {
        return Err(CCSError::parsing_unexpected_rule(process_pair.as_rule(), &process_pair.as_span()));
    }
    let process = parse_process(process_pair)?;

    Ok((name.into(), process))
}

fn parse_system(pair: Pair<Rule>, name: String) -> CCSResult<CCSSystem> {
    if pair.as_rule() != Rule::system {
        return Err(CCSError::parsing_unexpected_rule(pair.as_rule(), &pair.as_span()));
    }

    let mut processes = HashMap::new();
    let mut destinct_process = None;

    for spec_pair in pair.into_inner().filter(|p| p.as_rule() == Rule::specification) {
        let (name, process) = parse_specification(spec_pair)?;

        if destinct_process.is_none() {
            destinct_process = Some(name.clone());
        }

        processes.insert(name, process);
    }

    let destinct_process = destinct_process
        .ok_or(CCSError::parsing_rule_not_found(Rule::specification))?;

    Ok(CCSSystem::new(name, processes, destinct_process))
}

pub fn first_pass(input: &str) -> CCSResult<Pair<'_, Rule>> {
    Ok(CCSParser::parse(Rule::system, input)
        .map_err(CCSError::syntax_error)?
        .next().unwrap())
}

pub fn parse(name: String, input: &str) -> CCSResult<CCSSystem> {
    let first_pass = first_pass(input)?;
    let second_pass = parse_system(first_pass, name)?;
    Ok(second_pass)
}