[package]

name = "reowolf_rs"

version = "0.1.4"

authors = [

	"Christopher Esterhuyse <esterhuy@cwi.nl, christopher.esterhuyse@gmail.com>",

	"Hans-Dieter Hiep <hdh@cwi.nl>"

]

edition = "2018"

[dependencies]

# convenience macros

maplit = "1.0.2"

derive_more = "0.99.2"

# runtime

bincode = "1.3.1"

serde = { version = "1.0.114", features = ["derive"] }

getrandom = "0.1.14" # tiny crate. used to guess controller-id

# network

mio = { version = "0.7.0", package = "mio", features = ["udp", "tcp", "os-poll"] }

socket2 = { version = "0.3.12", optional = true }

# protocol

backtrace = "0.3"

lazy_static = "1.4.0"

# ffi

# socket ffi

libc = { version = "^0.2", optional = true }

os_socketaddr = { version = "0.1.0", optional = true }

[dev-dependencies]

# test-generator = "0.3.0"

crossbeam-utils = "0.7.2"

lazy_static = "1.4.0"

[lib]

crate-type = [

	"rlib", # for use as a Rust dependency. 

	"cdylib" # for FFI use, typically C.

]

[features]

ffi = [] # see src/ffi/mod.rs

ffi_pseudo_socket_api = ["ffi", "libc", "os_socketaddr"]# see src/ffi/pseudo_socket_api.rs.

endpoint_logging = [] # see src/macros.rs

session_optimization = [] # see src/runtime/setup.rs

use std::fmt;

use std::fs::File;

use std::io;

use std::path::Path;

use backtrace::Backtrace;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct InputSource {

    filename: String,

    input: Vec<u8>,

    line: usize,

    column: usize,

    offset: usize,

}

static STD_LIB_PDL: &'static [u8] = b"

primitive forward(in i, out o) {

    while(true) synchronous() put(o, get(i));

}

primitive sync(in i, out o) {

    while(true) synchronous() if(fires(i)) put(o, get(i));

}

primitive alternator(in i, out l, out r) {

    while(true) {

        synchronous() if(fires(i)) put(l, get(i));

        synchronous() if(fires(i)) put(r, get(i));

    }

}

primitive replicator(in i, out l, out r) {

    }

}

primitive merger(in l, in r, out o) {

    while(true) synchronous {

        if(fires(l))      put(o, get(l));

        else if(fires(r)) put(o, get(r));

    }

}";

impl InputSource {

    // Constructors

    pub fn new<R: io::Read, S: ToString>(filename: S, reader: &mut R) -> io::Result<InputSource> {

        let mut vec = STD_LIB_PDL.to_vec();

        reader.read_to_end(&mut vec)?;

        Ok(InputSource {

            filename: filename.to_string(),

            input: vec,

            line: 1,

            column: 1,

            offset: 0,

        })

    }

    // Constructor helpers

    pub fn from_file(path: &Path) -> io::Result<InputSource> {

        let filename = path.file_name();

        match filename {

            Some(filename) => {

                let mut f = File::open(path)?;

                InputSource::new(filename.to_string_lossy(), &mut f)

            }

            None => Err(io::Error::new(io::ErrorKind::NotFound, "Invalid path")),

        }

    }

    pub fn from_string(string: &str) -> io::Result<InputSource> {

        let buffer = Box::new(string);

        let mut bytes = buffer.as_bytes();

        InputSource::new(String::new(), &mut bytes)

    }

    pub fn from_buffer(buffer: &[u8]) -> io::Result<InputSource> {

        InputSource::new(String::new(), &mut Box::new(buffer))

    }

    // Internal methods

    pub fn pos(&self) -> InputPosition {

        InputPosition { line: self.line, column: self.column, offset: self.offset }

    }

    pub fn error<S: ToString>(&self, message: S) -> ParseError {

        self.pos().parse_error(message)

    }

    pub fn is_eof(&self) -> bool {

        self.next() == None

    }

    pub fn next(&self) -> Option<u8> {

        if self.offset < self.input.len() {

            Some((*self.input)[self.offset])

        } else {

            None

        }

    }

    pub fn lookahead(&self, pos: usize) -> Option<u8> {

        if let Some(x) = usize::checked_add(self.offset, pos) {

            if x < self.input.len() {

                return Some((*self.input)[x]);

            }

        }

        None

    }

