#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <kos32sys.h>
#if !defined(__WIN32__) && !defined(_KOLIBRI)
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mman.h>
#endif
#include "quakedef.h"
qboolean isDedicated;
int noconinput = 0;
char *basedir = ".";
cvar_t sys_linerefresh = {"sys_linerefresh","0"};// set for entity display
cvar_t sys_nostdout = {"sys_nostdout","0"};
// =======================================================================
// General routines
// =======================================================================
void Sys_DebugNumber(int y, int val)
{
}
void Sys_Printf (char *fmt, ...)
{
va_list argptr;
char text[1024];
//Con_Print (text);
}
void Sys_Quit (void)
{
Host_Shutdown();
}
void Sys_Init(void)
{
#if id386
Sys_SetFPCW();
#endif
}
#if !id386
/*
================
Sys_LowFPPrecision
================
*/
void Sys_LowFPPrecision (void)
{
// causes weird problems on Nextstep
}
/*
================
Sys_HighFPPrecision
================
*/
void Sys_HighFPPrecision (void)
{
// causes weird problems on Nextstep
}
#endif // !id386
void Sys_Error (char *error, ...)
{
va_list argptr;
char string[1024];
fprintf(stderr
, "Error: %s\n", string
);
Host_Shutdown ();
}
void Sys_Warn (char *warning, ...)
{
va_list argptr;
char string[1024];
fprintf(stderr
, "Warning: %s", string
);
}
/*
===============================================================================
FILE IO
===============================================================================
*/
#define MAX_HANDLES 10
FILE *sys_handles[MAX_HANDLES];
int findhandle (void)
{
int i;
for (i=1 ; i<MAX_HANDLES ; i++)
if (!sys_handles[i])
return i;
Sys_Error ("out of handles");
return -1;
}
/*
================
Qfilelength
================
*/
static int Qfilelength (FILE *f)
{
int pos;
int end;
fseek (f
, pos
, SEEK_SET
);
return end;
}
int Sys_FileOpenRead (char *path, int *hndl)
{
FILE *f;
int i;
i = findhandle ();
if (!f)
{
*hndl = -1;
return -1;
}
sys_handles[i] = f;
*hndl = i;
return Qfilelength(f);
}
int Sys_FileOpenWrite (char *path)
{
FILE *f;
int i;
i = findhandle ();
if (!f)
Sys_Error
("Error opening %s: %s", path
,strerror(errno
));
sys_handles[i] = f;
return i;
}
void Sys_FileClose (int handle)
{
if ( handle >= 0 ) {
sys_handles[handle] = NULL;
}
}
void Sys_FileSeek (int handle, int position)
{
if ( handle >= 0 ) {
fseek (sys_handles
[handle
], position
, SEEK_SET
);
}
}
int Sys_FileRead (int handle, void *dst, int count)
{
char *data;
int size, done;
size = 0;
if ( handle >= 0 ) {
data = dst;
while ( count > 0 ) {
done
= fread (data
, 1, count
, sys_handles
[handle
]);
if ( done == 0 ) {
break;
}
data += done;
count -= done;
size += done;
}
}
return size;
}
int Sys_FileWrite (int handle, void *src, int count)
{
char *data;
int size, done;
size = 0;
if ( handle >= 0 ) {
data = src;
while ( count > 0 ) {
done
= fread (data
, 1, count
, sys_handles
[handle
]);
if ( done == 0 ) {
break;
}
data += done;
count -= done;
size += done;
}
}
return size;
}
int Sys_FileTime (char *path)
{
FILE *f;
if (f)
{
return 1;
}
return -1;
}
void Sys_mkdir (char *path)
{
#ifdef __WIN32__
mkdir (path);
#else
//mkdir (path, 0777);
#endif
}
void Sys_DebugLog(char *file, char *fmt, ...)
{
va_list argptr;
static char data[1024];
FILE *fp;
}
double Sys_FloatTime (void)
{
#if defined(_KOLIBRI)
static int starttime = 0;
if ( ! starttime )
__asm__ __volatile__("int $0x40" : "=a"(starttime) : "a"(26), "b"(9));
int curtime;
__asm__ __volatile__("int $0x40" : "=a"(curtime) : "a"(26), "b"(9));
return (curtime-starttime)*0.01;
#elif defined(__WIN32__)
static int starttime = 0;
if ( ! starttime )
return (clock()-starttime
)*1.0/1024;
#else
struct timeval tp;
struct timezone tzp;
static int secbase;
gettimeofday(&tp, &tzp);
if (!secbase)
{
secbase = tp.tv_sec;
return tp.tv_usec/1000000.0;
}
return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
#endif
}
// =======================================================================
// Sleeps for microseconds
// =======================================================================
static volatile int oktogo;
void alarm_handler(int x)
{
oktogo=1;
}
byte *Sys_ZoneBase (int *size)
{
char *QUAKEOPT
= getenv("QUAKEOPT");
*size = 0xc00000;
if (QUAKEOPT)
{
while (*QUAKEOPT)
{
*size
= atof(QUAKEOPT
) * 1024*1024;
break;
}
}
}
void Sys_LineRefresh(void)
{
}
void Sys_Sleep(void)
{
#ifdef _KOLIBRI
delay(1);
#else
SDL_Delay(1);
#endif
}
#ifndef _KOLIBRI
void floating_point_exception_handler(int whatever)
{
// Sys_Warn("floating point exception\n");
signal(SIGFPE, floating_point_exception_handler);
}
#endif
void moncontrol(int x)
{
}
int main (int c, char **v)
{
#ifdef _KOLIBRI
#include "kolibri.h"
_ksys_setcwd(dirname(v[0]));
#endif
double time, oldtime
, newtime
;
quakeparms_t parms;
extern int vcrFile;
extern qboolean recording;
static int frame;
moncontrol(0);
#ifndef _KOLIBRI
// signal(SIGFPE, floating_point_exception_handler);
signal(SIGFPE, SIG_IGN);
#endif
parms.memsize = 8*1024*1024;
parms.
membase = malloc (parms.
memsize);
parms.basedir = basedir;
parms.cachedir = NULL;
COM_InitArgv(c, v);
parms.argc = com_argc;
parms.argv = com_argv;
Sys_Init();
Host_Init(&parms);
Cvar_RegisterVariable (&sys_nostdout);
oldtime = Sys_FloatTime () - 0.1;
while (1)
{
// find time spent rendering last frame
newtime = Sys_FloatTime ();
time = newtime
- oldtime
;
if (cls.state == ca_dedicated)
{ // play vcrfiles at max speed
if (time < sys_ticrate.
value && (vcrFile
== -1 || recording
) )
{
#ifdef _KOLIBRI
delay(1);
#else
SDL_Delay (1);
#endif
continue; // not time to run a server only tic yet
}
time = sys_ticrate.
value;
}
if (time > sys_ticrate.
value*2)
oldtime = newtime;
else
if (++frame > 10)
moncontrol(1); // profile only while we do each Quake frame
moncontrol(0);
// graphic debugging aids
if (sys_linerefresh.value)
Sys_LineRefresh ();
}
}
/*
================
Sys_MakeCodeWriteable
================
*/
void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
{
#ifndef _KOLIBRI
int r;
unsigned long addr;
int psize = getpagesize();
fprintf(stderr
, "writable code %lx-%lx\n", startaddr
, startaddr
+length
);
addr = startaddr & ~(psize-1);
r = mprotect((char*)addr, length + startaddr - addr, 7);
if (r < 0)
Sys_Error("Protection change failed\n");
#endif
}