GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)

mcu/riscv/libs/Makefile

@@ -0,0 +1,8 @@
+SRCS-y += lib.c stdio.c div64.c
+SRCS-$(CONFIG_PRINTF) += printf.c
+ifdef CONFIG_MALLOC
+SRCS-y += malloc.c memlib.c
+else
+SRCS-y += simple_malloc.c
+endif
+SRCS-y += reserved_mem.c

mcu/riscv/libs/div64.c

@@ -0,0 +1,34 @@
+
+#include <sys/types.h>
+
+uint32_t __div64_32(uint64_t *n, uint32_t base)
+{
+	uint64_t rem = *n;
+	uint64_t b = base;
+	uint64_t res, d = 1;
+	uint32_t high = rem >> 32;
+
+	res = 0;
+	if (high >= base) {
+		high /= base;
+		res = (uint64_t) high << 32;
+		rem -= (uint64_t) (high * base) << 32;
+	}
+
+	while ((int64_t)b > 0 && b < rem) {
+		b = b + b;
+		d = d + d;
+	}
+
+	do {
+		if (rem >= b) {
+			rem -= b;
+			res += d;
+		}
+		b >>= 1;
+		d >>= 1;
+	} while (d);
+
+	*n = res;
+	return rem;
+}

mcu/riscv/libs/lib.c

@@ -0,0 +1,216 @@
+
+#include <stdio.h>
+#include <lib.h>
+#include <serial.h>
+
+int memset_s(void* dest, size_t destMax, unsigned char c, size_t count)
+{
+    unsigned char *__dest = (unsigned char *)dest;
+
+    if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN) {
+        return FAILURE;
+    }
+
+    if (__dest == NULL) {
+        return FAILURE;
+    }
+
+    if (count > destMax) {
+        while (destMax--)
+		    *__dest++ = (unsigned char)c;   /*set entire buffer to value c*/
+        return FAILURE;
+    }
+
+    while (count--)
+		*__dest++ = (unsigned char)c;
+
+    return SUCCESS;
+}
+
+int memset(void* dest, unsigned char c, size_t count)
+{
+	return memset_s(dest, SECUREC_MEM_MAX_LEN, c, count);
+}
+
+int memcpy_s(void* dest, size_t destMax, const void* src, size_t count)
+{
+    unsigned char *__dest = (unsigned char *)dest;
+    unsigned char *__src = (unsigned char *)src;
+
+    if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN ) {
+        return FAILURE;
+    }
+
+    if (__dest == NULL || __src == NULL) {
+        if (__dest != NULL ) {
+            while (destMax--)
+	        *__dest++ = 0;   /*set entire buffer to value 0 */
+            return FAILURE;
+        }
+        return FAILURE;
+    }
+
+    if (count > destMax) {
+        while (destMax--)
+	    *__dest++ = 0;       /*set entire buffer to value 0 */
+        return FAILURE;
+    }
+
+    if (__dest == __src) {
+        return SUCCESS;
+    }
+
+    if ((__dest > __src && __dest < ((u8*)__src + count)) ||
+        (__src > __dest && __src < ((u8*)__dest + count)) ) {
+        while (destMax--)
+		    *__dest++ = 0;   /*set entire buffer to value 0 */
+
+        return FAILURE;
+    }
+
+	while (count--)
+		*__dest++ = *__src++;
+
+    return SUCCESS;
+}
+
+void *memcpy(void *dst, const void *src, size_t len)
+{
+	if(SUCCESS == memcpy_s(dst, len, src, len))
+		return dst;
+	return NULL;
+}
+
+int memcmp(const void *b1, const void *b2, size_t len)
+{
+	int res = 0;
+	const char *d = b1;
+	const char *s = b2;
+
+	if (b1 == NULL || b2 == NULL) {
+		puts("memcmp : Invalid args\n");
+		return res;
+	}
+
+	while (len > 0) {
+		res = *d - *s;
+		if (res != 0)
+			break;
+		d++;
+		s++;
+		len--;
+	}
+
+	return res;
+}
+
+u32 strlen(const char * s)
+{
+	const char *sc;
+
+	for (sc = s; *sc != '\0'; ++sc)
+		/* nothing */;
+	return sc - s;
+}
+
+char *strcat(char *dest, const char *src)
+{
+	char *tmp = dest;
+
+	while (*dest)
+		dest++;
+	while ((*dest++ = *src++) != '\0')
+		;
+
+	return tmp;
+}
+
+char *strcpy(char *dest, const char*src)
+{
+	char *tmp = dest;
+
+	while (*src != '\0') {
+		*dest = *src;
+		dest++;
+		src++;
+	}
+
+	*dest = '\0';
+
+	return tmp;
+}
+
+
+char *strncpy(char *dest, char *src, size_t n)
+{
+	char *tmp = dest;
+
+	while (n > 0 && *src != '\0') {
+		*dest = *src;
+		dest++;
+		src++;
+		n--;
+	}
+
+	while (n > 0) {
+		*dest = '\0';
+		dest++;
+		n--;
+	}
+
+	return tmp;
+}
+
+int strcmp(const char *s1, const char *s2) {
+    while (*s1 && (*s1 == *s2)) {
+        s1++;
+        s2++;
+    }
+    return *(const unsigned char*)s1 - *(const unsigned char*)s2;
+}
+
+int strncmp(const char *s1, const char *s2, size_t n) {
+    if (n == 0)
+        return 0;
+    do {
+        if (*s1 != *s2++)
+            return *(const unsigned char*)s1 - *(const unsigned char*)--s2;
+        if (*s1++ == 0)
+            break;
+    } while (--n != 0);
+    return 0;
+}
+
+/*****************************************************************************/
+/* for gcc -fstack-protector-all */
+unsigned long __stack_chk_guard = 0x000a0dff;
+
+void __stack_chk_fail(void)
+{
+        serial_puts("Stack is corrupted\n");
+        while (1) {
+                reset_cpu();
+        }
+}
+
+unsigned short crc16(unsigned char *data, unsigned int length)
+{
+	unsigned int i;
+	unsigned short crc_table;
+	unsigned short crc = 0xffff;
+	unsigned char inter1;
+	unsigned char inter2;
+
+	if (data == NULL)
+		return (crc);
+
+	for (i = 0; i < length; ++i) {
+		inter1 = data[i] ^ ((unsigned char) crc);
+		inter2 = (unsigned char) (inter1 ^ (inter1 << 4)); /* bit size 4 */
+		crc_table = (inter2 << 8) ^ (inter2 << 3) ^ (inter2 >> 4); /* bit size 8 3 4 */
+		crc = (crc >> 8) ^ crc_table; /* bit size 8 */
+	}
+	crc ^= 0xffff;
+	return (crc);
+}
+

