X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=pb_encode.c;h=3fc03811dfc867b78c40e19a259db55a685e4cdb;hb=f1d7640fe1be0f150f604c72108ea516222c2505;hp=2a4d8e112570f9e52a1446ffc03ffe0714b3782b;hpb=8b635924ba6b199e792e22bf56e30af9ba37ecdb;p=apps%2Fagl-service-can-low-level.git diff --git a/pb_encode.c b/pb_encode.c index 2a4d8e11..3fc03811 100644 --- a/pb_encode.c +++ b/pb_encode.c @@ -3,18 +3,19 @@ * 2011 Petteri Aimonen */ +#define NANOPB_INTERNALS #include "pb.h" #include "pb_encode.h" #include -#ifdef __GNUC__ -/* Verify that we remember to check all return values for proper error propagation */ -#define checkreturn __attribute__((warn_unused_result)) +/* The warn_unused_result attribute appeared first in gcc-3.4.0 */ +#if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4) + #define checkreturn #else -#define checkreturn + /* Verify that we remember to check all return values for proper error propagation */ + #define checkreturn __attribute__((warn_unused_result)) #endif - typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src) checkreturn; /* --- Function pointers to field encoders --- @@ -23,7 +24,8 @@ typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, cons static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = { &pb_enc_varint, &pb_enc_svarint, - &pb_enc_fixed, + &pb_enc_fixed32, + &pb_enc_fixed64, &pb_enc_bytes, &pb_enc_string, @@ -67,26 +69,37 @@ bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count /* Main encoding stuff */ +/* Callbacks don't need this function because they usually know the data type + * without examining the field structure. + * Therefore it is static for now. + */ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field, const void *pData, size_t count, pb_encoder_t func) { - int i; + size_t i; const void *p; size_t size; - if (PB_LTYPE(field->type) < PB_LTYPE_LAST_PACKABLE) + if (count == 0) + return true; + + if (PB_LTYPE(field->type) <= PB_LTYPE_LAST_PACKABLE) { if (!pb_encode_tag(stream, PB_WT_STRING, field->tag)) return false; /* Determine the total size of packed array. */ - if (PB_LTYPE(field->type) == PB_LTYPE_FIXED) + if (PB_LTYPE(field->type) == PB_LTYPE_FIXED32) + { + size = 4 * count; + } + else if (PB_LTYPE(field->type) == PB_LTYPE_FIXED64) { - size = field->data_size * count; + size = 8 * count; } else { - pb_ostream_t sizestream = {0}; + pb_ostream_t sizestream = {0,0,0,0}; p = pData; for (i = 0; i < count; i++) { @@ -97,7 +110,7 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie size = sizestream.bytes_written; } - if (!pb_encode_varint(stream, size)) + if (!pb_encode_varint(stream, (uint64_t)size)) return false; if (stream->callback == NULL) @@ -137,15 +150,14 @@ bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], cons while (field->tag != 0) { + pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)]; pData = (const char*)pData + prev_size + field->data_offset; pSize = (const char*)pData + field->size_offset; prev_size = field->data_size; if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY) prev_size *= field->array_size; - - pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)]; - + switch (PB_HTYPE(field->type)) { case PB_HTYPE_REQUIRED: @@ -200,7 +212,7 @@ bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value) while (value) { - buffer[i] = (value & 0x7F) | 0x80; + buffer[i] = (uint8_t)((value & 0x7F) | 0x80); value >>= 7; i++; } @@ -209,10 +221,55 @@ bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value) return pb_write(stream, buffer, i); } +bool checkreturn pb_encode_svarint(pb_ostream_t *stream, int64_t value) +{ + uint64_t zigzagged; + if (value < 0) + zigzagged = ~(value << 1); + else + zigzagged = value << 1; + + return pb_encode_varint(stream, zigzagged); +} + +bool checkreturn pb_encode_fixed32(pb_ostream_t *stream, const void *value) +{ + #ifdef __BIG_ENDIAN__ + const uint8_t *bytes = value; + uint8_t lebytes[4]; + lebytes[0] = bytes[3]; + lebytes[1] = bytes[2]; + lebytes[2] = bytes[1]; + lebytes[3] = bytes[0]; + return pb_write(stream, lebytes, 4); + #else + return pb_write(stream, (uint8_t*)value, 4); + #endif +} + +bool checkreturn pb_encode_fixed64(pb_ostream_t *stream, const void *value) +{ + #ifdef __BIG_ENDIAN__ + const uint8_t *bytes = value; + uint8_t lebytes[8]; + lebytes[0] = bytes[7]; + lebytes[1] = bytes[6]; + lebytes[2] = bytes[5]; + lebytes[3] = bytes[4]; + lebytes[4] = bytes[3]; + lebytes[5] = bytes[2]; + lebytes[6] = bytes[1]; + lebytes[7] = bytes[0]; + return pb_write(stream, lebytes, 8); + #else + return pb_write(stream, (uint8_t*)value, 8); + #endif +} + bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number) { int tag = wiretype | (field_number << 3); - return pb_encode_varint(stream, tag); + return pb_encode_varint(stream, (uint64_t)tag); } bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field) @@ -225,13 +282,12 @@ bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t wiretype = PB_WT_VARINT; break; - case PB_LTYPE_FIXED: - if (field->data_size == 4) - wiretype = PB_WT_32BIT; - else if (field->data_size == 8) - wiretype = PB_WT_64BIT; - else - return false; + case PB_LTYPE_FIXED32: + wiretype = PB_WT_32BIT; + break; + + case PB_LTYPE_FIXED64: + wiretype = PB_WT_64BIT; break; case PB_LTYPE_BYTES: @@ -249,115 +305,113 @@ bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t bool checkreturn pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size) { - if (!pb_encode_varint(stream, size)) + if (!pb_encode_varint(stream, (uint64_t)size)) return false; return pb_write(stream, buffer, size); } -/* Field encoders */ - -/* Copy srcsize bytes from src so that values are casted properly. - * On little endian machine, copy to start of dest - * On big endian machine, copy to end of dest - * destsize must always be larger than srcsize - * - * Note: This is the reverse of the endian_copy in pb_decode.c. - */ -static void endian_copy(void *dest, const void *src, size_t destsize, size_t srcsize) +bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct) { -#ifdef __BIG_ENDIAN__ - memcpy((char*)dest + (destsize - srcsize), src, srcsize); -#else - memcpy(dest, src, srcsize); -#endif + /* First calculate the message size using a non-writing substream. */ + pb_ostream_t substream = {0,0,0,0}; + size_t size; + bool status; + + if (!pb_encode(&substream, fields, src_struct)) + return false; + + size = substream.bytes_written; + + if (!pb_encode_varint(stream, (uint64_t)size)) + return false; + + if (stream->callback == NULL) + return pb_write(stream, NULL, size); /* Just sizing */ + + if (stream->bytes_written + size > stream->max_size) + return false; + + /* Use a substream to verify that a callback doesn't write more than + * what it did the first time. */ + substream.callback = stream->callback; + substream.state = stream->state; + substream.max_size = size; + substream.bytes_written = 0; + + status = pb_encode(&substream, fields, src_struct); + + stream->bytes_written += substream.bytes_written; + stream->state = substream.state; + + if (substream.bytes_written != size) + return false; + + return status; } +/* Field encoders */ + bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src) { uint64_t value = 0; - endian_copy(&value, src, sizeof(value), field->data_size); + + switch (field->data_size) + { + case 1: value = *(uint8_t*)src; break; + case 2: value = *(uint16_t*)src; break; + case 4: value = *(uint32_t*)src; break; + case 8: value = *(uint64_t*)src; break; + default: return false; + } + return pb_encode_varint(stream, value); } bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src) { uint64_t value = 0; - uint64_t zigzagged; - uint64_t signbitmask, xormask; - endian_copy(&value, src, sizeof(value), field->data_size); - signbitmask = (uint64_t)0x80 << (field->data_size * 8 - 8); - xormask = ((uint64_t)-1) >> (64 - field->data_size * 8); - if (value & signbitmask) - zigzagged = ((value ^ xormask) << 1) | 1; - else - zigzagged = value << 1; + switch (field->data_size) + { + case 4: value = *(int32_t*)src; break; + case 8: value = *(int64_t*)src; break; + default: return false; + } - return pb_encode_varint(stream, zigzagged); + return pb_encode_svarint(stream, value); } -bool checkreturn pb_enc_fixed(pb_ostream_t *stream, const pb_field_t *field, const void *src) +bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src) { - #ifdef __BIG_ENDIAN__ - uint8_t bytes[8] = {0}; - endian_copy(bytes, src, sizeof(bytes), field->data_size); - uint8_t lebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4], - bytes[3], bytes[2], bytes[1], bytes[0]}; - return pb_write(stream, lebytes, field->data_size); - #else - return pb_write(stream, (uint8_t*)src, field->data_size); - #endif + UNUSED(field); + return pb_encode_fixed64(stream, src); +} + +bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src) +{ + UNUSED(field); + return pb_encode_fixed32(stream, src); } bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src) { pb_bytes_array_t *bytes = (pb_bytes_array_t*)src; + UNUSED(field); return pb_encode_string(stream, bytes->bytes, bytes->size); } bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src) { + UNUSED(field); return pb_encode_string(stream, (uint8_t*)src, strlen((char*)src)); } bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src) { - pb_ostream_t substream = {0}; - size_t size; - bool status; - if (field->ptr == NULL) return false; - if (!pb_encode(&substream, (pb_field_t*)field->ptr, src)) - return false; - - size = substream.bytes_written; - - if (!pb_encode_varint(stream, size)) - return false; - - if (stream->callback == NULL) - return pb_write(stream, NULL, size); /* Just sizing */ - - if (stream->bytes_written + size > stream->max_size) - return false; - - /* Use a substream to verify that a callback doesn't write more than - * what it did the first time. */ - substream.callback = stream->callback; - substream.state = stream->state; - substream.max_size = size; - substream.bytes_written = 0; - - status = pb_encode(&substream, (pb_field_t*)field->ptr, src); - - stream->bytes_written += substream.bytes_written; - - if (substream.bytes_written != size) - return false; - - return status; + return pb_encode_submessage(stream, (pb_field_t*)field->ptr, src); }