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

 */

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

{

}

bool

TypeManager::initialize()

{

    voidType_ = Type::NewVoid(zone_);

    if (!voidType_)

        return false;

    uncheckedType_ = Type::NewUnchecked(zone_);

    if (!uncheckedType_)

        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] = Type::NewReference(zone_, type, false)) == NULL)

            return false;

    }

    return true;

}

Type *

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

{

    // :TODO: cache this.

    return Type::NewArray(zone_, contained, elements, isConst);

}

Type *

TypeManager::newExternalArray(Handle<Type> contained)

{

    return Type::NewExternalArray(zone_, contained);

}

Type *

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

{

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

        return referenceTypes_[type->primitive()];

    // :TODO: cache this.

    return Type::NewReference(zone_, type, isConst);

}

Type *

TypeManager::newFunction(Handle<Type> returnType, Handle<FixedArray> args,

                         Handle<FixedArray> defaults)

{

    // :TODO: cache this.

    return Type::NewFunction(zone_, returnType, args, defaults);

}

Type *

TypeManager::newNative(Handle<Type> returnType, Handle<FixedArray> args,

                       Handle<FixedArray> defaults, bool variadic)

{

    // :TODO: cache this.

    return Type::NewNative(zone_, returnType, args, defaults, variadic);

}

Type *

TypeManager::newEnum(Handle<String> name)

{

    return Type::NewEnum(zone_, name);

}

Type *

TypeManager::newStruct(Handle<String> name, Handle<FixedArray> fields, Handle<Map> newMap)

{

    return Type::NewStruct(zone_, name, fields, newMap);

}

void

TypeManager::accept(VirtualObjectVisitor *visitor)

{

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

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

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

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

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

    }

}