console.h File Reference

#include <stddef.h>
#include "qtypes.h"
#include "cmd.h"
#include "lhnet.h"

Include dependency graph for console.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	con_lineinfo_t
struct	conbuffer_t

Functions
void	Con_CenterPrint (const char *str)
	Prints a center-aligned message to the console.
void	Con_CenterPrintf (int maxLineLength, const char *fmt,...) DP_FUNC_PRINTF(2)
	Left-pad a string with spaces to make it appear centered.
void	Con_CheckResize (void)
	If the line width has changed, reformat the buffer.
void	Con_Clear_f (cmd_state_t *cmd)
void	Con_ClearNotify (void)
	Clear all notify lines.
int	Con_CompleteCommandLine (cmd_state_t *cmd, qbool is_console)
	wrapper function to attempt to either complete the command line or to list possible matches grouped by type (i.e.
void	Con_DisplayList (const char **list)
	Generic libs/util/console.c function to display a list formatted in columns on the console.
void	Con_DPrint (const char *msg)
	A Con_Print that only shows up if the "developer" cvar is set.
void	Con_DPrintf (const char *fmt,...) DP_FUNC_PRINTF(1)
	A Con_Printf that only shows up if the "developer" cvar is set.
void	Con_DrawConsole (int lines, qbool forcedfullscreen)
void	Con_DrawNotify (void)
void	Con_Init (void)
void	Con_Init_Commands (void)
void	Con_MaskPrint (unsigned additionalmask, const char *msg)
	Prints to a chosen console target.
void	Con_MaskPrintf (unsigned mask, const char *fmt,...) DP_FUNC_PRINTF(2)
void	Con_Print (const char *txt)
	Prints to all appropriate console targets, and adds timestamps.
void	Con_Printf (const char *fmt,...) DP_FUNC_PRINTF(1)
	Prints to all appropriate console targets.
const char *	Con_Quakebar (int len, char *bar, size_t bufsize)
	Returns a horizontal line.
void	Con_Rcon_Redirect_Abort (void)
void	Con_Rcon_Redirect_End (void)
void	Con_Rcon_Redirect_Init (lhnetsocket_t *sock, lhnetaddress_t *dest, qbool proquakeprotocol)
void	Con_Shutdown (void)
void	Con_ToggleConsole_f (cmd_state_t *cmd)
qbool	GetMapList (const char *s, char *completedname, int completednamebufferlength)

Variables
int	con_backscroll
qbool	con_initialized
int	con_totallines

log
#define	CON_ERROR   "^1"
#define	CON_MASK_CHAT   1
#define	CON_MASK_DEVELOPER   4
#define	CON_MASK_HIDENOTIFY   128
#define	CON_MASK_INPUT   2
#define	CON_MASK_PRINT   8
#define	CON_WARN   "^3"
void	ConBuffer_AddLine (conbuffer_t *buf, const char *line, int len, unsigned mask)
	Appends a given string as a new line to the console.
void	ConBuffer_Clear (conbuffer_t *buf)
void	ConBuffer_DeleteLastLine (conbuffer_t *buf)
	Deletes the last line from the console history.
void	ConBuffer_DeleteLine (conbuffer_t *buf)
	Deletes the first line from the console history.
int	ConBuffer_FindNextLine (conbuffer_t *buf, unsigned mask_must, unsigned mask_mustnot, int start)
int	ConBuffer_FindPrevLine (conbuffer_t *buf, unsigned mask_must, unsigned mask_mustnot, int start)
void	ConBuffer_FixTimes (conbuffer_t *buf)
const char *	ConBuffer_GetLine (conbuffer_t *buf, int i)
void	ConBuffer_Init (conbuffer_t *buf, int textsize, int maxlines, mempool_t *mempool)
#define	CONBUFFER_LINES(buf, i)
#define	CONBUFFER_LINES_COUNT(buf)
#define	CONBUFFER_LINES_LAST(buf)
void	ConBuffer_Shutdown (conbuffer_t *buf)
void	Log_Close (void)
void	Log_DestBuffer_Flush (void)
	call this once per frame to send out replies to rcon streaming clients
void	Log_Init (void)
void	Log_Printf (const char *logfilename, const char *fmt,...) DP_FUNC_PRINTF(2)
void	Log_Start (void)

Macro Definition Documentation

CON_ERROR

#define CON_ERROR   "^1"

Definition at line 102 of file console.h.

Referenced by CL_EstablishConnection(), CL_OpenVideo(), CL_ParseServerInfo(), CL_PlayDemo(), CL_Record_f(), CL_VM_Init(), Cmd_GetCvarValue(), Con_ConDump_f(), Crypto_KeyGen_Finished(), Curl_Select(), Font_GetKerningForMap(), Font_LoadFile(), Font_LoadFont(), Font_LoadMap(), Font_LoadSize(), Font_SearchSize(), font_start(), FS_AddPack_Fullpath(), FS_GameDir_f(), FS_SetGameDirs(), FS_SysOpenFiledesc(), GL_DebugOutputCallback(), hmac_mdfour_challenge_matching(), hmac_mdfour_time_matching(), Host_Error(), Host_SaveConfig(), Key_History_Shutdown(), LHNET_OpenSocket_Connectionless(), LibAV_LoadLibrary(), libavw_decodeframe(), libavw_message(), LibAvW_OpenLibrary(), loadimagepixelsbgra(), LoadSky_f(), Mod_IDS2_Load(), Mod_LoadModel(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLightGrid(), MVM_error_cmd(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_Init(), NetConn_OpenClientPort(), NetConn_OpenServerPort(), OpenStream(), plaintext_matching(), PNG_error_fn(), R_GLSL_DumpShader_f(), R_Mesh_CreateFramebufferObject(), RCon_Execute(), S_LoadSound(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_ScreenShot_f(), SndSys_Init(), SV_Impact(), SV_Loadgame_f(), SV_Savegame_f(), SV_Savegame_to(), SV_SpawnServer(), SV_StartDemoRecording(), Sys_Error(), Sys_SDL_HandleEvents(), VID_ApplyDisplayMode(), VID_EnableJoystick(), VID_Init(), VID_InitModeGL(), VID_Restart_f(), VID_SetVsync_c(), VM_CL_effect(), VM_error(), VM_objerror(), and W_LoadTextureWadFile().

CON_MASK_CHAT

#define CON_MASK_CHAT   1

Definition at line 107 of file console.h.

Referenced by Con_ClearNotify(), Con_DrawNotify(), Con_DrawNotifyRect(), and Con_MaskPrint().

CON_MASK_DEVELOPER

#define CON_MASK_DEVELOPER   4

Definition at line 109 of file console.h.

Referenced by Con_DPrint(), Con_DPrintf(), Con_DrawConsole(), Con_DrawNotify(), and Con_MaskPrint().

CON_MASK_HIDENOTIFY

#define CON_MASK_HIDENOTIFY   128

Definition at line 106 of file console.h.

Referenced by Con_CenterPrint(), Con_CenterPrintf(), Con_ClearNotify(), and Con_DrawNotify().

CON_MASK_INPUT

#define CON_MASK_INPUT   2

Definition at line 108 of file console.h.

Referenced by Con_DrawNotify().

CON_MASK_PRINT

#define CON_MASK_PRINT   8

Definition at line 110 of file console.h.

Referenced by Con_Print(), and Con_Printf().

CON_WARN

#define CON_WARN   "^3"

Definition at line 101 of file console.h.

Referenced by alert_legacy_font_api(), Cbuf_AddText(), Cbuf_Execute(), Cbuf_InsertText(), CL_Locs_Save_f(), CL_Reconnect_f(), CL_VM_Init(), Cmd_AddCommand(), Cmd_Alias_f(), Cmd_Callback(), Cmd_CheckParm(), Cmd_CL_Callback(), Cmd_Exec(), Cmd_Exec_f(), Cmd_ExecuteString(), Cmd_GetCvarValue(), Cmd_SV_Callback(), Cmd_Toggle_f(), Cmd_TokenizeString(), Con_CenterPrintf(), Cvar_Callback(), Cvar_Delete(), Cvar_Get(), Cvar_Readonly(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), Cvar_Set(), Cvar_SetQuick(), dp__strlcpy(), dp_stpecpy(), dp_ustr2stp(), EntityFrameQW_CL_ReadFrame(), Font_LoadFile(), Font_LoadMap(), FS_OpenPackedFile(), FS_SetGameDirs(), FS_Write(), GL_DebugOutputCallback(), Host_LockSession(), libavw_message(), LoadFont_f(), LoadSubtitles(), Mem_PrintStats(), Mod_BSP_RecursiveNodePortals(), Mod_BuildVBOs(), Mod_Mesh_Validate(), Mod_Q1BSP_Load(), Mod_Q2BSP_Load(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLightGrid(), Mod_ShadowMesh_AddMesh(), Mod_VBSP_LoadTextures(), NetConn_ClientParsePacket(), Palette_Load(), PNG_warning_fn(), PRVM_Prog_Load(), R_Mesh_Draw(), R_Mesh_Start(), R_Mesh_VertexPointer(), SCR_CaptureVideo_RIFF_Pop(), SV_Frame(), SV_Loadgame_f(), SV_Savegame_f(), SV_SpawnServer(), SV_UnstickEntity(), Sys_SDL_HandleEvents(), Sys_UpdateTime(), VID_ApplyDisplayMode(), VID_Start(), and VM_Warning().

CONBUFFER_LINES

#define CONBUFFER_LINES	(		buf,
			i )

Value:

(buf)->lines[((buf)->lines_first + (i)) % (buf)->maxlines]

Definition at line 136 of file console.h.

Referenced by ConBuffer_FindPrevLine(), ConBuffer_FixTimes(), and ConBuffer_GetLine().

CONBUFFER_LINES_COUNT

#define CONBUFFER_LINES_COUNT

(

buf

)

Value:

((buf)->lines_count)

Definition at line 137 of file console.h.

Referenced by Key_History_Down(), Key_History_f(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Last(), Key_History_Shutdown(), and Key_History_Up().

CONBUFFER_LINES_LAST

#define CONBUFFER_LINES_LAST

(

buf

)

Value:

CONBUFFER_LINES(buf, CONBUFFER_LINES_COUNT(buf) - 1)

Definition at line 138 of file console.h.

Referenced by ConBuffer_AddLine(), ConBuffer_BytesLeft(), and ConBuffer_FixTimes().

Function Documentation

Con_CenterPrint()

void Con_CenterPrint

(

const char *

str

)

Prints a center-aligned message to the console.

Note

Authored by johnfitz

Parameters

[in]

str

A multiline string to print

Definition at line 1655 of file console.c.

{
    char bar[42];
 
    Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%s", Con_Quakebar(40, bar, sizeof(bar)));
    Con_CenterPrintf(40, "%s\n", str);
    Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%s", bar);
}

References Con_CenterPrintf(), CON_MASK_HIDENOTIFY, Con_MaskPrintf(), and Con_Quakebar().

Referenced by SCR_CenterPrint().

Con_CenterPrintf()

void Con_CenterPrintf	(	int	maxLineLength,
		const char *	fmt,
			... )

Left-pad a string with spaces to make it appear centered.

Note

Authored by johnfitz

Parameters

[in]	maxLineLength	Center-align
[in]	fmt	A printf format string
[in]	<unnamed>	Zero or more values used by fmt

Definition at line 1600 of file console.c.

{
    va_list argptr;
    char    msg[MAX_INPUTLINE];  // the original message
    char    spaces[21];          // buffer for spaces
    char   *msgCursor, *lineEnding;
    int     lineLength, msgLength;
    size_t  indentSize;
 
    va_start(argptr, fmt);
    msgLength = dpvsnprintf(msg, sizeof (msg), fmt, argptr);
    va_end(argptr);
 
    if (msgLength < 0)
    {
        Con_Printf(CON_WARN "The message given to Con_CenterPrintf was too long\n");
        return;
    }
 
    maxLineLength = min(maxLineLength, con_linewidth);
 
    for (msgCursor = msg; *msgCursor;)
    {
        lineEnding = strchr(msgCursor, '\n');
        if (lineEnding)
        {
            lineLength = lineEnding - msgCursor;  // print just the line
            lineEnding++;  // set cursor to next character after new line
        }
        else // last line
        {
            lineLength = msgLength;  // print entire message
            lineEnding = msgCursor + lineLength;  // set next line cursor to terminator
        }
 
        if (lineLength < maxLineLength)
        {
            indentSize = min(sizeof(spaces) - 1, (size_t)(maxLineLength - lineLength) / 2);
            memset(spaces, ' ', indentSize);
            spaces[indentSize] = 0;
            Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%s%.*s\n", spaces, lineLength, msgCursor);
        }
        else
            Con_MaskPrintf(CON_MASK_HIDENOTIFY, "%.*s\n", lineLength, msgCursor);
        msgLength -= lineEnding - msgCursor;  // Consume all characters until end of line
        msgCursor = lineEnding;  // Update message cursor
    }
}

References con_linewidth, CON_MASK_HIDENOTIFY, Con_MaskPrintf(), Con_Printf(), CON_WARN, dpvsnprintf(), MAX_INPUTLINE, and min.

Referenced by Con_CenterPrint().

Con_CheckResize()

void Con_CheckResize

(

void

)

If the line width has changed, reformat the buffer.

Definition at line 763 of file console.c.

{
    int i, width;
    float f;
 
    f = bound(1, con_textsize.value, 128);
    if(f != con_textsize.value)
        Cvar_SetValueQuick(&con_textsize, f);
    width = (int)floor(vid_conwidth.value / con_textsize.value);
    width = bound(1, width, con.textsize/4);
        // FIXME uses con in a non abstracted way
 
    if (width == con_linewidth)
        return;
 
    con_linewidth = width;
 
    for(i = 0; i < CON_LINES_COUNT; ++i)
        CON_LINES(i).height = -1; // recalculate when next needed
 
    Con_ClearNotify();
    con_backscroll = 0;
}

References bound, con, con_backscroll, Con_ClearNotify(), CON_LINES, CON_LINES_COUNT, con_linewidth, con_textsize, Cvar_SetValueQuick(), f, floor(), i, int(), conbuffer_t::textsize, cvar_t::value, vid_conwidth, and width.

Referenced by SCR_SetUpToDrawConsole().

Con_Clear_f()

void Con_Clear_f

(

cmd_state_t *

cmd

)

Definition at line 840 of file console.c.

{
    if (con_mutex) Thread_LockMutex(con_mutex);
    ConBuffer_Clear(&con);
    if (con_mutex) Thread_UnlockMutex(con_mutex);
}

References con, con_mutex, ConBuffer_Clear(), Thread_LockMutex, and Thread_UnlockMutex.

Referenced by Con_Init().

Con_ClearNotify()

void Con_ClearNotify

(

void

)

Clear all notify lines.

Definition at line 702 of file console.c.

{
    int i;
    for(i = 0; i < CON_LINES_COUNT; ++i)
        if(!(CON_LINES(i).mask & CON_MASK_CHAT))
            CON_LINES(i).mask |= CON_MASK_HIDENOTIFY;
}

References CON_LINES, CON_LINES_COUNT, CON_MASK_CHAT, CON_MASK_HIDENOTIFY, i, and mask.

Referenced by CL_SignonReply(), Con_CheckResize(), and Con_ToggleConsole_f().

Con_CompleteCommandLine()

int Con_CompleteCommandLine	(	cmd_state_t *	cmd,
		qbool	is_console )

wrapper function to attempt to either complete the command line or to list possible matches grouped by type (i.e.

will display possible variables, aliases, commands that match what they've typed so far)

Definition at line 2898 of file console.c.

{
    const char *text = "";
    char *s;
    const char **list[4] = {0, 0, 0, 0};
    char s2[512];
    char command[512];
    int c, v, a, i, cmd_len, pos, k;
    int n; // nicks --blub
    const char *space, *patterns;
    char vabuf[1024];
 
    char *line;
    int linestart, linepos;
    unsigned int linesize;
    if (is_console)
    {
        line = key_line;
        linepos = key_linepos;
        linesize = sizeof(key_line);
        linestart = 1;
    }
    else
    {
        line = chat_buffer;
        linepos = chat_bufferpos;
        linesize = sizeof(chat_buffer);
        linestart = 0;
    }
 
    //find what we want to complete
    pos = linepos;
    while(--pos >= linestart)
    {
        k = line[pos];
        if(k == '\"' || k == ';' || k == ' ' || k == '\'')
            break;
    }
    pos++;
 
    s = line + pos;
    dp_strlcpy(s2, line + linepos, sizeof(s2)); //save chars after cursor
    line[linepos] = 0; //hide them
 
    c = v = a = n = cmd_len = 0;
    if (!is_console)
        goto nicks;
 
    space = strchr(line + 1, ' ');
    if(space && pos == (space - line) + 1)
    {
        // adding 1 to line drops the leading ]
        dp_ustr2stp(command, sizeof(command), line + 1, space - (line + 1));
 
        patterns = Cvar_VariableString(cmd->cvars, va(vabuf, sizeof(vabuf), "con_completion_%s", command), CF_CLIENT | CF_SERVER); // TODO maybe use a better place for this?
        if(patterns && !*patterns)
            patterns = NULL; // get rid of the empty string
 
        if(!strcmp(command, "map") || !strcmp(command, "changelevel") || (patterns && !strcmp(patterns, "map")))
        {
            //maps search
            char t[MAX_QPATH];
            if (GetMapList(s, t, sizeof(t)))
            {
                // first move the cursor
                linepos += (int)strlen(t) - (int)strlen(s);
 
                // and now do the actual work
                *s = 0;
                dp_strlcat(line, t, MAX_INPUTLINE);
                dp_strlcat(line, s2, MAX_INPUTLINE); //add back chars after cursor
 
                // and fix the cursor
                if(linepos > (int) strlen(line))
                    linepos = (int) strlen(line);
            }
            return linepos;
        }
        else
        {
            if(patterns)
            {
                char t[MAX_QPATH];
                stringlist_t resultbuf, dirbuf;
 
                // Usage:
                //   // store completion patterns (space separated) for command foo in con_completion_foo
                //   set con_completion_foo "foodata/*.foodefault *.foo"
                //   foo <TAB>
                //
                // Note: patterns with slash are always treated as absolute
                // patterns; patterns without slash search in the innermost
                // directory the user specified. There is no way to "complete into"
                // a directory as of now, as directories seem to be unknown to the
                // FS subsystem.
                //
                // Examples:
                //   set con_completion_playermodel "models/player/*.zym models/player/*.md3 models/player/*.psk models/player/*.dpm"
                //   set con_completion_playdemo "*.dem"
                //   set con_completion_play "*.wav *.ogg"
                //
                // TODO somehow add support for directories; these shall complete
                // to their name + an appended slash.
 
                stringlistinit(&resultbuf);
                stringlistinit(&dirbuf);
                while(COM_ParseToken_Simple(&patterns, false, false, true))
                {
                    fssearch_t *search;
                    if(strchr(com_token, '/'))
                    {
                        search = FS_Search(com_token, true, true, NULL);
                    }
                    else
                    {
                        const char *slash = strrchr(s, '/');
                        if(slash)
                        {
                            dp_strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
                            dp_strlcat(t, com_token, sizeof(t));
                            search = FS_Search(t, true, true, NULL);
                        }
                        else
                            search = FS_Search(com_token, true, true, NULL);
                    }
                    if(search)
                    {
                        for(i = 0; i < search->numfilenames; ++i)
                            if(!strncmp(search->filenames[i], s, strlen(s)))
                                if(FS_FileType(search->filenames[i]) == FS_FILETYPE_FILE)
                                    stringlistappend(&resultbuf, search->filenames[i]);
                        FS_FreeSearch(search);
                    }
                }
 
                // In any case, add directory names
                {
                    fssearch_t *search;
                    const char *slash = strrchr(s, '/');
                    if(slash)
                    {
                        dp_strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
                        dp_strlcat(t, "*", sizeof(t));
                        search = FS_Search(t, true, true, NULL);
                    }
                    else
                        search = FS_Search("*", true, true, NULL);
                    if(search)
                    {
                        for(i = 0; i < search->numfilenames; ++i)
                            if(!strncmp(search->filenames[i], s, strlen(s)))
                                if(FS_FileType(search->filenames[i]) == FS_FILETYPE_DIRECTORY)
                                    stringlistappend(&dirbuf, search->filenames[i]);
                        FS_FreeSearch(search);
                    }
                }
 
                if(resultbuf.numstrings > 0 || dirbuf.numstrings > 0)
                {
                    const char *p, *q;
                    unsigned int matchchars;
                    if(resultbuf.numstrings == 0 && dirbuf.numstrings == 1)
                    {
                        dpsnprintf(t, sizeof(t), "%s/", dirbuf.strings[0]);
                    }
                    else
                    if(resultbuf.numstrings == 1 && dirbuf.numstrings == 0)
                    {
                        dpsnprintf(t, sizeof(t), "%s ", resultbuf.strings[0]);
                    }
                    else
                    {
                        stringlistsort(&resultbuf, true); // dirbuf is already sorted
                        Con_Printf("\n%i possible filenames\n", resultbuf.numstrings + dirbuf.numstrings);
                        for(i = 0; i < dirbuf.numstrings; ++i)
                        {
                            Con_Printf("^4%s^7/\n", dirbuf.strings[i]);
                        }
                        for(i = 0; i < resultbuf.numstrings; ++i)
                        {
                            Con_Printf("%s\n", resultbuf.strings[i]);
                        }
                        matchchars = sizeof(t) - 1;
                        if(resultbuf.numstrings > 0)
                        {
                            p = resultbuf.strings[0];
                            q = resultbuf.strings[resultbuf.numstrings - 1];
                            for(; *p && *p == *q; ++p, ++q);
                            matchchars = (unsigned int)(p - resultbuf.strings[0]);
                        }
                        if(dirbuf.numstrings > 0)
                        {
                            p = dirbuf.strings[0];
                            q = dirbuf.strings[dirbuf.numstrings - 1];
                            for(; *p && *p == *q; ++p, ++q);
                            matchchars = min(matchchars, (unsigned int)(p - dirbuf.strings[0]));
                        }
                        // now p points to the first non-equal character, or to the end
                        // of resultbuf.strings[0]. We want to append the characters
                        // from resultbuf.strings[0] to (not including) p as these are
                        // the unique prefix
                        dp_strlcpy(t, (resultbuf.numstrings > 0 ? resultbuf : dirbuf).strings[0], min(matchchars + 1, sizeof(t)));
                    }
 
                    // first move the cursor
                    linepos += (int)strlen(t) - (int)strlen(s);
 
                    // and now do the actual work
                    *s = 0;
                    dp_strlcat(line, t, MAX_INPUTLINE);
                    dp_strlcat(line, s2, MAX_INPUTLINE); //add back chars after cursor
 
                    // and fix the cursor
                    if(linepos > (int) strlen(line))
                        linepos = (int) strlen(line);
                }
                stringlistfreecontents(&resultbuf);
                stringlistfreecontents(&dirbuf);
 
                return linepos; // bail out, when we complete for a command that wants a file name
            }
        }
    }
 
    // Count number of possible matches and print them
    c = Cmd_CompleteCountPossible(cmd, s);
    if (c)
    {
        Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
        Cmd_CompleteCommandPrint(cmd, s);
    }
    v = Cvar_CompleteCountPossible(cmd->cvars, s, CF_CLIENT | CF_SERVER);
    if (v)
    {
        Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
        Cvar_CompleteCvarPrint(cmd->cvars, s, CF_CLIENT | CF_SERVER);
    }
    a = Cmd_CompleteAliasCountPossible(cmd, s);
    if (a)
    {
        Con_Printf("\n%i possible alias%s\n", a, (a > 1) ? "es: " : ":");
        Cmd_CompleteAliasPrint(cmd, s);
    }
 
nicks:
    n = Nicks_CompleteCountPossible(line, linepos, s, is_console);
    if (n)
    {
        Con_Printf("\n%i possible nick%s\n", n, (n > 1) ? "s: " : ":");
        Cmd_CompleteNicksPrint(n);
    }
 
    if (!(c + v + a + n))   // No possible matches
    {
        if(s2[0])
            dp_strlcpy(&line[linepos], s2, linesize - linepos);
        return linepos;
    }
 
    if (c)
        text = *(list[0] = Cmd_CompleteBuildList(cmd, s));
    if (v)
        text = *(list[1] = Cvar_CompleteBuildList(cmd->cvars, s, cmd->cvars_flagsmask));
    if (a)
        text = *(list[2] = Cmd_CompleteAliasBuildList(cmd, s));
    if (n)
    {
        if (is_console)
            text = *(list[3] = Nicks_CompleteBuildList(n));
        else
            text = *(Nicks_CompleteBuildList(n));
    }
 
    for (cmd_len = (int)strlen(s);;cmd_len++)
    {
        const char **l;
        for (i = 0; i < 3; i++)
            if (list[i])
                for (l = list[i];*l;l++)
                    if ((*l)[cmd_len] != text[cmd_len])
                        goto done;
        // all possible matches share this character, so we continue...
        if (!text[cmd_len])
        {
            // if all matches ended at the same position, stop
            // (this means there is only one match)
            break;
        }
    }
done:
 
    // prevent a buffer overrun by limiting cmd_len according to remaining space
    cmd_len = min(cmd_len, (int)linesize - 1 - pos);
    if (text)
    {
        linepos = pos;
        memcpy(&line[linepos], text, cmd_len);
        linepos += cmd_len;
        // if there is only one match, add a space after it
        if (c + v + a + n == 1 && linepos < (int)linesize - 1)
        {
            if(n)
            { // was a nick, might have an offset, and needs colors ;) --blub
                linepos = pos - Nicks_offset[0];
                cmd_len = (int)strlen(Nicks_list[0]);
                cmd_len = min(cmd_len, (int)linesize - 3 - pos);
 
                memcpy(&line[linepos] , Nicks_list[0], cmd_len);
                linepos += cmd_len;
                if(linepos < (int)(linesize - 7)) // space for color code (^[0-9] or ^xrgb), space and \0
                    linepos = Nicks_AddLastColor(line, linepos);
            }
            line[linepos++] = ' ';
        }
    }
 
    // use strlcat to avoid a buffer overrun
    line[linepos] = 0;
    dp_strlcat(line, s2, linesize);
 
    if (!is_console)
        return linepos;
 
    // free the command, cvar, and alias lists
    for (i = 0; i < 4; i++)
        if (list[i])
            Mem_Free((void *)list[i]);
 
    return linepos;
}

References a, CF_CLIENT, CF_SERVER, chat_buffer, chat_bufferpos, cmd(), Cmd_CompleteAliasBuildList(), Cmd_CompleteAliasCountPossible(), Cmd_CompleteAliasPrint(), Cmd_CompleteBuildList(), Cmd_CompleteCommandPrint(), Cmd_CompleteCountPossible(), Cmd_CompleteNicksPrint(), COM_ParseToken_Simple(), com_token, Con_Printf(), Cvar_CompleteBuildList(), Cvar_CompleteCountPossible(), Cvar_CompleteCvarPrint(), Cvar_VariableString(), dp_strlcat, dp_strlcpy, dp_ustr2stp(), dpsnprintf(), fssearch_t::filenames, FS_FileType(), FS_FILETYPE_DIRECTORY, FS_FILETYPE_FILE, FS_FreeSearch(), FS_Search(), GetMapList(), i, int(), key_line, key_linepos, MAX_INPUTLINE, MAX_QPATH, Mem_Free, min, n, Nicks_AddLastColor(), Nicks_CompleteBuildList(), Nicks_CompleteCountPossible(), Nicks_list, Nicks_offset, NULL, fssearch_t::numfilenames, stringlist_t::numstrings, stringlistappend(), stringlistfreecontents(), stringlistinit(), stringlistsort(), stringlist_t::strings, strlen(), v, and va().

Referenced by Key_Parse_CommonKeys().

Con_DisplayList()

void Con_DisplayList

(

const char **

list

)

Generic libs/util/console.c function to display a list formatted in columns on the console.

Definition at line 2452 of file console.c.

{
    int i = 0, pos = 0, len = 0, maxlen = 0, width = (con_linewidth - 4);
    const char **walk = list;
 
    while (*walk) {
        len = (int)strlen(*walk);
        if (len > maxlen)
            maxlen = len;
        walk++;
    }
    maxlen += 1;
 
    while (*list) {
        len = (int)strlen(*list);
        if (pos + maxlen >= width) {
            Con_Print("\n");
            pos = 0;
        }
 
        Con_Print(*list);
        for (i = 0; i < (maxlen - len); i++)
            Con_Print(" ");
 
        pos += maxlen;
        list++;
    }
 
    if (pos)
        Con_Print("\n\n");
}

References con_linewidth, Con_Print(), i, int(), strlen(), and width.

Con_DPrint()

void Con_DPrint

(

const char *

msg

)

A Con_Print that only shows up if the "developer" cvar is set.

Definition at line 1531 of file console.c.

{
    if(developer.integer < 0) // at 0, we still add to the buffer but hide
        return;
 
    Con_MaskPrint(CON_MASK_DEVELOPER, msg);
}

References CON_MASK_DEVELOPER, Con_MaskPrint(), developer, and cvar_t::integer.

Referenced by CL_DisconnectEx(), CL_NewBeam(), CL_ParseServerInfo(), CL_SetSignonStage_WithMsg(), CL_VM_ShutDown(), Collision_NewBrushFromPlanes(), Cvar_Command(), Cvar_RestoreInitState(), Cvar_Set_f(), Cvar_SetA_f(), Font_LoadMap(), GL_CheckExtension(), GL_Setup(), Host_Init(), M_Menu_Main_f(), Mod_LoadQ3Shaders(), NetConn_ReceivedMessage(), Palette_Load(), PRVM_ED_CallSpawnFunction(), S_PaintAndSubmit(), SndSys_Init(), SV_Color_f(), SV_Prepare_CSQC(), SV_Spawn_f(), and VID_InitModeGL().

Con_DPrintf()

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

A Con_Printf that only shows up if the "developer" cvar is set.

Definition at line 1544 of file console.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    if(developer.integer < 0) // at 0, we still add to the buffer but hide
        return;
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    Con_MaskPrint(CON_MASK_DEVELOPER, msg);
}

References CON_MASK_DEVELOPER, Con_MaskPrint(), developer, dpvsnprintf(), cvar_t::integer, and MAX_INPUTLINE.

Referenced by _Mem_Alloc(), _Mem_Free(), _Mem_FreeBlock(), alert_legacy_font_api(), Buffer_Callback(), CDAudio_Play_byName(), CheckPendingDownloads(), CL_DisconnectEx(), CL_ExaminePrintString(), CL_IPLog_Add(), CL_LinkEdict(), CL_NetworkTimeReceived(), CL_NewParticlesFromEffectinfo(), CL_OpenVideo(), CL_ParseServerMessage(), CL_ParseStatic(), CL_ParticleEffect_Fallback(), CL_SignonReply(), CL_Startdemos_f(), CL_StopDownload(), CL_ValidateState(), CL_VM_Init(), CLVM_ExecuteProgram(), Cmd_AddCommand(), Cmd_RestoreInitState(), Collision_CalcPlanesForTriangleBrushFloat(), Collision_NewBrushFromPlanes(), Crypto_ServerError(), Crypto_SoftClientError(), Crypto_SoftServerError(), Curl_Begin(), Curl_CheckCommandWhenDone(), curl_default_callback(), Cvar_Get(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), Cvar_RestoreInitState(), Cvar_SetQuick(), Draw_CachePic_Flags(), Draw_Frame(), Draw_FreePic(), Draw_GetPicTexture(), Draw_IsPicLoaded(), Draw_NewPic(), EntityFrame5_WriteFrame(), EntityFrameCSQC_LostFrame(), EntityFrameQW_CL_ReadFrame(), EntityState5_Priority(), Font_LoadFile(), Font_LoadMap(), FS_FindFile(), FS_Init_Dir(), FS_LoadPackPAK(), FS_LoadPackPK3FromFD(), FS_LoadPackVirtual(), FS_OpenReadFile(), FS_UnloadPacks_dlcache(), FS_WriteFileInBlocks(), GetMapList(), GL_Backend_CompileProgram(), GL_CheckExtension(), GL_InitFunctions(), gl_main_start(), GL_Setup(), JPEG_SaveImage_to_Buffer(), Key_Event(), LHNET_OpenSocket_Connectionless(), LHNET_Read(), LHNET_Write(), LoadFont(), LoadFont_f(), loadimagepixelsbgra(), LoadSubtitles(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_LoadCustomMaterial(), Mod_LoadModel(), Mod_LoadQ3Shaders(), Mod_LoadQ3Shaders_EnumerateWaveFunc(), Mod_LoadTextureFromQ3Shader(), Mod_Mesh_Validate(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadBrushes(), Mod_Q3BSP_Load(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLightmaps(), NetConn_ClientParsePacket(), NetConn_ServerParsePacket(), PRVM_ED_LoadFromFile(), PRVM_ED_ParseEdict(), PRVM_ED_ParseEpair(), PRVM_ED_ParseGlobals(), PRVM_GarbageCollection(), PRVM_Init(), PRVM_MarkReferencedEdicts(), PRVM_Prog_Load(), PRVM_SetEngineString(), PRVM_SetTempString(), Q3Shader_AddToHash(), QW_CL_NextUpload_f(), QW_CL_ServerInfo(), QW_CL_StartUpload(), R_BuildFogTexture(), R_GLSL_CompilePermutation(), R_LoadCubemap(), R_LoadTextureDDSFile(), R_Mesh_Draw(), R_Mesh_VertexPointer(), R_Modules_Shutdown(), R_Modules_Start(), R_Q1BSP_CallRecursiveGetLightInfo(), R_RTLight_Compile(), R_SetupShader_SetPermutationGLSL(), R_UpdateTexture(), S_PaintAndSubmit(), S_PlaySfxOnChannel(), Sbar_DeathmatchOverlay(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_CaptureVideo_RIFF_Finish(), SCR_DrawInfobar(), SCR_PopLoadingScreen(), ShaderModeInfo_GetShaderText(), SV_ConnectClient(), SV_Download_f(), SV_DropClient(), SV_LinkEdict(), SV_Prepare_CSQC(), SV_ReadClientMessage(), SV_ReadClientMove(), SV_SendServerinfo(), SV_Shutdown(), SV_ThreadFunc(), SV_UnstickEntity(), SV_VM_Setup(), SVVM_ExecuteProgram(), Sys_LoadDependency(), Sys_LoadDependencyFunctions(), Sys_SDL_HandleEvents(), VID_ApplyDisplayMode(), VID_ApplyDisplayMode_c(), VID_EnableJoystick(), VID_ListModes(), VID_SetMouse(), VID_SetVsync_c(), VM_CL_gettagindex(), VM_CL_gettaginfo(), VM_CL_R_AddDynamicLight(), VM_CL_setattachment(), VM_dprint(), VM_fclose(), VM_fgets(), VM_fopen(), VM_fputs(), VM_FrameBlendFromFrameGroupBlend(), VM_SV_gettagindex(), VM_SV_gettaginfo(), VM_SV_setattachment(), VM_SV_sound(), and World_SetSize().

Con_DrawConsole()

void Con_DrawConsole	(	int	lines,
		qbool	forcedfullscreen )

Definition at line 2138 of file console.c.

{
    float alpha, alpha0;
    double sx, sy;
    int mask_must = 0;
    int mask_mustnot = (developer.integer>0) ? 0 : CON_MASK_DEVELOPER;
    cachepic_t *conbackpic;
    unsigned int conbackflags;
 
    if (lines <= 0)
        return;
 
    if (con_mutex) Thread_LockMutex(con_mutex);
 
    if (con_backscroll < 0)
        con_backscroll = 0;
 
    con_vislines = lines;
 
    r_draw2d_force = true;
 
// draw the background
    alpha0 = forcedfullscreen ? 1.0f : scr_conalpha.value; // always full alpha when not forced fullscreen
    if((alpha = alpha0 * scr_conalphafactor.value) > 0)
    {
        sx = scr_conscroll_x.value;
        sy = scr_conscroll_y.value;
        conbackflags = CACHEPICFLAG_FAILONMISSING; // So console is readable when game content is missing
        if (sx != 0 || sy != 0)
            conbackflags &= CACHEPICFLAG_NOCLAMP;
        conbackpic = scr_conbrightness.value >= 0.01f ? Draw_CachePic_Flags("gfx/conback", conbackflags) : NULL;
        sx *= host.realtime; sy *= host.realtime;
        sx -= floor(sx); sy -= floor(sy);
        if (Draw_IsPicLoaded(conbackpic))
            DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
                    0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0);
        else
            DrawQ_Fill(0, lines - vid_conheight.integer, vid_conwidth.integer, vid_conheight.integer, 0.0f, 0.0f, 0.0f, alpha, 0);
    }
    if((alpha = alpha0 * scr_conalpha2factor.value) > 0)
    {
        sx = scr_conscroll2_x.value;
        sy = scr_conscroll2_y.value;
        conbackpic = Draw_CachePic_Flags("gfx/conback2", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
        sx *= host.realtime; sy *= host.realtime;
        sx -= floor(sx); sy -= floor(sy);
        if(Draw_IsPicLoaded(conbackpic))
            DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
                    0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0);
    }
    if((alpha = alpha0 * scr_conalpha3factor.value) > 0)
    {
        sx = scr_conscroll3_x.value;
        sy = scr_conscroll3_y.value;
        conbackpic = Draw_CachePic_Flags("gfx/conback3", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
        sx *= host.realtime; sy *= host.realtime;
        sx -= floor(sx); sy -= floor(sy);
        if(Draw_IsPicLoaded(conbackpic))
            DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
                    0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
                    0);
    }
    DrawQ_String(vid_conwidth.integer - DrawQ_TextWidth(engineversion, 0, con_textsize.value, con_textsize.value, false, FONT_CONSOLE), lines - con_textsize.value, engineversion, 0, con_textsize.value, con_textsize.value, 1, 0, 0, 1, 0, NULL, true, FONT_CONSOLE);
 
// draw the text
#if 0
    {
        int i;
        int count = CON_LINES_COUNT;
        float ymax = con_vislines - 2 * con_textsize.value;
        float y = ymax + con_textsize.value * con_backscroll;
        for (i = 0;i < count && y >= 0;i++)
            y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y - con_textsize.value, CON_LINES_COUNT - 1 - i, 0, ymax) * con_textsize.value;
        // fix any excessive scrollback for the next frame
        if (i >= count && y >= 0)
        {
            con_backscroll -= (int)(y / con_textsize.value);
            if (con_backscroll < 0)
                con_backscroll = 0;
        }
    }
#else
    if(CON_LINES_COUNT > 0)
    {
        int i, last, limitlast;
        float y;
        float ymax = con_vislines - 2 * con_textsize.value;
        Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
        //Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
        y = ymax - con_textsize.value;
 
        if(limitlast)
            y += (CON_LINES(last).height - limitlast) * con_textsize.value;
        i = last;
 
        for(;;)
        {
            y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y, i, 0, ymax) * con_textsize.value;
            if(i == 0)
                break; // top of console buffer
            if(y < 0)
                break; // top of console window
            limitlast = 0;
            --i;
        }
    }
#endif
 
// draw the input prompt, user text, and cursor if desired
    Con_DrawInput(true, 0, con_vislines - con_textsize.value * 2, con_textsize.value);
 
    r_draw2d_force = false;
    if (con_mutex) Thread_UnlockMutex(con_mutex);
}

References alpha, CACHEPICFLAG_FAILONMISSING, CACHEPICFLAG_NOCLAMP, con_backscroll, Con_DrawConsoleLine(), Con_DrawInput(), Con_LastVisibleLine(), CON_LINES, CON_LINES_COUNT, CON_MASK_DEVELOPER, con_mutex, con_textsize, con_vislines, count, developer, Draw_CachePic_Flags(), Draw_IsPicLoaded(), DrawQ_Fill(), DrawQ_String(), DrawQ_SuperPic(), DrawQ_TextWidth(), engineversion, floor(), FONT_CONSOLE, host, i, int(), cvar_t::integer, NULL, r_draw2d_force, host_static_t::realtime, scr_conalpha, scr_conalpha2factor, scr_conalpha3factor, scr_conalphafactor, scr_conbrightness, scr_conscroll2_x, scr_conscroll2_y, scr_conscroll3_x, scr_conscroll3_y, scr_conscroll_x, scr_conscroll_y, Thread_LockMutex, Thread_UnlockMutex, cvar_t::value, vid_conheight, vid_conwidth, and y.

Referenced by SCR_DrawConsole().

Con_DrawNotify()

void Con_DrawNotify

(

void

)

Definition at line 1945 of file console.c.

{
    float x, v;
    float chatstart, notifystart, inputsize, height;
    float align;
    int numChatlines;
    int chatpos;
 
    if (con_mutex) Thread_LockMutex(con_mutex);
    ConBuffer_FixTimes(&con);
 
    numChatlines = con_chat.integer;
 
    chatpos = con_chatpos.integer;
 
    if (con_notify.integer < 0)
        Cvar_SetValueQuick(&con_notify, 0);
    if (gamemode == GAME_TRANSFUSION)
        v = 8; // vertical offset
    else
        v = 0;
 
    // GAME_NEXUIZ: center, otherwise left justify
    align = con_notifyalign.value;
    if(!*con_notifyalign.string) // empty string, evaluated to 0 above
    {
        if(IS_OLDNEXUIZ_DERIVED(gamemode))
            align = 0.5;
    }
 
    if(numChatlines || !con_chatrect.integer)
    {
        if(chatpos == 0)
        {
            // first chat, input line, then notify
            chatstart = v;
            notifystart = v + (numChatlines + 1) * con_chatsize.value;
        }
        else if(chatpos > 0)
        {
            // first notify, then (chatpos-1) empty lines, then chat, then input
            notifystart = v;
            chatstart = v + (con_notify.value + (chatpos - 1)) * con_notifysize.value;
        }
        else // if(chatpos < 0)
        {
            // first notify, then much space, then chat, then input, then -chatpos-1 empty lines
            notifystart = v;
            chatstart = vid_conheight.value - (-chatpos-1 + numChatlines + 1) * con_chatsize.value;
        }
    }
    else
    {
        // just notify and input
        notifystart = v;
        chatstart = 0; // shut off gcc warning
    }
 
    v = notifystart + con_notifysize.value * Con_DrawNotifyRect(0, CON_MASK_INPUT | CON_MASK_HIDENOTIFY | (numChatlines ? CON_MASK_CHAT : 0) | CON_MASK_DEVELOPER, con_notifytime.value, 0, notifystart, vid_conwidth.value, con_notify.value * con_notifysize.value, con_notifysize.value, align, 0.0, "");
 
    if(con_chatrect.integer)
    {
        x = con_chatrect_x.value * vid_conwidth.value;
        v = con_chatrect_y.value * vid_conheight.value;
    }
    else
    {
        x = 0;
        if(numChatlines) // only do this if chat area is enabled, or this would move the input line wrong
            v = chatstart;
    }
    height = numChatlines * con_chatsize.value;
 
    if(numChatlines)
    {
        Con_DrawNotifyRect(CON_MASK_CHAT, CON_MASK_INPUT, con_chattime.value, x, v, vid_conwidth.value * con_chatwidth.value, height, con_chatsize.value, 0.0, 1.0, "^3 ... ");
        v += height;
    }
    if (key_dest == key_message)
    {
        inputsize = (numChatlines ? con_chatsize : con_notifysize).value;
        Con_DrawInput(false, x, v, inputsize);
    }
    else
        chat_bufferpos = 0;
 
    if (con_mutex) Thread_UnlockMutex(con_mutex);
}

References chat_bufferpos, con, con_chat, con_chatpos, con_chatrect, con_chatrect_x, con_chatrect_y, con_chatsize, con_chattime, con_chatwidth, Con_DrawInput(), Con_DrawNotifyRect(), CON_MASK_CHAT, CON_MASK_DEVELOPER, CON_MASK_HIDENOTIFY, CON_MASK_INPUT, con_mutex, con_notify, con_notifyalign, con_notifysize, con_notifytime, ConBuffer_FixTimes(), Cvar_SetValueQuick(), GAME_TRANSFUSION, gamemode, height, cvar_t::integer, IS_OLDNEXUIZ_DERIVED, key_dest, key_message, cvar_t::string, Thread_LockMutex, Thread_UnlockMutex, v, cvar_t::value, value, vid_conheight, vid_conwidth, and x.

Referenced by SCR_DrawScreen().

Con_Init()

void Con_Init

(

void

)

Definition at line 861 of file console.c.

{
    con_linewidth = 80;
    ConBuffer_Init(&con, CON_TEXTSIZE, CON_MAXLINES, zonemempool);
    if (Thread_HasThreads())
        con_mutex = Thread_CreateMutex();
 
    // Allocate a log queue, this will be freed after configs are parsed
    logq_size = MAX_INPUTLINE;
    logqueue = (unsigned char *)Mem_Alloc (tempmempool, logq_size);
    logq_ind = 0;
 
    Cvar_RegisterVariable (&sys_colortranslation);
    Cvar_RegisterVariable (&sys_specialcharactertranslation);
#if defined(__linux__)
    // Linux terminals natively support RGB 8bpc codes or convert them to a palette.
    Cvar_SetQuick(&sys_colortranslation, "2");
#elif defined(WIN32)
    // Windows 10 default PowerShell and cmd.exe have no RGB or ANSI support by default.
    // TODO: it can be enabled on current versions using a platform-specific call,
    // issue: https://gitlab.com/xonotic/darkplaces/-/issues/426
    Cvar_SetQuick(&sys_colortranslation, "0");
#endif
 
    Cvar_RegisterVariable (&log_file);
    Cvar_RegisterVariable (&log_file_stripcolors);
    Cvar_RegisterVariable (&log_dest_udp);
 
    // support for the classic Quake option
// COMMANDLINEOPTION: Console: -condebug logs console messages to qconsole.log, see also log_file
    if (Sys_CheckParm ("-condebug") != 0)
        Cvar_SetQuick (&log_file, "qconsole.log");
 
    // register our cvars
    Cvar_RegisterVariable (&con_chat);
    Cvar_RegisterVariable (&con_chatpos);
    Cvar_RegisterVariable (&con_chatrect_x);
    Cvar_RegisterVariable (&con_chatrect_y);
    Cvar_RegisterVariable (&con_chatrect);
    Cvar_RegisterVariable (&con_chatsize);
    Cvar_RegisterVariable (&con_chattime);
    Cvar_RegisterVariable (&con_chatwidth);
    Cvar_RegisterVariable (&con_notify);
    Cvar_RegisterVariable (&con_notifyalign);
    Cvar_RegisterVariable (&con_notifysize);
    Cvar_RegisterVariable (&con_notifytime);
    Cvar_RegisterVariable (&con_textsize);
    Cvar_RegisterVariable (&con_chatsound);
    Cvar_RegisterVariable (&con_chatsound_file);
    Cvar_RegisterVariable (&con_chatsound_team_file);
    Cvar_RegisterVariable (&con_chatsound_team_mask);
 
    // --blub
    Cvar_RegisterVariable (&con_nickcompletion);
    Cvar_RegisterVariable (&con_nickcompletion_flags);
 
    Cvar_RegisterVariable (&con_completion_playdemo); // *.dem
    Cvar_RegisterVariable (&con_completion_timedemo); // *.dem
    Cvar_RegisterVariable (&con_completion_exec); // *.cfg
 
    Cvar_RegisterVariable (&condump_stripcolors);
 
    Cvar_RegisterVariable(&rcon_address);
    Cvar_RegisterVariable(&rcon_secure);
    Cvar_RegisterCallback(&rcon_secure, Con_RCon_ClearPassword_c);
    Cvar_RegisterVariable(&rcon_secure_challengetimeout);
    Cvar_RegisterVariable(&rcon_password);
 
    // register our commands
    Cmd_AddCommand(CF_CLIENT, "toggleconsole", Con_ToggleConsole_f, "opens or closes the console");
    Cmd_AddCommand(CF_CLIENT, "messagemode", Con_MessageMode_f, "input a chat message to say to everyone");
    Cmd_AddCommand(CF_CLIENT, "messagemode2", Con_MessageMode2_f, "input a chat message to say to only your team");
    Cmd_AddCommand(CF_CLIENT, "commandmode", Con_CommandMode_f, "input a console command");
    Cmd_AddCommand(CF_SHARED, "clear", Con_Clear_f, "clear console history");
    Cmd_AddCommand(CF_SHARED, "maps", Con_Maps_f, "list information about available maps");
    Cmd_AddCommand(CF_SHARED, "condump", Con_ConDump_f, "output console history to a file (see also log_file)");
 
    con_initialized = true;
}

References CF_CLIENT, CF_SHARED, Cmd_AddCommand(), con, con_chat, con_chatpos, con_chatrect, con_chatrect_x, con_chatrect_y, con_chatsize, con_chatsound, con_chatsound_file, con_chatsound_team_file, con_chatsound_team_mask, con_chattime, con_chatwidth, Con_Clear_f(), Con_CommandMode_f(), con_completion_exec, con_completion_playdemo, con_completion_timedemo, Con_ConDump_f(), con_initialized, con_linewidth, Con_Maps_f(), CON_MAXLINES, Con_MessageMode2_f(), Con_MessageMode_f(), con_mutex, con_nickcompletion, con_nickcompletion_flags, con_notify, con_notifyalign, con_notifysize, con_notifytime, Con_RCon_ClearPassword_c(), CON_TEXTSIZE, con_textsize, Con_ToggleConsole_f(), ConBuffer_Init(), condump_stripcolors, Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_SetQuick(), log_dest_udp, log_file, log_file_stripcolors, logq_ind, logq_size, logqueue, MAX_INPUTLINE, Mem_Alloc, rcon_address, rcon_password, rcon_secure, rcon_secure_challengetimeout, Sys_CheckParm(), sys_colortranslation, sys_specialcharactertranslation, tempmempool, Thread_CreateMutex, Thread_HasThreads(), and zonemempool.

Referenced by Host_Init().

Con_Init_Commands()

void Con_Init_Commands

(

void

)

Con_MaskPrint()

void Con_MaskPrint	(	unsigned	additionalmask,
		const char *	msg )

Prints to a chosen console target.

Definition at line 1161 of file console.c.

{
    static unsigned mask = 0;
    static unsigned index = 0;
    static char line[MAX_INPUTLINE];
 
    if (con_mutex)
        Thread_LockMutex(con_mutex);
 
    for (;*msg;msg++)
    {
        Con_Rcon_AddChar(*msg);
        // if this is the beginning of a new line, print timestamp
        if (index == 0)
        {
            // reset the color
            // FIXME: 1. perhaps we should use a terminal system 2. use a constant instead of 7!
            line[index++] = STRING_COLOR_TAG;
            // assert( STRING_COLOR_DEFAULT < 10 )
            line[index++] = STRING_COLOR_DEFAULT + '0';
            // special color codes for chat messages must always come first
            // for Con_PrintToHistory to work properly
            if (*msg == 1 || *msg == 2 || *msg == 3)
            {
                // play talk wav
                if (*msg == 1)
                {
                    if (con_chatsound.value)
                    {
                        if(msg[1] == con_chatsound_team_mask.integer && cl.foundteamchatsound)
                            S_LocalSound (con_chatsound_team_file.string);
                        else
                            S_LocalSound (con_chatsound_file.string);
                    }
                }
                // Send to chatbox for say/tell (1) and messages (3)
                // 3 is just so that a message can be sent to the chatbox without a sound.
                if (*msg == 1 || *msg == 3)
                    mask = CON_MASK_CHAT;
 
                line[index++] = STRING_COLOR_TAG;
                line[index++] = '3';
                msg++;
                Con_Rcon_AddChar(*msg);
            }
            // store timestamp
            if (timestamps.integer)
                index += Sys_TimeString(&line[index], sizeof(line) - index, timeformat.string);
            // add the mask
            mask |= additionalmask;
        }
        // append the character
        line[index++] = *msg;
        // if this is a newline character, we have a complete line to print
        // bones_was_here: why do we only use half the line buffer?
        if (*msg == '\n' || index >= (int)sizeof(line) / 2)
        {
            // terminate the line
            line[index] = 0;
            // send to log file
            Log_ConPrint(line);
            // send to scrollable buffer
            if (con_initialized && cls.state != ca_dedicated)
            {
                Con_PrintToHistory(line, mask);
            }
            // send to terminal or dedicated server window
            if (sys.outfd >= 0)
            if (developer.integer || !(mask & CON_MASK_DEVELOPER))
            {
                if(sys_specialcharactertranslation.integer)
                {
                    char *p;
                    const char *q;
                    p = line;
                    while(*p)
                    {
                        int ch = u8_getchar(p, &q);
                        if(ch >= 0xE000 && ch <= 0xE0FF && ((unsigned char) qfont_table[ch - 0xE000]) >= 0x20)
                        {
                            *p = qfont_table[ch - 0xE000];
                            if(q > p+1)
                                memmove(p+1, q, strlen(q)+1);
                            p = p + 1;
                        }
                        else
                            p = p + (q - p);
                    }
                }
 
                if(sys_colortranslation.integer > 0) // ANSI, RGB, or both
                {
                    // ANSI translation:
                        // 2 can become 7 bytes, rounding that up to 8, and 3 bytes are added at the end
                        // a newline can transform into four bytes, but then prevents the three extra bytes from appearing
                    // 8bpc RGB brings new worst-cases:
                        // 5 can become 21 bytes, rounding that up to * 5, plenty of space for extra bytes at the end.
                        // sys_colortranslation 3: 2 can become 21 bytes, rounding that up to * 11
                    char printline[sizeof(line) * 11];
                    int lastcolor = 0;
                    const char *in;
                    char *out;
                    int color;
                    u8 rgb[3];
                    for(in = line, out = printline; *in; ++in)
                    {
                        switch(*in)
                        {
                            case STRING_COLOR_TAG:
                                if( in[1] == STRING_COLOR_RGB_TAG_CHAR && isxdigit(in[2]) && isxdigit(in[3]) && isxdigit(in[4]) )
                                {
                                    VectorCopy(in + 2, rgb);
                                    // it's a hex digit already, so the else part needs no check --blub
                                    for (int i = 0; i < 3; ++i)
                                    {
                                        if (isdigit(rgb[i])) rgb[i] -= '0';
                                        else rgb[i] = tolower(rgb[i]) - 87;
                                        rgb[i] *= 17;
                                    }
 
                                    if (sys_colortranslation.integer > 1) // 8bpc RGB
                                    {
                                        char *p;
                                        float B;
 
                                        in += 4;
                                    rgbout:
                                        color = rgb[0]<<16 | rgb[1]<<8 | rgb[2] | /* disambiguates from quake colours */ 0x40000000;
                                        if (lastcolor == color)
                                            break;
                                        else
                                            lastcolor = color;
 
                                        B = r_textbrightness.value * 255;
                                        for (int i = 0; i < 3; ++i)
                                            rgb[i] = bound(0, rgb[i] * r_textcontrast.value + B, 255);
 
                                        // format must be decimal 0-255, max length is 21 bytes
                                        if (sys_colortranslation.integer == 2)
                                            memcpy(out, "\x1B[1;38;2", 8);
                                        else
                                            memcpy(out, "\x1B[0;38;2", 8);
                                        out += 8;
                                        for (int i = 0; i < 3; ++i)
                                        {
                                            *out++ = ';';
                                            p = out += ((rgb[i] > 99) ? 3 : (rgb[i] > 9) ? 2 : 1);
                                            do { *--p = (rgb[i] % 10) + '0';
                                            } while ((rgb[i] /= 10) > 0);
                                        }
                                        *out++ = 'm';
 
                                        break;
                                    }
                                    
                                    color = Sys_Con_NearestColor(rgb[0], rgb[1], rgb[2]);
                                    in += 3; // 3 only, the switch down there does the fourth
                                }
                                else
                                {
                                    color = in[1];
                                
                                    if (sys_colortranslation.integer == 3 && isdigit(color)) // Quake to RGB
                                    {
                                        color -= '0';
                                        VectorScale(string_colors[color], 255 * string_colors[color][3], rgb);
                                        ++in;
                                        goto rgbout;
                                    }
                                }
 
                                switch(color)
                                {
                                    case STRING_COLOR_TAG:
                                        ++in;
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                    case '0':
                                    case '7':
                                        // normal color
                                        ++in;
                                        if(lastcolor == 0) break; else lastcolor = 0;
                                        *out++ = 0x1B; *out++ = '['; *out++ = 'm';
                                        break;
                                    case '1':
                                        // light red
                                        ++in;
                                        if(lastcolor == 1) break; else lastcolor = 1;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '1'; *out++ = 'm';
                                        break;
                                    case '2':
                                        // light green
                                        ++in;
                                        if(lastcolor == 2) break; else lastcolor = 2;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '2'; *out++ = 'm';
                                        break;
                                    case '3':
                                        // yellow
                                        ++in;
                                        if(lastcolor == 3) break; else lastcolor = 3;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '3'; *out++ = 'm';
                                        break;
                                    case '4':
                                        // light blue
                                        ++in;
                                        if(lastcolor == 4) break; else lastcolor = 4;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '4'; *out++ = 'm';
                                        break;
                                    case '5':
                                        // light cyan
                                        ++in;
                                        if(lastcolor == 5) break; else lastcolor = 5;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '6'; *out++ = 'm';
                                        break;
                                    case '6':
                                        // light magenta
                                        ++in;
                                        if(lastcolor == 6) break; else lastcolor = 6;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '5'; *out++ = 'm';
                                        break;
                                    // 7 handled above
                                    case '8':
                                    case '9':
                                        // bold normal color
                                        ++in;
                                        if(lastcolor == 8) break; else lastcolor = 8;
                                        *out++ = 0x1B; *out++ = '['; *out++ = '0'; *out++ = ';'; *out++ = '1'; *out++ = 'm';
                                        break;
                                    default:
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                }
                                break;
                            case '\n':
                                if(lastcolor != 0)
                                {
                                    *out++ = 0x1B; *out++ = '['; *out++ = 'm';
                                    lastcolor = 0;
                                }
                                *out++ = *in;
                                break;
                            default:
                                *out++ = *in;
                                break;
                        }
                    }
                    if(lastcolor != 0)
                    {
                        *out++ = 0x1B;
                        *out++ = '[';
                        *out++ = 'm';
                    }
                    *out = '\0';
                    Sys_Print(printline, out - printline);
                }
                else if(sys_colortranslation.integer == -1) // print as text
                {
                    Sys_Print(line, index);
                }
                else // strip
                {
                    char printline[MAX_INPUTLINE]; // it can only get shorter here
                    const char *in;
                    char *out;
                    for(in = line, out = printline; *in; ++in)
                    {
                        switch(*in)
                        {
                            case STRING_COLOR_TAG:
                                switch(in[1])
                                {
                                    case STRING_COLOR_RGB_TAG_CHAR:
                                        if ( isxdigit(in[2]) && isxdigit(in[3]) && isxdigit(in[4]) )
                                        {
                                            in+=4;
                                            break;
                                        }
                                        *out++ = STRING_COLOR_TAG;
                                        *out++ = STRING_COLOR_RGB_TAG_CHAR;
                                        ++in;
                                        break;
                                    case STRING_COLOR_TAG:
                                        ++in;
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                    case '0':
                                    case '1':
                                    case '2':
                                    case '3':
                                    case '4':
                                    case '5':
                                    case '6':
                                    case '7':
                                    case '8':
                                    case '9':
                                        ++in;
                                        break;
                                    default:
                                        *out++ = STRING_COLOR_TAG;
                                        break;
                                }
                                break;
                            default:
                                *out++ = *in;
                                break;
                        }
                    }
                    *out = '\0';
                    Sys_Print(printline, out - printline);
                }
            }
            // empty the line buffer
            index = 0;
            mask = 0;
        }
    }
 
    if (con_mutex)
        Thread_UnlockMutex(con_mutex);
}

References bound, ca_dedicated, cl, cls, color, con_chatsound, con_chatsound_file, con_chatsound_team_file, con_chatsound_team_mask, con_initialized, CON_MASK_CHAT, CON_MASK_DEVELOPER, con_mutex, Con_PrintToHistory(), Con_Rcon_AddChar(), developer, client_state_t::foundteamchatsound, i, index, cvar_t::integer, Log_ConPrint(), mask, MAX_INPUTLINE, sys_t::outfd, qfont_table, r_textbrightness, r_textcontrast, rgb, S_LocalSound(), client_static_t::state, cvar_t::string, STRING_COLOR_DEFAULT, STRING_COLOR_RGB_TAG_CHAR, STRING_COLOR_TAG, string_colors, strlen(), sys, sys_colortranslation, Sys_Con_NearestColor(), Sys_Print(), sys_specialcharactertranslation, Sys_TimeString(), Thread_LockMutex, Thread_UnlockMutex, timeformat, timestamps, u8_getchar, cvar_t::value, VectorCopy, and VectorScale.

Referenced by Con_DPrint(), Con_DPrintf(), Con_MaskPrintf(), Con_Print(), and Con_Printf().

Con_MaskPrintf()

void Con_MaskPrintf	(	unsigned	mask,
		const char *	fmt,
			... )

Definition at line 1487 of file console.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    Con_MaskPrint(mask, msg);
}

References Con_MaskPrint(), dpvsnprintf(), mask, and MAX_INPUTLINE.

Referenced by Con_CenterPrint(), and Con_CenterPrintf().

Con_Print()

void Con_Print

(

const char *

txt

)

Prints to all appropriate console targets, and adds timestamps.

Definition at line 1504 of file console.c.

{
    Con_MaskPrint(CON_MASK_PRINT, msg);
}

References CON_MASK_PRINT, and Con_MaskPrint().

Referenced by CDAudio_Startup(), CheckPendingDownloads(), CL_Color_f(), CL_Connect_f(), CL_DrawVideo(), CL_KeepaliveMessage(), CL_NextDemo(), CL_Parse_DumpPacket(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_PauseDemo_f(), CL_PlayDemo_f(), CL_PlayVideo_f(), CL_Reconnect_f(), CL_Record_f(), CL_Stop_f(), CL_TimeDemo_f(), CL_UpdateScreen(), Cmd_Alias_f(), Cmd_Echo_f(), Cmd_Exec_f(), Cmd_StuffCmds_f(), Cmd_Toggle_f(), Cmd_UnAlias_f(), Collision_ValidateBrush(), Com_HexDumpToConsole(), Con_DisplayList(), Crypto_DecryptPacket(), Crypto_EncryptPacket(), Crypto_HostKey_Clear_f(), Crypto_HostKeys_f(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_Keys_f(), CSQC_AddPrintText(), Curl_Curl_f(), Curl_Info_f(), Cvar_Callback(), Cvar_PrintHelp(), Cvar_Readonly(), Cvar_RegisterCallback(), Cvar_SetQuick(), EntityFrame4_AckFrame(), EntityFrame4_CL_ReadFrame(), EntityFrame4_WriteFrame(), EntityFrame_AddFrame_Client(), EntityFrame_AddFrame_Server(), EntityState5_ReadUpdate(), EntityState_ReadFields(), EntityStateQW_ReadEntityUpdate(), FindViewthing(), font_start(), FS_Inflate(), FS_ListDirectoryCmd(), FS_Path_f(), FS_Rescan(), GetMapList(), GetWavinfo(), GL_Backend_ResetState(), gl_backend_shutdown(), GL_Setup(), GL_TextureMode_f(), hmac_mdfour_challenge_matching(), hmac_mdfour_time_matching(), Image_Compress(), JPEG_SaveImage_preflipped(), JPEG_SaveImage_to_Buffer(), Key_Bind_f(), Key_History_Shutdown(), Key_In_Bind_f(), Key_In_Bindmap_f(), Key_In_Unbind_f(), Key_Unbind_f(), KeyDown(), LHNET_Init(), LHNET_OpenSocket_Connectionless(), LHNET_Read(), LoadConChars_BGRA(), LoadLMP_BGRA(), LoadPCX_BGRA(), LoadSky_f(), LoadTGA_BGRA(), LoadWAL_BGRA(), LoadWAL_GetMetadata(), Mem_PrintList(), MemList_f(), Mod_BSP_RecursiveNodePortals(), Mod_Decompile_f(), Mod_Precache_f(), Mod_Print_f(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_RecursiveHullCheck(), Mod_Q1BSP_TraceBox(), Mod_Q1BSP_TraceLine(), Mod_Q2BSP_LoadLeafs(), Mod_Q3BSP_LoadFaces(), Mod_ShadowMesh_AddMesh(), Mod_ValidateElements(), MVM_error_cmd(), Net_Heartbeat_f(), Net_Stats_f(), NetConn_CL_UpdateSockets_Callback(), NetConn_SendUnreliableMessage(), NetConn_sv_netport_Callback(), plaintext_matching(), PNG_SaveImage_preflipped(), Portal_Visibility(), PRVM_CallProfile_f(), PRVM_ChildProfile_f(), PRVM_ED_CallSpawnFunction(), PRVM_ED_Count_f(), PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_Print(), PRVM_ED_PrintEdict_f(), PRVM_ED_PrintEdicts_f(), PRVM_Fields_f(), PRVM_Globals_f(), PRVM_LeakTest(), PRVM_PrintStatement(), PRVM_Profile_f(), PRVM_StackTrace(), R_Envmap_f(), R_ListWorldTextures_f(), R_LoadCubemap(), R_Modules_Restart_f(), R_ReplaceWorldTexture_f(), R_Shadow_EditLights_CopyInfo_f(), R_Shadow_EditLights_Edit_f(), R_Shadow_EditLights_EditAll_f(), R_Shadow_EditLights_Help_f(), R_Shadow_EditLights_Lock_f(), R_Shadow_EditLights_PasteInfo_f(), R_Shadow_EditLights_Remove_f(), R_Shadow_EditLights_Spawn_f(), R_Shadow_EditLights_ToggleCorona_f(), R_Shadow_EditLights_ToggleShadow_f(), R_Shadow_LoadLightsFile(), R_Shadow_LoadWorldLights(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), R_Shadow_SaveWorldLights(), R_TextureStats_Print(), S_PauseSound_f(), S_SoundInfo_f(), S_Startup(), S_StaticSound(), SCR_ScreenShot_f(), SndSys_Init(), SV_Begin_f(), SV_BroadcastPrint(), SV_Changelevel_f(), SV_Loadgame_f(), SV_Map_f(), SV_MaxPlayers_f(), SV_PreSpawn_f(), SV_ReadClientMessage(), SV_Restart_f(), SV_SaveEntFile_f(), SV_Savegame_f(), SV_Savegame_to(), SV_Say(), SV_Spawn_f(), SV_StartDemoRecording(), SV_Tell_f(), Sys_SDL_HandleEvents(), SZ_GetSpace(), VID_Restart_f(), VID_SetMouse(), VID_Start(), VM_print(), VM_SV_clientcommand(), VM_SV_setcolor(), VM_SV_setspawnparms(), VM_SV_sprint(), W_GetLumpName(), W_GetTextureBGRA(), and W_LoadTextureWadFile().

Con_Printf()

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

Prints to all appropriate console targets.

Definition at line 1514 of file console.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    Con_MaskPrint(CON_MASK_PRINT, msg);
}

References CON_MASK_PRINT, Con_MaskPrint(), dpvsnprintf(), and MAX_INPUTLINE.

Referenced by AnglesFromVectors(), Cbuf_AddText(), Cbuf_Execute(), Cbuf_InsertText(), CD_f(), CheckPendingDownloads(), CL_BeginDownloads(), CL_BeginDownloads_f(), CL_Cache_TraceLineSurfaces(), CL_ClearTempEntities(), CL_Color_f(), CL_DisconnectEx(), CL_DownloadBegin_f(), CL_DownloadFinished_f(), CL_Effect(), CL_EstablishConnection(), CL_ExaminePrintString(), CL_FinishTimeDemo(), CL_Fog_f(), CL_Fog_HeightTexture_f(), CL_ForwardToServer(), CL_Frame(), CL_FullInfo_f(), CL_FullServerinfo_f(), CL_Init(), CL_IPLog_List_f(), CL_IPLog_Load(), CL_LinkEdict(), CL_Locs_Add_f(), CL_Locs_FreeNode(), CL_Locs_Reload_f(), CL_Locs_RemoveNearest_f(), CL_Locs_Save_f(), CL_ModelIndexList_f(), CL_Name_f(), CL_NewBeam(), CL_NewFrameReceived(), CL_OpenVideo(), CL_Packet_f(), CL_ParseBeam(), CL_ParseDownload(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseStaticSound(), CL_ParticleRain(), CL_Particles_ParseEffectInfo(), CL_PlayDemo(), CL_PQRcon_f(), CL_PrintEntities_f(), CL_Rcon_f(), CL_ReadPointFile_f(), CL_Reconnect_f(), CL_Record_f(), CL_SendMove(), CL_SetInfo(), CL_SetInfo_f(), CL_SoundIndexList_f(), CL_Startdemos_f(), CL_StopDownload(), CL_StopDownload_f(), CL_TimeRefresh_f(), CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), CL_User_f(), CL_Users_f(), CL_VM_Init(), CLVM_count_edicts(), Cmd_AddCommand(), Cmd_Alias_f(), Cmd_Apropos_f(), Cmd_Callback(), Cmd_CheckParm(), Cmd_CL_Callback(), Cmd_CompleteAliasPrint(), Cmd_CompleteCommandPrint(), Cmd_CompleteNicksPrint(), Cmd_Defer_f(), Cmd_Echo_f(), Cmd_Exec(), Cmd_Exec_f(), Cmd_ExecuteString(), Cmd_GetCvarValue(), Cmd_List_f(), Cmd_Toggle_f(), Cmd_TokenizeString(), Cmd_UnAlias_f(), Collision_ClipLineToGenericEntity(), Collision_ClipPointToGenericEntity(), Collision_ClipToGenericEntity(), Collision_ClipTrace_Box(), Collision_PrintBrushAsQHull(), Collision_ValidateBrush(), COM_ChangeGameTypeForGameDirs(), Con_CenterPrintf(), Con_CompleteCommandLine(), Con_ConDump_f(), Con_Maps_f(), Crypto_DecryptPacket(), Crypto_EncryptPacket(), Crypto_FinishInstance(), Crypto_HostKey_Clear_f(), Crypto_HostKeys_f(), Crypto_Init(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_Keys_f(), Crypto_LoadKeys(), Crypto_ServerParsePacket(), Crypto_StoreHostKey(), Curl_Begin(), Curl_Curl_f(), Curl_EndDownload(), Curl_Info_f(), Curl_Select(), Curl_SendRequirements(), Cvar_Del_f(), Cvar_Delete(), Cvar_Get(), Cvar_List_f(), Cvar_PrintHelp(), Cvar_Readonly(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), Cvar_Set(), Cvar_Set_f(), Cvar_SetA_f(), Cvar_SetQuick(), decode_image(), dp__strlcpy(), dp_stpecpy(), dp_ustr2stp(), em_savefs_f(), EntityFrame4_AckFrame(), EntityFrame4_CL_ReadFrame(), EntityFrame4_WriteFrame(), EntityFrame5_CL_ReadFrame(), EntityFrame5_WriteFrame(), EntityFrame_CL_ReadFrame(), EntityFrameCSQC_DeallocFrame(), EntityFrameCSQC_LostFrame(), EntityFrameQW_CL_ReadFrame(), EntityState5_ReadUpdate(), EntityState_ReadFields(), EntityStateQW_ReadEntityUpdate(), FindFont(), Font_GetKerningForMap(), Font_LoadFile(), Font_LoadFont(), Font_LoadMap(), Font_LoadSize(), Font_SearchSize(), fractalnoise(), fractalnoisequick(), FS_AddFileToPack(), FS_AddPack(), FS_AddPack_Fullpath(), FS_Deflate(), FS_GameDir_f(), FS_Inflate(), FS_ListDirectory(), FS_ListDirectoryCmd(), FS_LoadAndCloseQFile(), FS_LoadPackPAK(), FS_LoadPackPK3FromFD(), FS_OpenPackedFile(), FS_OpenReadFile(), FS_OpenRealFile(), FS_OpenVirtualFile(), FS_Path_f(), FS_Read(), FS_Search(), FS_Seek(), FS_SetGameDirs(), FS_SysOpenFiledesc(), FS_Which_f(), FS_Write(), FS_WriteFileInBlocks(), GetMapList(), GetWavinfo(), GL_Backend_CompileShader(), gl_backend_start(), GL_DebugOutputCallback(), GL_Mesh_ListVBOs(), GL_Setup(), GL_TextureMode_f(), Host_Error(), Host_Init(), Host_LockSession(), Host_Quit_f(), Host_SaveConfig(), Host_Version_f(), Image_Compress(), Image_FixTransparentPixels_f(), Image_MipReduce32(), Image_Resample32(), IN_BestWeapon_f(), IN_BestWeapon_Register(), IN_BestWeapon_Register_f(), InfoString_GetValue(), InfoString_Print(), InfoString_SetValue(), jam_video(), JPEG_LoadImage_BGRA(), JPEG_OpenLibrary(), JPEG_SaveImage_to_Buffer(), Key_Bind_f(), Key_Event(), Key_History_f(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_Push(), Key_In_Bind_f(), Key_In_BindList_f(), Key_In_Bindmap_f(), Key_In_Unbind_f(), Key_Parse_CommonKeys(), Key_PrintBindList(), Key_Unbind_f(), LHNET_OpenSocket_Connectionless(), LHNETADDRESS_FromString(), LibAV_LoadLibrary(), libavw_decodeframe(), libavw_message(), LibAvW_OpenLibrary(), LoadConChars_BGRA(), LoadFont_f(), loadimagepixelsbgra(), LoadLMP_BGRA(), LoadPCX_BGRA(), LoadSky_f(), LoadSubtitles(), LoadTGA_BGRA(), LoadWAL_BGRA(), Matrix4x4_Print(), Mem_PrintList(), Mem_PrintStats(), Mod_AliasInit(), Mod_BSP_DecompressVis(), Mod_BuildVBOs(), Mod_DARKPLACESMODEL_Load(), Mod_Decompile_OBJ(), Mod_Decompile_SMD(), Mod_FrameGroupify(), Mod_FrameGroupify_ParseGroups(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_GenerateLightmaps_f(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDS2_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_LoadModel(), Mod_LoadQ3Shaders(), Mod_LoadSkinFiles(), Mod_LoadTextureFromQ3Shader(), Mod_MDL_LoadFrames(), Mod_Print_f(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadEdges(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_LoadNodes(), Mod_Q1BSP_LoadTexinfo(), Mod_Q1BSP_LoadTextures(), Mod_Q1BSP_TraceBox(), Mod_Q1BSP_TraceLine(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadLeafs(), Mod_Q2BSP_LoadNodes(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_LoadEffects(), Mod_Q3BSP_LoadEntities(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLightGrid(), Mod_Q3BSP_LoadLightmaps(), Mod_Q3BSP_LoadTriangles(), Mod_UnloadModel(), Mod_ValidateElements(), Mod_VBSP_LoadEdges(), Mod_VBSP_LoadTexinfo(), Mod_VBSP_LoadTextures(), Mod_ZYMOTICMODEL_Load(), ModList_Enable(), MVM_count_edicts(), MVM_error_cmd(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ConnectionEstablished(), NetConn_Init(), NetConn_OpenClientPort(), NetConn_OpenClientPorts(), NetConn_OpenServerPort(), NetConn_Read(), NetConn_ReceivedMessage(), NetConn_SendUnreliableMessage(), NetConn_ServerParsePacket(), NetConn_UpdateSockets(), NetConn_Write(), OGG_LoadVorbisFile(), OpenStream(), PHYS_TestEntityPosition(), PK3_GetTrueFileOffset(), PNG_error_fn(), PNG_fReadData(), PNG_LoadImage_BGRA(), PNG_warning_fn(), Portal_CheckPolygon(), Portal_Visibility(), PrintFrameName(), PrintStats(), PrintTargaHeader(), PRVM_Breakpoint(), PRVM_Breakpoint_f(), PRVM_CallProfile(), PRVM_ChildProfile_f(), PRVM_Crash(), PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_ParseEdict(), PRVM_ED_ParseEpair(), PRVM_ED_ParseGlobals(), PRVM_ED_Print(), PRVM_ED_PrintEdicts_f(), PRVM_ED_Write(), PRVM_ED_WriteGlobals(), PRVM_EdictWatchpoint_f(), PRVM_ExplicitCoverageEvent(), PRVM_Fields_f(), PRVM_FriendlyProgFromString(), PRVM_FunctionCoverageEvent(), PRVM_GameCommand(), PRVM_Global_f(), PRVM_Globals_f(), PRVM_GlobalSet_f(), PRVM_GlobalWatchpoint_f(), PRVM_LeakTest(), PRVM_MarkReferencedEdicts(), PRVM_PrintFunction_f(), PRVM_PrintFunctionStatements(), PRVM_PrintState(), PRVM_PrintStatement(), PRVM_Profile(), PRVM_Profile_f(), PRVM_Prog_Load(), PRVM_StackTrace(), PRVM_StatementCoverageEvent(), PRVM_UpdateBreakpoints(), QW_CL_Changing_f(), QW_CL_CheckOrDownloadFile(), QW_CL_NextUpload_f(), QW_CL_ParseDownload(), QW_CL_RequestNextDownload(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), R_Envmap_f(), R_GLSL_CompilePermutation(), R_GLSL_DumpShader_f(), R_InitParticleTexture(), R_ListWorldTextures_f(), R_LoadCubemap(), R_LoadQWSkin(), R_LoadSkyBox(), R_LoadTextureDDSFile(), R_Mesh_CreateFramebufferObject(), R_Mesh_Draw(), R_Mesh_Start(), R_Model_Sprite_Draw_TransparentCallback(), R_Modules_Start(), R_RegisterModule(), R_ReplaceWorldTexture_f(), R_SetSkyBox(), R_SetupTexture(), R_Shadow_ComputeShadowCasterCullingPlanes(), R_Shadow_EditLights_Edit_f(), R_Shadow_LoadLightsFile(), R_Shadow_LoadWorldLights(), R_Shadow_RenderLighting(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalBGRA(), R_SkinFrame_LoadInternalQuake(), R_SkinFrame_LoadInternalUsingTexture(), R_TextureStats_Print(), R_UnloadSkyBox(), R_Viewport_InitOrtho(), R_Water_ProcessPlanes(), RCon_Execute(), S_FindName(), S_FreeSfx(), S_LoadSound(), S_LoadWavFile(), S_LocalSoundEx(), S_PaintAndSubmit(), S_PlaySfxOnChannel(), S_Restart_f(), S_SetChannelLayout(), S_SoundInfo_f(), S_SoundList_f(), S_Startup(), S_StaticSound(), S_UnloadAllSounds_f(), S_Update(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_CaptureVideo_RIFF_Pop(), SCR_InfoBar_f(), SCR_ScreenShot_f(), SndSys_Init(), SV_Begin_f(), SV_CanSeeBox(), SV_CheckVelocity(), SV_ConnectClient(), SV_DropClient(), SV_Ent_Create_f(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), SV_ExecuteClientMoves(), SV_FlyMove(), SV_Impact(), SV_LinkEdict(), SV_LinkEdict_TouchAreaGrid(), SV_Loadgame_f(), SV_MaxPlayers_f(), SV_ModelIndex(), SV_ParticleEffectIndex(), SV_Pause_f(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_Ping_f(), SV_PointSuperContents(), SV_PushEntity(), SV_PushMove(), SV_ReadClientMessage(), SV_ReadClientMove(), SV_Savegame_to(), SV_ServerOptions(), SV_SoundIndex(), SV_Spawn_f(), SV_SpawnServer(), SV_StartDemoRecording(), SV_StartPointSound(), SV_StartSound(), SV_Status_f(), SV_StopDemoRecording(), SV_TraceBox(), SV_TraceLine(), SV_TracePoint(), SV_UnstickEntity(), SV_Viewmodel_f(), SV_WriteEntitiesToClient(), SVVM_count_edicts(), Sys_DirtyTime(), Sys_Error(), Sys_LoadDependency(), Sys_SDL_HandleEvents(), Sys_Sleep(), Sys_UpdateTime(), testmul128(), Thread_Init(), V_BonusFlash_f(), VID_ApplyDisplayMode(), VID_ApplyJoyState(), VID_EnableJoystick(), VID_Init(), VID_InitModeGL(), VID_Mode(), VID_Restart_f(), VID_SetVsync_c(), VID_Shared_SetJoystick(), VM_CL_effect(), VM_CL_findbox(), VM_CL_findradius(), VM_CL_makestatic(), VM_error(), VM_GetFileHandle(), VM_objerror(), VM_SV_findbox(), VM_SV_findradius(), VM_Warning(), W_LoadTextureWadFile(), World_LinkEdict_AreaGrid(), World_PrintAreaStats(), XMP_LoadModFile(), and XMP_OpenLibrary().

Con_Quakebar()

const char * Con_Quakebar	(	int	len,
		char *	bar,
		size_t	barsize )

Returns a horizontal line.

Returns a graphical horizontal line of length len, but never wider than the console. Includes a newline, unless len is >= to the console width

Note

Authored by johnfitz

Parameters

[in]

len

Length of the horizontal line

Returns

A string of the line

Definition at line 1570 of file console.c.

{
    assert(barsize >= 5);
 
    len = min(len, (int)barsize - 2);
    len = min(len, con_linewidth);
 
    bar[0] = '\35';
    memset(&bar[1], '\36', len - 2);
    bar[len - 1] = '\37';
 
    if (len < con_linewidth)
    {
        bar[len] = '\n';
        bar[len + 1] = 0;
    }
    else
        bar[len] = 0;
 
    return bar;
}

References con_linewidth, and min.

Referenced by Con_CenterPrint().

Con_Rcon_Redirect_Abort()

void Con_Rcon_Redirect_Abort

(

void

)

Definition at line 1048 of file console.c.

{
    rcon_redirect_dest = NULL;
    rcon_redirect_sock = NULL;
}

References NULL, rcon_redirect_dest, and rcon_redirect_sock.

Referenced by Host_Error().

Con_Rcon_Redirect_End()

void Con_Rcon_Redirect_End

(

void

)

Definition at line 1041 of file console.c.

{
    Con_Rcon_Redirect_Flush();
    rcon_redirect_dest = NULL;
    rcon_redirect_sock = NULL;
}

References Con_Rcon_Redirect_Flush(), NULL, rcon_redirect_dest, and rcon_redirect_sock.

Referenced by RCon_Execute().

Con_Rcon_Redirect_Init()

void Con_Rcon_Redirect_Init	(	lhnetsocket_t *	sock,
		lhnetaddress_t *	dest,
		qbool	proquakeprotocol )

Definition at line 1004 of file console.c.

{
    rcon_redirect_sock = sock;
    rcon_redirect_dest = dest;
    rcon_redirect_proquakeprotocol = proquakeprotocol;
    if (rcon_redirect_proquakeprotocol)
    {
        // reserve space for the packet header
        rcon_redirect_buffer[0] = 0;
        rcon_redirect_buffer[1] = 0;
        rcon_redirect_buffer[2] = 0;
        rcon_redirect_buffer[3] = 0;
        // this is a reply to a CCREQ_RCON
        rcon_redirect_buffer[4] = (unsigned char)CCREP_RCON;
    }
    else
        memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
    rcon_redirect_bufferpos = 5;
}

References CCREP_RCON, rcon_redirect_buffer, rcon_redirect_bufferpos, rcon_redirect_dest, rcon_redirect_proquakeprotocol, and rcon_redirect_sock.

Referenced by RCon_Execute().

Con_Shutdown()

void Con_Shutdown

(

void

)

Definition at line 941 of file console.c.

{
    if (con_mutex) Thread_LockMutex(con_mutex);
    ConBuffer_Shutdown(&con);
    if (con_mutex) Thread_UnlockMutex(con_mutex);
    if (con_mutex) Thread_DestroyMutex(con_mutex);
    con_mutex = NULL;
}

References con, con_mutex, ConBuffer_Shutdown(), NULL, Thread_DestroyMutex, Thread_LockMutex, and Thread_UnlockMutex.

Referenced by Host_Shutdown().

Con_ToggleConsole_f()

void Con_ToggleConsole_f

(

cmd_state_t *

cmd

)

Definition at line 686 of file console.c.

{
    if (Sys_CheckParm ("-noconsole"))
        if (!(key_consoleactive & KEY_CONSOLEACTIVE_USER))
            return; // only allow the key bind to turn off console
 
    // toggle the 'user wants console' bit
    key_consoleactive ^= KEY_CONSOLEACTIVE_USER;
    Con_ClearNotify();
}

References Con_ClearNotify(), key_consoleactive, KEY_CONSOLEACTIVE_USER, and Sys_CheckParm().

Referenced by Con_Init(), IN_Move_TouchScreen_Quake(), Key_Event(), M_Main_Key(), and M_Options_Key().

ConBuffer_AddLine()

void ConBuffer_AddLine	(	conbuffer_t *	buf,
		const char *	line,
		int	len,
		unsigned	mask )

Appends a given string as a new line to the console.

Definition at line 332 of file console.c.

{
    char *putpos;
    con_lineinfo_t *p;
 
    // developer_memory 1 during shutdown prints while conbuffer_t is being freed
    if (!buf->active)
        return;
 
    ConBuffer_FixTimes(buf);
 
    if(len >= buf->textsize)
    {
        // line too large?
        // only display end of line.
        line += len - buf->textsize + 1;
        len = buf->textsize - 1;
    }
    while(!(putpos = ConBuffer_BytesLeft(buf, len + 1)) || buf->lines_count >= buf->maxlines)
        ConBuffer_DeleteLine(buf);
    memcpy(putpos, line, len);
    putpos[len] = 0;
    ++buf->lines_count;
 
    //fprintf(stderr, "Now have %d lines (%d -> %d).\n", buf->lines_count, buf->lines_first, CON_LINES_LAST);
 
    p = &CONBUFFER_LINES_LAST(buf);
    p->start = putpos;
    p->len = len;
    p->addtime = cl.time;
    p->mask = mask;
    p->height = -1; // calculate when needed
}

References con_lineinfo_t::addtime, buf, cl, ConBuffer_BytesLeft(), ConBuffer_DeleteLine(), ConBuffer_FixTimes(), CONBUFFER_LINES_LAST, con_lineinfo_t::height, con_lineinfo_t::len, con_lineinfo_t::mask, mask, con_lineinfo_t::start, and client_state_t::time.

Referenced by Con_PrintToHistory(), Key_History_Init(), and Key_History_Push().

ConBuffer_Clear()

void ConBuffer_Clear

(

conbuffer_t *

buf

)

Definition at line 212 of file console.c.

{
    buf->lines_count = 0;
}

References buf.

Referenced by Con_Clear_f(), and Key_History_f().

ConBuffer_DeleteLastLine()

void ConBuffer_DeleteLastLine

(

conbuffer_t *

buf

)

Deletes the last line from the console history.

Definition at line 278 of file console.c.

{
    if(buf->lines_count == 0)
        return;
    --buf->lines_count;
}

References buf.

Referenced by Con_PrintToHistory().

ConBuffer_DeleteLine()

void ConBuffer_DeleteLine

(

conbuffer_t *

buf

)

Deletes the first line from the console history.

Definition at line 263 of file console.c.

{
    if(buf->lines_count == 0)
        return;
    --buf->lines_count;
    buf->lines_first = (buf->lines_first + 1) % buf->maxlines;
}

References buf.

Referenced by ConBuffer_AddLine().

ConBuffer_FindNextLine()

int ConBuffer_FindNextLine	(	conbuffer_t *	buf,
		unsigned	mask_must,
		unsigned	mask_mustnot,
		int	start )

ConBuffer_FindPrevLine()

int ConBuffer_FindPrevLine	(	conbuffer_t *	buf,
		unsigned	mask_must,
		unsigned	mask_mustnot,
		int	start )

Definition at line 366 of file console.c.

{
    int i;
    if(start == -1)
        start = buf->lines_count;
    for(i = start - 1; i >= 0; --i)
    {
        con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
 
        if((l->mask & mask_must) != mask_must)
            continue;
        if(l->mask & mask_mustnot)
            continue;
 
        return i;
    }
 
    return -1;
}

References buf, CONBUFFER_LINES, i, and con_lineinfo_t::mask.

ConBuffer_FixTimes()

void ConBuffer_FixTimes

(

conbuffer_t *

buf

)

Notifies the console code about the current time (and shifts back times of other entries when the time went backwards)

Definition at line 242 of file console.c.

{
    int i;
    if(buf->lines_count >= 1)
    {
        double diff = cl.time - CONBUFFER_LINES_LAST(buf).addtime;
        if(diff < 0)
        {
            for(i = 0; i < buf->lines_count; ++i)
                CONBUFFER_LINES(buf, i).addtime += diff;
        }
    }
}

References buf, cl, CONBUFFER_LINES, CONBUFFER_LINES_LAST, i, and client_state_t::time.

Referenced by Con_DrawNotify(), and ConBuffer_AddLine().

ConBuffer_GetLine()

const char * ConBuffer_GetLine	(	conbuffer_t *	buf,
		int	i )

Definition at line 386 of file console.c.

{
    static char copybuf[MAX_INPUTLINE]; // client only
    con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
 
    dp_ustr2stp(copybuf, sizeof(copybuf), l->start, l->len);
    return copybuf;
}

References buf, CONBUFFER_LINES, dp_ustr2stp(), i, con_lineinfo_t::len, MAX_INPUTLINE, and con_lineinfo_t::start.

Referenced by Key_History_Down(), Key_History_f(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Last(), Key_History_Shutdown(), and Key_History_Up().

ConBuffer_Init()

void ConBuffer_Init	(	conbuffer_t *	buf,
		int	textsize,
		int	maxlines,
		mempool_t *	mempool )

Definition at line 108 of file console.c.

{
    buf->active = true;
    buf->textsize = textsize;
    buf->text = (char *) Mem_Alloc(mempool, textsize);
    buf->maxlines = maxlines;
    buf->lines = (con_lineinfo_t *) Mem_Alloc(mempool, maxlines * sizeof(*buf->lines));
    buf->lines_first = 0;
    buf->lines_count = 0;
}

References buf, and Mem_Alloc.

Referenced by Con_Init(), and Key_History_Init().

ConBuffer_Shutdown()

void ConBuffer_Shutdown

(

conbuffer_t *

buf

)

Definition at line 222 of file console.c.

{
    buf->active = false;
    if (buf->text)
        Mem_Free(buf->text);
    if (buf->lines)
        Mem_Free(buf->lines);
    buf->text = NULL;
    buf->lines = NULL;
}

References buf, Mem_Free, and NULL.

Referenced by Con_Shutdown(), and Key_History_Shutdown().

GetMapList()

qbool GetMapList	(	const char *	s,
		char *	completedname,
		int	completednamebufferlength )

Definition at line 2275 of file console.c.

{
    fssearch_t  *t;
    char        message[1024];
    int         i, k, max, p, o, min;
    unsigned char *len;
    qfile_t     *f;
    unsigned char buf[1024];
 
    dpsnprintf(message, sizeof(message), "maps/%s*.bsp", s);
    t = FS_Search(message, 1, true, NULL);
    if(!t)
        return false;
    if (t->numfilenames > 1)
        Con_Printf("^1 %i maps found :\n", t->numfilenames);
    len = (unsigned char *)Z_Malloc(t->numfilenames);
    min = 666;
    for(max=i=0;i<t->numfilenames;i++)
    {
        k = (int)strlen(t->filenames[i]);
        k -= 9;
        if(max < k)
            max = k;
        else
        if(min > k)
            min = k;
        len[i] = k;
    }
    o = (int)strlen(s);
    for(i=0;i<t->numfilenames;i++)
    {
        int lumpofs = 0, lumplen = 0;
        char *entities = NULL;
        const char *data = NULL;
        char keyname[64];
        char entfilename[MAX_QPATH];
        char desc[64];
        desc[0] = 0;
        dp_strlcpy(message, "^1ERROR: open failed^7", sizeof(message));
        p = 0;
        f = FS_OpenVirtualFile(t->filenames[i], true);
        if(f)
        {
            dp_strlcpy(message, "^1ERROR: not a known map format^7", sizeof(message));
            memset(buf, 0, 1024);
            FS_Read(f, buf, 1024);
            if (!memcmp(buf, "IBSP", 4))
            {
                p = LittleLong(((int *)buf)[1]);
                if (p == Q3BSPVERSION || p == Q3BSPVERSION_LIVE || p == Q3BSPVERSION_IG)
                {
                    q3dheader_t *header = (q3dheader_t *)buf;
                    lumpofs = LittleLong(header->lumps[Q3LUMP_ENTITIES].fileofs);
                    lumplen = LittleLong(header->lumps[Q3LUMP_ENTITIES].filelen);
                    dpsnprintf(desc, sizeof(desc), "Q3BSP%i", p);
                }
                else if (p == Q2BSPVERSION)
                {
                    q2dheader_t *header = (q2dheader_t *)buf;
                    lumpofs = LittleLong(header->lumps[Q2LUMP_ENTITIES].fileofs);
                    lumplen = LittleLong(header->lumps[Q2LUMP_ENTITIES].filelen);
                    dpsnprintf(desc, sizeof(desc), "Q2BSP%i", p);
                }
                else
                    dpsnprintf(desc, sizeof(desc), "IBSP%i", p);
            }
            else if (BuffLittleLong(buf) == BSPVERSION)
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSP29");
            }
            else if (BuffLittleLong(buf) == 30)
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSPHL");
            }
            else if (!memcmp(buf, "BSP2", 4))
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSP2");
            }
            else if (!memcmp(buf, "2PSB", 4))
            {
                lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
                lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
                dpsnprintf(desc, sizeof(desc), "BSP2RMQe");
            }
            else if(!memcmp(buf, "VBSP", 4))
            {
                hl2dheader_t *header = (hl2dheader_t *)buf;
                lumpofs = LittleLong(header->lumps[HL2LUMP_ENTITIES].fileofs);
                lumplen = LittleLong(header->lumps[HL2LUMP_ENTITIES].filelen);
                dpsnprintf(desc, sizeof(desc), "VBSP%i", LittleLong(((int *)buf)[1]));
            }
            else
                dpsnprintf(desc, sizeof(desc), "unknown%i", BuffLittleLong(buf));
            dp_strlcpy(entfilename, t->filenames[i], sizeof(entfilename));
            memcpy(entfilename + strlen(entfilename) - 4, ".ent", 5);
            entities = (char *)FS_LoadFile(entfilename, tempmempool, true, NULL);
            if (!entities && lumplen >= 10)
            {
                FS_Seek(f, lumpofs, SEEK_SET);
                entities = (char *)Z_Malloc(lumplen + 1);
                FS_Read(f, entities, lumplen);
            }
            if (entities)
            {
                // if there are entities to parse, a missing message key just
                // means there is no title, so clear the message string now
                message[0] = 0;
                data = entities;
                for (;;)
                {
                    int l;
                    if (!COM_ParseToken_Simple(&data, false, false, true))
                        break;
                    if (com_token[0] == '{')
                        continue;
                    if (com_token[0] == '}')
                        break;
                    // skip leading whitespace
                    for (k = 0;com_token[k] && ISWHITESPACE(com_token[k]);k++);
                    for (l = 0;l < (int)sizeof(keyname) - 1 && com_token[k+l] && !ISWHITESPACE(com_token[k+l]);l++)
                        keyname[l] = com_token[k+l];
                    keyname[l] = 0;
                    if (!COM_ParseToken_Simple(&data, false, false, true))
                        break;
                    if (developer_extra.integer)
                        Con_DPrintf("key: %s %s\n", keyname, com_token);
                    if (!strcmp(keyname, "message"))
                    {
                        // get the message contents
                        dp_strlcpy(message, com_token, sizeof(message));
                        break;
                    }
                }
            }
        }
        if (entities)
            Z_Free(entities);
        if(f)
            FS_Close(f);
        *(t->filenames[i]+len[i]+5) = 0;
        Con_Printf("%16s (%-8s) %s\n", t->filenames[i]+5, desc, message);
    }
    Con_Print("\n");
    for(p=o;p<min;p++)
    {
        k = *(t->filenames[0]+5+p);
        if(k == 0)
            goto endcomplete;
        for(i=1;i<t->numfilenames;i++)
            if(*(t->filenames[i]+5+p) != k)
                goto endcomplete;
    }
endcomplete:
    if(p > o && completedname && completednamebufferlength > 0)
    {
        memset(completedname, 0, completednamebufferlength);
        memcpy(completedname, (t->filenames[0]+5), min(p, completednamebufferlength - 1));
    }
    Z_Free(len);
    FS_FreeSearch(t);
    return p > o;
}

References BSPVERSION, buf, BuffLittleLong(), COM_ParseToken_Simple(), com_token, Con_DPrintf(), Con_Print(), Con_Printf(), data, developer_extra, dp_strlcpy, dpsnprintf(), f, hl2lump_t::filelen, lump_t::filelen, fssearch_t::filenames, hl2lump_t::fileofs, lump_t::fileofs, FS_Close(), FS_FreeSearch(), FS_LoadFile(), FS_OpenVirtualFile(), FS_Read(), FS_Search(), FS_Seek(), HL2LUMP_ENTITIES, i, int(), cvar_t::integer, ISWHITESPACE, LittleLong, LUMP_ENTITIES, hl2dheader_t::lumps, q2dheader_t::lumps, q3dheader_t::lumps, max, MAX_QPATH, message, min, NULL, fssearch_t::numfilenames, Q2BSPVERSION, Q2LUMP_ENTITIES, Q3BSPVERSION, Q3BSPVERSION_IG, Q3BSPVERSION_LIVE, Q3LUMP_ENTITIES, strlen(), tempmempool, Z_Free, and Z_Malloc.

Referenced by Con_CompleteCommandLine(), and Con_Maps_f().

Log_Close()

void Log_Close

(

void

)

Definition at line 521 of file console.c.

{
    qfile_t* l = logfile;
 
    if (l == NULL)
        return;
 
    FS_Print (l, Log_Timestamp ("Log stopped"));
    FS_Print (l, "\n");
    logfile = NULL;
    FS_Close (l);
 
    crt_log_file[0] = '\0';
}

References crt_log_file, FS_Close(), FS_Print(), Log_Timestamp(), logfile, and NULL.

Referenced by Host_Shutdown(), and Log_ConPrint().

Log_DestBuffer_Flush()

void Log_DestBuffer_Flush

(

void

)

call this once per frame to send out replies to rcon streaming clients

Definition at line 465 of file console.c.

{
    if (con_mutex)
        Thread_LockMutex(con_mutex);
    Log_DestBuffer_Flush_NoLock();
    if (con_mutex)
        Thread_UnlockMutex(con_mutex);
}

References con_mutex, Log_DestBuffer_Flush_NoLock(), Thread_LockMutex, and Thread_UnlockMutex.

Referenced by Host_Frame().

Log_Init()

void Log_Init

(

void

)

Log_Printf()

void Log_Printf	(	const char *	logfilename,
		const char *	fmt,
			... )

Definition at line 655 of file console.c.

{
    qfile_t *file;
 
    file = FS_OpenRealFile(logfilename, "a", true);
    if (file != NULL)
    {
        va_list argptr;
 
        va_start (argptr, fmt);
        FS_VPrintf (file, fmt, argptr);
        va_end (argptr);
 
        FS_Close (file);
    }
}

References FS_Close(), FS_OpenRealFile(), FS_VPrintf(), and NULL.

Referenced by CL_FinishTimeDemo(), CL_IPLog_Add(), loadimagepixelsbgra(), and R_LoadTextureDDSFile().

Log_Start()

void Log_Start

(

void

)

Definition at line 542 of file console.c.

{
    size_t pos;
    size_t n;
    Log_Open ();
 
    // Dump the contents of the log queue into the log file and free it
    if (logqueue != NULL)
    {
        unsigned char *temp = logqueue;
        logqueue = NULL;
        if(logq_ind != 0)
        {
            if (logfile != NULL)
                FS_Write (logfile, temp, logq_ind);
            if(*log_dest_udp.string)
            {
                for(pos = 0; pos < logq_ind; )
                {
                    if(log_dest_buffer_pos == 0)
                        Log_DestBuffer_Init();
                    n = min(sizeof(log_dest_buffer) - log_dest_buffer_pos - 1, logq_ind - pos);
                    memcpy(log_dest_buffer + log_dest_buffer_pos, temp + pos, n);
                    log_dest_buffer_pos += n;
                    Log_DestBuffer_Flush_NoLock();
                    pos += n;
                }
            }
        }
        Mem_Free (temp);
        logq_ind = 0;
        logq_size = 0;
    }
}

References FS_Write(), log_dest_buffer, log_dest_buffer_pos, log_dest_udp, Log_DestBuffer_Flush_NoLock(), Log_DestBuffer_Init(), Log_Open(), logfile, logq_ind, logq_size, logqueue, Mem_Free, min, n, NULL, and cvar_t::string.

Referenced by Host_Init().

Variable Documentation

con_backscroll

int con_backscroll

extern

Definition at line 37 of file console.c.

Referenced by Con_CheckResize(), Con_DrawConsole(), Con_LastVisibleLine(), Key_Console(), and Key_Parse_CommonKeys().

con_initialized

qbool con_initialized

extern

Definition at line 97 of file console.c.

Referenced by CL_UpdateScreen(), Con_Init(), and Con_MaskPrint().

con_totallines

int con_totallines

extern