/* 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 "Zone.h"

#include "Strings.h"

#include "Heap-inl.h"

using namespace ke;

Type *

Type::NewVoid(Zone *zone)

{

    Local<Type> type(zone, Type::cast(zone->allocate(MapKind_Type, sizeof(Type), Heap::Tenure_Old)));

    if (!type)

        return NULL;

    type->kind_ = VOID;

    type->tag_ = NULL;

    type->contained_ = NULL;

    type->returnType_ = NULL;

    type->parameters_ = NULL;

    return type;

}

Type *

Type::NewPrimitive(Zone *zone, Handle<String> tag)

{

    Local<Type> type(zone, Type::cast(zone->allocate(MapKind_Type, sizeof(Type), Heap::Tenure_Old)));

    if (!type)

        return NULL;

    assert(!tag || strcmp(tag->chars(), "_"));

    type->kind_ = PRIMITIVE;

    type->tag_ = tag;

    type->contained_ = NULL;

    type->returnType_ = NULL;

    type->parameters_ = NULL;

    if (tag && strcmp(tag->chars(), "Float") == 0)

        type->primitive_ = PrimitiveType_Float;

    else if (tag && strcmp(tag->chars(), "String") == 0)

        type->primitive_ = PrimitiveType_Char;

    else if (tag && strcmp(tag->chars(), "bool") == 0)

        type->primitive_ = PrimitiveType_Bool;

    else

        type->primitive_ = PrimitiveType_Int32;

    return type;

}

Type *

Type::NewPrimitive(Zone *zone, PrimitiveType prim)

{

    Local<Type> type(zone, Type::cast(zone->allocate(MapKind_Type, sizeof(Type), Heap::Tenure_Old)));

    if (!type)

        return NULL;

    type->kind_ = PRIMITIVE;

    type->tag_ = NULL;

    type->contained_ = NULL;

    type->returnType_ = NULL;

    type->parameters_ = NULL;

    type->primitive_ = prim;

    return type;

}

Type *

Type::NewArray(Zone *zone, Handle<Type> contained, int elements, bool isConst)

{

    Local<Type> type(zone, Type::cast(zone->allocate(MapKind_Type, sizeof(Type), Heap::Tenure_Old)));

    if (!type)

        return NULL;

    type->kind_ = ARRAY;

    type->tag_ = NULL;

    type->contained_ = contained;

    type->returnType_ = NULL;

    type->parameters_ = NULL;

    type->elements_ = elements;

    if (contained->isPrimitive())

        type->levels_ = 1;

    else

        type->levels_ = contained->levels() + 1;

    type->const_ = isConst;

    return type;

}

Type *

Type::NewReference(Zone *zone, Handle<Type> contained, bool isConst)

{

    Local<Type> type(zone, Type::cast(zone->allocate(MapKind_Type, sizeof(Type), Heap::Tenure_Old)));

    if (!type)

        return NULL;

    type->kind_ = REFERENCE;

    type->tag_ = NULL;

    type->contained_ = contained;

    type->returnType_ = NULL;

    type->parameters_ = NULL;

    type->const_ = isConst;

    return type;

}

Type *

Type::NewFunction(Zone *zone, Handle<Type> returnType, Handle<FixedArray> parameters)

{

    Local<Type> type(zone, Type::cast(zone->allocate(MapKind_Type, sizeof(Type), Heap::Tenure_Old)));

    if (!type)

        return NULL;

    type->kind_ = FUNCTION;

    type->contained_ = NULL;

    type->returnType_ = returnType;

    type->parameters_ = parameters;

    return type;

}

Type *

Type::NewNative(Zone *zone, Handle<Type> returnType, Handle<FixedArray> parameters, bool variadic)

{

    Local<Type> type(zone, Type::cast(zone->allocate(MapKind_Type, sizeof(Type), Heap::Tenure_Old)));

    if (!type)

        return NULL;

    type->kind_ = NATIVE;

    type->contained_ = NULL;

    type->returnType_ = returnType;

    type->parameters_ = parameters;

    type->variadicNative_ = variadic;

    return type;

}

bool

Type::Compare(Type *left, Type *right)

{

    if (left->kind() != right->kind())

        return false;

    switch (left->kind()) {

      case Type::PRIMITIVE:

        return (left->primitive() == right->primitive() &&

                left->tag() == right->tag());

      case Type::ARRAY:

      {

        if (left->levels() != right->levels())

          return false;

        if (left->elements() != right->elements())

          return false;

        return Compare(left->contained(), right->contained());

      }

      case Type::FUNCTION:

      {

        if (!Compare(left->returnType(), right->returnType()))

            return false;

        if (left->parameters()->length() != right->parameters()->length())

            return false;

        if (left->isNative() != right->isNative())

            return false;

        if (left->isNative() && (left->isNativeVariadic() != right->isNativeVariadic()))

            return false;

        for (unsigned i = 0; i < left->parameters()->length(); i++) {

            Type *leftparam = left->parameterAt(i);

            Type *rightparam = right->parameterAt(i);

            if (!Compare(leftparam, rightparam))

                return false;

        }

        return true;

      }

      case Type::VOID:

      	return true;

      default:

        assert(left->kind() == Type::REFERENCE);

        return Compare(left->contained(), right->contained());

    }

}