}
}
-/*
-============
-Cmd_Centerprint_f
-
-Print something to the center of the screen using SCR_Centerprint
-============
-*/
-static void Cmd_Centerprint_f (cmd_state_t *cmd)
-{
- char msg[MAX_INPUTLINE];
- unsigned int i, c, p;
- c = Cmd_Argc(cmd);
- if(c >= 2)
- {
- strlcpy(msg, Cmd_Argv(cmd,1), sizeof(msg));
- for(i = 2; i < c; ++i)
- {
- strlcat(msg, " ", sizeof(msg));
- strlcat(msg, Cmd_Argv(cmd, i), sizeof(msg));
- }
- c = (unsigned int)strlen(msg);
- for(p = 0, i = 0; i < c; ++i)
- {
- if(msg[i] == '\\')
- {
- if(msg[i+1] == 'n')
- msg[p++] = '\n';
- else if(msg[i+1] == '\\')
- msg[p++] = '\\';
- else {
- msg[p++] = '\\';
- msg[p++] = msg[i+1];
- }
- ++i;
- } else {
- msg[p++] = msg[i];
- }
- }
- msg[p] = '\0';
- SCR_CenterPrint(msg);
- }
-}
-
/*
=============================================================================
============
Cbuf_LinkString
-Copies a command string into a buffer node
+Copies a command string into a buffer node.
+The input should not be null-terminated, the output will be.
============
*/
static void Cbuf_LinkString(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text, qbool leavepending, unsigned int cmdsize)
}
cbuf->size += cmdsize;
- strlcpy(&node->text[offset], text, cmdsize + 1); // always sets the last char to \0
+ dp_ustr2stp(&node->text[offset], node->length + 1, text, cmdsize);
//Con_Printf("^5Cbuf_LinkString(): %s `^7%s^5`\n", node->pending ? "append" : "new", &node->text[offset]);
node->pending = leavepending;
}
cmd_buf_t *cbuf = cmd->cbuf;
llist_t llist = {&llist, &llist};
- Cbuf_Lock(cbuf);
-
- if (cbuf->maxsize - cbuf->size <= l)
- Con_Print("Cbuf_AddText: overflow\n");
- else
+ if (cbuf->size + l > cbuf->maxsize)
{
- // If the string terminates but the (last) line doesn't, the node will be left in the pending state (to be continued).
- Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.prev, cmd_input_t, list)), text, true);
- List_Splice_Tail(&llist, &cbuf->start);
+ Con_Printf(CON_WARN "Cbuf_AddText: input too large, %luKB ought to be enough for anybody.\n", (unsigned long)(cbuf->maxsize / 1024));
+ return;
}
+
+ Cbuf_Lock(cbuf);
+
+ // If the string terminates but the (last) line doesn't, the node will be left in the pending state (to be continued).
+ Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.prev, cmd_input_t, list)), text, true);
+ List_Splice_Tail(&llist, &cbuf->start);
+
Cbuf_Unlock(cbuf);
}
llist_t llist = {&llist, &llist};
size_t l = strlen(text);
- Cbuf_Lock(cbuf);
-
- if (cbuf->size + l >= cbuf->maxsize)
- Con_Print("Cbuf_InsertText: overflow\n");
- else
+ if (cbuf->size + l > cbuf->maxsize)
{
- // bones_was_here assertion: when prepending to the buffer it never makes sense to leave node(s) in the `pending` state,
- // it would have been impossible to append to such text later in the old raw text buffer,
- // and allowing it causes bugs when .cfg files lack \n at EOF (see: https://gitlab.com/xonotic/darkplaces/-/issues/378).
- Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text, false);
- List_Splice(&llist, &cbuf->start);
+ Con_Printf(CON_WARN "Cbuf_InsertText: input too large, %luKB ought to be enough for anybody.\n", (unsigned long)(cbuf->maxsize / 1024));
+ return;
}
+ Cbuf_Lock(cbuf);
+
+ // bones_was_here assertion: when prepending to the buffer it never makes sense to leave node(s) in the `pending` state,
+ // it would have been impossible to append to such text later in the old raw text buffer,
+ // and allowing it causes bugs when .cfg files lack \n at EOF (see: https://gitlab.com/xonotic/darkplaces/-/issues/378).
+ Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text, false);
+ List_Splice(&llist, &cbuf->start);
+
Cbuf_Unlock(cbuf);
}
if (host.realtime - cbuf->deferred_oldtime < 0 || host.realtime - cbuf->deferred_oldtime > 1800)
cbuf->deferred_oldtime = host.realtime;
eat = host.realtime - cbuf->deferred_oldtime;
- if (eat < 1/128)
+ if (eat < 1.0/128.0)
return;
cbuf->deferred_oldtime = host.realtime;
============
*/
extern qbool prvm_runawaycheck;
-static qbool Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias );
void Cbuf_Execute (cmd_buf_t *cbuf)
{
cmd_input_t *current;
- char preprocessed[MAX_INPUTLINE];
- char *firstchar;
unsigned int i = 0;
// LadyHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes
* can insert data at the beginning of the text buffer
*/
current = List_Entry(cbuf->start.next, cmd_input_t, list);
-
- // Recycle memory so using WASD doesn't cause a malloc and free
- List_Move_Tail(¤t->list, &cbuf->free);
-
+
/*
* Assume we're rolling with the current command-line and
* always set this false because alias expansion or cbuf insertion
*/
current->pending = false;
+ Cmd_PreprocessAndExecuteString(current->source, current->text, current->length, src_local, false);
cbuf->size -= current->length;
-
- firstchar = current->text;
- while(*firstchar && ISWHITESPACE(*firstchar))
- ++firstchar;
- if((strncmp(firstchar, "alias", 5) || !ISWHITESPACE(firstchar[5])) &&
- (strncmp(firstchar, "bind", 4) || !ISWHITESPACE(firstchar[4])) &&
- (strncmp(firstchar, "in_bind", 7) || !ISWHITESPACE(firstchar[7])))
- {
- if(Cmd_PreprocessString(current->source, current->text, preprocessed, sizeof(preprocessed), NULL ))
- Cmd_ExecuteString(current->source, preprocessed, src_local, false);
- }
- else
- {
- Cmd_ExecuteString (current->source, current->text, src_local, false);
- }
-
- current = NULL;
+ // Recycle memory so using WASD doesn't cause a malloc and free
+ List_Move_Tail(¤t->list, &cbuf->free);
if (cbuf->wait)
{
if (++i == 1000000 && prvm_runawaycheck)
{
Con_Printf(CON_WARN "Cbuf_Execute: runaway loop counter hit limit of %d commands, clearing command buffers!\n", i);
- while (!List_Is_Empty(&cbuf->start))
- List_Move_Tail(cbuf->start.next, &cbuf->free);
- while (!List_Is_Empty(&cbuf->deferred))
- List_Move_Tail(cbuf->deferred.next, &cbuf->free);
- cbuf->size = 0;
+ Cbuf_Clear(cbuf);
}
}
}
{
char *line;
- while ((line = Sys_ConsoleInput()))
- Cbuf_AddText(cmd_local, line);
+ if ((line = Sys_ConsoleInput()))
+ {
+ // bones_was_here: prepending allows a loop such as `alias foo "bar; wait; foo"; foo`
+ // to be broken with an alias or unalias command
+ Cbuf_InsertText(cmd_local, line);
+ }
}
void Cbuf_Frame(cmd_buf_t *cbuf)
// R_TimeReport("console");
}
+void Cbuf_Clear(cmd_buf_t *cbuf)
+{
+ while (!List_Is_Empty(&cbuf->start))
+ List_Move_Tail(cbuf->start.next, &cbuf->free);
+ while (!List_Is_Empty(&cbuf->deferred))
+ List_Move_Tail(cbuf->deferred.next, &cbuf->free);
+ cbuf->size = 0;
+}
+
/*
==============================================================================
f = (char *)FS_LoadFile (filename, tempmempool, false, NULL);
if (!f)
{
- Con_Printf("couldn't exec %s\n",filename);
+ Con_Printf(CON_WARN "couldn't exec %s\n",filename);
return;
}
Con_Printf("execing %s\n",filename);
Cbuf_InsertText(cmd, "\n"
"csqc_polygons_defaultmaterial_nocullface 1\n"
"con_chatsound_team_mask 13\n"
-"sv_gameplayfix_customstats 1\n"
+"sv_qcstats 1\n"
"mod_q1bsp_zero_hullsize_cutoff 8.03125\n"
);
break;
s = FS_Search(Cmd_Argv(cmd, 1), true, true, NULL);
if(!s || !s->numfilenames)
{
- Con_Printf("couldn't exec %s\n",Cmd_Argv(cmd, 1));
+ Con_Printf(CON_WARN "couldn't exec %s\n",Cmd_Argv(cmd, 1));
return;
}
}
else
{ // Invalid CVar
- Con_Printf("ERROR : CVar '%s' not found\n", Cmd_Argv(cmd, 1) );
+ Con_Printf(CON_WARN "ERROR : CVar '%s' not found\n", Cmd_Argv(cmd, 1) );
}
}
}
s = Cmd_Argv(cmd, 1);
if (strlen(s) >= MAX_ALIAS_NAME)
{
- Con_Print("Alias name is too long\n");
+ Con_Print(CON_WARN "Alias name is too long\n");
return;
}
cmd_alias_t *prev, *current;
a = (cmd_alias_t *)Z_Malloc (sizeof(cmd_alias_t));
- strlcpy (a->name, s, sizeof (a->name));
+ dp_strlcpy (a->name, s, sizeof (a->name));
// insert it at the right alphanumeric position
for( prev = NULL, current = cmd->userdefined->alias ; current && strcmp( current->name, a->name ) < 0 ; prev = current, current = current->next )
;
for (i=2 ; i < c ; i++)
{
if (i != 2)
- strlcat (line, " ", sizeof (line));
- strlcat (line, Cmd_Argv(cmd, i), sizeof (line));
+ dp_strlcat (line, " ", sizeof (line));
+ dp_strlcat (line, Cmd_Argv(cmd, i), sizeof (line));
}
- strlcat (line, "\n", sizeof (line));
+ dp_strlcat (line, "\n", sizeof (line));
alloclen = strlen (line) + 1;
if(alloclen >= 2)
return varstr;
}
-/*
+/**
Cmd_PreprocessString
Preprocesses strings and replaces $*, $param#, $cvar accordingly. Also strips comments.
+Returns the number of bytes written to *outtext excluding the \0 terminator.
*/
-static qbool Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias ) {
+static size_t Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias)
+{
const char *in;
size_t eat, varlen;
unsigned outlen;
// don't crash if there's no room in the outtext buffer
if( maxoutlen == 0 ) {
- return false;
+ return 0;
}
maxoutlen--; // because of \0
{
val = Cmd_GetCvarValue(cmd, in + 1, varlen, alias);
if(!val)
- return false;
+ return 0;
eat = varlen + 2;
}
else
varlen = strspn(in, "#*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-");
val = Cmd_GetCvarValue(cmd, in, varlen, alias);
if(!val)
- return false;
+ return 0;
eat = varlen;
}
if(val)
else
outtext[outlen++] = *in++;
}
- outtext[outlen] = 0;
- return true;
+ outtext[outlen] = '\0';
+ return outlen;
}
/*
Cbuf_InsertText(cmd, buffer2);
}
+void Cmd_PreprocessAndExecuteString(cmd_state_t *cmd, const char *text, size_t textlen, cmd_source_t src, qbool lockmutex)
+{
+ char preprocessed[MAX_INPUTLINE];
+ size_t preprocessed_len;
+ const char *firstchar;
+
+ firstchar = text;
+ while(*firstchar && ISWHITESPACE(*firstchar))
+ ++firstchar;
+ if((strncmp(firstchar, "alias", 5) || !ISWHITESPACE(firstchar[5]))
+ && (strncmp(firstchar, "bind", 4) || !ISWHITESPACE(firstchar[4]))
+ && (strncmp(firstchar, "in_bind", 7) || !ISWHITESPACE(firstchar[7])))
+ {
+ if((preprocessed_len = Cmd_PreprocessString(cmd, text, preprocessed, sizeof(preprocessed), NULL)))
+ Cmd_ExecuteString(cmd, preprocessed, preprocessed_len, src, lockmutex);
+ }
+ else
+ Cmd_ExecuteString(cmd, text, textlen, src, lockmutex);
+}
+
/*
========
Cmd_List
Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : "");
}
-static cmd_state_t *Cmd_AddInterpreter(cmd_buf_t *cbuf, cvar_state_t *cvars, int cvars_flagsmask, int cmds_flagsmask, cmd_userdefined_t *userdefined)
+static cmd_state_t *Cmd_AddInterpreter(cmd_buf_t *cbuf, cvar_state_t *cvars, unsigned cvars_flagsmask, unsigned cmds_flagsmask, cmd_userdefined_t *userdefined)
{
cmd_state_t *cmd = (cmd_state_t *)Mem_Alloc(tempmempool, sizeof(cmd_state_t));
cmd->cvars = cvars;
cmd->cvars_flagsmask = cvars_flagsmask;
- cmd->cmd_flags = cmds_flagsmask;
+ cmd->cmd_flagsmask = cmds_flagsmask;
cmd->userdefined = userdefined;
return cmd;
void Cmd_Init(void)
{
cmd_buf_t *cbuf;
+ unsigned cvars_flagsmask, cmds_flagsmask;
+
cbuf_mempool = Mem_AllocPool("Command buffer", 0, NULL);
cbuf = (cmd_buf_t *)Mem_Alloc(cbuf_mempool, sizeof(cmd_buf_t));
cbuf->maxsize = CMDBUFSIZE;
cmd_iter_all = (cmd_iter_t *)Mem_Alloc(tempmempool, sizeof(cmd_iter_t) * 3);
// local console
- cmd_iter_all[0].cmd = cmd_local = Cmd_AddInterpreter(cbuf, &cvars_all, CF_CLIENT | CF_SERVER, CF_CLIENT | CF_CLIENT_FROM_SERVER | CF_SERVER_FROM_CLIENT, &cmd_userdefined_all);
+ if (cls.state == ca_dedicated)
+ {
+ cvars_flagsmask = CF_SERVER;
+ cmds_flagsmask = CF_SERVER | CF_SERVER_FROM_CLIENT;
+ }
+ else
+ {
+ cvars_flagsmask = CF_CLIENT | CF_SERVER;
+ cmds_flagsmask = CF_CLIENT | CF_SERVER | CF_CLIENT_FROM_SERVER | CF_SERVER_FROM_CLIENT;
+ }
+ cmd_iter_all[0].cmd = cmd_local = Cmd_AddInterpreter(cbuf, &cvars_all, cvars_flagsmask, cmds_flagsmask, &cmd_userdefined_all);
cmd_local->Handle = Cmd_CL_Callback;
- cmd_local->NotFound = NULL;
// server commands received from clients have no reason to access cvars, cvar expansion seems perilous.
cmd_iter_all[1].cmd = cmd_serverfromclient = Cmd_AddInterpreter(cbuf, &cvars_null, 0, CF_SERVER_FROM_CLIENT | CF_USERINFO, &cmd_userdefined_null);
cmd_serverfromclient->Handle = Cmd_SV_Callback;
- cmd_serverfromclient->NotFound = Cmd_SV_NotFound;
cmd_iter_all[2].cmd = NULL;
//
//
// client-only commands
Cmd_AddCommand(CF_SHARED, "wait", Cmd_Wait_f, "make script execution wait for next rendered frame");
- Cmd_AddCommand(CF_CLIENT, "cprint", Cmd_Centerprint_f, "print something at the screen center");
// maintenance commands used for upkeep of cvars and saved configs
Cmd_AddCommand(CF_SHARED, "stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)");
}
}
-/*
-============
-Cmd_Argc
-============
-*/
-int Cmd_Argc (cmd_state_t *cmd)
-{
- return cmd->argc;
-}
-
-/*
-============
-Cmd_Argv
-============
-*/
-const char *Cmd_Argv(cmd_state_t *cmd, int arg)
-{
- if (arg >= cmd->argc )
- return cmd->null_string;
- return cmd->argv[arg];
-}
-
-/*
-============
-Cmd_Args
-============
-*/
-const char *Cmd_Args (cmd_state_t *cmd)
-{
- return cmd->args;
-}
-
/*
============
Cmd_TokenizeString
Parses the given string into command line tokens.
+Takes a null terminated string. Does not need to be /n terminated.
============
*/
-// AK: This function should only be called from ExcuteString because the current design is a bit of an hack
+// AK: This function should only be called from ExecuteString because the current design is a bit of an hack
static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text)
{
int l;
l = (int)strlen(com_token) + 1;
if (cmd->cbuf->tokenizebufferpos + l > CMD_TOKENIZELENGTH)
{
- Con_Printf("Cmd_TokenizeString: ran out of %i character buffer space for command arguments\n", CMD_TOKENIZELENGTH);
+ Con_Printf(CON_WARN "Cmd_TokenizeString: ran out of %i character buffer space for command arguments\n", CMD_TOKENIZELENGTH);
break;
}
memcpy (cmd->cbuf->tokenizebuffer + cmd->cbuf->tokenizebufferpos, com_token, l);
Cmd_AddCommand
============
*/
-void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const char *description)
+void Cmd_AddCommand(unsigned flags, const char *cmd_name, xcommand_t function, const char *description)
{
cmd_function_t *func;
cmd_function_t *prev, *current;
for (i = 0; i < 2; i++)
{
cmd = cmd_iter_all[i].cmd;
- if (flags & cmd->cmd_flags)
+ if (flags & cmd->cmd_flagsmask)
{
// fail if the command is a variable name
if (Cvar_FindVar(cmd->cvars, cmd_name, ~0))
{
- Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
+ Con_Printf(CON_WARN "Cmd_AddCommand: %s already defined as a var\n", cmd_name);
return;
}
{
if (!strcmp(cmd_name, func->name))
{
- Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name);
+ Con_Printf(CON_WARN "Cmd_AddCommand: %s already defined\n", cmd_name);
continue;
}
}
* implement that behavior that doesn't involve an #ifdef, or
* making a mess of hooks.
*/
-qbool Cmd_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src)
+qbool Cmd_Callback(cmd_state_t *cmd, cmd_function_t *func)
{
if (func->function)
func->function(cmd);
else
- Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0));
+ Con_Printf(CON_WARN "Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0));
return true;
}
-qbool Cmd_CL_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src)
+qbool Cmd_CL_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, size_t textlen, cmd_source_t src)
{
// TODO: Assign these functions to QC commands directly?
if(func->qcfunc)
{
- if(((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text)) ||
- ((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text)))
+ if(((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text, textlen)) ||
+ ((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text, textlen)))
return true;
if (func->overridden) // If this QC command overrides an engine command,
}
else if(!(func->flags & CF_SERVER))
{
- Con_Printf("Cannot execute client commands from a dedicated server console.\n");
+ Con_Printf(CON_WARN "Cannot execute client commands from a dedicated server console.\n");
return true;
}
}
- return Cmd_Callback(cmd, func, text, src);
+ return Cmd_Callback(cmd, func);
}
-qbool Cmd_SV_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src)
+qbool Cmd_SV_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, size_t textlen, cmd_source_t src)
{
if(func->qcfunc && (func->flags & CF_SERVER))
- return SV_VM_ConsoleCommand(text);
+ return SV_VM_ConsoleCommand(text, textlen);
else if (src == src_client)
{
if((func->flags & CF_CHEAT) && !sv_cheats.integer)
- SV_ClientPrintf("No cheats allowed. The server must have sv_cheats set to 1\n");
+ SV_ClientPrintf(CON_WARN "No cheats allowed. The server must have sv_cheats set to 1\n");
else
func->function(cmd);
return true;
return false;
}
-qbool Cmd_SV_NotFound(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src)
-{
- if (cmd->source == src_client)
- {
- Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text);
- return true;
- }
- return false;
-}
/*
============
Cmd_ExecuteString
FIXME: lookupnoadd the token to speed search?
============
*/
-void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qbool lockmutex)
+void Cmd_ExecuteString(cmd_state_t *cmd, const char *text, size_t textlen, cmd_source_t src, qbool lockmutex)
{
int oldpos;
cmd_function_t *func;
cmd_alias_t *a;
+
if (lockmutex)
Cbuf_Lock(cmd->cbuf);
oldpos = cmd->cbuf->tokenizebufferpos;
// check functions
for (func = cmd->userdefined->qc_functions; func; func = func->next)
- {
if (!strcasecmp(cmd->argv[0], func->name))
- {
- if(cmd->Handle(cmd, func, text, src))
- goto done;
- }
- }
+ if(cmd->Handle(cmd, func, text, textlen, src))
+ goto functions_done;
for (func = cmd->engine_functions; func; func=func->next)
- {
if (!strcasecmp (cmd->argv[0], func->name))
- {
- if(cmd->Handle(cmd, func, text, src))
- goto done;
- }
- }
+ if(cmd->Handle(cmd, func, text, textlen, src))
+ goto functions_done;
- // if it's a client command and no command was found, say so.
- if(cmd->NotFound)
+functions_done:
+ // If it's a client command and wasn't found and handled, say so.
+ // Also don't let clients call server aliases.
+ if (cmd->source == src_client)
{
- if(cmd->NotFound(cmd, func, text, src))
- goto done;
+ if (!func)
+ Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text);
+ goto done;
}
// check alias
+ // Execute any alias with the same name as a command after the command.
for (a=cmd->userdefined->alias ; a ; a=a->next)
{
if (!strcasecmp (cmd->argv[0], a->name))
}
}
+ // If the command was found and handled don't try to handle it as a cvar.
+ if (func)
+ goto done;
+
// check cvars
- if (!Cvar_Command(cmd) && host.framecount > 0)
- Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(cmd, 0));
+ // Xonotic is still maintained so we don't want to hide problems from getting fixed
+ if (!Cvar_Command(cmd) && (host.framecount > 0 || gamemode == GAME_XONOTIC))
+ Con_Printf(CON_WARN "Unknown command \"%s\"\n", Cmd_Argv(cmd, 0));
done:
cmd->cbuf->tokenizebufferpos = oldpos;
if (lockmutex)
if (!parm)
{
- Con_Printf ("Cmd_CheckParm: NULL");
+ Con_Printf(CON_WARN "Cmd_CheckParm: NULL");
return 0;
}