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

 #define _include_jc_object_visitor_h_

 #include "Objects.h"

 #include "Types.h"

 #include "FixedArray.h"

 #include "Code.h"

 #include "Reference.h"

 #include "Modules.h"

 #include "Functions.h"

 #include "Array.h"

 #include "Strings.h"

 #include "Environments.h"

 #include "Structures.h"

 #include "Box.h"

 #include "Packages.h"

 #include "List.h"

 namespace ke {

 // An ObjectVisitor is used for traversing object references in the heap. Since

 // this pattern must be lightning fast, we avoid virtual dispatch by forcing

 // visitors to compose themselves with the visiting logic.

 template <typename T>

 class ObjectVisitor : public T

 {

   private:

     void visitField(Object *obj, size_t offset) {

         this->visit(reinterpret_cast<Object **>(Address(obj) + offset));

     }

     size_t iterateType(Object *obj) {

         visitField(obj, Type::offsetOfRoot());

         return sizeof(Type);

     }

     size_t iterateEnumType(Object *obj) {

         visitField(obj, EnumType::offsetOfName());

         return sizeof(EnumType);

     }

     size_t iterateReferenceType(Object *obj) {

         iterateType(obj);

         visitField(obj, ReferenceType::offsetOfContained());

         return sizeof(ReferenceType);

     }

     size_t iterateArrayType(Object *obj) {

         iterateType(obj);

         visitField(obj, ArrayType::offsetOfContained());

         visitField(obj, ArrayType::offsetOfNewMap());

         return sizeof(ArrayType);

     }

     size_t iterateStructType(Object *obj) {

         iterateType(obj);

         visitField(obj, StructType::offsetOfFields());

         visitField(obj, StructType::offsetOfNewMap());

         visitField(obj, StructType::offsetOfName());

         return sizeof(StructType);

     }

     size_t iterateFunctionType(Object *obj) {

         iterateType(obj);

         visitField(obj, FunctionType::offsetOfReturnType());

         visitField(obj, FunctionType::offsetOfParameters());      

         visitField(obj, FunctionType::offsetOfDefaults());

         visitField(obj, FunctionType::offsetOfName());

         return sizeof(FunctionType);

     }

     size_t iterateFixedArray(FixedArray *array) {

         unsigned length = array->length();

         Object **ptr = reinterpret_cast<Object **>(array + 1);

         for (unsigned i = 0; i < length; i++)

             this->visit(ptr + i);

         return array->objSize();

     }

     size_t iterateByteArray(ByteArray *array) {

         return array->objSize();

     }

     size_t iterateCode(Object *obj) {

         visitField(obj, Code::offsetOfModule());

         visitField(obj, Code::offsetOfBytecode());

         visitField(obj, Code::offsetOfLocals());

         visitField(obj, Code::offsetOfObjects());

         visitField(obj, Code::offsetOfSafepoints());

         visitField(obj, Code::offsetOfSourceMap());

         visitField(obj, Code::offsetOfStrings());

         return sizeof(Code);

     }

     size_t iterateReference(Object *obj) {

         visitField(obj, Reference::offsetOfBase());

         return sizeof(Reference);

     }

     void visitImportable(Object *obj) {

         visitField(obj, Package::offsetOfName());

         visitField(obj, Package::offsetOfParent());

         visitField(obj, Package::offsetOfPath());

     }

     size_t iterateModule(Object *obj) {

         visitImportable(obj);

         visitField(obj, Module::offsetOfGlobals());

         visitField(obj, Module::offsetOfCode());

         return sizeof(Module);

     }

     size_t iteratePackage(Object *obj) {

         visitImportable(obj);

         visitField(obj, Package::offsetOfContents());

         return sizeof(Package);

     }

     size_t iterateFunction(Object *obj) {

         visitField(obj, Function::offsetOfCode());

         visitField(obj, Function::offsetOfType());

         visitField(obj, Function::offsetOfName());

         return sizeof(Function);

     }

     size_t iterateDescriptor(Object *obj) {

         visitField(obj, Descriptor::offsetOfName());

         visitField(obj, Descriptor::offsetOfType());

         return sizeof(Descriptor);

     }

     size_t iterateNative(Object *obj) {

         visitField(obj, Native::offsetOfType());

         return sizeof(Native);

     }

     size_t iterateString(Object *obj) {

         return String::cast(obj)->objSize();

     }

     size_t iterateArray(Array *array, ArrayMap *map) {

         if (!map->type()->hasInlineElements())

             visitField(array, Array::offsetOfElements());

         return array->objSize(map);

     }

     size_t iterateDependentArray(Object *array) {

         visitField(array, DependentArray::offsetOfRoot());

         return sizeof(DependentArray);

     }

     size_t iterateBox(Box *obj) {

         visitField(obj, Box::offsetOfType());

         if (obj->type()->isTraceable())

             visitField(obj, Box::offsetOfObj());

         return sizeof(Box);

     }

     size_t iterateArrayMap(ArrayMap *map) {

         visitField(map, ArrayMap::offsetOfType());

         return sizeof(ArrayMap);

     }

     size_t iterateEnvironmentSlotDescriptorArray(EnvironmentSlotDescriptorArray *env) {

         unsigned length = env->length();

         EnvironmentSlotDescriptor *desc = env->slots();

         for (unsigned i = 0; i < length; i++)

             this->visit(desc->type.addr());

         return env->objSize();

     }

     size_t iterateEnvironmentMap(EnvironmentMap *map) {

         visitField(map, EnvironmentMap::offsetOfSlots());

         return map->objSize();

     }

     size_t iterateStructMap(StructMap *map) {

         visitField(map, StructMap::offsetOfType());

         visitField(map, StructMap::offsetOfComposed());

         return map->objSize();

     }

     size_t iterateEnvironment(Environment *env) {

         EnvironmentMap *map = env->map();

         const unsigned *offsets = map->traceOffsets();

         unsigned noffsets = map->traceOffsetCount();

         for (unsigned i = 0; i < noffsets; i++)

             visitField(env, Environment::offsetOfSlotOffset(offsets[i]));

         return env->objSize();

     }

     size_t iterateStruct(Struct *obj) {

         StructMap *map = obj->map();

         const unsigned *offsets = map->traceOffsets();

         unsigned noffsets = map->traceOffsetCount();

         for (unsigned i = 0; i < noffsets; i++)

             visitField(obj, Struct::offsetOfSlotOffset(offsets[i]));

         return obj->objSize();

     }

     size_t iterateList(Object *obj) {

         visitField(obj, List<Object>::offsetOfArray());

         return sizeof(List<Object>);

     }

   private:

     size_t iterateObject(Object *obj) {

         visitField(obj, Object::offsetOfMap());

         return iterate(obj, obj->map());

     }

     size_t iterateObject(Object *obj, Map *map) {

         switch (map->kind()) {

           case MapKind_Type:

             return iterateType(obj);

           case MapKind_ReferenceType:

             return iterateReferenceType(obj);

           case MapKind_ArrayType:

             return iterateArrayType(obj);

           case MapKind_EnumType:

             return iterateEnumType(obj);

           case MapKind_FunctionType:

             return iterateFunctionType(obj);

           case MapKind_StructType:

             return iterateStructType(obj);

           case MapKind_FixedArray:

             return iterateFixedArray(FixedArray::cast(obj));

           case MapKind_ByteArray:

             return iterateByteArray(ByteArray::cast(obj));

           case MapKind_Code:

             return iterateCode(obj);

           case MapKind_Reference:

             return iterateReference(obj);

           case MapKind_Module:

             return iterateModule(obj);

           case MapKind_Package:

             return iteratePackage(obj);

           case MapKind_Function:

             return iterateFunction(obj);

           case MapKind_Descriptor:

             return iterateDescriptor(obj);

           case MapKind_String:

             return iterateString(obj);

           case MapKind_Array:

             return iterateArray(Array::cast(obj), ArrayMap::cast(map));

           case MapKind_DependentArray:

             return iterateDependentArray(obj);

           case MapKind_Box:

             return iterateBox(Box::cast(obj));

           case MapKind_Struct:

             return iterateStruct(Struct::cast(obj));

           case MapKind_List:

             return iterateList(obj);

           case MapKind_EnvironmentSlotDescriptorArray:

             return iterateEnvironmentSlotDescriptorArray(EnvironmentSlotDescriptorArray::cast(obj));

           case MapKind_Environment:

             return iterateEnvironment(Environment::cast(obj));

           case MapKind_Native:

             return iterateNative(obj);

           case MapKind_MetaArray:

             return iterateArrayMap(ArrayMap::cast(obj));

           case MapKind_MetaEnvironment:

             return iterateEnvironmentMap(EnvironmentMap::cast(obj));

           case MapKind_MetaStruct:

             return iterateStructMap(StructMap::cast(obj));

           default:

             assert(map->kind() == MapKind_Meta);

             return sizeof(Map);

         }

     }

   public:

     size_t iterate(Object *obj) {

         return Align(iterateObject(obj), kObjectAlignment);

     }

     size_t iterate(Object *obj, Map *map) {

         return Align(iterateObject(obj, map), kObjectAlignment);

     }

 };

 static inline size_t

 SizeOfObjectRaw(Object *obj, Map *map)

 {

     switch (map->kind()) {

       case MapKind_Type:

         return sizeof(Type);

       case MapKind_ReferenceType:

         return sizeof(ReferenceType);

       case MapKind_ArrayType:

         return sizeof(ArrayType);

       case MapKind_EnumType:

         return sizeof(EnumType);

       case MapKind_FunctionType:

         return sizeof(FunctionType);

       case MapKind_StructType:

         return sizeof(StructType);

       case MapKind_FixedArray:

         return FixedArray::cast(obj)->objSize();

       case MapKind_ByteArray:

         return ByteArray::cast(obj)->objSize();

       case MapKind_Code:

         return sizeof(Code);

       case MapKind_Reference:

         return sizeof(Reference);

       case MapKind_Module:

         return sizeof(Module);

       case MapKind_Package:

         return sizeof(Package);

       case MapKind_Descriptor:

         return sizeof(Descriptor);

       case MapKind_Function:

         return sizeof(Function);

       case MapKind_String:

         return String::cast(obj)->objSize();

       case MapKind_Native:

         return sizeof(Native);

       case MapKind_Array:

         return Array::cast(obj)->objSize(ArrayMap::cast(map));

        case MapKind_DependentArray:

         return sizeof(DependentArray);

       case MapKind_Box:

         return sizeof(Box);

       case MapKind_List:

         return sizeof(List<Object>);

       case MapKind_Struct:

         return Struct::cast(obj)->objSize();

       case MapKind_EnvironmentSlotDescriptorArray:

         return EnvironmentSlotDescriptorArray::cast(obj)->objSize();

       case MapKind_Environment:

         return Environment::cast(obj)->objSize();

       case MapKind_MetaArray:

         return sizeof(ArrayMap);

       case MapKind_MetaEnvironment:

         return EnvironmentMap::cast(obj)->objSize();

       case MapKind_MetaStruct:

         return StructMap::cast(obj)->objSize();

       case MapKind_FreeRegion:

         return *reinterpret_cast<size_t *>(reinterpret_cast<Address>(obj + 1));

       default:

         assert(map->kind() == MapKind_Meta);

         return sizeof(Map);

     }

 }

 static inline size_t

 SizeOfObject(Object *obj, Map *map)

 {

     return Align(SizeOfObjectRaw(obj, map), kObjectAlignment);

 }

 class ObjectSizeEvaluator

 {

   public:

     size_t operator()(Object *obj, Map *map) {

         return SizeOfObject(obj, map);

     }

 };

 }

 #endif // _include_jc_object_visitor_h_