dvander@146: /* vim: set ts=4 sw=4 tw=99 et:
dvander@85:  *
dvander@85:  * Copyright (C) 2012 David Anderson
dvander@85:  *
dvander@146:  * This file is part of SourcePawn.
dvander@85:  *
dvander@146:  * SourcePawn is free software: you can redistribute it and/or modify it under
dvander@85:  * the terms of the GNU General Public License as published by the Free
dvander@85:  * Software Foundation, either version 3 of the License, or (at your option)
dvander@85:  * any later version.
dvander@85:  * 
dvander@146:  * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY
dvander@85:  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
dvander@85:  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
dvander@85:  *
dvander@85:  * You should have received a copy of the GNU General Public License along with
dvander@146:  * SourcePawn. If not, see http://www.gnu.org/licenses/.
dvander@85:  */
dvander@147: #include <string.h>
dvander@85: #include "Structures.h"
dvander@146: #include "Zone.h"
dvander@85: #include "Types.h"
danderson@92: #include "Spaces-inl.h"
danderson@92: #include "Heap-inl.h"
dvander@85: 
dvander@85: using namespace ke;
dvander@85: 
dvander@85: StructureBufferBuilder::StructureBufferBuilder()
dvander@85:   : size_(0)
dvander@85: {
dvander@85: }
dvander@85: 
dvander@85: bool
dvander@85: StructureBufferBuilder::add(Handle<Type> type, unsigned *offset)
dvander@85: {
dvander@85:     *offset = size_;
dvander@85: 
dvander@85:     if (!type->isTraceable()) {
dvander@85:         // For now, assume the size of primitives is 4-byte.
dvander@85:         assert(type->isInt32() || type->isFloat());
dvander@85:         size_ += 4;
dvander@85:         return true;
dvander@85:     }
dvander@85: 
dvander@85:     if (!offsets_.append(size_))
dvander@85:         return false;
dvander@85: 
dvander@85:     size_ += sizeof(Object *);
dvander@85:     return true;
dvander@85: }
dvander@146: 
dvander@146: Descriptor *
dvander@146: Descriptor::New(Zone *zone, Handle<String> name, Handle<Type> type, unsigned offset)
dvander@146: {
dvander@146:     Local<Descriptor> desc(zone,
dvander@146:         Descriptor::cast(zone->allocate(MapKind_Descriptor, sizeof(Descriptor), Heap::Tenure_Old)));
dvander@146:     if (!desc)
dvander@146:         return NULL;
dvander@146: 
dvander@146:     desc->name_ = name;
dvander@146:     desc->type_ = type;
dvander@146:     desc->offset_ = offset;
dvander@146:     return desc;
dvander@146: }
dvander@146: 
dvander@147: StructMap *
dvander@153: StructMap::New(Zone *zone, const StructureBufferBuilder &builder, Handle<FixedArray> composed)
dvander@147: {
dvander@147:     size_t bytesNeeded = sizeof(StructMap) +
dvander@147:                          (builder.traceableOffsetCount() * sizeof(unsigned));
dvander@147: 
dvander@147:     Local<StructMap> map(zone);
dvander@147:     map = StructMap::cast(zone->allocateMap(MapKind_Struct, bytesNeeded, MapKind_MetaStruct));
dvander@147:     if (!map)
dvander@147:         return NULL;
dvander@147: 
dvander@147:     map->structureSize_ = builder.structureSize();
dvander@147:     map->traceOffsetCount_ = builder.traceableOffsetCount();
dvander@147:     map->type_ = NULL;
dvander@153:     map->composed_ = composed;
dvander@147:     memcpy(const_cast<unsigned *>(map->traceOffsets()), builder.offsets(),
dvander@147:            sizeof(unsigned) * builder.traceableOffsetCount());
dvander@147: 
dvander@147:     return map;
dvander@147: }
dvander@147: 
dvander@147: Struct *
dvander@147: Struct::New(Zone *zone, Handle<StructMap> map, Heap::Tenure tenure)
dvander@147: {
dvander@147:     size_t bytesNeeded = sizeof(Struct) + map->structureSize();
dvander@147:     Local<Struct> obj(zone, Struct::cast(zone->allocate(map, bytesNeeded, tenure)));
dvander@147:     if (!obj)
dvander@147:         return NULL;
dvander@147: 
dvander@147:     memset((Struct *)obj + 1, 0, map->structureSize());
dvander@153: 
dvander@153:     // Initialize any sub-structures. Right now, this is performed as part of
dvander@153:     // struct allocation, rather than inlined in bytecode, for simplicity.
dvander@153:     if (map->composed()) {
dvander@153:         Local<Descriptor> desc(zone);
dvander@153:         Local<Struct> child(zone);
dvander@153:         Local<StructMap> childMap(zone);
dvander@153:         for (unsigned i = 0; i < map->composed()->length(); i++) {
dvander@153:             desc = Descriptor::cast(map->composed()->at(i));
dvander@153: 
dvander@153:             // We don't support composing arrays yet.
dvander@153:             assert(desc->type()->isStruct());
dvander@153: 
dvander@153:             childMap = StructMap::cast(desc->type()->newMap());
dvander@153:             child = Struct::New(zone, childMap, tenure);
dvander@153:             if (!child)
dvander@153:                 return NULL;
dvander@153: 
dvander@153:             obj->set(zone, desc, child);
dvander@153:         }
dvander@153:     }
dvander@153: 
dvander@147:     return obj;
dvander@147: }
dvander@147: