#include "../qcommon/qcommon.h"
#include "winquake.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <direct.h>
#include <io.h>
#include <conio.h>

Macros
#define	VIRTUAL_ALLOC

Functions
void *	Hunk_Begin (int maxsize)

void *	Hunk_Alloc (int size)

int	Hunk_End (void)

void	Hunk_Free (void *base)

int	Sys_Milliseconds (void)

void	Sys_Mkdir (char *path)

static qboolean	CompareAttributes (unsigned found, unsigned musthave, unsigned canthave)

char *	Sys_FindFirst (char *path, unsigned musthave, unsigned canthave)

char *	Sys_FindNext (unsigned musthave, unsigned canthave)

void	Sys_FindClose (void)

Variables
int	hunkcount

byte *	membase

int	hunkmaxsize

int	cursize

int	curtime

char	findbase [MAX_OSPATH]

char	findpath [MAX_OSPATH]

int	findhandle

Macro Definition Documentation

◆ VIRTUAL_ALLOC

#define VIRTUAL_ALLOC

Definition at line 39 of file q_shwin.c.

Function Documentation

◆ CompareAttributes()

static qboolean CompareAttributes	(	unsigned	found,
		unsigned	musthave,
		unsigned	canthave
	)

static

Definition at line 146 of file q_shwin.c.

 {
     if ( ( found & _A_RDONLY ) && ( canthave & SFF_RDONLY ) )
         return false;
     if ( ( found & _A_HIDDEN ) && ( canthave & SFF_HIDDEN ) )
         return false;
     if ( ( found & _A_SYSTEM ) && ( canthave & SFF_SYSTEM ) )
         return false;
     if ( ( found & _A_SUBDIR ) && ( canthave & SFF_SUBDIR ) )
         return false;
     if ( ( found & _A_ARCH ) && ( canthave & SFF_ARCH ) )
         return false;
  
     if ( ( musthave & SFF_RDONLY ) && !( found & _A_RDONLY ) )
         return false;
     if ( ( musthave & SFF_HIDDEN ) && !( found & _A_HIDDEN ) )
         return false;
     if ( ( musthave & SFF_SYSTEM ) && !( found & _A_SYSTEM ) )
         return false;
     if ( ( musthave & SFF_SUBDIR ) && !( found & _A_SUBDIR ) )
         return false;
     if ( ( musthave & SFF_ARCH ) && !( found & _A_ARCH ) )
         return false;
  
     return true;
 }

Referenced by Sys_FindFirst(), and Sys_FindNext().

◆ Hunk_Alloc()

void* Hunk_Alloc ( int size )

Definition at line 57 of file q_shwin.c.

 {
     void    *buf;
  
     // round to cacheline
     size = (size+31)&~31;
  
 #ifdef VIRTUAL_ALLOC
     // commit pages as needed
 //  buf = VirtualAlloc (membase+cursize, size, MEM_COMMIT, PAGE_READWRITE);
     buf = VirtualAlloc (membase, cursize+size, MEM_COMMIT, PAGE_READWRITE);
     if (!buf)
     {
         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &buf, 0, NULL);
         Sys_Error ("VirtualAlloc commit failed.\n%s", buf);
     }
 #endif
     cursize += size;
     if (cursize > hunkmaxsize)
         Sys_Error ("Hunk_Alloc overflow");
  
     return (void *)(membase+cursize-size);
 }

Referenced by GL_BuildPolygonFromSurface(), Mod_LoadAliasModel(), Mod_LoadEdges(), Mod_LoadFaces(), Mod_LoadLeafs(), Mod_LoadLighting(), Mod_LoadMarksurfaces(), Mod_LoadNodes(), Mod_LoadPlanes(), Mod_LoadSpriteModel(), Mod_LoadSubmodels(), Mod_LoadSurfedges(), Mod_LoadTexinfo(), Mod_LoadVertexes(), Mod_LoadVisibility(), and SubdividePolygon().

◆ Hunk_Begin()