mcu/riscv/libs/malloc.c

@@ -0,0 +1,46 @@
+
+#include <stddef.h>
+#include <hlist.h>
+#include "memlib.h"
+
+static struct list g_malloc_list = {0};
+
+void malloc_init(unsigned int base, unsigned int size)
+{
+    if ((g_malloc_list.base.next != NULL) && (g_malloc_list.base.prev != NULL)) {
+        return;
+    }
+    memlib_init(&g_malloc_list, base, size);
+}
+
+void *malloc(uint32 bytes)
+{
+    if ((g_malloc_list.base.next == NULL) || (g_malloc_list.base.prev == NULL)) {
+        return NULL;
+    }
+    return memlib_malloc(&g_malloc_list, bytes);
+}
+
+void *memalign(uint32 alignment, uint32 bytes)
+{
+    if ((g_malloc_list.base.next == NULL) || (g_malloc_list.base.prev == NULL)) {
+        return NULL;
+    }
+    return memlib_memalign(&g_malloc_list, alignment, bytes);
+}
+
+void free(void *ptr)
+{
+    if ((g_malloc_list.base.next == NULL) || (g_malloc_list.base.prev == NULL)) {
+        return;
+    }
+    memlib_free(&g_malloc_list, ptr);
+}
+
+void show_memnode(unsigned int cnt)
+{
+    if ((g_malloc_list.base.next == NULL) || (g_malloc_list.base.prev == NULL)) {
+        return;
+    }
+    memlib_show_memnode(&g_malloc_list, cnt);
+}

mcu/riscv/libs/memlib.c

