#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/times.h>
#include <streamdevices.h>
#include <string.h>
#include <stdio.h>
#include <gpio.h>
#include <uart.h>

#undef errno



#ifdef __cplusplus
extern "C" {
#endif
extern int errno;
streamdevice* __files__[256];

char *__env[1] = { 0 };
char **environ = __env;

int _exit() 
{
	while(1);
}

int _close(int file) 
{
	if(file<256 && __files__[file]!=NULL)
	{
		return __files__[file]->close(__files__[file]);
	}	
	return 0;
}

int _write(int file, char *ptr, int len) 
{	
	if(file<256 && __files__[file]!=NULL)
	{
		if(__files__[file]->write(__files__[file],ptr,1,len)) return len;
	}	
	return 0;
}

int _execve(char *name, char **argv, char **env) {
errno = ENOMEM;
return -1;
}


int _fork(void) {
errno = EAGAIN;
return -1;
}

int _fstat(int file, struct stat *st) {
st->st_mode = S_IFCHR;
return 0;
}


int _getpid(void) {
return 1;
}


int _isatty(int file) {
return 1;
}


int _kill(int pid, int sig) {
errno = EINVAL;
return -1;
}


int _link(char *old, char *new) {
errno = EMLINK;
return -1;
}


int _lseek(int file, int ptr, int dir) {
return 0;
}

int _open(const char *name, int flags, int mode) 
{
	if(!strncmp("UART", name, 4) && ((name[4] & 0x30)==0x30))
	{
		uart_t* uart1 = malloc(sizeof(uart_t));
    		streamdevice* fd1 = malloc(sizeof(streamdevice));
    		if(uartopen((name[4] & 0xF)-1,uart1));
		{
	    		uartmkstreamdev(uart1,fd1);
			int i=2;
			while(i<256 && __files__[i]!=NULL)i++;
			if(i!=256)
			{
				__files__[i] = fd1;
				return i;
			}
			else printf("Too much files opened\n\r");
		}
	}
	return -1;
}

int _read(int file, char *ptr, int len) {
return 0;
}



caddr_t _sbrk(int incr) {
register char * stack_ptr __asm__ ("sp");
extern char _end; /* Defined by the linker */
static char *heap_end;
char *prev_heap_end;
if (heap_end == 0) {
heap_end = &_end;
}
prev_heap_end = heap_end;
if (heap_end + incr > stack_ptr) {
_write (1, "Heap and stack collision\n", 25);
abort ();
}
heap_end += incr;
return (caddr_t) prev_heap_end;
}



int _stat(char *file, struct stat *st) {
st->st_mode = S_IFCHR;
return 0;
}


int _times(struct tms *buf) {
return -1;
}


int _unlink(char *name) {
errno = ENOENT;
return -1;
}

int _wait(int *status) {
errno = ECHILD;
return -1;
}


int _read_r (struct _reent *r, int file, char * ptr, int len)
{
  r = r;
  file = file;
  ptr = ptr;
  len = len;
  
  errno = EINVAL;
  return -1;
}

/***************************************************************************/

int _lseek_r (struct _reent *r, int file, int ptr, int dir)
{
  r = r;
  file = file;
  ptr = ptr;
  dir = dir;
  
  return 0;
}

/***************************************************************************/

int _write_r (struct _reent *r, int file, char * ptr, int len)
{  
     return _write(file, ptr, len); 
}

/***************************************************************************/

int _close_r (struct _reent *r, int file)
{
  return 0;
}

/***************************************************************************/

caddr_t _sbrk_r (struct _reent *r, int incr)
{
register char * stack_ptr __asm__ ("sp");
extern char _end; /* Defined by the linker */
static char *heap_end;
char *prev_heap_end;
if (heap_end == 0) {
heap_end = &_end;
}
prev_heap_end = heap_end;
if (heap_end + incr > stack_ptr) {
_write (1, "Heap and stack collision\n", 25);
abort ();
}
heap_end += incr;
return (caddr_t) prev_heap_end;
}

/***************************************************************************/

int _fstat_r (struct _reent *r, int file, struct stat * st)
{
  r = r; 
  file = file;
   
  memset (st, 0, sizeof (* st));
  st->st_mode = S_IFCHR;
  return 0;
}

/***************************************************************************/
int _open_r(struct _reent *r,const char *name, int flags, int mode) 
{
	return _open(name, flags, mode);
}

int _isatty_r(struct _reent *r, int fd)
{
  r = r;
  fd = fd;
   
  return 1;
}


#ifdef __cplusplus
}
#endif