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

            })

            .collect();

        return Ok(ProtocolDescription {

            modules,

            heap: self.parser.heap,

            types: self.parser.type_table,

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

        });

    }

}

pub struct TypeInspector<'a> {

    heap: &'a Definition,

    type_table: &'a MonoType,

}

impl<'a> TypeInspector<'a> {

    pub fn as_union(&'a self) -> UnionTypeInspector<'a> {

        let heap = self.heap.as_union();

        let type_table = self.type_table.variant.as_union();

        return UnionTypeInspector{ heap, type_table };

    }

}

pub struct UnionTypeInspector<'a> {

    heap: &'a UnionDefinition,

    type_table: &'a UnionMonomorph,

}

impl UnionTypeInspector<'_> {

    /// Retrieves union variant tag value.

    pub fn get_variant_tag_value(&self, variant_name: &[u8]) -> Option<i64> {

        let variant_index = self.heap.variants.iter()

            .position(|v| v.identifier.value.as_bytes() == variant_name)?;

        return Some(variant_index as i64);

    }

}

}

impl MonoTypeVariant {

    fn as_struct_mut(&mut self) -> &mut StructMonomorph {

        match self {

            MonoTypeVariant::Struct(v) => v,

            _ => unreachable!(),

        }

    }

    pub(crate) fn as_union(&self) -> &UnionMonomorph {

        match self {

            MonoTypeVariant::Union(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_union_mut(&mut self) -> &mut UnionMonomorph {

        match self {

            MonoTypeVariant::Union(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {

        match self {

            MonoTypeVariant::Tuple(v) => v,

            _ => unreachable!(),

        }

    }

    pub(crate) fn as_procedure(&self) -> &ProcedureMonomorph {

        match self {

            MonoTypeVariant::Procedure(v) => v,

            _ => unreachable!(),

        }

    }

    fn as_procedure_mut(&mut self) -> &mut ProcedureMonomorph {

        match self {

            MonoTypeVariant::Procedure(v) => v,

            _ => unreachable!(),

        }

    }

}

/// Struct monomorph

pub struct StructMonomorph {

use crate::protocol::eval::{ValueGroup, Value};

use crate::runtime2::*;

use crate::runtime2::component::{CompCtx, CompId, PortInstruction};

use crate::runtime2::stdlib::internet::*;

use crate::runtime2::poll::*;

use super::component::{self, *};

use super::control_layer::*;

use super::consensus::*;

use std::io::ErrorKind as IoErrorKind;

    Connected(SocketTcpClient),

    Error,

}

    fn get_socket(&self) -> &SocketTcpClient {

        match self {

        }

    }

}

/// States from the point of view of the component that is connecting to this

/// TCP component (i.e. from the point of view of attempting to interface with

/// a socket).

#[derive(PartialEq, Debug)]

enum ClientSyncState {

    AwaitingCmd,

    Getting,

    Putting,

    FinishSync,

    FinishSyncThenQuit,

}

pub struct ComponentTcpClient {

    // Properties for the tcp socket

    sync_state: ClientSyncState,

    poll_ticket: Option<PollTicket>,

    inbox_main: InboxMain,

    inbox_backup: InboxBackup,

    pdl_input_port_id: PortId, // input from PDL, so transmitted over socket

    pdl_output_port_id: PortId, // output towards PDL, so received over socket

    input_union_send_tag_value: i64,

    input_union_receive_tag_value: i64,

    input_union_finish_tag_value: i64,

    input_union_shutdown_tag_value: i64,

    // Generic component state

    exec_state: CompExecState,

    control: ControlLayer,

    consensus: Consensus,

    // Temporary variables

    byte_buffer: Vec<u8>,

}

impl Component for ComponentTcpClient {

    fn on_creation(&mut self, id: CompId, sched_ctx: &SchedulerCtx) {

        // Retrieve type information for messages we're going to receive

        let pd = &sched_ctx.runtime.protocol;

        let cmd_type = pd.find_type(b"std.internet", b"Cmd")

            .expect("'Cmd' type in the 'std.internet' module");

        let cmd_type = cmd_type

            .as_union();

        self.input_union_send_tag_value = cmd_type.get_variant_tag_value(b"Send").unwrap();

        self.input_union_receive_tag_value = cmd_type.get_variant_tag_value(b"Receive").unwrap();

        self.input_union_finish_tag_value = cmd_type.get_variant_tag_value(b"Finish").unwrap();

        self.input_union_shutdown_tag_value = cmd_type.get_variant_tag_value(b"Shutdown").unwrap();

        // Register socket for async events

            let self_handle = sched_ctx.runtime.get_component_public(id);

            let poll_ticket = sched_ctx.polling.register(socket, self_handle, true, true)

                .expect("registering tcp component");

            debug_assert!(self.poll_ticket.is_none());

            self.poll_ticket = Some(poll_ticket);

        }

    }

    fn on_shutdown(&mut self, sched_ctx: &SchedulerCtx) {

        if let Some(poll_ticket) = self.poll_ticket.take() {

            sched_ctx.polling.unregister(poll_ticket)

                .expect("unregistering tcp component");

        }

    }

    fn adopt_message(&mut self, _comp_ctx: &mut CompCtx, message: DataMessage) {

        let slot = &mut self.inbox_main[0];

        if slot.is_none() {

            *slot = Some(message);

        } else {

            self.inbox_backup.push(message);

        }

    }

                    component::default_handle_error_for_builtin(&mut self.exec_state, sched_ctx, location_and_message);

                }

            },

            Message::Poll => {

                sched_ctx.info("Received polling event");

            },

        }

    }

    fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> CompScheduling {

        sched_ctx.info(&format!("Running component ComponentTcpClient (mode: {:?}, sync state: {:?})", self.exec_state.mode, self.sync_state));

        match self.exec_state.mode {

            CompMode::BlockedSelect |

            CompMode::PutPortsBlockedTransferredPorts |

            CompMode::PutPortsBlockedAwaitingAcks |

            CompMode::PutPortsBlockedSendingPort |

            CompMode::NewComponentBlocked => {

                // Not possible: we never enter this state

                unreachable!();

            },

            CompMode::NonSync => {

                // When in non-sync mode

                match &mut self.socket_state {

                        if self.sync_state == ClientSyncState::FinishSyncThenQuit {

                            // Previous request was to let the component shut down

                            self.exec_state.set_as_start_exit(ExitReason::Termination);

                        } else {

                            // Reset for a new request

                            self.sync_state = ClientSyncState::AwaitingCmd;

                            component::default_handle_sync_start(

                                &mut self.exec_state, &mut self.inbox_main, sched_ctx, comp_ctx, &mut self.consensus

                            );

                        }

                        return CompScheduling::Immediate;

                    },

                        // Could potentially send an error message to the

                        // connected component.

                        self.exec_state.set_as_start_exit(ExitReason::ErrorNonSync);

                        return CompScheduling::Immediate;

                    }

                }

            },

