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 }

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;

pub use protocol::{ProtocolDescription, ProtocolDescriptionBuilder, ComponentCreationError};

                                    for element in elements {

                                        message.push(element.as_char());

                                    }

                                    // Drop the heap-allocated value from the

                                    // store

                                    self.store.drop_heap_pos(value_heap_pos);

                                    println!("{}", message);

                                },

                                Method::SelectStart => {

                                    let num_cases = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let num_ports = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                },

                                Method::SelectRegisterCasePort => {

                                    let case_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let port_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let port_value = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_port_id();

                                },

                                Method::SelectWait => {

                                    match ctx.performed_select_wait() {

                                        Some(select_index) => {

                                            cur_frame.expr_values.push_back(Value::UInt32(select_index));

                                        },

                                    }

                                },

                                Method::UserComponent => {

                                    // This is actually handled by the evaluation

                                    // of the statement.

                                    debug_assert_eq!(heap[expr.procedure].parameters.len(), cur_frame.expr_values.len());

                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this)

                                },

                                Method::UserFunction => {

                                    // Push a new frame. Note that all expressions have

                                    // been pushed to the front, so they're in the order

                                    // of the definition.

                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

    fn performed_select_wait(&mut self) -> Option<u32>; // None if not yet notified runtime of select blocker

}

pub struct ProtocolDescriptionBuilder {

    parser: Parser,

}

impl ProtocolDescriptionBuilder {

    pub fn new() -> Self {

        return Self{

            parser: Parser::new(),

        }

    }

    // --- Visiting the select statement

    fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {

        // Utility for the last stage of rewriting process. Note that caller

        // still needs to point the end of the if-statement to the end of the

        // replacement statement of the select statement.

        fn transform_select_case_code(

            ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId,

            select_id: SelectStatementId, case_index: usize,

            select_var_id: VariableId, select_var_type_id: TypeIdReference

            // Retrieve statement IDs associated with case

            let case = &ctx.heap[select_id].cases[case_index];

            let case_guard_id = case.guard;

            let case_body_id = case.body;

            let case_scope_id = case.scope;

            // Create the if-statement for the result of the select statement

            let compare_expr_id = create_ast_equality_comparison_expr(ctx, containing_procedure_id, select_var_id, select_var_type_id, case_index as u64);

            let true_case = IfStatementCase{

                body: case_guard_id, // which is linked up to the body

                scope: case_scope_id,

            };

            let (if_stmt_id, end_if_stmt_id) = create_ast_if_stmt(ctx, compare_expr_id.upcast(), true_case, None);

            // Link up body statement to end-if

            set_ast_statement_next(ctx, case_body_id, end_if_stmt_id.upcast());

        }

        // Precreate the block that will end up containing all of the

        // transformed statements. Also precreate the scope associated with it

        let (outer_block_id, outer_end_block_id, outer_scope_id) =

            create_ast_block_stmt(ctx, Vec::new());

        // The "select" and the "end select" statement will act like trampolines

        // that jump to the replacement block. So set the child/parent

        // relationship already.

        // --- for the statements

        let select_stmt = &mut ctx.heap[id];

            let call_expr = &mut ctx.heap[get_call_expr_id];

            call_expr.arguments[0] = variable_expr_id.upcast();

            transformed_stmts.push(variable_decl_stmt_id.upcast().upcast());

            locals.push((variable_id, port_type_ref));

        }

        // Insert runtime calls that facilitate the semantics of the select

        // block.

        // Create the call that indicates the start of the select block

        {

            let arguments = vec![

                num_cases_expression_id.upcast(),

                num_ports_expression_id.upcast()

            ];

            let call_expression_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectStart, &mut self.expression_buffer, arguments);

            let call_statement_id = create_ast_expression_stmt(ctx, call_expression_id.upcast());