@@ -0,0 +1,205 @@
+
+#include <stddef.h>
+#include <hlist.h>
+#include <stdio.h>
+
+#define MEM_ALLOC_MAGIC_NUM  0xACCA5995
+typedef struct _mem_node {
+	uint32 magicnum;
+	struct node nodeinfo;
+	/* Size & flag of the current node (the high two bits represent a flag,and the rest bits specify the size) */
+	uint32 size_flag;
+}mem_node;
+
+uint32 g_heap_start = 0;
+uint32 g_heap_end = 0;
+
+#define around(size, align)     (((size) + (align) - 1) & (~((align) - 1)))
+
+#define MEM_NODE_HEAD_SIZE             sizeof(struct _mem_node)
+#define MEM_ALIGN_SIZE                 4
+#define MEM_NODE_USED_FLAG             0x80000000U
+#define MEM_NODE_ALIGNED_FLAG          0x40000000U
+#define MEM_NODE_ALIGNED_AND_USED_FLAG (MEM_NODE_USED_FLAG | MEM_NODE_ALIGNED_FLAG)
+
+#define mem_node_get_used_flag(size_flag) ((size_flag) & MEM_NODE_USED_FLAG)
+#define mem_node_set_used_flag(size_flag)  ((size_flag) = ((size_flag) | MEM_NODE_USED_FLAG))
+#define mem_node_get_aligned_gapsize(sizeAndFlag) ((sizeAndFlag) & ~MEM_NODE_ALIGNED_FLAG)
+#define mem_node_get_aligned_flag(size_flag)  ((size_flag) & MEM_NODE_ALIGNED_FLAG)
+#define mem_node_set_aligned_flag(size_flag) ((size_flag) = ((size_flag) | MEM_NODE_ALIGNED_FLAG))
+#define mem_node_get_size(size_flag) ((size_flag) & ~MEM_NODE_ALIGNED_AND_USED_FLAG)
+
+#define mem_node_clear_used_aligned_flag(size_flag) ((size_flag) = (size_flag) & (~ (MEM_NODE_ALIGNED_AND_USED_FLAG)))
+
+#define is_pow_two(value)             ((((uintptr_t)(value)) & ((uintptr_t)(value) - 1)) == 0)
+#define is_aligned(value, alignSize)  ((((uintptr_t)(value)) & ((uintptr_t)((alignSize) - 1))) == 0)
+
+void memlib_init(struct list *listhead, unsigned int base, unsigned int size)
+{
+	mem_node *firstnode = (mem_node *)(uintptr_t)(base);
+	if (mem_node_get_used_flag(size) || mem_node_get_aligned_flag(size)) {
+		printf("malloc init failed, size:0x%x\n", size);
+		return;
+	}
+	list_init(listhead);
+	firstnode->magicnum = MEM_ALLOC_MAGIC_NUM;
+	firstnode->size_flag = size;
+	list_add_tail(listhead, &firstnode->nodeinfo);
+	g_heap_start = base;
+	g_heap_end = base + size;
+#ifdef CONFIG_DEBUG_INFO
+	puts("malloc init,base: 0x");puthex(g_heap_start);puts(", size: ");putdec(size);puts("\n");
+#endif
+}
+
+static void *mem_find_freeblock(struct list *listhead, uint32 allocsize)
+{
+	mem_node *entry = NULL;
+	mem_node *tmp = NULL;
+	mem_node *newnode = NULL;
+	unsigned int nodesize;
+	list_for_each_entry_safe(entry, tmp, listhead, mem_node, nodeinfo) {
+		nodesize = mem_node_get_size(entry->size_flag);
+		if ((!mem_node_get_used_flag(entry->size_flag)) && nodesize >= allocsize) {
+			if ((nodesize - allocsize) < (MEM_NODE_HEAD_SIZE + MEM_ALIGN_SIZE)) {
+				mem_node_set_used_flag(entry->size_flag);
+				return entry + 1;
+			} else {
+				newnode = (mem_node *)((uintptr_t)entry + allocsize);
+				newnode->magicnum = MEM_ALLOC_MAGIC_NUM;
+				newnode->size_flag = entry->size_flag - allocsize;
+				entry->size_flag = allocsize;
+				mem_node_set_used_flag(entry->size_flag);
+				list_insert_backward(&entry->nodeinfo, &newnode->nodeinfo); /* newnode 插入到 entry 后面 */
+				return entry + 1;
+			}
+		}
+	}
+	printf("no suitable free mem block\n");
+	return NULL;
+}
+
+void *memlib_malloc(struct list *listhead, uint32 bytes)
+{
+	void *ptr = NULL;
+	if (bytes == 0) {
+		return NULL;
+	}
+	uint32 allocsize = around(bytes + MEM_NODE_HEAD_SIZE, MEM_ALIGN_SIZE);
+	ptr = mem_find_freeblock(listhead, allocsize);
+	return ptr;
+}
+
+void *memlib_memalign(struct list *listhead, uint32 alignment, uint32 bytes)
+{
+	uint32 gap_size;
+	uint32 use_size;
+	void *ptr = NULL;
+	void *align_ptr = NULL;
+	mem_node *node = NULL;
+	if (bytes == 0 || alignment == 0 || !is_pow_two(alignment) || !is_aligned(alignment, sizeof(void*))) {
+		return NULL;
+	}
+
+	/*
+	 * sizeof(gap_size) bytes stores offset between align_ptr and ptr,
+	 * the ptr has been OS_MEM_ALIGN_SIZE(4 or 8) aligned, so maximum
+	 * offset between alignedPtr and ptr is alignment - OS_MEM_ALIGN_SIZE
+	 */
+	if ((alignment - sizeof(gap_size)) > ((uint32)(-1) - bytes)) {
+		return NULL;
+	}
+	use_size = around(bytes + MEM_NODE_HEAD_SIZE + alignment - sizeof(gap_size), MEM_ALIGN_SIZE);
+	if (mem_node_get_used_flag(use_size) || mem_node_get_aligned_flag(use_size)) {
+		printf("size is too large:0x%x\n", use_size);
+		return NULL;
+	}
+	ptr = mem_find_freeblock(listhead, use_size);
+	if (ptr == NULL) {
+		return NULL;
+	}
+	align_ptr = (void *)around((uintptr_t)ptr, alignment);
+	if (ptr == align_ptr) {
+		return ptr;
+	}
+	gap_size = (uintptr_t)align_ptr - (uintptr_t)ptr;
+	mem_node_set_aligned_flag(gap_size);
+	node = (mem_node *)ptr - 1;
+	mem_node_set_aligned_flag(node->size_flag);
+	*(uint32 *)((uintptr_t)align_ptr - sizeof(gap_size)) = gap_size;
+	ptr = align_ptr;
+	return ptr;
+}
+void *memptr_to_node(void *ptr)
+{
+	uint32 gapsize;
+	if (((uintptr_t)ptr) & (MEM_ALIGN_SIZE - 1)) {
+		printf("ptr not align by 4byte\n");
+		return NULL;
+	}
+	gapsize = *(uint32 *)((uintptr_t)ptr - sizeof(uint32));
+	if (mem_node_get_aligned_flag(gapsize) && mem_node_get_used_flag(gapsize)) {
+		printf("gapsize:0x%x error\n", gapsize);
+		return NULL;
+	}
+	if (mem_node_get_aligned_flag(gapsize)) {
+		gapsize = mem_node_get_aligned_gapsize(gapsize);
+		if ((gapsize & (MEM_ALIGN_SIZE - 1)) || (gapsize > ((uintptr_t)ptr - MEM_NODE_HEAD_SIZE))) {
+			return NULL;
+		}
+		ptr = (void *)((uintptr_t)ptr - gapsize);
+	}
+	return (void *)((uintptr_t)ptr - MEM_NODE_HEAD_SIZE);
+}
+
+void memlib_free(struct list *listhead, void *ptr)
+{
+	mem_node *entry = NULL;
+	mem_node *next_entry = NULL;
+	mem_node *pre_entry = NULL;
+	if (ptr == NULL) {
+		return;
+	}
+	entry = (mem_node *)memptr_to_node(ptr);
+	if (entry == NULL) {
+		return;
+	}
+	if (entry->magicnum != MEM_ALLOC_MAGIC_NUM) {
+		printf("MAGIC NUM is wrong! magicnum:0x%x\n", entry->magicnum);
+		return;
+	}
+	if (!mem_node_get_used_flag(entry->size_flag)) {
+		return;
+	}
+	mem_node_clear_used_aligned_flag(entry->size_flag);
+	next_entry = list_next_entry(entry, listhead, mem_node, nodeinfo);
+	if (next_entry != NULL) {
+		if (!mem_node_get_used_flag(next_entry->size_flag)) {
+			entry->size_flag += next_entry->size_flag;
+			next_entry->magicnum = 0;
+			list_remove(&next_entry->nodeinfo);
+		}
+	}
+	pre_entry = list_prev_entry(entry, listhead, mem_node, nodeinfo);
+	if (pre_entry != NULL) {
+		if (!mem_node_get_used_flag(pre_entry->size_flag)) {
+			pre_entry->size_flag += entry->size_flag;
+			entry->magicnum = 0;
+			list_remove(&entry->nodeinfo);
+		}
+	}
+}
+
+void memlib_show_memnode(struct list *listhead, unsigned int cnt)
+{
+	mem_node *entry = NULL;
+	uint32 i = 0;
+	list_for_each_entry(entry, listhead, mem_node, nodeinfo) {
+		printf("%d:entry, magic:0x%x, size: %d, used:0x%x, aligned:0x%x\n", i++, entry->magicnum,
+				mem_node_get_size(entry->size_flag), mem_node_get_used_flag(entry->size_flag),
+				mem_node_get_aligned_flag(entry->size_flag));
+		if (cnt != 0 && i == cnt) {
+			break;
+		}
+	}
+}

mcu/riscv/libs/memlib.h

@@ -0,0 +1,12 @@
+
+#ifndef _MEM_LIB_H_
+#define _MEM_LIB_H_
+
+#include <hlist.h>
+
+void memlib_init(struct list *listhead, unsigned int base, unsigned int size);
+void *memlib_malloc(struct list *listhead, unsigned int  bytes);
+void *memlib_memalign(struct list *listhead, unsigned int alignment, unsigned int bytes);
+void memlib_free(struct list *listhead, void *ptr);
+void memlib_show_memnode(struct list *listhead, unsigned int cnt);
+#endif /* _MEM_LIB_H_ */

