This is a backwards incompatible change.
Number
======
-.. cfunction:: json_t *json_integer(int value)
+.. cfunction:: json_t *json_integer(long value)
.. refcounting:: new
Returns a new JSON integer, or *NULL* on error.
-.. cfunction:: int json_integer_value(const json_t *integer)
+.. cfunction:: long json_integer_value(const json_t *integer)
Returns the associated value of *integer*, or 0 if *json* is not a
JSON integer.
-.. cfunction:: int json_integer_set(const json_t *integer, int value)
+.. cfunction:: int json_integer_set(const json_t *integer, long value)
Sets the associated value of *integer* to *value*. Returns 0 on
success and -1 if *integer* is not a JSON integer.
JSON makes no distinction between real and integer numbers; Jansson
does. Real numbers are mapped to the ``double`` type and integers to
-the ``int`` type.
+the ``long`` type.
A JSON number is considered to be a real number if its lexical
representation includes one of ``e``, ``E``, or ``.``; regardless if
-1E+999 may result in a parsing error.
Likewise, integer numbers whose absolute values are too large to be
-represented in the ``int`` type will result in an overflow error (a
+represented in the ``long`` type will result in an overflow error (a
JSON decoding error). Thus, depending on platform, JSON numbers like
1000000000000000 may result in parsing error.
-----
No support is provided in Jansson for any C numeric types other than
-``int`` and ``double``. This excludes things such as unsigned types,
-``long``, ``long long``, ``long double``, etc. Obviously, shorter
-types like ``short`` and ``float`` are implicitly handled via the
+``long`` and ``double``. This excludes things such as unsigned types,
+``long long``, ``long double``, etc. Obviously, shorter types like
+``short``, ``int`` and ``float`` are implicitly handled via the
ordinary C type coercion rules (subject to overflow semantics). Also,
no support or hooks are provided for any supplemental "bignum" type
add-on packages.
char buffer[MAX_INTEGER_STR_LENGTH];
int size;
- size = snprintf(buffer, MAX_INTEGER_STR_LENGTH, "%d", json_integer_value(json));
+ size = snprintf(buffer, MAX_INTEGER_STR_LENGTH, "%li", json_integer_value(json));
if(size >= MAX_INTEGER_STR_LENGTH)
return -1;
json_t *json_array(void);
json_t *json_string(const char *value);
json_t *json_string_nocheck(const char *value);
-json_t *json_integer(int value);
+json_t *json_integer(long value);
json_t *json_real(double value);
json_t *json_true(void);
json_t *json_false(void);
}
const char *json_string_value(const json_t *string);
-int json_integer_value(const json_t *integer);
+long json_integer_value(const json_t *integer);
double json_real_value(const json_t *real);
double json_number_value(const json_t *json);
int json_string_set(json_t *string, const char *value);
int json_string_set_nocheck(json_t *string, const char *value);
-int json_integer_set(json_t *integer, int value);
+int json_integer_set(json_t *integer, long value);
int json_real_set(json_t *real, double value);
typedef struct {
json_t json;
- int value;
+ long value;
} json_integer_t;
#define json_to_object(json_) container_of(json_, json_object_t, json)
int line, column;
union {
char *string;
- int integer;
+ long integer;
double real;
} value;
} lex_t;
value = strtol(saved_text, &end, 10);
assert(end == saved_text + lex->saved_text.length);
- if((value == LONG_MAX && errno == ERANGE) || value > INT_MAX) {
+ if(value == LONG_MAX && errno == ERANGE) {
error_set(error, lex, "too big integer");
goto out;
}
- else if((value == LONG_MIN && errno == ERANGE) || value < INT_MIN) {
+ else if(value == LONG_MIN && errno == ERANGE) {
error_set(error, lex, "too big negative integer");
goto out;
}
lex->token = TOKEN_INTEGER;
- lex->value.integer = (int)value;
+ lex->value.integer = value;
return 0;
}
/*** integer ***/
-json_t *json_integer(int value)
+json_t *json_integer(long value)
{
json_integer_t *integer = malloc(sizeof(json_integer_t));
if(!integer)
return &integer->json;
}
-int json_integer_value(const json_t *json)
+long json_integer_value(const json_t *json)
{
if(!json_is_integer(json))
return 0;
return json_to_integer(json)->value;
}
-int json_integer_set(json_t *json, int value)
+int json_integer_set(json_t *json, long value)
{
if(!json_is_integer(json))
return -1;