Perform field initialization to defaults only when the field is skipped.

Avoids unnecessary initialization & unnecessary scan of
the pb_field_t array.

Runtime on Cortex-M3 -5%, code size +2%.

Could need some more testing with random field orders.
Have to write a tool to randomize fields in a message.

CHANGELOG

@@ -1,20 +1,3 @@
-nanopb-0.2.1
- NOTE: The default callback function signature has changed.
-       If you don't want to update your code, define PB_OLD_CALLBACK_STYLE.
- 
- Change the callback function to use void** (issue 69)
- Add support for defining the nanopb options in a separate file (issue 12)
- Add support for packed structs in IAR and MSVC (in addition to GCC) (issue 66)
- Implement error message support for the encoder side (issue 7)
- Handle unterminated strings when encoding (issue 68)
- Fix bug with empty strings in repeated string callbacks (issue 73)
- Fix regression in 0.2.0 with optional callback fields (issue 70)
- Fix bugs with empty message types (issues 64, 65)
- Fix some compiler warnings on clang (issue 67)
- Some portability improvements (issues 60, 62)
- Various new generator options
- Improved tests
-
 nanopb-0.2.0
  NOTE: This release requires you to regenerate all .pb.c
        files. Files generated by older versions will not

docs/concepts.rst

@@ -10,40 +10,47 @@ The things outlined here are the underlying concepts of the nanopb design.
 
 Proto files
 ===========
-All Protocol Buffers implementations use .proto files to describe the message
-format. The point of these files is to be a portable interface description
-language.
+All Protocol Buffers implementations use .proto files to describe the message format.
+The point of these files is to be a portable interface description language.
 
 Compiling .proto files for nanopb
 ---------------------------------
-Nanopb uses the Google's protoc compiler to parse the .proto file, and then a
-python script to generate the C header and source code from it::
+Nanopb uses the Google's protoc compiler to parse the .proto file, and then a python script to generate the C header and source code from it::
 
     user@host:~$ protoc -omessage.pb message.proto
     user@host:~$ python ../generator/nanopb_generator.py message.pb
     Writing to message.h and message.c
     user@host:~$
 
-Modifying generator behaviour
------------------------------
-Using generator options, you can set maximum sizes for fields in order to
-allocate them statically. The preferred way to do this is to create an .options
-file with the same name as your .proto file::
+Compiling .proto files with nanopb options
+------------------------------------------
+Nanopb defines two extensions for message fields described in .proto files: *max_size* and *max_count*.
+These are the maximum size of a string and maximum count of items in an array::
 
-   # Foo.proto
-   message Foo {
-      required string name = 1;
+    required string name = 1 [(nanopb).max_size = 40];
+    repeated PhoneNumber phone = 4 [(nanopb).max_count = 5];
+
+To use these extensions, you need to place an import statement in the beginning of the file::
+
+    import "nanopb.proto";
+
+This file, in turn, requires the file *google/protobuf/descriptor.proto*. This is usually installed under */usr/include*. Therefore, to compile a .proto file which uses options, use a protoc command similar to::
+
+    protoc -I/usr/include -Inanopb/generator -I. -omessage.pb message.proto
+
+The options can be defined in file, message and field scopes::
+
+    option (nanopb_fileopt).max_size = 20; // File scope
+    message Message
+    {
+        option (nanopb_msgopt).max_size = 30; // Message scope
+        required string fieldsize = 1 [(nanopb).max_size = 40]; // Field scope
     }
 
-::
+It is also possible to give the options on command line, but then they will affect the whole file. For example::
 
-   # Foo.options
-   Foo.name max_size:16
+    user@host:~$ python ../generator/nanopb_generator.py -s 'max_size: 20' message.pb
 
-For more information on this, see the `Proto file options`_ section in the
-reference manual.
-
-.. _`Proto file options`: reference.html#proto-file-options
 
 Streams
 =======

docs/reference.rst

@@ -6,182 +6,31 @@ Nanopb: API reference
 
 .. contents ::
 
-
-
-
 Compilation options
 ===================
-The following options can be specified in one of two ways:
+The following options can be specified using -D switch given to the C compiler:
 
-1. Using the -D switch on the C compiler command line.
-2. By #defining them at the top of pb.h.
-
-You must have the same settings for the nanopb library and all code that
-includes pb.h.
-
-============================  ================================================
-__BIG_ENDIAN__                 Set this if your platform stores integers and
-                               floats in big-endian format. Mixed-endian
-                               systems (different layout for ints and floats)
-                               are currently not supported.
-NANOPB_INTERNALS               Set this to expose the field encoder functions
-                               that are hidden since nanopb-0.1.3.
-PB_MAX_REQUIRED_FIELDS         Maximum number of required fields to check for
-                               presence. Default value is 64. Increases stack
-                               usage 1 byte per every 8 fields. Compiler
-                               warning will tell if you need this.
-PB_FIELD_16BIT                 Add support for tag numbers > 255 and fields
-                               larger than 255 bytes or 255 array entries.
-                               Increases code size 3 bytes per each field.
-                               Compiler error will tell if you need this.
-PB_FIELD_32BIT                 Add support for tag numbers > 65535 and fields
-                               larger than 65535 bytes or 65535 array entries.
-                               Increases code size 9 bytes per each field.
-                               Compiler error will tell if you need this.
-PB_NO_ERRMSG                   Disables the support for error messages; only
-                               error information is the true/false return
-                               value. Decreases the code size by a few hundred
-                               bytes.
-PB_BUFFER_ONLY                 Disables the support for custom streams. Only
-                               supports encoding and decoding with memory
-                               buffers. Speeds up execution and decreases code
-                               size slightly.
-PB_OLD_CALLBACK_STYLE          Use the old function signature (void\* instead
-                               of void\*\*) for callback fields. This was the
+============================  ================================================================================================
+__BIG_ENDIAN__                 Set this if your platform stores integers and floats in big-endian format.
+                               Mixed-endian systems (different layout for ints and floats) are currently not supported.
+NANOPB_INTERNALS               Set this to expose the field encoder functions that are hidden since nanopb-0.1.3.
+PB_MAX_REQUIRED_FIELDS         Maximum number of required fields to check for presence. Default value is 64. Increases stack
+                               usage 1 byte per every 8 fields. Compiler warning will tell if you need this.
+PB_FIELD_16BIT                 Add support for tag numbers > 255 and fields larger than 255 bytes or 255 array entries.
+                               Increases code size 3 bytes per each field. Compiler error will tell if you need this.
+PB_FIELD_32BIT                 Add support for tag numbers > 65535 and fields larger than 65535 bytes or 65535 array entries.
+                               Increases code size 9 bytes per each field. Compiler error will tell if you need this.
+PB_NO_ERRMSG                   Disables the support for error messages; only error information is the true/false return value.
+                               Decreases the code size by a few hundred bytes.
+PB_BUFFER_ONLY                 Disables the support for custom streams. Only supports encoding to memory buffers.
+                               Speeds up execution and decreases code size slightly.
+PB_OLD_CALLBACK_STYLE          Use the old function signature (void\* instead of void\*\*) for callback fields. This was the
                                default until nanopb-0.2.1.
-============================  ================================================
-
-The PB_MAX_REQUIRED_FIELDS, PB_FIELD_16BIT and PB_FIELD_32BIT settings allow
-raising some datatype limits to suit larger messages. Their need is recognized
-automatically by C-preprocessor #if-directives in the generated .pb.h files.
-The default setting is to use the smallest datatypes (least resources used).
-
-
-
-
-Proto file options
-==================
-The generator behaviour can be adjusted using these options, defined in the
-'nanopb.proto' file in the generator folder:
-
-============================  ================================================
-max_size                       Allocated size for *bytes* and *string* fields.
-max_count                      Allocated number of entries in arrays
-                               (*repeated* fields).
-type                           Type of the generated field. Default value
-                               is *FT_DEFAULT*, which selects automatically.
-                               You can use *FT_CALLBACK*, *FT_STATIC* or
-                               *FT_IGNORE* to force a callback field, a static
-                               field or to completely ignore the field.
-long_names                     Prefix the enum name to the enum value in
-                               definitions, i.e. *EnumName_EnumValue*. Enabled
-                               by default.
-packed_struct                  Make the generated structures packed.
-                               NOTE: This cannot be used on CPUs that break
-                               on unaligned accesses to variables.
-============================  ================================================
-
-These options can be defined for the .proto files before they are converted
-using the nanopb-generatory.py. There are three ways to define the options:
-
-1. Using a separate .options file.
-   This is the preferred way as of nanopb-0.2.1, because it has the best
-   compatibility with other protobuf libraries.
-2. Defining the options on the command line of nanopb_generator.py.
-   This only makes sense for settings that apply to a whole file.
-3. Defining the options in the .proto file using the nanopb extensions.
-   This is the way used in nanopb-0.1, and will remain supported in the
-   future. It however sometimes causes trouble when using the .proto file
-   with other protobuf libraries.
-
-The effect of the options is the same no matter how they are given. The most
-common purpose is to define maximum size for string fields in order to
-statically allocate them.
-
-Defining the options in a .options file
----------------------------------------
-The preferred way to define options is to have a separate file
-'myproto.options' in the same directory as the 'myproto.proto'. ::
-
-    # myproto.proto
-    message MyMessage {
-        required string name = 1;
-        repeated int32 ids = 4;
-    }
-
-::
-
-    # myproto.options
-    MyMessage.name         max_size:40
-    MyMessage.ids          max_count:5
-
-The generator will automatically search for this file and read the
-options from it. The file format is as follows:
-
-* Lines starting with '#' or '//' are regarded as comments.
-* Blank lines are ignored.
-* All other lines should start with a field name pattern, followed by one or
-  more options. For example: *"MyMessage.myfield max_size:5 max_count:10"*.
-* The field name pattern is matched against a string of form *'Message.field'*.
-  For nested messages, the string is *'Message.SubMessage.field'*.
-* The field name pattern may use the notation recognized by Python fnmatch():
-
-  - *\** matches any part of string, like 'Message.\*' for all fields
-  - *\?* matches any single character
-  - *[seq]* matches any of characters 's', 'e' and 'q'
-  - *[!seq]* matches any other character
-
-* The options are written as *'option_name:option_value'* and several options
-  can be defined on same line, separated by whitespace.
-* Options defined later in the file override the ones specified earlier, so
-  it makes sense to define wildcard options first in the file and more specific
-  ones later.
-  
-If preferred, the name of the options file can be set using the command line
-switch *-f* to nanopb_generator.py.
-
-Defining the options on command line
-------------------------------------
-The nanopb_generator.py has a simple command line option *-s OPTION:VALUE*.
-The setting applies to the whole file that is being processed.
-
-Defining the options in the .proto file
----------------------------------------
-The .proto file format allows defining custom options for the fields.
-The nanopb library comes with *nanopb.proto* which does exactly that, allowing
-you do define the options directly in the .proto file::
-
-    import "nanopb.proto";
-    
-    message MyMessage {
-        required string name = 1 [(nanopb).max_size = 40];
-        repeated int32 ids = 4   [(nanopb).max_count = 5];
-    }
-
-A small complication is that you have to set the include path of protoc so that
-nanopb.proto can be found. This file, in turn, requires the file
-*google/protobuf/descriptor.proto*. This is usually installed under
-*/usr/include*. Therefore, to compile a .proto file which uses options, use a
-protoc command similar to::
-
-    protoc -I/usr/include -Inanopb/generator -I. -omessage.pb message.proto
-
-The options can be defined in file, message and field scopes::
-
-    option (nanopb_fileopt).max_size = 20; // File scope
-    message Message
-    {
-        option (nanopb_msgopt).max_size = 30; // Message scope
-        required string fieldsize = 1 [(nanopb).max_size = 40]; // Field scope
-    }
-
-
-
-
-
-
-
+============================  ================================================================================================
 
+The PB_MAX_REQUIRED_FIELDS, PB_FIELD_16BIT and PB_FIELD_32BIT settings allow raising some datatype limits to suit larger messages.
+Their need is recognized automatically by C-preprocessor #if-directives in the generated .pb.h files. The default setting is to use
+the smallest datatypes (least resources used).
 
 pb.h
 ====
@@ -299,41 +148,6 @@ Protocol Buffers wire types. These are used with `pb_encode_tag`_. ::
         PB_WT_32BIT  = 5
     } pb_wire_type_t;
 
