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

/* ////////////////////////////////////////////////////////////////////////////////////// * 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_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_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;}

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;}