"val" intrinsic gives inconsistent results between C# and C++ MiniScript, and generally doesn't handle octal/binary

[MineRobber9000]

Exactly what it says on the tin.

C++ MiniScript can resolve "0x"-prefixed hexadecimal numbers, but not "0o" or "0b" (octal and binary respectively). Meanwhile, C# MiniScript can't even resolve "0x"-prefixed hexadecimal numbers (tested in Mini Micro). Ideally, MiniScript should be able to support hex, octal, and binary strings across all versions.

[MineRobber9000]

Interestingly enough, I'm not sure C++ MiniScript's support of "0x"-prefixed hex was intentional. The C# code responsible for val is:

            // val
            //  Return the numeric value of a given string.  (If given a number,
            //  returns it as-is; if given a list or map, returns null.)
            //  May be called with function syntax or dot syntax.
            // self (string or number): string to get the value of
            // Returns: numeric value of the given string
            // Example: "1234.56".val       returns 1234.56
            // See also: str
            f = Intrinsic.Create("val");
            f.AddParam("self", 0);
            f.code = (context, partialResult) => {
                Value val = context.self;
                if (val is ValNumber) return new Intrinsic.Result(val);
                if (val is ValString) {
                    double value = 0;
                    double.TryParse(val.ToString(), NumberStyles.Any, CultureInfo.InvariantCulture, out value);
                    return new Intrinsic.Result(value);
                }
                return Intrinsic.Result.Null;
            };

This is why val doesn't support hex/octal/binary strings; C#'s double.TryParse doesn't attempt to parse them and just leaves value as 0.

The corresponding C++ code is:

    static IntrinsicResult intrinsic_val(Context *context, IntrinsicResult partialResult) {
        Value val = context->GetVar("self");
        if (val.type == ValueType::Number) return IntrinsicResult(val);
        if (val.type == ValueType::String) return IntrinsicResult(val.GetString().DoubleValue());
        return IntrinsicResult::Null;
    }

Which calls SimpleString.DoubleValue:

    double String::DoubleValue(const char* formatSpec) const {
        double retval = 0;
        sscanf(c_str(), formatSpec, &retval);
        return retval;
    }

sscanf, for some inexplicable reason, when told to find a double (%lf), will parse a hex string, but not octal or binary. (This implementation also has the side effect of yet another inconsistency: as long as a string starts with something parseable as a float, C++ MiniScript will report that as the value, even if the rest of the string is decidedly not a float; print "1foo2".val will print 1 in C++ and 0 in C#, but that's another issue for another time.)

That being said, I do feel like being able to handle these prefixed numbers is a thing MiniScript should do; either that, or go with the Lua/Python approach where you supply a radix to convert a string in that radix to a number.

[JoeStrout]

You are correct; there is no intended support for "0x" or other prefixes. "val" is meant to interpret numbers in decimal format only.