/* 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();

}