_ => unreachable!(),

        }

    }

}

#[derive(Debug)]

pub enum ProcedureSource {

    FuncUserDefined,

    CompUserDefined,

    // Builtin functions, available to user

    FuncGet,

    FuncPut,

    FuncFires,

    FuncCreate,

    FuncLength,

    FuncAssert,

    FuncPrint,

    // Buitlin functions, not available to user

    FuncSelectStart,

    FuncSelectRegisterCasePort,

    FuncSelectWait,

    // Builtin components, available to user

    CompRandomU32, // TODO: Remove, temporary thing

    CompTcpClient,

}

impl ProcedureSource {

    pub(crate) fn is_builtin(&self) -> bool {

        match self {

            ProcedureSource::FuncUserDefined | ProcedureSource::CompUserDefined => false,

            _ => true,

        }

    }

}

/// Generic storage for functions and components.

// Note that we will have function definitions for builtin functions as well. In

// that case the span, the identifier span and the body are all invalid.

#[derive(Debug)]

pub struct ProcedureDefinition {

    pub this: ProcedureDefinitionId,

    pub defined_in: RootId,

    // Symbol scanning

    pub kind: ProcedureKind,

    pub identifier: Identifier,

    pub poly_vars: Vec<Identifier>,

    // Parser

    pub procedure: ProcedureDefinitionId,

    // Validator/Linker

    pub parent: ExpressionParent,

    // Typing

    pub type_index: i32,

}

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

pub enum Method {

    // Builtin function, accessible by programmer

    Get,

    Put,

    Fires,

    Create,

    Length,

    Assert,

    Print,

    // Builtin function, not accessible by programmer

    SelectStart, // SelectStart(total_num_cases, total_num_ports)

    SelectRegisterCasePort, // SelectRegisterCasePort(case_index, port_index, port_id)

    SelectWait, // SelectWait() -> u32

    // Builtin component,

    ComponentRandomU32,

    ComponentTcpClient,

    // User-defined

    UserFunction,

    UserComponent,

}

impl Method {

    pub(crate) fn is_public_builtin(&self) -> bool {

        use Method::*;

        match self {

            Get | Put | Fires | Create | Length | Assert | Print => true,

            _ => false,

        }

    }

    pub(crate) fn is_user_defined(&self) -> bool {

        use Method::*;

        match self {

            UserFunction | UserComponent => true,

            _ => false,

        }

    }

}

#[derive(Debug, Clone)]

pub struct LiteralExpression {

    pub this: LiteralExpressionId,

    // Parsing

    pub span: InputSpan,

    pub value: Literal,

    // Validator/Linker

    pub parent: ExpressionParent,

    // Typing

