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

 #include "compiler/Token.h"

 namespace ke {

 class String;

 class Descriptor;

 class StructMap;

 #define MAX_ARRAY_DEPTH     5

 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

 {

   protected:

     enum Kind {

         // A primitive is a plain-old-data type.

         PRIMITIVE,

         // An array is a fixed-length vector of any other type.

         ARRAY,

         EXTERNAL_ARRAY,

         // A reference type may only be specified on parameters, and

         // references may only be computed to primitives or enums.

         REFERENCE,

         // A function type encapsulates a function signature.

         FUNCTION,

         // Void is an internal type used to specify that a function returns no

         // value.

         VOID,

         // Enums are plain-old-data with int32 storage. They allow for extra

         // type checking that would not be possible with integers.

         ENUM,

         // Structs are composite records that may contain primitives, arrays,

         // functions, enums, and other structs.

         STRUCT,

         // Unchecked is a magic type that has implicit, bitwise coercion to

         // int32, float, bool, or an enum.

         UNCHECKED

     };

   private:

     Kind kind() {

         return kind_;

     }

   public:

     static const int DYNAMIC_ARRAY_SIZE = -1;

     static Type *NewVoid(Zone *zone);

     static Type *NewUnchecked(Zone *zone);

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

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

     static Type *NewExternalArray(Zone *zone, Handle<Type> contained);

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

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

                obj->is(MapKind_FunctionType) ||

                obj->is(MapKind_StructType));

         return (Type *)obj;

     }

     bool isPrimitive() {

         return kind() == PRIMITIVE;

     }

     bool isArray() {

         return kind() == ARRAY || kind() == EXTERNAL_ARRAY;

     }

     bool isReference() {

         return kind() == REFERENCE;

     }

     bool isFunction() {

         return kind() == FUNCTION;

     }

     bool isVoid() {

         return kind() == VOID;

     }

     bool isUnchecked() {

         return kind() == UNCHECKED;

     }

     bool isStruct() {

         return kind() == STRUCT;

     }

     PrimitiveType primitive() {

         assert(isPrimitive());

         return primitive_;

     }

     bool isPod() {

         return isPrimitive() || isEnum() || isUnchecked();

     }

     PrimitiveType pod() {

         assert(isPod());

         return isPrimitive()

                ? (primitive() == PrimitiveType_Bool)

                  ? PrimitiveType_Int32

                  : primitive()

                : PrimitiveType_Int32;

     }

     Type *contained() {

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

         return Type::cast(contained_);

     }

     bool isFixedLength() {

         assert(isArray());

         return elements_ > 0;

     }

     unsigned fixedLength() {

         assert(isFixedLength());

         return elements_;

     }

     unsigned levels() {

         assert(isArray());

         return levels_;

     }

     bool hasInlineElements() {

         assert(isArray());

         // We don't allocate traceable elements inline, since there's no

         // point to the optimization; we're going to be allocating lots of

         // objects anyway (in theory).

         return isFixedLength() && !contained()->isTraceable();

     }

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

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

     }

     bool isCharArray() {

         return isArray() &&

                contained()->isPrimitive() &&

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

     }

     bool isExternalArray() {

         return kind() == EXTERNAL_ARRAY;

     }

     bool isTraceable() {

         return !isPrimitive();

     }

     bool isConst() {

         assert(isPrimitive() ||

                isArray() ||

                isReference());

         return const_;

     }

     bool isEnum() {

         return kind() == ENUM;

     }

     String *name() {

         assert(isEnum() || isStruct());

         return name_;

     }

     Map *newMap() {

         assert(false);

         return NULL;

     }

     void setNewMap(void *p) {

         assert(false);

     }

     // GC Descriptor.

     static inline size_t offsetOfContained() {

         return OFFSETOF(Type, contained_);

     }

     static inline size_t offsetOfName() {

         return OFFSETOF(Type, name_);

     }

     // End GC Descriptor.

   protected:

     Kind kind_;

     PrimitiveType primitive_;

     // Primitives, arrays, and references.

     bool const_;

     // Arrays only.

     int32 elements_;

     unsigned levels_;

     // Arrays and references only.

     Barriered<Type> contained_;

     // Enums and structs only.

     Barriered<String> name_;

 };

 class StructType : public Type

 {

   public:

     static StructType *New(Zone *zone, Handle<String> name, Handle<FixedArray> fields);

     FixedArray *fields() {

         assert(isStruct());

         return fields_;

     }

     Descriptor *lookupField(Handle<String> name, unsigned *index = NULL);

     // Objects of this type can be created with this cached map.

     StructMap *newMap() {

         return newMap_;

     }

     void setNewMap(StructMap *map) {

         assert(!newMap());

         newMap_ = map;

     }

     // GC Descriptor.

     static inline size_t offsetOfFields() {

         return OFFSETOF(StructType, fields_);

     }

     static inline size_t offsetOfNewMap() {

         return OFFSETOF(StructType, newMap_);

     }

     // End GC Descriptor.

     static StructType *cast(Object *obj) {

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

         return (StructType *)obj;

     }

   private:

     // Structs only.

     Barriered<FixedArray> fields_;

     Barriered<StructMap> newMap_;

 };

 class FunctionType : public Type

 {

   public:

     static FunctionType *New(Zone *zone, TokenKind kind);

     Type *parameterAt(size_t i) {

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

     }

     Type *returnType() {

         assert(isFunction());

         return returnType_;

     }

     FixedArray *parameters() {

         assert(isFunction());

         return parameters_;

     }

     FixedArray *defaults() {

         assert(isFunction());

         return defaults_;

     }

     bool isNative() {

         return token_ == TOK_NATIVE;

     }

     bool isForward() {

         return token_ == TOK_FORWARD;

     }

     bool isNativeVariadic() {

         assert(isNative());

         return variadicNative_;

     }

     void setReturnType(Handle<Type> returnType) {

         assert(!returnType_);

         returnType_ = returnType;

     }

     void setParameterTypes(Handle<FixedArray> types) {

         assert(!parameters_);

         parameters_ = types;

     }

     TokenKind token() {

         return token_;

     }

     // GC Descriptor.

     static inline size_t offsetOfReturnType() {

         return OFFSETOF(FunctionType, returnType_);

     }

     static inline size_t offsetOfParameters() {

         return OFFSETOF(FunctionType, parameters_);

     }

     static inline size_t offsetOfDefaults() {

         return OFFSETOF(FunctionType, defaults_);

     }

     // End GC Descriptor.

     static FunctionType *cast(Object *obj) {

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

         return (FunctionType *)obj;

     }

   private:

     // Functions only.

     Barriered<Type> returnType_;

     Barriered<FixedArray> parameters_;

     Barriered<FixedArray> defaults_;

     TokenKind token_;

     bool variadicNative_;

 };

 class BoxedPrimitive

 {

     PrimitiveType type_;

     union {

         int i_;

         float f_;

     };

   public:

     static BoxedPrimitive Int(int i) {

         BoxedPrimitive b;

         b.type_ = PrimitiveType_Int32;

         b.i_ = i;

         return b;

     }

     static BoxedPrimitive Float(float f) {

         BoxedPrimitive b;

         b.type_ = PrimitiveType_Float;

         b.f_ = f;

         return b;

     }

     PrimitiveType type() const {

         return type_;

     }

     int toInt() const {

         assert(type() == PrimitiveType_Int32);

         return i_;

     }

     float toFloat() const {

         assert(type() == PrimitiveType_Float);

         return f_;

     }

 };

 const char *GetTypeName(Type *type);

 }

 #endif // _include_jc_types_h_