#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)
  };

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: \

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

typedef unsigned value_t;

struct node
{
   node* left_;
   node* right_;
   value_t value_;
};

generator(iterate_tree_t) 
{
    node* curr;
    std::vector<node*> node_queue;

    iterate_tree_t(node* root) : curr (root) {}

    /** Depth-first iteration over tree
     *  Time complexity: O(N)
     *  Average space complexity: O(log N)
     *  Worst space complexity: O(N)
     */
    emit(node*)
        if (curr)
        {
            node_queue.clear();
            node_queue.reserve(128);
            
            for (;;)
            {
                yield(curr);

               if (curr->left_ && curr->right_)
               {
                   node_queue.push_back(curr->right_);
                   curr = curr->left_;
               }
               else if (curr->left_)
               {
                   curr = curr->left_;
               }
               else if (curr->right_)
               {
                   curr = curr->right_;
               }
               else
               {
                   if (node_queue.empty())
                       break;
                   curr = node_queue.back();
                   node_queue.pop_back();
               }
            }
       }
    stop(0);
};

int main()
{
    node tree [4] = {};
    
    tree[0].value_ = 11;
    tree[0].left_ = &tree[1];
    tree[0].right_ = &tree[2];

    tree[1].value_ = 21;
    tree[1].left_ = &tree[3];
    tree[1].right_ = 0;

    tree[2].value_ = 22;
    tree[2].left_ = 0;
    tree[2].right_ = 0;

    tree[3].value_ = 31;
    tree[3].left_ = 0;
    tree[3].right_ = 0;

    iterate_tree_t iter (&tree[0]);
    do
    {
        node* n = iter();
        if (n)
            std::cout << "node: " << n->value_ << std::endl;
        else
            std::cout << "[end]" << std::endl;
    }
    while (iter);
}

generator(iterate_tree_rec_t, node*) 
{
    node* root;
    std::vector<iterate_tree_rec_t> iter_queue;

public:
    iterate_tree_rec_t(node* root)
        : root (root)
    {}

    emit(node*)
        if (0 == root)
            return;

        yield(root);

        {
            for (size_t i = 0; i != root->children_.size(); ++i)
                iter_queue.push_back(root->children_[i]);
        }

        while (iter_queue.size())
        {
            while (iter_queue.back().next())
                yield(iter_queue.back().value());
            iter_queue.pop_back();
        }

    stop_emit();
};

struct waw {
    std::vector<waw> Oh;
};

generator(iterate_tree_rec_t, node*) 
{
    node* root;

public:
    iterate_tree_rec_t(node* root)
        : root (root)
    {}

    emit(node*)
        if (0 == root)
            return;

        yield(root);

        for (size_t i = 0; i != root->children_.size(); ++i)
        {
               iterate_tree_rec_t inner (root->children_[i]);
               while (inner.next())
                    yield(inner.value());
        }
    stop_emit();
};

class CPlusPlusPorno {
    CPlusPlusPorno inner;
};

  //++ coroutine, generator, continuation for C++

  struct _generator
  {
    int _line;
    _generator():_line(-1) {}
  };

  #define $generator(NAME) struct NAME : public _generator

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

  #define $stop  } _line = 0; return false; }

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

  //-- coroutine, generator, continuation for C++

$generator(sample_gen)
{
  int n;
  $emit(int) 
    for(n = 10; n >= 0; --n)   
      $yield(n);
  $stop
};

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

bool operator()(T& _rv)
{
  do { 
     ....    

  } while(_pop());
}

bool _pop()
{
  if(!_stack) return false;
  _generatror<NAME>* t = _stack;
  *this = *_stack;
  delete t;
}

$foreach(int i, some_gen(10))
  printf("got number = %d\n",n);

#define $emit(T)    bool operator()(T& _rv) { \
                      if(_line < 0) { _line=0;}\
                      goto label(_line) // <- иди туда, куда _line укажет или... exception or UB

#define $yield(V)     \
          do {\
              _line=__LINE__;\
              _rv = (V); \
               return true; \
               label(__LINE__):;\ // <- сегануть сюда бы, да без помощи свича!
          } while (0)

volatile int global;

int main()
{
  int i;
  global = 2;
  i = global;
}

#include <vector>

struct SomeType
{
      std::vector< SomeType > vec;
};

int main()
{
      SomeType variable;
      variable.vec.push_back( variable );
      return 0;
}

template<typename T>
class vector
{
  char buf [sizeof(T)];
  ...
};

#ifndef __generator_h_
#define __generator_h_

#include <boost/preprocessor/cat.hpp>

class _generator
{
protected:
    int _addr;
    _generator():_addr(-1) {}
};

//..................................................................
#define $generator(NAME) class NAME : public _generator

#define  GOTO_LABEL         \
  if ( _addr!=-1 )          \
  {                         \
    int addr = _addr;       \
    __asm                   \
    {                       \
      __asm mov eax, addr   \
      __asm jmp eax         \
    }                       \
  }

