1 files changed, 0 insertions, 108 deletions
diff --git a/libcr_ipc/coroutine_rpc.h b/libcr_ipc/coroutine_rpc.h
deleted file mode 100644
index 11d40d7..0000000
--- a/libcr_ipc/coroutine_rpc.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/* coroutine_rpc.h - Simple request/response system for coroutine.{h,c}
- *
- * Copyright (C) 2024  Luke T. Shumaker <lukeshu@lukeshu.com>
- * SPDX-Licence-Identifier: AGPL-3.0-or-later
- */
-
-/**
- * The cr_rpc_* macros form a simple request/response mechanism built
- * on top of the cr_pause_and_yeild() and cr_unpause() primitives.
- */
-#ifndef _COROUTINE_RPC_H_
-#define _COROUTINE_RPC_H_
-
-#include <assert.h>
-
-#include "coroutine.h"
-
-/**
- * cr_rpc_t(req_t, resp_t) returns the type definition for a
- * rcp-channel on which the requester submits a value of type `req_t`
- * and the responder responds with a value of type `resp_t`.
- *
- * There may be multiple concurrent requesters, but only one
- * concurrent responder.  If you need multiple concurrent responders,
- * set up a system of coroutine_chan.h channels.
- */
-#define cr_rpc_t(req_t, resp_t) struct {            \
-		cid_t   requester, *tail_requester; \
-		cid_t   responder;                  \
-		req_t  *req_p;                      \
-		resp_t *resp_p;                     \
-	}
-
-/* These "functions" are preprocessor macros instead of real C
- * functions so that the compiler can do type-checking instead of
- * having these functions take `void*`.  */ 
-
-/**
- * ch_rpc_req(cr_rpc_t(req_t, resp_t) *ch, resp_t *resp, req_t req)
- * submits the `req` request to `ch` puts the response in `*resp_p`.
- *
- * Blocking: Always; until the responder has called both
- * cr_rpc_recv_req() and cr_rpc_send_resp().
- */
-#define cr_rpc_req(ch, _resp_p, _req) do {                    \
-		cid_t next = 0;                               \
-		if ((ch)->requester) {                        \
-			*((ch)->tail_requester = cr_getcid(); \
-			(ch)->tail_requester = &next;         \
-			cr_pause_and_yield();                 \
-		} else {                                      \
-			(ch)->requester = cr_getcid();        \
-			(ch)->tail_requester = &next;         \
-		}                                             \
-		assert((ch)->requester == cr_getcid());       \
-		(ch)->req_p = &(_req);                        \
-		(ch)->resp_p = (_resp_p;                      \
-		if ((ch)->responder != 0)                     \
-			cr_unpause((ch)->responder);          \
-		cr_pause_and_yield();                         \
-		if (next) {                                   \
-			(ch)->requester = next;               \
-			cr_unpause(next);                     \
-		} else {                                      \
-			(ch)->requester = 0;                  \
-			(ch)->tail_requester = NULL;          \
-		}
-	} while (0)
-
-/**
- * cr_rpc_have_req(cr_rpc_t(req_t, resp_t) *ch) allows a responder
- * to check whether or not there is a request waiting to be received
- * (with cr_rpc_recv_req()) without blocking if there is not.
- *
- * Blocking: Never.
- */
-#define cr_rpc_have_req(ch) ((ch)->req_p != NULL)
-
-/**
- * cr_rpc_recv_req(cr_rpc_t(req_t, resp_t) *ch, req_t *req_p) reads
- * a request from ch into `*req_p`.
- *
- * If there is not a pending request on `ch`, blocks until there is.
- *
- * Blocking: Maybe.
- */
-#define cr_rpc_recv_req(ch, _req_p) do {       \
-		(ch)->responder = cr_getcid(); \
-		if ((ch)->requester == 0)      \
-			cr_pause_and_yield();  \
-		*(_req_p) = *((ch)->req_p);    \
-		(ch)->req_p = NULL;            \
-	} while (0)
-
-/**
- * cr_rpc_send_resp(cr_rpc_t(req_t, resp_t) *ch, resp_t resp) sends
- * the reply to the most-recently-read request.
- *
- * Blocking: Never.
- */
-#define cr_rpc_send_resp(ch, _resp) do {       \
-		(ch)->responder = 0;           \
-		*((ch)->resp_p) = (_resp);     \
-		(ch)->resp_p = NULL;           \
-		cr_unpause((ch)->requester);   \
-	} while (0)
-
-#endif /* _COROUTINE_RPC_H_ */