-PB_GET_ERROR
-------------
-Get the current error message from a stream, or a placeholder string if
-there is no error message::
-
-    #define PB_GET_ERROR(stream) (string expression)
-
-This should be used for printing errors, for example::
-
-    if (!pb_decode(...))
-    {
-        printf("Decode failed: %s\n", PB_GET_ERROR(stream));
-    }
-
-The macro only returns pointers to constant strings (in code memory),
-so that there is no need to release the returned pointer.
-
-PB_RETURN_ERROR
----------------
-Set the error message and return false::
-
-    #define PB_RETURN_ERROR(stream,msg) (sets error and returns false)
-
-This should be used to handle error conditions inside nanopb functions
-and user callback functions::
-
-    if (error_condition)
-    {
-        PB_RETURN_ERROR(stream, "something went wrong");
-    }
-
-The *msg* parameter must be a constant string.
-
-
-
 pb_encode.h
 ===========
 
@@ -483,17 +297,6 @@ In Protocol Buffers format, the submessage size must be written before the subme
 
 If the submessage contains callback fields, the callback function might misbehave and write out a different amount of data on the second call. This situation is recognized and *false* is returned, but garbage will be written to the output before the problem is detected.
 
-
-
-
-
-
-
-
-
-
-
-
 pb_decode.h
 ===========
 

example/fileproto.options

@@ -1,13 +0,0 @@
-# This file defines the nanopb-specific options for the messages defined
-# in fileproto.proto.
-#
-# If you come from high-level programming background, the hardcoded
-# maximum lengths may disgust you. However, if your microcontroller only
-# has a few kB of ram to begin with, setting reasonable limits for
-# filenames is ok.
-#
-# On the other hand, using the callback interface, it is not necessary
-# to set a limit on the number of files in the response.
-
-ListFilesRequest.path 	max_size:128
-FileInfo.name 		max_size:128

example/fileproto.proto

@@ -1,14 +1,22 @@
+import "nanopb.proto";
+
 // This defines protocol for a simple server that lists files.
 //
