/* 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_Bool,         // 0 or 1

     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,

         VOID

     };

   private:

     Kind kind() {

         return kind_;

     }

   public:

     static const int UNKNOWN_SIZE = -1;

     static const size_t MAX_UNSAFE_ARRAY_DEPTH = 5;

     static Type *NewVoid(Zone *zone);

     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 isVoid() {

         return kind() == VOID;

     }

     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_