    pub type_index: i32,

}

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

                                    return Ok(EvalContinuation::SelectStart(num_cases, num_ports));

                                },

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

                                    return Ok(EvalContinuation::SelectRegisterPort(expr_id, case_index, port_index, port_value));

                                },

                                Method::SelectWait => {

                                    match ctx.performed_select_wait() {

                                        Some(select_index) => {

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

                                        },

                                        None => {

                                            cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr.this.upcast()));

                                            return Ok(EvalContinuation::SelectWait)

                                        },

                                    }

                                },

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

                                    let num_args = expr.arguments.len();

                                    // Determine stack boundaries

                                    let cur_stack_boundary = self.store.cur_stack_boundary;

                                    let new_stack_boundary = self.store.stack.len();

                                    // Push new boundary and function arguments for new frame

                                    self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));

                                    for _ in 0..num_args {

                                        let argument = self.store.read_take_ownership(cur_frame.expr_values.pop_front().unwrap());

                                        self.store.stack.push(argument);

        let module = &self.heap[root_id];

        let definition_id = module.get_definition_by_ident(&self.heap, type_name)?;

        let definition = &self.heap[definition_id];

        // Make sure type is not polymorphic and is not a procedure

        if !definition.poly_vars().is_empty() {

            return None;

        }

        if definition.is_procedure() {

            return None;

        }

        // Lookup type in type table

        let type_parts = [ConcreteTypePart::Instance(definition_id, 0)];

        let type_id = self.types.get_monomorph_type_id(&definition_id, &type_parts)

            .expect("type ID for non-polymorphic type");

        let type_monomorph = self.types.get_monomorph(type_id);

        return Some(TypeInspector{

            heap: definition,

            type_table: type_monomorph

        });

    }

    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::Pointer | 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 },

            if iter.next() != Some(TokenKind::CloseCurly) {

                // Just to keep the compiler writers in line ;)

                panic!("compiler error: when using the #builtin pragma, wrap it in curly braces");

            }

            iter.consume();

            // Retrieve module and procedure name

            assert!(module.name.is_some(), "compiler error: builtin procedure body in unnamed module");

            let (_, module_name) = module.name.as_ref().unwrap();

            let module_name = module_name.as_str();

            let definition = ctx.heap[definition_id].as_procedure();

            let procedure_name = definition.identifier.value.as_str();

            let source = match (module_name, procedure_name) {

                ("std.global", "get") => ProcedureSource::FuncGet,

                ("std.global", "put") => ProcedureSource::FuncPut,

                ("std.global", "fires") => ProcedureSource::FuncFires,

                ("std.global", "create") => ProcedureSource::FuncCreate,

                ("std.global", "length") => ProcedureSource::FuncLength,

                ("std.global", "assert") => ProcedureSource::FuncAssert,

                ("std.global", "print") => ProcedureSource::FuncPrint,

                ("std.random", "random_u32") => ProcedureSource::CompRandomU32,

                ("std.internet", "tcp_client") => ProcedureSource::CompTcpClient,

                _ => panic!(

                    "compiler error: unknown builtin procedure '{}' in module '{}'",

                    procedure_name, module_name

                ),

            };

            return Ok((BlockStatementId::new_invalid(), source));

        } else {

            let body_id = self.consume_block_statement(module, iter, ctx)?;

            let source = match kind {

                ProcedureKind::Function =>

                    ProcedureSource::FuncUserDefined,

                ProcedureKind::Component =>

                    ProcedureSource::CompUserDefined,

            };

            return Ok((body_id, source))

        }

    }

    /// Consumes a statement and returns a boolean indicating whether it was a

    /// block or not.

    fn consume_statement(&mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx) -> Result<StatementId, ParseError> {

        let next = iter.next().expect("consume_statement has a next token");

                                }).upcast()

                            },

                            Definition::Procedure(proc_def) => {

                                // Check whether it is a builtin function

                                // TODO: Once we start generating bytecode this is unnecessary

                                let procedure_id = proc_def.this;

                                let method = match proc_def.source {

                                    // Bit of a hack, at this point the source is not yet known, except if it is a

                                    // builtin. So we check for the "kind"

                                    ProcedureSource::FuncUserDefined | ProcedureSource::CompUserDefined => {

                                        match proc_def.kind {

                                            ProcedureKind::Function => Method::UserFunction,

                                            ProcedureKind::Component => Method::UserComponent,

                                        }

                                    },

                                    ProcedureSource::FuncGet => Method::Get,

                                    ProcedureSource::FuncPut => Method::Put,

                                    ProcedureSource::FuncFires => Method::Fires,

                                    ProcedureSource::FuncCreate => Method::Create,

                                    ProcedureSource::FuncLength => Method::Length,

                                    ProcedureSource::FuncAssert => Method::Assert,

                                    ProcedureSource::FuncPrint => Method::Print,

                                    ProcedureSource::CompRandomU32 => Method::ComponentRandomU32,

                                    ProcedureSource::CompTcpClient => Method::ComponentTcpClient,

                                    _ => todo!("other procedure sources"),

                                };

                                // Function call: consume the arguments

                                let func_span = parser_type.full_span;

                                let mut full_span = func_span;

                                let arguments = self.consume_expression_list(

                                    module, iter, ctx, Some(&mut full_span.end)

                                )?;

                                ctx.heap.alloc_call_expression(|this| CallExpression{

                                    this, func_span, full_span, parser_type, method, arguments,

                                    procedure: procedure_id,

                                    parent: ExpressionParent::None,

                                    type_index: -1,

                                }).upcast()

                            }

                        }

                    },

                    _ => {

                        return Err(ParseError::new_error_str_at_span(

                            &module.source, parser_type.full_span, "unexpected type in expression"

                        ))

                    }

                expecting_wrapping_sync_stmt = true;

                expecting_no_select_stmt = true;

            },

            Method::Fires => {

                expecting_wrapping_sync_stmt = true;

            },

            Method::Create => {},

            Method::Length => {},

            Method::Assert => {

                expecting_wrapping_sync_stmt = true;

                expecting_no_select_stmt = true;

                if self.proc_kind == ProcedureKind::Function {

                    let call_span = call_expr.func_span;

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module().source, call_span,

                        "assert statement may only occur in components"

                    ));

                }

            },

            Method::Print => {},

            Method::SelectStart

            | Method::SelectRegisterCasePort

            | Method::SelectWait => unreachable!(), // not usable by programmer directly

            Method::ComponentRandomU32

                expecting_wrapping_new_stmt = true;

            },

            Method::UserFunction => {}

            Method::UserComponent => {

                expecting_wrapping_new_stmt = true;

            },

        }

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

        fn get_span_and_name<'a>(ctx: &'a Ctx, id: CallExpressionId) -> (InputSpan, String) {

            let call = &ctx.heap[id];

            let span = call.func_span;

            let name = String::from_utf8_lossy(ctx.module().source.section_at_span(span)).to_string();

            return (span, name);

        }

        if expecting_wrapping_sync_stmt {

            if self.in_sync.is_invalid() {

                let (call_span, func_name) = get_span_and_name(ctx, id);

                return Err(ParseError::new_error_at_span(

                    &ctx.module().source, call_span,

                    format!("a call to '{}' may only occur inside synchronous blocks", func_name)

                ))

// TODO: Replace when implementing port sending. Should probably be incorporated

//  into CompCtx (and rename CompCtx into CompComms)

pub(crate) type InboxMain = Vec<Option<DataMessage>>;

pub(crate) type InboxMainRef = [Option<DataMessage>];

pub(crate) type InboxBackup = Vec<DataMessage>;

/// Creates a new component based on its definition. Meaning that if it is a

/// user-defined component then we set up the PDL code state. Otherwise we

/// construct a custom component. This does NOT take care of port and message

/// management.

pub(crate) fn create_component(

    protocol: &ProtocolDescription,

    definition_id: ProcedureDefinitionId, type_id: TypeId,

    arguments: ValueGroup, num_ports: usize

) -> Box<dyn Component> {

    let definition = &protocol.heap[definition_id];

    debug_assert_eq!(definition.kind, ProcedureKind::Component);

    if definition.source.is_builtin() {

        // Builtin component

        let component: Box<dyn Component> = match definition.source {

            ProcedureSource::CompRandomU32 => Box::new(ComponentRandomU32::new(arguments)),

            ProcedureSource::CompTcpClient => Box::new(ComponentTcpClient::new(arguments)),

            _ => unreachable!(),

        };

        return component;

    } else {

        // User-defined component

        let prompt = Prompt::new(

            &protocol.types, &protocol.heap,

            definition_id, type_id, arguments

        );

        let component = CompPDL::new(prompt, num_ports);

        return Box::new(component);

    }

}

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

// Generic component messaging utilities (for sending and receiving)

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

/// Default handling of sending a data message. In case the port is blocked then

/// the `ExecState` will become blocked as well. Note that

/// `default_handle_control_message` will ensure that the port becomes

/// unblocked if so instructed by the receiving component. The returned

/// scheduling value must be used.

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;

use std::net::{IpAddr, Ipv4Addr};

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

// ComponentTcpClient

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

enum ClientSocketState {

    Connected(SocketTcpClient),

    Error,

}

impl ClientSocketState {

    fn get_socket(&self) -> &SocketTcpClient {

        match self {

            ClientSocketState::Connected(v) => v,

            ClientSocketState::Error => unreachable!(),

        }

    }

}

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

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

        return value_group;

    }

}

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

