#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

class Pool
{
  size_t m_reserved;
  size_t m_maxsize;
  int* m_data;
public:
  Pool(int max_size): m_reserved(0), m_maxsize(max_size), m_data(0) {}
  ~Pool() { free(m_data); };

  void* get(size_t size)
  {
    int* ret;
    size_t aligned_size= (size+sizeof(int*)+1)%sizeof(int*);
    if (!m_data)
    {
      m_data= (int*)malloc(m_maxsize/sizeof(int*));
      printf("  allocated pool: 0x%lx\n", (unsigned long)m_data);
    }
    ret= m_data+m_reserved;
    assert(ret+aligned_size < m_data+m_maxsize);
    m_reserved+= aligned_size;
    return ret;
  }
};

static Pool global_pool(2048);

class Base
{
public:
  /*
    Class specific new and delete operators
  */
  static void *operator new(size_t size) throw ()
  {
    printf("Base::new(%ld)\n", size);
    return global_pool.get(size);
  }

  static void operator delete(void *ptr, size_t size)
  {
    printf("Base::delete(0x%lx, %ld)\n", (unsigned long)ptr, size);
    /*
      Don't do anything, memory will be freed when either the
      local pool or global pool goes out of scope
    */
  }

  static void *operator new[](size_t size)
  {
    printf("Base::new[](%ld)\n", size);
    return global_pool.get(size);
  }
  static void operator delete[](void *ptr, size_t size)
  {
    printf("Base::delete[](0x%lx, %ld)\n", (unsigned long)ptr, size);
    /*
      Don't do anything, memory will be freed when either the
      local pool or global pool goes out of scope
    */
  }

  /* Class specific placement new and delete operators for void* */
  static void *operator new(size_t size, void *root) throw ()
  {
    printf("Base::new(%ld, void*: 0x%lx)\n", size, (unsigned long)root);
    /*
      Don't allocate any new memory, just return the passed root
      pointe, the instance will be constructed in root. Beware!
    */
    return root;
  }
  static void operator delete(void *ptr, void *root)
  {
    /* never called */
    abort();
  }

  static void *operator new[](size_t size, void *root) throw ()
  {
    printf("Base::new[](%ld, void*: 0x%lx)\n", size, (unsigned long)root);
    /*
      Don't allocate any new memory, just return the passed root
      pointe, the instance will be constructed in root. Beware!
    */
    return root;
  }
  static void operator delete[](void *ptr, void* root)
  {
    /* never called */
    abort();
  }

  /* Class specific placement new and delete operators for Pool */
  static void *operator new(size_t size, Pool *pool) throw ()
  {
    printf("Base::new(%ld, pool*: 0x%lx)\n", size, (unsigned long)pool);
    return pool->get(size);
  }
  static void operator delete(void *ptr, Pool *pool)
  {
    /* never called */
    abort();
  }

  static void *operator new[](size_t size, Pool *pool) throw ()
  {
    printf("Base::new[](%ld, pool*: 0x%lx)\n", size, (unsigned long)pool);
    return pool->get(size);
  }
  static void operator delete[](void *ptr, Pool *pool)
  {
    /* never called */
    abort();
  }

  Base()
  {
    printf("Base::Base, this: 0x%lx\n", (unsigned long)this);
  }
  ~Base()
  {
    printf("Base::~Base, this: 0x%lx\n", (unsigned long)this);
  }

};


class AClass : public Base
{
public:
  AClass()
  {
    printf("AClass::AClass, this: 0x%lx\n", (unsigned long)this);
  }
  inline ~AClass()
  {
    printf("AClass::~AClass, this: 0x%lx\n", (unsigned long)this);
  }

};

int main (){

  Base on_stack;
  Base on_stack_array[10];
  Base* b;

  AClass a_class_on_stack;
  AClass a_class_on_stack_array[10];
  AClass* a;

  /* Stack memory to allocate _one_ instance of Base */
  char root1[sizeof(AClass)];

  /* Stack memory to allocate 10 instances of Base */
  char root10[sizeof(AClass)*10];

  Pool pool(2048);

  printf("== Program started ==\n");

  printf("=== Testing new ===\n");
  b=  new Base;
  delete b;

  a= new AClass;
  delete a;

  printf("=== Testing placement new void* (0x%lx) ===\n", (unsigned long)root1);
  b=  new (root1) Base;
  delete b;

  a= new (root1) AClass;
  delete a;

  printf("=== Testing placement new pool* ===\n");
  b=  new (&pool) Base;
  delete b;

  a= new (&pool) AClass;
  delete a;

  printf("=== Testing array new ===\n");
  b=  new Base[10];
  delete[] b;

  a= new AClass[10];
  delete[] a;

  printf("=== Testing placement array new void* (0x%lx) ===\n", (unsigned long)root10);
  b=  new (root10) Base[10];
  delete[] b;

  a= new (root10) AClass[10];
  delete[] a;

  printf("=== Testing placement array new pool* ===\n");
  b= new (&pool) Base[10];
  delete[] b;

  a= new (&pool) AClass[10];
  delete[] a;

  printf("== Program ending ==\n");

}