3party/protobuf-c
0
0
Fork 0
mirror of https://github.com/protobuf-c/protobuf-c.git synced 2024-12-27 13:31:02 +08:00
Code Issues Projects Releases Wiki Activity

protobuf-c/: gratuitous style changes

Browse Source 
dave's original style drives me crazy. reformat the C code in
protobuf-c/ with "indent -kr -i8" and manually reflow for readability.

try to fit most lines in 80 columns, but due to the lengthy type and
function names in protobuf-c, enforcing an 80 column rule would result
in a lot of cramped statements, so try to fit lines in up to 100 columns
if it would improve readability. (e.g., one <=100 column line is
probably better than 3-4 <=80 column lines.)

ultimately i'd like to adopt most of the recommendations in the linux
coding style: https://www.kernel.org/doc/Documentation/CodingStyle.
this commit gets us most of the kernel indentation and comment coding
style recommendations. later commits will tackle style recommendations
that require more intrusive changes: breaking up large functions,
replacing macros that affect control flow (e.g., DO_ALLOC). this will
hopefully facilitate review and make the code base easier to maintain.

i ran the old and new versions of protobuf-c.c through something like:

  gcc -S -D__PRETTY_FUNCTION__=0 -D__FILE__=0 -D__LINE__=0 -Wall -O0 \
    -o protobuf-c.S -c protobuf-c.c

and reviewed the diffs of the assembly output to spot any functions that
changed, and went back to make sure that any differences were
functionally equivalent.
This commit is contained in:
Robert Edmonds 2014-01-11 13:41:11 -05:00
parent 934ff223db
commit c797b07eec
3 changed files with 2901 additions and 2804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
protobuf-c/protobuf-c-private.h
View File

