crate-type = [

	"rlib", # for use as a Rust dependency. 

	"cdylib" # for FFI use, typically C.

]

[features]

ffi = [] # see src/ffi/mod.rs

ffi_pseudo_socket_api = ["ffi", "libc", "os_socketaddr"]# see src/ffi/pseudo_socket_api.rs.

endpoint_logging = [] # see src/macros.rs

session_optimization = [] # see src/runtime/setup.rs

#include "../../reowolf.h"

#include "../utility.c"

int main(int argc, char** argv) {

	Arc_ProtocolDescription * pd = protocol_description_parse("", 0);

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	rw_err_peek(c);

	PortId putter, getter;

	FfiSocketAddr local_addr = {{0, 0, 0, 0}, 8000};

	FfiSocketAddr peer_addr =  {{8, 8, 8, 1}, 8001};

	memset(msg_ptr, 42, msg_len);

	int i;

	for(i=0; i<10; i++) {

		connector_put_bytes(c, putter, msg_ptr, msg_len);

		rw_err_peek(c);

		connector_sync(c, -1);

		rw_err_peek(c);

	}

	printf("Exiting\n");

	protocol_description_destroy(pd);

script_path = os.path.dirname(os.path.realpath(__file__));

for c_file in glob.glob(script_path + "/*/*.c", recursive=False):

  print("compiling", c_file)

  args = [

    "gcc",          # compiler

    "-std=c11",     # C11 mode

    "-Wl,-R./",     # pass -R flag to linker: produce relocatable object

    c_file,         # input source file

typedef uint32_t U32Suffix;

typedef struct {

  ConnectorId connector_id;

  U32Suffix u32_suffix;

typedef struct {

  uint8_t ipv4[4];

  uint16_t port;

} FfiSocketAddr;

Connector *connector_new(const Arc_ProtocolDescription *pd);

Connector *connector_new_logging(const Arc_ProtocolDescription *pd,

                                 const uint8_t *path_ptr,

                                 uintptr_t path_len);

intptr_t connector_next_batch(Connector *connector);

void connector_print_debug(Connector *connector);

/**

 * Convenience function combining the functionalities of

}

#[derive(

    Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize,

)]

#[repr(transparent)]

pub struct PortId(Id);

pub struct Payload(Arc<Vec<u8>>);

#[derive(

    Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd, serde::Serialize, serde::Deserialize,

)]

#[repr(C)]

pub enum Polarity {

    PutMsg(PortId, Payload),

    NondetChoice { n: u16 },

}

pub(crate) struct DenseDebugHex<'a>(pub &'a [u8]);

///////////////////// IMPL /////////////////////

impl IdParts for Id {

    fn id_parts(self) -> (ConnectorId, U32Suffix) {

        (self.connector_id, self.u32_suffix)

    }

}

impl IdParts for PortId {

    Box::into_raw(Box::new(pd.clone()))

}

///////////////////// CONNECTOR //////////////////////////

#[no_mangle]

    pd: &Arc<ProtocolDescription>,

    path_ptr: *const u8,

    path_len: usize,

) -> *mut Connector {

    StoredError::tl_clear();

    let path_bytes = &*slice_from_raw_parts(path_ptr, path_len);

    let path_str = match std::str::from_utf8(path_bytes) {

        Ok(path_str) => path_str,

        Err(err) => {

            StoredError::tl_debug_store(&err);

            return std::ptr::null_mut();

        }

    };

    match std::fs::File::create(path_str) {

        Ok(file) => {

            let file_logger = Box::new(FileLogger::new(connector_id, file));

            let c = Connector::new(file_logger, pd.clone(), connector_id);

            Box::into_raw(Box::new(c))

        }

        Err(err) => {

            StoredError::tl_debug_store(&err);

            std::ptr::null_mut()

        }

    }

}

#[no_mangle]

pub unsafe extern "C" fn connector_print_debug(connector: &mut Connector) {

    println!("Debug print dump {:#?}", connector);

}

/*

Change the definition of these macros to control the logging level statically

*/

macro_rules! log {

        if let Some(w) = $logger.line_writer() {

            let _ = writeln!(w, $($arg)*);

        }

    }};

    ($logger:expr, $($arg:tt)*) => {{

    }};

}

        timeout: Option<Duration>,

    ) -> Result<Option<RoundOk>, SyncError> {

        //////////////////////////////////

        use SyncError as Se;

        //////////////////////////////////

        log!(

            cu.inner.logger,

            "~~~ SYNC called with timeout {:?}; starting round {}",

            &timeout,

            comm.round_index

        );

        // 1. run all proto components to Nonsync blockers

        // NOTE: original components are immutable until Decision::Success

        let mut branching_proto_components =

            HashMap::<ProtoComponentId, BranchingProtoComponent>::default();

        let mut unrun_components: Vec<(ProtoComponentId, ProtoComponent)> =

                    branching_proto_components

                        .insert(proto_component_id, BranchingProtoComponent::initial(component));

                }

            }

        }

        log!(

            cu.inner.logger,

            "All {} proto components are now done with Nonsync phase",

            branching_proto_components.len(),

        );

        // Create temp structures needed for the synchronous phase of the round

        let mut rctx = RoundCtx {

            solution_storage: {

                let n = std::iter::once(SubtreeId::LocalComponent(ComponentId::Native));

                let c = cu

                SolutionStorage::new(subtree_id_iter)

            },

            spec_var_stream: cu.inner.id_manager.new_spec_var_stream(),

            getter_buffer: Default::default(),

            deadline: timeout.map(|to| Instant::now() + to),

        };

        // Explore all native branches eagerly. Find solutions, buffer messages, etc.

        log!(

            cu.inner.logger,

            "Translating {} native batches into branches...",

            comm.native_batches.len()

                unreachable!()

            }

        }

        // restore the invariant: !native_batches.is_empty()

        comm.native_batches.push(Default::default());

        // Call to another big method; keep running this round until a distributed decision is reached

        let decision = Self::sync_reach_decision(

            cu,

            comm,

            &mut branching_native,

            &mut branching_proto_components,

            &mut rctx,

        )?;

        comm.endpoint_manager.udp_endpoints_round_end(&mut *cu.inner.logger, &decision)?;

        // propagate the decision to children

        let msg = Msg::CommMsg(CommMsg {

            round_index: comm.round_index,

            contents: CommMsgContents::CommCtrl(CommCtrlMsg::Announce {

                    cu.proto_components.keys()

                );

                // consume native

                Ok(Some(branching_native.collapse_with(&mut *cu.inner.logger, &predicate)))

            }

        };

        ret

    }

    fn sync_reach_decision(

        cu: &mut ConnectorUnphased,

        comm: &mut ConnectorCommunication,