/* 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());

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

        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 Struct::SizeFor(map);

    }

    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::SizeFor(StructMap::cast(map));

      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_