Coroutines in C

I wouldn't call it "copious", necessarily. It's easily reusable, at least. My aforementioned cooperative multitasking hackery involved inheriting from a base "coroutine-able" class that, among other things, kept a per-instance execution stack that would be updated by the dispatching loop depending on the value yielded by the generator. The end result would look something like this:

  def foo(self):
      spam = 1
      while True:
          yield self.call(self.spam_and_eggs, spam)
          spam += 1

  def spam_and_eggs(self, spam):
      print ("spam, " * spam) + "and eggs"
      if spam >= 20:
          yield self.halt()
      else:
          yield self.wait(2)
      yield self.ret()

Other actions included a goto (clear the stack and jump to a new generator method), conditional waits (keep running the thread unless, say, 2 miliseconds have elapsed since it started this cycle), and "message passing" between threads (push something onto another instance's stack). The main downside was that stack traces from exceptions inside a faux-thread were singularly useless, though I was working on some debugging tools for code using it.

The guts of it amounted to maybe a few hundred lines of code, most of which is the dispatch loop and bookkeeping for message queues. One of these days I ought to clean it up and post the code on the web somewhere, but unfortunately I'm currently in a somewhat sticky spot and looking for work (and I fear that spending more time on things like building cooperative multitasking in Python than things to further my humdrum day-job career has not been a great help thus far).