            transformed_stmts.push(call_statement_id.upcast());

        }

        // Create calls for each select case that will register the ports that

        // we are waiting on at the runtime.

        {

            let mut total_port_index = 0;

            for case_index in 0..total_num_cases {

                let case = &ctx.heap[id].cases[case_index];

                let case_num_ports = case.involved_ports.len();

                for case_port_index in 0..case_num_ports {

                    // Arguments to runtime call

                    let (port_variable_id, port_variable_type) = locals[total_port_index]; // so far this variable contains the temporary variables for the port expressions

                    let port_variable_expr_id = create_ast_variable_expr(ctx, self.current_procedure_id, port_variable_id, port_variable_type);

                    let runtime_call_arguments = vec![

                        case_index_expr_id.upcast(),

                        port_index_expr_id.upcast(),

                        port_variable_expr_id.upcast()

                    ];

                    // Create runtime call, then store it

                    let runtime_call_expr_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectRegisterCasePort, &mut self.expression_buffer, runtime_call_arguments);

                    let runtime_call_stmt_id = create_ast_expression_stmt(ctx, runtime_call_expr_id.upcast());

                    transformed_stmts.push(runtime_call_stmt_id.upcast());

        {

            let runtime_call_expr_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectWait, &mut self.expression_buffer, Vec::new());

            let variable_stmt_id = create_ast_variable_declaration_stmt(ctx, self.current_procedure_id, select_variable_id, select_variable_type, runtime_call_expr_id.upcast());

            transformed_stmts.push(variable_stmt_id.upcast().upcast());

        }

        call_id_section.forget();

        expr_id_section.forget();

        // Now we transform each of the select block case's guard and code into

        // a chained if-else statement.

        if total_num_cases > 0 {

            let first_end_if_stmt = &mut ctx.heap[end_if_stmt_id];

            first_end_if_stmt.next = outer_end_block_id.upcast();

            let mut last_if_stmt_id = if_stmt_id;

            let mut last_end_if_stmt_id = end_if_stmt_id;

            transformed_stmts.push(last_if_stmt_id.upcast());

            for case_index in 1..total_num_cases {

                let false_case_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(last_if_stmt_id, false)));

                set_ast_if_statement_false_body(ctx, last_if_stmt_id, last_end_if_stmt_id, IfStatementCase{ body: if_stmt_id.upcast(), scope: false_case_scope_id });

                let end_if_stmt = &mut ctx.heap[end_if_stmt_id];

                end_if_stmt.next = last_end_if_stmt_id.upcast();

                last_if_stmt_id = if_stmt_id;

                last_end_if_stmt_id = end_if_stmt_id;

            }

        }

        // Final steps: set the statements of the replacement block statement,

        let first_stmt_id = transformed_stmts[0];

        let mut last_stmt_id = transformed_stmts[0];

        for stmt_id in transformed_stmts.iter().skip(1).copied() {

            set_ast_statement_next(ctx, last_stmt_id, stmt_id);

            last_stmt_id = stmt_id;

        }

        let outer_block_stmt = &mut ctx.heap[outer_block_id];

        outer_block_stmt.next = first_stmt_id;

        outer_block_stmt.statements = transformed_stmts;

        return Ok(())

        type_index: call_type_index,

    });

    for argument_index in 0..expression_ids.len() {

        let argument_id = expression_ids[argument_index];

        let argument_expr = &mut ctx.heap[argument_id];

        *argument_expr.parent_mut() = ExpressionParent::Expression(call_expression_id.upcast(), argument_index as u32);

    }

    return call_expression_id;

}

    return ctx.heap.alloc_literal_expression(|this| LiteralExpression{

        this,

        span: InputSpan::new(),

        value: Literal::Integer(LiteralInteger{

            unsigned_value,

            negated: false,

        }),

        parent: ExpressionParent::None,

        type_index: literal_type_index,

    });

}

fn create_ast_equality_comparison_expr(

    ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId,

    variable_id: VariableId, variable_type: TypeIdReference, value: u64

) -> BinaryExpressionId {

    let var_expr_id = create_ast_variable_expr(ctx, containing_procedure_id, variable_id, variable_type);

    let cmp_type_index = add_new_procedure_expression_type(ctx, containing_procedure_id, TypeIdReference::DirectTypeId(ctx.arch.bool_type_id));

    let cmp_expr_id = ctx.heap.alloc_binary_expression(|this| BinaryExpression{

        this,

        operator_span: InputSpan::new(),

        full_span: InputSpan::new(),

        left: var_expr_id.upcast(),

        operation: BinaryOperator::Equality,

        right: int_expr_id.upcast(),

        parent: ExpressionParent::None,

        type_index: cmp_type_index,

    });

    let expression = &mut ctx.heap[expression_id];

    *expression.parent_mut() = ExpressionParent::ExpressionStmt(statement_id);

    return statement_id;

}

