doom3-gpl
Doom 3 GPL source release
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
win_shared.cpp
Go to the documentation of this file.
1 /*
2 ===========================================================================
3 
4 Doom 3 GPL Source Code
5 Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
6 
7 This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
8 
9 Doom 3 Source Code is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13 
14 Doom 3 Source Code is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18 
19 You should have received a copy of the GNU General Public License
20 along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
21 
22 In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
23 
24 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
25 
26 ===========================================================================
27 */
28 
29 #include "../../idlib/precompiled.h"
30 #pragma hdrstop
31 
32 #include "win_local.h"
33 #include <lmerr.h>
34 #include <lmcons.h>
35 #include <lmwksta.h>
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <direct.h>
39 #include <io.h>
40 #include <conio.h>
41 
42 #ifndef ID_DEDICATED
43 #include <comdef.h>
44 #include <comutil.h>
45 #include <Wbemidl.h>
46 
47 #pragma comment (lib, "wbemuuid.lib")
48 #endif
49 
50 /*
51 ================
52 Sys_Milliseconds
53 ================
54 */
55 int Sys_Milliseconds( void ) {
56  int sys_curtime;
57  static int sys_timeBase;
58  static bool initialized = false;
59 
60  if ( !initialized ) {
61  sys_timeBase = timeGetTime();
62  initialized = true;
63  }
64  sys_curtime = timeGetTime() - sys_timeBase;
65 
66  return sys_curtime;
67 }
68 
69 /*
70 ================
71 Sys_GetSystemRam
72 
73  returns amount of physical memory in MB
74 ================
75 */
76 int Sys_GetSystemRam( void ) {
77  MEMORYSTATUSEX statex;
78  statex.dwLength = sizeof ( statex );
79  GlobalMemoryStatusEx (&statex);
80  int physRam = statex.ullTotalPhys / ( 1024 * 1024 );
81  // HACK: For some reason, ullTotalPhys is sometimes off by a meg or two, so we round up to the nearest 16 megs
82  physRam = ( physRam + 8 ) & ~15;
83  return physRam;
84 }
85 
86 
87 /*
88 ================
89 Sys_GetDriveFreeSpace
90 returns in megabytes
91 ================
92 */
93 int Sys_GetDriveFreeSpace( const char *path ) {
94  DWORDLONG lpFreeBytesAvailable;
95  DWORDLONG lpTotalNumberOfBytes;
96  DWORDLONG lpTotalNumberOfFreeBytes;
97  int ret = 26;
98  //FIXME: see why this is failing on some machines
99  if ( ::GetDiskFreeSpaceEx( path, (PULARGE_INTEGER)&lpFreeBytesAvailable, (PULARGE_INTEGER)&lpTotalNumberOfBytes, (PULARGE_INTEGER)&lpTotalNumberOfFreeBytes ) ) {
100  ret = ( double )( lpFreeBytesAvailable ) / ( 1024.0 * 1024.0 );
101  }
102  return ret;
103 }
104 
105 
106 /*
107 ================
108 Sys_GetVideoRam
109 returns in megabytes
110 ================
111 */
112 int Sys_GetVideoRam( void ) {
113 #ifdef ID_DEDICATED
114  return 0;
115 #else
116  unsigned int retSize = 64;
117 
118  CComPtr<IWbemLocator> spLoc = NULL;
119  HRESULT hr = CoCreateInstance( CLSID_WbemLocator, 0, CLSCTX_SERVER, IID_IWbemLocator, ( LPVOID * ) &spLoc );
120  if ( hr != S_OK || spLoc == NULL ) {
121  return retSize;
122  }
123 
124  CComBSTR bstrNamespace( _T( "\\\\.\\root\\CIMV2" ) );
125  CComPtr<IWbemServices> spServices;
126 
127  // Connect to CIM
128  hr = spLoc->ConnectServer( bstrNamespace, NULL, NULL, 0, NULL, 0, 0, &spServices );
129  if ( hr != WBEM_S_NO_ERROR ) {
130  return retSize;
131  }
132 
133  // Switch the security level to IMPERSONATE so that provider will grant access to system-level objects.
134  hr = CoSetProxyBlanket( spServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );
135  if ( hr != S_OK ) {
136  return retSize;
137  }
138 
139  // Get the vid controller
140  CComPtr<IEnumWbemClassObject> spEnumInst = NULL;
141  hr = spServices->CreateInstanceEnum( CComBSTR( "Win32_VideoController" ), WBEM_FLAG_SHALLOW, NULL, &spEnumInst );
142  if ( hr != WBEM_S_NO_ERROR || spEnumInst == NULL ) {
143  return retSize;
144  }
145 
146  ULONG uNumOfInstances = 0;
147  CComPtr<IWbemClassObject> spInstance = NULL;
148  hr = spEnumInst->Next( 10000, 1, &spInstance, &uNumOfInstances );
149 
150  if ( hr == S_OK && spInstance ) {
151  // Get properties from the object
152  CComVariant varSize;
153  hr = spInstance->Get( CComBSTR( _T( "AdapterRAM" ) ), 0, &varSize, 0, 0 );
154  if ( hr == S_OK ) {
155  retSize = varSize.intVal / ( 1024 * 1024 );
156  if ( retSize == 0 ) {
157  retSize = 64;
158  }
159  }
160  }
161  return retSize;
162 #endif
163 }
164 
165 /*
166 ================
167 Sys_GetCurrentMemoryStatus
168 
169  returns OS mem info
170  all values are in kB except the memoryload
171 ================
172 */
174  MEMORYSTATUSEX statex;
175  unsigned __int64 work;
176 
177  memset( &statex, sizeof( statex ), 0 );
178  statex.dwLength = sizeof( statex );
179  GlobalMemoryStatusEx( &statex );
180 
181  memset( &stats, 0, sizeof( stats ) );
182 
183  stats.memoryLoad = statex.dwMemoryLoad;
184 
185  work = statex.ullTotalPhys >> 20;
186  stats.totalPhysical = *(int*)&work;
187 
188  work = statex.ullAvailPhys >> 20;
189  stats.availPhysical = *(int*)&work;
190 
191  work = statex.ullAvailPageFile >> 20;
192  stats.availPageFile = *(int*)&work;
193 
194  work = statex.ullTotalPageFile >> 20;
195  stats.totalPageFile = *(int*)&work;
196 
197  work = statex.ullTotalVirtual >> 20;
198  stats.totalVirtual = *(int*)&work;
199 
200  work = statex.ullAvailVirtual >> 20;
201  stats.availVirtual = *(int*)&work;
202 
203  work = statex.ullAvailExtendedVirtual >> 20;
204  stats.availExtendedVirtual = *(int*)&work;
205 }
206 
207 /*
208 ================
209 Sys_LockMemory
210 ================
211 */
212 bool Sys_LockMemory( void *ptr, int bytes ) {
213  return ( VirtualLock( ptr, (SIZE_T)bytes ) != FALSE );
214 }
215 
216 /*
217 ================
218 Sys_UnlockMemory
219 ================
220 */
221 bool Sys_UnlockMemory( void *ptr, int bytes ) {
222  return ( VirtualUnlock( ptr, (SIZE_T)bytes ) != FALSE );
223 }
224 
225 /*
226 ================
227 Sys_SetPhysicalWorkMemory
228 ================
229 */
230 void Sys_SetPhysicalWorkMemory( int minBytes, int maxBytes ) {
231  ::SetProcessWorkingSetSize( GetCurrentProcess(), minBytes, maxBytes );
232 }
233 
234 /*
235 ================
236 Sys_GetCurrentUser
237 ================
238 */
239 char *Sys_GetCurrentUser( void ) {
240  static char s_userName[1024];
241  unsigned long size = sizeof( s_userName );
242 
243 
244  if ( !GetUserName( s_userName, &size ) ) {
245  strcpy( s_userName, "player" );
246  }
247 
248  if ( !s_userName[0] ) {
249  strcpy( s_userName, "player" );
250  }
251 
252  return s_userName;
253 }
254 
255 
256 /*
257 ===============================================================================
258 
259  Call stack
260 
261 ===============================================================================
262 */
263 
264 
265 #define PROLOGUE_SIGNATURE 0x00EC8B55
266 
267 #include <dbghelp.h>
268 
269 const int UNDECORATE_FLAGS = UNDNAME_NO_MS_KEYWORDS |
270  UNDNAME_NO_ACCESS_SPECIFIERS |
271  UNDNAME_NO_FUNCTION_RETURNS |
272  UNDNAME_NO_ALLOCATION_MODEL |
273  UNDNAME_NO_ALLOCATION_LANGUAGE |
274  UNDNAME_NO_MEMBER_TYPE;
275 
276 #if defined(_DEBUG) && 1
277 
278 typedef struct symbol_s {
279  int address;
280  char * name;
281  struct symbol_s * next;
282 } symbol_t;
283 
284 typedef struct module_s {
285  int address;
286  char * name;
287  symbol_t * symbols;
288  struct module_s * next;
289 } module_t;
290 
291 module_t *modules;
292 
293 /*
294 ==================
295 SkipRestOfLine
296 ==================
297 */
298 void SkipRestOfLine( const char **ptr ) {
299  while( (**ptr) != '\0' && (**ptr) != '\n' && (**ptr) != '\r' ) {
300  (*ptr)++;
301  }
302  while( (**ptr) == '\n' || (**ptr) == '\r' ) {
303  (*ptr)++;
304  }
305 }
306 
307 /*
308 ==================
309 SkipWhiteSpace
310 ==================
311 */
312 void SkipWhiteSpace( const char **ptr ) {
313  while( (**ptr) == ' ' ) {
314  (*ptr)++;
315  }
316 }
317 
318 /*
319 ==================
320 ParseHexNumber
321 ==================
322 */
323 int ParseHexNumber( const char **ptr ) {
324  int n = 0;
325  while( (**ptr) >= '0' && (**ptr) <= '9' || (**ptr) >= 'a' && (**ptr) <= 'f' ) {
326  n <<= 4;
327  if ( **ptr >= '0' && **ptr <= '9' ) {
328  n |= ( (**ptr) - '0' );
329  } else {
330  n |= 10 + ( (**ptr) - 'a' );
331  }
332  (*ptr)++;
333  }
334  return n;
335 }
336 
337 /*
338 ==================
339 Sym_Init
340 ==================
341 */
342 void Sym_Init( long addr ) {
343  TCHAR moduleName[MAX_STRING_CHARS];
344  MEMORY_BASIC_INFORMATION mbi;
345 
346  VirtualQuery( (void*)addr, &mbi, sizeof(mbi) );
347 
348  GetModuleFileName( (HMODULE)mbi.AllocationBase, moduleName, sizeof( moduleName ) );
349 
350  char *ext = moduleName + strlen( moduleName );
351  while( ext > moduleName && *ext != '.' ) {
352  ext--;
353  }
354  if ( ext == moduleName ) {
355  strcat( moduleName, ".map" );
356  } else {
357  strcpy( ext, ".map" );
358  }
359 
360  module_t *module = (module_t *) malloc( sizeof( module_t ) );
361  module->name = (char *) malloc( strlen( moduleName ) + 1 );
362  strcpy( module->name, moduleName );
363  module->address = (int)mbi.AllocationBase;
364  module->symbols = NULL;
365  module->next = modules;
366  modules = module;
367 
368  FILE *fp = fopen( moduleName, "rb" );
369  if ( fp == NULL ) {
370  return;
371  }
372 
373  int pos = ftell( fp );
374  fseek( fp, 0, SEEK_END );
375  int length = ftell( fp );
376  fseek( fp, pos, SEEK_SET );
377 
378  char *text = (char *) malloc( length+1 );
379  fread( text, 1, length, fp );
380  text[length] = '\0';
381  fclose( fp );
382 
383  const char *ptr = text;
384 
385  // skip up to " Address" on a new line
386  while( *ptr != '\0' ) {
387  SkipWhiteSpace( &ptr );
388  if ( idStr::Cmpn( ptr, "Address", 7 ) == 0 ) {
389  SkipRestOfLine( &ptr );
390  break;
391  }
392  SkipRestOfLine( &ptr );
393  }
394 
395  int symbolAddress;
396  int symbolLength;
397  char symbolName[MAX_STRING_CHARS];
398  symbol_t *symbol;
399 
400  // parse symbols
401  while( *ptr != '\0' ) {
402 
403  SkipWhiteSpace( &ptr );
404 
405  ParseHexNumber( &ptr );
406  if ( *ptr == ':' ) {
407  ptr++;
408  } else {
409  break;
410  }
411  ParseHexNumber( &ptr );
412 
413  SkipWhiteSpace( &ptr );
414 
415  // parse symbol name
416  symbolLength = 0;
417  while( *ptr != '\0' && *ptr != ' ' ) {
418  symbolName[symbolLength++] = *ptr++;
419  if ( symbolLength >= sizeof( symbolName ) - 1 ) {
420  break;
421  }
422  }
423  symbolName[symbolLength++] = '\0';
424 
425  SkipWhiteSpace( &ptr );
426 
427  // parse symbol address
428  symbolAddress = ParseHexNumber( &ptr );
429 
430  SkipRestOfLine( &ptr );
431 
432  symbol = (symbol_t *) malloc( sizeof( symbol_t ) );
433  symbol->name = (char *) malloc( symbolLength );
434  strcpy( symbol->name, symbolName );
435  symbol->address = symbolAddress;
436  symbol->next = module->symbols;
437  module->symbols = symbol;
438  }
439 
440  free( text );
441 }
442 
443 /*
444 ==================
445 Sym_Shutdown
446 ==================
447 */
448 void Sym_Shutdown( void ) {
449  module_t *m;
450  symbol_t *s;
451 
452  for ( m = modules; m != NULL; m = modules ) {
453  modules = m->next;
454  for ( s = m->symbols; s != NULL; s = m->symbols ) {
455  m->symbols = s->next;
456  free( s->name );
457  free( s );
458  }
459  free( m->name );
460  free( m );
461  }
462  modules = NULL;
463 }
464 
465 /*
466 ==================
467 Sym_GetFuncInfo
468 ==================
469 */
470 void Sym_GetFuncInfo( long addr, idStr &module, idStr &funcName ) {
471  MEMORY_BASIC_INFORMATION mbi;
472  module_t *m;
473  symbol_t *s;
474 
475  VirtualQuery( (void*)addr, &mbi, sizeof(mbi) );
476 
477  for ( m = modules; m != NULL; m = m->next ) {
478  if ( m->address == (int) mbi.AllocationBase ) {
479  break;
480  }
481  }
482  if ( !m ) {
483  Sym_Init( addr );
484  m = modules;
485  }
486 
487  for ( s = m->symbols; s != NULL; s = s->next ) {
488  if ( s->address == addr ) {
489 
490  char undName[MAX_STRING_CHARS];
491  if ( UnDecorateSymbolName( s->name, undName, sizeof(undName), UNDECORATE_FLAGS ) ) {
492  funcName = undName;
493  } else {
494  funcName = s->name;
495  }
496  for ( int i = 0; i < funcName.Length(); i++ ) {
497  if ( funcName[i] == '(' ) {
498  funcName.CapLength( i );
499  break;
500  }
501  }
502  module = m->name;
503  return;
504  }
505  }
506 
507  sprintf( funcName, "0x%08x", addr );
508  module = "";
509 }
510 
511 #elif defined(_DEBUG)
512 
513 DWORD lastAllocationBase = -1;
514 HANDLE processHandle;
515 idStr lastModule;
516 
517 /*
518 ==================
519 Sym_Init
520 ==================
521 */
522 void Sym_Init( long addr ) {
523  TCHAR moduleName[MAX_STRING_CHARS];
524  TCHAR modShortNameBuf[MAX_STRING_CHARS];
525  MEMORY_BASIC_INFORMATION mbi;
526 
527  if ( lastAllocationBase != -1 ) {
528  Sym_Shutdown();
529  }
530 
531  VirtualQuery( (void*)addr, &mbi, sizeof(mbi) );
532 
533  GetModuleFileName( (HMODULE)mbi.AllocationBase, moduleName, sizeof( moduleName ) );
534  _splitpath( moduleName, NULL, NULL, modShortNameBuf, NULL );
535  lastModule = modShortNameBuf;
536 
537  processHandle = GetCurrentProcess();
538  if ( !SymInitialize( processHandle, NULL, FALSE ) ) {
539  return;
540  }
541  if ( !SymLoadModule( processHandle, NULL, moduleName, NULL, (DWORD)mbi.AllocationBase, 0 ) ) {
542  SymCleanup( processHandle );
543  return;
544  }
545 
546  SymSetOptions( SymGetOptions() & ~SYMOPT_UNDNAME );
547 
548  lastAllocationBase = (DWORD) mbi.AllocationBase;
549 }
550 
551 /*
552 ==================
553 Sym_Shutdown
554 ==================
555 */
556 void Sym_Shutdown( void ) {
557  SymUnloadModule( GetCurrentProcess(), lastAllocationBase );
558  SymCleanup( GetCurrentProcess() );
559  lastAllocationBase = -1;
560 }
561 
562 /*
563 ==================
564 Sym_GetFuncInfo
565 ==================
566 */
567 void Sym_GetFuncInfo( long addr, idStr &module, idStr &funcName ) {
568  MEMORY_BASIC_INFORMATION mbi;
569 
570  VirtualQuery( (void*)addr, &mbi, sizeof(mbi) );
571 
572  if ( (DWORD) mbi.AllocationBase != lastAllocationBase ) {
573  Sym_Init( addr );
574  }
575 
576  BYTE symbolBuffer[ sizeof(IMAGEHLP_SYMBOL) + MAX_STRING_CHARS ];
577  PIMAGEHLP_SYMBOL pSymbol = (PIMAGEHLP_SYMBOL)&symbolBuffer[0];
578  pSymbol->SizeOfStruct = sizeof(symbolBuffer);
579  pSymbol->MaxNameLength = 1023;
580  pSymbol->Address = 0;
581  pSymbol->Flags = 0;
582  pSymbol->Size =0;
583 
584  DWORD symDisplacement = 0;
585  if ( SymGetSymFromAddr( processHandle, addr, &symDisplacement, pSymbol ) ) {
586  // clean up name, throwing away decorations that don't affect uniqueness
587  char undName[MAX_STRING_CHARS];
588  if ( UnDecorateSymbolName( pSymbol->Name, undName, sizeof(undName), UNDECORATE_FLAGS ) ) {
589  funcName = undName;
590  } else {
591  funcName = pSymbol->Name;
592  }
593  module = lastModule;
594  }
595  else {
596  LPVOID lpMsgBuf;
597  FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
598  NULL,
599  GetLastError(),
600  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
601  (LPTSTR) &lpMsgBuf,
602  0,
603  NULL
604  );
605  LocalFree( lpMsgBuf );
606 
607  // Couldn't retrieve symbol (no debug info?, can't load dbghelp.dll?)
608  sprintf( funcName, "0x%08x", addr );
609  module = "";
610  }
611 }
612 
613 #else
614 
615 /*
616 ==================
617 Sym_Init
618 ==================
619 */
620 void Sym_Init( long addr ) {
621 }
622 
623 /*
624 ==================
625 Sym_Shutdown
626 ==================
627 */
628 void Sym_Shutdown( void ) {
629 }
630 
631 /*
632 ==================
633 Sym_GetFuncInfo
634 ==================
635 */
636 void Sym_GetFuncInfo( long addr, idStr &module, idStr &funcName ) {
637  module = "";
638  sprintf( funcName, "0x%08x", addr );
639 }
640 
641 #endif
642 
643 /*
644 ==================
645 GetFuncAddr
646 ==================
647 */
649  long temp;
650  do {
651  temp = (long)(*(long*)midPtPtr);
652  if ( (temp&0x00FFFFFF) == PROLOGUE_SIGNATURE ) {
653  break;
654  }
655  midPtPtr--;
656  } while(true);
657 
658  return midPtPtr;
659 }
660 
661 /*
662 ==================
663 GetCallerAddr
664 ==================
665 */
666 address_t GetCallerAddr( long _ebp ) {
667  long midPtPtr;
668  long res = 0;
669 
670  __asm {
671  mov eax, _ebp
672  mov ecx, [eax] // check for end of stack frames list
673  test ecx, ecx // check for zero stack frame
674  jz label
675  mov eax, [eax+4] // get the ret address
676  test eax, eax // check for zero return address
677  jz label
678  mov midPtPtr, eax
679  }
680  res = GetFuncAddr( midPtPtr );
681 label:
682  return res;
683 }
684 
685 /*
686 ==================
687 Sys_GetCallStack
688 
689  use /Oy option
690 ==================
691 */
692 void Sys_GetCallStack( address_t *callStack, const int callStackSize ) {
693 #if 1 //def _DEBUG
694  int i;
695  long m_ebp;
696 
697  __asm {
698  mov eax, ebp
699  mov m_ebp, eax
700  }
701  // skip last two functions
702  m_ebp = *((long*)m_ebp);
703  m_ebp = *((long*)m_ebp);
704  // list functions
705  for ( i = 0; i < callStackSize; i++ ) {
706  callStack[i] = GetCallerAddr( m_ebp );
707  if ( callStack[i] == 0 ) {
708  break;
709  }
710  m_ebp = *((long*)m_ebp);
711  }
712 #else
713  int i = 0;
714 #endif
715  while( i < callStackSize ) {
716  callStack[i++] = 0;
717  }
718 }
719 
720 /*
721 ==================
722 Sys_GetCallStackStr
723 ==================
724 */
725 const char *Sys_GetCallStackStr( const address_t *callStack, const int callStackSize ) {
726  static char string[MAX_STRING_CHARS*2];
727  int index, i;
728  idStr module, funcName;
729 
730  index = 0;
731  for ( i = callStackSize-1; i >= 0; i-- ) {
732  Sym_GetFuncInfo( callStack[i], module, funcName );
733  index += sprintf( string+index, " -> %s", funcName.c_str() );
734  }
735  return string;
736 }
737 
738 /*
739 ==================
740 Sys_GetCallStackCurStr
741 ==================
742 */
743 const char *Sys_GetCallStackCurStr( int depth ) {
744  address_t *callStack;
745 
746  callStack = (address_t *) _alloca( depth * sizeof( address_t ) );
747  Sys_GetCallStack( callStack, depth );
748  return Sys_GetCallStackStr( callStack, depth );
749 }
750 
751 /*
752 ==================
753 Sys_GetCallStackCurAddressStr
754 ==================
755 */
757  static char string[MAX_STRING_CHARS*2];
758  address_t *callStack;
759  int index, i;
760 
761  callStack = (address_t *) _alloca( depth * sizeof( address_t ) );
762  Sys_GetCallStack( callStack, depth );
763 
764  index = 0;
765  for ( i = depth-1; i >= 0; i-- ) {
766  index += sprintf( string+index, " -> 0x%08x", callStack[i] );
767  }
768  return string;
769 }
770 
771 /*
772 ==================
773 Sys_ShutdownSymbols
774 ==================
775 */
776 void Sys_ShutdownSymbols( void ) {
777  Sym_Shutdown();
778 }
void Sym_Init(long addr)
Definition: win_shared.cpp:620
char * Sys_GetCurrentUser(void)
Definition: win_shared.cpp:239
void Sys_SetPhysicalWorkMemory(int minBytes, int maxBytes)
Definition: win_shared.cpp:230
unsigned long sys_timeBase
void Sym_GetFuncInfo(long addr, idStr &module, idStr &funcName)
Definition: win_shared.cpp:636
int Length(void) const
Definition: Str.h:702
void Sys_GetCurrentMemoryStatus(sysMemoryStats_t &stats)
Definition: win_shared.cpp:173
int Sys_GetDriveFreeSpace(const char *path)
Definition: win_shared.cpp:93
address_t GetCallerAddr(long _ebp)
Definition: win_shared.cpp:666
DWORD
Definition: win_qgl.cpp:61
GLenum GLsizei n
Definition: glext.h:3705
case const int
Definition: Callbacks.cpp:52
typedef HANDLE(WINAPI *PFNWGLCREATEBUFFERREGIONARBPROC)(HDC hDC
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glext.h:2878
GLenum GLsizei const GLvoid * string
Definition: glext.h:3472
GLdouble s
Definition: glext.h:2935
void Sym_Shutdown(void)
Definition: win_shared.cpp:628
const int UNDECORATE_FLAGS
Definition: win_shared.cpp:269
bool Sys_LockMemory(void *ptr, int bytes)
Definition: win_shared.cpp:212
int i
Definition: process.py:33
int Cmpn(const char *text, int n) const
Definition: Str.h:657
int test(char *url)
Definition: lib500.c:3
void Sys_GetCallStack(address_t *callStack, const int callStackSize)
Definition: win_shared.cpp:692
#define SEEK_END
Definition: Unzip.cpp:131
GLuint index
Definition: glext.h:3476
#define MAX_STRING_CHARS
Definition: Lib.h:95
int availExtendedVirtual
Definition: sys_public.h:231
const char * Sys_GetCallStackCurStr(int depth)
Definition: win_shared.cpp:743
#define NULL
Definition: Lib.h:88
bool initialized
Definition: maya_main.cpp:38
void CapLength(int)
Definition: Str.h:859
const char * path
Definition: sws.c:117
#define PROLOGUE_SIGNATURE
Definition: win_shared.cpp:265
const char * Sys_GetCallStackStr(const address_t *callStack, const int callStackSize)
Definition: win_shared.cpp:725
int Sys_Milliseconds(void)
Definition: win_shared.cpp:55
GLenum const GLvoid * addr
Definition: glext.h:5393
int Sys_GetVideoRam(void)
Definition: win_shared.cpp:112
size_t fread(void *, size_t, size_t, FILE *)
#define SEEK_SET
Definition: Unzip.cpp:129
void Sys_ShutdownSymbols(void)
Definition: win_shared.cpp:776
const GLcharARB * name
Definition: glext.h:3629
GLsizeiptr size
Definition: glext.h:3112
Definition: Str.h:116
GLsizei const GLcharARB const GLint * length
Definition: glext.h:3599
GLuint address
Definition: glext.h:5165
typedef LPVOID(WINAPI *PFNWGLCREATEIMAGEBUFFERI3DPROC)(HDC hDC
const char * c_str(void) const
Definition: Str.h:487
#define FALSE
Definition: mprintf.c:70
GLuint res
Definition: glext.h:5385
const char * Sys_GetCallStackCurAddressStr(int depth)
Definition: win_shared.cpp:756
unsigned long address_t
Definition: sys_public.h:234
int Sys_GetSystemRam(void)
Definition: win_shared.cpp:76
address_t GetFuncAddr(address_t midPtPtr)
Definition: win_shared.cpp:648
int sprintf(idStr &string, const char *fmt,...)
Definition: Str.cpp:1528
bool Sys_UnlockMemory(void *ptr, int bytes)
Definition: win_shared.cpp:221
LPDIRECTSOUND IUnknown FAR *typedef HRESULT(FAR PASCAL *LPEAXDIRECTSOUNDCREATE)(GUID *