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

 {

     // A boolean type semantically represents 0 or 1. As an optimization, its

     // internal storage type is the same as int32, and any non-zero value

     // compares positively to "true".

     PrimitiveType_Bool,

     // A character is an arbitrary 8-bit value. Characters are not supported

     // as a normal storage class; they may only be used for arrays. When read

     // from an array, they are immediately sign extended to 32 bits. Integers

     // stored into an char array are truncated to 8 bits.

     PrimitiveType_Char,         // signed, 8-bit character

     // Enumerations and untyped variables are stored as signed, 32-bit integers.

     PrimitiveType_Int32,

     // Floating point values are 32-bit IEEE-754 floats. This is required ro

     // SourcePawn 1 compatibility.

     PrimitiveType_Float,

     // This is a native-sized integer type (32-bit on 32-bit systems, 64-bit

     // on 64-bit systems), and does not exist in language semantics.

     PrimitiveType_Native,

     PrimitiveTypes_Total

 };

 class Type : public Object

 {

     enum Kind {

         PRIMITIVE,

         ARRAY,

         REFERENCE,

         FUNCTION,

         NATIVE,

         VOID,

         ENUM

     };

   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, 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 Type *NewEnum(Zone *zone, Handle<String> name);

     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_;

     }

     PrimitiveType pod() {

         assert(isPrimitive() || isEnum());

         return isPrimitive()

                ? primitive()

                : PrimitiveType_Int32;

     }

     Type *contained() {

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

         return Type::cast(contained_);

     }

     int elements() {

         assert(isArray());

         return elements_;

     }

     unsigned levels() {

         assert(isArray());

         return levels_;

     }

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

         return isInt32() || isEnum();

     }

     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_;

     }

     bool isEnum() {

         return kind() == ENUM;

     }

     String *name() {

         assert(isEnum());

         return name_;

     }

     // 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 offsetOfName() {

         return OFFSETOF(Type, name_);

     }

     // End GC Descriptor.

   private:

     Kind kind_;

     PrimitiveType primitive_;

     // 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_;

     // Enums only.

     Barriered<String> name_;

 };

 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_