fn create_ast_variable_declaration_stmt(

    ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId,

    variable_id: VariableId, variable_type: TypeIdReference, initial_value_expr_id: ExpressionId

) -> MemoryStatementId {

    // Create the assignment expression, assigning the initial value to the variable

    let variable_expr_id = create_ast_variable_expr(ctx, containing_procedure_id, variable_id, variable_type);

    let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{

        this,

        operator_span: InputSpan::new(),

        full_span: InputSpan::new(),

        left: variable_expr_id.upcast(),

        operation: AssignmentOperator::Set,

        right: initial_value_expr_id,

        parent: ExpressionParent::None,

    });

    // Create the memory statement

    let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{

        this,

        span: InputSpan::new(),

        variable: variable_id,

        initial_expr: assignment_expr_id,

        next: StatementId::new_invalid(),

    });

    // Set all parents which we can access

    let old_parent = &mut ctx.heap[old_parent_scope_id];

    let scope_index = old_parent.nested.iter()

        .position(|v| *v == child_scope_id)

        .unwrap();

    old_parent.nested.remove(scope_index);

    // Add to new parent

    add_child_scope_to_parent(ctx, scope_buffer, new_parent_scope_id, child_scope_id, new_relative_pos_in_parent);

}

/// Will add a child scope to a parent scope using the relative position hint.

fn add_child_scope_to_parent(ctx: &mut Ctx, scope_buffer: &mut ScopedBuffer<ScopeId>, parent_scope_id: ScopeId, child_scope_id: ScopeId, relative_pos_hint: i32) {

    let mut insert_pos = existing_scope_ids.len();

    for index in 0..existing_scope_ids.len() {

        let existing_scope_id = existing_scope_ids[index];

        let existing_scope = &ctx.heap[existing_scope_id];

        if relative_pos_hint <= existing_scope.relative_pos_in_parent {

            insert_pos = index;

            break;

        }

    }

    existing_scope_ids.forget();

    let parent_scope = &mut ctx.heap[parent_scope_id];

            }

        },

        TypeIdReference::IndirectSameAsExpr(source_type_index) => {

            for monomorph in procedure.monomorphs.iter_mut() {

                debug_assert_eq!(monomorph.expr_info.len(), type_index);

                let copied_expr_info = monomorph.expr_info[source_type_index as usize];

                monomorph.expr_info.push(copied_expr_info)

            }

        }

    }

    return type_index as i32;

        }

        // Write the types of the arguments

        let procedure = &ctx.heap[self.procedure_id];

        for parameter_id in procedure.parameters.iter().copied() {

            let mut concrete = ConcreteType::default();

            let var_data = self.var_data.iter().find(|v| v.var_id == parameter_id).unwrap();

            var_data.var_type.write_concrete_type(&mut concrete);

            let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete)?;

            monomorph.argument_types.push(type_id)

        }

        // Determine if we have already assigned type indices to the expressions

        // before (the indices that, for a monomorph, can retrieve the type of

        // the expression).

        let has_type_indices = self.reserved_monomorph_index > 0;

        if has_type_indices {

            // already have indices, so resize and then index into it

            debug_assert!(monomorph.expr_info.is_empty());

            monomorph.expr_info.resize(num_infer_nodes, ExpressionInfo::new_invalid());

            for infer_node in self.infer_nodes.iter() {

                let type_index = ctx.heap[infer_node.expr_id].type_index();

                monomorph.expr_info[type_index as usize] = infer_node.as_expression_info();

            }

            // }

        }

    }

}

impl PartialEq for MonoSearchKey {

