#include <stdarg.h>
#include <assert.h>
#include "qtypes.h"
#include "qdefs.h"
#include "strings.h"

Include dependency graph for common.h:

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

Data Structures
struct	sizebuf_t

Macros
#define	ContainerOf(ptr, type, member)
	MSVC has a different name for several standard functions.

Functions
unsigned	Com_BlockChecksum (void *buffer, int length)

void	Com_BlockFullChecksum (void buffer, int len, unsigned char outbuf)

unsigned char	COM_BlockSequenceCRCByteQW (unsigned char *base, int length, int sequence)

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

void	COM_Init_Commands (void)

unsigned short	CRC_Block (const unsigned char *data, size_t size)

unsigned short	CRC_Block_CaseInsensitive (const unsigned char *data, size_t size)

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)

Byte order functions.
#define	BigFloat(l)

#define	BigLong(l)

#define	BigShort(l)

float	BuffBigFloat (const unsigned char *buffer)
	Extract a big endian 32bit float from the given `buffer`.

int	BuffBigLong (const unsigned char *buffer)
	Extract a big endian 32bit int from the given `buffer`.

short	BuffBigShort (const unsigned char *buffer)
	Extract a big endian 16bit short from the given `buffer`.

float	BuffLittleFloat (const unsigned char *buffer)
	Extract a little endian 32bit float from the given `buffer`.

int	BuffLittleLong (const unsigned char *buffer)
	Extract a little endian 32bit int from the given `buffer`.

short	BuffLittleShort (const unsigned char *buffer)
	Extract a little endian 16bit short from the given `buffer`.

#define	LittleFloat(l)

#define	LittleLong(l)

#define	LittleShort(l)

enum	protocolversion_t { PROTOCOL_UNKNOWN , PROTOCOL_DARKPLACES8 , PROTOCOL_DARKPLACES7 , PROTOCOL_DARKPLACES6 , PROTOCOL_DARKPLACES5 , PROTOCOL_DARKPLACES4 , PROTOCOL_DARKPLACES3 , PROTOCOL_DARKPLACES2 , PROTOCOL_DARKPLACES1 , PROTOCOL_QUAKEDP , PROTOCOL_NEHAHRAMOVIE , PROTOCOL_QUAKE , PROTOCOL_QUAKEWORLD , PROTOCOL_NEHAHRABJP , PROTOCOL_NEHAHRABJP2 , PROTOCOL_NEHAHRABJP3 }

void	StoreBigLong (unsigned char *buffer, unsigned int i)
	Encode a big endian 32bit int to the given `buffer`.

void	StoreBigShort (unsigned char *buffer, unsigned short i)
	Encode a big endian 16bit int to the given `buffer`.

void	StoreLittleLong (unsigned char *buffer, unsigned int i)
	Encode a little endian 32bit int to the given `buffer`.

void	StoreLittleShort (unsigned char *buffer, unsigned short i)
	Encode a little endian 16bit int to the given `buffer`.

Message IO functions.
Handles byte ordering and avoids alignment errors
#define	ARRAY_SIZE(a)

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

struct cvar_s	cmdline

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

void	COM_Init (void)

typedef int(*	COM_LineProcessorFunc) (void passthrough, const char line, size_t length, float width, qbool isContination)

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)

void	COM_Shutdown (void)

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)

char	com_token [MAX_INPUTLINE]

unsigned	com_token_len

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.

typedef float(*	COM_WordWidthFunc_t) (void passthrough, const char w, size_t *length, float maxWidth)

int	COM_Wordwrap (const char string, size_t length, float continuationSize, 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.

#define	DP_STATIC_ASSERT(expr, str)

char *	dp_stpecpy (char dst, char end, const char *src)
	Chain-copies a string with truncation and efficiency (compared to strlcat()).

#define	dp_strlcat(dst, src, dsize)

#define	dp_strlcpy(dst, src, dsize)

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,...) DP_FUNC_PRINTF(3)
	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	MSG_BeginReading (sizebuf_t *sb)

void	MSG_InitReadBuffer (sizebuf_t buf, unsigned char data, int size)

float	MSG_ReadAngle (sizebuf_t *sb, protocolversion_t protocol)

float	MSG_ReadAngle16i (sizebuf_t *sb)

float	MSG_ReadAngle32f (sizebuf_t *sb)

float	MSG_ReadAngle8i (sizebuf_t *sb)

float	MSG_ReadBigFloat (sizebuf_t *sb)

int	MSG_ReadBigLong (sizebuf_t *sb)

int	MSG_ReadBigShort (sizebuf_t *sb)

#define	MSG_ReadByte(sb)

#define	MSG_ReadByte_opt(sb)
	Same as MSG_ReadByte but with no need to copy twice (first to `int` to check for -1) so each byte can be copied directly to a string[].

size_t	MSG_ReadBytes (sizebuf_t sb, size_t numbytes, unsigned char out)

#define	MSG_ReadChar(sb)

float	MSG_ReadCoord (sizebuf_t *sb, protocolversion_t protocol)

float	MSG_ReadCoord13i (sizebuf_t *sb)

float	MSG_ReadCoord16i (sizebuf_t *sb)

float	MSG_ReadCoord32f (sizebuf_t *sb)

#define	MSG_ReadFloat MSG_ReadLittleFloat

float	MSG_ReadLittleFloat (sizebuf_t *sb)

int	MSG_ReadLittleLong (sizebuf_t *sb)

int	MSG_ReadLittleShort (sizebuf_t *sb)

#define	MSG_ReadLong MSG_ReadLittleLong

#define	MSG_ReadShort MSG_ReadLittleShort

char *	MSG_ReadString (sizebuf_t sb, char string, size_t maxstring)

size_t	MSG_ReadString_len (sizebuf_t sb, char string, size_t maxstring)
	Same as MSG_ReadString except it returns the number of bytes written to *string excluding the \0 terminator.

void	MSG_ReadVector (sizebuf_t *sb, vec3_t v, protocolversion_t protocol)

void	MSG_WriteAngle (sizebuf_t *sb, vec_t f, protocolversion_t protocol)

void	MSG_WriteAngle16i (sizebuf_t *sb, vec_t f)

void	MSG_WriteAngle32f (sizebuf_t *sb, vec_t f)

void	MSG_WriteAngle8i (sizebuf_t *sb, vec_t f)

void	MSG_WriteByte (sizebuf_t *sb, int c)

void	MSG_WriteChar (sizebuf_t *sb, int c)

void	MSG_WriteCoord (sizebuf_t *sb, vec_t f, protocolversion_t protocol)

void	MSG_WriteCoord13i (sizebuf_t *sb, vec_t f)

void	MSG_WriteCoord16i (sizebuf_t *sb, vec_t f)

void	MSG_WriteCoord32f (sizebuf_t *sb, vec_t f)

void	MSG_WriteFloat (sizebuf_t *sb, vec_t f)

void	MSG_WriteLong (sizebuf_t *sb, int c)

void	MSG_WriteShort (sizebuf_t *sb, int c)

void	MSG_WriteString (sizebuf_t sb, const char s)

void	MSG_WriteUnterminatedString (sizebuf_t sb, const char s)

void	MSG_WriteVector (sizebuf_t *sb, const vec3_t v, protocolversion_t protocol)

struct cvar_s	registered

#define	snprintf DP_STATIC_ASSERT(0, "snprintf is forbidden for portability reasons. Use dpsnprintf instead.")

#define	sprintf DP_STATIC_ASSERT(0, "sprintf is forbidden for security reasons. Use dpsnprintf instead.")

#define	stpcpy DP_STATIC_ASSERT(0, "stpcpy is forbidden for security reasons. Use dp_stpecpy or memcpy instead.")

#define	strcat DP_STATIC_ASSERT(0, "strcat is forbidden for security reasons. Use dp_strlcat or memcpy instead.")

#define	strcpy DP_STATIC_ASSERT(0, "strcpy is forbidden for security reasons. Use dp_strlcpy or memcpy instead.")

#define	strlcat DP_STATIC_ASSERT(0, "strlcat is forbidden for stability and correctness. See common.h and common.c comments.")

#define	strlcpy DP_STATIC_ASSERT(0, "strlcpy is forbidden for stability and correctness. See common.h and common.c comments.")

#define	strncat DP_STATIC_ASSERT(0, "strncat is forbidden for security reasons. Use dp_strlcat or memcpy instead.")

#define	strncpy DP_STATIC_ASSERT(0, "strncpy is forbidden for security reasons. Use dp_strlcpy or memcpy instead.")

enum	userdirmode_t { USERDIRMODE_NOHOME , USERDIRMODE_HOME , USERDIRMODE_MYGAMES , USERDIRMODE_SAVEDGAMES , USERDIRMODE_COUNT }

#define	ustpcpy DP_STATIC_ASSERT(0, "ustpcpy is forbidden for security reasons. Use dp_ustr2stp or memcpy instead.")

#define	ustr2stp DP_STATIC_ASSERT(0, "ustr2stp is forbidden for security reasons. Use dp_ustr2stp or memcpy instead.")

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

