if (prog->globaloffsets.self >= 0)
{
ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict);
- PRVM_ED_Print(ed);
+ PRVM_ED_Print(ed, NULL);
}
PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
if (prog->globaloffsets.self >= 0)
{
ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict);
- PRVM_ED_Print(ed);
+ PRVM_ED_Print(ed, NULL);
PRVM_ED_Free (ed);
}
*/
void VM_cvar (void)
{
- VM_SAFEPARMCOUNT(1,VM_cvar);
-
- PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(PRVM_G_STRING(OFS_PARM0));
+ char string[VM_STRINGTEMP_LENGTH];
+ VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
+ VM_VarString(0, string, sizeof(string));
+ VM_CheckEmptyString(string);
+ PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
}
/*
=================
VM_cvar_string
-const string VM_cvar_string (string)
+const string VM_cvar_string (string, ...)
=================
*/
void VM_cvar_string(void)
{
- const char *name;
- VM_SAFEPARMCOUNT(1,VM_cvar_string);
-
- name = PRVM_G_STRING(OFS_PARM0);
-
- VM_CheckEmptyString(name);
-
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableString(name));
+ char string[VM_STRINGTEMP_LENGTH];
+ 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));
}
========================
VM_cvar_defstring
-const string VM_cvar_defstring (string)
+const string VM_cvar_defstring (string, ...)
========================
*/
void VM_cvar_defstring (void)
{
- const char *name;
- VM_SAFEPARMCOUNT(1,VM_cvar_string);
-
- name = PRVM_G_STRING(OFS_PARM0);
-
- VM_CheckEmptyString(name);
-
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(name));
+ char string[VM_STRINGTEMP_LENGTH];
+ VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_defstring);
+ VM_VarString(0, string, sizeof(string));
+ VM_CheckEmptyString(string);
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(string));
}
/*
=================
VM_cvar_set
-void cvar_set (string,string)
+void cvar_set (string,string, ...)
=================
*/
void VM_cvar_set (void)
{
- VM_SAFEPARMCOUNT(2,VM_cvar_set);
-
- Cvar_Set(PRVM_G_STRING(OFS_PARM0), PRVM_G_STRING(OFS_PARM1));
+ const char *name;
+ char string[VM_STRINGTEMP_LENGTH];
+ VM_SAFEPARMCOUNTRANGE(2,8,VM_cvar_set);
+ VM_VarString(1, string, sizeof(string));
+ name = PRVM_G_STRING(OFS_PARM0);
+ VM_CheckEmptyString(name);
+ Cvar_Set(name, string);
}
/*
}
else
PRVM_ED_Free (ed);
-// if (ed == prog->edicts)
-// PRVM_ERROR ("remove: tried to remove world");
-// if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients)
-// Host_Error("remove: tried to remove a client");
}
/*
{
VM_SAFEPARMCOUNT(1,VM_eprint);
- PRVM_ED_PrintNum (PRVM_G_EDICTNUM(OFS_PARM0));
+ PRVM_ED_PrintNum (PRVM_G_EDICTNUM(OFS_PARM0), NULL);
}
/*
PRVM_G_FLOAT(OFS_RETURN) = nCnt;
}
+// DRESK - String to Uppercase and Lowercase
+/*
+=========
+VM_strtolower
+
+string strtolower(string s)
+=========
+*/
+// string (string s) strtolower = #480; // returns passed in string in lowercase form
+void VM_strtolower(void)
+{
+ char szNewString[VM_STRINGTEMP_LENGTH];
+ const char *szString;
+
+ // Prepare Strings
+ VM_SAFEPARMCOUNT(1,VM_strtolower);
+ szString = PRVM_G_STRING(OFS_PARM0);
+
+ COM_ToLowerString(szString, szNewString, sizeof(szNewString) );
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
+}
+
+/*
+=========
+VM_strtoupper
+
+string strtoupper(string s)
+=========
+*/
+// string (string s) strtoupper = #481; // returns passed in string in uppercase form
+void VM_strtoupper(void)
+{
+ char szNewString[VM_STRINGTEMP_LENGTH];
+ const char *szString;
+
+ // Prepare Strings
+ VM_SAFEPARMCOUNT(1,VM_strtoupper);
+ szString = PRVM_G_STRING(OFS_PARM0);
+
+ COM_ToUpperString(szString, szNewString, sizeof(szNewString) );
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
+}
+
/*
=========
VM_strcat
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);
+
+ 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)
+ {
+ // 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);
+
+ 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)
+ {
+ // 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_stov
p = PRVM_G_STRING(OFS_PARM0);
num_tokens = 0;
- while(COM_ParseToken(&p, false))
+ while(COM_ParseToken_VM_Tokenize(&p, false))
{
if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
break;
int separatorlen[7];
const char *separators[7];
const char *p;
+ const char *token;
char tokentext[MAX_INPUTLINE];
VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
for (j = 1;j < prog->argc;j++)
{
// skip any blank separator strings
- if (!PRVM_G_STRING(OFS_PARM0 + j)[0])
+ const char *s = PRVM_G_STRING(OFS_PARM0+j*3);
+ if (!s[0])
continue;
- separators[numseparators] = PRVM_G_STRING(OFS_PARM0 + j);
- separatorlen[numseparators] = strlen(separators[numseparators]);
+ separators[numseparators] = s;
+ separatorlen[numseparators] = strlen(s);
numseparators++;
}
num_tokens = 0;
- for (num_tokens = 0;num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0]));num_tokens++)
+ j = 0;
+
+ while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0])))
{
+ token = tokentext + j;
while (*p)
{
for (k = 0;k < numseparators;k++)
}
if (k < numseparators)
break;
- if (j < (int)sizeof(tokentext[MAX_INPUTLINE]-1))
+ if (j < (int)sizeof(tokentext)-1)
tokentext[j++] = *p;
p++;
}
- tokentext[j] = 0;
- tokens[num_tokens] = PRVM_SetTempString(tokentext);
+ if (j >= (int)sizeof(tokentext))
+ break;
+ tokentext[j++] = 0;
+ tokens[num_tokens++] = PRVM_SetTempString(token);
if (!*p)
break;
}
VM_SAFEPARMCOUNT(2, VM_parseentitydata);
- // get edict and test it
+ // get edict and test it
ent = PRVM_G_EDICT(OFS_PARM0);
if (ent->priv.required->free)
PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
data = PRVM_G_STRING(OFS_PARM1);
- // parse the opening brace
- if (!COM_ParseTokenConsole(&data) || com_token[0] != '{' )
+ // parse the opening brace
+ 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);
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);
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_PARM5);
+
+ 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 (pos[0], pos[1], string, 0, scale[0], scale[1], 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false);
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
/*
=========
VM_drawpic
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(out);
}
+// #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
+//strstr, without generating a new string. Use in conjunction with FRIK_FILE's substring for more similar strstr.
+void VM_strstrofs (void)
+{
+ const char *instr, *match;
+ int firstofs;
+ 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;
+
+ if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
+ return;
+ }
+
+ match = strstr(instr+firstofs, match);
+ if (!match)
+ PRVM_G_FLOAT(OFS_RETURN) = -1;
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = match - instr;
+}
+
//#222 string(string s, float index) str2chr (FTE_STRINGS)
void VM_str2chr (void)
{
const char *s;
VM_SAFEPARMCOUNT(2, VM_str2chr);
s = PRVM_G_STRING(OFS_PARM0);
- if((unsigned)PRVM_G_FLOAT(OFS_PARM1) > strlen(s))
- return;
- PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(int)PRVM_G_FLOAT(OFS_PARM1)];
+ if((unsigned)PRVM_G_FLOAT(OFS_PARM1) < strlen(s))
+ PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(unsigned)PRVM_G_FLOAT(OFS_PARM1)];
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
}
//#223 string(float c, ...) chr2str (FTE_STRINGS)
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
}
+static int chrconv_number(int i, int base, int conv)
+{
+ i -= base;
+ switch (conv)
+ {
+ default:
+ case 5:
+ case 6:
+ case 0:
+ break;
+ case 1:
+ base = '0';
+ break;
+ case 2:
+ base = '0'+128;
+ break;
+ case 3:
+ base = '0'-30;
+ break;
+ case 4:
+ base = '0'+128-30;
+ break;
+ }
+ return i + base;
+}
+static int chrconv_punct(int i, int base, int conv)
+{
+ i -= base;
+ switch (conv)
+ {
+ default:
+ case 0:
+ break;
+ case 1:
+ base = 0;
+ break;
+ case 2:
+ base = 128;
+ break;
+ }
+ return i + base;
+}
+
+static int chrchar_alpha(int i, int basec, int baset, int convc, int convt, int charnum)
+{
+ //convert case and colour seperatly...
+
+ i -= baset + basec;
+ switch (convt)
+ {
+ default:
+ case 0:
+ break;
+ case 1:
+ baset = 0;
+ break;
+ case 2:
+ baset = 128;
+ break;
+
+ case 5:
+ case 6:
+ baset = 128*((charnum&1) == (convt-5));
+ break;
+ }
+
+ switch (convc)
+ {
+ default:
+ case 0:
+ break;
+ case 1:
+ basec = 'a';
+ break;
+ case 2:
+ basec = 'A';
+ break;
+ }
+ return i + basec + baset;
+}
+// #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
+//bulk convert a string. change case or colouring.
+void VM_strconv (void)
+{
+ int ccase, redalpha, rednum, len, i;
+ unsigned char resbuf[VM_STRINGTEMP_LENGTH];
+ unsigned char *result = resbuf;
+
+ 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
+ VM_VarString(3, (char *) resbuf, sizeof(resbuf));
+ len = strlen((char *) resbuf);
+
+ for (i = 0; i < len; i++, result++) //should this be done backwards?
+ {
+ if (*result >= '0' && *result <= '9') //normal numbers...
+ *result = chrconv_number(*result, '0', rednum);
+ else if (*result >= '0'+128 && *result <= '9'+128)
+ *result = chrconv_number(*result, '0'+128, rednum);
+ else if (*result >= '0'+128-30 && *result <= '9'+128-30)
+ *result = chrconv_number(*result, '0'+128-30, rednum);
+ else if (*result >= '0'-30 && *result <= '9'-30)
+ *result = chrconv_number(*result, '0'-30, rednum);
+
+ else if (*result >= 'a' && *result <= 'z') //normal numbers...
+ *result = chrchar_alpha(*result, 'a', 0, ccase, redalpha, i);
+ else if (*result >= 'A' && *result <= 'Z') //normal numbers...
+ *result = chrchar_alpha(*result, 'A', 0, ccase, redalpha, i);
+ else if (*result >= 'a'+128 && *result <= 'z'+128) //normal numbers...
+ *result = chrchar_alpha(*result, 'a', 128, ccase, redalpha, i);
+ else if (*result >= 'A'+128 && *result <= 'Z'+128) //normal numbers...
+ *result = chrchar_alpha(*result, 'A', 128, ccase, redalpha, i);
+
+ else if ((*result & 127) < 16 || !redalpha) //special chars..
+ *result = *result;
+ else if (*result < 128)
+ *result = chrconv_punct(*result, 0, redalpha);
+ else
+ *result = chrconv_punct(*result, 128, redalpha);
+ }
+ *result = '\0';
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString((char *) resbuf);
+}
+
+// #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
+void VM_strpad (void)
+{
+ char src[VM_STRINGTEMP_LENGTH];
+ char destbuf[VM_STRINGTEMP_LENGTH];
+ int pad;
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad);
+ pad = PRVM_G_FLOAT(OFS_PARM0);
+ VM_VarString(1, src, sizeof(src));
+
+ // note: < 0 = left padding, > 0 = right padding,
+ // this is reverse logic of printf!
+ dpsnprintf(destbuf, sizeof(destbuf), "%*s", -pad, src);
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(destbuf);
+}
+
+// #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
+//uses qw style \key\value strings
+void VM_infoadd (void)
+{
+ const char *info, *key;
+ char value[VM_STRINGTEMP_LENGTH];
+ char temp[VM_STRINGTEMP_LENGTH];
+
+ VM_SAFEPARMCOUNTRANGE(2, 8, VM_infoadd);
+ info = PRVM_G_STRING(OFS_PARM0);
+ key = PRVM_G_STRING(OFS_PARM1);
+ VM_VarString(2, value, sizeof(value));
+
+ strlcpy(temp, info, VM_STRINGTEMP_LENGTH);
+
+ InfoString_SetValue(temp, VM_STRINGTEMP_LENGTH, key, value);
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(temp);
+}
+
+// #227 string(string info, string key) infoget (FTE_STRINGS)
+//uses qw style \key\value strings
+void VM_infoget (void)
+{
+ const char *info;
+ const char *key;
+ char value[VM_STRINGTEMP_LENGTH];
+
+ VM_SAFEPARMCOUNT(2, VM_infoget);
+ info = PRVM_G_STRING(OFS_PARM0);
+ key = PRVM_G_STRING(OFS_PARM1);
+
+ InfoString_GetValue(info, key, value, VM_STRINGTEMP_LENGTH);
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(value);
+}
+
//#228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
+// also float(string s1, string s2) strcmp (FRIK_FILE)
void VM_strncmp (void)
{
const char *s1, *s2;
- VM_SAFEPARMCOUNT(1, VM_strncmp);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_strncmp);
+ s1 = PRVM_G_STRING(OFS_PARM0);
+ s2 = PRVM_G_STRING(OFS_PARM1);
+ if (prog->argc > 2)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = strncmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2));
+ }
+ else
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = strcmp(s1, s2);
+ }
+}
+
+// #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
+// #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
+void VM_strncasecmp (void)
+{
+ const char *s1, *s2;
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_strncasecmp);
s1 = PRVM_G_STRING(OFS_PARM0);
s2 = PRVM_G_STRING(OFS_PARM1);
- PRVM_G_FLOAT(OFS_RETURN) = strncmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2));
+ if (prog->argc > 2)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = strncasecmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2));
+ }
+ else
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = strcasecmp(s1, s2);
+ }
}
void VM_wasfreed (void)
projects / xonotic / darkplaces.git / blobdiff