/* * 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. */ /* ** Our memory representation for parsing tables and messages themselves. ** Functions in this file are used by generated code and possibly reflection. ** ** The definitions in this file are internal to upb. **/ #ifndef UPB_MSG_INT_H_ #define UPB_MSG_INT_H_ #include <stdint.h> #include <stdlib.h> #include <string.h> #include "upb/extension_registry.h" #include "upb/internal/table.h" #include "upb/msg.h" #include "upb/upb.h" /* Must be last. */ #include "upb/port_def.inc" #ifdef __cplusplus extern "C" { #endif /** upb_*Int* conversion routines ********************************************/ UPB_INLINE int32_t _upb_Int32_FromI(int v) { … } UPB_INLINE int64_t _upb_Int64_FromLL(long long v) { … } UPB_INLINE uint32_t _upb_UInt32_FromU(unsigned v) { … } UPB_INLINE uint64_t _upb_UInt64_FromULL(unsigned long long v) { … } /** upb_MiniTable *************************************************************/ /* upb_MiniTable represents the memory layout of a given upb_MessageDef. The * members are public so generated code can initialize them, but users MUST NOT * read or write any of its members. */ upb_MiniTable_Field; #define kUpb_NoSub … upb_FieldMode; // Mask to isolate the upb_FieldMode from field.mode. #define kUpb_FieldMode_Mask … /* Extra flags on the mode field. */ upb_LabelFlags; // Note: we sort by this number when calculating layout order. upb_FieldRep; UPB_INLINE upb_FieldMode upb_FieldMode_Get(const upb_MiniTable_Field* field) { … } UPB_INLINE bool upb_IsRepeatedOrMap(const upb_MiniTable_Field* field) { … } UPB_INLINE bool upb_IsSubMessage(const upb_MiniTable_Field* field) { … } struct upb_Decoder; struct upb_MiniTable; _upb_FieldParser; _upb_FastTable_Entry; upb_MiniTable_Enum; upb_MiniTable_Sub; upb_ExtMode; /* MessageSet wire format is: * message MessageSet { * repeated group Item = 1 { * required int32 type_id = 2; * required bytes message = 3; * } * } */ upb_msgext_fieldnum; struct upb_MiniTable { … }; upb_MiniTable_Extension; upb_MiniTable_File; // Computes a bitmask in which the |l->required_count| lowest bits are set, // except that we skip the lowest bit (because upb never uses hasbit 0). // // Sample output: // requiredmask(1) => 0b10 (0x2) // requiredmask(5) => 0b111110 (0x3e) UPB_INLINE uint64_t upb_MiniTable_requiredmask(const upb_MiniTable* l) { … } /** upb_ExtensionRegistry *****************************************************/ /* Adds the given extension info for message type |l| and field number |num| * into the registry. Returns false if this message type and field number were * already in the map, or if memory allocation fails. */ bool _upb_extreg_add(upb_ExtensionRegistry* r, const upb_MiniTable_Extension** e, size_t count); /* Looks up the extension (if any) defined for message type |l| and field * number |num|. If an extension was found, copies the field info into |*ext| * and returns true. Otherwise returns false. */ const upb_MiniTable_Extension* _upb_extreg_get(const upb_ExtensionRegistry* r, const upb_MiniTable* l, uint32_t num); /** upb_Message ***************************************************************/ /* Internal members of a upb_Message that track unknown fields and/or * extensions. We can change this without breaking binary compatibility. We put * these before the user's data. The user's upb_Message* points after the * upb_Message_Internal. */ upb_Message_InternalData; upb_Message_Internal; /* Maps upb_CType -> memory size. */ extern char _upb_CTypeo_size[12]; UPB_INLINE size_t upb_msg_sizeof(const upb_MiniTable* l) { … } UPB_INLINE upb_Message* _upb_Message_New_inl(const upb_MiniTable* l, upb_Arena* a) { … } /* Creates a new messages with the given layout on the given arena. */ upb_Message* _upb_Message_New(const upb_MiniTable* l, upb_Arena* a); UPB_INLINE upb_Message_Internal* upb_Message_Getinternal(upb_Message* msg) { … } /* Clears the given message. */ void _upb_Message_Clear(upb_Message* msg, const upb_MiniTable* l); /* Discards the unknown fields for this message only. */ void _upb_Message_DiscardUnknown_shallow(upb_Message* msg); /* Adds unknown data (serialized protobuf data) to the given message. The data * is copied into the message instance. */ bool _upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len, upb_Arena* arena); /** upb_Message_Extension *****************************************************/ /* The internal representation of an extension is self-describing: it contains * enough information that we can serialize it to binary format without needing * to look it up in a upb_ExtensionRegistry. * * This representation allocates 16 bytes to data on 64-bit platforms. This is * rather wasteful for scalars (in the extreme case of bool, it wastes 15 * bytes). We accept this because we expect messages to be the most common * extension type. */ upb_Message_Extension; /* Adds the given extension data to the given message. |ext| is copied into the * message instance. This logically replaces any previously-added extension with * this number */ upb_Message_Extension* _upb_Message_GetOrCreateExtension( upb_Message* msg, const upb_MiniTable_Extension* ext, upb_Arena* arena); /* Returns an array of extensions for this message. Note: the array is * ordered in reverse relative to the order of creation. */ const upb_Message_Extension* _upb_Message_Getexts(const upb_Message* msg, size_t* count); /* Returns an extension for the given field number, or NULL if no extension * exists for this field number. */ const upb_Message_Extension* _upb_Message_Getext( const upb_Message* msg, const upb_MiniTable_Extension* ext); void _upb_Message_Clearext(upb_Message* msg, const upb_MiniTable_Extension* ext); void _upb_Message_Clearext(upb_Message* msg, const upb_MiniTable_Extension* ext); /** Hasbit access *************************************************************/ UPB_INLINE bool _upb_hasbit(const upb_Message* msg, size_t idx) { … } UPB_INLINE void _upb_sethas(const upb_Message* msg, size_t idx) { … } UPB_INLINE void _upb_clearhas(const upb_Message* msg, size_t idx) { … } UPB_INLINE size_t _upb_Message_Hasidx(const upb_MiniTable_Field* f) { … } UPB_INLINE bool _upb_hasbit_field(const upb_Message* msg, const upb_MiniTable_Field* f) { … } UPB_INLINE void _upb_sethas_field(const upb_Message* msg, const upb_MiniTable_Field* f) { … } UPB_INLINE void _upb_clearhas_field(const upb_Message* msg, const upb_MiniTable_Field* f) { … } /** Oneof case access *********************************************************/ UPB_INLINE uint32_t* _upb_oneofcase(upb_Message* msg, size_t case_ofs) { … } UPB_INLINE uint32_t _upb_getoneofcase(const void* msg, size_t case_ofs) { … } UPB_INLINE size_t _upb_oneofcase_ofs(const upb_MiniTable_Field* f) { … } UPB_INLINE uint32_t* _upb_oneofcase_field(upb_Message* msg, const upb_MiniTable_Field* f) { … } UPB_INLINE uint32_t _upb_getoneofcase_field(const upb_Message* msg, const upb_MiniTable_Field* f) { … } UPB_INLINE bool _upb_has_submsg_nohasbit(const upb_Message* msg, size_t ofs) { … } /** upb_Array *****************************************************************/ /* Our internal representation for repeated fields. */ upb_Array; UPB_INLINE const void* _upb_array_constptr(const upb_Array* arr) { … } UPB_INLINE uintptr_t _upb_array_tagptr(void* ptr, int elem_size_lg2) { … } UPB_INLINE void* _upb_array_ptr(upb_Array* arr) { … } UPB_INLINE uintptr_t _upb_tag_arrptr(void* ptr, int elem_size_lg2) { … } UPB_INLINE upb_Array* _upb_Array_New(upb_Arena* a, size_t init_size, int elem_size_lg2) { … } /* Resizes the capacity of the array to be at least min_size. */ bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena); /* Fallback functions for when the accessors require a resize. */ void* _upb_Array_Resize_fallback(upb_Array** arr_ptr, size_t size, int elem_size_lg2, upb_Arena* arena); bool _upb_Array_Append_fallback(upb_Array** arr_ptr, const void* value, int elem_size_lg2, upb_Arena* arena); UPB_INLINE bool _upb_array_reserve(upb_Array* arr, size_t size, upb_Arena* arena) { … } UPB_INLINE bool _upb_Array_Resize(upb_Array* arr, size_t size, upb_Arena* arena) { … } UPB_INLINE void _upb_array_detach(const void* msg, size_t ofs) { … } UPB_INLINE const void* _upb_array_accessor(const void* msg, size_t ofs, size_t* size) { … } UPB_INLINE void* _upb_array_mutable_accessor(void* msg, size_t ofs, size_t* size) { … } UPB_INLINE void* _upb_Array_Resize_accessor2(void* msg, size_t ofs, size_t size, int elem_size_lg2, upb_Arena* arena) { … } UPB_INLINE bool _upb_Array_Append_accessor2(void* msg, size_t ofs, int elem_size_lg2, const void* value, upb_Arena* arena) { … } /* Used by old generated code, remove once all code has been regenerated. */ UPB_INLINE int _upb_sizelg2(upb_CType type) { … } UPB_INLINE void* _upb_Array_Resize_accessor(void* msg, size_t ofs, size_t size, upb_CType type, upb_Arena* arena) { … } UPB_INLINE bool _upb_Array_Append_accessor(void* msg, size_t ofs, size_t elem_size, upb_CType type, const void* value, upb_Arena* arena) { … } /** upb_Map *******************************************************************/ /* Right now we use strmaps for everything. We'll likely want to use * integer-specific maps for integer-keyed maps.*/ upb_Map; /* Map entries aren't actually stored, they are only used during parsing. For * parsing, it helps a lot if all map entry messages have the same layout. * The compiler and def.c must ensure that all map entries have this layout. */ upb_MapEntry; /* Creates a new map on the given arena with this key/value type. */ upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size); /* Converting between internal table representation and user values. * * _upb_map_tokey() and _upb_map_fromkey() are inverses. * _upb_map_tovalue() and _upb_map_fromvalue() are inverses. * * These functions account for the fact that strings are treated differently * from other types when stored in a map. */ UPB_INLINE upb_StringView _upb_map_tokey(const void* key, size_t size) { … } UPB_INLINE void _upb_map_fromkey(upb_StringView key, void* out, size_t size) { … } UPB_INLINE bool _upb_map_tovalue(const void* val, size_t size, upb_value* msgval, upb_Arena* a) { … } UPB_INLINE void _upb_map_fromvalue(upb_value val, void* out, size_t size) { … } /* Map operations, shared by reflection and generated code. */ UPB_INLINE size_t _upb_Map_Size(const upb_Map* map) { … } UPB_INLINE bool _upb_Map_Get(const upb_Map* map, const void* key, size_t key_size, void* val, size_t val_size) { … } UPB_INLINE void* _upb_map_next(const upb_Map* map, size_t* iter) { … } _upb_MapInsertStatus; UPB_INLINE _upb_MapInsertStatus _upb_Map_Insert(upb_Map* map, const void* key, size_t key_size, void* val, size_t val_size, upb_Arena* a) { … } UPB_INLINE bool _upb_Map_Delete(upb_Map* map, const void* key, size_t key_size) { … } UPB_INLINE void _upb_Map_Clear(upb_Map* map) { … } /* Message map operations, these get the map from the message first. */ UPB_INLINE size_t _upb_msg_map_size(const upb_Message* msg, size_t ofs) { … } UPB_INLINE bool _upb_msg_map_get(const upb_Message* msg, size_t ofs, const void* key, size_t key_size, void* val, size_t val_size) { … } UPB_INLINE void* _upb_msg_map_next(const upb_Message* msg, size_t ofs, size_t* iter) { … } UPB_INLINE bool _upb_msg_map_set(upb_Message* msg, size_t ofs, const void* key, size_t key_size, void* val, size_t val_size, upb_Arena* arena) { … } UPB_INLINE bool _upb_msg_map_delete(upb_Message* msg, size_t ofs, const void* key, size_t key_size) { … } UPB_INLINE void _upb_msg_map_clear(upb_Message* msg, size_t ofs) { … } /* Accessing map key/value from a pointer, used by generated code only. */ UPB_INLINE void _upb_msg_map_key(const void* msg, void* key, size_t size) { … } UPB_INLINE void _upb_msg_map_value(const void* msg, void* val, size_t size) { … } UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val, size_t size) { … } /** _upb_mapsorter ************************************************************/ /* _upb_mapsorter sorts maps and provides ordered iteration over the entries. * Since maps can be recursive (map values can be messages which contain other * maps). _upb_mapsorter can contain a stack of maps. */ _upb_mapsorter; _upb_sortedmap; UPB_INLINE void _upb_mapsorter_init(_upb_mapsorter* s) { … } UPB_INLINE void _upb_mapsorter_destroy(_upb_mapsorter* s) { … } bool _upb_mapsorter_pushmap(_upb_mapsorter* s, upb_FieldType key_type, const upb_Map* map, _upb_sortedmap* sorted); UPB_INLINE void _upb_mapsorter_popmap(_upb_mapsorter* s, _upb_sortedmap* sorted) { … } UPB_INLINE bool _upb_sortedmap_next(_upb_mapsorter* s, const upb_Map* map, _upb_sortedmap* sorted, upb_MapEntry* ent) { … } #ifdef __cplusplus } /* extern "C" */ #endif #include "upb/port_undef.inc" #endif /* UPB_MSG_INT_H_ */
Codebase Browser
chromium