    pub fn consume(&mut self) {

        match self.next() {

            Some(x) if x == b'\r' && self.lookahead(1) != Some(b'\n') || x == b'\n' => {

                self.line += 1;

                self.offset += 1;

                self.column = 1;

            }

            Some(_) => {

                self.offset += 1;

                self.column += 1;

            }

            None => {}

        }

    }

}

impl fmt::Display for InputSource {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        self.pos().fmt(f)

    }

}

#[derive(Debug, Clone, Copy, Default, serde::Serialize, serde::Deserialize)]

pub struct InputPosition {

    line: usize,

    column: usize,

    offset: usize,

}

impl InputPosition {

    fn context<'a>(&self, source: &'a InputSource) -> &'a [u8] {

        let start = self.offset - (self.column - 1);

        let mut end = self.offset;

        while end < source.input.len() {

            let cur = (*source.input)[end];

            if cur == b'\n' || cur == b'\r' {

                break;

            }

            end += 1;

        }

        &source.input[start..end]

    }

    fn parse_error<S: ToString>(&self, message: S) -> ParseError {

        ParseError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }

    }

    fn eval_error<S: ToString>(&self, message: S) -> EvalError {

        EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }

    }

}

impl fmt::Display for InputPosition {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "{}:{}", self.line, self.column)

    }

}

pub trait SyntaxElement {

    fn position(&self) -> InputPosition;

    fn error<S: ToString>(&self, message: S) -> EvalError {

        self.position().eval_error(message)

    }

}

#[derive(Debug, Clone)]

pub struct ParseError {

    position: InputPosition,

    message: String,

    backtrace: Backtrace,

}

impl ParseError {

    pub fn new<S: ToString>(position: InputPosition, message: S) -> ParseError {

        ParseError { position, message: message.to_string(), backtrace: Backtrace::new() }

    }

    // Diagnostic methods

    pub fn write<A: io::Write>(&self, source: &InputSource, writer: &mut A) -> io::Result<()> {

        if !source.filename.is_empty() {

            writeln!(

                writer,

                "Parse error at {}:{}: {}",

                source.filename, self.position, self.message

            )?;

        } else {

            writeln!(writer, "Parse error at {}: {}", self.position, self.message)?;

        }

        let line = self.position.context(source);

        writeln!(writer, "{}", String::from_utf8_lossy(line))?;

        let mut arrow: Vec<u8> = Vec::new();

        for pos in 1..self.position.column {

            let c = line[pos - 1];

            if c == b'\t' {

                arrow.push(b'\t')

            } else {

                arrow.push(b' ')

            }

        }

        arrow.push(b'^');

        writeln!(writer, "{}", String::from_utf8_lossy(&arrow))

    }

    pub fn print(&self, source: &InputSource) {

        self.write(source, &mut std::io::stdout()).unwrap()

    }

    pub fn display<'a>(&'a self, source: &'a InputSource) -> DisplayParseError<'a> {

        DisplayParseError::new(self, source)

    }

}

impl From<ParseError> for io::Error {

    fn from(_: ParseError) -> io::Error {

        io::Error::new(io::ErrorKind::InvalidInput, "parse error")

    }

}

#[derive(Clone, Copy)]

pub struct DisplayParseError<'a> {

    error: &'a ParseError,

    source: &'a InputSource,

}

impl DisplayParseError<'_> {

    fn new<'a>(error: &'a ParseError, source: &'a InputSource) -> DisplayParseError<'a> {

        DisplayParseError { error, source }

    }

}

impl fmt::Display for DisplayParseError<'_> {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        let mut vec: Vec<u8> = Vec::new();

        match self.error.write(self.source, &mut vec) {

            Err(_) => {

                return fmt::Result::Err(fmt::Error);

            }

            Ok(_) => {}

        }

        write!(f, "{}", String::from_utf8_lossy(&vec))

    }

}

#[derive(Debug, Clone)]

pub struct EvalError {

    position: InputPosition,

    message: String,

    backtrace: Backtrace,

}

impl EvalError {

    pub fn new<S: ToString>(position: InputPosition, message: S) -> EvalError {

        EvalError { position, message: message.to_string(), backtrace: Backtrace::new() }

    }

    // Diagnostic methods