#define	vsnprintf DP_STATIC_ASSERT(0, "vsnprintf is forbidden for portability reasons. Use dpvsnprintf instead.")

char **	XPM_DecodeString (const char *in)

Macro Definition Documentation

◆ ARRAY_SIZE

#define ARRAY_SIZE ( a )

Value:

(sizeof(a) / sizeof((a)[0]))

a

ret a

Definition shader_glsl.h:305

Definition at line 318 of file common.h.

Referenced by Sys_SDL_HandleEvents().

◆ BigFloat

#define BigFloat ( l )

Value:

BuffBigFloat((unsigned char *)&(l))

BuffBigFloat

float BuffBigFloat(const unsigned char *buffer)

Extract a big endian 32bit float from the given buffer.

Definition com_msg.c:37

Definition at line 93 of file common.h.

Referenced by Mod_DARKPLACESMODEL_Load(), and Mod_ZYMOTICMODEL_Load().

◆ BigLong

#define BigLong ( l )

Value:

BuffBigLong((unsigned char *)&(l))

BuffBigLong

int BuffBigLong(const unsigned char *buffer)

Extract a big endian 32bit int from the given buffer.

Definition com_msg.c:49

Definition at line 91 of file common.h.

Referenced by Mod_DARKPLACESMODEL_Load(), and Mod_ZYMOTICMODEL_Load().

◆ BigShort

#define BigShort ( l )

Value:

BuffBigShort((unsigned char *)&(l))

BuffBigShort

short BuffBigShort(const unsigned char *buffer)

Extract a big endian 16bit short from the given buffer.

Definition com_msg.c:54

Definition at line 89 of file common.h.

◆ ContainerOf

#define ContainerOf	(	ptr,
		type,
		member )

Value:

((type *)((char *)(ptr) - offsetof(type, member)))

type

GLenum type

Definition glquake.h:656

MSVC has a different name for several standard functions.

Definition at line 46 of file common.h.

◆ DP_STATIC_ASSERT

#define DP_STATIC_ASSERT	(		expr,
			str )

Value:

_Static_assert(expr, str)

Definition at line 231 of file common.h.

◆ dp_strlcat

#define dp_strlcat	(	dst,
		src,
		dsize )

Value:

dp__strlcat(dst, src, dsize, __func__, __LINE__)

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...

Definition common.c:1423

src

prvm_eval_t * src

Definition prvm_execprogram.h:4

Definition at line 304 of file common.h.

Referenced by CL_ForwardToServer(), CL_ParseServerMessage(), Cmd_Alias_f(), Con_CompleteCommandLine(), Crypto_BuildIdString(), Crypto_KeyGen_f(), Curl_SendRequirement(), Curl_SendRequirements(), dpvsimpledecode_open(), FS_DefaultExtension(), FS_Init_Dir(), FS_Rescan(), FS_Search(), GL_InitFunctions(), jam_open(), Key_Bind_f(), Key_In_Bind_f(), LibAvW_OpenVideo(), M_Keys_Draw(), Mod_PSKMODEL_Load(), Mod_Q1BSP_LoadLighting(), Protocol_Names(), PRVM_ED_Print(), PRVM_Fields_f(), PRVM_LoadLNO(), R_GLSL_CompilePermutation(), R_TimeReport(), S_Play_Common(), SCR_Centerprint_f(), SV_Download_f(), SV_Say(), Sys_Error(), Sys_HandleCrash(), Sys_LoadDependency(), VM_buf_implode(), and VM_findkeysforcommand().

◆ dp_strlcpy

#define dp_strlcpy	(	dst,
		src,
		dsize )

Value:

dp__strlcpy(dst, src, dsize, __func__, __LINE__)

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...

Definition common.c:1406

Definition at line 303 of file common.h.

