/* vim: set ts=4 sw=4 tw=99 et:

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of SourcePawn.

  *

  * SourcePawn 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.

  * 

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

  * SourcePawn. If not, see http://www.gnu.org/licenses/.

  */

 #ifndef _include_jitcraft_type_manager_h_

 #define _include_jitcraft_type_manager_h_

 #include "Barriers.h"

 #include "Types.h"

 #include "HashTable.h"

 #include "AllocatorPolicies.h"

 #include "VirtualObjectVisitor.h"

 namespace ke {

 class String;

 class TypeManager

 {

     struct LookupKey

     {

         Handle<Type> type;

         TypeQualifiers quals;

         LookupKey(Handle<Type> type, TypeQualifiers quals)

           : type(type),

             quals(quals)

         {

         }

     };

     struct Policy

     {

         typedef Type * Payload;

         static uint32 hash(const LookupKey &key) {

             // We'll need to rehash with moving GC.

             return HashPointer(key.type);

         }

         static bool matches(const LookupKey &key, Type *type) {

             assert(type->hasTypeQualifiers());

             return key.type == type->unqualified() &&

                    key.quals == type->quals();                   

         }

     };

     typedef HashTable<Policy, ZoneAllocatorPolicy> TypeHashTable;

   public:

     TypeManager(Zone *zone);

     bool initialize();

     Type *getPrimitive(PrimitiveType type) {

         return primitiveTypes_[type];

     }

     Type *getString() {

         return stringType_;

     }

     Type *getVoid() {

         return voidType_;

     }

     Type *getUnchecked() {

         return uncheckedType_;

     }

     Type *getImportable() {

         return importableType_;

     }

     Type *getType() {

         return typeType_;

     }

     ReferenceType *getReference(Handle<Type> type, bool isConst);

     ArrayType *newArray(Handle<Type> contained, int elements);

     ArrayType *newExternalArray(Handle<Type> contained);

     EnumType *newEnum(Handle<String> name);

     void accept(VirtualObjectVisitor *visitor);

     void sweep();

     Type *qualify(Handle<Type> type, TypeQualifiers quals);

   private:

     Zone *zone_;

     // Primitive type cache.

     Unbarriered<Type> voidType_;

     Unbarriered<Type> stringType_;

     Unbarriered<Type> uncheckedType_;

     Unbarriered<Type> importableType_;

     Unbarriered<Type> typeType_;

     Unbarriered<Type> primitiveTypes_[PrimitiveTypes_Total];

     Unbarriered<ReferenceType> referenceTypes_[PrimitiveTypes_Total];

     TypeHashTable qualTable_;

 };

 }

 #endif // _include_jitcraft_type_manager_h_