Refactor coroutine macros

Since for the original version, programmers may misuse these macros,
to avoid such situation, we have modified macros that are used for
controlling coroutines and macros that programmers use for declaring
coroutine functions and their corresponding contexts.
First of all, cr_proto was introduced as the generator of coroutine
function declarations, and all coroutines should be specified with
this macro.
By introducing cr_proto, we have wrapped the argument that refers to
the coroutine context into a fixed name variable called ctx, which will
be refered by controlling macros such as cr_begin, cr_end, cr_wait and
so on. Invoking these macros is valid only in a coroutine function that
was generated by cr_proto, otherwise, compiler will report errors.
Next, we have modified structure cr that its field local is removed, and
macro cr_context is introduced for programmers to declare the coroutine
contexts. The name assigned to cr_context should be identical with the
one used to generate the coroutine function. After generated a coroutine
function and its corresponding context, programmers could launch that
coroutine via macro cr_run.
Finally, to declare static variables in coroutine, macro cr_local is
introduced, which helps to mark wheather a variable is a part of
coroutine or just for temporary usage.

Abstract using of coroutine macros

With in this version, a set of macros are introduced, which aim to
provide standard style for someone declare or access the coroutine
function and its corresponding context.
One should declare a coroutine function with cr_func_def macro, and
its corresponding context with cr_context macro, the argument name
provides to those macros for the same coroutine should be identical.
After declaration, one could run a coroutine by cr_run macro.
Wrapping a set of cr_run macros in a loop makes several coroutines
execute concurrently.
Since the declaration of a coroutine funciton is wrapped by macro
cr_func_def, there is no need to provide the context as argument of
macros that contorl the coroutine, such as cr_begin, cr_end, cr_wait
etc. That argument was hardcoded as __ct in the body of those macros.
To pass arguments to a coroutine, one can provide a pointer to that
argument as parameter of cr_context_init macro, and to extact them
in the coroutine, two macros, cr_arg and cr_arg_member, were
introduced. Macro cr_arg will cast __ct->arg to the pointer of
corresponding type, while cr_arg_member will return a pointer to the
specific member of given structure type that __ct->arg points to.
Finally, to define a static variable with in the coroutine, one can
define them with cr_local macro, which helps to hightlight wheather
a variable is a part of that coroutine or just for temporary usage.

Rename macros and variables

To make the name of macros and variables indicate purpose of themself
more clearly, some of them were renamed. Following lists the modified
macros and variables:
* Macro cr_func_def is renamed as cr_define, which will avoid confusing
  and make programmers focus on dealing body of coroutine.
