sys_shared.c File Reference

#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <time.h>
#include <dlfcn.h>
#include <signal.h>
#include "quakedef.h"
#include "taskqueue.h"
#include "thread.h"
#include "libcurl.h"

Include dependency graph for sys_shared.c:

Go to the source code of this file.

Macros
#define	SUPPORTDLL

Functions
void	Sys_AllowProfiling (qbool enable)
int	Sys_CheckParm (const char *parm)
char *	Sys_ConsoleInput (void)
	Reads a line from POSIX stdin or the Windows console.
double	Sys_DirtyTime (void)
void	Sys_Error (const char *error,...)
	Causes the entire program to exit ASAP.
static const char *	Sys_FindExecutableName (void)
static const char *	Sys_FindInPATH (const char *name, char namesep, const char *PATH, char pathsep, char *buf, size_t bufsize)
static void	Sys_Frame (void)
	JS+WebGL doesn't support a main loop, only a function called to run a frame.
void	Sys_FreeLibrary (dllhandle_t *handle)
void *	Sys_GetProcAddress (dllhandle_t handle, const char *name)
static void	Sys_HandleCrash (int sig)
	Halt and try not to catch fire.
static void	Sys_HandleSignal (int sig)
void	Sys_Init_Commands (void)
	called after command system is initialized but before first Con_Print
void	Sys_InitProcessNice (void)
	called to set process priority for dedicated servers
static void	Sys_InitSignals (void)
	SDL2 only handles SIGINT and SIGTERM by default and doesn't log anything.
qbool	Sys_LoadDependency (const char **dllnames, dllhandle_t *handle, const dllfunction_t *fcts)
static qbool	Sys_LoadDependencyFunctions (dllhandle_t dllhandle, const dllfunction_t *fcts, qbool complain, qbool has_next)
qbool	Sys_LoadLibrary (const char *name, dllhandle_t *handle)
qbool	Sys_LoadSelf (dllhandle_t *handle)
int	Sys_Main (int argc, char *argv[])
	main() but renamed so we can wrap it in sys_sdl.c and sys_null.c to avoid needing to include SDL.h in this file (would make the dedicated server require SDL).
void	Sys_MakeProcessMean (void)
void	Sys_MakeProcessNice (void)
void	Sys_Print (const char *text, size_t textlen)
	(may) output text to terminal which launched program is POSIX async-signal-safe textlen excludes any (optional) \0 terminator
void	Sys_Printf (const char *fmt,...)
	used to report failures inside Con_Printf()
void	Sys_ProvideSelfFD (void)
static const char *	Sys_SigDesc (int sig)
double	Sys_Sleep (double time)
	called to yield for a little bit so as not to hog cpu when paused or debugging
size_t	Sys_TimeString (char buf[], size_t bufsize, const char *timeformat)
static void	Sys_UpdateOutFD_c (cvar_t *var)
static double	Sys_UpdateTime (double newtime, double oldtime)

