Lots of changes but it's all just moving things around. Backward-compatible stub #include's have been provided for now. upb_Arena/upb_Status have been split out from upb/upb.? upb_Array/upb_Map/upb_MessageValue have been split out from upb/collections.? upb_ExtensionRegistry has been split out from upb/msg.? upb/decode_internal.h is now upb/internal/decode.h upb/mini_table_accessors_internal.h is now upb/internal/mini_table_accessors.h upb/table_internal.h is now upb/internal/table.h upb/upb_internal.h is now upb/internal/upb.h PiperOrigin-RevId: 456297617pull/13171/head
Protobuf Team Bot
3 years ago
committed by
Copybara-Service
parent
97993b219d
commit
e4635f223e
41 changed files with 2042 additions and 1442 deletions
@ -0,0 +1,277 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "upb/arena.h" |
||||||
|
|
||||||
|
#include <stdlib.h> |
||||||
|
|
||||||
|
#include "upb/internal/upb.h" |
||||||
|
|
||||||
|
// Must be last.
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
/* upb_alloc ******************************************************************/ |
||||||
|
|
||||||
|
static void* upb_global_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize, |
||||||
|
size_t size) { |
||||||
|
UPB_UNUSED(alloc); |
||||||
|
UPB_UNUSED(oldsize); |
||||||
|
if (size == 0) { |
||||||
|
free(ptr); |
||||||
|
return NULL; |
||||||
|
} else { |
||||||
|
return realloc(ptr, size); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
static uint32_t* upb_cleanup_pointer(uintptr_t cleanup_metadata) { |
||||||
|
return (uint32_t*)(cleanup_metadata & ~0x1); |
||||||
|
} |
||||||
|
|
||||||
|
static bool upb_cleanup_has_initial_block(uintptr_t cleanup_metadata) { |
||||||
|
return cleanup_metadata & 0x1; |
||||||
|
} |
||||||
|
|
||||||
|
static uintptr_t upb_cleanup_metadata(uint32_t* cleanup, |
||||||
|
bool has_initial_block) { |
||||||
|
return (uintptr_t)cleanup | has_initial_block; |
||||||
|
} |
||||||
|
|
||||||
|
upb_alloc upb_alloc_global = {&upb_global_allocfunc}; |
||||||
|
|
||||||
|
/* upb_Arena ******************************************************************/ |
||||||
|
|
||||||
|
struct mem_block { |
||||||
|
struct mem_block* next; |
||||||
|
uint32_t size; |
||||||
|
uint32_t cleanups; |
||||||
|
/* Data follows. */ |
||||||
|
}; |
||||||
|
|
||||||
|
typedef struct cleanup_ent { |
||||||
|
upb_CleanupFunc* cleanup; |
||||||
|
void* ud; |
||||||
|
} cleanup_ent; |
||||||
|
|
||||||
|
static const size_t memblock_reserve = |
||||||
|
UPB_ALIGN_UP(sizeof(mem_block), UPB_MALLOC_ALIGN); |
||||||
|
|
||||||
|
static upb_Arena* arena_findroot(upb_Arena* a) { |
||||||
|
/* Path splitting keeps time complexity down, see:
|
||||||
|
* https://en.wikipedia.org/wiki/Disjoint-set_data_structure */
|
||||||
|
while (a->parent != a) { |
||||||
|
upb_Arena* next = a->parent; |
||||||
|
a->parent = next->parent; |
||||||
|
a = next; |
||||||
|
} |
||||||
|
return a; |
||||||
|
} |
||||||
|
|
||||||
|
static void upb_Arena_addblock(upb_Arena* a, upb_Arena* root, void* ptr, |
||||||
|
size_t size) { |
||||||
|
mem_block* block = ptr; |
||||||
|
|
||||||
|
/* The block is for arena |a|, but should appear in the freelist of |root|. */ |
||||||
|
block->next = root->freelist; |
||||||
|
block->size = (uint32_t)size; |
||||||
|
block->cleanups = 0; |
||||||
|
root->freelist = block; |
||||||
|
a->last_size = block->size; |
||||||
|
if (!root->freelist_tail) root->freelist_tail = block; |
||||||
|
|
||||||
|
a->head.ptr = UPB_PTR_AT(block, memblock_reserve, char); |
||||||
|
a->head.end = UPB_PTR_AT(block, size, char); |
||||||
|
a->cleanup_metadata = upb_cleanup_metadata( |
||||||
|
&block->cleanups, upb_cleanup_has_initial_block(a->cleanup_metadata)); |
||||||
|
|
||||||
|
UPB_POISON_MEMORY_REGION(a->head.ptr, a->head.end - a->head.ptr); |
||||||
|
} |
||||||
|
|
||||||
|
static bool upb_Arena_Allocblock(upb_Arena* a, size_t size) { |
||||||
|
upb_Arena* root = arena_findroot(a); |
||||||
|
size_t block_size = UPB_MAX(size, a->last_size * 2) + memblock_reserve; |
||||||
|
mem_block* block = upb_malloc(root->block_alloc, block_size); |
||||||
|
|
||||||
|
if (!block) return false; |
||||||
|
upb_Arena_addblock(a, root, block, block_size); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
void* _upb_Arena_SlowMalloc(upb_Arena* a, size_t size) { |
||||||
|
if (!upb_Arena_Allocblock(a, size)) return NULL; /* Out of memory. */ |
||||||
|
UPB_ASSERT(_upb_ArenaHas(a) >= size); |
||||||
|
return upb_Arena_Malloc(a, size); |
||||||
|
} |
||||||
|
|
||||||
|
static void* upb_Arena_doalloc(upb_alloc* alloc, void* ptr, size_t oldsize, |
||||||
|
size_t size) { |
||||||
|
upb_Arena* a = (upb_Arena*)alloc; /* upb_alloc is initial member. */ |
||||||
|
return upb_Arena_Realloc(a, ptr, oldsize, size); |
||||||
|
} |
||||||
|
|
||||||
|
/* Public Arena API ***********************************************************/ |
||||||
|
|
||||||
|
upb_Arena* arena_initslow(void* mem, size_t n, upb_alloc* alloc) { |
||||||
|
const size_t first_block_overhead = sizeof(upb_Arena) + memblock_reserve; |
||||||
|
upb_Arena* a; |
||||||
|
|
||||||
|
/* We need to malloc the initial block. */ |
||||||
|
n = first_block_overhead + 256; |
||||||
|
if (!alloc || !(mem = upb_malloc(alloc, n))) { |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
a = UPB_PTR_AT(mem, n - sizeof(*a), upb_Arena); |
||||||
|
n -= sizeof(*a); |
||||||
|
|
||||||
|
a->head.alloc.func = &upb_Arena_doalloc; |
||||||
|
a->block_alloc = alloc; |
||||||
|
a->parent = a; |
||||||
|
a->refcount = 1; |
||||||
|
a->freelist = NULL; |
||||||
|
a->freelist_tail = NULL; |
||||||
|
a->cleanup_metadata = upb_cleanup_metadata(NULL, false); |
||||||
|
|
||||||
|
upb_Arena_addblock(a, a, mem, n); |
||||||
|
|
||||||
|
return a; |
||||||
|
} |
||||||
|
|
||||||
|
upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc) { |
||||||
|
upb_Arena* a; |
||||||
|
|
||||||
|
if (n) { |
||||||
|
/* Align initial pointer up so that we return properly-aligned pointers. */ |
||||||
|
void* aligned = (void*)UPB_ALIGN_UP((uintptr_t)mem, UPB_MALLOC_ALIGN); |
||||||
|
size_t delta = (uintptr_t)aligned - (uintptr_t)mem; |
||||||
|
n = delta <= n ? n - delta : 0; |
||||||
|
mem = aligned; |
||||||
|
} |
||||||
|
|
||||||
|
/* Round block size down to alignof(*a) since we will allocate the arena
|
||||||
|
* itself at the end. */ |
||||||
|
n = UPB_ALIGN_DOWN(n, UPB_ALIGN_OF(upb_Arena)); |
||||||
|
|
||||||
|
if (UPB_UNLIKELY(n < sizeof(upb_Arena))) { |
||||||
|
return arena_initslow(mem, n, alloc); |
||||||
|
} |
||||||
|
|
||||||
|
a = UPB_PTR_AT(mem, n - sizeof(*a), upb_Arena); |
||||||
|
|
||||||
|
a->head.alloc.func = &upb_Arena_doalloc; |
||||||
|
a->block_alloc = alloc; |
||||||
|
a->parent = a; |
||||||
|
a->refcount = 1; |
||||||
|
a->last_size = UPB_MAX(128, n); |
||||||
|
a->head.ptr = mem; |
||||||
|
a->head.end = UPB_PTR_AT(mem, n - sizeof(*a), char); |
||||||
|
a->freelist = NULL; |
||||||
|
a->cleanup_metadata = upb_cleanup_metadata(NULL, true); |
||||||
|
|
||||||
|
return a; |
||||||
|
} |
||||||
|
|
||||||
|
static void arena_dofree(upb_Arena* a) { |
||||||
|
mem_block* block = a->freelist; |
||||||
|
UPB_ASSERT(a->parent == a); |
||||||
|
UPB_ASSERT(a->refcount == 0); |
||||||
|
|
||||||
|
while (block) { |
||||||
|
/* Load first since we are deleting block. */ |
||||||
|
mem_block* next = block->next; |
||||||
|
|
||||||
|
if (block->cleanups > 0) { |
||||||
|
cleanup_ent* end = UPB_PTR_AT(block, block->size, void); |
||||||
|
cleanup_ent* ptr = end - block->cleanups; |
||||||
|
|
||||||
|
for (; ptr < end; ptr++) { |
||||||
|
ptr->cleanup(ptr->ud); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
upb_free(a->block_alloc, block); |
||||||
|
block = next; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void upb_Arena_Free(upb_Arena* a) { |
||||||
|
a = arena_findroot(a); |
||||||
|
if (--a->refcount == 0) arena_dofree(a); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_Arena_AddCleanup(upb_Arena* a, void* ud, upb_CleanupFunc* func) { |
||||||
|
cleanup_ent* ent; |
||||||
|
uint32_t* cleanups = upb_cleanup_pointer(a->cleanup_metadata); |
||||||
|
|
||||||
|
if (!cleanups || _upb_ArenaHas(a) < sizeof(cleanup_ent)) { |
||||||
|
if (!upb_Arena_Allocblock(a, 128)) return false; /* Out of memory. */ |
||||||
|
UPB_ASSERT(_upb_ArenaHas(a) >= sizeof(cleanup_ent)); |
||||||
|
cleanups = upb_cleanup_pointer(a->cleanup_metadata); |
||||||
|
} |
||||||
|
|
||||||
|
a->head.end -= sizeof(cleanup_ent); |
||||||
|
ent = (cleanup_ent*)a->head.end; |
||||||
|
(*cleanups)++; |
||||||
|
UPB_UNPOISON_MEMORY_REGION(ent, sizeof(cleanup_ent)); |
||||||
|
|
||||||
|
ent->cleanup = func; |
||||||
|
ent->ud = ud; |
||||||
|
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_Arena_Fuse(upb_Arena* a1, upb_Arena* a2) { |
||||||
|
upb_Arena* r1 = arena_findroot(a1); |
||||||
|
upb_Arena* r2 = arena_findroot(a2); |
||||||
|
|
||||||
|
if (r1 == r2) return true; /* Already fused. */ |
||||||
|
|
||||||
|
/* Do not fuse initial blocks since we cannot lifetime extend them. */ |
||||||
|
if (upb_cleanup_has_initial_block(r1->cleanup_metadata)) return false; |
||||||
|
if (upb_cleanup_has_initial_block(r2->cleanup_metadata)) return false; |
||||||
|
|
||||||
|
/* Only allow fuse with a common allocator */ |
||||||
|
if (r1->block_alloc != r2->block_alloc) return false; |
||||||
|
|
||||||
|
/* We want to join the smaller tree to the larger tree.
|
||||||
|
* So swap first if they are backwards. */ |
||||||
|
if (r1->refcount < r2->refcount) { |
||||||
|
upb_Arena* tmp = r1; |
||||||
|
r1 = r2; |
||||||
|
r2 = tmp; |
||||||
|
} |
||||||
|
|
||||||
|
/* r1 takes over r2's freelist and refcount. */ |
||||||
|
r1->refcount += r2->refcount; |
||||||
|
if (r2->freelist_tail) { |
||||||
|
UPB_ASSERT(r2->freelist_tail->next == NULL); |
||||||
|
r2->freelist_tail->next = r1->freelist; |
||||||
|
r1->freelist = r2->freelist; |
||||||
|
} |
||||||
|
r2->parent = r1; |
||||||
|
return true; |
||||||
|
} |
||||||
@ -0,0 +1,225 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_ARENA_H_ |
||||||
|
#define UPB_ARENA_H_ |
||||||
|
|
||||||
|
#include <assert.h> |
||||||
|
#include <stdbool.h> |
||||||
|
#include <stdint.h> |
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
/** upb_alloc *****************************************************************/ |
||||||
|
|
||||||
|
/* A upb_alloc is a possibly-stateful allocator object.
|
||||||
|
* |
||||||
|
* It could either be an arena allocator (which doesn't require individual |
||||||
|
* free() calls) or a regular malloc() (which does). The client must therefore |
||||||
|
* free memory unless it knows that the allocator is an arena allocator. */ |
||||||
|
|
||||||
|
struct upb_alloc; |
||||||
|
typedef struct upb_alloc upb_alloc; |
||||||
|
|
||||||
|
/* A malloc()/free() function.
|
||||||
|
* If "size" is 0 then the function acts like free(), otherwise it acts like |
||||||
|
* realloc(). Only "oldsize" bytes from a previous allocation are preserved. */ |
||||||
|
typedef void* upb_alloc_func(upb_alloc* alloc, void* ptr, size_t oldsize, |
||||||
|
size_t size); |
||||||
|
|
||||||
|
struct upb_alloc { |
||||||
|
upb_alloc_func* func; |
||||||
|
}; |
||||||
|
|
||||||
|
UPB_INLINE void* upb_malloc(upb_alloc* alloc, size_t size) { |
||||||
|
UPB_ASSERT(alloc); |
||||||
|
return alloc->func(alloc, NULL, 0, size); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void* upb_realloc(upb_alloc* alloc, void* ptr, size_t oldsize, |
||||||
|
size_t size) { |
||||||
|
UPB_ASSERT(alloc); |
||||||
|
return alloc->func(alloc, ptr, oldsize, size); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void upb_free(upb_alloc* alloc, void* ptr) { |
||||||
|
assert(alloc); |
||||||
|
alloc->func(alloc, ptr, 0, 0); |
||||||
|
} |
||||||
|
|
||||||
|
/* The global allocator used by upb. Uses the standard malloc()/free(). */ |
||||||
|
|
||||||
|
extern upb_alloc upb_alloc_global; |
||||||
|
|
||||||
|
/* Functions that hard-code the global malloc.
|
||||||
|
* |
||||||
|
* We still get benefit because we can put custom logic into our global |
||||||
|
* allocator, like injecting out-of-memory faults in debug/testing builds. */ |
||||||
|
|
||||||
|
UPB_INLINE void* upb_gmalloc(size_t size) { |
||||||
|
return upb_malloc(&upb_alloc_global, size); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void* upb_grealloc(void* ptr, size_t oldsize, size_t size) { |
||||||
|
return upb_realloc(&upb_alloc_global, ptr, oldsize, size); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void upb_gfree(void* ptr) { upb_free(&upb_alloc_global, ptr); } |
||||||
|
|
||||||
|
/* upb_Arena ******************************************************************/ |
||||||
|
|
||||||
|
/* upb_Arena is a specific allocator implementation that uses arena allocation.
|
||||||
|
* The user provides an allocator that will be used to allocate the underlying |
||||||
|
* arena blocks. Arenas by nature do not require the individual allocations |
||||||
|
* to be freed. However the Arena does allow users to register cleanup |
||||||
|
* functions that will run when the arena is destroyed. |
||||||
|
* |
||||||
|
* A upb_Arena is *not* thread-safe. |
||||||
|
* |
||||||
|
* You could write a thread-safe arena allocator that satisfies the |
||||||
|
* upb_alloc interface, but it would not be as efficient for the |
||||||
|
* single-threaded case. */ |
||||||
|
|
||||||
|
typedef void upb_CleanupFunc(void* ud); |
||||||
|
|
||||||
|
struct upb_Arena; |
||||||
|
typedef struct upb_Arena upb_Arena; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
/* We implement the allocator interface.
|
||||||
|
* This must be the first member of upb_Arena! |
||||||
|
* TODO(haberman): remove once handlers are gone. */ |
||||||
|
upb_alloc alloc; |
||||||
|
|
||||||
|
char *ptr, *end; |
||||||
|
} _upb_ArenaHead; |
||||||
|
|
||||||
|
/* Creates an arena from the given initial block (if any -- n may be 0).
|
||||||
|
* Additional blocks will be allocated from |alloc|. If |alloc| is NULL, this |
||||||
|
* is a fixed-size arena and cannot grow. */ |
||||||
|
upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc); |
||||||
|
void upb_Arena_Free(upb_Arena* a); |
||||||
|
bool upb_Arena_AddCleanup(upb_Arena* a, void* ud, upb_CleanupFunc* func); |
||||||
|
bool upb_Arena_Fuse(upb_Arena* a, upb_Arena* b); |
||||||
|
void* _upb_Arena_SlowMalloc(upb_Arena* a, size_t size); |
||||||
|
|
||||||
|
UPB_INLINE upb_alloc* upb_Arena_Alloc(upb_Arena* a) { return (upb_alloc*)a; } |
||||||
|
|
||||||
|
UPB_INLINE size_t _upb_ArenaHas(upb_Arena* a) { |
||||||
|
_upb_ArenaHead* h = (_upb_ArenaHead*)a; |
||||||
|
return (size_t)(h->end - h->ptr); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void* _upb_Arena_FastMalloc(upb_Arena* a, size_t size) { |
||||||
|
_upb_ArenaHead* h = (_upb_ArenaHead*)a; |
||||||
|
void* ret = h->ptr; |
||||||
|
UPB_ASSERT(UPB_ALIGN_MALLOC((uintptr_t)ret) == (uintptr_t)ret); |
||||||
|
UPB_ASSERT(UPB_ALIGN_MALLOC(size) == size); |
||||||
|
UPB_UNPOISON_MEMORY_REGION(ret, size); |
||||||
|
|
||||||
|
h->ptr += size; |
||||||
|
|
||||||
|
#if UPB_ASAN |
||||||
|
{ |
||||||
|
size_t guard_size = 32; |
||||||
|
if (_upb_ArenaHas(a) >= guard_size) { |
||||||
|
h->ptr += guard_size; |
||||||
|
} else { |
||||||
|
h->ptr = h->end; |
||||||
|
} |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void* upb_Arena_Malloc(upb_Arena* a, size_t size) { |
||||||
|
size = UPB_ALIGN_MALLOC(size); |
||||||
|
|
||||||
|
if (UPB_UNLIKELY(_upb_ArenaHas(a) < size)) { |
||||||
|
return _upb_Arena_SlowMalloc(a, size); |
||||||
|
} |
||||||
|
|
||||||
|
return _upb_Arena_FastMalloc(a, size); |
||||||
|
} |
||||||
|
|
||||||
|
// Shrinks the last alloc from arena.
|
||||||
|
// REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
|
||||||
|
// We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
|
||||||
|
// this was not the last alloc.
|
||||||
|
UPB_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr, size_t oldsize, |
||||||
|
size_t size) { |
||||||
|
_upb_ArenaHead* h = (_upb_ArenaHead*)a; |
||||||
|
oldsize = UPB_ALIGN_MALLOC(oldsize); |
||||||
|
size = UPB_ALIGN_MALLOC(size); |
||||||
|
UPB_ASSERT((char*)ptr + oldsize == h->ptr); // Must be the last alloc.
|
||||||
|
UPB_ASSERT(size <= oldsize); |
||||||
|
h->ptr = (char*)ptr + size; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize, |
||||||
|
size_t size) { |
||||||
|
_upb_ArenaHead* h = (_upb_ArenaHead*)a; |
||||||
|
oldsize = UPB_ALIGN_MALLOC(oldsize); |
||||||
|
size = UPB_ALIGN_MALLOC(size); |
||||||
|
bool is_most_recent_alloc = (uintptr_t)ptr + oldsize == (uintptr_t)h->ptr; |
||||||
|
|
||||||
|
if (is_most_recent_alloc) { |
||||||
|
ptrdiff_t diff = size - oldsize; |
||||||
|
if ((ptrdiff_t)_upb_ArenaHas(a) >= diff) { |
||||||
|
h->ptr += diff; |
||||||
|
return ptr; |
||||||
|
} |
||||||
|
} else if (size <= oldsize) { |
||||||
|
return ptr; |
||||||
|
} |
||||||
|
|
||||||
|
void* ret = upb_Arena_Malloc(a, size); |
||||||
|
|
||||||
|
if (ret && oldsize > 0) { |
||||||
|
memcpy(ret, ptr, UPB_MIN(oldsize, size)); |
||||||
|
} |
||||||
|
|
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE upb_Arena* upb_Arena_New(void) { |
||||||
|
return upb_Arena_Init(NULL, 0, &upb_alloc_global); |
||||||
|
} |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#endif /* UPB_ARENA_H_ */ |
||||||
@ -0,0 +1,114 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "upb/array.h" |
||||||
|
|
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include "upb/internal/table.h" |
||||||
|
#include "upb/msg.h" |
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
static const char _upb_CTypeo_sizelg2[12] = { |
||||||
|
0, |
||||||
|
0, /* kUpb_CType_Bool */ |
||||||
|
2, /* kUpb_CType_Float */ |
||||||
|
2, /* kUpb_CType_Int32 */ |
||||||
|
2, /* kUpb_CType_UInt32 */ |
||||||
|
2, /* kUpb_CType_Enum */ |
||||||
|
UPB_SIZE(2, 3), /* kUpb_CType_Message */ |
||||||
|
3, /* kUpb_CType_Double */ |
||||||
|
3, /* kUpb_CType_Int64 */ |
||||||
|
3, /* kUpb_CType_UInt64 */ |
||||||
|
UPB_SIZE(3, 4), /* kUpb_CType_String */ |
||||||
|
UPB_SIZE(3, 4), /* kUpb_CType_Bytes */ |
||||||
|
}; |
||||||
|
|
||||||
|
upb_Array* upb_Array_New(upb_Arena* a, upb_CType type) { |
||||||
|
return _upb_Array_New(a, 4, _upb_CTypeo_sizelg2[type]); |
||||||
|
} |
||||||
|
|
||||||
|
size_t upb_Array_Size(const upb_Array* arr) { return arr->len; } |
||||||
|
|
||||||
|
upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i) { |
||||||
|
upb_MessageValue ret; |
||||||
|
const char* data = _upb_array_constptr(arr); |
||||||
|
int lg2 = arr->data & 7; |
||||||
|
UPB_ASSERT(i < arr->len); |
||||||
|
memcpy(&ret, data + (i << lg2), 1 << lg2); |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val) { |
||||||
|
char* data = _upb_array_ptr(arr); |
||||||
|
int lg2 = arr->data & 7; |
||||||
|
UPB_ASSERT(i < arr->len); |
||||||
|
memcpy(data + (i << lg2), &val, 1 << lg2); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_Array_Append(upb_Array* arr, upb_MessageValue val, upb_Arena* arena) { |
||||||
|
if (!upb_Array_Resize(arr, arr->len + 1, arena)) { |
||||||
|
return false; |
||||||
|
} |
||||||
|
upb_Array_Set(arr, arr->len - 1, val); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_Array_Move(upb_Array* arr, size_t dst_idx, size_t src_idx, |
||||||
|
size_t count) { |
||||||
|
char* data = _upb_array_ptr(arr); |
||||||
|
int lg2 = arr->data & 7; |
||||||
|
memmove(&data[dst_idx << lg2], &data[src_idx << lg2], count << lg2); |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_Array_Insert(upb_Array* arr, size_t i, size_t count, |
||||||
|
upb_Arena* arena) { |
||||||
|
UPB_ASSERT(i <= arr->len); |
||||||
|
UPB_ASSERT(count + arr->len >= count); |
||||||
|
size_t oldsize = arr->len; |
||||||
|
if (!upb_Array_Resize(arr, arr->len + count, arena)) { |
||||||
|
return false; |
||||||
|
} |
||||||
|
upb_Array_Move(arr, i + count, i, oldsize - i); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* i end arr->len |
||||||
|
* |------------|XXXXXXXX|--------| |
||||||
|
*/ |
||||||
|
void upb_Array_Delete(upb_Array* arr, size_t i, size_t count) { |
||||||
|
size_t end = i + count; |
||||||
|
UPB_ASSERT(i <= end); |
||||||
|
UPB_ASSERT(end <= arr->len); |
||||||
|
upb_Array_Move(arr, i, end, arr->len - end); |
||||||
|
arr->len -= count; |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_Array_Resize(upb_Array* arr, size_t size, upb_Arena* arena) { |
||||||
|
return _upb_Array_Resize(arr, size, arena); |
||||||
|
} |
||||||
@ -0,0 +1,83 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_ARRAY_H_ |
||||||
|
#define UPB_ARRAY_H_ |
||||||
|
|
||||||
|
#include "google/protobuf/descriptor.upb.h" |
||||||
|
#include "upb/message_value.h" |
||||||
|
|
||||||
|
// Must be last.
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
/* Creates a new array on the given arena that holds elements of this type. */ |
||||||
|
upb_Array* upb_Array_New(upb_Arena* a, upb_CType type); |
||||||
|
|
||||||
|
/* Returns the size of the array. */ |
||||||
|
size_t upb_Array_Size(const upb_Array* arr); |
||||||
|
|
||||||
|
/* Returns the given element, which must be within the array's current size. */ |
||||||
|
upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i); |
||||||
|
|
||||||
|
/* Sets the given element, which must be within the array's current size. */ |
||||||
|
void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val); |
||||||
|
|
||||||
|
/* Appends an element to the array. Returns false on allocation failure. */ |
||||||
|
bool upb_Array_Append(upb_Array* array, upb_MessageValue val, upb_Arena* arena); |
||||||
|
|
||||||
|
/* Moves elements within the array using memmove(). Like memmove(), the source
|
||||||
|
* and destination elements may be overlapping. */ |
||||||
|
void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx, |
||||||
|
size_t count); |
||||||
|
|
||||||
|
/* Inserts one or more empty elements into the array. Existing elements are
|
||||||
|
* shifted right. The new elements have undefined state and must be set with |
||||||
|
* `upb_Array_Set()`. |
||||||
|
* REQUIRES: `i <= upb_Array_Size(arr)` */ |
||||||
|
bool upb_Array_Insert(upb_Array* array, size_t i, size_t count, |
||||||
|
upb_Arena* arena); |
||||||
|
|
||||||
|
/* Deletes one or more elements from the array. Existing elements are shifted
|
||||||
|
* left. |
||||||
|
* REQUIRES: `i + count <= upb_Array_Size(arr)` */ |
||||||
|
void upb_Array_Delete(upb_Array* array, size_t i, size_t count); |
||||||
|
|
||||||
|
/* Changes the size of a vector. New elements are initialized to empty/0.
|
||||||
|
* Returns false on allocation failure. */ |
||||||
|
bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena); |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#endif /* UPB_ARRAY_H_ */ |
||||||
@ -0,0 +1,93 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "upb/extension_registry.h" |
||||||
|
|
||||||
|
#include "upb/internal/table.h" |
||||||
|
#include "upb/msg.h" |
||||||
|
#include "upb/msg_internal.h" |
||||||
|
|
||||||
|
// Must be last.
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
struct upb_ExtensionRegistry { |
||||||
|
upb_Arena* arena; |
||||||
|
upb_strtable exts; /* Key is upb_MiniTable* concatenated with fieldnum. */ |
||||||
|
}; |
||||||
|
|
||||||
|
#define EXTREG_KEY_SIZE (sizeof(upb_MiniTable*) + sizeof(uint32_t)) |
||||||
|
|
||||||
|
static void extreg_key(char* buf, const upb_MiniTable* l, uint32_t fieldnum) { |
||||||
|
memcpy(buf, &l, sizeof(l)); |
||||||
|
memcpy(buf + sizeof(l), &fieldnum, sizeof(fieldnum)); |
||||||
|
} |
||||||
|
|
||||||
|
upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena) { |
||||||
|
upb_ExtensionRegistry* r = upb_Arena_Malloc(arena, sizeof(*r)); |
||||||
|
if (!r) return NULL; |
||||||
|
r->arena = arena; |
||||||
|
if (!upb_strtable_init(&r->exts, 8, arena)) return NULL; |
||||||
|
return r; |
||||||
|
} |
||||||
|
|
||||||
|
bool _upb_extreg_add(upb_ExtensionRegistry* r, |
||||||
|
const upb_MiniTable_Extension** e, size_t count) { |
||||||
|
char buf[EXTREG_KEY_SIZE]; |
||||||
|
const upb_MiniTable_Extension** start = e; |
||||||
|
const upb_MiniTable_Extension** end = UPB_PTRADD(e, count); |
||||||
|
for (; e < end; e++) { |
||||||
|
const upb_MiniTable_Extension* ext = *e; |
||||||
|
extreg_key(buf, ext->extendee, ext->field.number); |
||||||
|
if (!upb_strtable_insert(&r->exts, buf, EXTREG_KEY_SIZE, |
||||||
|
upb_value_constptr(ext), r->arena)) { |
||||||
|
goto failure; |
||||||
|
} |
||||||
|
} |
||||||
|
return true; |
||||||
|
|
||||||
|
failure: |
||||||
|
/* Back out the entries previously added. */ |
||||||
|
for (end = e, e = start; e < end; e++) { |
||||||
|
const upb_MiniTable_Extension* ext = *e; |
||||||
|
extreg_key(buf, ext->extendee, ext->field.number); |
||||||
|
upb_strtable_remove2(&r->exts, buf, EXTREG_KEY_SIZE, NULL); |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
const upb_MiniTable_Extension* _upb_extreg_get(const upb_ExtensionRegistry* r, |
||||||
|
const upb_MiniTable* l, |
||||||
|
uint32_t num) { |
||||||
|
char buf[EXTREG_KEY_SIZE]; |
||||||
|
upb_value v; |
||||||
|
extreg_key(buf, l, num); |
||||||
|
if (upb_strtable_lookup2(&r->exts, buf, EXTREG_KEY_SIZE, &v)) { |
||||||
|
return upb_value_getconstptr(v); |
||||||
|
} else { |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,84 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_EXTENSION_REGISTRY_H_ |
||||||
|
#define UPB_EXTENSION_REGISTRY_H_ |
||||||
|
|
||||||
|
#include <stddef.h> |
||||||
|
|
||||||
|
#include "upb/upb.h" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
/* Extension registry: a dynamic data structure that stores a map of:
|
||||||
|
* (upb_MiniTable, number) -> extension info |
||||||
|
* |
||||||
|
* upb_decode() uses upb_ExtensionRegistry to look up extensions while parsing |
||||||
|
* binary format. |
||||||
|
* |
||||||
|
* upb_ExtensionRegistry is part of the mini-table (msglayout) family of |
||||||
|
* objects. Like all mini-table objects, it is suitable for reflection-less |
||||||
|
* builds that do not want to expose names into the binary. |
||||||
|
* |
||||||
|
* Unlike most mini-table types, upb_ExtensionRegistry requires dynamic memory |
||||||
|
* allocation and dynamic initialization: |
||||||
|
* * If reflection is being used, then upb_DefPool will construct an appropriate |
||||||
|
* upb_ExtensionRegistry automatically. |
||||||
|
* * For a mini-table only build, the user must manually construct the |
||||||
|
* upb_ExtensionRegistry and populate it with all of the extensions the user |
||||||
|
* cares about. |
||||||
|
* * A third alternative is to manually unpack relevant extensions after the |
||||||
|
* main parse is complete, similar to how Any works. This is perhaps the |
||||||
|
* nicest solution from the perspective of reducing dependencies, avoiding |
||||||
|
* dynamic memory allocation, and avoiding the need to parse uninteresting |
||||||
|
* extensions. The downsides are: |
||||||
|
* (1) parse errors are not caught during the main parse |
||||||
|
* (2) the CPU hit of parsing comes during access, which could cause an |
||||||
|
* undesirable stutter in application performance. |
||||||
|
* |
||||||
|
* Users cannot directly get or put into this map. Users can only add the |
||||||
|
* extensions from a generated module and pass the extension registry to the |
||||||
|
* binary decoder. |
||||||
|
* |
||||||
|
* A upb_DefPool provides a upb_ExtensionRegistry, so any users who use |
||||||
|
* reflection do not need to populate a upb_ExtensionRegistry directly. |
||||||
|
*/ |
||||||
|
|
||||||
|
struct upb_ExtensionRegistry; |
||||||
|
typedef struct upb_ExtensionRegistry upb_ExtensionRegistry; |
||||||
|
|
||||||
|
/* Creates a upb_ExtensionRegistry in the given arena. The arena must outlive
|
||||||
|
* any use of the extreg. */ |
||||||
|
upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena); |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#endif /* UPB_EXTENSION_REGISTRY_H_ */ |
||||||
@ -0,0 +1,211 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
/*
|
||||||
|
* Internal implementation details of the decoder that are shared between |
||||||
|
* decode.c and decode_fast.c. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_INTERNAL_DECODE_H_ |
||||||
|
#define UPB_INTERNAL_DECODE_H_ |
||||||
|
|
||||||
|
#include <setjmp.h> |
||||||
|
|
||||||
|
#include "upb/decode.h" |
||||||
|
#include "upb/internal/upb.h" |
||||||
|
#include "upb/msg_internal.h" |
||||||
|
#include "third_party/utf8_range/utf8_range.h" |
||||||
|
|
||||||
|
/* Must be last. */ |
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#define DECODE_NOGROUP (uint32_t) - 1 |
||||||
|
|
||||||
|
typedef struct upb_Decoder { |
||||||
|
const char* end; /* Can read up to 16 bytes slop beyond this. */ |
||||||
|
const char* limit_ptr; /* = end + UPB_MIN(limit, 0) */ |
||||||
|
upb_Message* unknown_msg; /* If non-NULL, add unknown data at buffer flip. */ |
||||||
|
const char* unknown; /* Start of unknown data. */ |
||||||
|
const upb_ExtensionRegistry* |
||||||
|
extreg; /* For looking up extensions during the parse. */ |
||||||
|
int limit; /* Submessage limit relative to end. */ |
||||||
|
int depth; /* Tracks recursion depth to bound stack usage. */ |
||||||
|
uint32_t end_group; /* field number of END_GROUP tag, else DECODE_NOGROUP */ |
||||||
|
uint16_t options; |
||||||
|
bool missing_required; |
||||||
|
char patch[32]; |
||||||
|
upb_Arena arena; |
||||||
|
jmp_buf err; |
||||||
|
|
||||||
|
#ifndef NDEBUG |
||||||
|
const char* debug_tagstart; |
||||||
|
const char* debug_valstart; |
||||||
|
#endif |
||||||
|
} upb_Decoder; |
||||||
|
|
||||||
|
/* Error function that will abort decoding with longjmp(). We can't declare this
|
||||||
|
* UPB_NORETURN, even though it is appropriate, because if we do then compilers |
||||||
|
* will "helpfully" refuse to tailcall to it |
||||||
|
* (see: https://stackoverflow.com/a/55657013), which will defeat a major goal
|
||||||
|
* of our optimizations. That is also why we must declare it in a separate file, |
||||||
|
* otherwise the compiler will see that it calls longjmp() and deduce that it is |
||||||
|
* noreturn. */ |
||||||
|
const char* fastdecode_err(upb_Decoder* d, int status); |
||||||
|
|
||||||
|
extern const uint8_t upb_utf8_offsets[]; |
||||||
|
|
||||||
|
UPB_INLINE |
||||||
|
bool decode_verifyutf8_inl(const char* ptr, int len) { |
||||||
|
const char* end = ptr + len; |
||||||
|
|
||||||
|
// Check 8 bytes at a time for any non-ASCII char.
|
||||||
|
while (end - ptr >= 8) { |
||||||
|
uint64_t data; |
||||||
|
memcpy(&data, ptr, 8); |
||||||
|
if (data & 0x8080808080808080) goto non_ascii; |
||||||
|
ptr += 8; |
||||||
|
} |
||||||
|
|
||||||
|
// Check one byte at a time for non-ASCII.
|
||||||
|
while (ptr < end) { |
||||||
|
if (*ptr & 0x80) goto non_ascii; |
||||||
|
ptr++; |
||||||
|
} |
||||||
|
|
||||||
|
return true; |
||||||
|
|
||||||
|
non_ascii: |
||||||
|
return utf8_range2((const unsigned char*)ptr, end - ptr) == 0; |
||||||
|
} |
||||||
|
|
||||||
|
const char* decode_checkrequired(upb_Decoder* d, const char* ptr, |
||||||
|
const upb_Message* msg, |
||||||
|
const upb_MiniTable* l); |
||||||
|
|
||||||
|
/* x86-64 pointers always have the high 16 bits matching. So we can shift
|
||||||
|
* left 8 and right 8 without loss of information. */ |
||||||
|
UPB_INLINE intptr_t decode_totable(const upb_MiniTable* tablep) { |
||||||
|
return ((intptr_t)tablep << 8) | tablep->table_mask; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE const upb_MiniTable* decode_totablep(intptr_t table) { |
||||||
|
return (const upb_MiniTable*)(table >> 8); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE |
||||||
|
const char* decode_isdonefallback_inl(upb_Decoder* d, const char* ptr, |
||||||
|
int overrun, int* status) { |
||||||
|
if (overrun < d->limit) { |
||||||
|
/* Need to copy remaining data into patch buffer. */ |
||||||
|
UPB_ASSERT(overrun < 16); |
||||||
|
if (d->unknown_msg) { |
||||||
|
if (!_upb_Message_AddUnknown(d->unknown_msg, d->unknown, ptr - d->unknown, |
||||||
|
&d->arena)) { |
||||||
|
*status = kUpb_DecodeStatus_OutOfMemory; |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
d->unknown = &d->patch[0] + overrun; |
||||||
|
} |
||||||
|
memset(d->patch + 16, 0, 16); |
||||||
|
memcpy(d->patch, d->end, 16); |
||||||
|
ptr = &d->patch[0] + overrun; |
||||||
|
d->end = &d->patch[16]; |
||||||
|
d->limit -= 16; |
||||||
|
d->limit_ptr = d->end + d->limit; |
||||||
|
d->options &= ~kUpb_DecodeOption_AliasString; |
||||||
|
UPB_ASSERT(ptr < d->limit_ptr); |
||||||
|
return ptr; |
||||||
|
} else { |
||||||
|
*status = kUpb_DecodeStatus_Malformed; |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
const char* decode_isdonefallback(upb_Decoder* d, const char* ptr, int overrun); |
||||||
|
|
||||||
|
UPB_INLINE |
||||||
|
bool decode_isdone(upb_Decoder* d, const char** ptr) { |
||||||
|
int overrun = *ptr - d->end; |
||||||
|
if (UPB_LIKELY(*ptr < d->limit_ptr)) { |
||||||
|
return false; |
||||||
|
} else if (UPB_LIKELY(overrun == d->limit)) { |
||||||
|
return true; |
||||||
|
} else { |
||||||
|
*ptr = decode_isdonefallback(d, *ptr, overrun); |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
#if UPB_FASTTABLE |
||||||
|
UPB_INLINE |
||||||
|
const char* fastdecode_tagdispatch(upb_Decoder* d, const char* ptr, |
||||||
|
upb_Message* msg, intptr_t table, |
||||||
|
uint64_t hasbits, uint64_t tag) { |
||||||
|
const upb_MiniTable* table_p = decode_totablep(table); |
||||||
|
uint8_t mask = table; |
||||||
|
uint64_t data; |
||||||
|
size_t idx = tag & mask; |
||||||
|
UPB_ASSUME((idx & 7) == 0); |
||||||
|
idx >>= 3; |
||||||
|
data = table_p->fasttable[idx].field_data ^ tag; |
||||||
|
UPB_MUSTTAIL return table_p->fasttable[idx].field_parser(d, ptr, msg, table, |
||||||
|
hasbits, data); |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
UPB_INLINE uint32_t fastdecode_loadtag(const char* ptr) { |
||||||
|
uint16_t tag; |
||||||
|
memcpy(&tag, ptr, 2); |
||||||
|
return tag; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void decode_checklimit(upb_Decoder* d) { |
||||||
|
UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit)); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE int decode_pushlimit(upb_Decoder* d, const char* ptr, int size) { |
||||||
|
int limit = size + (int)(ptr - d->end); |
||||||
|
int delta = d->limit - limit; |
||||||
|
decode_checklimit(d); |
||||||
|
d->limit = limit; |
||||||
|
d->limit_ptr = d->end + UPB_MIN(0, limit); |
||||||
|
decode_checklimit(d); |
||||||
|
return delta; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void decode_poplimit(upb_Decoder* d, const char* ptr, |
||||||
|
int saved_delta) { |
||||||
|
UPB_ASSERT(ptr - d->end == d->limit); |
||||||
|
decode_checklimit(d); |
||||||
|
d->limit += saved_delta; |
||||||
|
d->limit_ptr = d->end + UPB_MIN(0, d->limit); |
||||||
|
decode_checklimit(d); |
||||||
|
} |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#endif /* UPB_INTERNAL_DECODE_H_ */ |
||||||
@ -0,0 +1,59 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2022, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_INTERNAL_MINI_TABLE_ACCESSORS_H_ |
||||||
|
#define UPB_INTERNAL_MINI_TABLE_ACCESSORS_H_ |
||||||
|
|
||||||
|
#include "upb/msg_internal.h" |
||||||
|
|
||||||
|
// Must be last.
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
UPB_INLINE bool _upb_MiniTable_Field_InOneOf(const upb_MiniTable_Field* field) { |
||||||
|
return field->presence < 0; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void _upb_MiniTable_SetPresence(upb_Message* msg, |
||||||
|
const upb_MiniTable_Field* field) { |
||||||
|
if (field->presence > 0) { |
||||||
|
_upb_sethas_field(msg, field); |
||||||
|
} else if (_upb_MiniTable_Field_InOneOf(field)) { |
||||||
|
*_upb_oneofcase_field(msg, field) = field->number; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#endif // UPB_INTERNAL_MINI_TABLE_ACCESSORS_H_
|
||||||
@ -0,0 +1,385 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
/*
|
||||||
|
* upb_table |
||||||
|
* |
||||||
|
* This header is INTERNAL-ONLY! Its interfaces are not public or stable! |
||||||
|
* This file defines very fast int->upb_value (inttable) and string->upb_value |
||||||
|
* (strtable) hash tables. |
||||||
|
* |
||||||
|
* The table uses chained scatter with Brent's variation (inspired by the Lua |
||||||
|
* implementation of hash tables). The hash function for strings is Austin |
||||||
|
* Appleby's "MurmurHash." |
||||||
|
* |
||||||
|
* The inttable uses uintptr_t as its key, which guarantees it can be used to |
||||||
|
* store pointers or integers of at least 32 bits (upb isn't really useful on |
||||||
|
* systems where sizeof(void*) < 4). |
||||||
|
* |
||||||
|
* The table must be homogeneous (all values of the same type). In debug |
||||||
|
* mode, we check this on insert and lookup. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_INTERNAL_TABLE_H_ |
||||||
|
#define UPB_INTERNAL_TABLE_H_ |
||||||
|
|
||||||
|
#include <stdint.h> |
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include "upb/upb.h" |
||||||
|
|
||||||
|
// Must be last.
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
/* upb_value ******************************************************************/ |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
uint64_t val; |
||||||
|
} upb_value; |
||||||
|
|
||||||
|
/* Variant that works with a length-delimited rather than NULL-delimited string,
|
||||||
|
* as supported by strtable. */ |
||||||
|
char* upb_strdup2(const char* s, size_t len, upb_Arena* a); |
||||||
|
|
||||||
|
UPB_INLINE void _upb_value_setval(upb_value* v, uint64_t val) { v->val = val; } |
||||||
|
|
||||||
|
/* For each value ctype, define the following set of functions:
|
||||||
|
* |
||||||
|
* // Get/set an int32 from a upb_value.
|
||||||
|
* int32_t upb_value_getint32(upb_value val); |
||||||
|
* void upb_value_setint32(upb_value *val, int32_t cval); |
||||||
|
* |
||||||
|
* // Construct a new upb_value from an int32.
|
||||||
|
* upb_value upb_value_int32(int32_t val); */ |
||||||
|
#define FUNCS(name, membername, type_t, converter, proto_type) \ |
||||||
|
UPB_INLINE void upb_value_set##name(upb_value* val, type_t cval) { \
|
||||||
|
val->val = (converter)cval; \
|
||||||
|
} \
|
||||||
|
UPB_INLINE upb_value upb_value_##name(type_t val) { \
|
||||||
|
upb_value ret; \
|
||||||
|
upb_value_set##name(&ret, val); \
|
||||||
|
return ret; \
|
||||||
|
} \
|
||||||
|
UPB_INLINE type_t upb_value_get##name(upb_value val) { \
|
||||||
|
return (type_t)(converter)val.val; \
|
||||||
|
} |
||||||
|
|
||||||
|
FUNCS(int32, int32, int32_t, int32_t, UPB_CTYPE_INT32) |
||||||
|
FUNCS(int64, int64, int64_t, int64_t, UPB_CTYPE_INT64) |
||||||
|
FUNCS(uint32, uint32, uint32_t, uint32_t, UPB_CTYPE_UINT32) |
||||||
|
FUNCS(uint64, uint64, uint64_t, uint64_t, UPB_CTYPE_UINT64) |
||||||
|
FUNCS(bool, _bool, bool, bool, UPB_CTYPE_BOOL) |
||||||
|
FUNCS(cstr, cstr, char*, uintptr_t, UPB_CTYPE_CSTR) |
||||||
|
FUNCS(ptr, ptr, void*, uintptr_t, UPB_CTYPE_PTR) |
||||||
|
FUNCS(constptr, constptr, const void*, uintptr_t, UPB_CTYPE_CONSTPTR) |
||||||
|
|
||||||
|
#undef FUNCS |
||||||
|
|
||||||
|
UPB_INLINE void upb_value_setfloat(upb_value* val, float cval) { |
||||||
|
memcpy(&val->val, &cval, sizeof(cval)); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE void upb_value_setdouble(upb_value* val, double cval) { |
||||||
|
memcpy(&val->val, &cval, sizeof(cval)); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE upb_value upb_value_float(float cval) { |
||||||
|
upb_value ret; |
||||||
|
upb_value_setfloat(&ret, cval); |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE upb_value upb_value_double(double cval) { |
||||||
|
upb_value ret; |
||||||
|
upb_value_setdouble(&ret, cval); |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
#undef SET_TYPE |
||||||
|
|
||||||
|
/* upb_tabkey *****************************************************************/ |
||||||
|
|
||||||
|
/* Either:
|
||||||
|
* 1. an actual integer key, or |
||||||
|
* 2. a pointer to a string prefixed by its uint32_t length, owned by us. |
||||||
|
* |
||||||
|
* ...depending on whether this is a string table or an int table. We would |
||||||
|
* make this a union of those two types, but C89 doesn't support statically |
||||||
|
* initializing a non-first union member. */ |
||||||
|
typedef uintptr_t upb_tabkey; |
||||||
|
|
||||||
|
UPB_INLINE char* upb_tabstr(upb_tabkey key, uint32_t* len) { |
||||||
|
char* mem = (char*)key; |
||||||
|
if (len) memcpy(len, mem, sizeof(*len)); |
||||||
|
return mem + sizeof(*len); |
||||||
|
} |
||||||
|
|
||||||
|
UPB_INLINE upb_StringView upb_tabstrview(upb_tabkey key) { |
||||||
|
upb_StringView ret; |
||||||
|
uint32_t len; |
||||||
|
ret.data = upb_tabstr(key, &len); |
||||||
|
ret.size = len; |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
/* upb_tabval *****************************************************************/ |
||||||
|
|
||||||
|
typedef struct upb_tabval { |
||||||
|
uint64_t val; |
||||||
|
} upb_tabval; |
||||||
|
|
||||||
|
#define UPB_TABVALUE_EMPTY_INIT \ |
||||||
|
{ -1 } |
||||||
|
|
||||||
|
/* upb_table ******************************************************************/ |
||||||
|
|
||||||
|
typedef struct _upb_tabent { |
||||||
|
upb_tabkey key; |
||||||
|
upb_tabval val; |
||||||
|
|
||||||
|
/* Internal chaining. This is const so we can create static initializers for
|
||||||
|
* tables. We cast away const sometimes, but *only* when the containing |
||||||
|
* upb_table is known to be non-const. This requires a bit of care, but |
||||||
|
* the subtlety is confined to table.c. */ |
||||||
|
const struct _upb_tabent* next; |
||||||
|
} upb_tabent; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
size_t count; /* Number of entries in the hash part. */ |
||||||
|
uint32_t mask; /* Mask to turn hash value -> bucket. */ |
||||||
|
uint32_t max_count; /* Max count before we hit our load limit. */ |
||||||
|
uint8_t size_lg2; /* Size of the hashtable part is 2^size_lg2 entries. */ |
||||||
|
upb_tabent* entries; |
||||||
|
} upb_table; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
upb_table t; |
||||||
|
} upb_strtable; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
upb_table t; /* For entries that don't fit in the array part. */ |
||||||
|
const upb_tabval* array; /* Array part of the table. See const note above. */ |
||||||
|
size_t array_size; /* Array part size. */ |
||||||
|
size_t array_count; /* Array part number of elements. */ |
||||||
|
} upb_inttable; |
||||||
|
|
||||||
|
UPB_INLINE size_t upb_table_size(const upb_table* t) { |
||||||
|
if (t->size_lg2 == 0) |
||||||
|
return 0; |
||||||
|
else |
||||||
|
return 1 << t->size_lg2; |
||||||
|
} |
||||||
|
|
||||||
|
/* Internal-only functions, in .h file only out of necessity. */ |
||||||
|
UPB_INLINE bool upb_tabent_isempty(const upb_tabent* e) { return e->key == 0; } |
||||||
|
|
||||||
|
/* Initialize and uninitialize a table, respectively. If memory allocation
|
||||||
|
* failed, false is returned that the table is uninitialized. */ |
||||||
|
bool upb_inttable_init(upb_inttable* table, upb_Arena* a); |
||||||
|
bool upb_strtable_init(upb_strtable* table, size_t expected_size, upb_Arena* a); |
||||||
|
|
||||||
|
/* Returns the number of values in the table. */ |
||||||
|
size_t upb_inttable_count(const upb_inttable* t); |
||||||
|
UPB_INLINE size_t upb_strtable_count(const upb_strtable* t) { |
||||||
|
return t->t.count; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_strtable_clear(upb_strtable* t); |
||||||
|
|
||||||
|
/* Inserts the given key into the hashtable with the given value. The key must
|
||||||
|
* not already exist in the hash table. For strtables, the key is not required |
||||||
|
* to be NULL-terminated, and the table will make an internal copy of the key. |
||||||
|
* Inttables must not insert a value of UINTPTR_MAX. |
||||||
|
* |
||||||
|
* If a table resize was required but memory allocation failed, false is |
||||||
|
* returned and the table is unchanged. */ |
||||||
|
bool upb_inttable_insert(upb_inttable* t, uintptr_t key, upb_value val, |
||||||
|
upb_Arena* a); |
||||||
|
bool upb_strtable_insert(upb_strtable* t, const char* key, size_t len, |
||||||
|
upb_value val, upb_Arena* a); |
||||||
|
|
||||||
|
/* Looks up key in this table, returning "true" if the key was found.
|
||||||
|
* If v is non-NULL, copies the value for this key into *v. */ |
||||||
|
bool upb_inttable_lookup(const upb_inttable* t, uintptr_t key, upb_value* v); |
||||||
|
bool upb_strtable_lookup2(const upb_strtable* t, const char* key, size_t len, |
||||||
|
upb_value* v); |
||||||
|
|
||||||
|
/* For NULL-terminated strings. */ |
||||||
|
UPB_INLINE bool upb_strtable_lookup(const upb_strtable* t, const char* key, |
||||||
|
upb_value* v) { |
||||||
|
return upb_strtable_lookup2(t, key, strlen(key), v); |
||||||
|
} |
||||||
|
|
||||||
|
/* Removes an item from the table. Returns true if the remove was successful,
|
||||||
|
* and stores the removed item in *val if non-NULL. */ |
||||||
|
bool upb_inttable_remove(upb_inttable* t, uintptr_t key, upb_value* val); |
||||||
|
bool upb_strtable_remove2(upb_strtable* t, const char* key, size_t len, |
||||||
|
upb_value* val); |
||||||
|
|
||||||
|
UPB_INLINE bool upb_strtable_remove(upb_strtable* t, const char* key, |
||||||
|
upb_value* v) { |
||||||
|
return upb_strtable_remove2(t, key, strlen(key), v); |
||||||
|
} |
||||||
|
|
||||||
|
/* Updates an existing entry in an inttable. If the entry does not exist,
|
||||||
|
* returns false and does nothing. Unlike insert/remove, this does not |
||||||
|
* invalidate iterators. */ |
||||||
|
bool upb_inttable_replace(upb_inttable* t, uintptr_t key, upb_value val); |
||||||
|
|
||||||
|
/* Optimizes the table for the current set of entries, for both memory use and
|
||||||
|
* lookup time. Client should call this after all entries have been inserted; |
||||||
|
* inserting more entries is legal, but will likely require a table resize. */ |
||||||
|
void upb_inttable_compact(upb_inttable* t, upb_Arena* a); |
||||||
|
|
||||||
|
/* Exposed for testing only. */ |
||||||
|
bool upb_strtable_resize(upb_strtable* t, size_t size_lg2, upb_Arena* a); |
||||||
|
|
||||||
|
/* Iterators ******************************************************************/ |
||||||
|
|
||||||
|
/* Iteration over inttable.
|
||||||
|
* |
||||||
|
* intptr_t iter = UPB_INTTABLE_BEGIN; |
||||||
|
* uintptr_t key; |
||||||
|
* upb_value val; |
||||||
|
* while (upb_inttable_next2(t, &key, &val, &iter)) { |
||||||
|
* // ...
|
||||||
|
* } |
||||||
|
*/ |
||||||
|
|
||||||
|
#define UPB_INTTABLE_BEGIN -1 |
||||||
|
|
||||||
|
bool upb_inttable_next2(const upb_inttable* t, uintptr_t* key, upb_value* val, |
||||||
|
intptr_t* iter); |
||||||
|
void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter); |
||||||
|
|
||||||
|
/* Iteration over strtable.
|
||||||
|
* |
||||||
|
* intptr_t iter = UPB_INTTABLE_BEGIN; |
||||||
|
* upb_StringView key; |
||||||
|
* upb_value val; |
||||||
|
* while (upb_strtable_next2(t, &key, &val, &iter)) { |
||||||
|
* // ...
|
||||||
|
* } |
||||||
|
*/ |
||||||
|
|
||||||
|
#define UPB_STRTABLE_BEGIN -1 |
||||||
|
|
||||||
|
bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key, |
||||||
|
upb_value* val, intptr_t* iter); |
||||||
|
void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter); |
||||||
|
|
||||||
|
/* DEPRECATED iterators, slated for removal.
|
||||||
|
* |
||||||
|
* Iterators for int and string tables. We are subject to some kind of unusual |
||||||
|
* design constraints: |
||||||
|
* |
||||||
|
* For high-level languages: |
||||||
|
* - we must be able to guarantee that we don't crash or corrupt memory even if |
||||||
|
* the program accesses an invalidated iterator. |
||||||
|
* |
||||||
|
* For C++11 range-based for: |
||||||
|
* - iterators must be copyable |
||||||
|
* - iterators must be comparable |
||||||
|
* - it must be possible to construct an "end" value. |
||||||
|
* |
||||||
|
* Iteration order is undefined. |
||||||
|
* |
||||||
|
* Modifying the table invalidates iterators. upb_{str,int}table_done() is |
||||||
|
* guaranteed to work even on an invalidated iterator, as long as the table it |
||||||
|
* is iterating over has not been freed. Calling next() or accessing data from |
||||||
|
* an invalidated iterator yields unspecified elements from the table, but it is |
||||||
|
* guaranteed not to crash and to return real table elements (except when done() |
||||||
|
* is true). */ |
||||||
|
|
||||||
|
/* upb_strtable_iter **********************************************************/ |
||||||
|
|
||||||
|
/* upb_strtable_iter i;
|
||||||
|
* upb_strtable_begin(&i, t); |
||||||
|
* for(; !upb_strtable_done(&i); upb_strtable_next(&i)) { |
||||||
|
* const char *key = upb_strtable_iter_key(&i); |
||||||
|
* const upb_value val = upb_strtable_iter_value(&i); |
||||||
|
* // ...
|
||||||
|
* } |
||||||
|
*/ |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
const upb_strtable* t; |
||||||
|
size_t index; |
||||||
|
} upb_strtable_iter; |
||||||
|
|
||||||
|
void upb_strtable_begin(upb_strtable_iter* i, const upb_strtable* t); |
||||||
|
void upb_strtable_next(upb_strtable_iter* i); |
||||||
|
bool upb_strtable_done(const upb_strtable_iter* i); |
||||||
|
upb_StringView upb_strtable_iter_key(const upb_strtable_iter* i); |
||||||
|
upb_value upb_strtable_iter_value(const upb_strtable_iter* i); |
||||||
|
void upb_strtable_iter_setdone(upb_strtable_iter* i); |
||||||
|
bool upb_strtable_iter_isequal(const upb_strtable_iter* i1, |
||||||
|
const upb_strtable_iter* i2); |
||||||
|
|
||||||
|
/* upb_inttable_iter **********************************************************/ |
||||||
|
|
||||||
|
/* upb_inttable_iter i;
|
||||||
|
* upb_inttable_begin(&i, t); |
||||||
|
* for(; !upb_inttable_done(&i); upb_inttable_next(&i)) { |
||||||
|
* uintptr_t key = upb_inttable_iter_key(&i); |
||||||
|
* upb_value val = upb_inttable_iter_value(&i); |
||||||
|
* // ...
|
||||||
|
* } |
||||||
|
*/ |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
const upb_inttable* t; |
||||||
|
size_t index; |
||||||
|
bool array_part; |
||||||
|
} upb_inttable_iter; |
||||||
|
|
||||||
|
UPB_INLINE const upb_tabent* str_tabent(const upb_strtable_iter* i) { |
||||||
|
return &i->t->t.entries[i->index]; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_inttable_begin(upb_inttable_iter* i, const upb_inttable* t); |
||||||
|
void upb_inttable_next(upb_inttable_iter* i); |
||||||
|
bool upb_inttable_done(const upb_inttable_iter* i); |
||||||
|
uintptr_t upb_inttable_iter_key(const upb_inttable_iter* i); |
||||||
|
upb_value upb_inttable_iter_value(const upb_inttable_iter* i); |
||||||
|
void upb_inttable_iter_setdone(upb_inttable_iter* i); |
||||||
|
bool upb_inttable_iter_isequal(const upb_inttable_iter* i1, |
||||||
|
const upb_inttable_iter* i2); |
||||||
|
|
||||||
|
uint32_t _upb_Hash(const void* p, size_t n, uint64_t seed); |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#endif /* UPB_INTERNAL_TABLE_H_ */ |
||||||
@ -0,0 +1,68 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_INTERNAL_UPB_H_ |
||||||
|
#define UPB_INTERNAL_UPB_H_ |
||||||
|
|
||||||
|
#include "upb/upb.h" |
||||||
|
|
||||||
|
struct mem_block; |
||||||
|
typedef struct mem_block mem_block; |
||||||
|
|
||||||
|
struct upb_Arena { |
||||||
|
_upb_ArenaHead head; |
||||||
|
/* Stores cleanup metadata for this arena.
|
||||||
|
* - a pointer to the current cleanup counter. |
||||||
|
* - a boolean indicating if there is an unowned initial block. */ |
||||||
|
uintptr_t cleanup_metadata; |
||||||
|
|
||||||
|
/* Allocator to allocate arena blocks. We are responsible for freeing these
|
||||||
|
* when we are destroyed. */ |
||||||
|
upb_alloc* block_alloc; |
||||||
|
uint32_t last_size; |
||||||
|
|
||||||
|
/* When multiple arenas are fused together, each arena points to a parent
|
||||||
|
* arena (root points to itself). The root tracks how many live arenas |
||||||
|
* reference it. */ |
||||||
|
uint32_t refcount; /* Only used when a->parent == a */ |
||||||
|
struct upb_Arena* parent; |
||||||
|
|
||||||
|
/* Linked list of blocks to free/cleanup. */ |
||||||
|
mem_block *freelist, *freelist_tail; |
||||||
|
}; |
||||||
|
|
||||||
|
// Encodes a float or double that is round-trippable, but as short as possible.
|
||||||
|
// These routines are not fully optimal (not guaranteed to be shortest), but are
|
||||||
|
// short-ish and match the implementation that has been used in protobuf since
|
||||||
|
// the beginning.
|
||||||
|
//
|
||||||
|
// The given buffer size must be at least kUpb_RoundTripBufferSize.
|
||||||
|
enum { kUpb_RoundTripBufferSize = 32 }; |
||||||
|
void _upb_EncodeRoundTripDouble(double val, char* buf, size_t size); |
||||||
|
void _upb_EncodeRoundTripFloat(float val, char* buf, size_t size); |
||||||
|
|
||||||
|
#endif /* UPB_INTERNAL_UPB_H_ */ |
||||||
@ -0,0 +1,117 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_MAP_H_ |
||||||
|
#define UPB_MAP_H_ |
||||||
|
|
||||||
|
#include "google/protobuf/descriptor.upb.h" |
||||||
|
#include "upb/message_value.h" |
||||||
|
|
||||||
|
// Must be last.
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
/* Creates a new map on the given arena with the given key/value size. */ |
||||||
|
upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type); |
||||||
|
|
||||||
|
/* Returns the number of entries in the map. */ |
||||||
|
size_t upb_Map_Size(const upb_Map* map); |
||||||
|
|
||||||
|
/* Stores a value for the given key into |*val| (or the zero value if the key is
|
||||||
|
* not present). Returns whether the key was present. The |val| pointer may be |
||||||
|
* NULL, in which case the function tests whether the given key is present. */ |
||||||
|
bool upb_Map_Get(const upb_Map* map, upb_MessageValue key, |
||||||
|
upb_MessageValue* val); |
||||||
|
|
||||||
|
/* Removes all entries in the map. */ |
||||||
|
void upb_Map_Clear(upb_Map* map); |
||||||
|
|
||||||
|
typedef enum { |
||||||
|
// LINT.IfChange
|
||||||
|
kUpb_MapInsertStatus_Inserted = 0, |
||||||
|
kUpb_MapInsertStatus_Replaced = 1, |
||||||
|
kUpb_MapInsertStatus_OutOfMemory = 2, |
||||||
|
// LINT.ThenChange(//depot/google3/third_party/upb/upb/msg_internal.h)
|
||||||
|
} upb_MapInsertStatus; |
||||||
|
|
||||||
|
/* Sets the given key to the given value, returning whether the key was inserted
|
||||||
|
* or replaced. If the key was inserted, then any existing iterators will be |
||||||
|
* invalidated. */ |
||||||
|
upb_MapInsertStatus upb_Map_Insert(upb_Map* map, upb_MessageValue key, |
||||||
|
upb_MessageValue val, upb_Arena* arena); |
||||||
|
|
||||||
|
/* Sets the given key to the given value. Returns false if memory allocation
|
||||||
|
* failed. If the key is newly inserted, then any existing iterators will be |
||||||
|
* invalidated. */ |
||||||
|
UPB_INLINE bool upb_Map_Set(upb_Map* map, upb_MessageValue key, |
||||||
|
upb_MessageValue val, upb_Arena* arena) { |
||||||
|
return upb_Map_Insert(map, key, val, arena) != |
||||||
|
kUpb_MapInsertStatus_OutOfMemory; |
||||||
|
} |
||||||
|
|
||||||
|
/* Deletes this key from the table. Returns true if the key was present. */ |
||||||
|
bool upb_Map_Delete(upb_Map* map, upb_MessageValue key); |
||||||
|
|
||||||
|
/* Map iteration:
|
||||||
|
* |
||||||
|
* size_t iter = kUpb_Map_Begin; |
||||||
|
* while (upb_MapIterator_Next(map, &iter)) { |
||||||
|
* upb_MessageValue key = upb_MapIterator_Key(map, iter); |
||||||
|
* upb_MessageValue val = upb_MapIterator_Value(map, iter); |
||||||
|
* |
||||||
|
* // If mutating is desired.
|
||||||
|
* upb_MapIterator_SetValue(map, iter, value2); |
||||||
|
* } |
||||||
|
*/ |
||||||
|
|
||||||
|
/* Advances to the next entry. Returns false if no more entries are present. */ |
||||||
|
bool upb_MapIterator_Next(const upb_Map* map, size_t* iter); |
||||||
|
|
||||||
|
/* Returns true if the iterator still points to a valid entry, or false if the
|
||||||
|
* iterator is past the last element. It is an error to call this function with |
||||||
|
* kUpb_Map_Begin (you must call next() at least once first). */ |
||||||
|
bool upb_MapIterator_Done(const upb_Map* map, size_t iter); |
||||||
|
|
||||||
|
/* Returns the key and value for this entry of the map. */ |
||||||
|
upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter); |
||||||
|
upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter); |
||||||
|
|
||||||
|
/* Sets the value for this entry. The iterator must not be done, and the
|
||||||
|
* iterator must not have been initialized const. */ |
||||||
|
void upb_MapIterator_SetValue(upb_Map* map, size_t iter, |
||||||
|
upb_MessageValue value); |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#endif /* UPB_MAP_H_ */ |
||||||
@ -0,0 +1,66 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_MESSAGE_VALUE_H_ |
||||||
|
#define UPB_MESSAGE_VALUE_H_ |
||||||
|
|
||||||
|
#include "google/protobuf/descriptor.upb.h" |
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
// Definitions commn to both upb_Array and upb_Map.
|
||||||
|
|
||||||
|
typedef union { |
||||||
|
bool bool_val; |
||||||
|
float float_val; |
||||||
|
double double_val; |
||||||
|
int32_t int32_val; |
||||||
|
int64_t int64_val; |
||||||
|
uint32_t uint32_val; |
||||||
|
uint64_t uint64_val; |
||||||
|
const upb_Map* map_val; |
||||||
|
const upb_Message* msg_val; |
||||||
|
const upb_Array* array_val; |
||||||
|
upb_StringView str_val; |
||||||
|
} upb_MessageValue; |
||||||
|
|
||||||
|
typedef union { |
||||||
|
upb_Map* map; |
||||||
|
upb_Message* msg; |
||||||
|
upb_Array* array; |
||||||
|
} upb_MutableMessageValue; |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#endif /* UPB_MESSAGE_VALUE_H_ */ |
||||||
@ -0,0 +1,86 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "upb/status.h" |
||||||
|
|
||||||
|
#include <errno.h> |
||||||
|
#include <float.h> |
||||||
|
#include <stdarg.h> |
||||||
|
#include <stddef.h> |
||||||
|
#include <stdint.h> |
||||||
|
#include <stdio.h> |
||||||
|
#include <stdlib.h> |
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include "upb/internal/upb.h" |
||||||
|
|
||||||
|
// Must be last.
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
void upb_Status_Clear(upb_Status* status) { |
||||||
|
if (!status) return; |
||||||
|
status->ok = true; |
||||||
|
status->msg[0] = '\0'; |
||||||
|
} |
||||||
|
|
||||||
|
bool upb_Status_IsOk(const upb_Status* status) { return status->ok; } |
||||||
|
|
||||||
|
const char* upb_Status_ErrorMessage(const upb_Status* status) { |
||||||
|
return status->msg; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_Status_SetErrorMessage(upb_Status* status, const char* msg) { |
||||||
|
if (!status) return; |
||||||
|
status->ok = false; |
||||||
|
strncpy(status->msg, msg, _kUpb_Status_MaxMessage - 1); |
||||||
|
status->msg[_kUpb_Status_MaxMessage - 1] = '\0'; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...) { |
||||||
|
va_list args; |
||||||
|
va_start(args, fmt); |
||||||
|
upb_Status_VSetErrorFormat(status, fmt, args); |
||||||
|
va_end(args); |
||||||
|
} |
||||||
|
|
||||||
|
void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt, |
||||||
|
va_list args) { |
||||||
|
if (!status) return; |
||||||
|
status->ok = false; |
||||||
|
vsnprintf(status->msg, sizeof(status->msg), fmt, args); |
||||||
|
status->msg[_kUpb_Status_MaxMessage - 1] = '\0'; |
||||||
|
} |
||||||
|
|
||||||
|
void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt, |
||||||
|
va_list args) { |
||||||
|
size_t len; |
||||||
|
if (!status) return; |
||||||
|
status->ok = false; |
||||||
|
len = strlen(status->msg); |
||||||
|
vsnprintf(status->msg + len, sizeof(status->msg) - len, fmt, args); |
||||||
|
status->msg[_kUpb_Status_MaxMessage - 1] = '\0'; |
||||||
|
} |
||||||
@ -0,0 +1,66 @@ |
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2021, Google LLC |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are met: |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer in the |
||||||
|
* documentation and/or other materials provided with the distribution. |
||||||
|
* * Neither the name of Google LLC nor the |
||||||
|
* names of its contributors may be used to endorse or promote products |
||||||
|
* derived from this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, |
||||||
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||||
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||||
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
||||||
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef UPB_STATUS_H_ |
||||||
|
#define UPB_STATUS_H_ |
||||||
|
|
||||||
|
#include <stdarg.h> |
||||||
|
#include <stdbool.h> |
||||||
|
|
||||||
|
#include "upb/port_def.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
#define _kUpb_Status_MaxMessage 127 |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
bool ok; |
||||||
|
char msg[_kUpb_Status_MaxMessage]; /* Error message; NULL-terminated. */ |
||||||
|
} upb_Status; |
||||||
|
|
||||||
|
const char* upb_Status_ErrorMessage(const upb_Status* status); |
||||||
|
bool upb_Status_IsOk(const upb_Status* status); |
||||||
|
|
||||||
|
/* These are no-op if |status| is NULL. */ |
||||||
|
void upb_Status_Clear(upb_Status* status); |
||||||
|
void upb_Status_SetErrorMessage(upb_Status* status, const char* msg); |
||||||
|
void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...) |
||||||
|
UPB_PRINTF(2, 3); |
||||||
|
void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt, |
||||||
|
va_list args) UPB_PRINTF(2, 0); |
||||||
|
void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt, |
||||||
|
va_list args) UPB_PRINTF(2, 0); |
||||||
|
|
||||||
|
#include "upb/port_undef.inc" |
||||||
|
|
||||||
|
#ifdef __cplusplus |
||||||
|
} /* extern "C" */ |
||||||
|
#endif |
||||||
|
|
||||||
|
#endif /* UPB_STATUS_H_ */ |
||||||
Loading…
Reference in new issue