/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_bool_t tb_directory_create(tb_char_t const* path)
{
// check
tb_assert_and_check_return_val(path, tb_false);
// the absolute path
tb_wchar_t full[TB_PATH_MAXN];
if (!tb_path_absolute_w(path, full, TB_PATH_MAXN)) return tb_false;
// make it
tb_bool_t ok = CreateDirectoryW(full, tb_null)? tb_true : tb_false;
if (!ok)
{
// make directory
tb_wchar_t temp[TB_PATH_MAXN] = {0};
tb_wchar_t const* p = full;
tb_wchar_t* t = temp;
tb_wchar_t const* e = temp + TB_PATH_MAXN - 1;
for (; t < e && *p; t++)
{
*t = *p;
if (*p == L'\\' || *p == L'/')
{
// make directory if not exists
if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(temp)) CreateDirectoryW(temp, tb_null);
// skip repeat '\\' or '/'
while (*p && (*p == L'\\' || *p == L'/')) p++;
}
else p++;
}
// make it again
ok = CreateDirectoryW(full, tb_null)? tb_true : tb_false;
}
// ok?
return ok;
}
tb_long_t tb_wprintf(tb_wchar_t const* format, ...)
{
// check
tb_check_return_val(format, 0);
// format line
tb_long_t size = 0;
tb_wchar_t line[8192] = {0};
tb_vswprintf_format(line, 8191, format, &size);
if (size >= 0 && size < 8192) line[size] = L'\0';
// wtoa
tb_char_t text[8192] = {0};
size = tb_wtoa(text, line, 8191);
tb_assert_and_check_return_val(size != -1, 0);
// print it
tb_print(text);
// ok?
return size;
}
tb_char_t const* tb_string_rtrim(tb_string_ref_t string)
{
// check
tb_assert_and_check_return_val(string, tb_null);
// init
tb_char_t* s = (tb_char_t*)tb_string_cstr(string);
tb_size_t n = tb_string_size(string);
tb_check_return_val(s && n, tb_null);
// done
tb_char_t* e = s + n - 1;
while (e >= s && tb_isspace(*e)) e--;
// strip it
if (e >= s) tb_string_strip(string, e - s + 1);
// clear it
else tb_string_clear(string);
// ok?
return tb_string_cstr(string);
}
tb_object_ref_t tb_object_dump(tb_object_ref_t object)
{
// check
tb_assert_and_check_return_val(object, tb_null);
// data
tb_object_ref_t odata = tb_object_data(object, TB_OBJECT_FORMAT_XML);
if (odata)
{
// data & size
tb_byte_t const* data = (tb_byte_t const*)tb_object_data_getp(odata);
tb_size_t size = tb_object_data_size(odata);
if (data && size)
{
tb_char_t const* p = tb_strstr((tb_char_t const*)data, "?>");
tb_char_t const* e = (tb_char_t const*)data + size;
tb_char_t b[4096 + 1];
if (p && p + 2 < e)
{
p += 2;
while (p < e && *p && tb_isspace(*p)) p++;
while (p < e && *p)
{
tb_char_t* q = b;
tb_char_t const* d = b + 4096;
for (; p < e && q < d && *p; p++, q++) *q = *p;
*q = '\0';
tb_printf("%s", b);
}
tb_printf("\n");
}
}
// exit data
tb_object_exit(odata);
}
return object;
}
static tb_size_t tb_database_sqlite3_result_row_iterator_next(tb_iterator_ref_t iterator, tb_size_t itor)
{
// check
tb_database_sqlite3_result_t* result = (tb_database_sqlite3_result_t*)iterator;
tb_assert(result);
tb_assert_and_check_return_val(itor < result->count, result->count);
// statement result?
if (result->statement)
{
// step statement
tb_int_t ok = sqlite3_step(result->statement);
// end?
if (ok != SQLITE_ROW)
{
// reset it
if (SQLITE_OK != sqlite3_reset(result->statement))
{
// the sqlite
tb_database_sqlite3_t* sqlite = (tb_database_sqlite3_t*)iterator->priv;
if (sqlite)
{
// save state
sqlite->base.state = tb_database_sqlite3_state_from_errno(sqlite3_errcode(sqlite->database));
// trace
tb_trace_e("statement: reset failed, error[%d]: %s", sqlite3_errcode(sqlite->database), sqlite3_errmsg(sqlite->database));
}
}
// tail
return result->count;
}
}
// next
return itor + 1;
}
/* stdout: io.isatty()
* stderr: io.isatty(io.stderr)
* stdin: io.isatty(io.stdin)
*/
tb_int_t xm_io_isatty(lua_State* lua)
{
// check
tb_assert_and_check_return_val(lua, 0);
// get file pointer
FILE** fp = (FILE**)luaL_checkudata(lua, 1, LUA_FILEHANDLE);
// no arguments? default: stdout
tb_int_t answer = 1;
#ifdef TB_CONFIG_OS_WINDOWS
if (fp) answer = _isatty(_fileno(*fp));
#else
if (fp) answer = isatty(fileno(*fp));
#endif
// return answer
lua_pushboolean(lua, answer);
// ok
return 1;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_size_t tb_walk(tb_iterator_ref_t iterator, tb_size_t head, tb_size_t tail, tb_walk_func_t func, tb_cpointer_t priv)
{
// check
tb_assert_and_check_return_val(iterator && (tb_iterator_mode(iterator) & TB_ITERATOR_MODE_FORWARD) && func, 0);
// null?
tb_check_return_val(head != tail, 0);
// walk
tb_size_t count = 0;
tb_for (tb_pointer_t, item, head, tail, iterator)
{
// done
if (!func(iterator, item, priv)) break;
// count++
count++;
}
// ok?
return count;
}
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(!tb_strchr(value, ';'), "invalid value: %s", value);
// append value
tb_string_cstrcat(&values, value);
tb_string_chrcat(&values, ';');
}
tb_long_t tb_transfer_pool_wait_all(tb_transfer_pool_ref_t pool, tb_long_t timeout)
{
// check
tb_transfer_pool_impl_t* impl = (tb_transfer_pool_impl_t*)pool;
tb_assert_and_check_return_val(impl, -1);
// wait it
tb_size_t size = 0;
tb_hong_t time = tb_cache_time_spak();
while ((timeout < 0 || tb_cache_time_spak() < time + timeout))
{
// enter
tb_spinlock_enter(&impl->lock);
// the size
tb_size_t size = tb_list_entry_size(&impl->work);
// trace
tb_trace_d("wait: %lu: ..", size);
// trace work
#ifdef __tb_debug__
if (size) tb_walk_all(tb_list_entry_itor(&impl->work), tb_transfer_pool_work_wait, tb_null);
#endif
// leave
tb_spinlock_leave(&impl->lock);
// ok?
tb_check_break(size);
// wait some time
tb_msleep(200);
}
// ok?
return !size? 1 : 0;
}
tb_zip_ref_t tb_zip_zlib_init(tb_size_t action)
{
// make zip
tb_zip_ref_t zip = (tb_zip_ref_t)tb_malloc0_type(tb_zip_zlib_t);
tb_assert_and_check_return_val(zip, tb_null);
// init zip
zip->algo = TB_ZIP_ALGO_ZLIB;
zip->action = (tb_uint16_t)action;
// open zst
switch (action)
{
case TB_ZIP_ACTION_INFLATE:
{
zip->spak = tb_zip_zlib_spak_inflate;
// skip zlib header, only inflate raw data
if (inflateInit2(&((tb_zip_zlib_t*)zip)->zst, -MAX_WBITS) != Z_OK) goto fail;
}
break;
case TB_ZIP_ACTION_DEFLATE:
{
zip->spak = tb_zip_zlib_spak_deflate;
if (deflateInit(&((tb_zip_zlib_t*)zip)->zst, Z_DEFAULT_COMPRESSION) != Z_OK) goto fail;
}
break;
default:
break;
}
// ok
return zip;
fail:
if (zip) tb_free(zip);
return tb_null;
}
tb_sint64_t tb_oc_number_sint64(tb_object_ref_t object)
{
// check
tb_oc_number_t* number = tb_oc_number_cast(object);
tb_assert_and_check_return_val(number, 0);
// sint64
switch (number->type)
{
case TB_OC_NUMBER_TYPE_UINT64:
return number->v.u64;
case TB_OC_NUMBER_TYPE_SINT64:
return number->v.s64;
case TB_OC_NUMBER_TYPE_UINT32:
return number->v.u32;
case TB_OC_NUMBER_TYPE_SINT32:
return number->v.s32;
case TB_OC_NUMBER_TYPE_UINT16:
return number->v.u16;
case TB_OC_NUMBER_TYPE_SINT16:
return number->v.s16;
case TB_OC_NUMBER_TYPE_UINT8:
return number->v.u8;
case TB_OC_NUMBER_TYPE_SINT8:
return number->v.s8;
#ifdef TB_CONFIG_TYPE_HAVE_FLOAT
case TB_OC_NUMBER_TYPE_FLOAT:
return (tb_sint64_t)number->v.f;
case TB_OC_NUMBER_TYPE_DOUBLE:
return (tb_sint64_t)number->v.d;
#endif
default:
break;
}
tb_assert(0);
return 0;
}
tb_bool_t tb_context_make(tb_context_ref_t context, tb_pointer_t stack, tb_size_t stacksize, tb_context_func_t func, tb_cpointer_t priv)
{
// check
ucontext_t* ucontext = (ucontext_t*)context;
tb_assert_and_check_return_val(ucontext && stack && stacksize && func, tb_false);
// get context first
if (getcontext(ucontext) == 0)
{
// init stack and size
ucontext->uc_stack.ss_sp = stack;
ucontext->uc_stack.ss_size = stacksize;
// init link
ucontext->uc_link = tb_null;
// make it
makecontext(ucontext, (tb_void_t(*)())func, 1, (tb_size_t)priv);
}
// ok
return tb_true;
}
tb_bool_t tb_thread_local_set(tb_thread_local_ref_t local, tb_cpointer_t priv)
{
// check
tb_assert(local);
// have been not initialized?
tb_assert_and_check_return_val(local->inited, tb_false);
// free the previous data first
if (local->free && tb_thread_local_has(local))
local->free(tb_thread_local_get(local));
// set it
tb_bool_t ok = pthread_setspecific(((pthread_key_t*)local->priv)[0], priv) == 0;
if (ok)
{
// mark exists
ok = pthread_setspecific(((pthread_key_t*)local->priv)[1], (tb_pointer_t)tb_true) == 0;
}
// ok?
return ok;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* private implementation
*/
static tb_bool_t xm_machine_main_save_arguments(xm_machine_impl_t* impl, tb_int_t argc, tb_char_t** argv)
{
// check
tb_assert_and_check_return_val(impl && impl->lua && argc >= 1 && argv, tb_false);
// put a new table into the stack
lua_newtable(impl->lua);
// save all arguments to the new table
tb_int_t i = 0;
for (i = 1; i < argc; i++)
{
// table_new[table.getn(table_new) + 1] = argv[i]
lua_pushstring(impl->lua, argv[i]);
lua_rawseti(impl->lua, -2, luaL_getn(impl->lua, -2) + 1);
}
// _ARGV = table_new
lua_setglobal(impl->lua, "_ARGV");
// ok
return tb_true;
}
tb_long_t tb_thread_pool_task_wait(tb_thread_pool_ref_t pool, tb_thread_pool_task_ref_t task, tb_long_t timeout)
{
// check
tb_thread_pool_job_t* job = (tb_thread_pool_job_t*)task;
tb_assert_and_check_return_val(pool && job, -1);
// wait it
tb_hong_t time = tb_cache_time_spak();
tb_size_t state = TB_STATE_WAITING;
while ( ((state = tb_atomic_get(&job->state)) != TB_STATE_FINISHED)
&& state != TB_STATE_KILLED
&& (timeout < 0 || tb_cache_time_spak() < time + timeout))
{
// trace
tb_trace_d("task[%p:%s]: wait: state: %s: ..", job->task.done, job->task.name, tb_state_cstr(state));
// wait some time
tb_msleep(200);
}
// ok?
return (state == TB_STATE_FINISHED || state == TB_STATE_KILLED)? 1 : 0;
}
static tb_size_t tb_vector_nremove_last_test()
{
// init
tb_vector_ref_t vector = tb_vector_init(TB_VECTOR_GROW_SIZE, tb_element_long());
tb_assert_and_check_return_val(vector, 0);
tb_size_t n = 10000;
tb_vector_ninsert_head(vector, (tb_pointer_t)0xf, n);
tb_hong_t t = tb_mclock();
tb_vector_nremove_last(vector, n);
t = tb_mclock() - t;
// time
tb_trace_i("tb_vector_nremove_last(%lu): %lld ms, size: %lu, maxn: %lu", n, t, tb_vector_size(vector), tb_vector_maxn(vector));
// check
tb_assert(!tb_vector_size(vector));
// exit
tb_vector_exit(vector);
return n / ((tb_uint32_t)(t) + 1);
}
tb_double_t tb_stod(tb_char_t const* s)
{
// check
tb_assert_and_check_return_val(s, 0);
// skip space
tb_char_t const* p = s;
while (tb_isspace(*p)) p++;
// has sign?
if (*p == '-') p++;
// is hex?
if (*p++ == '0')
{
if (*p == 'x' || *p == 'X')
return tb_s16tod(s);
else if (*p == 'b' || *p == 'B')
return tb_s2tod(s);
else return tb_s8tod(s);
}
else return tb_s10tod(s);
}
static tb_long_t tb_ifaddrs_netlink_socket_recv(tb_long_t sock, tb_pointer_t data, tb_size_t size)
{
// check
tb_assert_and_check_return_val(sock >= 0 && data && size, -1);
// done
struct msghdr packet;
struct iovec iov = { data, size };
struct sockaddr_nl addr;
while (1)
{
// init packet
packet.msg_name = (tb_pointer_t)&addr;
packet.msg_namelen = sizeof(addr);
packet.msg_iov = &iov;
packet.msg_iovlen = 1;
packet.msg_control = tb_null;
packet.msg_controllen = 0;
packet.msg_flags = 0;
// recv packet
tb_long_t ok = recvmsg(sock, &packet, 0);
// failed or continue
if (ok < 0)
{
if (errno == EINTR) continue;
return -2;
}
// buffer was too small
if (packet.msg_flags & MSG_TRUNC) return -1;
// ok
return ok;
}
}
tb_semaphore_ref_t tb_semaphore_init(tb_size_t init)
{
// check
tb_assert_and_check_return_val(init <= TB_SEMAPHORE_VALUE_MAXN, tb_null);
// done
tb_bool_t ok = tb_false;
tb_semaphore_impl_t* impl = tb_null;
do
{
// make semaphore
impl = tb_malloc0_type(tb_semaphore_impl_t);
tb_assert_and_check_break(impl);
// init semaphore
impl->semaphore = CreateSemaphoreA(tb_null, (DWORD)init, TB_SEMAPHORE_VALUE_MAXN, tb_null);
tb_assert_and_check_break(impl->semaphore && impl->semaphore != INVALID_HANDLE_VALUE);
// init value
impl->value = init;
// ok
ok = tb_true;
} while (0);
// failed?
if (!ok)
{
// exit it
if (impl) tb_semaphore_exit((tb_semaphore_ref_t)impl);
impl = tb_null;
}
// ok?
return (tb_semaphore_ref_t)impl;
}
tb_bool_t tb_allocator_free_(tb_allocator_ref_t allocator, tb_pointer_t data __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(allocator, tb_false);
// enter
tb_spinlock_enter(&allocator->lock);
// trace
tb_trace_d("free(%p): at %s(): %d, %s", data __tb_debug_args__);
// free it
tb_bool_t ok = tb_false;
if (allocator->free) ok = allocator->free(allocator, data __tb_debug_args__);
else if (allocator->large_free) ok = allocator->large_free(allocator, data __tb_debug_args__);
// failed? dump it
#ifdef __tb_debug__
if (!ok)
{
// trace
tb_trace_e("free(%p) failed! at %s(): %lu, %s", data, func_, line_, file_);
// dump data
tb_pool_data_dump((tb_byte_t const*)data, tb_true, "[large_allocator]: [error]: ");
// abort
tb_abort();
}
#endif
// leave
tb_spinlock_leave(&allocator->lock);
// ok?
return ok;
}
tb_uint64_t tb_s8tou64(tb_char_t const* s)
{
// check
tb_assert_and_check_return_val(s, 0);
// skip space
while (tb_isspace(*s)) s++;
// has sign?
tb_int_t sign = 0;
if (*s == '-')
{
sign = 1;
s++;
}
// skip '0'
while ((*s) == '0') s++;
// compute number
tb_uint64_t val = 0;
while (*s)
{
tb_char_t ch = *s;
if (tb_isdigit8(ch))
val = (val << 3) + (ch - '0');
else break;
s++;
}
// is negative number?
if (sign) val = ~val + 1;
// the value
return val;
}
static tb_object_ref_t tb_oc_number_copy(tb_object_ref_t object)
{
// check
tb_oc_number_t* number = (tb_oc_number_t*)object;
tb_assert_and_check_return_val(number, tb_null);
// copy
switch (number->type)
{
case TB_OC_NUMBER_TYPE_UINT64:
return tb_oc_number_init_from_uint64(number->v.u64);
case TB_OC_NUMBER_TYPE_SINT64:
return tb_oc_number_init_from_sint64(number->v.s64);
case TB_OC_NUMBER_TYPE_UINT32:
return tb_oc_number_init_from_uint32(number->v.u32);
case TB_OC_NUMBER_TYPE_SINT32:
return tb_oc_number_init_from_sint32(number->v.s32);
case TB_OC_NUMBER_TYPE_UINT16:
return tb_oc_number_init_from_uint16(number->v.u16);
case TB_OC_NUMBER_TYPE_SINT16:
return tb_oc_number_init_from_sint16(number->v.s16);
case TB_OC_NUMBER_TYPE_UINT8:
return tb_oc_number_init_from_uint8(number->v.u8);
case TB_OC_NUMBER_TYPE_SINT8:
return tb_oc_number_init_from_sint8(number->v.s8);
#ifdef TB_CONFIG_TYPE_HAVE_FLOAT
case TB_OC_NUMBER_TYPE_FLOAT:
return tb_oc_number_init_from_float(number->v.f);
case TB_OC_NUMBER_TYPE_DOUBLE:
return tb_oc_number_init_from_double(number->v.d);
#endif
default:
break;
}
return tb_null;
}
static tb_bool_t tb_demo_transfer_done_func(tb_size_t state, tb_hize_t offset, tb_hong_t size, tb_hize_t save, tb_size_t rate, tb_cpointer_t priv)
{
// check
tb_demo_context_t* context = (tb_demo_context_t*)priv;
tb_assert_and_check_return_val(context && context->option, tb_false);
// print verbose info
if (context->verbose)
{
// percent
tb_size_t percent = 0;
if (size > 0) percent = (tb_size_t)((offset * 100) / size);
else if (state == TB_STATE_CLOSED) percent = 100;
// trace
tb_printf("save: %llu bytes, rate: %lu bytes/s, percent: %lu%%, state: %s\n", save, rate, percent, tb_state_cstr(state));
}
// failed or closed? exit wait
if (state != TB_STATE_OK && context->event) tb_event_post(context->event);
// ok?
return (state == TB_STATE_OK)? tb_true : tb_false;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_size_t tb_rfind_if(tb_iterator_ref_t iterator, tb_size_t head, tb_size_t tail, tb_predicate_ref_t pred, tb_cpointer_t value)
{
// check
tb_assert_and_check_return_val(pred && iterator && (tb_iterator_mode(iterator) & TB_ITERATOR_MODE_REVERSE), tb_iterator_tail(iterator));
// null?
tb_check_return_val(head != tail, tb_iterator_tail(iterator));
// find
tb_size_t itor = tail;
tb_bool_t find = tb_false;
do
{
// the previous item
itor = tb_iterator_prev(iterator, itor);
// comp
if ((find = pred(iterator, tb_iterator_item(iterator, itor), value))) break;
} while (itor != head);
// ok?
return find? itor : tb_iterator_tail(iterator);
}
tb_long_t tb_object_writ_to_url(tb_object_ref_t object, tb_char_t const* url, tb_size_t format)
{
// check
tb_assert_and_check_return_val(object && url, -1);
// make stream
tb_long_t writ = -1;
tb_stream_ref_t stream = tb_stream_init_from_url(url);
if (stream)
{
// ctrl stream
if (tb_stream_type(stream) == TB_STREAM_TYPE_FILE)
tb_stream_ctrl(stream, TB_STREAM_CTRL_FILE_SET_MODE, TB_FILE_MODE_RW | TB_FILE_MODE_BINARY | TB_FILE_MODE_CREAT | TB_FILE_MODE_TRUNC);
// open and writ stream
if (tb_stream_open(stream)) writ = tb_object_writ(object, stream, format);
// exit stream
tb_stream_exit(stream);
}
// ok?
return writ;
}
tb_long_t tb_aicp_wait_all(tb_aicp_ref_t aicp, tb_long_t timeout)
{
// check
tb_aicp_impl_t* impl = (tb_aicp_impl_t*)aicp;
tb_assert_and_check_return_val(impl, -1);
// trace
tb_trace_d("wait: all: ..");
// wait it
tb_size_t size = 0;
tb_hong_t time = tb_cache_time_spak();
while ((timeout < 0 || tb_cache_time_spak() < time + timeout))
{
// enter
tb_spinlock_enter(&impl->lock);
// the aico count
size = impl->pool? tb_fixed_pool_size(impl->pool) : 0;
// trace
tb_trace_d("wait: count: %lu: ..", size);
// leave
tb_spinlock_leave(&impl->lock);
// ok?
tb_check_break(size);
// wait some time
tb_msleep(200);
}
// ok?
return !size? 1 : 0;
}
static tb_bool_t tb_oc_xml_writer_func_array(tb_oc_xml_writer_t* writer, tb_object_ref_t object, tb_size_t level)
{
// check
tb_assert_and_check_return_val(writer && writer->stream, tb_false);
// writ
if (tb_oc_array_size(object))
{
// writ beg
if (!tb_oc_writer_tab(writer->stream, writer->deflate, level)) return tb_false;
if (tb_stream_printf(writer->stream, "<array>") < 0) return tb_false;
if (!tb_oc_writer_newline(writer->stream, writer->deflate)) return tb_false;
// walk
tb_for_all (tb_object_ref_t, item, tb_oc_array_itor(object))
{
// item
if (item)
{
// func
tb_oc_xml_writer_func_t func = tb_oc_xml_writer_func(item->type);
tb_assert_and_check_continue(func);
// writ
if (!func(writer, item, level + 1)) return tb_false;
}
}
// writ end
if (!tb_oc_writer_tab(writer->stream, writer->deflate, level)) return tb_false;
if (tb_stream_printf(writer->stream, "</array>") < 0) return tb_false;
if (!tb_oc_writer_newline(writer->stream, writer->deflate)) return tb_false;
}
else
{
if (!tb_oc_writer_tab(writer->stream, writer->deflate, level)) return tb_false;
tb_context_ref_t tb_context_init(tb_byte_t* data, tb_size_t size)
{
// check size
tb_size_t context_size = tb_context_size();
tb_assert_and_check_return_val(data && context_size && context_size <= size, tb_null);
// get context
tb_context_ref_t context = (tb_context_ref_t)data;
// init context
tb_memset(data, 0, context_size);
#if defined(TB_CONFIG_POSIX_HAVE_GETCONTEXT) && \
defined(TB_CONFIG_POSIX_HAVE_SETCONTEXT) && \
defined(TB_CONFIG_POSIX_HAVE_MAKECONTEXT)
// init sigmask
sigset_t zero;
sigemptyset(&zero);
sigprocmask(SIG_BLOCK, &zero, &((ucontext_t*)context)->uc_sigmask);
#endif
// ok
return context;
}
static tb_static_large_data_head_t* tb_static_large_allocator_malloc_pred(tb_static_large_allocator_ref_t allocator, tb_size_t space)
{
// check
tb_assert_and_check_return_val(allocator && allocator->data_head, tb_null);
// walk the pred cache
tb_size_t indx = tb_static_large_allocator_pred_index(allocator, space);
tb_size_t size = tb_arrayn(allocator->data_pred);
tb_static_large_data_pred_t* pred = allocator->data_pred;
tb_static_large_data_head_t* data_head = tb_null;
tb_static_large_data_head_t* pred_head = tb_null;
for (; indx < size && !data_head; indx++)
{
// the pred data head
pred_head = pred[indx].data_head;
if (pred_head)
{
// find the free data from the pred data head
data_head = tb_static_large_allocator_malloc_find(allocator, pred_head, 1, space);
#ifdef __tb_debug__
// update the total count
pred[indx].total_count++;
// update the failed count
if (!data_head) pred[indx].failed_count++;
#endif
}
}
// trace
tb_trace_d("malloc: pred: %lu: %s", space, data_head? "ok" : "no");
// ok?
return data_head;
}
tb_double_t tb_oc_number_double(tb_object_ref_t object)
{
// check
tb_oc_number_t* number = tb_oc_number_cast(object);
tb_assert_and_check_return_val(number, 0);
// double
switch (number->type)
{
case TB_OC_NUMBER_TYPE_DOUBLE:
return number->v.d;
case TB_OC_NUMBER_TYPE_FLOAT:
return (tb_double_t)number->v.f;
case TB_OC_NUMBER_TYPE_UINT8:
return (tb_double_t)number->v.u8;
case TB_OC_NUMBER_TYPE_SINT8:
return (tb_double_t)number->v.s8;
case TB_OC_NUMBER_TYPE_UINT16:
return (tb_double_t)number->v.u16;
case TB_OC_NUMBER_TYPE_SINT16:
return (tb_double_t)number->v.s16;
case TB_OC_NUMBER_TYPE_UINT32:
return (tb_double_t)number->v.u32;
case TB_OC_NUMBER_TYPE_SINT32:
return (tb_double_t)number->v.s32;
case TB_OC_NUMBER_TYPE_UINT64:
return (tb_double_t)number->v.u64;
case TB_OC_NUMBER_TYPE_SINT64:
return (tb_double_t)number->v.s64;
default:
break;
}
tb_assert(0);
return 0;
}
