Cbuf_Lock(cbuf);
if (cbuf->maxsize - cbuf->size <= l)
- Con_Print("Cbuf_AddText: overflow\n");
+ Con_Print(CON_WARN "Cbuf_AddText: overflow\n");
else
{
// If the string terminates but the (last) line doesn't, the node will be left in the pending state (to be continued).
Cbuf_Lock(cbuf);
if (cbuf->size + l >= cbuf->maxsize)
- Con_Print("Cbuf_InsertText: overflow\n");
+ Con_Print(CON_WARN "Cbuf_InsertText: overflow\n");
else
{
// bones_was_here assertion: when prepending to the buffer it never makes sense to leave node(s) in the `pending` state,
* 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
Cmd_ExecuteString (current->source, current->text, src_local, false);
}
+ // Recycle memory so using WASD doesn't cause a malloc and free
+ List_Move_Tail(¤t->list, &cbuf->free);
+
current = NULL;
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);
}
}
}
// 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);
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;
}
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;
//
}
}
-/*
-============
-Cmd_Argc
-============
-*/
-inline int Cmd_Argc (cmd_state_t *cmd)
-{
- return cmd->argc;
-}
-
-/*
-============
-Cmd_Argv
-============
-*/
-inline const char *Cmd_Argv(cmd_state_t *cmd, int arg)
-{
- if (arg >= cmd->argc )
- return cmd->null_string;
- return cmd->argv[arg];
-}
-
-/*
-============
-Cmd_Args
-============
-*/
-inline 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;
}
}
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;
}
}
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;
}
}
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
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;
- }
- }
+ 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;
- }
- }
+ 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));
+ 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;
}
projects / xonotic / darkplaces.git / blobdiff