Publishing nanopb-0.2.9.2

Also backports cdbf51 generator bugfix.

CHANGELOG.txt

@@ -1,22 +1,11 @@
-nanopb-0.3.1 (2014-09-11)
+nanopb-0.2.9.2 (2015-01-24)
+ Fix memory leaks with PB_ENABLE_MALLOC with some submessage hierarchies (issue 138)
+ Fix compilation error with generated initializers for repeated pointer fields
+
+nanopb-0.2.9.1 (2014-09-11)
  Fix security issue due to size_t overflows. (issue 132)
  Fix memory leak with duplicated fields and PB_ENABLE_MALLOC
  Fix crash if pb_release() is called twice.
- Fix cyclic message support (issue 130)
- Fix error in generated initializers for repeated pointer fields.
- Improve tests (issues 113, 126)
-
-nanopb-0.3.0 (2014-08-26)
- NOTE: See docs/migration.html or online at
- http://koti.kapsi.fi/~jpa/nanopb/docs/migration.html
- for changes in this version. Most importantly, you need to add
- pb_common.c to the list of files to compile.
-
- Separated field iterator logic to pb_common.c (issue 128)
- Change the _count fields to use pb_size_t datatype (issue 82)
- Added PB_ prefix to macro names (issue 106)
- Added #if version guard to generated files (issue 129)
- Added migration document
 
 nanopb-0.2.9 (2014-08-09)
  NOTE: If you are using the -e option with the generator, you have

docs/Makefile

@@ -1,4 +1,4 @@
-all: index.html concepts.html reference.html security.html migration.html \
+all: index.html concepts.html reference.html security.html \
 	generator_flow.png
 
 %.png: %.svg

docs/menu.rst

@@ -4,10 +4,8 @@
     2) `Concepts`_
     3) `API reference`_
     4) `Security model`_
-    5) `Migration from older versions`_
     
 .. _`Overview`: index.html
 .. _`Concepts`: concepts.html
 .. _`API reference`: reference.html
 .. _`Security model`: security.html
-.. _`Migration from older versions`: migration.html

docs/migration.rst

@@ -1,239 +0,0 @@
-=====================================
-Nanopb: Migration from older versions
-=====================================
-
-.. include :: menu.rst
-
-This document details all the breaking changes that have been made to nanopb
-since its initial release. For each change, the rationale and required
-modifications of user applications are explained. Also any error indications
-are included, in order to make it easier to find this document.
-
-.. contents ::
-
-Nanopb-0.3.0 (2014-08-26)
-=========================
-
-Separate field iterator logic to pb_common.c
---------------------------------------------
-**Rationale:** Originally, the field iteration logic was simple enough to be
-duplicated in *pb_decode.c* and *pb_encode.c*. New field types have made the
-logic more complex, which required the creation of a new file to contain the
-common functionality.
-
-**Changes:** There is a new file, *pb_common.c*, which must be included in
-builds.
-
-**Required actions:** Add *pb_common.c* to build rules. This file is always
-required. Either *pb_decode.c* or *pb_encode.c* can still be left out if some
-functionality is not needed.
-
-**Error indications:** Linker error: undefined reference to
-*pb_field_iter_begin*, *pb_field_iter_next* or similar.
-
-Change data type of field counts to pb_size_t
----------------------------------------------
-**Rationale:** Often nanopb is used with small arrays, such as 255 items or
-less. Using a full *size_t* field to store the array count wastes memory if
-there are many arrays. There already exists parameters *PB_FIELD_16BIT* and
-*PB_FIELD_32BIT* which tell nanopb what is the maximum size of arrays in use.
-
-**Changes:** Generator will now use *pb_size_t* for the array *_count* fields.
-The size of the type will be controlled by the *PB_FIELD_16BIT* and
-*PB_FIELD_32BIT* compilation time options.
-
-**Required actions:** Regenerate all *.pb.h* files. In some cases casts to the
-*pb_size_t* type may need to be added in the user code when accessing the
-*_count* fields.
-
-**Error indications:** Incorrect data at runtime, crashes. But note that other
-changes in the same version already require regenerating the files and have
-better indications of errors, so this is only an issue for development
-versions.
-
-Renamed some macros and identifiers
------------------------------------
-**Rationale:** Some names in nanopb core were badly chosen and conflicted with
-ISO C99 reserved names or lacked a prefix. While they haven't caused trouble
-so far, it is reasonable to switch to non-conflicting names as these are rarely
-used from user code.
-
-**Changes:** The following identifier names have changed:
-
-  * Macros:
-  
-    * STATIC_ASSERT(x) -> PB_STATIC_ASSERT(x)
-    * UNUSED(x) -> PB_UNUSED(x)
-  
-  * Include guards:
-  
-    * _PB_filename_ -> PB_filename_INCLUDED
-  
-  * Structure forward declaration tags:
-  
-    * _pb_field_t -> pb_field_s
-    * _pb_bytes_array_t -> pb_bytes_array_s
-    * _pb_callback_t -> pb_callback_s
-    * _pb_extension_type_t -> pb_extension_type_s
-    * _pb_extension_t -> pb_extension_s
-    * _pb_istream_t -> pb_istream_s
-    * _pb_ostream_t -> pb_ostream_s
-
-**Required actions:** Regenerate all *.pb.c* files. If you use any of the above
-identifiers in your application code, perform search-replace to the new name.
-
-**Error indications:** Compiler errors on lines with the macro/type names.
-
-Nanopb-0.2.9 (2014-08-09)
-=========================
-
-Change semantics of generator -e option
----------------------------------------
-**Rationale:** Some compilers do not accept filenames with two dots (like
-in default extension .pb.c). The *-e* option to the generator allowed changing
-the extension, but not skipping the extra dot.
-
-**Changes:** The *-e* option in generator will no longer add the prepending
-dot. The default value has been adjusted accordingly to *.pb.c* to keep the
-default behaviour the same as before.
-
-**Required actions:** Only if using the generator -e option. Add dot before
-the parameter value on the command line.
-
-**Error indications:** File not found when trying to compile generated files.
-
-Nanopb-0.2.7 (2014-04-07)
-=========================
-
-Changed pointer-type bytes field datatype
------------------------------------------
-**Rationale:** In the initial pointer encoding support since nanopb-0.2.5,
-the bytes type used a separate *pb_bytes_ptr_t* type to represent *bytes*
-fields. This made it easy to encode data from a separate, user-allocated
-buffer. However, it made the internal logic more complex and was inconsistent
-with the other types.
-
-**Changes:** Dynamically allocated bytes fields now have the *pb_bytes_array_t*
-type, just like statically allocated ones.
-
-**Required actions:** Only if using pointer-type fields with the bytes datatype.
-Change any access to *msg->field.size* to *msg->field->size*. Change any
-allocation to reserve space of amount *PB_BYTES_ARRAY_T_ALLOCSIZE(n)*. If the
-data pointer was begin assigned from external source, implement the field using
-a callback function instead.
-
-**Error indications:** Compiler error: unknown type name *pb_bytes_ptr_t*.
-
-Nanopb-0.2.4 (2013-11-07)
-=========================
-
-Remove the NANOPB_INTERNALS compilation option
-----------------------------------------------
-**Rationale:** Having the option in the headers required the functions to
-be non-static, even if the option is not used. This caused errors on some
-static analysis tools.
-
-**Changes:** The *#ifdef* and associated functions were removed from the
-header.
-
-**Required actions:** Only if the *NANOPB_INTERNALS* option was previously
-used. Actions are as listed under nanopb-0.1.3 and nanopb-0.1.6.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_dec_string*, *pb_enc_string*, or similar.
-
-Nanopb-0.2.1 (2013-04-14)
-=========================
-
-Callback function signature
----------------------------
-**Rationale:** Previously the auxilary data to field callbacks was passed
-as *void\**. This allowed passing of any data, but made it unnecessarily
-complex to return a pointer from callback.
-
-**Changes:** The callback function parameter was changed to *void\*\**.
-
-**Required actions:** You can continue using the old callback style by
-defining *PB_OLD_CALLBACK_STYLE*. Recommended action is to:
-
-  * Change the callback signatures to contain *void\*\** for decoders and
-    *void \* const \** for encoders.
-  * Change the callback function body to use *\*arg* instead of *arg*.
-
-**Error indications:** Compiler warning: assignment from incompatible
-pointer type, when initializing *funcs.encode* or *funcs.decode*.
-
-Nanopb-0.2.0 (2013-03-02)
-=========================
-
-Reformatted generated .pb.c file using macros
----------------------------------------------
-**Rationale:** Previously the generator made a list of C *pb_field_t*
-initializers in the .pb.c file. This led to a need to regenerate all .pb.c
-files after even small changes to the *pb_field_t* definition.
-
-**Changes:** Macros were added to pb.h which allow for cleaner definition
-of the .pb.c contents. By changing the macro definitions, changes to the
-field structure are possible without breaking compatibility with old .pb.c
-files.
-
-**Required actions:** Regenerate all .pb.c files from the .proto sources.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_delta_end*.
-
-Changed pb_type_t definitions
------------------------------
-**Rationale:** The *pb_type_t* was previously an enumeration type. This
-caused warnings on some compilers when using bitwise operations to set flags
-inside the values.
-
-**Changes:** The *pb_type_t* was changed to *typedef uint8_t*. The values
-were changed to *#define*. Some value names were changed for consistency.
-
-**Required actions:** Only if you directly access the `pb_field_t` contents
-in your own code, something which is not usually done. Needed changes:
-
-  * Change *PB_HTYPE_ARRAY* to *PB_HTYPE_REPEATED*.
-  * Change *PB_HTYPE_CALLBACK* to *PB_ATYPE()* and *PB_ATYPE_CALLBACK*.
-
-**Error indications:** Compiler error: *PB_HTYPE_ARRAY* or *PB_HTYPE_CALLBACK*
-undeclared.
-
-Nanopb-0.1.6 (2012-09-02)
-=========================
-
-Refactored field decoder interface
-----------------------------------
-**Rationale:** Similarly to field encoders in nanopb-0.1.3.
-
-**Changes:** New functions with names *pb_decode_\** were added.
-
-**Required actions:** By defining NANOPB_INTERNALS, you can still keep using
-the old functions. Recommended action is to replace any calls with the newer
-*pb_decode_\** equivalents.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_dec_string*, *pb_dec_varint*, *pb_dec_submessage* or similar.
-
-Nanopb-0.1.3 (2012-06-12)
-=========================
-
-Refactored field encoder interface
-----------------------------------
-**Rationale:** The old *pb_enc_\** functions were designed mostly for the
-internal use by the core. Because they are internally accessed through
-function pointers, their signatures had to be common. This led to a confusing
-interface for external users.
-
-**Changes:** New functions with names *pb_encode_\** were added. These have
-easier to use interfaces. The old functions are now only thin wrappers for
-the new interface.
-
-**Required actions:** By defining NANOPB_INTERNALS, you can still keep using
-the old functions. Recommended action is to replace any calls with the newer
-*pb_encode_\** equivalents.
-
-**Error indications:** Compiler warning: implicit declaration of function
-*pb_enc_string*, *pb_enc_varint, *pb_enc_submessage* or similar.
-

docs/security.rst

@@ -26,9 +26,9 @@ The following data is regarded as **trusted**. It must be under the control of
 the application writer. Malicious data in these structures could cause
 security issues, such as execution of arbitrary code:
 
-1. Callback, pointer and extension fields in message structures given to
+1. Callback and extension fields in message structures given to pb_encode()
-   pb_encode() and pb_decode(). These fields are memory pointers, and are
+   and pb_decode(). These fields are memory pointers, and are generated
-   generated depending on the message definition in the .proto file.
+   depending on the .proto file.
 2. The automatically generated field definitions, i.e. *pb_field_t* lists.
 3. Contents of the *pb_istream_t* and *pb_ostream_t* structures (this does not
    mean the contents of the stream itself, just the stream definition).
@@ -38,7 +38,7 @@ these will cause "garbage in, garbage out" behaviour. It will not cause
 buffer overflows, information disclosure or other security problems:
 
 1. All data read from *pb_istream_t*.
-2. All fields in message structures, except callbacks, pointers and extensions.
+2. All fields in message structures, except callbacks and extensions.
    (Beginning with nanopb-0.2.4, in earlier versions the field sizes are partially unchecked.)
 
 Invariants
@@ -76,6 +76,4 @@ The following list is not comprehensive:
    stop a denial of service attack from using an infinite message.
 4. If using network sockets as streams, a timeout should be set to stop
    denial of service attacks.
-5. If using *malloc()* support, some method of limiting memory use should be
+
-   employed. This can be done by defining custom *pb_realloc()* function.
-   Nanopb will properly detect and handle failed memory allocations.

examples/simple/Makefile

@@ -10,7 +10,6 @@ CSRC  = simple.c                   # The main program
 CSRC += simple.pb.c                # The compiled protocol definition
 CSRC += $(NANOPB_DIR)/pb_encode.c  # The nanopb encoder
 CSRC += $(NANOPB_DIR)/pb_decode.c  # The nanopb decoder
-CSRC += $(NANOPB_DIR)/pb_common.c  # The nanopb common parts
 
 # Build rule for the main program
 simple: $(CSRC)

extra/FindNanopb.cmake

@@ -182,8 +182,8 @@ mark_as_advanced(NANOPB_INCLUDE_DIRS)
 # Find nanopb source files
 set(NANOPB_SRCS)
 set(NANOPB_HDRS)
-list(APPEND _nanopb_srcs pb_decode.c pb_encode.c pb_common.c)
+list(APPEND _nanopb_srcs pb_decode.c pb_encode.c)
-list(APPEND _nanopb_hdrs pb_decode.h pb_encode.h pb_common.h pb.h)
+list(APPEND _nanopb_hdrs pb_decode.h pb_encode.h pb.h)
 
 foreach(FIL ${_nanopb_srcs})
   find_file(${FIL}__nano_pb_file NAMES ${FIL} PATHS ${NANOPB_SRC_ROOT_FOLDER} ${NANOPB_INCLUDE_DIRS})

extra/nanopb.mk

@@ -5,7 +5,7 @@
 NANOPB_DIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST)))../)
 
 # Files for the nanopb core
