Retro68/libretro/syscalls.c

284 lines
5.6 KiB
C

/*
Copyright 2015 Wolfgang Thaller.
This file is part of Retro68.
Retro68 is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Retro68 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/time.h>
#include <reent.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <MacMemory.h>
#include <Processes.h>
#include <Files.h>
#include <TextUtils.h>
void *_sbrk_r(struct _reent *reent, ptrdiff_t increment)
{
Debugger();
return NewPtrClear(increment);
}
void _exit(int status)
{
//if(status != 0)
// Debugger();
ExitToShell();
for(;;)
;
}
ssize_t _consolewrite(int fd, const void *buf, size_t count);
ssize_t _consoleread(int fd, void *buf, size_t count);
const int kMacRefNumOffset = 10;
ssize_t _write_r(struct _reent *reent, int fd, const void *buf, size_t count)
{
long cnt = count;
if(fd >= kMacRefNumOffset)
{
FSWrite(fd - kMacRefNumOffset, &cnt, buf);
return cnt;
}
else
return _consolewrite(fd,buf,count);
}
ssize_t _read_r(struct _reent *reent, int fd, void *buf, size_t count)
{
long cnt = count;
if(fd >= kMacRefNumOffset)
{
FSRead(fd - kMacRefNumOffset, &cnt, buf);
return cnt;
}
else
return _consoleread(fd,buf,count);
}
int _open_r(struct _reent *reent, const char* name, int flags, int mode)
{
Str255 pname;
#if TARGET_API_MAC_CARBON
// Carbon has the new, sane version.
c2pstrcpy(pname,name);
#else
// It is also availble in various glue code libraries and
// in some versions of InterfaceLib, but it's confusing.
// Using the inplace variant, c2pstr, isn't much better than
// doing things by hand:
strncpy(&pname[1],name,255);
pname[0] = strlen(name);
#endif
short ref;
SInt8 permission;
switch(flags & O_ACCMODE)
{
case O_RDONLY:
permission = fsRdPerm;
break;
case O_WRONLY:
permission = fsWrPerm;
break;
case O_RDWR:
permission = fsRdWrPerm;
break;
}
if(flags & O_CREAT)
{
HCreate(0,0,pname,'????','TEXT');
}
OSErr err = HOpenDF(0,0,pname,fsRdWrPerm,&ref);
if(err == paramErr)
err = HOpen(0,0,pname,fsRdWrPerm,&ref);
if(err)
return -1; // TODO: errno
if(flags & O_TRUNC)
{
SetEOF(ref, 0);
}
return ref + kMacRefNumOffset;
}
int _close_r(struct _reent *reent, int fd)
{
if(fd >= kMacRefNumOffset)
FSClose(fd - kMacRefNumOffset);
return 0;
}
int _fstat_r(struct _reent *reent, int fd, struct stat *buf)
{
return -1;
}
extern int _stat_r(struct _reent * reent, const char *fn, struct stat *buf)
{
return -1;
}
off_t _lseek_r(struct _reent *reent, int fd, off_t offset, int whence)
{
if(fd >= kMacRefNumOffset)
{
short posMode;
switch(whence)
{
case SEEK_SET:
posMode = fsFromStart;
break;
case SEEK_CUR:
posMode = fsFromMark;
break;
case SEEK_END:
posMode = fsFromLEOF;
break;
}
short ref = fd - kMacRefNumOffset;
SetFPos(ref, posMode, offset);
long finalPos;
GetFPos(ref, &finalPos);
return finalPos;
}
return (off_t) -1;
}
int _kill_r(struct _reent *reent, pid_t pid, int sig)
{
if(pid == 42)
_exit(42);
else
return -1;
}
pid_t _getpid_r(struct _reent *reent)
{
return 42;
}
int _fork_r(struct _reent *reent)
{
return -1;
}
int _execve_r(struct _reent *reent, const char *fn, char *const * argv, char *const *envp)
{
return -1;
}
int _fcntl_r(struct _reent *reent, int fd, int cmd, int arg)
{
return -1;
}
int _isatty_r(struct _reent *reent, int fd)
{
return fd < kMacRefNumOffset;
}
int _link_r(struct _reent *reent, const char *from, const char *to)
{
reent->_errno = EPERM;
return -1;
}
int _mkdir_r(struct _reent *reent, const char *fn, int mode)
{
return -1;
}
int _rename_r(struct _reent *reent, const char *from, const char *to)
{
return -1;
}
int _unlink_r(struct _reent *reent, const char *fn)
{
return -1;
}
_CLOCK_T_ _times_r(struct _reent *reent, struct tms *buf)
{
reent->_errno = EACCES;
return -1;
}
int _wait_r(struct _reent *reent, int *wstatus)
{
reent->_errno = ECHILD;
return -1; /* Always fails */
}
int _gettimeofday_r(struct _reent *reent, struct timeval *tp, void *__tz)
{
/* Classic MacOS's GetDateTime function returns an integer.
* TickCount() has a slightly higher resolution, but is independend of the real-time clock.
*/
unsigned long secs;
GetDateTime(&secs);
unsigned long ticks = TickCount();
static unsigned long savedTicks = 0, savedSecs = 0;
if(!savedSecs)
{
savedTicks = ticks;
savedSecs = secs;
}
else
{
unsigned long elapsedTicks = ticks - savedTicks;
unsigned long elapsedSecs = secs - savedSecs;
unsigned long expectedTicks = elapsedSecs * 60 + elapsedSecs * 3 / 20;
if(expectedTicks > elapsedTicks)
savedTicks = ticks;
else
savedTicks += expectedTicks;
savedSecs = secs;
}
if(tp)
{
tp->tv_sec = secs - 86400 * (365 * 66 + 66/4);
tp->tv_usec = (ticks - savedTicks) * 20000000 / 2003;
}
return 0;
}