    pub fn write<A: io::Write>(&self, source: &InputSource, writer: &mut A) -> io::Result<()> {

        if !source.filename.is_empty() {

            writeln!(

                writer,

                "Evaluation error at {}:{}: {}",

                source.filename, self.position, self.message

            )?;

        } else {

            writeln!(writer, "Evaluation error at {}: {}", self.position, self.message)?;

        }

        let line = self.position.context(source);

        writeln!(writer, "{}", String::from_utf8_lossy(line))?;

        let mut arrow: Vec<u8> = Vec::new();

        for pos in 1..self.position.column {

            let c = line[pos - 1];

            if c == b'\t' {

                arrow.push(b'\t')

            } else {

                arrow.push(b' ')

            }

        }

        arrow.push(b'^');

        writeln!(writer, "{}", String::from_utf8_lossy(&arrow))

    }

    pub fn print(&self, source: &InputSource) {

        self.write(source, &mut std::io::stdout()).unwrap()

    }

    pub fn display<'a>(&'a self, source: &'a InputSource) -> DisplayEvalError<'a> {

        DisplayEvalError::new(self, source)

    }

}

impl From<EvalError> for io::Error {

    fn from(_: EvalError) -> io::Error {

        io::Error::new(io::ErrorKind::InvalidInput, "eval error")

    }

}

#[derive(Clone, Copy)]

pub struct DisplayEvalError<'a> {

    error: &'a EvalError,

    source: &'a InputSource,

}

impl DisplayEvalError<'_> {

    fn new<'a>(error: &'a EvalError, source: &'a InputSource) -> DisplayEvalError<'a> {

        DisplayEvalError { error, source }

    }

}

impl fmt::Display for DisplayEvalError<'_> {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        let mut vec: Vec<u8> = Vec::new();

        match self.error.write(self.source, &mut vec) {

            Err(_) => {

                return fmt::Result::Err(fmt::Error);

            }

            Ok(_) => {}

        }

        write!(f, "{}", String::from_utf8_lossy(&vec))

    }

}

// #[cfg(test)]

// mod tests {

//     use super::*;

//     #[test]

//     fn test_from_string() {

//         let mut is = InputSource::from_string("#version 100\n").unwrap();

//         assert!(is.input.len() == 13);

//         assert!(is.line == 1);

//         assert!(is.column == 1);

//         assert!(is.offset == 0);

//         let ps = is.pos();

//         assert!(ps.line == 1);

//         assert!(ps.column == 1);

//         assert!(ps.offset == 0);

//         assert!(is.next() == Some(b'#'));

//         is.consume();

//         assert!(is.next() == Some(b'v'));

//         assert!(is.lookahead(1) == Some(b'e'));

//         is.consume();

//         assert!(is.next() == Some(b'e'));

//         is.consume();

//         assert!(is.next() == Some(b'r'));

//         is.consume();

//         assert!(is.next() == Some(b's'));

//         is.consume();

//         assert!(is.next() == Some(b'i'));

//         is.consume();

//         {

//             let ps = is.pos();

//             assert_eq!(b"#version 100", ps.context(&is));

//             let er = is.error("hello world!");

//             let mut vec: Vec<u8> = Vec::new();

//             er.write(&is, &mut vec).unwrap();

//             assert_eq!(

//                 "Parse error at 1:7: hello world!\n#version 100\n      ^\n",

//                 String::from_utf8_lossy(&vec)

//             );

//         }

//         assert!(is.next() == Some(b'o'));

//         is.consume();

//         assert!(is.next() == Some(b'n'));

//         is.consume();

//         assert!(is.input.len() == 13);

//         assert!(is.line == 1);

//         assert!(is.column == 9);

//         assert!(is.offset == 8);

//         assert!(is.next() == Some(b' '));

//         is.consume();

//         assert!(is.next() == Some(b'1'));

//         is.consume();

//         assert!(is.next() == Some(b'0'));

//         is.consume();

//         assert!(is.next() == Some(b'0'));

//         is.consume();

//         assert!(is.input.len() == 13);

//         assert!(is.line == 1);

//         assert!(is.column == 13);

//         assert!(is.offset == 12);

//         assert!(is.next() == Some(b'\n'));

//         is.consume();

//         assert!(is.input.len() == 13);

//         assert!(is.line == 2);

//         assert!(is.column == 1);

//         assert!(is.offset == 13);

//         {

//             let ps = is.pos();

//             assert_eq!(b"", ps.context(&is));

//         }

//         assert!(is.next() == None);

//         is.consume();

//         assert!(is.next() == None);

//     }

//     #[test]

//     fn test_split() {

//         let mut is = InputSource::from_string("#version 100\n").unwrap();

//         let backup = is.clone();

//         assert!(is.next() == Some(b'#'));