Referenced by _Mem_AllocPool(), _Mem_strdup(), CD_f(), CDAudio_StartPlaylist(), CL_AllocLightFlash(), CL_DisconnectEx(), CL_DownloadBegin_f(), CL_EstablishConnection(), CL_Fog_HeightTexture_f(), CL_FullInfo_f(), CL_FullServerinfo_f(), CL_IPLog_Add(), CL_Locs_FindLocationName(), CL_ParseEntityLump(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_Particles_LoadEffectInfo(), CL_Particles_ParseEffectInfo(), CL_PlayDemo(), CL_Rcon_f(), CL_Record_f(), CL_SetupWorldModel(), CL_Startdemos_f(), Cmd_Alias_f(), COM_InsertFlags(), COM_SetGameType(), CompressedImageCache_Add(), Con_CompleteCommandLine(), Con_DrawInput(), Crypto_ClientParsePacket(), Crypto_RetrieveHostKey(), Crypto_RetrieveLocalKey(), Crypto_ServerParsePacket_Internal(), Curl_Begin(), Curl_CommandWhenDone(), Curl_CommandWhenError(), Curl_EndDownload(), Curl_FindPackURL(), Curl_GetDownloadInfo(), Curl_RequireFile(), Draw_CachePic_Flags(), Draw_NewPic(), FindFont(), Font_LoadFile(), Font_LoadFont(), fontfilecache_LoadFile(), FS_AddFileToPack(), FS_AddGameDirectory(), FS_AddPack_Fullpath(), FS_ChooseUserDir(), FS_Init_Dir(), FS_ListGameDirs(), FS_LoadPackPAK(), FS_LoadPackPK3FromFD(), FS_LoadPackVirtual(), FS_Rescan(), FS_Search(), FS_SetGameDirs(), GetMapList(), GL_Draw_Init(), Host_Error(), Image_StripImageExtension(), IN_BestWeapon_Register(), InfoString_SetValue(), Key_History_Down(), Key_History_Find_Backwards(), Key_History_Find_Forwards(), Key_History_First(), Key_History_Get_foundCommand(), Key_History_Last(), Key_History_Up(), Key_Parse_CommonKeys(), LoadFont(), LoadFont_f(), loadimagepixelsbgra(), Log_Open(), M_Keys_Draw(), M_Menu_Setup_f(), M_ScanSaves(), Mod_BrushInit(), Mod_Decompile_f(), Mod_Decompile_OBJ(), Mod_FindName(), Mod_FrameGroupify_ParseGroups(), Mod_FrameGroupify_ParseGroups_Store(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_LoadCustomMaterial(), Mod_LoadQ3Shaders(), Mod_LoadSkinFiles(), Mod_LoadTextureFromQ3Shader(), Mod_MDL_LoadFrames(), Mod_Mesh_Create(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadTextures(), Mod_Q1BSP_ParseWadsFromEntityLump(), Mod_Q2BSP_Load(), Mod_Q3BSP_Load(), Mod_Q3BSP_LoadEffects(), Mod_Q3BSP_LoadEntities(), Mod_UnloadModel(), ModList_RebuildList(), NetConn_BuildStatusResponse(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ConnectionEstablished(), NetConn_ServerParsePacket(), Nicks_CompleteCountPossible(), Nicks_CutMatchesAlphaNumeric(), Nicks_CutMatchesNoSpaces(), OpenVideo(), PRVM_Breakpoint_f(), PRVM_ED_ParseEdict(), PRVM_ED_ParseGlobals(), PRVM_EdictWatchpoint_f(), PRVM_GlobalWatchpoint_f(), PRVM_ShortStackTrace(), PRVM_UglyValueString(), PRVM_ValueString(), QW_CL_CheckOrDownloadFile(), QW_CL_ParseModelList(), QW_CL_ParseSoundList(), QW_CL_ProcessUserInfo(), QW_CL_ServerInfo(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), R_BuildFogHeightTexture(), R_Envmap_f(), R_GetCubemap(), R_InitParticleTexture(), R_LoadQWSkin(), R_LoadTextureDDSFile(), R_LoadTextureRenderBuffer(), R_Mesh_CreateMeshBuffer(), R_RTLight_Update(), R_SetSkyBox(), R_SetupTexture(), R_Shadow_EditLights_CopyInfo_f(), R_Shadow_EditLights_Edit_f(), R_Shadow_EditLights_Reload_f(), R_Shadow_LoadWorldLightsFromMap_LightArghliteTyrlite(), R_Shadow_UpdateWorldLight(), R_SkinFrame_Find(), S_FindName(), S_Play_Common(), Sbar_ShowFPS(), Sbar_SortFrags(), SCR_CenterPrint(), SCR_Centerprint_f(), SCR_DrawScreen(), SCR_InfoBar_f(), SCR_PushLoadingScreen(), SCR_ScreenShot_f(), SHOWLMP_decodeshow(), SV_ConnectClient(), SV_Download_f(), SV_Loadgame_f(), SV_ModelIndex(), SV_Name(), SV_Name_f(), SV_ParticleEffectIndex(), SV_Playermodel_f(), SV_Playerskin_f(), SV_Prepare_CSQC(), SV_Savegame_f(), SV_SoundIndex(), SV_SpawnServer(), SV_StartDemoRecording(), SV_Status_f(), SV_UpdateToReliableMessages(), SV_WriteClientdataToMessage(), Sys_HandleCrash(), Sys_LoadDependency(), Sys_SDL_GetClipboardData(), VM_altstr_ins(), VM_altstr_set(), VM_bufstr_find(), VM_CL_getplayerkey(), VM_CL_getstats(), VM_CL_lightstyle(), VM_CL_R_PolygonBegin(), VM_infoadd(), VM_loadfont(), VM_M_setserverlistmaskstring(), VM_matchpattern(), VM_SV_lightstyle(), VM_SV_UpdateCustomStats(), VM_tokenize(), VM_tokenize_console(), VM_tokenizebyseparator(), VM_uri_get(), World_SetSize(), and XPM_DecodeString().

◆ LittleFloat

#define LittleFloat ( l )

Value:

BuffLittleFloat((unsigned char *)&(l))

BuffLittleFloat

float BuffLittleFloat(const unsigned char *buffer)

Extract a little endian 32bit float from the given buffer.

Definition com_msg.c:59

Definition at line 94 of file common.h.

Referenced by CL_ReadDemoMessage(), CL_WriteDemoMessage(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_MDL_LoadFrames(), Mod_PSKMODEL_Load(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadModels(), Mod_Q3BSP_LoadPlanes(), Mod_Q3BSP_LoadVertices(), Mod_Sprite_SharedSetup(), and SV_WriteDemoMessage().

◆ LittleLong

#define LittleLong ( l )

Value:

BuffLittleLong((unsigned char *)&(l))

BuffLittleLong

int BuffLittleLong(const unsigned char *buffer)

Extract a little endian 32bit int from the given buffer.

Definition com_msg.c:71

Definition at line 92 of file common.h.

Referenced by CL_ReadDemoMessage(), CL_WriteDemoMessage(), FS_LoadPackPAK(), GetMapList(), jam_open(), jam_video(), LoadWAL_BGRA(), LoadWAL_GetMetadata(), Mod_IBSP_Load(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_IDS2_Load(), Mod_IDSP_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_MDL_LoadFrames(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadLighting(), Mod_Q2BSP_Load(), Mod_Q3BSP_Load(), Mod_Q3BSP_LoadBrushes(), Mod_Q3BSP_LoadBrushSides(), Mod_Q3BSP_LoadBrushSides_IG(), Mod_Q3BSP_LoadEffects(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLeafBrushes(), Mod_Q3BSP_LoadLeafFaces(), Mod_Q3BSP_LoadLeafs(), Mod_Q3BSP_LoadLightmaps(), Mod_Q3BSP_LoadModels(), Mod_Q3BSP_LoadNodes(), Mod_Q3BSP_LoadPVS(), Mod_Q3BSP_LoadTextures(), Mod_Q3BSP_LoadTriangles(), Mod_Sprite_SharedSetup(), MSG_WriteFloat(), NetConn_ReceivedMessage(), PK3_GetEndOfCentralDir(), PRVM_LoadLNO(), PRVM_Prog_Load(), SV_WriteDemoMessage(), W_GetLumpName(), W_LoadTextureWadFile(), and W_SwapLumps().

◆ LittleShort

#define LittleShort ( l )

Value:

BuffLittleShort((unsigned char *)&(l))

BuffLittleShort

short BuffLittleShort(const unsigned char *buffer)

Extract a little endian 16bit short from the given buffer.

Definition com_msg.c:76

Definition at line 90 of file common.h.

Referenced by LoadPCX_BGRA(), LoadPCX_QWSkin(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_PSKMODEL_Load(), NetConn_SendUnreliableMessage(), PK3_GetEndOfCentralDir(), and PRVM_Prog_Load().

◆ MSG_ReadByte

#define MSG_ReadByte ( sb )

Value:

((sb)->readcount >= (sb)->cursize ? ((sb)->badread = true, -1) : (unsigned char)(sb)->data[(sb)->readcount++])

Definition at line 188 of file common.h.

Referenced by CL_ParseBaseline(), CL_ParseClientdata(), CL_ParseEffect(), CL_ParseEffect2(), CL_ParseParticleEffect(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseStaticSound(), CL_ParseTempEntity(), EntityFrameQuake_ReadEntity(), EntityFrameQW_CL_ReadFrame(), EntityState5_ReadUpdate(), EntityState_ReadExtendBits(), EntityState_ReadFields(), EntityStateQW_ReadEntityUpdate(), EntityStateQW_ReadPlayerUpdate(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadTextures(), Mod_VBSP_LoadFaces(), MSG_ReadAngle8i(), NetConn_ClientParsePacket(), NetConn_ServerParsePacket(), QW_CL_ParseDownload(), QW_CL_ParseModelList(), QW_CL_ParseNails(), QW_CL_ParseSoundList(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), SHOWLMP_decodeshow(), SV_ReadClientMessage(), SV_ReadClientMove(), V_ParseDamage(), VM_CL_ReadByte(), and VM_CL_ReadPicture().

◆ MSG_ReadByte_opt

#define MSG_ReadByte_opt ( sb )

Value:

((sb)->readcount >= (sb)->cursize ? ((sb)->badread = true, '\0') : (unsigned char)(sb)->data[(sb)->readcount++])

Same as MSG_ReadByte but with no need to copy twice (first to int to check for -1) so each byte can be copied directly to a string[].

Definition at line 190 of file common.h.

Referenced by MSG_ReadBytes(), MSG_ReadString(), and MSG_ReadString_len().

◆ MSG_ReadChar

#define MSG_ReadChar ( sb )

Value:

((sb)->readcount >= (sb)->cursize ? ((sb)->badread = true, -1) : (signed char)(sb)->data[(sb)->readcount++])

Definition at line 187 of file common.h.

Referenced by CL_ParseClientdata(), CL_ParseParticleEffect(), CL_ParseStartSoundPacket(), CL_ParseTempEntity(), and VM_CL_ReadChar().

◆ MSG_ReadFloat

#define MSG_ReadFloat MSG_ReadLittleFloat

Definition at line 193 of file common.h.

Referenced by CL_ParseServerInfo(), CL_ParseServerMessage(), EntityFrame_CL_ReadFrame(), EntityFrameQuake_ReadEntity(), MSG_ReadAngle32f(), SV_ReadClientMove(), and VM_CL_ReadFloat().

◆ MSG_ReadLong

#define MSG_ReadLong MSG_ReadLittleLong

Definition at line 192 of file common.h.

Referenced by CL_ParseClientdata(), CL_ParseDownload(), CL_ParseServerInfo(), CL_ParseServerMessage(), EntityFrame4_CL_ReadFrame(), EntityFrame5_CL_ReadFrame(), EntityFrame_CL_ReadFrame(), EntityState5_ReadUpdate(), NetConn_ClientParsePacket(), QW_CL_UpdateUserInfo(), SV_ReadClientMessage(), SV_ReadClientMove(), and VM_CL_ReadLong().

◆ MSG_ReadShort

◆ snprintf

#define snprintf DP_STATIC_ASSERT(0, "snprintf is forbidden for portability reasons. Use dpsnprintf instead.")

Definition at line 238 of file common.h.

Referenced by dpvsnprintf().

◆ sprintf

#define sprintf DP_STATIC_ASSERT(0, "sprintf is forbidden for security reasons. Use dpsnprintf instead.")

Definition at line 269 of file common.h.

Referenced by main().

◆ stpcpy

#define stpcpy DP_STATIC_ASSERT(0, "stpcpy is forbidden for security reasons. Use dp_stpecpy or memcpy instead.")

Definition at line 263 of file common.h.

◆ strcat

#define strcat DP_STATIC_ASSERT(0, "strcat is forbidden for security reasons. Use dp_strlcat or memcpy instead.")

Definition at line 255 of file common.h.

Referenced by float().

◆ strcpy

#define strcpy DP_STATIC_ASSERT(0, "strcpy is forbidden for security reasons. Use dp_strlcpy or memcpy instead.")

Definition at line 259 of file common.h.

◆ strlcat

#define strlcat DP_STATIC_ASSERT(0, "strlcat is forbidden for stability and correctness. See common.h and common.c comments.")

Definition at line 274 of file common.h.

Referenced by Mod_Q1BSP_LoadMapBrushes().

◆ strlcpy

#define strlcpy DP_STATIC_ASSERT(0, "strlcpy is forbidden for stability and correctness. See common.h and common.c comments.")

Definition at line 272 of file common.h.

Referenced by Mod_Q1BSP_LoadMapBrushes().

◆ strncat

#define strncat DP_STATIC_ASSERT(0, "strncat is forbidden for security reasons. Use dp_strlcat or memcpy instead.")

Definition at line 257 of file common.h.

◆ strncpy

#define strncpy DP_STATIC_ASSERT(0, "strncpy is forbidden for security reasons. Use dp_strlcpy or memcpy instead.")

Definition at line 261 of file common.h.

◆ ustpcpy

#define ustpcpy DP_STATIC_ASSERT(0, "ustpcpy is forbidden for security reasons. Use dp_ustr2stp or memcpy instead.")

Definition at line 265 of file common.h.

◆ ustr2stp

#define ustr2stp DP_STATIC_ASSERT(0, "ustr2stp is forbidden for security reasons. Use dp_ustr2stp or memcpy instead.")

Definition at line 267 of file common.h.

◆ vsnprintf

#define vsnprintf DP_STATIC_ASSERT(0, "vsnprintf is forbidden for portability reasons. Use dpvsnprintf instead.")

Definition at line 240 of file common.h.

Referenced by dpvsnprintf().

Typedef Documentation

◆ COM_LineProcessorFunc

typedef int(* COM_LineProcessorFunc) (void *passthrough, const char *line, size_t length, float width, qbool isContination)

Definition at line 208 of file common.h.

◆ COM_WordWidthFunc_t

typedef float(* COM_WordWidthFunc_t) (void *passthrough, const char *w, size_t *length, float maxWidth)

Definition at line 207 of file common.h.

Enumeration Type Documentation

◆ protocolversion_t

enum protocolversion_t

Enumerator
PROTOCOL_UNKNOWN
PROTOCOL_DARKPLACES8	added parting messages. WIP
PROTOCOL_DARKPLACES7	added QuakeWorld-style movement protocol to allow more consistent prediction
PROTOCOL_DARKPLACES6	various changes
PROTOCOL_DARKPLACES5	uses EntityFrame5 entity snapshot encoder/decoder which is based on a Tribes networking article at http://www.garagegames.com/articles/networking1/
PROTOCOL_DARKPLACES4	various changes
PROTOCOL_DARKPLACES3	uses EntityFrame4 entity snapshot encoder/decoder which is broken, this attempted to do partial snapshot updates on a QuakeWorld-like protocol, but it is broken and impossible to fix
PROTOCOL_DARKPLACES2	various changes
PROTOCOL_DARKPLACES1	uses EntityFrame entity snapshot encoder/decoder which is a QuakeWorld-like entity snapshot delta compression method
PROTOCOL_QUAKEDP	darkplaces extended quake protocol (used by TomazQuake and others), backwards compatible as long as no extended features are used
PROTOCOL_NEHAHRAMOVIE	Nehahra movie protocol, a big nasty hack dating back to early days of the Quake Standards Group (but only ever used by neh_gl.exe), this is potentially backwards compatible with quake protocol as long as no extended features are used (but in actuality the neh_gl.exe which wrote this protocol ALWAYS wrote the extended information)
PROTOCOL_QUAKE	quake (aka netquake/normalquake/nq) protocol
PROTOCOL_QUAKEWORLD	quakeworld protocol
PROTOCOL_NEHAHRABJP	same as QUAKEDP but with 16bit modelindex
PROTOCOL_NEHAHRABJP2	same as NEHAHRABJP but with 16bit soundindex
PROTOCOL_NEHAHRABJP3	same as NEHAHRABJP2 but with some changes

Definition at line 131 of file common.h.

{
    PROTOCOL_UNKNOWN,
    PROTOCOL_DARKPLACES8, 
    PROTOCOL_DARKPLACES7, 
    PROTOCOL_DARKPLACES6, 
    PROTOCOL_DARKPLACES5, 
    PROTOCOL_DARKPLACES4, 
    PROTOCOL_DARKPLACES3, 
    PROTOCOL_DARKPLACES2, 
    PROTOCOL_DARKPLACES1, 
    PROTOCOL_QUAKEDP, 
    PROTOCOL_NEHAHRAMOVIE, 
    PROTOCOL_QUAKE, 
    PROTOCOL_QUAKEWORLD, 
    PROTOCOL_NEHAHRABJP, 
    PROTOCOL_NEHAHRABJP2, 
    PROTOCOL_NEHAHRABJP3 
}

◆ userdirmode_t

enum userdirmode_t

Enumerator
USERDIRMODE_NOHOME
USERDIRMODE_HOME
USERDIRMODE_MYGAMES
USERDIRMODE_SAVEDGAMES
USERDIRMODE_COUNT

Definition at line 282 of file common.h.

{
    USERDIRMODE_NOHOME, // basedir only
    USERDIRMODE_HOME, // Windows basedir, general POSIX (~/.)
    USERDIRMODE_MYGAMES, // pre-Vista (My Documents/My Games/), general POSIX (~/.)
    USERDIRMODE_SAVEDGAMES, // Vista (%USERPROFILE%/Saved Games/), OSX (~/Library/Application Support/), Linux (~/.config)
    USERDIRMODE_COUNT
}

Function Documentation

◆ 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().

◆ BuffBigFloat()

float BuffBigFloat ( const unsigned char * buffer )

Extract a big endian 32bit float from the given buffer.

Definition at line 37 of file com_msg.c.

{
    union
    {
        float f;
        unsigned int i;
    }
    u;
    u.i = ((unsigned)buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
    return u.f;
}

References buffer, f, and i.

◆ BuffBigLong()

int BuffBigLong ( const unsigned char * buffer )

Extract a big endian 32bit int from the given buffer.

Definition at line 49 of file com_msg.c.

{
    return ((unsigned)buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
}

References buffer.

Referenced by Crypto_DecryptPacket(), Crypto_EncryptPacket(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), NetConn_ServerParsePacket(), PK3_BuildFileList(), PK3_GetEndOfCentralDir(), and PK3_GetTrueFileOffset().

◆ BuffBigShort()

short BuffBigShort ( const unsigned char * buffer )

Extract a big endian 16bit short from the given buffer.

Definition at line 54 of file com_msg.c.

{
    return (buffer[0] << 8) | buffer[1];
}

References buffer.

◆ BuffLittleFloat()

float BuffLittleFloat ( const unsigned char * buffer )

Extract a little endian 32bit float from the given buffer.

Definition at line 59 of file com_msg.c.

{
    union
    {
        float f;
        unsigned int i;
    }
    u;
    u.i = ((unsigned)buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];
    return u.f;
}

References buffer, f, and i.

◆ BuffLittleLong()

int BuffLittleLong ( const unsigned char * buffer )

Extract a little endian 32bit int from the given buffer.

Definition at line 71 of file com_msg.c.

{
    return ((unsigned)buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];
}

References buffer.

Referenced by Crypto_ClientParsePacket(), GetLittleLong(), GetMapList(), Mod_Q1BSP_LoadFaces(), PK3_BuildFileList(), and R_LoadTextureDDSFile().

◆ BuffLittleShort()

short BuffLittleShort ( const unsigned char * buffer )

Extract a little endian 16bit short from the given buffer.

Definition at line 76 of file com_msg.c.

{
    return (buffer[1] << 8) | buffer[0];
}

References buffer.

Referenced by GetLittleShort(), Mod_Q1BSP_LoadFaces(), Mod_VBSP_LoadFaces(), PK3_BuildFileList(), and PK3_GetTrueFileOffset().

◆ Com_BlockChecksum()

unsigned Com_BlockChecksum	(	void *	buffer,
		int	length )

Definition at line 198 of file mdfour.c.

{
    int             digest[4];
    unsigned        val;
 
    mdfour ( (unsigned char *) digest, (unsigned char *) buffer, length );
 
    val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
 
    return val;
}

References buffer, length, and mdfour().

Referenced by Mod_Q1BSP_Load(), Mod_Q2BSP_Load(), and Mod_Q3BSP_Load().

◆ Com_BlockFullChecksum()

void Com_BlockFullChecksum	(	void *	buffer,
		int	len,
		unsigned char *	outbuf )

Definition at line 210 of file mdfour.c.

{
    mdfour ( outbuf, (unsigned char *) buffer, len );
}

References buffer, and mdfour().

◆ COM_BlockSequenceCRCByteQW()

unsigned char COM_BlockSequenceCRCByteQW	(	unsigned char *	base,
		int	length,
		int	sequence )

Definition at line 132 of file com_crc16.c.

{
    const unsigned char *p;
    unsigned char chkb[60 + 4];
 
    p = chktbl + (sequence % (sizeof(chktbl) - 8));
 
    if (length > 60)
        length = 60;
    memcpy(chkb, base, length);
 
    chkb[length] = (sequence & 0xff) ^ p[0];
    chkb[length+1] = p[1];
    chkb[length+2] = ((sequence>>8) & 0xff) ^ p[2];
    chkb[length+3] = p[3];
 
    return CRC_Block(chkb, length + 4) & 0xff;
}

References chktbl, CRC_Block(), and length.

Referenced by CL_SendMove().

◆ 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()

void COM_Init ( void )

◆ 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_Shutdown()

void COM_Shutdown ( void )

◆ 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
}

◆ 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	continuationSize,
		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().

◆ CRC_Block()

unsigned short CRC_Block	(	const unsigned char *	data,
		size_t	size )

Definition at line 75 of file com_crc16.c.

{
    unsigned short crc = CRC_INIT_VALUE;
    while (size--)
        crc = (crc << 8) ^ crctable[(crc >> 8) ^ (*data++)];
    return crc ^ CRC_XOR_VALUE;
}

References CRC_INIT_VALUE, CRC_XOR_VALUE, crctable, data, and size.

Referenced by CL_StopDownload(), CL_VM_Init(), COM_BlockSequenceCRCByteQW(), CompressedImageCache_Add(), CompressedImageCache_Find(), Crypto_ClearHostKey(), Crypto_RetrieveHostKey(), Crypto_StoreHostKey(), Cvar_FindVar(), Cvar_FindVarLink(), Cvar_Link(), Cvar_RegisterVirtual(), Draw_CachePic_Flags(), Draw_FreePic(), Draw_NewPic(), FS_CRCFile(), Mod_LoadModel(), Mod_Q1BSP_LoadSplitSky(), Mod_Q1BSP_LoadTextures(), PRVM_PO_Load(), PRVM_PO_Lookup(), PRVM_Prog_Load(), R_InitShaderModeInfo(), R_SkinFrame_Find(), R_SkinFrame_FindNextByName(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalQuake(), SV_Prepare_CSQC(), SV_ReadClientMessage(), and VM_crc16().

◆ CRC_Block_CaseInsensitive()

unsigned short CRC_Block_CaseInsensitive	(	const unsigned char *	data,
		size_t	size )

Definition at line 83 of file com_crc16.c.

{
    unsigned short crc = CRC_INIT_VALUE;
    while (size--)
        crc = (crc << 8) ^ crctable[(crc >> 8) ^ (tolower(*data++))];
    return crc ^ CRC_XOR_VALUE;
}

References CRC_INIT_VALUE, CRC_XOR_VALUE, crctable, data, and size.

Referenced by Mod_LookupQ3Shader(), Q3Shader_AddToHash(), and VM_crc16().

◆ 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,
			... )

extern

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 )

extern

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().

◆ MSG_BeginReading()

void MSG_BeginReading ( sizebuf_t * sb )

Definition at line 257 of file com_msg.c.

{
    sb->readcount = 0;
    sb->badread = false;
}

References sizebuf_t::badread, and sizebuf_t::readcount.

Referenced by CL_ReadDemoMessage(), MSG_InitReadBuffer(), NetConn_ClientParsePacket(), NetConn_ReceivedMessage(), NetConn_ServerParsePacket(), and W_ConvertWAD3TextureBGRA().

◆ MSG_InitReadBuffer()

void MSG_InitReadBuffer	(	sizebuf_t *	buf,
		unsigned char *	data,
		int	size )

Definition at line 249 of file com_msg.c.

{
    memset(buf, 0, sizeof(*buf));
    buf->data = data;
    buf->maxsize = buf->cursize = size;
    MSG_BeginReading(buf);
}

References buf, data, MSG_BeginReading(), and size.

Referenced by Mod_Q1BSP_Load(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_Load(), Mod_VBSP_Load(), and W_GetTextureBGRA().

◆ MSG_ReadAngle()

float MSG_ReadAngle	(	sizebuf_t *	sb,
		protocolversion_t	protocol )

Definition at line 424 of file com_msg.c.

{
    if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4 || protocol == PROTOCOL_QUAKEWORLD)
        return MSG_ReadAngle8i (sb);
    else
        return MSG_ReadAngle16i (sb);
}

References MSG_ReadAngle16i(), MSG_ReadAngle8i(), PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, and PROTOCOL_QUAKEWORLD.

Referenced by CL_ParseBaseline(), CL_ParseServerMessage(), EntityFrameQuake_ReadEntity(), and VM_CL_ReadAngle().

◆ MSG_ReadAngle16i()

float MSG_ReadAngle16i ( sizebuf_t * sb )

Definition at line 414 of file com_msg.c.

{
    return (signed short)MSG_ReadShort (sb) * (360.0/65536.0);
}

References MSG_ReadShort.

Referenced by CL_ParseClientdata(), EntityState5_ReadUpdate(), EntityState_ReadFields(), EntityStateQW_ReadPlayerUpdate(), MSG_ReadAngle(), and SV_ReadClientMove().

◆ MSG_ReadAngle32f()

float MSG_ReadAngle32f ( sizebuf_t * sb )

Definition at line 419 of file com_msg.c.

{
    return MSG_ReadFloat (sb);
}

References MSG_ReadFloat.

Referenced by SV_ReadClientMove().

◆ MSG_ReadAngle8i()

float MSG_ReadAngle8i ( sizebuf_t * sb )

Definition at line 409 of file com_msg.c.

{
    return (signed char) MSG_ReadByte (sb) * (360.0/256.0);
}

References MSG_ReadByte.

Referenced by EntityState5_ReadUpdate(), EntityState_ReadFields(), EntityStateQW_ReadEntityUpdate(), MSG_ReadAngle(), and SV_ReadClientMove().

◆ MSG_ReadBigFloat()

float MSG_ReadBigFloat ( sizebuf_t * sb )

Definition at line 324 of file com_msg.c.

{
    union
    {
        float f;
        int l;
    } dat;
    if (sb->readcount+4 > sb->cursize)
    {
        sb->badread = true;
        return -1;
    }
    sb->readcount += 4;
    dat.l = ((unsigned)sb->data[sb->readcount-4]<<24) | (sb->data[sb->readcount-3]<<16) | (sb->data[sb->readcount-2]<<8) | sb->data[sb->readcount-1];
    return dat.f;
}

References sizebuf_t::badread, sizebuf_t::cursize, sizebuf_t::data, f, and sizebuf_t::readcount.

◆ MSG_ReadBigLong()

int MSG_ReadBigLong ( sizebuf_t * sb )

Definition at line 296 of file com_msg.c.

{
    if (sb->readcount+4 > sb->cursize)
    {
        sb->badread = true;
        return -1;
    }
    sb->readcount += 4;
    return ((unsigned)sb->data[sb->readcount-4]<<24) + (sb->data[sb->readcount-3]<<16) + (sb->data[sb->readcount-2]<<8) + sb->data[sb->readcount-1];
}

References sizebuf_t::badread, sizebuf_t::cursize, sizebuf_t::data, and sizebuf_t::readcount.

◆ MSG_ReadBigShort()

int MSG_ReadBigShort ( sizebuf_t * sb )

Definition at line 274 of file com_msg.c.

{
    if (sb->readcount+2 > sb->cursize)
    {
        sb->badread = true;
        return -1;
    }
    sb->readcount += 2;
    return (short)((sb->data[sb->readcount-2]<<8) + sb->data[sb->readcount-1]);
}

References sizebuf_t::badread, sizebuf_t::cursize, sizebuf_t::data, and sizebuf_t::readcount.

◆ MSG_ReadBytes()

size_t MSG_ReadBytes	(	sizebuf_t *	sb,
		size_t	numbytes,
		unsigned char *	out )

Definition at line 364 of file com_msg.c.

{
    size_t l = 0;
 
    // when numbytes have been read sb->readcount won't be advanced any further
    while (l < numbytes && !sb->badread)
        out[l++] = MSG_ReadByte_opt(sb);
    return l;
}

References MSG_ReadByte_opt.

Referenced by CL_ParseDownload(), Mod_Q1BSP_LoadEntities(), Mod_Q1BSP_LoadVisibility(), Mod_Q2BSP_LoadLighting(), Mod_Q2BSP_LoadTexinfo(), Mod_VBSP_LoadEntities(), QW_CL_ParseDownload(), VM_CL_ReadPicture(), and W_ConvertWAD3TextureBGRA().

◆ MSG_ReadCoord()

float MSG_ReadCoord	(	sizebuf_t *	sb,
		protocolversion_t	protocol )

Definition at line 389 of file com_msg.c.

{
    if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_QUAKEWORLD)
        return MSG_ReadCoord13i(sb);
    else if (protocol == PROTOCOL_DARKPLACES1)
        return MSG_ReadCoord32f(sb);
    else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
        return MSG_ReadCoord16i(sb);
    else
        return MSG_ReadCoord32f(sb);
}

References MSG_ReadCoord13i(), MSG_ReadCoord16i(), MSG_ReadCoord32f(), PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, and PROTOCOL_QUAKEWORLD.

Referenced by CL_ParseBaseline(), CL_ParseServerMessage(), CL_ParseTempEntity(), EntityFrameQuake_ReadEntity(), MSG_ReadVector(), and VM_CL_ReadCoord().

◆ MSG_ReadCoord13i()

float MSG_ReadCoord13i ( sizebuf_t * sb )

Definition at line 374 of file com_msg.c.

{
    return MSG_ReadLittleShort(sb) * (1.0/8.0);
}

References MSG_ReadLittleShort().

Referenced by EntityState5_ReadUpdate(), EntityStateQW_ReadEntityUpdate(), and MSG_ReadCoord().

◆ MSG_ReadCoord16i()

float MSG_ReadCoord16i ( sizebuf_t * sb )

Definition at line 379 of file com_msg.c.

{
    return (signed short) MSG_ReadLittleShort(sb);
}

References MSG_ReadLittleShort().

Referenced by CL_ParseClientdata(), EntityState_ReadFields(), MSG_ReadCoord(), and SV_ReadClientMove().

◆ MSG_ReadCoord32f()

float MSG_ReadCoord32f ( sizebuf_t * sb )

Definition at line 384 of file com_msg.c.

{
    return MSG_ReadLittleFloat(sb);
}

References MSG_ReadLittleFloat().

Referenced by CL_ParseClientdata(), EntityState5_ReadUpdate(), EntityState_ReadFields(), and MSG_ReadCoord().

◆ MSG_ReadLittleFloat()

float MSG_ReadLittleFloat ( sizebuf_t * sb )

Definition at line 307 of file com_msg.c.

{
    union
    {
        float f;
        int l;
    } dat;
    if (sb->readcount+4 > sb->cursize)
    {
        sb->badread = true;
        return -1;
    }
    sb->readcount += 4;
    dat.l = sb->data[sb->readcount-4] | (sb->data[sb->readcount-3]<<8) | (sb->data[sb->readcount-2]<<16) | ((unsigned)sb->data[sb->readcount-1]<<24);
    return dat.f;
}

References sizebuf_t::badread, sizebuf_t::cursize, sizebuf_t::data, f, and sizebuf_t::readcount.

Referenced by Mod_BSP_LoadSubmodels(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadNodes(), Mod_Q1BSP_LoadPlanes(), Mod_Q1BSP_LoadTexinfo(), Mod_Q1BSP_LoadVertexes(), Mod_Q2BSP_LoadTexinfo(), Mod_VBSP_LoadPlanes(), Mod_VBSP_LoadTexinfo(), Mod_VBSP_LoadVertexes(), and MSG_ReadCoord32f().

◆ MSG_ReadLittleLong()

int MSG_ReadLittleLong ( sizebuf_t * sb )

Definition at line 285 of file com_msg.c.

{
    if (sb->readcount+4 > sb->cursize)
    {
        sb->badread = true;
        return -1;
    }
    sb->readcount += 4;
    return sb->data[sb->readcount-4] | (sb->data[sb->readcount-3]<<8) | (sb->data[sb->readcount-2]<<16) | ((unsigned)sb->data[sb->readcount-1]<<24);
}

References sizebuf_t::badread, sizebuf_t::cursize, sizebuf_t::data, and sizebuf_t::readcount.

Referenced by Mod_BSP_LoadSubmodels(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadClipnodes(), Mod_Q1BSP_LoadEdges(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadLeaffaces(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadNodes(), Mod_Q1BSP_LoadPlanes(), Mod_Q1BSP_LoadSurfedges(), Mod_Q1BSP_LoadTexinfo(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadBrushes(), Mod_Q2BSP_LoadLeafs(), Mod_Q2BSP_LoadNodes(), Mod_Q2BSP_LoadTexinfo(), Mod_Q2BSP_LoadVisibility(), Mod_VBSP_Load(), Mod_VBSP_LoadFaces(), Mod_VBSP_LoadPlanes(), Mod_VBSP_LoadSurfedges(), Mod_VBSP_LoadTexinfo(), and W_ConvertWAD3TextureBGRA().

◆ MSG_ReadLittleShort()

int MSG_ReadLittleShort ( sizebuf_t * sb )

Definition at line 263 of file com_msg.c.

{
    if (sb->readcount+2 > sb->cursize)
    {
        sb->badread = true;
        return -1;
    }
    sb->readcount += 2;
    return (short)(sb->data[sb->readcount-2] | (sb->data[sb->readcount-1]<<8));
}

References sizebuf_t::badread, sizebuf_t::cursize, sizebuf_t::data, and sizebuf_t::readcount.

Referenced by Mod_Q1BSP_LoadClipnodes(), Mod_Q1BSP_LoadEdges(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadLeaffaces(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadNodes(), Mod_Q2BSP_LoadBrushSides(), Mod_Q2BSP_LoadLeafBrushes(), Mod_Q2BSP_LoadLeafs(), Mod_Q2BSP_LoadNodes(), Mod_VBSP_LoadEdges(), Mod_VBSP_LoadFaces(), MSG_ReadCoord13i(), and MSG_ReadCoord16i().

◆ MSG_ReadString()

char * MSG_ReadString	(	sizebuf_t *	sb,
		char *	string,
		size_t	maxstring )

Definition at line 341 of file com_msg.c.

{
    size_t l = 0;
 
    // read string into sbfer, but only store as many characters as will fit
    // if dest buffer is full sb->readcount will still be advanced to end of message string
    while ((string[l] = MSG_ReadByte_opt(sb)) != '\0')
        if (l < maxstring)
            ++l;
    return string;
}

References MSG_ReadByte_opt, and string.

Referenced by CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ParseTempEntity(), NetConn_ClientParsePacket(), NetConn_ServerParsePacket(), QW_CL_ParseModelList(), QW_CL_ParseSoundList(), QW_CL_ServerInfo(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), SHOWLMP_decodehide(), SHOWLMP_decodeshow(), and SV_ReadClientMessage().

◆ MSG_ReadString_len()

size_t MSG_ReadString_len	(	sizebuf_t *	sb,
		char *	string,
		size_t	maxstring )

Same as MSG_ReadString except it returns the number of bytes written to *string excluding the \0 terminator.

Definition at line 352 of file com_msg.c.

{
    size_t l = 0;
 
    // read string into sbfer, but only store as many characters as will fit
    // if dest buffer is full sb->readcount will still be advanced to end of message string
    while ((string[l] = MSG_ReadByte_opt(sb)) != '\0')
        if (l < maxstring)
            ++l;
    return l;
}

References MSG_ReadByte_opt.

Referenced by CL_ParseServerMessage(), SV_ReadClientMessage(), VM_CL_ReadPicture(), and VM_CL_ReadString().

◆ MSG_ReadVector()

void MSG_ReadVector	(	sizebuf_t *	sb,
		vec3_t	v,
		protocolversion_t	protocol )

Definition at line 401 of file com_msg.c.

{
    v[0] = MSG_ReadCoord(sb, protocol);
    v[1] = MSG_ReadCoord(sb, protocol);
    v[2] = MSG_ReadCoord(sb, protocol);
}

References MSG_ReadCoord(), and v.

Referenced by CL_ParseBeam(), CL_ParseEffect(), CL_ParseEffect2(), CL_ParseParticleEffect(), CL_ParsePointParticles(), CL_ParsePointParticles1(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseStaticSound(), CL_ParseTempEntity(), CL_ParseTrailParticles(), EntityStateQW_ReadPlayerUpdate(), and V_ParseDamage().

◆ MSG_WriteAngle()

void MSG_WriteAngle	(	sizebuf_t *	sb,
		vec_t	f,
		protocolversion_t	protocol )

Definition at line 237 of file com_msg.c.

{
    if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4 || protocol == PROTOCOL_QUAKEWORLD)
        MSG_WriteAngle8i (sb, f);
    else
        MSG_WriteAngle16i (sb, f);
}

References f, MSG_WriteAngle16i(), MSG_WriteAngle8i(), PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, and PROTOCOL_QUAKEWORLD.

Referenced by EntityFrameQuake_WriteFrame(), SV_CreateBaseline(), SV_Spawn_f(), SV_WriteClientdataToMessage(), VM_M_WriteAngle(), VM_SV_makestatic(), and VM_SV_WriteAngle().

◆ MSG_WriteAngle16i()

void MSG_WriteAngle16i	(	sizebuf_t *	sb,
		vec_t	f )

Definition at line 227 of file com_msg.c.

{
    MSG_WriteShort (sb, (int)Q_rint(f*(65536.0/360.0)) & 65535);
}

References f, MSG_WriteShort(), and Q_rint.

Referenced by CL_SendMove(), EntityState5_WriteUpdate(), EntityState_WriteFields(), MSG_WriteAngle(), QW_MSG_WriteDeltaUsercmd(), and SV_WriteClientdataToMessage().

◆ MSG_WriteAngle32f()

void MSG_WriteAngle32f	(	sizebuf_t *	sb,
		vec_t	f )

Definition at line 232 of file com_msg.c.

{
    MSG_WriteFloat (sb, f);
}

References f, and MSG_WriteFloat().

Referenced by CL_SendMove().

◆ MSG_WriteAngle8i()

void MSG_WriteAngle8i	(	sizebuf_t *	sb,
		vec_t	f )

Definition at line 222 of file com_msg.c.

{
    MSG_WriteByte (sb, (int)Q_rint(f*(256.0/360.0)) & 255);
}

References f, MSG_WriteByte(), and Q_rint.

Referenced by CL_SendMove(), EntityState5_WriteUpdate(), EntityState_WriteFields(), and MSG_WriteAngle().

◆ MSG_WriteByte()

void MSG_WriteByte	(	sizebuf_t *	sb,
		int	c )

Definition at line 130 of file com_msg.c.

{
    unsigned char    *buf;
 
    buf = SZ_GetSpace (sb, 1);
    buf[0] = c;
}

References buf, and SZ_GetSpace().

Referenced by CL_DisconnectEx(), CL_ForwardToServer(), CL_ParseServerInfo(), CL_PQRcon_f(), CL_SendMove(), CL_SendPlayerInfo(), CL_SetInfo(), CL_SignonReply(), CL_Stop_f(), Cvar_SetQuick_Internal(), EntityFrame4_WriteFrame(), EntityFrame5_WriteFrame(), EntityFrame_WriteFrame(), EntityFrameCSQC_WriteFrame(), EntityFrameQuake_WriteFrame(), EntityState5_WriteUpdate(), EntityState_WriteExtendBits(), EntityState_WriteFields(), MakeDownloadPacket(), MSG_WriteAngle8i(), NetConn_ClientFrame(), NetConn_ServerParsePacket(), Protocol_WriteStatsReliable(), QW_CL_CheckOrDownloadFile(), QW_CL_NextUpload_f(), QW_CL_ParseDownload(), QW_CL_ParseModelList(), QW_CL_ParseSoundList(), QW_CL_RequestNextDownload(), QW_MSG_WriteDeltaUsercmd(), Sbar_DeathmatchOverlay(), SV_BroadcastPrint(), SV_ClientCommands(), SV_ClientPrint(), SV_Color_f(), SV_CreateBaseline(), SV_DropClient(), SV_ModelIndex(), SV_Name(), SV_Pause_f(), SV_Pings_f(), SV_PreSpawn_f(), SV_SendClientDatagram(), SV_SendServerinfo(), SV_SoundIndex(), SV_Spawn_f(), SV_SpawnServer(), SV_StartEffect(), SV_StartParticle(), SV_StartPointSound(), SV_StartSound(), SV_StopDemoRecording(), SV_UpdateToReliableMessages(), SV_WriteClientdataToMessage(), SV_WriteNetnameIntoDemo(), VM_M_WriteByte(), VM_SV_ambientsound(), VM_SV_makestatic(), VM_SV_pointparticles(), VM_SV_setcolor(), VM_SV_setpause(), VM_SV_te_beam(), VM_SV_te_blood(), VM_SV_te_bloodshower(), VM_SV_te_customflash(), VM_SV_te_explosion(), VM_SV_te_explosion2(), VM_SV_te_explosionquad(), VM_SV_te_explosionrgb(), VM_SV_te_flamejet(), VM_SV_te_gunshot(), VM_SV_te_gunshotquad(), VM_SV_te_knightspike(), VM_SV_te_lavasplash(), VM_SV_te_lightning1(), VM_SV_te_lightning2(), VM_SV_te_lightning3(), VM_SV_te_particlecube(), VM_SV_te_particlerain(), VM_SV_te_particlesnow(), VM_SV_te_plasmaburn(), VM_SV_te_smallflash(), VM_SV_te_spark(), VM_SV_te_spike(), VM_SV_te_spikequad(), VM_SV_te_superspike(), VM_SV_te_superspikequad(), VM_SV_te_tarexplosion(), VM_SV_te_teleport(), VM_SV_te_wizspike(), VM_SV_trailparticles(), and VM_SV_WriteByte().

◆ MSG_WriteChar()

void MSG_WriteChar	(	sizebuf_t *	sb,
		int	c )

Definition at line 122 of file com_msg.c.

{
    unsigned char    *buf;
 
    buf = SZ_GetSpace (sb, 1);
    buf[0] = c;
}

References buf, and SZ_GetSpace().

Referenced by CL_KeepaliveMessage(), CL_Reconnect_f(), MSG_WriteString(), NetConn_ConnectionEstablished(), SV_SendClientDatagram(), SV_StartParticle(), SV_StartSound(), SV_WriteClientdataToMessage(), VM_M_WriteChar(), VM_sprint(), VM_SV_centerprint(), VM_SV_lightstyle(), VM_SV_sprint(), VM_SV_te_blood(), VM_SV_te_spark(), and VM_SV_WriteChar().

◆ MSG_WriteCoord()

void MSG_WriteCoord	(	sizebuf_t *	sb,
		vec_t	f,
		protocolversion_t	protocol )

Definition at line 202 of file com_msg.c.

{
    if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_QUAKEWORLD)
        MSG_WriteCoord13i (sb, f);
    else if (protocol == PROTOCOL_DARKPLACES1)
        MSG_WriteCoord32f (sb, f);
    else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
        MSG_WriteCoord16i (sb, f);
    else
        MSG_WriteCoord32f (sb, f);
}

References f, MSG_WriteCoord13i(), MSG_WriteCoord16i(), MSG_WriteCoord32f(), PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, and PROTOCOL_QUAKEWORLD.

Referenced by EntityFrameQuake_WriteFrame(), MSG_WriteVector(), SV_CreateBaseline(), SV_StartEffect(), SV_StartParticle(), SV_StartPointSound(), SV_StartSound(), SV_WriteClientdataToMessage(), VM_M_WriteCoord(), VM_SV_makestatic(), VM_SV_te_beam(), VM_SV_te_blood(), VM_SV_te_bloodshower(), VM_SV_te_customflash(), VM_SV_te_explosion(), VM_SV_te_explosion2(), VM_SV_te_explosionquad(), VM_SV_te_explosionrgb(), VM_SV_te_flamejet(), VM_SV_te_gunshot(), VM_SV_te_gunshotquad(), VM_SV_te_knightspike(), VM_SV_te_lavasplash(), VM_SV_te_lightning1(), VM_SV_te_lightning2(), VM_SV_te_lightning3(), VM_SV_te_particlecube(), VM_SV_te_particlerain(), VM_SV_te_particlesnow(), VM_SV_te_plasmaburn(), VM_SV_te_smallflash(), VM_SV_te_spark(), VM_SV_te_spike(), VM_SV_te_spikequad(), VM_SV_te_superspike(), VM_SV_te_superspikequad(), VM_SV_te_tarexplosion(), VM_SV_te_teleport(), VM_SV_te_wizspike(), and VM_SV_WriteCoord().

◆ MSG_WriteCoord13i()

void MSG_WriteCoord13i	(	sizebuf_t *	sb,
		vec_t	f )

Definition at line 187 of file com_msg.c.

{
    MSG_WriteShort (sb, Q_rint(f*8));
}

References f, MSG_WriteShort(), and Q_rint.

Referenced by EntityState5_WriteUpdate(), and MSG_WriteCoord().

◆ MSG_WriteCoord16i()

void MSG_WriteCoord16i	(	sizebuf_t *	sb,
		vec_t	f )

Definition at line 192 of file com_msg.c.

{
    MSG_WriteShort (sb, Q_rint(f));
}

References f, MSG_WriteShort(), and Q_rint.

Referenced by CL_SendMove(), EntityState_WriteFields(), MSG_WriteCoord(), and SV_WriteClientdataToMessage().

◆ MSG_WriteCoord32f()

void MSG_WriteCoord32f	(	sizebuf_t *	sb,
		vec_t	f )

Definition at line 197 of file com_msg.c.

{
    MSG_WriteFloat (sb, f);
}

References f, and MSG_WriteFloat().

Referenced by EntityState5_WriteUpdate(), EntityState_WriteFields(), MSG_WriteCoord(), and SV_WriteClientdataToMessage().

◆ MSG_WriteFloat()

void MSG_WriteFloat	(	sizebuf_t *	sb,
		vec_t	f )

Definition at line 158 of file com_msg.c.

{
    union
    {
        float   f;
        int     l;
    } dat;
 
 
    dat.f = f;
    dat.l = LittleLong (dat.l);
 
    SZ_Write (sb, (unsigned char *)&dat.l, 4);
}

References f, LittleLong, and SZ_Write().

Referenced by CL_SendMove(), EntityFrame_WriteFrame(), EntityFrameQuake_WriteFrame(), MSG_WriteAngle32f(), MSG_WriteCoord32f(), SV_SendClientDatagram(), and SV_Spawn_f().

◆ MSG_WriteLong()

void MSG_WriteLong	(	sizebuf_t *	sb,
		int	c )

Definition at line 147 of file com_msg.c.

{
    unsigned char    *buf;
 
    buf = SZ_GetSpace (sb, 4);
    buf[0] = c&0xff;
    buf[1] = (c>>8)&0xff;
    buf[2] = (c>>16)&0xff;
    buf[3] = c>>24;
}

References buf, and SZ_GetSpace().

Referenced by CL_PQRcon_f(), CL_SendMove(), EntityFrame4_WriteFrame(), EntityFrame5_WriteFrame(), EntityFrame_WriteFrame(), EntityState5_WriteUpdate(), MakeDownloadPacket(), NetConn_ClientFrame(), NetConn_ServerParsePacket(), Protocol_WriteStatsReliable(), SCR_CaptureVideo_RIFF_IndexEntry(), SCR_CaptureVideo_RIFF_Write32(), SV_SendClientDatagram(), SV_SendServerinfo(), SV_Spawn_f(), SV_WriteClientdataToMessage(), VM_M_WriteLong(), and VM_SV_WriteLong().

◆ MSG_WriteShort()

void MSG_WriteShort	(	sizebuf_t *	sb,
		int	c )

Definition at line 138 of file com_msg.c.

{
    unsigned char    *buf;
 
    buf = SZ_GetSpace (sb, 2);
    buf[0] = c&0xff;
    buf[1] = c>>8;
}

References buf, and SZ_GetSpace().

Referenced by CL_SendMove(), EntityFrame4_WriteFrame(), EntityFrame5_WriteFrame(), EntityFrame_WriteFrame(), EntityFrameCSQC_WriteFrame(), EntityFrameQuake_WriteFrame(), EntityState5_WriteUpdate(), EntityState_WriteFields(), EntityState_WriteUpdate(), MakeDownloadPacket(), MSG_WriteAngle16i(), MSG_WriteCoord13i(), MSG_WriteCoord16i(), QW_CL_NextUpload_f(), QW_MSG_WriteDeltaUsercmd(), SCR_CaptureVideo_RIFF_Write16(), SV_CreateBaseline(), SV_DropClient(), SV_ModelIndex(), SV_Pings_f(), SV_SendClientDatagram(), SV_SendServerinfo(), SV_SoundIndex(), SV_Spawn_f(), SV_StartEffect(), SV_StartPointSound(), SV_StartSound(), SV_UpdateToReliableMessages(), SV_WriteClientdataToMessage(), VM_M_WriteEntity(), VM_M_WriteShort(), VM_SV_ambientsound(), VM_SV_makestatic(), VM_SV_pointparticles(), VM_SV_te_beam(), VM_SV_te_bloodshower(), VM_SV_te_lightning1(), VM_SV_te_lightning2(), VM_SV_te_lightning3(), VM_SV_te_particlecube(), VM_SV_te_particlerain(), VM_SV_te_particlesnow(), VM_SV_trailparticles(), VM_SV_WriteEntity(), VM_SV_WritePicture(), and VM_SV_WriteShort().

◆ MSG_WriteString()

void MSG_WriteString	(	sizebuf_t *	sb,
		const char *	s )

Definition at line 173 of file com_msg.c.

{
    if (!s || !*s)
        MSG_WriteChar (sb, 0);
    else
        SZ_Write (sb, (unsigned char *)s, (int)strlen(s)+1);
}

References MSG_WriteChar(), strlen(), and SZ_Write().

Referenced by CL_DisconnectEx(), CL_ParseServerInfo(), CL_PQRcon_f(), CL_Reconnect_f(), CL_SendPlayerInfo(), CL_SetInfo(), CL_SignonReply(), Cvar_SetQuick_Internal(), MakeDownloadPacket(), NetConn_ClientFrame(), NetConn_ServerParsePacket(), QW_CL_CheckOrDownloadFile(), QW_CL_ParseDownload(), QW_CL_ParseModelList(), QW_CL_ParseSoundList(), QW_CL_RequestNextDownload(), Sbar_DeathmatchOverlay(), SCR_CaptureVideo_RIFF_WriteTerminatedString(), SV_BroadcastPrint(), SV_ClientCommands(), SV_ClientPrint(), SV_DropClient(), SV_ModelIndex(), SV_Name(), SV_Pings_f(), SV_SendServerinfo(), SV_SoundIndex(), SV_Spawn_f(), SV_SpawnServer(), SV_WriteNetnameIntoDemo(), VM_M_WriteString(), VM_sprint(), VM_SV_centerprint(), VM_SV_lightstyle(), VM_SV_sprint(), VM_SV_WritePicture(), and VM_SV_WriteString().

◆ MSG_WriteUnterminatedString()

void MSG_WriteUnterminatedString	(	sizebuf_t *	sb,
		const char *	s )

Definition at line 181 of file com_msg.c.

{
    if (s && *s)
        SZ_Write (sb, (unsigned char *)s, (int)strlen(s));
}

References strlen(), and SZ_Write().

Referenced by NetConn_ServerParsePacket(), SCR_CaptureVideo_RIFF_IndexEntry(), SCR_CaptureVideo_RIFF_WriteFourCC(), SV_Pings_f(), SV_WriteNetnameIntoDemo(), and VM_SV_WriteUnterminatedString().

◆ MSG_WriteVector()

void MSG_WriteVector	(	sizebuf_t *	sb,
		const vec3_t	v,
		protocolversion_t	protocol )

Definition at line 214 of file com_msg.c.

{
    MSG_WriteCoord (sb, v[0], protocol);
    MSG_WriteCoord (sb, v[1], protocol);
    MSG_WriteCoord (sb, v[2], protocol);
}

References MSG_WriteCoord(), and v.

Referenced by VM_SV_ambientsound(), VM_SV_pointparticles(), and VM_SV_trailparticles().

◆ StoreBigLong()

void StoreBigLong	(	unsigned char *	buffer,
		unsigned int	i )

Encode a big endian 32bit int to the given buffer.

Definition at line 81 of file com_msg.c.

{
    buffer[0] = (i >> 24) & 0xFF;
    buffer[1] = (i >> 16) & 0xFF;
    buffer[2] = (i >>  8) & 0xFF;
    buffer[3] = i         & 0xFF;
}

References buffer, and i.

Referenced by CL_PQRcon_f(), Con_Rcon_Redirect_Flush(), NetConn_ClientFrame(), NetConn_ReceivedMessage(), NetConn_SendUnreliableMessage(), and NetConn_ServerParsePacket().

◆ StoreBigShort()

void StoreBigShort	(	unsigned char *	buffer,
		unsigned short	i )

Encode a big endian 16bit int to the given buffer.

Definition at line 89 of file com_msg.c.

{
    buffer[0] = (i >>  8) & 0xFF;
    buffer[1] = i         & 0xFF;
}

References buffer, and i.

◆ StoreLittleLong()

void StoreLittleLong	(	unsigned char *	buffer,
		unsigned int	i )

Encode a little endian 32bit int to the given buffer.

Definition at line 95 of file com_msg.c.

{
    buffer[0] = i         & 0xFF;
    buffer[1] = (i >>  8) & 0xFF;
    buffer[2] = (i >> 16) & 0xFF;
    buffer[3] = (i >> 24) & 0xFF;
}

References buffer, and i.

Referenced by NetConn_SendUnreliableMessage(), and R_SaveTextureDDSFile().

◆ StoreLittleShort()

void StoreLittleShort	(	unsigned char *	buffer,
		unsigned short	i )

Encode a little endian 16bit int to the given buffer.

Definition at line 103 of file com_msg.c.

{
    buffer[0] = i         & 0xFF;
    buffer[1] = (i >>  8) & 0xFF;
}

References buffer, and i.

◆ 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

◆ cmdline

struct cvar_s cmdline

extern

Definition at line 33 of file common.c.

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

CF_READONLY

#define CF_READONLY

cvar cannot be changed from the console or the command buffer, and is considered CF_PERSISTENT

Definition cmd.h:54

CF_SERVER

#define CF_SERVER

cvar/command that only the server can change/execute

Definition cmd.h:49

CF_CLIENT

#define CF_CLIENT

cvar/command that only the client can change/execute

Definition cmd.h:48

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

◆ com_token

char com_token[MAX_INPUTLINE]

extern

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

extern

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().

◆ registered

struct cvar_s registered

extern

Definition at line 32 of file common.c.

32{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().

Data Structures

Macros

Functions

Byte order functions.

Message IO functions.

Macro Definition Documentation

◆ ARRAY_SIZE

◆ BigFloat

◆ BigLong

◆ BigShort

◆ ContainerOf

◆ DP_STATIC_ASSERT

◆ dp_strlcat

◆ dp_strlcpy

◆ LittleFloat

◆ LittleLong

◆ LittleShort

◆ MSG_ReadByte

◆ MSG_ReadByte_opt

◆ MSG_ReadChar

◆ MSG_ReadFloat

◆ MSG_ReadLong

◆ MSG_ReadShort

◆ snprintf

◆ sprintf

◆ stpcpy

◆ strcat

◆ strcpy

◆ strlcat

◆ strlcpy

◆ strncat

◆ strncpy

◆ ustpcpy

◆ ustr2stp

◆ vsnprintf

Typedef Documentation

◆ COM_LineProcessorFunc

◆ COM_WordWidthFunc_t

Enumeration Type Documentation

◆ protocolversion_t

◆ userdirmode_t

Function Documentation

◆ base64_encode()

◆ BuffBigFloat()

◆ BuffBigLong()

◆ BuffBigShort()

◆ BuffLittleFloat()

◆ BuffLittleLong()

◆ BuffLittleShort()

◆ Com_BlockChecksum()

◆ Com_BlockFullChecksum()

◆ COM_BlockSequenceCRCByteQW()

◆ Com_CalcRoll()

◆ Com_HexDumpToConsole()

◆ COM_Init()

◆ COM_Init_Commands()

◆ COM_ParseToken_Console()

◆ COM_ParseToken_QuakeC()

◆ COM_ParseToken_Simple()

◆ COM_ParseToken_VM_Tokenize()

◆ COM_ReadAndTokenizeLine()

◆ COM_Shutdown()

◆ COM_StringBeginsWith()

◆ COM_StringDecolorize()

◆ COM_StringLengthNoColors()

◆ COM_ToLowerString()

◆ COM_ToUpperString()

◆ COM_Wordwrap()

◆ CRC_Block()

◆ CRC_Block_CaseInsensitive()

◆ dp__strlcat()

◆ dp__strlcpy()

◆ dp_stpecpy()

◆ dp_ustr2stp()

◆ dpsnprintf()

◆ dpvsnprintf()

◆ FindFraction()

◆ MSG_BeginReading()

◆ MSG_InitReadBuffer()

◆ MSG_ReadAngle()