#define $emit(T)    bool operator()(T& _rv)     \
                    {                           \
                      GOTO_LABEL                \
                      {
//.......

#define $stop         }                       \
                     _addr = -1;              \
                     return false;            \
                   }

#define $yield(V)                             \
          do {                                \
            _rv = (V);                        \
                                              \
            int * iPtr = &_addr;              \
            __asm mov ecx, dword ptr [iPtr]   \
            __asm                             \
            {                                 \
              __asm mov eax, OFFSET BOOST_PP_CAT(label,__LINE__) \
              __asm mov dword ptr [ecx], eax  \
            }                                 \
                                              \
            return true;                      \
            BOOST_PP_CAT(label,__LINE__)##:;  \
          } while (0);

#endif // __generator_h_

//=============================================================================
#include <stdio.h>

$generator(desc)
{
  int m_i;

public:
  desc( int start=-1 ) : m_i(start) {}

  $emit(int) 
  {
    for(; m_i >= 0; --m_i)
    {
// doesn't it work ?
      switch ( m_i )
      {
        case 9 : case 7 :
          $yield( m_i + 100 );
        break;

        case 5:
          $yield( m_i + 100000 );
        break;
      
        default:
          $yield( m_i );
      }
    }
  }
  $stop  
};


int main(int argc, char* argv[])
{
  desc gen( 11 );
  int i;
  while(gen(i))
  {    
    printf("got number %d\n", i);
    //gen.m_i = 10;
  }
}

int * iPtr = &_addr;              \
__asm mov ecx, dword ptr [iPtr]   \

template<typename T>
  struct _generator
  {
    T* _stack;
    int _line;
    _generator():_stack(0), _line(-1) {}
    void _push() { T* n = new T; *n = *static_cast<T*>(this); _stack = n; }
    bool _pop() { if(!_stack) return false; T* t = _stack; *static_cast<T*>(this) = *_stack; t->_stack = 0; delete t; return true; }
    ~_generator() { while(_pop()); }
  };

  #define $generator(NAME) struct NAME : public _generator<NAME>

  #define $emit(T) bool operator()(T& _rv) { \
                      if(_line < 0) _line=0; \
                      $START: switch(_line) { case 0:;

  #define $stop  } _line = 0; if(_pop()) goto $START; return false; }

  #define $restart(WITH) { _push(); _stack->_line = __LINE__; _line=0; WITH; goto $START; case __LINE__:; }

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

struct node
{
   int   value;
   node* next;
   node* kid;
   node(int v):value(v), next(0), kid(0) {}
   node* foster( node* child ) { child->next = kid; kid = child; return child; }
};

$generator(scan)
{
  node* n;
  scan( node* root = 0 ): n(root) {}

  $emit(int)
    for(;n; n = n->next)
    {
      $yield(n->value);
      if( n->kid )
        $restart( n = n->kid );
    }
  $stop
};

int main(int argc, char* argv[])
{
  node * root = new node(0);
  root->foster(new node(1));
  root->foster(new node(2));
  root->foster(new node(3));
  root->foster(new node(4));
  node * child5 = root->foster(new node(5));
  root->foster(new node(6));
  root->foster(new node(7));
  root->foster(new node(8));
  root->foster(new node(9));

  child5->foster(new node(50));
  child5->foster(new node(51));
  child5->foster(new node(52));
  child5->foster(new node(53));

  scan g(root);
  for(int n; g(n);)
      printf("n = %d\n",n);
    return 0;
}

#ifndef __generator_h_
#define __generator_h_

#include <boost/preprocessor/cat.hpp>

struct _generator
{
    void * _addr;
    _generator():_addr(0) {}
};

//------------------------------------------------------------------------------
#define $generator(NAME) class NAME : protected _generator

//.......
/// \note NB: Remember! The values of local varaibles are not preserved between
///       generator() invocation. Use them with precaution or use class members.
#define $emit(T)    bool operator()(T& _rv)              \
                    {                                    \
                      GOTO_GENERATOR_LABEL               \
                      {
//.......
#define $yield(V)       do {                             \
                          _rv = (V);                     \
                          SAVE_ADDR;                     \
                          return true;                   \
                      GENERATOR_LABEL:;                  \
                        } while (0);
//.......
#define $stop         }                                  \
                     _addr = 0;                          \
                     return false;                       \
                   }

//------------------------------------------------------------------------------
/// auxiliary macroses
#define GENERATOR_LABEL BOOST_PP_CAT(generator_label_,__LINE__)

#if defined(_MSC_VER)
# define  GOTO_GENERATOR_LABEL                           \
    if ( _addr )                                         \
    {                                                    \
      void * addr = _addr;                               \
      __asm                                              \
      {                                                  \
        __asm jmp addr                                   \
      }                                                  \
    }

# define SAVE_ADDR \
    {                                                    \
      void * pAddr = &_addr;                             \
      __asm                                              \
      {                                                  \
        __asm mov ebx, dword ptr [pAddr]                 \
        __asm mov eax, OFFSET GENERATOR_LABEL            \
        __asm mov dword ptr [ebx], eax                   \
      }                                                  \
    }

#elif defined(__GNUC__)
# define  GOTO_GENERATOR_LABEL                           \
    if ( _addr )                                         \
    {                                                    \
      void * addr = _addr;                               \
      goto *addr;                                        \
    }

# define SAVE_ADDR                                       \
    {                                                    \
      void * addr = &&GENERATOR_LABEL;                   \
      _addr = addr;                                      \
    }
#else
# error You have to check a support of "goto *label" on your platform or implement it yourself.
#endif

#endif // __generator_h_

//=============================================================================
#include <stdio.h>

$generator(desc)
{
  int m_i;

public:
  desc( int start=-1 ) : m_i(start) {}

  $emit(int) 
  {
    for(; m_i >= 0; --m_i)
    {
      switch ( m_i )
      {
        case 9 : case 7 :
          $yield( m_i + 100 );
        break;

        case 5:
          $yield( m_i + 100000 );
        break;
      
        default:
          $yield( m_i );
      }
      $yield( m_i );
    }
  }
  $stop  
};


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