fix various standards violations
parent
7c1801a236
commit
49b23bd290
|
@ -35,7 +35,7 @@ cvar_t bgm_extmusic = {"bgm_extmusic", "1", CVAR_ARCHIVE};
|
|||
static bool no_extmusic = false;
|
||||
static float old_volume = -1.0f;
|
||||
|
||||
typedef enum _bgm_player
|
||||
typedef enum
|
||||
{
|
||||
BGM_NONE = -1,
|
||||
BGM_MIDIDRV = 1,
|
||||
|
|
|
@ -264,7 +264,7 @@ void IN_JumpUp(void)
|
|||
|
||||
void IN_Impulse(void)
|
||||
{
|
||||
in_impulse = Q_atoi(Cmd_Argv(1));
|
||||
in_impulse = atoi(Cmd_Argv(1));
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -404,7 +404,7 @@ void CL_BaseMove(usercmd_t *cmd)
|
|||
|
||||
CL_AdjustAngles();
|
||||
|
||||
Q_memset(cmd, 0, sizeof(*cmd));
|
||||
memset(cmd, 0, sizeof(*cmd));
|
||||
|
||||
if(in_strafe.state & 1)
|
||||
{
|
||||
|
|
|
@ -1056,7 +1056,7 @@ void CL_ParseServerMessage(void)
|
|||
if(i >= MAX_LIGHTSTYLES)
|
||||
Sys_Error("svc_lightstyle > MAX_LIGHTSTYLES");
|
||||
q_strlcpy(cl_lightstyle[i].map, MSG_ReadString(), MAX_STYLESTRING);
|
||||
cl_lightstyle[i].length = Q_strlen(cl_lightstyle[i].map);
|
||||
cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
|
||||
//johnfitz -- save extra info
|
||||
if(cl_lightstyle[i].length)
|
||||
{
|
||||
|
|
28
source/cmd.c
28
source/cmd.c
|
@ -74,7 +74,7 @@ Cbuf_Init
|
|||
*/
|
||||
void Cbuf_Init(void)
|
||||
{
|
||||
SZ_Alloc(&cmd_text, 1 << 18); // space for commands and script files. spike -- was 8192, but modern configs can be _HUGE_, at least if they contain lots of comments/docs for things.
|
||||
SZ_Alloc(&cmd_text, 1 << 18); // space for commands and script files. spike -- was 8192, but modern configs can be *HUGE*, at least if they contain lots of comments/docs for things.
|
||||
}
|
||||
|
||||
|
||||
|
@ -89,7 +89,7 @@ void Cbuf_AddText(const char *text)
|
|||
{
|
||||
int32_t l;
|
||||
|
||||
l = Q_strlen(text);
|
||||
l = strlen(text);
|
||||
|
||||
if(cmd_text.cursize + l >= cmd_text.maxsize)
|
||||
{
|
||||
|
@ -97,7 +97,7 @@ void Cbuf_AddText(const char *text)
|
|||
return;
|
||||
}
|
||||
|
||||
SZ_Write(&cmd_text, text, Q_strlen(text));
|
||||
SZ_Write(&cmd_text, text, strlen(text));
|
||||
}
|
||||
|
||||
|
||||
|
@ -120,7 +120,7 @@ void Cbuf_InsertText(const char *text)
|
|||
if(templen)
|
||||
{
|
||||
temp = (char *) Z_Malloc(templen);
|
||||
Q_memcpy(temp, cmd_text.data, templen);
|
||||
memcpy(temp, cmd_text.data, templen);
|
||||
SZ_Clear(&cmd_text);
|
||||
}
|
||||
else
|
||||
|
@ -468,12 +468,12 @@ void Cmd_List_f(void)
|
|||
{
|
||||
cmd_function_t *cmd;
|
||||
const char *partial;
|
||||
int32_t len, count;
|
||||
size_t len, count;
|
||||
|
||||
if(Cmd_Argc() > 1)
|
||||
{
|
||||
partial = Cmd_Argv(1);
|
||||
len = Q_strlen(partial);
|
||||
len = strlen(partial);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -484,7 +484,7 @@ void Cmd_List_f(void)
|
|||
count = 0;
|
||||
for(cmd = cmd_functions ; cmd ; cmd = cmd->next)
|
||||
{
|
||||
if(partial && Q_strncmp(partial, cmd->name, len))
|
||||
if(partial && strncmp(partial, cmd->name, len))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
@ -492,7 +492,7 @@ void Cmd_List_f(void)
|
|||
count++;
|
||||
}
|
||||
|
||||
Con_SafePrintf("%" PRIi32 " commands", count);
|
||||
Con_SafePrintf("%zu commands", count);
|
||||
if(partial)
|
||||
{
|
||||
Con_SafePrintf(" beginning with \"%s\"", partial);
|
||||
|
@ -502,7 +502,7 @@ void Cmd_List_f(void)
|
|||
|
||||
static char *Cmd_TintSubstring(const char *in, const char *substr, char *out, size_t outsize)
|
||||
{
|
||||
int32_t l;
|
||||
size_t l;
|
||||
char *m;
|
||||
q_strlcpy(out, in, outsize);
|
||||
while((m = q_strcasestr(out, substr)))
|
||||
|
@ -686,7 +686,7 @@ void Cmd_AddCommand(const char *cmd_name, xcommand_t function)
|
|||
// fail if the command already exists
|
||||
for(cmd = cmd_functions ; cmd ; cmd = cmd->next)
|
||||
{
|
||||
if(!Q_strcmp(cmd_name, cmd->name))
|
||||
if(!strcmp(cmd_name, cmd->name))
|
||||
{
|
||||
Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name);
|
||||
return;
|
||||
|
@ -729,7 +729,7 @@ bool Cmd_Exists(const char *cmd_name)
|
|||
|
||||
for(cmd = cmd_functions ; cmd ; cmd = cmd->next)
|
||||
{
|
||||
if(!Q_strcmp(cmd_name, cmd->name))
|
||||
if(!strcmp(cmd_name, cmd->name))
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -746,16 +746,16 @@ Cmd_CompleteCommand
|
|||
const char *Cmd_CompleteCommand(const char *partial)
|
||||
{
|
||||
cmd_function_t *cmd;
|
||||
int32_t len;
|
||||
size_t len;
|
||||
|
||||
len = Q_strlen(partial);
|
||||
len = strlen(partial);
|
||||
|
||||
if(!len)
|
||||
return NULL;
|
||||
|
||||
// check functions
|
||||
for(cmd = cmd_functions ; cmd ; cmd = cmd->next)
|
||||
if(!Q_strncmp(partial, cmd->name, len))
|
||||
if(!strncmp(partial, cmd->name, len))
|
||||
return cmd->name;
|
||||
|
||||
return NULL;
|
||||
|
|
270
source/common.c
270
source/common.c
|
@ -252,262 +252,6 @@ int32_t q_snprintf(char *str, size_t size, const char *format, ...)
|
|||
return ret;
|
||||
}
|
||||
|
||||
void Q_memset(void *dest, int32_t fill, size_t count)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if((((size_t)dest | count) & 3) == 0)
|
||||
{
|
||||
count >>= 2;
|
||||
fill = fill | (fill << 8) | (fill << 16) | (fill << 24);
|
||||
for(i = 0; i < count; i++)
|
||||
((int32_t *)dest)[i] = fill;
|
||||
}
|
||||
else
|
||||
for(i = 0; i < count; i++)
|
||||
((byte *)dest)[i] = fill;
|
||||
}
|
||||
|
||||
void Q_memcpy(void *dest, const void *src, size_t count)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if((((size_t)dest | (size_t)src | count) & 3) == 0)
|
||||
{
|
||||
count >>= 2;
|
||||
for(i = 0; i < count; i++)
|
||||
((int32_t *)dest)[i] = ((int32_t *)src)[i];
|
||||
}
|
||||
else
|
||||
for(i = 0; i < count; i++)
|
||||
((byte *)dest)[i] = ((byte *)src)[i];
|
||||
}
|
||||
|
||||
int32_t Q_memcmp(const void *m1, const void *m2, size_t count)
|
||||
{
|
||||
while(count)
|
||||
{
|
||||
count--;
|
||||
if(((byte *)m1)[count] != ((byte *)m2)[count])
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void Q_strcpy(char *dest, const char *src)
|
||||
{
|
||||
while(*src)
|
||||
{
|
||||
*dest++ = *src++;
|
||||
}
|
||||
*dest++ = 0;
|
||||
}
|
||||
|
||||
void Q_strncpy(char *dest, const char *src, int32_t count)
|
||||
{
|
||||
while(*src && count--)
|
||||
{
|
||||
*dest++ = *src++;
|
||||
}
|
||||
if(count)
|
||||
*dest++ = 0;
|
||||
}
|
||||
|
||||
int32_t Q_strlen(const char *str)
|
||||
{
|
||||
int32_t count;
|
||||
|
||||
count = 0;
|
||||
while(str[count])
|
||||
count++;
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
char *Q_strrchr(const char *s, char c)
|
||||
{
|
||||
int32_t len = Q_strlen(s);
|
||||
s += len;
|
||||
while(len--)
|
||||
{
|
||||
if(*--s == c)
|
||||
return (char *)s;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void Q_strcat(char *dest, const char *src)
|
||||
{
|
||||
dest += Q_strlen(dest);
|
||||
Q_strcpy(dest, src);
|
||||
}
|
||||
|
||||
int32_t Q_strcmp(const char *s1, const char *s2)
|
||||
{
|
||||
while(1)
|
||||
{
|
||||
if(*s1 != *s2)
|
||||
return -1; // strings not equal
|
||||
if(!*s1)
|
||||
return 0; // strings are equal
|
||||
s1++;
|
||||
s2++;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int32_t Q_strncmp(const char *s1, const char *s2, int32_t count)
|
||||
{
|
||||
while(1)
|
||||
{
|
||||
if(!count--)
|
||||
return 0;
|
||||
if(*s1 != *s2)
|
||||
return -1; // strings not equal
|
||||
if(!*s1)
|
||||
return 0; // strings are equal
|
||||
s1++;
|
||||
s2++;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int32_t Q_atoi(const char *str)
|
||||
{
|
||||
int32_t val;
|
||||
int32_t sign;
|
||||
int32_t c;
|
||||
|
||||
if(*str == '-')
|
||||
{
|
||||
sign = -1;
|
||||
str++;
|
||||
}
|
||||
else
|
||||
sign = 1;
|
||||
|
||||
val = 0;
|
||||
|
||||
//
|
||||
// check for hex
|
||||
//
|
||||
if(str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
|
||||
{
|
||||
str += 2;
|
||||
while(1)
|
||||
{
|
||||
c = *str++;
|
||||
if(c >= '0' && c <= '9')
|
||||
val = (val << 4) + c - '0';
|
||||
else if(c >= 'a' && c <= 'f')
|
||||
val = (val << 4) + c - 'a' + 10;
|
||||
else if(c >= 'A' && c <= 'F')
|
||||
val = (val << 4) + c - 'A' + 10;
|
||||
else
|
||||
return val * sign;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// check for character
|
||||
//
|
||||
if(str[0] == '\'')
|
||||
{
|
||||
return sign * str[1];
|
||||
}
|
||||
|
||||
//
|
||||
// assume decimal
|
||||
//
|
||||
while(1)
|
||||
{
|
||||
c = *str++;
|
||||
if(c < '0' || c > '9')
|
||||
return val * sign;
|
||||
val = val * 10 + c - '0';
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
float Q_atof(const char *str)
|
||||
{
|
||||
double val;
|
||||
int32_t sign;
|
||||
int32_t c;
|
||||
int32_t decimal, total;
|
||||
|
||||
if(*str == '-')
|
||||
{
|
||||
sign = -1;
|
||||
str++;
|
||||
}
|
||||
else
|
||||
sign = 1;
|
||||
|
||||
val = 0;
|
||||
|
||||
//
|
||||
// check for hex
|
||||
//
|
||||
if(str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
|
||||
{
|
||||
str += 2;
|
||||
while(1)
|
||||
{
|
||||
c = *str++;
|
||||
if(c >= '0' && c <= '9')
|
||||
val = (val * 16) + c - '0';
|
||||
else if(c >= 'a' && c <= 'f')
|
||||
val = (val * 16) + c - 'a' + 10;
|
||||
else if(c >= 'A' && c <= 'F')
|
||||
val = (val * 16) + c - 'A' + 10;
|
||||
else
|
||||
return val * sign;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// check for character
|
||||
//
|
||||
if(str[0] == '\'')
|
||||
{
|
||||
return sign * str[1];
|
||||
}
|
||||
|
||||
//
|
||||
// assume decimal
|
||||
//
|
||||
decimal = -1;
|
||||
total = 0;
|
||||
while(1)
|
||||
{
|
||||
c = *str++;
|
||||
if(c == '.')
|
||||
{
|
||||
decimal = total;
|
||||
continue;
|
||||
}
|
||||
if(c < '0' || c > '9')
|
||||
break;
|
||||
val = val * 10 + c - '0';
|
||||
total++;
|
||||
}
|
||||
|
||||
if(decimal == -1)
|
||||
return val * sign;
|
||||
while(total > decimal)
|
||||
{
|
||||
val /= 10;
|
||||
total--;
|
||||
}
|
||||
|
||||
return val * sign;
|
||||
}
|
||||
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
|
@ -591,7 +335,7 @@ void MSG_WriteString(sizebuf_t *sb, const char *s)
|
|||
if(!s)
|
||||
SZ_Write(sb, "", 1);
|
||||
else
|
||||
SZ_Write(sb, s, Q_strlen(s) + 1);
|
||||
SZ_Write(sb, s, strlen(s) + 1);
|
||||
}
|
||||
|
||||
//johnfitz -- original behavior, 13.3 fixed point coords, max range +-4096
|
||||
|
@ -858,22 +602,22 @@ void *SZ_GetSpace(sizebuf_t *buf, int32_t length)
|
|||
|
||||
void SZ_Write(sizebuf_t *buf, const void *data, int32_t length)
|
||||
{
|
||||
Q_memcpy(SZ_GetSpace(buf, length), data, length);
|
||||
memcpy(SZ_GetSpace(buf, length), data, length);
|
||||
}
|
||||
|
||||
void SZ_Print(sizebuf_t *buf, const char *data)
|
||||
{
|
||||
int32_t len = Q_strlen(data) + 1;
|
||||
int32_t len = strlen(data) + 1;
|
||||
|
||||
if(buf->data[buf->cursize - 1])
|
||||
{
|
||||
/* no trailing 0 */
|
||||
Q_memcpy((byte *)SZ_GetSpace(buf, len), data, len);
|
||||
memcpy((byte *)SZ_GetSpace(buf, len), data, len);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* write over trailing 0 */
|
||||
Q_memcpy((byte *)SZ_GetSpace(buf, len - 1) - 1, data, len);
|
||||
memcpy((byte *)SZ_GetSpace(buf, len - 1) - 1, data, len);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1121,7 +865,7 @@ int32_t COM_CheckParm(const char *parm)
|
|||
{
|
||||
if(!com_argv[i])
|
||||
continue; // NEXTSTEP sometimes clears appkit vars.
|
||||
if(!Q_strcmp(parm, com_argv[i]))
|
||||
if(!strcmp(parm, com_argv[i]))
|
||||
return i;
|
||||
}
|
||||
|
||||
|
@ -1163,7 +907,7 @@ void COM_InitArgv(int32_t argc, char **argv)
|
|||
for(com_argc = 0; (com_argc < MAX_NUM_ARGVS) && (com_argc < argc); com_argc++)
|
||||
{
|
||||
largv[com_argc] = argv[com_argc];
|
||||
if(!Q_strcmp("-safe", argv[com_argc]))
|
||||
if(!strcmp("-safe", argv[com_argc]))
|
||||
safemode = 1;
|
||||
}
|
||||
|
||||
|
|
|
@ -165,19 +165,6 @@ float MSG_ReadAngle16(uint32_t flags); //johnfitz
|
|||
|
||||
//============================================================================
|
||||
|
||||
void Q_memset(void *dest, int32_t fill, size_t count);
|
||||
void Q_memcpy(void *dest, const void *src, size_t count);
|
||||
int32_t Q_memcmp(const void *m1, const void *m2, size_t count);
|
||||
void Q_strcpy(char *dest, const char *src);
|
||||
void Q_strncpy(char *dest, const char *src, int32_t count);
|
||||
int32_t Q_strlen(const char *str);
|
||||
char *Q_strrchr(const char *s, char c);
|
||||
void Q_strcat(char *dest, const char *src);
|
||||
int32_t Q_strcmp(const char *s1, const char *s2);
|
||||
int32_t Q_strncmp(const char *s1, const char *s2, int32_t count);
|
||||
int32_t Q_atoi(const char *str);
|
||||
float Q_atof(const char *str);
|
||||
|
||||
/* use our own copies of strlcpy and strlcat taken from OpenBSD */
|
||||
size_t q_strlcpy(char *dst, const char *src, size_t size);
|
||||
size_t q_strlcat(char *dst, const char *src, size_t size);
|
||||
|
@ -319,7 +306,7 @@ const char *COM_ParseStringNewline(const char *buffer);
|
|||
* Allocating and filling in the fshandle_t structure is the users'
|
||||
* responsibility when the file is initially opened. */
|
||||
|
||||
typedef struct _fshandle_t
|
||||
typedef struct
|
||||
{
|
||||
FILE *file;
|
||||
bool pak; /* is the file read from a pak */
|
||||
|
|
|
@ -140,7 +140,7 @@ Con_Clear_f
|
|||
static void Con_Clear_f(void)
|
||||
{
|
||||
if(con_text)
|
||||
Q_memset(con_text, ' ', con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
memset(con_text, ' ', con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
con_backscroll = 0; //johnfitz -- if console is empty, being scrolled up is confusing
|
||||
}
|
||||
|
||||
|
@ -276,8 +276,8 @@ void Con_CheckResize(void)
|
|||
mark = Hunk_LowMark(); //johnfitz
|
||||
tbuf = Hunk_AllocName(con_buffersize, __func__); //johnfitz
|
||||
|
||||
Q_memcpy(tbuf, con_text, con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
Q_memset(con_text, ' ', con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
memcpy(tbuf, con_text, con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
memset(con_text, ' ', con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
|
||||
for(i = 0; i < numlines; i++)
|
||||
{
|
||||
|
@ -309,13 +309,13 @@ void Con_Init(void)
|
|||
//johnfitz -- user settable console buffer size
|
||||
i = COM_CheckParm("-consize");
|
||||
if(i && i < com_argc - 1)
|
||||
con_buffersize = q_max(CON_MINSIZE, Q_atoi(com_argv[i + 1]) * 1024);
|
||||
con_buffersize = q_max(CON_MINSIZE, atoi(com_argv[i + 1]) * 1024);
|
||||
else
|
||||
con_buffersize = CON_TEXTSIZE;
|
||||
//johnfitz
|
||||
|
||||
con_text = (char *)Hunk_AllocName(con_buffersize, "con_text"); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
Q_memset(con_text, ' ', con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
memset(con_text, ' ', con_buffersize); //johnfitz -- con_buffersize replaces CON_TEXTSIZE
|
||||
con_linewidth = -1;
|
||||
|
||||
//johnfitz -- no need to run Con_CheckResize here
|
||||
|
@ -355,7 +355,7 @@ static void Con_Linefeed(void)
|
|||
|
||||
con_x = 0;
|
||||
con_current++;
|
||||
Q_memset(&con_text[(con_current % con_totallines)*con_linewidth], ' ', con_linewidth);
|
||||
memset(&con_text[(con_current % con_totallines)*con_linewidth], ' ', con_linewidth);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -836,7 +836,7 @@ const char *FindCompletion(const char *partial, filelist_item_t *filelist, int32
|
|||
static char matched[32];
|
||||
char *i_matched, *i_name;
|
||||
filelist_item_t *file;
|
||||
int32_t init, match, plen;
|
||||
size_t init, match, plen;
|
||||
|
||||
memset(matched, 0, sizeof(matched));
|
||||
plen = strlen(partial);
|
||||
|
@ -893,7 +893,7 @@ void BuildTabList(const char *partial)
|
|||
cmdalias_t *alias;
|
||||
cvar_t *cvar;
|
||||
cmd_function_t *cmd;
|
||||
int32_t len;
|
||||
size_t len;
|
||||
|
||||
tablist = NULL;
|
||||
len = strlen(partial);
|
||||
|
@ -903,15 +903,15 @@ void BuildTabList(const char *partial)
|
|||
|
||||
cvar = Cvar_FindVarAfter("", CVAR_NONE);
|
||||
for(; cvar ; cvar = cvar->next)
|
||||
if(!Q_strncmp(partial, cvar->name, len))
|
||||
if(!strncmp(partial, cvar->name, len))
|
||||
AddToTabList(cvar->name, "cvar");
|
||||
|
||||
for(cmd = cmd_functions ; cmd ; cmd = cmd->next)
|
||||
if(!Q_strncmp(partial, cmd->name, len))
|
||||
if(!strncmp(partial, cmd->name, len))
|
||||
AddToTabList(cmd->name, "command");
|
||||
|
||||
for(alias = cmd_alias ; alias ; alias = alias->next)
|
||||
if(!Q_strncmp(partial, alias->name, len))
|
||||
if(!strncmp(partial, alias->name, len))
|
||||
AddToTabList(alias->name, "alias");
|
||||
}
|
||||
|
||||
|
@ -963,7 +963,7 @@ void Con_TabComplete(void)
|
|||
q_strlcpy(partial, matched_map, MAXCMDLINE);
|
||||
*c = '\0';
|
||||
q_strlcat(key_lines[edit_line], partial, MAXCMDLINE);
|
||||
key_linepos = c - key_lines[edit_line] + Q_strlen(matched_map); //set new cursor position
|
||||
key_linepos = c - key_lines[edit_line] + strlen(matched_map); //set new cursor position
|
||||
if(key_linepos >= MAXCMDLINE)
|
||||
key_linepos = MAXCMDLINE - 1;
|
||||
// if only one match, append a space
|
||||
|
@ -1027,7 +1027,7 @@ void Con_TabComplete(void)
|
|||
match = keydown[K_SHIFT] ? t->prev->name : t->name;
|
||||
do
|
||||
{
|
||||
if(!Q_strcmp(t->name, partial))
|
||||
if(!strcmp(t->name, partial))
|
||||
{
|
||||
match = keydown[K_SHIFT] ? t->prev->name : t->next->name;
|
||||
break;
|
||||
|
@ -1043,7 +1043,7 @@ void Con_TabComplete(void)
|
|||
q_strlcat(partial, key_lines[edit_line] + key_linepos, MAXCMDLINE); //then add chars after cursor
|
||||
*c = '\0'; //now copy all of this into edit line
|
||||
q_strlcat(key_lines[edit_line], partial, MAXCMDLINE);
|
||||
key_linepos = c - key_lines[edit_line] + Q_strlen(match); //set new cursor position
|
||||
key_linepos = c - key_lines[edit_line] + strlen(match); //set new cursor position
|
||||
if(key_linepos >= MAXCMDLINE)
|
||||
key_linepos = MAXCMDLINE - 1;
|
||||
|
||||
|
|
|
@ -43,12 +43,12 @@ void Cvar_List_f(void)
|
|||
{
|
||||
cvar_t *cvar;
|
||||
const char *partial;
|
||||
int32_t len, count;
|
||||
size_t len, count;
|
||||
|
||||
if(Cmd_Argc() > 1)
|
||||
{
|
||||
partial = Cmd_Argv(1);
|
||||
len = Q_strlen(partial);
|
||||
len = strlen(partial);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -59,7 +59,7 @@ void Cvar_List_f(void)
|
|||
count = 0;
|
||||
for(cvar = cvar_vars ; cvar ; cvar = cvar->next)
|
||||
{
|
||||
if(partial && Q_strncmp(partial, cvar->name, len))
|
||||
if(partial && strncmp(partial, cvar->name, len))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
@ -71,7 +71,7 @@ void Cvar_List_f(void)
|
|||
count++;
|
||||
}
|
||||
|
||||
Con_SafePrintf("%" PRIi32 " cvars", count);
|
||||
Con_SafePrintf("%zu cvars", count);
|
||||
if(partial)
|
||||
{
|
||||
Con_SafePrintf(" beginning with \"%s\"", partial);
|
||||
|
@ -96,7 +96,7 @@ void Cvar_Inc_f(void)
|
|||
Cvar_SetValue(Cmd_Argv(1), Cvar_VariableValue(Cmd_Argv(1)) + 1);
|
||||
break;
|
||||
case 3:
|
||||
Cvar_SetValue(Cmd_Argv(1), Cvar_VariableValue(Cmd_Argv(1)) + Q_atof(Cmd_Argv(2)));
|
||||
Cvar_SetValue(Cmd_Argv(1), Cvar_VariableValue(Cmd_Argv(1)) + atof(Cmd_Argv(2)));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -146,14 +146,14 @@ void Cvar_Cycle_f(void)
|
|||
//zero is assumed to be a string, even though it could actually be zero. The worst case
|
||||
//is that the first time you call this command, it won't match on zero when it should, but after that,
|
||||
//it will be comparing strings that all had the same source (the user) so it will work.
|
||||
if(Q_atof(Cmd_Argv(i)) == 0)
|
||||
if(atof(Cmd_Argv(i)) == 0)
|
||||
{
|
||||
if(!strcmp(Cmd_Argv(i), Cvar_VariableString(Cmd_Argv(1))))
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(Q_atof(Cmd_Argv(i)) == Cvar_VariableValue(Cmd_Argv(1)))
|
||||
if(atof(Cmd_Argv(i)) == Cvar_VariableValue(Cmd_Argv(1)))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -251,7 +251,7 @@ cvar_t *Cvar_FindVar(const char *var_name)
|
|||
|
||||
for(var = cvar_vars ; var ; var = var->next)
|
||||
{
|
||||
if(!Q_strcmp(var_name, var->name))
|
||||
if(!strcmp(var_name, var->name))
|
||||
return var;
|
||||
}
|
||||
|
||||
|
@ -323,7 +323,7 @@ float Cvar_VariableValue(const char *var_name)
|
|||
var = Cvar_FindVar(var_name);
|
||||
if(!var)
|
||||
return 0;
|
||||
return Q_atof(var->string);
|
||||
return atof(var->string);
|
||||
}
|
||||
|
||||
|
||||
|
@ -351,16 +351,16 @@ Cvar_CompleteVariable
|
|||
const char *Cvar_CompleteVariable(const char *partial)
|
||||
{
|
||||
cvar_t *cvar;
|
||||
int32_t len;
|
||||
size_t len;
|
||||
|
||||
len = Q_strlen(partial);
|
||||
len = strlen(partial);
|
||||
if(!len)
|
||||
return NULL;
|
||||
|
||||
// check functions
|
||||
for(cvar = cvar_vars ; cvar ; cvar = cvar->next)
|
||||
{
|
||||
if(!Q_strncmp(partial, cvar->name, len))
|
||||
if(!strncmp(partial, cvar->name, len))
|
||||
return cvar->name;
|
||||
}
|
||||
|
||||
|
@ -394,14 +394,14 @@ void Cvar_SetQuick(cvar_t *var, const char *value)
|
|||
var->string = Z_Strdup(value);
|
||||
else
|
||||
{
|
||||
int32_t len;
|
||||
size_t len;
|
||||
|
||||
if(!strcmp(var->string, value))
|
||||
return; // no change
|
||||
|
||||
var->flags |= CVAR_CHANGED;
|
||||
len = Q_strlen(value);
|
||||
if(len != Q_strlen(var->string))
|
||||
len = strlen(value);
|
||||
if(len != strlen(var->string))
|
||||
{
|
||||
Z_Free(var->string);
|
||||
var->string = (char *) Z_Malloc(len + 1);
|
||||
|
@ -409,7 +409,7 @@ void Cvar_SetQuick(cvar_t *var, const char *value)
|
|||
memcpy((char *)var->string, value, len + 1);
|
||||
}
|
||||
|
||||
var->value = Q_atof(var->string);
|
||||
var->value = atof(var->string);
|
||||
|
||||
//johnfitz -- save initial value for "reset" command
|
||||
if(!var->default_string)
|
||||
|
|
|
@ -498,7 +498,7 @@ void Mod_LoadTextures(lump_t *l)
|
|||
//johnfitz -- lots of changes
|
||||
if(!isDedicated) //no texture uploading for dedicated server
|
||||
{
|
||||
if(!q_strncasecmp(tx->name, "sky", 3)) //sky texture //also note -- was Q_strncmp, changed to match qbsp
|
||||
if(!q_strncasecmp(tx->name, "sky", 3)) //sky texture //also note -- was strncmp, changed to match qbsp
|
||||
Sky_LoadTexture(tx);
|
||||
else if(tx->name[0] == '*') //warping texture
|
||||
{
|
||||
|
@ -1218,7 +1218,7 @@ void Mod_LoadFaces(lump_t *l, bool bsp2)
|
|||
out->samples = loadmodel->lightdata + (lofs * 3); //johnfitz -- lit support via lordhavoc (was "+ i")
|
||||
|
||||
//johnfitz -- this section rewritten
|
||||
if(!q_strncasecmp(out->texinfo->texture->name, "sky", 3)) // sky surface //also note -- was Q_strncmp, changed to match qbsp
|
||||
if(!q_strncasecmp(out->texinfo->texture->name, "sky", 3)) // sky surface //also note -- was strncmp, changed to match qbsp
|
||||
{
|
||||
out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
|
||||
Mod_PolyForUnlitSurface(out); //no more subdivision
|
||||
|
|
|
@ -782,7 +782,7 @@ void SCR_ScreenShot_f(void)
|
|||
int32_t i, quality;
|
||||
bool ok;
|
||||
|
||||
Q_strncpy(ext, "png", sizeof(ext));
|
||||
strncpy(ext, "png", sizeof(ext));
|
||||
|
||||
if(Cmd_Argc() >= 2)
|
||||
{
|
||||
|
@ -791,7 +791,7 @@ void SCR_ScreenShot_f(void)
|
|||
if(!q_strcasecmp("png", requested_ext)
|
||||
|| !q_strcasecmp("tga", requested_ext)
|
||||
|| !q_strcasecmp("jpg", requested_ext))
|
||||
Q_strncpy(ext, requested_ext, sizeof(ext));
|
||||
strncpy(ext, requested_ext, sizeof(ext));
|
||||
else
|
||||
{
|
||||
SCR_ScreenShot_Usage();
|
||||
|
@ -802,7 +802,7 @@ void SCR_ScreenShot_f(void)
|
|||
// read quality as the 3rd param (only used for JPG)
|
||||
quality = 90;
|
||||
if(Cmd_Argc() >= 3)
|
||||
quality = Q_atoi(Cmd_Argv(2));
|
||||
quality = atoi(Cmd_Argv(2));
|
||||
if(quality < 1 || quality > 100)
|
||||
{
|
||||
SCR_ScreenShot_Usage();
|
||||
|
|
|
@ -134,7 +134,7 @@ static void TexMgr_TextureMode_f(cvar_t *var)
|
|||
|
||||
for(i = 0; i < NUM_GLMODES; i++)
|
||||
{
|
||||
if(!Q_strcmp(glmodes[i].name, gl_texturemode.string))
|
||||
if(!strcmp(glmodes[i].name, gl_texturemode.string))
|
||||
{
|
||||
if(glmode_idx != i)
|
||||
{
|
||||
|
|
|
@ -191,7 +191,7 @@ void Host_FindMaxClients(void)
|
|||
cls.state = ca_dedicated;
|
||||
if(i != (com_argc - 1))
|
||||
{
|
||||
svs.maxclients = Q_atoi(com_argv[i + 1]);
|
||||
svs.maxclients = atoi(com_argv[i + 1]);
|
||||
}
|
||||
else
|
||||
svs.maxclients = 8;
|
||||
|
@ -205,7 +205,7 @@ void Host_FindMaxClients(void)
|
|||
if(cls.state == ca_dedicated)
|
||||
Sys_Error("Only one of -dedicated or -listen can be specified");
|
||||
if(i != (com_argc - 1))
|
||||
svs.maxclients = Q_atoi(com_argv[i + 1]);
|
||||
svs.maxclients = atoi(com_argv[i + 1]);
|
||||
else
|
||||
svs.maxclients = 8;
|
||||
}
|
||||
|
@ -666,7 +666,7 @@ Host_Frame
|
|||
Runs all active servers
|
||||
==================
|
||||
*/
|
||||
void _Host_Frame(float time)
|
||||
static void Host_FrameT(float time)
|
||||
{
|
||||
static double time1 = 0;
|
||||
static double time2 = 0;
|
||||
|
@ -771,12 +771,12 @@ void Host_Frame(float time)
|
|||
|
||||
if(!serverprofile.value)
|
||||
{
|
||||
_Host_Frame(time);
|
||||
Host_FrameT(time);
|
||||
return;
|
||||
}
|
||||
|
||||
time1 = Sys_DoubleTime();
|
||||
_Host_Frame(time);
|
||||
Host_FrameT(time);
|
||||
time2 = Sys_DoubleTime();
|
||||
|
||||
timetotal += time2 - time1;
|
||||
|
|
|
@ -67,7 +67,7 @@ void FileList_Add(const char *name, filelist_item_t **list)
|
|||
// ignore duplicate
|
||||
for(item = *list; item; item = item->next)
|
||||
{
|
||||
if(!Q_strcmp(name, item->name))
|
||||
if(!strcmp(name, item->name))
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -504,7 +504,7 @@ void Host_God_f(void)
|
|||
SV_ClientPrintf("godmode ON\n");
|
||||
break;
|
||||
case 2:
|
||||
if(Q_atof(Cmd_Argv(1)))
|
||||
if(atof(Cmd_Argv(1)))
|
||||
{
|
||||
ED_FLOAT(sv_player, ED_flags) = (int32_t)ED_FLOAT(sv_player, ED_flags) | FL_GODMODE;
|
||||
SV_ClientPrintf("godmode ON\n");
|
||||
|
@ -549,7 +549,7 @@ void Host_Notarget_f(void)
|
|||
SV_ClientPrintf("notarget ON\n");
|
||||
break;
|
||||
case 2:
|
||||
if(Q_atof(Cmd_Argv(1)))
|
||||
if(atof(Cmd_Argv(1)))
|
||||
{
|
||||
ED_FLOAT(sv_player, ED_flags) = (int32_t)ED_FLOAT(sv_player, ED_flags) | FL_NOTARGET;
|
||||
SV_ClientPrintf("notarget ON\n");
|
||||
|
@ -603,7 +603,7 @@ void Host_Noclip_f(void)
|
|||
}
|
||||
break;
|
||||
case 2:
|
||||
if(Q_atof(Cmd_Argv(1)))
|
||||
if(atof(Cmd_Argv(1)))
|
||||
{
|
||||
noclip_anglehack = true;
|
||||
ED_FLOAT(sv_player, ED_movetype) = MOVETYPE_NOCLIP;
|
||||
|
@ -718,7 +718,7 @@ void Host_Fly_f(void)
|
|||
}
|
||||
break;
|
||||
case 2:
|
||||
if(Q_atof(Cmd_Argv(1)))
|
||||
if(atof(Cmd_Argv(1)))
|
||||
{
|
||||
ED_FLOAT(sv_player, ED_movetype) = MOVETYPE_FLY;
|
||||
SV_ClientPrintf("flymode ON\n");
|
||||
|
@ -1297,7 +1297,7 @@ void Host_Name_f(void)
|
|||
|
||||
if(cmd_source == src_command)
|
||||
{
|
||||
if(Q_strcmp(cl_name.string, newName) == 0)
|
||||
if(strcmp(cl_name.string, newName) == 0)
|
||||
return;
|
||||
Cvar_Set("_cl_name", newName);
|
||||
if(cls.state == ca_connected)
|
||||
|
@ -1307,10 +1307,10 @@ void Host_Name_f(void)
|
|||
|
||||
if(host_client->name[0] && strcmp(host_client->name, "unconnected"))
|
||||
{
|
||||
if(Q_strcmp(host_client->name, newName) != 0)
|
||||
if(strcmp(host_client->name, newName) != 0)
|
||||
Con_Printf("%s renamed to %s\n", host_client->name, newName);
|
||||
}
|
||||
Q_strcpy(host_client->name, newName);
|
||||
strcpy(host_client->name, newName);
|
||||
ED_RSTRING(host_client->edict, ED_netname) = PR_SetEngineString(host_client->name);
|
||||
|
||||
// send notification to all clients
|
||||
|
@ -1788,9 +1788,9 @@ void Host_Kick_f(void)
|
|||
|
||||
save = host_client;
|
||||
|
||||
if(Cmd_Argc() > 2 && Q_strcmp(Cmd_Argv(1), "#") == 0)
|
||||
if(Cmd_Argc() > 2 && strcmp(Cmd_Argv(1), "#") == 0)
|
||||
{
|
||||
i = Q_atof(Cmd_Argv(2)) - 1;
|
||||
i = atof(Cmd_Argv(2)) - 1;
|
||||
if(i < 0 || i >= svs.maxclients)
|
||||
return;
|
||||
if(!svs.clients[i].active)
|
||||
|
@ -1918,7 +1918,7 @@ void Host_Give_f(void)
|
|||
{
|
||||
val = GetEdictFieldValue(sv_player, "ammo_shells1");
|
||||
if(val)
|
||||
val->_float = v;
|
||||
val->flt = v;
|
||||
}
|
||||
ED_FLOAT(sv_player, ED_ammo_shells) = v;
|
||||
break;
|
||||
|
@ -1929,7 +1929,7 @@ void Host_Give_f(void)
|
|||
val = GetEdictFieldValue(sv_player, "ammo_nails1");
|
||||
if(val)
|
||||
{
|
||||
val->_float = v;
|
||||
val->flt = v;
|
||||
if(ED_FLOAT(sv_player, ED_weapon) <= IT_LIGHTNING)
|
||||
ED_FLOAT(sv_player, ED_ammo_nails) = v;
|
||||
}
|
||||
|
@ -1946,7 +1946,7 @@ void Host_Give_f(void)
|
|||
val = GetEdictFieldValue(sv_player, "ammo_lava_nails");
|
||||
if(val)
|
||||
{
|
||||
val->_float = v;
|
||||
val->flt = v;
|
||||
if(ED_FLOAT(sv_player, ED_weapon) > IT_LIGHTNING)
|
||||
ED_FLOAT(sv_player, ED_ammo_nails) = v;
|
||||
}
|
||||
|
@ -1959,7 +1959,7 @@ void Host_Give_f(void)
|
|||
val = GetEdictFieldValue(sv_player, "ammo_rockets1");
|
||||
if(val)
|
||||
{
|
||||
val->_float = v;
|
||||
val->flt = v;
|
||||
if(ED_FLOAT(sv_player, ED_weapon) <= IT_LIGHTNING)
|
||||
ED_FLOAT(sv_player, ED_ammo_rockets) = v;
|
||||
}
|
||||
|
@ -1976,7 +1976,7 @@ void Host_Give_f(void)
|
|||
val = GetEdictFieldValue(sv_player, "ammo_multi_rockets");
|
||||
if(val)
|
||||
{
|
||||
val->_float = v;
|
||||
val->flt = v;
|
||||
if(ED_FLOAT(sv_player, ED_weapon) > IT_LIGHTNING)
|
||||
ED_FLOAT(sv_player, ED_ammo_rockets) = v;
|
||||
}
|
||||
|
@ -1993,7 +1993,7 @@ void Host_Give_f(void)
|
|||
val = GetEdictFieldValue(sv_player, "ammo_cells1");
|
||||
if(val)
|
||||
{
|
||||
val->_float = v;
|
||||
val->flt = v;
|
||||
if(ED_FLOAT(sv_player, ED_weapon) <= IT_LIGHTNING)
|
||||
ED_FLOAT(sv_player, ED_ammo_cells) = v;
|
||||
}
|
||||
|
@ -2010,7 +2010,7 @@ void Host_Give_f(void)
|
|||
val = GetEdictFieldValue(sv_player, "ammo_plasma");
|
||||
if(val)
|
||||
{
|
||||
val->_float = v;
|
||||
val->flt = v;
|
||||
if(ED_FLOAT(sv_player, ED_weapon) > IT_LIGHTNING)
|
||||
ED_FLOAT(sv_player, ED_ammo_cells) = v;
|
||||
}
|
||||
|
|
|
@ -147,7 +147,7 @@ bool Image_WriteTGA(const char *name, byte *data, int32_t width, int32_t height,
|
|||
if(handle == -1)
|
||||
return false;
|
||||
|
||||
Q_memset(header, 0, TARGAHEADERSIZE);
|
||||
memset(header, 0, TARGAHEADERSIZE);
|
||||
header[2] = 2; // uncompressed type
|
||||
header[12] = width & 255;
|
||||
header[13] = width >> 8;
|
||||
|
|
|
@ -371,7 +371,7 @@ void Key_Console(int32_t key)
|
|||
|
||||
case K_UPARROW:
|
||||
if(history_line == edit_line)
|
||||
Q_strcpy(current, workline);
|
||||
strcpy(current, workline);
|
||||
|
||||
history_line_last = history_line;
|
||||
do
|
||||
|
@ -387,8 +387,8 @@ void Key_Console(int32_t key)
|
|||
}
|
||||
|
||||
key_tabpartial[0] = 0;
|
||||
Q_strcpy(workline, key_lines[history_line]);
|
||||
key_linepos = Q_strlen(workline);
|
||||
strcpy(workline, key_lines[history_line]);
|
||||
key_linepos = strlen(workline);
|
||||
return;
|
||||
|
||||
case K_DOWNARROW:
|
||||
|
@ -404,9 +404,9 @@ void Key_Console(int32_t key)
|
|||
while(history_line != edit_line && !key_lines[history_line][1]);
|
||||
|
||||
if(history_line == edit_line)
|
||||
Q_strcpy(workline, current);
|
||||
else Q_strcpy(workline, key_lines[history_line]);
|
||||
key_linepos = Q_strlen(workline);
|
||||
strcpy(workline, current);
|
||||
else strcpy(workline, key_lines[history_line]);
|
||||
key_linepos = strlen(workline);
|
||||
return;
|
||||
|
||||
case K_INS:
|
||||
|
|
|
@ -694,8 +694,8 @@ void M_Menu_Setup_f(void)
|
|||
key_dest = key_menu;
|
||||
m_state = m_setup;
|
||||
m_entersound = true;
|
||||
Q_strcpy(setup_myname, cl_name.string);
|
||||
Q_strcpy(setup_hostname, hostname.string);
|
||||
strcpy(setup_myname, cl_name.string);
|
||||
strcpy(setup_hostname, hostname.string);
|
||||
setup_top = setup_oldtop = ((int32_t)cl_color.value) >> 4;
|
||||
setup_bottom = setup_oldbottom = ((int32_t)cl_color.value) & 15;
|
||||
}
|
||||
|
@ -791,9 +791,9 @@ forward:
|
|||
goto forward;
|
||||
|
||||
// setup_cursor == 4 (OK)
|
||||
if(Q_strcmp(cl_name.string, setup_myname) != 0)
|
||||
if(strcmp(cl_name.string, setup_myname) != 0)
|
||||
Cbuf_AddText(va("name \"%s\"\n", setup_myname));
|
||||
if(Q_strcmp(hostname.string, setup_hostname) != 0)
|
||||
if(strcmp(hostname.string, setup_hostname) != 0)
|
||||
Cvar_Set("hostname", setup_hostname);
|
||||
if(setup_top != setup_oldtop || setup_bottom != setup_oldbottom)
|
||||
Cbuf_AddText(va("color %" PRIi32 " %" PRIi32 "\n", setup_top, setup_bottom));
|
||||
|
@ -1871,7 +1871,7 @@ void M_LanConfig_Key(int32_t key)
|
|||
lanConfig_cursor = 0;
|
||||
}
|
||||
|
||||
l = Q_atoi(lanConfig_portname);
|
||||
l = atoi(lanConfig_portname);
|
||||
if(l > 65535)
|
||||
l = lanConfig_port;
|
||||
else
|
||||
|
|
|
@ -246,9 +246,9 @@ extern int32_t hostCacheCount;
|
|||
extern hostcache_t hostcache[HOSTCACHESIZE];
|
||||
|
||||
|
||||
typedef struct _PollProcedure
|
||||
typedef struct PollProcedure_s
|
||||
{
|
||||
struct _PollProcedure *next;
|
||||
struct PollProcedure_s *next;
|
||||
double nextTime;
|
||||
void (*procedure)(void *arg);
|
||||
void *arg;
|
||||
|
|
|
@ -99,8 +99,8 @@ static void NET_Ban_f(void)
|
|||
case 1:
|
||||
if(banAddr.s_addr != INADDR_ANY)
|
||||
{
|
||||
Q_strcpy(addrStr, inet_ntoa(banAddr));
|
||||
Q_strcpy(maskStr, inet_ntoa(banMask));
|
||||
strcpy(addrStr, inet_ntoa(banAddr));
|
||||
strcpy(maskStr, inet_ntoa(banMask));
|
||||
print_fn("Banning %s [%s]\n", addrStr, maskStr);
|
||||
}
|
||||
else
|
||||
|
@ -145,7 +145,7 @@ int32_t Datagram_SendMessage(qsocket_t *sock, sizebuf_t *data)
|
|||
Sys_Error("SendMessage: called with canSend == false\n");
|
||||
#endif
|
||||
|
||||
Q_memcpy(sock->sendMessage, data->data, data->cursize);
|
||||
memcpy(sock->sendMessage, data->data, data->cursize);
|
||||
sock->sendMessageLength = data->cursize;
|
||||
|
||||
if(data->cursize <= MAX_DATAGRAM)
|
||||
|
@ -162,7 +162,7 @@ int32_t Datagram_SendMessage(qsocket_t *sock, sizebuf_t *data)
|
|||
|
||||
packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
|
||||
packetBuffer.sequence = BigLong(sock->sendSequence++);
|
||||
Q_memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
||||
memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
||||
|
||||
sock->canSend = false;
|
||||
|
||||
|
@ -195,7 +195,7 @@ static int32_t SendMessageNext(qsocket_t *sock)
|
|||
|
||||
packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
|
||||
packetBuffer.sequence = BigLong(sock->sendSequence++);
|
||||
Q_memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
||||
memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
||||
|
||||
sock->sendNext = false;
|
||||
|
||||
|
@ -228,7 +228,7 @@ static int32_t ReSendMessage(qsocket_t *sock)
|
|||
|
||||
packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
|
||||
packetBuffer.sequence = BigLong(sock->sendSequence - 1);
|
||||
Q_memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
||||
memcpy(packetBuffer.data, sock->sendMessage, dataLen);
|
||||
|
||||
sock->sendNext = false;
|
||||
|
||||
|
@ -273,7 +273,7 @@ int32_t Datagram_SendUnreliableMessage(qsocket_t *sock, sizebuf_t *data)
|
|||
|
||||
packetBuffer.length = BigLong(packetLen | NETFLAG_UNRELIABLE);
|
||||
packetBuffer.sequence = BigLong(sock->unreliableSendSequence++);
|
||||
Q_memcpy(packetBuffer.data, data->data, data->cursize);
|
||||
memcpy(packetBuffer.data, data->data, data->cursize);
|
||||
|
||||
if(sfunc.Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
|
||||
return -1;
|
||||
|
@ -420,7 +420,7 @@ int32_t Datagram_GetMessage(qsocket_t *sock)
|
|||
break;
|
||||
}
|
||||
|
||||
Q_memcpy(sock->receiveMessage + sock->receiveMessageLength, packetBuffer.data, length);
|
||||
memcpy(sock->receiveMessage + sock->receiveMessageLength, packetBuffer.data, length);
|
||||
sock->receiveMessageLength += length;
|
||||
continue;
|
||||
}
|
||||
|
@ -458,7 +458,7 @@ static void NET_Stats_f(void)
|
|||
Con_Printf("shortPacketCount = %" PRIi32 "\n", shortPacketCount);
|
||||
Con_Printf("droppedDatagrams = %" PRIi32 "\n", droppedDatagrams);
|
||||
}
|
||||
else if(Q_strcmp(Cmd_Argv(1), "*") == 0)
|
||||
else if(strcmp(Cmd_Argv(1), "*") == 0)
|
||||
{
|
||||
for(s = net_activeSockets; s; s = s->next)
|
||||
PrintStats(s);
|
||||
|
@ -501,10 +501,10 @@ static const char *Strip_Port(const char *host)
|
|||
if(!host || !*host)
|
||||
return host;
|
||||
q_strlcpy(noport, host, sizeof(noport));
|
||||
if((p = Q_strrchr(noport, ':')) == NULL)
|
||||
if((p = strrchr(noport, ':')) == NULL)
|
||||
return host;
|
||||
*p++ = '\0';
|
||||
port = Q_atoi(p);
|
||||
port = atoi(p);
|
||||
if(port > 0 && port < 65536 && port != net_hostport)
|
||||
{
|
||||
net_hostport = port;
|
||||
|
@ -559,11 +559,11 @@ static void Test_Poll(void *unused)
|
|||
Sys_Error("Unexpected repsonse to Player Info request\n");
|
||||
|
||||
MSG_ReadByte(); /* playerNumber */
|
||||
Q_strcpy(name, MSG_ReadString());
|
||||
strcpy(name, MSG_ReadString());
|
||||
colors = MSG_ReadLong();
|
||||
frags = MSG_ReadLong();
|
||||
connectTime = MSG_ReadLong();
|
||||
Q_strcpy(address, MSG_ReadString());
|
||||
strcpy(address, MSG_ReadString());
|
||||
|
||||
Con_Printf("%s\n frags:%3" PRIi32 " colors:%" PRIi32 " %" PRIi32 " time:%" PRIi32 "\n %s\n", name, frags, colors >> 4, colors & 0x0f, connectTime / 60, address);
|
||||
}
|
||||
|
@ -602,7 +602,7 @@ static void Test_f(void)
|
|||
continue;
|
||||
net_landriverlevel = hostcache[n].ldriver;
|
||||
maxusers = hostcache[n].maxusers;
|
||||
Q_memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
|
||||
memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -689,10 +689,10 @@ static void Test2_Poll(void *unused)
|
|||
if(MSG_ReadByte() != CCREP_RULE_INFO)
|
||||
goto error;
|
||||
|
||||
Q_strcpy(name, MSG_ReadString());
|
||||
strcpy(name, MSG_ReadString());
|
||||
if(name[0] == 0)
|
||||
goto done;
|
||||
Q_strcpy(value, MSG_ReadString());
|
||||
strcpy(value, MSG_ReadString());
|
||||
|
||||
Con_Printf("%-16.16s %-16.16s\n", name, value);
|
||||
|
||||
|
@ -737,7 +737,7 @@ static void Test2_f(void)
|
|||
if(hostcache[n].driver != myDriverLevel)
|
||||
continue;
|
||||
net_landriverlevel = hostcache[n].ldriver;
|
||||
Q_memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
|
||||
memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -858,7 +858,7 @@ void Datagram_Listen(bool state)
|
|||
}
|
||||
|
||||
|
||||
static qsocket_t *_Datagram_CheckNewConnections(void)
|
||||
static qsocket_t *Datagram_CheckNewConnections_(void)
|
||||
{
|
||||
struct qsockaddr clientaddr;
|
||||
struct qsockaddr newaddr;
|
||||
|
@ -895,7 +895,7 @@ static qsocket_t *_Datagram_CheckNewConnections(void)
|
|||
command = MSG_ReadByte();
|
||||
if(command == CCREQ_SERVER_INFO)
|
||||
{
|
||||
if(Q_strcmp(MSG_ReadString(), "QUAKE") != 0)
|
||||
if(strcmp(MSG_ReadString(), "QUAKE") != 0)
|
||||
return NULL;
|
||||
|
||||
SZ_Clear(&net_message);
|
||||
|
@ -984,7 +984,7 @@ static qsocket_t *_Datagram_CheckNewConnections(void)
|
|||
if(command != CCREQ_CONNECT)
|
||||
return NULL;
|
||||
|
||||
if(Q_strcmp(MSG_ReadString(), "QUAKE") != 0)
|
||||
if(strcmp(MSG_ReadString(), "QUAKE") != 0)
|
||||
return NULL;
|
||||
|
||||
if(MSG_ReadByte() != NET_PROTOCOL_VERSION)
|
||||
|
@ -1087,7 +1087,7 @@ static qsocket_t *_Datagram_CheckNewConnections(void)
|
|||
sock->socket = newsock;
|
||||
sock->landriver = net_landriverlevel;
|
||||
sock->addr = clientaddr;
|
||||
Q_strcpy(sock->address, dfunc.AddrToString(&clientaddr));
|
||||
strcpy(sock->address, dfunc.AddrToString(&clientaddr));
|
||||
|
||||
// send him back the info about the server connection he has been allocated
|
||||
SZ_Clear(&net_message);
|
||||
|
@ -1112,7 +1112,7 @@ qsocket_t *Datagram_CheckNewConnections(void)
|
|||
{
|
||||
if(net_landrivers[net_landriverlevel].initialized)
|
||||
{
|
||||
if((ret = _Datagram_CheckNewConnections()) != NULL)
|
||||
if((ret = Datagram_CheckNewConnections_()) != NULL)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -1120,7 +1120,7 @@ qsocket_t *Datagram_CheckNewConnections(void)
|
|||
}
|
||||
|
||||
|
||||
static void _Datagram_SearchForHosts(bool xmit)
|
||||
static void Datagram_SearchForHosts_(bool xmit)
|
||||
{
|
||||
int32_t ret;
|
||||
int32_t n;
|
||||
|
@ -1184,21 +1184,21 @@ static void _Datagram_SearchForHosts(bool xmit)
|
|||
|
||||
// add it
|
||||
hostCacheCount++;
|
||||
Q_strcpy(hostcache[n].name, MSG_ReadString());
|
||||
Q_strcpy(hostcache[n].map, MSG_ReadString());
|
||||
strcpy(hostcache[n].name, MSG_ReadString());
|
||||
strcpy(hostcache[n].map, MSG_ReadString());
|
||||
hostcache[n].users = MSG_ReadByte();
|
||||
hostcache[n].maxusers = MSG_ReadByte();
|
||||
if(MSG_ReadByte() != NET_PROTOCOL_VERSION)
|
||||
{
|
||||
Q_strcpy(hostcache[n].cname, hostcache[n].name);
|
||||
strcpy(hostcache[n].cname, hostcache[n].name);
|
||||
hostcache[n].cname[14] = 0;
|
||||
Q_strcpy(hostcache[n].name, "*");
|
||||
Q_strcat(hostcache[n].name, hostcache[n].cname);
|
||||
strcpy(hostcache[n].name, "*");
|
||||
strcat(hostcache[n].name, hostcache[n].cname);
|
||||
}
|
||||
Q_memcpy(&hostcache[n].addr, &readaddr, sizeof(struct qsockaddr));
|
||||
memcpy(&hostcache[n].addr, &readaddr, sizeof(struct qsockaddr));
|
||||
hostcache[n].driver = net_driverlevel;
|
||||
hostcache[n].ldriver = net_landriverlevel;
|
||||
Q_strcpy(hostcache[n].cname, dfunc.AddrToString(&readaddr));
|
||||
strcpy(hostcache[n].cname, dfunc.AddrToString(&readaddr));
|
||||
|
||||
// check for a name conflict
|
||||
for(i = 0; i < hostCacheCount; i++)
|
||||
|
@ -1207,7 +1207,7 @@ static void _Datagram_SearchForHosts(bool xmit)
|
|||
continue;
|
||||
if(q_strcasecmp(hostcache[n].name, hostcache[i].name) == 0)
|
||||
{
|
||||
i = Q_strlen(hostcache[n].name);
|
||||
i = strlen(hostcache[n].name);
|
||||
if(i < 15 && hostcache[n].name[i - 1] > '8')
|
||||
{
|
||||
hostcache[n].name[i] = '0';
|
||||
|
@ -1229,12 +1229,12 @@ void Datagram_SearchForHosts(bool xmit)
|
|||
if(hostCacheCount == HOSTCACHESIZE)
|
||||
break;
|
||||
if(net_landrivers[net_landriverlevel].initialized)
|
||||
_Datagram_SearchForHosts(xmit);
|
||||
Datagram_SearchForHosts_(xmit);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static qsocket_t *_Datagram_Connect(const char *host)
|
||||
static qsocket_t *Datagram_Connect_(const char *host)
|
||||
{
|
||||
struct qsockaddr sendaddr;
|
||||
struct qsockaddr readaddr;
|
||||
|
@ -1342,7 +1342,7 @@ static qsocket_t *_Datagram_Connect(const char *host)
|
|||
{
|
||||
reason = "No Response";
|
||||
Con_Printf("%s\n", reason);
|
||||
Q_strcpy(m_return_reason, reason);
|
||||
strcpy(m_return_reason, reason);
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
@ -1350,7 +1350,7 @@ static qsocket_t *_Datagram_Connect(const char *host)
|
|||
{
|
||||
reason = "Network error";
|
||||
Con_Printf("%s\n", reason);
|
||||
Q_strcpy(m_return_reason, reason);
|
||||
strcpy(m_return_reason, reason);
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
@ -1365,14 +1365,14 @@ static qsocket_t *_Datagram_Connect(const char *host)
|
|||
|
||||
if(ret == CCREP_ACCEPT)
|
||||
{
|
||||
Q_memcpy(&sock->addr, &sendaddr, sizeof(struct qsockaddr));
|
||||
memcpy(&sock->addr, &sendaddr, sizeof(struct qsockaddr));
|
||||
dfunc.SetSocketPort(&sock->addr, MSG_ReadLong());
|
||||
}
|
||||
else
|
||||
{
|
||||
reason = "Bad Response";
|
||||
Con_Printf("%s\n", reason);
|
||||
Q_strcpy(m_return_reason, reason);
|
||||
strcpy(m_return_reason, reason);
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
@ -1386,7 +1386,7 @@ static qsocket_t *_Datagram_Connect(const char *host)
|
|||
{
|
||||
reason = "Connect to Game failed";
|
||||
Con_Printf("%s\n", reason);
|
||||
Q_strcpy(m_return_reason, reason);
|
||||
strcpy(m_return_reason, reason);
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
@ -1416,7 +1416,7 @@ qsocket_t *Datagram_Connect(const char *host)
|
|||
{
|
||||
if(net_landrivers[net_landriverlevel].initialized)
|
||||
{
|
||||
if((ret = _Datagram_Connect(host)) != NULL)
|
||||
if((ret = Datagram_Connect_(host)) != NULL)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -56,21 +56,21 @@ void Loop_SearchForHosts(bool xmit)
|
|||
return;
|
||||
|
||||
hostCacheCount = 1;
|
||||
if(Q_strcmp(hostname.string, "UNNAMED") == 0)
|
||||
Q_strcpy(hostcache[0].name, "local");
|
||||
if(strcmp(hostname.string, "UNNAMED") == 0)
|
||||
strcpy(hostcache[0].name, "local");
|
||||
else
|
||||
Q_strcpy(hostcache[0].name, hostname.string);
|
||||
Q_strcpy(hostcache[0].map, sv.name);
|
||||
strcpy(hostcache[0].name, hostname.string);
|
||||
strcpy(hostcache[0].map, sv.name);
|
||||
hostcache[0].users = net_activeconnections;
|
||||
hostcache[0].maxusers = svs.maxclients;
|
||||
hostcache[0].driver = net_driverlevel;
|
||||
Q_strcpy(hostcache[0].cname, "local");
|
||||
strcpy(hostcache[0].cname, "local");
|
||||
}
|
||||
|
||||
|
||||
qsocket_t *Loop_Connect(const char *host)
|
||||
{
|
||||
if(Q_strcmp(host, "local") != 0)
|
||||
if(strcmp(host, "local") != 0)
|
||||
return NULL;
|
||||
|
||||
localconnectpending = true;
|
||||
|
@ -82,7 +82,7 @@ qsocket_t *Loop_Connect(const char *host)
|
|||
Con_Printf("Loop_Connect: no qsocket available\n");
|
||||
return NULL;
|
||||
}
|
||||
Q_strcpy(loop_client->address, "localhost");
|
||||
strcpy(loop_client->address, "localhost");
|
||||
}
|
||||
loop_client->receiveMessageLength = 0;
|
||||
loop_client->sendMessageLength = 0;
|
||||
|
@ -95,7 +95,7 @@ qsocket_t *Loop_Connect(const char *host)
|
|||
Con_Printf("Loop_Connect: no qsocket available\n");
|
||||
return NULL;
|
||||
}
|
||||
Q_strcpy(loop_server->address, "LOCAL");
|
||||
strcpy(loop_server->address, "LOCAL");
|
||||
}
|
||||
loop_server->receiveMessageLength = 0;
|
||||
loop_server->sendMessageLength = 0;
|
||||
|
@ -183,7 +183,7 @@ int32_t Loop_SendMessage(qsocket_t *sock, sizebuf_t *data)
|
|||
buffer++;
|
||||
|
||||
// message
|
||||
Q_memcpy(buffer, data->data, data->cursize);
|
||||
memcpy(buffer, data->data, data->cursize);
|
||||
*bufferLength = IntAlign(*bufferLength + data->cursize + 4);
|
||||
|
||||
sock->canSend = false;
|
||||
|
@ -217,7 +217,7 @@ int32_t Loop_SendUnreliableMessage(qsocket_t *sock, sizebuf_t *data)
|
|||
buffer++;
|
||||
|
||||
// message
|
||||
Q_memcpy(buffer, data->data, data->cursize);
|
||||
memcpy(buffer, data->data, data->cursize);
|
||||
*bufferLength = IntAlign(*bufferLength + data->cursize + 4);
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -105,7 +105,7 @@ qsocket_t *NET_NewQSocket(void)
|
|||
|
||||
sock->disconnected = false;
|
||||
sock->connecttime = net_time;
|
||||
Q_strcpy(sock->address, "UNSET ADDRESS");
|
||||
strcpy(sock->address, "UNSET ADDRESS");
|
||||
sock->driver = net_driverlevel;
|
||||
sock->socket = 0;
|
||||
sock->driverdata = NULL;
|
||||
|
@ -173,7 +173,7 @@ static void NET_Listen_f(void)
|
|||
return;
|
||||
}
|
||||
|
||||
listening = Q_atoi(Cmd_Argv(1)) ? true : false;
|
||||
listening = atoi(Cmd_Argv(1)) ? true : false;
|
||||
|
||||
for(net_driverlevel = 0; net_driverlevel < net_numdrivers; net_driverlevel++)
|
||||
{
|
||||
|
@ -200,7 +200,7 @@ static void MaxPlayers_f(void)
|
|||
return;
|
||||
}
|
||||
|
||||
n = Q_atoi(Cmd_Argv(1));
|
||||
n = atoi(Cmd_Argv(1));
|
||||
if(n < 1)
|
||||
n = 1;
|
||||
if(n > svs.maxclientslimit)
|
||||
|
@ -233,7 +233,7 @@ static void NET_Port_f(void)
|
|||
return;
|
||||
}
|
||||
|
||||
n = Q_atoi(Cmd_Argv(1));
|
||||
n = atoi(Cmd_Argv(1));
|
||||
if(n < 1 || n > 65534)
|
||||
{
|
||||
Con_Printf("Bad value, must be between 1 and 65534\n");
|
||||
|
@ -772,7 +772,7 @@ void NET_Init(void)
|
|||
if(i)
|
||||
{
|
||||
if(i < com_argc - 1)
|
||||
DEFAULTnet_hostport = Q_atoi(com_argv[i + 1]);
|
||||
DEFAULTnet_hostport = atoi(com_argv[i + 1]);
|
||||
else
|
||||
Sys_Error("NET_Init: you must specify a number after -port");
|
||||
}
|
||||
|
|
|
@ -58,7 +58,7 @@ typedef struct
|
|||
|
||||
typedef union eval_s
|
||||
{
|
||||
float _float;
|
||||
float flt;
|
||||
vec3_t vec;
|
||||
func_t func;
|
||||
int32_t _int;
|
||||
|
|
|
@ -420,7 +420,7 @@ static void ED_PrintEdict_f(void)
|
|||
if(!sv.active)
|
||||
return;
|
||||
|
||||
i = Q_atoi(Cmd_Argv(1));
|
||||
i = atoi(Cmd_Argv(1));
|
||||
if(i < 0 || i >= sv.num_edicts)
|
||||
{
|
||||
Con_Printf("Bad edict number\n");
|
||||
|
|
|
@ -142,7 +142,7 @@ PR_PrintStatement
|
|||
*/
|
||||
static void PR_PrintStatement(dstatement_t *s)
|
||||
{
|
||||
int32_t i;
|
||||
size_t i;
|
||||
|
||||
if((uint32_t)s->op < arraysizeof(pr_opnames))
|
||||
{
|
||||
|
@ -398,7 +398,7 @@ void PR_ExecuteProgram(func_t fnum)
|
|||
|
||||
#define MakeOpArithF(op, exp) \
|
||||
case op: \
|
||||
OPC->_float = OPA->_float exp OPB->_float; \
|
||||
OPC->flt = OPA->flt exp OPB->flt; \
|
||||
break;
|
||||
|
||||
#define MakeOpArithV(op, exp) \
|
||||
|
@ -410,7 +410,7 @@ void PR_ExecuteProgram(func_t fnum)
|
|||
|
||||
#define MakeOpArithB(op, exp) \
|
||||
case op: \
|
||||
OPC->_float = (int32_t)OPA->_float exp (int32_t)OPB->_float; \
|
||||
OPC->flt = (int32_t)OPA->flt exp (int32_t)OPB->flt; \
|
||||
break;
|
||||
|
||||
MakeOpArithF(OP_ADD_F, +)
|
||||
|
@ -424,9 +424,9 @@ void PR_ExecuteProgram(func_t fnum)
|
|||
MakeOpArithB(OP_BITAND, &)
|
||||
MakeOpArithB(OP_BITOR, |)
|
||||
|
||||
case OP_MUL_V: OPC->_float = DotProduct(OPA->vec, OPB->vec); break;
|
||||
case OP_MUL_FV: VectorScale(OPB->vec, OPA->_float, OPC->vec); break;
|
||||
case OP_MUL_VF: VectorScale(OPA->vec, OPB->_float, OPC->vec); break;
|
||||
case OP_MUL_V: OPC->flt = DotProduct(OPA->vec, OPB->vec); break;
|
||||
case OP_MUL_FV: VectorScale(OPB->vec, OPA->flt, OPC->vec); break;
|
||||
case OP_MUL_VF: VectorScale(OPA->vec, OPB->flt, OPC->vec); break;
|
||||
|
||||
MakeOpArithF(OP_GE, >=)
|
||||
MakeOpArithF(OP_LE, <=)
|
||||
|
@ -438,51 +438,51 @@ void PR_ExecuteProgram(func_t fnum)
|
|||
MakeOpArithF(OP_NE_F, !=)
|
||||
|
||||
case OP_NOT_F:
|
||||
OPC->_float = !OPA->_float;
|
||||
OPC->flt = !OPA->flt;
|
||||
break;
|
||||
case OP_NOT_V:
|
||||
OPC->_float = !OPA->vec[0] && !OPA->vec[1] && !OPA->vec[2];
|
||||
OPC->flt = !OPA->vec[0] && !OPA->vec[1] && !OPA->vec[2];
|
||||
break;
|
||||
case OP_NOT_S:
|
||||
OPC->_float = !OPA->string || !*PR_GetString(OPA->string);
|
||||
OPC->flt = !OPA->string || !*PR_GetString(OPA->string);
|
||||
break;
|
||||
case OP_NOT_FNC:
|
||||
OPC->_float = !OPA->func;
|
||||
OPC->flt = !OPA->func;
|
||||
break;
|
||||
case OP_NOT_ENT:
|
||||
OPC->_float = PROG_TO_EDICT(OPA->edict) == sv.edicts;
|
||||
OPC->flt = PROG_TO_EDICT(OPA->edict) == sv.edicts;
|
||||
break;
|
||||
|
||||
case OP_EQ_V:
|
||||
OPC->_float = OPA->vec[0] == OPB->vec[0] &&
|
||||
OPC->flt = OPA->vec[0] == OPB->vec[0] &&
|
||||
OPA->vec[1] == OPB->vec[1] &&
|
||||
OPA->vec[2] == OPB->vec[2];
|
||||
break;
|
||||
case OP_EQ_S:
|
||||
OPC->_float = !strcmp(PR_GetString(OPA->string), PR_GetString(OPB->string));
|
||||
OPC->flt = !strcmp(PR_GetString(OPA->string), PR_GetString(OPB->string));
|
||||
break;
|
||||
case OP_EQ_E: OPC->_float = OPA->edict == OPB->edict; break;
|
||||
case OP_EQ_FNC: OPC->_float = OPA->func == OPB->func; break;
|
||||
case OP_EQ_E: OPC->flt = OPA->edict == OPB->edict; break;
|
||||
case OP_EQ_FNC: OPC->flt = OPA->func == OPB->func; break;
|
||||
|
||||
case OP_NE_V:
|
||||
OPC->_float = OPA->vec[0] != OPB->vec[0] ||
|
||||
OPC->flt = OPA->vec[0] != OPB->vec[0] ||
|
||||
OPA->vec[1] != OPB->vec[1] ||
|
||||
OPA->vec[2] != OPB->vec[2];
|
||||
break;
|
||||
case OP_NE_S:
|
||||
OPC->_float = strcmp(PR_GetString(OPA->string), PR_GetString(OPB->string));
|
||||
OPC->flt = strcmp(PR_GetString(OPA->string), PR_GetString(OPB->string));
|
||||
break;
|
||||
case OP_NE_E: OPC->_float = OPA->edict != OPB->edict; break;
|
||||
case OP_NE_FNC: OPC->_float = OPA->func != OPB->func; break;
|
||||
case OP_NE_E: OPC->flt = OPA->edict != OPB->edict; break;
|
||||
case OP_NE_FNC: OPC->flt = OPA->func != OPB->func; break;
|
||||
|
||||
case OP_STORE_F: OPB->_float = OPA->_float; break;
|
||||
case OP_STORE_F: OPB->flt = OPA->flt; break;
|
||||
case OP_STORE_ENT: OPB->edict = OPA->edict; break;
|
||||
case OP_STORE_FLD: OPB->field = OPA->field; break;
|
||||
case OP_STORE_S: OPB->string = OPA->string; break;
|
||||
case OP_STORE_FNC: OPB->func = OPA->func; break;
|
||||
case OP_STORE_V: VectorCopy(OPA->vec, OPB->vec); break;
|
||||
|
||||
case OP_STOREP_F: PTR->_float = OPA->_float; break;
|
||||
case OP_STOREP_F: PTR->flt = OPA->flt; break;
|
||||
case OP_STOREP_ENT: PTR->edict = OPA->edict; break;
|
||||
case OP_STOREP_FLD: PTR->field = OPA->field; break;
|
||||
case OP_STOREP_S: PTR->string = OPA->string; break;
|
||||
|
@ -514,7 +514,7 @@ void PR_ExecuteProgram(func_t fnum)
|
|||
#endif
|
||||
switch(st->op)
|
||||
{
|
||||
case OP_LOAD_F: OPC->_float = ED_FLOAT(ed, OPB->field); break;
|
||||
case OP_LOAD_F: OPC->flt = ED_FLOAT(ed, OPB->field); break;
|
||||
case OP_LOAD_FLD: OPC->field = ED_PFIELD(ed, OPB->field); break;
|
||||
case OP_LOAD_ENT: OPC->edict = ED_PEDICT(ed, OPB->field); break;
|
||||
case OP_LOAD_S: OPC->string = ED_RSTRING(ed, OPB->field); break;
|
||||
|
@ -574,7 +574,7 @@ void PR_ExecuteProgram(func_t fnum)
|
|||
case OP_STATE:
|
||||
ed = PROG_TO_EDICT(G_PEDICT(GBL_self));
|
||||
ED_FLOAT(ed, ED_nextthink) = G_FLOAT(GBL_time) + 0.1;
|
||||
ED_FLOAT(ed, ED_frame) = OPA->_float;
|
||||
ED_FLOAT(ed, ED_frame) = OPA->flt;
|
||||
ED_FUNC(ed, ED_think) = OPB->func;
|
||||
break;
|
||||
|
||||
|
|
|
@ -64,7 +64,7 @@ const char *PR_ValueString(int32_t type, eval_t *val)
|
|||
sprintf(line, "void");
|
||||
break;
|
||||
case ev_float:
|
||||
sprintf(line, "%5.1f", val->_float);
|
||||
sprintf(line, "%5.1f", val->flt);
|
||||
break;
|
||||
case ev_vector:
|
||||
sprintf(line, "'%5.1f %5.1f %5.1f'", val->vec[0], val->vec[1], val->vec[2]);
|
||||
|
@ -117,7 +117,7 @@ const char *PR_UglyValueString(int32_t type, eval_t *val)
|
|||
sprintf(line, "void");
|
||||
break;
|
||||
case ev_float:
|
||||
sprintf(line, "%f", val->_float);
|
||||
sprintf(line, "%f", val->flt);
|
||||
break;
|
||||
case ev_vector:
|
||||
sprintf(line, "%f %f %f", val->vec[0], val->vec[1], val->vec[2]);
|
||||
|
|
|
@ -155,7 +155,7 @@ void R_InitParticles(void)
|
|||
|
||||
if(i)
|
||||
{
|
||||
r_numparticles = (int32_t)(Q_atoi(com_argv[i + 1]));
|
||||
r_numparticles = (int32_t)(atoi(com_argv[i + 1]));
|
||||
if(r_numparticles < ABSOLUTE_MIN_PARTICLES)
|
||||
r_numparticles = ABSOLUTE_MIN_PARTICLES;
|
||||
}
|
||||
|
|
|
@ -320,7 +320,7 @@ scroll the string inside a glscissor region
|
|||
void Sbar_DrawScrollString(int32_t x, int32_t y, int32_t width, const char *str)
|
||||
{
|
||||
float scale;
|
||||
int32_t len, ofs, left;
|
||||
size_t len, ofs, left;
|
||||
|
||||
scale = CLAMP(1.0, scr_sbarscale.value, (float)glwidth / 320.0);
|
||||
left = x * scale;
|
||||
|
@ -331,7 +331,7 @@ void Sbar_DrawScrollString(int32_t x, int32_t y, int32_t width, const char *str)
|
|||
glScissor(left, 0, width * scale, glheight);
|
||||
|
||||
len = strlen(str) * 8 + 40;
|
||||
ofs = ((int32_t)(realtime * 30)) % len;
|
||||
ofs = (size_t)(realtime * 30) % len;
|
||||
Sbar_DrawString(x - ofs, y, str);
|
||||
Sbar_DrawCharacter(x - ofs + len - 32, y, '/');
|
||||
Sbar_DrawCharacter(x - ofs + len - 24, y, '/');
|
||||
|
@ -498,7 +498,7 @@ void Sbar_SoloScoreboard(void)
|
|||
{
|
||||
char str[256];
|
||||
int32_t minutes, seconds, tens, units;
|
||||
int32_t len;
|
||||
size_t len;
|
||||
|
||||
sprintf(str, "Kills: %" PRIi32 "/%" PRIi32 "", cl.stats[STAT_MONSTERS], cl.stats[STAT_TOTALMONSTERS]);
|
||||
Sbar_DrawString(8, 12, str);
|
||||
|
|
|
@ -1485,7 +1485,7 @@ void VID_Init(void)
|
|||
p = COM_CheckParm("-width");
|
||||
if(p && p < com_argc - 1)
|
||||
{
|
||||
width = Q_atoi(com_argv[p + 1]);
|
||||
width = atoi(com_argv[p + 1]);
|
||||
|
||||
if(!COM_CheckParm("-height"))
|
||||
height = width * 3 / 4;
|
||||
|
@ -1494,7 +1494,7 @@ void VID_Init(void)
|
|||
p = COM_CheckParm("-height");
|
||||
if(p && p < com_argc - 1)
|
||||
{
|
||||
height = Q_atoi(com_argv[p + 1]);
|
||||
height = atoi(com_argv[p + 1]);
|
||||
|
||||
if(!COM_CheckParm("-width"))
|
||||
width = height * 4 / 3;
|
||||
|
@ -1502,11 +1502,11 @@ void VID_Init(void)
|
|||
|
||||
p = COM_CheckParm("-refreshrate");
|
||||
if(p && p < com_argc - 1)
|
||||
refreshrate = Q_atoi(com_argv[p + 1]);
|
||||
refreshrate = atoi(com_argv[p + 1]);
|
||||
|
||||
p = COM_CheckParm("-bpp");
|
||||
if(p && p < com_argc - 1)
|
||||
bpp = Q_atoi(com_argv[p + 1]);
|
||||
bpp = atoi(com_argv[p + 1]);
|
||||
|
||||
if(COM_CheckParm("-window") || COM_CheckParm("-w"))
|
||||
fullscreen = false;
|
||||
|
|
|
@ -93,7 +93,7 @@ int32_t main(int32_t argc, char *argv[])
|
|||
{
|
||||
t = COM_CheckParm("-heapsize") + 1;
|
||||
if(t < com_argc)
|
||||
parms.memsize = Q_atoi(com_argv[t]) * 1024;
|
||||
parms.memsize = atoi(com_argv[t]) * 1024;
|
||||
}
|
||||
|
||||
parms.membase = malloc(parms.memsize);
|
||||
|
|
|
@ -94,7 +94,7 @@ static cvar_t ambient_level = {"ambient_level", "0.3", CVAR_NONE};
|
|||
static cvar_t ambient_fade = {"ambient_fade", "100", CVAR_NONE};
|
||||
static cvar_t snd_noextraupdate = {"snd_noextraupdate", "0", CVAR_NONE};
|
||||
static cvar_t snd_show = {"snd_show", "0", CVAR_NONE};
|
||||
static cvar_t _snd_mixahead = {"_snd_mixahead", "0.1", CVAR_ARCHIVE};
|
||||
static cvar_t snd_mixahead = {"_snd_mixahead", "0.1", CVAR_ARCHIVE};
|
||||
|
||||
|
||||
static void S_SoundInfo_f(void)
|
||||
|
@ -181,7 +181,7 @@ void S_Init(void)
|
|||
Cvar_RegisterVariable(&ambient_fade);
|
||||
Cvar_RegisterVariable(&snd_noextraupdate);
|
||||
Cvar_RegisterVariable(&snd_show);
|
||||
Cvar_RegisterVariable(&_snd_mixahead);
|
||||
Cvar_RegisterVariable(&snd_mixahead);
|
||||
Cvar_RegisterVariable(&sndspeed);
|
||||
Cvar_RegisterVariable(&snd_mixspeed);
|
||||
Cvar_RegisterVariable(&snd_filterquality);
|
||||
|
@ -276,13 +276,13 @@ static sfx_t *S_FindName(const char *name)
|
|||
if(!name)
|
||||
Sys_Error("S_FindName: NULL");
|
||||
|
||||
if(Q_strlen(name) >= MAX_QPATH)
|
||||
if(strlen(name) >= MAX_QPATH)
|
||||
Sys_Error("Sound name too long: %s", name);
|
||||
|
||||
// see if already loaded
|
||||
for(i = 0; i < num_sfx; i++)
|
||||
{
|
||||
if(!Q_strcmp(known_sfx[i].name, name))
|
||||
if(!strcmp(known_sfx[i].name, name))
|
||||
{
|
||||
return &known_sfx[i];
|
||||
}
|
||||
|
@ -925,7 +925,7 @@ static void S_Update_(void)
|
|||
}
|
||||
|
||||
// mix ahead of current position
|
||||
endtime = soundtime + (uint32_t)(_snd_mixahead.value * shm->speed);
|
||||
endtime = soundtime + (uint32_t)(snd_mixahead.value * shm->speed);
|
||||
samps = shm->samples >> (shm->channels - 1);
|
||||
endtime = q_min(endtime, (uint32_t)(soundtime + samps));
|
||||
|
||||
|
@ -979,7 +979,7 @@ static void S_Play(void)
|
|||
while(i < Cmd_Argc())
|
||||
{
|
||||
q_strlcpy(name, Cmd_Argv(i), sizeof(name));
|
||||
if(!Q_strrchr(Cmd_Argv(i), '.'))
|
||||
if(!strrchr(Cmd_Argv(i), '.'))
|
||||
{
|
||||
q_strlcat(name, ".wav", sizeof(name));
|
||||
}
|
||||
|
@ -1001,12 +1001,12 @@ static void S_PlayVol(void)
|
|||
while(i < Cmd_Argc())
|
||||
{
|
||||
q_strlcpy(name, Cmd_Argv(i), sizeof(name));
|
||||
if(!Q_strrchr(Cmd_Argv(i), '.'))
|
||||
if(!strrchr(Cmd_Argv(i), '.'))
|
||||
{
|
||||
q_strlcat(name, ".wav", sizeof(name));
|
||||
}
|
||||
sfx = S_PrecacheSound(name);
|
||||
vol = Q_atof(Cmd_Argv(i + 1));
|
||||
vol = atof(Cmd_Argv(i + 1));
|
||||
S_StartSound(hash++, 0, sfx, listener_origin, vol, 1.0);
|
||||
i += 2;
|
||||
}
|
||||
|
|
|
@ -217,7 +217,7 @@ static void FindNextChunk(const char *name)
|
|||
}
|
||||
last_chunk = data_p + ((iff_chunk_len + 1) & ~1);
|
||||
data_p -= 8;
|
||||
if(!Q_strncmp((char *)data_p, name, 4))
|
||||
if(!strncmp((char *)data_p, name, 4))
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -250,7 +250,7 @@ wavinfo_t GetWavinfo(const char *name, byte *wav, int32_t wavlength)
|
|||
|
||||
// find "RIFF" chunk
|
||||
FindChunk("RIFF");
|
||||
if(!(data_p && !Q_strncmp((char *)data_p + 8, "WAVE", 4)))
|
||||
if(!(data_p && !strncmp((char *)data_p + 8, "WAVE", 4)))
|
||||
{
|
||||
Con_Printf("%s missing RIFF/WAVE chunks\n", name);
|
||||
return info;
|
||||
|
|
|
@ -36,12 +36,6 @@ typedef int32_t fci_t; /* FCompactIndex */
|
|||
|
||||
#define UPKG_HDR_TAG 0x9e2a83c1
|
||||
|
||||
struct _genhist /* for upkg versions >= 68 */
|
||||
{
|
||||
int32_t export_count;
|
||||
int32_t name_count;
|
||||
};
|
||||
|
||||
struct upkg_hdr
|
||||
{
|
||||
uint32_t tag; /* UPKG_HDR_TAG */
|
||||
|
@ -63,7 +57,6 @@ struct upkg_hdr
|
|||
uint32_t guid[4];
|
||||
int32_t generation_count;
|
||||
#define UPKG_HDR_SIZE 64 /* 64 bytes up until here */
|
||||
/*struct _genhist *gen;*/
|
||||
};
|
||||
_Static_assert(sizeof(struct upkg_hdr) == UPKG_HDR_SIZE,
|
||||
"upkg_hdr not correct size");
|
||||
|
|
|
@ -517,7 +517,7 @@ byte *SV_FatPVS(vec3_t org, qmodel_t *worldmodel) //johnfitz -- added worldmode
|
|||
Sys_Error("SV_FatPVS: realloc() failed on %" PRIi32 " bytes", fatpvs_capacity);
|
||||
}
|
||||
|
||||
Q_memset(fatpvs, 0, fatbytes);
|
||||
memset(fatpvs, 0, fatbytes);
|
||||
SV_AddToFatPVS(org, worldmodel->nodes, worldmodel); //johnfitz -- worldmodel as a parameter
|
||||
return fatpvs;
|
||||
}
|
||||
|
@ -654,7 +654,7 @@ void SV_WriteEntitiesToClient(edict_t *clent, sizebuf_t *msg)
|
|||
eval_t *val;
|
||||
val = GetEdictFieldValue(ent, "alpha");
|
||||
if(val)
|
||||
ent->alpha = ENTALPHA_ENCODE(val->_float);
|
||||
ent->alpha = ENTALPHA_ENCODE(val->flt);
|
||||
}
|
||||
|
||||
//don't send invisible entities unless they have effects
|
||||
|
@ -820,7 +820,7 @@ void SV_WriteClientdataToMessage(edict_t *ent, sizebuf_t *msg)
|
|||
val = GetEdictFieldValue(ent, "items2");
|
||||
|
||||
if(val)
|
||||
items = (int32_t)ED_FLOAT(ent, ED_items) | ((int32_t)val->_float << 23);
|
||||
items = (int32_t)ED_FLOAT(ent, ED_items) | ((int32_t)val->flt << 23);
|
||||
else
|
||||
items = (int32_t)ED_FLOAT(ent, ED_items) | ((int32_t)G_FLOAT(GBL_serverflags) << 28);
|
||||
|
||||
|
@ -960,7 +960,7 @@ bool SV_SendClientDatagram(client_t *client)
|
|||
msg.cursize = 0;
|
||||
|
||||
//johnfitz -- if client is nonlocal, use smaller max size so packets aren't fragmented
|
||||
if(Q_strcmp(NET_QSocketGetAddressString(client->netconnection), "LOCAL") != 0)
|
||||
if(strcmp(NET_QSocketGetAddressString(client->netconnection), "LOCAL") != 0)
|
||||
msg.maxsize = DATAGRAM_MTU;
|
||||
//johnfitz
|
||||
|
||||
|
|
|
@ -394,8 +394,8 @@ void SV_AddGravity(edict_t *ent)
|
|||
eval_t *val;
|
||||
|
||||
val = GetEdictFieldValue(ent, "gravity");
|
||||
if(val && val->_float)
|
||||
ent_gravity = val->_float;
|
||||
if(val && val->flt)
|
||||
ent_gravity = val->flt;
|
||||
else
|
||||
ent_gravity = 1.0;
|
||||
|
||||
|
|
|
@ -140,7 +140,7 @@ sys_socket_t UDP_OpenSocket(int32_t port)
|
|||
{
|
||||
sys_socket_t newsocket;
|
||||
struct sockaddr_in address;
|
||||
int32_t _true = 1;
|
||||
int32_t istrue = 1;
|
||||
int32_t err;
|
||||
|
||||
if((newsocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == INVALID_SOCKET)
|
||||
|
@ -150,7 +150,7 @@ sys_socket_t UDP_OpenSocket(int32_t port)
|
|||
return INVALID_SOCKET;
|
||||
}
|
||||
|
||||
if(ioctlsocket(newsocket, FIONBIO, &_true) == SOCKET_ERROR)
|
||||
if(ioctlsocket(newsocket, FIONBIO, &istrue) == SOCKET_ERROR)
|
||||
goto error;
|
||||
|
||||
memset(&address, 0, sizeof(struct sockaddr_in));
|
||||
|
|
|
@ -309,7 +309,7 @@ static int32_t PartialIPAddress(const char *in, struct qsockaddr *hostaddr)
|
|||
}
|
||||
|
||||
if(*b++ == ':')
|
||||
port = Q_atoi(b);
|
||||
port = atoi(b);
|
||||
else
|
||||
port = net_hostport;
|
||||
|
||||
|
@ -478,11 +478,11 @@ int32_t WINS_GetNameFromAddr(struct qsockaddr *addr, char *name)
|
|||
sizeof(struct in_addr), AF_INET);
|
||||
if(hostentry)
|
||||
{
|
||||
Q_strncpy(name, (char *)hostentry->h_name, NET_NAMELEN - 1);
|
||||
strncpy(name, (char *)hostentry->h_name, NET_NAMELEN - 1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
Q_strcpy(name, WINS_AddrToString(addr));
|
||||
strcpy(name, WINS_AddrToString(addr));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -96,8 +96,8 @@ sys_socket_t WIPX_Init(void)
|
|||
broadcastaddr.sa_socket = htons((uint16_t)net_hostport);
|
||||
|
||||
WIPX_GetSocketAddr(net_controlsocket, &addr);
|
||||
Q_strcpy(my_ipx_address, WIPX_AddrToString(&addr));
|
||||
colon = Q_strrchr(my_ipx_address, ':');
|
||||
strcpy(my_ipx_address, WIPX_AddrToString(&addr));
|
||||
colon = strrchr(my_ipx_address, ':');
|
||||
if(colon)
|
||||
*colon = 0;
|
||||
|
||||
|
@ -327,7 +327,7 @@ int32_t WIPX_StringToAddr(const char *string, struct qsockaddr *addr)
|
|||
char buf[3];
|
||||
|
||||
buf[2] = 0;
|
||||
Q_memset(addr, 0, sizeof(struct qsockaddr));
|
||||
memset(addr, 0, sizeof(struct qsockaddr));
|
||||
addr->qsa_family = AF_IPX;
|
||||
|
||||
#define DO(src,dest) do { \
|
||||
|
@ -363,7 +363,7 @@ int32_t WIPX_GetSocketAddr(sys_socket_t handle, struct qsockaddr *addr)
|
|||
sys_socket_t socketid = ipxsocket[handle];
|
||||
socklen_t addrlen = sizeof(struct qsockaddr);
|
||||
|
||||
Q_memset(addr, 0, sizeof(struct qsockaddr));
|
||||
memset(addr, 0, sizeof(struct qsockaddr));
|
||||
if(getsockname(socketid, (struct sockaddr *)addr, &addrlen) != 0)
|
||||
{
|
||||
int32_t err = SOCKETERRNO;
|
||||
|
@ -378,7 +378,7 @@ int32_t WIPX_GetSocketAddr(sys_socket_t handle, struct qsockaddr *addr)
|
|||
|
||||
int32_t WIPX_GetNameFromAddr(struct qsockaddr *addr, char *name)
|
||||
{
|
||||
Q_strcpy(name, WIPX_AddrToString(addr));
|
||||
strcpy(name, WIPX_AddrToString(addr));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -389,7 +389,7 @@ int32_t WIPX_GetAddrFromName(const char *name, struct qsockaddr *addr)
|
|||
int32_t n;
|
||||
char buf[32];
|
||||
|
||||
n = Q_strlen(name);
|
||||
n = strlen(name);
|
||||
|
||||
if(n == 12)
|
||||
{
|
||||
|
|
|
@ -207,7 +207,7 @@ void *Z_Malloc(int32_t size)
|
|||
buf = Z_TagMalloc(size, 1);
|
||||
if(!buf)
|
||||
Sys_Error("Z_Malloc: failed on allocation of %" PRIi32 " bytes", size);
|
||||
Q_memset(buf, 0, size);
|
||||
memset(buf, 0, size);
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
@ -618,9 +618,9 @@ void Cache_Move(cache_system_t *c)
|
|||
{
|
||||
// Con_Printf ("cache_move ok\n");
|
||||
|
||||
Q_memcpy(new_cs + 1, c + 1, c->size - sizeof(cache_system_t));
|
||||
memcpy(new_cs + 1, c + 1, c->size - sizeof(cache_system_t));
|
||||
new_cs->user = c->user;
|
||||
Q_memcpy(new_cs->name, c->name, sizeof(new_cs->name));
|
||||
memcpy(new_cs->name, c->name, sizeof(new_cs->name));
|
||||
Cache_Free(c->user, false); //johnfitz -- added second argument
|
||||
new_cs->user->data = new_cs + 1;
|
||||
}
|
||||
|
@ -977,7 +977,7 @@ void Memory_Init(void *buf, int32_t size)
|
|||
if(p)
|
||||
{
|
||||
if(p < com_argc - 1)
|
||||
zonesize = Q_atoi(com_argv[p + 1]) * 1024;
|
||||
zonesize = atoi(com_argv[p + 1]) * 1024;
|
||||
else
|
||||
Sys_Error("Memory_Init: you must specify a size in KB after -zone");
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue