// Block the peer of the port

        let message = control.create_port_transfer_message(unblock_put_control_id, comp_ctx.id, peer_port_id);

        let peer_handle = comp_ctx.get_peer_handle(peer_comp_id);

        let peer_info = comp_ctx.get_peer(peer_handle);

            AckAction::UnblockPutWithPorts => {

                // Send the message (containing ports) stored in the component

                // execution state to the recipient

                debug_assert_eq!(exec_state.mode, CompMode::PutPortsBlockedAwaitingAcks);

                exec_state.mode = CompMode::PutPortsBlockedSendingPort;

                let port_handle = comp_ctx.get_port_handle(exec_state.mode_port);

impl ComponentTcpClient {

    pub(crate) fn new(arguments: ValueGroup) -> Self {

        // Parsing arguments

            let (ip_address, port) = ip_addr_and_port_from_args(&arguments, 0, 1);

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

        if let Err(socket) = socket {

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

        }

}

struct PendingComponent {

    cmd_rx: PortId,

    data_tx: PortId,

}

        // Retrieve type information for the message with ports we're going to send

        let pd = &sched_ctx.runtime.protocol;

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

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

        let cmd_type = cmd_type.as_union();

                                // Now that we're outside the sync round, create the tcp client

                                // component

                                let pending = self.pending_component.take().unwrap();

                                    &mut self.exec_state, sched_ctx, comp_ctx, &mut self.control,

                                );

                            },

                            ListenerSyncState::FinishSyncThenQuit => {

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

                    ListenerSyncState::AcceptCommandReceived => {

                        let socket = self.socket_state.get_socket();

                        match socket.accept() {

                                // Create the channels (and the inbox entries, to stay consistent

                                // with the expectations from the `component` module's functions)

                                let cmd_channel = comp_ctx.create_channel();

                                let data_channel = comp_ctx.create_channel();

                                self.sync_state = ListenerSyncState::AcceptChannelGenerated;

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

                                self.pending_component = Some(PendingComponent{

                                    cmd_rx: cmd_channel.getter_id,

                                    data_tx: data_channel.putter_id

                                });

            inbox_backup: InboxBackup::new(),

            pdl_input_port_id: input_port,

            pdl_output_port_id: output_port,

            input_union_accept_tag: -1,

            input_union_shutdown_tag: -1,

            output_struct_tx_index: 0,

    }

    fn log(&self, message: &str) {

            println!("[polling] {}", message);

        }

    }

            return Err(SocketError::Modifying);

        }

        return Ok(SocketTcpClient{

            socket_handle,

            is_blocking: SOCKET_BLOCKING,

        })

    }

        if !set_socket_blocking(socket_handle, SOCKET_BLOCKING) {

            unsafe{ libc::close(socket_handle); }

            return Err(SocketError::Modifying);

impl Drop for SocketTcpClient {

    fn drop(&mut self) {

        debug_assert!(self.socket_handle >= 0);

        unsafe{ close(self.socket_handle) };

    }

            }

        }

        return Ok(SocketTcpListener{

            socket_handle,

            is_blocking: SOCKET_BLOCKING,

        });

    }

        let (mut address, mut address_size) = create_sockaddr_in_empty();

        let address_pointer = &mut address as *mut sockaddr_in;

        let socket_handle = unsafe { accept(self.socket_handle, address_pointer.cast(), &mut address_size) };

            return Err(IoError::last_os_error());

        }

    }

}

impl Drop for SocketTcpListener {

    fn drop(&mut self) {

        debug_assert!(self.socket_handle >= 0);

        unsafe{ close(self.socket_handle) };

    }

    import std.internet::*;

    func listen_port() -> u16 {

    }

        // Start tcp listener

        channel listen_cmd_tx -> listen_cmd_rx;

        channel listen_conn_tx -> listen_conn_rx;

        // Shut down the listener

        print(\"server: shutting down listener\");

    }

    // Waits for a single TCP byte (to simplify potentially having to

        sync put(conn.tx, ClientCmd::Shutdown);

    }

        channel cmd_tx -> cmd_rx;

        channel data_tx -> data_rx;

        new tcp_client({127, 0, 0, 1}, listen_port(), cmd_rx, data_tx);

        // Shut down the TCP connection

        print(\"requester: shutting down TCP component\");

        sync put(cmd_tx, ClientCmd::Shutdown);

    }

    comp constructor() {

        auto num_connections = 1;

        auto connection_index = 0;

        while (connection_index < num_connections) {

        }

    }

    ", "constructor", no_args());

}

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

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

        .expect("successful compilation");

        .expect("successful runtime startup");

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

}