quake/src/WinQuake/sys_dos.cpp - platform/external/quake - Git at Google

 /*
 Copyright (C) 1996-1997 Id Software, Inc.

 This program 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 2
 of the License, or (at your option) any later version.

 This program 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.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */
 #include <errno.h>
 #include <unistd.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <dir.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <string.h>
 #include <dpmi.h>
 #include <sys/nearptr.h>
 #include <conio.h>

 #include "quakedef.h"
 #include "dosisms.h"

 #define MINIMUM_WIN_MEMORY			0x800000
 #define MINIMUM_WIN_MEMORY_LEVELPAK	(MINIMUM_WIN_MEMORY + 0x100000)

 int			end_of_memory;
 qboolean	lockmem, lockunlockmem, unlockmem;
 static int	win95;

 #define STDOUT	1

 #define	KEYBUF_SIZE	256
 static unsigned char	keybuf[KEYBUF_SIZE];
 static int				keybuf_head=0;
 static int				keybuf_tail=0;

 static quakeparms_t	quakeparms;
 int					sys_checksum;
 static double		curtime = 0.0;
 static double		lastcurtime = 0.0;
 static double		oldtime = 0.0;

 static qboolean		isDedicated;

 static int			minmem;

 float				fptest_temp;

 extern char	start_of_memory __asm__("start");

 //=============================================================================

 // this is totally dependent on cwsdpmi putting the stack right after tge
 // global data

 // This does evil things in a Win95 DOS box!!!
 #if 0
 extern byte end;
 #define	CHECKBYTE	0xed
 void Sys_InitStackCheck (void)
 {
 	int		i;

 	for (i=0 ; i<128*1024 ; i++)
 		(&end)[i] = CHECKBYTE;
 }

 void Sys_StackCheck (void)
 {
 	int		i;

 	for (i=0 ; i<128*1024 ; i++)
 		if ( (&end)[i] != CHECKBYTE )
 			break;

 	Con_Printf ("%i undisturbed stack bytes\n", i);
 	if (end != CHECKBYTE)
 		Sys_Error ("System stack overflow!");
 }
 #endif

 //=============================================================================

 byte        scantokey[128] =
 					{
 //  0           1       2       3       4       5       6       7
 //  8           9       A       B       C       D       E       F
 	0  ,    27,     '1',    '2',    '3',    '4',    '5',    '6',
 	'7',    '8',    '9',    '0',    '-',    '=',    K_BACKSPACE, 9, // 0
 	'q',    'w',    'e',    'r',    't',    'y',    'u',    'i',
 	'o',    'p',    '[',    ']',    13 ,    K_CTRL,'a',  's',      // 1
 	'd',    'f',    'g',    'h',    'j',    'k',    'l',    ';',
 	'\'' ,    '`',    K_SHIFT,'\\',  'z',    'x',    'c',    'v',      // 2
 	'b',    'n',    'm',    ',',    '.',    '/',    K_SHIFT,'*',
 	K_ALT,' ',   0  ,    K_F1, K_F2, K_F3, K_F4, K_F5,   // 3
 	K_F6, K_F7, K_F8, K_F9, K_F10,0  ,    0  , K_HOME,
 	K_UPARROW,K_PGUP,'-',K_LEFTARROW,'5',K_RIGHTARROW,'+',K_END, //4
 	K_DOWNARROW,K_PGDN,K_INS,K_DEL,0,0,             0,              K_F11,
 	K_F12,0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,        // 5
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,        // 6
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0         // 7
 					};

 byte        shiftscantokey[128] =
 					{
 //  0           1       2       3       4       5       6       7
 //  8           9       A       B       C       D       E       F
 	0  ,    27,     '!',    '@',    '#',    '$',    '%',    '^',
 	'&',    '*',    '(',    ')',    '_',    '+',    K_BACKSPACE, 9, // 0
 	'Q',    'W',    'E',    'R',    'T',    'Y',    'U',    'I',
 	'O',    'P',    '{',    '}',    13 ,    K_CTRL,'A',  'S',      // 1
 	'D',    'F',    'G',    'H',    'J',    'K',    'L',    ':',
 	'"' ,    '~',    K_SHIFT,'|',  'Z',    'X',    'C',    'V',      // 2
 	'B',    'N',    'M',    '<',    '>',    '?',    K_SHIFT,'*',
 	K_ALT,' ',   0  ,    K_F1, K_F2, K_F3, K_F4, K_F5,   // 3
 	K_F6, K_F7, K_F8, K_F9, K_F10,0  ,    0  , K_HOME,
 	K_UPARROW,K_PGUP,'_',K_LEFTARROW,'%',K_RIGHTARROW,'+',K_END, //4
 	K_DOWNARROW,K_PGDN,K_INS,K_DEL,0,0,             0,              K_F11,
 	K_F12,0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,        // 5
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,        // 6
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0,
 	0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0  ,    0         // 7
 					};

 void TrapKey(void)
 {
 //	static int ctrl=0;
 	keybuf[keybuf_head] = dos_inportb(0x60);
 	dos_outportb(0x20, 0x20);
 	/*
 	if (scantokey[keybuf[keybuf_head]&0x7f] == K_CTRL)
 		ctrl=keybuf[keybuf_head]&0x80;
 	if (ctrl && scantokey[keybuf[keybuf_head]&0x7f] == 'c')
 		Sys_Error("ctrl-c hit\n");
 	*/
 	keybuf_head = (keybuf_head + 1) & (KEYBUF_SIZE-1);
 }

 #define SC_UPARROW              0x48
 #define SC_DOWNARROW    0x50
 #define SC_LEFTARROW            0x4b
 #define SC_RIGHTARROW   0x4d
 #define SC_LEFTSHIFT   0x2a
 #define SC_RIGHTSHIFT   0x36
 #define SC_RIGHTARROW   0x4d

 void MaskExceptions (void);
 void Sys_InitFloatTime (void);
 void Sys_PushFPCW_SetHigh (void);
 void Sys_PopFPCW (void);

 #define LEAVE_FOR_CACHE (512*1024)		//FIXME: tune
 #define LOCKED_FOR_MALLOC (128*1024)	//FIXME: tune


 void Sys_DetectWin95 (void)
 {
 	__dpmi_regs				r;

 	r.x.ax = 0x160a;		/* Get Windows Version */
 	__dpmi_int(0x2f, &r);

 	if(r.x.ax || r.h.bh < 4)	/* Not windows or earlier than Win95 */
 	{
 		win95 = 0;
 		lockmem = true;
 		lockunlockmem = false;
 		unlockmem = true;
 	}
 	else
 	{
 		win95 = 1;
 		lockunlockmem = COM_CheckParm ("-winlockunlock");

 		if (lockunlockmem)
 			lockmem = true;
 		else
 			lockmem = COM_CheckParm ("-winlock");

 		unlockmem = lockmem && !lockunlockmem;
 	}
 }


 void *dos_getmaxlockedmem(int *size)
 {
 	__dpmi_free_mem_info	meminfo;
 	__dpmi_meminfo			info;
 	int						working_size;
 	void					*working_memory;
 	int						last_locked;
 	int						extra, 	i, j, allocsize;
 	static char				*msg = "Locking data...";
 	int						m, n;
 	byte					*x;

 // first lock all the current executing image so the locked count will
 // be accurate.  It doesn't hurt to lock the memory multiple times
 	last_locked = __djgpp_selector_limit + 1;
 	info.size = last_locked - 4096;
 	info.address = __djgpp_base_address + 4096;

 	if (lockmem)
 	{
 		if(__dpmi_lock_linear_region(&info))
 		{
 			Sys_Error ("Lock of current memory at 0x%lx for %ldKb failed!\n",
 						info.address, info.size/1024);
 		}
 	}

 	__dpmi_get_free_memory_information(&meminfo);

 	if (!win95)		/* Not windows or earlier than Win95 */
 	{
 		working_size = meminfo.maximum_locked_page_allocation_in_pages * 4096;
 	}
 	else
 	{
 		working_size = meminfo.largest_available_free_block_in_bytes -
 				LEAVE_FOR_CACHE;
 	}

 	working_size &= ~0xffff;		/* Round down to 64K */
 	working_size += 0x10000;

 	do
 	{
 		working_size -= 0x10000;		/* Decrease 64K and try again */
 		working_memory = sbrk(working_size);
 	} while (working_memory == (void *)-1);

 	extra = 0xfffc - ((unsigned)sbrk(0) & 0xffff);

 	if (extra > 0)
 	{
 		sbrk(extra);
 		working_size += extra;
 	}

 // now grab the memory
 	info.address = last_locked + __djgpp_base_address;

 	if (!win95)
 	{
 	    info.size = __djgpp_selector_limit + 1 - last_locked;

 		while (info.size > 0 && __dpmi_lock_linear_region(&info))
 		{
 			info.size -= 0x1000;
 			working_size -= 0x1000;
 			sbrk(-0x1000);
 		}
 	}
 	else
 	{			/* Win95 section */
 		j = COM_CheckParm("-winmem");

 		if (standard_quake)
 			minmem = MINIMUM_WIN_MEMORY;
 		else
 			minmem = MINIMUM_WIN_MEMORY_LEVELPAK;

 		if (j)
 		{
 			allocsize = ((int)(Q_atoi(com_argv[j+1]))) * 0x100000 +
 					LOCKED_FOR_MALLOC;

 			if (allocsize < (minmem + LOCKED_FOR_MALLOC))
 				allocsize = minmem + LOCKED_FOR_MALLOC;
 		}
 		else
 		{
 			allocsize = minmem + LOCKED_FOR_MALLOC;
 		}

 		if (!lockmem)
 		{
 		// we won't lock, just sbrk the memory
 			info.size = allocsize;
 			goto UpdateSbrk;
 		}

 		// lock the memory down
 		write (STDOUT, msg, strlen (msg));

 		for (j=allocsize ; j>(minmem + LOCKED_FOR_MALLOC) ;
 			 j -= 0x100000)
 		{
 			info.size = j;

 			if (!__dpmi_lock_linear_region(&info))
 				goto Locked;

 			write (STDOUT, ".", 1);
 		}

 	// finally, try with the absolute minimum amount
 		for (i=0 ; i<10 ; i++)
 		{
 			info.size = minmem + LOCKED_FOR_MALLOC;

 			if (!__dpmi_lock_linear_region(&info))
 				goto Locked;
 		}

 		Sys_Error ("Can't lock memory; %d Mb lockable RAM required. "
 				   "Try shrinking smartdrv.", info.size / 0x100000);

 Locked:

 UpdateSbrk:

 		info.address += info.size;
 		info.address -= __djgpp_base_address + 4; // ending point, malloc align
 		working_size = info.address - (int)working_memory;
 		sbrk(info.address-(int)sbrk(0));		// negative adjustment
 	}


 	if (lockunlockmem)
 	{
 		__dpmi_unlock_linear_region (&info);
 		printf ("Locked and unlocked %d Mb data\n", working_size / 0x100000);
 	}
 	else if (lockmem)
 	{
 		printf ("Locked %d Mb data\n", working_size / 0x100000);
 	}
 	else
 	{
 		printf ("Allocated %d Mb data\n", working_size / 0x100000);
 	}

 // touch all the memory to make sure it's there. The 16-page skip is to
 // keep Win 95 from thinking we're trying to page ourselves in (we are
 // doing that, of course, but there's no reason we shouldn't)
 	x = (byte *)working_memory;

 	for (n=0 ; n<4 ; n++)
 	{
 		for (m=0 ; m<(working_size - 16 * 0x1000) ; m += 4)
 		{
 			sys_checksum += *(int *)&x[m];
 			sys_checksum += *(int *)&x[m + 16 * 0x1000];
 		}
 	}

 // give some of what we locked back for malloc before returning.  Done
 // by cheating and passing a negative value to sbrk
 	working_size -= LOCKED_FOR_MALLOC;
 	sbrk( -(LOCKED_FOR_MALLOC));
 	*size = working_size;
 	return working_memory;
 }


 /*
 ============
 Sys_FileTime

 returns -1 if not present
 ============
 */
 int	Sys_FileTime (char *path)
 {
 	struct	stat	buf;

 	if (stat (path,&buf) == -1)
 		return -1;

 	return buf.st_mtime;
 }

 void Sys_mkdir (char *path)
 {
 	mkdir (path, 0777);
 }


 void Sys_Sleep(void)
 {
 }


 char *Sys_ConsoleInput(void)
 {
 	static char	text[256];
 	static int	len = 0;
 	char		ch;

 	if (!isDedicated)
 		return NULL;

 	if (! kbhit())
 		return NULL;

 	ch = getche();

 	switch (ch)
 	{
 		case '\r':
 			putch('\n');
 			if (len)
 			{
 				text[len] = 0;
 				len = 0;
 				return text;
 			}
 			break;

 		case '\b':
 			putch(' ');
 			if (len)
 			{
 				len--;
 				putch('\b');
 			}
 			break;

 		default:
 			text[len] = ch;
 			len = (len + 1) & 0xff;
 			break;
 	}

 	return NULL;
 }

 void Sys_Init(void)
 {

 	MaskExceptions ();

 	Sys_SetFPCW ();

     dos_outportb(0x43, 0x34); // set system timer to mode 2
     dos_outportb(0x40, 0);    // for the Sys_FloatTime() function
     dos_outportb(0x40, 0);

 	Sys_InitFloatTime ();

 	_go32_interrupt_stack_size = 4 * 1024;;
 	_go32_rmcb_stack_size = 4 * 1024;
 }

 void Sys_Shutdown(void)
 {
 	if (!isDedicated)
 		dos_restoreintr(9);

 	if (unlockmem)
 	{
 		dos_unlockmem (&start_of_memory,
 					   end_of_memory - (int)&start_of_memory);
 		dos_unlockmem (quakeparms.membase, quakeparms.memsize);
 	}
 }


 #define SC_RSHIFT       0x36
 #define SC_LSHIFT       0x2a
 void Sys_SendKeyEvents (void)
 {
 	int k, next;
 	int outkey;

 // get key events

 	while (keybuf_head != keybuf_tail)
 	{

 		k = keybuf[keybuf_tail++];
 		keybuf_tail &= (KEYBUF_SIZE-1);

 		if (k==0xe0)
 			continue;               // special / pause keys
 		next = keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)];
 		if (next == 0xe1)
 			continue;                               // pause key bullshit
 		if (k==0xc5 && next == 0x9d)
 		{
 			Key_Event (K_PAUSE, true);
 			continue;
 		}

 		// extended keyboard shift key bullshit
 		if ( (k&0x7f)==SC_LSHIFT || (k&0x7f)==SC_RSHIFT )
 		{
 			if ( keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)]==0xe0 )
 				continue;
 			k &= 0x80;
 			k |= SC_RSHIFT;
 		}

 		if (k==0xc5 && keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)] == 0x9d)
 			continue; // more pause bullshit

 		outkey = scantokey[k & 0x7f];

 		if (k & 0x80)
 			Key_Event (outkey, false);
 		else
 			Key_Event (outkey, true);

 	}

 }


 // =======================================================================
 // General routines
 // =======================================================================

 /*
 ================
 Sys_Printf
 ================
 */

 void Sys_Printf (char *fmt, ...)
 {
 	va_list		argptr;
 	char		text[1024];

 	va_start (argptr,fmt);
 	vsprintf (text,fmt,argptr);
 	va_end (argptr);

 	if (cls.state == ca_dedicated)
 		fprintf(stderr, "%s", text);
 }

 void Sys_AtExit (void)
 {

 // shutdown only once (so Sys_Error can call this function to shutdown, then
 // print the error message, then call exit without exit calling this function
 // again)
 	Sys_Shutdown();
 }


 void Sys_Quit (void)
 {
 	byte	screen[80*25*2];
 	byte	*d;
 	char			ver[6];
 	int			i;


 // load the sell screen before shuting everything down
 	if (registered.value)
 		d = COM_LoadHunkFile ("end2.bin");
 	else
 		d = COM_LoadHunkFile ("end1.bin");
 	if (d)
 		memcpy (screen, d, sizeof(screen));

 // write the version number directly to the end screen
 	sprintf (ver, " v%4.2f", VERSION);
 	for (i=0 ; i<6 ; i++)
 		screen[0*80*2 + 72*2 + i*2] = ver[i];

 	Host_Shutdown();

 // do the text mode sell screen
 	if (d)
 	{
 		memcpy ((void *)real2ptr(0xb8000), screen,80*25*2);

 	// set text pos
 		regs.x.ax = 0x0200;
 		regs.h.bh = 0;
 		regs.h.dl = 0;
 		regs.h.dh = 22;
 		dos_int86 (0x10);
 	}
 	else
 		printf ("couldn't load endscreen.\n");

 	exit(0);
 }

 void Sys_Error (char *error, ...)
 {
     va_list     argptr;
     char        string[1024];

     va_start (argptr,error);
     vsprintf (string,error,argptr);
     va_end (argptr);

 	Host_Shutdown();
 	fprintf(stderr, "Error: %s\n", string);
 // Sys_AtExit is called by exit to shutdown the system
 	exit(0);
 }


 int Sys_FileOpenRead (char *path, int *handle)
 {
 	int	h;
 	struct stat	fileinfo;

 	h = open (path, O_RDONLY|O_BINARY, 0666);
 	*handle = h;
 	if (h == -1)
 		return -1;

 	if (fstat (h,&fileinfo) == -1)
 		Sys_Error ("Error fstating %s", path);

 	return fileinfo.st_size;
 }

 int Sys_FileOpenWrite (char *path)
 {
 	int     handle;

 	umask (0);

 	handle = open(path,O_RDWR | O_BINARY | O_CREAT | O_TRUNC
 	, 0666);

 	if (handle == -1)
 		Sys_Error ("Error opening %s: %s", path,strerror(errno));

 	return handle;
 }

 void Sys_FileClose (int handle)
 {
 	close (handle);
 }

 void Sys_FileSeek (int handle, int position)
 {
 	lseek (handle, position, SEEK_SET);
 }

 int Sys_FileRead (int handle, void *dest, int count)
 {
    return read (handle, dest, count);
 }

 int Sys_FileWrite (int handle, void *data, int count)
 {
 	return write (handle, data, count);
 }

 /*
 ================
 Sys_MakeCodeWriteable
 ================
 */
 void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
 {
 	// it's always writeable
 }


 /*
 ================
 Sys_FloatTime
 ================
 */
 double Sys_FloatTime (void)
 {
     int				r;
     unsigned		t, tick;
 	double			ft, time;
 	static int		sametimecount;

 	Sys_PushFPCW_SetHigh ();

 //{static float t = 0; t=t+0.05; return t;}	// DEBUG

     t = *(unsigned short*)real2ptr(0x46c) * 65536;

     dos_outportb(0x43, 0); // latch time
     r = dos_inportb(0x40);
     r |= dos_inportb(0x40) << 8;
     r = (r-1) & 0xffff;

     tick = *(unsigned short*)real2ptr(0x46c) * 65536;
     if ((tick != t) && (r & 0x8000))
 		t = tick;

 	ft = (double) (t+(65536-r)) / 1193200.0;
 	time = ft - oldtime;
 	oldtime = ft;

 	if (time < 0)
 	{
 		if (time > -3000.0)
 			time = 0.0;
 		else
 			time += 3600.0;
 	}

 	curtime += time;

 	if (curtime == lastcurtime)
 	{
 		sametimecount++;

 		if (sametimecount > 100000)
 		{
 			curtime += 1.0;
 			sametimecount = 0;
 		}
 	}
 	else
 	{
 		sametimecount = 0;
 	}

 	lastcurtime = curtime;

 	Sys_PopFPCW ();

     return curtime;
 }


 /*
 ================
 Sys_InitFloatTime
 ================
 */
 void Sys_InitFloatTime (void)
 {
 	int		j;

 	Sys_FloatTime ();

 	oldtime = curtime;

 	j = COM_CheckParm("-starttime");

 	if (j)
 	{
 		curtime = (double) (Q_atof(com_argv[j+1]));
 	}
 	else
 	{
 		curtime = 0.0;
 	}
 	lastcurtime = curtime;
 }


 /*
 ================
 Sys_GetMemory
 ================
 */
 void Sys_GetMemory(void)
 {
 	int		j, tsize;

 	j = COM_CheckParm("-mem");
 	if (j)
 	{
 		quakeparms.memsize = (int) (Q_atof(com_argv[j+1]) * 1024 * 1024);
 		quakeparms.membase = malloc (quakeparms.memsize);
 	}
 	else
 	{
 		quakeparms.membase = dos_getmaxlockedmem (&quakeparms.memsize);
 	}

 	fprintf(stderr, "malloc'd: %d\n", quakeparms.memsize);

 	if (COM_CheckParm ("-heapsize"))
 	{
 		tsize = Q_atoi (com_argv[COM_CheckParm("-heapsize") + 1]) * 1024;

 		if (tsize < quakeparms.memsize)
 			quakeparms.memsize = tsize;
 	}
 }


 /*
 ================
 Sys_PageInProgram

 walks the text, data, and bss to make sure it's all paged in so that the
 actual physical memory detected by Sys_GetMemory is correct.
 ================
 */
 void Sys_PageInProgram(void)
 {
 	int		i, j;

 	end_of_memory = (int)sbrk(0);

 	if (lockmem)
 	{
 		if (dos_lockmem ((void *)&start_of_memory,
 						 end_of_memory - (int)&start_of_memory))
 			Sys_Error ("Couldn't lock text and data");
 	}

 	if (lockunlockmem)
 	{
 		dos_unlockmem((void *)&start_of_memory,
 						 end_of_memory - (int)&start_of_memory);
 		printf ("Locked and unlocked %d Mb image\n",
 				(end_of_memory - (int)&start_of_memory) / 0x100000);
 	}
 	else if (lockmem)
 	{
 		printf ("Locked %d Mb image\n",
 				(end_of_memory - (int)&start_of_memory) / 0x100000);
 	}
 	else
 	{
 		printf ("Loaded %d Mb image\n",
 				(end_of_memory - (int)&start_of_memory) / 0x100000);
 	}

 // touch the entire image, doing the 16-page skip so Win95 doesn't think we're
 // trying to page ourselves in
 	for (j=0 ; j<4 ; j++)
 	{
 		for(i=(int)&start_of_memory ; i<(end_of_memory - 16 * 0x1000) ; i += 4)
 		{
 			sys_checksum += *(int *)i;
 			sys_checksum += *(int *)(i + 16 * 0x1000);
 		}
 	}
 }


 /*
 ================
 Sys_NoFPUExceptionHandler
 ================
 */
 void Sys_NoFPUExceptionHandler(int whatever)
 {
 	printf ("\nError: Quake requires a floating-point processor\n");
 	exit (0);
 }


 /*
 ================
 Sys_DefaultExceptionHandler
 ================
 */
 void Sys_DefaultExceptionHandler(int whatever)
 {
 }


 /*
 ================
 main
 ================
 */
 int main (int c, char **v)
 {
 	double			time, oldtime, newtime;
 	extern void (*dos_error_func)(char *, ...);
 	static	char	cwd[1024];

 	printf ("Quake v%4.2f\n", VERSION);

 // make sure there's an FPU
 	signal(SIGNOFP, Sys_NoFPUExceptionHandler);
 	signal(SIGABRT, Sys_DefaultExceptionHandler);
 	signal(SIGALRM, Sys_DefaultExceptionHandler);
 	signal(SIGKILL, Sys_DefaultExceptionHandler);
 	signal(SIGQUIT, Sys_DefaultExceptionHandler);
 	signal(SIGINT, Sys_DefaultExceptionHandler);

 	if (fptest_temp >= 0.0)
 		fptest_temp += 0.1;

 	COM_InitArgv (c, v);

 	quakeparms.argc = com_argc;
 	quakeparms.argv = com_argv;

 	dos_error_func = Sys_Error;

 	Sys_DetectWin95 ();
 	Sys_PageInProgram ();
 	Sys_GetMemory ();

 	atexit (Sys_AtExit);	// in case we crash

 	getwd (cwd);
 	if (cwd[Q_strlen(cwd)-1] == '/') cwd[Q_strlen(cwd)-1] = 0;
 	quakeparms.basedir = cwd; //"f:/quake";

 	isDedicated = (COM_CheckParm ("-dedicated") != 0);

 	Sys_Init ();

 	if (!isDedicated)
 		dos_registerintr(9, TrapKey);

 //Sys_InitStackCheck ();

 	Host_Init(&quakeparms);

 //Sys_StackCheck ();

 //Con_Printf ("Top of stack: 0x%x\n", &time);
 	oldtime = Sys_FloatTime ();
 	while (1)
 	{
 		newtime = Sys_FloatTime ();
 		time = newtime - oldtime;

 		if (cls.state == ca_dedicated && (time<sys_ticrate.value))
 			continue;

 		Host_Frame (time);

 //Sys_StackCheck ();

 		oldtime = newtime;
 	}
 }
	/*
	Copyright (C) 1996-1997 Id Software, Inc.

	This program 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 2
	of the License, or (at your option) any later version.

	This program 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.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

	*/
	#include <errno.h>
	#include <unistd.h>
	#include <signal.h>
	#include <stdlib.h>
	#include <limits.h>
	#include <sys/time.h>
	#include <sys/types.h>
	#include <dir.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <sys/stat.h>
	#include <string.h>
	#include <dpmi.h>
	#include <sys/nearptr.h>
	#include <conio.h>

	#include "quakedef.h"
	#include "dosisms.h"

	#define MINIMUM_WIN_MEMORY 0x800000
	#define MINIMUM_WIN_MEMORY_LEVELPAK (MINIMUM_WIN_MEMORY + 0x100000)

	int end_of_memory;
	qboolean lockmem, lockunlockmem, unlockmem;
	static int win95;

	#define STDOUT 1

	#define KEYBUF_SIZE 256
	static unsigned char keybuf[KEYBUF_SIZE];
	static int keybuf_head=0;
	static int keybuf_tail=0;

	static quakeparms_t quakeparms;
	int sys_checksum;
	static double curtime = 0.0;
	static double lastcurtime = 0.0;
	static double oldtime = 0.0;

	static qboolean isDedicated;

	static int minmem;

	float fptest_temp;

	extern char start_of_memory __asm__("start");

	//=============================================================================

	// this is totally dependent on cwsdpmi putting the stack right after tge
	// global data

	// This does evil things in a Win95 DOS box!!!
	#if 0
	extern byte end;
	#define CHECKBYTE 0xed
	void Sys_InitStackCheck (void)
	{
	int i;

	for (i=0 ; i<128*1024 ; i++)
	(&end)[i] = CHECKBYTE;
	}

	void Sys_StackCheck (void)
	{
	int i;

	for (i=0 ; i<128*1024 ; i++)
	if ( (&end)[i] != CHECKBYTE )
	break;

	Con_Printf ("%i undisturbed stack bytes\n", i);
	if (end != CHECKBYTE)
	Sys_Error ("System stack overflow!");
	}
	#endif

	//=============================================================================

	byte scantokey[128] =
	{
	// 0 1 2 3 4 5 6 7
	// 8 9 A B C D E F
	0 , 27, '1', '2', '3', '4', '5', '6',
	'7', '8', '9', '0', '-', '=', K_BACKSPACE, 9, // 0
	'q', 'w', 'e', 'r', 't', 'y', 'u', 'i',
	'o', 'p', '[', ']', 13 , K_CTRL,'a', 's', // 1
	'd', 'f', 'g', 'h', 'j', 'k', 'l', ';',
	'\'' , '`', K_SHIFT,'\\', 'z', 'x', 'c', 'v', // 2
	'b', 'n', 'm', ',', '.', '/', K_SHIFT,'*',
	K_ALT,' ', 0 , K_F1, K_F2, K_F3, K_F4, K_F5, // 3
	K_F6, K_F7, K_F8, K_F9, K_F10,0 , 0 , K_HOME,
	K_UPARROW,K_PGUP,'-',K_LEFTARROW,'5',K_RIGHTARROW,'+',K_END, //4
	K_DOWNARROW,K_PGDN,K_INS,K_DEL,0,0, 0, K_F11,
	K_F12,0 , 0 , 0 , 0 , 0 , 0 , 0, // 5
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0, // 6
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 // 7
	};

	byte shiftscantokey[128] =
	{
	// 0 1 2 3 4 5 6 7
	// 8 9 A B C D E F
	0 , 27, '!', '@', '#', '$', '%', '^',
	'&', '*', '(', ')', '_', '+', K_BACKSPACE, 9, // 0
	'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I',
	'O', 'P', '{', '}', 13 , K_CTRL,'A', 'S', // 1
	'D', 'F', 'G', 'H', 'J', 'K', 'L', ':',
	'"' , '~', K_SHIFT,'\|', 'Z', 'X', 'C', 'V', // 2
	'B', 'N', 'M', '<', '>', '?', K_SHIFT,'*',
	K_ALT,' ', 0 , K_F1, K_F2, K_F3, K_F4, K_F5, // 3
	K_F6, K_F7, K_F8, K_F9, K_F10,0 , 0 , K_HOME,
	K_UPARROW,K_PGUP,'_',K_LEFTARROW,'%',K_RIGHTARROW,'+',K_END, //4
	K_DOWNARROW,K_PGDN,K_INS,K_DEL,0,0, 0, K_F11,
	K_F12,0 , 0 , 0 , 0 , 0 , 0 , 0, // 5
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0, // 6
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0,
	0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 // 7
	};

	void TrapKey(void)
	{
	// static int ctrl=0;
	keybuf[keybuf_head] = dos_inportb(0x60);
	dos_outportb(0x20, 0x20);
	/*
	if (scantokey[keybuf[keybuf_head]&0x7f] == K_CTRL)
	ctrl=keybuf[keybuf_head]&0x80;
	if (ctrl && scantokey[keybuf[keybuf_head]&0x7f] == 'c')
	Sys_Error("ctrl-c hit\n");
	*/
	keybuf_head = (keybuf_head + 1) & (KEYBUF_SIZE-1);
	}

	#define SC_UPARROW 0x48
	#define SC_DOWNARROW 0x50
	#define SC_LEFTARROW 0x4b
	#define SC_RIGHTARROW 0x4d
	#define SC_LEFTSHIFT 0x2a
	#define SC_RIGHTSHIFT 0x36
	#define SC_RIGHTARROW 0x4d

	void MaskExceptions (void);
	void Sys_InitFloatTime (void);
	void Sys_PushFPCW_SetHigh (void);
	void Sys_PopFPCW (void);

	#define LEAVE_FOR_CACHE (512*1024) //FIXME: tune
	#define LOCKED_FOR_MALLOC (128*1024) //FIXME: tune


	void Sys_DetectWin95 (void)
	{
	__dpmi_regs r;

	r.x.ax = 0x160a; /* Get Windows Version */
	__dpmi_int(0x2f, &r);

	if(r.x.ax \|\| r.h.bh < 4) /* Not windows or earlier than Win95 */
	{
	win95 = 0;
	lockmem = true;
	lockunlockmem = false;
	unlockmem = true;
	}
	else
	{
	win95 = 1;
	lockunlockmem = COM_CheckParm ("-winlockunlock");

	if (lockunlockmem)
	lockmem = true;
	else
	lockmem = COM_CheckParm ("-winlock");

	unlockmem = lockmem && !lockunlockmem;
	}
	}


	void dos_getmaxlockedmem(int size)
	{
	__dpmi_free_mem_info meminfo;
	__dpmi_meminfo info;
	int working_size;
	void *working_memory;
	int last_locked;
	int extra, i, j, allocsize;
	static char *msg = "Locking data...";
	int m, n;
	byte *x;

	// first lock all the current executing image so the locked count will
	// be accurate. It doesn't hurt to lock the memory multiple times
	last_locked = __djgpp_selector_limit + 1;
	info.size = last_locked - 4096;
	info.address = __djgpp_base_address + 4096;

	if (lockmem)
	{
	if(__dpmi_lock_linear_region(&info))
	{
	Sys_Error ("Lock of current memory at 0x%lx for %ldKb failed!\n",
	info.address, info.size/1024);
	}
	}

	__dpmi_get_free_memory_information(&meminfo);

	if (!win95) /* Not windows or earlier than Win95 */
	{
	working_size = meminfo.maximum_locked_page_allocation_in_pages * 4096;
	}
	else
	{
	working_size = meminfo.largest_available_free_block_in_bytes -
	LEAVE_FOR_CACHE;
	}

	working_size &= ~0xffff; /* Round down to 64K */
	working_size += 0x10000;

	do
	{
	working_size -= 0x10000; /* Decrease 64K and try again */
	working_memory = sbrk(working_size);
	} while (working_memory == (void *)-1);

	extra = 0xfffc - ((unsigned)sbrk(0) & 0xffff);

	if (extra > 0)
	{
	sbrk(extra);
	working_size += extra;
	}

	// now grab the memory
	info.address = last_locked + __djgpp_base_address;

	if (!win95)
	{
	info.size = __djgpp_selector_limit + 1 - last_locked;

	while (info.size > 0 && __dpmi_lock_linear_region(&info))
	{
	info.size -= 0x1000;
	working_size -= 0x1000;
	sbrk(-0x1000);
	}
	}
	else
	{ /* Win95 section */
	j = COM_CheckParm("-winmem");

	if (standard_quake)
	minmem = MINIMUM_WIN_MEMORY;
	else
	minmem = MINIMUM_WIN_MEMORY_LEVELPAK;

	if (j)
	{
	allocsize = ((int)(Q_atoi(com_argv[j+1]))) * 0x100000 +
	LOCKED_FOR_MALLOC;

	if (allocsize < (minmem + LOCKED_FOR_MALLOC))
	allocsize = minmem + LOCKED_FOR_MALLOC;
	}
	else
	{
	allocsize = minmem + LOCKED_FOR_MALLOC;
	}

	if (!lockmem)
	{
	// we won't lock, just sbrk the memory
	info.size = allocsize;
	goto UpdateSbrk;
	}

	// lock the memory down
	write (STDOUT, msg, strlen (msg));

	for (j=allocsize ; j>(minmem + LOCKED_FOR_MALLOC) ;
	j -= 0x100000)
	{
	info.size = j;

	if (!__dpmi_lock_linear_region(&info))
	goto Locked;

	write (STDOUT, ".", 1);
	}

	// finally, try with the absolute minimum amount
	for (i=0 ; i<10 ; i++)
	{
	info.size = minmem + LOCKED_FOR_MALLOC;

	if (!__dpmi_lock_linear_region(&info))
	goto Locked;
	}

	Sys_Error ("Can't lock memory; %d Mb lockable RAM required. "
	"Try shrinking smartdrv.", info.size / 0x100000);

	Locked:

	UpdateSbrk:

	info.address += info.size;
	info.address -= __djgpp_base_address + 4; // ending point, malloc align
	working_size = info.address - (int)working_memory;
	sbrk(info.address-(int)sbrk(0)); // negative adjustment
	}


	if (lockunlockmem)
	{
	__dpmi_unlock_linear_region (&info);
	printf ("Locked and unlocked %d Mb data\n", working_size / 0x100000);
	}
	else if (lockmem)
	{
	printf ("Locked %d Mb data\n", working_size / 0x100000);
	}
	else
	{
	printf ("Allocated %d Mb data\n", working_size / 0x100000);
	}

	// touch all the memory to make sure it's there. The 16-page skip is to
	// keep Win 95 from thinking we're trying to page ourselves in (we are
	// doing that, of course, but there's no reason we shouldn't)
	x = (byte *)working_memory;

	for (n=0 ; n<4 ; n++)
	{
	for (m=0 ; m<(working_size - 16 * 0x1000) ; m += 4)
	{
	sys_checksum += (int )&x[m];
	sys_checksum += (int )&x[m + 16 * 0x1000];
	}
	}

	// give some of what we locked back for malloc before returning. Done
	// by cheating and passing a negative value to sbrk
	working_size -= LOCKED_FOR_MALLOC;
	sbrk( -(LOCKED_FOR_MALLOC));
	*size = working_size;
	return working_memory;
	}


	/*
	============
	Sys_FileTime

	returns -1 if not present
	============
	*/
	int Sys_FileTime (char *path)
	{
	struct stat buf;

	if (stat (path,&buf) == -1)
	return -1;

	return buf.st_mtime;
	}

	void Sys_mkdir (char *path)
	{
	mkdir (path, 0777);
	}


	void Sys_Sleep(void)
	{
	}


	char *Sys_ConsoleInput(void)
	{
	static char text[256];
	static int len = 0;
	char ch;

	if (!isDedicated)
	return NULL;

	if (! kbhit())
	return NULL;

	ch = getche();

	switch (ch)
	{
	case '\r':
	putch('\n');
	if (len)
	{
	text[len] = 0;
	len = 0;
	return text;
	}
	break;

	case '\b':
	putch(' ');
	if (len)
	{
	len--;
	putch('\b');
	}
	break;

	default:
	text[len] = ch;
	len = (len + 1) & 0xff;
	break;
	}

	return NULL;
	}

	void Sys_Init(void)
	{

	MaskExceptions ();

	Sys_SetFPCW ();

	dos_outportb(0x43, 0x34); // set system timer to mode 2
	dos_outportb(0x40, 0); // for the Sys_FloatTime() function
	dos_outportb(0x40, 0);

	Sys_InitFloatTime ();

	_go32_interrupt_stack_size = 4 * 1024;;
	_go32_rmcb_stack_size = 4 * 1024;
	}

	void Sys_Shutdown(void)
	{
	if (!isDedicated)
	dos_restoreintr(9);

	if (unlockmem)
	{
	dos_unlockmem (&start_of_memory,
	end_of_memory - (int)&start_of_memory);
	dos_unlockmem (quakeparms.membase, quakeparms.memsize);
	}
	}


	#define SC_RSHIFT 0x36
	#define SC_LSHIFT 0x2a
	void Sys_SendKeyEvents (void)
	{
	int k, next;
	int outkey;

	// get key events

	while (keybuf_head != keybuf_tail)
	{

	k = keybuf[keybuf_tail++];
	keybuf_tail &= (KEYBUF_SIZE-1);

	if (k==0xe0)
	continue; // special / pause keys
	next = keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)];
	if (next == 0xe1)
	continue; // pause key bullshit
	if (k==0xc5 && next == 0x9d)
	{
	Key_Event (K_PAUSE, true);
	continue;
	}

	// extended keyboard shift key bullshit
	if ( (k&0x7f)==SC_LSHIFT \|\| (k&0x7f)==SC_RSHIFT )
	{
	if ( keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)]==0xe0 )
	continue;
	k &= 0x80;
	k \|= SC_RSHIFT;
	}

	if (k==0xc5 && keybuf[(keybuf_tail-2)&(KEYBUF_SIZE-1)] == 0x9d)
	continue; // more pause bullshit

	outkey = scantokey[k & 0x7f];

	if (k & 0x80)
	Key_Event (outkey, false);
	else
	Key_Event (outkey, true);

	}

	}


	// =======================================================================
	// General routines
	// =======================================================================

	/*
	================
	Sys_Printf
	================
	*/

	void Sys_Printf (char *fmt, ...)
	{
	va_list argptr;
	char text[1024];

	va_start (argptr,fmt);
	vsprintf (text,fmt,argptr);
	va_end (argptr);

	if (cls.state == ca_dedicated)
	fprintf(stderr, "%s", text);
	}

	void Sys_AtExit (void)
	{

	// shutdown only once (so Sys_Error can call this function to shutdown, then
	// print the error message, then call exit without exit calling this function
	// again)
	Sys_Shutdown();
	}


	void Sys_Quit (void)
	{
	byte screen[80252];
	byte *d;
	char ver[6];
	int i;


	// load the sell screen before shuting everything down
	if (registered.value)
	d = COM_LoadHunkFile ("end2.bin");
	else
	d = COM_LoadHunkFile ("end1.bin");
	if (d)
	memcpy (screen, d, sizeof(screen));

	// write the version number directly to the end screen
	sprintf (ver, " v%4.2f", VERSION);
	for (i=0 ; i<6 ; i++)
	screen[0802 + 722 + i2] = ver[i];

	Host_Shutdown();

	// do the text mode sell screen
	if (d)
	{
	memcpy ((void )real2ptr(0xb8000), screen,8025*2);

	// set text pos
	regs.x.ax = 0x0200;
	regs.h.bh = 0;
	regs.h.dl = 0;
	regs.h.dh = 22;
	dos_int86 (0x10);
	}
	else
	printf ("couldn't load endscreen.\n");

	exit(0);
	}

	void Sys_Error (char *error, ...)
	{
	va_list argptr;
	char string[1024];

	va_start (argptr,error);
	vsprintf (string,error,argptr);
	va_end (argptr);

	Host_Shutdown();
	fprintf(stderr, "Error: %s\n", string);
	// Sys_AtExit is called by exit to shutdown the system
	exit(0);
	}


	int Sys_FileOpenRead (char path, int handle)
	{
	int h;
	struct stat fileinfo;

	h = open (path, O_RDONLY\|O_BINARY, 0666);
	*handle = h;
	if (h == -1)
	return -1;

	if (fstat (h,&fileinfo) == -1)
	Sys_Error ("Error fstating %s", path);

	return fileinfo.st_size;
	}

	int Sys_FileOpenWrite (char *path)
	{
	int handle;

	umask (0);

	handle = open(path,O_RDWR \| O_BINARY \| O_CREAT \| O_TRUNC
	, 0666);

	if (handle == -1)
	Sys_Error ("Error opening %s: %s", path,strerror(errno));

	return handle;
	}

	void Sys_FileClose (int handle)
	{
	close (handle);
	}

	void Sys_FileSeek (int handle, int position)
	{
	lseek (handle, position, SEEK_SET);
	}

	int Sys_FileRead (int handle, void *dest, int count)
	{
	return read (handle, dest, count);
	}

	int Sys_FileWrite (int handle, void *data, int count)
	{
	return write (handle, data, count);
	}

	/*
	================
	Sys_MakeCodeWriteable
	================
	*/
	void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
	{
	// it's always writeable
	}


	/*
	================
	Sys_FloatTime
	================
	*/
	double Sys_FloatTime (void)
	{
	int r;
	unsigned t, tick;
	double ft, time;
	static int sametimecount;

	Sys_PushFPCW_SetHigh ();

	//{static float t = 0; t=t+0.05; return t;} // DEBUG

	t = (unsigned short)real2ptr(0x46c) * 65536;

	dos_outportb(0x43, 0); // latch time
	r = dos_inportb(0x40);
	r \|= dos_inportb(0x40) << 8;
	r = (r-1) & 0xffff;

	tick = (unsigned short)real2ptr(0x46c) * 65536;
	if ((tick != t) && (r & 0x8000))
	t = tick;

	ft = (double) (t+(65536-r)) / 1193200.0;
	time = ft - oldtime;
	oldtime = ft;

	if (time < 0)
	{
	if (time > -3000.0)
	time = 0.0;
	else
	time += 3600.0;
	}

	curtime += time;

	if (curtime == lastcurtime)
	{
	sametimecount++;

	if (sametimecount > 100000)
	{
	curtime += 1.0;
	sametimecount = 0;
	}
	}
	else
	{
	sametimecount = 0;
	}

	lastcurtime = curtime;

	Sys_PopFPCW ();

	return curtime;
	}


	/*
	================
	Sys_InitFloatTime
	================
	*/
	void Sys_InitFloatTime (void)
	{
	int j;

	Sys_FloatTime ();

	oldtime = curtime;

	j = COM_CheckParm("-starttime");

	if (j)
	{
	curtime = (double) (Q_atof(com_argv[j+1]));
	}
	else
	{
	curtime = 0.0;
	}
	lastcurtime = curtime;
	}


	/*
	================
	Sys_GetMemory
	================
	*/
	void Sys_GetMemory(void)
	{
	int j, tsize;

	j = COM_CheckParm("-mem");
	if (j)
	{
	quakeparms.memsize = (int) (Q_atof(com_argv[j+1]) * 1024 * 1024);
	quakeparms.membase = malloc (quakeparms.memsize);
	}
	else
	{
	quakeparms.membase = dos_getmaxlockedmem (&quakeparms.memsize);
	}

	fprintf(stderr, "malloc'd: %d\n", quakeparms.memsize);

	if (COM_CheckParm ("-heapsize"))
	{
	tsize = Q_atoi (com_argv[COM_CheckParm("-heapsize") + 1]) * 1024;

	if (tsize < quakeparms.memsize)
	quakeparms.memsize = tsize;
	}
	}


	/*
	================
	Sys_PageInProgram

	walks the text, data, and bss to make sure it's all paged in so that the
	actual physical memory detected by Sys_GetMemory is correct.
	================
	*/
	void Sys_PageInProgram(void)
	{
	int i, j;

	end_of_memory = (int)sbrk(0);

	if (lockmem)
	{
	if (dos_lockmem ((void *)&start_of_memory,
	end_of_memory - (int)&start_of_memory))
	Sys_Error ("Couldn't lock text and data");
	}

	if (lockunlockmem)
	{
	dos_unlockmem((void *)&start_of_memory,
	end_of_memory - (int)&start_of_memory);
	printf ("Locked and unlocked %d Mb image\n",
	(end_of_memory - (int)&start_of_memory) / 0x100000);
	}
	else if (lockmem)
	{
	printf ("Locked %d Mb image\n",
	(end_of_memory - (int)&start_of_memory) / 0x100000);
	}
	else
	{
	printf ("Loaded %d Mb image\n",
	(end_of_memory - (int)&start_of_memory) / 0x100000);
	}

	// touch the entire image, doing the 16-page skip so Win95 doesn't think we're
	// trying to page ourselves in
	for (j=0 ; j<4 ; j++)
	{
	for(i=(int)&start_of_memory ; i<(end_of_memory - 16 * 0x1000) ; i += 4)
	{
	sys_checksum += (int )i;
	sys_checksum += (int )(i + 16 * 0x1000);
	}
	}
	}


	/*
	================
	Sys_NoFPUExceptionHandler
	================
	*/
	void Sys_NoFPUExceptionHandler(int whatever)
	{
	printf ("\nError: Quake requires a floating-point processor\n");
	exit (0);
	}


	/*
	================
	Sys_DefaultExceptionHandler
	================
	*/
	void Sys_DefaultExceptionHandler(int whatever)
	{
	}


	/*
	================
	main
	================
	*/
	int main (int c, char **v)
	{
	double time, oldtime, newtime;
	extern void (dos_error_func)(char , ...);
	static char cwd[1024];

	printf ("Quake v%4.2f\n", VERSION);

	// make sure there's an FPU
	signal(SIGNOFP, Sys_NoFPUExceptionHandler);
	signal(SIGABRT, Sys_DefaultExceptionHandler);
	signal(SIGALRM, Sys_DefaultExceptionHandler);
	signal(SIGKILL, Sys_DefaultExceptionHandler);
	signal(SIGQUIT, Sys_DefaultExceptionHandler);
	signal(SIGINT, Sys_DefaultExceptionHandler);

	if (fptest_temp >= 0.0)
	fptest_temp += 0.1;

	COM_InitArgv (c, v);

	quakeparms.argc = com_argc;
	quakeparms.argv = com_argv;

	dos_error_func = Sys_Error;

	Sys_DetectWin95 ();
	Sys_PageInProgram ();
	Sys_GetMemory ();

	atexit (Sys_AtExit); // in case we crash

	getwd (cwd);
	if (cwd[Q_strlen(cwd)-1] == '/') cwd[Q_strlen(cwd)-1] = 0;
	quakeparms.basedir = cwd; //"f:/quake";

	isDedicated = (COM_CheckParm ("-dedicated") != 0);

	Sys_Init ();

	if (!isDedicated)
	dos_registerintr(9, TrapKey);

	//Sys_InitStackCheck ();

	Host_Init(&quakeparms);

	//Sys_StackCheck ();

	//Con_Printf ("Top of stack: 0x%x\n", &time);
	oldtime = Sys_FloatTime ();
	while (1)
	{
	newtime = Sys_FloatTime ();
	time = newtime - oldtime;

	if (cls.state == ca_dedicated && (time<sys_ticrate.value))
	continue;

	Host_Frame (time);

	//Sys_StackCheck ();

	oldtime = newtime;
	}
	}