自学教程：C++ tb_check_return_val函数代码示例

tb_size_t tb_backtrace_frames(tb_pointer_t* frames, tb_size_t nframe, tb_size_t nskip){    // note: cannot use assert    tb_check_return_val(frames && nframe, 0);    // skip some frames?    if (nskip)    {        // init temp frames        tb_pointer_t    temp[256] = {0};        tb_check_return_val(nframe + nskip < 256, 0);        // done backtrace        tb_size_t       size = backtrace(temp, nframe + nskip);        tb_check_return_val(nskip < size, 0);        // update nframe        nframe = tb_min(nframe, size - nskip);        // save to frames        tb_memcpy_(frames, temp + nskip, nframe * sizeof(tb_pointer_t));    }    // backtrace    else nframe = backtrace(frames, nframe);    // ok?    return nframe;}

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_long_t tb_semaphore_wait(tb_semaphore_ref_t semaphore, tb_long_t timeout){    // check    sem_t* h = (sem_t*)semaphore;    tb_assert_and_check_return_val(h, -1);    // init time    struct timespec t = {0};    t.tv_sec = time(tb_null);    if (timeout > 0)    {        t.tv_sec += timeout / 1000;        t.tv_nsec += (timeout % 1000) * 1000000;    }    else if (timeout < 0) t.tv_sec += 12 * 30 * 24 * 3600; // infinity: one year    // wait semaphore    tb_long_t r = sem_timedwait(h, &t);    // ok?    tb_check_return_val(r, 1);    // timeout?    tb_check_return_val(errno != EAGAIN && errno != ETIMEDOUT, 0);    // error    return -1;}

tb_long_t tb_semaphore_wait(tb_semaphore_ref_t semaphore, tb_long_t timeout){    // check    tb_semaphore_impl_t* impl = (tb_semaphore_impl_t*)semaphore;    tb_assert_and_check_return_val(semaphore && impl->semaphore && impl->semaphore != INVALID_HANDLE_VALUE, -1);    // wait    tb_long_t r = WaitForSingleObject(impl->semaphore, timeout >= 0? timeout : INFINITE);    tb_assert_and_check_return_val(r != WAIT_FAILED, -1);    // timeout?    tb_check_return_val(r != WAIT_TIMEOUT, 0);    // error?    tb_check_return_val(r >= WAIT_OBJECT_0, -1);    // check value    tb_assert_and_check_return_val((tb_long_t)tb_atomic_get(&impl->value) > 0, -1);        // value--    tb_atomic_fetch_and_dec(&impl->value);        // ok    return 1;}

tb_char_t const* tb_backtrace_symbols_name(tb_handle_t symbols, tb_pointer_t* frames, tb_size_t nframe, tb_size_t iframe){    // check    tb_check_return_val(symbols && frames && nframe && iframe < nframe, tb_null);    // the frame address    tb_pointer_t frame = frames[iframe];    tb_check_return_val(frame, tb_null);    // the frame dlinfo    Dl_info dlinfo = {0};    if (!dladdr(frame, &dlinfo)) return tb_null;    // format    tb_long_t size = 0;    tb_size_t maxn = 8192;    if (dlinfo.dli_fname) size = tb_snprintf((tb_char_t*)symbols, maxn, "%s(", dlinfo.dli_fname);    if (dlinfo.dli_sname && size >= 0) size += tb_snprintf((tb_char_t*)symbols + size, maxn - size, "%s", dlinfo.dli_sname);    if (dlinfo.dli_sname && frame >= dlinfo.dli_saddr && size >= 0) size += tb_snprintf((tb_char_t*)symbols + size, maxn - size, "+%#lx", (tb_size_t)(frame - dlinfo.dli_saddr));    if (size >= 0) size += tb_snprintf((tb_char_t*)symbols + size, maxn - size, ") [%p]", frame);    if (size >= 0) ((tb_char_t*)symbols)[size] = '/0';    // ok    return symbols;}

static tb_long_t tb_dns_looker_resp(tb_dns_looker_impl_t* impl, tb_ipaddr_ref_t addr){    // check    tb_check_return_val(!(impl->step & TB_DNS_LOOKER_STEP_RESP), 1);    // need wait if no data    impl->step &= ~TB_DNS_LOOKER_STEP_NEVT;    // recv response data    tb_byte_t rpkt[4096];    while (1)    {        // read data        tb_long_t read = tb_socket_urecv(impl->sock, tb_null, rpkt, 4096);        //tb_trace_d("read %d", read);        tb_assert_and_check_return_val(read >= 0, -1);        // no data?         if (!read)        {            // end? read x, read 0            tb_check_break(!tb_static_buffer_size(&impl->rpkt));                // abort? read 0, read 0            tb_check_return_val(!impl->tryn, -1);                        // tryn++            impl->tryn++;            // continue             return 0;        }        else impl->tryn = 0;        // copy data        tb_static_buffer_memncat(&impl->rpkt, rpkt, read);    }    // done    if (!tb_dns_looker_resp_done(impl, addr)) return -1;    // check    tb_assert_and_check_return_val(tb_static_string_size(&impl->name) && !tb_ipaddr_ip_is_empty(addr), -1);    // save address to cache    tb_dns_cache_set(tb_static_string_cstr(&impl->name), addr);    // finish it    impl->step |= TB_DNS_LOOKER_STEP_RESP;    impl->tryn = 0;    // reset rpkt    impl->size = 0;    tb_static_buffer_clear(&impl->rpkt);    // ok    tb_trace_d("response: ok");    return 1;}

static tb_pool_data_empty_head_t* tb_static_fixed_pool_malloc_find(tb_static_fixed_pool_t* pool){    // check    tb_assert_and_check_return_val(pool, tb_null);    // init    tb_size_t   i = 0;    tb_size_t*  p = (tb_size_t*)pool->used_info;    tb_size_t*  e = (tb_size_t*)(pool->used_info + pool->info_size);    tb_byte_t*  d = tb_null;    // check align    tb_assert_and_check_return_val(!(((tb_size_t)p) & (TB_CPU_BITBYTE - 1)), tb_null);    // find the free chunk, item_space * 32|64 items#ifdef __tb_small__ //  while (p < e && *p == 0xffffffff) p++;//  while (p < e && *p == 0xffffffffffffffffL) p++;    while (p < e && !((*p) + 1)) p++;#else    while (p + 7 < e)    {        if (p[0] + 1) { p += 0; break; }        if (p[1] + 1) { p += 1; break; }        if (p[2] + 1) { p += 2; break; }        if (p[3] + 1) { p += 3; break; }        if (p[4] + 1) { p += 4; break; }        if (p[5] + 1) { p += 5; break; }        if (p[6] + 1) { p += 6; break; }        if (p[7] + 1) { p += 7; break; }        p += 8;    }    while (p < e && !(*p + 1)) p++; #endif    tb_check_return_val(p < e, tb_null);    // find the free bit index    tb_size_t m = pool->item_maxn;    i = (((tb_byte_t*)p - pool->used_info) << 3) + tb_static_fixed_pool_find_free(*p);    tb_check_return_val(i < m, tb_null);    // allocate it    d = pool->data + i * pool->item_space;    tb_static_fixed_pool_used_set1(pool->used_info, i);    // predict this index if no full?    if ((*p) + 1) tb_static_fixed_pool_cache_pred(pool, i);    // ok?    return (tb_pool_data_empty_head_t*)d;}

tb_long_t tb_thread_wait(tb_thread_ref_t thread, tb_long_t timeout){    // wait    tb_long_t r = WaitForSingleObject((HANDLE)thread, (DWORD)(timeout >= 0? timeout : INFINITE));    tb_assert_and_check_return_val(r != WAIT_FAILED, -1);    // timeout?    tb_check_return_val(r != WAIT_TIMEOUT, 0);    // error?    tb_check_return_val(r >= WAIT_OBJECT_0, -1);    // ok    return 1;}

tb_int32_t tb_int32_div(tb_int32_t x, tb_int32_t y, tb_int_t nbits){    tb_assert(y);    tb_check_return_val(x, 0);    // get sign    tb_int32_t s = tb_int32_get_sign(x ^ y);    x = tb_abs(x);    y = tb_abs(y);    tb_int_t xbits = (tb_int_t)tb_bits_cl0_u32_be(x) - 1;    tb_int_t ybits = (tb_int_t)tb_bits_cl0_u32_be(y) - 1;    tb_int_t bits = nbits - xbits + ybits;     // underflow?    if (bits < 0) return 0;     // overflow?    if (bits > 31) return tb_int32_set_sign(TB_MAXS32, s);    x <<= xbits;    y <<= ybits;    // do the first one    tb_int32_t r = 0;    if ((x -= y) >= 0) r = 1;    else x += y;        // now fall into our switch statement if there are more bits to compute    if (bits > 0)     {        // make room for the rest of the answer bits        r <<= bits;        switch (bits)         {#define TB_INT32_DIV_CASE(n) /        case n: /            if ((x = (x << 1) - y) >= 0) /            r |= 1 << (n - 1); else x += y            TB_INT32_DIV_CASE(31); TB_INT32_DIV_CASE(30); TB_INT32_DIV_CASE(29);            TB_INT32_DIV_CASE(28); TB_INT32_DIV_CASE(27); TB_INT32_DIV_CASE(26);            TB_INT32_DIV_CASE(25); TB_INT32_DIV_CASE(24); TB_INT32_DIV_CASE(23);            TB_INT32_DIV_CASE(22); TB_INT32_DIV_CASE(21); TB_INT32_DIV_CASE(20);            TB_INT32_DIV_CASE(19); TB_INT32_DIV_CASE(18); TB_INT32_DIV_CASE(17);            TB_INT32_DIV_CASE(16); TB_INT32_DIV_CASE(15); TB_INT32_DIV_CASE(14);            TB_INT32_DIV_CASE(13); TB_INT32_DIV_CASE(12); TB_INT32_DIV_CASE(11);            TB_INT32_DIV_CASE(10); TB_INT32_DIV_CASE( 9); TB_INT32_DIV_CASE( 8);            TB_INT32_DIV_CASE( 7); TB_INT32_DIV_CASE( 6); TB_INT32_DIV_CASE( 5);            TB_INT32_DIV_CASE( 4); TB_INT32_DIV_CASE( 3); TB_INT32_DIV_CASE( 2);            // we merge these last two together, makes gcc make better arm        default:            TB_INT32_DIV_CASE(1);        }    }    if (r < 0) r = TB_MAXS32;    return tb_int32_set_sign(r, s);}

tb_iterator_ref_t tb_ifaddrs_itor(tb_ifaddrs_ref_t ifaddrs, tb_bool_t reload){    // check    tb_list_ref_t interfaces = (tb_list_ref_t)ifaddrs;    tb_assert_and_check_return_val(interfaces, tb_null);    // uses the cached interfaces?    tb_check_return_val(reload, (tb_iterator_ref_t)interfaces);     // clear interfaces first    tb_list_clear(interfaces);    // done    tb_long_t sock = -1;    do    {        // make sock        sock = tb_ifaddrs_netlink_socket_init();        tb_assert_and_check_break(sock >= 0);        // load ipaddr        if (!tb_ifaddrs_interface_load(interfaces, sock, RTM_GETADDR)) break;        // load hwaddr        if (!tb_ifaddrs_interface_load(interfaces, sock, RTM_GETLINK)) break;    } while (0);    // exit sock    if (sock >= 0) close(sock);    sock = -1;    // ok?    return (tb_iterator_ref_t)interfaces;}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_size_t gb_float_unit_divide(gb_float_t numer, gb_float_t denom, gb_float_t* result){    // check    tb_assert_abort(result);    // negate it    if (numer < 0)    {        numer = -numer;        denom = -denom;    }    // must be valid numerator and denominator    if (0 == denom || 0 == numer || numer >= denom)        return 0;    // the result: numer / denom    gb_float_t r = gb_div(numer, denom);    // must be finite value    tb_assert_and_check_return_val(gb_isfinite(r), 0);    // must be in range: [0, 1)    tb_assert_and_check_return_val(r >= 0 && r < GB_ONE, 0);    // too smaller? not save result    tb_check_return_val(r != 0, 0);    // save result    *result = r;    // ok    return 1;}

tb_long_t tb_dns_looker_wait(tb_dns_looker_ref_t looker, tb_long_t timeout){    // check    tb_dns_looker_impl_t* impl = (tb_dns_looker_impl_t*)looker;    tb_assert_and_check_return_val(impl && impl->sock, -1);    // has asio event?    tb_size_t e = TB_AIOE_CODE_NONE;    if (!(impl->step & TB_DNS_LOOKER_STEP_NEVT))    {        if (!(impl->step & TB_DNS_LOOKER_STEP_REQT)) e = TB_AIOE_CODE_SEND;        else if (!(impl->step & TB_DNS_LOOKER_STEP_RESP)) e = TB_AIOE_CODE_RECV;    }    // need wait?    tb_long_t r = 0;    if (e)    {        // wait        r = tb_aioo_wait(impl->sock, e, timeout);        // fail or timeout?        tb_check_return_val(r > 0, r);    }    // ok?    return r;}

static tb_object_ref_t tb_object_json_reader_done(tb_stream_ref_t stream){    // check    tb_assert_and_check_return_val(stream, tb_null);    // init reader    tb_object_json_reader_t reader = {0};    reader.stream = stream;    // skip spaces    tb_char_t type = '/0';    while (tb_stream_left(stream))     {        type = tb_stream_bread_s8(stream);        if (!tb_isspace(type)) break;    }    // empty?    tb_check_return_val(tb_stream_left(stream), tb_null);    // the func    tb_object_json_reader_func_t func = tb_object_json_reader_func(type);    tb_assert_and_check_return_val(func, tb_null);    // read it    return func(&reader, type);}

static tb_pointer_t tb_memset_u16_impl(tb_pointer_t s, tb_uint16_t c, tb_size_t n){    // check    tb_assert_and_check_return_val(s, tb_null);    // no size?    tb_check_return_val(n, s);    // must be aligned by 2-bytes     tb_assert(!(((tb_size_t)s) & 0x1));    // init    __tb_register__ tb_uint16_t* p = (tb_uint16_t*)s;    // done#ifdef __tb_small__    while (n--) *p++ = c;#else    tb_size_t l = n & 0x3; n = (n - l) >> 2;    while (n--)    {        p[0] = c;        p[1] = c;        p[2] = c;        p[3] = c;        p += 4;    }    while (l--) *p++ = c;#endif    // ok?    return s;}

tb_bool_t tb_dns_looker_done(tb_char_t const* name, tb_ipaddr_ref_t addr){    // check    tb_assert_and_check_return_val(name && addr, tb_false);    // try to lookup it from cache first    if (tb_dns_cache_get(name, addr)) return tb_true;    // init looker    tb_dns_looker_ref_t looker = tb_dns_looker_init(name);    tb_check_return_val(looker, tb_false);    // spak    tb_long_t r = -1;    while (!(r = tb_dns_looker_spak(looker, addr)))    {        // wait        r = tb_dns_looker_wait(looker, TB_DNS_LOOKER_TIMEOUT);        tb_assert_and_check_break(r >= 0);    }    // exit    tb_dns_looker_exit(looker);    // ok    return r > 0? tb_true : tb_false;}

static tb_pointer_t tb_memset_impl(tb_pointer_t s, tb_byte_t c, tb_size_t n){    // check    tb_assert_and_check_return_val(s, tb_null);    // no size?    tb_check_return_val(n, s);    // init    __tb_register__ tb_byte_t* p = s;    // done#ifdef __tb_small__    while (n--) *p++ = c;#else    tb_size_t l = n & 0x3; n = (n - l) >> 2;    while (n--)    {        p[0] = c;        p[1] = c;        p[2] = c;        p[3] = c;        p += 4;    }    while (l--) *p++ = c;#endif    return s;}

tb_wchar_t* tb_wcsncpy(tb_wchar_t* s1, tb_wchar_t const* s2, tb_size_t n){    // check    tb_assert_and_check_return_val(s1 && s2, s1);    // no size or same?     tb_check_return_val(n && s1 != s2, s1);    // copy#if 0    tb_wchar_t* s = s1;    while (n)     {        if (*s = *s2) s2++;        ++s;        --n;    }    return s1;#else    tb_size_t sn = tb_wcslen(s2);    tb_size_t cn = tb_min(sn, n);    tb_size_t fn = sn < n? n - sn : 0;    tb_memcpy(s1, s2, cn * sizeof(tb_wchar_t));    if (fn) tb_memset(s1 + cn, 0, fn * sizeof(tb_wchar_t));    return s1;#endif}

__tb_no_sanitize_address__ tb_size_t tb_pool_data_size(tb_cpointer_t data){    // check    tb_check_return_val(data, 0);    // done    tb_size_t               size = 0;    tb_pool_data_head_t*    data_head = tb_null;    do    {        // tbox must be running normally        tb_check_break(tb_state() == TB_STATE_OK);        // get global allocator        tb_allocator_ref_t allocator = tb_allocator();        tb_check_break(allocator);        // have this data address?        tb_check_break(tb_allocator_have(allocator, data));        // the data head        data_head = &(((tb_pool_data_head_t*)data)[-1]);        tb_check_break(data_head->debug.magic == TB_POOL_DATA_MAGIC);        // ok        size = data_head->size;    } while (0);    // ok?    return size;}

tb_size_t tb_wcslcpy(tb_wchar_t* s1, tb_wchar_t const* s2, tb_size_t n){    // check    tb_assert_and_check_return_val(s1 && s2, 0);    // no size or same?     tb_check_return_val(n && s1 != s2, tb_wcslen(s1));    // copy#if 0    tb_wchar_t const* s = s2; --n;    while (*s1 = *s2)     {        if (n)         {            --n;            ++s1;        }        ++s2;    }    return s2 - s;#else    tb_size_t sn = tb_wcslen(s2);    tb_memcpy(s1, s2, tb_min(sn + 1, n) * sizeof(tb_wchar_t));    return tb_min(sn, n);#endif}

tb_long_t tb_dns_looker_wait(tb_dns_looker_ref_t self, tb_long_t timeout){    // check    tb_dns_looker_t* looker = (tb_dns_looker_t*)self;    tb_assert_and_check_return_val(looker && looker->sock, -1);    // has io event?    tb_size_t e = TB_SOCKET_EVENT_NONE;    if (!(looker->step & TB_DNS_LOOKER_STEP_NEVT))    {        if (!(looker->step & TB_DNS_LOOKER_STEP_REQT)) e = TB_SOCKET_EVENT_SEND;        else if (!(looker->step & TB_DNS_LOOKER_STEP_RESP)) e = TB_SOCKET_EVENT_RECV;    }    // need wait?    tb_long_t r = 0;    if (e)    {        // trace        tb_trace_d("waiting %p ..", looker->sock);        // wait        r = tb_socket_wait(looker->sock, e, timeout);        // fail or timeout?        tb_check_return_val(r > 0, r);    }    // ok?    return r;}

tb_byte_t* tb_queue_buffer_push_init(tb_queue_buffer_ref_t buffer, tb_size_t* size){    // check    tb_assert_and_check_return_val(buffer && buffer->maxn, tb_null);    // no data?    if (!buffer->data)    {        // make data        buffer->data = tb_malloc_bytes(buffer->maxn);        tb_assert_and_check_return_val(buffer->data, tb_null);        // init         buffer->head = buffer->data;        buffer->size = 0;    }    tb_assert_and_check_return_val(buffer->data && buffer->head, tb_null);    // full?    tb_size_t left = buffer->maxn - buffer->size;    tb_check_return_val(left, tb_null);    // move data to head first, make sure there is enough write space     if (buffer->head != buffer->data)    {        if (buffer->size) tb_memmov(buffer->data, buffer->head, buffer->size);        buffer->head = buffer->data;    }    // save size    if (size) *size = left;    // ok    return buffer->head + buffer->size;}

tb_char_t const* tb_string_ltrim(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*  p = s;    tb_char_t*  e = s + n;    while (p < e && tb_isspace(*p)) p++;    // strip it    if (p < e)    {        // move it if exists spaces        if (p > s) tb_buffer_memmov(string, p - s);    }    // clear it    else tb_string_clear(string);    // ok?    return tb_string_cstr(string);}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_bool_t gb_bitmap_biltter_shader_init(gb_bitmap_biltter_ref_t biltter, gb_bitmap_ref_t bitmap, gb_paint_ref_t paint){    // check    tb_assert_abort(biltter && bitmap && paint);     // init bitmap    biltter->bitmap = bitmap;    // init pixmap    biltter->pixmap = gb_pixmap(gb_bitmap_pixfmt(bitmap), gb_paint_alpha(paint));    tb_check_return_val(biltter->pixmap, tb_false);    // init btp and row_bytes    biltter->btp        = biltter->pixmap->btp;    biltter->row_bytes  = gb_bitmap_row_bytes(biltter->bitmap);    // init shader    // TODO    // init operations    // TODO    // trace    tb_trace_noimpl();    // ok    return tb_false;}

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_handle_t tb_backtrace_symbols_init(tb_pointer_t* frames, tb_size_t nframe){    // check    tb_check_return_val(frames && nframe, tb_null);    // init symbols    return malloc(8192);}

tb_pointer_t tb_native_memory_nalloc0(tb_size_t item, tb_size_t size){    // check    tb_check_return_val(item && size, tb_null);         // nalloc0    return tb_native_memory_malloc0(item * size);}

tb_char_t const* tb_addrinfo_name(tb_ipaddr_ref_t addr, tb_char_t* name, tb_size_t maxn){    // check    tb_assert_and_check_return_val(addr && name && maxn, tb_null);#if defined(TB_CONFIG_POSIX_HAVE_GETNAMEINFO)    // load socket address    struct sockaddr_storage saddr;    socklen_t saddrlen = (socklen_t)tb_sockaddr_load(&saddr, addr);    tb_assert_and_check_return_val(saddrlen, tb_null);    // get host name from address    return !getnameinfo((struct sockaddr const*)&saddr, saddrlen, name, maxn, tb_null, 0, NI_NAMEREQD)? name : tb_null;#elif defined(TB_CONFIG_POSIX_HAVE_GETHOSTBYNAME)    // done    struct hostent* hostaddr = tb_null;    switch (tb_ipaddr_family(addr))    {    case TB_IPADDR_FAMILY_IPV4:        {            // init ip address            struct in_addr ipaddr = {0};            ipaddr.s_addr = tb_ipaddr_ip_is_any(addr)? INADDR_ANY : addr->u.ipv4.u32;            // get host name from address            hostaddr = gethostbyaddr((tb_char_t const*)&ipaddr, sizeof(ipaddr), AF_INET);        }        break;    case TB_IPADDR_FAMILY_IPV6:        {            // init ip address            struct in6_addr ipaddr;            tb_memset(&ipaddr, 0, sizeof(ipaddr));            // save ipv6            if (tb_ipaddr_ip_is_any(addr)) ipaddr = in6addr_any;            else tb_memcpy(ipaddr.s6_addr, addr->u.ipv6.addr.u8, sizeof(ipaddr.s6_addr));            // get host name from address            hostaddr = gethostbyaddr((tb_char_t const*)&ipaddr, sizeof(ipaddr), AF_INET6);        }        break;    default:        break;    }    tb_check_return_val(hostaddr && hostaddr->h_name, tb_null);    // save name    tb_strlcpy(name, hostaddr->h_name, maxn);    // ok?    return name;#else    tb_trace_noimpl();    return tb_null;#endif}

static tb_handle_t tb_default_allocator_instance_init(tb_cpointer_t* ppriv){    // check    tb_check_return_val(ppriv, tb_null);    // the data and size    tb_value_ref_t  tuple = (tb_value_ref_t)*ppriv;    tb_byte_t*      data = (tb_byte_t*)tuple[0].ptr;    tb_size_t       size = tuple[1].ul;    // clear the private data first    *ppriv = tb_null;    // done    tb_bool_t               ok = tb_false;    tb_allocator_ref_t      allocator = tb_null;    tb_allocator_ref_t      large_allocator = tb_null;    do    {        /* init the page first         *         * because this allocator may be called before tb_init()         */        if (!tb_page_init()) break ;        /* init the native memory first         *         * because this allocator may be called before tb_init()         */        if (!tb_native_memory_init()) break ;        // init large allocator        large_allocator = tb_large_allocator_init(data, size);        tb_assert_and_check_break(large_allocator);        // init allocator        allocator = tb_default_allocator_init(large_allocator);        tb_assert_and_check_break(allocator);        // ok        ok = tb_true;    } while (0);    // failed?    if (!ok)    {        // exit large allocator        if (large_allocator) tb_allocator_exit(large_allocator);        large_allocator = tb_null;    }    // ok?    return (tb_handle_t)allocator;}