mcu/riscv/libs/printf.c

@@ -0,0 +1,995 @@
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+//             2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
+//        embedded systems with a very limited resources. These routines are thread
+//        safe and reentrant!
+//        Use this instead of the bloated standard/newlib printf cause these use
+//        malloc for printf (and may not be thread safe).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <stdarg.h>
+#include <stddef.h>
+/* #include <sys/stat.h> */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+
+// define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H ...) to include the
+// printf_config.h header file
+// default: undefined
+#ifdef PRINTF_INCLUDE_CONFIG_H
+#include "printf_config.h"
+#endif
+
+
+// 'ntoa' conversion buffer size, this must be big enough to hold one converted
+// numeric number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_NTOA_BUFFER_SIZE
+#define PRINTF_NTOA_BUFFER_SIZE    32U
+#endif
+
+// 'ftoa' conversion buffer size, this must be big enough to hold one converted
+// float number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_FTOA_BUFFER_SIZE
+#define PRINTF_FTOA_BUFFER_SIZE    32U
+#endif
+
+// support for the floating point type (%f)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_FLOAT
+#define PRINTF_SUPPORT_FLOAT
+#endif
+
+// support for exponential floating point notation (%e/%g)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
+#define PRINTF_SUPPORT_EXPONENTIAL
+#endif
+
+// define the default floating point precision
+// default: 6 digits
+#ifndef PRINTF_DEFAULT_FLOAT_PRECISION
+#define PRINTF_DEFAULT_FLOAT_PRECISION  6U
+#endif
+
+// define the largest float suitable to print with %f
+// default: 1e9
+#ifndef PRINTF_MAX_FLOAT
+#define PRINTF_MAX_FLOAT  1e9
+#endif
+
+// support for the long long types (%llu or %p)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
+#define PRINTF_SUPPORT_LONG_LONG
+#endif
+
+// support for the ptrdiff_t type (%t)
+// ptrdiff_t is normally defined in <stddef.h> as long or long long type
+// default: activated
+/* #ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
+ * #define PRINTF_SUPPORT_PTRDIFF_T
+ * #endif */
+
+///////////////////////////////////////////////////////////////////////////////
+
+// internal flag definitions
+#define FLAGS_ZEROPAD   (1U <<  0U)
+#define FLAGS_LEFT      (1U <<  1U)
+#define FLAGS_PLUS      (1U <<  2U)
+#define FLAGS_SPACE     (1U <<  3U)
+#define FLAGS_HASH      (1U <<  4U)
+#define FLAGS_UPPERCASE (1U <<  5U)
+#define FLAGS_CHAR      (1U <<  6U)
+#define FLAGS_SHORT     (1U <<  7U)
+#define FLAGS_LONG      (1U <<  8U)
+#define FLAGS_LONG_LONG (1U <<  9U)
+#define FLAGS_PRECISION (1U << 10U)
+#define FLAGS_ADAPT_EXP (1U << 11U)
+
+
+// import float.h for DBL_MAX
+#if defined(PRINTF_SUPPORT_FLOAT)
+#include <float.h>
+#endif
+
+/* int _close(int fd)
+ * {
+ *     return -1;
+ * }
+ *
+ * caddr_t _sbrk(int incr)
+ * {
+ *     return NULL;
+ * }
+ *
+ * int _fstat(int fd, struct stat* st)
+ * {
+ *   return -1;
+ * }
+ *
+ * int _isatty(int fd)
+ * {
+ *   if (fd == (int)stdout || fd == (int)stderr)
+ *     return 1;
+ *
+ *   return 0;
+ * }
+ *
+ * long _lseek(int fd, off_t ptr, int dir)
+ * {
+ *   return -1;
+ * }
+ *
+ * int _read(int fd, void* ptr, size_t len)
+ * {
+ *   return -1;
+ * }
+ *
+ * int _write(int fd, const void* buffer, size_t count)
+ * {
+ *     char *s = (char *)buffer;
+ *     if (_isatty(fd))
+ *     {
+ *         for (int i = 0; i < count; i++)
+ *         {
+ *             fputc(*s, (void *)-1);
+ *             return count;
+ *         }
+ *     }
+ *
+ *     return -1;
+ * } */
+
+
+
+/* int putc(int c, FILE *stream)
+ * {
+ *    return fputc(c, stream);
+ * } */
+
+
+
+/* int puts(const char *s)
+ * {
+ *    while(*s !='\0')
+ *    {
+ *        putchar(*s);
+ *        s++;
+ *    }
+ *    putchar('\n');
+ *    return 0;
+ * } */
+
+// output function type
+typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen);
+
+
+// wrapper (used as buffer) for output function type
+typedef struct {
+  void  (*fct)(char character, void* arg);
+  void* arg;
+} out_fct_wrap_type;
+
+
+// internal buffer output
+static inline void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen)
+{
+  if (idx < maxlen) {
+    ((char*)buffer)[idx] = character;
+  }
+}
+
+
+// internal null output
+static inline void _out_null(char character, void* buffer, size_t idx, size_t maxlen)
+{
+  (void)character; (void)buffer; (void)idx; (void)maxlen;
+}
+
+
+static inline void _out_char(char character, void* buffer, size_t idx, size_t maxlen)
+{
+  (void)buffer; (void)idx; (void)maxlen;
+  if (character) {
+    putchar(character);
+  }
+}
+
+
+// internal output function wrapper
+static inline void _out_fct(char character, void* buffer, size_t idx, size_t maxlen)
+{
+  (void)idx; (void)maxlen;
+  if (character) {
+    // buffer is the output fct pointer
+    ((out_fct_wrap_type*)buffer)->fct(character, ((out_fct_wrap_type*)buffer)->arg);
+  }
+}
+
+
+// internal secure strlen
+// \return The length of the string (excluding the terminating 0) limited by 'maxsize'
+static inline unsigned int _strnlen_s(const char* str, size_t maxsize)
+{
+  const char* s;
+  for (s = str; *s && maxsize--; ++s);
+  return (unsigned int)(s - str);
+}
+
+
+// internal test if char is a digit (0-9)
+// \return true if char is a digit
+static inline bool _is_digit(char ch)
+{
+  return (ch >= '0') && (ch <= '9');
+}
+
+
+// internal ASCII string to unsigned int conversion
+static unsigned int _atoi(const char** str)
+{
+  unsigned int i = 0U;
+  while (_is_digit(**str)) {
+    i = i * 10U + (unsigned int)(*((*str)++) - '0');
+  }
+  return i;
+}
+
+
+// output the specified string in reverse, taking care of any zero-padding
+static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
+{
+  const size_t start_idx = idx;
+
+  // pad spaces up to given width
+  if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
+    for (size_t i = len; i < width; i++) {
+      out(' ', buffer, idx++, maxlen);
+    }
+  }
+
+  // reverse string
+  while (len) {
+    out(buf[--len], buffer, idx++, maxlen);
+  }
+
+  // append pad spaces up to given width
+  if (flags & FLAGS_LEFT) {
+    while (idx - start_idx < width) {
+      out(' ', buffer, idx++, maxlen);
+    }
+  }
+
+  return idx;
+}
+
+
+// internal itoa format
+static size_t _ntoa_format(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, unsigned int base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+  // pad leading zeros
+  if (!(flags & FLAGS_LEFT)) {
+    if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+      width--;
+    }
+    while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = '0';
+    }
+    while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = '0';
+    }
+  }
+
+  // handle hash
+  if (flags & FLAGS_HASH) {
+    if (!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) {
+      len--;
+      if (len && (base == 16U)) {
+        len--;
+      }
+    }
+    if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = 'x';
+    }
+    else if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = 'X';
+    }
+    else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = 'b';
+    }
+    if (len < PRINTF_NTOA_BUFFER_SIZE) {
+      buf[len++] = '0';
+    }
+  }
+
+  if (len < PRINTF_NTOA_BUFFER_SIZE) {
+    if (negative) {
+      buf[len++] = '-';
+    }
+    else if (flags & FLAGS_PLUS) {
+      buf[len++] = '+';  // ignore the space if the '+' exists
+    }
+    else if (flags & FLAGS_SPACE) {
+      buf[len++] = ' ';
+    }
+  }
+
+  return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+
+// internal itoa for 'long' type
+static size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long value, bool negative, unsigned long base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+  char buf[PRINTF_NTOA_BUFFER_SIZE];
+  size_t len = 0U;
+
+  // no hash for 0 values
+  if (!value) {
+    flags &= ~FLAGS_HASH;
+  }
+
+  // write if precision != 0 and value is != 0
+  if (!(flags & FLAGS_PRECISION) || value) {
+    do {
+      const char digit = (char)(value % base);
+      buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+      value /= base;
+    } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+  }
+
+  return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+
+
+// internal itoa for 'long long' type
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+  char buf[PRINTF_NTOA_BUFFER_SIZE];
+  size_t len = 0U;
+
+  // no hash for 0 values
+  if (!value) {
+    flags &= ~FLAGS_HASH;
+  }
+
+  // write if precision != 0 and value is != 0
+  if (!(flags & FLAGS_PRECISION) || value) {
+    do {
+      const char digit = (char)(value % base);
+      buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+      value /= base;
+    } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+  }
+
+  return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+#endif  // PRINTF_SUPPORT_LONG_LONG
+
+
+#if defined(PRINTF_SUPPORT_FLOAT)
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
+static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags);
+#endif
+
+
+// internal ftoa for fixed decimal floating point
+static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
+{
+  char buf[PRINTF_FTOA_BUFFER_SIZE];
+  size_t len  = 0U;
+  double diff = 0.0;
+
+  // powers of 10
+  static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+
+  // test for special values
+  if (value != value)
+    return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
+  if (value < -DBL_MAX)
+    return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
+  if (value > DBL_MAX)
+    return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
+
+  // test for very large values
+  // standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
+  if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+    return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
+#else
+    return 0U;
+#endif
+  }
+
+  // test for negative
+  bool negative = false;
+  if (value < 0) {
+    negative = true;
+    value = 0 - value;
+  }
+
+  // set default precision, if not set explicitly
+  if (!(flags & FLAGS_PRECISION)) {
+    prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+  }
+  // limit precision to 9, cause a prec >= 10 can lead to overflow errors
+  while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
+    buf[len++] = '0';
+    prec--;
+  }
+
+  int whole = (int)value;
+  double tmp = (value - whole) * pow10[prec];
+  unsigned long frac = (unsigned long)tmp;
+  diff = tmp - frac;
+
+  if (diff > 0.5) {
+    ++frac;
+    // handle rollover, e.g. case 0.99 with prec 1 is 1.0
+    if (frac >= pow10[prec]) {
+      frac = 0;
+      ++whole;
+    }
+  }
+  else if (diff < 0.5) {
+  }
+  else if ((frac == 0U) || (frac & 1U)) {
+    // if halfway, round up if odd OR if last digit is 0
+    ++frac;
+  }
+
+  if (prec == 0U) {
+    diff = value - (double)whole;
+    if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
+      // exactly 0.5 and ODD, then round up
+      // 1.5 -> 2, but 2.5 -> 2
+      ++whole;
+    }
+  }
+  else {
+    unsigned int count = prec;
+    // now do fractional part, as an unsigned number
+    while (len < PRINTF_FTOA_BUFFER_SIZE) {
+      --count;
+      buf[len++] = (char)(48U + (frac % 10U));
+      if (!(frac /= 10U)) {
+        break;
+      }
+    }
+    // add extra 0s
+    while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
+      buf[len++] = '0';
+    }
+    if (len < PRINTF_FTOA_BUFFER_SIZE) {
+      // add decimal
+      buf[len++] = '.';
+    }
+  }
+
+  // do whole part, number is reversed
+  while (len < PRINTF_FTOA_BUFFER_SIZE) {
+    buf[len++] = (char)(48 + (whole % 10));
+    if (!(whole /= 10)) {
+      break;
+    }
+  }
+
+  // pad leading zeros
+  if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
+    if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+      width--;
+    }
+    while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
+      buf[len++] = '0';
+    }
+  }
+
+  if (len < PRINTF_FTOA_BUFFER_SIZE) {
+    if (negative) {
+      buf[len++] = '-';
+    }
+    else if (flags & FLAGS_PLUS) {
+      buf[len++] = '+';  // ignore the space if the '+' exists
+    }
+    else if (flags & FLAGS_SPACE) {
+      buf[len++] = ' ';
+    }
+  }
+
+  return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
+static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
+{
+  // check for NaN and special values
+  if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
+    return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
+  }
+
+  // determine the sign
+  const bool negative = value < 0;
+  if (negative) {
+    value = -value;
+  }
+
+  // default precision
+  if (!(flags & FLAGS_PRECISION)) {
+    prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+  }
+
+  // determine the decimal exponent
+  // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
+  union {
+    uint64_t U;
+    double   F;
+  } conv;
+
+  conv.F = value;
+  int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023;           // effectively log2
+  conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U);  // drop the exponent so conv.F is now in [1,2)
+  // now approximate log10 from the log2 integer part and an expansion of ln around 1.5
+  int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
+  // now we want to compute 10^expval but we want to be sure it won't overflow
+  exp2 = (int)(expval * 3.321928094887362 + 0.5);
+  const double z  = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
+  const double z2 = z * z;
+  conv.U = (uint64_t)(exp2 + 1023) << 52U;
+  // compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
+  conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
+  // correct for rounding errors
+  if (value < conv.F) {
+    expval--;
+    conv.F /= 10;
+  }
+
+  // the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
+  unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
+
+  // in "%g" mode, "prec" is the number of *significant figures* not decimals
+  if (flags & FLAGS_ADAPT_EXP) {
+    // do we want to fall-back to "%f" mode?
+    if ((value >= 1e-4) && (value < 1e6)) {
+      if ((int)prec > expval) {
+        prec = (unsigned)((int)prec - expval - 1);
+      }
+      else {
+        prec = 0;
+      }
+      flags |= FLAGS_PRECISION;   // make sure _ftoa respects precision
+      // no characters in exponent
+      minwidth = 0U;
+      expval   = 0;
+    }
+    else {
+      // we use one sigfig for the whole part
+      if ((prec > 0) && (flags & FLAGS_PRECISION)) {
+        --prec;
+      }
+    }
+  }
+
+  // will everything fit?
+  unsigned int fwidth = width;
+  if (width > minwidth) {
+    // we didn't fall-back so subtract the characters required for the exponent
+    fwidth -= minwidth;
+  } else {
+    // not enough characters, so go back to default sizing
+    fwidth = 0U;
+  }
+  if ((flags & FLAGS_LEFT) && minwidth) {
+    // if we're padding on the right, DON'T pad the floating part
+    fwidth = 0U;
+  }
+
+  // rescale the float value
+  if (expval) {
+    value /= conv.F;
+  }
+
+  // output the floating part
+  const size_t start_idx = idx;
+  idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
+
+  // output the exponent part
+  if (minwidth) {
+    // output the exponential symbol
+    out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
+    // output the exponent value
+    idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth-1, FLAGS_ZEROPAD | FLAGS_PLUS);
+    // might need to right-pad spaces
+    if (flags & FLAGS_LEFT) {
+      while (idx - start_idx < width) out(' ', buffer, idx++, maxlen);
+    }
+  }
+  return idx;
+}
+#endif  // PRINTF_SUPPORT_EXPONENTIAL
+#endif  // PRINTF_SUPPORT_FLOAT
+
+
+// internal vsnprintf
+static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va)
+{
+  unsigned int flags, width, precision, n;
+  size_t idx = 0U;
+
+  if (!buffer) {
+    // use null output function
+    out = _out_null;
+  }
+
+  while (*format)
+  {
+    // format specifier?  %[flags][width][.precision][length]
+    if (*format != '%') {
+      // no
+      out(*format, buffer, idx++, maxlen);
+      format++;
+      continue;
+    }
+    else {
+      // yes, evaluate it
+      format++;
+    }
+
+    // evaluate flags
+    flags = 0U;
+    do {
+      switch (*format) {
+        case '0': flags |= FLAGS_ZEROPAD; format++; n = 1U; break;
+        case '-': flags |= FLAGS_LEFT;    format++; n = 1U; break;
+        case '+': flags |= FLAGS_PLUS;    format++; n = 1U; break;
+        case ' ': flags |= FLAGS_SPACE;   format++; n = 1U; break;
+        case '#': flags |= FLAGS_HASH;    format++; n = 1U; break;
+        default :                                   n = 0U; break;
+      }
+    } while (n);
+
+    // evaluate width field
+    width = 0U;
+    if (_is_digit(*format)) {
+      width = _atoi(&format);
+    }
+    else if (*format == '*') {
+      const int w = va_arg(va, int);
+      if (w < 0) {
+        flags |= FLAGS_LEFT;    // reverse padding
+        width = (unsigned int)-w;
+      }
+      else {
+        width = (unsigned int)w;
+      }
+      format++;
+    }
+
+    // evaluate precision field
+    precision = 0U;
+    if (*format == '.') {
+      flags |= FLAGS_PRECISION;
+      format++;
+      if (_is_digit(*format)) {
+        precision = _atoi(&format);
+      }
+      else if (*format == '*') {
+        const int prec = (int)va_arg(va, int);
+        precision = prec > 0 ? (unsigned int)prec : 0U;
+        format++;
+      }
+    }
+
+    // evaluate length field
+    switch (*format) {
+      case 'l' :
+        flags |= FLAGS_LONG;
+        format++;
+        if (*format == 'l') {
+          flags |= FLAGS_LONG_LONG;
+          format++;
+        }
+        break;
+      case 'h' :
+        flags |= FLAGS_SHORT;
+        format++;
+        if (*format == 'h') {
+          flags |= FLAGS_CHAR;
+          format++;
+        }
+        break;
+#if defined(PRINTF_SUPPORT_PTRDIFF_T)
+      case 't' :
+        flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+        format++;
+        break;
+#endif
+      case 'j' :
+        flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+        format++;
+        break;
+      case 'z' :
+        flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+        format++;
+        break;
+      default :
+        break;
+    }
+
+    // evaluate specifier
+    switch (*format) {
+      case 'd' :
+      case 'i' :
+      case 'u' :
+      case 'x' :
+      case 'X' :
+      case 'o' :
+      case 'b' : {
+        // set the base
+        unsigned int base;
+        if (*format == 'x' || *format == 'X') {
+          base = 16U;
+        }
+        else if (*format == 'o') {
+          base =  8U;
+        }
+        else if (*format == 'b') {
+          base =  2U;
+        }
+        else {
+          base = 10U;
+          flags &= ~FLAGS_HASH;   // no hash for dec format
+        }
+        // uppercase
+        if (*format == 'X') {
+          flags |= FLAGS_UPPERCASE;
+        }
+
+        // no plus or space flag for u, x, X, o, b
+        if ((*format != 'i') && (*format != 'd')) {
+          flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
+        }
+
+        // ignore '0' flag when precision is given
+        if (flags & FLAGS_PRECISION) {
+          flags &= ~FLAGS_ZEROPAD;
+        }
+
+        // convert the integer
+        if ((*format == 'i') || (*format == 'd')) {
+          // signed
+          if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+            const long long value = va_arg(va, long long);
+            idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
+#endif
+          }
+          else if (flags & FLAGS_LONG) {
+            const long value = va_arg(va, long);
+            idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
+          }
+          else {
+            const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, int) : va_arg(va, int);
+            idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
+          }
+        }
+        else {
+          // unsigned
+          if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+            idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags);
+#endif
+          }
+          else if (flags & FLAGS_LONG) {
+            idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags);
+          }
+          else {
+            const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va, unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) : va_arg(va, unsigned int);
+            idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
+          }
+        }
+        format++;
+        break;
+      }
+#if defined(PRINTF_SUPPORT_FLOAT)
+      case 'f' :
+      case 'F' :
+        if (*format == 'F') flags |= FLAGS_UPPERCASE;
+        idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+        format++;
+        break;
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+      case 'e':
+      case 'E':
+      case 'g':
+      case 'G':
+        if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP;
+        if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE;
+        idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+        format++;
+        break;
+#endif  // PRINTF_SUPPORT_EXPONENTIAL
+#endif  // PRINTF_SUPPORT_FLOAT
+      case 'c' : {
+        unsigned int l = 1U;
+        // pre padding
+        if (!(flags & FLAGS_LEFT)) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        // char output
+        out((char)va_arg(va, int), buffer, idx++, maxlen);
+        // post padding
+        if (flags & FLAGS_LEFT) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        format++;
+        break;
+      }
+
+      case 's' : {
+        const char* p = va_arg(va, char*);
+        unsigned int l = _strnlen_s(p, precision ? precision : (size_t)-1);
+        // pre padding
+        if (flags & FLAGS_PRECISION) {
+          l = (l < precision ? l : precision);
+        }
+        if (!(flags & FLAGS_LEFT)) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        // string output
+        while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
+          out(*(p++), buffer, idx++, maxlen);
+        }
+        // post padding
+        if (flags & FLAGS_LEFT) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        format++;
+        break;
+      }
+
+      case 'p' : {
+        width = sizeof(void*) * 2U;
+        flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+        const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
+        if (is_ll) {
+          idx = _ntoa_long_long(out, buffer, idx, maxlen, (uintptr_t)va_arg(va, void*), false, 16U, precision, width, flags);
+        }
+        else {
+#endif
+          idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)((uintptr_t)va_arg(va, void*)), false, 16U, precision, width, flags);
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+        }
+#endif
+        format++;
+        break;
+      }
+
+      case '%' :
+        out('%', buffer, idx++, maxlen);
+        format++;
+        break;
+
+      default :
+        out(*format, buffer, idx++, maxlen);
+        format++;
+        break;
+    }
+  }
+
+  // termination
+  out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+  // return written chars without terminating \0
+  return (int)idx;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+int printf(const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  char buffer[1];
+  const int ret = _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
+  va_end(va);
+  return ret;
+}
+
+/* int fprintf(FILE *stream, const char* format, ...)
+ * {
+ *
+ *   va_list va;
+ *   va_start(va, format);
+ *   char buffer[1];
+ *   const int ret = _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
+ *   va_end(va);
+ *   return ret;
+ * } */
+
+
+
+int sprintf(char* buffer, const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va);
+  va_end(va);
+  return ret;
+}
+
+
+int snprintf(char* buffer, size_t count, const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  const int ret = _vsnprintf(_out_buffer, buffer, count, format, va);
+  va_end(va);
+  return ret;
+}
+
+
+int vprintf(const char* format, va_list va)
+{
+  char buffer[1];
+  return _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
+}
+
+
+int vsnprintf(char* buffer, size_t count, const char* format, va_list va)
+{
+  return _vsnprintf(_out_buffer, buffer, count, format, va);
+}
+
+
+int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  const out_fct_wrap_type out_fct_wrap = { out, arg };
+  const int ret = _vsnprintf(_out_fct, (char*)(uintptr_t)&out_fct_wrap, (size_t)-1, format, va);
+  va_end(va);
+  return ret;
+}