Variables
static double	benchmark_time
sys_t	sys
static cvar_t	sys_debugsleep = {CF_SHARED, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"}
cvar_t	sys_libdir = {CF_READONLY | CF_SHARED, "sys_libdir", "", "Default engine library directory"}
static cvar_t	sys_stdout = {CF_SHARED, "sys_stdout", "1", "0: nothing is written to stdout (-nostdout cmdline option sets this), 1: normal messages are written to stdout, 2: normal messages are written to stderr (-stderr cmdline option sets this)"}
static cvar_t	sys_stdout_blocks = {CF_SHARED, "sys_stdout_blocks", "0", "1: writes to stdout and stderr streams will block (causing a stutter or complete halt) if the buffer is full, ensuring no messages are lost at a price"}
cvar_t	sys_usenoclockbutbenchmark = {CF_SHARED, "sys_usenoclockbutbenchmark", "0", "don't use ANY real timing, and simulate a clock (for benchmarking); the game then runs as fast as possible. Run a QC mod with bots that does some stuff, then does a quit at the end, to benchmark a server. NEVER do this on a public server."}
static cvar_t	sys_usesdldelay = {CF_SHARED, "sys_usesdldelay", "0", "use SDL_Delay() (low precision, for debugging)"}
static cvar_t	sys_usesdlgetticks = {CF_SHARED, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (low precision, for debugging)"}

Macro Definition Documentation

SUPPORTDLL

#define SUPPORTDLL

Definition at line 7 of file sys_shared.c.

Function Documentation

Sys_AllowProfiling()

void Sys_AllowProfiling

(

qbool

enable

)

on some build/platform combinations (such as Linux gcc with the -pg profiling option) this can turn on/off profiling, used primarily to limit profiling to certain areas of the code, such as ingame performance without regard for loading/shutdown performance (-profilegameonly on commandline)

Definition at line 65 of file sys_shared.c.

{
#ifdef __ANDROID__
#ifdef USE_PROFILER
    extern void monstartup(const char *libname);
    extern void moncleanup(void);
    if (enable)
        monstartup("libmain.so");
    else
        moncleanup();
#endif
#elif (defined(__linux__) && (defined(__GLIBC__) || defined(__GNU_LIBRARY__))) || defined(__FreeBSD__)
    extern int moncontrol(int);
    moncontrol(enable);
#endif
}

Referenced by CL_DisconnectEx(), CL_SignonReply(), Host_Init(), Host_Shutdown(), Sys_Frame(), and Sys_Main().

Sys_CheckParm()

int Sys_CheckParm

(

const char *

parm

)

Definition at line 327 of file sys_shared.c.

{
    int i;
 
    for (i=1 ; i<sys.argc ; i++)
    {
        if (!sys.argv[i])
            continue;               // NEXTSTEP sometimes clears appkit vars.
        if (!strcmp (parm,sys.argv[i]))
            return i;
    }
 
    return 0;
}

References sys_t::argc, sys_t::argv, i, and sys.

Referenced by CDAudio_Init(), CDAudio_Startup(), CL_DisconnectEx(), CL_EstablishConnection(), CL_FinishTimeDemo(), CL_PlayVideo_f(), CL_Screen_Init(), CL_SignonReply(), CL_Startdemos_f(), CL_StopPlayback(), Cmd_Exec(), COM_InitGameType(), COM_SetGameType(), Con_Init(), Con_ToggleConsole_f(), FS_Init_Dir(), FS_Init_SelfPack(), FS_mkdir(), FS_Rescan(), FS_SysOpenFiledesc(), GL_CheckExtension(), Host_Init(), Host_InitSession(), Host_LockSession(), Host_SaveConfig(), Host_Shutdown(), Key_Event(), LibAV_LoadLibrary(), LibAvW_OpenLibrary(), MR_Init(), NetConn_Init(), OGG_OpenLibrary(), Palette_Load(), PRVM_Init(), S_Init(), S_Startup(), SV_ServerOptions(), Sys_Main(), Sys_SDL_Init(), VID_InitModeGL(), VID_Start(), XMP_LoadModFile(), and XMP_OpenLibrary().

Sys_ConsoleInput()

char * Sys_ConsoleInput

(

void

)

Reads a line from POSIX stdin or the Windows console.

Definition at line 667 of file sys_shared.c.

{
    static char text[MAX_INPUTLINE];
#ifdef WIN32
    static unsigned int len = 0;
    int c;
 
    // read a line out
    while (_kbhit ())
    {
        c = _getch ();
        if (c == '\r')
        {
            text[len] = '\0';
            _putch ('\n');
            len = 0;
            return text;
        }
        if (c == '\b')
        {
            if (len)
            {
                _putch (c);
                _putch (' ');
                _putch (c);
                len--;
            }
            continue;
        }
        if (len < sizeof (text) - 1)
        {
            _putch (c);
            text[len] = c;
            len++;
        }
    }
#else
    fd_set fdset;
    struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 };
 
    FD_ZERO(&fdset);
    FD_SET(fileno(stdin), &fdset);
    if (select(1, &fdset, NULL, NULL, &timeout) != -1 && FD_ISSET(fileno(stdin), &fdset))
        return fgets(text, sizeof(text), stdin);
#endif
    return NULL;
}

References fgets(), MAX_INPUTLINE, and NULL.

Referenced by Cbuf_Frame_Input().

Sys_DirtyTime()

double Sys_DirtyTime

(

void

)

Definition at line 417 of file sys_shared.c.

{
    // first all the OPTIONAL timers
 
    // benchmark timer (fake clock)
    if(sys_usenoclockbutbenchmark.integer)
    {
        double old_benchmark_time = benchmark_time;
        benchmark_time += 1;
        if(benchmark_time == old_benchmark_time)
            Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
        return benchmark_time * 0.000001;
    }
 
    if(sys_supportsdlgetticks && sys_usesdlgetticks.integer)
        return (double) Sys_SDL_GetTicks() / 1000.0;
 
#if HAVE_QUERYPERFORMANCECOUNTER
    if (sys_usequeryperformancecounter.integer)
    {
        // QueryPerformanceCounter
        // platform:
        // Windows 95/98/ME/NT/2000/XP
        // features:
        // + very accurate (constant-rate TSCs on modern systems)
        // known issues:
        // - does not necessarily match realtime too well (tends to get faster and faster in win98)
        // - wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
        // - higher access latency on Vista
        // Microsoft says on Win 7 or later, latency and overhead are very low, synchronisation is excellent.
        LARGE_INTEGER PerformanceCount;
 
        if (PerformanceFreq.QuadPart)
        {
            QueryPerformanceCounter (&PerformanceCount);
            return (double)PerformanceCount.QuadPart * (1.0 / (double)PerformanceFreq.QuadPart);
        }
        else
        {
            Con_Printf("No hardware timer available\n");
            // fall back to other clock sources
            Cvar_SetValueQuick(&sys_usequeryperformancecounter, false);
        }
    }
#endif
 
#if HAVE_CLOCKGETTIME
    {
        struct timespec ts;
#  ifdef CLOCK_MONOTONIC_RAW
        // Linux-specific, SDL_GetPerformanceCounter() uses it
        clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
#  elif defined(CLOCK_MONOTONIC)
        // POSIX
        clock_gettime(CLOCK_MONOTONIC, &ts);
#  else
        // sunos
        clock_gettime(CLOCK_HIGHRES, &ts);
#  endif
        return (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
    }
#endif
 
    // now all the FALLBACK timers
#if HAVE_TIMEGETTIME
    {
        // timeGetTime
        // platform:
        // Windows 95/98/ME/NT/2000/XP
        // features:
        // reasonable accuracy (millisecond)
        // issues:
        // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
        // requires Sys_SetTimerResolution()
        return (double) timeGetTime() / 1000.0;
    }
#else
    // fallback for using the SDL timer if no other timer is available
    // this calls Sys_Error() if not linking against SDL
    return (double) Sys_SDL_GetTicks() / 1000.0;
#endif
}

References benchmark_time, Con_Printf(), Cvar_SetValueQuick(), cvar_t::integer, Sys_Error(), Sys_SDL_GetTicks(), sys_supportsdlgetticks, sys_usenoclockbutbenchmark, and sys_usesdlgetticks.

Referenced by CL_Frame(), CL_KeepaliveMessage(), CL_TimeRefresh_f(), CL_UpdateScreen(), CLVM_ExecuteProgram(), Crypto_ServerParsePacket(), Host_Init(), PRVM_CallProfile(), PRVM_Prog_Load(), R_TimeReport(), R_TimeReport_BeginFrame(), R_TimeReport_EndFrame(), SV_Frame(), SV_ThreadFunc(), SVVM_ExecuteProgram(), Sys_Frame(), Sys_Sleep(), VM_CL_R_AddDynamicLight(), VM_CL_R_AddEntities(), VM_CL_R_AddEntity(), VM_CL_R_RenderScene(), VM_gettime(), and while().

Sys_Error()

void Sys_Error	(	const char *	error,
			... )

Causes the entire program to exit ASAP.

Trailing
should be omitted.

Definition at line 724 of file sys_shared.c.

{
    va_list argptr;
    char string[MAX_INPUTLINE];
    int i;
 
    // Disable Sys_HandleSignal() but not Sys_HandleCrash()
    host.state = host_shutdown;
 
    // set output to blocking stderr
    sys.outfd = fileno(stderr);
#ifndef WIN32
    fcntl(sys.outfd, F_SETFL, fcntl(sys.outfd, F_GETFL, 0) & ~O_NONBLOCK);
#endif
 
    va_start (argptr,error);
    dpvsnprintf (string, sizeof (string), error, argptr);
    va_end (argptr);
 
    Con_Printf(CON_ERROR "Engine Aborted: %s\n^9%s\n", string, engineversion);
 
    dp_strlcat(string, "\n\n", sizeof(string));
    dp_strlcat(string, engineversion, sizeof(string));
 
    // Most shutdown funcs can't be called here as they could error while we error.
 
    // DP8 TODO: send a disconnect message indicating we aborted, see Host_Error() and Sys_HandleCrash()
 
    if (cls.demorecording)
        CL_Stop_f(cmd_local);
    if (sv.active)
    {
        sv.active = false; // make SV_DropClient() skip the QC stuff to avoid recursive errors
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
            if (host_client->active)
                SV_DropClient(false, "Server aborted!"); // closes demo file
    }
    // don't want a dead window left blocking the OS UI or the abort dialog
    VID_Shutdown();
    S_StopAllSounds();
 
    host.state = host_failed; // make Sys_HandleSignal() call _Exit()
    Sys_SDL_Dialog("Engine Aborted", string);
 
    fflush(stderr);
    exit (1);
}

References client_t::active, server_t::active, CL_Stop_f(), server_static_t::clients, cls, cmd_local, CON_ERROR, Con_Printf(), client_static_t::demorecording, dp_strlcat, dpvsnprintf(), engineversion, error(), host, host_client, host_failed, host_shutdown, i, MAX_INPUTLINE, server_static_t::maxclients, O_NONBLOCK, sys_t::outfd, S_StopAllSounds(), host_static_t::state, sv, SV_DropClient(), svs, sys, Sys_SDL_Dialog(), and VID_Shutdown().

Referenced by _Mem_Alloc(), _Mem_AllocPool(), _Mem_CheckSentinels(), _Mem_CheckSentinelsGlobal(), _Mem_EmptyPool(), _Mem_Free(), _Mem_FreeBlock(), _Mem_FreePool(), Buffer_Callback(), CL_CutDemo(), CL_ExpandEntities(), Clump_AllocBlock(), Clump_FreeBlock(), COM_ChangeGameTypeForGameDirs(), FS_SetGameDirs(), GL_InitFunctions(), GL_Setup(), Host_Error(), Host_LockSession(), M_Menu_Keys_f(), Mem_ExpandableArray_FreeRecord(), MVM_error_cmd(), PHYS_NudgeOutOfSolid(), R_BufferData_Store(), R_Mesh_TexBind(), R_Mesh_TexBound(), R_Mesh_TexCoordPointer(), R_RegisterModule(), R_SetupTexture(), R_UploadFullTexture(), R_UploadPartialTexture(), RSurf_DrawBatch(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_Interleave(), SCR_CaptureVideo_RIFF_IndexEntry(), SCR_CaptureVideo_RIFF_MakeIxChunk(), SCR_CaptureVideo_RIFF_OverflowCheck(), setuptex(), SV_SendClientMessages(), Sys_DirtyTime(), Sys_SDL_Delay(), Sys_SDL_GetTicks(), Sys_SDL_Init(), Sys_Sleep(), VID_Init(), VID_InitMode(), VID_InitModeGL(), VID_Restart_f(), VID_Start(), and VM_nudgeoutofsolid().

Sys_FindExecutableName()

static const char * Sys_FindExecutableName ( void )

static

Definition at line 797 of file sys_shared.c.

{
#if defined(WIN32)
    return sys.argv[0];
#else
    static char exenamebuf[MAX_OSPATH+1];
    ssize_t n = -1;
#if defined(__FreeBSD__)
    int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
    size_t exenamebuflen = sizeof(exenamebuf)-1;
    if (sysctl(mib, 4, exenamebuf, &exenamebuflen, NULL, 0) == 0)
    {
        n = exenamebuflen;
    }
#elif defined(__linux__)
    n = readlink("/proc/self/exe", exenamebuf, sizeof(exenamebuf)-1);
#endif
    if(n > 0 && (size_t)(n) < sizeof(exenamebuf))
    {
        exenamebuf[n] = 0;
        return exenamebuf;
    }
    if(strchr(sys.argv[0], '/'))
        return sys.argv[0]; // possibly a relative path
    else
        return Sys_FindInPATH(sys.argv[0], '/', getenv("PATH"), ':', exenamebuf, sizeof(exenamebuf));
#endif
}

References sys_t::argv, MAX_OSPATH, n, NULL, sys, and Sys_FindInPATH().

Referenced by Sys_ProvideSelfFD().

Sys_FindInPATH()

static const char * Sys_FindInPATH ( const char * name, char namesep, const char * PATH, char pathsep, char * buf, size_t bufsize )

static

Definition at line 773 of file sys_shared.c.

{
    const char *p = PATH;
    const char *q;
    if(p && name)
    {
        while((q = strchr(p, ':')))
        {
            dpsnprintf(buf, bufsize, "%.*s%c%s", (int)(q-p), p, namesep, name);
            if(FS_SysFileExists(buf))
                return buf;
            p = q + 1;
        }
        if(!q) // none found - try the last item
        {
            dpsnprintf(buf, bufsize, "%s%c%s", p, namesep, name);
            if(FS_SysFileExists(buf))
                return buf;
        }
    }
    return name;
}

References buf, dpsnprintf(), FS_SysFileExists(), and name.

Referenced by Sys_FindExecutableName().

Sys_Frame()

static void Sys_Frame ( void )

static

JS+WebGL doesn't support a main loop, only a function called to run a frame.

Definition at line 1133 of file sys_shared.c.

{
    double time, newtime, sleeptime;
#ifdef __EMSCRIPTEN__
    static double sleepstarttime = 0;
    host.sleeptime = Sys_DirtyTime() - sleepstarttime;
#endif
 
    if (setjmp(host.abortframe)) // Something bad happened, or the server disconnected
        host.state = host_active; // In case we were loading
 
    if (host.state >= host_shutdown) // see Sys_HandleCrash() comments
    {
#ifdef __EMSCRIPTEN__
        emscripten_cancel_main_loop();
#endif
#ifdef __ANDROID__
        Sys_AllowProfiling(false);
#endif
        Host_Shutdown();
        exit(0);
    }
 
    newtime = Sys_DirtyTime();
    host.realtime += time = Sys_UpdateTime(newtime, host.dirtytime);
    host.dirtytime = newtime;
 
    sleeptime = Host_Frame(time);
    sleeptime -= Sys_DirtyTime() - host.dirtytime; // execution time
 
#ifdef __EMSCRIPTEN__
    // This platform doesn't support a main loop... it will sleep when Sys_Frame() returns.
    // Not using emscripten_sleep() via Sys_Sleep() because it would cause two sleeps per frame.
    if (!vid_vsync.integer) // see VID_SetVsync_c()
        emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, host.restless ? 0 : sleeptime * 1000.0);
    sleepstarttime = Sys_DirtyTime();
#else
    host.sleeptime = Sys_Sleep(sleeptime);
#endif
}

References host_static_t::abortframe, host_static_t::dirtytime, host, host_active, Host_Frame(), Host_Shutdown(), host_shutdown, cvar_t::integer, host_static_t::realtime, host_static_t::restless, host_static_t::sleeptime, host_static_t::state, Sys_AllowProfiling(), Sys_DirtyTime(), Sys_Sleep(), Sys_UpdateTime(), time, and vid_vsync.

Referenced by Sys_Main().

Sys_FreeLibrary()

void Sys_FreeLibrary

(

dllhandle_t *

handle

)

Definition at line 245 of file sys_shared.c.

{
#ifdef SUPPORTDLL
    if (handle == NULL || *handle == NULL)
        return;
 
#ifdef WIN32
    FreeLibrary (*handle);
#else
    dlclose (*handle);
#endif
 
    *handle = NULL;
#endif
}

References NULL.

Referenced by Crypto_CloseLibrary(), Crypto_Rijndael_CloseLibrary(), CURL_CloseLibrary(), Font_CloseLibrary(), FS_Shutdown(), JPEG_CloseLibrary(), LibAV_LoadLibrary(), LibAvW_CloseLibrary(), LibAvW_OpenLibrary(), OGG_CloseLibrary(), PK3_CloseLibrary(), PNG_CloseLibrary(), PNG_OpenLibrary(), SCR_CaptureVideo_Ogg_CloseDLL(), Sys_LoadDependency(), XMP_CloseLibrary(), and XMP_OpenLibrary().

Sys_GetProcAddress()

void * Sys_GetProcAddress	(	dllhandle_t	handle,
		const char *	name )

Definition at line 261 of file sys_shared.c.

{
#ifdef SUPPORTDLL
#ifdef WIN32
    return (void *)GetProcAddress (handle, name);
#else
    return (void *)dlsym (handle, name);
#endif
#else
    return NULL;
#endif
}

References name, and NULL.

Referenced by Sys_LoadDependencyFunctions().

Sys_HandleCrash()

static void Sys_HandleCrash ( int sig )

static

Halt and try not to catch fire.

Writing to any file could corrupt it, any uneccessary code could crash while we crash. Try to use only POSIX async-signal-safe library functions here (see: man signal-safety).

Definition at line 994 of file sys_shared.c.

{
#if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
    // Before doing anything else grab the stack frame addresses
    #include <execinfo.h>
    void *stackframes[32];
    int framecount = backtrace(stackframes, 32);
    char **btstrings;
#endif
    char dialogtext[3072];
    const char *sigdesc;
 
    // Break any loop and disable Sys_HandleSignal()
    if (host.state == host_failing || host.state == host_failed)
        return;
    host.state = host_failing;
 
    sigdesc = Sys_SigDesc(sig);
 
    // set output to blocking stderr and print header, backtrace, version
    sys.outfd = fileno(stderr); // not async-signal-safe :(
#ifndef WIN32
    fcntl(sys.outfd, F_SETFL, fcntl(sys.outfd, F_GETFL, 0) & ~O_NONBLOCK);
    Sys_Print("\n\n\x1B[1;37;41m    Engine Crash: ", 30);
    Sys_Print(sigdesc, strlen(sigdesc));
    Sys_Print("    \x1B[m\n", 8);
  #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
    // the first two addresses will be in this function and in signal() in libc
    backtrace_symbols_fd(stackframes + 2, framecount - 2, sys.outfd);
  #endif
    Sys_Print("\x1B[1m", 4);
    Sys_Print(engineversion, strlen(engineversion));
    Sys_Print("\x1B[m\n", 4);
#else // Windows console doesn't support colours
    Sys_Print("\n\nEngine Crash: ", 16);
    Sys_Print(sigdesc, strlen(sigdesc));
    Sys_Print("\n", 1);
    Sys_Print(engineversion, strlen(engineversion));
    Sys_Print("\n", 1);
#endif
 
    // DP8 TODO: send a disconnect message indicating we crashed, see Sys_Error() and Host_Error()
 
    // don't want a dead window left blocking the OS UI or the crash dialog
    VID_Shutdown();
    S_StopAllSounds();
 
    // prepare the dialogtext: signal, backtrace, version
    // the dp_st* funcs are POSIX async-signal-safe IF we don't trigger their warnings
    dp_strlcpy(dialogtext, sigdesc, sizeof(dialogtext));
    dp_strlcat(dialogtext, "\n\n", sizeof(dialogtext));
#if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
    btstrings = backtrace_symbols(stackframes + 2, framecount - 2); // calls malloc :(
    if (btstrings)
        for (int i = 0; i < framecount - 2; ++i)
        {
            dp_strlcat(dialogtext, btstrings[i], sizeof(dialogtext));
            dp_strlcat(dialogtext, "\n", sizeof(dialogtext));
        }
#endif
    dp_strlcat(dialogtext, "\n", sizeof(dialogtext));
    dp_strlcat(dialogtext, engineversion, sizeof(dialogtext));
 
    host.state = host_failed; // make Sys_HandleSignal() call _Exit()
    Sys_SDL_Dialog("Engine Crash", dialogtext);
 
    fflush(stderr); // not async-signal-safe :(
 
    // Continue execution with default signal handling.
    // A real crash will be re-triggered so the platform can handle it,
    // a fake crash (kill -SEGV) will cause a graceful shutdown.
    signal(sig, SIG_DFL);
}

References dp_strlcat, dp_strlcpy, engineversion, host, host_failed, host_failing, i, O_NONBLOCK, sys_t::outfd, S_StopAllSounds(), host_static_t::state, strlen(), sys, Sys_Print(), Sys_SDL_Dialog(), Sys_SigDesc(), and VID_Shutdown().

Referenced by Sys_InitSignals().

Sys_HandleSignal()

static void Sys_HandleSignal ( int sig )

static

Definition at line 1068 of file sys_shared.c.

{
    const char *sigdesc;
 
    // Break any loop, eg if each Sys_Print triggers a SIGPIPE
    if (host.state == host_shutdown || host.state == host_failing)
        return;
 
    sigdesc = Sys_SigDesc(sig);
    Sys_Print("\nReceived ", 10);
    Sys_Print(sigdesc, strlen(sigdesc));
    Sys_Print(" signal, exiting...\n", 20);
    if (host.state == host_failed)
    {
        // user is trying to kill the process while the SDL dialog is open
        fflush(stderr); // not async-signal-safe :(
        _Exit(sig);
    }
    host.state = host_shutdown;
}

References host, host_failed, host_failing, host_shutdown, host_static_t::state, strlen(), Sys_Print(), and Sys_SigDesc().

Referenced by Sys_InitSignals().

Sys_Init_Commands()

void Sys_Init_Commands

(

void

)

called after command system is initialized but before first Con_Print

Definition at line 353 of file sys_shared.c.

{
    Cvar_RegisterVariable(&sys_debugsleep);
    Cvar_RegisterVariable(&sys_usenoclockbutbenchmark);
    Cvar_RegisterVariable(&sys_libdir);
#if HAVE_TIMEGETTIME || HAVE_QUERYPERFORMANCECOUNTER || HAVE_CLOCKGETTIME
    if(sys_supportsdlgetticks)
    {
        Cvar_RegisterVariable(&sys_usesdlgetticks);
        Cvar_RegisterVariable(&sys_usesdldelay);
    }
#endif
#if HAVE_QUERYPERFORMANCECOUNTER
    Cvar_RegisterVariable(&sys_usequeryperformancecounter);
#endif
 
    Cvar_RegisterVariable(&sys_stdout);
    Cvar_RegisterCallback(&sys_stdout, Sys_UpdateOutFD_c);
#ifndef WIN32
    Cvar_RegisterVariable(&sys_stdout_blocks);
#endif
}

References Cvar_RegisterCallback(), Cvar_RegisterVariable(), sys_debugsleep, sys_libdir, sys_stdout, sys_stdout_blocks, sys_supportsdlgetticks, Sys_UpdateOutFD_c(), sys_usenoclockbutbenchmark, sys_usesdldelay, and sys_usesdlgetticks.

Referenced by Host_Init().

Sys_InitProcessNice()

void Sys_InitProcessNice

(

void

)

called to set process priority for dedicated servers

Definition at line 955 of file sys_shared.c.

{
}

Referenced by Host_Init().

Sys_InitSignals()

static void Sys_InitSignals ( void )

static

SDL2 only handles SIGINT and SIGTERM by default and doesn't log anything.

Definition at line 1090 of file sys_shared.c.

{
    // Windows only supports the C99 signals
    signal(SIGINT,  Sys_HandleSignal);
    signal(SIGILL,  Sys_HandleCrash);
    signal(SIGABRT, Sys_HandleCrash);
    signal(SIGFPE,  Sys_HandleCrash);
    signal(SIGSEGV, Sys_HandleCrash);
    signal(SIGTERM, Sys_HandleSignal);
#ifndef WIN32
    // POSIX has several others worth catching
    signal(SIGHUP,  Sys_HandleSignal);
    signal(SIGQUIT, Sys_HandleSignal);
    signal(SIGBUS,  Sys_HandleCrash);
    signal(SIGPIPE, Sys_HandleSignal);
#endif
}

References Sys_HandleCrash(), and Sys_HandleSignal().

Referenced by Sys_Main().

Sys_LoadDependency()

qbool Sys_LoadDependency	(	const char **	dllnames,
		dllhandle_t *	handle,
		const dllfunction_t *	fcts )

Loads a dependency library.

Parameters

dllnames	a NULL terminated array of possible names for the DLL you want to load.
handle
fcts

Definition at line 131 of file sys_shared.c.

{
#ifdef SUPPORTDLL
    const dllfunction_t *func;
    dllhandle_t dllhandle = 0;
    unsigned int i;
 
    if (handle == NULL)
        return false;
 
#ifndef WIN32
#ifdef PREFER_PRELOAD
    dllhandle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
    if(Sys_LoadDependencyFunctions(dllhandle, fcts, false, false))
    {
        Con_DPrintf ("All of %s's functions were already linked in! Not loading dynamically...\n", dllnames[0]);
        *handle = dllhandle;
        return true;
    }
    else
        Sys_FreeLibrary(&dllhandle);
notfound:
#endif
#endif
 
    // Initializations
    for (func = fcts; func && func->name != NULL; func++)
        *func->funcvariable = NULL;
 
    // Try every possible name
    Con_DPrintf ("Trying to load library...");
    for (i = 0; dllnames[i] != NULL; i++)
    {
        Con_DPrintf (" \"%s\"", dllnames[i]);
#ifdef WIN32
# ifndef DONT_USE_SETDLLDIRECTORY
#  ifdef _WIN64
        SetDllDirectory("bin64");
#  else
        SetDllDirectory("bin32");
#  endif
# endif
#endif
        if(Sys_LoadLibrary(dllnames[i], &dllhandle))
        {
            if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
                break;
            else
                Sys_FreeLibrary (&dllhandle);
        }
    }
 
    // see if the names can be loaded relative to the executable path
    // (this is for Mac OSX which does not check next to the executable)
    if (!dllhandle && strrchr(sys.argv[0], '/'))
    {
        char path[MAX_OSPATH];
        dp_strlcpy(path, sys.argv[0], sizeof(path));
        strrchr(path, '/')[1] = 0;
        for (i = 0; dllnames[i] != NULL; i++)
        {
            char temp[MAX_OSPATH];
            dp_strlcpy(temp, path, sizeof(temp));
            dp_strlcat(temp, dllnames[i], sizeof(temp));
            Con_DPrintf (" \"%s\"", temp);
 
            if(Sys_LoadLibrary(temp, &dllhandle))
            {
                if (Sys_LoadDependencyFunctions(dllhandle, fcts, true, (dllnames[i+1] != NULL) || (strrchr(sys.argv[0], '/'))))
                    break;
                else
                    Sys_FreeLibrary (&dllhandle);
            }
        }
    }
 
    // No DLL found
    if (! dllhandle)
    {
        Con_DPrintf(" - failed.\n");
        return false;
    }
 
    Con_DPrintf(" - loaded.\n");
    Con_Printf("Loaded library \"%s\"\n", dllnames[i]);
 
    *handle = dllhandle;
    return true;
#else
    return false;
#endif
}

References sys_t::argv, Con_DPrintf(), Con_Printf(), dp_strlcat, dp_strlcpy, dllfunction_t::funcvariable, i, MAX_OSPATH, dllfunction_t::name, NULL, sys, Sys_FreeLibrary(), Sys_LoadDependencyFunctions(), and Sys_LoadLibrary().

Referenced by Crypto_OpenLibrary(), Crypto_Rijndael_OpenLibrary(), CURL_OpenLibrary(), Font_OpenLibrary(), FS_ChooseUserDir(), JPEG_OpenLibrary(), LibAV_LoadLibrary(), LibAvW_OpenLibrary(), OGG_OpenLibrary(), PK3_OpenLibrary(), PNG_OpenLibrary(), SCR_CaptureVideo_Ogg_OpenLibrary(), VID_Shared_Init(), and XMP_OpenLibrary().

Sys_LoadDependencyFunctions()

static qbool Sys_LoadDependencyFunctions ( dllhandle_t dllhandle, const dllfunction_t * fcts, qbool complain, qbool has_next )

static

Definition at line 91 of file sys_shared.c.

{
    const dllfunction_t *func;
    if(dllhandle)
    {
        for (func = fcts; func && func->name != NULL; func++)
            if (!(*func->funcvariable = (void *) Sys_GetProcAddress (dllhandle, func->name)))
            {
                if(complain)
                {
                    Con_DPrintf (" - missing function \"%s\" - broken library!", func->name);
                    if(has_next)
                        Con_DPrintf("\nContinuing with");
                }
                goto notfound;
            }
        return true;
 
    notfound:
        for (func = fcts; func && func->name != NULL; func++)
            *func->funcvariable = NULL;
    }
    return false;
}

References Con_DPrintf(), dllfunction_t::funcvariable, dllfunction_t::name, NULL, and Sys_GetProcAddress().

Referenced by Sys_LoadDependency().

Sys_LoadLibrary()

qbool Sys_LoadLibrary	(	const char *	name,
		dllhandle_t *	handle )

Loads a library.

Parameters

name	a string of the library filename
handle

Returns

true if library was loaded successfully

Definition at line 224 of file sys_shared.c.

{
    dllhandle_t dllhandle = 0;
 
    if(handle == NULL)
        return false;
 
#ifdef SUPPORTDLL
# ifdef WIN32
    dllhandle = LoadLibrary (name);
# else
    dllhandle = dlopen (name, RTLD_LAZY | RTLD_GLOBAL);
# endif
#endif
    if(!dllhandle)
        return false;
 
    *handle = dllhandle;
    return true;
}

References name, and NULL.

Referenced by Sys_LoadDependency().

Sys_LoadSelf()

qbool Sys_LoadSelf

(

dllhandle_t *

handle

)

Definition at line 116 of file sys_shared.c.

{
    dllhandle_t dllhandle = 0;
 
    if (handle == NULL)
        return false;
#ifdef WIN32
    dllhandle = LoadLibrary (NULL);
#else
    dllhandle = dlopen (NULL, RTLD_NOW | RTLD_GLOBAL);
#endif
    *handle = dllhandle;
    return true;
}

References NULL.

Sys_Main()

int Sys_Main	(	int	argc,
		char *	argv[] )

main() but renamed so we can wrap it in sys_sdl.c and sys_null.c to avoid needing to include SDL.h in this file (would make the dedicated server require SDL).

SDL builds need SDL.h in the file where main() is defined because SDL renames and wraps main().

Definition at line 1178 of file sys_shared.c.

{
    sys.argc = argc;
    sys.argv = (const char **)argv;
 
    // COMMANDLINEOPTION: Console: -nostdout disables text output to the terminal the game was launched from
    // COMMANDLINEOPTION: -noterminal disables console output on stdout
    if(Sys_CheckParm("-noterminal") || Sys_CheckParm("-nostdout"))
        sys_stdout.string = "0";
    // COMMANDLINEOPTION: -stderr moves console output to stderr
    else if(Sys_CheckParm("-stderr"))
        sys_stdout.string = "2";
    // too early for Cvar_SetQuick
    sys_stdout.value = sys_stdout.integer = atoi(sys_stdout.string);
    Sys_UpdateOutFD_c(&sys_stdout);
#ifndef WIN32
    fcntl(fileno(stdin), F_SETFL, fcntl(fileno(stdin), F_GETFL, 0) | O_NONBLOCK);
    // stdout/stderr will be set to blocking in Sys_Print() if so configured, or during a fatal error.
    fcntl(fileno(stdout), F_SETFL, fcntl(fileno(stdout), F_GETFL, 0) | O_NONBLOCK);
    fcntl(fileno(stderr), F_SETFL, fcntl(fileno(stderr), F_GETFL, 0) | O_NONBLOCK);
#endif
 
    sys.selffd = -1;
    Sys_ProvideSelfFD(); // may call Con_Printf() so must be after sys.outfd is set
 
#ifdef __ANDROID__
    Sys_AllowProfiling(true);
#endif
 
    Sys_InitSignals();
 
#ifdef WIN32
    Sys_SetTimerResolution();
#endif
 
    Host_Init();
#ifdef __EMSCRIPTEN__
    emscripten_set_main_loop(Sys_Frame, 0, true); // doesn't return
#else
    while(true)
        Sys_Frame();
#endif
 
    return 0;
}

References sys_t::argc, argv(), sys_t::argv, Host_Init(), cvar_t::integer, O_NONBLOCK, sys_t::selffd, cvar_t::string, sys, Sys_AllowProfiling(), Sys_CheckParm(), Sys_Frame(), Sys_InitSignals(), Sys_ProvideSelfFD(), sys_stdout, Sys_UpdateOutFD_c(), and cvar_t::value.

Referenced by main().

Sys_MakeProcessMean()

void Sys_MakeProcessMean

(

void

)

Definition at line 961 of file sys_shared.c.

{
}

Referenced by Host_AbortCurrentFrame(), and SV_SpawnServer().

Sys_MakeProcessNice()

void Sys_MakeProcessNice

(

void

)

Definition at line 958 of file sys_shared.c.

{
}

Referenced by SV_SpawnServer().

Sys_Print()

void Sys_Print	(	const char *	text,
		size_t	textlen )

(may) output text to terminal which launched program is POSIX async-signal-safe textlen excludes any (optional) \0 terminator

Definition at line 615 of file sys_shared.c.

{
#ifdef __ANDROID__
    if (developer.integer > 0)
    {
        __android_log_write(ANDROID_LOG_DEBUG, sys.argv[0], text);
    }
#else
    if(sys.outfd < 0)
        return;
  #ifndef WIN32
    // BUG: for some reason, NDELAY also affects stdout (1) when used on stdin (0).
    // this is because both go to /dev/tty by default!
    {
        int origflags = fcntl(sys.outfd, F_GETFL, 0);
        if (sys_stdout_blocks.integer)
            fcntl(sys.outfd, F_SETFL, origflags & ~O_NONBLOCK);
  #else
    #define write _write
  #endif
        while(*text && textlen)
        {
            fs_offset_t written = (fs_offset_t)write(sys.outfd, text, textlen);
            if(written <= 0)
                break; // sorry, I cannot do anything about this error - without an output
            text += written;
            textlen -= written;
        }
  #ifndef WIN32
        if (sys_stdout_blocks.integer)
            fcntl(sys.outfd, F_SETFL, origflags);
    }
  #endif
    //fprintf(stdout, "%s", text);
#endif
}

References sys_t::argv, developer, cvar_t::integer, O_NONBLOCK, sys_t::outfd, sys, and sys_stdout_blocks.

Referenced by Con_MaskPrint(), dpvsnprintf(), Sys_HandleCrash(), Sys_HandleSignal(), and Sys_Printf().

Sys_Printf()

void Sys_Printf	(	const char *	fmt,
			... )

used to report failures inside Con_Printf()

Definition at line 652 of file sys_shared.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
    int msglen;
 
    va_start(argptr,fmt);
    msglen = dpvsnprintf(msg, sizeof(msg), fmt, argptr);
    va_end(argptr);
 
    if (msglen >= 0)
        Sys_Print(msg, msglen);
}

References dpvsnprintf(), MAX_INPUTLINE, and Sys_Print().

Referenced by _Thread_AtomicAdd(), _Thread_AtomicDecRef(), _Thread_AtomicGet(), _Thread_AtomicIncRef(), _Thread_AtomicLock(), _Thread_AtomicSet(), _Thread_AtomicTryLock(), _Thread_AtomicUnlock(), _Thread_CondBroadcast(), _Thread_CondSignal(), _Thread_CondWait(), _Thread_CreateBarrier(), _Thread_CreateCond(), _Thread_CreateMutex(), _Thread_CreateThread(), _Thread_DestroyBarrier(), _Thread_DestroyCond(), _Thread_DestroyMutex(), _Thread_LockMutex(), _Thread_UnlockMutex(), _Thread_WaitBarrier(), _Thread_WaitThread(), _Thread_WaitThread(), and Con_WordWidthFunc().

Sys_ProvideSelfFD()

void Sys_ProvideSelfFD

(

void

)

Definition at line 826 of file sys_shared.c.

{
    if(sys.selffd != -1)
        return;
    sys.selffd = FS_SysOpenFD(Sys_FindExecutableName(), "rb", false);
}

References FS_SysOpenFD(), sys_t::selffd, sys, and Sys_FindExecutableName().

Referenced by Sys_Main().

Sys_SigDesc()

static const char * Sys_SigDesc ( int sig )

static

Definition at line 967 of file sys_shared.c.

{
    switch (sig)
    {
        // Windows only supports the C99 signals
        case SIGINT:  return "Interrupt";
        case SIGILL:  return "Illegal instruction";
        case SIGABRT: return "Aborted";
        case SIGFPE:  return "Floating point exception";
        case SIGSEGV: return "Segmentation fault";
        case SIGTERM: return "Termination";
#ifndef WIN32
        // POSIX has several others worth catching
        case SIGHUP:  return "Hangup";
        case SIGQUIT: return "Quit";
        case SIGBUS:  return "Bus error (bad memory access)";
        case SIGPIPE: return "Broken pipe";
#endif
        default:      return "Yo dawg, we bugged out while bugging out";
    }
}

Referenced by Sys_HandleCrash(), and Sys_HandleSignal().

Sys_Sleep()

double Sys_Sleep

(

double

time

)

called to yield for a little bit so as not to hog cpu when paused or debugging

Definition at line 500 of file sys_shared.c.

{
    double dt;
    uint32_t msec, usec, nsec;
 
    if (time < 1.0/1000000.0 || host.restless)
        return 0; // not sleeping this frame
    if (time >= 1)
        time = 0.999999; // simpler, also ensures values are in range for all platform APIs
    msec = time * 1000;
    usec = time * 1000000;
    nsec = time * 1000000000;
 
    if(sys_usenoclockbutbenchmark.integer)
    {
        double old_benchmark_time = benchmark_time;
        benchmark_time += usec;
        if(benchmark_time == old_benchmark_time)
            Sys_Error("sys_usenoclockbutbenchmark cannot run any longer, sorry");
        return 0;
    }
 
    if(sys_debugsleep.integer)
        Con_Printf("sys_debugsleep: requested %u, ", usec);
    dt = Sys_DirtyTime();
 
    // less important on newer libcurl so no need to disturb dedicated servers
    if (cls.state != ca_dedicated && Curl_Select(msec))
    {
        // a transfer is ready or we finished sleeping
    }
    else if(sys_supportsdlgetticks && sys_usesdldelay.integer)
        Sys_SDL_Delay(msec);
#if HAVE_SELECT
    else if (cls.state == ca_dedicated && sv_checkforpacketsduringsleep.integer)
    {
        struct timeval tv;
        lhnetsocket_t *s;
        fd_set fdreadset;
        int lastfd = -1;
 
        FD_ZERO(&fdreadset);
        List_For_Each_Entry(s, &lhnet_socketlist.list, lhnetsocket_t, list)
        {
            if (s->address.addresstype == LHNETADDRESSTYPE_INET4 || s->address.addresstype == LHNETADDRESSTYPE_INET6)
            {
                if (lastfd < s->inetsocket)
                    lastfd = s->inetsocket;
    #if defined(WIN32) && !defined(_MSC_VER)
                FD_SET((int)s->inetsocket, &fdreadset);
    #else
                FD_SET((unsigned int)s->inetsocket, &fdreadset);
    #endif
            }
        }
        tv.tv_sec = 0;
        tv.tv_usec = usec;
        // on Win32, select() cannot be used with all three FD list args being NULL according to MSDN
        // (so much for POSIX...), not with an empty fd_set either.
        select(lastfd + 1, &fdreadset, NULL, NULL, &tv);
    }
#endif
#if HAVE_CLOCK_NANOSLEEP
    else
    {
        struct timespec ts;
        ts.tv_sec = 0;
        ts.tv_nsec = nsec;
        clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
    }
#elif HAVE_SELECT_POSIX
    else
    {
        struct timeval tv;
        tv.tv_sec = 0;
        tv.tv_usec = usec;
        select(0, NULL, NULL, NULL, &tv);
    }
#elif HAVE_WIN32_USLEEP // Windows XP/2003 minimum
    else
    {
        HANDLE timer;
        LARGE_INTEGER sleeptime;
 
        // takes 100ns units, negative indicates relative time
        sleeptime.QuadPart = -((int64_t)nsec / 100);
        timer = CreateWaitableTimer(NULL, true, NULL);
        SetWaitableTimer(timer, &sleeptime, 0, NULL, NULL, 0);
        WaitForSingleObject(timer, INFINITE);
        CloseHandle(timer);
    }
#elif HAVE_Sleep
    else
        Sleep(msec);
#else
    else
        Sys_SDL_Delay(msec);
#endif
 
    dt = Sys_DirtyTime() - dt;
    if(sys_debugsleep.integer)
        Con_Printf("got %u, oversleep %d\n", (uint32_t)(dt * 1000000), (uint32_t)(dt * 1000000) - usec);
    return (dt < 0 || dt >= 1800) ? 0 : dt;
}

References benchmark_time, ca_dedicated, cls, Con_Printf(), Curl_Select(), host, cvar_t::integer, lhnet_socketlist, LHNETADDRESSTYPE_INET4, LHNETADDRESSTYPE_INET6, lhnetsocket_t::list, List_For_Each_Entry, NULL, host_static_t::restless, client_static_t::state, sv_checkforpacketsduringsleep, sys_debugsleep, Sys_DirtyTime(), Sys_Error(), Sys_SDL_Delay(), sys_supportsdlgetticks, sys_usenoclockbutbenchmark, sys_usesdldelay, and time.

Referenced by attempt_malloc(), CL_Frame(), SV_ThreadFunc(), Sys_Frame(), and TaskQueue_ThreadFunc().

Sys_TimeString()

size_t Sys_TimeString	(	char	buf[],
		size_t	bufsize,
		const char *	timeformat )

Returns

current timestamp

Definition at line 45 of file sys_shared.c.

{
    time_t mytime = time(NULL);
    size_t strlen;
#if _MSC_VER >= 1400
    struct tm mytm;
    localtime_s(&mytm, &mytime);
    strlen = strftime(buf, bufsize, timeformat, &mytm);
#else
    strlen = strftime(buf, bufsize, timeformat, localtime(&mytime));
#endif
    if (!strlen) // means the array contents are undefined (but it's not always an error)
        buf[0] = '\0'; // better fix it
    return strlen;
}

References buf, NULL, strlen(), time, and timeformat.

Referenced by CL_FinishTimeDemo(), CL_Locs_Save_f(), CL_ParseServerInfo(), Con_MaskPrint(), Sbar_ShowFPS(), SCR_ScreenShot_f(), and SV_SendServerinfo().

Sys_UpdateOutFD_c()

static void Sys_UpdateOutFD_c ( cvar_t * var )

static

Definition at line 342 of file sys_shared.c.

{
    switch (sys_stdout.integer)
    {
        case 0: sys.outfd = -1; break;
        default:
        case 1: sys.outfd = fileno(stdout); break;
        case 2: sys.outfd = fileno(stderr); break;
    }
}

References cvar_t::integer, sys_t::outfd, sys, and sys_stdout.

Referenced by Sys_Init_Commands(), and Sys_Main().

Sys_UpdateTime()

static double Sys_UpdateTime ( double newtime, double oldtime )

inlinestatic

Definition at line 1109 of file sys_shared.c.

{
    double time = newtime - oldtime;
 
    if (time < 0)
    {
        // warn if it's significant
        if (time < -0.01)
            Con_Printf(CON_WARN "Host_UpdateTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, time);
        time = 0;
    }
    else if (time >= 1800)
    {
        Con_Printf(CON_WARN "Host_UpdateTime: time stepped forward (went from %f to %f, difference %f)\n", oldtime, newtime, time);
        time = 0;
    }
 
    return time;
}

References Con_Printf(), CON_WARN, and time.

Referenced by Sys_Frame().

Variable Documentation

benchmark_time

double benchmark_time

static

Definition at line 317 of file sys_shared.c.

Referenced by Sys_DirtyTime(), and Sys_Sleep().

sys

sys_t sys

Definition at line 42 of file sys_shared.c.

Referenced by CL_FinishTimeDemo(), Cmd_StuffCmds_f(), COM_Init_Commands(), COM_InitGameType(), COM_InsertFlags(), COM_SetGameType(), Con_MaskPrint(), FS_Init_Dir(), FS_Init_SelfPack(), FS_Rescan(), Host_Error(), Host_Init(), Host_InitSession(), MVM_error_cmd(), NetConn_Init(), Palette_Load(), S_Startup(), SV_ServerOptions(), Sys_CheckParm(), Sys_Error(), Sys_FindExecutableName(), Sys_HandleCrash(), Sys_LoadDependency(), Sys_Main(), Sys_Print(), Sys_ProvideSelfFD(), Sys_UpdateOutFD_c(), VID_InitModeGL(), VID_Start(), and VM_Warning().

sys_debugsleep

cvar_t sys_debugsleep = {CF_SHARED, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"}

static

Definition at line 305 of file sys_shared.c.

{CF_SHARED, "sys_debugsleep", "0", "write requested and attained sleep times to standard output, to be used with gnuplot"};

Referenced by Sys_Init_Commands(), and Sys_Sleep().

sys_libdir

cvar_t sys_libdir = {CF_READONLY | CF_SHARED, "sys_libdir", "", "Default engine library directory"}

Definition at line 302 of file sys_shared.c.

{CF_READONLY | CF_SHARED, "sys_libdir", "", "Default engine library directory"};

Referenced by Sys_Init_Commands().

sys_stdout

cvar_t sys_stdout = {CF_SHARED, "sys_stdout", "1", "0: nothing is written to stdout (-nostdout cmdline option sets this), 1: normal messages are written to stdout, 2: normal messages are written to stderr (-stderr cmdline option sets this)"}

static

Definition at line 312 of file sys_shared.c.

{CF_SHARED, "sys_stdout", "1", "0: nothing is written to stdout (-nostdout cmdline option sets this), 1: normal messages are written to stdout, 2: normal messages are written to stderr (-stderr cmdline option sets this)"};

Referenced by Sys_Init_Commands(), Sys_Main(), and Sys_UpdateOutFD_c().

sys_stdout_blocks

cvar_t sys_stdout_blocks = {CF_SHARED, "sys_stdout_blocks", "0", "1: writes to stdout and stderr streams will block (causing a stutter or complete halt) if the buffer is full, ensuring no messages are lost at a price"}

static

Definition at line 314 of file sys_shared.c.

{CF_SHARED, "sys_stdout_blocks", "0", "1: writes to stdout and stderr streams will block (causing a stutter or complete halt) if the buffer is full, ensuring no messages are lost at a price"};

Referenced by Sys_Init_Commands(), and Sys_Print().

sys_usenoclockbutbenchmark

cvar_t sys_usenoclockbutbenchmark = {CF_SHARED, "sys_usenoclockbutbenchmark", "0", "don't use ANY real timing, and simulate a clock (for benchmarking); the game then runs as fast as possible. Run a QC mod with bots that does some stuff, then does a quit at the end, to benchmark a server. NEVER do this on a public server."}

Definition at line 301 of file sys_shared.c.

{CF_SHARED, "sys_usenoclockbutbenchmark", "0", "don't use ANY real timing, and simulate a clock (for benchmarking); the game then runs as fast as possible. Run a QC mod with bots that does some stuff, then does a quit at the end, to benchmark a server. NEVER do this on a public server."};

Referenced by Sys_DirtyTime(), Sys_Init_Commands(), and Sys_Sleep().

sys_usesdldelay

cvar_t sys_usesdldelay = {CF_SHARED, "sys_usesdldelay", "0", "use SDL_Delay() (low precision, for debugging)"}

static

Definition at line 307 of file sys_shared.c.

{CF_SHARED, "sys_usesdldelay", "0", "use SDL_Delay() (low precision, for debugging)"};

Referenced by Sys_Init_Commands(), and Sys_Sleep().

sys_usesdlgetticks

cvar_t sys_usesdlgetticks = {CF_SHARED, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (low precision, for debugging)"}

static

Definition at line 306 of file sys_shared.c.

{CF_SHARED, "sys_usesdlgetticks", "0", "use SDL_GetTicks() timer (low precision, for debugging)"};

Referenced by Sys_DirtyTime(), and Sys_Init_Commands().