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

  */

 #include <string.h>

 #include "Types.h"

 #include "TypeManager.h"

 #include "Zone.h"

 #include "Strings.h"

 #include "Spaces-inl.h"

 #include "Heap-inl.h"

 using namespace ke;

 TypeManager::TypeManager(Zone *zone)

   : zone_(zone),

     qualTable_(ZoneAllocatorPolicy())

 {

 }

 bool

 TypeManager::initialize()

 {

     voidType_ = Type::NewVoid(zone_);

     if (!voidType_)

         return false;

     uncheckedType_ = Type::NewUnchecked(zone_);

     if (!uncheckedType_)

         return false;

     stringType_ = Type::NewString(zone_);

     if (!stringType_)

         return false;

     importableType_ = Type::NewImportable(zone_);

     if (!importableType_)

         return false;

     typeType_ = Type::NewType(zone_);

     if (!typeType_)

         return false;

     if ((primitiveTypes_[PrimitiveType_Int32] = Type::NewPrimitive(zone_, PrimitiveType_Int32)) == NULL)

         return false;

     if ((primitiveTypes_[PrimitiveType_Float] = Type::NewPrimitive(zone_, PrimitiveType_Float)) == NULL)

         return false;

     if ((primitiveTypes_[PrimitiveType_Native] = Type::NewPrimitive(zone_, PrimitiveType_Native)) == NULL)

         return false;

     if ((primitiveTypes_[PrimitiveType_Char] = Type::NewPrimitive(zone_, PrimitiveType_Char)) == NULL)

         return false;

     if ((primitiveTypes_[PrimitiveType_Bool] = Type::NewPrimitive(zone_, PrimitiveType_Bool)) == NULL)

         return false;

     Local<Type> type(zone_);

     for (unsigned i = 0; i < PrimitiveTypes_Total; i++) {

         type = primitiveTypes_[i];

         if ((referenceTypes_[i] = ReferenceType::New(zone_, type)) == NULL)

             return false;

     }

     if (!qualTable_.init(32))

         return false;

     return true;

 }

 ArrayType *

 TypeManager::newArray(Handle<Type> contained, int elements)

 {

     // :TODO: cache this.

     return ArrayType::New(zone_, contained, elements);

 }

 ArrayType *

 TypeManager::newExternalArray(Handle<Type> contained)

 {

     return ArrayType::NewExternal(zone_, contained);

 }

 ReferenceType *

 TypeManager::getReference(Handle<Type> type, bool isConst)

 {

     if (!isConst && type->isPrimitive())

         return referenceTypes_[type->primitive()];

     // :TODO: cache this.

     return ReferenceType::New(zone_, type);

 }

 EnumType *

 TypeManager::newEnum(Handle<String> name)

 {

     return EnumType::New(zone_, name);

 }

 Type *

 TypeManager::qualify(Handle<Type> argType, TypeQualifiers quals)

 {

     Local<Type> type(zone_, argType->unqualified());

     if (!quals)

         return type;

     LookupKey key(type, quals);

     // We can't use findForAdd because a GC could rehash the table.

     TypeHashTable::Result r = qualTable_.find(key);

     if (r.found())

         return *r;

     Type *quald = Type::NewQualified(zone_, quals, type);

     if (!quald)

         return NULL;

     // :TODO: assert-no-gc

     TypeHashTable::Insert i = qualTable_.findForAdd(key);

     assert(!i.found());

     if (!qualTable_.add(i, quald))

         return NULL;

     return quald;

 }

 void

 TypeManager::accept(VirtualObjectVisitor *visitor)

 {

     visitor->visit(voidType_.address());

     visitor->visit(uncheckedType_.address());

     visitor->visit(stringType_.address());

     visitor->visit(importableType_.address());

     visitor->visit(typeType_.address());

     for (unsigned i = 0; i < PrimitiveTypes_Total; i++) {

         visitor->visit(primitiveTypes_[i].address());

         visitor->visit(referenceTypes_[i].address());

     }

 }

 void

 TypeManager::sweep()

 {

     for (TypeHashTable::iterator i(&qualTable_); !i.empty(); i.next()) {

         Type *obj = *i;

         MarkBit bits = HeapChunk::GetMarkBit(obj);

         if (HeapChunk::IsWhite(bits))

             i.erase();

         else

             assert(HeapChunk::IsBlack(bits));

     }

     qualTable_.checkDensity();

 }