#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <rt_sys.h>
#include "RTE_Components.h"
#ifdef RTE_Compiler_IO_STDOUT_EVR
#include "EventRecorder.h"
#endif
#ifdef RTE_Compiler_IO_File_FS
#include "rl_fs_lib.h"
#endif
#ifndef STDIN_ECHO
#define STDIN_ECHO 0
#endif
#ifndef STDOUT_CR_LF
#define STDOUT_CR_LF 0
#endif
#ifndef STDERR_CR_LF
#define STDERR_CR_LF 0
#endif
#if (defined(RTE_Compiler_IO_TTY_ITM) || \
defined(RTE_Compiler_IO_STDIN_ITM) || \
defined(RTE_Compiler_IO_STDOUT_ITM) || \
defined(RTE_Compiler_IO_STDERR_ITM))
#define ITM_PORT0_U8 (*((volatile uint8_t *)0xE0000000))
#define ITM_PORT0_U32 (*((volatile uint32_t *)0xE0000000))
#define ITM_TER (*((volatile uint32_t *)0xE0000E00))
#define ITM_TCR (*((volatile uint32_t *)0xE0000E80))
#define ITM_TCR_ITMENA_Msk (1UL << 0)
#define ITM_RXBUFFER_EMPTY 0x5AA55AA5
extern
volatile int32_t ITM_RxBuffer;
volatile int32_t ITM_RxBuffer = ITM_RXBUFFER_EMPTY;
int32_t ITM_SendChar (int32_t ch);
int32_t ITM_SendChar (int32_t ch) {
if ((ITM_TCR & ITM_TCR_ITMENA_Msk) &&
(ITM_TER & (1UL << 0) )) {
while (ITM_PORT0_U32 == 0);
ITM_PORT0_U8 = (uint8_t)ch;
}
return (ch);
}
int32_t ITM_ReceiveChar (void);
int32_t ITM_ReceiveChar (void) {
int32_t ch = -1;
if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY) {
ch = ITM_RxBuffer;
ITM_RxBuffer = ITM_RXBUFFER_EMPTY;
}
return (ch);
}
#endif
#if defined(RTE_Compiler_IO_STDIN)
#if defined(RTE_Compiler_IO_STDIN_User)
extern int stdin_getchar (void);
#elif defined(RTE_Compiler_IO_STDIN_ITM)
static int stdin_getchar (void) {
int32_t ch;
do {
ch = ITM_ReceiveChar();
} while (ch == -1);
return (ch);
}
#elif defined(RTE_Compiler_IO_STDIN_BKPT)
static int stdin_getchar (void) {
int32_t ch = -1;
__asm("BKPT 0");
return (ch);
}
#endif
#endif
#if defined(RTE_Compiler_IO_STDOUT)
#if defined(RTE_Compiler_IO_STDOUT_User)
extern int stdout_putchar (int ch);
#elif defined(RTE_Compiler_IO_STDOUT_ITM)
static int stdout_putchar (int ch) {
return (ITM_SendChar(ch));
}
#elif defined(RTE_Compiler_IO_STDOUT_EVR)
static int stdout_putchar (int ch) {
static uint32_t index = 0U;
static uint8_t buffer[8];
if (index >= 8U) {
return (-1);
}
buffer[index++] = (uint8_t)ch;
if ((index == 8U) || (ch == '\n')) {
EventRecordData(EventID(EventLevelOp, 0xFE, 0x00), buffer, index);
index = 0U;
}
return (ch);
}
#elif defined(RTE_Compiler_IO_STDOUT_BKPT)
static int stdout_putchar (int ch) {
__asm("BKPT 0");
return (ch);
}
#endif
#endif
#if defined(RTE_Compiler_IO_STDERR)
#if defined(RTE_Compiler_IO_STDERR_User)
extern int stderr_putchar (int ch);
#elif defined(RTE_Compiler_IO_STDERR_ITM)
static int stderr_putchar (int ch) {
return (ITM_SendChar(ch));
}
#elif defined(RTE_Compiler_IO_STDERR_BKPT)
static int stderr_putchar (int ch) {
__asm("BKPT 0");
return (ch);
}
#endif
#endif
#ifdef __MICROLIB
#ifdef RTE_Compiler_IO_STDIN
static int getchar_undo = 0;
static int getchar_ch = -1;
#endif
__attribute__((weak))
int fputc (int c, FILE * stream) {
#if (!defined(RTE_Compiler_IO_STDOUT) && !defined(RTE_Compiler_IO_STDERR))
(void)c;
(void)stream;
#endif
#ifdef RTE_Compiler_IO_STDOUT
if (stream == &__stdout) {
#if (STDOUT_CR_LF != 0)
if (c == '\n') stdout_putchar('\r');
#endif
return (stdout_putchar(c));
}
#endif
#ifdef RTE_Compiler_IO_STDERR
if (stream == &__stderr) {
#if (STDERR_CR_LF != 0)
if (c == '\n') stderr_putchar('\r');
#endif
return (stderr_putchar(c));
}
#endif
return (-1);
}
__attribute__((weak))
int fgetc (FILE * stream) {
#ifdef RTE_Compiler_IO_STDIN
int ch;
if (stream == &__stdin) {
if (getchar_undo) {
ch = getchar_ch;
getchar_ch = -1;
getchar_undo = 0;
return (ch);
}
ch = stdin_getchar();
#if (STDIN_ECHO != 0)
stdout_putchar(ch);
#endif
getchar_ch = ch;
return (ch);
}
#else
(void)stream;
#endif
return (-1);
}
__attribute__((weak))
int __backspace(FILE *stream);
int __backspace(FILE *stream) {
#ifdef RTE_Compiler_IO_STDIN
if (stream == &__stdin) {
if (getchar_ch != -1) {
getchar_undo = 1;
return (0);
}
return (-1);
}
#else
(void)stream;
#endif
return (-1);
}
__attribute__((weak,noreturn))
void __aeabi_assert (const char *expr, const char *file, int line) {
char str[12], *p;
fputs("*** assertion failed: ", stderr);
fputs(expr, stderr);
fputs(", file ", stderr);
fputs(file, stderr);
fputs(", line ", stderr);
p = str + sizeof(str);
*--p = '\0';
*--p = '\n';
while (line > 0) {
*--p = '0' + (line % 10);
line /= 10;
}
fputs(p, stderr);
abort();
}
__attribute__((weak))
void abort(void) {
for (;;);
}
#else
#if (defined(RTE_Compiler_IO_STDIN) || \
defined(RTE_Compiler_IO_STDOUT) || \
defined(RTE_Compiler_IO_STDERR) || \
defined(RTE_Compiler_IO_File))
#define RETARGET_SYS
#define FH_STDIN 0x8001
#define FH_STDOUT 0x8002
#define FH_STDERR 0x8003
const char __stdin_name[] = ":STDIN";
const char __stdout_name[] = ":STDOUT";
const char __stderr_name[] = ":STDERR";
#endif
#ifdef RETARGET_SYS
__attribute__((weak))
FILEHANDLE _sys_open (const char *name, int openmode) {
#if (!defined(RTE_Compiler_IO_File))
(void)openmode;
#endif
if (name == NULL) {
return (-1);
}
if (name[0] == ':') {
if (strcmp(name, ":STDIN") == 0) {
return (FH_STDIN);
}
if (strcmp(name, ":STDOUT") == 0) {
return (FH_STDOUT);
}
if (strcmp(name, ":STDERR") == 0) {
return (FH_STDERR);
}
return (-1);
}
#ifdef RTE_Compiler_IO_File
#ifdef RTE_Compiler_IO_File_FS
return (__sys_open(name, openmode));
#endif
#else
return (-1);
#endif
}
#endif
#ifdef RETARGET_SYS
__attribute__((weak))
int _sys_close (FILEHANDLE fh) {
switch (fh) {
case FH_STDIN:
return (0);
case FH_STDOUT:
return (0);
case FH_STDERR:
return (0);
}
#ifdef RTE_Compiler_IO_File
#ifdef RTE_Compiler_IO_File_FS
return (__sys_close(fh));
#endif
#else
return (-1);
#endif
}
#endif
#ifdef RETARGET_SYS
__attribute__((weak))
int _sys_write (FILEHANDLE fh, const uint8_t *buf, uint32_t len, int mode) {
#if (defined(RTE_Compiler_IO_STDOUT) || defined(RTE_Compiler_IO_STDERR))
int ch;
#elif (!defined(RTE_Compiler_IO_File))
(void)buf;
(void)len;
#endif
(void)mode;
switch (fh) {
case FH_STDIN:
return (-1);
case FH_STDOUT:
#ifdef RTE_Compiler_IO_STDOUT
for (; len; len--) {
ch = *buf++;
#if (STDOUT_CR_LF != 0)
if (ch == '\n') stdout_putchar('\r');
#endif
stdout_putchar(ch);
}
#endif
return (0);
case FH_STDERR:
#ifdef RTE_Compiler_IO_STDERR
for (; len; len--) {
ch = *buf++;
#if (STDERR_CR_LF != 0)
if (ch == '\n') stderr_putchar('\r');
#endif
stderr_putchar(ch);
}
#endif
return (0);
}
#ifdef RTE_Compiler_IO_File
#ifdef RTE_Compiler_IO_File_FS
return (__sys_write(fh, buf, len));
#endif
#else
return (-1);
#endif
}
#endif
#ifdef RETARGET_SYS
__attribute__((weak))
int _sys_read (FILEHANDLE fh, uint8_t *buf, uint32_t len, int mode) {
#ifdef RTE_Compiler_IO_STDIN
int ch;
#elif (!defined(RTE_Compiler_IO_File))
(void)buf;
(void)len;
#endif
(void)mode;
switch (fh) {
case FH_STDIN:
#ifdef RTE_Compiler_IO_STDIN
ch = stdin_getchar();
if (ch < 0) {
return ((int)(len | 0x80000000U));
}
*buf++ = (uint8_t)ch;
#if (STDIN_ECHO != 0)
stdout_putchar(ch);
#endif
len--;
return ((int)(len));
#else
return ((int)(len | 0x80000000U));
#endif
case FH_STDOUT:
return (-1);
case FH_STDERR:
return (-1);
}
#ifdef RTE_Compiler_IO_File
#ifdef RTE_Compiler_IO_File_FS
return (__sys_read(fh, buf, len));
#endif
#else
return (-1);
#endif
}
#endif
#if defined(RTE_Compiler_IO_TTY)
#if defined(RTE_Compiler_IO_TTY_User)
extern void ttywrch (int ch);
__attribute__((weak))
void _ttywrch (int ch) {
ttywrch(ch);
}
#elif defined(RTE_Compiler_IO_TTY_ITM)
__attribute__((weak))
void _ttywrch (int ch) {
ITM_SendChar(ch);
}
#elif defined(RTE_Compiler_IO_TTY_BKPT)
__attribute__((weak))
void _ttywrch (int ch) {
(void)ch;
__asm("BKPT 0");
}
#endif
#endif
#ifdef RETARGET_SYS
__attribute__((weak))
int _sys_istty (FILEHANDLE fh) {
switch (fh) {
case FH_STDIN:
return (1);
case FH_STDOUT:
return (1);
case FH_STDERR:
return (1);
}
return (0);
}
#endif
#ifdef RETARGET_SYS
__attribute__((weak))
int _sys_seek (FILEHANDLE fh, long pos) {
#if (!defined(RTE_Compiler_IO_File))
(void)pos;
#endif
switch (fh) {
case FH_STDIN:
return (-1);
case FH_STDOUT:
return (-1);
case FH_STDERR:
return (-1);
}
#ifdef RTE_Compiler_IO_File
#ifdef RTE_Compiler_IO_File_FS
return (__sys_seek(fh, (uint32_t)pos));
#endif
#else
return (-1);
#endif
}
#endif
#ifdef RETARGET_SYS
__attribute__((weak))
long _sys_flen (FILEHANDLE fh) {
switch (fh) {
case FH_STDIN:
return (0);
case FH_STDOUT:
return (0);
case FH_STDERR:
return (0);
}
#ifdef RTE_Compiler_IO_File
#ifdef RTE_Compiler_IO_File_FS
return (__sys_flen(fh));
#endif
#else
return (0);
#endif
}
#endif
#endif