common.c File Reference

#include "shared/shared.h"
#include "common/bsp.h"
#include "common/cmd.h"
#include "common/cmodel.h"
#include "common/common.h"
#include "common/cvar.h"
#include "common/error.h"
#include "common/field.h"
#include "common/fifo.h"
#include "common/files.h"
#include "common/math.h"
#include "common/mdfour.h"
#include "common/msg.h"
#include "common/net/net.h"
#include "common/net/chan.h"
#include "common/pmove.h"
#include "common/prompt.h"
#include "common/protocol.h"
#include "common/tests.h"
#include "common/utils.h"
#include "common/x86/fpu.h"
#include "common/zone.h"
#include "client/client.h"
#include "client/keys.h"
#include "server/server.h"
#include "system/system.h"
#include <setjmp.h>
#include <Windows.h>

Go to the source code of this file.

Functions
void	Com_BeginRedirect (int target, char *buffer, size_t buffersize, rdflush_t flush)
static void	Com_AbortRedirect (void)
void	Com_EndRedirect (void)
static void	Com_Redirect (const char *msg, size_t total)
static void	logfile_close (void)
static void	logfile_open (void)
static void	logfile_enable_changed (cvar_t *self)
static void	logfile_param_changed (cvar_t *self)
static size_t	format_local_time (char *buffer, size_t size, const char *fmt)
static void	logfile_write (print_type_t type, const char *s)
void	Com_SetColor (color_index_t color)
void	Com_SetLastError (const char *msg)
char *	Com_GetLastError (void)
void	Com_LPrintf (print_type_t type, const char *fmt,...)
void	Com_Error (error_type_t code, const char *fmt,...)
void	Com_AbortFunc (void(*func)(void *), void *arg)
void	Com_AbortFrame (void)
void	Com_Quit (const char *reason, error_type_t type)
static void	Com_Quit_f (void)
static void	Com_Recycle_f (void)
size_t	Com_Time_m (char *buffer, size_t size)
static size_t	Com_Date_m (char *buffer, size_t size)
size_t	Com_Uptime_m (char *buffer, size_t size)
size_t	Com_UptimeLong_m (char *buffer, size_t size)
static size_t	Com_Random_m (char *buffer, size_t size)
static size_t	Com_MapList_m (char *buffer, size_t size)
static void	Com_LastError_f (void)
void	Com_Address_g (genctx_t *ctx)
void	Com_Generic_c (genctx_t *ctx, int argnum)
static void	Com_AddEarlyCommands (qboolean clear)
static qboolean	Com_AddLateCommands (void)
void	Com_AddConfigFile (const char *name, unsigned flags)
void	Qcommon_Init (int argc, char **argv)
void	Qcommon_Frame (void)

Variables
static jmp_buf	com_abortframe
static void(*	com_abort_func )(void *)
static void *	com_abort_arg
static qboolean	com_errorEntered
static char	com_errorMsg [MAXERRORMSG]
static int	com_printEntered
static qhandle_t	com_logFile
static qboolean	com_logNewline
static char **	com_argv
static int	com_argc
cvar_t *	z_perturb
cvar_t *	timescale
cvar_t *	fixedtime
cvar_t *	dedicated
cvar_t *	backdoor
cvar_t *	com_version
cvar_t *	logfile_enable
cvar_t *	logfile_flush
cvar_t *	logfile_name
cvar_t *	logfile_prefix
cvar_t *	sv_running
cvar_t *	sv_paused
cvar_t *	com_timedemo
cvar_t *	com_date_format
cvar_t *	com_time_format
cvar_t *	com_fatal_error
cvar_t *	allow_download
cvar_t *	allow_download_players
cvar_t *	allow_download_models
cvar_t *	allow_download_sounds
cvar_t *	allow_download_maps
cvar_t *	allow_download_textures
cvar_t *	allow_download_pics
cvar_t *	allow_download_others
cvar_t *	rcon_password
cvar_t *	fs_shareware
const char	com_version_string []
unsigned	com_framenum
unsigned	com_eventTime
unsigned	com_localTime
qboolean	com_initialized
time_t	com_startTime
static int	rd_target
static char *	rd_buffer
static size_t	rd_buffersize
static size_t	rd_length
static rdflush_t	rd_flush

Function Documentation

Com_AbortFrame()

void Com_AbortFrame

(

void

)

Definition at line 595 of file common.c.

{
    longjmp(com_abortframe, -1);
}

Referenced by Sys_Quit().

Com_AbortFunc()

void Com_AbortFunc	(	void(*)(void *)	func,
		void *	arg
	)

Definition at line 588 of file common.c.

{
    com_abort_func = func;
    com_abort_arg = arg;
}

Referenced by read_server_file(), and SV_Map().

Com_AbortRedirect()

static void Com_AbortRedirect ( void  )

static

Definition at line 163 of file common.c.

{
    rd_target = 0;
    rd_buffer = NULL;
    rd_buffersize = 0;
    rd_flush = NULL;
    rd_length = 0;
}

Referenced by Com_Error().

Com_AddConfigFile()

void Com_AddConfigFile	(	const char *	name,
		unsigned	flags
	)

Definition at line 876 of file common.c.

{
    qerror_t ret;
 
    ret = Cmd_ExecuteFile(name, flags);
    if (ret == Q_ERR_SUCCESS) {
        Cbuf_Execute(&cmd_buffer);
    } else if (ret != Q_ERR_NOENT) {
        Com_WPrintf("Couldn't exec %s: %s\n", name, Q_ErrorString(ret));
    }
}

Referenced by fs_game_changed(), Qcommon_Init(), and R_BeginRegistration_RTX().

Com_AddEarlyCommands()

static void Com_AddEarlyCommands ( qboolean  clear )

