[package]

name = "reowolf_rs"

version = "1.2.0"

authors = [

	"Max Henger <henger@cwi.nl>",

	"Christopher Esterhuyse <esterhuy@cwi.nl>",

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

]

[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]

rand = "0.8.4"

rand_pcg = "0.3.1"

[lib]

crate-type = [

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

]

#[macro_use]

mod macros;

// mod common;

mod protocol;

pub mod runtime;

pub mod runtime2;

mod collections;

mod arena;

pub(crate) mod eval;

pub(crate) mod input_source;

mod parser;

#[cfg(test)] mod tests;

pub(crate) mod ast;

pub(crate) mod ast_printer;

use std::sync::Mutex;

use crate::collections::{StringPool, StringRef};

use crate::protocol::ast::*;

use crate::protocol::eval::*;

use crate::protocol::input_source::*;

use crate::protocol::parser::*;

use crate::protocol::type_table::*;

/// A protocol description module

pub struct Module {

    pub(crate) source: InputSource,

    pub(crate) root_id: RootId,

    pub(crate) name: Option<StringRef<'static>>,

}

/// Description of a protocol object, used to configure new connectors.

#[repr(C)]

pub struct ProtocolDescription {

    pub(crate) modules: Vec<Module>,

    pub(crate) heap: Heap,

    pub(crate) types: TypeTable,

    pub(crate) pool: Mutex<StringPool>,

}

#[derive(Debug, Clone)]

pub(crate) struct ComponentState {

    pub(crate) prompt: Prompt,

}

#[derive(Debug)]

pub enum ComponentCreationError {

    ModuleDoesntExist,

    DefinitionDoesntExist,

    DefinitionNotComponent,

    InvalidNumArguments,

    InvalidArgumentType(usize),

    UnownedPort,

    InSync,

}

impl ProtocolDescription {

    pub fn parse(buffer: &[u8]) -> Result<Self, String> {

        let source = InputSource::new(String::new(), Vec::from(buffer));

        let mut parser = Parser::new();

        parser.feed(source).expect("failed to feed source");

        if let Err(err) = parser.parse() {

            println!("ERROR:\n{}", err);

            return Err(format!("{}", err))

        }

        debug_assert_eq!(parser.modules.len(), 1, "only supporting one module here for now");

        let modules: Vec<Module> = parser.modules.into_iter()

            .map(|module| Module{

                source: module.source,

                root_id: module.root_id,

                name: module.name.map(|(_, name)| name)

            })

            .collect();

        return Ok(ProtocolDescription {

            modules,

            heap: parser.heap,

            types: parser.type_table,

            pool: Mutex::new(parser.string_pool),

        });

    }

    pub(crate) fn new_component(

        &self, module_name: &[u8], identifier: &[u8], arguments: ValueGroup

    ) -> Result<Prompt, ComponentCreationError> {

        // Find the module in which the definition can be found

        let module_root = self.lookup_module_root(module_name);

        if module_root.is_none() {

            return Err(ComponentCreationError::ModuleDoesntExist);

        }

        let module_root = module_root.unwrap();

        let root = &self.heap[module_root];

        let definition_id = root.get_definition_ident(&self.heap, identifier);

        if definition_id.is_none() {

            return Err(ComponentCreationError::DefinitionDoesntExist);

        }

        let definition_id = definition_id.unwrap();

        let ast_definition = &self.heap[definition_id];

        if !ast_definition.is_component() {

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // Make sure that the types of the provided value group matches that of

        // the expected types.

        let ast_definition = ast_definition.as_component();

        if !ast_definition.poly_vars.is_empty() {

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // - check number of arguments by retrieving the one instantiated

        //   monomorph

        let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(definition_id, 0)] };

        let mono_index = self.types.get_procedure_monomorph_index(&definition_id, &concrete_type.parts).unwrap();

        let mono_type = self.types.get_procedure_monomorph(mono_index);

        if mono_type.arg_types.len() != arguments.values.len() {

            return Err(ComponentCreationError::InvalidNumArguments);

        }

        // - for each argument try to make sure the types match

        for arg_idx in 0..arguments.values.len() {

            let expected_type = &mono_type.arg_types[arg_idx];

            let provided_value = &arguments.values[arg_idx];

            if !self.verify_same_type(expected_type, 0, &arguments, provided_value) {

                return Err(ComponentCreationError::InvalidArgumentType(arg_idx));

            }

        }

        // By now we're sure that all of the arguments are correct. So create

        // the connector.

        return Ok(Prompt::new(&self.types, &self.heap, definition_id, mono_index, arguments));

    }

