Add cco_await_void().

docs/ccommon_api.md

@@ -362,14 +362,15 @@ To resume the coroutine from where it was suspended with *cco_yield()*, simply c
 |           | `cco_yield(retval)`                  | Suspend execution and return retval     |
 |           | `cco_yield()`                        | Suspend execution (return void)         |
 |           | `cco_await(promise)`                 | Suspend and return false until promise is true |
+|           | `cco_await_void(promise)`            | Suspend until promise is true (return void) |
 |           | `cco_await_while(cond, retval)`      | Suspend and return retval while cond is true |
-|           | From caller side:                    |                                         | 
-| `void`    | `cco_stop(ctx)`                      | Next call of coroutine returns `cco_end()` |                  
-| `void`    | `cco_reset(ctx)`                     | Reset state to initial (for reuse)      |
 |           | Semaphores:                          |                                         | 
 |           | `cco_semaphore`                      | Semaphore type                          |                  
 |           | `cco_await_sem(sem)`                 | Await for the semaphore count > 0       |                  
 |           | `cco_signal_sem(sem)`                | Signal the semaphore by increasing count|
+|           | From caller side:                    |                                         | 
+| `void`    | `cco_stop(ctx)`                      | Next call of coroutine returns `cco_end()` |                  
+| `void`    | `cco_reset(ctx)`                     | Reset state to initial (for reuse)      |
 
 ---
 ## RAII scope macros

include/stc/algo/coroutine.h

@@ -89,6 +89,7 @@ enum cco_states {
     } while (0)
 
 #define cco_await(promise) cco_await_while(!(promise), false)
+#define cco_await_void(promise) cco_await_while(!(promise), )
 
 #define cco_final \
     case cco_state_final: \
@@ -120,7 +121,7 @@ typedef struct {
  * This macro carries out the "wait" operation on the semaphore. The
  * wait operation causes the "thread" to block while the counter is
  * zero. When the counter reaches a value larger than zero, the
- * protothread will continue.
+ * "thread" will continue.
  */
 #define cco_await_sem(sem) \
   do { \
@@ -136,6 +137,6 @@ typedef struct {
  * eventually will cause waiting "threads" to continue executing.
  */
 #define cco_signal_sem(sem) ++(sem)->count
-#define cco_reset_sem(sem, value) ((sem)->count = value)
+#define cco_reset_sem(sem, value) ((sem)->count = (value))
 
 #endif