static

Definition at line 806 of file common.c.

{
    int     i;
    char    *s;
 
    for (i = 1; i < com_argc; i++) {
        s = com_argv[i];
        if (!s) {
            continue;
        }
        if (strcmp(s, "+set")) {
            continue;
        }
        if (i + 2 >= com_argc) {
            Com_Printf("Usage: +set <variable> <value>\n");
            com_argc = i;
            break;
        }
        Cvar_SetEx(com_argv[i + 1], com_argv[i + 2], FROM_CMDLINE);
        if (clear) {
            com_argv[i] = com_argv[i + 1] = com_argv[i + 2] = NULL;
        }
        i += 2;
    }
}

Referenced by Qcommon_Init().

Com_AddLateCommands()

static qboolean Com_AddLateCommands ( void  )

static

Definition at line 845 of file common.c.

{
    int     i;
    char    *s;
    qboolean ret = qfalse;
 
    for (i = 1; i < com_argc; i++) {
        s = com_argv[i];
        if (!s) {
            continue;
        }
        if (*s == '+') {
            if (ret) {
                Cbuf_AddText(&cmd_buffer, "\n");
            }
            s++;
        } else if (ret) {
            Cbuf_AddText(&cmd_buffer, " ");
        }
        Cbuf_AddText(&cmd_buffer, s);
        ret = qtrue;
    }
 
    if (ret) {
        Cbuf_AddText(&cmd_buffer, "\n");
        Cbuf_Execute(&cmd_buffer);
    }
 
    return ret;
}

Referenced by Qcommon_Init().

Com_Address_g()

void Com_Address_g

(

genctx_t *

ctx

)

Definition at line 729 of file common.c.

{
    int i;
    cvar_t *var;
 
    for (i = 0; i < 1024; i++) {
        var = Cvar_FindVar(va("adr%d", i));
        if (!var) {
            break;
        }
        if (!var->string[0]) {
            continue;
        }
        if (!Prompt_AddMatch(ctx, var->string)) {
            break;
        }
    }
}

Referenced by CL_Connect_c(), CL_InitLocal(), CL_RemoteMode_c(), CL_ServerStatus_c(), and MVD_Connect_c().

Com_BeginRedirect()

void Com_BeginRedirect	(	int	target,
		char *	buffer,
		size_t	buffersize,
		rdflush_t	flush
	)

Definition at line 151 of file common.c.

{
    if (rd_target || !target || !buffer || !buffersize || !flush) {
        return;
    }
    rd_target = target;
    rd_buffer = buffer;
    rd_buffersize = buffersize;
    rd_flush = flush;
    rd_length = 0;
}

Com_Date_m()

static size_t Com_Date_m ( char *  buffer, size_t  size  )

static

Definition at line 657 of file common.c.

{
    return format_local_time(buffer, size, com_date_format->string);
}

Referenced by Qcommon_Init().

Com_EndRedirect()

void Com_EndRedirect

(

void

)

Definition at line 172 of file common.c.

{
    if (!rd_target) {
        return;
    }
    rd_flush(rd_target, rd_buffer, rd_length);
    rd_target = 0;
    rd_buffer = NULL;
    rd_buffersize = 0;
    rd_flush = NULL;
    rd_length = 0;
}

Referenced by MVD_Join_f(), SV_AC_Info_f(), SV_AC_List_f(), SV_Lag_f(), SV_ShowMiscInfo_f(), SV_ShowServerInfo_f(), and SVC_RemoteCommand().

Com_Error()

void Com_Error	(	error_type_t	code,
		const char *	fmt,
			...
	)

Definition at line 496 of file common.c.

{
    char            msg[MAXERRORMSG];
    va_list         argptr;
    size_t          len;
 
    // may not be entered recursively
    if (com_errorEntered) {
#ifdef _DEBUG
        if (com_debug_break && com_debug_break->integer) {
            Sys_DebugBreak();
        }
#endif
        Sys_Error("recursive error after: %s", com_errorMsg);
    }
 
    com_errorEntered = qtrue;
 
    va_start(argptr, fmt);
    len = Q_vscnprintf(msg, sizeof(msg), fmt, argptr);
    va_end(argptr);
 
    // save error msg
    // can't print into it directly since it may
    // overlap with one of the arguments!
    memcpy(com_errorMsg, msg, len + 1);
 
    // fix up drity message buffers
    MSG_Init();
 
    // abort any console redirects
    Com_AbortRedirect();
 
    // call custom cleanup function if set
    if (com_abort_func) {
        com_abort_func(com_abort_arg);
        com_abort_func = NULL;
    }
 
    // reset Com_Printf recursion level
    com_printEntered = 0;
 
    X86_POP_FPCW;
 
    if (code == ERR_DISCONNECT || code == ERR_RECONNECT) {
        Com_WPrintf("%s\n", com_errorMsg);
        SV_Shutdown(va("Server was killed: %s\n", com_errorMsg), code);
        CL_Disconnect(code);
        goto abort;
    }
 
#ifdef _DEBUG
    if (com_debug_break && com_debug_break->integer) {
        Sys_DebugBreak();
    }
#endif
 
    // make otherwise non-fatal errors fatal
    if (com_fatal_error && com_fatal_error->integer) {
        code = ERR_FATAL;
    }
 
    if (code == ERR_DROP) {
        Com_EPrintf("********************\n"
                    "ERROR: %s\n"
                    "********************\n", com_errorMsg);
        SV_Shutdown(va("Server crashed: %s\n", com_errorMsg), ERR_DROP);
        CL_Disconnect(ERR_DROP);
        goto abort;
    }
 
    if (com_logFile) {
        FS_FPrintf(com_logFile, "FATAL: %s\n", com_errorMsg);
    }
 
    SV_Shutdown(va("Server fatal crashed: %s\n", com_errorMsg), ERR_FATAL);
    CL_Shutdown();
    NET_Shutdown();
    logfile_close();
    FS_Shutdown();
 
    Sys_Error("%s", com_errorMsg);
    // doesn't get there
 
abort:
    if (com_logFile) {
        FS_Flush(com_logFile);
    }
    com_errorEntered = qfalse;
    longjmp(com_abortframe, -1);
}

