File-Raw-JSON
view release on metacpan or search on metacpan
include/file_raw_json.h view on Meta::CPAN
typedef struct {
json_mode_t mode; /* document vs lines */
int pretty; /* 0 / 1 */
int indent; /* 2 or 4 (yyjson constraint) */
int sort_keys; /* 0 / 1 */
int canonical; /* sort_keys + minimal whitespace */
int utf8; /* 1 = bytes are UTF-8 */
int relaxed; /* allow comments + trailing commas (decode) */
int allow_nonref; /* accept top-level scalars */
int allow_nan_inf; /* round-trip NaN / Infinity */
int ordered; /* decode JSON objects as Tie::IxHash */
/* HVs so insertion order is preserved */
/* on the Perl side (yyjson already */
/* preserves it; HV randomisation is the */
/* thing we're working around). */
int max_depth; /* nesting cap */
char eol[4]; /* JSONL only; "\n" by default */
int eol_len;
/* boolean_class is held as an SV* outside this struct (see XS). */
} json_options_t;
include/yyjson.h view on Meta::CPAN
and use libc's `strtod/snprintf` instead.
This will reduce the binary size by about 30%, but significantly slow down the
floating-point read/write speed.
*/
#ifndef YYJSON_DISABLE_FAST_FP_CONV
#endif
/*
Define as 1 to disable non-standard JSON support at compile-time:
- Reading and writing inf/nan literal, such as `NaN`, `-Infinity`.
- Single line and multiple line comments.
- Single trailing comma at the end of an object or array.
- Invalid unicode in string value.
This will also invalidate these run-time options:
- YYJSON_READ_ALLOW_INF_AND_NAN
- YYJSON_READ_ALLOW_COMMENTS
- YYJSON_READ_ALLOW_TRAILING_COMMAS
- YYJSON_READ_ALLOW_INVALID_UNICODE
- YYJSON_WRITE_ALLOW_INF_AND_NAN
include/yyjson.h view on Meta::CPAN
static const yyjson_read_flag YYJSON_READ_STOP_WHEN_DONE = 1 << 1;
/** Allow single trailing comma at the end of an object or array,
such as `[1,2,3,]`, `{"a":1,"b":2,}` (non-standard). */
static const yyjson_read_flag YYJSON_READ_ALLOW_TRAILING_COMMAS = 1 << 2;
/** Allow C-style single line and multiple line comments (non-standard). */
static const yyjson_read_flag YYJSON_READ_ALLOW_COMMENTS = 1 << 3;
/** Allow inf/nan number and literal, case-insensitive,
such as 1e999, NaN, inf, -Infinity (non-standard). */
static const yyjson_read_flag YYJSON_READ_ALLOW_INF_AND_NAN = 1 << 4;
/** Read all numbers as raw strings (value with `YYJSON_TYPE_RAW` type),
inf/nan literal is also read as raw with `ALLOW_INF_AND_NAN` flag. */
static const yyjson_read_flag YYJSON_READ_NUMBER_AS_RAW = 1 << 5;
/** Allow reading invalid unicode when parsing string values (non-standard).
Invalid characters will be allowed to appear in the string values, but
invalid escape sequences will still be reported as errors.
This flag does not affect the performance of correctly encoded strings.
include/yyjson.h view on Meta::CPAN
/** Write JSON pretty with 4 space indent. */
static const yyjson_write_flag YYJSON_WRITE_PRETTY = 1 << 0;
/** Escape unicode as `uXXXX`, make the output ASCII only. */
static const yyjson_write_flag YYJSON_WRITE_ESCAPE_UNICODE = 1 << 1;
/** Escape '/' as '\/'. */
static const yyjson_write_flag YYJSON_WRITE_ESCAPE_SLASHES = 1 << 2;
/** Write inf and nan number as 'Infinity' and 'NaN' literal (non-standard). */
static const yyjson_write_flag YYJSON_WRITE_ALLOW_INF_AND_NAN = 1 << 3;
/** Write inf and nan number as null literal.
This flag will override `YYJSON_WRITE_ALLOW_INF_AND_NAN` flag. */
static const yyjson_write_flag YYJSON_WRITE_INF_AND_NAN_AS_NULL = 1 << 4;
/** Allow invalid unicode when encoding string values (non-standard).
Invalid characters in string value will be copied byte by byte.
If `YYJSON_WRITE_ESCAPE_UNICODE` flag is also set, invalid character will be
escaped as `U+FFFD` (replacement character).
include/yyjson.h view on Meta::CPAN
/** Invalid parameter, such as NULL document. */
static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_PARAMETER = 1;
/** Memory allocation failure occurs. */
static const yyjson_write_code YYJSON_WRITE_ERROR_MEMORY_ALLOCATION = 2;
/** Invalid value type in JSON document. */
static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_VALUE_TYPE = 3;
/** NaN or Infinity number occurs. */
static const yyjson_write_code YYJSON_WRITE_ERROR_NAN_OR_INF = 4;
/** Failed to open a file. */
static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_OPEN = 5;
/** Failed to write a file. */
static const yyjson_write_code YYJSON_WRITE_ERROR_FILE_WRITE = 6;
/** Invalid unicode in string. */
static const yyjson_write_code YYJSON_WRITE_ERROR_INVALID_STRING = 7;
lib/File/Raw/JSON.pm view on Meta::CPAN
Decode: tolerate C<//> and C</* */> comments and trailing commas.
=item C<allow_nonref>
Decode: accept top-level scalars (C<42>, C<"hi">, C<true>). Default
true.
=item C<allow_nan_inf>
Round-trip C<NaN>, C<Infinity>, C<-Infinity>. Non-standard JSON;
default false.
=item C<ordered>
Decode JSON objects as L<Tie::OrderedHash>-tied hashes so insertion
order is preserved on the Perl side. yyjson already preserves source
order on parse; the regular Perl HV randomises iteration since 5.18,
which is what this option works around.
my $config = file_slurp("config.json", plugin => 'json', ordered => 1);
/*==============================================================================
* IEEE-754 Double Number Constants
*============================================================================*/
/* Inf raw value (positive) */
#define F64_RAW_INF U64(0x7FF00000, 0x00000000)
/* NaN raw value (quiet NaN, no payload, no sign) */
#if defined(__hppa__) || (defined(__mips__) && !defined(__mips_nan2008))
#define F64_RAW_NAN U64(0x7FF7FFFF, 0xFFFFFFFF)
#else
#define F64_RAW_NAN U64(0x7FF80000, 0x00000000)
#endif
/* double number bits */
#define F64_BITS 64
/* double number exponent part bits */
memcpy(&uni, src, 4);
return uni.u;
}
#endif
/*==============================================================================
* Number Utils
* These functions are used to detect and convert NaN and Inf numbers.
*============================================================================*/
/** Convert raw binary to double. */
static_inline f64 f64_from_raw(u64 u) {
/* use memcpy to avoid violating the strict aliasing rule */
f64 f;
memcpy(&f, &u, 8);
return f;
}
val->uni.str = (const char *)hdr;
} else {
val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
val->uni.u64 = f64_raw_get_inf(sign);
}
return true;
}
return false;
}
/** Read 'NaN' literal (ignoring case). */
static_inline bool read_nan(bool sign, u8 **ptr, u8 **pre, yyjson_val *val) {
u8 *hdr = *ptr - sign;
u8 *cur = *ptr;
u8 **end = ptr;
if ((cur[0] == 'N' || cur[0] == 'n') &&
(cur[1] == 'A' || cur[1] == 'a') &&
(cur[2] == 'N' || cur[2] == 'n')) {
cur += 3;
*end = cur;
if (pre) {
val->uni.str = (const char *)hdr;
} else {
val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL;
val->uni.u64 = f64_raw_get_nan(sign);
}
return true;
}
return false;
}
/** Read 'Inf', 'Infinity' or 'NaN' literal (ignoring case). */
static_inline bool read_inf_or_nan(bool sign, u8 **ptr, u8 **pre,
yyjson_val *val) {
if (read_inf(sign, ptr, pre, val)) return true;
if (read_nan(sign, ptr, pre, val)) return true;
return false;
}
/** Read a JSON number as raw string. */
static_noinline bool read_number_raw(u8 **ptr,
u8 **pre,
return buf + 4;
}
else if (has_write_flag(ALLOW_INF_AND_NAN)) {
if (sig_raw == 0) {
buf[0] = '-';
buf += sign;
byte_copy_8(buf, "Infinity");
buf += 8;
return buf;
} else {
byte_copy_4(buf, "NaN");
return buf + 3;
}
}
return NULL;
}
/* add sign for all finite double value, including 0.0 and inf */
buf[0] = '-';
buf += sign;
hdr = buf;
if (has_write_flag(INF_AND_NAN_AS_NULL)) {
byte_copy_4(buf, "null");
return buf + 4;
}
else if (has_write_flag(ALLOW_INF_AND_NAN)) {
if (*cur == 'i') {
byte_copy_8(cur, "Infinity");
cur += 8;
return cur;
} else if (*cur == 'n') {
byte_copy_4(buf, "NaN");
return buf + 3;
}
}
return NULL;
} else {
/* finite number */
int i = 0;
bool fp = false;
for (; i < len; i++) {
if (buf[i] == ',') buf[i] = '.';
( run in 1.617 second using v1.01-cache-2.11-cpan-9581c071862 )