{
struct cmddeferred_s *next;
char *value;
- double time;
+ double delay;
} cmddeferred_t;
static cmddeferred_t *cmd_deferred_list = NULL;
{
if(Cmd_Argc() == 1)
{
- double time = Sys_DoubleTime();
cmddeferred_t *next = cmd_deferred_list;
if(!next)
Con_Printf("No commands are pending.\n");
while(next)
{
- Con_Printf("-> In %9.2f: %s\n", next->time-time, next->value);
+ Con_Printf("-> In %9.2f: %s\n", next->delay, next->value);
next = next->next;
}
} else if(Cmd_Argc() == 2 && !strcasecmp("clear", Cmd_Argv(1)))
cmddeferred_t *defcmd = (cmddeferred_t*)Mem_Alloc(tempmempool, sizeof(*defcmd));
size_t len = strlen(value);
- defcmd->time = Sys_DoubleTime() + atof(Cmd_Argv(1));
+ defcmd->delay = atof(Cmd_Argv(1));
defcmd->value = (char*)Mem_Alloc(tempmempool, len+1);
memcpy(defcmd->value, value, len+1);
defcmd->next = NULL;
static unsigned char cmd_text_buf[CMDBUFSIZE];
void *cmd_text_mutex = NULL;
-static void Cbuf_LockThreadMutex(void)
-{
- if (cmd_text_mutex)
- Thread_LockMutex(cmd_text_mutex);
-}
-
-static void Cbuf_UnlockThreadMutex(void)
-{
- if (cmd_text_mutex)
- Thread_UnlockMutex(cmd_text_mutex);
-}
+#define Cbuf_LockThreadMutex() (cmd_text_mutex ? Thread_LockMutex(cmd_text_mutex),1 : 0)
+#define Cbuf_UnlockThreadMutex() (cmd_text_mutex ? Thread_UnlockMutex(cmd_text_mutex),1 : 0)
/*
============
if (cmd_text.cursize + l >= cmd_text.maxsize)
Con_Print("Cbuf_AddText: overflow\n");
else
- SZ_Write(&cmd_text, (const unsigned char *)text, (int)strlen (text));
+ SZ_Write(&cmd_text, (const unsigned char *)text, l);
Cbuf_UnlockThreadMutex();
}
*/
void Cbuf_InsertText (const char *text)
{
- char *temp;
- int templen;
-
+ size_t l = strlen(text);
Cbuf_LockThreadMutex();
-
- // copy off any commands still remaining in the exec buffer
- templen = cmd_text.cursize;
- if (templen)
- {
- temp = (char *)Mem_Alloc (tempmempool, templen);
- memcpy (temp, cmd_text.data, templen);
- SZ_Clear (&cmd_text);
- }
+ // we need to memmove the existing text and stuff this in before it...
+ if (cmd_text.cursize + l >= (size_t)cmd_text.maxsize)
+ Con_Print("Cbuf_InsertText: overflow\n");
else
- temp = NULL;
-
- // add the entire text of the file
- Cbuf_AddText (text);
-
- // add the copied off data
- if (temp != NULL)
{
- SZ_Write (&cmd_text, (const unsigned char *)temp, templen);
- Mem_Free (temp);
+ // we don't have a SZ_Prepend, so...
+ memmove(cmd_text.data + l, cmd_text.data, cmd_text.cursize);
+ cmd_text.cursize += l;
+ memcpy(cmd_text.data, text, l);
}
-
Cbuf_UnlockThreadMutex();
}
Cbuf_Execute_Deferred --blub
============
*/
-void Cbuf_Execute_Deferred (void)
+static void Cbuf_Execute_Deferred (void)
{
+ static double oldrealtime = 0;
cmddeferred_t *cmd, *prev;
- double time = Sys_DoubleTime();
+ double eat;
+ if (realtime - oldrealtime < 0 || realtime - oldrealtime > 1800) oldrealtime = realtime;
+ eat = realtime - oldrealtime;
+ if (eat < (1.0 / 120.0))
+ return;
+ oldrealtime = realtime;
prev = NULL;
cmd = cmd_deferred_list;
while(cmd)
{
- if(cmd->time <= time)
+ cmd->delay -= eat;
+ if(cmd->delay <= 0)
{
Cbuf_AddText(cmd->value);
Cbuf_AddText(";\n");
qboolean quotes;
char *comment;
- Cbuf_LockThreadMutex();
- SV_LockThreadMutex();
-
// LordHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes
cmd_tokenizebufferpos = 0;
- Cbuf_Execute_Deferred();
while (cmd_text.cursize)
{
// find a \n or ; line break
break;
}
}
+}
- SV_UnlockThreadMutex();
- Cbuf_UnlockThreadMutex();
+void Cbuf_Frame(void)
+{
+ Cbuf_Execute_Deferred();
+ if (cmd_text.cursize)
+ {
+ SV_LockThreadMutex();
+ Cbuf_Execute();
+ SV_UnlockThreadMutex();
+ }
}
/*
===============
*/
qboolean host_stuffcmdsrun = false;
-void Cmd_StuffCmds_f (void)
+static void Cmd_StuffCmds_f (void)
{
int i, j, l;
// this is for all commandline options combined (and is bounds checked)
cvar_t *cvar;
long argno;
char *endptr;
+ char vabuf[1024];
if(is_multiple)
*is_multiple = false;
}
else if(!strcmp(varname, "#"))
{
- return va("%d", Cmd_Argc());
+ return va(vabuf, sizeof(vabuf), "%d", Cmd_Argc());
}
else if(varname[strlen(varname) - 1] == '-')
{
static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t *alias)
{
- static char varname[MAX_INPUTLINE];
- static char varval[MAX_INPUTLINE];
+ static char varname[MAX_INPUTLINE]; // cmd_mutex
+ static char varval[MAX_INPUTLINE]; // cmd_mutex
const char *varstr;
char *varfunc;
static char asis[] = "asis"; // just to suppress const char warnings
*/
static void Cmd_ExecuteAlias (cmdalias_t *alias)
{
- static char buffer[ MAX_INPUTLINE ];
- static char buffer2[ MAX_INPUTLINE ];
+ static char buffer[ MAX_INPUTLINE ]; // cmd_mutex
+ static char buffer2[ MAX_INPUTLINE ]; // cmd_mutex
Cmd_PreprocessString( alias->value, buffer, sizeof(buffer) - 2, alias );
// insert at start of command buffer, so that aliases execute in order
// (fixes bug introduced by Black on 20050705)
const char *partial;
int count;
qboolean ispattern;
+ char vabuf[1024];
if (Cmd_Argc() > 1)
partial = Cmd_Args();
ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
if(!ispattern)
- partial = va("*%s*", partial);
+ partial = va(vabuf, sizeof(vabuf), "*%s*", partial);
count = 0;
for (cvar = cvar_vars; cvar; cvar = cvar->next)
void Cmd_Shutdown(void)
{
if (cmd_text_mutex)
+ {
+ // we usually have this locked when we get here from Host_Quit_f
+ Cbuf_UnlockThreadMutex();
Thread_DestroyMutex(cmd_text_mutex);
+ }
cmd_text_mutex = NULL;
Mem_FreePool(&cmd_mempool);
cmd->csqcfunc = false;
}
-qboolean CL_VM_ConsoleCommand (const char *cmd);
/*
============
Cmd_ExecuteString
cmd_function_t *cmd;
cmdalias_t *a;
- if (lockmutex)
- Cbuf_LockThreadMutex();
oldpos = cmd_tokenizebufferpos;
cmd_source = src;
found = false;
done:
cmd_tokenizebufferpos = oldpos;
- if (lockmutex)
- Cbuf_UnlockThreadMutex();
}
void Cmd_ForwardToServer (void)
{
const char *s;
+ char vabuf[1024];
if (!strcasecmp(Cmd_Argv(0), "cmd"))
{
// we want to strip off "cmd", so just send the args
else
{
// we need to keep the command name, so send Cmd_Argv(0), a space and then Cmd_Args()
- s = va("%s %s", Cmd_Argv(0), Cmd_Argc() > 1 ? Cmd_Args() : "");
+ s = va(vabuf, sizeof(vabuf), "%s %s", Cmd_Argv(0), Cmd_Argc() > 1 ? Cmd_Args() : "");
}
// don't send an empty forward message if the user tries "cmd" by itself
if (!s || !*s)
projects / xonotic / darkplaces.git / blobdiff