// ComponentTcpListener

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

enum ListenerSocketState {

    Connected(SocketTcpListener),

    Error,

}

impl ListenerSocketState {

    fn get_socket(&self) -> &SocketTcpListener {

        match self {

            ListenerSocketState::Connected(v) => return v,

            ListenerSocketState::Error => unreachable!(),

        }

    }

}

enum ListenerSyncState {

    AwaitingCmd,

    FinishSyncThenQuit,

}

pub struct ComponentTcpListener {

    // Properties for the tcp socket

    socket_state: ListenerSocketState,

    sync_state: ListenerSyncState,

    poll_ticket: Option<PollTicket>,

    inbox_main: InboxMain,

    inbox_backup: InboxBackup,

    pdl_input_port_id: PortId, // input port, receives commands

    pdl_output_port_id: PortId, // output port, sends connections

    input_union_accept_tag: i64,

    input_union_shutdown_tag: i64,

    output_struct_rx_index: usize,

    output_struct_tx_index: usize,

    // Generic component state

    exec_state: CompExecState,

    control: ControlLayer,

    consensus: Consensus,

}

impl Component for ComponentTcpListener {

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

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

        self.input_union_accept_tag = cmd_type.get_variant_tag_value(b"Accept").unwrap();

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

        let conn_type = pd.find_type(b"std.internet", b"TcpConnection")

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

        // Register socket for async events