-NANOPB_CORE = $(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_common.c
+NANOPB_CORE = $(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_decode.c
 
 # Check if we are running on Windows
 ifdef windir

generator/nanopb_generator.py

@@ -1,7 +1,7 @@
 #!/usr/bin/python
 
 '''Generate header file for nanopb from a ProtoBuf FileDescriptorSet.'''
-nanopb_version = "nanopb-0.3.1"
+nanopb_version = "nanopb-0.2.9.2"
 
 import sys
 
@@ -261,7 +261,7 @@ class Field:
         result = ''
         if self.allocation == 'POINTER':
             if self.rules == 'REPEATED':
-                result += '    pb_size_t ' + self.name + '_count;\n'
+                result += '    size_t ' + self.name + '_count;\n'
             
             if self.pbtype == 'MESSAGE':
                 # Use struct definition, so recursive submessages are possible
@@ -277,14 +277,17 @@ class Field:
             if self.rules == 'OPTIONAL' and self.allocation == 'STATIC':
                 result += '    bool has_' + self.name + ';\n'
             elif self.rules == 'REPEATED' and self.allocation == 'STATIC':
-                result += '    pb_size_t ' + self.name + '_count;\n'
+                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.pbtype == 'BYTES' and self.allocation == 'STATIC':
-            result = 'typedef PB_BYTES_ARRAY_T(%d) %s;\n' % (self.max_size, self.ctype)
+            result = 'typedef struct {\n'
+            result += '    size_t size;\n'
+            result += '    uint8_t bytes[%d];\n' % self.max_size
+            result += '} %s;\n' % self.ctype
         else:
             result = None
         return result
@@ -361,7 +364,7 @@ class Field:
         '''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  = '    PB_FIELD(%3d, ' % self.tag
+        result  = '    PB_FIELD2(%3d, ' % self.tag
         result += '%-8s, ' % self.pbtype
         result += '%s, ' % self.rules
         result += '%-8s, ' % self.allocation
@@ -546,7 +549,7 @@ class Message:
 
     def get_dependencies(self):
         '''Get list of type names that this structure refers to.'''
-        return [str(field.ctype) for field in self.fields if field.allocation == 'STATIC']
+        return [str(field.ctype) for field in self.fields]
     
     def __str__(self):
         result = 'typedef struct _%s {\n' % self.name
@@ -770,8 +773,8 @@ def generate_header(dependencies, headername, enums, messages, extensions, optio
         yield '/* Generated by %s at %s. */\n\n' % (nanopb_version, time.asctime())
     
     symbol = make_identifier(headername)
-    yield '#ifndef PB_%s_INCLUDED\n' % symbol
+    yield '#ifndef _PB_%s_\n' % symbol
-    yield '#define PB_%s_INCLUDED\n' % symbol
+    yield '#define _PB_%s_\n' % symbol
     try:
         yield options.libformat % ('pb.h')
     except TypeError:
@@ -784,11 +787,6 @@ def generate_header(dependencies, headername, enums, messages, extensions, optio
         yield options.genformat % (noext + options.extension + '.h')
         yield '\n'
 
-    yield '#if PB_PROTO_HEADER_VERSION != 30\n'
-    yield '#error Regenerate this file with the current version of nanopb generator.\n'
-    yield '#endif\n'
-    yield '\n'
-
     yield '#ifdef __cplusplus\n'
     yield 'extern "C" {\n'
     yield '#endif\n\n'
@@ -861,11 +859,6 @@ def generate_source(headername, enums, messages, extensions, options):
     yield options.genformat % (headername)
     yield '\n'
     
-    yield '#if PB_PROTO_HEADER_VERSION != 30\n'
-    yield '#error Regenerate this file with the current version of nanopb generator.\n'
-    yield '#endif\n'
-    yield '\n'
-    
     for msg in messages:
         yield msg.default_decl(False)
     
@@ -920,7 +913,7 @@ def generate_source(headername, enums, messages, extensions, options):
                 yield ' * numbers or field sizes that are larger than what can fit in 8 or 16 bit\n'
                 yield ' * field descriptors.\n'
                 yield ' */\n'
-                yield 'PB_STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
+                yield 'STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
             yield '#endif\n\n'
         
         if worst < 65536:
@@ -937,7 +930,7 @@ def generate_source(headername, enums, messages, extensions, options):
                 yield ' * numbers or field sizes that are larger than what can fit in the default\n'
                 yield ' * 8 bit descriptors.\n'
                 yield ' */\n'
-                yield 'PB_STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
+                yield 'STATIC_ASSERT((%s), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_%s)\n'%(assertion,msgs)
             yield '#endif\n\n'
     
     # Add check for sizeof(double)
@@ -953,7 +946,7 @@ def generate_source(headername, enums, messages, extensions, options):
         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 'PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)\n'
+        yield 'STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)\n'
     
     yield '\n'
 

pb.h

@@ -2,8 +2,8 @@
  * stuff. For the high-level interface, see pb_encode.h and pb_decode.h.
  */
 
-#ifndef PB_H_INCLUDED
+#ifndef _PB_H_
-#define PB_H_INCLUDED
+#define _PB_H_
 
 /*****************************************************************
  * Nanopb compilation time options. You can change these here by *
@@ -46,7 +46,7 @@
 
 /* Version of the nanopb library. Just in case you want to check it in
  * your own program. */
-#define NANOPB_VERSION nanopb-0.3.1
+#define NANOPB_VERSION nanopb-0.2.9.2
 
 /* Include all the system headers needed by nanopb. You will need the
  * definitions of the following:
@@ -98,27 +98,23 @@
 #endif
 
 /* Handly macro for suppressing unreferenced-parameter compiler warnings. */
-#ifndef PB_UNUSED
+#ifndef UNUSED
-#define PB_UNUSED(x) (void)(x)
+#define UNUSED(x) (void)(x)
 #endif
 
 /* Compile-time assertion, used for checking compatible compilation options.
- * If this does not work properly on your compiler, use
+ * If this does not work properly on your compiler, use #define STATIC_ASSERT
- * #define PB_NO_STATIC_ASSERT to disable it.
+ * to disable it.
  *
  * But before doing that, check carefully the error message / place where it
  * comes from to see if the error has a real cause. Unfortunately the error
  * message is not always very clear to read, but you can see the reason better
- * in the place where the PB_STATIC_ASSERT macro was called.
+ * in the place where the STATIC_ASSERT macro was called.
  */
-#ifndef PB_NO_STATIC_ASSERT
+#ifndef STATIC_ASSERT
-#ifndef PB_STATIC_ASSERT
+#define STATIC_ASSERT(COND,MSG) typedef char STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1];
-#define PB_STATIC_ASSERT(COND,MSG) typedef char PB_STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1];
+#define STATIC_ASSERT_MSG(MSG, LINE, COUNTER) STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
-#define PB_STATIC_ASSERT_MSG(MSG, LINE, COUNTER) PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
+#define STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) static_assertion_##MSG##LINE##COUNTER
-#define PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) pb_static_assertion_##MSG##LINE##COUNTER
-#endif
-#else
-#define PB_STATIC_ASSERT(COND,MSG)
 #endif
 
 /* Number of required fields to keep track of. */
@@ -191,15 +187,12 @@ typedef uint8_t pb_type_t;
  * and array counts.
  */
 #if defined(PB_FIELD_32BIT)
-#define PB_SIZE_MAX ((uint32_t)-1)
     typedef uint32_t pb_size_t;
     typedef int32_t pb_ssize_t;
 #elif defined(PB_FIELD_16BIT)
-#define PB_SIZE_MAX ((uint16_t)-1)
     typedef uint16_t pb_size_t;
     typedef int16_t pb_ssize_t;
 #else
-#define PB_SIZE_MAX ((uint8_t)-1)
     typedef uint8_t pb_size_t;
     typedef int8_t pb_ssize_t;
 #endif
@@ -213,8 +206,8 @@ typedef uint8_t pb_type_t;
  * PB_FIELD_32BIT.
  */
 PB_PACKED_STRUCT_START
-typedef struct pb_field_s pb_field_t;
+typedef struct _pb_field_t pb_field_t;
-struct pb_field_s {
+struct _pb_field_t {
     pb_size_t tag;
     pb_type_t type;
     pb_size_t data_offset; /* Offset of field data, relative to previous field. */
@@ -235,27 +228,27 @@ PB_PACKED_STRUCT_END
  * If you get errors here, it probably means that your stdint.h is not
  * correct for your platform.
  */
-PB_STATIC_ASSERT(sizeof(int8_t) == 1, INT8_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int8_t) == 1, INT8_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint8_t) == 1, UINT8_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint8_t) == 1, UINT8_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(int16_t) == 2, INT16_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int16_t) == 2, INT16_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint16_t) == 2, UINT16_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint16_t) == 2, UINT16_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(int32_t) == 4, INT32_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int32_t) == 4, INT32_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint32_t) == 4, UINT32_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint32_t) == 4, UINT32_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(int64_t) == 8, INT64_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(int64_t) == 8, INT64_T_WRONG_SIZE)
-PB_STATIC_ASSERT(sizeof(uint64_t) == 8, UINT64_T_WRONG_SIZE)
+STATIC_ASSERT(sizeof(uint64_t) == 8, UINT64_T_WRONG_SIZE)
 
 /* This structure is used for 'bytes' arrays.
  * It has the number of bytes in the beginning, and after that an array.
  * Note that actual structs used will have a different length of bytes array.
  */
-#define PB_BYTES_ARRAY_T(n) struct { pb_size_t size; uint8_t bytes[n]; }
+#define PB_BYTES_ARRAY_T(n) struct { size_t size; uint8_t bytes[n]; }
 #define PB_BYTES_ARRAY_T_ALLOCSIZE(n) ((size_t)n + offsetof(pb_bytes_array_t, bytes))
 
-struct pb_bytes_array_s {
+struct _pb_bytes_array_t {
-    pb_size_t size;
+    size_t size;
     uint8_t bytes[1];
 };
-typedef struct pb_bytes_array_s pb_bytes_array_t;
+typedef struct _pb_bytes_array_t pb_bytes_array_t;
 
 /* This structure is used for giving the callback function.
  * It is stored in the message structure and filled in by the method that
@@ -275,10 +268,10 @@ typedef struct pb_bytes_array_s pb_bytes_array_t;
  *
  * The callback can be null if you want to skip a field.
  */
-typedef struct pb_istream_s pb_istream_t;
+typedef struct _pb_istream_t pb_istream_t;
-typedef struct pb_ostream_s pb_ostream_t;
+typedef struct _pb_ostream_t pb_ostream_t;
-typedef struct pb_callback_s pb_callback_t;
+typedef struct _pb_callback_t pb_callback_t;
-struct pb_callback_s {
+struct _pb_callback_t {
 #ifdef PB_OLD_CALLBACK_STYLE
     /* Deprecated since nanopb-0.2.1 */
     union {
@@ -311,9 +304,9 @@ typedef enum {
  * 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_s pb_extension_type_t;
+typedef struct _pb_extension_type_t pb_extension_type_t;
-typedef struct pb_extension_s pb_extension_t;
+typedef struct _pb_extension_t pb_extension_t;
-struct pb_extension_type_s {
+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.
@@ -335,7 +328,7 @@ struct pb_extension_type_s {
     const void *arg;
 };
 
-struct pb_extension_s {
+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;
@@ -365,9 +358,6 @@ struct pb_extension_s {
 #   endif
 #endif
 
-/* This is used to inform about need to regenerate .pb.h/.pb.c files. */
-#define PB_PROTO_HEADER_VERSION 30
-
 /* These macros are used to declare pb_field_t's in the constant array. */
 /* Size of a structure member, in bytes. */
 #define pb_membersize(st, m) (sizeof ((st*)0)->m)
@@ -479,15 +469,26 @@ struct pb_extension_s {
  *                 SINT32, SINT64, STRING, UINT32, UINT64 or EXTENSION
  * - Field rules:  REQUIRED, OPTIONAL or REPEATED
  * - Allocation:   STATIC or CALLBACK
- * - Placement: FIRST or OTHER, depending on if this is the first field in structure.
  * - Message name
  * - Field name
  * - Previous field name (or field name again for first field)
  * - Pointer to default value or submsg fields.
  */
 
-#define PB_FIELD(tag, type, rules, allocation, placement, message, field, prevfield, ptr) \
+#define PB_FIELD(tag, type, rules, allocation, message, field, prevfield, ptr) \
-        PB_ ## rules ## _ ## allocation(tag, message, field, \
+    PB_ ## rules ## _ ## allocation(tag, message, field, \
+        PB_DATAOFFSET_CHOOSE(message, field, prevfield), \
+        PB_LTYPE_MAP_ ## type, ptr)
+
+/* This is a new version of the macro used by nanopb generator from
+ * version 0.2.3 onwards. It avoids the use of a ternary expression in
+ * the initialization, which confused some compilers.
+ *
+ * - Placement: FIRST or OTHER, depending on if this is the first field in structure.
+ *
+ */
+#define PB_FIELD2(tag, type, rules, allocation, placement, message, field, prevfield, ptr) \
+    PB_ ## rules ## _ ## allocation(tag, message, field, \
         PB_DATAOFFSET_ ## placement(message, field, prevfield), \
         PB_LTYPE_MAP_ ## type, ptr)
 
@@ -501,7 +502,7 @@ struct pb_extension_s {
 #ifdef PB_NO_ERRMSG
 #define PB_RETURN_ERROR(stream,msg) \
     do {\
-        PB_UNUSED(stream); \
+        UNUSED(stream); \
         return false; \
     } while(0)
 #define PB_GET_ERROR(stream) "(errmsg disabled)"

pb_common.c

@@ -1,90 +0,0 @@
-/* pb_common.c: Common support functions for pb_encode.c and pb_decode.c.
- *
- * 2014 Petteri Aimonen <jpa@kapsi.fi>
- */
-
-#include "pb_common.h"
-
-bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_field_t *fields, void *dest_struct)
-{
-    iter->start = fields;
-    iter->pos = fields;
-    iter->required_field_index = 0;
-    iter->dest_struct = dest_struct;
-    iter->pData = (char*)dest_struct + iter->pos->data_offset;
-    iter->pSize = (char*)iter->pData + iter->pos->size_offset;
-    
-    return (iter->pos->tag != 0);
-}
-
-bool pb_field_iter_next(pb_field_iter_t *iter)
-{
-    const pb_field_t *prev_field = iter->pos;
-
-    if (prev_field->tag == 0)
-    {
-        /* Handle empty message types, where the first field is already the terminator.
-         * In other cases, the iter->pos never points to the terminator. */
-        return false;
-    }
-    
-    iter->pos++;
-    
-    if (iter->pos->tag == 0)
-    {
-        /* Wrapped back to beginning, reinitialize */
-        (void)pb_field_iter_begin(iter, iter->start, iter->dest_struct);
-        return false;
-    }
-    else
-    {
-        /* Increment the pointers based on previous field size */
-        size_t prev_size = prev_field->data_size;
-    
-        if (PB_ATYPE(prev_field->type) == PB_ATYPE_STATIC &&
-            PB_HTYPE(prev_field->type) == PB_HTYPE_REPEATED)
-        {
-            /* In static arrays, the data_size tells the size of a single entry and
-             * array_size is the number of entries */
-            prev_size *= prev_field->array_size;
-        }
-        else if (PB_ATYPE(prev_field->type) == PB_ATYPE_POINTER)
-        {
-            /* Pointer fields always have a constant size in the main structure.
-             * The data_size only applies to the dynamically allocated area. */
-            prev_size = sizeof(void*);
-        }
-        
-        if (PB_HTYPE(prev_field->type) == PB_HTYPE_REQUIRED)
-        {
-            /* Count the required fields, in order to check their presence in the
-             * decoder. */
-            iter->required_field_index++;
-        }
-    
-        iter->pData = (char*)iter->pData + prev_size + iter->pos->data_offset;
-        iter->pSize = (char*)iter->pData + iter->pos->size_offset;
-        return true;
-    }
-}
-
-bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag)
-{
-    const pb_field_t *start = iter->pos;
-    
-    do {
-        if (iter->pos->tag == tag &&
-            PB_LTYPE(iter->pos->type) != PB_LTYPE_EXTENSION)
-        {
-            /* Found the wanted field */
-            return true;
-        }
-        
-        (void)pb_field_iter_next(iter);
-    } while (iter->pos != start);
-    
-    /* Searched all the way back to start, and found nothing. */
-    return false;
-}
-
-

pb_common.h

@@ -1,42 +0,0 @@
-/* pb_common.h: Common support functions for pb_encode.c and pb_decode.c.
- * These functions are rarely needed by applications directly.
- */
-
-#ifndef PB_COMMON_H_INCLUDED
-#define PB_COMMON_H_INCLUDED
-
-#include "pb.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Iterator for pb_field_t list */
-struct pb_field_iter_s {
-    const pb_field_t *start;       /* Start of the pb_field_t array */
-    const pb_field_t *pos;         /* Current position of the iterator */
-    unsigned required_field_index; /* Zero-based index that counts only the required fields */
-    void *dest_struct;             /* Pointer to start of the structure */
-    void *pData;                   /* Pointer to current field value */
-    void *pSize;                   /* Pointer to count/has field */
-};
-typedef struct pb_field_iter_s pb_field_iter_t;
-
-/* Initialize the field iterator structure to beginning.
- * Returns false if the message type is empty. */
-bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_field_t *fields, void *dest_struct);
-
-/* Advance the iterator to the next field.
- * Returns false when the iterator wraps back to the first field. */
-bool pb_field_iter_next(pb_field_iter_t *iter);
-
-/* Advance the iterator until it points at a field with the given tag.
- * Returns false if no such field exists. */
-bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif
-

pb_decode.c

@@ -15,23 +15,37 @@
 
 #include "pb.h"
 #include "pb_decode.h"
-#include "pb_common.h"
 
 /**************************************
  * Declarations internal to this file *
  **************************************/
 
+/* Iterator for pb_field_t list */
+typedef struct {
+    const pb_field_t *start; /* Start of the pb_field_t array */
+    const pb_field_t *pos; /* Current position of the iterator */
+    unsigned field_index; /* Zero-based index of the field. */
+    unsigned required_field_index; /* Zero-based index that counts only the required fields */
+    void *dest_struct; /* Pointer to the destination structure to decode to */
+    void *pData; /* Pointer where to store current field value */
+    void *pSize; /* Pointer where to store the size of current array field */
+} pb_field_iterator_t;
+
 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
 
 static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count);
 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest);
 static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire_type, uint8_t *buf, size_t *size);
-static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
+static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct);
-static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
+static bool pb_field_next(pb_field_iterator_t *iter);
-static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter);
+static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag);
+static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
+static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
+static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
+static void iter_from_extension(pb_field_iterator_t *iter, pb_extension_t *extension);
 static bool checkreturn default_extension_decoder(pb_istream_t *stream, pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type);
-static bool checkreturn decode_extension(pb_istream_t *stream, uint32_t tag, pb_wire_type_t wire_type, pb_field_iter_t *iter);
+static bool checkreturn decode_extension(pb_istream_t *stream, uint32_t tag, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
-static bool checkreturn find_extension_field(pb_field_iter_t *iter);
+static bool checkreturn find_extension_field(pb_field_iterator_t *iter);
 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct);
 static bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest);
 static bool checkreturn pb_dec_uvarint(pb_istream_t *stream, const pb_field_t *field, void *dest);
@@ -46,7 +60,7 @@ static bool checkreturn pb_skip_string(pb_istream_t *stream);
 
 #ifdef PB_ENABLE_MALLOC
 static bool checkreturn allocate_field(pb_istream_t *stream, void *pData, size_t data_size, size_t array_size);
-static void pb_release_single_field(const pb_field_iter_t *iter);
+static void pb_release_single_field(const pb_field_iterator_t *iter);
 #endif
 
 /* --- Function pointers to field decoders ---
@@ -330,11 +344,75 @@ void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 #endif
 }
 
+static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
+{
+    iter->start = iter->pos = fields;
+    iter->field_index = 0;
+    iter->required_field_index = 0;
+    iter->pData = (char*)dest_struct + iter->pos->data_offset;
+    iter->pSize = (char*)iter->pData + iter->pos->size_offset;
+    iter->dest_struct = dest_struct;
+}
+
+static bool pb_field_next(pb_field_iterator_t *iter)
+{
+    bool notwrapped = true;
+    size_t prev_size = iter->pos->data_size;
+    
+    if (PB_ATYPE(iter->pos->type) == PB_ATYPE_STATIC &&
+        PB_HTYPE(iter->pos->type) == PB_HTYPE_REPEATED)
+    {
+        prev_size *= iter->pos->array_size;
+    }
+    else if (PB_ATYPE(iter->pos->type) == PB_ATYPE_POINTER)
+    {
+        prev_size = sizeof(void*);
+    }
+    
+    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++;
+    
+    iter->pos++;
+    iter->field_index++;
+    if (iter->pos->tag == 0)
+    {
+        iter->pos = iter->start;
+        iter->field_index = 0;
+        iter->required_field_index = 0;
+        iter->pData = iter->dest_struct;
+        prev_size = 0;
+        notwrapped = false;
+    }
+    
+    iter->pData = (char*)iter->pData + prev_size + iter->pos->data_offset;
+    iter->pSize = (char*)iter->pData + iter->pos->size_offset;
+    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;
+        }
+        (void)pb_field_next(iter);
+    } while (iter->field_index != start);
+    
+    return false;
+}
+
 /*************************
  * Decode a single field *
  *************************/
 
-static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
     pb_type_t type;
     pb_decoder_t func;
@@ -357,7 +435,7 @@ static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t
             {
                 /* Packed array */
                 bool status = true;
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                 pb_istream_t substream;
                 if (!pb_make_string_substream(stream, &substream))
                     return false;
@@ -382,7 +460,7 @@ static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t
             else
             {
                 /* Repeated field */
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                 void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size);
                 if (*size >= iter->pos->array_size)
                     PB_RETURN_ERROR(stream, "array overflow");
@@ -437,7 +515,7 @@ static bool checkreturn allocate_field(pb_istream_t *stream, void *pData, size_t
 }
 
 /* Clear a newly allocated item in case it contains a pointer, or is a submessage. */
-static void initialize_pointer_field(void *pItem, pb_field_iter_t *iter)
+static void initialize_pointer_field(void *pItem, pb_field_iterator_t *iter)
 {
     if (PB_LTYPE(iter->pos->type) == PB_LTYPE_STRING ||
         PB_LTYPE(iter->pos->type) == PB_LTYPE_BYTES)
@@ -451,11 +529,11 @@ static void initialize_pointer_field(void *pItem, pb_field_iter_t *iter)
 }
 #endif
 
-static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
 #ifndef PB_ENABLE_MALLOC
-    PB_UNUSED(wire_type);
+    UNUSED(wire_type);
-    PB_UNUSED(iter);
+    UNUSED(iter);
     PB_RETURN_ERROR(stream, "no malloc support");
 #else
     pb_type_t type;
@@ -495,7 +573,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
             {
                 /* Packed array, multiple items come in at once. */
                 bool status = true;
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                 size_t allocated_size = *size;
                 void *pItem;
                 pb_istream_t substream;
@@ -505,7 +583,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
                 
                 while (substream.bytes_left)
                 {
-                    if ((size_t)*size + 1 > allocated_size)
+                    if (*size + 1 > allocated_size)
                     {
                         /* Allocate more storage. This tries to guess the
                          * number of remaining entries. Round the division
@@ -527,16 +605,6 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
                         status = false;
                         break;
                     }
-                    
-                    if (*size == PB_SIZE_MAX)
-                    {
-#ifndef PB_NO_ERRMSG
-                        stream->errmsg = "too many array entries";
-#endif
-                        status = false;
-                        break;
-                    }
-                    
                     (*size)++;
                 }
                 pb_close_string_substream(stream, &substream);
@@ -546,12 +614,9 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
             else
             {
                 /* Normal repeated field, i.e. only one item at a time. */
-                pb_size_t *size = (pb_size_t*)iter->pSize;
+                size_t *size = (size_t*)iter->pSize;
                 void *pItem;
                 
-                if (*size == PB_SIZE_MAX)
-                    PB_RETURN_ERROR(stream, "too many array entries");
-                
                 (*size)++;
                 if (!allocate_field(stream, iter->pData, iter->pos->data_size, *size))
                     return false;
@@ -567,7 +632,7 @@ static bool checkreturn decode_pointer_field(pb_istream_t *stream, pb_wire_type_
 #endif
 }
 
-static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
     pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
     
@@ -614,7 +679,7 @@ static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type
     }
 }
 
-static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter)
+static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
     switch (PB_ATYPE(iter->pos->type))
     {
@@ -632,31 +697,38 @@ static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_t
     }
 }
 
+static void iter_from_extension(pb_field_iterator_t *iter, pb_extension_t *extension)
+{
+    const pb_field_t *field = (const pb_field_t*)extension->type->arg;
+    
+    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 = &extension->found;
+}
+
 /* Default handler for extension fields. Expects a pb_field_t structure
  * in extension->type->arg. */
 static bool checkreturn default_extension_decoder(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_iter_t iter;
+    pb_field_iterator_t iter;
     
     if (field->tag != tag)
         return true;
     
-    /* Fake a field iterator for the extension field.
+    iter_from_extension(&iter, extension);
-     * It is not actually safe to advance this iterator, but decode_field
-     * will not even try to. */
-    (void)pb_field_iter_begin(&iter, field, extension->dest);
-    iter.pData = extension->dest;
-    iter.pSize = &extension->found;
-    
     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_iter_t *iter)
+    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;
@@ -681,15 +753,15 @@ static bool checkreturn decode_extension(pb_istream_t *stream,
 /* 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_iter_t *iter)
+static bool checkreturn find_extension_field(pb_field_iterator_t *iter)
 {
-    const pb_field_t *start = iter->pos;
+    unsigned start = iter->field_index;
     
     do {
         if (PB_LTYPE(iter->pos->type) == PB_LTYPE_EXTENSION)
             return true;
-        (void)pb_field_iter_next(iter);
+        (void)pb_field_next(iter);
-    } while (iter->pos != start);
+    } while (iter->field_index != start);
     
     return false;
 }
@@ -697,15 +769,17 @@ static bool checkreturn find_extension_field(pb_field_iter_t *iter)
 /* Initialize message fields to default values, recursively */
 static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
 {
-    pb_field_iter_t iter;
+    pb_field_iterator_t iter;
-
+    pb_field_init(&iter, fields, dest_struct);
-    if (!pb_field_iter_begin(&iter, fields, dest_struct))
-        return; /* Empty message type */
     
     do
     {
         pb_type_t type;
         type = iter.pos->type;
+    
+        /* Avoid crash on empty message types (zero fields) */
+        if (iter.pos->tag == 0)
+            continue;
         
         if (PB_ATYPE(type) == PB_ATYPE_STATIC)
         {
@@ -718,7 +792,7 @@ static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_str
             else if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
             {
                 /* Set array count to 0, no need to initialize contents. */
-                *(pb_size_t*)iter.pSize = 0;
+                *(size_t*)iter.pSize = 0;
                 continue;
             }
             
@@ -746,14 +820,14 @@ static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_str
             /* Initialize array count to 0. */
             if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
             {
-                *(pb_size_t*)iter.pSize = 0;
+                *(size_t*)iter.pSize = 0;
             }
         }
         else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK)
         {
             /* Don't overwrite callback */
         }
-    } while (pb_field_iter_next(&iter));
+    } while (pb_field_next(&iter));
 }
 
 /*********************
@@ -764,11 +838,9 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
 {
     uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0, 0, 0, 0, 0, 0, 0, 0};
     uint32_t extension_range_start = 0;
-    pb_field_iter_t iter;
+    pb_field_iterator_t iter;
     
-    /* Return value ignored, as empty message types will be correctly handled by
+    pb_field_init(&iter, fields, dest_struct);
-     * pb_field_iter_find() anyway. */
-    (void)pb_field_iter_begin(&iter, fields, dest_struct);
     
     while (stream->bytes_left)
     {
@@ -784,7 +856,7 @@ bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[
                 return false;
         }
         
-        if (!pb_field_iter_find(&iter, tag))
+        if (!pb_field_find(&iter, tag))
         {
             /* No match found, check if it matches an extension. */
             if (tag >= extension_range_start)
@@ -837,7 +909,7 @@ 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_iter_next(&iter));
+        } while (pb_field_next(&iter));
         
         /* Fixup if last field was also required. */
         if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED && iter.pos->tag != 0)
@@ -886,11 +958,52 @@ bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *
 }
 
 #ifdef PB_ENABLE_MALLOC
-static void pb_release_single_field(const pb_field_iter_t *iter)
+static void pb_release_single_field(const pb_field_iterator_t *iter)
 {
     pb_type_t type;
     type = iter->pos->type;
 
+    /* Release anything contained inside an extension or submsg.
+     * This has to be done even if the submsg itself is statically
+     * allocated. */
+    if (PB_LTYPE(type) == PB_LTYPE_EXTENSION)
+    {
+        /* Release fields from all extensions in the linked list */
+        pb_extension_t *ext = *(pb_extension_t**)iter->pData;
+        while (ext != NULL)
+        {
+            pb_field_iterator_t ext_iter;
+            iter_from_extension(&ext_iter, ext);
+            pb_release_single_field(&ext_iter);
+            ext = ext->next;
+        }
+    }
+    else if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE)
+    {
+        /* Release fields in submessage or submsg array */
+        void *pItem = iter->pData;
+        pb_size_t count = 1;
+        
+        if (PB_ATYPE(type) == PB_ATYPE_POINTER)
+        {
+            pItem = *(void**)iter->pData;
+        }
+        
+        if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
+        {
+            count = *(pb_size_t*)iter->pSize;
+        }
+        
+        if (pItem)
+        {
+            while (count--)
+            {
+                pb_release((const pb_field_t*)iter->pos->ptr, pItem);
+                pItem = (uint8_t*)pItem + iter->pos->data_size;
+            }
+        }
+    }
+    
     if (PB_ATYPE(type) == PB_ATYPE_POINTER)
     {
         if (PB_HTYPE(type) == PB_HTYPE_REPEATED &&
@@ -905,28 +1018,12 @@ static void pb_release_single_field(const pb_field_iter_t *iter)
                 pb_free(*pItem);
                 *pItem++ = NULL;
             }
-            *(pb_size_t*)iter->pSize = 0;
         }
-        else if (PB_LTYPE(type) == PB_LTYPE_SUBMESSAGE)
+        
+        if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
         {
-            /* Release fields in submessages */
+            /* We are going to release the array, so set the size to 0 */
-            void *pItem = *(void**)iter->pData;
+            *(pb_size_t*)iter->pSize = 0;
-            if (pItem)
-            {
-                pb_size_t count = 1;
-                
-                if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
-                {
-                    count = *(pb_size_t*)iter->pSize;
-                    *(pb_size_t*)iter->pSize = 0;
-                }
-                
-                while (count--)
-                {
-                    pb_release((const pb_field_t*)iter->pos->ptr, pItem);
-                    pItem = (uint8_t*)pItem + iter->pos->data_size;
-                }
-            }
         }
         
         /* Release main item */
@@ -937,15 +1034,16 @@ static void pb_release_single_field(const pb_field_iter_t *iter)
 
 void pb_release(const pb_field_t fields[], void *dest_struct)
 {
-    pb_field_iter_t iter;
+    pb_field_iterator_t iter;
-    
+    pb_field_init(&iter, fields, dest_struct);
-    if (!pb_field_iter_begin(&iter, fields, dest_struct))
+
+    if (iter.pos->tag == 0)
         return; /* Empty message type */
     
     do
     {
         pb_release_single_field(&iter);
-    } while (pb_field_iter_next(&iter));
+    } while (pb_field_next(&iter));
 }
 #endif
 
@@ -1059,13 +1157,13 @@ static bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *f
 
 static bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
     return pb_decode_fixed32(stream, dest);
 }
 
 static bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
     return pb_decode_fixed64(stream, dest);
 }
 
@@ -1078,9 +1176,6 @@ static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *fie
     if (!pb_decode_varint32(stream, &size))
         return false;
     
-    if (size > PB_SIZE_MAX)
-        PB_RETURN_ERROR(stream, "bytes overflow");
-    
     alloc_size = PB_BYTES_ARRAY_T_ALLOCSIZE(size);
     if (size > alloc_size)
         PB_RETURN_ERROR(stream, "size too large");
@@ -1101,8 +1196,9 @@ static bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *fie
             PB_RETURN_ERROR(stream, "bytes overflow");
         bdest = (pb_bytes_array_t*)dest;
     }
+    
+    bdest->size = size;
 
-    bdest->size = (pb_size_t)size;
     return pb_read(stream, bdest->bytes, size);
 }
 

pb_decode.h

@@ -3,8 +3,8 @@
  * field descriptions created by nanopb_generator.py.
  */
 
-#ifndef PB_DECODE_H_INCLUDED
+#ifndef _PB_DECODE_H_
-#define PB_DECODE_H_INCLUDED
+#define _PB_DECODE_H_
 
 #include "pb.h"
 
@@ -25,7 +25,7 @@ extern "C" {
  *    is different than from the main stream. Don't use bytes_left to compute
  *    any pointers.
  */
-struct pb_istream_s
+struct _pb_istream_t
 {
 #ifdef PB_BUFFER_ONLY
     /* Callback pointer is not used in buffer-only configuration.

pb_encode.c

@@ -5,7 +5,6 @@
 
 #include "pb.h"
 #include "pb_encode.h"
-#include "pb_common.h"
 
 /* Use the GCC warn_unused_result attribute to check that all return values
  * are propagated correctly. On other compilers and gcc before 3.4.0 just
@@ -246,7 +245,7 @@ static bool checkreturn encode_basic_field(pb_ostream_t *stream,
             break;
         
         case PB_HTYPE_REPEATED:
-            if (!encode_array(stream, field, pData, *(const pb_size_t*)pSize, func))
+            if (!encode_array(stream, field, pData, *(const size_t*)pSize, func))
                 return false;
             break;
         
@@ -311,7 +310,7 @@ 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;
-    PB_UNUSED(field);
+    UNUSED(field);
     
     while (extension)
     {
@@ -334,38 +333,42 @@ static bool checkreturn encode_extension_field(pb_ostream_t *stream,
  * Encode all fields *
  *********************/
 
-static void *remove_const(const void *p)
-{
-    /* Note: this casts away const, in order to use the common field iterator
-     * logic for both encoding and decoding. */
-    union {
-        void *p1;
-        const void *p2;
-    } t;
-    t.p2 = p;
-    return t.p1;
-}
-
 bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 {
-    pb_field_iter_t iter;
+    const pb_field_t *field = fields;
-    if (!pb_field_iter_begin(&iter, fields, remove_const(src_struct)))
+    const void *pData = src_struct;
-        return true; /* Empty message type */
+    size_t prev_size = 0;
     
-    do {
+    while (field->tag != 0)
-        if (PB_LTYPE(iter.pos->type) == PB_LTYPE_EXTENSION)
+    {
+        pData = (const char*)pData + prev_size + field->data_offset;
+        if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
+            prev_size = sizeof(const void*);
+        else
+            prev_size = field->data_size;
+        
+        /* Special case for static arrays */
+        if (PB_ATYPE(field->type) == PB_ATYPE_STATIC &&
+            PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
+        {
+            prev_size *= field->array_size;
+        }
+        
+        if (PB_LTYPE(field->type) == PB_LTYPE_EXTENSION)
         {
             /* Special case for the extension field placeholder */
-            if (!encode_extension_field(stream, iter.pos, iter.pData))
+            if (!encode_extension_field(stream, field, pData))
                 return false;
         }
         else
         {
             /* Regular field */
-            if (!encode_field(stream, iter.pos, iter.pData))
+            if (!encode_field(stream, field, pData))
                 return false;
         }
-    } while (pb_field_iter_next(&iter));
+    
+        field++;
+    }
     
     return true;
 }
@@ -599,13 +602,13 @@ static bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *f
 
 static bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
     return pb_encode_fixed64(stream, src);
 }
 
 static bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
-    PB_UNUSED(field);
+    UNUSED(field);
     return pb_encode_fixed32(stream, src);
 }
 
@@ -630,6 +633,7 @@ static bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *fie
 
 static 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 loop */
     size_t size = 0;
     size_t max_size = field->data_size;
     const char *p = (const char*)src;
@@ -643,7 +647,6 @@ static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *fi
     }
     else
     {
-        /* strnlen() is not always available, so just use a loop */
         while (size < max_size && *p != '\0')
         {
             size++;

pb_encode.h

@@ -3,8 +3,8 @@
  * field descriptions created by nanopb_generator.py.
  */
 
-#ifndef PB_ENCODE_H_INCLUDED
+#ifndef _PB_ENCODE_H_
-#define PB_ENCODE_H_INCLUDED
+#define _PB_ENCODE_H_
 
 #include "pb.h"
 
@@ -24,7 +24,7 @@ extern "C" {
  * 4) Substreams will modify max_size and bytes_written. Don't use them
  *    to calculate any pointers.
  */
-struct pb_ostream_s
+struct _pb_ostream_t
 {
 #ifdef PB_BUFFER_ONLY
     /* Callback pointer is not used in buffer-only configuration.

tests/Makefile

@@ -10,12 +10,12 @@ coverage:
 	# LCOV does not like the newer gcov format
 	scons CC=gcc-4.6 CXX=gcc-4.6
 
+	# We are only interested in pb_encode.o and pb_decode.o
+	find build -name '*.gcda' -and \! \( -name '*pb_encode*' -or -name '*pb_decode*' \) -exec rm '{}' \;
+
 	# Collect the data
 	mkdir build/coverage
 	lcov --base-directory . --directory build/ --gcov-tool gcov-4.6 -c -o build/coverage/nanopb.info
 
-	# Remove the test code from results
-	lcov -r build/coverage/nanopb.info '*tests*' -o build/coverage/nanopb.info
-
 	# Generate HTML
 	genhtml -o build/coverage build/coverage/nanopb.info

tests/SConstruct

@@ -136,12 +136,18 @@ elif 'g++' in env['CXX'] or 'gcc' in env['CXX']:
     env.Append(CXXFLAGS = '-g -Wall -Werror -Wextra -Wno-missing-field-initializers')
 elif 'cl' in env['CXX']:
     env.Append(CXXFLAGS = '/Zi /W2 /WX')
-    
+
 # Now include the SConscript files from all subdirectories
 import os.path
 env['VARIANT_DIR'] = 'build'
 env['BUILD'] = '#' + env['VARIANT_DIR']
 env['COMMON'] = '#' + env['VARIANT_DIR'] + '/common'
+
+# Include common/SConscript first to make sure its exports are available
+# to other SConscripts.
+SConscript("common/SConscript", exports = 'env', variant_dir = env['VARIANT_DIR'] + '/common')
+
 for subdir in Glob('*/SConscript') + Glob('regression/*/SConscript'):
+    if str(subdir).startswith("common"): continue
     SConscript(subdir, exports = 'env', variant_dir = env['VARIANT_DIR'] + '/' + os.path.dirname(str(subdir)))
 

tests/alltypes/SConscript

@@ -4,8 +4,8 @@
 Import("env")
 
 env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
-dec = env.Program(["decode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+dec = env.Program(["decode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_decode.o"])
 
 # Test the round-trip from nanopb encoder to nanopb decoder
 env.RunTest(enc)

tests/alltypes_callback/SConscript

@@ -6,8 +6,8 @@ c = Copy("$TARGET", "$SOURCE")
 env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
 
 env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
-dec = env.Program(["decode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+dec = env.Program(["decode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_decode.o"])
 
 refdec = "$BUILD/alltypes/decode_alltypes$PROGSUFFIX"
 

tests/alltypes_pointer/SConscript

@@ -1,31 +1,20 @@
 # Encode the AllTypes message using pointers for all fields, and verify the
 # output against the normal AllTypes test case.
 
-Import("env")
+Import("env", "malloc_env")
-
-# We need our own pb_decode.o for the malloc support
-env = env.Clone()
-env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1});
-
-# Disable libmudflap, because it will confuse valgrind
-# and other memory leak detection tools.
-if '-fmudflap' in env["CCFLAGS"]:
-    env["CCFLAGS"].remove("-fmudflap")
-    env["LINKFLAGS"].remove("-fmudflap")
-    env["LIBS"].remove("mudflap")
-
-strict = env.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_with_malloc.o", "$NANOPB/pb_common.c")
 
 c = Copy("$TARGET", "$SOURCE")
 env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
 
 env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes_pointer.c", "alltypes.pb.c", "pb_encode_with_malloc.o", "pb_common_with_malloc.o"])
+enc = malloc_env.Program(["encode_alltypes_pointer.c",
-dec = env.Program(["decode_alltypes_pointer.c", "alltypes.pb.c", "pb_decode_with_malloc.o", "pb_common_with_malloc.o"])
+                          "alltypes.pb.c",
+                          "$COMMON/pb_encode_with_malloc.o",
+                          "$COMMON/malloc_wrappers.o"])
+dec = malloc_env.Program(["decode_alltypes_pointer.c",
+                          "alltypes.pb.c",
+                          "$COMMON/pb_decode_with_malloc.o",
+                          "$COMMON/malloc_wrappers.o"])
 
 # Encode and compare results to non-pointer alltypes test case
 env.RunTest(enc)

tests/backwards_compatibility/SConscript

@@ -3,8 +3,8 @@
 
 Import("env")
 
-enc = env.Program(["encode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_encode.o"])
-dec = env.Program(["decode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+dec = env.Program(["decode_legacy.c", "alltypes_legacy.c", "$COMMON/pb_decode.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_legacy.output"])

tests/backwards_compatibility/alltypes_legacy.c

@@ -1,37 +1,27 @@
 /* Automatically generated nanopb constant definitions */
-/* Generated by nanopb-0.3.0-dev at Tue Aug 19 17:53:24 2014. */
+/* Generated by 0.2.0-dev at Sun Feb 17 00:09:53 2013. */
+/* This is a file generated using nanopb-0.2.0-dev.
+ * It is used as a part of test suite in order to detect any
+ * incompatible changes made to the generator in future versions.
+ */
 
 #include "alltypes_legacy.h"
 
-#if PB_PROTO_HEADER_VERSION != 30
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
 const char SubMessage_substuff1_default[16] = "1";
 const int32_t SubMessage_substuff2_default = 2;
-const uint32_t SubMessage_substuff3_default = 3u;
+const uint32_t SubMessage_substuff3_default = 3;
-const int32_t Limits_int32_min_default = 2147483647;
-const int32_t Limits_int32_max_default = -2147483647;
-const uint32_t Limits_uint32_min_default = 4294967295u;
-const uint32_t Limits_uint32_max_default = 0u;
-const int64_t Limits_int64_min_default = 9223372036854775807ll;
-const int64_t Limits_int64_max_default = -9223372036854775807ll;
-const uint64_t Limits_uint64_min_default = 18446744073709551615ull;
-const uint64_t Limits_uint64_max_default = 0ull;
-const HugeEnum Limits_enum_min_default = HugeEnum_Positive;
-const HugeEnum Limits_enum_max_default = HugeEnum_Negative;
 const int32_t AllTypes_opt_int32_default = 4041;
-const int64_t AllTypes_opt_int64_default = 4042ll;
+const int64_t AllTypes_opt_int64_default = 4042;
-const uint32_t AllTypes_opt_uint32_default = 4043u;
+const uint32_t AllTypes_opt_uint32_default = 4043;
-const uint64_t AllTypes_opt_uint64_default = 4044ull;
+const uint64_t AllTypes_opt_uint64_default = 4044;
 const int32_t AllTypes_opt_sint32_default = 4045;
 const int64_t AllTypes_opt_sint64_default = 4046;
 const bool AllTypes_opt_bool_default = false;
-const uint32_t AllTypes_opt_fixed32_default = 4048u;
+const uint32_t AllTypes_opt_fixed32_default = 4048;
 const int32_t AllTypes_opt_sfixed32_default = 4049;
 const float AllTypes_opt_float_default = 4050;
-const uint64_t AllTypes_opt_fixed64_default = 4051ull;
+const uint64_t AllTypes_opt_fixed64_default = 4051;
-const int64_t AllTypes_opt_sfixed64_default = 4052ll;
+const int64_t AllTypes_opt_sfixed64_default = 4052;
 const double AllTypes_opt_double_default = 4053;
 const char AllTypes_opt_string_default[16] = "4054";
 const AllTypes_opt_bytes_t AllTypes_opt_bytes_default = {4, {0x34,0x30,0x35,0x35}};
@@ -39,115 +29,65 @@ const MyEnum AllTypes_opt_enum_default = MyEnum_Second;
 
 
 const pb_field_t SubMessage_fields[4] = {
-    PB_FIELD(  1, STRING  , REQUIRED, STATIC  , FIRST, SubMessage, substuff1, substuff1, &SubMessage_substuff1_default),
+    PB_FIELD(  1, STRING  , REQUIRED, STATIC, SubMessage, substuff1, substuff1, &SubMessage_substuff1_default),
-    PB_FIELD(  2, INT32   , REQUIRED, STATIC  , OTHER, SubMessage, substuff2, substuff1, &SubMessage_substuff2_default),
+    PB_FIELD(  2, INT32   , REQUIRED, STATIC, SubMessage, substuff2, substuff1, &SubMessage_substuff2_default),
-    PB_FIELD(  3, FIXED32 , OPTIONAL, STATIC  , OTHER, SubMessage, substuff3, substuff2, &SubMessage_substuff3_default),
+    PB_FIELD(  3, FIXED32 , OPTIONAL, STATIC, SubMessage, substuff3, substuff2, &SubMessage_substuff3_default),
     PB_LAST_FIELD
 };
 
-const pb_field_t EmptyMessage_fields[1] = {
+const pb_field_t AllTypes_fields[53] = {
+    PB_FIELD(  1, INT32   , REQUIRED, STATIC, AllTypes, req_int32, req_int32, 0),
+    PB_FIELD(  2, INT64   , REQUIRED, STATIC, AllTypes, req_int64, req_int32, 0),
+    PB_FIELD(  3, UINT32  , REQUIRED, STATIC, AllTypes, req_uint32, req_int64, 0),
+    PB_FIELD(  4, UINT64  , REQUIRED, STATIC, AllTypes, req_uint64, req_uint32, 0),
+    PB_FIELD(  5, SINT32  , REQUIRED, STATIC, AllTypes, req_sint32, req_uint64, 0),
+    PB_FIELD(  6, SINT64  , REQUIRED, STATIC, AllTypes, req_sint64, req_sint32, 0),
+    PB_FIELD(  7, BOOL    , REQUIRED, STATIC, AllTypes, req_bool, req_sint64, 0),
+    PB_FIELD(  8, FIXED32 , REQUIRED, STATIC, AllTypes, req_fixed32, req_bool, 0),
+    PB_FIELD(  9, SFIXED32, REQUIRED, STATIC, AllTypes, req_sfixed32, req_fixed32, 0),
+    PB_FIELD( 10, FLOAT   , REQUIRED, STATIC, AllTypes, req_float, req_sfixed32, 0),
+    PB_FIELD( 11, FIXED64 , REQUIRED, STATIC, AllTypes, req_fixed64, req_float, 0),
+    PB_FIELD( 12, SFIXED64, REQUIRED, STATIC, AllTypes, req_sfixed64, req_fixed64, 0),
+    PB_FIELD( 13, DOUBLE  , REQUIRED, STATIC, AllTypes, req_double, req_sfixed64, 0),
+    PB_FIELD( 14, STRING  , REQUIRED, STATIC, AllTypes, req_string, req_double, 0),
+    PB_FIELD( 15, BYTES   , REQUIRED, STATIC, AllTypes, req_bytes, req_string, 0),
+    PB_FIELD( 16, MESSAGE , REQUIRED, STATIC, AllTypes, req_submsg, req_bytes, &SubMessage_fields),
+    PB_FIELD( 17, ENUM    , REQUIRED, STATIC, AllTypes, req_enum, req_submsg, 0),
+    PB_FIELD( 21, INT32   , REPEATED, STATIC, AllTypes, rep_int32, req_enum, 0),
+    PB_FIELD( 22, INT64   , REPEATED, STATIC, AllTypes, rep_int64, rep_int32, 0),
+    PB_FIELD( 23, UINT32  , REPEATED, STATIC, AllTypes, rep_uint32, rep_int64, 0),
+    PB_FIELD( 24, UINT64  , REPEATED, STATIC, AllTypes, rep_uint64, rep_uint32, 0),
+    PB_FIELD( 25, SINT32  , REPEATED, STATIC, AllTypes, rep_sint32, rep_uint64, 0),
+    PB_FIELD( 26, SINT64  , REPEATED, STATIC, AllTypes, rep_sint64, rep_sint32, 0),
+    PB_FIELD( 27, BOOL    , REPEATED, STATIC, AllTypes, rep_bool, rep_sint64, 0),
+    PB_FIELD( 28, FIXED32 , REPEATED, STATIC, AllTypes, rep_fixed32, rep_bool, 0),
+    PB_FIELD( 29, SFIXED32, REPEATED, STATIC, AllTypes, rep_sfixed32, rep_fixed32, 0),
+    PB_FIELD( 30, FLOAT   , REPEATED, STATIC, AllTypes, rep_float, rep_sfixed32, 0),
+    PB_FIELD( 31, FIXED64 , REPEATED, STATIC, AllTypes, rep_fixed64, rep_float, 0),
+    PB_FIELD( 32, SFIXED64, REPEATED, STATIC, AllTypes, rep_sfixed64, rep_fixed64, 0),
+    PB_FIELD( 33, DOUBLE  , REPEATED, STATIC, AllTypes, rep_double, rep_sfixed64, 0),
+    PB_FIELD( 34, STRING  , REPEATED, STATIC, AllTypes, rep_string, rep_double, 0),
+    PB_FIELD( 35, BYTES   , REPEATED, STATIC, AllTypes, rep_bytes, rep_string, 0),
+    PB_FIELD( 36, MESSAGE , REPEATED, STATIC, AllTypes, rep_submsg, rep_bytes, &SubMessage_fields),
+    PB_FIELD( 37, ENUM    , REPEATED, STATIC, AllTypes, rep_enum, rep_submsg, 0),
+    PB_FIELD( 41, INT32   , OPTIONAL, STATIC, AllTypes, opt_int32, rep_enum, &AllTypes_opt_int32_default),
+    PB_FIELD( 42, INT64   , OPTIONAL, STATIC, AllTypes, opt_int64, opt_int32, &AllTypes_opt_int64_default),
+    PB_FIELD( 43, UINT32  , OPTIONAL, STATIC, AllTypes, opt_uint32, opt_int64, &AllTypes_opt_uint32_default),
+    PB_FIELD( 44, UINT64  , OPTIONAL, STATIC, AllTypes, opt_uint64, opt_uint32, &AllTypes_opt_uint64_default),
+    PB_FIELD( 45, SINT32  , OPTIONAL, STATIC, AllTypes, opt_sint32, opt_uint64, &AllTypes_opt_sint32_default),
+    PB_FIELD( 46, SINT64  , OPTIONAL, STATIC, AllTypes, opt_sint64, opt_sint32, &AllTypes_opt_sint64_default),
+    PB_FIELD( 47, BOOL    , OPTIONAL, STATIC, AllTypes, opt_bool, opt_sint64, &AllTypes_opt_bool_default),
+    PB_FIELD( 48, FIXED32 , OPTIONAL, STATIC, AllTypes, opt_fixed32, opt_bool, &AllTypes_opt_fixed32_default),
+    PB_FIELD( 49, SFIXED32, OPTIONAL, STATIC, AllTypes, opt_sfixed32, opt_fixed32, &AllTypes_opt_sfixed32_default),
+    PB_FIELD( 50, FLOAT   , OPTIONAL, STATIC, AllTypes, opt_float, opt_sfixed32, &AllTypes_opt_float_default),
+    PB_FIELD( 51, FIXED64 , OPTIONAL, STATIC, AllTypes, opt_fixed64, opt_float, &AllTypes_opt_fixed64_default),
+    PB_FIELD( 52, SFIXED64, OPTIONAL, STATIC, AllTypes, opt_sfixed64, opt_fixed64, &AllTypes_opt_sfixed64_default),
+    PB_FIELD( 53, DOUBLE  , OPTIONAL, STATIC, AllTypes, opt_double, opt_sfixed64, &AllTypes_opt_double_default),
+    PB_FIELD( 54, STRING  , OPTIONAL, STATIC, AllTypes, opt_string, opt_double, &AllTypes_opt_string_default),
+    PB_FIELD( 55, BYTES   , OPTIONAL, STATIC, AllTypes, opt_bytes, opt_string, &AllTypes_opt_bytes_default),
+    PB_FIELD( 56, MESSAGE , OPTIONAL, STATIC, AllTypes, opt_submsg, opt_bytes, &SubMessage_fields),
+    PB_FIELD( 57, ENUM    , OPTIONAL, STATIC, AllTypes, opt_enum, opt_submsg, &AllTypes_opt_enum_default),
+    PB_FIELD( 99, INT32   , REQUIRED, STATIC, AllTypes, end, opt_enum, 0),
     PB_LAST_FIELD
 };
 
-const pb_field_t Limits_fields[11] = {
-    PB_FIELD(  1, INT32   , REQUIRED, STATIC  , FIRST, Limits, int32_min, int32_min, &Limits_int32_min_default),
-    PB_FIELD(  2, INT32   , REQUIRED, STATIC  , OTHER, Limits, int32_max, int32_min, &Limits_int32_max_default),
-    PB_FIELD(  3, UINT32  , REQUIRED, STATIC  , OTHER, Limits, uint32_min, int32_max, &Limits_uint32_min_default),
-    PB_FIELD(  4, UINT32  , REQUIRED, STATIC  , OTHER, Limits, uint32_max, uint32_min, &Limits_uint32_max_default),
-    PB_FIELD(  5, INT64   , REQUIRED, STATIC  , OTHER, Limits, int64_min, uint32_max, &Limits_int64_min_default),
-    PB_FIELD(  6, INT64   , REQUIRED, STATIC  , OTHER, Limits, int64_max, int64_min, &Limits_int64_max_default),
-    PB_FIELD(  7, UINT64  , REQUIRED, STATIC  , OTHER, Limits, uint64_min, int64_max, &Limits_uint64_min_default),
-    PB_FIELD(  8, UINT64  , REQUIRED, STATIC  , OTHER, Limits, uint64_max, uint64_min, &Limits_uint64_max_default),
-    PB_FIELD(  9, ENUM    , REQUIRED, STATIC  , OTHER, Limits, enum_min, uint64_max, &Limits_enum_min_default),
-    PB_FIELD( 10, ENUM    , REQUIRED, STATIC  , OTHER, Limits, enum_max, enum_min, &Limits_enum_max_default),
-    PB_LAST_FIELD
-};
-
-const pb_field_t AllTypes_fields[54] = {
-    PB_FIELD(  1, INT32   , REQUIRED, STATIC  , FIRST, AllTypes, req_int32, req_int32, 0),
-    PB_FIELD(  2, INT64   , REQUIRED, STATIC  , OTHER, AllTypes, req_int64, req_int32, 0),
-    PB_FIELD(  3, UINT32  , REQUIRED, STATIC  , OTHER, AllTypes, req_uint32, req_int64, 0),
-    PB_FIELD(  4, UINT64  , REQUIRED, STATIC  , OTHER, AllTypes, req_uint64, req_uint32, 0),
-    PB_FIELD(  5, SINT32  , REQUIRED, STATIC  , OTHER, AllTypes, req_sint32, req_uint64, 0),
-    PB_FIELD(  6, SINT64  , REQUIRED, STATIC  , OTHER, AllTypes, req_sint64, req_sint32, 0),
-    PB_FIELD(  7, BOOL    , REQUIRED, STATIC  , OTHER, AllTypes, req_bool, req_sint64, 0),
-    PB_FIELD(  8, FIXED32 , REQUIRED, STATIC  , OTHER, AllTypes, req_fixed32, req_bool, 0),
-    PB_FIELD(  9, SFIXED32, REQUIRED, STATIC  , OTHER, AllTypes, req_sfixed32, req_fixed32, 0),
-    PB_FIELD( 10, FLOAT   , REQUIRED, STATIC  , OTHER, AllTypes, req_float, req_sfixed32, 0),
-    PB_FIELD( 11, FIXED64 , REQUIRED, STATIC  , OTHER, AllTypes, req_fixed64, req_float, 0),
-    PB_FIELD( 12, SFIXED64, REQUIRED, STATIC  , OTHER, AllTypes, req_sfixed64, req_fixed64, 0),
-    PB_FIELD( 13, DOUBLE  , REQUIRED, STATIC  , OTHER, AllTypes, req_double, req_sfixed64, 0),
-    PB_FIELD( 14, STRING  , REQUIRED, STATIC  , OTHER, AllTypes, req_string, req_double, 0),
-    PB_FIELD( 15, BYTES   , REQUIRED, STATIC  , OTHER, AllTypes, req_bytes, req_string, 0),
-    PB_FIELD( 16, MESSAGE , REQUIRED, STATIC  , OTHER, AllTypes, req_submsg, req_bytes, &SubMessage_fields),
-    PB_FIELD( 17, ENUM    , REQUIRED, STATIC  , OTHER, AllTypes, req_enum, req_submsg, 0),
-    PB_FIELD( 21, INT32   , REPEATED, STATIC  , OTHER, AllTypes, rep_int32, req_enum, 0),
-    PB_FIELD( 22, INT64   , REPEATED, STATIC  , OTHER, AllTypes, rep_int64, rep_int32, 0),
-    PB_FIELD( 23, UINT32  , REPEATED, STATIC  , OTHER, AllTypes, rep_uint32, rep_int64, 0),
-    PB_FIELD( 24, UINT64  , REPEATED, STATIC  , OTHER, AllTypes, rep_uint64, rep_uint32, 0),
-    PB_FIELD( 25, SINT32  , REPEATED, STATIC  , OTHER, AllTypes, rep_sint32, rep_uint64, 0),
-    PB_FIELD( 26, SINT64  , REPEATED, STATIC  , OTHER, AllTypes, rep_sint64, rep_sint32, 0),
-    PB_FIELD( 27, BOOL    , REPEATED, STATIC  , OTHER, AllTypes, rep_bool, rep_sint64, 0),
-    PB_FIELD( 28, FIXED32 , REPEATED, STATIC  , OTHER, AllTypes, rep_fixed32, rep_bool, 0),
-    PB_FIELD( 29, SFIXED32, REPEATED, STATIC  , OTHER, AllTypes, rep_sfixed32, rep_fixed32, 0),
-    PB_FIELD( 30, FLOAT   , REPEATED, STATIC  , OTHER, AllTypes, rep_float, rep_sfixed32, 0),
-    PB_FIELD( 31, FIXED64 , REPEATED, STATIC  , OTHER, AllTypes, rep_fixed64, rep_float, 0),
-    PB_FIELD( 32, SFIXED64, REPEATED, STATIC  , OTHER, AllTypes, rep_sfixed64, rep_fixed64, 0),
-    PB_FIELD( 33, DOUBLE  , REPEATED, STATIC  , OTHER, AllTypes, rep_double, rep_sfixed64, 0),
-    PB_FIELD( 34, STRING  , REPEATED, STATIC  , OTHER, AllTypes, rep_string, rep_double, 0),
-    PB_FIELD( 35, BYTES   , REPEATED, STATIC  , OTHER, AllTypes, rep_bytes, rep_string, 0),
-    PB_FIELD( 36, MESSAGE , REPEATED, STATIC  , OTHER, AllTypes, rep_submsg, rep_bytes, &SubMessage_fields),
-    PB_FIELD( 37, ENUM    , REPEATED, STATIC  , OTHER, AllTypes, rep_enum, rep_submsg, 0),
-    PB_FIELD( 41, INT32   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_int32, rep_enum, &AllTypes_opt_int32_default),
-    PB_FIELD( 42, INT64   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_int64, opt_int32, &AllTypes_opt_int64_default),
-    PB_FIELD( 43, UINT32  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_uint32, opt_int64, &AllTypes_opt_uint32_default),
-    PB_FIELD( 44, UINT64  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_uint64, opt_uint32, &AllTypes_opt_uint64_default),
-    PB_FIELD( 45, SINT32  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_sint32, opt_uint64, &AllTypes_opt_sint32_default),
-    PB_FIELD( 46, SINT64  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_sint64, opt_sint32, &AllTypes_opt_sint64_default),
-    PB_FIELD( 47, BOOL    , OPTIONAL, STATIC  , OTHER, AllTypes, opt_bool, opt_sint64, &AllTypes_opt_bool_default),
-    PB_FIELD( 48, FIXED32 , OPTIONAL, STATIC  , OTHER, AllTypes, opt_fixed32, opt_bool, &AllTypes_opt_fixed32_default),
-    PB_FIELD( 49, SFIXED32, OPTIONAL, STATIC  , OTHER, AllTypes, opt_sfixed32, opt_fixed32, &AllTypes_opt_sfixed32_default),
-    PB_FIELD( 50, FLOAT   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_float, opt_sfixed32, &AllTypes_opt_float_default),
-    PB_FIELD( 51, FIXED64 , OPTIONAL, STATIC  , OTHER, AllTypes, opt_fixed64, opt_float, &AllTypes_opt_fixed64_default),
-    PB_FIELD( 52, SFIXED64, OPTIONAL, STATIC  , OTHER, AllTypes, opt_sfixed64, opt_fixed64, &AllTypes_opt_sfixed64_default),
-    PB_FIELD( 53, DOUBLE  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_double, opt_sfixed64, &AllTypes_opt_double_default),
-    PB_FIELD( 54, STRING  , OPTIONAL, STATIC  , OTHER, AllTypes, opt_string, opt_double, &AllTypes_opt_string_default),
-    PB_FIELD( 55, BYTES   , OPTIONAL, STATIC  , OTHER, AllTypes, opt_bytes, opt_string, &AllTypes_opt_bytes_default),
-    PB_FIELD( 56, MESSAGE , OPTIONAL, STATIC  , OTHER, AllTypes, opt_submsg, opt_bytes, &SubMessage_fields),
-    PB_FIELD( 57, ENUM    , OPTIONAL, STATIC  , OTHER, AllTypes, opt_enum, opt_submsg, &AllTypes_opt_enum_default),
-    PB_FIELD( 99, INT32   , REQUIRED, STATIC  , OTHER, AllTypes, end, opt_enum, 0),
-    PB_FIELD(200, EXTENSION, OPTIONAL, CALLBACK, OTHER, AllTypes, extensions, end, 0),
-    PB_LAST_FIELD
-};
-
-
-/* Check that field information fits in pb_field_t */
-#if !defined(PB_FIELD_32BIT)
-/* If you get an error here, it means that you need to define PB_FIELD_32BIT
- * compile-time option. You can do that in pb.h or on compiler command line.
- * 
- * The reason you need to do this is that some of your messages contain tag
- * numbers or field sizes that are larger than what can fit in 8 or 16 bit
- * field descriptors.
- */
-PB_STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 65536 && pb_membersize(AllTypes, rep_submsg[0]) < 65536 && pb_membersize(AllTypes, opt_submsg) < 65536), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_SubMessage_EmptyMessage_Limits_AllTypes)
-#endif
-
-#if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
-/* If you get an error here, it means that you need to define PB_FIELD_16BIT
- * compile-time option. You can do that in pb.h or on compiler command line.
- * 
- * The reason you need to do this is that some of your messages contain tag
- * numbers or field sizes that are larger than what can fit in the default
- * 8 bit descriptors.
- */
-PB_STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 256 && pb_membersize(AllTypes, rep_submsg[0]) < 256 && pb_membersize(AllTypes, opt_submsg) < 256), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_SubMessage_EmptyMessage_Limits_AllTypes)
-#endif
-
-
-/* On some platforms (such as AVR), double is really float.
- * These are not directly supported by nanopb, but see example_avr_double.
- * To get rid of this error, remove any double fields from your .proto.
- */
-PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
-

tests/backwards_compatibility/alltypes_legacy.h

@@ -1,24 +1,18 @@
 /* Automatically generated nanopb header */
-/* Generated by nanopb-0.3.0-dev at Tue Aug 19 17:53:24 2014. */
+/* This is a file generated using nanopb-0.2.0-dev.
+ * It is used as a part of test suite in order to detect any
+ * incompatible changes made to the generator in future versions.
+ */
 
-#ifndef PB_ALLTYPES_LEGACY_H_INCLUDED
+#ifndef _PB_ALLTYPES_PB_H_
-#define PB_ALLTYPES_LEGACY_H_INCLUDED
+#define _PB_ALLTYPES_PB_H_
 #include <pb.h>
 
-#if PB_PROTO_HEADER_VERSION != 30
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* Enum definitions */
-typedef enum _HugeEnum {
-    HugeEnum_Negative = -2147483647,
-    HugeEnum_Positive = 2147483647
-} HugeEnum;
-
 typedef enum _MyEnum {
     MyEnum_Zero = 0,
     MyEnum_First = 1,
@@ -27,23 +21,6 @@ typedef enum _MyEnum {
 } MyEnum;
 
 /* Struct definitions */
-typedef struct _EmptyMessage {
-    uint8_t dummy_field;
-} EmptyMessage;
-
-typedef struct _Limits {
-    int32_t int32_min;
-    int32_t int32_max;
-    uint32_t uint32_min;
-    uint32_t uint32_max;
-    int64_t int64_min;
-    int64_t int64_max;
-    uint64_t uint64_min;
-    uint64_t uint64_max;
-    HugeEnum enum_min;
-    HugeEnum enum_max;
-} Limits;
-
 typedef struct _SubMessage {
     char substuff1[16];
     int32_t substuff2;
@@ -51,11 +28,20 @@ typedef struct _SubMessage {
     uint32_t substuff3;
 } SubMessage;
 
-typedef PB_BYTES_ARRAY_T(16) AllTypes_req_bytes_t;
+typedef struct {
+    size_t size;
+    uint8_t bytes[16];
+} AllTypes_req_bytes_t;
 
-typedef PB_BYTES_ARRAY_T(16) AllTypes_rep_bytes_t;
+typedef struct {
+    size_t size;
+    uint8_t bytes[16];
+} AllTypes_rep_bytes_t;
 
-typedef PB_BYTES_ARRAY_T(16) AllTypes_opt_bytes_t;
+typedef struct {
+    size_t size;
+    uint8_t bytes[16];
+} AllTypes_opt_bytes_t;
 
 typedef struct _AllTypes {
     int32_t req_int32;
@@ -75,39 +61,39 @@ typedef struct _AllTypes {
     AllTypes_req_bytes_t req_bytes;
     SubMessage req_submsg;
     MyEnum req_enum;
-    pb_size_t rep_int32_count;
+    size_t rep_int32_count;
     int32_t rep_int32[5];
-    pb_size_t rep_int64_count;
+    size_t rep_int64_count;
     int64_t rep_int64[5];
-    pb_size_t rep_uint32_count;
+    size_t rep_uint32_count;
     uint32_t rep_uint32[5];
-    pb_size_t rep_uint64_count;
+    size_t rep_uint64_count;
     uint64_t rep_uint64[5];
-    pb_size_t rep_sint32_count;
+    size_t rep_sint32_count;
     int32_t rep_sint32[5];
-    pb_size_t rep_sint64_count;
+    size_t rep_sint64_count;
     int64_t rep_sint64[5];
-    pb_size_t rep_bool_count;
+    size_t rep_bool_count;
     bool rep_bool[5];
-    pb_size_t rep_fixed32_count;
+    size_t rep_fixed32_count;
     uint32_t rep_fixed32[5];
-    pb_size_t rep_sfixed32_count;
+    size_t rep_sfixed32_count;
     int32_t rep_sfixed32[5];
-    pb_size_t rep_float_count;
+    size_t rep_float_count;
     float rep_float[5];
-    pb_size_t rep_fixed64_count;
+    size_t rep_fixed64_count;
     uint64_t rep_fixed64[5];
-    pb_size_t rep_sfixed64_count;
+    size_t rep_sfixed64_count;
     int64_t rep_sfixed64[5];
-    pb_size_t rep_double_count;
+    size_t rep_double_count;
     double rep_double[5];
-    pb_size_t rep_string_count;
+    size_t rep_string_count;
     char rep_string[5][16];
-    pb_size_t rep_bytes_count;
+    size_t rep_bytes_count;
     AllTypes_rep_bytes_t rep_bytes[5];
-    pb_size_t rep_submsg_count;
+    size_t rep_submsg_count;
     SubMessage rep_submsg[5];
-    pb_size_t rep_enum_count;
+    size_t rep_enum_count;
     MyEnum rep_enum[5];
     bool has_opt_int32;
     int32_t opt_int32;
@@ -144,23 +130,12 @@ typedef struct _AllTypes {
     bool has_opt_enum;
     MyEnum opt_enum;
     int32_t end;
-    pb_extension_t *extensions;
 } AllTypes;
 
 /* Default values for struct fields */
 extern const char SubMessage_substuff1_default[16];
 extern const int32_t SubMessage_substuff2_default;
 extern const uint32_t SubMessage_substuff3_default;
-extern const int32_t Limits_int32_min_default;
-extern const int32_t Limits_int32_max_default;
-extern const uint32_t Limits_uint32_min_default;
-extern const uint32_t Limits_uint32_max_default;
-extern const int64_t Limits_int64_min_default;
-extern const int64_t Limits_int64_max_default;
-extern const uint64_t Limits_uint64_min_default;
-extern const uint64_t Limits_uint64_max_default;
-extern const HugeEnum Limits_enum_min_default;
-extern const HugeEnum Limits_enum_max_default;
 extern const int32_t AllTypes_opt_int32_default;
 extern const int64_t AllTypes_opt_int64_default;
 extern const uint32_t AllTypes_opt_uint32_default;
@@ -178,94 +153,23 @@ extern const char AllTypes_opt_string_default[16];
 extern const AllTypes_opt_bytes_t AllTypes_opt_bytes_default;
 extern const MyEnum AllTypes_opt_enum_default;
 
-/* Initializer values for message structs */
-#define SubMessage_init_default                  {"1", 2, false, 3u}
-#define EmptyMessage_init_default                {0}
-#define Limits_init_default                      {2147483647, -2147483647, 4294967295u, 0u, 9223372036854775807ll, -9223372036854775807ll, 18446744073709551615ull, 0ull, HugeEnum_Positive, HugeEnum_Negative}
-#define AllTypes_init_default                    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", {0, {0}}, SubMessage_init_default, (MyEnum)0, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {"", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0, {SubMessage_init_default, SubMessage_init_default, SubMessage_init_default, SubMessage_init_default, SubMessage_init_default}, 0, {(MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0}, false, 4041, false, 4042ll, false, 4043u, false, 4044ull, false, 4045, false, 4046, false, false, false, 4048u, false, 4049, false, 4050, false, 4051ull, false, 4052ll, false, 4053, false, "4054", false, {4, {0x34,0x30,0x35,0x35}}, false, SubMessage_init_default, false, MyEnum_Second, 0, NULL}
-#define SubMessage_init_zero                     {"", 0, false, 0}
-#define EmptyMessage_init_zero                   {0}
-#define Limits_init_zero                         {0, 0, 0, 0, 0, 0, 0, 0, (HugeEnum)0, (HugeEnum)0}
-#define AllTypes_init_zero                       {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", {0, {0}}, SubMessage_init_zero, (MyEnum)0, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {0, 0, 0, 0, 0}, 0, {"", "", "", "", ""}, 0, {{0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}}, 0, {SubMessage_init_zero, SubMessage_init_zero, SubMessage_init_zero, SubMessage_init_zero, SubMessage_init_zero}, 0, {(MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0, (MyEnum)0}, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, "", false, {0, {0}}, false, SubMessage_init_zero, false, (MyEnum)0, 0, NULL}
-
-/* Field tags (for use in manual encoding/decoding) */
-#define Limits_int32_min_tag                     1
-#define Limits_int32_max_tag                     2
-#define Limits_uint32_min_tag                    3
-#define Limits_uint32_max_tag                    4
-#define Limits_int64_min_tag                     5
-#define Limits_int64_max_tag                     6
-#define Limits_uint64_min_tag                    7
-#define Limits_uint64_max_tag                    8
-#define Limits_enum_min_tag                      9
-#define Limits_enum_max_tag                      10
-#define SubMessage_substuff1_tag                 1
-#define SubMessage_substuff2_tag                 2
-#define SubMessage_substuff3_tag                 3
-#define AllTypes_req_int32_tag                   1
-#define AllTypes_req_int64_tag                   2
-#define AllTypes_req_uint32_tag                  3
-#define AllTypes_req_uint64_tag                  4
-#define AllTypes_req_sint32_tag                  5
-#define AllTypes_req_sint64_tag                  6
-#define AllTypes_req_bool_tag                    7
-#define AllTypes_req_fixed32_tag                 8
-#define AllTypes_req_sfixed32_tag                9
-#define AllTypes_req_float_tag                   10
-#define AllTypes_req_fixed64_tag                 11
-#define AllTypes_req_sfixed64_tag                12
-#define AllTypes_req_double_tag                  13
-#define AllTypes_req_string_tag                  14
-#define AllTypes_req_bytes_tag                   15
-#define AllTypes_req_submsg_tag                  16
-#define AllTypes_req_enum_tag                    17
-#define AllTypes_rep_int32_tag                   21
-#define AllTypes_rep_int64_tag                   22
-#define AllTypes_rep_uint32_tag                  23
-#define AllTypes_rep_uint64_tag                  24
-#define AllTypes_rep_sint32_tag                  25
-#define AllTypes_rep_sint64_tag                  26
-#define AllTypes_rep_bool_tag                    27
-#define AllTypes_rep_fixed32_tag                 28
-#define AllTypes_rep_sfixed32_tag                29
-#define AllTypes_rep_float_tag                   30
-#define AllTypes_rep_fixed64_tag                 31
-#define AllTypes_rep_sfixed64_tag                32
-#define AllTypes_rep_double_tag                  33
-#define AllTypes_rep_string_tag                  34
-#define AllTypes_rep_bytes_tag                   35
-#define AllTypes_rep_submsg_tag                  36
-#define AllTypes_rep_enum_tag                    37
-#define AllTypes_opt_int32_tag                   41
-#define AllTypes_opt_int64_tag                   42
-#define AllTypes_opt_uint32_tag                  43
-#define AllTypes_opt_uint64_tag                  44
-#define AllTypes_opt_sint32_tag                  45
-#define AllTypes_opt_sint64_tag                  46
-#define AllTypes_opt_bool_tag                    47
-#define AllTypes_opt_fixed32_tag                 48
-#define AllTypes_opt_sfixed32_tag                49
-#define AllTypes_opt_float_tag                   50
-#define AllTypes_opt_fixed64_tag                 51
-#define AllTypes_opt_sfixed64_tag                52
-#define AllTypes_opt_double_tag                  53
-#define AllTypes_opt_string_tag                  54
-#define AllTypes_opt_bytes_tag                   55
-#define AllTypes_opt_submsg_tag                  56
-#define AllTypes_opt_enum_tag                    57
-#define AllTypes_end_tag                         99
-
 /* Struct field encoding specification for nanopb */
 extern const pb_field_t SubMessage_fields[4];
-extern const pb_field_t EmptyMessage_fields[1];
+extern const pb_field_t AllTypes_fields[53];
-extern const pb_field_t Limits_fields[11];
-extern const pb_field_t AllTypes_fields[54];
 
-/* Maximum encoded size of messages (where known) */
+/* Check that field information fits in pb_field_t */
-#define SubMessage_size                          34
+#if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
-#define EmptyMessage_size                        0
+STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 256 && pb_membersize(AllTypes, rep_submsg[0]) < 256 && pb_membersize(AllTypes, opt_submsg) < 256), YOU_MUST_DEFINE_PB_FIELD_16BIT_FOR_MESSAGES_SubMessage_AllTypes)
-#define Limits_size                              90
+#endif
-#define AllTypes_size                            1362
+
+#if !defined(PB_FIELD_32BIT)
+STATIC_ASSERT((pb_membersize(AllTypes, req_submsg) < 65536 && pb_membersize(AllTypes, rep_submsg[0]) < 65536 && pb_membersize(AllTypes, opt_submsg) < 65536), YOU_MUST_DEFINE_PB_FIELD_32BIT_FOR_MESSAGES_SubMessage_AllTypes)
+#endif
+
+/* On some platforms (such as AVR), double is really float.
+ * These are not directly supported by nanopb, but see example_avr_double.
+ */
+STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
 
 #ifdef __cplusplus
 } /* extern "C" */

tests/backwards_compatibility/alltypes_legacy.options

@@ -1,3 +0,0 @@
-* max_size:16
-* max_count:5
-

tests/backwards_compatibility/alltypes_legacy.proto

@@ -1,108 +0,0 @@
-message SubMessage {
-    required string substuff1 = 1 [default = "1"];
-    required int32 substuff2 = 2 [default = 2];
-    optional fixed32 substuff3 = 3 [default = 3];
-}
-
-message EmptyMessage {
-
-}
-
-enum HugeEnum {
-    Negative = -2147483647; /* protoc doesn't accept -2147483648 here */
-    Positive =  2147483647;
-}
-
-message Limits {
-    required int32      int32_min  =  1 [default = 2147483647];
-    required int32      int32_max  =  2 [default = -2147483647];
-    required uint32     uint32_min =  3 [default = 4294967295];
-    required uint32     uint32_max =  4 [default = 0];
-    required int64      int64_min  =  5 [default = 9223372036854775807];
-    required int64      int64_max  =  6 [default = -9223372036854775807];
-    required uint64     uint64_min =  7 [default = 18446744073709551615];
-    required uint64     uint64_max =  8 [default = 0];
-    required HugeEnum   enum_min   =  9 [default = Positive];
-    required HugeEnum   enum_max   = 10 [default = Negative];
-}
-
-enum MyEnum {
-    Zero = 0;
-    First = 1;
-    Second = 2;
-    Truth = 42;
-}
-
-message AllTypes {
-    required int32      req_int32   = 1;
-    required int64      req_int64   = 2;
-    required uint32     req_uint32  = 3;
-    required uint64     req_uint64  = 4;
-    required sint32     req_sint32  = 5;
-    required sint64     req_sint64  = 6;
-    required bool       req_bool    = 7;
-    
-    required fixed32    req_fixed32 = 8;
-    required sfixed32   req_sfixed32= 9;
-    required float      req_float   = 10;
-    
-    required fixed64    req_fixed64 = 11;
-    required sfixed64   req_sfixed64= 12;
-    required double     req_double  = 13;
-    
-    required string     req_string  = 14;
-    required bytes      req_bytes   = 15;
-    required SubMessage req_submsg  = 16;
-    required MyEnum     req_enum    = 17;
-    
-    
-    repeated int32      rep_int32   = 21 [packed = true];
-    repeated int64      rep_int64   = 22 [packed = true];
-    repeated uint32     rep_uint32  = 23 [packed = true];
-    repeated uint64     rep_uint64  = 24 [packed = true];
-    repeated sint32     rep_sint32  = 25 [packed = true];
-    repeated sint64     rep_sint64  = 26 [packed = true];
-    repeated bool       rep_bool    = 27 [packed = true];
-    
-    repeated fixed32    rep_fixed32 = 28 [packed = true];
-    repeated sfixed32   rep_sfixed32= 29 [packed = true];
-    repeated float      rep_float   = 30 [packed = true];
-    
-    repeated fixed64    rep_fixed64 = 31 [packed = true];
-    repeated sfixed64   rep_sfixed64= 32 [packed = true];
-    repeated double     rep_double  = 33 [packed = true];
-    
-    repeated string     rep_string  = 34;
-    repeated bytes      rep_bytes   = 35;
-    repeated SubMessage rep_submsg  = 36;
-    repeated MyEnum     rep_enum    = 37 [packed = true];
-    
-    optional int32      opt_int32   = 41 [default = 4041];
-    optional int64      opt_int64   = 42 [default = 4042];
-    optional uint32     opt_uint32  = 43 [default = 4043];
-    optional uint64     opt_uint64  = 44 [default = 4044];
-    optional sint32     opt_sint32  = 45 [default = 4045];
-    optional sint64     opt_sint64  = 46 [default = 4046];
-    optional bool       opt_bool    = 47 [default = false];
-    
-    optional fixed32    opt_fixed32 = 48 [default = 4048];
-    optional sfixed32   opt_sfixed32= 49 [default = 4049];
-    optional float      opt_float   = 50 [default = 4050];
-    
-    optional fixed64    opt_fixed64 = 51 [default = 4051];
-    optional sfixed64   opt_sfixed64= 52 [default = 4052];
-    optional double     opt_double  = 53 [default = 4053];
-    
-    optional string     opt_string  = 54 [default = "4054"];
-    optional bytes      opt_bytes   = 55 [default = "4055"];
-    optional SubMessage opt_submsg  = 56;
-    optional MyEnum     opt_enum    = 57 [default = Second];
-
-    // 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/basic_buffer/SConscript

@@ -2,8 +2,8 @@
 
 Import("env")
 
-enc = env.Program(["encode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o"])
-dec = env.Program(["decode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+dec = env.Program(["decode_buffer.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_buffer.output"])

tests/basic_stream/SConscript

@@ -2,8 +2,8 @@
 
 Import("env")
 
-enc = env.Program(["encode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_encode.o"])
-dec = env.Program(["decode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+dec = env.Program(["decode_stream.c", "$COMMON/person.pb.c", "$COMMON/pb_decode.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_stream.output"])

tests/buffer_only/SConscript

@@ -18,11 +18,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_bufonly.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_bufonly.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_bufonly.o", "$NANOPB/pb_common.c")
 
 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_bufonly.o", "pb_common_bufonly.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_bufonly.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_bufonly.o", "pb_common_bufonly.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_bufonly.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])

tests/callbacks/SConscript

@@ -3,8 +3,8 @@
 Import("env")
 
 env.NanopbProto("callbacks")
-enc = env.Program(["encode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_encode.o"])
-dec = env.Program(["decode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+dec = env.Program(["decode_callbacks.c", "callbacks.pb.c", "$COMMON/pb_decode.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_callbacks.output"])

tests/common/SConscript

@@ -8,10 +8,39 @@ env.NanopbProto("unittestproto")
 # Protocol definitions for basic_buffer/stream tests
 env.NanopbProto("person")
 
+#--------------------------------------------
 # Binaries of the pb_decode.c and pb_encode.c
 # These are built using more strict warning flags.
 strict = env.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common.o", "$NANOPB/pb_common.c")
+
+#-----------------------------------------------
+# Binaries of pb_decode etc. with malloc support
+# Uses malloc_wrappers.c to count allocations.
+malloc_env = env.Clone()
+malloc_env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1,
+                                'PB_SYSTEM_HEADER': '\\"malloc_wrappers_syshdr.h\\"'})
+malloc_env.Append(CPPPATH = ["$COMMON"])
+
+if 'SYSHDR' in malloc_env:
+    malloc_env.Append(CPPDEFINES = {'PB_OLD_SYSHDR': malloc_env['SYSHDR']})
+
+# Disable libmudflap, because it will confuse valgrind
+# and other memory leak detection tools.
+if '-fmudflap' in env["CCFLAGS"]:
+    malloc_env["CCFLAGS"].remove("-fmudflap")
+    malloc_env["LINKFLAGS"].remove("-fmudflap")
+    malloc_env["LIBS"].remove("mudflap")
+
+malloc_strict = malloc_env.Clone()
+malloc_strict.Append(CFLAGS = malloc_strict['CORECFLAGS'])
+malloc_strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
+malloc_strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
+
+malloc_env.Object("malloc_wrappers.o", "malloc_wrappers.c")
+malloc_env.Depends("$NANOPB/pb.h", ["malloc_wrappers_syshdr.h", "malloc_wrappers.h"])
+
+Export("malloc_env")
+

tests/common/unittestproto.proto

@@ -34,8 +34,3 @@ message CallbackContainer {
 message CallbackContainerContainer {
     required CallbackContainer submsg = 1;
 }
-
-message StringPointerContainer {
-    repeated string rep_str = 1 [(nanopb).type = FT_POINTER];
-}
-

tests/cxx_main_program/SConscript

@@ -11,15 +11,14 @@ env.Append(CPPDEFINES = ['__STDC_LIMIT_MACROS'])
 c = Copy("$TARGET", "$SOURCE")
 env.Command("pb_encode.cxx", "#../pb_encode.c", c)
 env.Command("pb_decode.cxx", "#../pb_decode.c", c)
-env.Command("pb_common.cxx", "#../pb_common.c", c)
 env.Command("alltypes.pb.h", "$BUILD/alltypes/alltypes.pb.h", c)
 env.Command("alltypes.pb.cxx", "$BUILD/alltypes/alltypes.pb.c", c)
 env.Command("encode_alltypes.cxx", "$BUILD/alltypes/encode_alltypes.c", c)
 env.Command("decode_alltypes.cxx", "$BUILD/alltypes/decode_alltypes.c", c)
 
 # Now build and run the test normally.
-enc = env.Program(["encode_alltypes.cxx", "alltypes.pb.cxx", "pb_encode.cxx", "pb_common.cxx"])
+enc = env.Program(["encode_alltypes.cxx", "alltypes.pb.cxx", "pb_encode.cxx"])
-dec = env.Program(["decode_alltypes.cxx", "alltypes.pb.cxx", "pb_decode.cxx", "pb_common.cxx"])
+dec = env.Program(["decode_alltypes.cxx", "alltypes.pb.cxx", "pb_decode.cxx"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])

tests/cyclic_messages/SConscript

@@ -1,11 +0,0 @@
-Import("env")
-
-# Encode cyclic messages with callback fields
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("cyclic_callback.proto", "cyclic.proto", c)
-env.NanopbProto(["cyclic_callback", "cyclic_callback.options"])
-
-enc_callback = env.Program(["encode_cyclic_callback.c", "cyclic_callback.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
-
-

tests/cyclic_messages/cyclic.proto

@@ -1,25 +0,0 @@
-// Test structures with cyclic references.
-// These can only be handled in pointer/callback mode,
-// see associated .options files.
-
-message TreeNode
-{
-    optional int32 leaf = 1;
-    optional TreeNode left = 2;
-    optional TreeNode right = 3;
-}
-
-message Dictionary
-{
-    repeated KeyValuePair dictItem = 1;
-}
-
-message KeyValuePair
-{
-    required string key = 1;
-    optional string stringValue = 2;
-    optional int32 intValue = 3;
-    optional Dictionary dictValue = 4;
-    optional TreeNode treeValue = 5;
-}
-

tests/cyclic_messages/cyclic_callback.options

@@ -1,7 +0,0 @@
-TreeNode.left               type:FT_CALLBACK
-TreeNode.right              type:FT_CALLBACK
-
-Dictionary.data             type:FT_CALLBACK
-KeyValuePair.key            max_size:8
-KeyValuePair.stringValue    max_size:8
-KeyValuePair.treeValue      type:FT_CALLBACK

tests/cyclic_messages/encode_cyclic_callback.c

@@ -1,148 +0,0 @@
-/* This program parses an input string in a format a bit like JSON:
- * {'foobar': 1234, 'xyz': 'abc', 'tree': [[[1, 2], 3], [4, 5]]}
- * and encodes it as protobuf
- *
- * Note: The string parsing here is not in any way intended to be robust
- *       nor safe against buffer overflows. It is just for this test.
- */
-
-#include <pb_encode.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "cyclic_callback.pb.h"
-
-static char *find_end_of_item(char *p)
-{
-    int depth = 0;
-    do {
-        if (*p == '[' || *p == '{') depth++;
-        if (*p == ']' || *p == '}') depth--;
-        p++;
-    } while (depth > 0 || (*p != ',' && *p != '}'));
-    
-    if (*p == '}')
-        return p; /* End of parent dict */
-    
-    p++;
-    while (*p == ' ') p++;
-    return p;
-}
-
-/* Parse a tree in format [[1 2] 3] and encode it directly to protobuf */
-static bool encode_tree(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    TreeNode tree = TreeNode_init_zero;
-    char *p = (char*)*arg;
-    
-    if (*p == '[')
-    {
-        /* This is a tree branch */
-        p++;
-        tree.left.funcs.encode = encode_tree;
-        tree.left.arg = p;
-        
-        p = find_end_of_item(p);
-        tree.right.funcs.encode = encode_tree;
-        tree.right.arg = p;
-    }
-    else
-    {
-        /* This is a leaf node */
-        tree.has_leaf = true;
-        tree.leaf = atoi(p);
-    }
-    
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, TreeNode_fields, &tree);
-}
-
-/* Parse a dictionary in format {'name': value} and encode it directly to protobuf */
-static bool encode_dictionary(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    int textlen;
-    char *p = (char*)*arg;
-    if (*p == '{') p++;
-    while (*p != '}')
-    {
-        KeyValuePair pair = KeyValuePair_init_zero;
-        
-        if (*p != '\'')
-            PB_RETURN_ERROR(stream, "invalid key, missing quote");
-        
-        p++; /* Starting quote of key */
-        textlen = strchr(p, '\'') - p;
-        strncpy(pair.key, p, textlen);
-        pair.key[textlen] = 0;
-        p += textlen + 2;
-        
-        while (*p == ' ') p++;
-        
-        if (*p == '[')
-        {
-            /* Value is a tree */
-            pair.treeValue.funcs.encode = encode_tree;
-            pair.treeValue.arg = p;
-        }
-        else if (*p == '\'')
-        {
-            /* Value is a string */
-            pair.has_stringValue = true;
-            p++;
-            textlen = strchr(p, '\'') - p;
-            strncpy(pair.stringValue, p, textlen);
-            pair.stringValue[textlen] = 0;
-        }
-        else if (*p == '{')
-        {
-            /* Value is a dictionary */
-            pair.has_dictValue = true;
-            pair.dictValue.dictItem.funcs.encode = encode_dictionary;
-            pair.dictValue.dictItem.arg = p;
-        }
-        else
-        {
-            /* Value is integer */
-            pair.has_intValue = true;
-            pair.intValue = atoi(p);
-        }
-        
-        p = find_end_of_item(p);
-        
-        if (!pb_encode_tag_for_field(stream, field))
-            return false;
-        
-        if (!pb_encode_submessage(stream, KeyValuePair_fields, &pair))
-            return false;
-    }
-
-    return true;
-}
-
-
-int main(int argc, char *argv[])
-{
-    uint8_t buffer[256];
-    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
-    Dictionary dict = Dictionary_init_zero;
-    
-    if (argc <= 1)
-    {
-        fprintf(stderr, "Usage: %s \"{'foobar': 1234, ...}\"\n", argv[0]);
-        return 1;
-    }
-    
-    dict.dictItem.funcs.encode = encode_dictionary;
-    dict.dictItem.arg = argv[1];
-
-    if (!pb_encode(&stream, Dictionary_fields, &dict))
-    {
-        fprintf(stderr, "Encoding error: %s\n", PB_GET_ERROR(&stream));
-        return 1;
-    }
-    
-    fwrite(buffer, 1, stream.bytes_written, stdout);
-    return 0;
-}
-
-

tests/decode_unittests/decode_unittests.c

@@ -1,6 +1,5 @@
 /* This includes the whole .c file to get access to static functions. */
 #define PB_ENABLE_MALLOC
-#include "pb_common.c"
 #include "pb_decode.c"
 
 #include <stdio.h>
@@ -87,20 +86,6 @@ int main()
               pb_decode_varint(&s, (uint64_t*)&i) && i == -1));
         TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"),
               pb_decode_varint(&s, &u) && u == UINT64_MAX));
-        TEST((s = S("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"),
-              !pb_decode_varint(&s, &u)));
-    }
-    
-    {
-        pb_istream_t s;
-        uint32_t u;
-        
-        COMMENT("Test pb_decode_varint32");
-        TEST((s = S("\x00"), pb_decode_varint32(&s, &u) && u == 0));
-        TEST((s = S("\x01"), pb_decode_varint32(&s, &u) && u == 1));
-        TEST((s = S("\xAC\x02"), pb_decode_varint32(&s, &u) && u == 300));
-        TEST((s = S("\xFF\xFF\xFF\xFF\x0F"), pb_decode_varint32(&s, &u) && u == UINT32_MAX));
-        TEST((s = S("\xFF\xFF\xFF\xFF\xFF\x01"), !pb_decode_varint32(&s, &u)));
     }
     
     {
@@ -184,7 +169,7 @@ int main()
     
     {
         pb_istream_t s;
-        struct { pb_size_t size; uint8_t bytes[5]; } d;
+        struct { size_t size; uint8_t bytes[5]; } d;
         pb_field_t f = {1, PB_LTYPE_BYTES, 0, 0, sizeof(d), 0, 0};
         
         COMMENT("Test pb_dec_bytes")
@@ -265,7 +250,7 @@ int main()
     {
         pb_istream_t s;
         CallbackArray dest;
-        struct { pb_size_t size; uint8_t bytes[10]; } ref;
+        struct { size_t size; uint8_t bytes[10]; } ref;
         dest.data.funcs.decode = &callback_check;
         dest.data.arg = &ref;
         

tests/encode_unittests/encode_unittests.c

@@ -1,5 +1,4 @@
 /* This includes the whole .c file to get access to static functions. */
-#include "pb_common.c"
 #include "pb_encode.c"
 
 #include <stdio.h>
@@ -170,7 +169,7 @@ int main()
     {
         uint8_t buffer[30];
         pb_ostream_t s;
-        struct { pb_size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
+        struct { size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
     
         COMMENT("Test pb_enc_bytes")
         TEST(WRITES(pb_enc_bytes(&s, &BytesMessage_fields[0], &value), "\x05xyzzy"))
@@ -331,23 +330,6 @@ int main()
         TEST(s.bytes_written == StringMessage_size);
     }
     
-    {
-        uint8_t buffer[128];
-        pb_ostream_t s;
-        StringPointerContainer msg = StringPointerContainer_init_zero;
-        char *strs[1] = {NULL};
-        char zstr[] = "Z";
-        
-        COMMENT("Test string pointer encoding.");
-        
-        msg.rep_str = strs;
-        msg.rep_str_count = 1;
-        TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x00"))
-        
-        strs[0] = zstr;
-        TEST(WRITES(pb_encode(&s, StringPointerContainer_fields, &msg), "\x0a\x01Z"))
-    }
-    
     if (status != 0)
         fprintf(stdout, "\n\nSome tests FAILED!\n");
     

tests/extensions/SConscript

@@ -8,8 +8,8 @@ incpath.Append(PROTOCPATH = '$BUILD/alltypes')
 incpath.Append(CPPPATH = '$BUILD/alltypes')
 
 incpath.NanopbProto(["extensions", "extensions.options"])
-enc = incpath.Program(["encode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = incpath.Program(["encode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_encode.o"])
-dec = incpath.Program(["decode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+dec = incpath.Program(["decode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_decode.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_extensions.output"])

tests/extensions/extensions.proto

@@ -7,7 +7,6 @@ extend AllTypes {
 message ExtensionMessage {
     extend AllTypes {
         optional ExtensionMessage AllTypes_extensionfield2 = 254;
-	required ExtensionMessage AllTypes_extensionfield3 = 253;
 	repeated ExtensionMessage AllTypes_extensionfield4 = 252;
     }
     

tests/field_size_16/SConscript

@@ -19,11 +19,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_fields16.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_fields16.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_fields16.o", "$NANOPB/pb_common.c")
 
 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields16.o", "pb_common_fields16.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields16.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields16.o", "pb_common_fields16.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields16.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])

tests/field_size_32/SConscript

@@ -19,11 +19,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_fields32.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_fields32.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_fields32.o", "$NANOPB/pb_common.c")
 
 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields32.o", "pb_common_fields32.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_fields32.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields32.o", "pb_common_fields32.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_fields32.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])

tests/fuzztest/SConscript

@@ -1,30 +1,9 @@
 # Run a fuzz test to verify robustness against corrupted/malicious data.
 
-Import("env")
+Import("env", "malloc_env")
-
-# We need our own pb_decode.o for the malloc support
-env = env.Clone()
-env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1,
-                         'PB_SYSTEM_HEADER': '\\"fuzz_syshdr.h\\"'})
-env.Append(CPPPATH = ".")
-
-if 'SYSHDR' in env:
-    env.Append(CPPDEFINES = {'PB_OLD_SYSHDR': env['SYSHDR']})
-
-# Disable libmudflap, because it will confuse valgrind
-# and other memory leak detection tools.
-if '-fmudflap' in env["CCFLAGS"]:
-    env["CCFLAGS"].remove("-fmudflap")
-    env["LINKFLAGS"].remove("-fmudflap")
-    env["LIBS"].remove("mudflap")
-
-strict = env.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_with_malloc.o", "$NANOPB/pb_common.c")
 
 # We want both pointer and static versions of the AllTypes message
+# Prefix them with package name.
 env.Command("alltypes_static.proto", "#alltypes/alltypes.proto",
             lambda target, source, env:
                 open(str(target[0]), 'w').write("package alltypes_static;\n"
@@ -36,23 +15,20 @@ env.Command("alltypes_pointer.proto", "#alltypes/alltypes.proto",
 
 p1 = env.NanopbProto(["alltypes_pointer", "alltypes_pointer.options"])
 p2 = env.NanopbProto(["alltypes_static", "alltypes_static.options"])
-fuzz = env.Program(["fuzztest.c",
+fuzz = malloc_env.Program(["fuzztest.c",
                     "alltypes_pointer.pb.c",
                     "alltypes_static.pb.c",
-                    "pb_encode_with_malloc.o",
+                    "$COMMON/pb_encode_with_malloc.o",
-                    "pb_decode_with_malloc.o",
+                    "$COMMON/pb_decode_with_malloc.o",
-                    "pb_common_with_malloc.o",
+                    "$COMMON/malloc_wrappers.o"])
-                    "malloc_wrappers.c"])
-Depends([p1, p2, fuzz], ["fuzz_syshdr.h", "malloc_wrappers.h"])
 
 env.RunTest(fuzz)
 
-fuzzstub = env.Program(["fuzzstub.c",
+fuzzstub = malloc_env.Program(["fuzzstub.c",
                     "alltypes_pointer.pb.c",
                     "alltypes_static.pb.c",
-                    "pb_encode_with_malloc.o",
+                    "$COMMON/pb_encode_with_malloc.o",
-                    "pb_decode_with_malloc.o",
+                    "$COMMON/pb_decode_with_malloc.o",
-                    "pb_common_with_malloc.o",
+                    "$COMMON/malloc_wrappers.o"])
-                    "malloc_wrappers.c"])
 
 

tests/fuzztest/fuzzstub.c

@@ -10,7 +10,7 @@
 #include <string.h>
 #include <assert.h>
 #include <time.h>
-#include "malloc_wrappers.h"
+#include <malloc_wrappers.h>
 #include "alltypes_static.pb.h"
 #include "alltypes_pointer.pb.h"
 

tests/fuzztest/fuzztest.c

@@ -9,7 +9,7 @@
 #include <string.h>
 #include <assert.h>
 #include <time.h>
-#include "malloc_wrappers.h"
+#include <malloc_wrappers.h>
 #include "alltypes_static.pb.h"
 #include "alltypes_pointer.pb.h"
 

tests/io_errors/SConscript

@@ -1,15 +0,0 @@
-# Simulate io errors when encoding and decoding
-
-Import("env")
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
-
-env.NanopbProto(["alltypes", "alltypes.options"])
-
-ioerr = env.Program(["io_errors.c", "alltypes.pb.c",
-                     "$COMMON/pb_encode.o", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
-
-env.RunTest("io_errors.output", [ioerr, "$BUILD/alltypes/encode_alltypes.output"])
-
-

tests/io_errors/alltypes.options

@@ -1,3 +0,0 @@
-* max_size:16
-* max_count:5
-

tests/io_errors/io_errors.c

@@ -1,140 +0,0 @@
-/* Simulate IO errors after each byte in a stream.
- * Verifies proper error propagation.
- */
-
-#include <stdio.h>
-#include <pb_decode.h>
-#include <pb_encode.h>
-#include "alltypes.pb.h"
-#include "test_helpers.h"
-
-typedef struct
-{
-    uint8_t *buffer;
-    size_t fail_after;
-} faulty_stream_t;
-
-bool read_callback(pb_istream_t *stream, uint8_t *buf, size_t count)
-{
-    faulty_stream_t *state = stream->state;
-    
-    while (count--)
-    {
-        if (state->fail_after == 0)
-            PB_RETURN_ERROR(stream, "simulated");
-        state->fail_after--;
-        *buf++ = *state->buffer++;
-    }
-    
-    return true;
-}
-bool write_callback(pb_ostream_t *stream, const uint8_t *buf, size_t count)
-{
-    faulty_stream_t *state = stream->state;
-    
-    while (count--)
-    {
-        if (state->fail_after == 0)
-            PB_RETURN_ERROR(stream, "simulated");
-        state->fail_after--;
-        *state->buffer++ = *buf++;
-    }
-    
-    return true;
-}
-
-int main()
-{
-    uint8_t buffer[2048];
-    size_t msglen;
-    AllTypes msg = AllTypes_init_zero;
-    
-    /* Get some base data to run the tests with */
-    SET_BINARY_MODE(stdin);
-    msglen = fread(buffer, 1, sizeof(buffer), stdin);
-    
-    /* Test IO errors on decoding */
-    {
-        bool status;
-        pb_istream_t stream = {&read_callback, NULL, SIZE_MAX};
-        faulty_stream_t fs;
-        size_t i;
-        
-        for (i = 0; i < msglen; i++)
-        {
-            stream.bytes_left = msglen;
-            stream.state = &fs;
-            fs.buffer = buffer;
-            fs.fail_after = i;
-
-            status = pb_decode(&stream, AllTypes_fields, &msg);
-            if (status != false)
-            {
-                fprintf(stderr, "Unexpected success in decode\n");
-                return 2;
-            }
-            else if (strcmp(stream.errmsg, "simulated") != 0)
-            {
-                fprintf(stderr, "Wrong error in decode: %s\n", stream.errmsg);
-                return 3;
-            }
-        }
-        
-        stream.bytes_left = msglen;
-        stream.state = &fs;
-        fs.buffer = buffer;
-        fs.fail_after = msglen;
-        status = pb_decode(&stream, AllTypes_fields, &msg);
-        
-        if (!status)
-        {
-            fprintf(stderr, "Decoding failed: %s\n", stream.errmsg);
-            return 4;
-        }
-    }
-    
-    /* Test IO errors on encoding */
-    {
-        bool status;
-        pb_ostream_t stream = {&write_callback, NULL, SIZE_MAX, 0};
-        faulty_stream_t fs;
-        size_t i;
-        
-        for (i = 0; i < msglen; i++)
-        {
-            stream.max_size = msglen;
-            stream.bytes_written = 0;
-            stream.state = &fs;
-            fs.buffer = buffer;
-            fs.fail_after = i;
-
-            status = pb_encode(&stream, AllTypes_fields, &msg);
-            if (status != false)
-            {
-                fprintf(stderr, "Unexpected success in encode\n");
-                return 5;
-            }
-            else if (strcmp(stream.errmsg, "simulated") != 0)
-            {
-                fprintf(stderr, "Wrong error in encode: %s\n", stream.errmsg);
-                return 6;
-            }
-        }
-        
-        stream.max_size = msglen;
-        stream.bytes_written = 0;
-        stream.state = &fs;
-        fs.buffer = buffer;
-        fs.fail_after = msglen;
-        status = pb_encode(&stream, AllTypes_fields, &msg);
-        
-        if (!status)
-        {
-            fprintf(stderr, "Encoding failed: %s\n", stream.errmsg);
-            return 7;
-        }
-    }
-
-    return 0;   
-}
-

tests/io_errors_pointers/SConscript

@@ -1,42 +0,0 @@
-# Simulate io errors when encoding and decoding
-
-Import("env")
-
-# We need our own pb_decode.o for the malloc support
-env = env.Clone()
-env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1});
-
-# Disable libmudflap, because it will confuse valgrind
-# and other memory leak detection tools.
-if '-fmudflap' in env["CCFLAGS"]:
-    env["CCFLAGS"].remove("-fmudflap")
-    env["LINKFLAGS"].remove("-fmudflap")
-    env["LIBS"].remove("mudflap")
-
-strict = env.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_with_malloc.o", "$NANOPB/pb_common.c")
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
-env.Command("io_errors.c", "#io_errors/io_errors.c", c)
-
-env.NanopbProto(["alltypes", "alltypes.options"])
-
-ioerr = env.Program(["io_errors.c", "alltypes.pb.c",
-                     "pb_encode_with_malloc.o",
-                     "pb_decode_with_malloc.o",
-                     "pb_common_with_malloc.o"])
-
-# Run tests under valgrind if available
-valgrind = env.WhereIs('valgrind')
-kwargs = {}
-if valgrind:
-    kwargs['COMMAND'] = valgrind
-    kwargs['ARGS'] = ["-q", ioerr[0].abspath]
-
-env.RunTest("io_errors.output", [ioerr, "$BUILD/alltypes/encode_alltypes.output"], **kwargs)
-
-

tests/io_errors_pointers/alltypes.options

@@ -1,3 +0,0 @@
-# Generate all fields as pointers.
-* type:FT_POINTER
-

tests/mem_release/SConscript

@@ -0,0 +1,12 @@
+Import("env", "malloc_env")
+
+env.NanopbProto("mem_release.proto")
+
+test = malloc_env.Program(["mem_release.c",
+                    "mem_release.pb.c",
+                    "$COMMON/pb_encode_with_malloc.o",
+                    "$COMMON/pb_decode_with_malloc.o",
+                    "$COMMON/malloc_wrappers.o"])
+
+env.RunTest(test)
+

tests/mem_release/mem_release.c

@@ -0,0 +1,106 @@
+/* Make sure that all fields are freed in various scenarios. */
+
+#include <pb_decode.h>
+#include <pb_encode.h>
+#include <malloc_wrappers.h>
+#include <stdio.h>
+#include <test_helpers.h>
+#include "mem_release.pb.h"
+
+#define TEST(x) if (!(x)) { \
+    fprintf(stderr, "Test " #x " on line %d failed.\n", __LINE__); \
+    return false; \
+    }
+
+static char *test_str_arr[] = {"1", "2", ""};
+static SubMessage test_msg_arr[] = {SubMessage_init_zero, SubMessage_init_zero};
+
+static bool do_test()
+{
+    uint8_t buffer[256];
+    size_t msgsize;
+    
+    /* Construct a message with various fields filled in */
+    {
+        TestMessage msg = TestMessage_init_zero;
+        pb_extension_t ext2;
+        pb_ostream_t stream;
+        msg.static_req_submsg.dynamic_str = "12345";
+        msg.static_req_submsg.dynamic_str_arr_count = 3;
+        msg.static_req_submsg.dynamic_str_arr = test_str_arr;
+        msg.static_req_submsg.dynamic_submsg_count = 2;
+        msg.static_req_submsg.dynamic_submsg = test_msg_arr;
+        msg.static_req_submsg.dynamic_submsg[1].dynamic_str = "abc";
+        msg.static_opt_submsg.dynamic_str = "abc";
+        msg.has_static_opt_submsg = true;
+        msg.dynamic_submsg = &msg.static_req_submsg;
+        
+        msg.extensions = &ext2;
+        ext2.type = &static_ext;
+        ext2.dest = &msg.static_req_submsg;
+        ext2.next = NULL;
+        
+        stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+        if (!pb_encode(&stream, TestMessage_fields, &msg))
+        {
+            fprintf(stderr, "Encode failed: %s\n", PB_GET_ERROR(&stream));
+            return false;
+        }
+        msgsize = stream.bytes_written;
+    }
+    
+    /* Output encoded message for debug */
+    SET_BINARY_MODE(stdout);
+    fwrite(buffer, 1, msgsize, stdout);
+    
+    /* Decode memory using dynamic allocation */
+    {
+        TestMessage msg = TestMessage_init_zero;
+        pb_istream_t stream;
+        SubMessage ext2_dest = SubMessage_init_zero;
+        pb_extension_t ext2;
+        
+        msg.extensions = &ext2;
+        ext2.type = &static_ext;
+        ext2.dest = &ext2_dest;
+        ext2.next = NULL;
+        
+        stream = pb_istream_from_buffer(buffer, msgsize);
+        if (!pb_decode(&stream, TestMessage_fields, &msg))
+        {
+            fprintf(stderr, "Decode failed: %s\n", PB_GET_ERROR(&stream));
+            return false;
+        }
+        
+        /* Make sure it encodes back to same data */
+        {
+            uint8_t buffer2[256];
+            pb_ostream_t ostream = pb_ostream_from_buffer(buffer2, sizeof(buffer2));
+            TEST(pb_encode(&ostream, TestMessage_fields, &msg));
+            TEST(ostream.bytes_written == msgsize);
+            TEST(memcmp(buffer, buffer2, msgsize) == 0);
+        }
+        
+        /* Make sure that malloc counters work */
+        TEST(get_alloc_count() > 0);
+        
+        /* Make sure that pb_release releases everything */
+        pb_release(TestMessage_fields, &msg);
+        TEST(get_alloc_count() == 0);
+        
+        /* Check that double-free is a no-op */
+        pb_release(TestMessage_fields, &msg);
+        TEST(get_alloc_count() == 0);
+    }
+    
+    return true;
+}
+
+int main()
+{
+    if (do_test())
+        return 0;
+    else
+        return 1;
+}
+

tests/mem_release/mem_release.proto

@@ -0,0 +1,23 @@
+syntax = "proto2";
+import "nanopb.proto";
+
+message SubMessage
+{
+    optional string dynamic_str = 1 [(nanopb).type = FT_POINTER];
+    repeated string dynamic_str_arr = 2 [(nanopb).type = FT_POINTER];
+    repeated SubMessage dynamic_submsg = 3 [(nanopb).type = FT_POINTER];
+}
+
+message TestMessage
+{
+    required SubMessage static_req_submsg = 1 [(nanopb).type = FT_STATIC];
+    optional SubMessage dynamic_submsg = 2 [(nanopb).type = FT_POINTER];
+    optional SubMessage static_opt_submsg = 3 [(nanopb).type = FT_STATIC];
+    extensions 100 to 200;
+}
+
+extend TestMessage
+{
+    optional SubMessage static_ext = 101 [(nanopb).type = FT_STATIC];
+}
+

tests/missing_fields/SConscript

@@ -3,6 +3,6 @@
 Import("env")
 
 env.NanopbProto("missing_fields")
-test = env.Program(["missing_fields.c", "missing_fields.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+test = env.Program(["missing_fields.c", "missing_fields.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_decode.o"])
 env.RunTest(test)
 

tests/no_errmsg/SConscript

@@ -18,11 +18,10 @@ strict = opts.Clone()
 strict.Append(CFLAGS = strict['CORECFLAGS'])
 strict.Object("pb_decode_noerr.o", "$NANOPB/pb_decode.c")
 strict.Object("pb_encode_noerr.o", "$NANOPB/pb_encode.c")
-strict.Object("pb_common_noerr.o", "$NANOPB/pb_common.c")
 
 # Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_noerr.o", "pb_common_noerr.o"])
+enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_noerr.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_noerr.o", "pb_common_noerr.o"])
+dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_noerr.o"])
 
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])

tests/package_name/SConscript

@@ -29,7 +29,7 @@ def modify_c(target, source, env):
 env.Command("encode_alltypes.c", "#alltypes/encode_alltypes.c", modify_c)
 
 # Encode and compare results to original alltypes testcase
-enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+enc = env.Program(["encode_alltypes.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
 refdec = "$BUILD/alltypes/decode_alltypes$PROGSUFFIX"
 env.RunTest(enc)
 env.Compare(["encode_alltypes.output", "$BUILD/alltypes/encode_alltypes.output"])

tests/splint/SConscript

@@ -11,6 +11,3 @@ if p:
     env.Command('pb_encode.splint', '$NANOPB/pb_encode.c',
         'splint -f splint/splint.rc $SOURCE 2> $TARGET')
 
-    env.Command('pb_common.splint', '$NANOPB/pb_common.c',
-        'splint -f splint/splint.rc $SOURCE 2> $TARGET')
-

tests/splint/splint.rc

@@ -2,6 +2,7 @@
 +partial
 +matchanyintegral
 +strictlib
+-isoreserved		# to be fixed in 0.3
 -nullassign
 -predboolint
 -predboolptr
@@ -27,7 +28,6 @@
 -kepttrans
 -branchstate
 -immediatetrans
--mustfreefresh
 
 # These tests give false positives, compiler typically has
 # better warnings for these.