void setvariablevalue(svariable_t *v, svalue_t newvalue)
{
if(killscript) return; // protect the variables when killing script
if(!v) return;
if(v->type == svt_const)
{
// const adapts to the value it is set to
v->type = newvalue.type;
// alloc memory for string
if(v->type == svt_string) // static incase a global_script var
v->value.s = Z_Malloc(128, PU_STATIC, 0);
}
if(v->type == svt_int)
v->value.i = intvalue(newvalue);
if(v->type == svt_string)
strcpy(v->value.s, stringvalue(newvalue));
if(v->type == svt_fixed)
v->value.fixed = fixedvalue(newvalue);
if(v->type == svt_mobj)
v->value.mobj = MobjForSvalue(newvalue);
if(v->type == svt_pInt)
*v->value.pI = intvalue(newvalue);
if(v->type == svt_pString)
{
// free old value
free(*v->value.pS);
// dup new string
*v->value.pS = strdup(stringvalue(newvalue));
}
if(v->type == svt_pFixed)
*v->value.pFixed = fixedvalue(newvalue);
if(v->type == svt_pMobj)
*v->value.pMobj = MobjForSvalue(newvalue);
if(v->type == svt_function)
script_error("attempt to set function to a value\n");
}
// set a variable to a value from an svalue_t
void svariable_t::setvalue(svalue_t newvalue)
{
if (killscript) return; // protect the variables when killing script
if (type == svt_const)
{
// const adapts to the value it is set to
type = newvalue.type;
// alloc memory for string
if(type == svt_string) // static incase a global_script var
value.s = (char *)Z_Malloc(256, PU_STATIC, 0);
}
switch (type)
{
case svt_int:
value.i = intvalue(newvalue);
break;
case svt_string:
strcpy(value.s, stringvalue(newvalue));
break;
case svt_fixed:
value.i = fixedvalue(newvalue).value();
break;
case svt_actor:
value.mobj = MobjForSvalue(newvalue);
break;
case svt_pInt:
*value.pI = intvalue(newvalue);
break;
case svt_pString:
// free old value
free(*value.pS);
// dup new string
*value.pS = strdup(stringvalue(newvalue));
break;
case svt_pFixed:
*value.pFixed = fixedvalue(newvalue);
break;
case svt_pActor:
*value.pMobj = MobjForSvalue(newvalue);
break;
case svt_function:
script_error("attempt to set function to a value\n");
}
}
void spn_value_print(const SpnValue *val)
{
switch (valtype(val)) {
case SPN_TTAG_NIL: {
fputs("nil", stdout);
break;
}
case SPN_TTAG_BOOL: {
fputs(boolvalue(val) ? "true" : "false", stdout);
break;
}
case SPN_TTAG_NUMBER: {
if (isfloat(val)) {
printf("%.*g", DBL_DIG, floatvalue(val));
} else {
printf("%ld", intvalue(val));
}
break;
}
case SPN_TTAG_STRING: {
SpnString *s = stringvalue(val);
fputs(s->cstr, stdout);
break;
}
case SPN_TTAG_ARRAY: {
SpnArray *array = objvalue(val);
print_array(array, 0);
break;
}
case SPN_TTAG_HASHMAP: {
SpnHashMap *hashmap = objvalue(val);
print_hashmap(hashmap, 0);
break;
}
case SPN_TTAG_FUNC: {
SpnFunction *func = funcvalue(val);
void *p;
if (func->native) {
p = (void *)(ptrdiff_t)(func->repr.fn);
} else {
p = func->repr.bc;
}
printf("<function %p>", p);
break;
}
case SPN_TTAG_USERINFO: {
void *ptr = isobject(val) ? objvalue(val) : ptrvalue(val);
printf("<userinfo %p>", ptr);
break;
}
default:
SHANT_BE_REACHED();
break;
}
}
const char *spn_dbg_get_filename(SpnHashMap *debug_info)
{
if (debug_info) {
SpnValue fname = spn_hashmap_get_strkey(debug_info, "file");
if (isstring(&fname)) {
return stringvalue(&fname)->cstr;
}
}
return "???";
}
void DFsVariable::SetValue(FLevelLocals *Level, const svalue_t &newvalue)
{
if(type == svt_const)
{
// const adapts to the value it is set to
type = newvalue.type;
}
switch (type)
{
case svt_int:
value.i = intvalue(newvalue);
break;
case svt_string:
if (newvalue.type == svt_string)
{
string = newvalue.string;
}
else
{
string = stringvalue(newvalue);
}
break;
case svt_fixed:
value.fixed = fixedvalue(newvalue);
break;
case svt_mobj:
actor = actorvalue(Level, newvalue);
break;
case svt_pInt:
*value.pI = intvalue(newvalue);
break;
case svt_pMobj:
*value.pMobj = actorvalue(Level, newvalue);
break;
case svt_function:
script_error("attempt to set function to a value\n");
break;
default:
script_error("invalid variable type\n");
break;
}
}
/* returns zero on success, nonzero on error */
static int append_format(
struct string_builder *bld,
const struct format_args *args,
void *argv,
int *argidx,
int isval,
char **errmsg
)
{
switch (args->spec) {
case '%':
append_string(bld, "%", 1);
break;
case 's': {
const char *str;
size_t len;
if (isval) {
SpnString *strobj;
/* must be a string */
SpnValue *val = getarg_val(argv, argidx);
if (!isstring(val)) {
format_errmsg(
errmsg,
TYPE_MISMATCH,
*argidx,
SPN_TYPE_STRING,
val->type
);
return -1;
}
strobj = stringvalue(val);
str = strobj->cstr;
len = strobj->len;
} else {
str = getarg_raw(argv, argidx);
len = strlen(str);
}
if (args->precision >= 0 && args->precision < len) {
len = args->precision;
}
if (args->width >= 0 && args->width > len) {
size_t pad = args->width - len;
expand_buffer(bld, pad);
while (pad-- > 0) {
bld->buf[bld->len++] = ' ';
}
}
append_string(bld, str, len);
break;
}
case 'i':
case 'd':
case 'b':
case 'o':
case 'u':
case 'x':
case 'X': {
char *buf, *end, *begin;
size_t len = PR_LONG_DIGITS;
enum format_flags flags = args->flags;
unsigned base = base_for_specifier(args->spec);
long n;
unsigned long u;
if (isval) {
/* must be a number */
SpnValue *val = getarg_val(argv, argidx);
if (!isnum(val)) {
format_errmsg(
errmsg,
TYPE_MISMATCH,
*argidx,
SPN_TTAG_NUMBER,
val->type
);
return -1;
}
if (isint(val)) {
n = intvalue(val);
} else {
n = floatvalue(val); /* truncate */
}
} else {
/* "%i" expects an int, others expect a long */
if (args->spec == 'i') {
n = *(const int *)getarg_raw(argv, argidx);
} else {
n = *(const long *)getarg_raw(argv, argidx);
}
}
if (args->spec == 'i' || args->spec == 'd') {
/* signed conversion specifiers */
if (n < 0) {
flags |= FLAG_NEGATIVE;
u = -n;
} else {
u = n;
}
} else {
/* unsigned conversion specifiers */
u = n;
}
if (args->spec == 'X') {
flags |= FLAG_CAPS;
}
if (args->width >= 0 && args->width > len) {
len = args->width;
}
buf = spn_malloc(len);
end = buf + len;
begin = ulong2str(end, u, base, args->width, flags);
assert(buf <= begin);
append_string(bld, begin, end - begin);
free(buf);
break;
}
case 'c': {
unsigned char ch;
int len = 1; /* one character is one character long... */
if (isval) {
/* must be an integer */
SpnValue *val = getarg_val(argv, argidx);
if (!isnum(val)) {
format_errmsg(
errmsg,
TYPE_MISMATCH,
*argidx,
SPN_TTAG_NUMBER,
val->type
);
return -1;
}
if (isfloat(val)) {
format_errmsg(errmsg, EXPECT_INTEGER, *argidx);
return -1;
}
ch = intvalue(val);
} else {
ch = *(const long *)getarg_raw(argv, argidx);
}
if (args->width > len) {
len = args->width;
}
expand_buffer(bld, len);
while (len-- > 1) {
bld->buf[bld->len++] = ' ';
}
bld->buf[bld->len++] = ch;
break;
}
case 'f':
case 'F': {
char *buf, *end, *begin;
size_t len;
int prec;
double x;
enum format_flags flags = args->flags;
if (isval) {
SpnValue *val = getarg_val(argv, argidx);
if (!isnum(val)) {
format_errmsg(
errmsg,
TYPE_MISMATCH,
*argidx,
SPN_TTAG_NUMBER,
val->type
);
return -1;
}
if (isfloat(val)) {
x = floatvalue(val);
} else {
x = intvalue(val);
}
} else {
x = *(const double *)getarg_raw(argv, argidx);
}
if (args->spec == 'F') {
flags |= FLAG_CAPS;
}
/* handle special cases */
if (+1.0 / x == +1.0 / -0.0) {
/* negative zero: set sign flag and carry on */
flags |= FLAG_NEGATIVE;
} else if (
x != x /* NaN */
|| x == +1.0 / 0.0 /* +inf */
|| x == -1.0 / 0.0 /* -inf */
) {
print_special_fp(bld, flags, args->width, x);
break;
}
if (x < 0.0) {
flags |= FLAG_NEGATIVE;
x = -x;
}
/* at this point, `x' is non-negative or -0 */
if (x >= 1.0) {
len = ceil(log10(x)) + 1; /* 10 ^ n is n + 1 digits long */
} else {
len = 1; /* leading zero needs exactly one character */
}
prec = args->precision < 0 ? DBL_DIG : args->precision;
len += prec + 3; /* decimal point, sign, leading zero */
if (args->width >= 0 && args->width > len) {
len = args->width;
}
buf = spn_malloc(len);
end = buf + len;
begin = double2str(end, x, args->width, prec, flags);
assert(buf <= begin);
append_string(bld, begin, end - begin);
free(buf);
break;
}
case 'B': {
int boolval;
const char *str;
size_t len;
if (isval) {
/* must be a boolean */
SpnValue *val = getarg_val(argv, argidx);
if (!isbool(val)) {
format_errmsg(
errmsg,
TYPE_MISMATCH,
*argidx,
SPN_TTAG_BOOL,
val->type
);
return -1;
}
boolval = boolvalue(val);
} else {
boolval = *(const int *)getarg_raw(argv, argidx);
}
str = boolval ? "true" : "false";
len = strlen(str);
if (args->precision >= 0 && args->precision < len) {
len = args->precision;
}
if (args->width >= 0 && args->width > len) {
size_t pad = args->width - len;
expand_buffer(bld, pad);
while (pad-- > 0) {
bld->buf[bld->len++] = ' ';
}
}
append_string(bld, str, len);
break;
}
default:
format_errmsg(errmsg, INVALID_SPECIFIER, ++*argidx, args->spec);
return -1;
}
return 0;
}
static bool value( void )
{
DEVELOPER_DEBUG( "value() %s\n", cursor );
if ( ! ( unique_id() || number() || stringvalue() ) ) return false;
return true;
}
