tb_pointer_t tb_static_pool_nalloc_(tb_static_pool_ref_t pool, tb_size_t item, tb_size_t size __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(pool && size, tb_null);
tb_assert_and_check_return_val((item * size) <= TB_POOL_DATA_SIZE_MAXN, tb_null);
// nalloc data
tb_pointer_t data = tb_static_large_pool_malloc(pool, item * size, tb_null __tb_debug_args__);
tb_assertf_abort(data, "nalloc(%lu, %lu) failed!", item, size);
tb_assertf_abort(!(((tb_size_t)data) & (TB_POOL_DATA_ALIGN - 1)), "nalloc(%lu, %lu): unaligned data: %p", item, size, data);
// ok
return data;
}
tb_pointer_t tb_pool_align_malloc_(tb_pool_ref_t pool, tb_size_t size, tb_size_t align __tb_debug_decl__)
{
// check
tb_assertf_abort(!(align & 3), "invalid alignment size: %lu", align);
tb_check_return_val(!(align & 3), tb_null);
// malloc it
tb_byte_t* data = (tb_byte_t*)tb_pool_malloc_(pool, size + align __tb_debug_args__);
tb_check_return_val(data, tb_null);
// the different bytes
tb_byte_t diff = (tb_byte_t)((~(tb_long_t)data) & (align - 1)) + 1;
// adjust the address
data += diff;
// check
tb_assert_abort(!((tb_size_t)data & (align - 1)));
// save the different bytes
data[-1] = diff;
// ok?
return (tb_pointer_t)data;
}
tb_pointer_t tb_static_pool_ralloc_(tb_static_pool_ref_t pool, tb_pointer_t data, tb_size_t size __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(pool && data && size, tb_null);
tb_assert_and_check_return_val(size <= TB_POOL_DATA_SIZE_MAXN, tb_null);
// ralloc data
tb_pointer_t data_new = tb_static_large_pool_ralloc(pool, data, size, tb_null __tb_debug_args__);
// failed? dump it
#ifdef __tb_debug__
if (!data_new)
{
// trace
tb_trace_e("ralloc(%p, %lu) failed! at %s(): %lu, %s", data, size, func_, line_, file_);
// dump data
tb_pool_data_dump((tb_byte_t const*)data, tb_true, "[static_pool]: [error]: ");
// abort
tb_abort();
}
#endif
// check
tb_assertf_abort(!(((tb_size_t)data_new) & (TB_POOL_DATA_ALIGN - 1)), "ralloc(%lu): unaligned data: %p", size, data);
// ok
return data_new;
}
tb_pointer_t tb_pool_align_ralloc_(tb_pool_ref_t pool, tb_pointer_t data, tb_size_t size, tb_size_t align __tb_debug_decl__)
{
// check align
tb_assertf_abort(!(align & 3), "invalid alignment size: %lu", align);
tb_check_return_val(!(align & 3), tb_null);
// ralloc?
tb_byte_t diff = 0;
if (data)
{
// check address
tb_assertf_abort(!((tb_size_t)data & (align - 1)), "invalid address %p", data);
tb_check_return_val(!((tb_size_t)data & (align - 1)), tb_null);
// the different bytes
diff = ((tb_byte_t*)data)[-1];
// adjust the address
data = (tb_byte_t*)data - diff;
// ralloc it
data = tb_pool_ralloc_(pool, data, size + align __tb_debug_args__);
tb_check_return_val(data, tb_null);
}
// no data?
else
{
// malloc it directly
data = tb_pool_malloc_(pool, size + align __tb_debug_args__);
tb_check_return_val(data, tb_null);
}
// the different bytes
diff = (tb_byte_t)((~(tb_long_t)data) & (align - 1)) + 1;
// adjust the address
data = (tb_byte_t*)data + diff;
// check
tb_assert_abort(!((tb_size_t)data & (align - 1)));
// save the different bytes
((tb_byte_t*)data)[-1] = diff;
// ok?
return data;
}
tb_pointer_t tb_static_pool_malloc0_(tb_static_pool_ref_t pool, tb_size_t size __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(pool && size, tb_null);
tb_assert_and_check_return_val(size <= TB_POOL_DATA_SIZE_MAXN, tb_null);
// malloc0 data
tb_pointer_t data = tb_static_large_pool_malloc(pool, size, tb_null __tb_debug_args__);
tb_assertf_abort(data, "malloc0(%lu) failed!", size);
tb_assertf_abort(!(((tb_size_t)data) & (TB_POOL_DATA_ALIGN - 1)), "malloc0(%lu): unaligned data: %p", size, data);
// clear it
tb_memset_(data, 0, size);
// ok
return data;
}
tb_pointer_t tb_small_pool_nalloc0_(tb_small_pool_ref_t pool, tb_size_t item, tb_size_t size __tb_debug_decl__)
{
// check
tb_small_pool_impl_t* impl = (tb_small_pool_impl_t*)pool;
tb_assert_and_check_return_val(impl && impl->large_pool && size, tb_null);
tb_assert_and_check_return_val(item * size <= TB_SMALL_POOL_DATA_SIZE_MAXN, tb_null);
// disable small pool for debug
#ifdef TB_SMALL_POOL_DISABLE
return tb_large_pool_nalloc0(impl->large_pool, item, size, tb_null);
#endif
// done
tb_pointer_t data = tb_null;
do
{
// the fixed pool
tb_fixed_pool_ref_t fixed_pool = tb_small_pool_find_fixed(impl, item * size);
tb_assert_and_check_break(fixed_pool);
// done
data = tb_fixed_pool_malloc0_(fixed_pool __tb_debug_args__);
tb_assert_and_check_break(data);
// the data head
tb_pool_data_head_t* data_head = &(((tb_pool_data_head_t*)data)[-1]);
tb_assert_abort(data_head->debug.magic == TB_POOL_DATA_MAGIC);
#ifdef __tb_debug__
// fill the patch bytes
if (data_head->size > (item * size)) tb_memset_((tb_byte_t*)data + (item * size), TB_POOL_DATA_PATCH, data_head->size - (item * size));
#endif
// update size
data_head->size = item * size;
} while (0);
// check
tb_assertf_abort(data, "nalloc(%lu, %lu) failed!", item, size);
// ok?
return data;
}
tb_bool_t tb_environment_save(tb_environment_ref_t environment, tb_char_t const* name)
{
// check
tb_assert_and_check_return_val(environment && name, tb_false);
// empty? remove this environment variable
if (!tb_vector_size(environment)) return tb_environment_set_impl(name, tb_null);
// init values string
tb_string_t values;
if (!tb_string_init(&values)) return tb_false;
// make values string
tb_for_all_if (tb_char_t const*, value, environment, value)
{
// the single value cannot exist ';'
tb_assertf_abort(!tb_strchr(value, ';'), "invalid value: %s", value);
// append value
tb_string_cstrcat(&values, value);
tb_string_chrcat(&values, ';');
}
/* //////////////////////////////////////////////////////////////////////////////////////
* parser implementation
*/
static tb_char_t const* tb_xml_reader_element_parse(tb_xml_reader_impl_t* reader)
{
// clear element
tb_string_clear(&reader->element);
// parse element
tb_char_t ch = '\0';
tb_size_t in = 0;
while ((ch = tb_stream_bread_s8(reader->rstream)))
{
// append element
if (!in && ch == '<') in = 1;
else if (in)
{
if (ch != '>') tb_string_chrcat(&reader->element, ch);
else return tb_string_cstr(&reader->element);
}
}
// failed
tb_assertf_abort(0, "invalid element: %s from %s", tb_string_cstr(&reader->element), tb_url_get(tb_stream_url(reader->istream)));
return tb_null;
}
tb_pointer_t tb_fixed_pool_malloc_(tb_fixed_pool_ref_t pool __tb_debug_decl__)
{
// check
tb_fixed_pool_impl_t* impl = (tb_fixed_pool_impl_t*)pool;
tb_assert_and_check_return_val(impl, tb_null);
// done
tb_bool_t ok = tb_false;
tb_pointer_t data = tb_null;
do
{
// no current slot or the current slot is full? update the current slot
if (!impl->current_slot || tb_static_fixed_pool_full(impl->current_slot->pool))
{
// move the current slot to the full slots if exists
if (impl->current_slot) tb_list_entry_insert_tail(&impl->full_slots, &impl->current_slot->entry);
// clear the current slot
impl->current_slot = tb_null;
// attempt to get a slot from the partial slots
if (!tb_list_entry_is_null(&impl->partial_slots))
{
// the head entry
tb_list_entry_ref_t entry = tb_list_entry_head(&impl->partial_slots);
tb_assert_and_check_break(entry);
// the head slot
impl->current_slot = (tb_fixed_pool_slot_t*)tb_list_entry(&impl->partial_slots, entry);
tb_assert_and_check_break(impl->current_slot);
// remove this slot from the partial slots
tb_list_entry_remove(&impl->partial_slots, entry);
}
// make a new slot
else impl->current_slot = tb_fixed_pool_slot_init(impl);
}
// check
tb_assert_and_check_break(impl->current_slot && impl->current_slot->pool);
tb_assert_and_check_break(!tb_static_fixed_pool_full(impl->current_slot->pool));
// make data from the current slot
data = tb_static_fixed_pool_malloc(impl->current_slot->pool __tb_debug_args__);
tb_assert_and_check_break(data);
// done init
if (impl->func_init && !impl->func_init(data, impl->func_priv)) break;
// update the item count
impl->item_count++;
// ok
ok = tb_true;
} while (0);
// failed?
if (!ok)
{
// exit data
if (data && impl->current_slot && impl->current_slot->pool)
tb_static_fixed_pool_free(impl->current_slot->pool, data __tb_debug_args__);
data = tb_null;
}
// check
tb_assertf_abort(data, "malloc(%lu) failed!", impl->item_size);
// ok?
return data;
}