Com_Generic_c()

void Com_Generic_c	(	genctx_t *	ctx,
		int	argnum
	)

Definition at line 748 of file common.c.

{
    xcompleter_t c;
    xgenerator_t g;
    cvar_t *var;
    char *s;
 
    // complete command, alias or cvar name
    if (!argnum) {
        Cmd_Command_g(ctx);
        Cvar_Variable_g(ctx);
        Cmd_Alias_g(ctx);
        return;
    }
 
    // protect against possible duplicates
    ctx->ignoredups = qtrue;
 
    s = Cmd_Argv(ctx->argnum - argnum);
 
    // complete command argument or cvar value
    if ((c = Cmd_FindCompleter(s)) != NULL) {
        c(ctx, argnum);
    } else if (argnum == 1 && (var = Cvar_FindVar(s)) != NULL) {
        g = var->generator;
        if (g) {
            ctx->data = var;
            g(ctx);
        }
    }
}

Referenced by CL_Rcon_c(), Cmd_Alias_c(), Key_Bind_c(), and Prompt_CompleteCommand().

Com_GetLastError()

char* Com_GetLastError

(

void

)

Definition at line 391 of file common.c.

{
    return com_errorMsg;
}

Referenced by _SV_LoadGameLibrary(), AL_Init(), and CL_InitRefresh().

Com_LastError_f()

static void Com_LastError_f ( void  )

static

Definition at line 703 of file common.c.

{
    Com_Printf("%s\n", com_errorMsg);
}

Referenced by Qcommon_Init().

Com_LPrintf()

void Com_LPrintf	(	print_type_t	type,
		const char *	fmt,
			...
	)

Definition at line 404 of file common.c.

{
    va_list     argptr;
    char        msg[MAXPRINTMSG];
    size_t      len;
 
    // may be entered recursively only once
    if (com_printEntered >= 2) {
        return;
    }
 
    com_printEntered++;
 
    va_start(argptr, fmt);
    len = Q_vscnprintf(msg, sizeof(msg), fmt, argptr);
    va_end(argptr);
 
    if (type == PRINT_ERROR && !com_errorEntered && len) {
        size_t errlen = len;
 
        if (errlen >= sizeof(com_errorMsg)) {
            errlen = sizeof(com_errorMsg) - 1;
        }
 
        // save error msg
        memcpy(com_errorMsg, msg, errlen);
        com_errorMsg[errlen] = 0;
 
        // strip trailing '\n'
        if (com_errorMsg[errlen - 1] == '\n') {
            com_errorMsg[errlen - 1] = 0;
        }
    }
 
    if (rd_target) {
        Com_Redirect(msg, len);
    } else {
        switch (type) {
        case PRINT_TALK:
            Com_SetColor(COLOR_ALT);
            break;
        case PRINT_DEVELOPER:
            Com_SetColor(COLOR_BLUE);
            break;
        case PRINT_WARNING:
            Com_SetColor(COLOR_YELLOW);
            break;
        case PRINT_ERROR:
            Com_SetColor(COLOR_RED);
            break;
        case PRINT_NOTICE:
            Com_SetColor(COLOR_CYAN);
            break;
        default:
            break;
        }
 
        // graphical console
        Con_Print(msg);
 
        // debugging console
        Sys_ConsoleOutput(msg);
 
#ifdef _WIN32
        OutputDebugStringA(msg);
#endif
 
        // remote console
        //SV_ConsoleOutput(msg);
 
        // logfile
        if (com_logFile) {
            logfile_write(type, msg);
        }
 
        if (type) {
            Com_SetColor(COLOR_NONE);
        }
    }
 
    com_printEntered--;
}

Referenced by Qcommon_Init().

Com_MapList_m()

static size_t Com_MapList_m ( char *  buffer, size_t  size  )

static

Definition at line 677 of file common.c.

{
    int i, numFiles;
    void **list;
    char *s, *p;
    size_t len, total = 0;
 
    list = FS_ListFiles("maps", ".bsp", 0, &numFiles);
    for (i = 0; i < numFiles; i++) {
        s = list[i];
        p = COM_FileExtension(list[i]);
        *p = 0;
        len = strlen(s);
        if (total + len + 1 < size) {
            memcpy(buffer + total, s, len);
            buffer[total + len] = ' ';
            total += len + 1;
        }
        Z_Free(s);
    }
    buffer[total] = 0;
 
    Z_Free(list);
    return total;
}

Referenced by Qcommon_Init().

Com_Quit()

void Com_Quit	(	const char *	reason,
		error_type_t	type
	)

Definition at line 609 of file common.c.

{
    char buffer[MAX_STRING_CHARS];
    char *what = type == ERR_RECONNECT ? "restarted" : "quit";
 
    if (reason && *reason) {
        Q_snprintf(buffer, sizeof(buffer),
                   "Server %s: %s\n", what, reason);
    } else {
        Q_snprintf(buffer, sizeof(buffer),
                   "Server %s\n", what);
    }
 
    SV_Shutdown(buffer, type);
    CL_Shutdown();
    NET_Shutdown();
    logfile_close();
    FS_Shutdown();
 
    Sys_Quit();
    // doesn't get there
}

Referenced by Com_Quit_f(), Com_Recycle_f(), SV_GameMap_f(), Sys_Main(), and VID_PumpEvents().

