/* 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 <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 Zone

 {

     PoolAllocator pool_;

     Stack stack_;

     Heap heap_;

     // Map cache.

     Unbarriered<Map> maps_[MapKinds_Total];

     Unbarriered<ArrayMap> genericArrayMap_;

     Unbarriered<ArrayMap> charArrayMap_;

     TypeManager *types_;

     StringPool *symbols_;

     GlobalRoots *globalRoots_;

     // Root list.

     Local<Object> *lastLocalRoot_;

     RootScopeManager rootScopes_;

     // Exception stuff.

     bool hasPendingException_;

     Ke::IMessageReporter *reporter_;

   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 *genericArrayMap() {

         return genericArrayMap_;

     }

     ArrayMap *charArrayMap() {

         return charArrayMap_;

     }

     TypeManager *types() const {

         return types_;

     }

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

     }

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

     String *makeSymbol(const char *string);

     void reportOutOfMemory();

     void reportError(Message message, ...);

     void reportErrorVA(Message message, va_list ap);

     bool hasPendingException();

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

 };

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