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

#define _include_jitcraft_array_h_

#include "Heap.h"

#include "Handles.h"

#include "Types.h"

#include "FixedArray.h"

namespace ke {

class ArrayMap;

class Array : public Object

{

    friend class ArrayMap;

  protected:

    // Note: we do not write barrier |elements_|, since it can be set to

    // arbitrary pointers.

    uint32 length_;

    union {

        void *elements_;

        Object *objelements_;

    };

  protected:

    void updateLengthAndElements(Zone *zone, unsigned length, Object *array) {

        length_ = length;

        write(zone, &objelements_, array);

    }

  public:

    static Array *NewFixed(Zone *zone, Handle<ArrayMap> map, Heap::Tenure = Heap::Tenure_Default);

    static Array *NewString(Zone *zone, Handle<ArrayMap> map, char *buffer, size_t length, Heap::Tenure = Heap::Tenure_Default);

    static Array *NewSized(Zone *zone, Handle<ArrayMap> map, int sizes[MAX_ARRAY_DEPTH], Heap::Tenure = Heap::Tenure_Default);

    static Array *New1D(Zone *zone, Handle<ArrayMap> map, uint32 elements, Heap::Tenure tenure = Heap::Tenure_Default);

    static Array *NewEmpty(Zone *zone, Handle<ArrayMap> map, Heap::Tenure tenure = Heap::Tenure_Default);

    static Array *NewRaw(Zone *zone, Handle<ArrayMap> map, unsigned nelements, Heap::Tenure tenure);

    static Array *NewExternal(Zone *zone,

                              Handle<ArrayMap> map,

                              void *buffer,

                              unsigned length,

                              Heap::Tenure tenure = Heap::Tenure_Default);

    // Copies an array from one reference to another, obeying language semantics.

    static bool ShallowCopy(Zone *zone, Handle<Array> dest, Handle<Array> source);

    // Creates a full duplicate of an array, following all array references as if

    // they were fixed. Array references inside structs or objects use ShallowCopy

    // semantics, as this is only intended for duplicating array literals, which

    // cannot contain structs.

    static Array *DeepCopy(Zone *zone, Handle<Array> source, Heap::Tenure tenure);

    uint32 length() {

        return length_;

    }

    inline ArrayType *type();

    inline int *int32Vec();

    inline float *floatVec();

    inline char *chars();

    inline void *bytes();

    bool resize(Zone *zone, size_t newLength);

    static inline size_t SizeForElement(ArrayType *type) {

        if (type->contained()->isTraceable())

            return sizeof(ke::Object *);

        if (type->contained()->isInt32())

            return sizeof(int);

        if (type->contained()->primitive() == PrimitiveType_Char)

            return sizeof(char);

        assert(type->contained()->isFloat());

        return sizeof(float);

    }

    inline size_t objSize(ArrayMap *map);

    int readInt32(size_t index) {

        assert(index < length());

        return int32Vec()[index];

    }

    void writeInt32(size_t index, int i) {

        assert(index < length());

        int32Vec()[index] = i;

    }

    char readChar(size_t index) {

        assert(index < length());

        return chars()[index];

    }

    void writeChar(size_t index, char c) {

        assert(index < length());

        chars()[index] = c;

    }

    float readFloat(size_t index) {

        assert(index < length());

        return floatVec()[index];

    }

    void writeFloat(size_t index, float f) {

        assert(index < length());

        floatVec()[index] = f;

    }

    Object *readObject(size_t index) {

        return FixedArray::cast(objelements_)->at(index);

    }

    void writeObject(Zone *zone, size_t index, Object *ptr) {

        FixedArray::cast(objelements_)->set(zone, index, ptr);

    }

    // GC Descriptor.

    static inline size_t offsetOfElements() {

        return offsetof(Array, objelements_);

    }

    // End GC Descriptor.

    static Array *cast(Object *obj) {

        assert(!obj ||

               obj->is(MapKind_Array) ||

               obj->is(MapKind_DependentArray));

        return reinterpret_cast<Array *>(obj);

    }

};

class DependentArray : public Array

{

    Barriered<Array> root_;

  public:

    static Array *New(Zone *zone, Handle<Array> source, Handle<ArrayMap> map, unsigned index);

    // GC Descriptor.

    static inline size_t offsetOfRoot() {

        return offsetof(DependentArray, root_);

    }

    // End GC Descriptor.

    static DependentArray *cast(Object *obj) {

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

        return reinterpret_cast<DependentArray *>(obj);

    }

};

class ArrayMap : public Map

{

    Barriered<ArrayType> type_;

  public:

    // The way array maps work is kind of clownshoes. In the future, these

    // should be created immediately (or lazily) on the Type directly, and not

    // manually created via ::Attach. :TODO: do this when we begin caching

    // array types.

    static ArrayMap *New(Zone *zone, Handle<ArrayType> type);

    static ArrayMap *Attach(Zone *zone, Handle<ArrayType> type);

    // DependentArray maps are never attached, and are just free-floating,

    // rooted ultimately by the bytecode. A :TODO: that we might need to

    // cache these, or attach them somewhere saner like ArrayType, which

    // itself will eventually be cached.

    static ArrayMap *NewDependent(Zone *zone, Handle<ArrayType> type);

    ArrayType *type() {

        return type_;

    }

    // GC Descriptor.

    static inline size_t offsetOfType() {

        return OFFSETOF(ArrayMap, type_);

    }

    // End GC Descriptor.

    static ArrayMap *cast(Object *obj) {

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

        return reinterpret_cast<ArrayMap *>(obj);

    }

};

inline void *

Array::bytes()

{

    assert(!type()->contained()->isTraceable());

    assert(type()->hasInlineElements() ||

           type()->isExternalArray() ||

           is(MapKind_DependentArray) ||

           !length() ||

           ByteArray::cast((Object *)elements_));

    return Address(elements_) + ByteArray::offsetToElements();

}

inline int *

Array::int32Vec()

{

    assert(type()->contained()->isInt32());

    return reinterpret_cast<int *>(bytes());

}

inline float *

Array::floatVec()

{

    assert(type()->contained()->isFloat());

    return reinterpret_cast<float *>(bytes());

}

inline char *

Array::chars()

{

    assert(type()->isCharArray());

    return reinterpret_cast<char *>(bytes());

}

inline ArrayType *

Array::type()

{

    return ArrayMap::cast(map())->type();

}

inline size_t

Array::objSize(ArrayMap *map)

{

    assert(this->map() == map);

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

        return sizeof(Array) + Array::SizeForElement(map->type()) * length();

    return sizeof(Array);

}

}

#endif // _include_jitcraft_array_h_