/*
 *   Copyright 2011 Institute of Communication and Computer Systems (ICCS) 
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 */

#include "block_header.h"

block_header_t * get_header(void *ptr) {
    return (block_header_t *) ((char *) ptr - HEADER_SIZE);
}

size_t get_size(void *ptr) {
    return get_header(ptr)->size >> 1;
}

#ifdef FUTURE_FEATURES
size_t get_requested_size(void *ptr) {
    return get_header(ptr)->requested_size;
}
#endif /* FUTURE_FEATURES */

size_t get_size_availability(void *ptr) {
    return get_header(ptr)->size;
}

void set_size_and_free(allocator_t *allocator, void *ptr, size_t size) {
    block_header_t *next_block_header;

    get_header(ptr)->size = size << 1;

    if(allocator->border_ptr != ptr) {
        next_block_header = (block_header_t *) ((char *) ptr + get_size(ptr));
        next_block_header->previous_size = size << 1;
    }
}

void set_size_and_used(allocator_t *allocator, void *ptr, size_t size) {
    block_header_t *header, *next_block_header;

    header = get_header(ptr);
    header->size = size << 1;
    header->size |= 1;

    if(allocator->border_ptr != ptr) {
        next_block_header = (block_header_t *) ((char *) ptr + get_size(ptr));
        next_block_header->previous_size = size << 1;
        next_block_header->previous_size |= 1;
    }
}

#ifdef FUTURE_FEATURES
void set_requested_size(void *ptr, size_t size) {
    get_header(ptr)->requested_size = size;
}
#endif /* FUTURE_FEATURES */

void mark_used(allocator_t *allocator, void *ptr) {
    block_header_t *next_block_header;

    get_header(ptr)->size |= 1;

    if(allocator->border_ptr != ptr) {
        next_block_header = (block_header_t *) ((char *) ptr + get_size(ptr));
        next_block_header->previous_size |= 1;
    }
}

void mark_free(allocator_t *allocator, void *ptr) {
    block_header_t *next_block_header;
    
    get_header(ptr)->size &= (~ 0x1U);

    if(allocator->border_ptr != ptr) {
        next_block_header = (block_header_t *) ((char *) ptr + get_size(ptr));
        next_block_header->previous_size &= (~ 0x1U);
    }    
}

#ifdef WITH_OWNERSHIP

void set_owner(void *ptr, heap_t *heap_owner) {
    get_header(ptr)->heap_owner = heap_owner;
}

heap_t * get_owner(void *ptr) {
    return get_header(ptr)->heap_owner;
}

#endif /* WITH_OWNERSHIP */

bool is_free(void *ptr) {
    if(get_header(ptr)->size & (size_t) 1) {
        return false;
    } else {
        return true;
    }
}

bool is_previous_free(void *ptr) {
    if(get_header(ptr)->previous_size & (size_t) 1) {
        return false;
    } else {
        return true;
    }
}

void set_previous_size_availability(void *ptr, size_t previous_size_availability) {
    get_header(ptr)->previous_size = previous_size_availability;
}

size_t get_previous_size(void *ptr) {
    return get_header(ptr)->previous_size >> 1;
}

size_t get_previous_size_availability(void *ptr) {
    return get_header(ptr)->previous_size;
}

void * get_dlprevious(void *ptr) {
    return (void *) ((char *) ptr - HEADER_SIZE - get_previous_size(ptr));
}

void * get_dlnext(allocator_t *allocator, void *ptr) {
    if(allocator->border_ptr != ptr) {
        return (void *) ((char *) ptr + get_size(ptr) + HEADER_SIZE);
    } else {
        return NULL;
    }
}