mirror of
git://jb55.com/damus
synced 2024-09-29 16:30:44 +00:00
nostrdb: fix japanese profile names not loading
update flatcc, including the patch that fixes japanese usenames Changelog-Fixed: Fix japanese profiles names not loading
This commit is contained in:
William Casarin
parent
280d889f25
commit
6863e74c0f
@ -177,7 +177,7 @@ int flatcc_builder_default_alloc(void *alloc_context, iovec_t *b, size_t request
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define T_ptr(base, pos) ((void *)((uint8_t *)(base) + (uoffset_t)(pos)))
|
||||
#define T_ptr(base, pos) ((void *)((size_t)(base) + (size_t)(pos)))
|
||||
#define ds_ptr(pos) (T_ptr(B->buffers[flatcc_builder_alloc_ds].iov_base, (pos)))
|
||||
#define vs_ptr(pos) (T_ptr(B->buffers[flatcc_builder_alloc_vs].iov_base, (pos)))
|
||||
#define pl_ptr(pos) (T_ptr(B->buffers[flatcc_builder_alloc_pl].iov_base, (pos)))
|
||||
@ -698,7 +698,8 @@ static inline flatcc_builder_ref_t emit_back(flatcc_builder_t *B, iov_state_t *i
|
||||
return ref + 1;
|
||||
}
|
||||
|
||||
static int align_to_block(flatcc_builder_t *B, uint16_t *align, uint16_t block_align, int is_nested)
|
||||
/* If nested we cannot pad the end of the buffer without moving the entire buffer, so we don't. */
|
||||
static int align_buffer_end(flatcc_builder_t *B, uint16_t *align, uint16_t block_align, int is_nested)
|
||||
{
|
||||
size_t end_pad;
|
||||
iov_state_t iov;
|
||||
@ -708,7 +709,7 @@ static int align_to_block(flatcc_builder_t *B, uint16_t *align, uint16_t block_a
|
||||
get_min_align(align, block_align);
|
||||
/* Pad end of buffer to multiple. */
|
||||
if (!is_nested) {
|
||||
end_pad = back_pad(B, block_align);
|
||||
end_pad = back_pad(B, *align);
|
||||
if (end_pad) {
|
||||
init_iov();
|
||||
push_iov(_pad, end_pad);
|
||||
@ -723,13 +724,13 @@ static int align_to_block(flatcc_builder_t *B, uint16_t *align, uint16_t block_a
|
||||
|
||||
flatcc_builder_ref_t flatcc_builder_embed_buffer(flatcc_builder_t *B,
|
||||
uint16_t block_align,
|
||||
const void *data, size_t size, uint16_t align, int flags)
|
||||
const void *data, size_t size, uint16_t align, flatcc_builder_buffer_flags_t flags)
|
||||
{
|
||||
uoffset_t size_field, pad;
|
||||
iov_state_t iov;
|
||||
int with_size = flags & flatcc_builder_with_size;
|
||||
int with_size = (flags & flatcc_builder_with_size) != 0;
|
||||
|
||||
if (align_to_block(B, &align, block_align, !is_top_buffer(B))) {
|
||||
if (align_buffer_end(B, &align, block_align, !is_top_buffer(B))) {
|
||||
return 0;
|
||||
}
|
||||
pad = front_pad(B, (uoffset_t)(size + (with_size ? field_size : 0)), align);
|
||||
@ -744,7 +745,7 @@ flatcc_builder_ref_t flatcc_builder_embed_buffer(flatcc_builder_t *B,
|
||||
|
||||
flatcc_builder_ref_t flatcc_builder_create_buffer(flatcc_builder_t *B,
|
||||
const char identifier[identifier_size], uint16_t block_align,
|
||||
flatcc_builder_ref_t object_ref, uint16_t align, int flags)
|
||||
flatcc_builder_ref_t object_ref, uint16_t align, flatcc_builder_buffer_flags_t flags)
|
||||
{
|
||||
flatcc_builder_ref_t buffer_ref;
|
||||
uoffset_t header_pad, id_size = 0;
|
||||
@ -754,7 +755,7 @@ flatcc_builder_ref_t flatcc_builder_create_buffer(flatcc_builder_t *B,
|
||||
int is_nested = (flags & flatcc_builder_is_nested) != 0;
|
||||
int with_size = (flags & flatcc_builder_with_size) != 0;
|
||||
|
||||
if (align_to_block(B, &align, block_align, is_nested)) {
|
||||
if (align_buffer_end(B, &align, block_align, is_nested)) {
|
||||
return 0;
|
||||
}
|
||||
set_min_align(B, align);
|
||||
@ -808,7 +809,7 @@ flatcc_builder_ref_t flatcc_builder_create_struct(flatcc_builder_t *B, const voi
|
||||
}
|
||||
|
||||
int flatcc_builder_start_buffer(flatcc_builder_t *B,
|
||||
const char identifier[identifier_size], uint16_t block_align, int flags)
|
||||
const char identifier[identifier_size], uint16_t block_align, flatcc_builder_buffer_flags_t flags)
|
||||
{
|
||||
/*
|
||||
* This saves the parent `min_align` in the align field since we
|
||||
@ -820,7 +821,11 @@ int flatcc_builder_start_buffer(flatcc_builder_t *B,
|
||||
return -1;
|
||||
}
|
||||
/* B->align now has parent min_align, and child frames will save it. */
|
||||
B->min_align = 1;
|
||||
/* Since we allow objects to be created before the buffer at top level,
|
||||
we need to respect min_align in that case. */
|
||||
if (!is_top_buffer(B) || B->min_align == 0) {
|
||||
B->min_align = 1;
|
||||
}
|
||||
/* Save the parent block align, and set proper defaults for this buffer. */
|
||||
frame(container.buffer.block_align) = B->block_align;
|
||||
B->block_align = block_align;
|
||||
@ -845,9 +850,9 @@ int flatcc_builder_start_buffer(flatcc_builder_t *B,
|
||||
flatcc_builder_ref_t flatcc_builder_end_buffer(flatcc_builder_t *B, flatcc_builder_ref_t root)
|
||||
{
|
||||
flatcc_builder_ref_t buffer_ref;
|
||||
int flags;
|
||||
flatcc_builder_buffer_flags_t flags;
|
||||
|
||||
flags = B->buffer_flags & flatcc_builder_with_size;
|
||||
flags = (flatcc_builder_buffer_flags_t)B->buffer_flags & flatcc_builder_with_size;
|
||||
flags |= is_top_buffer(B) ? 0 : flatcc_builder_is_nested;
|
||||
check(frame(type) == flatcc_builder_buffer, "expected buffer frame");
|
||||
set_min_align(B, B->block_align);
|
||||
@ -859,6 +864,8 @@ flatcc_builder_ref_t flatcc_builder_end_buffer(flatcc_builder_t *B, flatcc_build
|
||||
B->nest_id = frame(container.buffer.nest_id);
|
||||
B->identifier = frame(container.buffer.identifier);
|
||||
B->buffer_flags = frame(container.buffer.flags);
|
||||
B->block_align = frame(container.buffer.block_align);
|
||||
|
||||
exit_frame(B);
|
||||
return buffer_ref;
|
||||
}
|
||||
@ -1327,6 +1334,7 @@ flatcc_builder_ref_t flatcc_builder_end_table(flatcc_builder_t *B)
|
||||
flatcc_builder_ref_t table_ref, vt_ref;
|
||||
int pl_count;
|
||||
voffset_t *pl;
|
||||
size_t tsize;
|
||||
|
||||
check(frame(type) == flatcc_builder_table, "expected table frame");
|
||||
|
||||
@ -1341,7 +1349,14 @@ flatcc_builder_ref_t flatcc_builder_end_table(flatcc_builder_t *B)
|
||||
* initial vtable offset field. Therefore `field_size` is added here
|
||||
* to the total table size in the vtable.
|
||||
*/
|
||||
vt[1] = (voffset_t)(B->ds_offset + field_size);
|
||||
tsize = (size_t)(B->ds_offset + field_size);
|
||||
/*
|
||||
* Tables are limited to 64K in standard FlatBuffers format due to the voffset
|
||||
* 16 bit size, but we must also be able to store the table size, so the
|
||||
* table payload has to be slightly less than that.
|
||||
*/
|
||||
check(tsize <= FLATBUFFERS_VOFFSET_MAX, "table too large");
|
||||
vt[1] = (voffset_t)tsize;
|
||||
FLATCC_BUILDER_UPDATE_VT_HASH(B->vt_hash, (uint32_t)vt[0], (uint32_t)vt[1]);
|
||||
/* Find already emitted vtable, or emit a new one. */
|
||||
if (!(vt_ref = flatcc_builder_create_cached_vtable(B, vt, vt_size, B->vt_hash))) {
|
||||
|
||||
@ -710,10 +710,13 @@ static inline void flatcc_builder_refmap_reset(flatcc_builder_t *B)
|
||||
}
|
||||
|
||||
|
||||
enum flatcc_builder_buffer_flags {
|
||||
flatcc_builder_is_nested = 1,
|
||||
flatcc_builder_with_size = 2,
|
||||
};
|
||||
typedef uint16_t flatcc_builder_buffer_flags_t;
|
||||
static const flatcc_builder_buffer_flags_t flatcc_builder_is_nested = 1;
|
||||
static const flatcc_builder_buffer_flags_t flatcc_builder_with_size = 2;
|
||||
|
||||
/* The flag size in the API needs to match the internal size. */
|
||||
static_assert(sizeof(flatcc_builder_buffer_flags_t) ==
|
||||
sizeof(((flatcc_builder_t *)0)->buffer_flags), "flag size mismatch");
|
||||
|
||||
/**
|
||||
* An alternative to start buffer, start struct/table ... end buffer.
|
||||
@ -776,7 +779,7 @@ enum flatcc_builder_buffer_flags {
|
||||
flatcc_builder_ref_t flatcc_builder_create_buffer(flatcc_builder_t *B,
|
||||
const char identifier[FLATBUFFERS_IDENTIFIER_SIZE],
|
||||
uint16_t block_align,
|
||||
flatcc_builder_ref_t ref, uint16_t align, int flags);
|
||||
flatcc_builder_ref_t ref, uint16_t align, flatcc_builder_buffer_flags_t flags);
|
||||
|
||||
/**
|
||||
* Creates a struct within the current buffer without using any
|
||||
@ -867,7 +870,7 @@ flatcc_builder_ref_t flatcc_builder_end_struct(flatcc_builder_t *B);
|
||||
*/
|
||||
int flatcc_builder_start_buffer(flatcc_builder_t *B,
|
||||
const char identifier[FLATBUFFERS_IDENTIFIER_SIZE],
|
||||
uint16_t block_align, int flags);
|
||||
uint16_t block_align, flatcc_builder_buffer_flags_t flags);
|
||||
|
||||
/**
|
||||
* The root object should be a struct or a table to conform to the
|
||||
@ -923,7 +926,7 @@ flatcc_builder_ref_t flatcc_builder_end_buffer(flatcc_builder_t *B, flatcc_build
|
||||
*/
|
||||
flatcc_builder_ref_t flatcc_builder_embed_buffer(flatcc_builder_t *B,
|
||||
uint16_t block_align,
|
||||
const void *data, size_t size, uint16_t align, int flags);
|
||||
const void *data, size_t size, uint16_t align, flatcc_builder_buffer_flags_t flags);
|
||||
|
||||
/**
|
||||
* Applies to the innermost open buffer. The identifier may be null or
|
||||
|
||||
@ -22,13 +22,12 @@ extern "C" {
|
||||
#define PDIAGNOSTIC_IGNORE_UNUSED
|
||||
#include "portable/pdiagnostic_push.h"
|
||||
|
||||
enum flatcc_json_parser_flags {
|
||||
flatcc_json_parser_f_skip_unknown = 1,
|
||||
flatcc_json_parser_f_force_add = 2,
|
||||
flatcc_json_parser_f_with_size = 4,
|
||||
flatcc_json_parser_f_skip_array_overflow = 8,
|
||||
flatcc_json_parser_f_reject_array_underflow = 16
|
||||
};
|
||||
typedef uint32_t flatcc_json_parser_flags_t;
|
||||
static const flatcc_json_parser_flags_t flatcc_json_parser_f_skip_unknown = 1;
|
||||
static const flatcc_json_parser_flags_t flatcc_json_parser_f_force_add = 2;
|
||||
static const flatcc_json_parser_flags_t flatcc_json_parser_f_with_size = 4;
|
||||
static const flatcc_json_parser_flags_t flatcc_json_parser_f_skip_array_overflow = 8;
|
||||
static const flatcc_json_parser_flags_t flatcc_json_parser_f_reject_array_underflow = 16;
|
||||
|
||||
#define FLATCC_JSON_PARSE_ERROR_MAP(XX) \
|
||||
XX(ok, "ok") \
|
||||
@ -92,7 +91,7 @@ typedef struct flatcc_json_parser_ctx flatcc_json_parser_t;
|
||||
struct flatcc_json_parser_ctx {
|
||||
flatcc_builder_t *ctx;
|
||||
const char *line_start;
|
||||
int flags;
|
||||
flatcc_json_parser_flags_t flags;
|
||||
#if FLATCC_JSON_PARSE_ALLOW_UNQUOTED
|
||||
int unquoted;
|
||||
#endif
|
||||
@ -111,7 +110,7 @@ static inline int flatcc_json_parser_get_error(flatcc_json_parser_t *ctx)
|
||||
return ctx->error;
|
||||
}
|
||||
|
||||
static inline void flatcc_json_parser_init(flatcc_json_parser_t *ctx, flatcc_builder_t *B, const char *buf, const char *end, int flags)
|
||||
static inline void flatcc_json_parser_init(flatcc_json_parser_t *ctx, flatcc_builder_t *B, const char *buf, const char *end, flatcc_json_parser_flags_t flags)
|
||||
{
|
||||
memset(ctx, 0, sizeof(*ctx));
|
||||
ctx->ctx = B;
|
||||
@ -237,30 +236,45 @@ static inline uint64_t flatcc_json_parser_symbol_part_ext(const char *buf, const
|
||||
{
|
||||
uint64_t w = 0;
|
||||
size_t n = (size_t)(end - buf);
|
||||
const uint8_t *ubuf = (const uint8_t*)buf;
|
||||
|
||||
if (n > 8) {
|
||||
n = 8;
|
||||
}
|
||||
/* This can bloat inlining for a rarely executed case. */
|
||||
#if 1
|
||||
/* Fall through comments needed to silence gcc 7 warnings. */
|
||||
switch (n) {
|
||||
case 8: w |= ((uint64_t)buf[7]) << (0 * 8);
|
||||
fallthrough;
|
||||
case 7: w |= ((uint64_t)buf[6]) << (1 * 8);
|
||||
fallthrough;
|
||||
case 6: w |= ((uint64_t)buf[5]) << (2 * 8);
|
||||
fallthrough;
|
||||
case 5: w |= ((uint64_t)buf[4]) << (3 * 8);
|
||||
fallthrough;
|
||||
case 4: w |= ((uint64_t)buf[3]) << (4 * 8);
|
||||
fallthrough;
|
||||
case 3: w |= ((uint64_t)buf[2]) << (5 * 8);
|
||||
fallthrough;
|
||||
case 2: w |= ((uint64_t)buf[1]) << (6 * 8);
|
||||
fallthrough;
|
||||
case 1: w |= ((uint64_t)buf[0]) << (7 * 8);
|
||||
fallthrough;
|
||||
case 8:
|
||||
w |= ((uint64_t)ubuf[7]) << (0 * 8);
|
||||
goto lbl_n_7;
|
||||
case 7:
|
||||
lbl_n_7:
|
||||
w |= ((uint64_t)ubuf[6]) << (1 * 8);
|
||||
goto lbl_n_6;
|
||||
case 6:
|
||||
lbl_n_6:
|
||||
w |= ((uint64_t)ubuf[5]) << (2 * 8);
|
||||
goto lbl_n_5;
|
||||
case 5:
|
||||
lbl_n_5:
|
||||
w |= ((uint64_t)ubuf[4]) << (3 * 8);
|
||||
goto lbl_n_4;
|
||||
case 4:
|
||||
lbl_n_4:
|
||||
w |= ((uint64_t)ubuf[3]) << (4 * 8);
|
||||
goto lbl_n_3;
|
||||
case 3:
|
||||
lbl_n_3:
|
||||
w |= ((uint64_t)ubuf[2]) << (5 * 8);
|
||||
goto lbl_n_2;
|
||||
case 2:
|
||||
lbl_n_2:
|
||||
w |= ((uint64_t)ubuf[1]) << (6 * 8);
|
||||
goto lbl_n_1;
|
||||
case 1:
|
||||
lbl_n_1:
|
||||
w |= ((uint64_t)ubuf[0]) << (7 * 8);
|
||||
break;
|
||||
case 0:
|
||||
break;
|
||||
}
|
||||
@ -872,10 +886,10 @@ const char *flatcc_json_parser_union_type_vector(flatcc_json_parser_t *ctx,
|
||||
* `buf`, `bufsiz` may be larger than the parsed json if trailing
|
||||
* space or zeroes are expected, but they must represent a valid memory buffer.
|
||||
* `fid` must be null, or a valid file identifier.
|
||||
* `flags` default to 0. See also `flatcc_json_parser_flags`.
|
||||
* `flags` default to 0. See also `flatcc_json_parser_f_` constants.
|
||||
*/
|
||||
int flatcc_json_parser_table_as_root(flatcc_builder_t *B, flatcc_json_parser_t *ctx,
|
||||
const char *buf, size_t bufsiz, int flags, const char *fid,
|
||||
const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags, const char *fid,
|
||||
flatcc_json_parser_table_f *parser);
|
||||
|
||||
/*
|
||||
@ -883,7 +897,7 @@ int flatcc_json_parser_table_as_root(flatcc_builder_t *B, flatcc_json_parser_t *
|
||||
* root.
|
||||
*/
|
||||
int flatcc_json_parser_struct_as_root(flatcc_builder_t *B, flatcc_json_parser_t *ctx,
|
||||
const char *buf, size_t bufsiz, int flags, const char *fid,
|
||||
const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags, const char *fid,
|
||||
flatcc_json_parser_struct_f *parser);
|
||||
|
||||
#include "portable/pdiagnostic_pop.h"
|
||||
|
||||
@ -243,14 +243,13 @@ static inline void flatcc_json_printer_set_nonstrict(flatcc_json_printer_t *ctx)
|
||||
flatcc_json_printer_set_noenum(ctx, 0);
|
||||
}
|
||||
|
||||
enum flatcc_json_printer_flags {
|
||||
flatcc_json_printer_f_unquote = 1,
|
||||
flatcc_json_printer_f_noenum = 2,
|
||||
flatcc_json_printer_f_skip_default = 4,
|
||||
flatcc_json_printer_f_force_default = 8,
|
||||
flatcc_json_printer_f_pretty = 16,
|
||||
flatcc_json_printer_f_nonstrict = 32,
|
||||
};
|
||||
typedef uint32_t flatcc_json_printer_flags_t;
|
||||
static const flatcc_json_printer_flags_t flatcc_json_printer_f_unquote = 1;
|
||||
static const flatcc_json_printer_flags_t flatcc_json_printer_f_noenum = 2;
|
||||
static const flatcc_json_printer_flags_t flatcc_json_printer_f_skip_default = 4;
|
||||
static const flatcc_json_printer_flags_t flatcc_json_printer_f_force_default = 8;
|
||||
static const flatcc_json_printer_flags_t flatcc_json_printer_f_pretty = 16;
|
||||
static const flatcc_json_printer_flags_t flatcc_json_printer_f_nonstrict = 32;
|
||||
|
||||
/*
|
||||
* May be called instead of setting operational modes individually.
|
||||
@ -268,7 +267,7 @@ enum flatcc_json_printer_flags {
|
||||
* `pretty` flag sets indentation to 2.
|
||||
* `nonstrict` implies: `noenum`, `unquote`, `pretty`.
|
||||
*/
|
||||
static inline void flatcc_json_printer_set_flags(flatcc_json_printer_t *ctx, int flags)
|
||||
static inline void flatcc_json_printer_set_flags(flatcc_json_printer_t *ctx, flatcc_json_printer_flags_t flags)
|
||||
{
|
||||
ctx->unquote = !!(flags & flatcc_json_printer_f_unquote);
|
||||
ctx->noenum = !!(flags & flatcc_json_printer_f_noenum);
|
||||
|
||||
@ -2,12 +2,12 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define FLATCC_VERSION_TEXT "0.6.1"
|
||||
#define FLATCC_VERSION_TEXT "0.6.2"
|
||||
#define FLATCC_VERSION_MAJOR 0
|
||||
#define FLATCC_VERSION_MINOR 6
|
||||
#define FLATCC_VERSION_PATCH 1
|
||||
#define FLATCC_VERSION_PATCH 2
|
||||
/* 1 or 0 */
|
||||
#define FLATCC_VERSION_RELEASED 1
|
||||
#define FLATCC_VERSION_RELEASED 0
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@ -141,11 +141,10 @@ descend:
|
||||
++buf;
|
||||
}
|
||||
while (buf != end && *buf <= 0x20) {
|
||||
/* Fall through comments needed to silence gcc 7 warnings. */
|
||||
switch (*buf) {
|
||||
case 0x0d: buf += (end - buf > 1 && buf[1] == 0x0a);
|
||||
/* Consume following LF or treating CR as LF. */
|
||||
fallthrough;
|
||||
++ctx->line; ctx->line_start = ++buf; continue;
|
||||
case 0x0a: ++ctx->line; ctx->line_start = ++buf; continue;
|
||||
case 0x09: ++buf; continue;
|
||||
case 0x20: goto again; /* Don't consume here, sync with power of 2 spaces. */
|
||||
@ -880,7 +879,7 @@ const char *flatcc_json_parser_char_array(flatcc_json_parser_t *ctx,
|
||||
if (ctx->flags & flatcc_json_parser_f_reject_array_underflow) {
|
||||
return flatcc_json_parser_set_error(ctx, buf, end, flatcc_json_parser_error_array_underflow);
|
||||
}
|
||||
memset(s, 0, n - k);
|
||||
memset(s, 0, n);
|
||||
}
|
||||
return flatcc_json_parser_string_end(ctx, buf, end);
|
||||
}
|
||||
@ -1258,12 +1257,12 @@ failed:
|
||||
}
|
||||
|
||||
int flatcc_json_parser_table_as_root(flatcc_builder_t *B, flatcc_json_parser_t *ctx,
|
||||
const char *buf, size_t bufsiz, int flags, const char *fid,
|
||||
const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags, const char *fid,
|
||||
flatcc_json_parser_table_f *parser)
|
||||
{
|
||||
flatcc_json_parser_t _ctx;
|
||||
flatcc_builder_ref_t root;
|
||||
int builder_flags = flags & flatcc_json_parser_f_with_size ? flatcc_builder_with_size : 0;
|
||||
flatcc_builder_buffer_flags_t builder_flags = flags & flatcc_json_parser_f_with_size ? flatcc_builder_with_size : 0;
|
||||
|
||||
ctx = ctx ? ctx : &_ctx;
|
||||
flatcc_json_parser_init(ctx, B, buf, buf + bufsiz, flags);
|
||||
@ -1278,12 +1277,12 @@ int flatcc_json_parser_table_as_root(flatcc_builder_t *B, flatcc_json_parser_t *
|
||||
}
|
||||
|
||||
int flatcc_json_parser_struct_as_root(flatcc_builder_t *B, flatcc_json_parser_t *ctx,
|
||||
const char *buf, size_t bufsiz, int flags, const char *fid,
|
||||
const char *buf, size_t bufsiz, flatcc_json_parser_flags_t flags, const char *fid,
|
||||
flatcc_json_parser_table_f *parser)
|
||||
{
|
||||
flatcc_json_parser_t _ctx;
|
||||
flatcc_builder_ref_t root;
|
||||
int builder_flags = flags & flatcc_json_parser_f_with_size ? flatcc_builder_with_size : 0;
|
||||
flatcc_builder_buffer_flags_t builder_flags = flags & flatcc_json_parser_f_with_size ? flatcc_builder_with_size : 0;
|
||||
|
||||
ctx = ctx ? ctx : &_ctx;
|
||||
flatcc_json_parser_init(ctx, B, buf, buf + bufsiz, flags);
|
||||
|
||||
@ -61,6 +61,8 @@ extern "C" {
|
||||
#define PORTABLE_C11_ALIGNED_ALLOC 0
|
||||
#elif defined (__clang__)
|
||||
#define PORTABLE_C11_ALIGNED_ALLOC 0
|
||||
#elif defined (__APPLE__)
|
||||
#define PORTABLE_C11_ALIGNED_ALLOC 0
|
||||
#elif defined(__IBMC__)
|
||||
#define PORTABLE_C11_ALIGNED_ALLOC 0
|
||||
#elif (defined(__STDC__) && __STDC__ && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
|
||||
|
||||
@ -40,7 +40,7 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef PORTABLE_EXPOSE_ATTRIBUTES
|
||||
#define PORTABLE_EXPOSE_ATTRIBUTES 1
|
||||
#define PORTABLE_EXPOSE_ATTRIBUTES 0
|
||||
#endif
|
||||
|
||||
#ifdef __has_c_attribute
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <string.h> /* memcpy */
|
||||
|
||||
/*
|
||||
* Parses a float or double number and returns the length parsed if
|
||||
* successful. The length argument is of limited value due to dependency
|
||||
@ -34,7 +36,7 @@ extern "C" {
|
||||
* Other compilers such as xlc may require linking with -lm which may not
|
||||
* be convienent so a default isinf is provided. If isinf is available
|
||||
* and there is a noticable performance issue, define
|
||||
* `PORTABLE_USE_ISINF`.
|
||||
* `PORTABLE_USE_ISINF`. This flag also affects isnan.
|
||||
*/
|
||||
#if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER) || defined(PORTABLE_USE_ISINF)
|
||||
#include <math.h>
|
||||
@ -44,12 +46,13 @@ extern "C" {
|
||||
#define isinf(x) (!_finite(x))
|
||||
#endif
|
||||
/*
|
||||
* clang-5 through clang-8 but not clang-9 issues incorrect precision
|
||||
* clang-3 through clang-8 but not clang-9 issues incorrect precision
|
||||
* loss warning with -Wconversion flag when cast is absent.
|
||||
*/
|
||||
#if defined(__clang__)
|
||||
#if __clang_major__ >= 5 && __clang_major__ <= 8
|
||||
#if __clang_major__ >= 3 && __clang_major__ <= 8
|
||||
#define parse_double_isinf(x) isinf((float)x)
|
||||
#define parse_double_isnan(x) isnan((float)x)
|
||||
#endif
|
||||
#endif
|
||||
#if !defined(parse_double_isinf)
|
||||
@ -64,19 +67,29 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
/* Avoid linking with libmath but depends on float/double being IEEE754 */
|
||||
static inline int parse_double_isinf(double x)
|
||||
static inline int parse_double_isinf(const double x)
|
||||
{
|
||||
union { uint64_t u64; double f64; } v;
|
||||
v.f64 = x;
|
||||
return (v.u64 & 0x7fffffff00000000ULL) == 0x7ff0000000000000ULL;
|
||||
uint64_t u64x;
|
||||
|
||||
memcpy(&u64x, &x, sizeof(u64x));
|
||||
return (u64x & 0x7fffffff00000000ULL) == 0x7ff0000000000000ULL;
|
||||
}
|
||||
|
||||
static inline int parse_float_isinf(float x)
|
||||
{
|
||||
union { uint32_t u32; float f32; } v;
|
||||
v.f32 = x;
|
||||
return (v.u32 & 0x7fffffff) == 0x7f800000;
|
||||
uint32_t u32x;
|
||||
|
||||
memcpy(&u32x, &x, sizeof(u32x));
|
||||
return (u32x & 0x7fffffff) == 0x7f800000;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if !defined(parse_double_isnan)
|
||||
#define parse_double_isnan isnan
|
||||
#endif
|
||||
#if !defined(parse_float_isnan)
|
||||
#define parse_float_isnan isnan
|
||||
#endif
|
||||
|
||||
/* Returns 0 when in range, 1 on overflow, and -1 on underflow. */
|
||||
@ -131,6 +144,79 @@ static inline const char *parse_float(const char *buf, size_t len, float *result
|
||||
return end;
|
||||
}
|
||||
|
||||
/* Inspired by https://bitbashing.io/comparing-floats.html */
|
||||
|
||||
/* Return signed ULP distance or INT64_MAX if any value is nan. */
|
||||
static inline int64_t parse_double_compare(const double x, const double y)
|
||||
{
|
||||
int64_t i64x, i64y;
|
||||
|
||||
if (x == y) return 0;
|
||||
if (parse_double_isnan(x)) return INT64_MAX;
|
||||
if (parse_double_isnan(y)) return INT64_MAX;
|
||||
memcpy(&i64x, &x, sizeof(i64x));
|
||||
memcpy(&i64y, &y, sizeof(i64y));
|
||||
if ((i64x < 0) != (i64y < 0)) return INT64_MAX;
|
||||
return i64x - i64y;
|
||||
}
|
||||
|
||||
/* Same as double, but INT32_MAX if nan. */
|
||||
static inline int32_t parse_float_compare(const float x, const float y)
|
||||
{
|
||||
int32_t i32x, i32y;
|
||||
|
||||
if (x == y) return 0;
|
||||
if (parse_float_isnan(x)) return INT32_MAX;
|
||||
if (parse_float_isnan(y)) return INT32_MAX;
|
||||
memcpy(&i32x, &x, sizeof(i32x));
|
||||
memcpy(&i32y, &y, sizeof(i32y));
|
||||
if ((i32x < 0) != (i32y < 0)) return INT32_MAX;
|
||||
return i32x - i32y;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns the absolute distance in floating point ULP (representational bit difference).
|
||||
* Uses signed return value so that INT64_MAX and INT32_MAX indicates NaN similar to
|
||||
* the compare function.
|
||||
*/
|
||||
static inline int64_t parse_double_dist(const double x, const double y)
|
||||
{
|
||||
uint64_t m64;
|
||||
int64_t i64;
|
||||
|
||||
i64 = parse_double_compare(x, y);
|
||||
/* Absolute integer value of compare. */
|
||||
m64 = (uint64_t)-(i64 < 0);
|
||||
return (int64_t)(((uint64_t)i64 + m64) ^ m64);
|
||||
}
|
||||
|
||||
/* Same as double, but INT32_MAX if NaN. */
|
||||
static inline int32_t parse_float_dist(const float x, const float y)
|
||||
{
|
||||
uint32_t m32;
|
||||
int32_t i32;
|
||||
|
||||
i32 = parse_float_compare(x, y);
|
||||
/* Absolute integer value of compare. */
|
||||
m32 = (uint32_t)-(i32 < 0);
|
||||
return (int32_t)(((uint32_t)i32 + m32) ^ m32);
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns 1 if no value is NaN, and the difference is at most one ULP (1 bit), and the
|
||||
* sign is the same, and 0 otherwise.
|
||||
*/
|
||||
static inline int parse_double_is_equal(const double x, const double y)
|
||||
{
|
||||
return parse_double_dist(x, y) >> 1 == 0;
|
||||
}
|
||||
|
||||
/* Same as double, but at lower precision. */
|
||||
static inline int parse_float_is_equal(const float x, const float y)
|
||||
{
|
||||
return parse_float_dist(x, y) >> 1 == 0;
|
||||
}
|
||||
|
||||
#include "pdiagnostic_pop.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
@ -64,7 +64,6 @@ static inline TK ## _option_t N ## _ ## NK ## _option(N ## _table_t t__tmp)\
|
||||
#define __flatbuffers_offset_field(T, ID, t, r, adjust)\
|
||||
{\
|
||||
flatbuffers_uoffset_t *elem__tmp;\
|
||||
printf("got here\n");
|
||||
__flatbuffers_read_vt(ID, offset__tmp, t)\
|
||||
if (offset__tmp) {\
|
||||
elem__tmp = (flatbuffers_uoffset_t *)((uint8_t *)(t) + offset__tmp);\
|
||||
|
||||
Loading…
Reference in New Issue
Block a user