Com_Quit_f()

static void Com_Quit_f ( void  )

static

Definition at line 632 of file common.c.

{
    Com_Quit(Cmd_Args(), ERR_DISCONNECT);
}

Referenced by Qcommon_Init().

Com_Random_m()

static size_t Com_Random_m ( char *  buffer, size_t  size  )

static

Definition at line 672 of file common.c.

{
    return Q_scnprintf(buffer, size, "%d", rand_byte() % 10);
}

Referenced by Qcommon_Init().

Com_Recycle_f()

static void Com_Recycle_f ( void  )

static

Definition at line 638 of file common.c.

{
    Com_Quit(Cmd_Args(), ERR_RECONNECT);
}

Referenced by Qcommon_Init().

Com_Redirect()

static void Com_Redirect ( const char *  msg, size_t  total  )

static

Definition at line 185 of file common.c.

{
    size_t length;
 
    while (total) {
        length = total;
        if (length > rd_buffersize) {
            length = rd_buffersize;
        }
        if (rd_length > rd_buffersize - length) {
            rd_flush(rd_target, rd_buffer, rd_length);
            rd_length = 0;
        }
        memcpy(rd_buffer + rd_length, msg, length);
        rd_length += length;
        total -= length;
    }
}

Referenced by Com_LPrintf().

Com_SetColor()

void Com_SetColor

(

color_index_t

color

)

Definition at line 373 of file common.c.

{
    if (rd_target) {
        return;
    }
    Con_SetColor(color);
    Sys_SetConsoleColor(color);
}

Referenced by CL_ParseServerData(), Cmd_EchoEx_f(), and Com_LPrintf().

Com_SetLastError()

void Com_SetLastError

(

const char *

msg

)

Definition at line 382 of file common.c.

{
    if (msg) {
        Q_strlcpy(com_errorMsg, msg, sizeof(com_errorMsg));
    } else {
        strcpy(com_errorMsg, "No error");
    }
}

Referenced by AL_Init(), CL_InitRefresh(), QAL_Init(), Qcommon_Init(), Sys_GetProcAddress(), and Sys_LoadLibrary().

Com_Time_m()

size_t Com_Time_m	(	char *	buffer,
		size_t	size
	)

Definition at line 652 of file common.c.

{
    return format_local_time(buffer, size, com_time_format->string);
}

Referenced by Con_DrawSolidConsole(), and Qcommon_Init().

Com_Uptime_m()

size_t Com_Uptime_m	(	char *	buffer,
		size_t	size
	)

Definition at line 662 of file common.c.

{
    return Com_TimeDiff(buffer, size, &com_startTime, time(NULL));
}

Referenced by Qcommon_Init(), and SV_StatusString().

Com_UptimeLong_m()

size_t Com_UptimeLong_m	(	char *	buffer,
		size_t	size
	)

Definition at line 667 of file common.c.

{
    return Com_TimeDiffLong(buffer, size, &com_startTime, time(NULL));
}

Referenced by Qcommon_Init(), and SV_StatusString().

format_local_time()

static size_t format_local_time ( char *  buffer, size_t  size, const char *  fmt  )

static

Definition at line 259 of file common.c.

{
    static struct tm cached_tm;
    static time_t cached_time;
    time_t now;
    struct tm *tm;
 
    if (!size) {
        return 0;
    }
 
    buffer[0] = 0;
 
    now = time(NULL);
    if (now == cached_time) {
        // avoid calling localtime() too often since it is not that cheap
        tm = &cached_tm;
    } else {
        tm = localtime(&now);
        if (!tm) {
            return 0;
        }
        cached_time = now;
        cached_tm = *tm;
    }
 
    return strftime(buffer, size, fmt, tm);
}

Referenced by Com_Date_m(), Com_Time_m(), and logfile_write().

logfile_close()

static void logfile_close ( void  )

static

Definition at line 204 of file common.c.

{
    if (!com_logFile) {
        return;
    }
 
    Com_Printf("Closing console log.\n");
 
    FS_FCloseFile(com_logFile);
    com_logFile = 0;
}

Referenced by Com_Error(), Com_Quit(), logfile_enable_changed(), logfile_param_changed(), and NET_Shutdown().

logfile_enable_changed()

static void logfile_enable_changed ( cvar_t *  self )

static

Definition at line 243 of file common.c.

{
    logfile_close();
    if (self->integer) {
        logfile_open();
    }
}

Referenced by Qcommon_Init().

logfile_open()

static void logfile_open ( void  )

static

Definition at line 216 of file common.c.

{
    char buffer[MAX_OSPATH];
    unsigned mode;
    qhandle_t f;
 
    mode = logfile_enable->integer > 1 ? FS_MODE_APPEND : FS_MODE_WRITE;
    if (logfile_flush->integer > 0) {
        if (logfile_flush->integer > 1) {
            mode |= FS_BUF_NONE;
        } else {
            mode |= FS_BUF_LINE;
        }
    }
 
    f = FS_EasyOpenFile(buffer, sizeof(buffer), mode | FS_FLAG_TEXT,
                        "logs/", logfile_name->string, ".log");
    if (!f) {
        Cvar_Set("logfile", "0");
        return;
    }
 
    com_logFile = f;
    com_logNewline = qtrue;
    Com_Printf("Logging console to %s\n", buffer);
}

Referenced by logfile_enable_changed(), and logfile_param_changed().

logfile_param_changed()

static void logfile_param_changed ( cvar_t *  self )

static

Definition at line 251 of file common.c.

{
    if (logfile_enable->integer) {
        logfile_close();
        logfile_open();
    }
}

Referenced by Qcommon_Init().

logfile_write()

