protothreads.h

Go to the documentation of this file.

/*
 * protothreads.h
 *
 * Part of librfn (a general utility library from redfelineninja.org.uk)
 *
 * Copyright (C) 2013-2014 Daniel Thompson <daniel@redfelineninja.org.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 */

#ifndef RF_PROTOTHREADS_H_
#define RF_PROTOTHREADS_H_

#include <assert.h>
#include <stdint.h>

typedef enum {
        PT_YIELDED,
        PT_WAITING,
        PT_EXITED
} pt_state_t;

typedef uint16_t pt_t;

#define PT_INIT(pt)                                                            \
        do {                                                                   \
                *(pt) = 0;                                                     \
        } while (0)

#define PT_BEGIN(pt)                                                           \
        {                                                                      \
                pt_t *missing_PT_BEGIN = pt;                                   \
                (void) missing_PT_BEGIN;                                       \
                switch (*missing_PT_BEGIN) {                                   \
                case 0:

#define PT_END()                                                               \
                        break;                                                 \
                default:                                                       \
                        assert(0);                                             \
                }                                                              \
        }                                                                      \
        return PT_EXITED

#define PT_WAIT()                                                              \
        do {                                                                   \
                *missing_PT_BEGIN = __LINE__;                                  \
                return PT_WAITING;                                             \
        case __LINE__:                                                         \
                ;                                                              \
        } while (0)

#define PT_WAIT_UNTIL(c)                                                       \
        do {                                                                   \
                *missing_PT_BEGIN = __LINE__;                                  \
        case __LINE__:                                                         \
                if (!(c))                                                      \
                        return PT_WAITING;                                     \
        } while (0)

#define PT_YIELD()                                                             \
        do {                                                                   \
                *missing_PT_BEGIN = __LINE__;                                  \
                return PT_YIELDED;                                             \
        case __LINE__:                                                         \
                ;                                                              \
        } while (0)

#define PT_EXIT() \
        return PT_EXITED

#define PT_EXIT_ON(x)                                                          \
        do {                                                                   \
                if (x)                                                         \
                        return PT_EXITED;                                      \
        } while (0)

#define PT_SPAWN(child, thread)                                                \
        do {                                                                   \
                pt_state_t ptres;                                              \
                PT_INIT(child);                                                \
                *missing_PT_BEGIN = __LINE__;                                  \
        case __LINE__:                                                         \
                ptres = (thread);                                              \
                if (ptres != PT_EXITED)                                        \
                        return ptres;                                          \
        } while (0)

#define PT_CALL(child, thread)                                                 \
        do {                                                                   \
                PT_INIT(child);                                                \
                while (PT_EXITED != (thread))                                  \
                        ;                                                      \
        } while (0)

#endif // RF_PROTOTHREADS_H_