PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
}
+/*
+=================
+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;
+=================
+*/
+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(strcmp(cvar->description, "custom cvar")) // has to match Cvar_Get's placeholder string
+ ret |= 16; // CVAR_TYPE_HASDESCRIPTION
+
+ PRVM_G_FLOAT(OFS_RETURN) = ret;
+}
+
/*
=================
VM_cvar_string
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);
}
/*
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)) ) ? 1.0f : 0.0f;
+}
+
/*
=========
VM_strlen
#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
// 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);
+}
+