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

 *

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn 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.

 * 

 * SourcePawn 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

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

 */

#ifndef _include_jitcraft_thread_h_

#define _include_jitcraft_thread_h_

#include <stdarg.h>

#include "PoolAllocator.h"

#include "Stack.h"

#include "Heap.h"

#include "Barriers.h"

#include "Handles.h"

#include "Messages.h"

#include "RootScopes.h"

#include "VirtualObjectVisitor.h"

namespace ke {

class TypeManager;

class String;

class StringPool;

class GlobalRoots;

class ArrayMap;

class Exception;

class NativeTable;

class Zone

{

    PoolAllocator pool_;

    Stack stack_;

    Heap heap_;

    // Map cache.

    Unbarriered<Map> maps_[MapKinds_Total];

    Unbarriered<ArrayMap> externalGenericArrayMap_;

    Unbarriered<ArrayMap> externalCharArrayMap_;

    TypeManager *types_;

    StringPool *symbols_;

    GlobalRoots *globalRoots_;

    NativeTable *nativeTable_;

    // Root list.

    Local<Object> *lastLocalRoot_;

    RootScopeManager rootScopes_;

    AutoRooted *specialRoots_;

    // Exception stuff.

    bool hasPendingException_;

    Ke::IMessageReporter *reporter_;

    Ke::IPublicFunctionListener *publicFunctionListener_;

  private:

    Zone *thisFromCtor() {

        return this;

    }

  public:

    Zone();

    ~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);

    ArrayMap *externalGenericArrayMap() {

        return externalGenericArrayMap_;

    }

    ArrayMap *externalCharArrayMap() {

        return externalCharArrayMap_;

    }

    TypeManager *types() const {

        return types_;

    }

    AutoRooted **lastSpecialRoot() {

        return &specialRoots_;

    }

    Local<Object> **lastLocalRoot() {

        return &lastLocalRoot_;

    }

    Object **makeScopedRoot(Object *ptr) {

        return rootScopes_.make(ptr);

    }

    RootScopeManager &rootScopes() {

        return rootScopes_;

    }

    StringPool *symbols() {

        return symbols_;

    }

    GlobalRoots *globalRoots() {

        return globalRoots_;

    }

    NativeTable *nativeTable() {

        return nativeTable_;

    }

    String *makeSymbol(const char *string, size_t length);

    String *makeSymbol(const char *string);

    void reportOutOfMemory();

    void reportAllocationOverflow();

    void reportError(Message message, ...);

    void reportErrorVA(Message message, va_list ap);

    bool hasPendingException();

    void clearPendingException();

    void installErrorReporter(Ke::IMessageReporter *reporter);

    void beginCompilationErrors(const char *file);

    void reportCompilationError(Message message, unsigned line, unsigned col, va_list ap);

    void endCompilationErrors();

    void accept(VirtualObjectVisitor *visitor);

    void setPublicFunctionListener(Ke::IPublicFunctionListener *listener);

    void registerPublic(Handle<Function> fun);

    void unregisterPublic(Handle<Function> fun);

};

// 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;

}

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)

  : Ke::HandleScope(zone, zone->rootScopes().position(), *zone->rootScopes().scope())

{

}

}

#endif // _include_jitcraft_thread_h_