        if let ListenerSocketState::Connected(socket) = &self.socket_state {

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

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

                .expect("registering tcp listener");

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

        }

    }

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

        unreachable!();

    }

    fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message) {

        match message {

            Message::Sync(message) => {

                let decision = self.consensus.receive_sync_message(sched_ctx, comp_ctx, message);

                component::default_handle_sync_decision(sched_ctx, &mut self.exec_state, comp_ctx, decision, &mut self.consensus);

            },

            Message::Control(message) => {

                if let Err(location_and_message) = component::default_handle_control_message(

                    &mut self.exec_state, &mut self.control, &mut self.consensus,

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

                ) {

                    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 {

        match self.exec_state.mode {

            CompMode::BlockedSelect

                => unreachable!(),

            CompMode::PutPortsBlockedTransferredPorts |

            CompMode::PutPortsBlockedAwaitingAcks |

            CompMode::PutPortsBlockedSendingPort |

            CompMode::NewComponentBlocked

                => return CompScheduling::Sleep,

            CompMode::NonSync => {

                match &self.socket_state {

                    ListenerSocketState::Connected(_socket) => {

                            ListenerSyncState::AwaitingCmd => {

                                component::default_handle_sync_start(

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

                                );

                            },

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

                                // component

                                component::special_create_component(

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

                                    &mut self.inbox_main, &mut self.inbox_backup, socket_component,

                                );

                                self.sync_state = ListenerSyncState::AwaitingCmd; // superfluous, see ListenerSyncState.take()

                            },

                            ListenerSyncState::FinishSyncThenQuit => {

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

                            },

                        }

                        return CompScheduling::Immediate;

                    },

                    ListenerSocketState::Error => {

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

                        return CompScheduling::Immediate;

                    }

                }

            },

            CompMode::Sync => {

                match self.sync_state {

                    ListenerSyncState::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

                        ) {

                    },

                    ListenerSyncState::AcceptCommandReceived => {

                        let socket = self.socket_state.get_socket();

                        match socket.accept() {

                            Ok(client) => {

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

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

                                let client = client.unwrap();

                                let cmd_channel = comp_ctx.create_channel();

                                let data_channel = comp_ctx.create_channel();

                                let port_ids = [

                                    cmd_channel.putter_id, cmd_channel.getter_id,

                                    data_channel.putter_id, data_channel.getter_id,

                                ];

                                for port_id in port_ids {

                                    let expected_port_index = self.inbox_main.len();

                                    let port_handle = comp_ctx.get_port_handle(port_id);

                                    self.inbox_main.push(None);

                                    self.consensus.notify_of_new_port(expected_port_index, port_handle, comp_ctx);

                                }

                                // Construct the message containing the appropriate ports that will

                                // be sent to the component commanding this listener.

                                if let Err(location_and_message) = component::default_send_data_message(

                                    &mut self.exec_state, self.pdl_output_port_id, PortInstruction::NoSource, values,

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

                                ) {

                                    component::default_handle_error_for_builtin(

                                        &mut self.exec_state, sched_ctx, location_and_message

                                    );

                                }

                                    client,

                                    cmd_rx: cmd_channel.getter_id,

                                    data_tx: data_channel.putter_id

                                return CompScheduling::Requeue;

                            },

                            Err(err) => {

                                if err.kind() == IoErrorKind::WouldBlock {

                                    return CompScheduling::Sleep;

                                } else {

                                    todo!("handle listener.accept error {:?}", err)

                                }

                            }

                        }

                    },

                        component::default_handle_sync_end(&mut self.exec_state, sched_ctx, comp_ctx, &mut self.consensus);

                        return CompScheduling::Requeue;

                    }

                }

            },

            CompMode::BlockedGet => {

                return CompScheduling::Sleep;

            },

            CompMode::SyncEnd | CompMode::BlockedPut

                => return CompScheduling::Sleep,

            CompMode::StartExit =>

                return component::default_handle_start_exit(&mut self.exec_state, &mut self.control, sched_ctx, comp_ctx, &mut self.consensus),

            CompMode::BusyExit =>

                return component::default_handle_busy_exit(&mut self.exec_state, &mut self.control, sched_ctx),

            CompMode::Exit =>

                return component::default_handle_exit(&self.exec_state),

        }

    }

}

impl ComponentTcpListener {

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

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

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

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

        if let Err(socket) = socket {

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

        }

        return Self {

            socket_state: ListenerSocketState::Connected(socket.unwrap()),

            sync_state: ListenerSyncState::AwaitingCmd,

            poll_ticket: None,

            inbox_main: vec![None, None],

            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,

            output_struct_rx_index: 0,

            exec_state: CompExecState::new(),

            control: ControlLayer::default(),

            consensus: Consensus::new(),

        }

    }

}

fn ip_addr_and_port_from_args(

    arguments: &ValueGroup, ip_index: usize, port_index: usize

) -> (IpAddr, u16) {

    debug_assert!(ip_index < arguments.values.len());

    debug_assert!(port_index < arguments.values.len());

    // Parsing IP address

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

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

    let ip_address = match ip_elements.len() {

        0 => IpAddr::V4(Ipv4Addr::UNSPECIFIED),

        4 => IpAddr::V4(Ipv4Addr::new(

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

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

        )),

        _ => todo!("friendly error reporting: ip should contain 4 octets (or 0 for unspecified)")

    };