static void logfile_write ( print_type_t  type, const char *  s  )

static

Definition at line 288 of file common.c.

{
    char text[MAXPRINTMSG];
    char buf[MAX_QPATH];
    char *p, *maxp;
    size_t len;
    ssize_t ret;
    int c;
 
    if (logfile_prefix->string[0]) {
        p = strchr(logfile_prefix->string, '@');
        if (p) {
            // expand it in place, hacky
            switch (type) {
            case PRINT_TALK:      *p = 'T'; break;
            case PRINT_DEVELOPER: *p = 'D'; break;
            case PRINT_WARNING:   *p = 'W'; break;
            case PRINT_ERROR:     *p = 'E'; break;
            case PRINT_NOTICE:    *p = 'N'; break;
            default:              *p = 'A'; break;
            }
        }
        len = format_local_time(buf, sizeof(buf), logfile_prefix->string);
        if (p) {
            *p = '@';
        }
    } else {
        len = 0;
    }
 
    p = text;
    maxp = text + sizeof(text) - 1;
    while (*s) {
        if (com_logNewline) {
            if (len > 0 && p + len < maxp) {
                memcpy(p, buf, len);
                p += len;
            }
            com_logNewline = qfalse;
        }
 
        if (p == maxp) {
            break;
        }
 
        c = *s++;
        if (c == '\n') {
            com_logNewline = qtrue;
        } else {
            c = Q_charascii(c);
        }
 
        *p++ = c;
    }
    *p = 0;
 
    len = p - text;
    ret = FS_Write(text, len, com_logFile);
    if (ret != len) {
        // zero handle BEFORE doing anything else to avoid recursion
        qhandle_t tmp = com_logFile;
        com_logFile = 0;
        FS_FCloseFile(tmp);
        Com_EPrintf("Couldn't write console log: %s\n", Q_ErrorString(ret));
        Cvar_Set("logfile", "0");
    }
}

Referenced by Com_LPrintf().

Qcommon_Frame()

void Qcommon_Frame

(

void

)

Definition at line 1078 of file common.c.

{
#if USE_CLIENT
    unsigned time_before, time_event, time_between, time_after;
    unsigned clientrem;
#endif
    unsigned oldtime, msec;
    static unsigned remaining;
    static float frac;
 
    if (setjmp(com_abortframe)) {
        return;            // an ERR_DROP was thrown
    }
 
#if USE_CLIENT
    time_before = time_event = time_between = time_after = 0;
 
    if (host_speeds->integer)
        time_before = Sys_Milliseconds();
#endif
 
    // sleep on network sockets when running a dedicated server
    // still do a select(), but don't sleep when running a client!
    NET_Sleep(remaining);
 
    // calculate time spent running last frame and sleeping
    oldtime = com_eventTime;
    com_eventTime = Sys_Milliseconds();
    if (oldtime > com_eventTime) {
        oldtime = com_eventTime;
    }
    msec = com_eventTime - oldtime;
 
#if USE_CLIENT
    // spin until msec is non-zero if running a client
    if (!dedicated->integer && !com_timedemo->integer) {
        while (msec < 1) {
            qboolean break_now = CL_ProcessEvents();
            com_eventTime = Sys_Milliseconds();
            msec = com_eventTime - oldtime;
            if (break_now)
                break;
        }
    }
#endif
 
    if (msec > 250) {
        Com_DPrintf("Hitch warning: %u msec frame time\n", msec);
        msec = 100; // time was unreasonable,
        // host OS was hibernated or something
    }
 
    if (fixedtime->integer) {
        Cvar_ClampInteger(fixedtime, 1, 1000);
        msec = fixedtime->integer;
    } else if (timescale->value > 0) {
        frac += msec * timescale->value;
        msec = frac;
        frac -= msec;
    }
 
    // run local time
    com_localTime += msec;
    com_framenum++;
 
#if USE_CLIENT
    if (host_speeds->integer)
        time_event = Sys_Milliseconds();
#endif
 
    // run system console
    Sys_RunConsole();
 
    NET_UpdateStats();
 
    remaining = SV_Frame(msec);
 
#if USE_CLIENT
    if (host_speeds->integer)
        time_between = Sys_Milliseconds();
 
    clientrem = CL_Frame(msec);
    if (remaining > clientrem) {
        remaining = clientrem;
    }
 
    if (host_speeds->integer)
        time_after = Sys_Milliseconds();
 
    if (host_speeds->integer) {
        int all, ev, sv, gm, cl, rf;
 
        all = time_after - time_before;
        ev = time_event - time_before;
        sv = time_between - time_event;
        cl = time_after - time_between;
        gm = time_after_game - time_before_game;
        rf = time_after_ref - time_before_ref;
        sv -= gm;
        cl -= rf;
 
        Com_Printf("all:%3i ev:%3i sv:%3i gm:%3i cl:%3i rf:%3i\n",
                   all, ev, sv, gm, cl, rf);
    }
#endif
}

Referenced by Sys_Main().

Qcommon_Init()

void Qcommon_Init	(	int	argc,
		char **	argv
	)

Definition at line 893 of file common.c.

