#include "generator.h"

generator(desc) 
{
   int i;
   emit(int) // будем выдавать int'ы
     for (i = 10; i > 0; --i)
       yield(i); // a.k.a. yield in Python - return next number in [10..1]
   stop(0); // все, конец последовательности.
};

int main(int argc, char* argv[])
{
  desc gen;
  do
    printf("got number %d\n", gen());
  while (gen);
  return 0;
}

// generator/continuation for C++
// author: Andrew Fedoniouk @ terrainformatica.com
// idea borrowed from: "coroutines in C" Simon Tatham, 
//                     http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html

#ifndef __generator_h_
#define __generator_h_

struct _generator
{
  int _line;
  _generator():_line(-1) {}
  operator bool() const { return _line != 0; }
};

#define generator(NAME) struct NAME : public _generator

#define emit(T)     T operator()() { \
                     if(_line < 0) { _line=0;}\
                     switch(_line) { case 0:;

#define stop(V)     } _line = 0; return (V); }

#define yield(V)     \
        do {\
            _line=__LINE__;\
            return (V); case __LINE__:;\
        } while (0)


#endif // __generator_h_

generator(backward) 
{
   int *head;
   int *tail;
   backward(int *start, int *end ): head(start), tail(end){}

   emit(int)
     while(--tail > head) 
         yield(*tail);
   stop(*tail);
};

int main(int argc, char* argv[])
{
  int arr[] = {1,2,3,4,5,6};
  backward scan(&arr[0],&arr[6]);
  do 
    printf("got number %d\n", scan());
  while(scan);
  return 0;
}

struct node 
{ 
  node*         parent;
  int           index;
  array<node*>  subs;
};

  $generator(node_iterator)
  {
    node* root;
    node* c;
    node* t;
    int   n;
    node_iterator( node* root_node ): root(root_blk) { }

    $emit(node*)
       n = 0; c = root;
       while( c )
       {
         for(; n < c->subs.size(); ++n )
         {
            t = c->subs[n];
            $yield(t);
            n = 0; c = t;
         }
         if( c == root )
           break;
         n = c->index + 1; c = c->parent;
       }
    $stop(0)
  };

CS>struct node 
CS>{ 
CS>  node*         parent;
CS>  int           index;
CS>  array<node*>  subs;
CS>};
CS>

strict node { array<node*> subs; };

int main(int argc, char* argv[])
{
  desc gen;
  do {
    printf("got number %d\n", gen());
    gen.i = 10; // <- бред, но всё же...
  }
  while (gen);
  return 0;
}

class _generator // <- class вместо struct
{
protected: // <- + это
  int _line;
public: // <- + это
  _generator():_line(-1) {}
  operator bool() const { return _line != 0; }
};

// тут тоже аналогично class вместо struct 
#define generator(NAME) class NAME : public _generator

// ну и напоследок сюда public вставим
#define emit(T)   public: \

E>Так не интересно. Для этого нет нужды городить генератор. У тебя и так состояние явно выписано, да ещё и в узле индекс хранить надо

  strict node { node* child, *prev, *next;  };

strict node { array<node*> subs; };