Re: [Qemu-devel] [PATCH] qemu: json: Fix parsing of integers >= 0x8000000000000000

[Markus Armbruster]

Anthony Liguori <address@hidden> writes:

>>> The actual value of the alert will surprise you :-)
>>>
>>> Integers in Javascript are actually represented as doubles
>>> internally which means that integer constants are only accurate up
>>> to 52 bits.
>>>
>>> So really, we should cap integers at 32-bit :-/
>>>
>>> Have I mentioned recently that I really dislike JSON...
>>
>> NB, I am distinguishing between JSON the generic specification and
>> JSON as implemented in web browsers. JSON the specification has *no*
>> limitation on integers.
>
> The spec has no notion of integers at all.  Here's the relevant

It doesn't differentiate between integers and floating-point numbers
*syntactically*.  There are just numbers.  Some of them happen to be
integers.

> text. Note that the BNF only has a single entry point for numbers.  It
> does not distinguish between integers and floating point numbers.
> Also, the only discussion of valid numbers is about whether the number
> can be represented as a rational number.  I think the only way to read
> the spec here is that *all* numbers are meant to be represented as
> floating point numbers.
>
> Regards,
>
> Anthony Liguori
>
> 2.4.  Numbers
>
>    The representation of numbers is similar to that used in most
>    programming languages.  A number contains an integer component that
>    may be prefixed with an optional minus sign, which may be followed by
>    a fraction part and/or an exponent part.
>
>    Octal and hex forms are not allowed.  Leading zeros are not allowed.
>
>    A fraction part is a decimal point followed by one or more digits.
>
>    An exponent part begins with the letter E in upper or lowercase,
>    which may be followed by a plus or minus sign.  The E and optional
>    sign are followed by one or more digits.
>
>    Numeric values that cannot be represented as sequences of digits
>    (such as Infinity and NaN) are not permitted.

Therefore, the number 1234567890123456789 is permitted.

>
>
>          number = [ minus ] int [ frac ] [ exp ]
>
>          decimal-point = %x2E       ; .
>
>          digit1-9 = %x31-39         ; 1-9
>
>          e = %x65 / %x45            ; e E
>
>          exp = e [ minus / plus ] 1*DIGIT
>
>          frac = decimal-point 1*DIGIT
>
>          int = zero / ( digit1-9 *DIGIT )
>
>          minus = %x2D               ; -
>
>          plus = %x2B                ; +
>
>          zero = %x30                ; 0

There's more:

4.  Parsers

   A JSON parser transforms a JSON text into another representation.  A
   JSON parser MUST accept all texts that conform to the JSON grammar.
   A JSON parser MAY accept non-JSON forms or extensions.

   An implementation may set limits on the size of texts that it
   accepts.  An implementation may set limits on the maximum depth of
==>nesting.  An implementation may set limits on the range of numbers.<==
   An implementation may set limits on the length and character contents
   of strings.

JavaScript's implementation of JSON sets limits on the range of numbers,
namely they need to fit into IEEE doubles.

Our implementation sets different limits.  IIRC, it's something like
"numbers with a fractional part or an exponent need to fit into IEEE
doubles, anything else into int64_t."  Not exactly the acme of elegance,
either.  But it works for us.