{
    if (setjmp(com_abortframe))
        Sys_Error("Error during initialization: %s", com_errorMsg);
 
    com_argc = argc;
    com_argv = argv;
 
    Com_SetLastError(NULL);
 
    X86_SetFPCW();
 
    srand(time(NULL));
 
    // prepare enough of the subsystems to handle
    // cvar and command buffer management
    Z_Init();
    MSG_Init();
    Cbuf_Init();
    Cmd_Init();
    Cvar_Init();
    Key_Init();
    Prompt_Init();
    Con_Init();
 
    //
    // init commands and vars
    //
    z_perturb = Cvar_Get("z_perturb", "0", 0);
#if USE_CLIENT
    host_speeds = Cvar_Get("host_speeds", "0", 0);
#endif
#ifdef _DEBUG
    developer = Cvar_Get("developer", "0", 0);
#endif
    timescale = Cvar_Get("timescale", "1", CVAR_CHEAT);
    fixedtime = Cvar_Get("fixedtime", "0", CVAR_CHEAT);
    logfile_enable = Cvar_Get("logfile", "1", 0);
    logfile_flush = Cvar_Get("logfile_flush", "1", 0);
    logfile_name = Cvar_Get("logfile_name", "console", 0);
    logfile_prefix = Cvar_Get("logfile_prefix", "[%Y-%m-%d %H:%M] ", 0);
#if USE_CLIENT
    dedicated = Cvar_Get("dedicated", "0", CVAR_NOSET);
    backdoor = Cvar_Get("backdoor", "0", CVAR_ARCHIVE);
    cl_running = Cvar_Get("cl_running", "0", CVAR_ROM);
    cl_paused = Cvar_Get("cl_paused", "0", CVAR_ROM);
#else
    dedicated = Cvar_Get("dedicated", "1", CVAR_ROM);
#endif
    sv_running = Cvar_Get("sv_running", "0", CVAR_ROM);
    sv_paused = Cvar_Get("sv_paused", "0", CVAR_ROM);
    com_timedemo = Cvar_Get("timedemo", "0", CVAR_CHEAT);
    com_date_format = Cvar_Get("com_date_format", "%Y-%m-%d", 0);
#ifdef _WIN32
    com_time_format = Cvar_Get("com_time_format", "%H.%M", 0);
#else
    com_time_format = Cvar_Get("com_time_format", "%H:%M", 0);
#endif
#ifdef _DEBUG
    com_debug_break = Cvar_Get("com_debug_break", "0", 0);
#endif
    com_fatal_error = Cvar_Get("com_fatal_error", "0", 0);
    com_version = Cvar_Get("version", com_version_string, CVAR_SERVERINFO | CVAR_USERINFO | CVAR_ROM);
 
    allow_download = Cvar_Get("allow_download", COM_DEDICATED ? "0" : "1", CVAR_ARCHIVE);
    allow_download_players = Cvar_Get("allow_download_players", "1", CVAR_ARCHIVE);
    allow_download_models = Cvar_Get("allow_download_models", "1", CVAR_ARCHIVE);
    allow_download_sounds = Cvar_Get("allow_download_sounds", "1", CVAR_ARCHIVE);
    allow_download_maps = Cvar_Get("allow_download_maps", "1", CVAR_ARCHIVE);
    allow_download_textures = Cvar_Get("allow_download_textures", "1", CVAR_ARCHIVE);
    allow_download_pics = Cvar_Get("allow_download_pics", "1", CVAR_ARCHIVE);
    allow_download_others = Cvar_Get("allow_download_others", "0", 0);
 
    rcon_password = Cvar_Get("rcon_password", "", CVAR_ARCHIVE);
 
    Cmd_AddCommand("z_stats", Z_Stats_f);
 
    //Cmd_AddCommand("setenv", Com_Setenv_f);
 
    Cmd_AddMacro("com_date", Com_Date_m);
    Cmd_AddMacro("com_time", Com_Time_m);
    Cmd_AddMacro("com_uptime", Com_Uptime_m);
    Cmd_AddMacro("com_uptime_long", Com_UptimeLong_m);
    Cmd_AddMacro("random", Com_Random_m);
    Cmd_AddMacro("com_maplist", Com_MapList_m);
 
    // add any system-wide configuration files
    Sys_AddDefaultConfig();
 
    // we need to add the early commands twice, because
    // a basedir or cddir needs to be set before execing
    // config files, but we want other parms to override
    // the settings of the config files
    Com_AddEarlyCommands(qfalse);
 
    Sys_Init();
 
    Sys_RunConsole();
 
    FS_Init();
 
    Sys_RunConsole();
 
    // no longer allow CVAR_NOSET modifications
    com_initialized = qtrue;
 
    // after FS is initialized, open logfile
    logfile_enable->changed = logfile_enable_changed;
    logfile_flush->changed = logfile_param_changed;
    logfile_name->changed = logfile_param_changed;
    logfile_enable_changed(logfile_enable);
 
    // execute configs: default.cfg and q2rtx.cfg may come from the packfile, but config.cfg
    // and autoexec.cfg must be real files within the game directory
    Com_AddConfigFile(COM_DEFAULT_CFG, 0);
    Com_AddConfigFile(COM_Q2RTX_CFG, 0);
    Com_AddConfigFile(COM_CONFIG_CFG, FS_TYPE_REAL | FS_PATH_GAME);
    Com_AddConfigFile(COM_AUTOEXEC_CFG, FS_TYPE_REAL | FS_PATH_GAME);
    Com_AddConfigFile(COM_POSTEXEC_CFG, FS_TYPE_REAL);
 
    Com_AddEarlyCommands(qtrue);
 
    Cmd_AddCommand("lasterror", Com_LastError_f);
 
    Cmd_AddCommand("quit", Com_Quit_f);
#if !USE_CLIENT
    Cmd_AddCommand("recycle", Com_Recycle_f);
#endif
 
    Netchan_Init();
    NET_Init();
    BSP_Init();
    CM_Init();
    SV_Init();
    CL_Init();
    TST_Init();
 
    Sys_RunConsole();
 
    // add + commands from command line
    if (!Com_AddLateCommands()) {
        // if the user didn't give any commands, run default action
        char *cmd = COM_DEDICATED ? "dedicated_start" : "client_start";
 
        if ((cmd = Cmd_AliasCommand(cmd)) != NULL) {
            Cbuf_AddText(&cmd_buffer, cmd);
            Cbuf_Execute(&cmd_buffer);
        }
    } else {
        // the user asked for something explicit
        // so drop the loading plaque
        SCR_EndLoadingPlaque();
    }
 
    // even not given a starting map, dedicated server starts
    // listening for rcon commands (create socket after all configs
    // are executed to make sure port number is properly set)
    if (COM_DEDICATED || backdoor->integer) {
        NET_Config(NET_SERVER);
    }
 
    Com_AddConfigFile(COM_POSTINIT_CFG, FS_TYPE_REAL);
 
    Com_Printf("====== " PRODUCT " initialized ======\n\n");
    Com_LPrintf(PRINT_NOTICE, APPLICATION " " VERSION_STRING ", " __DATE__ "\n");
 
    if (fs_shareware->integer)
    {
        char* newgame = Cmd_AliasCommand("newgame");
        if (!strstr(newgame, "demo1"))
        {
            Com_WPrintf("\nWARNING: It looks like you have mixed game data files (.pak) from the shareware demo and the full game. The game might not function properly.\n\n");
        }
    }
 
    time(&com_startTime);
 
    com_eventTime = Sys_Milliseconds();
}