            CompMode::Sync => {

                // When in sync mode: wait for a command to come in

                match self.sync_state {

                    ClientSyncState::AwaitingCmd => {

                        match component::default_attempt_get(

                            &mut self.exec_state, self.pdl_input_port_id, PortInstruction::NoSource,

                            &mut self.inbox_main, &mut self.inbox_backup, sched_ctx, comp_ctx,

                            &mut self.control, &mut self.consensus

                        ) {

                            GetResult::Received(message) => {

                                let (tag_value, embedded_heap_pos) = message.content.values[0].as_union();

                                if tag_value == self.input_union_send_tag_value {

                                    // Retrieve bytes from the message

                                    self.byte_buffer.clear();

                                    let union_content = &message.content.regions[embedded_heap_pos as usize];

                                    debug_assert_eq!(union_content.len(), 1);

                                    let array_heap_pos = union_content[0].as_array();

        debug_assert_eq!(arguments.values.len(), 4);

        // Parsing arguments

        let ip_heap_pos = arguments.values[0].as_array();

        let ip_elements = &arguments.regions[ip_heap_pos as usize];

        if ip_elements.len() != 4 {

            todo!("friendly error reporting: ip contains 4 octects");

        }

        let ip_address = IpAddr::V4(Ipv4Addr::new(

            ip_elements[0].as_uint8(), ip_elements[1].as_uint8(),

            ip_elements[2].as_uint8(), ip_elements[3].as_uint8()

        ));

        let port = arguments.values[1].as_uint16();

        let input_port = component::port_id_from_eval(arguments.values[2].as_input());

        let output_port = component::port_id_from_eval(arguments.values[3].as_output());

        let socket = SocketTcpClient::new(ip_address, port);

        if let Err(socket) = socket {

            todo!("friendly error reporting: failed to open socket (reason: {:?})", socket);

        }

        return Self{

            sync_state: ClientSyncState::AwaitingCmd,

            poll_ticket: None,

            inbox_main: vec![None],

            inbox_backup: Vec::new(),

            input_union_send_tag_value: -1,

            input_union_receive_tag_value: -1,

            input_union_finish_tag_value: -1,

            input_union_shutdown_tag_value: -1,

            pdl_input_port_id: input_port,

            pdl_output_port_id: output_port,

            exec_state: CompExecState::new(),

            control: ControlLayer::default(),

            consensus: Consensus::new(),

            byte_buffer: Vec::new(),

        }

    }

    // Handles incoming data from the PDL side (hence, going into the socket)

    fn handle_incoming_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: DataMessage) {

        if self.exec_state.mode.is_in_sync_block() {

            self.consensus.handle_incoming_data_message(comp_ctx, &message);

        }

        match component::default_handle_incoming_data_message(

            unreachable!();

        }

    }

    fn bytes_to_data_message_content(&self, buffer: &[u8]) -> ValueGroup {

        // Turn bytes into silly executor-style array

        let mut values = Vec::with_capacity(buffer.len());

        for byte in buffer.iter().copied() {

            values.push(Value::UInt8(byte));

        }

        // Put in a value group

        let mut value_group = ValueGroup::default();

        value_group.regions.push(values);

        value_group.values.push(Value::Array(0));

        return value_group;

    }

}

// -----------------------------------------------------------------------------

// ComponentTcpListener

// -----------------------------------------------------------------------------

use crate::protocol::*;

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

use crate::runtime2::runtime::*;

use crate::runtime2::component::{CompCtx, CompPDL};

mod messaging;

mod error_handling;

mod transfer_ports;

const LOG_LEVEL: LogLevel = LogLevel::Debug;

const NUM_THREADS: u32 = 1;

pub(crate) fn compile_and_create_component(source: &str, routine_name: &str, args: ValueGroup) {

    let protocol = ProtocolDescription::parse(source.as_bytes())

        .expect("successful compilation");

    let runtime = Runtime::new(NUM_THREADS, LOG_LEVEL, protocol)

        .expect("successful runtime startup");

    create_component(&runtime, "", routine_name, args);

}

pub(crate) fn create_component(rt: &Runtime, module_name: &str, routine_name: &str, args: ValueGroup) {

    let prompt = rt.inner.protocol.new_component(

        module_name.as_bytes(), routine_name.as_bytes(), args

    ).expect("create prompt");

    let reserved = rt.inner.start_create_component();

    let ctx = CompCtx::new(&reserved);

    let component = Box::new(CompPDL::new(prompt, 0));

    let (key, _) = rt.inner.finish_create_component(reserved, component, ctx, false);

    rt.inner.enqueue_work(key);

}

pub(crate) fn no_args() -> ValueGroup { ValueGroup::new_stack(Vec::new()) }

#module std.internet

union Cmd {

    Send(u8[]),

    Receive,

    Finish,

    Shutdown,

}

primitive tcp_client(u8[] ip, u16 port, in<Cmd> cmds, out<u8[]> rx) {

    #builtin

}