common.c File Reference

#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include "quakedef.h"
#include "utf8lib.h"

Include dependency graph for common.c:

Go to the source code of this file.

Macros
#define	APPEND(ch)

Functions
static void	base64_3to4 (const unsigned char *in, unsigned char *out, int bytes)
size_t	base64_encode (unsigned char *buf, size_t buflen, size_t outbuflen)
float	Com_CalcRoll (const vec3_t angles, const vec3_t velocity, const vec_t angleval, const vec_t velocityval)
void	Com_HexDumpToConsole (const unsigned char *data, int size)
void	COM_Init_Commands (void)
qbool	COM_ParseToken_Console (const char **datapointer)
qbool	COM_ParseToken_QuakeC (const char **datapointer, qbool returnnewline)
qbool	COM_ParseToken_Simple (const char **datapointer, qbool returnnewline, qbool parsebackslash, qbool parsecomments)
qbool	COM_ParseToken_VM_Tokenize (const char **datapointer, qbool returnnewline)
int	COM_ReadAndTokenizeLine (const char **text, char **argv, int maxargc, char *tokenbuf, int tokenbufsize, const char *commentprefix)
int	COM_StringBeginsWith (const char *s, const char *match)
size_t	COM_StringDecolorize (const char *in, size_t size_in, char *out, size_t size_out, qbool escape_carets)
size_t	COM_StringLengthNoColors (const char *s, size_t size_s, qbool *valid)
size_t	COM_ToLowerString (const char *in, char *out, size_t size_out)
	Returns the number of bytes written to *out excluding the \0 terminator.
size_t	COM_ToUpperString (const char *in, char *out, size_t size_out)
	Returns the number of bytes written to *out excluding the \0 terminator.
int	COM_Wordwrap (const char *string, size_t length, float continuationWidth, float maxWidth, COM_WordWidthFunc_t wordWidth, void *passthroughCW, COM_LineProcessorFunc processLine, void *passthroughPL)
size_t	dp__strlcat (char *dst, const char *src, size_t dsize, const char *func, unsigned line)
	Catenates a string, like strlcat() but with a better return: the number of bytes copied excluding the \0 terminator.
size_t	dp__strlcpy (char *dst, const char *src, size_t dsize, const char *func, unsigned line)
	Copies a string, like strlcpy() but with a better return: the number of bytes copied excluding the \0 terminator.
char *	dp_stpecpy (char *dst, char *end, const char *src)
	Chain-copies a string with truncation and efficiency (compared to strlcat()).
char *	dp_ustr2stp (char *dst, size_t dsize, const char *src, size_t slen)
	Copies a measured byte sequence (unterminated string) to a null-terminated string.
int	dpsnprintf (char *buffer, size_t buffersize, const char *format,...)
	Returns the number of printed characters, excluding the final '\0' or returns -1 if the buffer isn't big enough to contain the entire string.
int	dpvsnprintf (char *buffer, size_t buffersize, const char *format, va_list args)
	Returns the number of printed characters, excluding the final '\0' or returns -1 if the buffer isn't big enough to contain the entire string.
void	FindFraction (double val, int *num, int *denom, int denomMax)
void	SZ_Clear (sizebuf_t *buf)
unsigned char *	SZ_GetSpace (sizebuf_t *buf, int length)
void	SZ_HexDumpToConsole (const sizebuf_t *buf)
void	SZ_Write (sizebuf_t *buf, const unsigned char *data, int length)
char *	va (char *buf, size_t buflen, const char *format,...)
char **	XPM_DecodeString (const char *in)

