1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "oldpool.h"

     8

     9

/**

    10

 * Clean a pool in a safe way (does free all blocks)

    11

 */

    12

void CleanPool(OldMemoryPool *pool)

    13

{

    14

	uint i;

    15

    16

	DEBUG(misc, 4)("[Pool] (%s) Cleaning pool..", pool->name);

    17

    18

	/* Free all blocks */

    19

	for (i = 0; i < pool->current_blocks; i++) {

    20

		if (pool->clean_block_proc != NULL) {

    21

			pool->clean_block_proc(i * (1 << pool->block_size_bits), (i + 1) * (1 << pool->block_size_bits) - 1);

    22

		}

    23

		free(pool->blocks[i]);

    24

	}

    25

    26

	/* Free the block itself */

    27

	free(pool->blocks);

    28

    29

	/* Clear up some critical data */

    30

	pool->total_items = 0;

    31

	pool->current_blocks = 0;

    32

	pool->blocks = NULL;

    33

}

    34

    35

/**

    36

 * This function tries to increase the size of array by adding

    37

 *  1 block too it

    38

 *

    39

 * @return Returns false if the pool could not be increased

    40

 */

    41

bool AddBlockToPool(OldMemoryPool *pool)

    42

{

    43

	/* Is the pool at his max? */

    44

	if (pool->max_blocks == pool->current_blocks)

    45

		return false;

    46

    47

	pool->total_items = (pool->current_blocks + 1) * (1 << pool->block_size_bits);

    48

    49

	DEBUG(misc, 4)("[Pool] (%s) Increasing size of pool to %d items (%d bytes)", pool->name, pool->total_items, pool->total_items * pool->item_size);

    50

    51

	/* Increase the poolsize */

    52

	pool->blocks = realloc(pool->blocks, sizeof(pool->blocks[0]) * (pool->current_blocks + 1));

    53

	if (pool->blocks == NULL)

    54

		error("Pool: (%s) could not allocate memory for blocks", pool->name);

    55

    56

	/* Allocate memory to the new block item */

    57

	pool->blocks[pool->current_blocks] = malloc(pool->item_size * (1 << pool->block_size_bits));

    58

	if (pool->blocks[pool->current_blocks] == NULL)

    59

		error("Pool: (%s) could not allocate memory for blocks", pool->name);

    60

    61

	/* Clean the content of the new block */

    62

	memset(pool->blocks[pool->current_blocks], 0, pool->item_size * (1 << pool->block_size_bits));

    63

    64

	/* Call a custom function if defined (e.g. to fill indexes) */

    65

	if (pool->new_block_proc != NULL)

    66

		pool->new_block_proc(pool->current_blocks * (1 << pool->block_size_bits));

    67

    68

	/* We have a new block */

    69

	pool->current_blocks++;

    70

    71

	return true;

    72

}

    73

    74

/**

    75

 * Adds blocks to the pool if needed (and possible) till index fits inside the pool

    76

 *

    77

 * @return Returns false if adding failed

    78

 */

    79

bool AddBlockIfNeeded(OldMemoryPool *pool, uint index)

    80

{

    81

	while (index >= pool->total_items) {

    82

		if (!AddBlockToPool(pool))

    83

			return false;

    84

	}

    85

    86

	return true;

    87

}