/*

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

 namespace jc {

 enum PrimitiveType

 {

     PrimitiveType_Int32,

     PrimitiveType_Float

 };

 class Type

 {

     enum Kind {

         PRIMITIVE,

         UNSAFE_ARRAY

     };

   public:

     static const int UNKNOWN_SIZE = -1;

     static const size_t MAX_UNSAFE_ARRAY_DEPTH = 5;

     static Type *NewPrimitive(Name *tag);

     static Type *NewPrimitive(PrimitiveType type);

     static Type *NewUnsafeArray(Type *contained, int elements);

     bool isPrimitive() const {

         return kind_ == PRIMITIVE;

     }

     bool isArray() const {

         return isUnsafeArray();

     }

     bool isUnsafeArray() const {

         return kind_ == UNSAFE_ARRAY;

     }

     PrimitiveType primitive() const {

         assert(isPrimitive());

         return primitive_;

     }

     Type *contained() const {

         assert(isArray());

         return contained_;

     }

     int elements() const {

         assert(isArray());

         return elements_;

     }

     unsigned levels() const {

         assert(isArray());

         return levels_;

     }

     Name *tag() const {

         assert(isPrimitive());

         return tag_;

     }

     Type *innermost() const {

         assert(isArray());

         Type *temp = contained();

         while (temp->isArray())

             temp = temp->contained();

         return temp;

     }

     bool isFloat() const {

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

     }

     bool isInt() const {

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

     }

   private:

     Kind kind_;

     // If a primitive type, these tell the kind of type.

     Name *tag_;

     PrimitiveType primitive_;

     // The contained type of an array.

     Type *contained_;

     // The number of elements in the array.

     int elements_;

     // Levels deep this array goes (minimum is 1).

     unsigned levels_;

 };

 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_