Variables
static const char	base64 [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
cvar_t	cl_playermodel = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playermodel", "", "current player model in Nexuiz/Xonotic"}
cvar_t	cl_playerskin = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playerskin", "", "current player skin in Nexuiz/Xonotic"}
cvar_t	cmdline = {CF_CLIENT | CF_SERVER | CF_READONLY, "cmdline","0", "contains commandline the engine was launched with"}
char	com_token [MAX_INPUTLINE]
unsigned	com_token_len
static const char *	hexchar = "0123456789ABCDEF"
cvar_t	registered = {CF_CLIENT | CF_SERVER | CF_READONLY, "registered","0", "indicates if this is running registered quake (whether gfx/pop.lmp was found)"}

Macro Definition Documentation

APPEND

#define APPEND

(

ch

)

Value:

do { if(--size_out) { *out++ = (ch); } else { *out++ = 0; return 0; } } while(0)

Referenced by COM_StringDecolorize().

Function Documentation

base64_3to4()

static void base64_3to4 ( const unsigned char * in, unsigned char * out, int bytes )

static

Definition at line 1487 of file common.c.

{
    unsigned char i0 = (bytes > 0) ? in[0] : 0;
    unsigned char i1 = (bytes > 1) ? in[1] : 0;
    unsigned char i2 = (bytes > 2) ? in[2] : 0;
    unsigned char o0 = base64[i0 >> 2];
    unsigned char o1 = base64[((i0 << 4) | (i1 >> 4)) & 077];
    unsigned char o2 = base64[((i1 << 2) | (i2 >> 6)) & 077];
    unsigned char o3 = base64[i2 & 077];
    out[0] = (bytes > 0) ? o0 : '?';
    out[1] = (bytes > 0) ? o1 : '?';
    out[2] = (bytes > 1) ? o2 : '=';
    out[3] = (bytes > 2) ? o3 : '=';
}

References base64.

Referenced by base64_encode().

base64_encode()

size_t base64_encode	(	unsigned char *	buf,
		size_t	buflen,
		size_t	outbuflen )

Definition at line 1502 of file common.c.

{
    size_t blocks, i;
    // expand the out-buffer
    blocks = (buflen + 2) / 3;
    if(blocks*4 > outbuflen)
        return 0;
    for(i = blocks; i > 0; )
    {
        --i;
        base64_3to4(buf + 3*i, buf + 4*i, (int)(buflen - 3*i));
    }
    return blocks * 4;
}

References base64_3to4(), buf, and i.

Referenced by Crypto_KeyGen_f(), and VM_uri_get().

Com_CalcRoll()

float Com_CalcRoll	(	const vec3_t	angles,
		const vec3_t	velocity,
		const vec_t	angleval,
		const vec_t	velocityval )

Definition at line 890 of file common.c.

{
    vec3_t  forward, right, up;
    float   sign;
    float   side;
 
    AngleVectors (angles, forward, right, up);
    side = DotProduct (velocity, right);
    sign = side < 0 ? -1 : 1;
    side = fabs(side);
 
    if (side < velocityval)
        side = side * angleval / velocityval;
    else
        side = angleval;
 
    return side*sign;
 
}

References angles, AngleVectors(), DotProduct, fabs(), forward, right, up, and velocity.

Referenced by EntityStateQW_ReadPlayerUpdate(), SV_PlayerPhysics(), and V_CalcRefdefUsing().

Com_HexDumpToConsole()

void Com_HexDumpToConsole	(	const unsigned char *	data,
		int	size )

Definition at line 82 of file common.c.

{
    int i, j, n;
    char text[1024];
    char *cur, *flushpointer;
    const unsigned char *d;
    cur = text;
    flushpointer = text + 512;
    for (i = 0;i < size;)
    {
        n = 16;
        if (n > size - i)
            n = size - i;
        d = data + i;
        // print offset
        *cur++ = hexchar[(i >> 12) & 15];
        *cur++ = hexchar[(i >>  8) & 15];
        *cur++ = hexchar[(i >>  4) & 15];
        *cur++ = hexchar[(i >>  0) & 15];
        *cur++ = ':';
        // print hex
        for (j = 0;j < 16;j++)
        {
            if (j < n)
            {
                *cur++ = hexchar[(d[j] >> 4) & 15];
                *cur++ = hexchar[(d[j] >> 0) & 15];
            }
            else
            {
                *cur++ = ' ';
                *cur++ = ' ';
            }
            if ((j & 3) == 3)
                *cur++ = ' ';
        }
        // print text
        for (j = 0;j < 16;j++)
        {
            if (j < n)
            {
                // color change prefix character has to be treated specially
                if (d[j] == STRING_COLOR_TAG)
                {
                    *cur++ = STRING_COLOR_TAG;
                    *cur++ = STRING_COLOR_TAG;
                }
                else if (d[j] >= (unsigned char) ' ')
                    *cur++ = d[j];
                else
                    *cur++ = '.';
            }
            else
                *cur++ = ' ';
        }
        *cur++ = '\n';
        i += n;
        if (cur >= flushpointer || i >= size)
        {
            *cur++ = 0;
            Con_Print(text);
            cur = text;
        }
    }
}

References Con_Print(), data, hexchar, i, n, size, and STRING_COLOR_TAG.

Referenced by Crypto_DecryptPacket(), Crypto_EncryptPacket(), Crypto_KeyGen_Finished(), NetConn_ClientParsePacket(), NetConn_Read(), NetConn_ServerParsePacket(), NetConn_Write(), SV_ReadClientMessage(), and SZ_HexDumpToConsole().

COM_Init_Commands()

void COM_Init_Commands

(

void

)

Definition at line 917 of file common.c.

{
    int i, j, n;
    char com_cmdline[MAX_INPUTLINE];
 
    Cvar_RegisterVariable (&registered);
    Cvar_RegisterVariable (&cmdline);
    Cvar_RegisterVariable(&cl_playermodel);
    Cvar_RegisterVirtual(&cl_playermodel, "_cl_playermodel");
    Cvar_RegisterVariable(&cl_playerskin);
    Cvar_RegisterVirtual(&cl_playerskin, "_cl_playerskin");
 
    // reconstitute the command line for the cmdline externally visible cvar
    n = 0;
    for (j = 0;(j < MAX_NUM_ARGVS) && (j < sys.argc);j++)
    {
        i = 0;
        if (strstr(sys.argv[j], " "))
        {
            // arg contains whitespace, store quotes around it
            // This condition checks whether we can allow to put
            // in two quote characters.
            if (n >= ((int)sizeof(com_cmdline) - 2))
                break;
            com_cmdline[n++] = '\"';
            // This condition checks whether we can allow one
            // more character and a quote character.
            while ((n < ((int)sizeof(com_cmdline) - 2)) && sys.argv[j][i])
                // FIXME: Doesn't quote special characters.
                com_cmdline[n++] = sys.argv[j][i++];
            com_cmdline[n++] = '\"';
        }
        else
        {
            // This condition checks whether we can allow one
            // more character.
            while ((n < ((int)sizeof(com_cmdline) - 1)) && sys.argv[j][i])
                com_cmdline[n++] = sys.argv[j][i++];
        }
        if (n < ((int)sizeof(com_cmdline) - 1))
            com_cmdline[n++] = ' ';
        else
            break;
    }
    com_cmdline[n] = 0;
    Cvar_SetQuick(&cmdline, com_cmdline);
}

References sys_t::argc, sys_t::argv, cl_playermodel, cl_playerskin, cmdline, Cvar_RegisterVariable(), Cvar_RegisterVirtual(), Cvar_SetQuick(), i, MAX_INPUTLINE, MAX_NUM_ARGVS, n, registered, and sys.

Referenced by Host_Init().

COM_ParseToken_Console()

qbool COM_ParseToken_Console

(

const char **

datapointer

)

Definition at line 819 of file common.c.

{
    int len;
    const char *data = *datapointer;
 
    com_token_len = len = 0;
    com_token[0] = '\0';
 
    if (!data)
    {
        *datapointer = NULL;
        return false;
    }
 
// skip whitespace
skipwhite:
    for (;ISWHITESPACE(*data);data++)
    {
        if (*data == 0)
        {
            // end of file
            *datapointer = NULL;
            return false;
        }
    }
 
    if (*data == '/' && data[1] == '/')
    {
        // comment
        while (*data && *data != '\n' && *data != '\r')
            data++;
        goto skipwhite;
    }
    else if (*data == '\"')
    {
        // quoted string
        for (data++;*data && *data != '\"';data++)
        {
            // allow escaped " and \ case
            if (*data == '\\' && (data[1] == '\"' || data[1] == '\\'))
                data++;
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = *data;
        }
        com_token[len] = '\0';
        com_token_len = len;
        if (*data == '\"')
            data++;
        *datapointer = data;
    }
    else
    {
        // regular word
        for (;!ISWHITESPACE(*data);data++)
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = *data;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
    }
 
    return true;
}

References com_token, com_token_len, data, ISWHITESPACE, and NULL.

Referenced by CDAudio_StartPlaylist(), Cmd_GetDirectCvarValue(), Cmd_TokenizeString(), COM_InsertFlags(), Log_DestBuffer_Flush_NoLock(), Memory_Init_Commands(), PRVM_ED_ParseEdict(), RCon_Authenticate(), and VM_tokenize_console().

COM_ParseToken_QuakeC()

qbool COM_ParseToken_QuakeC	(	const char **	datapointer,
		qbool	returnnewline )

Definition at line 581 of file common.c.

{
    int len;
    int c;
    const char *data = *datapointer;
 
    com_token_len = len = 0;
    com_token[0] = '\0';
 
    if (!data)
    {
        *datapointer = NULL;
        return false;
    }
 
// skip whitespace
skipwhite:
    // line endings:
    // UNIX: \n
    // Mac: \r
    // Windows: \r\n
    for (;ISWHITESPACE(*data) && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
    {
        if (*data == 0)
        {
            // end of file
            *datapointer = NULL;
            return false;
        }
    }
 
    // handle Windows line ending
    if (data[0] == '\r' && data[1] == '\n')
        data++;
 
    if (data[0] == '/' && data[1] == '/')
    {
        // comment
        while (*data && *data != '\n' && *data != '\r')
            data++;
        goto skipwhite;
    }
    else if (data[0] == '/' && data[1] == '*')
    {
        // comment
        data++;
        while (*data && (data[0] != '*' || data[1] != '/'))
            data++;
        if (*data)
            data++;
        if (*data)
            data++;
        goto skipwhite;
    }
    else if (*data == '\"' || *data == '\'')
    {
        // quoted string
        char quote = *data;
        for (data++;*data && *data != quote;data++)
        {
            c = *data;
            if (*data == '\\')
            {
                data++;
                c = *data;
                if (c == 'n')
                    c = '\n';
                else if (c == 't')
                    c = '\t';
            }
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = c;
        }
        com_token[len] = '\0';
        com_token_len = len;
        if (*data == quote)
            data++;
        *datapointer = data;
        return true;
    }
    else if (*data == '\r')
    {
        // translate Mac line ending to UNIX
        com_token[len++] = '\n';data++;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
    else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == ':' || *data == ',' || *data == ';')
    {
        // single character
        com_token[len++] = *data++;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
    else
    {
        // regular word
        for (;!ISWHITESPACE(*data) && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != ':' && *data != ',' && *data != ';';data++)
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = *data;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
}

References com_token, com_token_len, data, ISWHITESPACE, and NULL.

Referenced by LoadSubtitles(), Mod_LoadQ3Shaders(), Mod_LoadSkinFiles(), and XPM_DecodeString().

COM_ParseToken_Simple()

qbool COM_ParseToken_Simple	(	const char **	datapointer,
		qbool	returnnewline,
		qbool	parsebackslash,
		qbool	parsecomments )

Definition at line 463 of file common.c.

{
    int len;
    int c;
    const char *data = *datapointer;
 
    com_token_len = len = 0;
    com_token[0] = '\0';
 
    if (!data)
    {
        *datapointer = NULL;
        return false;
    }
 
// skip whitespace
skipwhite:
    // line endings:
    // UNIX: \n
    // Mac: \r
    // Windows: \r\n
    for (;ISWHITESPACE(*data) && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
    {
        if (*data == 0)
        {
            // end of file
            *datapointer = NULL;
            return false;
        }
    }
 
    // handle Windows line ending
    if (data[0] == '\r' && data[1] == '\n')
        data++;
 
    if (parsecomments && data[0] == '/' && data[1] == '/')
    {
        // comment
        while (*data && *data != '\n' && *data != '\r')
            data++;
        goto skipwhite;
    }
    else if (parsecomments && data[0] == '/' && data[1] == '*')
    {
        // comment
        data++;
        while (*data && (data[0] != '*' || data[1] != '/'))
            data++;
        if (*data)
            data++;
        if (*data)
            data++;
        goto skipwhite;
    }
    else if (*data == '\"')
    {
        // quoted string
        for (data++;*data && *data != '\"';data++)
        {
            c = *data;
            if (*data == '\\' && parsebackslash)
            {
                data++;
                c = *data;
                if (c == 'n')
                    c = '\n';
                else if (c == 't')
                    c = '\t';
            }
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = c;
        }
        com_token[len] = '\0';
        com_token_len = len;
        if (*data == '\"')
            data++;
        *datapointer = data;
        return true;
    }
    else if (*data == '\r')
    {
        // translate Mac line ending to UNIX
        com_token[len++] = '\n';data++;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
    else if (*data == '\n')
    {
        // single character
        com_token[len++] = *data++;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
    else
    {
        // regular word
        for (;!ISWHITESPACE(*data);data++)
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = *data;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
}

References com_token, com_token_len, data, ISWHITESPACE, and NULL.

Referenced by CL_ParseEntityLump(), CL_Particles_ParseEffectInfo(), Con_CompleteCommandLine(), Curl_SendRequirements(), GetMapList(), LoadFont(), M_ScanSaves(), Mod_FrameGroupify_ParseGroups(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_ParseWadsFromEntityLump(), Mod_Q3BSP_LoadEntities(), PRVM_ED_LoadFromFile(), PRVM_ED_ParseEdict(), PRVM_ED_ParseGlobals(), R_InitParticleTexture(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), SV_Kick_f(), SV_Loadgame_f(), SV_ParticleEffectIndex(), and VM_parseentitydata().

COM_ParseToken_VM_Tokenize()

qbool COM_ParseToken_VM_Tokenize	(	const char **	datapointer,
		qbool	returnnewline )

Definition at line 700 of file common.c.

{
    int len;
    int c;
    const char *data = *datapointer;
 
    com_token_len = len = 0;
    com_token[0] = '\0';
 
    if (!data)
    {
        *datapointer = NULL;
        return false;
    }
 
// skip whitespace
skipwhite:
    // line endings:
    // UNIX: \n
    // Mac: \r
    // Windows: \r\n
    for (;ISWHITESPACE(*data) && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
    {
        if (*data == 0)
        {
            // end of file
            *datapointer = NULL;
            return false;
        }
    }
 
    // handle Windows line ending
    if (data[0] == '\r' && data[1] == '\n')
        data++;
 
    if (data[0] == '/' && data[1] == '/')
    {
        // comment
        while (*data && *data != '\n' && *data != '\r')
            data++;
        goto skipwhite;
    }
    else if (data[0] == '/' && data[1] == '*')
    {
        // comment
        data++;
        while (*data && (data[0] != '*' || data[1] != '/'))
            data++;
        if (*data)
            data++;
        if (*data)
            data++;
        goto skipwhite;
    }
    else if (*data == '\"' || *data == '\'')
    {
        char quote = *data;
        // quoted string
        for (data++;*data && *data != quote;data++)
        {
            c = *data;
            if (*data == '\\')
            {
                data++;
                c = *data;
                if (c == 'n')
                    c = '\n';
                else if (c == 't')
                    c = '\t';
            }
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = c;
        }
        com_token[len] = '\0';
        com_token_len = len;
        if (*data == quote)
            data++;
        *datapointer = data;
        return true;
    }
    else if (*data == '\r')
    {
        // translate Mac line ending to UNIX
        com_token[len++] = '\n';data++;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
    else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == ':' || *data == ',' || *data == ';')
    {
        // single character
        com_token[len++] = *data++;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
    else
    {
        // regular word
        for (;!ISWHITESPACE(*data) && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != ':' && *data != ',' && *data != ';';data++)
            if (len < (int)sizeof(com_token) - 1)
                com_token[len++] = *data;
        com_token[len] = '\0';
        com_token_len = len;
        *datapointer = data;
        return true;
    }
}

References com_token, com_token_len, data, ISWHITESPACE, and NULL.

Referenced by VM_loadfont(), and VM_tokenize().

COM_ReadAndTokenizeLine()

int COM_ReadAndTokenizeLine	(	const char **	text,
		char **	argv,
		int	maxargc,
		char *	tokenbuf,
		int	tokenbufsize,
		const char *	commentprefix )

Definition at line 1131 of file common.c.

{
    int argc, commentprefixlength;
    char *tokenbufend;
    const char *l;
    argc = 0;
    tokenbufend = tokenbuf + tokenbufsize;
    l = *text;
    commentprefixlength = 0;
    if (commentprefix)
        commentprefixlength = (int)strlen(commentprefix);
    while (*l && *l != '\n' && *l != '\r')
    {
        if (!ISWHITESPACE(*l))
        {
            if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
            {
                while (*l && *l != '\n' && *l != '\r')
                    l++;
                break;
            }
            if (argc >= maxargc)
                return -1;
            argv[argc++] = tokenbuf;
            if (*l == '"')
            {
                l++;
                while (*l && *l != '"')
                {
                    if (tokenbuf >= tokenbufend)
                        return -1;
                    *tokenbuf++ = *l++;
                }
                if (*l == '"')
                    l++;
            }
            else
            {
                while (!ISWHITESPACE(*l))
                {
                    if (tokenbuf >= tokenbufend)
                        return -1;
                    *tokenbuf++ = *l++;
                }
            }
            if (tokenbuf >= tokenbufend)
                return -1;
            *tokenbuf++ = 0;
        }
        else
            l++;
    }
    // line endings:
    // UNIX: \n
    // Mac: \r
    // Windows: \r\n
    if (*l == '\r')
        l++;
    if (*l == '\n')
        l++;
    *text = l;
    return argc;
}

References argv(), int(), ISWHITESPACE, and strlen().

COM_StringBeginsWith()

int COM_StringBeginsWith	(	const char *	s,
		const char *	match )

Definition at line 1123 of file common.c.

{
    for (;*s && *match;s++, match++)
        if (*s != *match)
            return false;
    return true;
}

COM_StringDecolorize()

size_t COM_StringDecolorize	(	const char *	in,
		size_t	size_in,
		char *	out,
		size_t	size_out,
		qbool	escape_carets )

Definition at line 1286 of file common.c.

{
#define APPEND(ch) do { if(--size_out) { *out++ = (ch); } else { *out++ = 0; return 0; } } while(0)
 
    const char *out_start = out;
    const char *end = size_in ? (in + size_in) : NULL;
 
    if(size_out < 1)
        return 0;
    for(;;)
    {
        switch((in == end) ? 0 : *in)
        {
            case 0:
                *out = '\0';
                return out - out_start;
            case STRING_COLOR_TAG:
                ++in;
                switch((in == end) ? 0 : *in)
                {
                    case STRING_COLOR_RGB_TAG_CHAR:
                        if (in+1 != end && isxdigit(in[1]) &&
                            in+2 != end && isxdigit(in[2]) &&
                            in+3 != end && isxdigit(in[3]) )
                        {
                            in+=3;
                            break;
                        }
                        APPEND(STRING_COLOR_TAG);
                        if(escape_carets)
                            APPEND(STRING_COLOR_TAG);
                        APPEND(STRING_COLOR_RGB_TAG_CHAR);
                        break;
                    case 0: // ends with unfinished color code!
                        APPEND(STRING_COLOR_TAG);
                        // finish the code by appending another caret when escaping
                        if(escape_carets)
                            APPEND(STRING_COLOR_TAG);
                        *out = '\0';
                        return out - out_start;
                    case STRING_COLOR_TAG: // escaped ^
                        APPEND(STRING_COLOR_TAG);
                        // append a ^ twice when escaping
                        if(escape_carets)
                            APPEND(STRING_COLOR_TAG);
                        break;
                    case '0': case '1': case '2': case '3': case '4':
                    case '5': case '6': case '7': case '8': case '9': // color code
                        break;
                    default: // not a color code
                        APPEND(STRING_COLOR_TAG);
                        APPEND(*in);
                        break;
                }
                break;
            default:
                APPEND(*in);
                break;
        }
        ++in;
    }
    // never get here
#undef APPEND
}

References APPEND, NULL, STRING_COLOR_RGB_TAG_CHAR, and STRING_COLOR_TAG.

Referenced by VM_strdecolorize(), and VM_uncolorstring().

COM_StringLengthNoColors()

size_t COM_StringLengthNoColors	(	const char *	s,
		size_t	size_s,
		qbool *	valid )

Definition at line 1212 of file common.c.

{
    const char *end = size_s ? (s + size_s) : NULL;
    size_t len = 0;
    for(;;)
    {
        switch((s == end) ? 0 : *s)
        {
            case 0:
                if(valid)
                    *valid = true;
                return len;
            case STRING_COLOR_TAG:
                ++s;
                switch((s == end) ? 0 : *s)
                {
                    case STRING_COLOR_RGB_TAG_CHAR:
                        if (s+1 != end && isxdigit(s[1]) &&
                            s+2 != end && isxdigit(s[2]) &&
                            s+3 != end && isxdigit(s[3]) )
                        {
                            s+=3;
                            break;
                        }
                        ++len; // STRING_COLOR_TAG
                        ++len; // STRING_COLOR_RGB_TAG_CHAR
                        break;
                    case 0: // ends with unfinished color code!
                        ++len;
                        if(valid)
                            *valid = false;
                        return len;
                    case STRING_COLOR_TAG: // escaped ^
                        ++len;
                        break;
                    case '0': case '1': case '2': case '3': case '4':
                    case '5': case '6': case '7': case '8': case '9': // color code
                        break;
                    default: // not a color code
                        ++len; // STRING_COLOR_TAG
                        ++len; // the character
                        break;
                }
                break;
            default:
                ++len;
                break;
        }
        ++s;
    }
    // never get here
}

References NULL, STRING_COLOR_RGB_TAG_CHAR, and STRING_COLOR_TAG.

Referenced by u8_COM_StringLengthNoColors().

COM_ToLowerString()

size_t COM_ToLowerString	(	const char *	in,
		char *	out,
		size_t	size_out )

Returns the number of bytes written to *out excluding the \0 terminator.

Definition at line 1051 of file common.c.

{
    const char *out_start = out;
 
    if (size_out == 0)
        return 0;
 
    if(utf8_enable.integer)
    {
        *out = 0;
        while(*in && size_out > 1)
        {
            int n;
            Uchar ch = u8_getchar_utf8_enabled(in, &in);
            ch = u8_tolower(ch);
            n = u8_fromchar(ch, out, size_out);
            out += n; // before the break so the return is correct
            if(n <= 0)
                break;
            size_out -= n;
        }
        return out - out_start;
    }
 
    while (*in && size_out > 1)
    {
        if (*in >= 'A' && *in <= 'Z')
            *out++ = *in++ + 'a' - 'A';
        else
            *out++ = *in++;
        size_out--;
    }
    *out = '\0';
    return out - out_start;
}

References cvar_t::integer, n, u8_fromchar(), u8_getchar_utf8_enabled(), u8_tolower(), and utf8_enable.

Referenced by COM_InitGameType(), and VM_strtolower().

COM_ToUpperString()

size_t COM_ToUpperString	(	const char *	in,
		char *	out,
		size_t	size_out )

Returns the number of bytes written to *out excluding the \0 terminator.

Definition at line 1087 of file common.c.

{
    const char *out_start = out;
 
    if (size_out == 0)
        return 0;
 
    if(utf8_enable.integer)
    {
        *out = 0;
        while(*in && size_out > 1)
        {
            int n;
            Uchar ch = u8_getchar_utf8_enabled(in, &in);
            ch = u8_toupper(ch);
            n = u8_fromchar(ch, out, size_out);
            out += n; // before the break so the return is correct
            if(n <= 0)
                break;
            size_out -= n;
        }
        return out - out_start;
    }
 
    while (*in && size_out > 1)
    {
        if (*in >= 'a' && *in <= 'z')
            *out++ = *in++ + 'A' - 'a';
        else
            *out++ = *in++;
        size_out--;
    }
    *out = '\0';
    return out - out_start;
}

References cvar_t::integer, n, u8_fromchar(), u8_getchar_utf8_enabled(), u8_toupper(), and utf8_enable.

Referenced by VM_strtoupper().

COM_Wordwrap()

int COM_Wordwrap	(	const char *	string,
		size_t	length,
		float	continuationWidth,
		float	maxWidth,
		COM_WordWidthFunc_t	wordWidth,
		void *	passthroughCW,
		COM_LineProcessorFunc	processLine,
		void *	passthroughPL )

Definition at line 174 of file common.c.

{
    // Logic is as follows:
    //
    // For each word or whitespace:
    //   Newline found? Output current line, advance to next line. This is not a continuation. Continue.
    //   Space found? Always add it to the current line, no matter if it fits.
    //   Word found? Check if current line + current word fits.
    //     If it fits, append it. Continue.
    //     If it doesn't fit, output current line, advance to next line. Append the word. This is a continuation. Continue.
 
    qbool isContinuation = false;
    float spaceWidth;
    const char *startOfLine = string;
    const char *cursor = string;
    const char *end = string + length;
    float spaceUsedInLine = 0;
    float spaceUsedForWord;
    int result = 0;
    size_t wordLen;
    size_t dummy;
 
    dummy = 0;
    wordWidth(passthroughCW, NULL, &dummy, -1);
    dummy = 1;
    spaceWidth = wordWidth(passthroughCW, " ", &dummy, -1);
 
    for(;;)
    {
        char ch = (cursor < end) ? *cursor : 0;
        switch(ch)
        {
            case 0: // end of string
                result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation);
                goto out;
            case '\n': // end of line
                result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation);
                isContinuation = false;
                ++cursor;
                startOfLine = cursor;
                break;
            case ' ': // space
                ++cursor;
                spaceUsedInLine += spaceWidth;
                break;
            default: // word
                wordLen = 1;
                while(cursor + wordLen < end)
                {
                    switch(cursor[wordLen])
                    {
                        case 0:
                        case '\n':
                        case ' ':
                            goto out_inner;
                        default:
                            ++wordLen;
                            break;
                    }
                }
                out_inner:
                spaceUsedForWord = wordWidth(passthroughCW, cursor, &wordLen, maxWidth - continuationWidth); // this may have reduced wordLen when it won't fit - but this is GOOD. TODO fix words that do fit in a non-continuation line
                if(wordLen < 1) // cannot happen according to current spec of wordWidth
                {
                    wordLen = 1;
                    spaceUsedForWord = maxWidth + 1; // too high, forces it in a line of itself
                }
                if(spaceUsedInLine + spaceUsedForWord <= maxWidth || cursor == startOfLine)
                {
                    // we can simply append it
                    cursor += wordLen;
                    spaceUsedInLine += spaceUsedForWord;
                }
                else
                {
                    // output current line
                    result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation);
                    isContinuation = true;
                    startOfLine = cursor;
                    cursor += wordLen;
                    spaceUsedInLine = continuationWidth + spaceUsedForWord;
                }
        }
    }
    out:
 
    return result;
 
/*
    qbool isContinuation = false;
    float currentWordSpace = 0;
    const char *currentWord = 0;
    float minReserve = 0;
 
    float spaceUsedInLine = 0;
    const char *currentLine = 0;
    const char *currentLineEnd = 0;
    float currentLineFinalWhitespace = 0;
    const char *p;
 
    int result = 0;
    minReserve = charWidth(passthroughCW, 0);
    minReserve += charWidth(passthroughCW, ' ');
 
    if(maxWidth < continuationWidth + minReserve)
        maxWidth = continuationWidth + minReserve;
 
    charWidth(passthroughCW, 0);
 
    for(p = string; p < string + length; ++p)
    {
        char c = *p;
        float w = charWidth(passthroughCW, c);
 
        if(!currentWord)
        {
            currentWord = p;
            currentWordSpace = 0;
        }
 
        if(!currentLine)
        {
            currentLine = p;
            spaceUsedInLine = isContinuation ? continuationWidth : 0;
            currentLineEnd = 0;
        }
 
        if(c == ' ')
        {
            // 1. I can add the word AND a space - then just append it.
            if(spaceUsedInLine + currentWordSpace + w <= maxWidth)
            {
                currentLineEnd = p; // note: space not included here
                currentLineFinalWhitespace = w;
                spaceUsedInLine += currentWordSpace + w;
            }
            // 2. I can just add the word - then append it, output current line and go to next one.
            else if(spaceUsedInLine + currentWordSpace <= maxWidth)
            {
                result += processLine(passthroughPL, currentLine, p - currentLine, spaceUsedInLine + currentWordSpace, isContinuation);
                currentLine = 0;
                isContinuation = true;
            }
            // 3. Otherwise, output current line and go to next one, where I can add the word.
            else if(continuationWidth + currentWordSpace + w <= maxWidth)
            {
                if(currentLineEnd)
                    result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
                currentLine = currentWord;
                spaceUsedInLine = continuationWidth + currentWordSpace + w;
                currentLineEnd = p;
                currentLineFinalWhitespace = w;
                isContinuation = true;
            }
            // 4. We can't even do that? Then output both current and next word as new lines.
            else
            {
                if(currentLineEnd)
                {
                    result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
                    isContinuation = true;
                }
                result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace, isContinuation);
                currentLine = 0;
                isContinuation = true;
            }
            currentWord = 0;
        }
        else if(c == '\n')
        {
            // 1. I can add the word - then do it.
            if(spaceUsedInLine + currentWordSpace <= maxWidth)
            {
                result += processLine(passthroughPL, currentLine, p - currentLine, spaceUsedInLine + currentWordSpace, isContinuation);
            }
            // 2. Otherwise, output current line, next one and make tabula rasa.
            else
            {
                if(currentLineEnd)
                {
                    processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
                    isContinuation = true;
                }
                result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace, isContinuation);
            }
            currentWord = 0;
            currentLine = 0;
            isContinuation = false;
        }
        else
        {
            currentWordSpace += w;
            if(
                spaceUsedInLine + currentWordSpace > maxWidth // can't join this line...
                &&
                continuationWidth + currentWordSpace > maxWidth // can't join any other line...
            )
            {
                // this word cannot join ANY line...
                // so output the current line...
                if(currentLineEnd)
                {
                    result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
                    isContinuation = true;
                }
 
                // then this word's beginning...
                if(isContinuation)
                {
                    // it may not fit, but we know we have to split it into maxWidth - continuationWidth pieces
                    float pieceWidth = maxWidth - continuationWidth;
                    const char *pos = currentWord;
                    currentWordSpace = 0;
 
                    // reset the char width function to a state where no kerning occurs (start of word)
                    charWidth(passthroughCW, ' ');
                    while(pos <= p)
                    {
                        float w = charWidth(passthroughCW, *pos);
                        if(currentWordSpace + w > pieceWidth) // this piece won't fit any more
                        {
                            // print everything until it
                            result += processLine(passthroughPL, currentWord, pos - currentWord, currentWordSpace, true);
                            // go to here
                            currentWord = pos;
                            currentWordSpace = 0;
                        }
                        currentWordSpace += w;
                        ++pos;
                    }
                    // now we have a currentWord that fits... set up its next line
                    // currentWordSpace has been set
                    // currentWord has been set
                    spaceUsedInLine = continuationWidth;
                    currentLine = currentWord;
                    currentLineEnd = 0;
                    isContinuation = true;
                }
                else
                {
                    // we have a guarantee that it will fix (see if clause)
                    result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace - w, isContinuation);
 
                    // and use the rest of this word as new start of a line
                    currentWordSpace = w;
                    currentWord = p;
                    spaceUsedInLine = continuationWidth;
                    currentLine = p;
                    currentLineEnd = 0;
                    isContinuation = true;
                }
            }
        }
    }
 
    if(!currentWord)
    {
        currentWord = p;
        currentWordSpace = 0;
    }
 
    if(currentLine) // Same procedure as \n
    {
        // Can I append the current word?
        if(spaceUsedInLine + currentWordSpace <= maxWidth)
            result += processLine(passthroughPL, currentLine, p - currentLine, spaceUsedInLine + currentWordSpace, isContinuation);
        else
        {
            if(currentLineEnd)
            {
                result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
                isContinuation = true;
            }
            result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace, isContinuation);
        }
    }
 
    return result;
*/
}

References length, NULL, and string.

Referenced by CL_DrawVideo(), Con_DrawConsoleLine(), Con_DrawNotifyRect(), and Con_LineHeight().

dp__strlcat()

size_t dp__strlcat	(	char *	dst,
		const char *	src,
		size_t	dsize,
		const char *	func,
		unsigned	line )

Catenates a string, like strlcat() but with a better return: the number of bytes copied excluding the \0 terminator.

Truncates and warns on overflow or unterminated source, whereas strlcat() truncates silently and overreads (possibly segfaulting). Guarantees \0 termination. Inefficient like any strcat(), please use memcpy(), dp_stpecpy() or dp_strlcpy() instead.

Definition at line 1423 of file common.c.

{
    size_t offset;
    char *p = (char *)memchr(dst, '\0', dsize);
 
    if (!p)
        p = dst;
    offset = p - dst;
    return dp__strlcpy(p, src, dsize - offset, func, line) + offset;
}

References dp__strlcpy(), offset, and src.

dp__strlcpy()

size_t dp__strlcpy	(	char *	dst,
		const char *	src,
		size_t	dsize,
		const char *	func,
		unsigned	line )

Copies a string, like strlcpy() but with a better return: the number of bytes copied excluding the \0 terminator.

Truncates and warns on overflow or unterminated source, whereas strlcpy() truncates silently and overreads (possibly segfaulting). Guarantees \0 termination. See also: dp_stpecpy() and dp_ustr2stp().

Definition at line 1406 of file common.c.

{
    char *p = (char *)memccpy(dst, src, '\0', dsize);
 
    if (p)
        return (p - 1) - dst;
    dst[dsize - 1] = '\0';
    Con_Printf(CON_WARN "%s:%u: src string unterminated or truncated to %lu bytes: \"%s\"\n", func, line, (unsigned long)dsize - 1, dst);
    return dsize - 1;
}

References Con_Printf(), CON_WARN, and src.

Referenced by dp__strlcat().

dp_stpecpy()

char * dp_stpecpy	(	char *	dst,
		char *	end,
		const char *	src )

Chain-copies a string with truncation and efficiency (compared to strlcat()).

The destination ends at an absolute pointer instead of a relative offset and a pointer to the \0 terminator is returned on success. Truncates, warns, and returns the end pointer on overflow or unterminated source. Guarantees \0 termination. end = dst + sizeof(src[])

Definition at line 1373 of file common.c.

{
    char *p = (char *)memccpy(dst, src, '\0', end - dst);
 
    if (p)
        return p - 1;
    end[-1] = '\0';
    Con_Printf(CON_WARN "%s: src string unterminated or truncated to %lu bytes: \"%s\"\n", __func__, (unsigned long)(dst == end ? 0 : (end - dst) - 1), dst);
    return end;
}

References Con_Printf(), CON_WARN, and src.

Referenced by PRVM_ShortStackTrace().

dp_ustr2stp()

char * dp_ustr2stp	(	char *	dst,
		size_t	dsize,
		const char *	src,
		size_t	slen )

Copies a measured byte sequence (unterminated string) to a null-terminated string.

Returns a pointer to the \0 terminator. Guarantees \0 termination. Compared to ustr2stp(): truncates and warns on overflow.

Definition at line 1388 of file common.c.

{
    if (slen >= dsize)
    {
        slen = dsize - 1;
        Con_Printf(CON_WARN "%s: src string truncated to %lu bytes: \"%.*s\"\n", __func__, (unsigned long)slen, (int)slen, src);
    }
    memcpy(dst, src, slen);
    dst[slen] = '\0';
    return &dst[slen];
}

References Con_Printf(), CON_WARN, and src.

Referenced by Cbuf_LinkString(), Con_CompleteCommandLine(), ConBuffer_GetLine(), FS_Search(), and RCon_Authenticate().

dpsnprintf()

int dpsnprintf	(	char *	buffer,
		size_t	buffersize,
		const char *	format,
			... )

Returns the number of printed characters, excluding the final '\0' or returns -1 if the buffer isn't big enough to contain the entire string.

Buffer is ALWAYS null-terminated.

Definition at line 997 of file common.c.

{
    va_list args;
    int result;
 
    va_start (args, format);
    result = dpvsnprintf (buffer, buffersize, format, args);
    va_end (args);
 
    return result;
}

References buffer, dpvsnprintf(), and format.

Referenced by adddirentry(), CDAudio_Play(), CDAudio_Play_byName(), CL_BeginDownloads(), CL_DisconnectEx(), CL_ForwardToServer(), CL_ForwardToServer_f(), CL_InitCommands(), CL_Locs_FindLocationName(), CL_Locs_Reload_f(), CL_Locs_Save_f(), CL_NextDemo(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_Particles_LoadEffectInfo(), CL_PlayVideo_f(), CL_Rcon_f(), CL_ReadPointFile_f(), CL_Record_f(), CL_SetSignonStage_WithMsg(), CL_StopDownload(), CleanURL(), Cmd_GetCvarValue(), Con_CompleteCommandLine(), Con_MsgCmdMode(), Crypto_BuildIdString(), Crypto_ClientError(), Crypto_ClientParsePacket(), Crypto_ServerError(), Curl_Begin(), Curl_Curl_f(), Curl_GetDownloadInfo(), Curl_SendRequirement(), Cvar_SetValue(), Cvar_SetValueQuick(), Font_LoadMap(), FS_AddPack(), FS_AddPack_Fullpath(), FS_ChooseUserDir(), FS_FileType(), FS_FindFile(), FS_Init_Dir(), FS_OpenReadFile(), FS_OpenRealFile(), GetMapList(), GL_CheckExtension(), GL_Draw_Init(), gl_main_newmap(), Host_InitSession(), Host_UpdateVersion(), Image_FixTransparentPixels_f(), Image_GetStockPicSize(), InfoString_SetValue(), LHNETADDRESS_GetInterfaceName(), LHNETADDRESS_Resolve(), LHNETADDRESS_ToString(), LibAvW_OpenVideo(), listdirectory(), LoadFont(), loadimagepixelsbgra(), LoadSubtitles(), Log_Timestamp(), M_DrawSlider(), M_Keys_Key(), M_LanConfig_Key(), M_Menu_LanConfig_f(), M_ScanSaves(), Mod_Decompile_f(), Mod_Decompile_OBJ(), Mod_Decompile_SMD(), Mod_FrameGroupify_ParseGroups_Store(), Mod_IDP0_Load(), Mod_IDS2_Load(), Mod_LoadQ3Shaders(), Mod_LoadTextureFromQ3Shader(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadTextures(), Mod_Q1BSP_ParseWadsFromEntityLump(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadBrushes(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_Load(), Mod_Sprite_SharedSetup(), NetConn_BuildStatusResponse(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ServerParsePacket(), OpenVideo(), PRVM_ED_ParseEdict(), PRVM_ED_Print(), PRVM_Fields_f(), PRVM_GlobalString(), PRVM_GlobalStringNoContents(), PRVM_PrintStatement(), PRVM_Prog_Load(), PRVM_ShortStackTrace(), PRVM_UglyValueString(), PRVM_ValueString(), PRVM_Watchpoint(), R_Envmap_f(), R_InitShaderModeInfo(), R_LoadCubemap(), R_LoadQWSkin(), R_LoadSkyBox(), R_Shadow_EditLights_DrawSelectedLightProperties(), R_Shadow_LoadLightsFile(), R_Shadow_LoadWorldLights(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), R_Shadow_SaveWorldLights(), R_TimeReport(), R_TimeReport_EndFrame(), S_LoadSound(), Sbar_DrawFace(), Sbar_DrawFrags(), Sbar_DrawInventory(), Sbar_DrawNum(), Sbar_DrawXNum(), Sbar_ShowFPS(), Sbar_SoloScoreboard(), SCR_DrawCurlDownload(), SCR_DrawNetGraph_DrawGraph(), SCR_DrawQWDownload(), SCR_DrawScreen(), SCR_ScreenShot_f(), SV_Ent_Create_f(), SV_ParticleEffectIndex(), SV_Pings_f(), SV_Savegame_to(), SV_Say(), SV_SendServerinfo(), SV_SpawnServer(), SV_Tell_f(), Sys_FindInPATH(), u8_strpad(), u8_strpad_colorcodes(), VM_CL_getplayerkey(), VM_etos(), VM_ftos(), VM_M_crypto_getencryptlevel(), VM_sprintf(), VM_strpad(), and VM_vtos().

dpvsnprintf()

int dpvsnprintf	(	char *	buffer,
		size_t	buffersize,
		const char *	format,
		va_list	args )

Returns the number of printed characters, excluding the final '\0' or returns -1 if the buffer isn't big enough to contain the entire string.

Buffer is ALWAYS null-terminated.

Definition at line 1010 of file common.c.

{
    int result;
 
#if _MSC_VER >= 1400
    result = _vsnprintf_s (buffer, buffersize, _TRUNCATE, format, args);
#else
    result = vsnprintf (buffer, buffersize, format, args);
#endif
    if (result < 0 || (size_t)result >= buffersize)
    {
        // _vsnprintf_s returns -1 on error and on truncation (indistinguishable),
        // vsnprintf returns negative on error and the desired strlen on truncation.
        buffer[buffersize - 1] = '\0'; // should be unnecessary, but just in case
        // Basic stdout only: we could be inside Con_Printf, Sys_Printf calls dpvsnprintf,
        // Windows console doesn't support colours.
        if (result < 0)
            Sys_Print("dpvsnprintf: output error!\n", 27);
        else
        {
            char msg[MAX_INPUTLINE];
#if _MSC_VER >= 1400
            result = _snprintf_s(msg, sizeof(msg), _TRUNCATE, "dpvsnprintf: truncated to %lu bytes: \"%s\"\n", (unsigned long)buffersize - 1, buffer);
#else
            result = snprintf(msg, sizeof(msg), "dpvsnprintf: truncated to %lu bytes: \"%s\"\n", (unsigned long)buffersize - 1, buffer);
#endif
            if (result > 0)
            {
                msg[sizeof(msg) - 1] = '\n'; // may have been lost in truncation
                Sys_Print(msg, min((size_t)result, sizeof(msg) - 1));
            }
        }
        return -1;
    }
 
    return result;
}

References buffer, format, MAX_INPUTLINE, min, snprintf, Sys_Print(), and vsnprintf.

Referenced by CL_DisconnectEx(), Con_CenterPrintf(), Con_DPrintf(), Con_MaskPrintf(), Con_Printf(), dpsnprintf(), FS_VPrintf(), Host_Error(), MVM_error_cmd(), SV_BroadcastPrintf(), SV_ClientCommands(), SV_ClientPrintf(), SV_DropClient(), Sys_Error(), Sys_Printf(), va(), and VM_Warning().

FindFraction()

void FindFraction	(	double	val,
		int *	num,
		int *	denom,
		int	denomMax )

Definition at line 1436 of file common.c.

{
    int i;
    double bestdiff;
    // initialize
    bestdiff = fabs(val);
    *num = 0;
    *denom = 1;
 
    for(i = 1; i <= denomMax; ++i)
    {
        int inum = (int) floor(0.5 + val * i);
        double diff = fabs(val - inum / (double)i);
        if(diff < bestdiff)
        {
            bestdiff = diff;
            *num = inum;
            *denom = i;
        }
    }
}

References fabs(), floor(), i, and int().

Referenced by SCR_CaptureVideo_Avi_BeginVideo(), and SCR_CaptureVideo_Ogg_BeginVideo().

SZ_Clear()

void SZ_Clear

(

sizebuf_t *

buf

)

Definition at line 44 of file common.c.

{
    buf->cursize = 0;
}

References buf.

Referenced by CL_PQRcon_f(), CL_Stop_f(), EntityFrame4_WriteFrame(), EntityFrameQuake_WriteFrame(), MakeDownloadPacket(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), NetConn_SendUnreliableMessage(), NetConn_ServerParsePacket(), SV_FlushBroadcastMessages(), SV_SendServerinfo(), SV_StopDemoRecording(), SV_UpdateToReliableMessages(), SV_WriteNetnameIntoDemo(), and SZ_GetSpace().

SZ_GetSpace()

unsigned char * SZ_GetSpace	(	sizebuf_t *	buf,
		int	length )

Definition at line 49 of file common.c.

{
    unsigned char *data;
 
    if (buf->cursize + length > buf->maxsize)
    {
        if (!buf->allowoverflow)
            Host_Error ("SZ_GetSpace: overflow without allowoverflow set");
 
        if (length > buf->maxsize)
            Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
 
        buf->overflowed = true;
        Con_Print("SZ_GetSpace: overflow\n");
        SZ_Clear (buf);
    }
 
    data = buf->data + buf->cursize;
    buf->cursize += length;
 
    return data;
}

References buf, Con_Print(), data, Host_Error(), length, and SZ_Clear().

Referenced by MSG_WriteByte(), MSG_WriteChar(), MSG_WriteLong(), MSG_WriteShort(), and SZ_Write().

SZ_HexDumpToConsole()

void SZ_HexDumpToConsole

(

const sizebuf_t *

buf

)

Definition at line 148 of file common.c.

{
    Com_HexDumpToConsole(buf->data, buf->cursize);
}

References buf, and Com_HexDumpToConsole().

Referenced by CL_Parse_DumpPacket(), and NetConn_SendUnreliableMessage().

SZ_Write()

void SZ_Write	(	sizebuf_t *	buf,
		const unsigned char *	data,
		int	length )

Definition at line 72 of file common.c.

{
    memcpy (SZ_GetSpace(buf,length),data,length);
}

References buf, data, length, and SZ_GetSpace().

Referenced by CL_ForwardToServer(), CL_PQRcon_f(), EntityFrame4_WriteFrame(), EntityFrame5_WriteFrame(), EntityFrameQuake_WriteFrame(), FS_Inflate(), MakeDownloadPacket(), MSG_WriteFloat(), MSG_WriteString(), MSG_WriteUnterminatedString(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), NetConn_ServerParsePacket(), QW_CL_NextUpload_f(), SV_FlushBroadcastMessages(), SV_PreSpawn_f(), SV_SendClientDatagram(), SV_UpdateToReliableMessages(), SV_WriteUnreliableMessages(), and VM_SV_WritePicture().

va()

char * va	(	char *	buf,
		size_t	buflen,
		const char *	format,
			... )

Definition at line 972 of file common.c.

{
    va_list argptr;
 
    va_start (argptr, format);
    dpvsnprintf (buf, buflen, format,argptr);
    va_end (argptr);
 
    return buf;
}

References buf, dpvsnprintf(), and format.

Referenced by CheckPendingDownloads(), CL_BeginDownloads(), CL_Bottomcolor_c(), CL_Color_c(), CL_FinishTimeDemo(), CL_LinkNetworkEntity(), CL_ParseServerInfo(), CL_SendCvar_f(), CL_SendPlayerInfo(), CL_SetInfo(), CL_Topcolor_c(), CL_VM_Init(), Cmd_Apropos_f(), Cmd_GetDirectCvarValue(), CompressedImageCache_Add(), CompressedImageCache_Find(), Con_CompleteCommandLine(), Crypto_BuildIdString(), Crypto_ClientParsePacket(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), Crypto_LoadFile(), Crypto_LoadKeys(), Crypto_SavePubKeyTextFile(), Crypto_ServerParsePacket_Internal(), Cvar_List_f(), Font_LoadFont(), FS_AddGameHierarchy(), FS_CheckGameDir(), FS_ChooseUserDir(), FS_Init_Dir(), FS_ListGameDirs(), FS_Rescan(), FS_SysCheckGameDir(), gl_draw_start(), Host_Init(), Host_LockSession(), Key_Event(), Key_History_f(), Key_History_Find_All(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_Message(), LightCubemapNumToName(), loadimagepixelsbgra(), M_Demo_Key(), M_Draw(), M_GameOptions_Draw(), M_GameOptions_Key(), M_Help_Draw(), M_LanConfig_Draw(), M_LanConfig_Key(), M_Load_Key(), M_Main_Draw(), M_MultiPlayer_Draw(), M_Save_Key(), M_ServerList_Draw(), M_ServerList_Key(), M_Setup_Draw(), M_Setup_Key(), M_SinglePlayer_Draw(), M_Transfusion_Episode_Draw(), M_Transfusion_Skill_Draw(), M_Video_Draw(), MakeDownloadPacket(), Mod_Decompile_f(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_INTERQUAKEMODEL_Load(), Mod_LoadModel(), Mod_LoadSkinFiles(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadTextures(), Mod_Q3BSP_LoadLightmaps(), Mod_VBSP_LoadFaces(), PRVM_Breakpoint(), PRVM_Crash(), PRVM_ED_CallSpawnFunction(), PRVM_ED_Write(), PRVM_ED_WriteGlobals(), PRVM_IsEdictRelevant(), PRVM_Prog_Load(), PRVM_ShortStackTrace(), PRVM_WhereAmI(), QW_CL_CheckOrDownloadFile(), QW_CL_ParseModelList(), QW_CL_ParseSoundList(), QW_CL_RequestNextDownload(), R_LoadSkyBox(), R_RenderTarget_Get(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), R_SkinFrame_GenerateTexturesFromQPixels(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalBGRA(), RCon_Authenticate(), Sbar_DeathmatchOverlay(), Sbar_Draw(), Sbar_DrawCharacter(), Sbar_DrawWeapon(), Sbar_PrintScoreboardItem(), Sbar_SoloScoreboard(), sbar_start(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_DrawLoadingScreen(), SCR_DrawNetGraph(), SCR_ScreenShot_f(), SND_Spatialize_WithSfx(), SV_Kick_f(), SV_SaveEntFile_f(), SV_SendServerinfo(), SV_SpawnServer(), SV_TimingReport(), VID_Mode(), VID_Restart_f(), VM_buf_loadfile(), VM_changelevel(), VM_findkeysforcommand(), VM_fopen(), and VM_sprintf().

XPM_DecodeString()

char ** XPM_DecodeString

(

const char *

in

)

Definition at line 1459 of file common.c.

{
    static char *tokens[257];
    static char lines[257][512];
    size_t line = 0;
 
    // skip until "{" token
    while(COM_ParseToken_QuakeC(&in, false) && strcmp(com_token, "{"));
 
    // now, read in succession: string, comma-or-}
    while(COM_ParseToken_QuakeC(&in, false))
    {
        tokens[line] = lines[line];
        dp_strlcpy(lines[line++], com_token, sizeof(lines[0]));
        if(!COM_ParseToken_QuakeC(&in, false))
            return NULL;
        if(!strcmp(com_token, "}"))
            break;
        if(strcmp(com_token, ","))
            return NULL;
        if(line >= sizeof(tokens) / sizeof(tokens[0]))
            return NULL;
    }
 
    return tokens;
}

References COM_ParseToken_QuakeC(), com_token, dp_strlcpy, NULL, and tokens.

Variable Documentation

base64

const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

static

Definition at line 1486 of file common.c.

Referenced by base64_3to4().

cl_playermodel

cvar_t cl_playermodel = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playermodel", "", "current player model in Nexuiz/Xonotic"}

Definition at line 36 of file common.c.

{CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playermodel", "", "current player model in Nexuiz/Xonotic"};

Referenced by CL_SendPlayerInfo(), and COM_Init_Commands().

cl_playerskin

cvar_t cl_playerskin = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playerskin", "", "current player skin in Nexuiz/Xonotic"}

Definition at line 37 of file common.c.

{CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playerskin", "", "current player skin in Nexuiz/Xonotic"};

Referenced by CL_SendPlayerInfo(), and COM_Init_Commands().

cmdline

cvar_t cmdline = {CF_CLIENT | CF_SERVER | CF_READONLY, "cmdline","0", "contains commandline the engine was launched with"}

Definition at line 33 of file common.c.

{CF_CLIENT | CF_SERVER | CF_READONLY, "cmdline","0", "contains commandline the engine was launched with"};

Referenced by CL_FinishTimeDemo(), COM_Init_Commands(), and COM_InitGameType().

com_token

char com_token[MAX_INPUTLINE]

Definition at line 39 of file common.c.

Referenced by CDAudio_StartPlaylist(), CL_ParseEntityLump(), CL_Particles_ParseEffectInfo(), Cmd_TokenizeString(), COM_InsertFlags(), COM_ParseToken_Console(), COM_ParseToken_QuakeC(), COM_ParseToken_Simple(), COM_ParseToken_VM_Tokenize(), Con_CompleteCommandLine(), Curl_SendRequirements(), GetMapList(), LoadFont(), LoadSubtitles(), Log_DestBuffer_Flush_NoLock(), M_ScanSaves(), Memory_Init_Commands(), Mod_FrameGroupify_ParseGroups(), Mod_LoadQ3Shaders(), Mod_LoadSkinFiles(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_ParseWadsFromEntityLump(), Mod_Q3BSP_LoadEntities(), PRVM_ED_LoadFromFile(), PRVM_ED_ParseEdict(), PRVM_ED_ParseGlobals(), R_InitParticleTexture(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), RCon_Authenticate(), SV_Loadgame_f(), SV_ParticleEffectIndex(), VM_loadfont(), VM_parseentitydata(), VM_tokenize(), VM_tokenize_console(), and XPM_DecodeString().

com_token_len

unsigned com_token_len

Definition at line 40 of file common.c.

Referenced by COM_ParseToken_Console(), COM_ParseToken_QuakeC(), COM_ParseToken_Simple(), COM_ParseToken_VM_Tokenize(), VM_tokenize(), and VM_tokenize_console().

hexchar

const char* hexchar = "0123456789ABCDEF"

static

Definition at line 81 of file common.c.

Referenced by Com_HexDumpToConsole().

registered

cvar_t registered = {CF_CLIENT | CF_SERVER | CF_READONLY, "registered","0", "indicates if this is running registered quake (whether gfx/pop.lmp was found)"}

Definition at line 32 of file common.c.

{CF_CLIENT | CF_SERVER | CF_READONLY, "registered","0", "indicates if this is running registered quake (whether gfx/pop.lmp was found)"};

Referenced by COM_Init_Commands(), FS_Rescan(), and M_Menu_GameOptions_f().