Quake-III-Arena

win_main.c (26994B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code 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.
 
 Quake III Arena source code 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 Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 // win_main.c
 
 #include "../client/client.h"
 #include "../qcommon/qcommon.h"
 #include "win_local.h"
 #include "resource.h"
 #include <errno.h>
 #include <float.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <direct.h>
 #include <io.h>
 #include <conio.h>
 
 #define	CD_BASEDIR	"quake3"
 #define	CD_EXE		"quake3.exe"
 #define	CD_BASEDIR_LINUX	"bin\\x86\\glibc-2.1"
 #define	CD_EXE_LINUX "quake3"
 #define MEM_THRESHOLD 96*1024*1024
 
 static char		sys_cmdline[MAX_STRING_CHARS];
 
 // define this to use alternate spanking method
 // I found out that the regular way doesn't work on my box for some reason
 // see the associated spank.sh script
 #define ALT_SPANK
 #ifdef ALT_SPANK
 #include <stdio.h>
 #include <sys\stat.h>
 
 int fh = 0;
 
 void Spk_Open(char *name)
 {
   fh = open( name, O_TRUNC | O_CREAT | O_WRONLY, S_IREAD | S_IWRITE );
 };
 
 void Spk_Close()
 {
   if (!fh)
     return;
 
   close( fh );
   fh = 0;
 }
 
 void Spk_Printf (const char *text, ...)
 {
   va_list argptr;
   char buf[32768];
 
   if (!fh)
     return;
 
   va_start (argptr,text);
   vsprintf (buf, text, argptr);
   write(fh, buf, strlen(buf));
   _commit(fh);
   va_end (argptr);
 
 };
 #endif
 
 /*
 ==================
 Sys_LowPhysicalMemory()
 ==================
 */
 
 qboolean Sys_LowPhysicalMemory() {
 	MEMORYSTATUS stat;
   GlobalMemoryStatus (&stat);
 	return (stat.dwTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse;
 }
 
 /*
 ==================
 Sys_BeginProfiling
 ==================
 */
 void Sys_BeginProfiling( void ) {
 	// this is just used on the mac build
 }
 
 /*
 =============
 Sys_Error
 
 Show the early console as an error dialog
 =============
 */
 void QDECL Sys_Error( const char *error, ... ) {
 	va_list		argptr;
 	char		text[4096];
     MSG        msg;
 
 	va_start (argptr, error);
 	vsprintf (text, error, argptr);
 	va_end (argptr);
 
 	Conbuf_AppendText( text );
 	Conbuf_AppendText( "\n" );
 
 	Sys_SetErrorText( text );
 	Sys_ShowConsole( 1, qtrue );
 
 	timeEndPeriod( 1 );
 
 	IN_Shutdown();
 
 	// wait for the user to quit
 	while ( 1 ) {
 		if (!GetMessage (&msg, NULL, 0, 0))
 			Com_Quit_f ();
 		TranslateMessage (&msg);
       	DispatchMessage (&msg);
 	}
 
 	Sys_DestroyConsole();
 
 	exit (1);
 }
 
 /*
 ==============
 Sys_Quit
 ==============
 */
 void Sys_Quit( void ) {
 	timeEndPeriod( 1 );
 	IN_Shutdown();
 	Sys_DestroyConsole();
 
 	exit (0);
 }
 
 /*
 ==============
 Sys_Print
 ==============
 */
 void Sys_Print( const char *msg ) {
 	Conbuf_AppendText( msg );
 }
 
 
 /*
 ==============
 Sys_Mkdir
 ==============
 */
 void Sys_Mkdir( const char *path ) {
 	_mkdir (path);
 }
 
 /*
 ==============
 Sys_Cwd
 ==============
 */
 char *Sys_Cwd( void ) {
 	static char cwd[MAX_OSPATH];
 
 	_getcwd( cwd, sizeof( cwd ) - 1 );
 	cwd[MAX_OSPATH-1] = 0;
 
 	return cwd;
 }
 
 /*
 ==============
 Sys_DefaultCDPath
 ==============
 */
 char *Sys_DefaultCDPath( void ) {
 	return "";
 }
 
 /*
 ==============
 Sys_DefaultBasePath
 ==============
 */
 char *Sys_DefaultBasePath( void ) {
 	return Sys_Cwd();
 }
 
 /*
 ==============================================================
 
 DIRECTORY SCANNING
 
 ==============================================================
 */
 
 #define	MAX_FOUND_FILES	0x1000
 
 void Sys_ListFilteredFiles( const char *basedir, char *subdirs, char *filter, char **list, int *numfiles ) {
 	char		search[MAX_OSPATH], newsubdirs[MAX_OSPATH];
 	char		filename[MAX_OSPATH];
 	int			findhandle;
 	struct _finddata_t findinfo;
 
 	if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
 		return;
 	}
 
 	if (strlen(subdirs)) {
 		Com_sprintf( search, sizeof(search), "%s\\%s\\*", basedir, subdirs );
 	}
 	else {
 		Com_sprintf( search, sizeof(search), "%s\\*", basedir );
 	}
 
 	findhandle = _findfirst (search, &findinfo);
 	if (findhandle == -1) {
 		return;
 	}
 
 	do {
 		if (findinfo.attrib & _A_SUBDIR) {
 			if (Q_stricmp(findinfo.name, ".") && Q_stricmp(findinfo.name, "..")) {
 				if (strlen(subdirs)) {
 					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s\\%s", subdirs, findinfo.name);
 				}
 				else {
 					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s", findinfo.name);
 				}
 				Sys_ListFilteredFiles( basedir, newsubdirs, filter, list, numfiles );
 			}
 		}
 		if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
 			break;
 		}
 		Com_sprintf( filename, sizeof(filename), "%s\\%s", subdirs, findinfo.name );
 		if (!Com_FilterPath( filter, filename, qfalse ))
 			continue;
 		list[ *numfiles ] = CopyString( filename );
 		(*numfiles)++;
 	} while ( _findnext (findhandle, &findinfo) != -1 );
 
 	_findclose (findhandle);
 }
 
 static qboolean strgtr(const char *s0, const char *s1) {
 	int l0, l1, i;
 
 	l0 = strlen(s0);
 	l1 = strlen(s1);
 
 	if (l1<l0) {
 		l0 = l1;
 	}
 
 	for(i=0;i<l0;i++) {
 		if (s1[i] > s0[i]) {
 			return qtrue;
 		}
 		if (s1[i] < s0[i]) {
 			return qfalse;
 		}
 	}
 	return qfalse;
 }
 
 char **Sys_ListFiles( const char *directory, const char *extension, char *filter, int *numfiles, qboolean wantsubs ) {
 	char		search[MAX_OSPATH];
 	int			nfiles;
 	char		**listCopy;
 	char		*list[MAX_FOUND_FILES];
 	struct _finddata_t findinfo;
 	int			findhandle;
 	int			flag;
 	int			i;
 
 	if (filter) {
 
 		nfiles = 0;
 		Sys_ListFilteredFiles( directory, "", filter, list, &nfiles );
 
 		list[ nfiles ] = 0;
 		*numfiles = nfiles;
 
 		if (!nfiles)
 			return NULL;
 
 		listCopy = Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
 		for ( i = 0 ; i < nfiles ; i++ ) {
 			listCopy[i] = list[i];
 		}
 		listCopy[i] = NULL;
 
 		return listCopy;
 	}
 
 	if ( !extension) {
 		extension = "";
 	}
 
 	// passing a slash as extension will find directories
 	if ( extension[0] == '/' && extension[1] == 0 ) {
 		extension = "";
 		flag = 0;
 	} else {
 		flag = _A_SUBDIR;
 	}
 
 	Com_sprintf( search, sizeof(search), "%s\\*%s", directory, extension );
 
 	// search
 	nfiles = 0;
 
 	findhandle = _findfirst (search, &findinfo);
 	if (findhandle == -1) {
 		*numfiles = 0;
 		return NULL;
 	}
 
 	do {
 		if ( (!wantsubs && flag ^ ( findinfo.attrib & _A_SUBDIR )) || (wantsubs && findinfo.attrib & _A_SUBDIR) ) {
 			if ( nfiles == MAX_FOUND_FILES - 1 ) {
 				break;
 			}
 			list[ nfiles ] = CopyString( findinfo.name );
 			nfiles++;
 		}
 	} while ( _findnext (findhandle, &findinfo) != -1 );
 
 	list[ nfiles ] = 0;
 
 	_findclose (findhandle);
 
 	// return a copy of the list
 	*numfiles = nfiles;
 
 	if ( !nfiles ) {
 		return NULL;
 	}
 
 	listCopy = Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
 	for ( i = 0 ; i < nfiles ; i++ ) {
 		listCopy[i] = list[i];
 	}
 	listCopy[i] = NULL;
 
 	do {
 		flag = 0;
 		for(i=1; i<nfiles; i++) {
 			if (strgtr(listCopy[i-1], listCopy[i])) {
 				char *temp = listCopy[i];
 				listCopy[i] = listCopy[i-1];
 				listCopy[i-1] = temp;
 				flag = 1;
 			}
 		}
 	} while(flag);
 
 	return listCopy;
 }
 
 void	Sys_FreeFileList( char **list ) {
 	int		i;
 
 	if ( !list ) {
 		return;
 	}
 
 	for ( i = 0 ; list[i] ; i++ ) {
 		Z_Free( list[i] );
 	}
 
 	Z_Free( list );
 }
 
 //========================================================
 
 
 /*
 ================
 Sys_ScanForCD
 
 Search all the drives to see if there is a valid CD to grab
 the cddir from
 ================
 */
 qboolean Sys_ScanForCD( void ) {
 	static char	cddir[MAX_OSPATH];
 	char		drive[4];
 	FILE		*f;
 	char		test[MAX_OSPATH];
 #if 0
 	// don't override a cdpath on the command line
 	if ( strstr( sys_cmdline, "cdpath" ) ) {
 		return;
 	}
 #endif
 
 	drive[0] = 'c';
 	drive[1] = ':';
 	drive[2] = '\\';
 	drive[3] = 0;
 
 	// scan the drives
 	for ( drive[0] = 'c' ; drive[0] <= 'z' ; drive[0]++ ) {
 		if ( GetDriveType (drive) != DRIVE_CDROM ) {
 			continue;
 		}
 
 		sprintf (cddir, "%s%s", drive, CD_BASEDIR);
 		sprintf (test, "%s\\%s", cddir, CD_EXE);
 		f = fopen( test, "r" );
 		if ( f ) {
 			fclose (f);
 			return qtrue;
     } else {
       sprintf(cddir, "%s%s", drive, CD_BASEDIR_LINUX);
       sprintf(test, "%s\\%s", cddir, CD_EXE_LINUX);
   		f = fopen( test, "r" );
 	  	if ( f ) {
 		  	fclose (f);
 			  return qtrue;
       }
     }
 	}
 
 	return qfalse;
 }
 
 /*
 ================
 Sys_CheckCD
 
 Return true if the proper CD is in the drive
 ================
 */
 qboolean	Sys_CheckCD( void ) {
   // FIXME: mission pack
   return qtrue;
 	//return Sys_ScanForCD();
 }
 
 
 /*
 ================
 Sys_GetClipboardData
 
 ================
 */
 char *Sys_GetClipboardData( void ) {
 	char *data = NULL;
 	char *cliptext;
 
 	if ( OpenClipboard( NULL ) != 0 ) {
 		HANDLE hClipboardData;
 
 		if ( ( hClipboardData = GetClipboardData( CF_TEXT ) ) != 0 ) {
 			if ( ( cliptext = GlobalLock( hClipboardData ) ) != 0 ) {
 				data = Z_Malloc( GlobalSize( hClipboardData ) + 1 );
 				Q_strncpyz( data, cliptext, GlobalSize( hClipboardData ) );
 				GlobalUnlock( hClipboardData );
 				
 				strtok( data, "\n\r\b" );
 			}
 		}
 		CloseClipboard();
 	}
 	return data;
 }
 
 
 /*
 ========================================================================
 
 LOAD/UNLOAD DLL
 
 ========================================================================
 */
 
 /*
 =================
 Sys_UnloadDll
 
 =================
 */
 void Sys_UnloadDll( void *dllHandle ) {
 	if ( !dllHandle ) {
 		return;
 	}
 	if ( !FreeLibrary( dllHandle ) ) {
 		Com_Error (ERR_FATAL, "Sys_UnloadDll FreeLibrary failed");
 	}
 }
 
 /*
 =================
 Sys_LoadDll
 
 Used to load a development dll instead of a virtual machine
 
 TTimo: added some verbosity in debug
 =================
 */
 extern char		*FS_BuildOSPath( const char *base, const char *game, const char *qpath );
 
 // fqpath param added 7/20/02 by T.Ray - Sys_LoadDll is only called in vm.c at this time
 // fqpath will be empty if dll not loaded, otherwise will hold fully qualified path of dll module loaded
 // fqpath buffersize must be at least MAX_QPATH+1 bytes long
 void * QDECL Sys_LoadDll( const char *name, char *fqpath , int (QDECL **entryPoint)(int, ...),
 				  int (QDECL *systemcalls)(int, ...) ) {
 	static int	lastWarning = 0;
 	HINSTANCE	libHandle;
 	void	(QDECL *dllEntry)( int (QDECL *syscallptr)(int, ...) );
 	char	*basepath;
 	char	*cdpath;
 	char	*gamedir;
 	char	*fn;
 #ifdef NDEBUG
 	int		timestamp;
   int   ret;
 #endif
 	char	filename[MAX_QPATH];
 
 	*fqpath = 0 ;		// added 7/20/02 by T.Ray
 
 	Com_sprintf( filename, sizeof( filename ), "%sx86.dll", name );
 
 #ifdef NDEBUG
 	timestamp = Sys_Milliseconds();
 	if( ((timestamp - lastWarning) > (5 * 60000)) && !Cvar_VariableIntegerValue( "dedicated" )
 		&& !Cvar_VariableIntegerValue( "com_blindlyLoadDLLs" ) ) {
 		if (FS_FileExists(filename)) {
 			lastWarning = timestamp;
 			ret = MessageBoxEx( NULL, "You are about to load a .DLL executable that\n"
 				  "has not been verified for use with Quake III Arena.\n"
 				  "This type of file can compromise the security of\n"
 				  "your computer.\n\n"
 				  "Select 'OK' if you choose to load it anyway.",
 				  "Security Warning", MB_OKCANCEL | MB_ICONEXCLAMATION | MB_DEFBUTTON2 | MB_TOPMOST | MB_SETFOREGROUND,
 				  MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ) );
 			if( ret != IDOK ) {
 				return NULL;
 			}
 		}
 	}
 #endif
 
 #ifndef NDEBUG
 	libHandle = LoadLibrary( filename );
   if (libHandle)
     Com_Printf("LoadLibrary '%s' ok\n", filename);
   else
     Com_Printf("LoadLibrary '%s' failed\n", filename);
 	if ( !libHandle ) {
 #endif
 	basepath = Cvar_VariableString( "fs_basepath" );
 	cdpath = Cvar_VariableString( "fs_cdpath" );
 	gamedir = Cvar_VariableString( "fs_game" );
 
 	fn = FS_BuildOSPath( basepath, gamedir, filename );
 	libHandle = LoadLibrary( fn );
 #ifndef NDEBUG
   if (libHandle)
     Com_Printf("LoadLibrary '%s' ok\n", fn);
   else
     Com_Printf("LoadLibrary '%s' failed\n", fn);
 #endif
 
 	if ( !libHandle ) {
 		if( cdpath[0] ) {
 			fn = FS_BuildOSPath( cdpath, gamedir, filename );
 			libHandle = LoadLibrary( fn );
 #ifndef NDEBUG
       if (libHandle)
         Com_Printf("LoadLibrary '%s' ok\n", fn);
       else
         Com_Printf("LoadLibrary '%s' failed\n", fn);
 #endif
 		}
 
 		if ( !libHandle ) {
 			return NULL;
 		}
 	}
 #ifndef NDEBUG
 	}
 #endif
 
 	dllEntry = ( void (QDECL *)( int (QDECL *)( int, ... ) ) )GetProcAddress( libHandle, "dllEntry" ); 
 	*entryPoint = (int (QDECL *)(int,...))GetProcAddress( libHandle, "vmMain" );
 	if ( !*entryPoint || !dllEntry ) {
 		FreeLibrary( libHandle );
 		return NULL;
 	}
 	dllEntry( systemcalls );
 
 	if ( libHandle ) Q_strncpyz ( fqpath , filename , MAX_QPATH ) ;		// added 7/20/02 by T.Ray
 	return libHandle;
 }
 
 
 /*
 ========================================================================
 
 BACKGROUND FILE STREAMING
 
 ========================================================================
 */
 
 #if 1
 
 void Sys_InitStreamThread( void ) {
 }
 
 void Sys_ShutdownStreamThread( void ) {
 }
 
 void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
 }
 
 void Sys_EndStreamedFile( fileHandle_t f ) {
 }
 
 int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
    return FS_Read( buffer, size * count, f );
 }
 
 void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
    FS_Seek( f, offset, origin );
 }
 
 
 #else
 
 typedef struct {
 	fileHandle_t	file;
 	byte	*buffer;
 	qboolean	eof;
 	qboolean	active;
 	int		bufferSize;
 	int		streamPosition;	// next byte to be returned by Sys_StreamRead
 	int		threadPosition;	// next byte to be read from file
 } streamsIO_t;
 
 typedef struct {
 	HANDLE				threadHandle;
 	int					threadId;
 	CRITICAL_SECTION	crit;
 	streamsIO_t			sIO[MAX_FILE_HANDLES];
 } streamState_t;
 
 streamState_t	stream;
 
 /*
 ===============
 Sys_StreamThread
 
 A thread will be sitting in this loop forever
 ================
 */
 void Sys_StreamThread( void ) {
 	int		buffer;
 	int		count;
 	int		readCount;
 	int		bufferPoint;
 	int		r, i;
 
 	while (1) {
 		Sleep( 10 );
 //		EnterCriticalSection (&stream.crit);
 
 		for (i=1;i<MAX_FILE_HANDLES;i++) {
 			// if there is any space left in the buffer, fill it up
 			if ( stream.sIO[i].active  && !stream.sIO[i].eof ) {
 				count = stream.sIO[i].bufferSize - (stream.sIO[i].threadPosition - stream.sIO[i].streamPosition);
 				if ( !count ) {
 					continue;
 				}
 
 				bufferPoint = stream.sIO[i].threadPosition % stream.sIO[i].bufferSize;
 				buffer = stream.sIO[i].bufferSize - bufferPoint;
 				readCount = buffer < count ? buffer : count;
 
 				r = FS_Read( stream.sIO[i].buffer + bufferPoint, readCount, stream.sIO[i].file );
 				stream.sIO[i].threadPosition += r;
 
 				if ( r != readCount ) {
 					stream.sIO[i].eof = qtrue;
 				}
 			}
 		}
 //		LeaveCriticalSection (&stream.crit);
 	}
 }
 
 /*
 ===============
 Sys_InitStreamThread
 
 ================
 */
 void Sys_InitStreamThread( void ) {
 	int i;
 
 	InitializeCriticalSection ( &stream.crit );
 
 	// don't leave the critical section until there is a
 	// valid file to stream, which will cause the StreamThread
 	// to sleep without any overhead
 //	EnterCriticalSection( &stream.crit );
 
 	stream.threadHandle = CreateThread(
 	   NULL,	// LPSECURITY_ATTRIBUTES lpsa,
 	   0,		// DWORD cbStack,
 	   (LPTHREAD_START_ROUTINE)Sys_StreamThread,	// LPTHREAD_START_ROUTINE lpStartAddr,
 	   0,			// LPVOID lpvThreadParm,
 	   0,			//   DWORD fdwCreate,
 	   &stream.threadId);
 	for(i=0;i<MAX_FILE_HANDLES;i++) {
 		stream.sIO[i].active = qfalse;
 	}
 }
 
 /*
 ===============
 Sys_ShutdownStreamThread
 
 ================
 */
 void Sys_ShutdownStreamThread( void ) {
 }
 
 
 /*
 ===============
 Sys_BeginStreamedFile
 
 ================
 */
 void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
 	if ( stream.sIO[f].file ) {
 		Sys_EndStreamedFile( stream.sIO[f].file );
 	}
 
 	stream.sIO[f].file = f;
 	stream.sIO[f].buffer = Z_Malloc( readAhead );
 	stream.sIO[f].bufferSize = readAhead;
 	stream.sIO[f].streamPosition = 0;
 	stream.sIO[f].threadPosition = 0;
 	stream.sIO[f].eof = qfalse;
 	stream.sIO[f].active = qtrue;
 
 	// let the thread start running
 //	LeaveCriticalSection( &stream.crit );
 }
 
 /*
 ===============
 Sys_EndStreamedFile
 
 ================
 */
 void Sys_EndStreamedFile( fileHandle_t f ) {
 	if ( f != stream.sIO[f].file ) {
 		Com_Error( ERR_FATAL, "Sys_EndStreamedFile: wrong file");
 	}
 	// don't leave critical section until another stream is started
 	EnterCriticalSection( &stream.crit );
 
 	stream.sIO[f].file = 0;
 	stream.sIO[f].active = qfalse;
 
 	Z_Free( stream.sIO[f].buffer );
 
 	LeaveCriticalSection( &stream.crit );
 }
 
 
 /*
 ===============
 Sys_StreamedRead
 
 ================
 */
 int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
 	int		available;
 	int		remaining;
 	int		sleepCount;
 	int		copy;
 	int		bufferCount;
 	int		bufferPoint;
 	byte	*dest;
 
 	if (stream.sIO[f].active == qfalse) {
 		Com_Error( ERR_FATAL, "Streamed read with non-streaming file" );
 	}
 
 	dest = (byte *)buffer;
 	remaining = size * count;
 
 	if ( remaining <= 0 ) {
 		Com_Error( ERR_FATAL, "Streamed read with non-positive size" );
 	}
 
 	sleepCount = 0;
 	while ( remaining > 0 ) {
 		available = stream.sIO[f].threadPosition - stream.sIO[f].streamPosition;
 		if ( !available ) {
 			if ( stream.sIO[f].eof ) {
 				break;
 			}
 			if ( sleepCount == 1 ) {
 				Com_DPrintf( "Sys_StreamedRead: waiting\n" );
 			}
 			if ( ++sleepCount > 100 ) {
 				Com_Error( ERR_FATAL, "Sys_StreamedRead: thread has died");
 			}
 			Sleep( 10 );
 			continue;
 		}
 
 		EnterCriticalSection( &stream.crit );
 
 		bufferPoint = stream.sIO[f].streamPosition % stream.sIO[f].bufferSize;
 		bufferCount = stream.sIO[f].bufferSize - bufferPoint;
 
 		copy = available < bufferCount ? available : bufferCount;
 		if ( copy > remaining ) {
 			copy = remaining;
 		}
 		memcpy( dest, stream.sIO[f].buffer + bufferPoint, copy );
 		stream.sIO[f].streamPosition += copy;
 		dest += copy;
 		remaining -= copy;
 
 		LeaveCriticalSection( &stream.crit );
 	}
 
 	return (count * size - remaining) / size;
 }
 
 /*
 ===============
 Sys_StreamSeek
 
 ================
 */
 void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
 
 	// halt the thread
 	EnterCriticalSection( &stream.crit );
 
 	// clear to that point
 	FS_Seek( f, offset, origin );
 	stream.sIO[f].streamPosition = 0;
 	stream.sIO[f].threadPosition = 0;
 	stream.sIO[f].eof = qfalse;
 
 	// let the thread start running at the new position
 	LeaveCriticalSection( &stream.crit );
 }
 
 #endif
 
 /*
 ========================================================================
 
 EVENT LOOP
 
 ========================================================================
 */
 
 #define	MAX_QUED_EVENTS		256
 #define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
 
 sysEvent_t	eventQue[MAX_QUED_EVENTS];
 int			eventHead, eventTail;
 byte		sys_packetReceived[MAX_MSGLEN];
 
 /*
 ================
 Sys_QueEvent
 
 A time of 0 will get the current time
 Ptr should either be null, or point to a block of data that can
 be freed by the game later.
 ================
 */
 void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
 	sysEvent_t	*ev;
 
 	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
 	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
 		Com_Printf("Sys_QueEvent: overflow\n");
 		// we are discarding an event, but don't leak memory
 		if ( ev->evPtr ) {
 			Z_Free( ev->evPtr );
 		}
 		eventTail++;
 	}
 
 	eventHead++;
 
 	if ( time == 0 ) {
 		time = Sys_Milliseconds();
 	}
 
 	ev->evTime = time;
 	ev->evType = type;
 	ev->evValue = value;
 	ev->evValue2 = value2;
 	ev->evPtrLength = ptrLength;
 	ev->evPtr = ptr;
 }
 
 /*
 ================
 Sys_GetEvent
 
 ================
 */
 sysEvent_t Sys_GetEvent( void ) {
     MSG			msg;
 	sysEvent_t	ev;
 	char		*s;
 	msg_t		netmsg;
 	netadr_t	adr;
 
 	// return if we have data
 	if ( eventHead > eventTail ) {
 		eventTail++;
 		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
 	}
 
 	// pump the message loop
 	while (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)) {
 		if ( !GetMessage (&msg, NULL, 0, 0) ) {
 			Com_Quit_f();
 		}
 
 		// save the msg time, because wndprocs don't have access to the timestamp
 		g_wv.sysMsgTime = msg.time;
 
 		TranslateMessage (&msg);
       	DispatchMessage (&msg);
 	}
 
 	// check for console commands
 	s = Sys_ConsoleInput();
 	if ( s ) {
 		char	*b;
 		int		len;
 
 		len = strlen( s ) + 1;
 		b = Z_Malloc( len );
 		Q_strncpyz( b, s, len-1 );
 		Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
 	}
 
 	// check for network packets
 	MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
 	if ( Sys_GetPacket ( &adr, &netmsg ) ) {
 		netadr_t		*buf;
 		int				len;
 
 		// copy out to a seperate buffer for qeueing
 		// the readcount stepahead is for SOCKS support
 		len = sizeof( netadr_t ) + netmsg.cursize - netmsg.readcount;
 		buf = Z_Malloc( len );
 		*buf = adr;
 		memcpy( buf+1, &netmsg.data[netmsg.readcount], netmsg.cursize - netmsg.readcount );
 		Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
 	}
 
 	// return if we have data
 	if ( eventHead > eventTail ) {
 		eventTail++;
 		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
 	}
 
 	// create an empty event to return
 
 	memset( &ev, 0, sizeof( ev ) );
 	ev.evTime = timeGetTime();
 
 	return ev;
 }
 
 //================================================================
 
 /*
 =================
 Sys_In_Restart_f
 
 Restart the input subsystem
 =================
 */
 void Sys_In_Restart_f( void ) {
 	IN_Shutdown();
 	IN_Init();
 }
 
 
 /*
 =================
 Sys_Net_Restart_f
 
 Restart the network subsystem
 =================
 */
 void Sys_Net_Restart_f( void ) {
 	NET_Restart();
 }
 
 
 /*
 ================
 Sys_Init
 
 Called after the common systems (cvars, files, etc)
 are initialized
 ================
 */
 #define OSR2_BUILD_NUMBER 1111
 #define WIN98_BUILD_NUMBER 1998
 
 void Sys_Init( void ) {
 	int cpuid;
 
 	// make sure the timer is high precision, otherwise
 	// NT gets 18ms resolution
 	timeBeginPeriod( 1 );
 
 	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
 	Cmd_AddCommand ("net_restart", Sys_Net_Restart_f);
 
 	g_wv.osversion.dwOSVersionInfoSize = sizeof( g_wv.osversion );
 
 	if (!GetVersionEx (&g_wv.osversion))
 		Sys_Error ("Couldn't get OS info");
 
 	if (g_wv.osversion.dwMajorVersion < 4)
 		Sys_Error ("Quake3 requires Windows version 4 or greater");
 	if (g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32s)
 		Sys_Error ("Quake3 doesn't run on Win32s");
 
 	if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT )
 	{
 		Cvar_Set( "arch", "winnt" );
 	}
 	else if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
 	{
 		if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= WIN98_BUILD_NUMBER )
 		{
 			Cvar_Set( "arch", "win98" );
 		}
 		else if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
 		{
 			Cvar_Set( "arch", "win95 osr2.x" );
 		}
 		else
 		{
 			Cvar_Set( "arch", "win95" );
 		}
 	}
 	else
 	{
 		Cvar_Set( "arch", "unknown Windows variant" );
 	}
 
 	// save out a couple things in rom cvars for the renderer to access
 	Cvar_Get( "win_hinstance", va("%i", (int)g_wv.hInstance), CVAR_ROM );
 	Cvar_Get( "win_wndproc", va("%i", (int)MainWndProc), CVAR_ROM );
 
 	//
 	// figure out our CPU
 	//
 	Cvar_Get( "sys_cpustring", "detect", 0 );
 	if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring"), "detect" ) )
 	{
 		Com_Printf( "...detecting CPU, found " );
 
 		cpuid = Sys_GetProcessorId();
 
 		switch ( cpuid )
 		{
 		case CPUID_GENERIC:
 			Cvar_Set( "sys_cpustring", "generic" );
 			break;
 		case CPUID_INTEL_UNSUPPORTED:
 			Cvar_Set( "sys_cpustring", "x86 (pre-Pentium)" );
 			break;
 		case CPUID_INTEL_PENTIUM:
 			Cvar_Set( "sys_cpustring", "x86 (P5/PPro, non-MMX)" );
 			break;
 		case CPUID_INTEL_MMX:
 			Cvar_Set( "sys_cpustring", "x86 (P5/Pentium2, MMX)" );
 			break;
 		case CPUID_INTEL_KATMAI:
 			Cvar_Set( "sys_cpustring", "Intel Pentium III" );
 			break;
 		case CPUID_AMD_3DNOW:
 			Cvar_Set( "sys_cpustring", "AMD w/ 3DNow!" );
 			break;
 		case CPUID_AXP:
 			Cvar_Set( "sys_cpustring", "Alpha AXP" );
 			break;
 		default:
 			Com_Error( ERR_FATAL, "Unknown cpu type %d\n", cpuid );
 			break;
 		}
 	}
 	else
 	{
 		Com_Printf( "...forcing CPU type to " );
 		if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "generic" ) )
 		{
 			cpuid = CPUID_GENERIC;
 		}
 		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "x87" ) )
 		{
 			cpuid = CPUID_INTEL_PENTIUM;
 		}
 		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "mmx" ) )
 		{
 			cpuid = CPUID_INTEL_MMX;
 		}
 		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "3dnow" ) )
 		{
 			cpuid = CPUID_AMD_3DNOW;
 		}
 		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIII" ) )
 		{
 			cpuid = CPUID_INTEL_KATMAI;
 		}
 		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "axp" ) )
 		{
 			cpuid = CPUID_AXP;
 		}
 		else
 		{
 			Com_Printf( "WARNING: unknown sys_cpustring '%s'\n", Cvar_VariableString( "sys_cpustring" ) );
 			cpuid = CPUID_GENERIC;
 		}
 	}
 	Cvar_SetValue( "sys_cpuid", cpuid );
 	Com_Printf( "%s\n", Cvar_VariableString( "sys_cpustring" ) );
 
 	Cvar_Set( "username", Sys_GetCurrentUser() );
 
 	IN_Init();		// FIXME: not in dedicated?
 }
 
 
 //=======================================================================
 
 int	totalMsec, countMsec;
 
 /*
 ==================
 WinMain
 
 ==================
 */
 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
 	char		cwd[MAX_OSPATH];
 	int			startTime, endTime;
 
     // should never get a previous instance in Win32
     if ( hPrevInstance ) {
         return 0;
 	}
 
 	g_wv.hInstance = hInstance;
 	Q_strncpyz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
 
 	// done before Com/Sys_Init since we need this for error output
 	Sys_CreateConsole();
 
 	// no abort/retry/fail errors
 	SetErrorMode( SEM_FAILCRITICALERRORS );
 
 	// get the initial time base
 	Sys_Milliseconds();
 #if 0
 	// if we find the CD, add a +set cddir xxx command line
 	Sys_ScanForCD();
 #endif
 
 	Sys_InitStreamThread();
 
 	Com_Init( sys_cmdline );
 	NET_Init();
 
 	_getcwd (cwd, sizeof(cwd));
 	Com_Printf("Working directory: %s\n", cwd);
 
 	// hide the early console since we've reached the point where we
 	// have a working graphics subsystems
 	if ( !com_dedicated->integer && !com_viewlog->integer ) {
 		Sys_ShowConsole( 0, qfalse );
 	}
 
     // main game loop
 	while( 1 ) {
 		// if not running as a game client, sleep a bit
 		if ( g_wv.isMinimized || ( com_dedicated && com_dedicated->integer ) ) {
 			Sleep( 5 );
 		}
 
 		// set low precision every frame, because some system calls
 		// reset it arbitrarily
 //		_controlfp( _PC_24, _MCW_PC );
 //    _controlfp( -1, _MCW_EM  ); // no exceptions, even if some crappy
                                 // syscall turns them back on!
 
 		startTime = Sys_Milliseconds();
 
 		// make sure mouse and joystick are only called once a frame
 		IN_Frame();
 
 		// run the game
 		Com_Frame();
 
 		endTime = Sys_Milliseconds();
 		totalMsec += endTime - startTime;
 		countMsec++;
 	}
 
 	// never gets here
 }