//         is.consume();

//         assert!(is.next() == Some(b'v'));

//         is.consume();

//         assert!(is.next() == Some(b'e'));

//         is.consume();

//         is = backup;

//         assert!(is.next() == Some(b'#'));

//         is.consume();

//         assert!(is.next() == Some(b'v'));

//         is.consume();

//         assert!(is.next() == Some(b'e'));

//         is.consume();

//     }

// }

use crate::common::*;

use crate::runtime::*;

impl TokenTarget {

    // subdivides the domain of usize into

    // [NET_ENDPOINT][UDP_ENDPOINT  ]

    // ^0            ^usize::MAX/2   ^usize::MAX

    const HALFWAY_INDEX: usize = usize::MAX / 2;

    const MAX_INDEX: usize = usize::MAX;

}

impl From<Token> for TokenTarget {

    fn from(Token(index): Token) -> Self {

        if let Some(shifted) = index.checked_sub(Self::HALFWAY_INDEX) {

            TokenTarget::UdpEndpoint { index: shifted }

        } else {

            TokenTarget::NetEndpoint { index }

        }

    }

}

impl Into<Token> for TokenTarget {

    fn into(self) -> Token {

        match self {

            TokenTarget::UdpEndpoint { index } => Token(index + Self::HALFWAY_INDEX),

            TokenTarget::NetEndpoint { index } => Token(index),

        }

    }

}

impl Connector {

    /// Create a new connector structure with the given protocol description (via Arc to facilitate sharing).

    /// The resulting connector will start in the setup phase, and cannot be used for communication until the

    /// `connect` procedure completes.

    /// # Safety

    /// The correctness of the system's underlying distributed algorithms requires that no two

    /// connectors have the same ID. If the user does not know the identifiers of other connectors in the

    /// system, it is advised to guess it using Connector::random_id (relying on the exceptionally low probability of an error).

    /// Sessions with duplicate connector identifiers will not result in any memory unsafety, but cannot be guaranteed

    /// to preserve their configured protocols.

    /// Fortunately, in most realistic cases, the presence of duplicate connector identifiers will result in an

    /// error during `connect`, observed as a peer misbehaving.

    pub fn new(

        mut logger: Box<dyn Logger>,

        proto_description: Arc<ProtocolDescription>,

        connector_id: ConnectorId,

    ) -> Self {

        log!(&mut *logger, "Created with connector_id {:?}", connector_id);

        let mut id_manager = IdManager::new(connector_id);

        let native_component_id = id_manager.new_component_id();

        Self {

            unphased: ConnectorUnphased {

                proto_description,

                proto_components: Default::default(),

                logger,

                native_component_id,

                ips: IdAndPortState { id_manager, port_info: Default::default() },

            },

            phased: ConnectorPhased::Setup(Box::new(ConnectorSetup {

                net_endpoint_setups: Default::default(),

                udp_endpoint_setups: Default::default(),

            })),

        }

    }

    /// Conceptually, this returning [p0, g1] is sugar for:

    /// 1. create port pair [p0, g0]

    /// 2. create port pair [p1, g1]

    /// 3. create udp component with interface of moved ports [p1, g0]

    /// 4. return [p0, g1]

    pub fn new_udp_mediator_component(

        &mut self,

        local_addr: SocketAddr,

        peer_addr: SocketAddr,

    ) -> Result<[PortId; 2], WrongStateError> {

        let Self { unphased: cu, phased } = self;

        match phased {

            ConnectorPhased::Communication(..) => Err(WrongStateError),

            ConnectorPhased::Setup(setup) => {

                let udp_index = setup.udp_endpoint_setups.len();

                let udp_cid = cu.ips.id_manager.new_component_id();

                // allocates 4 new port identifiers, two for each logical channel,

                // one channel per direction (into and out of the component)

                let mut npid = || cu.ips.id_manager.new_port_id();

                let [nin, nout, uin, uout] = [npid(), npid(), npid(), npid()];

                // allocate the native->udp_mediator channel's ports

                cu.ips.port_info.map.insert(

                    nout,

                    PortInfo {

                        route: Route::LocalComponent,

                        polarity: Putter,

                        peer: Some(uin),

                        owner: cu.native_component_id,

                    },

                );

                cu.ips.port_info.map.insert(

                    uin,

                    PortInfo {

                        route: Route::UdpEndpoint { index: udp_index },

                        polarity: Getter,

                        peer: Some(uin),