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

static tb_size_t tb_strlcpy_impl(tb_char_t* s1, tb_char_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_strlen(s1));    // copy#if 0    tb_char_t const* s = s2; --n;    while (*s1 = *s2)     {        if (n)         {            --n;            ++s1;        }        ++s2;    }    return s2 - s;#else    tb_size_t sn = tb_strlen(s2);    tb_memcpy(s1, s2, tb_min(sn + 1, n));    return tb_min(sn, n);#endif}

/* ////////////////////////////////////////////////////////////////////////////////////// * interfaces  */tb_long_t tb_strcmp(tb_char_t const* s1, tb_char_t const* s2){    // check#ifdef __tb_debug__    {        // check overflow?         tb_strlen(s1);        tb_strlen(s2);    }#endif    // done    return tb_strcmp_impl(s1, s2);}

tb_bool_t tb_directory_copy(tb_char_t const* path, tb_char_t const* dest){    // the absolute path    tb_char_t full0[TB_PATH_MAXN];    path = tb_path_absolute(path, full0, TB_PATH_MAXN);    tb_assert_and_check_return_val(path, tb_false);    // the dest path    tb_char_t full1[TB_PATH_MAXN];    dest = tb_path_absolute(dest, full1, TB_PATH_MAXN);    tb_assert_and_check_return_val(dest, tb_false);    // walk copy    tb_value_t tuple[3];    tuple[0].cstr = dest;    tuple[1].ul = tb_strlen(path);    tuple[2].b = tb_true;    tb_directory_walk(path, -1, tb_true, tb_directory_walk_copy, tuple);    // ok?    tb_bool_t ok = tuple[2].b;    // copy empty directory?    if (ok && !tb_file_info(dest, tb_null))         return tb_directory_create(dest);    // ok?    return ok;}

static tb_char_t* tb_strcpy_impl(tb_char_t* s1, tb_char_t const* s2){    tb_assert_and_check_return_val(s1 && s2, tb_null);    __tb_register__ tb_char_t* s = s1;    if (s1 == s2) return s;#if 1    tb_memcpy(s1, s2, tb_strlen(s2) + 1);#elif defined(__tb_small__)    while ((*s++ = *s2++)) ;#else    while (1)     {        if (!(s1[0] = s2[0])) break;        if (!(s1[1] = s2[1])) break;        if (!(s1[2] = s2[2])) break;        if (!(s1[3] = s2[3])) break;        s1 += 4;        s2 += 4;    }#endif    return s;}

static tb_char_t* tb_strncpy_impl(tb_char_t* s1, tb_char_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_char_t* s = s1;    while (n)     {        if (*s = *s2) s2++;        ++s;        --n;    }    return s1;#else    tb_size_t sn = tb_strlen(s2);    tb_size_t cn = tb_min(sn, n);    tb_size_t fn = sn < n? n - sn : 0;    tb_memcpy(s1, s2, cn);    if (fn) tb_memset(s1 + cn, 0, fn);    return s1;#endif}

static tb_bool_t xm_semver_select_from_branches(lua_State* lua, tb_int_t fromidx, tb_char_t const* range_str, tb_size_t range_len){    lua_Integer i = 0;    luaL_checktype(lua, fromidx, LUA_TTABLE);    for (i = lua_objlen(lua, fromidx); i > 0; --i)     {        lua_pushinteger(lua, i);        lua_gettable(lua, fromidx);        tb_char_t const* source_str = luaL_checkstring(lua, -1);        tb_check_continue(source_str);        tb_size_t source_len = tb_strlen(source_str);        if (source_len == range_len && tb_memcmp(source_str, range_str, source_len) == 0)         {            lua_createtable(lua, 0, 2);            lua_pushlstring(lua, source_str, source_len);            lua_setfield(lua, -2, "version");            lua_pushstring(lua, "branches");            lua_setfield(lua, -2, "source");            // ok            return tb_true;        }    }    // no matches    return tb_false;}

tb_size_t tb_murmur_make_from_cstr(tb_char_t const* cstr, tb_size_t seed){    // check    tb_assert_and_check_return_val(cstr, 0);    // make it    return tb_murmur_make((tb_byte_t const*)cstr, tb_strlen(cstr), seed);}

tb_long_t tb_charset_conv_cstr(tb_size_t ftype, tb_size_t ttype, tb_char_t const* cstr, tb_byte_t* data, tb_size_t size){    // check    tb_assert_and_check_return_val(TB_CHARSET_TYPE_OK(ftype) && TB_CHARSET_TYPE_OK(ttype) && cstr && data && size, -1);    // conv    return tb_charset_conv_data(ftype, ttype, (tb_byte_t const*)cstr, tb_strlen(cstr), data, size);}

/* ////////////////////////////////////////////////////////////////////////////////////// * main */ tb_int_t tb_demo_utils_url_main(tb_int_t argc, tb_char_t** argv){    tb_char_t ob[4096];    tb_size_t on = tb_url_encode(argv[1], tb_strlen(argv[1]), ob, 4096);    //tb_size_t on = tb_url_decode(argv[1], tb_strlen(argv[1]), ob, 4096);    tb_trace_i("%s: %lu", ob, on);    return 0;}

/* ////////////////////////////////////////////////////////////////////////////////////// * main */tb_int_t tb_demo_utils_fnv32_main(tb_int_t argc, tb_char_t** argv){    // data    tb_byte_t const*    data = (tb_byte_t const*)argv[1];    tb_size_t           size = tb_strlen((tb_char_t const*)data);    // trace    tb_trace_i("[fnv32]: %x", tb_fnv32_encode(data, size));    return 0;}

tb_long_t tb_puts(tb_char_t const* string){    // check    tb_check_return_val(string, 0);    // print it    tb_printl(string);    // ok?    return tb_strlen(string);}

static tb_void_t tb_test_strlen(tb_char_t const* s){    __tb_volatile__ tb_long_t   n = 1000000;    __tb_volatile__ tb_long_t   r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_strlen(s);    }    t = tb_mclock() - t;    tb_printf("%lld ms, tb_test_strlen(%s) = %ld/n", t, s, r);}

// semver.compare("v1.0.1-beta", "1.2") > 0?tb_int_t xm_semver_compare(lua_State* lua){    // check    tb_assert_and_check_return_val(lua, 0);    // get the version1 string    tb_char_t const* version1_str = luaL_checkstring(lua, 1);    tb_check_return_val(version1_str, 0);    // get the version2 string    tb_char_t const* version2_str = luaL_checkstring(lua, 2);    tb_check_return_val(version2_str, 0);    // try to parse version1 string    semver_t semver1 = {0};    if (semver_tryn(&semver1, version1_str, tb_strlen(version1_str)))     {        lua_pushnil(lua);        lua_pushfstring(lua, "unable to parse semver '%s'", version1_str);        return 2;    }    // try to parse version2 string    semver_t semver2 = {0};    if (semver_tryn(&semver2, version2_str, tb_strlen(version2_str)))     {        lua_pushnil(lua);        lua_pushfstring(lua, "unable to parse semver '%s'", version2_str);        return 2;    }    // do compare     lua_pushinteger(lua, semver_pcmp(&semver1, &semver2));    // end    semver_dtor(&semver1);    semver_dtor(&semver2);    return 1;}

static tb_void_t tb_element_str_repl(tb_element_ref_t element, tb_pointer_t buff, tb_cpointer_t data){    // check    tb_assert_and_check_return(element && element->dupl && buff);#if 0    // free it    if (element->free) element->free(element, buff);    // dupl it    element->dupl(element, buff, data);#else    // replace it    tb_pointer_t cstr = *((tb_pointer_t*)buff);    if (cstr && data)    {        // attempt to replace it        tb_char_t*          p = (tb_char_t*)cstr;        tb_char_t const*    q = (tb_char_t const*)data;        while (*p && *q) *p++ = *q++;        // not enough space?        if (!*p && *q)        {            // the left size            tb_size_t left = tb_strlen(q);            tb_assert_abort(left);            // the copy size            tb_size_t copy = p - (tb_char_t*)cstr;            // grow size            cstr = tb_ralloc(cstr, copy + left + 1);            tb_assert_abort(cstr);            // copy the left data            tb_strlcpy((tb_char_t*)cstr + copy, q, left + 1);             // update the cstr            *((tb_pointer_t*)buff) = cstr;        }        // end        else *p = '/0';    }    // duplicate it    else if (data) element->dupl(element, buff, data);    // free it    else if (element->free) element->free(element, buff);    // clear it    else *((tb_char_t const**)buff) = tb_null;#endif}

/* ////////////////////////////////////////////////////////////////////////////////////// * main */ tb_int_t tb_demo_utils_md5_main(tb_int_t argc, tb_char_t** argv){    tb_byte_t ob[16];    tb_size_t on = tb_md5_encode((tb_byte_t const*)argv[1], tb_strlen(argv[1]), ob, 16);    if (on != 16) return 0;    tb_size_t i = 0;    tb_char_t md5[256] = {0};    for (i = 0; i < 16; ++i) tb_snprintf(md5 + (i << 1), 3, "%02X", ob[i]);    tb_printf("%s: %lu/n", md5, on);    return 0;}

static tb_bool_t tb_environment_set_impl(tb_char_t const* name, tb_char_t const* value){    // check    tb_assert_and_check_return_val(name, tb_false);    // done    tb_bool_t   ok = tb_false;    tb_size_t   size = 0;    tb_wchar_t* value_w = tb_null;    tb_size_t   value_n = 0;    do    {        // make name        tb_wchar_t  name_w[512] = {0};        tb_size_t   name_n = tb_atow(name_w, name, tb_arrayn(name_w));        tb_assert_and_check_break(name_n);        // exists value?        if (value)        {            // make value            value_n = tb_strlen(value);            value_w = (tb_wchar_t*)tb_malloc0(sizeof(tb_wchar_t) * (value_n + 1));            tb_assert_and_check_break(value_w);            // init value            if (!tb_atow(value_w, value, value_n + 1)) break;            // set it            if (!tb_kernel32()->SetEnvironmentVariableW(name_w, value_w)) break;        }        // remove this variable        else        {            // remove it            if (!tb_kernel32()->SetEnvironmentVariableW(name_w, tb_null)) break;        }        // ok        ok = tb_true;    } while (0);    // exit data    if (value_w) tb_free(value_w);    value_w = tb_null;    // ok?    return ok;}

/* ////////////////////////////////////////////////////////////////////////////////////// * main */ tb_int_t tb_demo_utils_crc_main(tb_int_t argc, tb_char_t** argv){    tb_byte_t*  p = (tb_byte_t*)argv[1];    tb_size_t   n = tb_strlen((tb_char_t const*)p);#ifndef __tb_small__    tb_printf("[crc]: TB_CRC_MODE_8_ATM = %x/n", tb_crc_encode(TB_CRC_MODE_8_ATM, 0, p, n));    tb_printf("[crc]: TB_CRC_MODE_16_ANSI = %x/n", tb_crc_encode(TB_CRC_MODE_16_ANSI, 0, p, n));    tb_printf("[crc]: TB_CRC_MODE_16_CCITT = %x/n", tb_crc_encode(TB_CRC_MODE_16_CCITT, 0, p, n));    tb_printf("[crc]: TB_CRC_MODE_32_IEEE = %x/n", tb_crc_encode(TB_CRC_MODE_32_IEEE, 0, p, n));    tb_printf("[crc]: TB_CRC_MODE_32_IEEE_LE = %x/n", tb_crc_encode(TB_CRC_MODE_32_IEEE_LE, 0, p, n));#else    tb_printf("[crc]: TB_CRC_MODE_16_CCITT = %x/n", tb_crc_encode(TB_CRC_MODE_16_CCITT, 0, p, n));    tb_printf("[crc]: TB_CRC_MODE_32_IEEE_LE = %x/n", tb_crc_encode(TB_CRC_MODE_32_IEEE_LE, 0, p, n));#endif    return 0;}

/* ////////////////////////////////////////////////////////////////////////////////////// * private implementation */static tb_bool_t xm_semver_select_from_versions_tags(lua_State* lua, tb_int_t fromidx, semver_t* semver, semver_range_t const* range, semvers_t* matches){    // clear matches    semvers_pclear(matches);    // select all matches    lua_Integer i = 0;    luaL_checktype(lua, fromidx, LUA_TTABLE);    for (i = lua_objlen(lua, fromidx); i > 0; --i)     {        lua_pushinteger(lua, i);        lua_gettable(lua, fromidx);        tb_char_t const* source_str = luaL_checkstring(lua, -1);        if (source_str && semver_tryn(semver, source_str, tb_strlen(source_str)) == 0)         {            if (semver_range_pmatch(semver, range)) semvers_ppush(matches, *semver);            else semver_dtor(semver);        }    }    // no matches?    tb_check_return_val(matches->length, tb_false);    // sort matches    semvers_psort(matches);    // get the newest version     semver_t top = semvers_ppop(matches);    lua_createtable(lua, 0, 2);    // return results    lua_pushstring(lua, top.raw);    lua_setfield(lua, -2, "version");    lua_pushstring(lua, fromidx == 2? "versions" : "tags");    lua_setfield(lua, -2, "source");    // exit the popped semver     semver_dtor(&top);    // ok    return tb_true;}