Referenced by Sys_Main().

Variable Documentation

allow_download

cvar_t* allow_download

Definition at line 105 of file common.c.

Referenced by CL_Download_f(), CL_InitLocal(), CL_RequestNextDownload(), HTTP_SetServer(), Qcommon_Init(), and SV_BeginDownload_f().

allow_download_maps

cvar_t* allow_download_maps

Definition at line 109 of file common.c.

Referenced by CL_RequestNextDownload(), Qcommon_Init(), and SV_BeginDownload_f().

allow_download_models

cvar_t* allow_download_models

Definition at line 107 of file common.c.

Referenced by CL_RequestNextDownload(), Qcommon_Init(), and SV_BeginDownload_f().

allow_download_others

cvar_t* allow_download_others

Definition at line 112 of file common.c.

Referenced by Qcommon_Init(), and SV_BeginDownload_f().

allow_download_pics

cvar_t* allow_download_pics

Definition at line 111 of file common.c.

Referenced by CL_RequestNextDownload(), Qcommon_Init(), and SV_BeginDownload_f().

allow_download_players

cvar_t* allow_download_players

Definition at line 106 of file common.c.

Referenced by CL_RequestNextDownload(), Qcommon_Init(), and SV_BeginDownload_f().

allow_download_sounds

cvar_t* allow_download_sounds

Definition at line 108 of file common.c.

Referenced by CL_RequestNextDownload(), Qcommon_Init(), and SV_BeginDownload_f().

allow_download_textures

cvar_t* allow_download_textures

Definition at line 110 of file common.c.

Referenced by CL_RequestNextDownload(), Qcommon_Init(), and SV_BeginDownload_f().

backdoor

cvar_t* backdoor

Definition at line 83 of file common.c.

Referenced by Qcommon_Init().

com_abort_arg

void* com_abort_arg

static

Definition at line 62 of file common.c.

Referenced by Com_AbortFunc(), and Com_Error().

com_abort_func

void(* com_abort_func) (void *)

static

Definition at line 61 of file common.c.

Referenced by Com_AbortFunc(), and Com_Error().

com_abortframe

jmp_buf com_abortframe

static

Definition at line 59 of file common.c.

Referenced by Com_AbortFrame(), Com_Error(), Qcommon_Frame(), and Qcommon_Init().

com_argc

int com_argc

static

Definition at line 73 of file common.c.

Referenced by Com_AddEarlyCommands(), Com_AddLateCommands(), and Qcommon_Init().

com_argv

char** com_argv

static

Definition at line 72 of file common.c.

Referenced by Com_AddEarlyCommands(), Com_AddLateCommands(), and Qcommon_Init().

com_date_format

cvar_t* com_date_format

Definition at line 98 of file common.c.

Referenced by Com_Date_m(), and Qcommon_Init().

com_errorEntered

qboolean com_errorEntered

static

Definition at line 64 of file common.c.

Referenced by Com_Error(), and Com_LPrintf().

com_errorMsg

char com_errorMsg[MAXERRORMSG]

static

Definition at line 65 of file common.c.

Referenced by Com_Error(), Com_GetLastError(), Com_LastError_f(), Com_LPrintf(), Com_SetLastError(), and Qcommon_Init().

com_eventTime

unsigned com_eventTime

Definition at line 122 of file common.c.

Referenced by AddServer(), CL_KeyState(), Key_ClearStates(), KeyClear(), KeyDown(), NET_Init(), NET_UpdateStats(), PingSelected(), Qcommon_Frame(), Qcommon_Init(), SV_BuildClientFrame(), SV_SetLastFrame(), SVC_GetChallenge(), UI_ErrorEvent(), UI_Frame(), and UI_StatusEvent().

com_fatal_error

cvar_t* com_fatal_error

Definition at line 103 of file common.c.

Referenced by Com_Error(), and Qcommon_Init().

com_framenum

unsigned com_framenum

Definition at line 121 of file common.c.

Referenced by CL_SendUserinfo(), CL_UpdateUserinfo(), and Qcommon_Frame().

com_initialized

qboolean com_initialized

Definition at line 124 of file common.c.

Referenced by Cvar_ResetAll_f(), Cvar_SetByVar(), get_engine_cvar(), and Qcommon_Init().

com_localTime

unsigned com_localTime

Definition at line 123 of file common.c.