mcu/riscv/libs/reserved_mem.c

@@ -0,0 +1,91 @@
+
+#include <string.h>
+#include <debug.h>
+#include <common.h>
+
+#undef __RSV_MEM_DEBUG
+
+struct rsv_memctrl_t {
+	uint32 start;
+	uint32 end;
+	uint32 pos;
+};
+
+static struct rsv_memctrl_t g_rsv_memctrl = {0};
+
+void rsv_mem_init(uint32 start, uint32 len)
+{
+	if (g_rsv_memctrl.end == 0) {
+		g_rsv_memctrl.start = start;
+		g_rsv_memctrl.end = start + len;
+		g_rsv_memctrl.pos = 0;
+	}
+
+#ifdef CONFIG_DEBUG_INFO
+	puts("Reserved mem: 0x");puthex(start);puts(" - 0x");puthex(start + len);puts("\n");
+#endif
+}
+
+void rsv_mem_reinit(uint32 start, uint32 len)
+{
+	g_rsv_memctrl.end = 0;
+	rsv_mem_init(start, len);
+}
+
+void *__rsv_mem_alloc(uint32 bytes, const char *file, int line)
+{
+	uint32 new_ptr;
+	void *ptr = NULL;
+	if (g_rsv_memctrl.end == 0) {
+		pr_error("malloc module uninitializtion.\n");
+		return NULL;
+	}
+
+	new_ptr = g_rsv_memctrl.start + g_rsv_memctrl.pos + around(bytes, 4); /* 4 bytes align */
+	if (new_ptr >  g_rsv_memctrl.end) {
+		return NULL;
+	}
+	ptr = (void *)(uintptr_t)(g_rsv_memctrl.start + g_rsv_memctrl.pos);
+	g_rsv_memctrl.pos += around(bytes, 4); /* 4 bytes align */
+#ifdef __RSV_MEM_DEBUG
+	puts(file);puts("(");putdec(line);puts("): rsv mem alloc 0x");puthex((ulong)ptr);puts("(");putdec(bytes);puts(")\n");
+#endif
+	return ptr;
+}
+
+void *__rsv_mem_align(uint32 alignment, uint32 bytes, const char *file, int line)
+{
+	uint32 new_addr;
+	void *ptr = NULL;
+
+	if (g_rsv_memctrl.end == 0) {
+		puts("rsv mem NOT initialized.\n");
+		return NULL;
+	}
+
+	if (alignment & (alignment - 1)) {
+		puts("align must be powed of 2\n");
+		return NULL;
+	}
+
+	new_addr = around(g_rsv_memctrl.start + g_rsv_memctrl.pos, alignment);
+	if (new_addr + around(bytes, 4) > g_rsv_memctrl.end) { /* 4 bytes align */
+		return NULL;
+	}
+
+	g_rsv_memctrl.pos = new_addr - g_rsv_memctrl.start + around(bytes, 4); /* 4 bytes align */
+	ptr = (void *)(uintptr_t)new_addr;
+
+#ifdef __RSV_MEM_DEBUG
+	puts(file);puts("(");putdec(line);puts("): rsv mem align 0x");puthex((ulong)ptr);puts("(");putdec(bytes);puts(")\n");
+#endif
+	return ptr;
+}
+
+void dump_rsv_mem_info(void)
+{
+	puts("Reserved Mem Info:\n");
+	puts("start:       0x");puthex(g_rsv_memctrl.start);puts("\n");
+	puts("end:         0x");puthex(g_rsv_memctrl.end);puts("\n");
+	puts("pos:         0x");puthex(g_rsv_memctrl.pos);puts("\n");
+}