* Hardcoded __ct is renamed as ctx which stands for context.\
* The name of structure sock_w_loc_t is changed to conn_data_t, since
  it aims to hold data used for connection.

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,40 +14,50 @@ enum {
 struct cr {
     void *label;
     int status;
-    void *local; /* private local storage */
 };
 
-#define cr_init()                           \
+#define cr_context_name(name) __cr_context_##name
+#define cr_context(name) struct cr cr_context_name(name)
+#define cr_context_init()                   \
     {                                       \
         .label = NULL, .status = CR_BLOCKED \
     }
-#define cr_begin(o)                     \
-    do {                                \
-        if ((o)->status == CR_FINISHED) \
-            return;                     \
-        if ((o)->label)                 \
-            goto *(o)->label;           \
+
+#define cr_func_name(name) __cr_func_##name
+#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), ##__VA_ARGS__)
+
+#define cr_local static
+
+#define cr_begin()                         \
+    do {                                   \
+        if ((ctx)->status == CR_FINISHED)  \
+            return;                        \
+        if ((ctx)->label)                  \
+            goto *(ctx)->label;            \
     } while (0)
 #define cr_label(o, stat)                                   \
     do {                                                    \
         (o)->status = (stat);                               \
         __cr_line(label) : (o)->label = &&__cr_line(label); \
     } while (0)
-#define cr_end(o) cr_label(o, CR_FINISHED)
+#define cr_end() cr_label(ctx, CR_FINISHED)
 
-#define cr_status(o) (o)->status
+#define cr_status(name) cr_context_name(name).status
 
-#define cr_wait(o, cond)         \
-    do {                         \
-        cr_label(o, CR_BLOCKED); \
-        if (!(cond))             \
-            return;              \
+#define cr_wait(cond)               \
+    do {                            \
+        cr_label(ctx, CR_BLOCKED);  \
+        if (!(cond))                \
+            return;                 \
     } while (0)
 
-#define cr_exit(o, stat)   \
-    do {                   \
-        cr_label(o, stat); \
-        return;            \
+#define cr_exit(stat)         \
+    do {                      \
+        cr_label(ctx, stat);  \
+        return;               \
     } while (0)
 
 #define cr_queue(T, size) \
@@ -70,9 +80,9 @@ struct cr {
     (cr_queue_empty(q) ? NULL : &(q)->buf[(q)->r++ % cr_queue_len(q)])
 
 /* Wrap system calls and other functions that return -1 and set errno */
-#define cr_sys(o, call)                                                     \
-    cr_wait(o, (errno = 0) || !(((call) == -1) &&                           \
-                                (errno == EAGAIN || errno == EWOULDBLOCK || \
+#define cr_sys(call)                                                        \
+    cr_wait((errno = 0) ||                                                  \
+            !(((call) == -1) && (errno == EAGAIN || errno == EWOULDBLOCK || \
                                  errno == EINPROGRESS || errno == EINTR)))
 
 #include <arpa/inet.h>
@@ -87,47 +97,47 @@ struct cr {
 
 typedef cr_queue(uint8_t, 4096) byte_queue_t;
 
-static void stdin_loop(struct cr *o, byte_queue_t *out)
+static void cr_proto(stdin_loop, byte_queue_t *out)
 {
-    static uint8_t b;
-    static int r;
-    cr_begin(o);
+    cr_local uint8_t b;
+    cr_local int r;
+    cr_begin();
     for (;;) {
-        cr_sys(o, r = read(STDIN_FILENO, &b, 1));
+        cr_sys(r = read(STDIN_FILENO, &b, 1));
         if (r == 0) {
-            cr_wait(o, cr_queue_empty(out));
-            cr_exit(o, 1);
+            cr_wait(cr_queue_empty(out));
+            cr_exit(1);
         }
-        cr_wait(o, !cr_queue_full(out));
+        cr_wait(!cr_queue_full(out));
         cr_queue_push(out, b);
     }
-    cr_end(o);
+    cr_end();
 }
 
-static void socket_write_loop(struct cr *o, int fd, byte_queue_t *in)
+static void cr_proto(socket_write_loop, byte_queue_t *in, int fd)
 {
-    static uint8_t *b;
-    cr_begin(o);
+    cr_local uint8_t *b;
+    cr_begin();
     for (;;) {
-        cr_wait(o, !cr_queue_empty(in));
+        cr_wait(!cr_queue_empty(in));
         b = cr_queue_pop(in);
-        cr_sys(o, send(fd, b, 1, 0));
+        cr_sys(send(fd, b, 1, 0));
     }
-    cr_end(o);
+    cr_end();
 }
 
-static void socket_read_loop(struct cr *o, int fd)
+static void cr_proto(socket_read_loop, int fd)
 {
-    static uint8_t b;
-    static int r;
-    cr_begin(o);
+    cr_local uint8_t b;
+    cr_local int r;
+    cr_begin();
     for (;;) {
-        cr_sys(o, r = recv(fd, &b, 1, 0));
+        cr_sys(r = recv(fd, &b, 1, 0));
         if (r == 0)
-            cr_exit(o, 1);
-        cr_sys(o, write(STDOUT_FILENO, &b, 1));
+            cr_exit(1);
+        cr_sys(write(STDOUT_FILENO, &b, 1));
     }
-    cr_end(o);
+    cr_end();
 }
 
 static int nonblock(int fd)
@@ -176,23 +186,24 @@ int main(int argc, char *argv[])
     };
     connect(fd, (struct sockaddr *) &addr, sizeof(struct sockaddr_in));
 
-    struct cr cr_stdin = cr_init();
-    struct cr cr_socket_read = cr_init();
-    struct cr cr_socket_write = cr_init();
     byte_queue_t queue = cr_queue_init();
 
-    while (cr_status(&cr_stdin) == CR_BLOCKED &&
-           cr_status(&cr_socket_read) == CR_BLOCKED) {
+    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) {
         if (cr_queue_empty(&queue)) {
             fd_set fds;
             FD_ZERO(&fds);
             FD_SET(STDIN_FILENO, &fds);
             FD_SET(fd, &fds);
             select(fd + 1, &fds, NULL, NULL, NULL);
         }
-        socket_read_loop(&cr_socket_read, fd);
-        socket_write_loop(&cr_socket_write, fd, &queue);
-        stdin_loop(&cr_stdin, &queue);
+        cr_run(socket_read_loop, fd);
+        cr_run(socket_write_loop, &queue, fd);
+        cr_run(stdin_loop, &queue);
     }
 
     close(fd);