// cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
// also applies here
+#include "quakedef.h"
+
#include "prvm_cmds.h"
+#include "libcurl.h"
#include <time.h>
+extern cvar_t prvm_backtraceforwarnings;
+
// LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
void VM_Warning(const char *fmt, ...)
{
va_list argptr;
char msg[MAX_INPUTLINE];
+ static double recursive = -1;
va_start(argptr,fmt);
dpvsnprintf(msg,sizeof(msg),fmt,argptr);
va_end(argptr);
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]
- //PRVM_PrintState();
+ 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
+ {
+ recursive = realtime;
+ PRVM_PrintState();
+ recursive = -1;
+ }
}
void VM_CheckEmptyString (const char *s)
{
- if (s[0] <= ' ')
+ if (ISWHITESPACE(s[0]))
PRVM_ERROR ("%s: Bad string", PRVM_NAME);
}
=================
VM_vectoangles
-vector vectoangles(vector)
+vector vectoangles(vector[, vector])
=================
*/
void VM_vectoangles (void)
{
- float *value1;
- float forward;
- float yaw, pitch;
-
- VM_SAFEPARMCOUNT(1,VM_vectoangles);
-
- value1 = PRVM_G_VECTOR(OFS_PARM0);
-
- if (value1[1] == 0 && value1[0] == 0)
- {
- yaw = 0;
- if (value1[2] > 0)
- pitch = 90;
- else
- pitch = 270;
- }
- else
- {
- // LordHavoc: optimized a bit
- if (value1[0])
- {
- yaw = (atan2(value1[1], value1[0]) * 180 / M_PI);
- if (yaw < 0)
- yaw += 360;
- }
- else if (value1[1] > 0)
- yaw = 90;
- else
- yaw = 270;
+ VM_SAFEPARMCOUNTRANGE(1, 2,VM_vectoangles);
- forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]);
- pitch = (atan2(value1[2], forward) * 180 / M_PI);
- if (pitch < 0)
- pitch += 360;
- }
-
- PRVM_G_FLOAT(OFS_RETURN+0) = pitch;
- PRVM_G_FLOAT(OFS_RETURN+1) = yaw;
- PRVM_G_FLOAT(OFS_RETURN+2) = 0;
+ AnglesFromVectors(PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_PARM0), prog->argc >= 2 ? PRVM_G_VECTOR(OFS_PARM1) : NULL, true);
}
/*
Cbuf_AddText(string);
}
+static qboolean PRVM_Cvar_ReadOk(const char *string)
+{
+ cvar_t *cvar;
+ cvar = Cvar_FindVar(string);
+ return ((cvar) && ((cvar->flags & CVAR_PRIVATE) == 0));
+}
+
/*
=================
VM_cvar
VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
VM_VarString(0, string, sizeof(string));
VM_CheckEmptyString(string);
- PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
+ PRVM_G_FLOAT(OFS_RETURN) = PRVM_Cvar_ReadOk(string) ? Cvar_VariableValue(string) : 0;
+}
+
+/*
+=================
+VM_cvar
+
+float cvar_type (string)
+float CVAR_TYPEFLAG_EXISTS = 1;
+float CVAR_TYPEFLAG_SAVED = 2;
+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)
+{
+ char string[VM_STRINGTEMP_LENGTH];
+ cvar_t *cvar;
+ int ret;
+
+ VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
+ VM_VarString(0, string, sizeof(string));
+ VM_CheckEmptyString(string);
+ cvar = Cvar_FindVar(string);
+
+
+ if(!cvar)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ return; // CVAR_TYPE_NONE
+ }
+
+ ret = 1; // CVAR_EXISTS
+ if(cvar->flags & CVAR_SAVE)
+ ret |= 2; // CVAR_TYPE_SAVED
+ if(cvar->flags & CVAR_PRIVATE)
+ ret |= 4; // CVAR_TYPE_PRIVATE
+ if(!(cvar->flags & CVAR_ALLOCATED))
+ ret |= 8; // CVAR_TYPE_ENGINE
+ 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_SAFEPARMCOUNTRANGE(1,8,VM_cvar_string);
VM_VarString(0, string, sizeof(string));
VM_CheckEmptyString(string);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableString(string));
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(PRVM_Cvar_ReadOk(string) ? Cvar_VariableString(string) : "");
}
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
v = PRVM_G_FLOAT(OFS_PARM0);
if ((float)((int)v) == v)
- sprintf(s, "%i", (int)v);
+ dpsnprintf(s, sizeof(s), "%i", (int)v);
else
- sprintf(s, "%f", v);
+ dpsnprintf(s, sizeof(s), "%f", v);
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
}
VM_SAFEPARMCOUNT(1,VM_vtos);
- sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
+ dpsnprintf (s, sizeof(s), "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
}
VM_SAFEPARMCOUNT(1, VM_etos);
- sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
+ dpsnprintf (s, sizeof(s), "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
}
PRVM_G_INT(OFS_RETURN) = ent;
}
+/*
+========================
+VM_etof
+
+float etof(entity ent)
+========================
+*/
+void VM_etof(void)
+{
+ VM_SAFEPARMCOUNT(1, VM_etof);
+ PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICTNUM(OFS_PARM0);
+}
+
/*
=========
VM_strftime
void VM_strftime(void)
{
time_t t;
+#if _MSC_VER >= 1400
+ struct tm tm;
+ int tmresult;
+#else
struct tm *tm;
+#endif
char fmt[VM_STRINGTEMP_LENGTH];
char result[VM_STRINGTEMP_LENGTH];
VM_SAFEPARMCOUNTRANGE(2, 8, VM_strftime);
VM_VarString(1, fmt, sizeof(fmt));
t = time(NULL);
+#if _MSC_VER >= 1400
+ if (PRVM_G_FLOAT(OFS_PARM0))
+ tmresult = localtime_s(&tm, &t);
+ else
+ tmresult = gmtime_s(&tm, &t);
+ if (!tmresult)
+#else
if (PRVM_G_FLOAT(OFS_PARM0))
tm = localtime(&t);
else
tm = gmtime(&t);
if (!tm)
+#endif
{
- PRVM_G_FLOAT(OFS_RETURN) = 0;
+ PRVM_G_INT(OFS_RETURN) = 0;
return;
}
+#if _MSC_VER >= 1400
+ strftime(result, sizeof(result), fmt, &tm);
+#else
strftime(result, sizeof(result), fmt, tm);
- PRVM_G_FLOAT(OFS_RETURN) = PRVM_SetTempString(result);
+#endif
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(result);
}
/*
int f;
const char *s, *t;
prvm_edict_t *ent, *chain;
+ int chainfield;
- VM_SAFEPARMCOUNT(2,VM_findchain);
+ VM_SAFEPARMCOUNTRANGE(2,3,VM_findchain);
- if (prog->fieldoffsets.chain < 0)
- PRVM_ERROR("VM_findchain: %s doesnt have a chain field !", PRVM_NAME);
+ if(prog->argc == 3)
+ chainfield = PRVM_G_INT(OFS_PARM2);
+ else
+ chainfield = prog->fieldoffsets.chain;
+ if (chainfield < 0)
+ PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
chain = prog->edicts;
if (strcmp(t,s))
continue;
- PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_NUM_FOR_EDICT(chain);
+ PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_NUM_FOR_EDICT(chain);
chain = ent;
}
int f;
float s;
prvm_edict_t *ent, *chain;
+ int chainfield;
- VM_SAFEPARMCOUNT(2, VM_findchainfloat);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainfloat);
- if (prog->fieldoffsets.chain < 0)
- PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !", PRVM_NAME);
+ if(prog->argc == 3)
+ chainfield = PRVM_G_INT(OFS_PARM2);
+ else
+ chainfield = prog->fieldoffsets.chain;
+ if (chainfield < 0)
+ PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
chain = (prvm_edict_t *)prog->edicts;
if (PRVM_E_FLOAT(ent,f) != s)
continue;
- PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
+ PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
chain = ent;
}
int f;
int s;
prvm_edict_t *ent, *chain;
+ int chainfield;
- VM_SAFEPARMCOUNT(2, VM_findchainflags);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainflags);
- if (prog->fieldoffsets.chain < 0)
- PRVM_ERROR("VM_findchainflags: %s doesnt have a chain field !", PRVM_NAME);
+ if(prog->argc == 3)
+ chainfield = PRVM_G_INT(OFS_PARM2);
+ else
+ chainfield = prog->fieldoffsets.chain;
+ if (chainfield < 0)
+ PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
chain = (prvm_edict_t *)prog->edicts;
if (!((int)PRVM_E_FLOAT(ent,f) & s))
continue;
- PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
+ PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
chain = ent;
}
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);
}
VM_SAFEPARMCOUNT(1,VM_fgets);
+ // set the return value regardless of any possible errors
+ PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+
filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
{
Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
if (c >= 0 || end)
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
- else
- PRVM_G_INT(OFS_RETURN) = OFS_NULL;
}
/*
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);
}
// returns a section of a string as a tempstring
void VM_substring(void)
{
- int i, start, length;
+ int start, length, slength;
const char *s;
char string[VM_STRINGTEMP_LENGTH];
s = PRVM_G_STRING(OFS_PARM0);
start = (int)PRVM_G_FLOAT(OFS_PARM1);
length = (int)PRVM_G_FLOAT(OFS_PARM2);
- for (i = 0;i < start && *s;i++, s++);
- for (i = 0;i < (int)sizeof(string) - 1 && *s && i < length;i++, s++)
- string[i] = *s;
- string[i] = 0;
+ slength = strlen(s);
+ if (length < 0) // FTE_STRINGS feature
+ length += slength - start;
+ if (start < 0) // FTE_STRINGS feature
+ start += slength;
+ start = bound(0, start, slength); // consistent with php 5.2.0 but not 5.2.3
+ length = min(length, (int)sizeof(string) - 1);
+ length = min(length, slength - start);
+ memcpy(string, s + start, length);
+ string[length] = 0;
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
+}
+
+/*
+=========
+VM_strreplace
+
+string(string search, string replace, string subject) strreplace = #484;
+=========
+*/
+// replaces all occurrences of search with replace in the string subject, and returns the result
+void VM_strreplace(void)
+{
+ int i, j, si;
+ const char *search, *replace, *subject;
+ char string[VM_STRINGTEMP_LENGTH];
+ int search_len, replace_len, subject_len;
+
+ VM_SAFEPARMCOUNT(3,VM_strreplace);
+
+ search = PRVM_G_STRING(OFS_PARM0);
+ replace = PRVM_G_STRING(OFS_PARM1);
+ subject = PRVM_G_STRING(OFS_PARM2);
+
+ search_len = (int)strlen(search);
+ replace_len = (int)strlen(replace);
+ subject_len = (int)strlen(subject);
+
+ si = 0;
+ for (i = 0; i < subject_len; i++)
+ {
+ for (j = 0; j < search_len && i+j < subject_len; j++)
+ if (subject[i+j] != search[j])
+ break;
+ if (j == search_len || i+j == subject_len)
+ {
+ // found it at offset 'i'
+ for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
+ string[si++] = replace[j];
+ i += search_len - 1;
+ }
+ else
+ {
+ // not found
+ if (si < (int)sizeof(string) - 1)
+ string[si++] = subject[i];
+ }
+ }
+ string[si] = '\0';
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
+}
+
+/*
+=========
+VM_strireplace
+
+string(string search, string replace, string subject) strireplace = #485;
+=========
+*/
+// case-insensitive version of strreplace
+void VM_strireplace(void)
+{
+ int i, j, si;
+ const char *search, *replace, *subject;
+ char string[VM_STRINGTEMP_LENGTH];
+ int search_len, replace_len, subject_len;
+
+ VM_SAFEPARMCOUNT(3,VM_strreplace);
+
+ search = PRVM_G_STRING(OFS_PARM0);
+ replace = PRVM_G_STRING(OFS_PARM1);
+ subject = PRVM_G_STRING(OFS_PARM2);
+
+ search_len = (int)strlen(search);
+ replace_len = (int)strlen(replace);
+ subject_len = (int)strlen(subject);
+
+ si = 0;
+ for (i = 0; i < subject_len; i++)
+ {
+ for (j = 0; j < search_len && i+j < subject_len; j++)
+ if (tolower(subject[i+j]) != tolower(search[j]))
+ break;
+ if (j == search_len || i+j == subject_len)
+ {
+ // found it at offset 'i'
+ for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
+ string[si++] = replace[j];
+ i += search_len - 1;
+ }
+ else
+ {
+ // not found
+ if (si < (int)sizeof(string) - 1)
+ string[si++] = subject[i];
+ }
+ }
+ string[si] = '\0';
+
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
}
//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[VM_STRINGTEMP_LENGTH / 2];
+static int tokens_startpos[VM_STRINGTEMP_LENGTH / 2];
+static int tokens_endpos[VM_STRINGTEMP_LENGTH / 2];
+static char tokenize_string[VM_STRINGTEMP_LENGTH];
void VM_tokenize (void)
{
const char *p;
VM_SAFEPARMCOUNT(1,VM_tokenize);
- p = PRVM_G_STRING(OFS_PARM0);
+ 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;
int numseparators;
int separatorlen[7];
const char *separators[7];
- const char *p;
+ const char *p, *p0;
const char *token;
char tokentext[MAX_INPUTLINE];
VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
- p = PRVM_G_STRING(OFS_PARM0);
+ 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;
+ p0 = p;
while (*p)
{
for (k = 0;k < numseparators;k++)
if (j < (int)sizeof(tokentext)-1)
tokentext[j++] = *p;
p++;
+ p0 = p;
}
+ tokens_endpos[num_tokens] = p0 - 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
{
VM_SAFEPARMCOUNT(0,VM_clientstate);
- PRVM_G_FLOAT(OFS_RETURN) = cls.state;
+
+ switch( cls.state ) {
+ case ca_uninitialized:
+ case ca_dedicated:
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ break;
+ case ca_disconnected:
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+ break;
+ case ca_connected:
+ PRVM_G_FLOAT(OFS_RETURN) = 2;
+ break;
+ default:
+ // should never be reached!
+ break;
+ }
}
/*
#endif
}
-/*
-=========
-VM_getmousepos
-
-vector getmousepos()
-=========
-*/
-void VM_getmousepos(void)
-{
-
- VM_SAFEPARMCOUNT(0,VM_getmousepos);
-
- PRVM_G_VECTOR(OFS_RETURN)[0] = in_mouse_x * vid_conwidth.integer / vid.width;
- PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y * vid_conheight.integer / vid.height;
- PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
-}
-
/*
=========
VM_gettime
float gettime(void)
=========
*/
+extern double host_starttime;
void VM_gettime(void)
{
- VM_SAFEPARMCOUNT(0,VM_gettime);
+ int timer_index;
+
+ VM_SAFEPARMCOUNTRANGE(0,1,VM_gettime);
- PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+ if(prog->argc == 0)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+ }
+ else
+ {
+ timer_index = (int) PRVM_G_FLOAT(OFS_PARM0);
+ switch(timer_index)
+ {
+ case 0: // GETTIME_FRAMESTART
+ PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+ break;
+ case 1: // GETTIME_REALTIME
+ PRVM_G_FLOAT(OFS_RETURN) = (float) Sys_DoubleTime();
+ break;
+ case 2: // GETTIME_HIRES
+ PRVM_G_FLOAT(OFS_RETURN) = (float) (Sys_DoubleTime() - realtime);
+ break;
+ case 3: // GETTIME_UPTIME
+ PRVM_G_FLOAT(OFS_RETURN) = (float) Sys_DoubleTime() - host_starttime;
+ break;
+ default:
+ VM_Warning("VM_gettime: %s: unsupported timer specified, returning realtime\n", PRVM_NAME);
+ PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+ break;
+ }
+ }
}
/*
data = PRVM_G_STRING(OFS_PARM1);
// parse the opening brace
- if (!COM_ParseToken_Simple(&data, false) || com_token[0] != '{' )
+ if (!COM_ParseToken_Simple(&data, false, false) || com_token[0] != '{' )
PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data );
PRVM_ED_ParseEdict (data, ent);
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]);
}
/*
VM_CheckEmptyString (s);
// AK Draw_CachePic is supposed to always return a valid pointer
- if( Draw_CachePic(s, false)->tex == r_texture_notexture )
+ if( Draw_CachePic_Flags(s, CACHEPICFLAG_NOTPERSISTENT)->tex == r_texture_notexture )
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
}
Draw_FreePic(s);
}
+dp_font_t *getdrawfont()
+{
+ if(prog->globaloffsets.drawfont >= 0)
+ {
+ int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont);
+ if(f < 0 || f >= MAX_FONTS)
+ return FONT_DEFAULT;
+ return &dp_fonts[f];
+ }
+ else
+ return FONT_DEFAULT;
+}
+
/*
=========
VM_drawcharacter
return;
}
- DrawQ_String (pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true);
+ DrawQ_String_Font(pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
if(pos[2] || scale[2])
Con_Printf("VM_drawstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
- DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true);
+ DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
+
+/*
+=========
+VM_drawcolorcodedstring
+
+float drawcolorcodedstring(vector position, string text, vector scale, float alpha, float flag)
+=========
+*/
+void VM_drawcolorcodedstring(void)
+{
+ float *pos,*scale;
+ const char *string;
+ int flag,color;
+ VM_SAFEPARMCOUNT(5,VM_drawstring);
+
+ string = PRVM_G_STRING(OFS_PARM1);
+ pos = PRVM_G_VECTOR(OFS_PARM0);
+ scale = PRVM_G_VECTOR(OFS_PARM2);
+ flag = (int)PRVM_G_FLOAT(OFS_PARM4);
+
+ if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawcolorcodedstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
+ return;
+ }
+
+ if(!scale[0] || !scale[1])
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_drawcolorcodedstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
+ return;
+ }
+
+ if(pos[2] || scale[2])
+ Con_Printf("VM_drawcolorcodedstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
+
+ color = -1;
+ DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont());
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
+/*
+=========
+VM_stringwidth
+
+float stringwidth(string text, float allowColorCodes)
+=========
+*/
+void VM_stringwidth(void)
+{
+ const char *string;
+ int colors;
+ VM_SAFEPARMCOUNT(2,VM_drawstring);
+
+ string = PRVM_G_STRING(OFS_PARM0);
+ colors = (int)PRVM_G_FLOAT(OFS_PARM1);
+
+ PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()); // 1x1 characters, don't actually draw
+}
/*
=========
VM_drawpic
if(pos[2] || size[2])
Con_Printf("VM_drawpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
- DrawQ_Pic(pos[0], pos[1], Draw_CachePic(picname, true), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
+ DrawQ_Pic(pos[0], pos[1], Draw_CachePic (picname), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
+/*
+=========
+VM_drawrotpic
+
+float drawrotpic(vector position, string pic, vector size, vector org, float angle, vector rgb, float alpha, float flag)
+=========
+*/
+void VM_drawrotpic(void)
+{
+ const char *picname;
+ float *size, *pos, *org, *rgb;
+ int flag;
+
+ VM_SAFEPARMCOUNT(8,VM_drawrotpic);
+
+ picname = PRVM_G_STRING(OFS_PARM1);
+ VM_CheckEmptyString (picname);
+
+ // is pic cached ? no function yet for that
+ if(!1)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_drawrotpic: %s: %s not cached !\n", PRVM_NAME, picname);
+ return;
+ }
+
+ pos = PRVM_G_VECTOR(OFS_PARM0);
+ size = PRVM_G_VECTOR(OFS_PARM2);
+ org = PRVM_G_VECTOR(OFS_PARM3);
+ rgb = PRVM_G_VECTOR(OFS_PARM5);
+ flag = (int) PRVM_G_FLOAT(OFS_PARM7);
+
+ if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawrotpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
+ return;
+ }
+
+ if(pos[2] || size[2] || org[2])
+ Con_Printf("VM_drawrotpic: z value from pos/size/org discarded\n");
+
+ DrawQ_RotPic(pos[0], pos[1], Draw_CachePic(picname), size[0], size[1], org[0], org[1], PRVM_G_FLOAT(OFS_PARM4), rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM6), flag);
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
+/*
+=========
+VM_drawsubpic
+
+float drawsubpic(vector position, vector size, string pic, vector srcPos, vector srcSize, vector rgb, float alpha, float flag)
+
+=========
+*/
+void VM_drawsubpic(void)
+{
+ const char *picname;
+ float *size, *pos, *rgb, *srcPos, *srcSize, alpha;
+ int flag;
+
+ VM_SAFEPARMCOUNT(8,VM_drawsubpic);
+
+ picname = PRVM_G_STRING(OFS_PARM2);
+ VM_CheckEmptyString (picname);
+
+ // is pic cached ? no function yet for that
+ if(!1)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_drawsubpic: %s: %s not cached !\n", PRVM_NAME, picname);
+ return;
+ }
+
+ pos = PRVM_G_VECTOR(OFS_PARM0);
+ size = PRVM_G_VECTOR(OFS_PARM1);
+ srcPos = PRVM_G_VECTOR(OFS_PARM3);
+ srcSize = PRVM_G_VECTOR(OFS_PARM4);
+ rgb = PRVM_G_VECTOR(OFS_PARM5);
+ alpha = PRVM_G_FLOAT(OFS_PARM6);
+ flag = (int) PRVM_G_FLOAT(OFS_PARM7);
+
+ if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawsubpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
+ return;
+ }
+
+ if(pos[2] || size[2])
+ Con_Printf("VM_drawsubpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+
+ DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic (picname),
+ size[0], size[1],
+ srcPos[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha,
+ srcPos[0] + srcSize[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha,
+ srcPos[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha,
+ srcPos[0] + srcSize[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha,
+ flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
p = PRVM_G_STRING(OFS_PARM0);
VM_CheckEmptyString (p);
- pic = Draw_CachePic (p, false);
+ pic = Draw_CachePic_Flags (p, CACHEPICFLAG_NOTPERSISTENT);
PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width;
PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height;
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
CL_RestartVideo( video );
}
+/*
+========================
+VM_Gecko_Init
+========================
+*/
+void VM_Gecko_Init( void ) {
+ // the prog struct is memset to 0 by Initprog? [12/6/2007 Black]
+ // FIXME: remove the other _Init functions then, too? [12/6/2007 Black]
+}
+
+/*
+========================
+VM_Gecko_Destroy
+========================
+*/
+void VM_Gecko_Destroy( void ) {
+ int i;
+ for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) {
+ clgecko_t **instance = &prog->opengeckoinstances[ i ];
+ if( *instance ) {
+ CL_Gecko_DestroyBrowser( *instance );
+ }
+ *instance = NULL;
+ }
+}
+
+/*
+========================
+VM_gecko_create
+
+float[bool] gecko_create( string name )
+========================
+*/
+void VM_gecko_create( void ) {
+ const char *name;
+ int i;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_create );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ // find an empty slot for this gecko browser..
+ for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) {
+ if( prog->opengeckoinstances[ i ] == NULL ) {
+ break;
+ }
+ }
+ if( i == PRVM_MAX_GECKOINSTANCES ) {
+ VM_Warning("VM_gecko_create: %s ran out of gecko handles (%i)\n", PRVM_NAME, PRVM_MAX_GECKOINSTANCES);
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ instance = prog->opengeckoinstances[ i ] = CL_Gecko_CreateBrowser( name, PRVM_GetProgNr() );
+ if( !instance ) {
+ // TODO: error handling [12/3/2007 Black]
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+ PRVM_G_FLOAT( OFS_RETURN ) = 1;
+}
+
+/*
+========================
+VM_gecko_destroy
+
+void gecko_destroy( string name )
+========================
+*/
+void VM_gecko_destroy( void ) {
+ const char *name;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_destroy );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_DestroyBrowser( instance );
+}
+
+/*
+========================
+VM_gecko_navigate
+
+void gecko_navigate( string name, string URI )
+========================
+*/
+void VM_gecko_navigate( void ) {
+ const char *name;
+ const char *URI;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 2, VM_gecko_navigate );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ URI = PRVM_G_STRING( OFS_PARM1 );
+ VM_CheckEmptyString( name );
+ VM_CheckEmptyString( URI );
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_NavigateToURI( instance, URI );
+}
+
+/*
+========================
+VM_gecko_keyevent
+
+float[bool] gecko_keyevent( string name, float key, float eventtype )
+========================
+*/
+void VM_gecko_keyevent( void ) {
+ const char *name;
+ unsigned int key;
+ clgecko_buttoneventtype_t eventtype;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_keyevent );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ key = (unsigned int) PRVM_G_FLOAT( OFS_PARM1 );
+ switch( (unsigned int) PRVM_G_FLOAT( OFS_PARM2 ) ) {
+ case 0:
+ eventtype = CLG_BET_DOWN;
+ break;
+ case 1:
+ eventtype = CLG_BET_UP;
+ break;
+ case 2:
+ eventtype = CLG_BET_PRESS;
+ break;
+ case 3:
+ eventtype = CLG_BET_DOUBLECLICK;
+ break;
+ default:
+ // TODO: console printf? [12/3/2007 Black]
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, (keynum_t) key, eventtype ) == true);
+}
+
+/*
+========================
+VM_gecko_movemouse
+
+void gecko_mousemove( string name, float x, float y )
+========================
+*/
+void VM_gecko_movemouse( void ) {
+ const char *name;
+ float x, y;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ x = PRVM_G_FLOAT( OFS_PARM1 );
+ y = PRVM_G_FLOAT( OFS_PARM2 );
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_Event_CursorMove( instance, x, y );
+}
+
+
+/*
+========================
+VM_gecko_resize
+
+void gecko_resize( string name, float w, float h )
+========================
+*/
+void VM_gecko_resize( void ) {
+ const char *name;
+ float w, h;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ w = PRVM_G_FLOAT( OFS_PARM1 );
+ h = PRVM_G_FLOAT( OFS_PARM2 );
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_Resize( instance, (int) w, (int) h );
+}
+
+
+/*
+========================
+VM_gecko_get_texture_extent
+
+vector gecko_get_texture_extent( string name )
+========================
+*/
+void VM_gecko_get_texture_extent( void ) {
+ const char *name;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_movemouse );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ PRVM_G_VECTOR(OFS_RETURN)[0] = 0;
+ PRVM_G_VECTOR(OFS_RETURN)[1] = 0;
+ return;
+ }
+ CL_Gecko_GetTextureExtent( instance,
+ PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_RETURN)+1 );
+}
+
+
+
/*
==============
VM_makevectors
DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags);
}
-
-
-
-
// float(float number, float quantity) bitshift (EXT_BITSHIFT)
void VM_bitshift (void)
{
// BufString functions
////////////////////////////////////////
//[515]: string buffers support
-#define MAX_QCSTR_BUFFERS 128
-#define MAX_QCSTR_STRINGS 1024
-
-typedef struct
-{
- int num_strings;
- char *strings[MAX_QCSTR_STRINGS];
-}qcstrbuffer_t;
-
-// FIXME: move stringbuffers to prog_t to allow multiple progs!
-static qcstrbuffer_t *qcstringbuffers[MAX_QCSTR_BUFFERS];
-static int num_qcstringbuffers;
-static int buf_sortpower;
-#define BUFSTR_BUFFER(a) (a>=MAX_QCSTR_BUFFERS) ? NULL : (qcstringbuffers[a])
-#define BUFSTR_ISFREE(a) (a<MAX_QCSTR_BUFFERS&&qcstringbuffers[a]&&qcstringbuffers[a]->num_strings<=0) ? 1 : 0
+static size_t stringbuffers_sortlength;
-static int BufStr_FindFreeBuffer (void)
+static void BufStr_Expand(prvm_stringbuffer_t *stringbuffer, int strindex)
{
- int i;
- if(num_qcstringbuffers == MAX_QCSTR_BUFFERS)
- return -1;
- for(i=0;i<MAX_QCSTR_BUFFERS;i++)
- if(!qcstringbuffers[i])
- {
- qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
- memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
- return i;
- }
- return -1;
+ if (stringbuffer->max_strings <= strindex)
+ {
+ char **oldstrings = stringbuffer->strings;
+ stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
+ while (stringbuffer->max_strings <= strindex)
+ stringbuffer->max_strings *= 2;
+ 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)
+ Mem_Free(oldstrings);
+ }
}
-static void BufStr_ClearBuffer (int index)
+static void BufStr_Shrink(prvm_stringbuffer_t *stringbuffer)
{
- qcstrbuffer_t *b = qcstringbuffers[index];
- int i;
+ // reduce num_strings if there are empty string slots at the end
+ while (stringbuffer->num_strings > 0 && stringbuffer->strings[stringbuffer->num_strings - 1] == NULL)
+ stringbuffer->num_strings--;
- if(b)
+ // if empty, free the string pointer array
+ if (stringbuffer->num_strings == 0)
{
- if(b->num_strings > 0)
- {
- for(i=0;i<b->num_strings;i++)
- if(b->strings[i])
- Z_Free(b->strings[i]);
- num_qcstringbuffers--;
- }
- Z_Free(qcstringbuffers[index]);
- qcstringbuffers[index] = NULL;
+ stringbuffer->max_strings = 0;
+ if (stringbuffer->strings)
+ Mem_Free(stringbuffer->strings);
+ stringbuffer->strings = NULL;
}
}
-static int BufStr_FindFreeString (qcstrbuffer_t *b)
-{
- int i;
- for(i=0;i<b->num_strings;i++)
- if(!b->strings[i] || !b->strings[i][0])
- return i;
- if(i == MAX_QCSTR_STRINGS) return -1;
- else return i;
-}
-
static int BufStr_SortStringsUP (const void *in1, const void *in2)
{
const char *a, *b;
b = *((const char **) in2);
if(!a[0]) return 1;
if(!b[0]) return -1;
- return strncmp(a, b, buf_sortpower);
+ return strncmp(a, b, stringbuffers_sortlength);
}
static int BufStr_SortStringsDOWN (const void *in1, const void *in2)
b = *((const char **) in2);
if(!a[0]) return 1;
if(!b[0]) return -1;
- return strncmp(b, a, buf_sortpower);
+ return strncmp(b, a, stringbuffers_sortlength);
}
/*
*/
void VM_buf_create (void)
{
+ prvm_stringbuffer_t *stringbuffer;
int i;
VM_SAFEPARMCOUNT(0, VM_buf_create);
- i = BufStr_FindFreeBuffer();
- if(i >= 0)
- num_qcstringbuffers++;
- //else
- //Con_Printf("VM_buf_create: buffers overflow in %s\n", PRVM_NAME);
+ 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;
}
*/
void VM_buf_del (void)
{
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(1, VM_buf_del);
- if(BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)))
- BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0));
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if (stringbuffer)
+ {
+ int i;
+ for (i = 0;i < stringbuffer->num_strings;i++)
+ if (stringbuffer->strings[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
{
VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
*/
void VM_buf_getsize (void)
{
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(1, VM_buf_getsize);
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
PRVM_G_FLOAT(OFS_RETURN) = -1;
VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
else
- PRVM_G_FLOAT(OFS_RETURN) = b->num_strings;
+ PRVM_G_FLOAT(OFS_RETURN) = stringbuffer->num_strings;
}
/*
*/
void VM_buf_copy (void)
{
- qcstrbuffer_t *b1, *b2;
- int i;
+ prvm_stringbuffer_t *srcstringbuffer, *dststringbuffer;
+ int i;
VM_SAFEPARMCOUNT(2, VM_buf_copy);
- b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b1)
+ srcstringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!srcstringbuffer)
{
VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
return;
}
- b2 = BUFSTR_BUFFER(i);
- if(!b2)
+ dststringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!dststringbuffer)
{
VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
return;
}
- BufStr_ClearBuffer(i);
- qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
- memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
- b2->num_strings = b1->num_strings;
+ for (i = 0;i < dststringbuffer->num_strings;i++)
+ if (dststringbuffer->strings[i])
+ Mem_Free(dststringbuffer->strings[i]);
+ if (dststringbuffer->strings)
+ Mem_Free(dststringbuffer->strings);
+ *dststringbuffer = *srcstringbuffer;
+ if (dststringbuffer->max_strings)
+ dststringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(dststringbuffer->strings[0]) * dststringbuffer->max_strings);
- for(i=0;i<b1->num_strings;i++)
- if(b1->strings[i] && b1->strings[i][0])
+ for (i = 0;i < dststringbuffer->num_strings;i++)
+ {
+ if (srcstringbuffer->strings[i])
{
size_t stringlen;
- stringlen = strlen(b1->strings[i]) + 1;
- b2->strings[i] = (char *)Z_Malloc(stringlen);
- if(!b2->strings[i])
- {
- VM_Warning("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
- break;
- }
- memcpy(b2->strings[i], b1->strings[i], stringlen);
+ stringlen = strlen(srcstringbuffer->strings[i]) + 1;
+ dststringbuffer->strings[i] = (char *)Mem_Alloc(prog->progs_mempool, stringlen);
+ memcpy(dststringbuffer->strings[i], srcstringbuffer->strings[i], stringlen);
}
+ }
}
/*
========================
VM_buf_sort
-sort buffer by beginnings of strings (sortpower defaults it's lenght)
+sort buffer by beginnings of strings (cmplength defaults it's length)
"backward == TRUE" means that sorting goes upside-down
-void buf_sort(float bufhandle, float sortpower, float backward) = #464;
+void buf_sort(float bufhandle, float cmplength, float backward) = #464;
========================
*/
void VM_buf_sort (void)
{
- qcstrbuffer_t *b;
- int i;
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(3, VM_buf_sort);
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
- if(b->num_strings <= 0)
+ if(stringbuffer->num_strings <= 0)
{
VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
- buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1);
- if(buf_sortpower <= 0)
- buf_sortpower = 99999999;
+ stringbuffers_sortlength = (int)PRVM_G_FLOAT(OFS_PARM1);
+ if(stringbuffers_sortlength <= 0)
+ stringbuffers_sortlength = 0x7FFFFFFF;
if(!PRVM_G_FLOAT(OFS_PARM2))
- qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsUP);
+ qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsUP);
else
- qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
+ qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
- for(i=b->num_strings-1;i>=0;i--) //[515]: delete empty lines
- if(b->strings)
- {
- if(b->strings[i][0])
- break;
- else
- {
- Z_Free(b->strings[i]);
- --b->num_strings;
- b->strings[i] = NULL;
- }
- }
- else
- --b->num_strings;
+ BufStr_Shrink(stringbuffer);
}
/*
*/
void VM_buf_implode (void)
{
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
char k[VM_STRINGTEMP_LENGTH];
const char *sep;
int i;
size_t l;
VM_SAFEPARMCOUNT(2, VM_buf_implode);
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
- if(!b)
+ if(!stringbuffer)
{
VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
- if(!b->num_strings)
+ if(!stringbuffer->num_strings)
return;
sep = PRVM_G_STRING(OFS_PARM1);
k[0] = 0;
- for(l=i=0;i<b->num_strings;i++)
- if(b->strings[i])
+ for(l = i = 0;i < stringbuffer->num_strings;i++)
+ {
+ if(stringbuffer->strings[i])
{
- l += (i > 0 ? strlen(sep) : 0) + strlen(b->strings[i]);
+ l += (i > 0 ? strlen(sep) : 0) + strlen(stringbuffer->strings[i]);
if (l >= sizeof(k) - 1)
break;
strlcat(k, sep, sizeof(k));
- strlcat(k, b->strings[i], sizeof(k));
+ strlcat(k, stringbuffer->strings[i], sizeof(k));
}
+ }
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(k);
}
*/
void VM_bufstr_get (void)
{
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
int strindex;
VM_SAFEPARMCOUNT(2, VM_bufstr_get);
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
VM_Warning("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
- if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
+ if (strindex < 0)
{
VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
- if(b->num_strings <= strindex)
- return;
- if(b->strings[strindex])
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(b->strings[strindex]);
+ if (strindex < stringbuffer->num_strings && stringbuffer->strings[strindex])
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(stringbuffer->strings[strindex]);
}
/*
*/
void VM_bufstr_set (void)
{
- int bufindex, strindex;
- qcstrbuffer_t *b;
+ int strindex;
+ prvm_stringbuffer_t *stringbuffer;
const char *news;
- size_t alloclen;
VM_SAFEPARMCOUNT(3, VM_bufstr_set);
- bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
- b = BUFSTR_BUFFER(bufindex);
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
- VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
- if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
+ if(strindex < 0 || strindex >= 1000000) // huge number of strings
{
VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
+
+ BufStr_Expand(stringbuffer, strindex);
+ stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
+
+ if(stringbuffer->strings[strindex])
+ Mem_Free(stringbuffer->strings[strindex]);
+ stringbuffer->strings[strindex] = NULL;
+
news = PRVM_G_STRING(OFS_PARM2);
- if(b->strings[strindex])
- Z_Free(b->strings[strindex]);
- alloclen = strlen(news) + 1;
- b->strings[strindex] = (char *)Z_Malloc(alloclen);
- memcpy(b->strings[strindex], news, alloclen);
+ if (news && news[0])
+ {
+ size_t alloclen = strlen(news) + 1;
+ stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+ memcpy(stringbuffer->strings[strindex], news, alloclen);
+ }
+
+ BufStr_Shrink(stringbuffer);
}
/*
========================
VM_bufstr_add
-adds string to buffer in nearest free slot and returns it
+adds string to buffer in first free slot and returns its index
"order == TRUE" means that string will be added after last "full" slot
float bufstr_add(float bufhandle, string str, float order) = #467;
========================
*/
void VM_bufstr_add (void)
{
- int bufindex, order, strindex;
- qcstrbuffer_t *b;
+ int order, strindex;
+ prvm_stringbuffer_t *stringbuffer;
const char *string;
size_t alloclen;
VM_SAFEPARMCOUNT(3, VM_bufstr_add);
- bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
- b = BUFSTR_BUFFER(bufindex);
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
PRVM_G_FLOAT(OFS_RETURN) = -1;
- if(!b)
+ if(!stringbuffer)
{
- VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
string = PRVM_G_STRING(OFS_PARM1);
+ if(!string || !string[0])
+ {
+ VM_Warning("VM_bufstr_add: can not add an empty string to buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ return;
+ }
order = (int)PRVM_G_FLOAT(OFS_PARM2);
if(order)
- strindex = b->num_strings;
+ strindex = stringbuffer->num_strings;
else
- {
- strindex = BufStr_FindFreeString(b);
- if(strindex < 0)
- {
- VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
- return;
- }
- }
+ for (strindex = 0;strindex < stringbuffer->num_strings;strindex++)
+ if (stringbuffer->strings[strindex] == NULL)
+ break;
- while(b->num_strings <= strindex)
- {
- if(b->num_strings == MAX_QCSTR_STRINGS)
- {
- VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
- return;
- }
- b->strings[b->num_strings] = NULL;
- b->num_strings++;
- }
- if(b->strings[strindex])
- Z_Free(b->strings[strindex]);
+ BufStr_Expand(stringbuffer, strindex);
+
+ stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
alloclen = strlen(string) + 1;
- b->strings[strindex] = (char *)Z_Malloc(alloclen);
- memcpy(b->strings[strindex], string, alloclen);
+ stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+ memcpy(stringbuffer->strings[strindex], string, alloclen);
+
PRVM_G_FLOAT(OFS_RETURN) = strindex;
}
void VM_bufstr_free (void)
{
int i;
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(2, VM_bufstr_free);
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b)
+ 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;
}
i = (int)PRVM_G_FLOAT(OFS_PARM1);
- if(i < 0 || i > MAX_QCSTR_STRINGS)
+ if(i < 0)
{
VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
return;
}
- if(b->strings[i])
- Z_Free(b->strings[i]);
- b->strings[i] = NULL;
- if(i+1 == b->num_strings)
- --b->num_strings;
+
+ if (i < stringbuffer->num_strings)
+ {
+ if(stringbuffer->strings[i])
+ Mem_Free(stringbuffer->strings[i]);
+ stringbuffer->strings[i] = NULL;
+ }
+
+ 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;
+ }
}
+
+
+
//=============
/*
}
-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,
}
}
+// #494 float(float caseinsensitive, string s, ...) crc16
+void VM_crc16(void)
+{
+ float insensitive;
+ static char s[VM_STRINGTEMP_LENGTH];
+ VM_SAFEPARMCOUNTRANGE(2, 8, VM_hash);
+ insensitive = PRVM_G_FLOAT(OFS_PARM0);
+ VM_VarString(1, s, sizeof(s));
+ PRVM_G_FLOAT(OFS_RETURN) = (unsigned short) ((insensitive ? CRC_Block_CaseInsensitive : CRC_Block) ((unsigned char *) s, strlen(s)));
+}
+
void VM_wasfreed (void)
{
VM_SAFEPARMCOUNT(1, VM_wasfreed);
// only init the stuff for the current prog
VM_Files_Init();
VM_Search_Init();
+ VM_Gecko_Init();
// VM_BufStr_Init();
}
CL_PurgeOwner( MENUOWNER );
VM_Search_Reset();
VM_Files_CloseAll();
+ VM_Gecko_Destroy();
// VM_BufStr_ShutDown();
}
+// #510 string(string input, ...) uri_escape (DP_QC_URI_ESCAPE)
+// does URI escaping on a string (replace evil stuff by %AB escapes)
+void VM_uri_escape (void)
+{
+ char src[VM_STRINGTEMP_LENGTH];
+ char dest[VM_STRINGTEMP_LENGTH];
+ char *p, *q;
+ static const char *hex = "0123456789ABCDEF";
+
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_escape);
+ VM_VarString(0, src, sizeof(src));
+
+ for(p = src, q = dest; *p && q < dest + sizeof(dest) - 3; ++p)
+ {
+ if((*p >= 'A' && *p <= 'Z')
+ || (*p >= 'a' && *p <= 'z')
+ || (*p >= '0' && *p <= '9')
+ || (*p == '-') || (*p == '_') || (*p == '.')
+ || (*p == '!') || (*p == '~') || (*p == '*')
+ || (*p == '\'') || (*p == '(') || (*p == ')'))
+ *q++ = *p;
+ else
+ {
+ *q++ = '%';
+ *q++ = hex[(*(unsigned char *)p >> 4) & 0xF];
+ *q++ = hex[ *(unsigned char *)p & 0xF];
+ }
+ }
+ *q++ = 0;
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest);
+}
+
+// #510 string(string input, ...) uri_unescape (DP_QC_URI_ESCAPE)
+// does URI unescaping on a string (get back the evil stuff)
+void VM_uri_unescape (void)
+{
+ char src[VM_STRINGTEMP_LENGTH];
+ char dest[VM_STRINGTEMP_LENGTH];
+ char *p, *q;
+ int hi, lo;
+
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_unescape);
+ VM_VarString(0, src, sizeof(src));
+
+ for(p = src, q = dest; *p; ) // no need to check size, because unescape can't expand
+ {
+ if(*p == '%')
+ {
+ if(p[1] >= '0' && p[1] <= '9')
+ hi = p[1] - '0';
+ else if(p[1] >= 'a' && p[1] <= 'f')
+ hi = p[1] - 'a' + 10;
+ else if(p[1] >= 'A' && p[1] <= 'F')
+ hi = p[1] - 'A' + 10;
+ else
+ goto nohex;
+ if(p[2] >= '0' && p[2] <= '9')
+ lo = p[2] - '0';
+ else if(p[2] >= 'a' && p[2] <= 'f')
+ lo = p[2] - 'a' + 10;
+ else if(p[2] >= 'A' && p[2] <= 'F')
+ lo = p[2] - 'A' + 10;
+ else
+ goto nohex;
+ if(hi != 0 || lo != 0) // don't unescape NUL bytes
+ *q++ = (char) (hi * 0x10 + lo);
+ p += 3;
+ continue;
+ }
+
+nohex:
+ // otherwise:
+ *q++ = *p++;
+ }
+ *q++ = 0;
+
+ 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("");
+}
projects / xonotic / darkplaces.git / blobdiff