Make coroutine function be declared in C-Style

Macro cr_proto is introduced to replace cr_define, which makes
programmers to declare a coroutine function in C-style, that is,
more flexible than cr_define.
Macro cr_run is modified to make respond to cr_proto. The new
version of cr_run accepts variable length argument list.
From now, programmers could specify arguments that are going to be
passed to coroutines, by listing arguments after name while starting
coroutine with macro cr_run. Since the way of passing arguments was
changed, the field arg in structure cr is removed and macros that
aimed to fetch value from arg are also removed.

Author: forward-jt

tinync/tinync.c

@@ -14,23 +14,21 @@ enum {
 struct cr {
     void *label;
     int status;
-    void *arg;
 };
 
 #define cr_context_name(name) __cr_context_##name
 #define cr_context(name) struct cr cr_context_name(name)
-#define cr_context_init(argptr)                            \
-    {                                                      \
-        .label = NULL, .status = CR_BLOCKED, .arg = argptr \
+#define cr_context_init()                   \
+    {                                       \
+        .label = NULL, .status = CR_BLOCKED \
     }
 
 #define cr_func_name(name) __cr_func_##name
-#define cr_define(name) static void cr_func_name(name)(struct cr * ctx)
+#define cr_proto(name, ...) cr_func_name(name)(struct cr * ctx, ##__VA_ARGS__)
 
-#define cr_run(name) cr_func_name(name)(&cr_context_name(name))
+#define cr_run(name, ...) \
+    cr_func_name(name)(&cr_context_name(name), ##__VA_ARGS__)
 
-#define cr_arg(type) (type *) (ctx->arg)
-#define cr_arg_member(type, memb) &((type *) (ctx->arg))->memb;
 #define cr_local static
 
 #define cr_begin()                         \
@@ -99,14 +97,8 @@ struct cr {
 
 typedef cr_queue(uint8_t, 4096) byte_queue_t;
 
-typedef struct {
-    int fd;
-    byte_queue_t *queue;
-} conn_data_t;
-
-cr_define(stdin_loop)
+static void cr_proto(stdin_loop, byte_queue_t *out)
 {
-    byte_queue_t *out = cr_arg(byte_queue_t);
     cr_local uint8_t b;
     cr_local int r;
     cr_begin();
@@ -122,10 +114,8 @@ cr_define(stdin_loop)
     cr_end();
 }
 
-cr_define(socket_write_loop)
+static void cr_proto(socket_write_loop, byte_queue_t *in, int fd)
 {
-    byte_queue_t *in = *cr_arg_member(conn_data_t, queue);
-    int fd = *cr_arg_member(conn_data_t, fd);
     cr_local uint8_t *b;
     cr_begin();
     for (;;) {
@@ -136,9 +126,8 @@ cr_define(socket_write_loop)
     cr_end();
 }
 
-cr_define(socket_read_loop)
+static void cr_proto(socket_read_loop, int fd)
 {
-    int fd = *cr_arg(int);
     cr_local uint8_t b;
     cr_local int r;
     cr_begin();
@@ -198,14 +187,10 @@ int main(int argc, char *argv[])
     connect(fd, (struct sockaddr *) &addr, sizeof(struct sockaddr_in));
 
     byte_queue_t queue = cr_queue_init();
-    conn_data_t conn_data = {
-        .fd = fd,
-        .queue = &queue,
-    };
 
-    cr_context(stdin_loop) = cr_context_init(&queue);
-    cr_context(socket_read_loop) = cr_context_init(&fd);
-    cr_context(socket_write_loop) = cr_context_init(&conn_data);
+    cr_context(stdin_loop) = cr_context_init();
+    cr_context(socket_read_loop) = cr_context_init();
+    cr_context(socket_write_loop) = cr_context_init();
 
     while (cr_status(stdin_loop) == CR_BLOCKED &&
            cr_status(socket_read_loop) == CR_BLOCKED) {
@@ -216,9 +201,9 @@ int main(int argc, char *argv[])
             FD_SET(fd, &fds);
             select(fd + 1, &fds, NULL, NULL, NULL);
         }
-        cr_run(socket_read_loop);
-        cr_run(socket_write_loop);
-        cr_run(stdin_loop);
+        cr_run(socket_read_loop, fd);
+        cr_run(socket_write_loop, &queue, fd);
+        cr_run(stdin_loop, &queue);
     }
 
     close(fd);