#include "quakedef.h"
#include "prvm_cmds.h"
+#include "libcurl.h"
#include <time.h>
extern cvar_t prvm_backtraceforwarnings;
dpvsnprintf(msg,sizeof(msg),fmt,argptr);
va_end(argptr);
- Con_Printf(msg);
+ Con_Print(msg);
// TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black]
if(prvm_backtraceforwarnings.integer && recursive != realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
void VM_CheckEmptyString (const char *s)
{
- if (s[0] <= ' ')
+ if (ISWHITESPACE(s[0]))
PRVM_ERROR ("%s: Bad string", PRVM_NAME);
}
float CVAR_TYPEFLAG_PRIVATE = 4;
float CVAR_TYPEFLAG_ENGINE = 8;
float CVAR_TYPEFLAG_HASDESCRIPTION = 16;
+float CVAR_TYPEFLAG_READONLY = 32;
=================
*/
void VM_cvar_type (void)
ret |= 4; // CVAR_TYPE_PRIVATE
if(!(cvar->flags & CVAR_ALLOCATED))
ret |= 8; // CVAR_TYPE_ENGINE
- if(strcmp(cvar->description, "custom cvar")) // has to match Cvar_Get's placeholder string
+ if(cvar->description != cvar_dummy_description)
ret |= 16; // CVAR_TYPE_HASDESCRIPTION
+ if(cvar->flags & CVAR_READONLY)
+ ret |= 32; // CVAR_TYPE_READONLY
PRVM_G_FLOAT(OFS_RETURN) = ret;
}
VM_CheckEmptyString(string);
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(string));
}
+
+/*
+========================
+VM_cvar_defstring
+
+const string VM_cvar_description (string, ...)
+========================
+*/
+void VM_cvar_description (void)
+{
+ char string[VM_STRINGTEMP_LENGTH];
+ VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_description);
+ VM_VarString(0, string, sizeof(string));
+ VM_CheckEmptyString(string);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDescription(string));
+}
/*
=================
VM_cvar_set
return;
}
- Cvar_Get(name, value, flags);
+ Cvar_Get(name, value, flags, NULL);
PRVM_G_FLOAT(OFS_RETURN) = 1; // success
}
VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES);
return;
}
+ filename = PRVM_G_STRING(OFS_PARM0);
mode = (int)PRVM_G_FLOAT(OFS_PARM1);
switch(mode)
{
case 0: // FILE_READ
modestring = "rb";
+ prog->openfiles[filenum] = FS_OpenVirtualFile(va("data/%s", filename), false);
+ if (prog->openfiles[filenum] == NULL)
+ prog->openfiles[filenum] = FS_OpenVirtualFile(va("%s", filename), false);
break;
case 1: // FILE_APPEND
- modestring = "ab";
+ modestring = "a";
+ prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false);
break;
case 2: // FILE_WRITE
- modestring = "wb";
+ modestring = "w";
+ prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false);
break;
default:
PRVM_G_FLOAT(OFS_RETURN) = -3;
VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
return;
}
- filename = PRVM_G_STRING(OFS_PARM0);
-
- prog->openfiles[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
- if (prog->openfiles[filenum] == NULL && mode == 0)
- prog->openfiles[filenum] = FS_Open(va("%s", filename), modestring, false, false);
if (prog->openfiles[filenum] == NULL)
{
PRVM_G_FLOAT(OFS_RETURN) = filenum;
if (developer.integer >= 100)
Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
+ prog->openfiles_origin[filenum] = PRVM_AllocationOrigin();
}
}
}
FS_Close(prog->openfiles[filenum]);
prog->openfiles[filenum] = NULL;
+ if(prog->openfiles_origin[filenum])
+ PRVM_Free((char *)prog->openfiles_origin[filenum]);
if (developer.integer >= 100)
Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
}
PRVM_ED_Write (file, ent);
}
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_numentityfields
+
+float() numentityfields
+Return the number of entity fields - NOT offsets
+=========
+*/
+void VM_numentityfields(void)
+{
+ PRVM_G_FLOAT(OFS_RETURN) = prog->progs->numfielddefs;
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_entityfieldname
+
+string(float fieldnum) entityfieldname
+Return name of the specified field as a string, or empty if the field is invalid (warning)
+=========
+*/
+void VM_entityfieldname(void)
+{
+ ddef_t *d;
+ int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+ if (i < 0 || i >= prog->progs->numfielddefs)
+ {
+ VM_Warning("VM_entityfieldname: %s: field index out of bounds\n", PRVM_NAME);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+ return;
+ }
+
+ d = &prog->fielddefs[i];
+ PRVM_G_INT(OFS_RETURN) = d->s_name; // presuming that s_name points to a string already
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_entityfieldtype
+
+float(float fieldnum) entityfieldtype
+=========
+*/
+void VM_entityfieldtype(void)
+{
+ ddef_t *d;
+ int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+ if (i < 0 || i >= prog->progs->numfielddefs)
+ {
+ VM_Warning("VM_entityfieldtype: %s: field index out of bounds\n", PRVM_NAME);
+ PRVM_G_FLOAT(OFS_RETURN) = -1.0;
+ return;
+ }
+
+ d = &prog->fielddefs[i];
+ PRVM_G_FLOAT(OFS_RETURN) = (float)d->type;
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_getentityfieldstring
+
+string(float fieldnum, entity ent) getentityfieldstring
+=========
+*/
+void VM_getentityfieldstring(void)
+{
+ // put the data into a string
+ ddef_t *d;
+ int type, j;
+ int *v;
+ prvm_edict_t * ent;
+ int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+ if (i < 0 || i >= prog->progs->numfielddefs)
+ {
+ VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+ return;
+ }
+
+ d = &prog->fielddefs[i];
+
+ // get the entity
+ ent = PRVM_G_EDICT(OFS_PARM1);
+ if(ent->priv.required->free)
+ {
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+ VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
+ return;
+ }
+ v = (int *)((char *)ent->fields.vp + d->ofs*4);
+
+ // if it's 0 or blank, return an empty string
+ type = d->type & ~DEF_SAVEGLOBAL;
+ for (j=0 ; j<prvm_type_size[type] ; j++)
+ if (v[j])
+ break;
+ if (j == prvm_type_size[type])
+ {
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+ return;
+ }
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(PRVM_UglyValueString((etype_t)d->type, (prvm_eval_t *)v));
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_putentityfieldstring
+
+float(float fieldnum, entity ent, string s) putentityfieldstring
+=========
+*/
+void VM_putentityfieldstring(void)
+{
+ ddef_t *d;
+ prvm_edict_t * ent;
+ int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+ if (i < 0 || i >= prog->progs->numfielddefs)
+ {
+ VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME);
+ PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
+ return;
+ }
+
+ d = &prog->fielddefs[i];
+
+ // get the entity
+ ent = PRVM_G_EDICT(OFS_PARM1);
+ if(ent->priv.required->free)
+ {
+ VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
+ PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
+ return;
+ }
+
+ // parse the string into the value
+ PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(ent, d, PRVM_G_STRING(OFS_PARM2), false) ) ? 1.0f : 0.0f;
+}
+
/*
=========
VM_strlen
// Prepare Strings
VM_SAFEPARMCOUNT(1,VM_strdecolorize);
szString = PRVM_G_STRING(OFS_PARM0);
-
COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE);
-
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
}
//float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
//this function originally written by KrimZon, made shorter by LordHavoc
//20040203: rewritten by LordHavoc (no longer uses allocations)
-int num_tokens = 0;
-int tokens[256];
+static int num_tokens = 0;
+static int tokens[256];
+static int tokens_startpos[256];
+static int tokens_endpos[256];
+static char tokenize_string[VM_STRINGTEMP_LENGTH];
void VM_tokenize (void)
{
const char *p;
- static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
VM_SAFEPARMCOUNT(1,VM_tokenize);
- strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
- p = string;
+ strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+ p = tokenize_string;
+
+ num_tokens = 0;
+ for(;;)
+ {
+ if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
+ break;
+
+ // skip whitespace here to find token start pos
+ while(*p && ISWHITESPACE(*p))
+ ++p;
+
+ tokens_startpos[num_tokens] = p - tokenize_string;
+ if(!COM_ParseToken_VM_Tokenize(&p, false))
+ break;
+ tokens_endpos[num_tokens] = p - tokenize_string;
+ tokens[num_tokens] = PRVM_SetTempString(com_token);
+ ++num_tokens;
+ }
+
+ PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
+}
+
+//float(string s) tokenize = #514; // takes apart a string into individal words (access them with argv), returns how many
+void VM_tokenize_console (void)
+{
+ const char *p;
+
+ VM_SAFEPARMCOUNT(1,VM_tokenize);
+
+ strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+ p = tokenize_string;
num_tokens = 0;
- while(COM_ParseToken_VM_Tokenize(&p, false))
+ for(;;)
{
if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
break;
- tokens[num_tokens++] = PRVM_SetTempString(com_token);
+
+ // skip whitespace here to find token start pos
+ while(*p && ISWHITESPACE(*p))
+ ++p;
+
+ tokens_startpos[num_tokens] = p - tokenize_string;
+ if(!COM_ParseToken_Console(&p))
+ break;
+ tokens_endpos[num_tokens] = p - tokenize_string;
+ tokens[num_tokens] = PRVM_SetTempString(com_token);
+ ++num_tokens;
}
PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
const char *p;
const char *token;
char tokentext[MAX_INPUTLINE];
- static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
- strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
- p = string;
+ strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+ p = tokenize_string;
- numseparators = 0;;
+ numseparators = 0;
for (j = 1;j < prog->argc;j++)
{
// skip any blank separator strings
while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0])))
{
token = tokentext + j;
+ tokens_startpos[num_tokens] = p - tokenize_string;
while (*p)
{
for (k = 0;k < numseparators;k++)
tokentext[j++] = *p;
p++;
}
+ tokens_endpos[num_tokens] = p - tokenize_string;
if (j >= (int)sizeof(tokentext))
break;
tokentext[j++] = 0;
token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
+ if(token_num < 0)
+ token_num += num_tokens;
+
if (token_num >= 0 && token_num < num_tokens)
PRVM_G_INT(OFS_RETURN) = tokens[token_num];
else
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
}
+//float(float n) argv_start_index = #515; // returns the start index of a token
+void VM_argv_start_index (void)
+{
+ int token_num;
+
+ VM_SAFEPARMCOUNT(1,VM_argv);
+
+ token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+ if(token_num < 0)
+ token_num += num_tokens;
+
+ if (token_num >= 0 && token_num < num_tokens)
+ PRVM_G_FLOAT(OFS_RETURN) = tokens_startpos[token_num];
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
+}
+
+//float(float n) argv_end_index = #516; // returns the end index of a token
+void VM_argv_end_index (void)
+{
+ int token_num;
+
+ VM_SAFEPARMCOUNT(1,VM_argv);
+
+ token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+ if(token_num < 0)
+ token_num += num_tokens;
+
+ if (token_num >= 0 && token_num < num_tokens)
+ PRVM_G_FLOAT(OFS_RETURN) = tokens_endpos[token_num];
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
+}
+
/*
=========
VM_isserver
if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet)))
PRVM_G_FLOAT(OFS_RETURN) = -1;
else
+ {
+ prog->opensearches_origin[handle] = PRVM_AllocationOrigin();
PRVM_G_FLOAT(OFS_RETURN) = handle;
+ }
}
/*
FS_FreeSearch(prog->opensearches[handle]);
prog->opensearches[handle] = NULL;
+ if(prog->opensearches_origin[handle])
+ PRVM_Free((char *)prog->opensearches_origin[handle]);
}
/*
{
if(prog->globaloffsets.drawfont >= 0)
{
- int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont);
+ int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont);
if(f < 0 || f >= MAX_FONTS)
return FONT_DEFAULT;
return &dp_fonts[f];
string = PRVM_G_STRING(OFS_PARM1);
pos = PRVM_G_VECTOR(OFS_PARM0);
scale = PRVM_G_VECTOR(OFS_PARM2);
- flag = (int)PRVM_G_FLOAT(OFS_PARM5);
+ flag = (int)PRVM_G_FLOAT(OFS_PARM4);
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0)));
}
+/*
+=========
+VM_findkeysforcommand
+
+string findkeysforcommand(string command)
+
+the returned string is an altstring
+=========
+*/
+#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
+
+void M_FindKeysForCommand(const char *command, int *keys);
+void VM_findkeysforcommand(void)
+{
+ const char *cmd;
+ char ret[VM_STRINGTEMP_LENGTH];
+ int keys[NUMKEYS];
+ int i;
+
+ VM_SAFEPARMCOUNT(1, VM_findkeysforcommand);
+
+ cmd = PRVM_G_STRING(OFS_PARM0);
+
+ VM_CheckEmptyString(cmd);
+
+ M_FindKeysForCommand(cmd, keys);
+
+ ret[0] = 0;
+ for(i = 0; i < NUMKEYS; i++)
+ strlcat(ret, va(" \'%i\'", keys[i]), sizeof(ret));
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(ret);
+}
+
/*
=========
VM_stringtokeynum
return;
}
- PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true);
+ PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, (keynum_t) key, eventtype ) == true);
}
/*
if( !instance ) {
return;
}
- CL_Gecko_Resize( instance, w, h );
+ CL_Gecko_Resize( instance, (int) w, (int) h );
}
stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
while (stringbuffer->max_strings <= strindex)
stringbuffer->max_strings *= 2;
- stringbuffer->strings = Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
+ stringbuffer->strings = (char **) Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
if (stringbuffer->num_strings > 0)
memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0]));
if (oldstrings)
prvm_stringbuffer_t *stringbuffer;
int i;
VM_SAFEPARMCOUNT(0, VM_buf_create);
- stringbuffer = Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
+ stringbuffer = (prvm_stringbuffer_t *) Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
+ stringbuffer->origin = PRVM_AllocationOrigin();
PRVM_G_FLOAT(OFS_RETURN) = i;
}
Mem_Free(stringbuffer->strings[i]);
if (stringbuffer->strings)
Mem_Free(stringbuffer->strings);
+ if(stringbuffer->origin)
+ PRVM_Free((char *)stringbuffer->origin);
Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer);
}
else
BufStr_Shrink(stringbuffer);
}
+
+
+
+
+
+
+void VM_buf_cvarlist(void)
+{
+ cvar_t *cvar;
+ const char *partial, *antipartial;
+ size_t len, antilen;
+ size_t alloclen;
+ qboolean ispattern, antiispattern;
+ int n;
+ prvm_stringbuffer_t *stringbuffer;
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_buf_cvarlist);
+
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
+ {
+ VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ return;
+ }
+
+ partial = PRVM_G_STRING(OFS_PARM1);
+ if(!partial)
+ len = 0;
+ else
+ len = strlen(partial);
+
+ if(prog->argc == 3)
+ antipartial = PRVM_G_STRING(OFS_PARM2);
+ else
+ antipartial = NULL;
+ if(!antipartial)
+ antilen = 0;
+ else
+ antilen = strlen(antipartial);
+
+ for (n = 0;n < stringbuffer->num_strings;n++)
+ if (stringbuffer->strings[n])
+ Mem_Free(stringbuffer->strings[n]);
+ if (stringbuffer->strings)
+ Mem_Free(stringbuffer->strings);
+ stringbuffer->strings = NULL;
+
+ ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
+ antiispattern = antipartial && (strchr(antipartial, '*') || strchr(antipartial, '?'));
+
+ n = 0;
+ for(cvar = cvar_vars; cvar; cvar = cvar->next)
+ {
+ if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
+ continue;
+
+ if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
+ continue;
+
+ ++n;
+ }
+
+ stringbuffer->max_strings = stringbuffer->num_strings = n;
+ if (stringbuffer->max_strings)
+ stringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(stringbuffer->strings[0]) * stringbuffer->max_strings);
+
+ n = 0;
+ for(cvar = cvar_vars; cvar; cvar = cvar->next)
+ {
+ if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
+ continue;
+
+ if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
+ continue;
+
+ alloclen = strlen(cvar->name) + 1;
+ stringbuffer->strings[n] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+ memcpy(stringbuffer->strings[n], cvar->name, alloclen);
+
+ ++n;
+ }
+}
+
+
+
+
//=============
/*
PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[0] = ANGLEMOD (current + move);
}
-// TODO: adapt all static function names to use a single naming convention... [12/3/2007 Black]
-static int Is_Text_Color (char c, char t)
-{
- int a = 0;
- char c2 = c - (c & 128);
- char t2 = t - (t & 128);
-
- if(c != STRING_COLOR_TAG && c2 != STRING_COLOR_TAG) return 0;
- if(t >= '0' && t <= '9') a = 1;
- if(t2 >= '0' && t2 <= '9') a = 1;
-/* if(t >= 'A' && t <= 'Z') a = 2;
- if(t2 >= 'A' && t2 <= 'Z') a = 2;
-
- if(a == 1 && scr_colortext.integer > 0)
- return 1;
- if(a == 2 && scr_multifonts.integer > 0)
- return 2;
-*/
- return a;
-}
void VM_uncolorstring (void)
{
- const char *in;
- char out[VM_STRINGTEMP_LENGTH];
- int k = 0, i = 0;
+ char szNewString[VM_STRINGTEMP_LENGTH];
+ const char *szString;
+ // Prepare Strings
VM_SAFEPARMCOUNT(1, VM_uncolorstring);
- in = PRVM_G_STRING(OFS_PARM0);
- VM_CheckEmptyString (in);
-
- while (in[k])
- {
- if(in[k+1])
- if(Is_Text_Color(in[k], in[k+1]) == 1/* || (in[k] == '&' && in[k+1] == 'r')*/)
- {
- k += 2;
- continue;
- }
- out[i] = in[k];
- ++k;
- ++i;
- }
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(out);
+ szString = PRVM_G_STRING(OFS_PARM0);
+ COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
+
}
// #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
VM_SAFEPARMCOUNTRANGE(2, 3, VM_strstrofs);
instr = PRVM_G_STRING(OFS_PARM0);
match = PRVM_G_STRING(OFS_PARM1);
- firstofs = (prog->argc > 2)?PRVM_G_FLOAT(OFS_PARM2):0;
+ firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0;
if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
{
VM_SAFEPARMCOUNTRANGE(3, 8, VM_strconv);
- ccase = PRVM_G_FLOAT(OFS_PARM0); //0 same, 1 lower, 2 upper
- redalpha = PRVM_G_FLOAT(OFS_PARM1); //0 same, 1 white, 2 red, 5 alternate, 6 alternate-alternate
- rednum = PRVM_G_FLOAT(OFS_PARM2); //0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
+ ccase = (int) PRVM_G_FLOAT(OFS_PARM0); //0 same, 1 lower, 2 upper
+ redalpha = (int) PRVM_G_FLOAT(OFS_PARM1); //0 same, 1 white, 2 red, 5 alternate, 6 alternate-alternate
+ rednum = (int) PRVM_G_FLOAT(OFS_PARM2); //0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
VM_VarString(3, (char *) resbuf, sizeof(resbuf));
len = strlen((char *) resbuf);
char destbuf[VM_STRINGTEMP_LENGTH];
int pad;
VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad);
- pad = PRVM_G_FLOAT(OFS_PARM0);
+ pad = (int) PRVM_G_FLOAT(OFS_PARM0);
VM_VarString(1, src, sizeof(src));
// note: < 0 = left padding, > 0 = right padding,
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest);
}
+// #502 string(string filename) whichpack (DP_QC_WHICHPACK)
+// returns the name of the pack containing a file, or "" if it is not in any pack (but local or non-existant)
+void VM_whichpack (void)
+{
+ const char *fn, *pack;
+
+ VM_SAFEPARMCOUNT(1, VM_whichpack);
+ fn = PRVM_G_STRING(OFS_PARM0);
+ pack = FS_WhichPack(fn);
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(pack ? pack : "");
+}
+
+typedef struct
+{
+ int prognr;
+ double starttime;
+ float id;
+ char buffer[MAX_INPUTLINE];
+}
+uri_to_prog_t;
+
+static void uri_to_string_callback(int status, size_t length_received, unsigned char *buffer, void *cbdata)
+{
+ uri_to_prog_t *handle = (uri_to_prog_t *) cbdata;
+
+ if(!PRVM_ProgLoaded(handle->prognr))
+ {
+ // curl reply came too late... so just drop it
+ Z_Free(handle);
+ return;
+ }
+
+ PRVM_SetProg(handle->prognr);
+ PRVM_Begin;
+ if((prog->starttime == handle->starttime) && (prog->funcoffsets.URI_Get_Callback))
+ {
+ if(length_received >= sizeof(handle->buffer))
+ length_received = sizeof(handle->buffer) - 1;
+ handle->buffer[length_received] = 0;
+
+ PRVM_G_FLOAT(OFS_PARM0) = handle->id;
+ PRVM_G_FLOAT(OFS_PARM1) = status;
+ PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(handle->buffer);
+ PRVM_ExecuteProgram(prog->funcoffsets.URI_Get_Callback, "QC function URI_Get_Callback is missing");
+ }
+ PRVM_End;
+
+ Z_Free(handle);
+}
+
+// uri_get() gets content from an URL and calls a callback "uri_get_callback" with it set as string; an unique ID of the transfer is returned
+// returns 1 on success, and then calls the callback with the ID, 0 or the HTTP status code, and the received data in a string
+void VM_uri_get (void)
+{
+ const char *url;
+ float id;
+ qboolean ret;
+ uri_to_prog_t *handle;
+
+ if(!prog->funcoffsets.URI_Get_Callback)
+ PRVM_ERROR("uri_get called by %s without URI_Get_Callback defined", PRVM_NAME);
+
+ VM_SAFEPARMCOUNT(2, VM_uri_get);
+
+ url = PRVM_G_STRING(OFS_PARM0);
+ id = PRVM_G_FLOAT(OFS_PARM1);
+ handle = (uri_to_prog_t *) Z_Malloc(sizeof(*handle)); // this can't be the prog's mem pool, as curl may call the callback later!
+
+ handle->prognr = PRVM_GetProgNr();
+ handle->starttime = prog->starttime;
+ handle->id = id;
+ ret = Curl_Begin_ToMemory(url, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
+ if(ret)
+ {
+ PRVM_G_INT(OFS_RETURN) = 1;
+ }
+ else
+ {
+ Z_Free(handle);
+ PRVM_G_INT(OFS_RETURN) = 0;
+ }
+}
+
+void VM_netaddress_resolve (void)
+{
+ const char *ip;
+ char normalized[128];
+ int port;
+ lhnetaddress_t addr;
+
+ VM_SAFEPARMCOUNTRANGE(1, 2, VM_netaddress_resolve);
+
+ ip = PRVM_G_STRING(OFS_PARM0);
+ port = 0;
+ if(prog->argc > 1)
+ port = (int) PRVM_G_FLOAT(OFS_PARM1);
+
+ if(LHNETADDRESS_FromString(&addr, ip, port) && LHNETADDRESS_ToString(&addr, normalized, sizeof(normalized), prog->argc > 1))
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(normalized);
+ else
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+}