-// See also the nanopb-specific options in fileproto.options.
+// If you come from high-level programming background, the hardcoded
+// maximum lengths may disgust you. However, if your microcontroller only
+// has a few kB of ram to begin with, setting reasonable limits for
+// filenames is ok.
+//
+// On the other hand, using the callback interface, it is not necessary
+// to set a limit on the number of files in the response.
 
 message ListFilesRequest {
-    optional string path = 1 [default = "/"];
+    optional string path = 1 [default = "/", (nanopb).max_size = 128];
 }
 
 message FileInfo {
     required uint64 inode = 1;
-    required string name = 2;
+    required string name = 2 [(nanopb).max_size = 128];
 }
 
 message ListFilesResponse {

generator/nanopb.proto

@@ -33,8 +33,6 @@ message NanoPBOptions {
   optional bool long_names = 4 [default = true];
   
   // Add 'packed' attribute to generated structs.
-  // Note: this cannot be used on CPUs that break on unaligned
-  // accesses to variables.
   optional bool packed_struct = 5 [default = false];
 }
 

generator/nanopb_generator.py

@@ -1,5 +1,5 @@
 '''Generate header file for nanopb from a ProtoBuf FileDescriptorSet.'''
-nanopb_version = "nanopb-0.2.2-dev"
+nanopb_version = "nanopb-0.2.1-dev"
 
 try:
     import google.protobuf.descriptor_pb2 as descriptor
@@ -235,11 +235,6 @@ class Field:
         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.
@@ -275,64 +270,8 @@ class Field:
         return max(self.tag, self.max_size, self.max_count)        
 
 
-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 ''
-
-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':
-            raise NotImplementedError("Only 'optional' is supported for extension fields. "
-               + "(%s.rules == %s)" % (self.fullname, self.rules))
-
-        self.rules = 'OPTEXT'
-
-    def extension_decl(self):
-        '''Declaration of the extension type in the .pb.h file'''
-        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'''
-
-        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
 
 
 # ---------------------------------------------------------------------------
@@ -350,12 +289,6 @@ class Message:
             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()
@@ -420,6 +353,9 @@ class Message:
 
 
 
+
+
+
 # ---------------------------------------------------------------------------
 #                    Processing of entire .proto files
 # ---------------------------------------------------------------------------
@@ -439,23 +375,11 @@ def iterate_messages(desc, names = Names()):
         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 (enums, messages, extensions).'''
+    '''Takes a FileDescriptorProto and returns tuple (enum, messages).'''
     
     enums = []
     messages = []
-    extensions = []
     
     if fdesc.package:
         base_name = Names(fdesc.package.split('.'))
@@ -473,10 +397,6 @@ def parse_file(fdesc, file_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)
-        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:
@@ -486,7 +406,7 @@ def parse_file(fdesc, file_options):
                         idx = enum.value_longnames.index(field.default)
                         field.default = enum.values[idx][0]
     
-    return enums, messages, extensions
+    return enums, messages
 
 def toposort2(data):
     '''Topological sort.
@@ -529,7 +449,7 @@ def make_identifier(headername):
             result += '_'
     return result
 
-def generate_header(dependencies, headername, enums, messages, extensions, options):
+def generate_header(dependencies, headername, enums, messages, options):
     '''Generate content for a header file.
     Generates strings, which should be concatenated and stored to file.
     '''
@@ -565,23 +485,11 @@ def generate_header(dependencies, headername, enums, messages, extensions, optio
         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()
-    yield '\n'
-    
     yield '/* Struct field encoding specification for nanopb */\n'
     for msg in messages:
         yield msg.fields_declaration() + '\n'
@@ -593,7 +501,7 @@ def generate_header(dependencies, headername, enums, messages, extensions, optio
     # End of header
     yield '\n#endif\n'
 
-def generate_source(headername, enums, messages, extensions):
+def generate_source(headername, enums, messages):
     '''Generate content for a source file.'''
     
     yield '/* Automatically generated nanopb constant definitions */\n'
@@ -609,10 +517,6 @@ def generate_source(headername, enums, messages, extensions):
     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.rules == 'REQUIRED'])
         largest_msg = max(messages, key = count_required_fields)
@@ -624,6 +528,7 @@ def generate_source(headername, enums, messages, extensions):
             yield '       setting PB_MAX_REQUIRED_FIELDS to %d or more.\n' % largest_count
             yield '#endif\n'
     
+    # Add checks for numeric limits
     worst = 0
     worst_field = ''
     checks = []
@@ -808,7 +713,7 @@ def process(filenames, options):
         
         # Parse the file
         file_options = get_nanopb_suboptions(fdesc.file[0], toplevel_options, Names([filename]))
-        enums, messages, extensions = parse_file(fdesc.file[0], file_options)
+        enums, messages = parse_file(fdesc.file[0], file_options)
         
         noext = os.path.splitext(filename)[0]
         headername = noext + '.' + options.extension + '.h'
@@ -824,12 +729,11 @@ def process(filenames, options):
         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, extensions, options):
+        for part in generate_header(dependencies, headerbasename, enums, messages, options):
             header.write(part)
 
         source = open(sourcename, 'w')
-        for part in generate_source(headerbasename, enums, messages, extensions):
+        for part in generate_source(headerbasename, enums, messages):
             source.write(part)
 
     return True

pb.h

@@ -1,61 +1,13 @@
-/* Common parts of the nanopb library. Most of these are quite low-level
- * stuff. For the high-level interface, see pb_encode.h and pb_decode.h.
- */
-
 #ifndef _PB_H_
 #define _PB_H_
 
-/*****************************************************************
- * Nanopb compilation time options. You can change these here by *
- * uncommenting the lines, or on the compiler command line.      *
- *****************************************************************/
-
-/* Define this if your CPU architecture is big endian, i.e. it
- * stores the most-significant byte first. */
-/* #define __BIG_ENDIAN__ 1 */
-
-/* Increase the number of required fields that are tracked.
- * A compiler warning will tell if you need this. */
-/* #define PB_MAX_REQUIRED_FIELDS 256 */
-
-/* Add support for tag numbers > 255 and fields larger than 255 bytes. */
-/* #define PB_FIELD_16BIT 1 */
-
-/* Add support for tag numbers > 65536 and fields larger than 65536 bytes. */
-/* #define PB_FIELD_32BIT 1 */
-
-/* Disable support for error messages in order to save some code space. */
-/* #define PB_NO_ERRMSG 1 */
-
-/* Disable support for custom streams (support only memory buffers). */
-/* #define PB_BUFFER_ONLY 1 */
-
-/* Switch back to the old-style callback function signature.
- * This was the default until nanopb-0.2.1. */
-/* #define PB_OLD_CALLBACK_STYLE */
-
-
-/******************************************************************
- * You usually don't need to change anything below this line.     *
- * Feel free to look around and use the defined macros, though.   *
- ******************************************************************/
-
-
-/* Version of the nanopb library. Just in case you want to check it in
- * your own program. */
-#define NANOPB_VERSION nanopb-0.2.2-dev
-
-/* Include all the system headers needed by nanopb. You will need the
- * definitions of the following:
- * - strlen, memcpy, memset functions
- * - [u]int8_t, [u]int16_t, [u]int32_t, [u]int64_t
- * - size_t
- * - bool
- *
- * If you don't have the standard header files, you can instead provide
- * a custom header that defines or includes all this. In that case,
- * define PB_SYSTEM_HEADER to the path of this file.
+/* pb.h: Common parts for nanopb library.
+ * Most of these are quite low-level stuff. For the high-level interface,
+ * see pb_encode.h or pb_decode.h
  */
+
+#define NANOPB_VERSION nanopb-0.2.1-dev
+
 #ifdef PB_SYSTEM_HEADER
 #include PB_SYSTEM_HEADER
 #else
@@ -78,7 +30,7 @@
 #   define PB_PACKED_STRUCT_START _Pragma("pack(push, 1)")
 #   define PB_PACKED_STRUCT_END _Pragma("pack(pop)")
 #   define pb_packed
-#elif defined(_MSC_VER) && (_MSC_VER >= 1500)
+#elif defined(_MSC_VER)
     /* For Microsoft Visual C++ */
 #   define PB_PACKED_STRUCT_START __pragma(pack(push, 1))
 #   define PB_PACKED_STRUCT_END __pragma(pack(pop))
@@ -104,7 +56,8 @@
 #define STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) static_assertion_##MSG##LINE##COUNTER
 #endif
 
-/* Number of required fields to keep track of. */
+/* Number of required fields to keep track of
+ * (change here or on compiler command line). */
 #ifndef PB_MAX_REQUIRED_FIELDS
 #define PB_MAX_REQUIRED_FIELDS 64
 #endif
@@ -125,7 +78,9 @@
 
 typedef uint8_t pb_type_t;
 
-/**** Field data types ****/
+/************************
+ * Field contents types *
+ ************************/
 
 /* Numeric types */
 #define PB_LTYPE_VARINT 0x00 /* int32, uint32, int64, uint64, bool, enum */
@@ -148,22 +103,22 @@ typedef uint8_t pb_type_t;
  * submsg_fields is pointer to field descriptions */
 #define PB_LTYPE_SUBMESSAGE 0x06
 
-/* Extension pseudo-field
- * The field contains a pointer to pb_extension_t */
-#define PB_LTYPE_EXTENSION 0x07
-
 /* Number of declared LTYPES */
-#define PB_LTYPES_COUNT 8
+#define PB_LTYPES_COUNT 7
 #define PB_LTYPE_MASK 0x0F
 
-/**** Field repetition rules ****/
+/**************************
+ * Field repetition rules *
+ **************************/
 
 #define PB_HTYPE_REQUIRED 0x00
 #define PB_HTYPE_OPTIONAL 0x10
 #define PB_HTYPE_REPEATED 0x20
 #define PB_HTYPE_MASK     0x30
 
-/**** Field allocation types ****/
+/********************
+ * Allocation types *
+ ********************/
  
 #define PB_ATYPE_STATIC   0x00
 #define PB_ATYPE_CALLBACK 0x40
@@ -274,51 +229,6 @@ typedef enum {
     PB_WT_32BIT  = 5
 } pb_wire_type_t;
 
-/* Structure for defining the handling of unknown/extension fields.
- * Usually the pb_extension_type_t structure is automatically generated,
- * while the pb_extension_t structure is created by the user. However,
- * if you want to catch all unknown fields, you can also create a custom
- * pb_extension_type_t with your own callback.
- */
-typedef struct _pb_extension_type_t pb_extension_type_t;
-typedef struct _pb_extension_t pb_extension_t;
-struct _pb_extension_type_t {
-    /* Called for each unknown field in the message.
-     * If you handle the field, read off all of its data and return true.
-     * If you do not handle the field, do not read anything and return true.
-     * If you run into an error, return false.
-     * Set to NULL for default handler.
-     */
-    bool (*decode)(pb_istream_t *stream, pb_extension_t *extension,
-                   uint32_t tag, pb_wire_type_t wire_type);
-    
-    /* Called once after all regular fields have been encoded.
-     * If you have something to write, do so and return true.
-     * If you do not have anything to write, just return true.
-     * If you run into an error, return false.
-     * Set to NULL for default handler.
-     */
-    bool (*encode)(pb_ostream_t *stream, const pb_extension_t *extension);
-    
-    /* Free field for use by the callback. */
-    const void *arg;
-};
-
-struct _pb_extension_t {
-    /* Type describing the extension field. Usually you'll initialize
-     * this to a pointer to the automatically generated structure. */
-    const pb_extension_type_t *type;
-    
-    /* Destination for the decoded data. This must match the datatype
-     * of the extension field. */
-    void *dest;
-    
-    /* Pointer to the next extension handler, or NULL.
-     * If this extension does not match a field, the next handler is
-     * automatically called. */
-    pb_extension_t *next;
-};
-
 /* These macros are used to declare pb_field_t's in the constant array. */
 #define pb_membersize(st, m) (sizeof ((st*)0)->m)
 #define pb_arraysize(st, m) (pb_membersize(st, m) / pb_membersize(st, m[0]))
@@ -364,17 +274,6 @@ struct _pb_extension_t {
     {tag, PB_ATYPE_CALLBACK | PB_HTYPE_REPEATED | ltype, \
     pb_delta_end(st, m, pm), 0, pb_membersize(st, m), 0, ptr}
 
-/* Optional extensions don't have the has_ field, as that would be redundant. */
-#define PB_OPTEXT_STATIC(tag, st, m, pm, ltype, ptr) \
-    {tag, PB_ATYPE_STATIC | PB_HTYPE_OPTIONAL | ltype, \
-    0, \
-    0, \
-    pb_membersize(st, m), 0, ptr}
-
-#define PB_OPTEXT_CALLBACK(tag, st, m, pm, ltype, ptr) \
-    {tag, PB_ATYPE_CALLBACK | PB_HTYPE_OPTIONAL | ltype, \
-    0, 0, pb_membersize(st, m), 0, ptr}
-
 /* The mapping from protobuf types to LTYPEs is done using these macros. */
 #define PB_LTYPE_MAP_BOOL       PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_BYTES      PB_LTYPE_BYTES
@@ -393,14 +292,13 @@ struct _pb_extension_t {
 #define PB_LTYPE_MAP_STRING     PB_LTYPE_STRING
 #define PB_LTYPE_MAP_UINT32     PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_UINT64     PB_LTYPE_VARINT
-#define PB_LTYPE_MAP_EXTENSION  PB_LTYPE_EXTENSION
 
 /* This is the actual macro used in field descriptions.
  * It takes these arguments:
  * - Field tag number
  * - Field type:   BOOL, BYTES, DOUBLE, ENUM, FIXED32, FIXED64,
  *                 FLOAT, INT32, INT64, MESSAGE, SFIXED32, SFIXED64
- *                 SINT32, SINT64, STRING, UINT32, UINT64 or EXTENSION
+ *                 SINT32, SINT64, STRING, UINT32 or UINT64
  * - Field rules:  REQUIRED, OPTIONAL or REPEATED
  * - Allocation:   STATIC or CALLBACK
  * - Message name
@@ -413,7 +311,6 @@ struct _pb_extension_t {
     PB_ ## rules ## _ ## allocation(tag, message, field, prevfield, \
                                     PB_LTYPE_MAP_ ## type, ptr)
 
-
 /* These macros are used for giving out error messages.
  * They are mostly a debugging aid; the main error information
  * is the true/false return value from functions.

pb_decode.c

@@ -28,8 +28,7 @@ static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
     
     &pb_dec_bytes,
     &pb_dec_string,
-    &pb_dec_submessage,
-    NULL /* extensions */
+    &pb_dec_submessage
 };
 
 /**************
@@ -309,12 +308,12 @@ static bool pb_field_next(pb_field_iterator_t *iter)
         prev_size *= iter->pos->array_size;
     }
     
-    if (iter->pos->tag == 0)
-        return false; /* Only happens with empty message types */
-    
     if (PB_HTYPE(iter->pos->type) == PB_HTYPE_REQUIRED)
         iter->required_field_index++;
     
+    if (iter->pos->tag == 0)
+        return false; /* Only happens with empty message types */
+    
     iter->pos++;
     iter->field_index++;
     if (iter->pos->tag == 0)
@@ -332,22 +331,6 @@ static bool pb_field_next(pb_field_iterator_t *iter)
     return notwrapped;
 }
 
-static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag)
-{
-    unsigned start = iter->field_index;
-    
-    do {
-        if (iter->pos->tag == tag &&
-            PB_LTYPE(iter->pos->type) != PB_LTYPE_EXTENSION)
-        {
-            return true;
-        }
-        pb_field_next(iter);
-    } while (iter->field_index != start);
-    
-    return false;
-}
-
 /*************************
  * Decode a single field *
  *************************/
@@ -434,11 +417,11 @@ static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type
         if (!pb_make_string_substream(stream, &substream))
             return false;
         
-        do
+        while (substream.bytes_left)
         {
             if (!pCallback->funcs.decode(&substream, iter->pos, arg))
                 PB_RETURN_ERROR(stream, "callback failed");
-        } while (substream.bytes_left);
+        }
         
         pb_close_string_substream(stream, &substream);
         return true;
@@ -476,136 +459,105 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t
     }
 }
 
-/* Default handler for extension fields. Expects a pb_field_t structure
- * in extension->type->arg. */
-static bool checkreturn default_extension_handler(pb_istream_t *stream,
-    pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type)
-{
-    const pb_field_t *field = (const pb_field_t*)extension->type->arg;
-    pb_field_iterator_t iter;
-    bool dummy;
-    
-    if (field->tag != tag)
-        return true;
-    
-    iter.start = field;
-    iter.pos = field;
-    iter.field_index = 0;
-    iter.required_field_index = 0;
-    iter.dest_struct = extension->dest;
-    iter.pData = extension->dest;
-    iter.pSize = &dummy;
-    
-    return decode_field(stream, wire_type, &iter);
-}
-
-/* Try to decode an unknown field as an extension field. Tries each extension
- * decoder in turn, until one of them handles the field or loop ends. */
-static bool checkreturn decode_extension(pb_istream_t *stream,
-    uint32_t tag, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
-{
-    pb_extension_t *extension = *(pb_extension_t* const *)iter->pData;
-    size_t pos = stream->bytes_left;
-    
-    while (extension && pos == stream->bytes_left)
-    {
-        bool status;
-        if (extension->type->decode)
-            status = extension->type->decode(stream, extension, tag, wire_type);
-        else
-            status = default_extension_handler(stream, extension, tag, wire_type);
-
-        if (!status)
-            return false;
-        
-        extension = extension->next;
-    }
-    
-    return true;
-}
-
-/* Step through the iterator until an extension field is found or until all
- * entries have been checked. There can be only one extension field per
- * message. Returns false if no extension field is found. */
-static bool checkreturn find_extension_field(pb_field_iterator_t *iter)
-{
-    unsigned start = iter->field_index;
-    
-    do {
-        if (PB_LTYPE(iter->pos->type) == PB_LTYPE_EXTENSION)
-            return true;
-        pb_field_next(iter);
-    } while (iter->field_index != start);
-    
-    return false;
-}
-
-/* Initialize message fields to default values, recursively */
-static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
-{
-    pb_field_iterator_t iter;
-    pb_field_init(&iter, fields, dest_struct);
-    
-    /* Initialize size/has fields and apply default values */
-    do
+/* Set field count to zero (or clear has_ field). */
+static void pb_clear_field_count(const pb_field_iterator_t *iter)
 {
     pb_type_t type;
-        type = iter.pos->type;
+    type = iter->pos->type;
     
-        if (iter.pos->tag == 0)
-            continue;
+    if (iter->pos->tag == 0)
+        return; /* Empty message type */
 
     if (PB_ATYPE(type) == PB_ATYPE_STATIC)
     {
-            /* Initialize the size field for optional/repeated fields to 0. */
         if (PB_HTYPE(type) == PB_HTYPE_OPTIONAL)
         {
-                *(bool*)iter.pSize = false;
+            *(bool*)iter->pSize = false;
         }
         else if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
         {
-                *(size_t*)iter.pSize = 0;
-                continue; /* Array is empty, no need to initialize contents */
+            *(size_t*)iter->pSize = 0;
+        }
+    }
 }
 
-            /* Initialize field contents to default value */
-            if (PB_LTYPE(iter.pos->type) == PB_LTYPE_SUBMESSAGE)
+/* Initialize message field to default value. Recurses on submessages. */
+static void pb_set_field_to_default(const pb_field_iterator_t *iter)
 {
-                pb_message_set_to_defaults((const pb_field_t *) iter.pos->ptr, iter.pData);
+    pb_type_t type;
+    type = iter->pos->type;
+
+    if (iter->pos->tag == 0)
+        return; /* Empty message type */
+
+    /* We only need to initialize static fields.
+     * Furthermore, arrays do not need to be initialized as their length
+     * will be zero by default.
+     */
+    if (PB_ATYPE(type) == PB_ATYPE_STATIC &&
+        PB_HTYPE(type) != PB_HTYPE_REPEATED)
+    {
+        if (PB_LTYPE(iter->pos->type) == PB_LTYPE_SUBMESSAGE)
+        {
+            /* Submessage: initialize the fields recursively */
+            pb_field_iterator_t subiter;
+            pb_field_init(&subiter, (const pb_field_t *)iter->pos->ptr, iter->pData);
+            do {
+                pb_clear_field_count(&subiter);
+                pb_set_field_to_default(&subiter);
+            } while (pb_field_next(&subiter));
         }
-            else if (iter.pos->ptr != NULL)
+        else if (iter->pos->ptr != NULL)
         {
-                memcpy(iter.pData, iter.pos->ptr, iter.pos->data_size);
+            /* Normal field: copy the default value */
+            memcpy(iter->pData, iter->pos->ptr, iter->pos->data_size);
         }
         else
         {
-                memset(iter.pData, 0, iter.pos->data_size);
+            /* Normal field without default value: initialize to zero */
+            memset(iter->pData, 0, iter->pos->data_size);
         }
     }
-        else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK)
-        {
-            continue; /* Don't overwrite callback */
-        }
-    } while (pb_field_next(&iter));
 }
 
 /*********************
  * Decode all fields *
  *********************/
 
-bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
+/* Helper function to initialize fields while advancing iterator */
+static void advance_iterator(pb_field_iterator_t *iter, bool *initialize, bool *current_seen)
+{
+    /* Initialize the fields we didn't decode. */
+    if (*initialize && !*current_seen)
+        pb_set_field_to_default(iter);
+    
+    /* Stop initializing after the first pass through the array */
+    if (!pb_field_next(iter))
+        *initialize = false;
+    
+    /* Clear the field count before decoding */
+    if (*initialize)
+        pb_clear_field_count(iter);
+    
+    /* Reset the flag to indicate that the new field has not been written to yet. */
+    *current_seen = false;
+}
+
+static bool checkreturn pb_decode_inner(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct, bool initialize)
 {
     uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0}; /* Used to check for required fields */
-    uint32_t extension_range_start = 0;
+    bool current_seen = false;
     pb_field_iterator_t iter;
-    
     pb_field_init(&iter, fields, dest_struct);
+    pb_clear_field_count(&iter);
     
     while (stream->bytes_left)
     {
         uint32_t tag;
         pb_wire_type_t wire_type;
         bool eof;
+        unsigned start;
+        bool skip = false;
         
         if (!pb_decode_tag(stream, &wire_type, &tag, &eof))
         {
@@ -615,43 +567,45 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
                 return false;
         }
         
-        if (!pb_field_find(&iter, tag))
+        /* Go through the fields until we either find a match or
+         * wrap around to start. On the first pass, also initialize
+         * any missing fields.
+         * 
+         * The logic here is to avoid unnecessary initialization
+         * in the common case, where all fields occur in the proper
+         * order.
+         */
+        start = iter.field_index;
+        while (iter.pos->tag != tag)
         {
-            /* No match found, check if it matches an extension. */
-            if (tag >= extension_range_start)
-            {
-                if (!find_extension_field(&iter))
-                    extension_range_start = (uint32_t)-1;
-                else
-                    extension_range_start = iter.pos->tag;
+            advance_iterator(&iter, &initialize, &current_seen);
             
-                if (tag >= extension_range_start)
+            if (iter.field_index == start)
             {
-                    size_t pos = stream->bytes_left;
-                
-                    if (!decode_extension(stream, tag, wire_type, &iter))
-                        return false;
-                    
-                    if (pos != stream->bytes_left)
-                    {
-                        /* The field was handled */
-                        continue;                    
-                    }
+                skip = true;
+                break;
             }
         }
         
-            /* No match found, skip data */
+        /* Skip data if field was not found */
+        if (skip)
+        {
             if (!pb_skip_field(stream, wire_type))
                 return false;
+
             continue;
         }
         
+        current_seen = true;
+        
+        /* Keep track if all required fields are present */
         if (PB_HTYPE(iter.pos->type) == PB_HTYPE_REQUIRED
             && iter.required_field_index < PB_MAX_REQUIRED_FIELDS)
         {
             fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7));
         }
             
+        /* Finally, decode the field data */
         if (!decode_field(stream, wire_type, &iter))
             return false;
     }
@@ -661,6 +615,9 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
         /* First figure out the number of required fields by
          * seeking to the end of the field array. Usually we
          * are already close to end after decoding.
+         *
+         * Note: this simultaneously initializes any fields
+         * that haven't been already initialized.
          */
         unsigned req_field_count;
         pb_type_t last_type;
@@ -668,7 +625,8 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
         do {
             req_field_count = iter.required_field_index;
             last_type = iter.pos->type;
-        } while (pb_field_next(&iter));
+            advance_iterator(&iter, &initialize, &current_seen);
+        } while (iter.field_index != 0);
         
         /* Fixup if last field was also required. */
         if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED && iter.pos->tag)
@@ -689,23 +647,14 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
     return true;
 }
 
-bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
+bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 {
-    pb_message_set_to_defaults(fields, dest_struct);
-    return pb_decode_noinit(stream, fields, dest_struct);
+    return pb_decode_inner(stream, fields, dest_struct, false);
 }
 
-bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
+bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 {
-    pb_istream_t substream;
-    bool status;
-    
-    if (!pb_make_string_substream(stream, &substream))
-        return false;
-    
-    status = pb_decode(&substream, fields, dest_struct);
-    pb_close_string_substream(stream, &substream);
-    return status;
+    return pb_decode_inner(stream, fields, dest_struct, true);
 }
 
 /* Field decoders */
@@ -769,8 +718,7 @@ bool pb_decode_fixed64(pb_istream_t *stream, void *dest)
 bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
     uint64_t value;
-    if (!pb_decode_varint(stream, &value))
-        return false;
+    bool status = pb_decode_varint(stream, &value);
     
     switch (field->data_size)
     {
@@ -781,14 +729,13 @@ bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, vo
         default: PB_RETURN_ERROR(stream, "invalid data_size");
     }
     
-    return true;
+    return status;
 }
 
 bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
     int64_t value;
-    if (!pb_decode_svarint(stream, &value))
-        return false;
+    bool status = pb_decode_svarint(stream, &value);
     
     switch (field->data_size)
     {
@@ -797,7 +744,7 @@ bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, v
         default: PB_RETURN_ERROR(stream, "invalid data_size");
     }
     
-    return true;
+    return status;
 }
 
 bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
@@ -856,12 +803,7 @@ bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field
     if (field->ptr == NULL)
         PB_RETURN_ERROR(stream, "invalid field descriptor");
     
-    /* New array entries need to be initialized, while required and optional
-     * submessages have already been initialized in the top-level pb_decode. */
-    if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
     status = pb_decode(&substream, submsg_fields, dest);
-    else
-        status = pb_decode_noinit(&substream, submsg_fields, dest);
     
     pb_close_string_substream(stream, &substream);
     return status;

pb_decode.h

@@ -1,80 +1,31 @@
-/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
- * The main function is pb_decode. You also need an input stream, and the
- * field descriptions created by nanopb_generator.py.
- */
-
 #ifndef _PB_DECODE_H_
 #define _PB_DECODE_H_
 
+/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
+ * The main function is pb_decode. You will also need to create an input
+ * stream, which is easiest to do with pb_istream_from_buffer().
+ * 
+ * You also need structures and their corresponding pb_field_t descriptions.
+ * These are usually generated from .proto-files with a script.
+ */
+
+#include <stdbool.h>
 #include "pb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/***************************
- * Main decoding functions *
- ***************************/
- 
-/* Decode a single protocol buffers message from input stream into a C structure.
- * Returns true on success, false on any failure.
- * The actual struct pointed to by dest must match the description in fields.
- * Callback fields of the destination structure must be initialized by caller.
- * All other fields will be initialized by this function.
- *
- * Example usage:
- *    MyMessage msg = {};
- *    uint8_t buffer[64];
- *    pb_istream_t stream;
- *    
- *    // ... read some data into buffer ...
- *
- *    stream = pb_istream_from_buffer(buffer, count);
- *    pb_decode(&stream, MyMessage_fields, &msg);
- */
-bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
-
-/* Same as pb_decode, except does not initialize the destination structure
- * to default values. This is slightly faster if you need no default values
- * and just do memset(struct, 0, sizeof(struct)) yourself.
- *
- * This can also be used for 'merging' two messages, i.e. update only the
- * fields that exist in the new message.
- */
-bool pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
-
-/* Same as pb_decode, except expects the stream to start with the message size
- * encoded as varint. Corresponds to parseDelimitedFrom() in Google's
- * protobuf API.
- */
-bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
-
-
-/**************************************
- * Functions for manipulating streams *
- **************************************/
-
-/* Create an input stream for reading from a memory buffer.
- *
- * Alternatively, you can use a custom stream that reads directly from e.g.
- * a file or a network socket.
- */
-pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize);
-
-/* Function to read from a pb_istream_t. You can use this if you need to
- * read some custom header data, or to read data in field callbacks.
- */
-bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count);
-
-/* Structure for defining custom input streams. You will need to provide
- * a callback function to read the bytes from your storage, which can be
- * for example a file or a network socket.
- * 
- * The callback must conform to these rules:
+/* Lightweight input stream.
+ * You can provide a callback function for reading or use
+ * pb_istream_from_buffer.
  * 
+ * Rules for callback:
  * 1) Return false on IO errors. This will cause decoding to abort.
+ * 
  * 2) You can use state to store your own data (e.g. buffer pointer),
  * and rely on pb_read to verify that no-body reads past bytes_left.
+ * 
  * 3) Your callback may be used with substreams, in which case bytes_left
  * is different than from the main stream. Don't use bytes_left to compute
  * any pointers.
@@ -99,10 +50,27 @@ struct _pb_istream_t
 #endif
 };
 
+pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize);
+bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count);
 
-/************************************************
- * Helper functions for writing field callbacks *
- ************************************************/
+/* Decode from stream to destination struct.
+ * Returns true on success, false on any failure.
+ * 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_struct);
+
+/* Same as pb_decode, except does not initialize the destination structure
+ * to default values. This is slightly faster if you need no default values
+ * and just do memset(struct, 0, sizeof(struct)) yourself.
+ *
+ * It can also be used to merge fields from a new message into a previously
+ * initialized structure.
+ */
+bool pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
+
+/* --- Helper functions ---
+ * You may want to use these from your caller or callbacks.
+ */
 
 /* Decode the tag for the next field in the stream. Gives the wire type and
  * field tag. At end of the message, returns false and sets eof to true. */
@@ -131,10 +99,10 @@ bool pb_decode_fixed64(pb_istream_t *stream, void *dest);
 bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 
-
-/*******************************
- * Internal / legacy functions *
- *******************************/
+/* --- Internal functions ---
+ * These functions are not terribly useful for the average library user, but
+ * are exported to make the unit testing and extending nanopb easier.
+ */
 
 #ifdef NANOPB_INTERNALS
 bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest);

pb_encode.c

@@ -28,8 +28,7 @@ static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
     
     &pb_enc_bytes,
     &pb_enc_string,
-    &pb_enc_submessage,
-    NULL /* extensions */
+    &pb_enc_submessage
 };
 
 /* pb_ostream_t implementation */
@@ -84,7 +83,10 @@ bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count
 
 /* Main encoding stuff */
 
-/* Encode a static array. Handles the size calculations and possible packing. */
+/* 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)
 {
@@ -95,7 +97,6 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
     if (count == 0)
         return true;
     
-    /* We always pack arrays if the datatype allows it. */
     if (PB_LTYPE(field->type) <= PB_LTYPE_LAST_PACKABLE)
     {
         if (!pb_encode_tag(stream, PB_WT_STRING, field->tag))
@@ -154,21 +155,13 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
     return true;
 }
 
-/* Encode a field with static allocation, i.e. one whose data is stored
- * in the structure itself. */
-static bool checkreturn encode_static_field(pb_ostream_t *stream,
-    const pb_field_t *field, const void *pData)
+bool checkreturn encode_static_field(pb_ostream_t *stream, const pb_field_t *field, const void *pData)
 {
     pb_encoder_t func;
     const void *pSize;
-    bool dummy = true;
     
     func = PB_ENCODERS[PB_LTYPE(field->type)];
-    
-    if (field->size_offset)
     pSize = (const char*)pData + field->size_offset;
-    else
-        pSize = &dummy;
     
     switch (PB_HTYPE(field->type))
     {
@@ -202,10 +195,7 @@ static bool checkreturn encode_static_field(pb_ostream_t *stream,
     return true;
 }
 
-/* Encode a field with callback semantics. This means that a user function is
- * called to provide and encode the actual data. */
-static bool checkreturn encode_callback_field(pb_ostream_t *stream,
-    const pb_field_t *field, const void *pData)
+bool checkreturn encode_callback_field(pb_ostream_t *stream, const pb_field_t *field, const void *pData)
 {
     const pb_callback_t *callback = (const pb_callback_t*)pData;
     
@@ -223,57 +213,6 @@ static bool checkreturn encode_callback_field(pb_ostream_t *stream,
     return true;
 }
 
-/* Encode a single field of any callback or static type. */
-static bool checkreturn encode_field(pb_ostream_t *stream,
-    const pb_field_t *field, const void *pData)
-{
-    switch (PB_ATYPE(field->type))
-    {
-        case PB_ATYPE_STATIC:
-            return encode_static_field(stream, field, pData);
-        
-        case PB_ATYPE_CALLBACK:
-            return encode_callback_field(stream, field, pData);
-        
-        default:
-            PB_RETURN_ERROR(stream, "invalid field type");
-    }
-}
-
-/* Default handler for extension fields. Expects to have a pb_field_t
- * pointer in the extension->type->arg field. */
-static bool checkreturn default_extension_handler(pb_ostream_t *stream,
-    const pb_extension_t *extension)
-{
-    const pb_field_t *field = (const pb_field_t*)extension->type->arg;
-    return encode_field(stream, field, extension->dest);
-}
-
-/* Walk through all the registered extensions and give them a chance
- * to encode themselves. */
-static bool checkreturn encode_extension_field(pb_ostream_t *stream,
-    const pb_field_t *field, const void *pData)
-{
-    const pb_extension_t *extension = *(const pb_extension_t* const *)pData;
-    UNUSED(field);
-    
-    while (extension)
-    {
-        bool status;
-        if (extension->type->encode)
-            status = extension->type->encode(stream, extension);
-        else
-            status = default_extension_handler(stream, extension);
-
-        if (!status)
-            return false;
-        
-        extension = extension->next;
-    }
-    
-    return true;
-}
-
 bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 {
     const pb_field_t *field = fields;
@@ -292,17 +231,20 @@ bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], cons
             prev_size *= field->array_size;
         }
                 
-        if (PB_LTYPE(field->type) == PB_LTYPE_EXTENSION)
+        switch (PB_ATYPE(field->type))
         {
-            /* Special case for the extension field placeholder */
-            if (!encode_extension_field(stream, field, pData))
+            case PB_ATYPE_STATIC:
+                if (!encode_static_field(stream, field, pData))
                     return false;
-        }
-        else
-        {
-            /* Regular field */
-            if (!encode_field(stream, field, pData))
+                break;
+            
+            case PB_ATYPE_CALLBACK:
+                if (!encode_callback_field(stream, field, pData))
                     return false;
+                break;
+            
+            default:
+                PB_RETURN_ERROR(stream, "invalid field type");
         }
     
         field++;
@@ -311,11 +253,6 @@ bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], cons
     return true;
 }
 
-bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
-{
-    return pb_encode_submessage(stream, fields, src_struct);
-}
-
 /* Helper functions */
 bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value)
 {
@@ -524,16 +461,8 @@ bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, con
 
 bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
-    /* strnlen() is not always available, so just use a for-loop */
-    size_t size = 0;
-    const char *p = (const char*)src;
-    while (size < field->data_size && *p != '\0')
-    {
-        size++;
-        p++;
-    }
-
-    return pb_encode_string(stream, (const uint8_t*)src, size);
+    UNUSED(field);
+    return pb_encode_string(stream, (const uint8_t*)src, strlen((const char*)src));
 }
 
 bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)

pb_encode.h

@@ -1,86 +1,34 @@
-/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
- * The main function is pb_encode. You also need an output stream, and the
- * field descriptions created by nanopb_generator.py.
- */
-
 #ifndef _PB_ENCODE_H_
 #define _PB_ENCODE_H_
 
+/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
+ * The main function is pb_encode. You also need an output stream, structures
+ * and their field descriptions (just like with pb_decode).
+ */
+
+#include <stdbool.h>
 #include "pb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/***************************
- * Main encoding functions *
- ***************************/
-
-/* Encode a single protocol buffers message from C structure into a stream.
- * Returns true on success, false on any failure.
- * The actual struct pointed to by src_struct must match the description in fields.
- * All required fields in the struct are assumed to have been filled in.
+/* Lightweight output stream.
+ * You can provide callback for writing or use pb_ostream_from_buffer.
  * 
- * Example usage:
- *    MyMessage msg = {};
- *    uint8_t buffer[64];
- *    pb_ostream_t stream;
- *
- *    msg.field1 = 42;
- *    stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
- *    pb_encode(&stream, MyMessage_fields, &msg);
- */
-bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
-
-/* Same as pb_encode, but prepends the length of the message as a varint.
- * Corresponds to writeDelimitedTo() in Google's protobuf API.
- */
-bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
-
-/**************************************
- * Functions for manipulating streams *
- **************************************/
-
-/* Create an output stream for writing into a memory buffer.
- * The number of bytes written can be found in stream.bytes_written after
- * encoding the message.
- *
- * Alternatively, you can use a custom stream that writes directly to e.g.
- * a file or a network socket.
- */
-pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize);
-
-/* Pseudo-stream for measuring the size of a message without actually storing
- * the encoded data.
- * 
- * Example usage:
- *    MyMessage msg = {};
- *    pb_ostream_t stream = PB_OSTREAM_SIZING;
- *    pb_encode(&stream, MyMessage_fields, &msg);
- *    printf("Message size is %d\n", stream.bytes_written);
- */
-#ifndef PB_NO_ERRMSG
-#define PB_OSTREAM_SIZING {0,0,0,0,0}
-#else
-#define PB_OSTREAM_SIZING {0,0,0,0}
-#endif
-
-/* Function to write into a pb_ostream_t stream. You can use this if you need
- * to append or prepend some custom headers to the message.
- */
-bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
-
-/* Structure for defining custom output streams. You will need to provide
- * a callback function to write the bytes to your storage, which can be
- * for example a file or a network socket.
- *
- * The callback must conform to these rules:
+ * Alternatively, callback can be NULL in which case the stream will just
+ * count the number of bytes that would have been written. In this case
+ * max_size is not checked.
  *
+ * Rules for callback:
  * 1) Return false on IO errors. This will cause encoding to abort.
+ * 
  * 2) You can use state to store your own data (e.g. buffer pointer).
+ * 
  * 3) pb_write will update bytes_written after your callback runs.
- * 4) Substreams will modify max_size and bytes_written. Don't use them
- *    to calculate any pointers.
+ * 
+ * 4) Substreams will modify max_size and bytes_written. Don't use them to
+ * calculate any pointers.
  */
 struct _pb_ostream_t
 {
@@ -95,26 +43,42 @@ struct _pb_ostream_t
 #else
     bool (*callback)(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 #endif
-    void *state;          /* Free field for use by callback implementation. */
+    void *state; /* Free field for use by callback implementation */
     size_t max_size; /* Limit number of output bytes written (or use SIZE_MAX). */
-    size_t bytes_written; /* Number of bytes written so far. */
+    size_t bytes_written;
     
 #ifndef PB_NO_ERRMSG
     const char *errmsg;
 #endif
 };
 
+pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize);
+bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 
-/************************************************
- * Helper functions for writing field callbacks *
- ************************************************/
+/* Stream type for use in computing message sizes */
+#ifndef PB_NO_ERRMSG
+#define PB_OSTREAM_SIZING {0,0,0,0,0}
+#else
+#define PB_OSTREAM_SIZING {0,0,0,0}
+#endif
 
-/* Encode field header based on type and field number defined in the field
- * structure. Call this from the callback before writing out field contents. */
+/* Encode struct to given output stream.
+ * Returns true on success, false on any failure.
+ * The actual struct pointed to by src_struct must match the description in fields.
+ * All required fields in the struct are assumed to have been filled in.
+ */
+bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
+
+/* --- Helper functions ---
+ * You may want to use these from your caller or callbacks.
+ */
+
+/* Encode field header based on LTYPE and field number defined in the field structure.
+ * Call this from the callback before writing out field contents. */
 bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field);
 
-/* Encode field header by manually specifing wire type. You need to use this
- * if you want to write out packed arrays from a callback field. */
+/* Encode field header by manually specifing wire type. You need to use this if
+ * you want to write out packed arrays from a callback field. */
 bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number);
 
 /* Encode an integer in the varint format.
@@ -137,16 +101,15 @@ bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
 bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
 
 /* Encode a submessage field.
- * You need to pass the pb_field_t array and pointer to struct, just like
- * with pb_encode(). This internally encodes the submessage twice, first to
- * calculate message size and then to actually write it out.
+ * You need to pass the pb_field_t array and pointer to struct, just like with pb_encode().
+ * This internally encodes the submessage twice, first to calculate message size and then to actually write it out.
  */
 bool pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
 
-
-/*******************************
- * Internal / legacy functions *
- *******************************/
+/* --- Internal functions ---
+ * These functions are not terribly useful for the average library user, but
+ * are exported to make the unit testing and extending nanopb easier.
+ */
 
 #ifdef NANOPB_INTERNALS
 bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src);

tests/Makefile

@@ -8,7 +8,7 @@ TESTS=  decode_unittests encode_unittests \
 	test_decode_callbacks test_encode_callbacks \
 	test_missing_fields test_no_messages test_funny_name \
 	test_multiple_files test_cxxcompile test_options \
-	bc_encode bc_decode test_encode_extensions test_decode_extensions
+	bc_encode bc_decode
 
 # More strict checks for the core part of nanopb
 CC_VERSION=$(shell $(CC) -v 2>&1)
@@ -84,8 +84,6 @@ test_no_messages: no_messages.pb.h no_messages.pb.c no_messages.pb.o
 test_funny_name: funny-proto+name.pb.h funny-proto+name.pb.o
 bc_encode: bc_alltypes.pb.o pb_encode.o bc_encode.o
 bc_decode: bc_alltypes.pb.o pb_decode.o bc_decode.o
-test_encode_extensions: test_encode_extensions.c pb_encode.o alltypes.pb.o extensions.pb.o
-test_decode_extensions: test_decode_extensions.c pb_decode.o alltypes.pb.o extensions.pb.o
 
 %.pb: %.proto
 	protoc -I. -I../generator -I/usr/include -o$@ $<
@@ -125,9 +123,7 @@ run_unittests: $(TESTS)
 	./test_encode3 1 | ./test_decode3 1
 	./test_encode3 1 | protoc --decode=AllTypes -I. -I../generator -I/usr/include alltypes.proto >/dev/null
 	./test_encode3_buf 1 | ./test_decode3_buf 1
-	./test_decode3 < alltypes_with_extra_fields.pb
 	./bc_encode | ./bc_decode
-	./test_encode_extensions | ./test_decode_extensions
 	
 	./test_missing_fields
 

tests/alltypes.proto

@@ -86,8 +86,5 @@ message AllTypes {
     // Just to make sure that the size of the fields has been calculated
     // properly, i.e. otherwise a bug in last field might not be detected.
     required int32      end = 99;
-
-
-    extensions 200 to 255;
 }
 

tests/callbacks.proto

@@ -11,6 +11,5 @@ message TestMessage {
     repeated fixed32 fixed32value = 3;
     repeated fixed64 fixed64value = 4;
     optional SubMessage submsg = 5;
-    repeated string repeatedstring = 6;
 }
 

tests/decode_unittests.c

@@ -289,16 +289,6 @@ int main()
         TEST((s = S("\x08"), !pb_decode(&s, IntegerArray_fields, &dest)))
     }
     
-    {
-        pb_istream_t s;
-        IntegerContainer dest = {};
-        
-        COMMENT("Testing pb_decode_delimited")
-        TEST((s = S("\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"),
-              pb_decode_delimited(&s, IntegerContainer_fields, &dest)) &&
-              dest.submsg.data_count == 5)
-    }
-    
     if (status != 0)
         fprintf(stdout, "\n\nSome tests FAILED!\n");
     

tests/encode_unittests.c

@@ -180,14 +180,12 @@ int main()
     {
         uint8_t buffer[30];
         pb_ostream_t s;
-        char value[30] = "xyzzy";
+        char value[] = "xyzzy";
         
         COMMENT("Test pb_enc_string")
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x05xyzzy"))
+        TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x05xyzzy"))
         value[0] = '\0';
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x00"))
-        memset(value, 'x', 30);
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x0Axxxxxxxxxx"))
+        TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x00"))
     }
     
     {
@@ -244,16 +242,6 @@ int main()
                     "\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
     }
     
-    {
-        uint8_t buffer[20];
-        pb_ostream_t s;
-        IntegerContainer msg = {{5, {1,2,3,4,5}}};
-        
-        COMMENT("Test pb_encode_delimited.")
-        TEST(WRITES(pb_encode_delimited(&s, IntegerContainer_fields, &msg),
-                    "\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
-    }
-    
     {
         uint8_t buffer[10];
         pb_ostream_t s;

tests/extensions.options

@@ -1 +0,0 @@
-* max_size:16

tests/extensions.proto

@@ -1,15 +0,0 @@
-import 'alltypes.proto';
-
-extend AllTypes {
-    optional int32 AllTypes_extensionfield1 = 255;
-}
-
-message ExtensionMessage {
-    extend AllTypes {
-        optional ExtensionMessage AllTypes_extensionfield2 = 254;
-    }
-    
-    required string test1 = 1;
-    required int32 test2 = 2;
-}
-

tests/test_decode_callbacks.c

@@ -83,8 +83,6 @@ int main()
     testmessage.fixed32value.arg = "fixed32value: %ld\n";
     testmessage.fixed64value.funcs.decode = &print_fixed64;
     testmessage.fixed64value.arg = "fixed64value: %lld\n";
-    testmessage.repeatedstring.funcs.decode = &print_string;
-    testmessage.repeatedstring.arg = "repeatedstring: \"%s\"\n";
     
     if (!pb_decode(&stream, TestMessage_fields, &testmessage))
         return 1;

tests/test_decode_extensions.c

@@ -1,43 +0,0 @@
-/* Test decoding of extension fields. */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <pb_decode.h>
-#include "alltypes.pb.h"
-#include "extensions.pb.h"
-
-#define TEST(x) if (!(x)) { \
-    printf("Test " #x " failed.\n"); \
-    return 2; \
-    }
-
-int main(int argc, char **argv)
-{
-    uint8_t buffer[1024];
-    size_t count = fread(buffer, 1, sizeof(buffer), stdin);
-    pb_istream_t stream = pb_istream_from_buffer(buffer, count);
-    
-    AllTypes alltypes = {};
-    
-    int32_t extensionfield1;
-    pb_extension_t ext1 = {&AllTypes_extensionfield1, &extensionfield1, NULL};
-    alltypes.extensions = &ext1;
-        
-    ExtensionMessage extensionfield2 = {};
-    pb_extension_t ext2 = {&ExtensionMessage_AllTypes_extensionfield2, &extensionfield2, NULL};
-    ext1.next = &ext2;
-    
-    if (!pb_decode(&stream, AllTypes_fields, &alltypes))
-    {
-        printf("Parsing failed: %s\n", PB_GET_ERROR(&stream));
-        return 1;
-    }
-
-    TEST(extensionfield1 == 12345)
-    TEST(strcmp(extensionfield2.test1, "test") == 0)
-    TEST(extensionfield2.test2 == 54321)
-    
-    return 0;
-}
-

tests/test_encode_callbacks.c

@@ -41,22 +41,6 @@ bool encode_fixed64(pb_ostream_t *stream, const pb_field_t *field, void * const
     return pb_encode_fixed64(stream, &value);
 }
 
-bool encode_repeatedstring(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    char *str[4] = {"Hello world!", "", "Test", "Test2"};
-    int i;
-    
-    for (i = 0; i < 4; i++)
-    {
-        if (!pb_encode_tag_for_field(stream, field))
-            return false;
-        
-        if (!pb_encode_string(stream, (uint8_t*)str[i], strlen(str[i])))
-            return false;
-    }
-    return true;
-}
-
 int main()
 {
     uint8_t buffer[1024];
@@ -74,8 +58,6 @@ int main()
     testmessage.submsg.fixed32value.funcs.encode = &encode_fixed32;
     testmessage.submsg.fixed64value.funcs.encode = &encode_fixed64;
     
-    testmessage.repeatedstring.funcs.encode = &encode_repeatedstring;
-    
     if (!pb_encode(&stream, TestMessage_fields, &testmessage))
         return 1;
     

tests/test_encode_extensions.c

@@ -1,38 +0,0 @@
-/* Tests extension fields.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <pb_encode.h>
-#include "alltypes.pb.h"
-#include "extensions.pb.h"
-
-int main(int argc, char **argv)
-{
-    AllTypes alltypes = {};
-
-    int32_t extensionfield1 = 12345;
-    pb_extension_t ext1 = {&AllTypes_extensionfield1, &extensionfield1, NULL};
-    alltypes.extensions = &ext1;
-
-    ExtensionMessage extensionfield2 = {"test", 54321};
-    pb_extension_t ext2 = {&ExtensionMessage_AllTypes_extensionfield2, &extensionfield2, NULL};
-    ext1.next = &ext2;
-    
-    uint8_t buffer[1024];
-    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
-    
-    /* Now encode it and check if we succeeded. */
-    if (pb_encode(&stream, AllTypes_fields, &alltypes))
-    {
-        fwrite(buffer, 1, stream.bytes_written, stdout);
-        return 0; /* Success */
-    }
-    else
-    {
-        fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&stream));
-        return 1; /* Failure */
-    }
-}
-

tests/unittestproto.proto

@@ -8,10 +8,6 @@ message FloatArray {
     repeated float data = 1 [(nanopb).max_count = 10];
 }
 
-message StringMessage {
-    required string data = 1 [(nanopb).max_size = 10];
-}
-
 message CallbackArray {
     // We cheat a bit and use this message for testing other types, too.
     // Nanopb does not care about the actual defined data type for callback