/*

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

 */

#include <string.h>

#include "Utility.h"

#include "Environments.h"

#include "Structures.h"

#include "FixedArray.h"

#include "Zone.h"

#include "compiler/NameBinding.h"

#include "Spaces-inl.h"

#include "Heap-inl.h"

using namespace ke;

EnvironmentSlotDescriptorArray *

EnvironmentSlotDescriptorArray::New(Zone *zone, unsigned nslots)

{

    size_t bytesNeeded = sizeof(EnvironmentSlotDescriptorArray) +

                         sizeof(EnvironmentSlotDescriptor) * nslots;

    Local<EnvironmentSlotDescriptorArray> array(zone);

    Local<Map> map(zone, zone->getMap(MapKind_EnvironmentSlotDescriptorArray));

    array = EnvironmentSlotDescriptorArray::cast(zone->allocate(map, bytesNeeded, Heap::Tenure_Old));

    if (!array)

        return NULL;

    // We zero the array for safety, since we could GC or fail before initialization.

    array->length_ = nslots;

    memset(array->slots(), 0, sizeof(EnvironmentSlotDescriptor) * nslots);

    return array;

}

Environment *

Environment::New(Zone *zone, Handle<EnvironmentMap> map, Heap::Tenure tenure)

{

    size_t bytesNeeded = sizeof(Environment) + map->structureSize();

    Local<Environment> env(zone, Environment::cast(zone->allocate(map, bytesNeeded, tenure)));

    if (!env)

        return NULL;

    // Initialize when called from C++, to make sure object slots are NULL.

    memset((Object *)env + 1, 0, map->structureSize());

    return env;

}

#if 0

EnvironmentMap *

EnvironmentMap::New(Zone *zone, unsigned nvars, Variable **vars)

{

    StructureBufferBuilder structure;

    Local<EnvironmentSlotDescriptorArray> slots(zone);

    slots = EnvironmentSlotDescriptorArray::New(zone, nvars);

    if (!slots)

        return NULL;

    // Build the descriptor table, mapping each slot to an offset and type.

    Local<Type> type(zone);

    for (unsigned i = 0; i < nvars; i++) {

        assert(vars[i]->slot() == i);

        type = vars[i]->type();

        EnvironmentSlotDescriptor &desc = slots->slots()[i];

        if (!structure.add(type, &desc.offset))

            return NULL;

        desc.type = type;

    }

    // Allocate the actual map now.

    size_t bytesNeeded = sizeof(EnvironmentMap) + structure.traceableOffsetCount() * sizeof(unsigned);

    Local<EnvironmentMap> map(zone);

    map = EnvironmentMap::cast(zone->allocateMap(MapKind_Environment, bytesNeeded, MapKind_MetaEnvironment));

    if (!map)

        return NULL;

    // Fill in the map fields, and copy the traceable offsets structure.

    map->structureSize_ = structure.structureSize();

    map->traceOffsetCount_ = structure.traceableOffsetCount();

    map->slots_ = slots;

    memcpy(const_cast<unsigned *>(map->traceOffsets()), structure.offsets(), sizeof(unsigned) * structure.traceableOffsetCount());

    return map;

}

#endif