From 8bee7a0c232f5df03e620b41cfc03347c1acfbf1 Mon Sep 17 00:00:00 2001 From: "Man, Jianting (Meco)" <920369182@qq.com> Date: Sun, 19 Jun 2022 09:56:24 -0400 Subject: [libc] implement extension standard C functions (#6044) * implement extension standard C functions --- components/libc/compilers/common/SConscript | 2 +- components/libc/compilers/common/cctype.c | 25 + .../libc/compilers/common/compiler_private.h | 17 - components/libc/compilers/common/cstdio.c | 85 ++ components/libc/compilers/common/cstdlib.c | 144 +++ components/libc/compilers/common/cstring.c | 223 +++++ components/libc/compilers/common/ctime.c | 1038 ++++++++++++++++++++ components/libc/compilers/common/cwchar.c | 140 +++ components/libc/compilers/common/dirent.h | 71 -- .../compilers/common/extension/fcntl/msvc/fcntl.h | 8 +- .../compilers/common/extension/fcntl/octal/fcntl.h | 2 +- .../libc/compilers/common/extension/sys/errno.h | 2 +- .../libc/compilers/common/extension/sys/stat.h | 2 +- .../libc/compilers/common/extension/sys/types.h | 2 +- .../compilers/common/include/compiler_private.h | 17 + components/libc/compilers/common/include/dirent.h | 71 ++ .../libc/compilers/common/include/posix/ctype.h | 31 + .../libc/compilers/common/include/posix/stdio.h | 28 + .../libc/compilers/common/include/posix/stdlib.h | 32 + .../libc/compilers/common/include/posix/string.h | 43 + .../libc/compilers/common/include/posix/wchar.h | 27 + .../libc/compilers/common/include/sys/ioctl.h | 278 ++++++ .../libc/compilers/common/include/sys/select.h | 60 ++ .../libc/compilers/common/include/sys/signal.h | 232 +++++ .../libc/compilers/common/include/sys/statfs.h | 33 + .../libc/compilers/common/include/sys/time.h | 155 +++ .../libc/compilers/common/include/sys/unistd.h | 57 ++ components/libc/compilers/common/include/sys/vfs.h | 16 + components/libc/compilers/common/include/unistd.h | 10 + components/libc/compilers/common/stdlib.c | 46 - components/libc/compilers/common/sys/ioctl.h | 278 ------ components/libc/compilers/common/sys/select.h | 60 -- components/libc/compilers/common/sys/signal.h | 232 ----- components/libc/compilers/common/sys/statfs.h | 33 - components/libc/compilers/common/sys/time.h | 155 --- components/libc/compilers/common/sys/unistd.h | 57 -- components/libc/compilers/common/sys/vfs.h | 16 - components/libc/compilers/common/time.c | 1007 ------------------- components/libc/compilers/common/unistd.h | 10 - 39 files changed, 2754 insertions(+), 1991 deletions(-) create mode 100644 components/libc/compilers/common/cctype.c delete mode 100644 components/libc/compilers/common/compiler_private.h create mode 100644 components/libc/compilers/common/cstdio.c create mode 100644 components/libc/compilers/common/cstdlib.c create mode 100644 components/libc/compilers/common/cstring.c create mode 100644 components/libc/compilers/common/ctime.c create mode 100644 components/libc/compilers/common/cwchar.c delete mode 100644 components/libc/compilers/common/dirent.h create mode 100644 components/libc/compilers/common/include/compiler_private.h create mode 100644 components/libc/compilers/common/include/dirent.h create mode 100644 components/libc/compilers/common/include/posix/ctype.h create mode 100644 components/libc/compilers/common/include/posix/stdio.h create mode 100644 components/libc/compilers/common/include/posix/stdlib.h create mode 100644 components/libc/compilers/common/include/posix/string.h create mode 100644 components/libc/compilers/common/include/posix/wchar.h create mode 100644 components/libc/compilers/common/include/sys/ioctl.h create mode 100644 components/libc/compilers/common/include/sys/select.h create mode 100644 components/libc/compilers/common/include/sys/signal.h create mode 100644 components/libc/compilers/common/include/sys/statfs.h create mode 100644 components/libc/compilers/common/include/sys/time.h create mode 100644 components/libc/compilers/common/include/sys/unistd.h create mode 100644 components/libc/compilers/common/include/sys/vfs.h create mode 100644 components/libc/compilers/common/include/unistd.h delete mode 100644 components/libc/compilers/common/stdlib.c delete mode 100644 components/libc/compilers/common/sys/ioctl.h delete mode 100644 components/libc/compilers/common/sys/select.h delete mode 100644 components/libc/compilers/common/sys/signal.h delete mode 100644 components/libc/compilers/common/sys/statfs.h delete mode 100644 components/libc/compilers/common/sys/time.h delete mode 100644 components/libc/compilers/common/sys/unistd.h delete mode 100644 components/libc/compilers/common/sys/vfs.h delete mode 100644 components/libc/compilers/common/time.c delete mode 100644 components/libc/compilers/common/unistd.h diff --git a/components/libc/compilers/common/SConscript b/components/libc/compilers/common/SConscript index 1a341f5ad1..fda7c6bf61 100644 --- a/components/libc/compilers/common/SConscript +++ b/components/libc/compilers/common/SConscript @@ -4,7 +4,7 @@ Import('rtconfig') src = [] cwd = GetCurrentDir() group = [] -CPPPATH = [cwd] +CPPPATH = [cwd + '/include'] CPPDEFINES = [] if rtconfig.PLATFORM in ['armcc', 'armclang']: diff --git a/components/libc/compilers/common/cctype.c b/components/libc/compilers/common/cctype.c new file mode 100644 index 0000000000..ddcff1b39d --- /dev/null +++ b/components/libc/compilers/common/cctype.c @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-06-07 Meco Man The first version. + */ + +#include "posix/ctype.h" + +#ifndef isascii /* some toolchain use macro to define it */ +int isascii(int c) +{ + return c >= 0x00 && c <= 0x7f; +} +#endif + +#ifndef toascii +int toascii(int c) +{ + return (c)&0177; +} +#endif diff --git a/components/libc/compilers/common/compiler_private.h b/components/libc/compilers/common/compiler_private.h deleted file mode 100644 index 7f6b42e837..0000000000 --- a/components/libc/compilers/common/compiler_private.h +++ /dev/null @@ -1,17 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2021-12-26 Meco Man First Version - */ - -#ifndef __COMPILER_PRIVATE_H__ -#define __COMPILER_PRIVATE_H__ - -#define _WARNING_WITHOUT_FS "Please enable RT_USING_POSIX_FS" -#define _WARNING_WITHOUT_STDIO "Please enable RT_USING_POSIX_FS and RT_USING_POSIX_STDIO" - -#endif /* __COMPILER_PRIVATE_H__ */ diff --git a/components/libc/compilers/common/cstdio.c b/components/libc/compilers/common/cstdio.c new file mode 100644 index 0000000000..3dffe55aa7 --- /dev/null +++ b/components/libc/compilers/common/cstdio.c @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2014-05-22 ivanrad implement getline + */ + +#include "posix/stdio.h" +#include +#include +#include + +ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream) +{ + char *cur_pos, *new_lineptr; + size_t new_lineptr_len; + int c; + + if (lineptr == NULL || n == NULL || stream == NULL) + { + errno = EINVAL; + return -1; + } + + if (*lineptr == NULL) + { + *n = 128; /* init len */ + if ((*lineptr = (char *)malloc(*n)) == NULL) + { + errno = ENOMEM; + return -1; + } + } + + cur_pos = *lineptr; + for (;;) + { + c = getc(stream); + + if (ferror(stream) || (c == EOF && cur_pos == *lineptr)) + return -1; + + if (c == EOF) + break; + + if ((*lineptr + *n - cur_pos) < 2) + { + if (LONG_MAX / 2 < *n) + { +#ifdef EOVERFLOW + errno = EOVERFLOW; +#else + errno = ERANGE; /* no EOVERFLOW defined */ +#endif + return -1; + } + new_lineptr_len = *n * 2; + + if ((new_lineptr = (char *)realloc(*lineptr, new_lineptr_len)) == NULL) + { + errno = ENOMEM; + return -1; + } + cur_pos = new_lineptr + (cur_pos - *lineptr); + *lineptr = new_lineptr; + *n = new_lineptr_len; + } + + *cur_pos++ = (char)c; + + if (c == delim) + break; + } + + *cur_pos = '\0'; + return (ssize_t)(cur_pos - *lineptr); +} + +ssize_t getline(char **lineptr, size_t *n, FILE *stream) +{ + return getdelim(lineptr, n, '\n', stream); +} diff --git a/components/libc/compilers/common/cstdlib.c b/components/libc/compilers/common/cstdlib.c new file mode 100644 index 0000000000..9d1667b5d3 --- /dev/null +++ b/components/libc/compilers/common/cstdlib.c @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-02-15 Meco Man first version + */ + +#include + +#define DBG_TAG "stdlib" +#define DBG_LVL DBG_INFO +#include + +void __rt_libc_exit(int status) +{ + rt_thread_t self = rt_thread_self(); + + if (self != RT_NULL) + { +#ifdef RT_USING_PTHREADS + extern void pthread_exit(void *value); + pthread_exit((void *)status); +#else + LOG_E("thread:%s exit:%d!", self->name, status); + rt_thread_control(self, RT_THREAD_CTRL_CLOSE, RT_NULL); +#endif + } +} + +#ifdef RT_USING_MSH +int system(const char *command) +{ + extern int msh_exec(char *cmd, rt_size_t length); + + if (command) + { + msh_exec((char *)command, rt_strlen(command)); + } + + return 0; +} +RTM_EXPORT(system); +#endif /* RT_USING_MSH */ + +char *ltoa(long value, char *string, int radix) +{ + char tmp[33]; + char *tp = tmp; + long i; + unsigned long v; + int sign; + char *sp; + + if (string == NULL) + { + return 0 ; + } + + if (radix > 36 || radix <= 1) + { + return 0 ; + } + + sign = (radix == 10 && value < 0); + if (sign) + { + v = -value; + } + else + { + v = (unsigned long)value; + } + + while (v || tp == tmp) + { + i = v % radix; + v = v / radix; + if (i < 10) + *tp++ = i+'0'; + else + *tp++ = i + 'a' - 10; + } + + sp = string; + + if (sign) + *sp++ = '-'; + while (tp > tmp) + *sp++ = *--tp; + *sp = 0; + + return string; +} + +char *itoa(int value, char *string, int radix) +{ + return ltoa(value, string, radix) ; +} + + +char *ultoa(unsigned long value, char *string, int radix) +{ + char tmp[33]; + char *tp = tmp; + long i; + unsigned long v = value; + char *sp; + + if (string == NULL) + { + return 0; + } + + if (radix > 36 || radix <= 1) + { + return 0; + } + + while (v || tp == tmp) + { + i = v % radix; + v = v / radix; + if (i < 10) + *tp++ = i+'0'; + else + *tp++ = i + 'a' - 10; + } + + sp = string; + + while (tp > tmp) + *sp++ = *--tp; + *sp = 0; + + return string; +} + +char *utoa(unsigned value, char *string, int radix) +{ + return ultoa(value, string, radix) ; +} diff --git a/components/libc/compilers/common/cstring.c b/components/libc/compilers/common/cstring.c new file mode 100644 index 0000000000..dec1213d79 --- /dev/null +++ b/components/libc/compilers/common/cstring.c @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-01-12 Meco Man The first version. + */ + +#include "posix/string.h" +#include +#include +#include + +/** + * @brief erases the data in the n bytes of the memory starting at the + * location pointed to by s, by writing zeros (bytes containing '\0') to that area. + * + * @note The bzero() function is deprecated (marked as LEGACY in POSIX. 1-2001). + */ +void bzero(void* s, size_t n) +{ + rt_memset(s, 0, n); +} + +void bcopy(const void* src, void* dest, size_t n) +{ + rt_memcpy(dest, src, n); +} + +int bcmp(const void* s1, const void* s2, size_t n) +{ + return rt_memcmp(s1, s2, n); +} + +void explicit_bzero(void* s, size_t n) +{ + volatile char* vs = (volatile char*)s; + while (n) + { + *vs++ = 0; + n--; + } +} + +char* index(const char* s, int c) +{ + return strchr(s, c); +} + +char* rindex(const char* s, int c) +{ + return strrchr(s, c); +} + +int ffs(int i) +{ + int bit; + + if (0 == i) + return 0; + + for (bit = 1; !(i & 1); ++bit) + i >>= 1; + return bit; +} + +int ffsl(long i) +{ + int bit; + + if (0 == i) + return 0; + + for (bit = 1; !(i & 1); ++bit) + i >>= 1; + return bit; +} + +int ffsll(long long i) +{ + int bit; + + if (0 == i) + return 0; + + for (bit = 1; !(i & 1); ++bit) + i >>= 1; + return bit; +} + +/** + * @brief The memchr() function scans the initial n bytes of the memory area pointed to + * by s for the first instance of c. Both c and the bytes of the memory area + * pointed to by s are interpreted as unsigned char. + * + * @note This function is GNU extension, available since glibc 2.1.91. + */ +void* memrchr(const void* ptr, int ch, size_t pos) +{ + char* end = (char*)ptr + pos - 1; + while (end != ptr) + { + if (*end == ch) + return end; + end--; + } + return (*end == ch) ? (end) : (NULL); +} + +size_t strnlen(const char *s, size_t maxlen) +{ + const char *sc; + for (sc = s; maxlen != 0 && *sc != '\0'; maxlen--, ++sc); + return sc - s; +} + +char* strchrnul(const char* s, int c) +{ + while (*s != '\0' && *s != c) + s++; + return (char*)s; +} + +int strcasecmp(const char* s1, const char* s2) +{ + const unsigned char* u1 = (const unsigned char*)s1; + const unsigned char* u2 = (const unsigned char*)s2; + int result; + + while ((result = tolower(*u1) - tolower(*u2)) == 0 && *u1 != 0) + { + u1++; + u2++; + } + + return result; +} + +int strncasecmp(const char* s1, const char* s2, size_t n) +{ + const unsigned char* u1 = (const unsigned char*)s1; + const unsigned char* u2 = (const unsigned char*)s2; + int result; + + for (; n != 0; n--) + { + result = tolower(*u1) - tolower(*u2); + if (result) + return result; + if (*u1 == 0) + return 0; + u1++; + u2++; + } + return 0; +} + +char *strdup(const char *s) +{ + char *news = (char *)malloc(strlen(s) + 1); + + if (news) + { + strcpy(news, s); + } + + return news; +} + +char *strndup(const char *s, size_t size) +{ + size_t nsize = strnlen(s, size); + char *news = (char *)malloc(nsize + 1); + if (news) + { + rt_memcpy(news, s, nsize); + news[nsize] = '\0'; + } + + return news; +} + +char *strtok_r(char *str, const char *delim, char **saveptr) +{ + char *pbegin; + char *pend = NULL; + + if (str) + { + pbegin = str; + } + else if (saveptr && *saveptr) + { + pbegin = *saveptr; + } + else + { + return NULL; + } + + for (;*pbegin && strchr(delim, *pbegin) != NULL; pbegin++); + + if (!*pbegin) + { + return NULL; + } + + for (pend = pbegin + 1; *pend && strchr(delim, *pend) == NULL; pend++); + + if (*pend) + { + *pend++ = '\0'; + } + + if (saveptr) + { + *saveptr = pend; + } + + return pbegin; +} diff --git a/components/libc/compilers/common/ctime.c b/components/libc/compilers/common/ctime.c new file mode 100644 index 0000000000..6cef1e222d --- /dev/null +++ b/components/libc/compilers/common/ctime.c @@ -0,0 +1,1038 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2019-08-21 zhangjun copy from minilibc + * 2020-09-07 Meco Man combine gcc armcc iccarm + * 2021-02-05 Meco Man add timegm() + * 2021-02-07 Meco Man fixed gettimeofday() + * 2021-02-08 Meco Man add settimeofday() stime() + * 2021-02-10 Meco Man add ctime_r() and re-implement ctime() + * 2021-02-11 Meco Man fix bug #3183 - align days[] and months[] to 4 bytes + * 2021-02-12 Meco Man add errno + * 2012-12-08 Bernard fix the issue of _timevalue.tv_usec initialization, + * which found by Rob + * 2021-02-12 Meco Man move all of the functions located in to this file + * 2021-03-15 Meco Man fixed a bug of leaking memory in asctime() + * 2021-05-01 Meco Man support fixed timezone + * 2021-07-21 Meco Man implement that change/set timezone APIs + */ + +#include "sys/time.h" +#include +#include +#include +#include +#ifdef RT_USING_POSIX_DELAY +#include +#endif +#ifdef RT_USING_RTC +#include +#endif + +#define DBG_TAG "time" +#define DBG_LVL DBG_INFO +#include + +#define _WARNING_NO_RTC "Cannot find a RTC device!" + +/* seconds per day */ +#define SPD 24*60*60 + +/* days per month -- nonleap! */ +static const short __spm[13] = +{ + 0, + (31), + (31 + 28), + (31 + 28 + 31), + (31 + 28 + 31 + 30), + (31 + 28 + 31 + 30 + 31), + (31 + 28 + 31 + 30 + 31 + 30), + (31 + 28 + 31 + 30 + 31 + 30 + 31), + (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31), + (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30), + (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31), + (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30), + (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31), +}; + +ALIGN(4) static const char *days = "Sun Mon Tue Wed Thu Fri Sat "; +ALIGN(4) static const char *months = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec "; + +static int __isleap(int year) +{ + /* every fourth year is a leap year except for century years that are + * not divisible by 400. */ + /* return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)); */ + return (!(year % 4) && ((year % 100) || !(year % 400))); +} + +static void num2str(char *c, int i) +{ + c[0] = i / 10 + '0'; + c[1] = i % 10 + '0'; +} + +/** + * Get time from RTC device (without timezone, UTC+0) + * @param tv: struct timeval + * @return the operation status, RT_EOK on successful + */ +static rt_err_t get_timeval(struct timeval *tv) +{ +#ifdef RT_USING_RTC + static rt_device_t device = RT_NULL; + rt_err_t rst = -RT_ERROR; + + if (tv == RT_NULL) + return -RT_EINVAL; + + /* default is 0 */ + tv->tv_sec = 0; + tv->tv_usec = 0; + + /* optimization: find rtc device only first */ + if (device == RT_NULL) + { + device = rt_device_find("rtc"); + } + + /* read timestamp from RTC device */ + if (device != RT_NULL) + { + if (rt_device_open(device, 0) == RT_EOK) + { + rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &tv->tv_sec); + rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIMEVAL, tv); + rt_device_close(device); + } + } + else + { + LOG_W(_WARNING_NO_RTC); + return -RT_ENOSYS; + } + + return rst; + +#else + LOG_W(_WARNING_NO_RTC); + return -RT_ENOSYS; +#endif /* RT_USING_RTC */ +} + +/** + * Set time to RTC device (without timezone) + * @param tv: struct timeval + * @return the operation status, RT_EOK on successful + */ +static int set_timeval(struct timeval *tv) +{ +#ifdef RT_USING_RTC + static rt_device_t device = RT_NULL; + rt_err_t rst = -RT_ERROR; + + if (tv == RT_NULL) + return -RT_EINVAL; + + /* optimization: find rtc device only first */ + if (device == RT_NULL) + { + device = rt_device_find("rtc"); + } + + /* read timestamp from RTC device */ + if (device != RT_NULL) + { + if (rt_device_open(device, 0) == RT_EOK) + { + rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &tv->tv_sec); + rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIMEVAL, tv); + rt_device_close(device); + } + } + else + { + LOG_W(_WARNING_NO_RTC); + return -RT_ENOSYS; + } + + return rst; + +#else + LOG_W(_WARNING_NO_RTC); + return -RT_ENOSYS; +#endif /* RT_USING_RTC */ +} + +struct tm *gmtime_r(const time_t *timep, struct tm *r) +{ + time_t i; + time_t work = *timep % (SPD); + + if(timep == RT_NULL || r == RT_NULL) + { + rt_set_errno(EFAULT); + return RT_NULL; + } + + rt_memset(r, RT_NULL, sizeof(struct tm)); + + r->tm_sec = work % 60; + work /= 60; + r->tm_min = work % 60; + r->tm_hour = work / 60; + work = *timep / (SPD); + r->tm_wday = (4 + work) % 7; + for (i = 1970;; ++i) + { + time_t k = __isleap(i) ? 366 : 365; + if (work >= k) + work -= k; + else + break; + } + r->tm_year = i - 1900; + r->tm_yday = work; + + r->tm_mday = 1; + if (__isleap(i) && (work > 58)) + { + if (work == 59) + r->tm_mday = 2; /* 29.2. */ + work -= 1; + } + + for (i = 11; i && (__spm[i] > work); --i); + + r->tm_mon = i; + r->tm_mday += work - __spm[i]; + + r->tm_isdst = tz_is_dst(); + return r; +} +RTM_EXPORT(gmtime_r); + +struct tm* gmtime(const time_t* t) +{ + static struct tm tmp; + return gmtime_r(t, &tmp); +} +RTM_EXPORT(gmtime); + +struct tm* localtime_r(const time_t* t, struct tm* r) +{ + time_t local_tz; + + local_tz = *t + (time_t)tz_get() * 3600; + return gmtime_r(&local_tz, r); +} +RTM_EXPORT(localtime_r); + +struct tm* localtime(const time_t* t) +{ + static struct tm tmp; + return localtime_r(t, &tmp); +} +RTM_EXPORT(localtime); + +time_t mktime(struct tm * const t) +{ + time_t timestamp; + + timestamp = timegm(t); + timestamp = timestamp - 3600 * (time_t)tz_get(); + return timestamp; +} +RTM_EXPORT(mktime); + +char* asctime_r(const struct tm *t, char *buf) +{ + if(t == RT_NULL || buf == RT_NULL) + { + rt_set_errno(EFAULT); + return RT_NULL; + } + + rt_memset(buf, RT_NULL, 26); + + /* Checking input validity */ + if ((int)rt_strlen(days) <= (t->tm_wday << 2) || (int)rt_strlen(months) <= (t->tm_mon << 2)) + { + LOG_W("asctime_r: the input parameters exceeded the limit, please check it."); + *(int*) buf = *(int*) days; + *(int*) (buf + 4) = *(int*) months; + num2str(buf + 8, t->tm_mday); + if (buf[8] == '0') + buf[8] = ' '; + buf[10] = ' '; + num2str(buf + 11, t->tm_hour); + buf[13] = ':'; + num2str(buf + 14, t->tm_min); + buf[16] = ':'; + num2str(buf + 17, t->tm_sec); + buf[19] = ' '; + num2str(buf + 20, 2000 / 100); + num2str(buf + 22, 2000 % 100); + buf[24] = '\n'; + buf[25] = '\0'; + return buf; + } + + /* "Wed Jun 30 21:49:08 1993\n" */ + *(int*) buf = *(int*) (days + (t->tm_wday << 2)); + *(int*) (buf + 4) = *(int*) (months + (t->tm_mon << 2)); + num2str(buf + 8, t->tm_mday); + if (buf[8] == '0') + buf[8] = ' '; + buf[10] = ' '; + num2str(buf + 11, t->tm_hour); + buf[13] = ':'; + num2str(buf + 14, t->tm_min); + buf[16] = ':'; + num2str(buf + 17, t->tm_sec); + buf[19] = ' '; + num2str(buf + 20, (t->tm_year + 1900) / 100); + num2str(buf + 22, (t->tm_year + 1900) % 100); + buf[24] = '\n'; + buf[25] = '\0'; + return buf; +} +RTM_EXPORT(asctime_r); + +char* asctime(const struct tm *timeptr) +{ + static char buf[26]; + return asctime_r(timeptr, buf); +} +RTM_EXPORT(asctime); + +char *ctime_r(const time_t * tim_p, char * result) +{ + struct tm tm; + return asctime_r(localtime_r(tim_p, &tm), result); +} +RTM_EXPORT(ctime_r); + +char* ctime(const time_t *tim_p) +{ + return asctime(localtime(tim_p)); +} +RTM_EXPORT(ctime); + +double difftime(time_t time1, time_t time2) +{ + return (double)(time1 - time2); +} +RTM_EXPORT(difftime); + +RTM_EXPORT(strftime); /* inherent in the toolchain */ + +/** + * Returns the current time. + * + * @param time_t * t the timestamp pointer, if not used, keep NULL. + * + * @return The value ((time_t)-1) is returned if the calendar time is not available. + * If timer is not a NULL pointer, the return value is also stored in timer. + * + */ +RT_WEAK time_t time(time_t *t) +{ + struct timeval now; + + if(get_timeval(&now) == RT_EOK) + { + if (t) + { + *t = now.tv_sec; + } + return now.tv_sec; + } + else + { + rt_set_errno(EFAULT); + return ((time_t)-1); + } +} +RTM_EXPORT(time); + +RT_WEAK clock_t clock(void) +{ + return rt_tick_get(); +} +RTM_EXPORT(clock); + +int stime(const time_t *t) +{ + struct timeval tv; + + if (t == RT_NULL) + { + rt_set_errno(EFAULT); + return -1; + } + + tv.tv_sec = *t; + if (set_timeval(&tv) == RT_EOK) + { + return 0; + } + else + { + rt_set_errno(EFAULT); + return -1; + } +} +RTM_EXPORT(stime); + +time_t timegm(struct tm * const t) +{ + time_t day; + time_t i; + time_t years; + + if(t == RT_NULL) + { + rt_set_errno(EFAULT); + return (time_t)-1; + } + + years = (time_t)t->tm_year - 70; + if (t->tm_sec > 60) /* seconds after the minute - [0, 60] including leap second */ + { + t->tm_min += t->tm_sec / 60; + t->tm_sec %= 60; + } + if (t->tm_min >= 60) /* minutes after the hour - [0, 59] */ + { + t->tm_hour += t->tm_min / 60; + t->tm_min %= 60; + } + if (t->tm_hour >= 24) /* hours since midnight - [0, 23] */ + { + t->tm_mday += t->tm_hour / 24; + t->tm_hour %= 24; + } + if (t->tm_mon >= 12) /* months since January - [0, 11] */ + { + t->tm_year += t->tm_mon / 12; + t->tm_mon %= 12; + } + while (t->tm_mday > __spm[1 + t->tm_mon]) + { + if (t->tm_mon == 1 && __isleap(t->tm_year + 1900)) + { + --t->tm_mday; + } + t->tm_mday -= __spm[t->tm_mon]; + ++t->tm_mon; + if (t->tm_mon > 11) + { + t->tm_mon = 0; + ++t->tm_year; + } + } + + if (t->tm_year < 70) + { + rt_set_errno(EINVAL); + return (time_t) -1; + } + + /* Days since 1970 is 365 * number of years + number of leap years since 1970 */ + day = years * 365 + (years + 1) / 4; + + /* After 2100 we have to substract 3 leap years for every 400 years + This is not intuitive. Most mktime implementations do not support + dates after 2059, anyway, so we might leave this out for it's + bloat. */ + if (years >= 131) + { + years -= 131; + years /= 100; + day -= (years >> 2) * 3 + 1; + if ((years &= 3) == 3) + years--; + day -= years; + } + + day += t->tm_yday = __spm[t->tm_mon] + t->tm_mday - 1 + + (__isleap(t->tm_year + 1900) & (t->tm_mon > 1)); + + /* day is now the number of days since 'Jan 1 1970' */ + i = 7; + t->tm_wday = (day + 4) % i; /* Sunday=0, Monday=1, ..., Saturday=6 */ + + i = 24; + day *= i; + i = 60; + return ((day + t->tm_hour) * i + t->tm_min) * i + t->tm_sec; +} +RTM_EXPORT(timegm); + +int gettimeofday(struct timeval *tv, struct timezone *tz) +{ + /* The use of the timezone structure is obsolete; + * the tz argument should normally be specified as NULL. + * The tz_dsttime field has never been used under Linux. + * Thus, the following is purely of historic interest. + */ + if(tz != RT_NULL) + { + tz->tz_dsttime = DST_NONE; + tz->tz_minuteswest = -(tz_get() * 60); + } + + if (tv != RT_NULL && get_timeval(tv) == RT_EOK) + { + return 0; + } + else + { + rt_set_errno(EINVAL); + return -1; + } +} +RTM_EXPORT(gettimeofday); + +int settimeofday(const struct timeval *tv, const struct timezone *tz) +{ + /* The use of the timezone structure is obsolete; + * the tz argument should normally be specified as NULL. + * The tz_dsttime field has never been used under Linux. + * Thus, the following is purely of historic interest. + */ + if (tv != RT_NULL + && tv->tv_usec >= 0 + && set_timeval((struct timeval *)tv) == RT_EOK) + { + return 0; + } + else + { + rt_set_errno(EINVAL); + return -1; + } +} +RTM_EXPORT(settimeofday); + +#ifdef RT_USING_POSIX_DELAY +int nanosleep(const struct timespec *rqtp, struct timespec *rmtp) +{ + sleep(rqtp->tv_sec); + ndelay(rqtp->tv_nsec); + return 0; +} +RTM_EXPORT(nanosleep); +#endif /* RT_USING_POSIX_DELAY */ + +#ifdef RT_USING_POSIX_CLOCK +#ifdef RT_USING_RTC +static volatile struct timeval _timevalue; +static int _rt_clock_time_system_init(void) +{ + rt_base_t level; + time_t time = 0; + rt_tick_t tick; + rt_device_t device; + + device = rt_device_find("rtc"); + if (device != RT_NULL) + { + /* get realtime seconds */ + if(rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time) == RT_EOK) + { + level = rt_hw_interrupt_disable(); + tick = rt_tick_get(); /* get tick */ + _timevalue.tv_usec = (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK; + _timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1; + rt_hw_interrupt_enable(level); + return 0; + } + } + + level = rt_hw_interrupt_disable(); + _timevalue.tv_usec = 0; + _timevalue.tv_sec = 0; + rt_hw_interrupt_enable(level); + + return -1; +} +INIT_COMPONENT_EXPORT(_rt_clock_time_system_init); +#endif /* RT_USING_RTC */ + +int clock_getres(clockid_t clockid, struct timespec *res) +{ +#ifndef RT_USING_RTC + LOG_W(_WARNING_NO_RTC); + return -1; +#else + int ret = 0; + + if (res == RT_NULL) + { + rt_set_errno(EFAULT); + return -1; + } + + switch (clockid) + { + case CLOCK_REALTIME: + res->tv_sec = 0; + res->tv_nsec = NANOSECOND_PER_SECOND/RT_TICK_PER_SECOND; + break; + +#ifdef RT_USING_CPUTIME + case CLOCK_CPUTIME_ID: + res->tv_sec = 0; + res->tv_nsec = clock_cpu_getres(); + break; +#endif + + default: + res->tv_sec = 0; + res->tv_nsec = 0; + ret = -1; + rt_set_errno(EINVAL); + break; + } + + return ret; +#endif /* RT_USING_RTC */ +} +RTM_EXPORT(clock_getres); + +int clock_gettime(clockid_t clockid, struct timespec *tp) +{ +#ifndef RT_USING_RTC + LOG_W(_WARNING_NO_RTC); + return -1; +#else + int ret = 0; + + if (tp == RT_NULL) + { + rt_set_errno(EFAULT); + return -1; + } + + switch (clockid) + { + case CLOCK_REALTIME: + { + int tick; + rt_base_t level; + + level = rt_hw_interrupt_disable(); + tick = rt_tick_get(); /* get tick */ + tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND; + tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000; + rt_hw_interrupt_enable(level); + } + break; + +#ifdef RT_USING_CPUTIME + case CLOCK_CPUTIME_ID: + { + float unit = 0; + long long cpu_tick; + + unit = clock_cpu_getres(); + cpu_tick = clock_cpu_gettime(); + + tp->tv_sec = ((long long)(cpu_tick * unit)) / NANOSECOND_PER_SECOND; + tp->tv_nsec = ((long long)(cpu_tick * unit)) % NANOSECOND_PER_SECOND; + } + break; +#endif + default: + tp->tv_sec = 0; + tp->tv_nsec = 0; + rt_set_errno(EINVAL); + ret = -1; + } + + return ret; +#endif /* RT_USING_RTC */ +} +RTM_EXPORT(clock_gettime); + +int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *rqtp, struct timespec *rmtp) +{ + if ((clockid != CLOCK_REALTIME) || (rqtp == RT_NULL)) + { + rt_set_errno(EINVAL); + return -1; + } + + return nanosleep(rqtp, rmtp); +} + +int clock_settime(clockid_t clockid, const struct timespec *tp) +{ +#ifndef RT_USING_RTC + LOG_W(_WARNING_NO_RTC); + return -1; +#else + rt_base_t level; + int second; + rt_tick_t tick; + rt_device_t device; + + if ((clockid != CLOCK_REALTIME) || (tp == RT_NULL)) + { + rt_set_errno(EFAULT); + return -1; + } + + /* get second */ + second = tp->tv_sec; + + level = rt_hw_interrupt_disable(); + tick = rt_tick_get(); /* get tick */ + /* update timevalue */ + _timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK; + _timevalue.tv_sec = second - tick/RT_TICK_PER_SECOND - 1; + rt_hw_interrupt_enable(level); + + /* update for RTC device */ + device = rt_device_find("rtc"); + if (device != RT_NULL) + { + /* set realtime seconds */ + if(rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &second) == RT_EOK) + { + return 0; + } + } + + return -1; +#endif /* RT_USING_RTC */ +} +RTM_EXPORT(clock_settime); + +int rt_timespec_to_tick(const struct timespec *time) +{ + int tick; + int nsecond, second; + struct timespec tp = {0}; + + RT_ASSERT(time != RT_NULL); + + tick = RT_WAITING_FOREVER; + if (time != NULL) + { + /* get current tp */ + clock_gettime(CLOCK_REALTIME, &tp); + + if ((time->tv_nsec - tp.tv_nsec) < 0) + { + nsecond = NANOSECOND_PER_SECOND - (tp.tv_nsec - time->tv_nsec); + second = time->tv_sec - tp.tv_sec - 1; + } + else + { + nsecond = time->tv_nsec - tp.tv_nsec; + second = time->tv_sec - tp.tv_sec; + } + + tick = second * RT_TICK_PER_SECOND + nsecond * RT_TICK_PER_SECOND / NANOSECOND_PER_SECOND; + if (tick < 0) tick = 0; + } + + return tick; +} +RTM_EXPORT(rt_timespec_to_tick); + +#endif /* RT_USING_POSIX_CLOCK */ + +#ifdef RT_USING_POSIX_TIMER + +#define ACTIVE 1 +#define NOT_ACTIVE 0 + +struct timer_obj +{ + struct rt_timer timer; + void (*sigev_notify_function)(union sigval val); + union sigval val; + struct timespec interval; /* Reload value */ + rt_uint32_t reload; /* Reload value in ms */ + rt_uint32_t status; +}; + +static void rtthread_timer_wrapper(void *timerobj) +{ + struct timer_obj *timer; + + timer = (struct timer_obj *)timerobj; + + if (timer->reload == 0U) + { + timer->status = NOT_ACTIVE; + } + + if(timer->sigev_notify_function != RT_NULL) + { + (timer->sigev_notify_function)(timer->val); + } +} + +/** + * @brief Create a per-process timer. + * + * This API does not accept SIGEV_THREAD as valid signal event notification + * type. + * + * See IEEE 1003.1 + */ +int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid) +{ + static int num = 0; + struct timer_obj *timer; + char timername[RT_NAME_MAX] = {0}; + + if (clockid != CLOCK_MONOTONIC || evp == NULL || + (evp->sigev_notify != SIGEV_NONE && + evp->sigev_notify != SIGEV_SIGNAL)) + { + rt_set_errno(EINVAL); + return -RT_ERROR; + } + + timer = rt_malloc(sizeof(struct timer_obj)); + if(timer == RT_NULL) + { + rt_set_errno(ENOMEM); + return -RT_ENOMEM; + } + + RT_ASSERT(evp->sigev_notify_function != RT_NULL); + rt_snprintf(timername, RT_NAME_MAX, "psx_tm%02d", num++); + num %= 100; + timer->sigev_notify_function = evp->sigev_notify_function; + timer->val = evp->sigev_value; + timer->interval.tv_sec = 0; + timer->interval.tv_nsec = 0; + timer->reload = 0U; + timer->status = NOT_ACTIVE; + + if (evp->sigev_notify == SIGEV_NONE) + { + rt_timer_init(&timer->timer, timername, RT_NULL, RT_NULL, 0, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); + } + else + { + rt_timer_init(&timer->timer, timername, rtthread_timer_wrapper, timer, 0, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); + } + + *timerid = (timer_t)timer; + + return RT_EOK; +} +RTM_EXPORT(timer_create); + +/** + * @brief Delete a per-process timer. + * + * See IEEE 1003.1 + */ +int timer_delete(timer_t timerid) +{ + struct timer_obj *timer = (struct timer_obj *)timerid; + + if (timer == RT_NULL) + { + rt_set_errno(EINVAL); + return -RT_ERROR; + } + + if (timer->status == ACTIVE) + { + timer->status = NOT_ACTIVE; + rt_timer_stop(&timer->timer); + } + + rt_free(timer); + + return RT_EOK; +} +RTM_EXPORT(timer_delete); + +/** + * + * Return the overrun count for the last timer expiration. + * It is subefficient to create a new structure to get overrun count. + **/ +int timer_getoverrun(timer_t timerid) +{ + rt_set_errno(ENOSYS); + return -RT_ERROR; +} + +/** + * @brief Get amount of time left for expiration on a per-process timer. + * + * See IEEE 1003.1 + */ +int timer_gettime(timer_t timerid, struct itimerspec *its) +{ + struct timer_obj *timer = (struct timer_obj *)timerid; + rt_tick_t remaining; + rt_uint32_t seconds, nanoseconds; + + if (timer == NULL) + { + rt_set_errno(EINVAL); + return -RT_ERROR; + } + + if (its == NULL) + { + rt_set_errno(EFAULT); + return -RT_ERROR; + } + + if (timer->status == ACTIVE) + { + rt_tick_t remain_tick; + + rt_timer_control(&timer->timer, RT_TIMER_CTRL_GET_REMAIN_TIME, &remain_tick); + + /* 'remain_tick' is minimum-unit in the RT-Thread' timer, + * so the seconds, nanoseconds will be calculated by 'remain_tick'. + */ + remaining = remain_tick - rt_tick_get(); + + /* calculate 'second' */ + seconds = remaining / RT_TICK_PER_SECOND; + + /* calculate 'nanosecond'; To avoid lost of accuracy, because "RT_TICK_PER_SECOND" maybe 100, 1000, 1024 and so on. + * + * remain_tick millisecond remain_tick * MILLISECOND_PER_SECOND + * ------------------------- = -------------------------- ---> millisecond = ------------------------------------------- + * RT_TICK_PER_SECOND MILLISECOND_PER_SECOND RT_TICK_PER_SECOND + * + * remain_tick * MILLISECOND_PER_SECOND remain_tick * MILLISECOND_PER_SECOND * MICROSECOND_PER_SECOND + * millisecond = ---------------------------------------- ---> nanosecond = ------------------------------------------------------------------- + * RT_TICK_PER_SECOND RT_TICK_PER_SECOND + * + */ + nanoseconds = (((remaining % RT_TICK_PER_SECOND) * MILLISECOND_PER_SECOND) * MICROSECOND_PER_SECOND) / RT_TICK_PER_SECOND ; + + its->it_value.tv_sec = (rt_int32_t)seconds; + its->it_value.tv_nsec = (rt_int32_t)nanoseconds; + } + else + { + /* Timer is disarmed */ + its->it_value.tv_sec = 0; + its->it_value.tv_nsec = 0; + } + + /* The interval last set by timer_settime() */ + its->it_interval = timer->interval; + return RT_EOK; +} +RTM_EXPORT(timer_gettime); + +/** + * @brief Sets expiration time of per-process timer. + * + * See IEEE 1003.1 + */ +int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, + struct itimerspec *ovalue) +{ + struct timer_obj *timer = (struct timer_obj *)timerid; + + if (timer == NULL || + value->it_interval.tv_nsec < 0 || + value->it_interval.tv_nsec >= NANOSECOND_PER_SECOND || + value->it_value.tv_nsec < 0 || + value->it_value.tv_nsec >= NANOSECOND_PER_SECOND) + { + rt_set_errno(EINVAL); + return -RT_ERROR; + } + + if (value == NULL || ovalue == NULL) + { + rt_set_errno(EFAULT); + return -RT_ERROR; + } + + /* Save time to expire and old reload value. */ + if (ovalue != NULL) + { + timer_gettime(timerid, ovalue); + } + + /* Stop the timer if the value is 0 */ + if ((value->it_value.tv_sec == 0) && (value->it_value.tv_nsec == 0)) + { + if (timer->status == ACTIVE) + { + rt_timer_stop(&timer->timer); + } + + timer->status = NOT_ACTIVE; + return RT_EOK; + } + + /* calculate timer period(tick); To avoid lost of accuracy, because "RT_TICK_PER_SECOND" maybe 100, 1000, 1024 and so on. + * + * tick nanosecond nanosecond * RT_TICK_PER_SECOND + * ------------------------- = -------------------------- ---> tick = ------------------------------------- + * RT_TICK_PER_SECOND NANOSECOND_PER_SECOND NANOSECOND_PER_SECOND + * + */ + timer->reload = (value->it_interval.tv_sec * RT_TICK_PER_SECOND) + (value->it_interval.tv_nsec * RT_TICK_PER_SECOND) / NANOSECOND_PER_SECOND; + timer->interval.tv_sec = value->it_interval.tv_sec; + timer->interval.tv_nsec = value->it_interval.tv_nsec; + + if (timer->status == ACTIVE) + { + rt_timer_stop(&timer->timer); + } + + timer->status = ACTIVE; + rt_timer_control(&timer->timer, RT_TIMER_CTRL_SET_TIME, (void *)timer->reload); + rt_timer_control(&timer->timer, RT_TIMER_CTRL_SET_PERIODIC, RT_NULL); + rt_timer_start(&timer->timer); + + return RT_EOK; +} +RTM_EXPORT(timer_settime); +#endif /* RT_USING_POSIX_TIMER */ + + +/* timezone */ +#ifndef RT_LIBC_DEFAULT_TIMEZONE +#define RT_LIBC_DEFAULT_TIMEZONE 8 +#endif + +static volatile int8_t _current_timezone = RT_LIBC_DEFAULT_TIMEZONE; + +void tz_set(int8_t tz) +{ + rt_base_t level; + level = rt_hw_interrupt_disable(); + _current_timezone = tz; + rt_hw_interrupt_enable(level); +} + +int8_t tz_get(void) +{ + return _current_timezone; +} + +int8_t tz_is_dst(void) +{ + return 0; +} diff --git a/components/libc/compilers/common/cwchar.c b/components/libc/compilers/common/cwchar.c new file mode 100644 index 0000000000..c808083331 --- /dev/null +++ b/components/libc/compilers/common/cwchar.c @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2014-01-01 mattn implement wcwidth + */ + +#include "posix/wchar.h" +#include + +struct interval +{ + long first; + long last; +}; + +static int bisearch(wchar_t ucs, const struct interval *table, int max) +{ + int min = 0; + int mid; + + if (ucs < table[0].first || ucs > table[max].last) + { + return 0; + } + + while (max >= min) + { + mid = (min + max) / 2; + if (ucs > table[mid].last) + { + min = mid + 1; + } + else if (ucs < table[mid].first) + { + max = mid - 1; + } + else + { + return 1; + } + } + + return 0; +} + +int wcwidth(wchar_t ucs) +{ + /* sorted list of non-overlapping intervals of non-spacing characters */ + static const struct interval combining[] = { + { 0x0300, 0x034E }, { 0x0360, 0x0362 }, { 0x0483, 0x0486 }, + { 0x0488, 0x0489 }, { 0x0591, 0x05A1 }, { 0x05A3, 0x05B9 }, + { 0x05BB, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 }, + { 0x05C4, 0x05C4 }, { 0x064B, 0x0655 }, { 0x0670, 0x0670 }, + { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, + { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A }, + { 0x07A6, 0x07B0 }, { 0x0901, 0x0902 }, { 0x093C, 0x093C }, + { 0x0941, 0x0948 }, { 0x094D, 0x094D }, { 0x0951, 0x0954 }, + { 0x0962, 0x0963 }, { 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, + { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, + { 0x0A02, 0x0A02 }, { 0x0A3C, 0x0A3C }, { 0x0A41, 0x0A42 }, + { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D }, { 0x0A70, 0x0A71 }, + { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, + { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD }, { 0x0B01, 0x0B01 }, + { 0x0B3C, 0x0B3C }, { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, + { 0x0B4D, 0x0B4D }, { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, + { 0x0BC0, 0x0BC0 }, { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, + { 0x0C46, 0x0C48 }, { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, + { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD }, + { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D }, { 0x0DCA, 0x0DCA }, + { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 }, { 0x0E31, 0x0E31 }, + { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E }, { 0x0EB1, 0x0EB1 }, + { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC }, { 0x0EC8, 0x0ECD }, + { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 }, { 0x0F37, 0x0F37 }, + { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E }, { 0x0F80, 0x0F84 }, + { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 }, { 0x0F99, 0x0FBC }, + { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 }, { 0x1032, 0x1032 }, + { 0x1036, 0x1037 }, { 0x1039, 0x1039 }, { 0x1058, 0x1059 }, + { 0x1160, 0x11FF }, { 0x17B7, 0x17BD }, { 0x17C6, 0x17C6 }, + { 0x17C9, 0x17D3 }, { 0x180B, 0x180E }, { 0x18A9, 0x18A9 }, + { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x206A, 0x206F }, + { 0x20D0, 0x20E3 }, { 0x302A, 0x302F }, { 0x3099, 0x309A }, + { 0xFB1E, 0xFB1E }, { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, + { 0xFFF9, 0xFFFB } + }; + + /* test for 8-bit control characters */ + if (ucs == 0) + { + return 0; + } + if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) + { + return -1; + } + + /* binary search in table of non-spacing characters */ + if (bisearch(ucs, combining, sizeof(combining) / sizeof(struct interval) - 1)) + { + return 0; + } + + return 1 + + (ucs >= 0x1100 && + (ucs <= 0x115f || /* Hangul Jamo init. consonants */ + (ucs >= 0x2e80 && ucs <= 0xa4cf && (ucs & ~0x0011) != 0x300a && + ucs != 0x303f) || /* CJK ... Yi */ + (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */ + (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */ + (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */ + (ucs >= 0xff00 && ucs <= 0xff5f) || /* Fullwidth Forms */ + (ucs >= 0xffe0 && ucs <= 0xffe6) // || + //#ifndef _WIN32 + // (ucs >= 0x20000 && ucs <= 0x2ffff) + //#else + // 0 + //#endif + )); +} + +int wcswidth(const wchar_t *pwcs, size_t n) +{ + int w, width = 0; + + for (;*pwcs && n-- > 0; pwcs++) + { + if ((w = wcwidth(*pwcs)) < 0) + { + return -1; + } + else + { + width += w; + } + } + return width; +} diff --git a/components/libc/compilers/common/dirent.h b/components/libc/compilers/common/dirent.h deleted file mode 100644 index a9c7ef856d..0000000000 --- a/components/libc/compilers/common/dirent.h +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - */ - -#ifndef __DIRENT_H__ -#define __DIRENT_H__ - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* -* dirent.h - format of directory entries - * Ref: http://www.opengroup.org/onlinepubs/009695399/basedefs/dirent.h.html - */ - -/* File types */ -#define FT_REGULAR 0 /* regular file */ -#define FT_SOCKET 1 /* socket file */ -#define FT_DIRECTORY 2 /* directory */ -#define FT_USER 3 /* user defined */ - -#define DT_UNKNOWN 0x00 -#define DT_REG 0x01 -#define DT_DIR 0x02 - -#ifndef HAVE_DIR_STRUCTURE -#define HAVE_DIR_STRUCTURE -typedef struct -{ - int fd; /* directory file */ - char buf[512]; - int num; - int cur; -}DIR; -#endif - -#ifndef HAVE_DIRENT_STRUCTURE -#define HAVE_DIRENT_STRUCTURE - -#define DIRENT_NAME_MAX 256 - -struct dirent -{ - rt_uint8_t d_type; /* The type of the file */ - rt_uint8_t d_namlen; /* The length of the not including the terminating null file name */ - rt_uint16_t d_reclen; /* length of this record */ - char d_name[DIRENT_NAME_MAX]; /* The null-terminated file name */ -}; -#endif - -int closedir(DIR *); -DIR *opendir(const char *); -struct dirent *readdir(DIR *); -int readdir_r(DIR *, struct dirent *, struct dirent **); -void rewinddir(DIR *); -void seekdir(DIR *, long int); -long telldir(DIR *); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/components/libc/compilers/common/extension/fcntl/msvc/fcntl.h b/components/libc/compilers/common/extension/fcntl/msvc/fcntl.h index 26a380119d..7c0b55bb25 100644 --- a/components/libc/compilers/common/extension/fcntl/msvc/fcntl.h +++ b/components/libc/compilers/common/extension/fcntl/msvc/fcntl.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2021, RT-Thread Development Team + * Copyright (c) 2006-2022, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * @@ -39,9 +39,9 @@ extern "C" { #define O_RANDOM 0x0010 /* file access is primarily random */ /* extension */ -#define O_ACCMODE 0x0003 /* mask for above modes, from 4.4BSD https://minnie.tuhs.org/cgi-bin/utree.pl?file=4.4BSD/usr/include/sys/fcntl.h */ -#define O_NONBLOCK 0x0004 /* non blocking I/O, from BSD apple https://opensource.apple.com/source/xnu/xnu-1228.0.2/bsd/sys/fcntl.h */ -#define O_DIRECTORY 0x200000 /* from Newlib */ +#define O_ACCMODE 0x0003 /* mask for above modes, from 4.4BSD https://minnie.tuhs.org/cgi-bin/utree.pl?file=4.4BSD/usr/include/sys/fcntl.h */ +#define O_NONBLOCK 0x0004 /* non blocking I/O, from BSD apple https://opensource.apple.com/source/xnu/xnu-1228.0.2/bsd/sys/fcntl.h */ +#define O_DIRECTORY 0x200000 /* from Newlib */ #define F_DUPFD 0 #define F_GETFD 1 diff --git a/components/libc/compilers/common/extension/fcntl/octal/fcntl.h b/components/libc/compilers/common/extension/fcntl/octal/fcntl.h index c3bf851523..117dcc432f 100644 --- a/components/libc/compilers/common/extension/fcntl/octal/fcntl.h +++ b/components/libc/compilers/common/extension/fcntl/octal/fcntl.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2021, RT-Thread Development Team + * Copyright (c) 2006-2022, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * diff --git a/components/libc/compilers/common/extension/sys/errno.h b/components/libc/compilers/common/extension/sys/errno.h index d53ce4b386..6c6727ca84 100644 --- a/components/libc/compilers/common/extension/sys/errno.h +++ b/components/libc/compilers/common/extension/sys/errno.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2021, RT-Thread Development Team + * Copyright (c) 2006-2022, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * diff --git a/components/libc/compilers/common/extension/sys/stat.h b/components/libc/compilers/common/extension/sys/stat.h index d0e6cc9140..2164ee512f 100644 --- a/components/libc/compilers/common/extension/sys/stat.h +++ b/components/libc/compilers/common/extension/sys/stat.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2021, RT-Thread Development Team + * Copyright (c) 2006-2022, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * diff --git a/components/libc/compilers/common/extension/sys/types.h b/components/libc/compilers/common/extension/sys/types.h index 1275803c37..71907a65db 100644 --- a/components/libc/compilers/common/extension/sys/types.h +++ b/components/libc/compilers/common/extension/sys/types.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2021, RT-Thread Development Team + * Copyright (c) 2006-2022, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * diff --git a/components/libc/compilers/common/include/compiler_private.h b/components/libc/compilers/common/include/compiler_private.h new file mode 100644 index 0000000000..8f150bf104 --- /dev/null +++ b/components/libc/compilers/common/include/compiler_private.h @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-12-26 Meco Man First Version + */ + +#ifndef __COMPILER_PRIVATE_H__ +#define __COMPILER_PRIVATE_H__ + +#define _WARNING_WITHOUT_FS "Please enable RT_USING_POSIX_FS" +#define _WARNING_WITHOUT_STDIO "Please enable RT_USING_POSIX_FS and RT_USING_POSIX_STDIO" + +#endif /* __COMPILER_PRIVATE_H__ */ diff --git a/components/libc/compilers/common/include/dirent.h b/components/libc/compilers/common/include/dirent.h new file mode 100644 index 0000000000..55ebcd2d01 --- /dev/null +++ b/components/libc/compilers/common/include/dirent.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + */ + +#ifndef __DIRENT_H__ +#define __DIRENT_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* +* dirent.h - format of directory entries + * Ref: http://www.opengroup.org/onlinepubs/009695399/basedefs/dirent.h.html + */ + +/* File types */ +#define FT_REGULAR 0 /* regular file */ +#define FT_SOCKET 1 /* socket file */ +#define FT_DIRECTORY 2 /* directory */ +#define FT_USER 3 /* user defined */ + +#define DT_UNKNOWN 0x00 +#define DT_REG 0x01 +#define DT_DIR 0x02 + +#ifndef HAVE_DIR_STRUCTURE +#define HAVE_DIR_STRUCTURE +typedef struct +{ + int fd; /* directory file */ + char buf[512]; + int num; + int cur; +}DIR; +#endif + +#ifndef HAVE_DIRENT_STRUCTURE +#define HAVE_DIRENT_STRUCTURE + +#define DIRENT_NAME_MAX 256 + +struct dirent +{ + rt_uint8_t d_type; /* The type of the file */ + rt_uint8_t d_namlen; /* The length of the not including the terminating null file name */ + rt_uint16_t d_reclen; /* length of this record */ + char d_name[DIRENT_NAME_MAX]; /* The null-terminated file name */ +}; +#endif + +int closedir(DIR *); +DIR *opendir(const char *); +struct dirent *readdir(DIR *); +int readdir_r(DIR *, struct dirent *, struct dirent **); +void rewinddir(DIR *); +void seekdir(DIR *, long int); +long telldir(DIR *); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/components/libc/compilers/common/include/posix/ctype.h b/components/libc/compilers/common/include/posix/ctype.h new file mode 100644 index 0000000000..0ac42e3faf --- /dev/null +++ b/components/libc/compilers/common/include/posix/ctype.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-06-07 Meco Man The first version. + */ + +#ifndef __POSIX_CTYPE_H__ +#define __POSIX_CTYPE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +#ifndef isascii /* some toolchain use macro to define it */ +int isascii(int c); +#endif +#ifndef toascii +int toascii(int c); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __POSIX_CTYPE_H__ */ diff --git a/components/libc/compilers/common/include/posix/stdio.h b/components/libc/compilers/common/include/posix/stdio.h new file mode 100644 index 0000000000..7dea03bb0d --- /dev/null +++ b/components/libc/compilers/common/include/posix/stdio.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-06-07 Meco Man first version + */ + +#ifndef __POSIX_STDIO_H__ +#define __POSIX_STDIO_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream); +ssize_t getline(char **lineptr, size_t *n, FILE *stream); + +#ifdef __cplusplus +} +#endif + +#endif /* __POSIX_STDIO_H__ */ diff --git a/components/libc/compilers/common/include/posix/stdlib.h b/components/libc/compilers/common/include/posix/stdlib.h new file mode 100644 index 0000000000..bc53ebdecf --- /dev/null +++ b/components/libc/compilers/common/include/posix/stdlib.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-06-07 Meco Man The first version. + */ + +#ifndef __POSIX_STDLIB_H__ +#define __POSIX_STDLIB_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +char *itoa(int n, char *buffer, int radix); +char *lltoa(int64_t ll, char *buffer, int radix); +char *ltoa(long l, char *buffer, int radix); +char *ulltoa(uint64_t ll, char *buffer, int radix); +char *ultoa(unsigned long l, char *buffer, int radix); +char *utoa(unsigned int n, char *buffer, int radix); + +#ifdef __cplusplus +} +#endif + +#endif /* __POSIX_STDLIB_H__ */ diff --git a/components/libc/compilers/common/include/posix/string.h b/components/libc/compilers/common/include/posix/string.h new file mode 100644 index 0000000000..475de513fc --- /dev/null +++ b/components/libc/compilers/common/include/posix/string.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-01-12 Meco Man The first version. + */ + +#ifndef __POSIX_STRING_H__ +#define __POSIX_STRING_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +void bzero(void * s, size_t n); +void bcopy(const void * src, void * dest, size_t n); +int bcmp(const void * s1, const void * s2, size_t n); +void explicit_bzero(void * s, size_t n); +char *index(const char * s, int c); +char *rindex(const char * s, int c); +int ffs(int i); +int ffsl(long i); +int ffsll(long long i); +void *memrchr(const void* ptr, int ch, size_t pos); +size_t strnlen(const char *s, size_t maxlen); +char* strchrnul(const char *s, int c); +int strcasecmp(const char * s1, const char * s2); +int strncasecmp(const char * s1, const char * s2, size_t n); +char *strdup(const char *s); +char *strndup(const char *s, size_t size); +char *strtok_r(char *str, const char *delim, char **saveptr); + +#ifdef __cplusplus +} +#endif + +#endif /* __POSIX_STRING_H__ */ diff --git a/components/libc/compilers/common/include/posix/wchar.h b/components/libc/compilers/common/include/posix/wchar.h new file mode 100644 index 0000000000..91aed4e279 --- /dev/null +++ b/components/libc/compilers/common/include/posix/wchar.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-06-07 Meco Man The first version + */ + +#ifndef __POSIX_WCHAR_H__ +#define __POSIX_WCHAR_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +int wcwidth(wchar_t); +int wcswidth(const wchar_t*, size_t); + +#ifdef __cplusplus +} +#endif + +#endif /* __POSIX_WCHAR_H__ */ diff --git a/components/libc/compilers/common/include/sys/ioctl.h b/components/libc/compilers/common/include/sys/ioctl.h new file mode 100644 index 0000000000..e33f19cd6f --- /dev/null +++ b/components/libc/compilers/common/include/sys/ioctl.h @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2020-09-01 Meco Man First Version + */ + +#ifndef __SYS_IOCTL_H__ +#define __SYS_IOCTL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +struct winsize +{ + unsigned short ws_row; + unsigned short ws_col; + unsigned short ws_xpixel; + unsigned short ws_ypixel; +}; + +/* + * Direction bits, which any architecture can choose to override + * before including this file. + */ + +#ifndef _IOC_NONE +#define _IOC_NONE 0U +#endif + +#ifndef _IOC_WRITE +#define _IOC_WRITE 1U +#endif + +#ifndef _IOC_READ +#define _IOC_READ 2U +#endif + +#ifndef _IOC +#define _IOC(a,b,c,d) (((a)<<30) | ((b)<<8) | (c) | ((d)<<16)) +#endif + +#ifndef _IO +#define _IO(a,b) _IOC(_IOC_NONE, (a), (b), 0) +#endif + +#ifndef _IOW +#define _IOW(a,b,c) _IOC(_IOC_WRITE, (a), (b), sizeof(c)) +#endif + +#ifndef _IOR +#define _IOR(a,b,c) _IOC(_IOC_READ, (a), (b), sizeof(c)) +#endif + +#ifndef _IOWR +#define _IOWR(a,b,c) _IOC(_IOC_READ|_IOC_WRITE, (a), (b), sizeof(c)) +#endif + +#ifndef FIONREAD +#define FIONREAD _IOR('f', 127, int) /* get # bytes to read */ +#endif + +#ifndef FIONBIO +#define FIONBIO _IOW('f', 126, int) /* set/clear non-blocking i/o */ +#endif + +#ifndef FIOASYNC +#define FIOASYNC _IOW('f', 125, int) /* set/clear async i/o */ +#endif + +#ifndef FIONWRITE +#define FIONWRITE _IOR('f', 121, int) /* get # bytes outstanding in send queue */ +#endif + +/* Socket I/O Controls */ +#ifndef SIOCSHIWAT +#define SIOCSHIWAT _IOW('s', 0, int) /* set high watermark */ +#define SIOCGHIWAT _IOR('s', 1, int) /* get high watermark */ +#define SIOCSLOWAT _IOW('s', 2, int) /* set low watermark */ +#define SIOCGLOWAT _IOR('s', 3, int) /* get low watermark */ +#define SIOCATMARK _IOR('s', 7, int) /* at oob mark? */ +#endif + +#define TCGETS 0x5401 +#define TCSETS 0x5402 +#define TCSETSW 0x5403 +#define TCSETSF 0x5404 +#define TCGETA 0x5405 +#define TCSETA 0x5406 +#define TCSETAW 0x5407 +#define TCSETAF 0x5408 +#define TCSBRK 0x5409 +#define TCXONC 0x540A +#define TCFLSH 0x540B +#define TIOCEXCL 0x540C +#define TIOCNXCL 0x540D +#define TIOCSCTTY 0x540E +#define TIOCGPGRP 0x540F +#define TIOCSPGRP 0x5410 +#define TIOCOUTQ 0x5411 +#define TIOCSTI 0x5412 +#define TIOCGWINSZ 0x5413 +#define TIOCSWINSZ 0x5414 +#define TIOCMGET 0x5415 +#define TIOCMBIS 0x5416 +#define TIOCMBIC 0x5417 +#define TIOCMSET 0x5418 +#define TIOCGSOFTCAR 0x5419 +#define TIOCSSOFTCAR 0x541A +#define TIOCINQ FIONREAD +#define TIOCLINUX 0x541C +#define TIOCCONS 0x541D +#define TIOCGSERIAL 0x541E +#define TIOCSSERIAL 0x541F +#define TIOCPKT 0x5420 +#define TIOCNOTTY 0x5422 +#define TIOCSETD 0x5423 +#define TIOCGETD 0x5424 +#define TCSBRKP 0x5425 +#define TIOCSBRK 0x5427 +#define TIOCCBRK 0x5428 +#define TIOCGSID 0x5429 +#define TIOCGRS485 0x542E +#define TIOCSRS485 0x542F +#define TIOCGPTN 0x80045430 +#define TIOCSPTLCK 0x40045431 +#define TIOCGDEV 0x80045432 +#define TCGETX 0x5432 +#define TCSETX 0x5433 +#define TCSETXF 0x5434 +#define TCSETXW 0x5435 +#define TIOCSIG 0x40045436 +#define TIOCVHANGUP 0x5437 +#define TIOCGPKT 0x80045438 +#define TIOCGPTLCK 0x80045439 +#define TIOCGEXCL 0x80045440 + +#define FIONCLEX 0x5450 +#define FIOCLEX 0x5451 + +#define TIOCSERCONFIG 0x5453 +#define TIOCSERGWILD 0x5454 +#define TIOCSERSWILD 0x5455 +#define TIOCGLCKTRMIOS 0x5456 +#define TIOCSLCKTRMIOS 0x5457 +#define TIOCSERGSTRUCT 0x5458 +#define TIOCSERGETLSR 0x5459 +#define TIOCSERGETMULTI 0x545A +#define TIOCSERSETMULTI 0x545B + +#define TIOCMIWAIT 0x545C +#define TIOCGICOUNT 0x545D +#define FIOQSIZE 0x5460 + +#define TIOCPKT_DATA 0 +#define TIOCPKT_FLUSHREAD 1 +#define TIOCPKT_FLUSHWRITE 2 +#define TIOCPKT_STOP 4 +#define TIOCPKT_START 8 +#define TIOCPKT_NOSTOP 16 +#define TIOCPKT_DOSTOP 32 +#define TIOCPKT_IOCTL 64 + +#define TIOCSER_TEMT 0x01 + +#define TIOCM_LE 0x001 +#define TIOCM_DTR 0x002 +#define TIOCM_RTS 0x004 +#define TIOCM_ST 0x008 +#define TIOCM_SR 0x010 +#define TIOCM_CTS 0x020 +#define TIOCM_CAR 0x040 +#define TIOCM_RNG 0x080 +#define TIOCM_DSR 0x100 +#define TIOCM_CD TIOCM_CAR +#define TIOCM_RI TIOCM_RNG +#define TIOCM_OUT1 0x2000 +#define TIOCM_OUT2 0x4000 +#define TIOCM_LOOP 0x8000 + +#define N_TTY 0 +#define N_SLIP 1 +#define N_MOUSE 2 +#define N_PPP 3 +#define N_STRIP 4 +#define N_AX25 5 +#define N_X25 6 +#define N_6PACK 7 +#define N_MASC 8 +#define N_R3964 9 +#define N_PROFIBUS_FDL 10 +#define N_IRDA 11 +#define N_SMSBLOCK 12 +#define N_HDLC 13 +#define N_SYNC_PPP 14 +#define N_HCI 15 + +#define FIOSETOWN 0x8901 +#define SIOCSPGRP 0x8902 +#define FIOGETOWN 0x8903 +#define SIOCGPGRP 0x8904 +#define SIOCGSTAMP 0x8906 +#define SIOCGSTAMPNS 0x8907 + +#define SIOCADDRT 0x890B +#define SIOCDELRT 0x890C +#define SIOCRTMSG 0x890D + +#define SIOCGIFNAME 0x8910 +#define SIOCSIFLINK 0x8911 +#define SIOCGIFCONF 0x8912 +#define SIOCGIFFLAGS 0x8913 +#define SIOCSIFFLAGS 0x8914 +#define SIOCGIFADDR 0x8915 +#define SIOCSIFADDR 0x8916 +#define SIOCGIFDSTADDR 0x8917 +#define SIOCSIFDSTADDR 0x8918 +#define SIOCGIFBRDADDR 0x8919 +#define SIOCSIFBRDADDR 0x891a +#define SIOCGIFNETMASK 0x891b +#define SIOCSIFNETMASK 0x891c +#define SIOCGIFMETRIC 0x891d +#define SIOCSIFMETRIC 0x891e +#define SIOCGIFMEM 0x891f +#define SIOCSIFMEM 0x8920 +#define SIOCGIFMTU 0x8921 +#define SIOCSIFMTU 0x8922 +#define SIOCSIFNAME 0x8923 +#define SIOCSIFHWADDR 0x8924 +#define SIOCGIFENCAP 0x8925 +#define SIOCSIFENCAP 0x8926 +#define SIOCGIFHWADDR 0x8927 +#define SIOCGIFSLAVE 0x8929 +#define SIOCSIFSLAVE 0x8930 +#define SIOCADDMULTI 0x8931 +#define SIOCDELMULTI 0x8932 +#define SIOCGIFINDEX 0x8933 +#define SIOGIFINDEX SIOCGIFINDEX +#define SIOCSIFPFLAGS 0x8934 +#define SIOCGIFPFLAGS 0x8935 +#define SIOCDIFADDR 0x8936 +#define SIOCSIFHWBROADCAST 0x8937 +#define SIOCGIFCOUNT 0x8938 + +#define SIOCGIFBR 0x8940 +#define SIOCSIFBR 0x8941 + +#define SIOCGIFTXQLEN 0x8942 +#define SIOCSIFTXQLEN 0x8943 + +#define SIOCDARP 0x8953 +#define SIOCGARP 0x8954 +#define SIOCSARP 0x8955 + +#define SIOCDRARP 0x8960 +#define SIOCGRARP 0x8961 +#define SIOCSRARP 0x8962 + +#define SIOCGIFMAP 0x8970 +#define SIOCSIFMAP 0x8971 + +#define SIOCADDDLCI 0x8980 +#define SIOCDELDLCI 0x8981 + +#define SIOCDEVPRIVATE 0x89F0 +#define SIOCPROTOPRIVATE 0x89E0 + +int ioctl(int fildes, int cmd, ...); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/components/libc/compilers/common/include/sys/select.h b/components/libc/compilers/common/include/sys/select.h new file mode 100644 index 0000000000..9004658be9 --- /dev/null +++ b/components/libc/compilers/common/include/sys/select.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-07-21 Meco Man The first version + * 2021-12-25 Meco Man Handle newlib 2.2.0 or lower version + */ + +#ifndef __SYS_SELECT_H__ +#define __SYS_SELECT_H__ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef FD_SETSIZE +#define FD_SETSIZE 32 +#endif + +#ifdef SAL_USING_POSIX +#ifdef FD_SETSIZE +#undef FD_SETSIZE +#endif +#define FD_SETSIZE DFS_FD_MAX +#endif /* SAL_USING_POSIX */ + +typedef long fd_mask; + +#ifndef _SYS_TYPES_FD_SET /* Newlib 2.2.0 or lower version */ +#define NBBY 8 /* number of bits in a byte */ +#define NFDBITS (sizeof (fd_mask) * NBBY) /* bits per mask */ +#ifndef howmany +#define howmany(x,y) (((x)+((y)-1))/(y)) +#endif /* howmany */ + +typedef struct _types_fd_set { + fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)]; +} _types_fd_set; +#define fd_set _types_fd_set + +#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1L << ((n) % NFDBITS))) +#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1L << ((n) % NFDBITS))) +#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1L << ((n) % NFDBITS))) +#define FD_ZERO(p) rt_memset((void*)(p), 0, sizeof(*(p))) +#endif /* _SYS_TYPES_FD_SET */ + +int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); + +#ifdef __cplusplus +} +#endif + +#endif /* __SYS_SELECT_H__ */ diff --git a/components/libc/compilers/common/include/sys/signal.h b/components/libc/compilers/common/include/sys/signal.h new file mode 100644 index 0000000000..dbd947acb9 --- /dev/null +++ b/components/libc/compilers/common/include/sys/signal.h @@ -0,0 +1,232 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2017-09-12 Bernard The first version + * 2021-07-21 Meco Man move to libc/common + */ + +#ifndef __SYS_SIGNAL_H__ +#define __SYS_SIGNAL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + + +/* sigev_notify values + NOTE: P1003.1c/D10, p. 34 adds SIGEV_THREAD. */ + +#define SIGEV_NONE 1 /* No asynchronous notification shall be delivered */ + /* when the event of interest occurs. */ +#define SIGEV_SIGNAL 2 /* A queued signal, with an application defined */ + /* value, shall be delivered when the event of */ + /* interest occurs. */ +#define SIGEV_THREAD 3 /* A notification function shall be called to */ + /* perform notification. */ + +/* Signal Generation and Delivery, P1003.1b-1993, p. 63 + NOTE: P1003.1c/D10, p. 34 adds sigev_notify_function and + sigev_notify_attributes to the sigevent structure. */ +union sigval +{ + int sival_int; /* Integer signal value */ + void *sival_ptr; /* Pointer signal value */ +}; + +struct sigevent +{ + int sigev_notify; /* Notification type */ + int sigev_signo; /* Signal number */ + union sigval sigev_value; /* Signal value */ + void (*sigev_notify_function)( union sigval ); + /* Notification function */ + void *sigev_notify_attributes; /* Notification Attributes, really pthread_attr_t */ +}; + +struct siginfo +{ + uint16_t si_signo; + uint16_t si_code; + + union sigval si_value; +}; +typedef struct siginfo siginfo_t; + +#define SI_USER 0x01 /* Signal sent by kill(). */ +#define SI_QUEUE 0x02 /* Signal sent by sigqueue(). */ +#define SI_TIMER 0x03 /* Signal generated by expiration of a timer set by timer_settime(). */ +#define SI_ASYNCIO 0x04 /* Signal generated by completion of an asynchronous I/O request. */ +#define SI_MESGQ 0x05 /* Signal generated by arrival of a message on an empty message queue. */ + +typedef void (*_sig_func_ptr)(int); +typedef unsigned long sigset_t; + +struct sigaction +{ + _sig_func_ptr sa_handler; + sigset_t sa_mask; + int sa_flags; +}; + +/* + * Structure used in sigaltstack call. + */ +typedef struct sigaltstack +{ + void *ss_sp; /* Stack base or pointer. */ + int ss_flags; /* Flags. */ + size_t ss_size; /* Stack size. */ +} stack_t; + +#define SIG_SETMASK 0 /* set mask with sigprocmask() */ +#define SIG_BLOCK 1 /* set of signals to block */ +#define SIG_UNBLOCK 2 /* set of signals to, well, unblock */ + +#define sigaddset(what,sig) (*(what) |= (1<<(sig)), 0) +#define sigdelset(what,sig) (*(what) &= ~(1<<(sig)), 0) +#define sigemptyset(what) (*(what) = 0, 0) +#define sigfillset(what) (*(what) = ~(0), 0) +#define sigismember(what,sig) (((*(what)) & (1<<(sig))) != 0) + +int sigprocmask (int how, const sigset_t *set, sigset_t *oset); +int sigpending (sigset_t *set); +int sigsuspend (const sigset_t *set); + +#include "time.h" +int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout); +int sigwait(const sigset_t *set, int *sig); +int sigwaitinfo(const sigset_t *set, siginfo_t *info); +int raise(int sig); +int sigqueue(pid_t pid, int signo, const union sigval value); +int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); + +#ifdef __ARMCC_VERSION +#define SIGHUP 1 +/* #define SIGINT 2 */ +#define SIGQUIT 3 +/* #define SIGILL 4 */ +#define SIGTRAP 5 +/* #define SIGABRT 6 */ +#define SIGEMT 7 +/* #define SIGFPE 8 */ +#define SIGKILL 9 +#define SIGBUS 10 +/* #define SIGSEGV 11 */ +#define SIGSYS 12 +#define SIGPIPE 13 +#define SIGALRM 14 +/* #define SIGTERM 15 */ +#define SIGURG 16 +#define SIGSTOP 17 +#define SIGTSTP 18 +#define SIGCONT 19 +#define SIGCHLD 20 +#define SIGTTIN 21 +#define SIGTTOU 22 +#define SIGPOLL 23 +#define SIGWINCH 24 +#define SIGXCPU 24 /* exceeded CPU time limit */ +#define SIGXFSZ 25 /* exceeded file size limit */ +#define SIGVTALRM 26 /* virtual time alarm */ +/* #define SIGUSR1 25 */ +/* #define SIGUSR2 26 */ +#define SIGRTMIN 27 +#define SIGRTMAX 31 +#define NSIG 32 + +#include + +#elif defined(__IAR_SYSTEMS_ICC__) +#define SIGHUP 1 +#define SIGINT 2 +#define SIGQUIT 3 +#define SIGILL 4 +#define SIGTRAP 5 +/* #define SIGABRT 6 */ +#define SIGEMT 7 +#define SIGFPE 8 +#define SIGKILL 9 +#define SIGBUS 10 +#define SIGSEGV 11 +#define SIGSYS 12 +#define SIGPIPE 13 +#define SIGALRM 14 +#define SIGTERM 15 +#define SIGURG 16 +#define SIGSTOP 17 +#define SIGTSTP 18 +#define SIGCONT 19 +#define SIGCHLD 20 +#define SIGTTIN 21 +#define SIGTTOU 22 +#define SIGPOLL 23 +#define SIGWINCH 24 +#define SIGXCPU 24 /* exceeded CPU time limit */ +#define SIGXFSZ 25 /* exceeded file size limit */ +#define SIGVTALRM 26 /* virtual time alarm */ +#define SIGUSR1 25 +#define SIGUSR2 26 +#define SIGRTMIN 27 +#define SIGRTMAX 31 +#define NSIG 32 + +#include + +#elif defined(__GNUC__) +#define SIGHUP 1 /* hangup */ +#define SIGINT 2 /* interrupt */ +#define SIGQUIT 3 /* quit */ +#define SIGILL 4 /* illegal instruction (not reset when caught) */ +#define SIGTRAP 5 /* trace trap (not reset when caught) */ +#define SIGIOT 6 /* IOT instruction */ +#define SIGABRT 6 /* used by abort, replace SIGIOT in the future */ +#define SIGEMT 7 /* EMT instruction */ +#define SIGFPE 8 /* floating point exception */ +#define SIGKILL 9 /* kill (cannot be caught or ignored) */ +#define SIGBUS 10 /* bus error */ +#define SIGSEGV 11 /* segmentation violation */ +#define SIGSYS 12 /* bad argument to system call */ +#define SIGPIPE 13 /* write on a pipe with no one to read it */ +#define SIGALRM 14 /* alarm clock */ +#define SIGTERM 15 /* software termination signal from kill */ +#define SIGURG 16 /* urgent condition on IO channel */ +#define SIGSTOP 17 /* sendable stop signal not from tty */ +#define SIGTSTP 18 /* stop signal from tty */ +#define SIGCONT 19 /* continue a stopped process */ +#define SIGCHLD 20 /* to parent on child stop or exit */ +#define SIGCLD 20 /* System V name for SIGCHLD */ +#define SIGTTIN 21 /* to readers pgrp upon background tty read */ +#define SIGTTOU 22 /* like TTIN for output if (tp->t_local<OSTOP) */ +#define SIGIO 23 /* input/output possible signal */ +#define SIGPOLL SIGIO /* System V name for SIGIO */ +#define SIGXCPU 24 /* exceeded CPU time limit */ +#define SIGXFSZ 25 /* exceeded file size limit */ +#define SIGVTALRM 26 /* virtual time alarm */ +#define SIGPROF 27 /* profiling time alarm */ +#define SIGWINCH 28 /* window changed */ +#define SIGLOST 29 /* resource lost (eg, record-lock lost) */ +#define SIGUSR1 30 /* user defined signal 1 */ +#define SIGUSR2 31 /* user defined signal 2 */ +#define NSIG 32 /* signal 0 implied */ + +#ifndef _SIGNAL_H_ +/* Some applications take advantage of the fact that + * and are equivalent in glibc. Allow for that here. */ +#include +#endif + +#endif + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/components/libc/compilers/common/include/sys/statfs.h b/components/libc/compilers/common/include/sys/statfs.h new file mode 100644 index 0000000000..818ec9eb77 --- /dev/null +++ b/components/libc/compilers/common/include/sys/statfs.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + */ + +#ifndef __SYS_STATFS_H__ +#define __SYS_STATFS_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct statfs +{ + size_t f_bsize; /* block size */ + size_t f_blocks; /* total data blocks in file system */ + size_t f_bfree; /* free blocks in file system */ +}; + +int statfs(const char *path, struct statfs *buf); +int fstatfs(int fd, struct statfs *buf); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/components/libc/compilers/common/include/sys/time.h b/components/libc/compilers/common/include/sys/time.h new file mode 100644 index 0000000000..8a4dbb68f3 --- /dev/null +++ b/components/libc/compilers/common/include/sys/time.h @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2020-09-07 Meco Man combine gcc armcc iccarm + * 2021-02-12 Meco Man move all definitions located in to this file + */ + +#ifndef __SYS_TIME_H__ +#define __SYS_TIME_H__ + +#include +#include +#include +#include +#ifdef _WIN32 +typedef __time64_t time_t; +#endif /* _WIN32 */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* timezone */ +#define DST_NONE 0 /* not on dst */ +#define DST_USA 1 /* USA style dst */ +#define DST_AUST 2 /* Australian style dst */ +#define DST_WET 3 /* Western European dst */ +#define DST_MET 4 /* Middle European dst */ +#define DST_EET 5 /* Eastern European dst */ +#define DST_CAN 6 /* Canada */ +#define DST_GB 7 /* Great Britain and Eire */ +#define DST_RUM 8 /* Rumania */ +#define DST_TUR 9 /* Turkey */ +#define DST_AUSTALT 10 /* Australian style with shift in 1986 */ + +struct timezone +{ + int tz_minuteswest; /* minutes west of Greenwich */ + int tz_dsttime; /* type of dst correction */ +}; + +#ifndef _TIMEVAL_DEFINED +#define _TIMEVAL_DEFINED +struct timeval +{ + time_t tv_sec; /* seconds */ + suseconds_t tv_usec; /* and microseconds */ +}; +#endif /* _TIMEVAL_DEFINED */ + +#if defined(__ARMCC_VERSION) || defined(_WIN32) || (defined(__ICCARM__) && (__VER__ < 8010001)) +struct timespec +{ + time_t tv_sec; /* seconds */ + long tv_nsec; /* and nanoseconds */ +}; +#endif /* defined(__ARMCC_VERSION) || defined(_WIN32) || (defined(__ICCARM__) && (__VER__ < 8010001)) */ + +#if !(defined(__GNUC__) && !defined(__ARMCC_VERSION)/*GCC*/) +/* + * Structure defined by POSIX.1b to be like a itimerval, but with + * timespecs. Used in the timer_*() system calls. + */ +struct itimerspec +{ + struct timespec it_interval; + struct timespec it_value; +}; +#endif /* !(defined(__GNUC__) && !defined(__ARMCC_VERSION)) */ + +int stime(const time_t *t); +time_t timegm(struct tm * const t); +int gettimeofday(struct timeval *tv, struct timezone *tz); +int settimeofday(const struct timeval *tv, const struct timezone *tz); +#if defined(__ARMCC_VERSION) || defined (__ICCARM__) +struct tm *gmtime_r(const time_t *timep, struct tm *r); +struct tm* localtime_r(const time_t* t, struct tm* r); +char* asctime_r(const struct tm *t, char *buf); +char *ctime_r(const time_t * tim_p, char * result); +#elif defined(_WIN32) +struct tm* gmtime_r(const time_t* timep, struct tm* r); +struct tm* gmtime(const time_t* t); +struct tm* localtime_r(const time_t* t, struct tm* r); +struct tm* localtime(const time_t* t); +time_t mktime(struct tm* const t); +char* asctime_r(const struct tm* t, char* buf); +char* ctime_r(const time_t* tim_p, char* result); +char* ctime(const time_t* tim_p); +time_t time(time_t* t); +#endif + +#ifdef RT_USING_POSIX_DELAY +int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); +#endif /* RT_USING_POSIX_DELAY */ + +#if defined(RT_USING_POSIX_CLOCK) || defined (RT_USING_POSIX_TIMER) +/* POSIX clock and timer */ +#define MILLISECOND_PER_SECOND 1000UL +#define MICROSECOND_PER_SECOND 1000000UL +#define NANOSECOND_PER_SECOND 1000000000UL + +#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND) +#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND) +#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND) + +#ifndef CLOCK_REALTIME +#define CLOCK_REALTIME 1 +#endif + +#define CLOCK_CPUTIME_ID 2 + +#ifndef CLOCK_PROCESS_CPUTIME_ID +#define CLOCK_PROCESS_CPUTIME_ID CLOCK_CPUTIME_ID +#endif +#ifndef CLOCK_THREAD_CPUTIME_ID +#define CLOCK_THREAD_CPUTIME_ID CLOCK_CPUTIME_ID +#endif + +#ifndef CLOCK_MONOTONIC +#define CLOCK_MONOTONIC 4 +#endif +#endif /* defined(RT_USING_POSIX_CLOCK) || defined (RT_USING_POSIX_TIMER) */ + +#ifdef RT_USING_POSIX_CLOCK +int clock_getres (clockid_t clockid, struct timespec *res); +int clock_gettime (clockid_t clockid, struct timespec *tp); +int clock_settime (clockid_t clockid, const struct timespec *tp); +int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *rqtp, struct timespec *rmtp); +int rt_timespec_to_tick(const struct timespec *time); +#endif /* RT_USING_POSIX_CLOCK */ + +#ifdef RT_USING_POSIX_TIMER +#include "signal.h" +int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid); +int timer_delete(timer_t timerid); +int timer_getoverrun(timer_t timerid); +int timer_gettime(timer_t timerid, struct itimerspec *its); +int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, + struct itimerspec *ovalue); +#endif /* RT_USING_POSIX_TIMER */ + +/* timezone */ +void tz_set(int8_t tz); +int8_t tz_get(void); +int8_t tz_is_dst(void); + +#ifdef __cplusplus +} +#endif + +#endif /* _SYS_TIME_H_ */ diff --git a/components/libc/compilers/common/include/sys/unistd.h b/components/libc/compilers/common/include/sys/unistd.h new file mode 100644 index 0000000000..0eaf52423c --- /dev/null +++ b/components/libc/compilers/common/include/sys/unistd.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2020-12-16 Meco Man add usleep + * 2021-09-11 Meco Man move functions from dfs_posix.h to unistd.h + */ + +#ifndef __SYS_UNISTD_H__ +#define __SYS_UNISTD_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define STDIN_FILENO 0 /* standard input file descriptor */ +#define STDOUT_FILENO 1 /* standard output file descriptor */ +#define STDERR_FILENO 2 /* standard error file descriptor */ + +unsigned alarm(unsigned __secs); +ssize_t read(int fd, void *buf, size_t len); +ssize_t write(int fd, const void *buf, size_t len); +off_t lseek(int fd, off_t offset, int whence); +int pause(void); +int fsync(int fildes); +long sysconf(int __name); +int unlink(const char *pathname); +int close(int d); +int ftruncate(int fd, off_t length); +int rmdir(const char *path); +int chdir(const char *path); +char *getcwd(char *buf, size_t size); +int access(const char *path, int amode); +int pipe(int fildes[2]); +int isatty(int fd); +char *ttyname(int desc); +unsigned int sleep(unsigned int seconds); +int usleep(useconds_t usec); +pid_t gettid(void); +pid_t getpid(void); +pid_t getppid(void); +uid_t getuid(void); +uid_t geteuid(void); +gid_t getgid(void); +gid_t getegid(void); + +#ifdef __cplusplus +} +#endif + +#endif /* _SYS_UNISTD_H */ diff --git a/components/libc/compilers/common/include/sys/vfs.h b/components/libc/compilers/common/include/sys/vfs.h new file mode 100644 index 0000000000..25b36877f8 --- /dev/null +++ b/components/libc/compilers/common/include/sys/vfs.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-09-11 Meco Man First version + */ + +#ifndef __SYS_VFS_H__ +#define __SYS_VFS_H__ + +#include "statfs.h" /* */ + +#endif diff --git a/components/libc/compilers/common/include/unistd.h b/components/libc/compilers/common/include/unistd.h new file mode 100644 index 0000000000..6e63bc94d8 --- /dev/null +++ b/components/libc/compilers/common/include/unistd.h @@ -0,0 +1,10 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + */ + +#include "sys/unistd.h" diff --git a/components/libc/compilers/common/stdlib.c b/components/libc/compilers/common/stdlib.c deleted file mode 100644 index 12e379acbf..0000000000 --- a/components/libc/compilers/common/stdlib.c +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2021-02-15 Meco Man first version - */ - -#include - -#define DBG_TAG "stdlib" -#define DBG_LVL DBG_INFO -#include - -void __rt_libc_exit(int status) -{ - rt_thread_t self = rt_thread_self(); - - if (self != RT_NULL) - { -#ifdef RT_USING_PTHREADS - extern void pthread_exit(void *value); - pthread_exit((void *)status); -#else - LOG_E("thread:%s exit:%d!", self->name, status); - rt_thread_control(self, RT_THREAD_CTRL_CLOSE, RT_NULL); -#endif - } -} - -#ifdef RT_USING_MSH -int system(const char *command) -{ - extern int msh_exec(char *cmd, rt_size_t length); - - if (command) - { - msh_exec((char *)command, rt_strlen(command)); - } - - return 0; -} -RTM_EXPORT(system); -#endif /* RT_USING_MSH */ diff --git a/components/libc/compilers/common/sys/ioctl.h b/components/libc/compilers/common/sys/ioctl.h deleted file mode 100644 index 4f9287304e..0000000000 --- a/components/libc/compilers/common/sys/ioctl.h +++ /dev/null @@ -1,278 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2020-09-01 Meco Man First Version - */ - -#ifndef __SYS_IOCTL_H__ -#define __SYS_IOCTL_H__ - -#ifdef __cplusplus -extern "C" { -#endif - -struct winsize -{ - unsigned short ws_row; - unsigned short ws_col; - unsigned short ws_xpixel; - unsigned short ws_ypixel; -}; - -/* - * Direction bits, which any architecture can choose to override - * before including this file. - */ - -#ifndef _IOC_NONE -#define _IOC_NONE 0U -#endif - -#ifndef _IOC_WRITE -#define _IOC_WRITE 1U -#endif - -#ifndef _IOC_READ -#define _IOC_READ 2U -#endif - -#ifndef _IOC -#define _IOC(a,b,c,d) (((a)<<30) | ((b)<<8) | (c) | ((d)<<16)) -#endif - -#ifndef _IO -#define _IO(a,b) _IOC(_IOC_NONE, (a), (b), 0) -#endif - -#ifndef _IOW -#define _IOW(a,b,c) _IOC(_IOC_WRITE, (a), (b), sizeof(c)) -#endif - -#ifndef _IOR -#define _IOR(a,b,c) _IOC(_IOC_READ, (a), (b), sizeof(c)) -#endif - -#ifndef _IOWR -#define _IOWR(a,b,c) _IOC(_IOC_READ|_IOC_WRITE, (a), (b), sizeof(c)) -#endif - -#ifndef FIONREAD -#define FIONREAD _IOR('f', 127, int) /* get # bytes to read */ -#endif - -#ifndef FIONBIO -#define FIONBIO _IOW('f', 126, int) /* set/clear non-blocking i/o */ -#endif - -#ifndef FIOASYNC -#define FIOASYNC _IOW('f', 125, int) /* set/clear async i/o */ -#endif - -#ifndef FIONWRITE -#define FIONWRITE _IOR('f', 121, int) /* get # bytes outstanding in send queue */ -#endif - -/* Socket I/O Controls */ -#ifndef SIOCSHIWAT -#define SIOCSHIWAT _IOW('s', 0, int) /* set high watermark */ -#define SIOCGHIWAT _IOR('s', 1, int) /* get high watermark */ -#define SIOCSLOWAT _IOW('s', 2, int) /* set low watermark */ -#define SIOCGLOWAT _IOR('s', 3, int) /* get low watermark */ -#define SIOCATMARK _IOR('s', 7, int) /* at oob mark? */ -#endif - -#define TCGETS 0x5401 -#define TCSETS 0x5402 -#define TCSETSW 0x5403 -#define TCSETSF 0x5404 -#define TCGETA 0x5405 -#define TCSETA 0x5406 -#define TCSETAW 0x5407 -#define TCSETAF 0x5408 -#define TCSBRK 0x5409 -#define TCXONC 0x540A -#define TCFLSH 0x540B -#define TIOCEXCL 0x540C -#define TIOCNXCL 0x540D -#define TIOCSCTTY 0x540E -#define TIOCGPGRP 0x540F -#define TIOCSPGRP 0x5410 -#define TIOCOUTQ 0x5411 -#define TIOCSTI 0x5412 -#define TIOCGWINSZ 0x5413 -#define TIOCSWINSZ 0x5414 -#define TIOCMGET 0x5415 -#define TIOCMBIS 0x5416 -#define TIOCMBIC 0x5417 -#define TIOCMSET 0x5418 -#define TIOCGSOFTCAR 0x5419 -#define TIOCSSOFTCAR 0x541A -#define TIOCINQ FIONREAD -#define TIOCLINUX 0x541C -#define TIOCCONS 0x541D -#define TIOCGSERIAL 0x541E -#define TIOCSSERIAL 0x541F -#define TIOCPKT 0x5420 -#define TIOCNOTTY 0x5422 -#define TIOCSETD 0x5423 -#define TIOCGETD 0x5424 -#define TCSBRKP 0x5425 -#define TIOCSBRK 0x5427 -#define TIOCCBRK 0x5428 -#define TIOCGSID 0x5429 -#define TIOCGRS485 0x542E -#define TIOCSRS485 0x542F -#define TIOCGPTN 0x80045430 -#define TIOCSPTLCK 0x40045431 -#define TIOCGDEV 0x80045432 -#define TCGETX 0x5432 -#define TCSETX 0x5433 -#define TCSETXF 0x5434 -#define TCSETXW 0x5435 -#define TIOCSIG 0x40045436 -#define TIOCVHANGUP 0x5437 -#define TIOCGPKT 0x80045438 -#define TIOCGPTLCK 0x80045439 -#define TIOCGEXCL 0x80045440 - -#define FIONCLEX 0x5450 -#define FIOCLEX 0x5451 - -#define TIOCSERCONFIG 0x5453 -#define TIOCSERGWILD 0x5454 -#define TIOCSERSWILD 0x5455 -#define TIOCGLCKTRMIOS 0x5456 -#define TIOCSLCKTRMIOS 0x5457 -#define TIOCSERGSTRUCT 0x5458 -#define TIOCSERGETLSR 0x5459 -#define TIOCSERGETMULTI 0x545A -#define TIOCSERSETMULTI 0x545B - -#define TIOCMIWAIT 0x545C -#define TIOCGICOUNT 0x545D -#define FIOQSIZE 0x5460 - -#define TIOCPKT_DATA 0 -#define TIOCPKT_FLUSHREAD 1 -#define TIOCPKT_FLUSHWRITE 2 -#define TIOCPKT_STOP 4 -#define TIOCPKT_START 8 -#define TIOCPKT_NOSTOP 16 -#define TIOCPKT_DOSTOP 32 -#define TIOCPKT_IOCTL 64 - -#define TIOCSER_TEMT 0x01 - -#define TIOCM_LE 0x001 -#define TIOCM_DTR 0x002 -#define TIOCM_RTS 0x004 -#define TIOCM_ST 0x008 -#define TIOCM_SR 0x010 -#define TIOCM_CTS 0x020 -#define TIOCM_CAR 0x040 -#define TIOCM_RNG 0x080 -#define TIOCM_DSR 0x100 -#define TIOCM_CD TIOCM_CAR -#define TIOCM_RI TIOCM_RNG -#define TIOCM_OUT1 0x2000 -#define TIOCM_OUT2 0x4000 -#define TIOCM_LOOP 0x8000 - -#define N_TTY 0 -#define N_SLIP 1 -#define N_MOUSE 2 -#define N_PPP 3 -#define N_STRIP 4 -#define N_AX25 5 -#define N_X25 6 -#define N_6PACK 7 -#define N_MASC 8 -#define N_R3964 9 -#define N_PROFIBUS_FDL 10 -#define N_IRDA 11 -#define N_SMSBLOCK 12 -#define N_HDLC 13 -#define N_SYNC_PPP 14 -#define N_HCI 15 - -#define FIOSETOWN 0x8901 -#define SIOCSPGRP 0x8902 -#define FIOGETOWN 0x8903 -#define SIOCGPGRP 0x8904 -#define SIOCGSTAMP 0x8906 -#define SIOCGSTAMPNS 0x8907 - -#define SIOCADDRT 0x890B -#define SIOCDELRT 0x890C -#define SIOCRTMSG 0x890D - -#define SIOCGIFNAME 0x8910 -#define SIOCSIFLINK 0x8911 -#define SIOCGIFCONF 0x8912 -#define SIOCGIFFLAGS 0x8913 -#define SIOCSIFFLAGS 0x8914 -#define SIOCGIFADDR 0x8915 -#define SIOCSIFADDR 0x8916 -#define SIOCGIFDSTADDR 0x8917 -#define SIOCSIFDSTADDR 0x8918 -#define SIOCGIFBRDADDR 0x8919 -#define SIOCSIFBRDADDR 0x891a -#define SIOCGIFNETMASK 0x891b -#define SIOCSIFNETMASK 0x891c -#define SIOCGIFMETRIC 0x891d -#define SIOCSIFMETRIC 0x891e -#define SIOCGIFMEM 0x891f -#define SIOCSIFMEM 0x8920 -#define SIOCGIFMTU 0x8921 -#define SIOCSIFMTU 0x8922 -#define SIOCSIFNAME 0x8923 -#define SIOCSIFHWADDR 0x8924 -#define SIOCGIFENCAP 0x8925 -#define SIOCSIFENCAP 0x8926 -#define SIOCGIFHWADDR 0x8927 -#define SIOCGIFSLAVE 0x8929 -#define SIOCSIFSLAVE 0x8930 -#define SIOCADDMULTI 0x8931 -#define SIOCDELMULTI 0x8932 -#define SIOCGIFINDEX 0x8933 -#define SIOGIFINDEX SIOCGIFINDEX -#define SIOCSIFPFLAGS 0x8934 -#define SIOCGIFPFLAGS 0x8935 -#define SIOCDIFADDR 0x8936 -#define SIOCSIFHWBROADCAST 0x8937 -#define SIOCGIFCOUNT 0x8938 - -#define SIOCGIFBR 0x8940 -#define SIOCSIFBR 0x8941 - -#define SIOCGIFTXQLEN 0x8942 -#define SIOCSIFTXQLEN 0x8943 - -#define SIOCDARP 0x8953 -#define SIOCGARP 0x8954 -#define SIOCSARP 0x8955 - -#define SIOCDRARP 0x8960 -#define SIOCGRARP 0x8961 -#define SIOCSRARP 0x8962 - -#define SIOCGIFMAP 0x8970 -#define SIOCSIFMAP 0x8971 - -#define SIOCADDDLCI 0x8980 -#define SIOCDELDLCI 0x8981 - -#define SIOCDEVPRIVATE 0x89F0 -#define SIOCPROTOPRIVATE 0x89E0 - -int ioctl(int fildes, int cmd, ...); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/components/libc/compilers/common/sys/select.h b/components/libc/compilers/common/sys/select.h deleted file mode 100644 index 1232edd6e8..0000000000 --- a/components/libc/compilers/common/sys/select.h +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2021-07-21 Meco Man The first version - * 2021-12-25 Meco Man Handle newlib 2.2.0 or lower version - */ - -#ifndef __SYS_SELECT_H__ -#define __SYS_SELECT_H__ - -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef FD_SETSIZE -#define FD_SETSIZE 32 -#endif - -#ifdef SAL_USING_POSIX -#ifdef FD_SETSIZE -#undef FD_SETSIZE -#endif -#define FD_SETSIZE DFS_FD_MAX -#endif /* SAL_USING_POSIX */ - -typedef long fd_mask; - -#ifndef _SYS_TYPES_FD_SET /* Newlib 2.2.0 or lower version */ -#define NBBY 8 /* number of bits in a byte */ -#define NFDBITS (sizeof (fd_mask) * NBBY) /* bits per mask */ -#ifndef howmany -#define howmany(x,y) (((x)+((y)-1))/(y)) -#endif /* howmany */ - -typedef struct _types_fd_set { - fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)]; -} _types_fd_set; -#define fd_set _types_fd_set - -#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1L << ((n) % NFDBITS))) -#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1L << ((n) % NFDBITS))) -#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1L << ((n) % NFDBITS))) -#define FD_ZERO(p) rt_memset((void*)(p), 0, sizeof(*(p))) -#endif /* _SYS_TYPES_FD_SET */ - -int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); - -#ifdef __cplusplus -} -#endif - -#endif /* __SYS_SELECT_H__ */ diff --git a/components/libc/compilers/common/sys/signal.h b/components/libc/compilers/common/sys/signal.h deleted file mode 100644 index 041dd765b7..0000000000 --- a/components/libc/compilers/common/sys/signal.h +++ /dev/null @@ -1,232 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2017-09-12 Bernard The first version - * 2021-07-21 Meco Man move to libc/common - */ - -#ifndef __SYS_SIGNAL_H__ -#define __SYS_SIGNAL_H__ - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include - - -/* sigev_notify values - NOTE: P1003.1c/D10, p. 34 adds SIGEV_THREAD. */ - -#define SIGEV_NONE 1 /* No asynchronous notification shall be delivered */ - /* when the event of interest occurs. */ -#define SIGEV_SIGNAL 2 /* A queued signal, with an application defined */ - /* value, shall be delivered when the event of */ - /* interest occurs. */ -#define SIGEV_THREAD 3 /* A notification function shall be called to */ - /* perform notification. */ - -/* Signal Generation and Delivery, P1003.1b-1993, p. 63 - NOTE: P1003.1c/D10, p. 34 adds sigev_notify_function and - sigev_notify_attributes to the sigevent structure. */ -union sigval -{ - int sival_int; /* Integer signal value */ - void *sival_ptr; /* Pointer signal value */ -}; - -struct sigevent -{ - int sigev_notify; /* Notification type */ - int sigev_signo; /* Signal number */ - union sigval sigev_value; /* Signal value */ - void (*sigev_notify_function)( union sigval ); - /* Notification function */ - void *sigev_notify_attributes; /* Notification Attributes, really pthread_attr_t */ -}; - -struct siginfo -{ - uint16_t si_signo; - uint16_t si_code; - - union sigval si_value; -}; -typedef struct siginfo siginfo_t; - -#define SI_USER 0x01 /* Signal sent by kill(). */ -#define SI_QUEUE 0x02 /* Signal sent by sigqueue(). */ -#define SI_TIMER 0x03 /* Signal generated by expiration of a timer set by timer_settime(). */ -#define SI_ASYNCIO 0x04 /* Signal generated by completion of an asynchronous I/O request. */ -#define SI_MESGQ 0x05 /* Signal generated by arrival of a message on an empty message queue. */ - -typedef void (*_sig_func_ptr)(int); -typedef unsigned long sigset_t; - -struct sigaction -{ - _sig_func_ptr sa_handler; - sigset_t sa_mask; - int sa_flags; -}; - -/* - * Structure used in sigaltstack call. - */ -typedef struct sigaltstack -{ - void *ss_sp; /* Stack base or pointer. */ - int ss_flags; /* Flags. */ - size_t ss_size; /* Stack size. */ -} stack_t; - -#define SIG_SETMASK 0 /* set mask with sigprocmask() */ -#define SIG_BLOCK 1 /* set of signals to block */ -#define SIG_UNBLOCK 2 /* set of signals to, well, unblock */ - -#define sigaddset(what,sig) (*(what) |= (1<<(sig)), 0) -#define sigdelset(what,sig) (*(what) &= ~(1<<(sig)), 0) -#define sigemptyset(what) (*(what) = 0, 0) -#define sigfillset(what) (*(what) = ~(0), 0) -#define sigismember(what,sig) (((*(what)) & (1<<(sig))) != 0) - -int sigprocmask (int how, const sigset_t *set, sigset_t *oset); -int sigpending (sigset_t *set); -int sigsuspend (const sigset_t *set); - -#include "time.h" -int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout); -int sigwait(const sigset_t *set, int *sig); -int sigwaitinfo(const sigset_t *set, siginfo_t *info); -int raise(int sig); -int sigqueue(pid_t pid, int signo, const union sigval value); -int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); - -#ifdef __ARMCC_VERSION -#define SIGHUP 1 -/* #define SIGINT 2 */ -#define SIGQUIT 3 -/* #define SIGILL 4 */ -#define SIGTRAP 5 -/* #define SIGABRT 6 */ -#define SIGEMT 7 -/* #define SIGFPE 8 */ -#define SIGKILL 9 -#define SIGBUS 10 -/* #define SIGSEGV 11 */ -#define SIGSYS 12 -#define SIGPIPE 13 -#define SIGALRM 14 -/* #define SIGTERM 15 */ -#define SIGURG 16 -#define SIGSTOP 17 -#define SIGTSTP 18 -#define SIGCONT 19 -#define SIGCHLD 20 -#define SIGTTIN 21 -#define SIGTTOU 22 -#define SIGPOLL 23 -#define SIGWINCH 24 -#define SIGXCPU 24 /* exceeded CPU time limit */ -#define SIGXFSZ 25 /* exceeded file size limit */ -#define SIGVTALRM 26 /* virtual time alarm */ -/* #define SIGUSR1 25 */ -/* #define SIGUSR2 26 */ -#define SIGRTMIN 27 -#define SIGRTMAX 31 -#define NSIG 32 - -#include - -#elif defined(__IAR_SYSTEMS_ICC__) -#define SIGHUP 1 -#define SIGINT 2 -#define SIGQUIT 3 -#define SIGILL 4 -#define SIGTRAP 5 -/* #define SIGABRT 6 */ -#define SIGEMT 7 -#define SIGFPE 8 -#define SIGKILL 9 -#define SIGBUS 10 -#define SIGSEGV 11 -#define SIGSYS 12 -#define SIGPIPE 13 -#define SIGALRM 14 -#define SIGTERM 15 -#define SIGURG 16 -#define SIGSTOP 17 -#define SIGTSTP 18 -#define SIGCONT 19 -#define SIGCHLD 20 -#define SIGTTIN 21 -#define SIGTTOU 22 -#define SIGPOLL 23 -#define SIGWINCH 24 -#define SIGXCPU 24 /* exceeded CPU time limit */ -#define SIGXFSZ 25 /* exceeded file size limit */ -#define SIGVTALRM 26 /* virtual time alarm */ -#define SIGUSR1 25 -#define SIGUSR2 26 -#define SIGRTMIN 27 -#define SIGRTMAX 31 -#define NSIG 32 - -#include - -#elif defined(__GNUC__) -#define SIGHUP 1 /* hangup */ -#define SIGINT 2 /* interrupt */ -#define SIGQUIT 3 /* quit */ -#define SIGILL 4 /* illegal instruction (not reset when caught) */ -#define SIGTRAP 5 /* trace trap (not reset when caught) */ -#define SIGIOT 6 /* IOT instruction */ -#define SIGABRT 6 /* used by abort, replace SIGIOT in the future */ -#define SIGEMT 7 /* EMT instruction */ -#define SIGFPE 8 /* floating point exception */ -#define SIGKILL 9 /* kill (cannot be caught or ignored) */ -#define SIGBUS 10 /* bus error */ -#define SIGSEGV 11 /* segmentation violation */ -#define SIGSYS 12 /* bad argument to system call */ -#define SIGPIPE 13 /* write on a pipe with no one to read it */ -#define SIGALRM 14 /* alarm clock */ -#define SIGTERM 15 /* software termination signal from kill */ -#define SIGURG 16 /* urgent condition on IO channel */ -#define SIGSTOP 17 /* sendable stop signal not from tty */ -#define SIGTSTP 18 /* stop signal from tty */ -#define SIGCONT 19 /* continue a stopped process */ -#define SIGCHLD 20 /* to parent on child stop or exit */ -#define SIGCLD 20 /* System V name for SIGCHLD */ -#define SIGTTIN 21 /* to readers pgrp upon background tty read */ -#define SIGTTOU 22 /* like TTIN for output if (tp->t_local<OSTOP) */ -#define SIGIO 23 /* input/output possible signal */ -#define SIGPOLL SIGIO /* System V name for SIGIO */ -#define SIGXCPU 24 /* exceeded CPU time limit */ -#define SIGXFSZ 25 /* exceeded file size limit */ -#define SIGVTALRM 26 /* virtual time alarm */ -#define SIGPROF 27 /* profiling time alarm */ -#define SIGWINCH 28 /* window changed */ -#define SIGLOST 29 /* resource lost (eg, record-lock lost) */ -#define SIGUSR1 30 /* user defined signal 1 */ -#define SIGUSR2 31 /* user defined signal 2 */ -#define NSIG 32 /* signal 0 implied */ - -#ifndef _SIGNAL_H_ -/* Some applications take advantage of the fact that - * and are equivalent in glibc. Allow for that here. */ -#include -#endif - -#endif - -#ifdef __cplusplus -} -#endif - -#endif - diff --git a/components/libc/compilers/common/sys/statfs.h b/components/libc/compilers/common/sys/statfs.h deleted file mode 100644 index 6f92bf1cf3..0000000000 --- a/components/libc/compilers/common/sys/statfs.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - */ - -#ifndef __SYS_STATFS_H__ -#define __SYS_STATFS_H__ - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -struct statfs -{ - size_t f_bsize; /* block size */ - size_t f_blocks; /* total data blocks in file system */ - size_t f_bfree; /* free blocks in file system */ -}; - -int statfs(const char *path, struct statfs *buf); -int fstatfs(int fd, struct statfs *buf); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/components/libc/compilers/common/sys/time.h b/components/libc/compilers/common/sys/time.h deleted file mode 100644 index 8a4dbb68f3..0000000000 --- a/components/libc/compilers/common/sys/time.h +++ /dev/null @@ -1,155 +0,0 @@ -/* - * Copyright (c) 2006-2022, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2020-09-07 Meco Man combine gcc armcc iccarm - * 2021-02-12 Meco Man move all definitions located in to this file - */ - -#ifndef __SYS_TIME_H__ -#define __SYS_TIME_H__ - -#include -#include -#include -#include -#ifdef _WIN32 -typedef __time64_t time_t; -#endif /* _WIN32 */ - -#ifdef __cplusplus -extern "C" { -#endif - -/* timezone */ -#define DST_NONE 0 /* not on dst */ -#define DST_USA 1 /* USA style dst */ -#define DST_AUST 2 /* Australian style dst */ -#define DST_WET 3 /* Western European dst */ -#define DST_MET 4 /* Middle European dst */ -#define DST_EET 5 /* Eastern European dst */ -#define DST_CAN 6 /* Canada */ -#define DST_GB 7 /* Great Britain and Eire */ -#define DST_RUM 8 /* Rumania */ -#define DST_TUR 9 /* Turkey */ -#define DST_AUSTALT 10 /* Australian style with shift in 1986 */ - -struct timezone -{ - int tz_minuteswest; /* minutes west of Greenwich */ - int tz_dsttime; /* type of dst correction */ -}; - -#ifndef _TIMEVAL_DEFINED -#define _TIMEVAL_DEFINED -struct timeval -{ - time_t tv_sec; /* seconds */ - suseconds_t tv_usec; /* and microseconds */ -}; -#endif /* _TIMEVAL_DEFINED */ - -#if defined(__ARMCC_VERSION) || defined(_WIN32) || (defined(__ICCARM__) && (__VER__ < 8010001)) -struct timespec -{ - time_t tv_sec; /* seconds */ - long tv_nsec; /* and nanoseconds */ -}; -#endif /* defined(__ARMCC_VERSION) || defined(_WIN32) || (defined(__ICCARM__) && (__VER__ < 8010001)) */ - -#if !(defined(__GNUC__) && !defined(__ARMCC_VERSION)/*GCC*/) -/* - * Structure defined by POSIX.1b to be like a itimerval, but with - * timespecs. Used in the timer_*() system calls. - */ -struct itimerspec -{ - struct timespec it_interval; - struct timespec it_value; -}; -#endif /* !(defined(__GNUC__) && !defined(__ARMCC_VERSION)) */ - -int stime(const time_t *t); -time_t timegm(struct tm * const t); -int gettimeofday(struct timeval *tv, struct timezone *tz); -int settimeofday(const struct timeval *tv, const struct timezone *tz); -#if defined(__ARMCC_VERSION) || defined (__ICCARM__) -struct tm *gmtime_r(const time_t *timep, struct tm *r); -struct tm* localtime_r(const time_t* t, struct tm* r); -char* asctime_r(const struct tm *t, char *buf); -char *ctime_r(const time_t * tim_p, char * result); -#elif defined(_WIN32) -struct tm* gmtime_r(const time_t* timep, struct tm* r); -struct tm* gmtime(const time_t* t); -struct tm* localtime_r(const time_t* t, struct tm* r); -struct tm* localtime(const time_t* t); -time_t mktime(struct tm* const t); -char* asctime_r(const struct tm* t, char* buf); -char* ctime_r(const time_t* tim_p, char* result); -char* ctime(const time_t* tim_p); -time_t time(time_t* t); -#endif - -#ifdef RT_USING_POSIX_DELAY -int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); -#endif /* RT_USING_POSIX_DELAY */ - -#if defined(RT_USING_POSIX_CLOCK) || defined (RT_USING_POSIX_TIMER) -/* POSIX clock and timer */ -#define MILLISECOND_PER_SECOND 1000UL -#define MICROSECOND_PER_SECOND 1000000UL -#define NANOSECOND_PER_SECOND 1000000000UL - -#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND) -#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND) -#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND) - -#ifndef CLOCK_REALTIME -#define CLOCK_REALTIME 1 -#endif - -#define CLOCK_CPUTIME_ID 2 - -#ifndef CLOCK_PROCESS_CPUTIME_ID -#define CLOCK_PROCESS_CPUTIME_ID CLOCK_CPUTIME_ID -#endif -#ifndef CLOCK_THREAD_CPUTIME_ID -#define CLOCK_THREAD_CPUTIME_ID CLOCK_CPUTIME_ID -#endif - -#ifndef CLOCK_MONOTONIC -#define CLOCK_MONOTONIC 4 -#endif -#endif /* defined(RT_USING_POSIX_CLOCK) || defined (RT_USING_POSIX_TIMER) */ - -#ifdef RT_USING_POSIX_CLOCK -int clock_getres (clockid_t clockid, struct timespec *res); -int clock_gettime (clockid_t clockid, struct timespec *tp); -int clock_settime (clockid_t clockid, const struct timespec *tp); -int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *rqtp, struct timespec *rmtp); -int rt_timespec_to_tick(const struct timespec *time); -#endif /* RT_USING_POSIX_CLOCK */ - -#ifdef RT_USING_POSIX_TIMER -#include "signal.h" -int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid); -int timer_delete(timer_t timerid); -int timer_getoverrun(timer_t timerid); -int timer_gettime(timer_t timerid, struct itimerspec *its); -int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, - struct itimerspec *ovalue); -#endif /* RT_USING_POSIX_TIMER */ - -/* timezone */ -void tz_set(int8_t tz); -int8_t tz_get(void); -int8_t tz_is_dst(void); - -#ifdef __cplusplus -} -#endif - -#endif /* _SYS_TIME_H_ */ diff --git a/components/libc/compilers/common/sys/unistd.h b/components/libc/compilers/common/sys/unistd.h deleted file mode 100644 index fcf6e342e7..0000000000 --- a/components/libc/compilers/common/sys/unistd.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2020-12-16 Meco Man add usleep - * 2021-09-11 Meco Man move functions from dfs_posix.h to unistd.h - */ - -#ifndef __SYS_UNISTD_H__ -#define __SYS_UNISTD_H__ - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#define STDIN_FILENO 0 /* standard input file descriptor */ -#define STDOUT_FILENO 1 /* standard output file descriptor */ -#define STDERR_FILENO 2 /* standard error file descriptor */ - -unsigned alarm(unsigned __secs); -ssize_t read(int fd, void *buf, size_t len); -ssize_t write(int fd, const void *buf, size_t len); -off_t lseek(int fd, off_t offset, int whence); -int pause(void); -int fsync(int fildes); -long sysconf(int __name); -int unlink(const char *pathname); -int close(int d); -int ftruncate(int fd, off_t length); -int rmdir(const char *path); -int chdir(const char *path); -char *getcwd(char *buf, size_t size); -int access(const char *path, int amode); -int pipe(int fildes[2]); -int isatty(int fd); -char *ttyname(int desc); -unsigned int sleep(unsigned int seconds); -int usleep(useconds_t usec); -pid_t gettid(void); -pid_t getpid(void); -pid_t getppid(void); -uid_t getuid(void); -uid_t geteuid(void); -gid_t getgid(void); -gid_t getegid(void); - -#ifdef __cplusplus -} -#endif - -#endif /* _SYS_UNISTD_H */ diff --git a/components/libc/compilers/common/sys/vfs.h b/components/libc/compilers/common/sys/vfs.h deleted file mode 100644 index a9330df002..0000000000 --- a/components/libc/compilers/common/sys/vfs.h +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2021-09-11 Meco Man First version - */ - -#ifndef __SYS_VFS_H__ -#define __SYS_VFS_H__ - -#include "statfs.h" /* */ - -#endif diff --git a/components/libc/compilers/common/time.c b/components/libc/compilers/common/time.c deleted file mode 100644 index 96591113b8..0000000000 --- a/components/libc/compilers/common/time.c +++ /dev/null @@ -1,1007 +0,0 @@ -/* - * Copyright (c) 2006-2022, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - * 2019-08-21 zhangjun copy from minilibc - * 2020-09-07 Meco Man combine gcc armcc iccarm - * 2021-02-05 Meco Man add timegm() - * 2021-02-07 Meco Man fixed gettimeofday() - * 2021-02-08 Meco Man add settimeofday() stime() - * 2021-02-10 Meco Man add ctime_r() and re-implement ctime() - * 2021-02-11 Meco Man fix bug #3183 - align days[] and months[] to 4 bytes - * 2021-02-12 Meco Man add errno - * 2012-12-08 Bernard fix the issue of _timevalue.tv_usec initialization, - * which found by Rob - * 2021-02-12 Meco Man move all of the functions located in to this file - * 2021-03-15 Meco Man fixed a bug of leaking memory in asctime() - * 2021-05-01 Meco Man support fixed timezone - * 2021-07-21 Meco Man implement that change/set timezone APIs - */ - -#include "sys/time.h" -#include -#include -#include -#include -#ifdef RT_USING_POSIX_DELAY -#include -#endif -#ifdef RT_USING_RTC -#include -#endif - -#define DBG_TAG "time" -#define DBG_LVL DBG_INFO -#include - -#define _WARNING_NO_RTC "Cannot find a RTC device!" - -/* seconds per day */ -#define SPD 24*60*60 - -/* days per month -- nonleap! */ -static const short __spm[13] = -{ - 0, - (31), - (31 + 28), - (31 + 28 + 31), - (31 + 28 + 31 + 30), - (31 + 28 + 31 + 30 + 31), - (31 + 28 + 31 + 30 + 31 + 30), - (31 + 28 + 31 + 30 + 31 + 30 + 31), - (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31), - (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30), - (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31), - (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30), - (31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31), -}; - -ALIGN(4) static const char *days = "Sun Mon Tue Wed Thu Fri Sat "; -ALIGN(4) static const char *months = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec "; - -static int __isleap(int year) -{ - /* every fourth year is a leap year except for century years that are - * not divisible by 400. */ - /* return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)); */ - return (!(year % 4) && ((year % 100) || !(year % 400))); -} - -static void num2str(char *c, int i) -{ - c[0] = i / 10 + '0'; - c[1] = i % 10 + '0'; -} - -/** - * Get time from RTC device (without timezone, UTC+0) - * @param tv: struct timeval - * @return the operation status, RT_EOK on successful - */ -static rt_err_t get_timeval(struct timeval *tv) -{ -#ifdef RT_USING_RTC - static rt_device_t device = RT_NULL; - rt_err_t rst = -RT_ERROR; - - if (tv == RT_NULL) - return -RT_EINVAL; - - /* default is 0 */ - tv->tv_sec = 0; - tv->tv_usec = 0; - - /* optimization: find rtc device only first */ - if (device == RT_NULL) - { - device = rt_device_find("rtc"); - } - - /* read timestamp from RTC device */ - if (device != RT_NULL) - { - if (rt_device_open(device, 0) == RT_EOK) - { - rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &tv->tv_sec); - rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIMEVAL, tv); - rt_device_close(device); - } - } - else - { - LOG_W(_WARNING_NO_RTC); - return -RT_ENOSYS; - } - - return rst; - -#else - LOG_W(_WARNING_NO_RTC); - return -RT_ENOSYS; -#endif /* RT_USING_RTC */ -} - -/** - * Set time to RTC device (without timezone) - * @param tv: struct timeval - * @return the operation status, RT_EOK on successful - */ -static int set_timeval(struct timeval *tv) -{ -#ifdef RT_USING_RTC - static rt_device_t device = RT_NULL; - rt_err_t rst = -RT_ERROR; - - if (tv == RT_NULL) - return -RT_EINVAL; - - /* optimization: find rtc device only first */ - if (device == RT_NULL) - { - device = rt_device_find("rtc"); - } - - /* read timestamp from RTC device */ - if (device != RT_NULL) - { - if (rt_device_open(device, 0) == RT_EOK) - { - rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &tv->tv_sec); - rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIMEVAL, tv); - rt_device_close(device); - } - } - else - { - LOG_W(_WARNING_NO_RTC); - return -RT_ENOSYS; - } - - return rst; - -#else - LOG_W(_WARNING_NO_RTC); - return -RT_ENOSYS; -#endif /* RT_USING_RTC */ -} - -struct tm *gmtime_r(const time_t *timep, struct tm *r) -{ - time_t i; - time_t work = *timep % (SPD); - r->tm_sec = work % 60; - work /= 60; - r->tm_min = work % 60; - r->tm_hour = work / 60; - work = *timep / (SPD); - r->tm_wday = (4 + work) % 7; - for (i = 1970;; ++i) - { - time_t k = __isleap(i) ? 366 : 365; - if (work >= k) - work -= k; - else - break; - } - r->tm_year = i - 1900; - r->tm_yday = work; - - r->tm_mday = 1; - if (__isleap(i) && (work > 58)) - { - if (work == 59) - r->tm_mday = 2; /* 29.2. */ - work -= 1; - } - - for (i = 11; i && (__spm[i] > work); --i) - ; - r->tm_mon = i; - r->tm_mday += work - __spm[i]; - - r->tm_isdst = tz_is_dst(); - return r; -} -RTM_EXPORT(gmtime_r); - -struct tm* gmtime(const time_t* t) -{ - static struct tm tmp; - return gmtime_r(t, &tmp); -} -RTM_EXPORT(gmtime); - -struct tm* localtime_r(const time_t* t, struct tm* r) -{ - time_t local_tz; - - local_tz = *t + (time_t)tz_get() * 3600; - return gmtime_r(&local_tz, r); -} -RTM_EXPORT(localtime_r); - -struct tm* localtime(const time_t* t) -{ - static struct tm tmp; - return localtime_r(t, &tmp); -} -RTM_EXPORT(localtime); - -time_t mktime(struct tm * const t) -{ - time_t timestamp; - - timestamp = timegm(t); - timestamp = timestamp - 3600 * (time_t)tz_get(); - return timestamp; -} -RTM_EXPORT(mktime); - -char* asctime_r(const struct tm *t, char *buf) -{ - /* Checking input validity */ - if ((int)rt_strlen(days) <= (t->tm_wday << 2) || (int)rt_strlen(months) <= (t->tm_mon << 2)) - { - LOG_W("asctime_r: the input parameters exceeded the limit, please check it."); - *(int*) buf = *(int*) days; - *(int*) (buf + 4) = *(int*) months; - num2str(buf + 8, t->tm_mday); - if (buf[8] == '0') - buf[8] = ' '; - buf[10] = ' '; - num2str(buf + 11, t->tm_hour); - buf[13] = ':'; - num2str(buf + 14, t->tm_min); - buf[16] = ':'; - num2str(buf + 17, t->tm_sec); - buf[19] = ' '; - num2str(buf + 20, 2000 / 100); - num2str(buf + 22, 2000 % 100); - buf[24] = '\n'; - buf[25] = '\0'; - return buf; - } - - /* "Wed Jun 30 21:49:08 1993\n" */ - *(int*) buf = *(int*) (days + (t->tm_wday << 2)); - *(int*) (buf + 4) = *(int*) (months + (t->tm_mon << 2)); - num2str(buf + 8, t->tm_mday); - if (buf[8] == '0') - buf[8] = ' '; - buf[10] = ' '; - num2str(buf + 11, t->tm_hour); - buf[13] = ':'; - num2str(buf + 14, t->tm_min); - buf[16] = ':'; - num2str(buf + 17, t->tm_sec); - buf[19] = ' '; - num2str(buf + 20, (t->tm_year + 1900) / 100); - num2str(buf + 22, (t->tm_year + 1900) % 100); - buf[24] = '\n'; - buf[25] = '\0'; - return buf; -} -RTM_EXPORT(asctime_r); - -char* asctime(const struct tm *timeptr) -{ - static char buf[26]; - return asctime_r(timeptr, buf); -} -RTM_EXPORT(asctime); - -char *ctime_r(const time_t * tim_p, char * result) -{ - struct tm tm; - return asctime_r(localtime_r(tim_p, &tm), result); -} -RTM_EXPORT(ctime_r); - -char* ctime(const time_t *tim_p) -{ - return asctime(localtime(tim_p)); -} -RTM_EXPORT(ctime); - -double difftime(time_t time1, time_t time2) -{ - return (double)(time1 - time2); -} -RTM_EXPORT(difftime); - -RTM_EXPORT(strftime); /* inherent in the toolchain */ - -/** - * Returns the current time. - * - * @param time_t * t the timestamp pointer, if not used, keep NULL. - * - * @return The value ((time_t)-1) is returned if the calendar time is not available. - * If timer is not a NULL pointer, the return value is also stored in timer. - * - */ -RT_WEAK time_t time(time_t *t) -{ - struct timeval now; - - if(get_timeval(&now) == RT_EOK) - { - if (t) - { - *t = now.tv_sec; - } - return now.tv_sec; - } - else - { - rt_set_errno(EFAULT); - return ((time_t)-1); - } -} -RTM_EXPORT(time); - -RT_WEAK clock_t clock(void) -{ - return rt_tick_get(); -} -RTM_EXPORT(clock); - -int stime(const time_t *t) -{ - struct timeval tv; - - if (!t) - { - rt_set_errno(EFAULT); - return -1; - } - - tv.tv_sec = *t; - if (set_timeval(&tv) == RT_EOK) - { - return 0; - } - else - { - rt_set_errno(EFAULT); - return -1; - } -} -RTM_EXPORT(stime); - -time_t timegm(struct tm * const t) -{ - time_t day; - time_t i; - time_t years = (time_t)t->tm_year - 70; - - if (t->tm_sec > 60) /* seconds after the minute - [0, 60] including leap second */ - { - t->tm_min += t->tm_sec / 60; - t->tm_sec %= 60; - } - if (t->tm_min >= 60) /* minutes after the hour - [0, 59] */ - { - t->tm_hour += t->tm_min / 60; - t->tm_min %= 60; - } - if (t->tm_hour >= 24) /* hours since midnight - [0, 23] */ - { - t->tm_mday += t->tm_hour / 24; - t->tm_hour %= 24; - } - if (t->tm_mon >= 12) /* months since January - [0, 11] */ - { - t->tm_year += t->tm_mon / 12; - t->tm_mon %= 12; - } - while (t->tm_mday > __spm[1 + t->tm_mon]) - { - if (t->tm_mon == 1 && __isleap(t->tm_year + 1900)) - { - --t->tm_mday; - } - t->tm_mday -= __spm[t->tm_mon]; - ++t->tm_mon; - if (t->tm_mon > 11) - { - t->tm_mon = 0; - ++t->tm_year; - } - } - - if (t->tm_year < 70) - return (time_t) - 1; - - /* Days since 1970 is 365 * number of years + number of leap years since 1970 */ - day = years * 365 + (years + 1) / 4; - - /* After 2100 we have to substract 3 leap years for every 400 years - This is not intuitive. Most mktime implementations do not support - dates after 2059, anyway, so we might leave this out for it's - bloat. */ - if (years >= 131) - { - years -= 131; - years /= 100; - day -= (years >> 2) * 3 + 1; - if ((years &= 3) == 3) - years--; - day -= years; - } - - day += t->tm_yday = __spm[t->tm_mon] + t->tm_mday - 1 + - (__isleap(t->tm_year + 1900) & (t->tm_mon > 1)); - - /* day is now the number of days since 'Jan 1 1970' */ - i = 7; - t->tm_wday = (day + 4) % i; /* Sunday=0, Monday=1, ..., Saturday=6 */ - - i = 24; - day *= i; - i = 60; - return ((day + t->tm_hour) * i + t->tm_min) * i + t->tm_sec; -} -RTM_EXPORT(timegm); - -int gettimeofday(struct timeval *tv, struct timezone *tz) -{ - /* The use of the timezone structure is obsolete; - * the tz argument should normally be specified as NULL. - * The tz_dsttime field has never been used under Linux. - * Thus, the following is purely of historic interest. - */ - if(tz != RT_NULL) - { - tz->tz_dsttime = DST_NONE; - tz->tz_minuteswest = -(tz_get() * 60); - } - - if (tv != RT_NULL && get_timeval(tv) == RT_EOK) - { - return 0; - } - else - { - rt_set_errno(EFAULT); - return -1; - } -} -RTM_EXPORT(gettimeofday); - -int settimeofday(const struct timeval *tv, const struct timezone *tz) -{ - /* The use of the timezone structure is obsolete; - * the tz argument should normally be specified as NULL. - * The tz_dsttime field has never been used under Linux. - * Thus, the following is purely of historic interest. - */ - if (tv != RT_NULL - && tv->tv_usec >= 0 - && set_timeval((struct timeval *)tv) == RT_EOK) - { - return 0; - } - else - { - rt_set_errno(EINVAL); - return -1; - } -} -RTM_EXPORT(settimeofday); - -#ifdef RT_USING_POSIX_DELAY -int nanosleep(const struct timespec *rqtp, struct timespec *rmtp) -{ - sleep(rqtp->tv_sec); - ndelay(rqtp->tv_nsec); - return 0; -} -RTM_EXPORT(nanosleep); -#endif /* RT_USING_POSIX_DELAY */ - -#ifdef RT_USING_POSIX_CLOCK -#ifdef RT_USING_RTC -static volatile struct timeval _timevalue; -static int _rt_clock_time_system_init(void) -{ - rt_base_t level; - time_t time = 0; - rt_tick_t tick; - rt_device_t device; - - device = rt_device_find("rtc"); - if (device != RT_NULL) - { - /* get realtime seconds */ - if(rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time) == RT_EOK) - { - level = rt_hw_interrupt_disable(); - tick = rt_tick_get(); /* get tick */ - _timevalue.tv_usec = (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK; - _timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1; - rt_hw_interrupt_enable(level); - return 0; - } - } - - level = rt_hw_interrupt_disable(); - _timevalue.tv_usec = 0; - _timevalue.tv_sec = 0; - rt_hw_interrupt_enable(level); - - return -1; -} -INIT_COMPONENT_EXPORT(_rt_clock_time_system_init); -#endif /* RT_USING_RTC */ - -int clock_getres(clockid_t clockid, struct timespec *res) -{ -#ifndef RT_USING_RTC - LOG_W(_WARNING_NO_RTC); - return -1; -#else - int ret = 0; - - if (res == RT_NULL) - { - rt_set_errno(EINVAL); - return -1; - } - - switch (clockid) - { - case CLOCK_REALTIME: - res->tv_sec = 0; - res->tv_nsec = NANOSECOND_PER_SECOND/RT_TICK_PER_SECOND; - break; - -#ifdef RT_USING_CPUTIME - case CLOCK_CPUTIME_ID: - res->tv_sec = 0; - res->tv_nsec = clock_cpu_getres(); - break; -#endif - - default: - ret = -1; - rt_set_errno(EINVAL); - break; - } - - return ret; -#endif /* RT_USING_RTC */ -} -RTM_EXPORT(clock_getres); - -int clock_gettime(clockid_t clockid, struct timespec *tp) -{ -#ifndef RT_USING_RTC - LOG_W(_WARNING_NO_RTC); - return -1; -#else - int ret = 0; - - if (tp == RT_NULL) - { - rt_set_errno(EINVAL); - return -1; - } - - switch (clockid) - { - case CLOCK_REALTIME: - { - int tick; - rt_base_t level; - - level = rt_hw_interrupt_disable(); - tick = rt_tick_get(); /* get tick */ - tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND; - tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000; - rt_hw_interrupt_enable(level); - } - break; - -#ifdef RT_USING_CPUTIME - case CLOCK_CPUTIME_ID: - { - float unit = 0; - long long cpu_tick; - - unit = clock_cpu_getres(); - cpu_tick = clock_cpu_gettime(); - - tp->tv_sec = ((long long)(cpu_tick * unit)) / NANOSECOND_PER_SECOND; - tp->tv_nsec = ((long long)(cpu_tick * unit)) % NANOSECOND_PER_SECOND; - } - break; -#endif - default: - rt_set_errno(EINVAL); - ret = -1; - } - - return ret; -#endif /* RT_USING_RTC */ -} -RTM_EXPORT(clock_gettime); - -int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *rqtp, struct timespec *rmtp) -{ - if ((clockid != CLOCK_REALTIME) || (rqtp == RT_NULL)) - { - rt_set_errno(EINVAL); - return -1; - } - - return nanosleep(rqtp, rmtp); -} - -int clock_settime(clockid_t clockid, const struct timespec *tp) -{ -#ifndef RT_USING_RTC - LOG_W(_WARNING_NO_RTC); - return -1; -#else - rt_base_t level; - int second; - rt_tick_t tick; - rt_device_t device; - - if ((clockid != CLOCK_REALTIME) || (tp == RT_NULL)) - { - rt_set_errno(EINVAL); - return -1; - } - - /* get second */ - second = tp->tv_sec; - - level = rt_hw_interrupt_disable(); - tick = rt_tick_get(); /* get tick */ - /* update timevalue */ - _timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK; - _timevalue.tv_sec = second - tick/RT_TICK_PER_SECOND - 1; - rt_hw_interrupt_enable(level); - - /* update for RTC device */ - device = rt_device_find("rtc"); - if (device != RT_NULL) - { - /* set realtime seconds */ - if(rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &second) == RT_EOK) - { - return 0; - } - } - - return -1; -#endif /* RT_USING_RTC */ -} -RTM_EXPORT(clock_settime); - -int rt_timespec_to_tick(const struct timespec *time) -{ - int tick; - int nsecond, second; - struct timespec tp = {0}; - - RT_ASSERT(time != RT_NULL); - - tick = RT_WAITING_FOREVER; - if (time != NULL) - { - /* get current tp */ - clock_gettime(CLOCK_REALTIME, &tp); - - if ((time->tv_nsec - tp.tv_nsec) < 0) - { - nsecond = NANOSECOND_PER_SECOND - (tp.tv_nsec - time->tv_nsec); - second = time->tv_sec - tp.tv_sec - 1; - } - else - { - nsecond = time->tv_nsec - tp.tv_nsec; - second = time->tv_sec - tp.tv_sec; - } - - tick = second * RT_TICK_PER_SECOND + nsecond * RT_TICK_PER_SECOND / NANOSECOND_PER_SECOND; - if (tick < 0) tick = 0; - } - - return tick; -} -RTM_EXPORT(rt_timespec_to_tick); - -#endif /* RT_USING_POSIX_CLOCK */ - -#ifdef RT_USING_POSIX_TIMER - -#define ACTIVE 1 -#define NOT_ACTIVE 0 - -struct timer_obj -{ - struct rt_timer timer; - void (*sigev_notify_function)(union sigval val); - union sigval val; - struct timespec interval; /* Reload value */ - rt_uint32_t reload; /* Reload value in ms */ - rt_uint32_t status; -}; - -static void rtthread_timer_wrapper(void *timerobj) -{ - struct timer_obj *timer; - - timer = (struct timer_obj *)timerobj; - - if (timer->reload == 0U) - { - timer->status = NOT_ACTIVE; - } - - if(timer->sigev_notify_function != RT_NULL) - { - (timer->sigev_notify_function)(timer->val); - } -} - -/** - * @brief Create a per-process timer. - * - * This API does not accept SIGEV_THREAD as valid signal event notification - * type. - * - * See IEEE 1003.1 - */ -int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid) -{ - static int num = 0; - struct timer_obj *timer; - char timername[RT_NAME_MAX] = {0}; - - if (clockid != CLOCK_MONOTONIC || evp == NULL || - (evp->sigev_notify != SIGEV_NONE && - evp->sigev_notify != SIGEV_SIGNAL)) - { - rt_set_errno(EINVAL); - return -RT_ERROR; - } - - timer = rt_malloc(sizeof(struct timer_obj)); - if(timer == RT_NULL) - { - rt_set_errno(ENOMEM); - return -RT_ENOMEM; - } - - RT_ASSERT(evp->sigev_notify_function != RT_NULL); - rt_snprintf(timername, RT_NAME_MAX, "psx_tm%02d", num++); - num %= 100; - timer->sigev_notify_function = evp->sigev_notify_function; - timer->val = evp->sigev_value; - timer->interval.tv_sec = 0; - timer->interval.tv_nsec = 0; - timer->reload = 0U; - timer->status = NOT_ACTIVE; - - if (evp->sigev_notify == SIGEV_NONE) - { - rt_timer_init(&timer->timer, timername, RT_NULL, RT_NULL, 0, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); - } - else - { - rt_timer_init(&timer->timer, timername, rtthread_timer_wrapper, timer, 0, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); - } - - *timerid = (timer_t)timer; - - return RT_EOK; -} -RTM_EXPORT(timer_create); - -/** - * @brief Delete a per-process timer. - * - * See IEEE 1003.1 - */ -int timer_delete(timer_t timerid) -{ - struct timer_obj *timer = (struct timer_obj *)timerid; - - if (timer == RT_NULL) - { - rt_set_errno(EINVAL); - return -RT_ERROR; - } - - if (timer->status == ACTIVE) - { - timer->status = NOT_ACTIVE; - rt_timer_stop(&timer->timer); - } - - rt_free(timer); - - return RT_EOK; -} -RTM_EXPORT(timer_delete); - -/** - * - * Return the overrun count for the last timer expiration. - * It is subefficient to create a new structure to get overrun count. - **/ -int timer_getoverrun(timer_t timerid) -{ - rt_set_errno(ENOSYS); - return -RT_ERROR; -} - -/** - * @brief Get amount of time left for expiration on a per-process timer. - * - * See IEEE 1003.1 - */ -int timer_gettime(timer_t timerid, struct itimerspec *its) -{ - struct timer_obj *timer = (struct timer_obj *)timerid; - rt_tick_t remaining; - rt_uint32_t seconds, nanoseconds; - - if (timer == NULL) - { - rt_set_errno(EINVAL); - return -RT_ERROR; - } - - if (its == NULL) - { - rt_set_errno(EFAULT); - return -RT_ERROR; - } - - if (timer->status == ACTIVE) - { - rt_tick_t remain_tick; - - rt_timer_control(&timer->timer, RT_TIMER_CTRL_GET_REMAIN_TIME, &remain_tick); - - /* 'remain_tick' is minimum-unit in the RT-Thread' timer, - * so the seconds, nanoseconds will be calculated by 'remain_tick'. - */ - remaining = remain_tick - rt_tick_get(); - - /* calculate 'second' */ - seconds = remaining / RT_TICK_PER_SECOND; - - /* calculate 'nanosecond'; To avoid lost of accuracy, because "RT_TICK_PER_SECOND" maybe 100, 1000, 1024 and so on. - * - * remain_tick millisecond remain_tick * MILLISECOND_PER_SECOND - * ------------------------- = -------------------------- ---> millisecond = ------------------------------------------- - * RT_TICK_PER_SECOND MILLISECOND_PER_SECOND RT_TICK_PER_SECOND - * - * remain_tick * MILLISECOND_PER_SECOND remain_tick * MILLISECOND_PER_SECOND * MICROSECOND_PER_SECOND - * millisecond = ---------------------------------------- ---> nanosecond = ------------------------------------------------------------------- - * RT_TICK_PER_SECOND RT_TICK_PER_SECOND - * - */ - nanoseconds = (((remaining % RT_TICK_PER_SECOND) * MILLISECOND_PER_SECOND) * MICROSECOND_PER_SECOND) / RT_TICK_PER_SECOND ; - - its->it_value.tv_sec = (rt_int32_t)seconds; - its->it_value.tv_nsec = (rt_int32_t)nanoseconds; - } - else - { - /* Timer is disarmed */ - its->it_value.tv_sec = 0; - its->it_value.tv_nsec = 0; - } - - /* The interval last set by timer_settime() */ - its->it_interval = timer->interval; - return RT_EOK; -} -RTM_EXPORT(timer_gettime); - -/** - * @brief Sets expiration time of per-process timer. - * - * See IEEE 1003.1 - */ -int timer_settime(timer_t timerid, int flags, const struct itimerspec *value, - struct itimerspec *ovalue) -{ - struct timer_obj *timer = (struct timer_obj *)timerid; - - if (timer == NULL || - value->it_interval.tv_nsec < 0 || - value->it_interval.tv_nsec >= NANOSECOND_PER_SECOND || - value->it_value.tv_nsec < 0 || - value->it_value.tv_nsec >= NANOSECOND_PER_SECOND) - { - rt_set_errno(EINVAL); - return -RT_ERROR; - } - - if (value == NULL || ovalue == NULL) - { - rt_set_errno(EFAULT); - return -RT_ERROR; - } - - /* Save time to expire and old reload value. */ - if (ovalue != NULL) - { - timer_gettime(timerid, ovalue); - } - - /* Stop the timer if the value is 0 */ - if ((value->it_value.tv_sec == 0) && (value->it_value.tv_nsec == 0)) - { - if (timer->status == ACTIVE) - { - rt_timer_stop(&timer->timer); - } - - timer->status = NOT_ACTIVE; - return RT_EOK; - } - - /* calculate timer period(tick); To avoid lost of accuracy, because "RT_TICK_PER_SECOND" maybe 100, 1000, 1024 and so on. - * - * tick nanosecond nanosecond * RT_TICK_PER_SECOND - * ------------------------- = -------------------------- ---> tick = ------------------------------------- - * RT_TICK_PER_SECOND NANOSECOND_PER_SECOND NANOSECOND_PER_SECOND - * - */ - timer->reload = (value->it_interval.tv_sec * RT_TICK_PER_SECOND) + (value->it_interval.tv_nsec * RT_TICK_PER_SECOND) / NANOSECOND_PER_SECOND; - timer->interval.tv_sec = value->it_interval.tv_sec; - timer->interval.tv_nsec = value->it_interval.tv_nsec; - - if (timer->status == ACTIVE) - { - rt_timer_stop(&timer->timer); - } - - timer->status = ACTIVE; - rt_timer_control(&timer->timer, RT_TIMER_CTRL_SET_TIME, (void *)timer->reload); - rt_timer_control(&timer->timer, RT_TIMER_CTRL_SET_PERIODIC, RT_NULL); - rt_timer_start(&timer->timer); - - return RT_EOK; -} -RTM_EXPORT(timer_settime); -#endif /* RT_USING_POSIX_TIMER */ - - -/* timezone */ -#ifndef RT_LIBC_DEFAULT_TIMEZONE -#define RT_LIBC_DEFAULT_TIMEZONE 8 -#endif - -static volatile int8_t _current_timezone = RT_LIBC_DEFAULT_TIMEZONE; - -void tz_set(int8_t tz) -{ - rt_base_t level; - level = rt_hw_interrupt_disable(); - _current_timezone = tz; - rt_hw_interrupt_enable(level); -} - -int8_t tz_get(void) -{ - return _current_timezone; -} - -int8_t tz_is_dst(void) -{ - return 0; -} diff --git a/components/libc/compilers/common/unistd.h b/components/libc/compilers/common/unistd.h deleted file mode 100644 index 4dd71c842e..0000000000 --- a/components/libc/compilers/common/unistd.h +++ /dev/null @@ -1,10 +0,0 @@ -/* - * Copyright (c) 2006-2021, RT-Thread Development Team - * - * SPDX-License-Identifier: Apache-2.0 - * - * Change Logs: - * Date Author Notes - */ - -#include "sys/unistd.h" -- cgit v1.3.1