syscall.h

Go to the documentation of this file.

#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
 
 
/* Linker must provide these (define in linker.ld) */
extern char _heap_start; /* start of heap area (set in linker script) */
extern char _heap_end;   /* optional end of heap area */
 
static char *heap_ptr = &_heap_start;
const char msg[] = "\033[31m\nERR: Heap Collision!\n\033[0m";
 
/* _sbrk: provide heap for malloc */
ssize_t _sbrk(int incr)
{
    char *prev_heap = heap_ptr;
    if ((heap_ptr + incr) > &_heap_end) {
        write(1,msg,sizeof(msg));
        errno = ENOMEM;
        // while(1); //Should we halt the program when hit this issue ?
        return (ssize_t)-1;
    }
    heap_ptr += incr;
    return (ssize_t)prev_heap;
}
 
/* _write: used by printf/vfprintf -> send to UART */
ssize_t _write(int fd, const void *buf, size_t count)
{
    (void)fd; /* ignore fd; 1/2 -> stdout/stderr */
    const char *p = buf;
    for (size_t i = 0; i < count; ++i) {
        char c = p[i];
        if (c == '\n') {
            bsp_putChar('\r');
            //uart_write(&uart0, '\r');
        }
        bsp_putChar(c);
        //uart_write(&uart0, c);
    }
    return (ssize_t)count;
}
 
ssize_t _read(int fd, char *buf, size_t count)
{
    (void)fd;
    char *start = buf; // Remember where we started so we don't backspace too far
    size_t i = 0;
 
    for (; i < count; ) { // Remove ++i from here, we handle it manually
        
        char c = bsp_getChar(); // Read raw char
 
        // --- 1. Handle Enter (CR) ---
        if (c == '\r') {
            bsp_putChar('\r'); // Move to start of line
            bsp_putChar('\n'); // Move down (Visual Refresh)
            
            *buf = '\n';       // Standard C expects \n
            buf++;
            return (ssize_t)(i + 1); // Return immediately (Line Complete)
        }
 
        // --- 2. Handle Backspace (0x08 or 0x7F) ---
        if (c == 0x08 || c == 0x7F) {
            if (i > 0) {
                // Logic: Step back in buffer
                buf--; 
                i--;
                
                // Visual: Erase character from screen
                bsp_putChar('\b'); // Cursor Left
                bsp_putChar(' ');  // Overwrite with Space
                bsp_putChar('\b'); // Cursor Left again
            }
            continue; // Skip the rest, get next char
        }
 
        // --- 3. Handle Normal Characters ---
        // Optional: Block weird control characters
        if (c >= ' ' && c <= '~') {
            *buf = c;
            bsp_putChar(c); // Echo
            buf++;
            i++;
        }
    }
    
    return (ssize_t)i;
}
 
/* _close */
int _close(int fd)
{
    (void)fd;
    return -1;
}
 
/* _fstat: mark all fds as character special devices */
int _fstat(int fd, struct stat *st)
{
    (void)fd;
    st->st_mode = S_IFCHR;
    return 0;
}
 
/* _isatty */
int _isatty(int fd)
{
    (void)fd;
    return 1; /* treat as TTY */
}
 
/* _lseek */
off_t _lseek(int fd, off_t offset, int whence)
{
    (void)fd; (void)offset; (void)whence;
    return (off_t)-1;
}
 
/* _exit - terminate program: loop forever */
void _exit(int status)
{
    (void)status;
    while (1) { __asm__ volatile ("wfi"); }
}
 
/* _kill - required by newlib sometimes */
int _kill(int pid, int sig)
{
    (void)pid; (void)sig;
    errno = EINVAL;
    return -1;
}
 
/* _getpid */
int _getpid(void)
{
    return 1;
}