Referenced by CL_CheckTimeout(), CL_MeasureStats(), NetchanNew_Process(), NetchanNew_Setup(), NetchanNew_ShouldUpdate(), NetchanNew_Transmit(), NetchanNew_TransmitNextFragment(), NetchanOld_Process(), NetchanOld_Setup(), NetchanOld_ShouldUpdate(), NetchanOld_Transmit(), Qcommon_Frame(), and SV_SendAsyncPackets().

com_logFile

qhandle_t com_logFile

static

Definition at line 69 of file common.c.

Referenced by Com_Error(), Com_LPrintf(), logfile_close(), logfile_open(), and logfile_write().

com_logNewline

qboolean com_logNewline

static

Definition at line 70 of file common.c.

Referenced by logfile_open(), and logfile_write().

com_printEntered

int com_printEntered

static

Definition at line 67 of file common.c.

Referenced by Com_Error(), and Com_LPrintf().

com_startTime

time_t com_startTime

Definition at line 125 of file common.c.

Referenced by Com_Uptime_m(), Com_UptimeLong_m(), NET_Stats_f(), and Qcommon_Init().

com_time_format

cvar_t* com_time_format

Definition at line 99 of file common.c.

Referenced by Com_Time_m(), and Qcommon_Init().

com_timedemo

cvar_t* com_timedemo

Definition at line 97 of file common.c.

Referenced by check_paused(), CL_CheckForPause(), CL_CleanupDemos(), CL_DemoFrame(), CL_FirstDemoFrame(), CL_InitLocal(), CL_SetClientTime(), CL_UpdateFrameTimes(), Qcommon_Frame(), and Qcommon_Init().

com_version

cvar_t* com_version

Definition at line 84 of file common.c.

Referenced by AC_SendHello(), Qcommon_Init(), send_hello(), and start_download().

com_version_string

const char com_version_string[]

Initial value:

=
    APPLICATION " " VERSION_STRING " " __DATE__ " " BUILDSTRING " " CPUSTRING

Definition at line 118 of file common.c.

Referenced by Qcommon_Init().

dedicated

cvar_t* dedicated

Definition at line 82 of file common.c.

Referenced by AC_Connect(), BSP_Load(), check_paused(), CL_Init(), Cmd_Say_f(), MVD_SetChannel(), NET_OpenServer(), Qcommon_Frame(), Qcommon_Init(), SV_Loadgame_f(), SV_Map(), SV_NoSaveGames(), SV_Savegame_f(), SV_SetMaster_f(), SV_SpawnServer(), SVC_RemoteCommand(), Sys_Init(), and Sys_Quit().

fixedtime

cvar_t* fixedtime

Definition at line 81 of file common.c.

Referenced by Qcommon_Frame(), and Qcommon_Init().

fs_shareware

cvar_t* fs_shareware

Definition at line 204 of file files.c.

Referenced by FS_Init(), and Qcommon_Init().

logfile_enable

cvar_t* logfile_enable

Definition at line 86 of file common.c.

Referenced by logfile_open(), logfile_param_changed(), and Qcommon_Init().

logfile_flush

cvar_t* logfile_flush

Definition at line 87 of file common.c.

Referenced by logfile_open(), and Qcommon_Init().

logfile_name

cvar_t* logfile_name

Definition at line 88 of file common.c.

Referenced by logfile_open(), and Qcommon_Init().

logfile_prefix

cvar_t* logfile_prefix

Definition at line 89 of file common.c.

Referenced by logfile_write(), and Qcommon_Init().

rcon_password

cvar_t* rcon_password

Definition at line 114 of file common.c.

Referenced by CL_Rcon_f(), Qcommon_Init(), and rcon_valid().

rd_buffer

char* rd_buffer

static

Definition at line 146 of file common.c.

Referenced by Com_AbortRedirect(), Com_BeginRedirect(), Com_EndRedirect(), and Com_Redirect().

rd_buffersize

size_t rd_buffersize

static

Definition at line 147 of file common.c.

Referenced by Com_AbortRedirect(), Com_BeginRedirect(), Com_EndRedirect(), and Com_Redirect().

rd_flush

rdflush_t rd_flush

static

Definition at line 149 of file common.c.

Referenced by Com_AbortRedirect(), Com_BeginRedirect(), Com_EndRedirect(), and Com_Redirect().

rd_length

size_t rd_length

static

Definition at line 148 of file common.c.

Referenced by Com_AbortRedirect(), Com_BeginRedirect(), Com_EndRedirect(), and Com_Redirect().

rd_target

int rd_target

static

Definition at line 145 of file common.c.

Referenced by Com_AbortRedirect(), Com_BeginRedirect(), Com_EndRedirect(), Com_LPrintf(), Com_Redirect(), and Com_SetColor().

sv_paused

cvar_t* sv_paused

Definition at line 96 of file common.c.

Referenced by AL_AddLoopSounds(), check_paused(), CL_CheckForPause(), CL_CheckPredictionError(), CL_FinalizeCmd(), CL_Frame(), CL_PredictMovement(), CL_SendCmd(), CL_UpdateCmd(), is_accumulation_rendering_active(), Qcommon_Init(), R_InterceptKey_RTX(), SCR_DrawDemo(), SCR_DrawPause(), and vkpt_freecam_update().

sv_running

cvar_t* sv_running

Definition at line 95 of file common.c.

Referenced by CL_CheatsOK(), CL_CheckForResend(), CL_ParseServerData(), CL_Pause_f(), CL_Seek_f(), Cvar_SetByVar(), MVD_Spawn(), Qcommon_Init(), SCR_DrawDemo(), and SV_SpawnServer().

timescale

cvar_t* timescale

Definition at line 80 of file common.c.

Referenced by Qcommon_Frame(), and Qcommon_Init().

z_perturb

cvar_t* z_perturb

Definition at line 75 of file common.c.

Referenced by Qcommon_Init(), and Z_TagMalloc().