+#!/usr/bin/python
+
'''Generate header file for nanopb from a ProtoBuf FileDescriptorSet.'''
-nanopb_version = "nanopb-0.1.9-dev"
+nanopb_version = "nanopb-0.2.5-dev"
+
+import sys
try:
- import google.protobuf.descriptor_pb2 as descriptor
+ import google, distutils.util # bbfreeze seems to need these
+ import google.protobuf.text_format as text_format
except:
- print
- print "*************************************************************"
- print "*** Could not import the Google protobuf Python libraries ***"
- print "*** Try installing package 'python-protobuf' or similar. ***"
- print "*************************************************************"
- print
+ sys.stderr.write('''
+ *************************************************************
+ *** Could not import the Google protobuf Python libraries ***
+ *** Try installing package 'python-protobuf' or similar. ***
+ *************************************************************
+ ''' + '\n')
raise
try:
- import nanopb_pb2
+ import proto.nanopb_pb2 as nanopb_pb2
+ import proto.descriptor_pb2 as descriptor
except:
- print
- print "***************************************************************"
- print "*** Could not import the precompiled nanopb_pb2.py. ***"
- print "*** Run 'make' in the 'generator' folder to update the file.***"
- print "***************************************************************"
- print
+ sys.stderr.write('''
+ ********************************************************************
+ *** Failed to import the protocol definitions for generator. ***
+ *** You have to run 'make' in the nanopb/generator/proto folder. ***
+ ********************************************************************
+ ''' + '\n')
raise
-
-
-
-
# ---------------------------------------------------------------------------
# Generation of single fields
# ---------------------------------------------------------------------------
import time
import os.path
-# Values are tuple (c type, pb ltype)
+# Values are tuple (c type, pb type, encoded size)
FieldD = descriptor.FieldDescriptorProto
datatypes = {
- FieldD.TYPE_BOOL: ('bool', 'PB_LTYPE_VARINT'),
- FieldD.TYPE_DOUBLE: ('double', 'PB_LTYPE_FIXED64'),
- FieldD.TYPE_FIXED32: ('uint32_t', 'PB_LTYPE_FIXED32'),
- FieldD.TYPE_FIXED64: ('uint64_t', 'PB_LTYPE_FIXED64'),
- FieldD.TYPE_FLOAT: ('float', 'PB_LTYPE_FIXED32'),
- FieldD.TYPE_INT32: ('int32_t', 'PB_LTYPE_VARINT'),
- FieldD.TYPE_INT64: ('int64_t', 'PB_LTYPE_VARINT'),
- FieldD.TYPE_SFIXED32: ('int32_t', 'PB_LTYPE_FIXED32'),
- FieldD.TYPE_SFIXED64: ('int64_t', 'PB_LTYPE_FIXED64'),
- FieldD.TYPE_SINT32: ('int32_t', 'PB_LTYPE_SVARINT'),
- FieldD.TYPE_SINT64: ('int64_t', 'PB_LTYPE_SVARINT'),
- FieldD.TYPE_UINT32: ('uint32_t', 'PB_LTYPE_VARINT'),
- FieldD.TYPE_UINT64: ('uint64_t', 'PB_LTYPE_VARINT')
+ FieldD.TYPE_BOOL: ('bool', 'BOOL', 1),
+ FieldD.TYPE_DOUBLE: ('double', 'DOUBLE', 8),
+ 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', 10),
+ FieldD.TYPE_INT64: ('int64_t', 'INT64', 10),
+ FieldD.TYPE_SFIXED32: ('int32_t', 'SFIXED32', 4),
+ FieldD.TYPE_SFIXED64: ('int64_t', 'SFIXED64', 8),
+ FieldD.TYPE_SINT32: ('int32_t', 'SINT32', 5),
+ FieldD.TYPE_SINT64: ('int64_t', 'SINT64', 10),
+ FieldD.TYPE_UINT32: ('uint32_t', 'UINT32', 5),
+ FieldD.TYPE_UINT64: ('uint64_t', 'UINT64', 10)
}
class Names:
- '''Keeps a set of nested names and formats them to C identifier.
- You can subclass this with your own implementation.
- '''
+ '''Keeps a set of nested names and formats them to C identifier.'''
def __init__(self, parts = ()):
if isinstance(parts, Names):
parts = parts.parts
raise NotImplementedError("Lookup of non-absolute type names is not supported")
return Names(type_name[1:].split('.'))
+def varint_max_size(max_value):
+ '''Returns the maximum number of bytes a varint can take when encoded.'''
+ for i in range(1, 11):
+ if (max_value >> (i * 7)) == 0:
+ return i
+ raise ValueError("Value too large for varint: " + str(max_value))
+
+assert varint_max_size(0) == 1
+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'''
self.max_size = None
self.max_count = None
self.array_decl = ""
+ self.enc_size = None
# Parse field options
if field_options.HasField("max_size"):
if desc.HasField('default_value'):
self.default = desc.default_value
- # Decide HTYPE
- # HTYPE is the high-order nibble of nanopb field description,
- # defining whether value is required/optional/repeated.
+ # Check field rules, i.e. required/optional/repeated.
can_be_static = True
if desc.label == FieldD.LABEL_REQUIRED:
- self.htype = 'PB_HTYPE_REQUIRED'
+ self.rules = 'REQUIRED'
elif desc.label == FieldD.LABEL_OPTIONAL:
- self.htype = 'PB_HTYPE_OPTIONAL'
+ self.rules = 'OPTIONAL'
elif desc.label == FieldD.LABEL_REPEATED:
+ self.rules = 'REPEATED'
if self.max_count is None:
can_be_static = False
else:
- self.htype = 'PB_HTYPE_ARRAY'
self.array_decl = '[%d]' % self.max_count
else:
raise NotImplementedError(desc.label)
- # Decide LTYPE and CTYPE
- # LTYPE is the low-order nibble of nanopb field description,
- # defining how to decode an individual value.
- # CTYPE is the name of the c type to use in the struct.
+ # Check if the field can be implemented with static allocation
+ # i.e. whether the data size is known.
+ if desc.type == FieldD.TYPE_STRING and self.max_size is None:
+ can_be_static = False
+
+ if desc.type == FieldD.TYPE_BYTES and self.max_size is None:
+ can_be_static = False
+
+ # Decide how the field data will be allocated
+ if field_options.type == nanopb_pb2.FT_DEFAULT:
+ if can_be_static:
+ field_options.type = nanopb_pb2.FT_STATIC
+ else:
+ field_options.type = nanopb_pb2.FT_CALLBACK
+
+ if field_options.type == nanopb_pb2.FT_STATIC and not can_be_static:
+ raise Exception("Field %s is defined as static, but max_size or "
+ "max_count is not given." % self.name)
+
+ if field_options.type == nanopb_pb2.FT_STATIC:
+ self.allocation = 'STATIC'
+ elif field_options.type == nanopb_pb2.FT_POINTER:
+ self.allocation = 'POINTER'
+ elif field_options.type == nanopb_pb2.FT_CALLBACK:
+ self.allocation = 'CALLBACK'
+ else:
+ raise NotImplementedError(field_options.type)
+
+ # Decide the C data type to use in the struct.
if datatypes.has_key(desc.type):
- self.ctype, self.ltype = datatypes[desc.type]
+ self.ctype, self.pbtype, self.enc_size = datatypes[desc.type]
elif desc.type == FieldD.TYPE_ENUM:
- self.ltype = 'PB_LTYPE_VARINT'
+ self.pbtype = 'ENUM'
self.ctype = names_from_type_name(desc.type_name)
if self.default is not None:
self.default = self.ctype + self.default
+ self.enc_size = 5 # protoc rejects enum values > 32 bits
elif desc.type == FieldD.TYPE_STRING:
- self.ltype = 'PB_LTYPE_STRING'
- if self.max_size is None:
- can_be_static = False
- else:
+ self.pbtype = 'STRING'
+ self.ctype = 'char'
+ if self.allocation == 'STATIC':
self.ctype = 'char'
self.array_decl += '[%d]' % self.max_size
+ self.enc_size = varint_max_size(self.max_size) + self.max_size
elif desc.type == FieldD.TYPE_BYTES:
- self.ltype = 'PB_LTYPE_BYTES'
- if self.max_size is None:
- can_be_static = False
- else:
+ self.pbtype = 'BYTES'
+ if self.allocation == 'STATIC':
self.ctype = self.struct_name + self.name + 't'
+ self.enc_size = varint_max_size(self.max_size) + self.max_size
+ elif self.allocation == 'POINTER':
+ self.ctype = 'pb_bytes_ptr_t'
elif desc.type == FieldD.TYPE_MESSAGE:
- self.ltype = 'PB_LTYPE_SUBMESSAGE'
+ self.pbtype = 'MESSAGE'
self.ctype = self.submsgname = names_from_type_name(desc.type_name)
+ self.enc_size = None # Needs to be filled in after the message type is available
else:
raise NotImplementedError(desc.type)
- if field_options.type == nanopb_pb2.FT_DEFAULT:
- if can_be_static:
- field_options.type = nanopb_pb2.FT_STATIC
- else:
- field_options.type = nanopb_pb2.FT_CALLBACK
-
- if field_options.type == nanopb_pb2.FT_STATIC and not can_be_static:
- raise Exception("Field %s is defined as static, but max_size or max_count is not given." % self.name)
-
- if field_options.type == nanopb_pb2.FT_CALLBACK:
- self.htype = 'PB_HTYPE_CALLBACK'
- self.ctype = 'pb_callback_t'
- self.array_decl = ''
-
def __cmp__(self, other):
return cmp(self.tag, other.tag)
def __str__(self):
- if self.htype == 'PB_HTYPE_OPTIONAL':
- result = ' bool has_' + self.name + ';\n'
- elif self.htype == 'PB_HTYPE_ARRAY':
- result = ' size_t ' + self.name + '_count;\n'
+ result = ''
+ if self.allocation == 'POINTER':
+ if self.rules == 'REPEATED':
+ result += ' size_t ' + self.name + '_count;\n'
+
+ if self.pbtype == 'MESSAGE':
+ # Use struct definition, so recursive submessages are possible
+ result += ' struct _%s *%s;' % (self.ctype, self.name)
+ elif self.rules == 'REPEATED' and self.pbtype == 'STRING':
+ # String arrays need to be defined as pointers to pointers
+ result += ' %s **%s;' % (self.ctype, self.name)
+ else:
+ result += ' %s *%s;' % (self.ctype, self.name)
+ elif self.allocation == 'CALLBACK':
+ result += ' pb_callback_t %s;' % self.name
else:
- result = ''
- result += ' %s %s%s;' % (self.ctype, self.name, self.array_decl)
+ if self.rules == 'OPTIONAL' and self.allocation == 'STATIC':
+ result += ' bool has_' + self.name + ';\n'
+ elif self.rules == 'REPEATED' and self.allocation == 'STATIC':
+ result += ' size_t ' + self.name + '_count;\n'
+ result += ' %s %s%s;' % (self.ctype, self.name, self.array_decl)
return result
def types(self):
'''Return definitions for any special types this field might need.'''
- if self.ltype == 'PB_LTYPE_BYTES' and self.max_size is not None:
+ if self.pbtype == 'BYTES' and self.allocation == 'STATIC':
result = 'typedef struct {\n'
result += ' size_t size;\n'
result += ' uint8_t bytes[%d];\n' % self.max_size
'''Return definition for this field's default value.'''
if self.default is None:
return None
+
+ ctype, default = self.ctype, self.default
+ array_decl = ''
- if self.ltype == 'PB_LTYPE_STRING':
- ctype = 'char'
- if self.max_size is None:
+ if self.pbtype == 'STRING':
+ if self.allocation != 'STATIC':
return None # Not implemented
- else:
- array_decl = '[%d]' % (self.max_size + 1)
+
+ array_decl = '[%d]' % self.max_size
default = str(self.default).encode('string_escape')
default = default.replace('"', '\\"')
default = '"' + default + '"'
- elif self.ltype == 'PB_LTYPE_BYTES':
+ elif self.pbtype == 'BYTES':
+ if self.allocation != 'STATIC':
+ return None # Not implemented
+
data = self.default.decode('string_escape')
data = ['0x%02x' % ord(c) for c in data]
-
- if self.max_size is None:
- return None # Not implemented
- else:
- ctype = self.ctype
-
default = '{%d, {%s}}' % (len(data), ','.join(data))
- array_decl = ''
- else:
- ctype, default = self.ctype, self.default
- array_decl = ''
if declaration_only:
return 'extern const %s %s_default%s;' % (ctype, self.struct_name + self.name, array_decl)
else:
return 'const %s %s_default%s = %s;' % (ctype, self.struct_name + self.name, array_decl, default)
+ def tags(self):
+ '''Return the #define for the tag number of this field.'''
+ identifier = '%s_%s_tag' % (self.struct_name, self.name)
+ return '#define %-40s %d\n' % (identifier, self.tag)
+
def pb_field_t(self, prev_field_name):
'''Return the pb_field_t initializer to use in the constant array.
prev_field_name is the name of the previous field or None.
'''
- result = ' {%d, ' % self.tag
- result += '(pb_type_t) ((int) ' + self.htype
- if self.ltype is not None:
- result += ' | (int) ' + self.ltype
- result += '),\n'
-
- if prev_field_name is None:
- result += ' offsetof(%s, %s),' % (self.struct_name, self.name)
- else:
- result += ' pb_delta_end(%s, %s, %s),' % (self.struct_name, self.name, prev_field_name)
-
- if self.htype == 'PB_HTYPE_OPTIONAL':
- result += '\n pb_delta(%s, has_%s, %s),' % (self.struct_name, self.name, self.name)
- elif self.htype == 'PB_HTYPE_ARRAY':
- result += '\n pb_delta(%s, %s_count, %s),' % (self.struct_name, self.name, self.name)
- else:
- result += ' 0,'
-
+ result = ' PB_FIELD2(%3d, ' % self.tag
+ result += '%-8s, ' % self.pbtype
+ result += '%s, ' % self.rules
+ result += '%-8s, ' % self.allocation
+ result += '%s, ' % ("FIRST" if not prev_field_name else "OTHER")
+ result += '%s, ' % self.struct_name
+ result += '%s, ' % self.name
+ result += '%s, ' % (prev_field_name or self.name)
- if self.htype == 'PB_HTYPE_ARRAY':
- result += '\n pb_membersize(%s, %s[0]),' % (self.struct_name, self.name)
- result += ('\n pb_membersize(%s, %s) / pb_membersize(%s, %s[0]),'
- % (self.struct_name, self.name, self.struct_name, self.name))
+ if self.pbtype == 'MESSAGE':
+ result += '&%s_fields)' % self.submsgname
+ elif self.default is None:
+ result += '0)'
+ elif self.pbtype in ['BYTES', 'STRING'] and self.allocation != 'STATIC':
+ result += '0)' # Arbitrary size default values not implemented
else:
- result += '\n pb_membersize(%s, %s),' % (self.struct_name, self.name)
- result += ' 0,'
-
- if self.ltype == 'PB_LTYPE_SUBMESSAGE':
- result += '\n &%s_fields}' % self.submsgname
- elif self.default is None or self.htype == 'PB_HTYPE_CALLBACK':
- result += ' 0}'
- else:
- result += '\n &%s_default}' % (self.struct_name + self.name)
+ result += '&%s_default)' % (self.struct_name + self.name)
return result
def largest_field_value(self):
'''Determine if this field needs 16bit or 32bit pb_field_t structure to compile properly.
Returns numeric value or a C-expression for assert.'''
- if self.ltype == 'PB_LTYPE_SUBMESSAGE':
- if self.htype == 'PB_HTYPE_ARRAY':
+ if self.pbtype == 'MESSAGE':
+ if self.rules == 'REPEATED' and self.allocation == 'STATIC':
return 'pb_membersize(%s, %s[0])' % (self.struct_name, self.name)
else:
return 'pb_membersize(%s, %s)' % (self.struct_name, self.name)
return max(self.tag, self.max_size, self.max_count)
+ def encoded_size(self, allmsgs):
+ '''Return the maximum size that this field can take when encoded,
+ including the field tag. If the size cannot be determined, returns
+ None.'''
+
+ if self.allocation != 'STATIC':
+ return None
+
+ 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
+
+ # 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.
+ # 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
+ if self.rules == 'REPEATED':
+ # Decoders must be always able to handle unpacked arrays.
+ # Therefore we have to reserve space for it, even though
+ # we emit packed arrays ourselves.
+ encsize *= self.max_count
+
+ return encsize
+class ExtensionRange(Field):
+ def __init__(self, struct_name, range_start, field_options):
+ '''Implements a special pb_extension_t* field in an extensible message
+ structure. The range_start signifies the index at which the extensions
+ start. Not necessarily all tags above this are extensions, it is merely
+ a speed optimization.
+ '''
+ self.tag = range_start
+ self.struct_name = struct_name
+ self.name = 'extensions'
+ self.pbtype = 'EXTENSION'
+ self.rules = 'OPTIONAL'
+ self.allocation = 'CALLBACK'
+ self.ctype = 'pb_extension_t'
+ self.array_decl = ''
+ self.default = None
+ self.max_size = 0
+ self.max_count = 0
+
+ def __str__(self):
+ return ' pb_extension_t *extensions;'
+
+ def types(self):
+ return None
+
+ def tags(self):
+ return ''
+
+ def encoded_size(self, allmsgs):
+ # 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 EncodedSize(0)
+
+class ExtensionField(Field):
+ def __init__(self, struct_name, desc, field_options):
+ self.fullname = struct_name + desc.name
+ self.extendee_name = names_from_type_name(desc.extendee)
+ Field.__init__(self, self.fullname + 'struct', desc, field_options)
+
+ if self.rules != 'OPTIONAL':
+ self.skip = True
+ else:
+ 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:
+ msg = '/* Extension field %s was skipped because only "optional"\n' % self.fullname
+ msg +=' type of extension fields is currently supported. */\n'
+ return msg
+
+ return 'extern const pb_extension_type_t %s;\n' % self.fullname
+
+ def extension_def(self):
+ '''Definition of the extension type in the .pb.c file'''
+
+ if self.skip:
+ return ''
+
+ result = 'typedef struct {\n'
+ result += str(self)
+ result += '\n} %s;\n\n' % self.struct_name
+ result += ('static const pb_field_t %s_field = \n %s;\n\n' %
+ (self.fullname, self.pb_field_t(None)))
+ result += 'const pb_extension_type_t %s = {\n' % self.fullname
+ result += ' NULL,\n'
+ result += ' NULL,\n'
+ result += ' &%s_field\n' % self.fullname
+ result += '};\n'
+ return result
# ---------------------------------------------------------------------------
class Message:
def __init__(self, names, desc, message_options):
self.name = names
- self.fields = [Field(self.name, f, get_nanopb_suboptions(f, message_options)) for f in desc.field]
+ self.fields = []
+
+ for f in desc.field:
+ field_options = get_nanopb_suboptions(f, message_options, self.name + f.name)
+ if field_options.type != nanopb_pb2.FT_IGNORE:
+ self.fields.append(Field(self.name, f, field_options))
+
+ if len(desc.extension_range) > 0:
+ field_options = get_nanopb_suboptions(desc, message_options, self.name + 'extensions')
+ range_start = min([r.start for r in desc.extension_range])
+ if field_options.type != nanopb_pb2.FT_IGNORE:
+ self.fields.append(ExtensionRange(self.name, range_start, field_options))
+
self.packed = message_options.packed_struct
self.ordered_fields = self.fields[:]
self.ordered_fields.sort()
def __str__(self):
result = 'typedef struct _%s {\n' % self.name
+
+ if not self.ordered_fields:
+ # Empty structs are not allowed in C standard.
+ # Therefore add a dummy field if an empty message occurs.
+ result += ' uint8_t dummy_field;'
+
result += '\n'.join([str(f) for f in self.ordered_fields])
result += '\n}'
result += ' pb_packed'
result += ' %s;' % self.name
+
+ if self.packed:
+ result = 'PB_PACKED_STRUCT_START\n' + result
+ result += '\nPB_PACKED_STRUCT_END'
+
return result
def types(self):
prev = None
for field in self.ordered_fields:
result += field.pb_field_t(prev)
- result += ',\n\n'
+ result += ',\n'
prev = field.name
result += ' PB_LAST_FIELD\n};'
return result
-
-
-
+ def encoded_size(self, allmsgs):
+ '''Return the maximum size that this message can take when encoded.
+ If the size cannot be determined, returns None.
+ '''
+ size = EncodedSize(0)
+ for field in self.fields:
+ fsize = field.encoded_size(allmsgs)
+ if fsize is None:
+ return None
+ size += fsize
+
+ return size
# ---------------------------------------------------------------------------
for x in iterate_messages(submsg, sub_names):
yield x
+def iterate_extensions(desc, names = Names()):
+ '''Recursively find all extensions.
+ For each, yield name, FieldDescriptorProto.
+ '''
+ for extension in desc.extension:
+ yield names, extension
+
+ for subname, subdesc in iterate_messages(desc, names):
+ for extension in subdesc.extension:
+ yield subname, extension
+
def parse_file(fdesc, file_options):
- '''Takes a FileDescriptorProto and returns tuple (enum, messages).'''
+ '''Takes a FileDescriptorProto and returns tuple (enums, messages, extensions).'''
enums = []
messages = []
+ extensions = []
if fdesc.package:
base_name = Names(fdesc.package.split('.'))
base_name = Names()
for enum in fdesc.enum_type:
- enum_options = get_nanopb_suboptions(enum, file_options)
+ enum_options = get_nanopb_suboptions(enum, file_options, base_name + enum.name)
enums.append(Enum(base_name, enum, enum_options))
for names, message in iterate_messages(fdesc, base_name):
- message_options = get_nanopb_suboptions(message, file_options)
+ message_options = get_nanopb_suboptions(message, file_options, names)
messages.append(Message(names, message, message_options))
for enum in message.enum_type:
- enum_options = get_nanopb_suboptions(enum, message_options)
+ enum_options = get_nanopb_suboptions(enum, message_options, names + enum.name)
enums.append(Enum(names, enum, enum_options))
+ for names, extension in iterate_extensions(fdesc, base_name):
+ field_options = get_nanopb_suboptions(extension, file_options, names)
+ if field_options.type != nanopb_pb2.FT_IGNORE:
+ extensions.append(ExtensionField(names, extension, field_options))
+
# Fix field default values where enum short names are used.
for enum in enums:
if not enum.options.long_names:
idx = enum.value_longnames.index(field.default)
field.default = enum.values[idx][0]
- return enums, messages
+ return enums, messages, extensions
def toposort2(data):
'''Topological sort.
if msgname in message_by_name:
yield message_by_name[msgname]
-def generate_header(dependencies, headername, enums, messages):
+def make_identifier(headername):
+ '''Make #ifndef identifier that contains uppercase A-Z and digits 0-9'''
+ result = ""
+ for c in headername.upper():
+ if c.isalnum():
+ result += c
+ else:
+ result += '_'
+ return result
+
+def generate_header(dependencies, headername, enums, messages, extensions, options):
'''Generate content for a header file.
Generates strings, which should be concatenated and stored to file.
'''
yield '/* Automatically generated nanopb header */\n'
yield '/* Generated by %s at %s. */\n\n' % (nanopb_version, time.asctime())
- symbol = headername.replace('.', '_').upper()
+ symbol = make_identifier(headername)
yield '#ifndef _PB_%s_\n' % symbol
yield '#define _PB_%s_\n' % symbol
- yield '#include <pb.h>\n\n'
+ try:
+ yield options.libformat % ('pb.h')
+ except TypeError:
+ # no %s specified - use whatever was passed in as options.libformat
+ yield options.libformat
+ yield '\n'
for dependency in dependencies:
noext = os.path.splitext(dependency)[0]
- yield '#include "%s.pb.h"\n' % noext
-
+ yield options.genformat % (noext + '.' + options.extension + '.h')
+ yield '\n'
+
yield '#ifdef __cplusplus\n'
yield 'extern "C" {\n'
yield '#endif\n\n'
for msg in sort_dependencies(messages):
yield msg.types()
yield str(msg) + '\n\n'
+
+ if extensions:
+ yield '/* Extensions */\n'
+ for extension in extensions:
+ yield extension.extension_decl()
+ yield '\n'
yield '/* Default values for struct fields */\n'
for msg in messages:
yield msg.default_decl(True)
yield '\n'
+ yield '/* Field tags (for use in manual encoding/decoding) */\n'
+ 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'
for msg in messages:
yield msg.fields_declaration() + '\n'
+ yield '\n'
+
+ yield '/* Maximum encoded size of messages (where known) */\n'
+ for msg in messages:
+ msize = msg.encoded_size(messages)
+ if msize is not None:
+ identifier = '%s_size' % msg.name
+ yield '#define %-40s %s\n' % (identifier, msize)
+ yield '\n'
+
+ yield '#ifdef __cplusplus\n'
+ yield '} /* extern "C" */\n'
+ yield '#endif\n'
+
+ # End of header
+ yield '\n#endif\n'
+
+def generate_source(headername, enums, messages, extensions, options):
+ '''Generate content for a source file.'''
+
+ yield '/* Automatically generated nanopb constant definitions */\n'
+ yield '/* Generated by %s at %s. */\n\n' % (nanopb_version, time.asctime())
+ yield options.genformat % (headername)
+ yield '\n'
+
+ for msg in messages:
+ yield msg.default_decl(False)
+
+ yield '\n\n'
+
+ for msg in messages:
+ yield msg.fields_definition() + '\n\n'
+ for ext in extensions:
+ yield ext.extension_def() + '\n'
+
+ # Add checks for numeric limits
if messages:
- count_required_fields = lambda m: len([f for f in msg.fields if f.htype == 'PB_HTYPE_REQUIRED'])
+ count_required_fields = lambda m: len([f for f in msg.fields if f.rules == 'REQUIRED'])
largest_msg = max(messages, key = count_required_fields)
largest_count = count_required_fields(largest_msg)
if largest_count > 64:
yield 'STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
yield '#endif\n'
- yield '\n#ifdef __cplusplus\n'
- yield '} /* extern "C" */\n'
- yield '#endif\n'
+ # Add check for sizeof(double)
+ has_double = False
+ for msg in messages:
+ for field in msg.fields:
+ if field.ctype == 'double':
+ has_double = True
- # End of header
- yield '\n#endif\n'
+ if has_double:
+ yield '\n'
+ yield '/* On some platforms (such as AVR), double is really float.\n'
+ yield ' * These are not directly supported by nanopb, but see example_avr_double.\n'
+ yield ' * To get rid of this error, remove any double fields from your .proto.\n'
+ yield ' */\n'
+ yield 'STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)\n'
+
+ yield '\n'
-def generate_source(headername, enums, messages):
- '''Generate content for a source file.'''
+# ---------------------------------------------------------------------------
+# Options parsing for the .proto files
+# ---------------------------------------------------------------------------
+
+from fnmatch import fnmatch
+
+def read_options_file(infile):
+ '''Parse a separate options file to list:
+ [(namemask, options), ...]
+ '''
+ results = []
+ for line in infile:
+ line = line.strip()
+ if not line or line.startswith('//') or line.startswith('#'):
+ continue
+
+ parts = line.split(None, 1)
+ opts = nanopb_pb2.NanoPBOptions()
+ text_format.Merge(parts[1], opts)
+ results.append((parts[0], opts))
+
+ return results
+
+class Globals:
+ '''Ugly global variables, should find a good way to pass these.'''
+ verbose_options = False
+ separate_options = []
+
+def get_nanopb_suboptions(subdesc, options, name):
+ '''Get copy of options, and merge information from subdesc.'''
+ new_options = nanopb_pb2.NanoPBOptions()
+ new_options.CopyFrom(options)
- yield '/* Automatically generated nanopb constant definitions */\n'
- yield '/* Generated by %s at %s. */\n\n' % (nanopb_version, time.asctime())
- yield '#include "%s"\n\n' % headername
+ # Handle options defined in a separate file
+ dotname = '.'.join(name.parts)
+ for namemask, options in Globals.separate_options:
+ if fnmatch(dotname, namemask):
+ new_options.MergeFrom(options)
- for msg in messages:
- yield msg.default_decl(False)
+ # Handle options defined in .proto
+ if isinstance(subdesc.options, descriptor.FieldOptions):
+ ext_type = nanopb_pb2.nanopb
+ elif isinstance(subdesc.options, descriptor.FileOptions):
+ ext_type = nanopb_pb2.nanopb_fileopt
+ elif isinstance(subdesc.options, descriptor.MessageOptions):
+ ext_type = nanopb_pb2.nanopb_msgopt
+ elif isinstance(subdesc.options, descriptor.EnumOptions):
+ ext_type = nanopb_pb2.nanopb_enumopt
+ else:
+ raise Exception("Unknown options type")
- yield '\n\n'
+ if subdesc.options.HasExtension(ext_type):
+ ext = subdesc.options.Extensions[ext_type]
+ new_options.MergeFrom(ext)
- for msg in messages:
- yield msg.fields_definition() + '\n\n'
-
+ if Globals.verbose_options:
+ print "Options for " + dotname + ":"
+ print text_format.MessageToString(new_options)
+
+ return new_options
# ---------------------------------------------------------------------------
import sys
import os.path
from optparse import OptionParser
-import google.protobuf.text_format as text_format
optparser = OptionParser(
usage = "Usage: nanopb_generator.py [options] file.pb ...",
"Output will be written to file.pb.h and file.pb.c.")
optparser.add_option("-x", dest="exclude", metavar="FILE", action="append", default=[],
help="Exclude file from generated #include list.")
+optparser.add_option("-e", "--extension", dest="extension", metavar="EXTENSION", default="pb",
+ help="Set extension to use instead of 'pb' for generated files. [default: %default]")
+optparser.add_option("-f", "--options-file", dest="options_file", metavar="FILE", default="%s.options",
+ help="Set name of a separate generator options file.")
+optparser.add_option("-Q", "--generated-include-format", dest="genformat",
+ metavar="FORMAT", default='#include "%s"\n',
+ help="Set format string to use for including other .pb.h files. [default: %default]")
+optparser.add_option("-L", "--library-include-format", dest="libformat",
+ metavar="FORMAT", default='#include <%s>\n',
+ help="Set format string to use for including the nanopb pb.h header. [default: %default]")
optparser.add_option("-q", "--quiet", dest="quiet", action="store_true", default=False,
help="Don't print anything except errors.")
optparser.add_option("-v", "--verbose", dest="verbose", action="store_true", default=False,
optparser.add_option("-s", dest="settings", metavar="OPTION:VALUE", action="append", default=[],
help="Set generator option (max_size, max_count etc.).")
-def get_nanopb_suboptions(subdesc, options):
- '''Get copy of options, and merge information from subdesc.'''
- new_options = nanopb_pb2.NanoPBOptions()
- new_options.CopyFrom(options)
+def process_file(filename, fdesc, options):
+ '''Process a single file.
+ filename: The full path to the .proto or .pb source file, as string.
+ fdesc: The loaded FileDescriptorSet, or None to read from the input file.
+ options: Command line options as they come from OptionsParser.
- if isinstance(subdesc.options, descriptor.FieldOptions):
- ext_type = nanopb_pb2.nanopb
- elif isinstance(subdesc.options, descriptor.FileOptions):
- ext_type = nanopb_pb2.nanopb_fileopt
- elif isinstance(subdesc.options, descriptor.MessageOptions):
- ext_type = nanopb_pb2.nanopb_msgopt
- elif isinstance(subdesc.options, descriptor.EnumOptions):
- ext_type = nanopb_pb2.nanopb_enumopt
+ Returns a dict:
+ {'headername': Name of header file,
+ 'headerdata': Data for the .h header file,
+ 'sourcename': Name of the source code file,
+ 'sourcedata': Data for the .c source code file
+ }
+ '''
+ toplevel_options = nanopb_pb2.NanoPBOptions()
+ for s in options.settings:
+ text_format.Merge(s, toplevel_options)
+
+ if not fdesc:
+ data = open(filename, 'rb').read()
+ fdesc = descriptor.FileDescriptorSet.FromString(data).file[0]
+
+ # Check if there is a separate .options file
+ try:
+ optfilename = options.options_file % os.path.splitext(filename)[0]
+ except TypeError:
+ # No %s specified, use the filename as-is
+ optfilename = options.options_file
+
+ if options.verbose:
+ print 'Reading options from ' + optfilename
+
+ if os.path.isfile(optfilename):
+ Globals.separate_options = read_options_file(open(optfilename, "rU"))
else:
- raise Exception("Unknown options type")
+ Globals.separate_options = []
- if subdesc.options.HasExtension(ext_type):
- ext = subdesc.options.Extensions[ext_type]
- new_options.MergeFrom(ext)
+ # Parse the file
+ file_options = get_nanopb_suboptions(fdesc, toplevel_options, Names([filename]))
+ enums, messages, extensions = parse_file(fdesc, file_options)
- return new_options
+ # Decide the file names
+ noext = os.path.splitext(filename)[0]
+ headername = noext + '.' + options.extension + '.h'
+ sourcename = noext + '.' + options.extension + '.c'
+ headerbasename = os.path.basename(headername)
+
+ # List of .proto files that should not be included in the C header file
+ # even if they are mentioned in the source .proto.
+ excludes = ['nanopb.proto', 'google/protobuf/descriptor.proto'] + options.exclude
+ dependencies = [d for d in fdesc.dependency if d not in excludes]
+
+ headerdata = ''.join(generate_header(dependencies, headerbasename, enums,
+ messages, extensions, options))
-def process(filenames, options):
- '''Process the files given on the command line.'''
+ sourcedata = ''.join(generate_source(headerbasename, enums,
+ messages, extensions, options))
+
+ return {'headername': headername, 'headerdata': headerdata,
+ 'sourcename': sourcename, 'sourcedata': sourcedata}
+
+def main_cli():
+ '''Main function when invoked directly from the command line.'''
+
+ options, filenames = optparser.parse_args()
if not filenames:
optparser.print_help()
- return False
+ sys.exit(1)
if options.quiet:
options.verbose = False
-
- toplevel_options = nanopb_pb2.NanoPBOptions()
- for s in options.settings:
- text_format.Merge(s, toplevel_options)
+
+ Globals.verbose_options = options.verbose
for filename in filenames:
- data = open(filename, 'rb').read()
- fdesc = descriptor.FileDescriptorSet.FromString(data)
-
- file_options = get_nanopb_suboptions(fdesc.file[0], toplevel_options)
-
- if options.verbose:
- print "Options for " + filename + ":"
- print text_format.MessageToString(file_options)
-
- enums, messages = parse_file(fdesc.file[0], file_options)
-
- noext = os.path.splitext(filename)[0]
- headername = noext + '.pb.h'
- sourcename = noext + '.pb.c'
- headerbasename = os.path.basename(headername)
+ results = process_file(filename, None, options)
if not options.quiet:
- print "Writing to " + headername + " and " + sourcename
-
- # List of .proto files that should not be included in the C header file
- # even if they are mentioned in the source .proto.
- excludes = ['nanopb.proto', 'google/protobuf/descriptor.proto'] + options.exclude
- dependencies = [d for d in fdesc.file[0].dependency if d not in excludes]
-
- header = open(headername, 'w')
- for part in generate_header(dependencies, headerbasename, enums, messages):
- header.write(part)
-
- source = open(sourcename, 'w')
- for part in generate_source(headerbasename, enums, messages):
- source.write(part)
+ print "Writing to " + results['headername'] + " and " + results['sourcename']
+
+ open(results['headername'], 'w').write(results['headerdata'])
+ open(results['sourcename'], 'w').write(results['sourcedata'])
- return True
+def main_plugin():
+ '''Main function when invoked as a protoc plugin.'''
-if __name__ == '__main__':
- options, filenames = optparser.parse_args()
- status = process(filenames, options)
+ import sys
+ if sys.platform == "win32":
+ import os, msvcrt
+ # Set stdin and stdout to binary mode
+ msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
+ msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
- if not status:
- sys.exit(1)
+ import proto.plugin_pb2 as plugin_pb2
+ data = sys.stdin.read()
+ request = plugin_pb2.CodeGeneratorRequest.FromString(data)
+
+ import shlex
+ args = shlex.split(request.parameter)
+ options, dummy = optparser.parse_args(args)
+
+ # We can't go printing stuff to stdout
+ Globals.verbose_options = False
+ options.verbose = False
+ options.quiet = True
+ response = plugin_pb2.CodeGeneratorResponse()
+
+ for filename in request.file_to_generate:
+ for fdesc in request.proto_file:
+ if fdesc.name == filename:
+ results = process_file(filename, fdesc, options)
+
+ f = response.file.add()
+ f.name = results['headername']
+ f.content = results['headerdata']
+
+ f = response.file.add()
+ f.name = results['sourcename']
+ f.content = results['sourcedata']
+
+ sys.stdout.write(response.SerializeToString())
+
+if __name__ == '__main__':
+ # Check if we are running as a plugin under protoc
+ if 'protoc-gen-' in sys.argv[0] or '--protoc-plugin' in sys.argv:
+ main_plugin()
+ else:
+ main_cli()
+