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

#define _include_jc_types_h_

#include "Heap.h"

#include "Barriers.h"

#include "FixedArray.h"

namespace ke {

class String;

enum PrimitiveType

{

    PrimitiveType_Char,         // signed, 8-bit character

    PrimitiveType_Int32,        // signed, 32-bit integer

    PrimitiveType_Float,        // 32-bit IEEE-754 float

    PrimitiveType_Native,       // native-sized word

    PrimitiveTypes_Total

};

class Type : public Object

{

    enum Kind {

        PRIMITIVE,

        ARRAY,

        REFERENCE,

        FUNCTION,

        NATIVE

    };

  private:

    Kind kind() {

        return kind_;

    }

  public:

    static const int UNKNOWN_SIZE = -1;

    static const size_t MAX_UNSAFE_ARRAY_DEPTH = 5;

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

    static Type *NewPrimitive(Zone *zone, PrimitiveType type);

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

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

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

    static Type *NewNative(Zone *zone, Handle<Type> returnType, Handle<FixedArray> parameters, bool isVariadic);

    static bool Compare(Type *left, Type *right);

    static Type *cast(Object *obj) {

        assert(!obj || obj->is(MapKind_Type));

        return (Type *)obj;

    }

    bool isPrimitive() {

        return kind() == PRIMITIVE;

    }

    bool isArray() {

        return kind() == ARRAY;

    }

    bool isReference() {

        return kind() == REFERENCE;

    }

    bool isFunction() {

        return kind() == FUNCTION || kind() == NATIVE;

    }

    bool isNative() {

        return kind() == NATIVE;

    }

    bool isNativeVariadic() {

        assert(isNative());

        return variadicNative_;

    }

    PrimitiveType primitive() {

        assert(isPrimitive());

        return primitive_;

    }

    Type *contained() {

        assert(isArray() || isReference());

        return Type::cast(contained_);

    }

    int elements() {

        assert(isArray());

        return elements_;

    }

    unsigned levels() {

        assert(isArray());

        return levels_;

    }

    String *tag() {

        assert(isPrimitive());

        return tag_;

    }

    Type *innermost() {

        assert(isArray());

        Type *temp = contained();

        while (temp->isArray())

            temp = temp->contained();

        return temp;

    }

    bool isFloat() {

        return isPrimitive() && primitive() == PrimitiveType_Float;

    }

    bool isInt32() {

        return isPrimitive() && primitive() == PrimitiveType_Int32;

    }

    bool isCharArray() {

        return isArray() &&

               contained()->isPrimitive() &&

               contained()->primitive() == PrimitiveType_Char;

    }

    Type *returnType() {

        assert(isFunction());

        return returnType_;

    }

    FixedArray *parameters() {

        assert(isFunction());

        return parameters_;

    }

    Type *parameterAt(size_t i) {

        return Type::cast(parameters()->at(i));

    }

    bool isTraceable() {

        return !isPrimitive();

    }

    bool isConst() {

        assert(kind() == PRIMITIVE || kind() == ARRAY || kind() == REFERENCE);

        return const_;

    }

    // GC Descriptor.

    static inline size_t offsetOfContained() {

        return offsetof(Type, contained_);

    }

    static inline size_t offsetOfReturnType() {

        return offsetof(Type, returnType_);

    }

    static inline size_t offsetOfParameters() {

        return offsetof(Type, parameters_);

    }

    static inline size_t offsetOfTag() {

        return offsetof(Type, tag_);

    }

    // End GC Descriptor.

  private:

    Kind kind_;

    PrimitiveType primitive_;

    Barriered<String> tag_;

    // Primitives, arrays, and references.

    bool const_;

    // Arrays only.

    int32 elements_;

    unsigned levels_;

    // Arrays and references only.

    Barriered<Type> contained_;

    // Functions only.

    Barriered<Type> returnType_;

    Barriered<FixedArray> parameters_;

    bool variadicNative_;

};

class BoxedPrimitive

{

    PrimitiveType type_;

    union {

        int i_;

    };

  public:

    static BoxedPrimitive Int(int i) {

        BoxedPrimitive b;

        b.type_ = PrimitiveType_Int32;

        b.i_ = i;

        return b;

    }

    PrimitiveType type() const {

        return type_;

    }

    int toInt() const {

        assert(type() == PrimitiveType_Int32);

        return i_;

    }

};

}

#endif // _include_jc_types_h_