    fn lookup_module_root(&self, module_name: &[u8]) -> Option<RootId> {

        for module in self.modules.iter() {

            match &module.name {

                Some(name) => if name.as_bytes() == module_name {

                    return Some(module.root_id);

                },

                None => if module_name.is_empty() {

                    return Some(module.root_id);

                }

            }

        }

        return None;

    }

    fn verify_same_type(&self, expected: &ConcreteType, expected_idx: usize, arguments: &ValueGroup, argument: &Value) -> bool {

        use ConcreteTypePart as CTP;

        match &expected.parts[expected_idx] {

            CTP::Void | CTP::Message | CTP::Slice | CTP::Function(_, _) | CTP::Component(_, _) => unreachable!(),

            CTP::Bool => if let Value::Bool(_) = argument { true } else { false },

            CTP::UInt8 => if let Value::UInt8(_) = argument { true } else { false },

            CTP::UInt16 => if let Value::UInt16(_) = argument { true } else { false },

            CTP::UInt32 => if let Value::UInt32(_) = argument { true } else { false },

            CTP::UInt64 => if let Value::UInt64(_) = argument { true } else { false },

            CTP::SInt8 => if let Value::SInt8(_) = argument { true } else { false },

            CTP::SInt16 => if let Value::SInt16(_) = argument { true } else { false },

            CTP::SInt32 => if let Value::SInt32(_) = argument { true } else { false },

            CTP::SInt64 => if let Value::SInt64(_) = argument { true } else { false },

            CTP::Character => if let Value::Char(_) = argument { true } else { false },

            CTP::String => {

                // Match outer string type and embedded character types

                if let Value::String(heap_pos) = argument {

                    for element in &arguments.regions[*heap_pos as usize] {

                        if let Value::Char(_) = element {} else {

                            return false;

                        }

                    }

                } else {

                    return false;

                }

                return true;

            },

            CTP::Array => {

                if let Value::Array(heap_pos) = argument {

                    let heap_pos = *heap_pos;

                    for element in &arguments.regions[heap_pos as usize] {

                        if !self.verify_same_type(expected, expected_idx + 1, arguments, element) {

                            return false;

                        }

                    }

                    return true;

                } else {

                    return false;

                }

            },

            CTP::Input => if let Value::Input(_) = argument { true } else { false },

            CTP::Output => if let Value::Output(_) = argument { true } else { false },

            CTP::Tuple(_) => todo!("implement full type checking on user-supplied arguments"),

            CTP::Instance(definition_id, _num_embedded) => {

                let definition = self.types.get_base_definition(definition_id).unwrap();

                match &definition.definition {

                    DefinedTypeVariant::Enum(definition) => {

                        if let Value::Enum(variant_value) = argument {

                            let is_valid = definition.variants.iter()

                                .any(|v| v.value == *variant_value);

                            return is_valid;

                        }

                    },

                    _ => todo!("implement full type checking on user-supplied arguments"),

                }

                return false;

            },

        }

    }

}

pub trait RunContext {

    fn performed_put(&mut self, port: PortId) -> bool;

    fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message

    fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched

    fn performed_fork(&mut self) -> Option<bool>; // None if not yet forked

    fn created_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared

}

use crate::protocol::ast::*;

use super::symbol_table::*;

use crate::protocol::input_source::{ParseError, InputSpan};

use super::tokens::*;

use super::token_parsing::*;

use super::{Module, ModuleCompilationPhase, PassCtx};

/// Scans the module and finds all module-level type definitions. These will be

/// added to the symbol table such that during AST-construction we know which

/// identifiers point to types. Will also parse all pragmas to determine module

/// names.

pub(crate) struct PassSymbols {

    symbols: Vec<Symbol>,

    pragmas: Vec<PragmaId>,

    imports: Vec<ImportId>,

    definitions: Vec<DefinitionId>,

    buffer: String,

    has_pragma_version: bool,

    has_pragma_module: bool,

}

impl PassSymbols {