void* Hunk_Begin ( int maxsize )

Definition at line 41 of file q_shwin.c.

 {
     // reserve a huge chunk of memory, but don't commit any yet
     cursize = 0;
     hunkmaxsize = maxsize;
 #ifdef VIRTUAL_ALLOC
     membase = VirtualAlloc (NULL, maxsize, MEM_RESERVE, PAGE_NOACCESS);
 #else
     membase = malloc (maxsize);
     memset (membase, 0, maxsize);
 #endif
     if (!membase)
         Sys_Error ("VirtualAlloc reserve failed");
     return (void *)membase;
 }

Referenced by Mod_ForName().

◆ Hunk_End()

int Hunk_End ( void )

Definition at line 81 of file q_shwin.c.

 {
  
     // free the remaining unused virtual memory
 #if 0
     void    *buf;
  
     // write protect it
     buf = VirtualAlloc (membase, cursize, MEM_COMMIT, PAGE_READONLY);
     if (!buf)
         Sys_Error ("VirtualAlloc commit failed");
 #endif
  
     hunkcount++;
 //Com_Printf ("hunkcount: %i\n", hunkcount);
     return cursize;
 }

Referenced by Mod_ForName().

◆ Hunk_Free()

void Hunk_Free ( void * base )

Definition at line 99 of file q_shwin.c.

 {
     if ( base )
 #ifdef VIRTUAL_ALLOC
         VirtualFree (base, 0, MEM_RELEASE);
 #else
         free (base);
 #endif
  
     hunkcount--;
 }

Referenced by Mod_Free(), and R_EndRegistration().

◆ Sys_FindClose()

void Sys_FindClose ( void )

Definition at line 206 of file q_shwin.c.

 {
     if (findhandle != -1)
         _findclose (findhandle);
     findhandle = 0;
 }

Referenced by FS_ExecAutoexec(), FS_ListFiles(), PlayerConfig_ScanDirectories(), SV_CopySaveGame(), and SV_WipeSavegame().

◆ Sys_FindFirst()

char* Sys_FindFirst	(	char *	path,
		unsigned	musthave,
		unsigned	canthave
	)

Definition at line 173 of file q_shwin.c.

 {
     struct _finddata_t findinfo;
  
     if (findhandle)
         Sys_Error ("Sys_BeginFind without close");
     findhandle = 0;
  
     COM_FilePath (path, findbase);
     findhandle = _findfirst (path, &findinfo);
     if (findhandle == -1)
         return NULL;
     if ( !CompareAttributes( findinfo.attrib, musthave, canthave ) )
         return NULL;
     Com_sprintf (findpath, sizeof(findpath), "%s/%s", findbase, findinfo.name);
     return findpath;
 }

Referenced by FS_ExecAutoexec(), FS_ListFiles(), PlayerConfig_ScanDirectories(), SV_CopySaveGame(), and SV_WipeSavegame().

◆ Sys_FindNext()

char* Sys_FindNext	(	unsigned	musthave,
		unsigned	canthave
	)

Definition at line 191 of file q_shwin.c.

 {
     struct _finddata_t findinfo;
  
     if (findhandle == -1)
         return NULL;
     if (_findnext (findhandle, &findinfo) == -1)
         return NULL;
     if ( !CompareAttributes( findinfo.attrib, musthave, canthave ) )
         return NULL;
  
     Com_sprintf (findpath, sizeof(findpath), "%s/%s", findbase, findinfo.name);
     return findpath;
 }

Referenced by FS_ListFiles(), SV_CopySaveGame(), and SV_WipeSavegame().

◆ Sys_Milliseconds()

int Sys_Milliseconds ( void )

Definition at line 120 of file q_shwin.c.

 {
     static int      base;
     static qboolean initialized = false;
  
     if (!initialized)
     {   // let base retain 16 bits of effectively random data
         base = timeGetTime() & 0xffff0000;
         initialized = true;
     }
     curtime = timeGetTime() - base;
  
     return curtime;
 }