@ -28,68 +28,78 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* A little enum helper macro: this will ensure that your
enum's size is sizeof(int). In protobuf, it need not
be larger than 32-bits.
This is written assuming it is appended to a list w/o a tail comma. */
#define PROTOBUF_C_SERVICE_DESCRIPTOR_MAGIC 0x14159bc3
#define PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC 0x28aaeef9
#define PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC 0x114315af
/*
* A little enum helper macro: this will ensure that your enum's size is
* sizeof(int). In protobuf, it need not be larger than 32-bits. This is
* written assuming it is appended to a list w/o a tail comma.
*/
#ifndef _PROTOBUF_C_FORCE_ENUM_TO_BE_INT_SIZE
#define _PROTOBUF_C_FORCE_ENUM_TO_BE_INT_SIZE(enum_name) \
, _##enum_name##_IS_INT_SIZE = INT_MAX
#define _PROTOBUF_C_FORCE_ENUM_TO_BE_INT_SIZE(enum_name) \
, _##enum_name##_IS_INT_SIZE = INT_MAX
#endif
/* === needs to be declared for the PROTOBUF_C_BUFFER_SIMPLE_INIT macro === */
void protobuf_c_buffer_simple_append (ProtobufCBuffer *buffer,
size_t len,
const unsigned char *data);
void
protobuf_c_buffer_simple_append(
ProtobufCBuffer *buffer,
size_t len,
const unsigned char *data);
/* === stuff which needs to be declared for use in the generated code === */
struct _ProtobufCEnumValueIndex
{
const char *name;
unsigned index; /* into values[] array */
struct _ProtobufCEnumValueIndex {
const char *name;
unsigned index; /* into values[] array */
};
/* IntRange: helper structure for optimizing
int => index lookups
in the case where the keys are mostly consecutive values,
as they presumably are for enums and fields.
The data structures assumes that the values in the original
array are sorted */
struct _ProtobufCIntRange
{
int start_value;
unsigned orig_index;
/* NOTE: the number of values in the range can
be inferred by looking at the next element's orig_index.
a dummy element is added to make this simple */
/*
* IntRange: helper structure for optimizing int => index lookups in the case
* where the keys are mostly consecutive values, as they presumably are for
* enums and fields.
*
* The data structures assumes that the values in the original array are
* sorted.
*/
struct _ProtobufCIntRange {
int start_value;
unsigned orig_index;
/*
* NOTE: the number of values in the range can be inferred by looking
* at the next element's orig_index. A dummy element is added to make
* this simple.
*/
};
/* === declared for exposition on ProtobufCIntRange === */
/* note: ranges must have an extra sentinel IntRange at the end whose
orig_index is set to the number of actual values in the original array */
/* returns -1 if no orig_index found */
int protobuf_c_int_ranges_lookup (unsigned n_ranges,
ProtobufCIntRange *ranges);
#define PROTOBUF_C_SERVICE_DESCRIPTOR_MAGIC 0x14159bc3
#define PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC 0x28aaeef9
#define PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC 0x114315af
/*
* Note: ranges must have an extra sentinel IntRange at the end whose
* orig_index is set to the number of actual values in the original array.
* Returns -1 if no orig_index found.
*/
int
protobuf_c_int_ranges_lookup(unsigned n_ranges, ProtobufCIntRange *ranges);
/* === behind the scenes on the generated service's __init functions */
typedef void (*ProtobufCServiceDestroy) (ProtobufCService *service);
typedef void (*ProtobufCServiceDestroy)(ProtobufCService *);
void
protobuf_c_service_generated_init (ProtobufCService *service,
const ProtobufCServiceDescriptor *descriptor,
ProtobufCServiceDestroy destroy);
protobuf_c_service_generated_init(
ProtobufCService *service,
const ProtobufCServiceDescriptor *descriptor,
ProtobufCServiceDestroy destroy);
void
protobuf_c_service_invoke_internal(ProtobufCService *service,
unsigned method_index,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data);
protobuf_c_service_invoke_internal(
ProtobufCService *service,
unsigned method_index,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data);

5013
protobuf-c/protobuf-c.c
View File

File diff suppressed because it is too large Load Diff

590
protobuf-c/protobuf-c.h
View File

@ -1,4 +1,4 @@
/* --- protobuf-c.h: public protobuf c runtime api --- */
/* --- protobuf-c.h: protobuf c runtime api --- */
/*
* Copyright (c) 2008-2013, Dave Benson. All rights reserved.
@ -36,110 +36,105 @@
#include <limits.h>
#ifdef __cplusplus
# define PROTOBUF_C_BEGIN_DECLS extern "C" {
# define PROTOBUF_C_END_DECLS }
# define PROTOBUF_C_BEGIN_DECLS extern "C" {
# define PROTOBUF_C_END_DECLS }
#else
# define PROTOBUF_C_BEGIN_DECLS
# define PROTOBUF_C_END_DECLS
#endif
#if !defined(PROTOBUF_C_NO_DEPRECATED) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
#define PROTOBUF_C_DEPRECATED __attribute__((__deprecated__))
#define PROTOBUF_C_ASSERT(condition) assert(condition)
#define PROTOBUF_C_ASSERT_NOT_REACHED() assert(0)
#if !defined(PROTOBUF_C_NO_DEPRECATED)
# if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
# define PROTOBUF_C_DEPRECATED __attribute__((__deprecated__))
# endif
#else
#define PROTOBUF_C_DEPRECATED
# define PROTOBUF_C_DEPRECATED
#endif
#define PROTOBUF_C_OFFSETOF(struct, member) offsetof(struct, member)
/* The version of protobuf-c you are compiling against. */
#define PROTOBUF_C_MAJOR 0
#define PROTOBUF_C_MINOR 16
#define PROTOBUF_C_MAJOR 0
#define PROTOBUF_C_MINOR 16
/* The version of protobuf-c you are linking against. */
extern unsigned protobuf_c_major;
extern unsigned protobuf_c_minor;
/* Define int32_t, int64_t, uint32_t, uint64_t, uint8_t.
Usually, just include <inttypes.h> to do the work.
XXX: should we use stdint.h?
/*
* Define int32_t, int64_t, uint32_t, uint64_t, uint8_t.
*
* Usually, just include <inttypes.h> to do the work.
* XXX: should we use stdint.h?
*/
#ifndef PROTOBUF_C_SKIP_INTTYPES_H
# if defined(_MSC_VER)
/* On windows, in ms visual studio, define the types ourselves */
# define int32_t signed __int32
# define INT32_MIN _I32_MIN
# define INT32_MAX _I32_MAX
# define uint32_t unsigned __int32
# define UINT32_MIN _UI32_MIN
# define UINT32_MAX _UI32_MAX
# define int64_t signed __int64
# define INT64_MIN _I64_MIN
# define INT64_MAX _I64_MAX
# define uint64_t unsigned __int64
# define UINT64_MIN _UI64_MIN
# define UINT64_MAX _UI64_MAX
# define uint8_t unsigned char
# else
/* Use the system inttypes.h */
# include <inttypes.h>
# endif
# if defined(_MSC_VER) /* For MS Visual Studio, define the types ourselves */
# define int32_t signed __int32
# define INT32_MIN _I32_MIN
# define INT32_MAX _I32_MAX
# define uint32_t unsigned __int32
# define UINT32_MIN _UI32_MIN
# define UINT32_MAX _UI32_MAX
# define int64_t signed __int64
# define INT64_MIN _I64_MIN
# define INT64_MAX _I64_MAX
# define uint64_t unsigned __int64
# define UINT64_MIN _UI64_MIN
# define UINT64_MAX _UI64_MAX
# define uint8_t unsigned char
# else /* Use the system inttypes.h */
# include <inttypes.h>
# endif
#endif
#if defined(_WIN32) && defined(PROTOBUF_C_USE_SHARED_LIB)
# ifdef PROTOBUF_C_EXPORT
# define PROTOBUF_C_API __declspec(dllexport)
# define PROTOBUF_C_API __declspec(dllexport)
# else
# define PROTOBUF_C_API __declspec(dllimport)
#endif
# define PROTOBUF_C_API __declspec(dllimport)
# endif
#else
# define PROTOBUF_C_API
#endif
PROTOBUF_C_BEGIN_DECLS
typedef enum
{
PROTOBUF_C_LABEL_REQUIRED,
PROTOBUF_C_LABEL_OPTIONAL,
PROTOBUF_C_LABEL_REPEATED
typedef int protobuf_c_boolean;
typedef enum {
PROTOBUF_C_LABEL_REQUIRED,
PROTOBUF_C_LABEL_OPTIONAL,
PROTOBUF_C_LABEL_REPEATED
} ProtobufCLabel;
typedef enum
{
PROTOBUF_C_TYPE_INT32,
PROTOBUF_C_TYPE_SINT32,
PROTOBUF_C_TYPE_SFIXED32,
PROTOBUF_C_TYPE_INT64,
PROTOBUF_C_TYPE_SINT64,
PROTOBUF_C_TYPE_SFIXED64,
PROTOBUF_C_TYPE_UINT32,
PROTOBUF_C_TYPE_FIXED32,
PROTOBUF_C_TYPE_UINT64,
PROTOBUF_C_TYPE_FIXED64,
PROTOBUF_C_TYPE_FLOAT,
PROTOBUF_C_TYPE_DOUBLE,
PROTOBUF_C_TYPE_BOOL,
PROTOBUF_C_TYPE_ENUM,
PROTOBUF_C_TYPE_STRING,
PROTOBUF_C_TYPE_BYTES,
//PROTOBUF_C_TYPE_GROUP, // NOT SUPPORTED
PROTOBUF_C_TYPE_MESSAGE,
typedef enum {
PROTOBUF_C_TYPE_INT32,
PROTOBUF_C_TYPE_SINT32,
PROTOBUF_C_TYPE_SFIXED32,
PROTOBUF_C_TYPE_INT64,
PROTOBUF_C_TYPE_SINT64,
PROTOBUF_C_TYPE_SFIXED64,
PROTOBUF_C_TYPE_UINT32,
PROTOBUF_C_TYPE_FIXED32,
PROTOBUF_C_TYPE_UINT64,
PROTOBUF_C_TYPE_FIXED64,
PROTOBUF_C_TYPE_FLOAT,
PROTOBUF_C_TYPE_DOUBLE,
PROTOBUF_C_TYPE_BOOL,
PROTOBUF_C_TYPE_ENUM,
PROTOBUF_C_TYPE_STRING,
PROTOBUF_C_TYPE_BYTES,
//PROTOBUF_C_TYPE_GROUP, // NOT SUPPORTED
PROTOBUF_C_TYPE_MESSAGE,
} ProtobufCType;
typedef int protobuf_c_boolean;
#define PROTOBUF_C_OFFSETOF(struct, member) offsetof(struct, member)
#define PROTOBUF_C_ASSERT(condition) assert(condition)
#define PROTOBUF_C_ASSERT_NOT_REACHED() assert(0)
typedef struct _ProtobufCBinaryData ProtobufCBinaryData;
struct _ProtobufCBinaryData
{
size_t len;
uint8_t *data;
struct _ProtobufCBinaryData {
size_t len;
uint8_t *data;
};
typedef struct _ProtobufCIntRange ProtobufCIntRange; /* private */
@ -148,14 +143,15 @@ typedef struct _ProtobufCIntRange ProtobufCIntRange; /* private */
typedef struct _ProtobufCAllocator ProtobufCAllocator;
struct _ProtobufCAllocator
{
void *(*alloc)(void *allocator_data, size_t size);
void (*free)(void *allocator_data, void *pointer);
void *(*tmp_alloc)(void *allocator_data, size_t size);
unsigned max_alloca;
void *allocator_data;
void *(*alloc)(void *allocator_data, size_t size);
void (*free)(void *allocator_data, void *pointer);
void *(*tmp_alloc)(void *allocator_data, size_t size);
unsigned max_alloca;
void *allocator_data;
};
/* This is a configurable allocator.
/*
* This is a configurable allocator.
* By default, it uses the system allocator (meaning malloc() and free()).
* This is typically changed to adapt to frameworks that provide
* some nonstandard allocation functions.
@ -164,39 +160,42 @@ struct _ProtobufCAllocator
*/
extern PROTOBUF_C_API ProtobufCAllocator protobuf_c_default_allocator; /* settable */
/* This is the function that our default allocators call when they
run out-of-memory. The default behavior of this function is to
terminate your program. */
extern PROTOBUF_C_API void (*protobuf_c_out_of_memory) (void);
/*
* This is the function that our default allocators call when they run
* out-of-memory. The default behavior of this function is to terminate your
* program.
*/
extern PROTOBUF_C_API void (*protobuf_c_out_of_memory)(void);
/* --- append-only data buffer --- */
typedef struct _ProtobufCBuffer ProtobufCBuffer;
struct _ProtobufCBuffer
{
void (*append)(ProtobufCBuffer *buffer,
size_t len,
const uint8_t *data);
struct _ProtobufCBuffer {
void (*append)(ProtobufCBuffer *buffer,
size_t len,
const uint8_t *data);
};
/* --- enums --- */
typedef struct _ProtobufCEnumValue ProtobufCEnumValue;
typedef struct _ProtobufCEnumValueIndex ProtobufCEnumValueIndex;
typedef struct _ProtobufCEnumDescriptor ProtobufCEnumDescriptor;
/* ProtobufCEnumValue: this represents a single value of
* an enumeration.
/*
* ProtobufCEnumValue: this represents a single value of an enumeration.
* 'name' is the string identifying this value, as given in the .proto file.
* 'c_name' is the full name of the C enumeration value.
* 'value' is the number assigned to this value, as given in the .proto file.
*/
struct _ProtobufCEnumValue
{
const char *name;
const char *c_name;
int value;
struct _ProtobufCEnumValue {
const char *name;
const char *c_name;
int value;
};
/* ProtobufCEnumDescriptor: the represents the enum as a whole,
* with all its values.
/*
* ProtobufCEnumDescriptor: represents the enum as a whole, with all its values.
*
* 'magic' is a code we check to ensure that the api is used correctly.
* 'name' is the qualified name (e.g. "namespace.Type").
* 'short_name' is the unqualified name ("Type"), as given in the .proto file.
@ -208,44 +207,46 @@ struct _ProtobufCEnumValue
*
* The rest of the values are private essentially.
*
* see also: Use protobuf_c_enum_descriptor_get_value_by_name()
* See also: Use protobuf_c_enum_descriptor_get_value_by_name()
* and protobuf_c_enum_descriptor_get_value() to efficiently
* lookup values in the descriptor.
*/
struct _ProtobufCEnumDescriptor
{
uint32_t magic;
struct _ProtobufCEnumDescriptor {
uint32_t magic;
const char *name;
const char *short_name;
const char *c_name;
const char *package_name;
const char *name;
const char *short_name;
const char *c_name;
const char *package_name;
/* sorted by value */
unsigned n_values;
const ProtobufCEnumValue *values;
/* sorted by value */
unsigned n_values;
const ProtobufCEnumValue *values;
/* sorted by name */
unsigned n_value_names;
const ProtobufCEnumValueIndex *values_by_name;
/* sorted by name */
unsigned n_value_names;
const ProtobufCEnumValueIndex *values_by_name;
/* value-ranges, for faster lookups by number */
unsigned n_value_ranges;
const ProtobufCIntRange *value_ranges;
/* value-ranges, for faster lookups by number */
unsigned n_value_ranges;
const ProtobufCIntRange *value_ranges;
void *reserved1;
void *reserved2;
void *reserved3;
void *reserved4;
void *reserved1;
void *reserved2;
void *reserved3;
void *reserved4;
};
/* --- messages --- */
typedef struct _ProtobufCMessageDescriptor ProtobufCMessageDescriptor;
typedef struct _ProtobufCFieldDescriptor ProtobufCFieldDescriptor;
typedef struct _ProtobufCMessage ProtobufCMessage;
typedef void (*ProtobufCMessageInit)(ProtobufCMessage *);
/* ProtobufCFieldDescriptor: description of a single field
* in a message.
/*
* ProtobufCFieldDescriptor: description of a single field in a message.
*
* 'name' is the name of the field, as given in the .proto file.
* 'id' is the code representing the field, as given in the .proto file.
* 'label' is one of PROTOBUF_C_LABEL_{REQUIRED,OPTIONAL,REPEATED}
@ -263,23 +264,24 @@ typedef void (*ProtobufCMessageInit)(ProtobufCMessage *);
* 'packed' is only for REPEATED fields (it is 0 otherwise); this is if
* the repeated fields is marked with the 'packed' options.
*/
struct _ProtobufCFieldDescriptor
{
const char *name;
uint32_t id;
ProtobufCLabel label;
ProtobufCType type;
unsigned quantifier_offset;
unsigned offset;
const void *descriptor; /* for MESSAGE and ENUM types */
const void *default_value; /* or NULL if no default-value */
protobuf_c_boolean packed;
struct _ProtobufCFieldDescriptor {
const char *name;
uint32_t id;
ProtobufCLabel label;
ProtobufCType type;
unsigned quantifier_offset;
unsigned offset;
const void *descriptor; /* for MESSAGE and ENUM types */
const void *default_value; /* can be NULL */
protobuf_c_boolean packed;
unsigned reserved_flags;
void *reserved2;
void *reserved3;
unsigned reserved_flags;
void *reserved2;
void *reserved3;
};
/* ProtobufCMessageDescriptor: description of a message.
/*
* ProtobufCMessageDescriptor: description of a message.
*
* 'magic' is a code we check to ensure that the api is used correctly.
* 'name' is the qualified name (e.g. "namespace.Type").
@ -293,191 +295,209 @@ struct _ProtobufCFieldDescriptor
* 'fields_sorted_by_name', 'n_field_ranges' and 'field_ranges'
* are used for looking up fields by name and id. (private)
*/
struct _ProtobufCMessageDescriptor
{
uint32_t magic;
struct _ProtobufCMessageDescriptor {
uint32_t magic;
const char *name;
const char *short_name;
const char *c_name;
const char *package_name;
const char *name;
const char *short_name;
const char *c_name;
const char *package_name;
size_t sizeof_message;
size_t sizeof_message;
/* sorted by field-id */
unsigned n_fields;
const ProtobufCFieldDescriptor *fields;
const unsigned *fields_sorted_by_name;
/* sorted by field-id */
unsigned n_fields;
const ProtobufCFieldDescriptor *fields;
const unsigned *fields_sorted_by_name;
/* ranges, optimization for looking up fields */
unsigned n_field_ranges;
const ProtobufCIntRange *field_ranges;
/* ranges, optimization for looking up fields */
unsigned n_field_ranges;
const ProtobufCIntRange *field_ranges;
ProtobufCMessageInit message_init;
void *reserved1;
void *reserved2;
void *reserved3;
ProtobufCMessageInit message_init;
void *reserved1;
void *reserved2;
void *reserved3;
};
/* ProtobufCMessage: an instance of a message.
/*
* ProtobufCMessage: an instance of a message.
*
* ProtobufCMessage is sort-of a lightweight
* base-class for all messages.
*
* In particular, ProtobufCMessage doesn't have
* any allocation policy associated with it.
* That's because it is common to create ProtobufCMessage's
* on the stack. In fact, we that's what we recommend
* for sending messages (because if you just allocate from the
* stack, then you can't really have a memory leak).
* ProtobufCMessage is sort of a light-weight base class for all messages.
*
* This means that functions like protobuf_c_message_unpack()
* which return a ProtobufCMessage must be paired
* with a free function, like protobuf_c_message_free_unpacked().
* In particular, ProtobufCMessage doesn't have any allocation policy
* associated with it. That's because it's common to create ProtobufCMessage's
* on the stack. In fact, that's what we recommend for sending messages
* (because if you just allocate from the stack, then you can't really have a
* memory leak).
*
* 'descriptor' gives the locations and types of the members of message
* This means that functions like protobuf_c_message_unpack() which return a
* ProtobufCMessage must be paired with a free function, like
* protobuf_c_message_free_unpacked().
*
* 'descriptor' gives the locations and types of the members of message.
* 'n_unknown_fields' is the number of fields we didn't recognize.
* 'unknown_fields' are fields we didn't recognize.
*/
typedef struct _ProtobufCMessageUnknownField ProtobufCMessageUnknownField;
struct _ProtobufCMessage
{
const ProtobufCMessageDescriptor *descriptor;
unsigned n_unknown_fields;
ProtobufCMessageUnknownField *unknown_fields;
struct _ProtobufCMessage {
const ProtobufCMessageDescriptor *descriptor;
unsigned n_unknown_fields;
ProtobufCMessageUnknownField *unknown_fields;
};
#define PROTOBUF_C_MESSAGE_INIT(descriptor) { descriptor, 0, NULL }
/* To pack a message: you have two options:
(1) you can compute the size of the message
using protobuf_c_message_get_packed_size()
then pass protobuf_c_message_pack() a buffer of
that length.
(2) Provide a virtual buffer (a ProtobufCBuffer) to
accept data as we scan through it.
/*
* To pack a message: you have two options:
* (1) you can compute the size of the message using
* protobuf_c_message_get_packed_size() then pass
* protobuf_c_message_pack() a buffer of that length.
*
* (2) Provide a virtual buffer (a ProtobufCBuffer) to
* accept data as we scan through it.
*/
PROTOBUF_C_API size_t protobuf_c_message_get_packed_size(const ProtobufCMessage *message);
PROTOBUF_C_API size_t protobuf_c_message_pack (const ProtobufCMessage *message,
uint8_t *out);
PROTOBUF_C_API size_t protobuf_c_message_pack_to_buffer (const ProtobufCMessage *message,
ProtobufCBuffer *buffer);
PROTOBUF_C_API size_t
protobuf_c_message_get_packed_size(const ProtobufCMessage *);
PROTOBUF_C_API size_t
protobuf_c_message_pack(const ProtobufCMessage *, uint8_t *out);
PROTOBUF_C_API size_t
protobuf_c_message_pack_to_buffer(const ProtobufCMessage *, ProtobufCBuffer *);
PROTOBUF_C_API ProtobufCMessage *
protobuf_c_message_unpack (const ProtobufCMessageDescriptor *,
ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
PROTOBUF_C_API void protobuf_c_message_free_unpacked (ProtobufCMessage *message,
ProtobufCAllocator *allocator);
protobuf_c_message_unpack(
const ProtobufCMessageDescriptor *,
ProtobufCAllocator *,
size_t len,
const uint8_t *data);
PROTOBUF_C_API void
protobuf_c_message_free_unpacked(ProtobufCMessage *, ProtobufCAllocator *);
PROTOBUF_C_API protobuf_c_boolean
protobuf_c_message_check (const ProtobufCMessage *message);
protobuf_c_message_check(const ProtobufCMessage *);
/* WARNING: 'message' must be a block of memory
of size descriptor->sizeof_message. */
PROTOBUF_C_API void protobuf_c_message_init (const ProtobufCMessageDescriptor *,
void *message);
/*
* WARNING: 'message' must be a block of memory of size
* descriptor->sizeof_message.
*/
PROTOBUF_C_API void
protobuf_c_message_init(const ProtobufCMessageDescriptor *, void *message);
/* --- services --- */
typedef struct _ProtobufCMethodDescriptor ProtobufCMethodDescriptor;
struct _ProtobufCMethodDescriptor {
const char *name;
const ProtobufCMessageDescriptor *input;
const ProtobufCMessageDescriptor *output;
};
typedef struct _ProtobufCServiceDescriptor ProtobufCServiceDescriptor;
struct _ProtobufCServiceDescriptor {
uint32_t magic;
struct _ProtobufCMethodDescriptor
{
const char *name;
const ProtobufCMessageDescriptor *input;
const ProtobufCMessageDescriptor *output;
const char *name;
const char *short_name;
const char *c_name;
const char *package;
unsigned n_methods;
const ProtobufCMethodDescriptor *methods; /* in order from .proto file */
const unsigned *method_indices_by_name;
};
struct _ProtobufCServiceDescriptor
{
uint32_t magic;
const char *name;
const char *short_name;
const char *c_name;
const char *package;
unsigned n_methods;
const ProtobufCMethodDescriptor *methods; /* in order from .proto file */
const unsigned *method_indices_by_name;
};
typedef void (*ProtobufCClosure)(const ProtobufCMessage *, void *closure_data);
typedef struct _ProtobufCService ProtobufCService;
typedef void (*ProtobufCClosure)(const ProtobufCMessage *message,
void *closure_data);
struct _ProtobufCService
{
const ProtobufCServiceDescriptor *descriptor;
void (*invoke)(ProtobufCService *service,
unsigned method_index,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data);
void (*destroy) (ProtobufCService *service);
struct _ProtobufCService {
const ProtobufCServiceDescriptor *descriptor;
void (*invoke)(ProtobufCService *service,
unsigned method_index,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data);
void (*destroy)(ProtobufCService *service);
};
void protobuf_c_service_destroy (ProtobufCService *);
PROTOBUF_C_API void
protobuf_c_service_destroy(ProtobufCService *);
/* --- querying the descriptors --- */
PROTOBUF_C_API const ProtobufCEnumValue *
protobuf_c_enum_descriptor_get_value_by_name
(const ProtobufCEnumDescriptor *desc,
const char *name);
protobuf_c_enum_descriptor_get_value_by_name(
const ProtobufCEnumDescriptor *desc,
const char *name);
PROTOBUF_C_API const ProtobufCEnumValue *
protobuf_c_enum_descriptor_get_value
(const ProtobufCEnumDescriptor *desc,
int value);
protobuf_c_enum_descriptor_get_value(
const ProtobufCEnumDescriptor *desc,
int value);
PROTOBUF_C_API const ProtobufCFieldDescriptor *
protobuf_c_message_descriptor_get_field_by_name
(const ProtobufCMessageDescriptor *desc,
const char *name);
protobuf_c_message_descriptor_get_field_by_name(
const ProtobufCMessageDescriptor *desc,
const char *name);
PROTOBUF_C_API const ProtobufCFieldDescriptor *
protobuf_c_message_descriptor_get_field
(const ProtobufCMessageDescriptor *desc,
unsigned value);
protobuf_c_message_descriptor_get_field(
const ProtobufCMessageDescriptor *desc,
unsigned value);
PROTOBUF_C_API const ProtobufCMethodDescriptor *
protobuf_c_service_descriptor_get_method_by_name
(const ProtobufCServiceDescriptor *desc,
const char *name);
protobuf_c_service_descriptor_get_method_by_name(
const ProtobufCServiceDescriptor *desc,
const char *name);
/* --- wire format enums --- */
typedef enum
{
PROTOBUF_C_WIRE_TYPE_VARINT,
PROTOBUF_C_WIRE_TYPE_64BIT,
PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED,
PROTOBUF_C_WIRE_TYPE_START_GROUP, /* unsupported */
PROTOBUF_C_WIRE_TYPE_END_GROUP, /* unsupported */
PROTOBUF_C_WIRE_TYPE_32BIT
typedef enum {
PROTOBUF_C_WIRE_TYPE_VARINT,
PROTOBUF_C_WIRE_TYPE_64BIT,
PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED,
PROTOBUF_C_WIRE_TYPE_START_GROUP, /* unsupported */
PROTOBUF_C_WIRE_TYPE_END_GROUP, /* unsupported */
PROTOBUF_C_WIRE_TYPE_32BIT
} ProtobufCWireType;
/* --- unknown message fields --- */
struct _ProtobufCMessageUnknownField
{
uint32_t tag;
ProtobufCWireType wire_type;
size_t len;
uint8_t *data;
struct _ProtobufCMessageUnknownField {
uint32_t tag;
ProtobufCWireType wire_type;
size_t len;
uint8_t *data;
};
/* --- extra (superfluous) api: trivial buffer --- */
/* --- extra (superfluous) api: trivial buffer --- */
typedef struct _ProtobufCBufferSimple ProtobufCBufferSimple;
struct _ProtobufCBufferSimple
{
ProtobufCBuffer base;
size_t alloced;
size_t len;
uint8_t *data;
protobuf_c_boolean must_free_data;
struct _ProtobufCBufferSimple {
ProtobufCBuffer base;
size_t alloced;
size_t len;
uint8_t *data;
protobuf_c_boolean must_free_data;
};
#define PROTOBUF_C_BUFFER_SIMPLE_INIT(array_of_bytes) \
{ { protobuf_c_buffer_simple_append }, \
sizeof(array_of_bytes), 0, (array_of_bytes), 0 }
#define PROTOBUF_C_BUFFER_SIMPLE_CLEAR(simp_buf) \
do { if ((simp_buf)->must_free_data) \
protobuf_c_default_allocator.free (&protobuf_c_default_allocator.allocator_data, (simp_buf)->data); } while (0)
#define PROTOBUF_C_BUFFER_SIMPLE_INIT(array_of_bytes) \
{ \
{ protobuf_c_buffer_simple_append }, \
sizeof(array_of_bytes), \
0, \
(array_of_bytes), \
0 \
}
#define PROTOBUF_C_BUFFER_SIMPLE_CLEAR(simp_buf) \
do { \
if ((simp_buf)->must_free_data) \
protobuf_c_default_allocator.free( \
&protobuf_c_default_allocator.allocator_data, \
(simp_buf)->data); \
} while (0)
#ifdef PROTOBUF_C_PLEASE_INCLUDE_CTYPE
// This type is meant to reduce duplicated logic between
@ -488,30 +508,28 @@ struct _ProtobufCBufferSimple
// Because the names are confusing, and because this mechanism tends to be
// seldom used, you have to specifically request
// this API via #define PROTOBUF_C_PLEASE_INCLUDE_CTYPE.
typedef enum
{
PROTOBUF_C_CTYPE_INT32,
PROTOBUF_C_CTYPE_UINT32,
PROTOBUF_C_CTYPE_INT64,
PROTOBUF_C_CTYPE_UINT64,
PROTOBUF_C_CTYPE_FLOAT,
PROTOBUF_C_CTYPE_DOUBLE,
PROTOBUF_C_CTYPE_BOOL,
PROTOBUF_C_CTYPE_ENUM,
PROTOBUF_C_CTYPE_STRING,
PROTOBUF_C_CTYPE_BYTES,
PROTOBUF_C_CTYPE_MESSAGE,
typedef enum {
PROTOBUF_C_CTYPE_INT32,
PROTOBUF_C_CTYPE_UINT32,
PROTOBUF_C_CTYPE_INT64,
PROTOBUF_C_CTYPE_UINT64,
PROTOBUF_C_CTYPE_FLOAT,
PROTOBUF_C_CTYPE_DOUBLE,
PROTOBUF_C_CTYPE_BOOL,
PROTOBUF_C_CTYPE_ENUM,
PROTOBUF_C_CTYPE_STRING,
PROTOBUF_C_CTYPE_BYTES,
PROTOBUF_C_CTYPE_MESSAGE,
} ProtobufC_CType;
extern ProtobufC_CType protobuf_c_type_to_ctype (ProtobufCType type);
extern ProtobufC_CType protobuf_c_type_to_ctype(ProtobufCType type);
#define protobuf_c_type_to_ctype(type) \
((ProtobufC_CType)(protobuf_c_type_to_ctype_array[(type)]))
((ProtobufC_CType)(protobuf_c_type_to_ctype_array[(type)]))
#endif
/* ====== private ====== */
#include "protobuf-c-private.h"
PROTOBUF_C_END_DECLS
#endif /* __PROTOBUF_C_RUNTIME_H_ */