    pub(crate) fn new() -> Self {

        Self{

            symbols: Vec::with_capacity(128),

            pragmas: Vec::with_capacity(8),

            imports: Vec::with_capacity(32),

            definitions: Vec::with_capacity(128),

            buffer: String::with_capacity(128),

            has_pragma_version: false,

            has_pragma_module: false,

        }

    }

    fn reset(&mut self) {

        self.symbols.clear();

        self.pragmas.clear();

        self.imports.clear();

        self.definitions.clear();

        self.has_pragma_version = false;

        self.has_pragma_module = false;

    }

    pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {

        self.reset();

        let module = &mut modules[module_idx];

        let module_range = &module.tokens.ranges[0];

        debug_assert_eq!(module.phase, ModuleCompilationPhase::Tokenized);

        debug_assert_eq!(module_range.range_kind, TokenRangeKind::Module);

        debug_assert!(module.root_id.is_invalid()); // not set yet,

        // Preallocate root in the heap

        let root_id = ctx.heap.alloc_protocol_description(|this| {

            Root{

                this,

                pragmas: Vec::new(),

                imports: Vec::new(),

                definitions: Vec::new(),

            }

        });

        module.root_id = root_id;

        // Retrieve first range index, then make immutable borrow

        let mut range_idx = module_range.first_child_idx;

        // Visit token ranges to detect definitions and pragmas

        loop {

            let range_idx_usize = range_idx as usize;

            let cur_range = &module.tokens.ranges[range_idx_usize];

            let next_sibling_idx = cur_range.next_sibling_idx;

            let range_kind = cur_range.range_kind;

            // Parse if it is a definition or a pragma

            if range_kind == TokenRangeKind::Definition {

                self.visit_definition_range(modules, module_idx, ctx, range_idx_usize)?;

            } else if range_kind == TokenRangeKind::Pragma {

                self.visit_pragma_range(modules, module_idx, ctx, range_idx_usize)?;

            }

            if next_sibling_idx == NO_SIBLING {

                break;

            } else {

                range_idx = next_sibling_idx;

            }

        }

        // Add the module's symbol scope and the symbols we just parsed

        let module_scope = SymbolScope::Module(root_id);

        ctx.symbols.insert_scope(Some(SymbolScope::Global), module_scope);

        for symbol in self.symbols.drain(..) {

            ctx.symbols.insert_scope(Some(module_scope), SymbolScope::Definition(symbol.variant.as_definition().definition_id));

            if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(module_scope, symbol) {

                return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol))

            }

        }

        // Modify the preallocated root

        let root = &mut ctx.heap[root_id];

        root.pragmas.extend(self.pragmas.drain(..));

        root.definitions.extend(self.definitions.drain(..));

        let module = &mut modules[module_idx];

        module.phase = ModuleCompilationPhase::SymbolsScanned;

        Ok(())

    }

        let range = &module.tokens.ranges[range_idx];

        let mut iter = module.tokens.iter_range(range);

        // Consume pragma name

        let (pragma_section, pragma_start, _) = consume_pragma(&module.source, &mut iter)?;

        // Consume pragma values

        if pragma_section == b"#module" {

            // Check if name is defined twice within the same file

            if self.has_pragma_module {

                return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "module name is defined twice"));

            }

            // Consume the domain-name

            let (module_name, module_span) = consume_domain_ident(&module.source, &mut iter)?;

            if iter.next().is_some() {

                return Err(ParseError::new_error_str_at_pos(&module.source, iter.last_valid_pos(), "expected end of #module pragma after module name"));

            }

            // Add to heap and symbol table

            let pragma_span = InputSpan::from_positions(pragma_start, module_span.end);

            let module_name = ctx.pool.intern(module_name);

            let pragma_id = ctx.heap.alloc_pragma(|this| Pragma::Module(PragmaModule{

                this,

                span: pragma_span,

                value: Identifier{ span: module_span, value: module_name.clone() },

            }));

            self.pragmas.push(pragma_id);

                // Naming conflict

                let this_module = &modules[module_idx];

                let other_module = seek_module(modules, other_module_root_id).unwrap();

                let other_module_pragma_id = other_module.name.as_ref().map(|v| (*v).0).unwrap();

                let other_pragma = ctx.heap[other_module_pragma_id].as_module();

                return Err(ParseError::new_error_str_at_span(

                    &this_module.source, pragma_span, "conflict in module name"

                ).with_info_str_at_span(

                    &other_module.source, other_pragma.span, "other module is defined here"

                ));

            }

            self.has_pragma_module = true;

        } else if pragma_section == b"#version" {

            // Check if version is defined twice within the same file

            if self.has_pragma_version {

                return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "module version is defined twice"));

            }

            // Consume the version pragma

            let (version, version_span) = consume_integer_literal(&module.source, &mut iter, &mut self.buffer)?;

            let pragma_id = ctx.heap.alloc_pragma(|this| Pragma::Version(PragmaVersion{

                this,

                span: InputSpan::from_positions(pragma_start, version_span.end),

                version,

            }));

            self.pragmas.push(pragma_id);

            self.has_pragma_version = true;

        } else {

            // Custom pragma, maybe we support this in the future, but for now

            // we don't.

            return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "illegal pragma name"));

        }

        Ok(())

    }

    fn visit_definition_range(&mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize) -> Result<(), ParseError> {

        let module = &modules[module_idx];

        let range = &module.tokens.ranges[range_idx];

        let definition_span = InputSpan::from_positions(

            module.tokens.start_pos(range),

            module.tokens.end_pos(range)

        );

        let mut iter = module.tokens.iter_range(range);

        // First ident must be type of symbol

        let (kw_text, _) = consume_any_ident(&module.source, &mut iter).unwrap();

        // Retrieve identifier of definition

        let identifier = consume_ident_interned(&module.source, &mut iter, ctx)?;

        let mut poly_vars = Vec::new();

        maybe_consume_comma_separated(

            TokenKind::OpenAngle, TokenKind::CloseAngle, &module.source, &mut iter, ctx,

            |source, iter, ctx| consume_ident_interned(source, iter, ctx),

            &mut poly_vars, "a polymorphic variable", None

        )?;

        let ident_text = identifier.value.clone(); // because we need it later

        let ident_span = identifier.span.clone();

        // Reserve space in AST for definition and add it to the symbol table

        let definition_class;

        let ast_definition_id;

        match kw_text {

            KW_STRUCT => {

                let struct_def_id = ctx.heap.alloc_struct_definition(|this| {

                    StructDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Struct;

                ast_definition_id = struct_def_id.upcast();

            },

            KW_ENUM => {

                let enum_def_id = ctx.heap.alloc_enum_definition(|this| {

                    EnumDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Enum;

                ast_definition_id = enum_def_id.upcast();

            },

            KW_UNION => {

                let union_def_id = ctx.heap.alloc_union_definition(|this| {

                    UnionDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Union;

                ast_definition_id = union_def_id.upcast()

            },

            KW_FUNCTION => {

                let func_def_id = ctx.heap.alloc_function_definition(|this| {

                    FunctionDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Function;

                ast_definition_id = func_def_id.upcast();

            },

            KW_PRIMITIVE | KW_COMPOSITE => {

                let component_variant = if kw_text == KW_PRIMITIVE {

                    ComponentVariant::Primitive

                } else {

                    ComponentVariant::Composite

                };

                let comp_def_id = ctx.heap.alloc_component_definition(|this| {

                    ComponentDefinition::new_empty(this, module.root_id, definition_span, component_variant, identifier, poly_vars)

                });

                definition_class = DefinitionClass::Component;

                ast_definition_id = comp_def_id.upcast();

            },

            _ => unreachable!("encountered keyword '{}' in definition range", String::from_utf8_lossy(kw_text)),

        }

        let symbol = Symbol{

            name: ident_text,

            variant: SymbolVariant::Definition(SymbolDefinition{

                defined_in_module: module.root_id,

                defined_in_scope: SymbolScope::Module(module.root_id),

                definition_span,

                identifier_span: ident_span,

                imported_at: None,

                class: definition_class,

                definition_id: ast_definition_id,

            }),

        };

        self.symbols.push(symbol);

        self.definitions.push(ast_definition_id);

        Ok(())

    }

}

use crate::protocol::*;

use crate::protocol::ast::DefinitionId;

use crate::protocol::eval::{

    PortId as EvalPortId, Prompt,

    ValueGroup, Value,

    EvalContinuation, EvalResult, EvalError

};

use crate::runtime2::scheduler::SchedulerCtx;

use crate::runtime2::communication::*;

use super::component_context::*;

use super::control_layer::*;

use super::consensus::Consensus;

pub enum CompScheduling {

    Immediate,

    Requeue,

    Sleep,

    Exit,

}

pub enum ExecStmt {