mcu/riscv/libs/simple_malloc.c

@@ -0,0 +1,84 @@
+
+#include <malloc.h>
+#include <string.h>
+#include <debug.h>
+#include <common.h>
+
+struct memctrl_t {
+    uint32 start;
+    uint32 end;
+    uint32 pos;
+};
+
+uint32 g_heap_start = 0;
+uint32 g_heap_end = 0;
+
+static struct memctrl_t g_memctrl = {0};
+void malloc_init(uint32 start, uint32 len)
+{
+    if (g_memctrl.end == 0) {
+        g_heap_start = g_memctrl.start = start;
+        g_heap_end = g_memctrl.end = start + len;
+        g_memctrl.pos = 0;
+    }
+}
+
+void *__malloc(uint32 bytes, const char *file, int line)
+{
+    uint32 new_ptr;
+    void *ptr = NULL;
+    if (g_memctrl.end == 0) {
+        pr_error("malloc module uninitializtion.\n");
+        return NULL;
+    }
+
+    pr_debug("%s(%d): malloc:0x%x\n" _NONE, file, line, bytes);
+    new_ptr = g_memctrl.start + g_memctrl.pos + around(bytes, 4); /* 4 bytes align */
+    if (new_ptr >  g_memctrl.end) {
+        return NULL;
+    }
+    ptr = (void *)(uintptr_t)(g_memctrl.start + g_memctrl.pos);
+    g_memctrl.pos += around(bytes, 4); /* 4 bytes align */
+    return ptr;
+}
+
+void __free(const void *mem, const char *file, int line)
+{
+    if (g_memctrl.end == 0) {
+        pr_error("malloc module uninitializtion.\n");
+        return;
+    }
+
+    pr_debug("%s(%d): free\n" _NONE, file, line);
+    return;
+}
+
+void *__memalign(uint32 alignment, uint32 bytes, const char *file, int line)
+{
+    uint32 new_addr;
+    void *ptr = NULL;
+    if (g_memctrl.end == 0) {
+        pr_error("malloc module uninitializtion.\n");
+        return NULL;
+    }
+    if (alignment & (alignment - 1)) {
+        pr_error("align must be powed of 2\n");
+        return NULL;
+    }
+    new_addr = around(g_memctrl.start + g_memctrl.pos, alignment);
+    if (new_addr + around(bytes, 4) > g_memctrl.end) { /* 4 bytes align */
+        return NULL;
+    }
+    g_memctrl.pos = new_addr - g_memctrl.start + around(bytes, 4); /* 4 bytes align */
+    ptr = (void *)(uintptr_t)new_addr;
+    pr_debug("%s(%d): memalign:0x%x\n" _NONE, file, line, bytes);
+
+    return ptr;
+}
+
+void dump_malloc(void)
+{
+    printf("start:       0x%08x\n", g_memctrl.start);
+    printf("end:         0x%08x\n", g_memctrl.end);
+    printf("pos:         0x%08x\n", g_memctrl.pos);
+}

mcu/riscv/libs/stdio.c

@@ -0,0 +1,53 @@
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <string.h>
+#include <div64.h>
+#include <serial.h>
+
+extern void serial_put_hex(u32 hex);
+extern void serial_put_dec(u32 dec);
+/*****************************************************************************/
+
+int putchar(int c)
+{
+	if (c == '\n')
+		serial_putc('\r');
+	serial_putc(c);
+	return c;
+}
+
+int puts(const char *s)
+{
+	const char *ptr = s;
+
+	while (*ptr)
+		putchar(*ptr++);
+
+	return (ptr - s);
+}
+
+void puts_always(const char *s)
+{
+	serial_puts_always(s);
+}
+
+void puthex(unsigned int hex)
+{
+	serial_put_hex(hex);
+}
+
+void puthex_always(unsigned int hex)
+{
+	serial_put_hex_always(hex);
+}
+
+void putdec(unsigned int dec)
+{
+	serial_put_dec(dec);
+}
+
+int getchar(void)
+{
+	return serial_getc();
+}