/* vim: set ts=4 sw=4 tw=99 et:

 *

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

 * JITCraft is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * JITCraft. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_jitcraft_thread_h_

#define _include_jitcraft_thread_h_

#include "PoolAllocator.h"

#include "Stack.h"

#include "Heap.h"

#include "Barriers.h"

#include "Handles.h"

#include "RootScopes.h"

#include "VirtualObjectVisitor.h"

namespace jc {

class TypeManager;

class Zone

{

    PoolAllocator pool_;

    Stack stack_;

    Heap heap_;

    // Map cache.

    Unbarriered<Map> maps_[MapKinds_Total];

    TypeManager *types_;

    // Root list.

    Local<Object> *lastLocalRoot_;

    RootScopeManager rootScopes_;

  public:

    Zone();

    bool initialize();

    PoolAllocator &pool() {

        return pool_;

    }

    Stack &stack() {

        return stack_;

    }

    Heap &heap() {

        return heap_;

    }

    Object *allocate(MapKind kind, size_t bytes, Heap::Tenure tenure = Heap::Tenure_Default) {

        assert(maps_[kind]);

        Local<Map> map(this, maps_[kind]);

        return allocate(map, bytes, tenure);

    }

    Object *allocate(Handle<Map> map, size_t bytes, Heap::Tenure tenure = Heap::Tenure_Default) {

        return heap_.allocate(map, bytes, tenure);

    }

    Map *getMap(MapKind kind) {

        return maps_[kind];

    }

    Map *allocateMap(MapKind kind, size_t bytes, MapKind parent = MapKind_Meta);

    TypeManager *types() const {

        return types_;

    }

    Local<Object> **lastLocalRoot() {

        return &lastLocalRoot_;

    }

    Object **makeScopedRoot(Object *ptr) {

        return rootScopes_.make(ptr);

    }

    RootScopeManager &rootScopes() {

        return rootScopes_;

    }

    void accept(VirtualObjectVisitor *visitor);

};

// In a multi-threaded system, this would be a TLS variable.

// In the interest of simplicity, we are single-threaded for now.

extern Zone SingleThreadedZone;

static inline Zone *ZONE()

{

    return &SingleThreadedZone;

}

class LocalTop

{

    Top &mine_;

    Top *prev_;

  public:

    LocalTop(Top &mine)

      : mine_(mine),

        prev_(ZONE()->stack().top())

    {

        ZONE()->stack().setTop(&mine_);

    }

    ~LocalTop()

    {

        ZONE()->stack().setTop(prev_);

    }

};

template <typename T>

Local<T>::Local(Zone *zone, T *thing)

  : zone_(zone),

    thing_(thing),

    prev_(*zone->lastLocalRoot())

{

    *zone->lastLocalRoot() = toRaw();

}

template <typename T>

Local<T>::~Local()

{

    assert(*zone_->lastLocalRoot() == toRaw());

    *zone_->lastLocalRoot() = prev_;

}

template <typename T>

ScopedRoot<T>::ScopedRoot()

  : thingp_(make(NULL))

{

}

template <typename T>

ScopedRoot<T>::ScopedRoot(T *thing)

  : thingp_(make(thing))

{

    // Type check that T is an Object.

    (void)static_cast<Object *>(thing);

}

template <typename T> T **

ScopedRoot<T>::make(T *other)

{

    return reinterpret_cast<T **>(ZONE()->makeScopedRoot(other));

}

RootScope::RootScope(Zone *zone)

  : zone_(zone),

    position_(zone->rootScopes().position()),

    prev_(*zone->rootScopes().scope())

{

    *zone->rootScopes().scope() = this;

}

RootScope::~RootScope()

{

    zone_->rootScopes().unwind(position_);

    *zone_->rootScopes().scope() = prev_;

}

}

#endif // _include_jitcraft_thread_h_