--- /dev/null
+#ifndef _PB_H_
+#define _PB_H_
+
+#include <stdint.h>
+#include <stddef.h> // size_t
+
+/* Lightweight input stream.
+ * If buf is NULL, read but don't store bytes. */
+typedef struct _pb_istream_t pb_istream_t;
+struct _pb_istream_t
+{
+ bool (*callback)(pb_istream_t *stream, char *buf, size_t count);
+ void *state; // Free field for use by callback implementation
+ size_t bytes_left;
+};
+
+static inline bool pb_read(pb_istream_t *stream, char *buf, size_t count)
+{
+ bool status = stream->callback(stream, buf, count);
+ stream->bytes_left -= count;
+ return status;
+}
+
+/* Lightweight output stream. */
+typedef struct _pb_ostream_t pb_ostream_t;
+struct _pb_ostream_t
+{
+ bool (*callback)(pb_ostream_t *stream, const char *buf, size_t count);
+ void *state; // Free field for use by callback implementation
+ size_t bytes_written;
+};
+
+static inline bool pb_write(pb_ostream_t *stream, const char *buf, size_t count)
+{
+ bool status = stream->callback(stream, buf, count);
+ stream->bytes_written += count;
+ return status;
+}
+
+/* List of possible decode/encode action types */
+
+typedef enum {
+ // Special case. Sets boolean field to true, continues parsing the data.
+ PB_ACT_HAS,
+
+ // Standard integer types
+ PB_ACT_UINT32,
+ PB_ACT_SINT32,
+ PB_ACT_INT32,
+ PB_ACT_FIXED32,
+ PB_ACT_SFIXED32,
+ PB_ACT_UINT64,
+ PB_ACT_SINT64,
+ PB_ACT_INT64,
+ PB_ACT_FIXED64,
+ PB_ACT_SFIXED64,
+ PB_ACT_BOOL,
+
+ // Standard float types
+ PB_ACT_FLOAT,
+ PB_ACT_DOUBLE,
+
+ // Constant-sized array
+ PB_ACT_BYTES,
+
+ // Constant-sized array, with null termination
+ PB_ACT_STRING,
+
+ // Callback function pointer in field value
+ PB_ACT_SUBMESSAGE,
+
+ PB_LAST_ACT
+} pb_action_t;
+
+// This structure is used in constants to specify struct fields.
+typedef struct {
+ int field_number;
+ uint16_t offset;
+ pb_action_t action;
+ uint8_t fieldsize;
+} pb_field_t;
+
+#define PB_LAST_FIELD {0,0,0,0}
+
+/* --- Types to use inside generated structures. --- */
+
+// Byte array and size word.
+// Note: because of variable length array, this type cannot be directly used.
+// Autogenerated code declares the same type of fields but with explicit length.
+typedef struct {
+ size_t size;
+ char bytes[];
+} pb_bytearray_t;
+
+// This structure is used for giving the callback function.
+typedef struct _pb_callback_t pb_callback_t;
+struct _pb_callback_t {
+ union {
+ bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void *arg);
+ bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void *arg);
+ } funcs;
+
+ // Free arg for use by callback
+ void *arg;
+};
+
+#endif
\ No newline at end of file
--- /dev/null
+/* pb_decode.c -- decode a protobuf using callback functions
+ *
+ * 2011 Petteri Aimonen <jpa@kapsi.fi>
+ */
+
+#include "pb_decode.h"
+
+const pb_decoder_t PB_DECODERS[PB_LAST_ACT] = {
+ NULL,
+ &pb_dec_uint32,
+ &pb_dec_sint32,
+ &pb_dec_uint32, // Cast to int32
+ &pb_dec_fixed32,
+ &pb_dec_fixed32, // Cast to int32
+ &pb_dec_uint64,
+ &pb_dec_sint64,
+ &pb_dec_uint64, // Cast to int64
+ &pb_dec_fixed64,
+ &pb_dec_fixed64, // Cast to int64
+ &pb_dec_bool,
+ &pb_dec_float,
+ &pb_dec_double,
+ &pb_dec_bytes,
+ &pb_dec_string,
+ &pb_dec_submessage
+};
+
+enum wire_type {
+ WT_VARINT = 0,
+ WT_64BIT = 1,
+ WT_STRING = 2,
+ WT_32BIT = 5
+};
+
+// Note: pb_decode_varint32 is a bit un-orthodox:
+// it will refuse to decode values that exceed uint32 range.
+// The Google implementation would simply cast to 32 bits.
+bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
+{
+ char byte;
+ int bitpos = 0;
+ *dest = 0;
+
+ while (bitpos < 32 && pb_read(stream, &byte, 1))
+ {
+ *dest |= (byte & 0x7F) << bitpos;
+ bitpos += 7;
+
+ if (!(byte & 0x80))
+ return true;
+ }
+
+ return false;
+}
+
+bool pb_decode_varint64(pb_istream_t *stream, uint64_t *dest)
+{
+ char byte;
+ int bitpos = 0;
+ *dest = 0;
+
+ while (bitpos < 64 && pb_read(stream, &byte, 1))
+ {
+ *dest |= (byte & 0x7F) << bitpos;
+ bitpos += 7;
+
+ if (!(byte & 0x80))
+ return true;
+ }
+
+ return false;
+}
+
+bool pb_skip_varint(pb_istream_t *stream)
+{
+ char byte;
+ do
+ {
+ if (!pb_read(stream, &byte, 1))
+ return false;
+ } while (byte & 0x80);
+ return true;
+}
+
+bool pb_skip_string(pb_istream_t *stream)
+{
+ uint32_t length;
+ if (!pb_decode_varint32(stream, &length))
+ return false;
+
+ return pb_read(stream, NULL, length);
+}
+
+bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest)
+{
+ while (stream->bytes_left)
+ {
+ uint32_t temp;
+ if (!pb_decode_varint32(stream, &temp))
+ return false;
+
+ int field_number = temp >> 3;
+ int wire_type = temp & 7;
+
+ const pb_field_t *field = fields;
+ while (field->field_number != 0)
+ {
+ if (field->field_number != field_number)
+ {
+ field++;
+ continue;
+ }
+
+ void *destfield = dest + field->offset;
+
+ if (field->action == PB_ACT_HAS)
+ {
+ *(bool*)destfield = true;
+ field++;
+ continue;
+ }
+
+ pb_decoder_t func = PB_DECODERS[field->action];
+ if (!func(stream, field, destfield))
+ return false;
+
+ break;
+ }
+
+ if (field->field_number == 0) // No match found, skip data
+ {
+ bool status = false;
+ switch (wire_type)
+ {
+ case WT_VARINT:
+ status = pb_skip_varint(stream);
+ break;
+
+ case WT_64BIT:
+ status = pb_read(stream, NULL, 8);
+ break;
+
+ case WT_STRING:
+ status = pb_skip_string(stream);
+ break;
+
+ case WT_32BIT:
+ status = pb_read(stream, NULL, 4);
+ break;
+ }
+
+ if (!status)
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool pb_dec_uint32(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ return pb_decode_varint32(stream, (uint32_t*)dest);
+}
+
+bool pb_dec_sint32(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ uint32_t *x = (uint32_t*)dest;
+ bool status = pb_decode_varint32(stream, x);
+ *x = (*x >> 1) ^ -(int32_t)(*x & 1);
+ return status;
+}
+
+bool pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ char bytes[4] = {0};
+ bool status = pb_read(stream, bytes, 4);
+ *(uint32_t*)dest =
+ bytes[0] | ((uint32_t)bytes[1] << 8) |
+ ((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
+ return status;
+}
+
+bool pb_dec_uint64(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ return pb_decode_varint64(stream, (uint64_t*)dest);
+}
+
+bool pb_dec_sint64(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ uint64_t *x = (uint64_t*)dest;
+ bool status = pb_decode_varint64(stream, x);
+ *x = (*x >> 1) ^ -(int64_t)(*x & 1);
+ return status;
+}
+
+bool pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ char bytes[8] = {0};
+ bool status = pb_read(stream, bytes, 8);
+ *(uint64_t*)dest =
+ (uint64_t)bytes[0] | ((uint64_t)bytes[1] << 8) |
+ ((uint64_t)bytes[2] << 16) | ((uint64_t)bytes[3] << 24) |
+ ((uint64_t)bytes[4] << 32) | ((uint64_t)bytes[5] << 40) |
+ ((uint64_t)bytes[6] << 48) | ((uint64_t)bytes[7] << 56);
+ return status;
+}
+
+bool pb_dec_bool(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ uint32_t temp = 0;
+ bool status = pb_decode_varint32(stream, &temp);
+ *(bool*)dest = !!temp;
+ return status;
+}
+
+bool pb_dec_float(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ return pb_read(stream, (char*)dest, sizeof(float));
+}
+
+bool pb_dec_double(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ return pb_read(stream, (char*)dest, sizeof(double));
+}
+
+bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ pb_bytearray_t *x = (pb_bytearray_t*)dest;
+ uint32_t temp;
+ if (!pb_decode_varint32(stream, &temp))
+ return false;
+ x->size = temp;
+
+ if (x->size > field->fieldsize)
+ return false;
+
+ return pb_read(stream, x->bytes, x->size);
+}
+
+bool pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ uint32_t size;
+ if (!pb_decode_varint32(stream, &size))
+ return false;
+
+ if (size > field->fieldsize - 1)
+ return false;
+
+ bool status = pb_read(stream, (char*)dest, size);
+ *((char*)dest + size) = 0;
+ return status;
+}
+
+bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
+{
+ pb_callback_t *x = (pb_callback_t*)dest;
+
+ if (x->funcs.decode == NULL)
+ return pb_skip_string(stream);
+
+ uint32_t size;
+ if (!pb_decode_varint32(stream, &size))
+ return false;
+
+ if (stream->bytes_left < size)
+ return false;
+
+ // Make a limited-length istream for decoding submessage
+ pb_istream_t shortstream = *stream;
+ shortstream.bytes_left = size;
+ bool status = x->funcs.decode(&shortstream, field, x->arg);
+ stream->bytes_left -= size - shortstream.bytes_left;
+ return status;
+}
--- /dev/null
+#ifndef _PB_DECODE_H_
+#define _PB_DECODE_H_
+
+#include <stdbool.h>
+#include "pb.h"
+
+// Decode from stream to destination struct.
+// The actual struct pointed to by dest must match the description in fields.
+bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest);
+
+/* --- Helper functions ---
+ * You may want to use these from your callbacks.
+ */
+
+bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest);
+bool pb_decode_varint64(pb_istream_t *stream, uint64_t *dest);
+
+bool pb_skip_varint(pb_istream_t *stream);
+bool pb_skip_string(pb_istream_t *stream);
+
+/* --- Field decoders ---
+ * Each decoder takes stream and field description, and a pointer to the field
+ * in the destination struct (dest = struct_addr + field->offset).
+ */
+
+// Integer types.
+bool pb_dec_uint32(pb_istream_t *stream, const pb_field_t *field, void *dest);
+bool pb_dec_sint32(pb_istream_t *stream, const pb_field_t *field, void *dest);
+bool pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest);
+bool pb_dec_uint64(pb_istream_t *stream, const pb_field_t *field, void *dest);
+bool pb_dec_sint64(pb_istream_t *stream, const pb_field_t *field, void *dest);
+bool pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest);
+bool pb_dec_bool(pb_istream_t *stream, const pb_field_t *field, void *dest);
+
+// Floating point types. Info is ignored.
+bool pb_dec_float(pb_istream_t *stream, const pb_field_t *field, void *dest);
+bool pb_dec_double(pb_istream_t *stream, const pb_field_t *field, void *dest);
+
+// Byte array. Dest is pointer to
+bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest);
+
+// Null-terminated string.
+bool pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest);
+
+// Use callback. Dest is pointer to pb_callback_t struct.
+bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest);
+
+typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest);
+
+/* --- Function pointers to field decoders ---
+ * Order in the array must match pb_action_t numbering.
+ */
+const pb_decoder_t PB_DECODERS[PB_LAST_ACT];
+
+#endif
--- /dev/null
+message Person {
+ required string name = 1;
+ required int32 id = 2;
+ optional string email = 3;
+
+ enum PhoneType {
+ MOBILE = 0;
+ HOME = 1;
+ WORK = 2;
+ }
+
+ message PhoneNumber {
+ required string number = 1;
+ optional PhoneType type = 2 [default = HOME];
+ }
+
+ repeated PhoneNumber phone = 4;
+}
--- /dev/null
+#include <stdio.h>
+#include <string.h>
+#include <stddef.h>
+#include "pb_decode.h"
+
+/* Structures for "Person" message */
+
+typedef enum {
+ Person_PhoneType_MOBILE = 0,
+ Person_PhoneType_HOME = 1,
+ Person_PhoneType_WORK = 2,
+
+ _Person_PhoneType_size = 0xFFFFFFFF // Force 32-bit enum
+} Person_PhoneType;
+
+typedef struct {
+ char number[40];
+ bool has_type;
+ Person_PhoneType type;
+} Person_PhoneNumber;
+
+typedef struct {
+ char name[40];
+ int32_t id;
+ bool has_email;
+ char email[40];
+
+ pb_callback_t phone;
+} Person;
+
+/* Field descriptions */
+#define membersize(st, m) (sizeof ((st*)0)->m)
+
+const pb_field_t Person_PhoneNumber_fields[] = {
+ {1, offsetof(Person_PhoneNumber, number), PB_ACT_STRING, membersize(Person_PhoneNumber, number)},
+ {2, offsetof(Person_PhoneNumber, has_type), PB_ACT_HAS, membersize(Person_PhoneNumber, has_type)},
+ {2, offsetof(Person_PhoneNumber, type), PB_ACT_UINT32, membersize(Person_PhoneNumber, type)},
+ PB_LAST_FIELD
+};
+
+const pb_field_t Person_fields[] = {
+ {1, offsetof(Person, name), PB_ACT_STRING, membersize(Person, name)},
+ {2, offsetof(Person, id), PB_ACT_INT32, membersize(Person, id)},
+ {3, offsetof(Person, email), PB_ACT_STRING, membersize(Person, email)},
+ {4, offsetof(Person, phone), PB_ACT_SUBMESSAGE, membersize(Person, phone)}
+};
+
+/* Default value descriptions */
+#define Person_PhoneNumber_default {"", false, Person_PhoneType_HOME};
+#define Person_default {"", 0, false, "", {{0},0}};
+
+/* And now, the actual test program */
+
+bool print_phonenumber(pb_istream_t *stream, const pb_field_t *field, void *arg)
+{
+ Person_PhoneNumber x = Person_PhoneNumber_default;
+ if (!pb_decode(stream, Person_PhoneNumber_fields, &x))
+ return false;
+
+ printf("PhoneNumber: number '%s' type '%d'\n", x.number, x.type);
+ return true;
+}
+
+bool print_person(pb_istream_t *stream)
+{
+ Person x = Person_default;
+ x.phone.funcs.decode = &print_phonenumber;
+
+ if (!pb_decode(stream, Person_fields, &x))
+ return false;
+
+ printf("Person: name '%s' id '%d' email '%s'\n", x.name, x.id, x.email);
+ return true;
+}
+
+bool my_read(pb_istream_t *stream, char *buf, size_t count)
+{
+ char *source = (char*)stream->state;
+
+ if (!stream->bytes_left)
+ return false;
+
+ if (buf != NULL)
+ {
+ memcpy(buf, source, count);
+ }
+
+ stream->state = source + count;
+ return true;
+}
+
+int main()
+{
+ char buffer[512];
+ size_t size = fread(buffer, 1, 512, stdin);
+
+ pb_istream_t stream = {&my_read, buffer, size};
+ if (!print_person(&stream))
+ printf("Parsing failed.\n");
+
+ return 0;
+}
--- /dev/null
+
+\vTest Person\107\1a\11foobar@foobar.com"\10
+\f555-12345678\10\ 2
\ No newline at end of file
Code Review / apps / low-level-can-service.git / commitdiff