diff --git a/src/Kconfig b/src/Kconfig index 34836d33838..e7f2a5108b6 100644 --- a/src/Kconfig +++ b/src/Kconfig @@ -1,5 +1,7 @@ menu "RT-Thread Kernel" +rsource "klibc/Kconfig" + config RT_NAME_MAX int "The maximal size of kernel object name" range 2 64 @@ -201,123 +203,6 @@ menu "kservice options" default n endmenu -menu "klibc options" - - config RT_KLIBC_USING_STDLIB - bool "Enable klibc to use standard C library" - default n - - if RT_KLIBC_USING_STDLIB - config RT_KLIBC_USING_STDLIB_MEMORY - bool "Use stdlib memory functions to replace (faster, but not safe)" - default n - help - e.g. use memcpy to replace rt_memcpy - endif - - config RT_KLIBC_USING_TINY_SIZE - bool "Enable tiny size of klibc" - default n - - menu "rt_vsnprintf options" - config RT_KLIBC_USING_VSNPRINTF_STANDARD - bool "standard rt_vsnprintf version" - default y if ARCH_CPU_64BIT - default n - help - Standard version of rt_vsnprintf, which is full function but higher stack usage. - - config RT_KLIBC_USING_VSNPRINTF_LONGLONG - bool "Enable rt_vsnprintf function to support long-long format" - default y if RT_KLIBC_USING_VSNPRINTF_STANDARD - default n - help - Support for the long long integral types (with the ll, z and t length modifiers for specifiers - %d,%i,%o,%x,%X,%u, and with the %p specifier). Note: 'L' (long double) is not supported. - - if RT_KLIBC_USING_VSNPRINTF_STANDARD - - config RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS - bool "Support decimal notation floating point conversion specifiers (%f, %F)" - default y - help - Support for the decimal notation floating point conversion specifiers (%f, %F) - - config RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS - bool "Support exponential notation floating point conversion specifiers (%e, %g, %E, %G)" - default y - help - Support for the exponential notation floating point conversion specifiers (%e, %g, %E, %G) - - config RT_KLIBC_USING_VSNPRINTF_WRITEBACK_SPECIFIER - bool "Support length write-back specifier (%n)" - default y - help - Support for the length write-back specifier (%n) - - config RT_KLIBC_USING_VSNPRINTF_CHECK_NUL_IN_FORMAT_SPECIFIER - bool "safety check: no NULL end string" - default y if RT_USING_DEBUG - default n - help - Be extra-safe, and don't assume format specifiers are completed correctly - before the format string end. - - config RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS - bool "Support MSVC style integer specifiers" - default n - help - the integer format specifiers used in Microsoft's Visual C++ (MSVC) compiler. - These specifiers, like %I64d for 64-bit integers, deviate slightly from the standard - C format specifiers and are specific to MSVC. They allow for controlled formatting of - integers in printf()-like functions, accommodating different integer sizes and ensuring - compatibility with MSVC's environment. It's important to note that these specifiers might - not be recognized or function in other compilers due to their MSVC-specific nature. - - config RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE - int "'ntoa' conversion buffer size" - default 32 - help - 'ntoa' conversion buffer size, this must be big enough to hold one converted - numeric number including padded zeros (dynamically created on stack) - - config RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE - int "printing individual decimal numbers buffer size" - default 32 - help - size of the fixed (on-stack) buffer for printing individual decimal numbers. - this must be big enough to hold one converted floating-point value including - padded zeros. - - config RT_KLIBC_USING_VSNPRINTF_FLOAT_PRECISION - int "floating point conversion specifiers" - default 6 - help - Default precision for the floating point conversion specifiers (the C standard sets this at 6) - - config RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL - int "integral nums printed as float in rt_vsnprint" - default 9 - help - According to the C languages standard, printf() and related functions must be able to print any - integral number in floating-point notation, regardless of length, when using the %f specifier - - possibly hundreds of characters, potentially overflowing your buffers. In this implementation, - all values beyond this threshold are switched to exponential notation. - - config RT_KLIBC_USING_VSNPRINTF_LOG10_TAYLOR_TERMS - int "the number of terms in a Taylor series expansion of log_10(x)" - default 4 - range 2 99 - help - The number of terms in a Taylor series expansion of log_10(x) to - use for approximation - including the power-zero term (i.e. the - value at the point of expansion). - - endif - endmenu # rt_vsnprintf options - -endmenu # klibc options - menuconfig RT_USING_DEBUG bool "Enable debugging features" default y diff --git a/src/klibc/Kconfig b/src/klibc/Kconfig new file mode 100644 index 00000000000..6baafd24e18 --- /dev/null +++ b/src/klibc/Kconfig @@ -0,0 +1,250 @@ +menu "klibc options" + + comment "------------rt_memset options------------" + config RT_KLIBC_USING_USER_MEMSET + bool "Enable rt_memset to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_MEMSET + config RT_KLIBC_USING_LIBC_MEMSET + bool "Enable rt_memset to use libc memset" + default n + + config RT_KLIBC_USING_TINY_MEMSET + bool "Enable rt_memset to use tiny version" + depends on !RT_KLIBC_USING_LIBC_MEMSET + default n + endif + + comment "------------rt_memcpy options------------" + config RT_KLIBC_USING_USER_MEMCPY + bool "Enable rt_memcpy to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_MEMCPY + config RT_KLIBC_USING_LIBC_MEMCPY + bool "Enable rt_memcpy to use libc memcpy" + default n + + config RT_KLIBC_USING_TINY_MEMCPY + bool "Enable rt_memcpy to use tiny version" + depends on !RT_KLIBC_USING_LIBC_MEMCPY + default n + endif + + comment "------------rt_memmove options------------" + config RT_KLIBC_USING_USER_MEMMOVE + bool "Enable rt_memmove to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_MEMMOVE + config RT_KLIBC_USING_LIBC_MEMMOVE + bool "Enable rt_memmove to use libc memmove" + default n + endif + + comment "------------rt_memcmp options------------" + config RT_KLIBC_USING_USER_MEMCMP + bool "Enable rt_memcmp to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_MEMCMP + config RT_KLIBC_USING_LIBC_MEMCMP + bool "Enable rt_memcmp to use libc memcmp" + default n + endif + + comment "------------rt_strstr options------------" + config RT_KLIBC_USING_USER_STRSTR + bool "Enable rt_strstr to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_STRSTR + config RT_KLIBC_USING_LIBC_STRSTR + bool "Enable rt_strstr to use libc strstr" + default n + endif + + comment "------------rt_strcasecmp options------------" + config RT_KLIBC_USING_USER_STRCASECMP + bool "Enable rt_strcasecmp to use user-defined version" + default n + + comment "------------rt_strncpy options------------" + config RT_KLIBC_USING_USER_STRNCPY + bool "Enable rt_strncpy to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_STRNCPY + config RT_KLIBC_USING_LIBC_STRNCPY + bool "Enable rt_strncpy to use libc strncpy" + default n + endif + + comment "------------rt_strcpy options------------" + config RT_KLIBC_USING_USER_STRCPY + bool "Enable rt_strcpy to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_STRCPY + config RT_KLIBC_USING_LIBC_STRCPY + bool "Enable rt_strcpy to use libc strcpy" + default n + endif + + comment "------------rt_strncmp options------------" + config RT_KLIBC_USING_USER_STRNCMP + bool "Enable rt_strncmp to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_STRNCMP + config RT_KLIBC_USING_LIBC_STRNCMP + bool "Enable rt_strncmp to use libc strncmp" + default n + endif + + comment "------------rt_strcmp options------------" + config RT_KLIBC_USING_USER_STRCMP + bool "Enable rt_strcmp to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_STRCMP + config RT_KLIBC_USING_LIBC_STRCMP + bool "Enable rt_strcmp to use libc strcmp" + default n + endif + + comment "------------rt_strlen options------------" + config RT_KLIBC_USING_USER_STRLEN + bool "Enable rt_strlen to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_STRLEN + config RT_KLIBC_USING_LIBC_STRLEN + bool "Enable rt_strlen to use libc strlen" + default n + endif + + comment "------------rt_strlen options------------" + config RT_KLIBC_USING_USER_STRLEN + bool "Enable rt_strlen to use user-defined version" + default n + + if !RT_KLIBC_USING_USER_STRLEN + config RT_KLIBC_USING_LIBC_STRLEN + bool "Enable rt_strlen to use libc strlen" + default n + endif + + comment "------------rt_strnlen options------------" + config RT_KLIBC_USING_USER_STRNLEN + bool "Enable rt_strnlen to use user-defined version" + default n + + comment "------------rt_vsscanf options------------" + config RT_KLIBC_USING_LIBC_VSSCANF + bool "Enable rt_vsscanf to use libc vsscanf" + default n + + comment "------------rt_vsnprintf options------------" + config RT_KLIBC_USING_LIBC_VSNPRINTF + bool "Enable rt_vsnprintf to use libc vsscanf" + default n + + config RT_KLIBC_USING_VSNPRINTF_LONGLONG + bool "Enable rt_vsnprintf function to support long-long format" + depends on !RT_KLIBC_USING_LIBC_VSNPRINTF + default n + help + Support for the long long integral types (with the ll, z and t length modifiers for specifiers + %d,%i,%o,%x,%X,%u, and with the %p specifier). Note: 'L' (long double) is not supported. + + menuconfig RT_KLIBC_USING_VSNPRINTF_STANDARD + bool "Enable standard rt_vsnprintf version" + default y if ARCH_CPU_64BIT + default n + select RT_KLIBC_USING_VSNPRINTF_LONGLONG + depends on !RT_KLIBC_USING_LIBC_VSNPRINTF + help + Standard version of rt_vsnprintf, which is full function but higher stack usage. + + if RT_KLIBC_USING_VSNPRINTF_STANDARD + + config RT_KLIBC_USING_VSNPRINTF_DECIMAL_SPECIFIERS + bool "Support decimal notation floating point conversion specifiers (%f, %F)" + default y + help + Support for the decimal notation floating point conversion specifiers (%f, %F) + + config RT_KLIBC_USING_VSNPRINTF_EXPONENTIAL_SPECIFIERS + bool "Support exponential notation floating point conversion specifiers (%e, %g, %E, %G)" + default y + help + Support for the exponential notation floating point conversion specifiers (%e, %g, %E, %G) + + config RT_KLIBC_USING_VSNPRINTF_WRITEBACK_SPECIFIER + bool "Support length write-back specifier (%n)" + default y + help + Support for the length write-back specifier (%n) + + config RT_KLIBC_USING_VSNPRINTF_CHECK_NUL_IN_FORMAT_SPECIFIER + bool "safety check: no NULL end string" + default y if RT_USING_DEBUG + default n + help + Be extra-safe, and don't assume format specifiers are completed correctly + before the format string end. + + config RT_KLIBC_USING_VSNPRINTF_MSVC_STYLE_INTEGER_SPECIFIERS + bool "Support MSVC style integer specifiers" + default n + help + the integer format specifiers used in Microsoft's Visual C++ (MSVC) compiler. + These specifiers, like %I64d for 64-bit integers, deviate slightly from the standard + C format specifiers and are specific to MSVC. They allow for controlled formatting of + integers in printf()-like functions, accommodating different integer sizes and ensuring + compatibility with MSVC's environment. It's important to note that these specifiers might + not be recognized or function in other compilers due to their MSVC-specific nature. + + config RT_KLIBC_USING_VSNPRINTF_INTEGER_BUFFER_SIZE + int "'ntoa' conversion buffer size" + default 32 + help + 'ntoa' conversion buffer size, this must be big enough to hold one converted + numeric number including padded zeros (dynamically created on stack) + + config RT_KLIBC_USING_VSNPRINTF_DECIMAL_BUFFER_SIZE + int "printing individual decimal numbers buffer size" + default 32 + help + size of the fixed (on-stack) buffer for printing individual decimal numbers. + this must be big enough to hold one converted floating-point value including + padded zeros. + + config RT_KLIBC_USING_VSNPRINTF_FLOAT_PRECISION + int "floating point conversion specifiers" + default 6 + help + Default precision for the floating point conversion specifiers (the C standard sets this at 6) + + config RT_KLIBC_USING_VSNPRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL + int "integral nums printed as float in rt_vsnprint" + default 9 + help + According to the C languages standard, printf() and related functions must be able to print any + integral number in floating-point notation, regardless of length, when using the %f specifier - + possibly hundreds of characters, potentially overflowing your buffers. In this implementation, + all values beyond this threshold are switched to exponential notation. + + config RT_KLIBC_USING_VSNPRINTF_LOG10_TAYLOR_TERMS + int "the number of terms in a Taylor series expansion of log_10(x)" + default 4 + range 2 99 + help + The number of terms in a Taylor series expansion of log_10(x) to + use for approximation - including the power-zero term (i.e. the + value at the point of expansion). + + endif +endmenu diff --git a/src/klibc/SConscript b/src/klibc/SConscript index 4a17403c20a..eb629ef7250 100644 --- a/src/klibc/SConscript +++ b/src/klibc/SConscript @@ -2,7 +2,16 @@ from building import * import os cwd = GetCurrentDir() -src = Glob('*.c') +src = ['kerrno.c', 'kstdio.c', 'kstring.c'] + +if not GetDepend(['RT_KLIBC_USING_LIBC_VSNPRINTF']): + if GetDepend(['RT_KLIBC_USING_VSNPRINTF_STANDARD']): + src += ['rt_vsnprintf_std.c'] + else: + src += ['rt_vsnprintf_tiny.c'] + +if not GetDepend(['RT_KLIBC_USING_LIBC_VSSCANF']): + src += ['rt_vsscanf.c'] group = DefineGroup('klibc', src, depend = ['']) diff --git a/src/klibc/kstdio.c b/src/klibc/kstdio.c index ceb891f3251..df73eab49bd 100644 --- a/src/klibc/kstdio.c +++ b/src/klibc/kstdio.c @@ -9,6 +9,10 @@ */ #include +#if defined(RT_KLIBC_USING_LIBC_VSSCANF) || \ + defined(RT_KLIBC_USING_LIBC_VSNPRINTF) +#include +#endif /** * @brief This function will fill a formatted string to buffer. @@ -73,6 +77,22 @@ int rt_sprintf(char *buf, const char *format, ...) } RTM_EXPORT(rt_sprintf); +#ifdef RT_KLIBC_USING_LIBC_VSNPRINTF +int rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args) +{ + return vsnprintf(buf, size, fmt, args); +} +#endif /* RT_KLIBC_USING_LIBC_VSNPRINTF */ +RTM_EXPORT(rt_vsnprintf); + +#ifdef RT_KLIBC_USING_LIBC_VSSCANF +int rt_vsscanf(const char *buffer, const char *format, va_list ap) +{ + return vsscanf(buffer, format, ap); +} +#endif /* RT_KLIBC_USING_LIBC_VSSCANF */ +RTM_EXPORT(rt_vsscanf); + /** * @brief This function parses a formatted string from the input string. * diff --git a/src/klibc/kstring.c b/src/klibc/kstring.c index 9eba5e57100..d2988d629cb 100644 --- a/src/klibc/kstring.c +++ b/src/klibc/kstring.c @@ -9,9 +9,19 @@ */ #include -#ifdef RT_KLIBC_USING_STDLIB + +#if defined(RT_KLIBC_USING_LIBC_MEMSET) || \ + defined(RT_KLIBC_USING_LIBC_MEMCPY) || \ + defined(RT_KLIBC_USING_LIBC_MEMMOVE) || \ + defined(RT_KLIBC_USING_LIBC_MEMCMP) || \ + defined(RT_KLIBC_USING_LIBC_STRSTR) || \ + defined(RT_KLIBC_USING_LIBC_STRNCPY) || \ + defined(RT_KLIBC_USING_LIBC_STRCPY) || \ + defined(RT_KLIBC_USING_LIBC_STRNCMP) || \ + defined(RT_KLIBC_USING_LIBC_STRCMP) || \ + defined(RT_KLIBC_USING_LIBC_STRLEN) #include -#endif /* RT_KLIBC_USING_STDLIB */ +#endif /** * @brief This function will set the content of memory to specified value. @@ -25,11 +35,12 @@ * * @return The address of source memory. */ -rt_weak void *rt_memset(void *s, int c, rt_ubase_t count) +#ifndef RT_KLIBC_USING_USER_MEMSET +void *rt_memset(void *s, int c, rt_ubase_t count) { -#if defined(RT_KLIBC_USING_STDLIB_MEMORY) +#if defined(RT_KLIBC_USING_LIBC_MEMSET) return memset(s, c, count); -#elif defined(RT_KLIBC_USING_TINY_SIZE) +#elif defined(RT_KLIBC_USING_TINY_MEMSET) char *xs = (char *)s; while (count--) @@ -37,6 +48,7 @@ rt_weak void *rt_memset(void *s, int c, rt_ubase_t count) return s; #else + #define LBLOCKSIZE (sizeof(rt_ubase_t)) #define UNALIGNED(X) ((long)X & (LBLOCKSIZE - 1)) #define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE) @@ -92,8 +104,9 @@ rt_weak void *rt_memset(void *s, int c, rt_ubase_t count) #undef LBLOCKSIZE #undef UNALIGNED #undef TOO_SMALL -#endif /* RT_KLIBC_USING_STDLIB_MEMORY */ +#endif /* RT_KLIBC_USING_LIBC_MEMSET */ } +#endif /* RT_KLIBC_USING_USER_MEMSET */ RTM_EXPORT(rt_memset); /** @@ -107,11 +120,12 @@ RTM_EXPORT(rt_memset); * * @return The address of destination memory */ -rt_weak void *rt_memcpy(void *dst, const void *src, rt_ubase_t count) +#ifndef RT_KLIBC_USING_USER_MEMCPY +void *rt_memcpy(void *dst, const void *src, rt_ubase_t count) { -#if defined(RT_KLIBC_USING_STDLIB_MEMORY) +#if defined(RT_KLIBC_USING_LIBC_MEMCPY) return memcpy(dst, src, count); -#elif defined(RT_KLIBC_USING_TINY_SIZE) +#elif defined(RT_KLIBC_USING_TINY_MEMCPY) char *tmp = (char *)dst, *s = (char *)src; rt_ubase_t len = 0; @@ -178,8 +192,9 @@ rt_weak void *rt_memcpy(void *dst, const void *src, rt_ubase_t count) #undef BIGBLOCKSIZE #undef LITTLEBLOCKSIZE #undef TOO_SMALL -#endif /* RT_KLIBC_USING_STDLIB_MEMORY */ +#endif /* RT_KLIBC_USING_LIBC_MEMCPY */ } +#endif /* RT_KLIBC_USING_USER_MEMCPY */ RTM_EXPORT(rt_memcpy); /** @@ -195,9 +210,10 @@ RTM_EXPORT(rt_memcpy); * * @return The address of destination memory. */ +#ifndef RT_KLIBC_USING_USER_MEMMOVE void *rt_memmove(void *dest, const void *src, rt_size_t n) { -#ifdef RT_KLIBC_USING_STDLIB_MEMORY +#ifdef RT_KLIBC_USING_LIBC_MEMMOVE return memmove(dest, src, n); #else char *tmp = (char *)dest, *s = (char *)src; @@ -217,8 +233,9 @@ void *rt_memmove(void *dest, const void *src, rt_size_t n) } return dest; -#endif /* RT_KLIBC_USING_STDLIB_MEMORY */ +#endif /* RT_KLIBC_USING_LIBC_MEMMOVE */ } +#endif /* RT_KLIBC_USING_USER_MEMMOVE */ RTM_EXPORT(rt_memmove); /** @@ -235,9 +252,10 @@ RTM_EXPORT(rt_memmove); * If the result > 0, cs is greater than ct. * If the result = 0, cs is equal to ct. */ +#ifndef RT_KLIBC_USING_USER_MEMCMP rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_size_t count) { -#ifdef RT_KLIBC_USING_STDLIB_MEMORY +#ifdef RT_KLIBC_USING_LIBC_MEMCMP return memcmp(cs, ct, count); #else const unsigned char *su1 = RT_NULL, *su2 = RT_NULL; @@ -248,8 +266,9 @@ rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_size_t count) break; return res; -#endif /* RT_KLIBC_USING_STDLIB_MEMORY */ +#endif /* RT_KLIBC_USING_LIBC_MEMCMP */ } +#endif /* RT_KLIBC_USING_USER_MEMCMP */ RTM_EXPORT(rt_memcmp); /** @@ -262,9 +281,10 @@ RTM_EXPORT(rt_memcmp); * * @return The first occurrence of a s2 in s1, or RT_NULL if no found. */ +#ifndef RT_KLIBC_USING_USER_STRSTR char *rt_strstr(const char *s1, const char *s2) { -#ifdef RT_KLIBC_USING_STDLIB +#ifdef RT_KLIBC_USING_LIBC_STRSTR return strstr(s1, s2); #else int l1 = 0, l2 = 0; @@ -288,8 +308,9 @@ char *rt_strstr(const char *s1, const char *s2) } return RT_NULL; -#endif /* RT_KLIBC_USING_STDLIB */ +#endif /* RT_KLIBC_USING_LIBC_STRSTR */ } +#endif /* RT_KLIBC_USING_USER_STRSTR */ RTM_EXPORT(rt_strstr); /** @@ -304,6 +325,7 @@ RTM_EXPORT(rt_strstr); * If the result > 0, a is greater than a. * If the result = 0, a is equal to a. */ +#ifndef RT_KLIBC_USING_USER_STRCASECMP rt_int32_t rt_strcasecmp(const char *a, const char *b) { int ca = 0, cb = 0; @@ -321,6 +343,7 @@ rt_int32_t rt_strcasecmp(const char *a, const char *b) return ca - cb; } +#endif /* RT_KLIBC_USING_USER_STRCASECMP */ RTM_EXPORT(rt_strcasecmp); /** @@ -334,9 +357,10 @@ RTM_EXPORT(rt_strcasecmp); * * @return The address where the copied content is stored. */ +#ifndef RT_KLIBC_USING_USER_STRNCPY char *rt_strncpy(char *dst, const char *src, rt_size_t n) { -#ifdef RT_KLIBC_USING_STDLIB +#ifdef RT_KLIBC_USING_LIBC_STRNCPY return strncpy(dst, src, n); #else if (n != 0) @@ -360,8 +384,9 @@ char *rt_strncpy(char *dst, const char *src, rt_size_t n) } return (dst); -#endif /* RT_KLIBC_USING_STDLIB */ +#endif /* RT_KLIBC_USING_LIBC_STRNCPY */ } +#endif /* RT_KLIBC_USING_USER_STRNCPY */ RTM_EXPORT(rt_strncpy); /** @@ -373,9 +398,10 @@ RTM_EXPORT(rt_strncpy); * * @return The address where the copied content is stored. */ +#ifndef RT_KLIBC_USING_USER_STRCPY char *rt_strcpy(char *dst, const char *src) { -#ifdef RT_KLIBC_USING_STDLIB +#ifdef RT_KLIBC_USING_LIBC_STRCPY return strcpy(dst, src); #else char *dest = dst; @@ -389,8 +415,9 @@ char *rt_strcpy(char *dst, const char *src) *dst = '\0'; return dest; -#endif /* RT_KLIBC_USING_STDLIB */ +#endif /* RT_KLIBC_USING_LIBC_STRCPY */ } +#endif /* RT_KLIBC_USING_USER_STRCPY */ RTM_EXPORT(rt_strcpy); /** @@ -407,9 +434,10 @@ RTM_EXPORT(rt_strcpy); * If the result > 0, cs is greater than ct. * If the result = 0, cs is equal to ct. */ +#ifndef RT_KLIBC_USING_USER_STRNCMP rt_int32_t rt_strncmp(const char *cs, const char *ct, rt_size_t count) { -#ifdef RT_KLIBC_USING_STDLIB +#ifdef RT_KLIBC_USING_LIBC_STRNCMP return strncmp(cs, ct, count); #else signed char res = 0; @@ -425,8 +453,9 @@ rt_int32_t rt_strncmp(const char *cs, const char *ct, rt_size_t count) } return res; -#endif /* RT_KLIBC_USING_STDLIB */ +#endif /* RT_KLIBC_USING_LIBC_STRNCMP */ } +#endif /* RT_KLIBC_USING_USER_STRNCMP */ RTM_EXPORT(rt_strncmp); /** @@ -441,9 +470,10 @@ RTM_EXPORT(rt_strncmp); * If the result > 0, cs is greater than ct. * If the result = 0, cs is equal to ct. */ +#ifndef RT_KLIBC_USING_USER_STRCMP rt_int32_t rt_strcmp(const char *cs, const char *ct) { -#ifdef RT_KLIBC_USING_STDLIB +#ifdef RT_KLIBC_USING_LIBC_STRCMP return strcmp(cs, ct); #else while (*cs && *cs == *ct) @@ -453,8 +483,9 @@ rt_int32_t rt_strcmp(const char *cs, const char *ct) } return (*cs - *ct); -#endif /* RT_KLIBC_USING_STDLIB */ +#endif /* RT_KLIBC_USING_LIBC_STRCMP */ } +#endif /* RT_KLIBC_USING_USER_STRCMP */ RTM_EXPORT(rt_strcmp); /** @@ -465,16 +496,18 @@ RTM_EXPORT(rt_strcmp); * * @return The length of string. */ +#ifndef RT_KLIBC_USING_USER_STRLEN rt_size_t rt_strlen(const char *s) { -#ifdef RT_KLIBC_USING_STDLIB +#ifdef RT_KLIBC_USING_LIBC_STRLEN return strlen(s); #else const char *sc = RT_NULL; for (sc = s; *sc != '\0'; ++sc); return sc - s; -#endif /* RT_KLIBC_USING_STDLIB */ +#endif /* RT_KLIBC_USING_LIBC_STRLEN */ } +#endif /* RT_KLIBC_USING_USER_STRLEN */ RTM_EXPORT(rt_strlen); /** @@ -490,12 +523,14 @@ RTM_EXPORT(rt_strlen); * * @return The length of string. */ +#ifndef RT_KLIBC_USING_USER_STRNLEN rt_size_t rt_strnlen(const char *s, rt_ubase_t maxlen) { const char *sc; for (sc = s; *sc != '\0' && (rt_ubase_t)(sc - s) < maxlen; ++sc); return sc - s; } +#endif /* RT_KLIBC_USING_USER_STRNLEN */ RTM_EXPORT(rt_strnlen); #ifdef RT_USING_HEAP diff --git a/src/klibc/rt_vsnprintf_std.c b/src/klibc/rt_vsnprintf_std.c index 520061d2779..583cfb715be 100644 --- a/src/klibc/rt_vsnprintf_std.c +++ b/src/klibc/rt_vsnprintf_std.c @@ -49,9 +49,6 @@ */ #include - -#ifdef RT_KLIBC_USING_VSNPRINTF_STANDARD - #include #include #include @@ -1352,5 +1349,3 @@ int rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args) output_gadget_t gadget = buffer_gadget(buf, size); return vsnprintf_impl(&gadget, fmt, args); } - -#endif /* RT_KLIBC_USING_VSNPRINTF_STANDARD */ diff --git a/src/klibc/rt_vsnprintf_tiny.c b/src/klibc/rt_vsnprintf_tiny.c index a91e1498d5e..75c89512d91 100644 --- a/src/klibc/rt_vsnprintf_tiny.c +++ b/src/klibc/rt_vsnprintf_tiny.c @@ -10,8 +10,6 @@ #include -#ifndef RT_KLIBC_USING_VSNPRINTF_STANDARD - #define _ISDIGIT(c) ((unsigned)((c) - '0') < 10) /** @@ -608,9 +606,6 @@ int rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args) */ return str - buf; } -RTM_EXPORT(rt_vsnprintf); #if (defined(__GNUC__) && !defined(__ARMCC_VERSION) /* GCC */) && (__GNUC__ >= 7) #pragma GCC diagnostic pop /* ignored "-Wimplicit-fallthrough" */ #endif /* (defined(__GNUC__) && !defined(__ARMCC_VERSION)) && (__GNUC__ >= 7 */ - -#endif /* !RT_KLIBC_USING_VSNPRINTF_STANDARD */