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

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

rand = "0.8.4"

rand_pcg = "0.3.1"

pub mod runtime;

pub mod runtime2;

mod collections;

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

                                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 => {

    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

}

            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;

            // 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

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

        {

            let arguments = vec![

                num_cases_expression_id.upcast(),

                num_ports_expression_id.upcast()

                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(),

        // 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];

                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() {

    return call_expression_id;

}

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

        this,

        span: InputSpan::new(),

    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,

) -> 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(),

        operation: AssignmentOperator::Set,

        right: initial_value_expr_id,

        parent: ExpressionParent::None,

    });

    // Create the memory statement

/// 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];

    }

    return type_index as i32;

            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).

        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

                    _ => 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_types.push(MonoType{

                    type_id,

                    concrete_type,

                    variant: MonoTypeVariant::Builtin

                });

    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!() }

}

        };

    }

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

}

    port_id_counter: u32,

}

pub struct LocalPortHandle(PortId);

#[derive(Copy, Clone)]

use crate::protocol::*;

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

use crate::protocol::eval::{

    CreatedChannel((Value, Value)),

    PerformedPut,

    PerformedGet(ValueGroup),

    PerformedSelectWait(u32),

    None,

}

        }

    }

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

        match self.stmt.take() {

            ExecStmt::None => return None,

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

        }

    }

}

    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

}

pub(crate) struct CompPDL {

    pub mode: Mode,

    pub mode_port: PortId, // when blocked on a port

    pub mode_value: ValueGroup, // when blocked on a put

    pub prompt: Prompt,

    pub control: ControlLayer,

    pub consensus: Consensus,

    //  reserved per port.

    // Should be same length as the number of ports. Corresponding indices imply

    // message is intended for that port.

    pub inbox_backup: Vec<DataMessage>,

}

            mode: Mode::NonSync,

            mode_port: PortId::new_invalid(),

            mode_value: ValueGroup::default(),

            prompt: initial_state,

            control: ControlLayer::default(),

            consensus: Consensus::new(),

        // Depending on the mode don't do anything at all, take some special

        // actions, or fall through and run the PDL code.

        match self.mode {

            Mode::SyncEnd | Mode::BlockedGet | Mode::BlockedPut => {

                return Ok(CompScheduling::Sleep);

            }

            },

            EC::Put(port_id, value) => {

                debug_assert_eq!(self.mode, Mode::Sync);

                let port_id = port_id_from_eval(port_id);

                let port_handle = comp_ctx.get_port_handle(port_id);

                let port_info = comp_ctx.get_port(port_handle);

                    return Ok(CompScheduling::Immediate);

                }

            },

                debug_assert_eq!(self.mode, Mode::Sync);

            },

            EC::SelectRegisterPort(case_index, port_index, port_id) => {

                debug_assert_eq!(self.mode, Mode::Sync);

            },

            EC::SelectWait => {

                debug_assert_eq!(self.mode, Mode::Sync);

            },

            // Results that can be returned outside of sync mode

            EC::ComponentTerminated => {

        }

    }

    fn handle_component_exit(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {

        sched_ctx.log("Component exiting");

        debug_assert_eq!(self.mode, Mode::StartExit);

                // We were indeed blocked

                self.mode = Mode::Sync;

                self.mode_port = PortId::new_invalid();

            }

            return;

            self.highest_id = header.highest_id;

            for peer in comp_ctx.iter_peers() {

                if peer.id == header.sending_id {

                    continue;

                }

    let pd = ProtocolDescription::parse(b"

    func infinite_assert<T>(T val, T expected) -> () {

        while (val != expected) { print(\"nope!\"); }

    }

    primitive receiver(in<u32> in_a, in<u32> in_b, u32 num_sends) {

            sync select {

                auto v = get(in_a) -> {

                    print(\"got something from A\");

                    num_from_a += 1;

                }

                auto v = get(in_b) -> {

                    print(\"got something from B\");

                }

            }

        }

    }

    composite constructor() {

        channel tx_a -> rx_a;

        channel tx_b -> rx_b;

        new sender(tx_a, num_sends);

        new sender(tx_b, num_sends);

    }

    ").expect("compilation");

    create_component(&rt, "", "constructor", no_args());

}