#!/usr/bin/python
'''Generate header file for nanopb from a ProtoBuf FileDescriptorSet.'''
-nanopb_version = "nanopb-0.2.4-dev"
+nanopb_version = "nanopb-0.2.5-dev"
try:
import google.protobuf.descriptor_pb2 as descriptor
FieldD.TYPE_FIXED32: ('uint32_t', 'FIXED32', 4),
FieldD.TYPE_FIXED64: ('uint64_t', 'FIXED64', 8),
FieldD.TYPE_FLOAT: ('float', 'FLOAT', 4),
- FieldD.TYPE_INT32: ('int32_t', 'INT32', 5),
+ FieldD.TYPE_INT32: ('int32_t', 'INT32', 10),
FieldD.TYPE_INT64: ('int64_t', 'INT64', 10),
FieldD.TYPE_SFIXED32: ('int32_t', 'SFIXED32', 4),
FieldD.TYPE_SFIXED64: ('int64_t', 'SFIXED64', 8),
assert varint_max_size(127) == 1
assert varint_max_size(128) == 2
+class EncodedSize:
+ '''Class used to represent the encoded size of a field or a message.
+ Consists of a combination of symbolic sizes and integer sizes.'''
+ def __init__(self, value = 0, symbols = []):
+ if isinstance(value, (str, Names)):
+ symbols = [str(value)]
+ value = 0
+ self.value = value
+ self.symbols = symbols
+
+ def __add__(self, other):
+ if isinstance(other, (int, long)):
+ return EncodedSize(self.value + other, self.symbols)
+ elif isinstance(other, (str, Names)):
+ return EncodedSize(self.value, self.symbols + [str(other)])
+ elif isinstance(other, EncodedSize):
+ return EncodedSize(self.value + other.value, self.symbols + other.symbols)
+ else:
+ raise ValueError("Cannot add size: " + repr(other))
+
+ def __mul__(self, other):
+ if isinstance(other, (int, long)):
+ return EncodedSize(self.value * other, [str(other) + '*' + s for s in self.symbols])
+ else:
+ raise ValueError("Cannot multiply size: " + repr(other))
+
+ def __str__(self):
+ if not self.symbols:
+ return str(self.value)
+ else:
+ return '(' + str(self.value) + ' + ' + ' + '.join(self.symbols) + ')'
+
+ def upperlimit(self):
+ if not self.symbols:
+ return self.value
+ else:
+ return 2**32 - 1
+
class Enum:
def __init__(self, names, desc, enum_options):
'''desc is EnumDescriptorProto'''
if self.allocation != 'STATIC':
return None
- encsize = self.enc_size
if self.pbtype == 'MESSAGE':
for msg in allmsgs:
if msg.name == self.submsgname:
encsize = msg.encoded_size(allmsgs)
if encsize is None:
return None # Submessage size is indeterminate
- encsize += varint_max_size(encsize) # submsg length is encoded also
+
+ # Include submessage length prefix
+ encsize += varint_max_size(encsize.upperlimit())
break
else:
# Submessage cannot be found, this currently occurs when
# the submessage type is defined in a different file.
- return None
-
- if encsize is None:
+ # Instead of direct numeric value, reference the size that
+ # has been #defined in the other file.
+ encsize = EncodedSize(self.submsgname + 'size')
+
+ # We will have to make a conservative assumption on the length
+ # prefix size, though.
+ encsize += 5
+
+ elif self.enc_size is None:
raise RuntimeError("Could not determine encoded size for %s.%s"
% (self.struct_name, self.name))
+ else:
+ encsize = EncodedSize(self.enc_size)
encsize += varint_max_size(self.tag << 3) # Tag + wire type
# We exclude extensions from the count, because they cannot be known
# until runtime. Other option would be to return None here, but this
# way the value remains useful if extensions are not used.
- return 0
+ return EncodedSize(0)
class ExtensionField(Field):
def __init__(self, struct_name, desc, field_options):
self.skip = False
self.rules = 'OPTEXT'
+ def tags(self):
+ '''Return the #define for the tag number of this field.'''
+ identifier = '%s_tag' % self.fullname
+ return '#define %-40s %d\n' % (identifier, self.tag)
+
def extension_decl(self):
'''Declaration of the extension type in the .pb.h file'''
if self.skip:
'''Return the maximum size that this message can take when encoded.
If the size cannot be determined, returns None.
'''
- size = 0
+ size = EncodedSize(0)
for field in self.fields:
fsize = field.encoded_size(allmsgs)
if fsize is None:
for msg in sort_dependencies(messages):
for field in msg.fields:
yield field.tags()
+ for extension in extensions:
+ yield extension.tags()
yield '\n'
yield '/* Struct field encoding specification for nanopb */\n'
msize = msg.encoded_size(messages)
if msize is not None:
identifier = '%s_size' % msg.name
- yield '#define %-40s %d\n' % (identifier, msize)
+ yield '#define %-40s %s\n' % (identifier, msize)
yield '\n'
yield '#ifdef __cplusplus\n'