    fn eq(&self, other: &Self) -> bool {

        let mut self_index = 0;

        let mut other_index = 0;

        while self_index < self.parts.len() && other_index < other.parts.len() {

            // Retrieve part and flags

            let self_in_use = true; // (self_bits & Self::KEY_IN_USE) != 0; @Deduplication

            let other_in_use = true; // (other_bits & Self::KEY_IN_USE) != 0; @Deduplication

            // Determine ending indices

            let self_end_index = self.find_end_index(self_index);

            let other_end_index = other.find_end_index(other_index);

            if self_in_use == other_in_use {

                if self_in_use {

                    // Both are in use, so both parts should be equal

                    let delta_self = self_end_index - self_index;

                    let delta_other = other_end_index - other_index;

                    CTP::SInt32 => arch.sint32_type_id,

                    CTP::SInt64 => arch.sint64_type_id,

                    CTP::Character => arch.char_type_id,

                    CTP::String => arch.string_type_id,

                    CTP::Array => arch.array_type_id,

                    CTP::Slice => arch.slice_type_id,

                    CTP::Input => arch.input_type_id,

                    CTP::Output => arch.output_type_id,

                    CTP::Pointer => arch.pointer_type_id,

                    _ => unreachable!(),

                };

                let base_type = &self.mono_types[base_type_id.0 as usize];

                let type_id = TypeId(self.mono_types.len() as i64);

                Self::set_search_key_to_type(&mut self.mono_search_key, &self.definition_lookup, &concrete_type.parts);

                self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);

                self.mono_types.push(MonoType{

                    type_id,

                    concrete_type,

                    variant: MonoTypeVariant::Builtin

                });

                type_id

            },

            // User-defined types

            CTP::Tuple(num_embedded) => {

                debug_assert!(definition_id.is_invalid()); // because tuples do not have an associated `DefinitionId`

                let mut members = Vec::with_capacity(*num_embedded as usize);

                for section in ConcreteTypeIter::new(&concrete_type.parts, 0) {

                    members.push(TupleMonomorphMember{

                        type_id: TypeId::new_invalid(),

        },

        _ => None

    }

}

struct FakeRunContext{}

impl RunContext for FakeRunContext {

    fn performed_put(&mut self, _port: PortId) -> bool { unreachable!() }

    fn performed_get(&mut self, _port: PortId) -> Option<ValueGroup> { unreachable!() }

    fn fires(&mut self, _port: PortId) -> Option<Value> { unreachable!() }

    fn performed_fork(&mut self) -> Option<bool> { unreachable!() }

    fn created_channel(&mut self) -> Option<(Value, Value)> { unreachable!() }

    fn performed_select_wait(&mut self) -> Option<u32> { unreachable!() }

}

            taken => unreachable!("prepared statement is '{:?}' during 'created_channel()'", taken),

        };

    }

    fn performed_fork(&mut self) -> Option<bool> {

        return match self.prepared.take() {

            PreparedStatement::None => None,

            PreparedStatement::ForkedExecution(path) => Some(path),

            taken => unreachable!("prepared statement is '{:?}' during 'performed_fork()'", taken),

        };

    }

    fn performed_select_wait(&mut self) -> Option<u32> { unreachable!() }

}

impl Connector for ConnectorPDL {

    fn run(&mut self, sched_ctx: SchedulerCtx, comp_ctx: &mut ComponentCtx) -> ConnectorScheduling {

        if let Some(scheduling) = self.handle_new_messages(comp_ctx) {

            return scheduling;

        }

        match self.mode {

            Mode::Sync => {

                // Run in sync mode

}

/// Port and peer management structure. Will keep a local reference counter to

/// the ports associate with peers, additionally manages the atomic reference

/// counter associated with the peers' component handles.

pub struct CompCtx {

    pub id: CompId,

    ports: Vec<Port>,

    peers: Vec<Peer>,

    port_id_counter: u32,

}

pub struct LocalPortHandle(PortId);

#[derive(Copy, Clone)]

pub struct LocalPeerHandle(CompId);

impl CompCtx {

    /// Creates a new component context based on a reserved entry in the

    /// component store. This reservation is used such that we already know our

    /// assigned ID.

    pub(crate) fn new(reservation: &CompReserved) -> Self {

        return Self{

            id: reservation.id(),

use crate::protocol::*;

use crate::protocol::ast::ProcedureDefinitionId;

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::*;

pub enum CompScheduling {

    Immediate,

    Requeue,

    Sleep,

    Exit,

}

pub enum ExecStmt {

    CreatedChannel((Value, Value)),

    PerformedPut,

    PerformedGet(ValueGroup),

    PerformedSelectWait(u32),

    None,

}

impl ExecStmt {

    fn take(&mut self) -> ExecStmt {

        let mut value = ExecStmt::None;

        std::mem::swap(self, &mut value);

        return value;

    }

    fn is_none(&self) -> bool {

    fn performed_fork(&mut self) -> Option<bool> {

        todo!("remove fork")

    }

    fn created_channel(&mut self) -> Option<(Value, Value)> {

        match self.stmt.take() {

            ExecStmt::None => return None,

            ExecStmt::CreatedChannel(ports) => return Some(ports),

            _ => unreachable!(),

        }

    }

    fn performed_select_wait(&mut self) -> Option<u32> {

        match self.stmt.take() {

            ExecStmt::None => return None,

            ExecStmt::PerformedSelectWait(selected_case) => Some(selected_case),

        }

    }

}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]

pub(crate) enum Mode {

    NonSync, // not in sync mode

    Sync, // in sync mode, can interact with other components

    SyncEnd, // awaiting a solution, i.e. encountered the end of the sync block

    StartExit, // temporary state: if encountered then we start the shutdown process

    BusyExit, // temporary state: waiting for Acks for all the closed ports

    Exit, // exiting: shutdown process started, now waiting until the reference count drops to 0

}