Fixed pb_get_message_size

Code reduction optimization by sharing common field descriptor information for numeric field types
2012-02-27 14:46:38 -08:00 · 2012-02-24 13:46:36 -08:00
119 changed files with 1964 additions and 6833 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,21 +0,0 @@
 *.gcda
 *.gcno
 *.gcov
 *.o
 *.pb.c
 *.pb.h
 *.pb
 *~
 *.tar.gz
 .sconsign.dblite
 julkaisu.txt
 docs/*.html
 docs/generator_flow.png
 example/client
 example/server
 example_avr_double/decode_double
 example_avr_double/encode_double
 example_avr_double/test_conversions
 example_unions/decode
 example_unions/encode
 generator/nanopb_pb2.pyc
--- a/112
+++ b/112
@@ -1,112 +0,0 @@
 nanopb-0.2.3
 Improve compatibility by removing ternary operator from initializations (issue 88)
 Fix build error on Visual C++ (issue 84, patch by Markus Schwarzenberg)
 Don't stop on unsupported extension fields (issue 83)
 Add an example pb_syshdr.h file for non-C99 compilers
 Reorganize tests and examples into subfolders (issue 63)
 Switch from Makefiles to scons for building the tests
 Make the tests buildable on Windows
 nanopb-0.2.2
 Add support for extension fields (issue 17)
 Fix unknown fields in empty message (issue 78)
 Include the field tags in the generated .pb.h file.
 Add pb_decode_delimited and pb_encode_delimited wrapper functions (issue 74)
 Add a section in top of pb.h for changing compilation settings (issue 76)
 Documentation improvements (issues 12, 77 and others)
 Improved tests
 nanopb-0.2.1
 NOTE: The default callback function signature has changed.
       If you don't want to update your code, define PB_OLD_CALLBACK_STYLE.
 Change the callback function to use void** (issue 69)
 Add support for defining the nanopb options in a separate file (issue 12)
 Add support for packed structs in IAR and MSVC (in addition to GCC) (issue 66)
 Implement error message support for the encoder side (issue 7)
 Handle unterminated strings when encoding (issue 68)
 Fix bug with empty strings in repeated string callbacks (issue 73)
 Fix regression in 0.2.0 with optional callback fields (issue 70)
 Fix bugs with empty message types (issues 64, 65)
 Fix some compiler warnings on clang (issue 67)
 Some portability improvements (issues 60, 62)
 Various new generator options
 Improved tests
 nanopb-0.2.0
 NOTE: This release requires you to regenerate all .pb.c
       files. Files generated by older versions will not
       compile anymore.
 Reformat generated .pb.c files using macros (issue 58)
 Rename PB_HTYPE_ARRAY -> PB_HTYPE_REPEATED
 Separate PB_HTYPE to PB_ATYPE and PB_HTYPE
 Move STATIC_ASSERTs to .pb.c file
 Added CMake file (by Pavel Ilin)
 Add option to give file extension to generator (by Michael Haberler)
 Documentation updates
 nanopb-0.1.9
 Fixed error message bugs (issues 52, 56)
 Sanitize #ifndef filename (issue 50)
 Performance improvements
 Add compile-time option PB_BUFFER_ONLY
 Add Java package name to nanopb.proto
 Check for sizeof(double) == 8 (issue 54)
 Added generator option to ignore some fields. (issue 51)
 Added generator option to make message structs packed. (issue 49)
 Add more test cases.
 nanopb-0.1.8
 Fix bugs in the enum short names introduced in 0.1.7 (issues 42, 43)
 Fix STATIC_ASSERT macro when using multiple .proto files. (issue 41)
 Fix missing initialization of istream.errmsg
 Make tests/Makefile work for non-gcc compilers (issue 40)
 nanopb-0.1.7
 Remove "skip" mode from pb_istream_t callbacks. Example implementation had a bug. (issue 37)
 Add option to use shorter names for enum values (issue 38)
 Improve options support in generator (issues 12, 30)
 Add nanopb version number to generated files (issue 36)
 Add extern "C" to generated headers (issue 35)
 Add names for structs to allow forward declaration (issue 39)
 Add buffer size check in example (issue 34)
 Fix build warnings on MS compilers (issue 33)
 nanopb-0.1.6
 Reorganize the field decoder interface (issue 2)
 Improve performance in submessage decoding (issue 28)
 Implement error messages in the decoder side (issue 7)
 Extended testcases (alltypes test is now complete).
 Fix some compiler warnings (issues 25, 26, 27, 32).
 nanopb-0.1.5
 Fix bug in decoder with packed arrays (issue 23).
 Extended testcases.
 Fix some compiler warnings.
 nanopb-0.1.4
 Add compile-time options for easy-to-use >255 field support.
 Improve the detection of missing required fields.
 Added example on how to handle union messages.
 Fix generator error with .proto without messages.
 Fix problems that stopped the code from compiling with some compilers.
 Fix some compiler warnings.
 nanopb-0.1.3
 Refactor the field encoder interface.
 Improve generator error messages (issue 5)
 Add descriptor.proto into the #include exclusion list
 Fix some compiler warnings.
 nanopb-0.1.2
 Make the generator to generate include for other .proto files (issue 4).
 Fixed generator not working on Windows (issue 3)
 nanopb-0.1.1
 Fixed bug in encoder with 'bytes' fields (issue 1).
 Fixed a bug in the generator that caused a compiler error on sfixed32 and sfixed64 fields.
 Extended testcases.
 nanopb-0.1.0
 First stable release.
--- a/13
+++ b/13
@@ -5,7 +5,14 @@ Homepage: http://kapsi.fi/~jpa/nanopb/
 To compile the library, you'll need these libraries:
 protobuf-compiler python-protobuf libprotobuf-dev
 The only runtime dependencies are memset() and memcpy().
 To run the tests, run make under the tests folder.
-If it completes without error, everything is fine.
+If it completes without error, everything is fine. 
 Code size optimization is currently only supported for 32-bit 
 architecture. If you want to run on 64-bit architecture,
 you must disable code size optimization by providing -n option to
 code generator nanopb_generator.py.  
 For testing purpose, you may need to pass -m32 compiler to gcc if 
 you're running on a 64-bit machine unless -n option is used for code 
 generation. 
--- a/cmake/FindNanopb.cmake
+++ b/cmake/FindNanopb.cmake
@@ -1,224 +0,0 @@
 # Locate and configure the nanopb library.
 #
 # The following varialbes have to be set:
 #
 #   NANOPB_SRC_ROOT_FOLDER  - Path to nanopb source folder
 #
 # The following variables can be set and are optional:
 #
 #
 #   PROTOBUF_SRC_ROOT_FOLDER - When compiling with MSVC, if this cache variable is set
 #                              the protobuf-default VS project build locations
 #                              (vsprojects/Debug & vsprojects/Release) will be searched
 #                              for libraries and binaries.
 #
 #   NANOPB_IMPORT_DIRS       - List of additional directories to be searched for
 #                              imported .proto files.
 #
 #   NANOPB_GENERATE_CPP_APPEND_PATH - By default -I will be passed to protoc
 #                                     for each directory where a proto file is referenced.
 #                                     Set to FALSE if you want to disable this behaviour.
 #
 # Defines the following variables:
 #
 #   NANOPB_FOUND - Found the nanopb library (source&header files, generator tool, protoc compiler tool)
 #   NANOPB_INCLUDE_DIRS - Include directories for Google Protocol Buffers
 #
 # The following cache variables are also available to set or use:
 #   NANOPB_GENERATOR_EXECUTABLE - The nanopb generator
 #   PROTOBUF_PROTOC_EXECUTABLE - The protoc compiler
 #
 #  ====================================================================
 #
 # NANOPB_GENERATE_CPP (public function)
 #   SRCS = Variable to define with autogenerated
 #          source files
 #   HDRS = Variable to define with autogenerated
 #          header files
 #   ARGN = proto files
 #
 #  ====================================================================
 #  Example:
 #
 #   set(NANOPB_SRC_ROOT_FOLDER "/path/to/nanopb")
 #   set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${NANOPB_SRC_ROOT_FOLDER}/cmake)
 #   find_package( Nanopb REQUIRED )
 #   include_directories(${NANOPB_INCLUDE_DIRS})
 #
 #   NANOPB_GENERATE_CPP(PROTO_SRCS PROTO_HDRS foo.proto)
 #
 #   include_directories(${CMAKE_CURRENT_BINARY_DIR})
 #   add_executable(bar bar.cc ${PROTO_SRCS} ${PROTO_HDRS})
 #
 #  ====================================================================
 #=============================================================================
 # Copyright 2009 Kitware, Inc.
 # Copyright 2009-2011 Philip Lowman <philip@yhbt.com>
 # Copyright 2008 Esben Mose Hansen, Ange Optimization ApS
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # * Redistributions of source code must retain the above copyright
 #   notice, this list of conditions and the following disclaimer.
 #
 # * Redistributions in binary form must reproduce the above copyright
 #   notice, this list of conditions and the following disclaimer in the
 #   documentation and/or other materials provided with the distribution.
 #
 # * Neither the names of Kitware, Inc., the Insight Software Consortium,
 #   nor the names of their contributors may be used to endorse or promote
 #   products derived from this software without specific prior written
 #   permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 #=============================================================================
 #
 # Changes
 # 2013.01.31 - Pavlo Ilin - used Modules/FindProtobuf.cmake from cmake 2.8.10 to
 #                           write FindNanopb.cmake
 #
 #=============================================================================
 function(NANOPB_GENERATE_CPP SRCS HDRS)
  if(NOT ARGN)
    return()
  endif()
  if(NANOPB_GENERATE_CPP_APPEND_PATH)
    # Create an include path for each file specified
    foreach(FIL ${ARGN})
      get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
      get_filename_component(ABS_PATH ${ABS_FIL} PATH)
      list(FIND _nanobp_include_path ${ABS_PATH} _contains_already)
      if(${_contains_already} EQUAL -1)
          list(APPEND _nanobp_include_path -I ${ABS_PATH})
      endif()
    endforeach()
  else()
    set(_nanobp_include_path -I ${CMAKE_CURRENT_SOURCE_DIR})
  endif()
  if(DEFINED NANOPB_IMPORT_DIRS)
    foreach(DIR ${NANOPB_IMPORT_DIRS})
      get_filename_component(ABS_PATH ${DIR} ABSOLUTE)
      list(FIND _nanobp_include_path ${ABS_PATH} _contains_already)
      if(${_contains_already} EQUAL -1)
          list(APPEND _nanobp_include_path -I ${ABS_PATH})
      endif()
    endforeach()
  endif()
  set(${SRCS})
  set(${HDRS})
  get_filename_component(GENERATOR_PATH ${NANOPB_GENERATOR_EXECUTABLE} PATH)
  foreach(FIL ${ARGN})
    get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
    get_filename_component(FIL_WE ${FIL} NAME_WE)
    list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.c")
    list(APPEND ${HDRS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h")
    add_custom_command(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb"
      COMMAND  ${PROTOBUF_PROTOC_EXECUTABLE}
      ARGS -I${GENERATOR_PATH} -I${CMAKE_CURRENT_BINARY_DIR} ${_nanobp_include_path} -o${FIL_WE}.pb ${ABS_FIL}
      DEPENDS ${ABS_FIL}
      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
      VERBATIM )
    add_custom_command(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.c"
             "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h"
      COMMAND python
      ARGS ${NANOPB_GENERATOR_EXECUTABLE} ${FIL_WE}.pb
      DEPENDS ${FIL_WE}.pb
      COMMENT "Running nanopb generator on ${FIL_WE}.pb"
      VERBATIM )
  endforeach()
  set_source_files_properties(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
  set(${SRCS} ${${SRCS}} ${NANOPB_SRCS} PARENT_SCOPE)
  set(${HDRS} ${${HDRS}} ${NANOPB_HDRS} PARENT_SCOPE)
 endfunction()
 #
 # Main.
 #
 # By default have NANOPB_GENERATE_CPP macro pass -I to protoc
 # for each directory where a proto file is referenced.
 if(NOT DEFINED NANOPB_GENERATE_CPP_APPEND_PATH)
  set(NANOPB_GENERATE_CPP_APPEND_PATH TRUE)
 endif()
 # Find the include directory
 find_path(NANOPB_INCLUDE_DIRS
    pb.h
    PATHS ${NANOPB_SRC_ROOT_FOLDER}
 )
 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)
 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})
  list(APPEND NANOPB_SRCS "${${FIL}__nano_pb_file}")
  mark_as_advanced(${FIL}__nano_pb_file)
 endforeach()
 foreach(FIL ${_nanopb_hdrs})
  find_file(${FIL}__nano_pb_file NAMES ${FIL} PATHS ${NANOPB_INCLUDE_DIRS})
  mark_as_advanced(${FIL}__nano_pb_file)
  list(APPEND NANOPB_HDRS "${${FIL}__nano_pb_file}")
 endforeach()
 # Find the protoc Executable
 find_program(PROTOBUF_PROTOC_EXECUTABLE
    NAMES protoc
    DOC "The Google Protocol Buffers Compiler"
    PATHS
    ${PROTOBUF_SRC_ROOT_FOLDER}/vsprojects/Release
    ${PROTOBUF_SRC_ROOT_FOLDER}/vsprojects/Debug
 )
 mark_as_advanced(PROTOBUF_PROTOC_EXECUTABLE)
 # Find nanopb generator
 find_file(NANOPB_GENERATOR_EXECUTABLE
    NAMES nanopb_generator.py
    DOC "nanopb generator"
    PATHS
    ${NANOPB_SRC_ROOT_FOLDER}/generator
 )
 mark_as_advanced(NANOPB_GENERATOR_EXECUTABLE)
 include(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(NANOPB DEFAULT_MSG
  NANOPB_INCLUDE_DIRS
  NANOPB_SRCS NANOPB_HDRS
  NANOPB_GENERATOR_EXECUTABLE
  PROTOBUF_PROTOC_EXECUTABLE
  )
--- a/compat/pb_syshdr.h
+++ b/compat/pb_syshdr.h
@@ -1,94 +0,0 @@
 /* This is an example of a header file for platforms/compilers that do
 * not come with stdint.h/stddef.h/stdbool.h/string.h. To use it, define
 * PB_SYSTEM_HEADER as "pb_syshdr.h", including the quotes, and add the
 * compat folder to your include path.
 *
 * It is very likely that you will need to customize this file to suit
 * your platform. For any compiler that supports C99, this file should
 * not be necessary.
 */
 #ifndef _PB_SYSHDR_H_
 #define _PB_SYSHDR_H_
 /* stdint.h subset */
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #else
 /* You will need to modify these to match the word size of your platform. */
 typedef signed char int8_t;
 typedef unsigned char uint8_t;
 typedef signed short int16_t;
 typedef unsigned short uint16_t;
 typedef signed int int32_t;
 typedef unsigned int uint32_t;
 typedef signed long long int64_t;
 typedef unsigned long long uint64_t;
 #endif
 /* stddef.h subset */
 #ifdef HAVE_STDDEF_H
 #include <stddef.h>
 #else
 typedef uint32_t size_t;
 #define offsetof(st, m) ((size_t)(&((st *)0)->m))
 #ifndef NULL
 #define NULL 0
 #endif
 #endif
 /* stdbool.h subset */
 #ifdef HAVE_STDBOOL_H
 #include <stdbool.h>
 #else
 #ifndef __cplusplus
 typedef int bool;
 #define false 0
 #define true 1
 #endif
 #endif
 /* string.h subset */
 #ifdef HAVE_STRING_H
 #include <string.h>
 #else
 /* Implementations are from the Public Domain C Library (PDCLib). */
 static size_t strlen( const char * s )
 {
    size_t rc = 0;
    while ( s[rc] )
    {
        ++rc;
    }
    return rc;
 }
 static void * memcpy( void *s1, const void *s2, size_t n )
 {
    char * dest = (char *) s1;
    const char * src = (const char *) s2;
    while ( n-- )
    {
        *dest++ = *src++;
    }
    return s1;
 }
 static void * memset( void * s, int c, size_t n )
 {
    unsigned char * p = (unsigned char *) s;
    while ( n-- )
    {
        *p++ = (unsigned char) c;
    }
    return s;
 }
 #endif
 #endif
--- a/docs/concepts.rst
+++ b/docs/concepts.rst
@@ -10,40 +10,33 @@ The things outlined here are the underlying concepts of the nanopb design.
 Proto files
 ===========
-All Protocol Buffers implementations use .proto files to describe the message
+All Protocol Buffers implementations use .proto files to describe the message format.
-format. The point of these files is to be a portable interface description
+The point of these files is to be a portable interface description language.
 language.
 Compiling .proto files for nanopb
 ---------------------------------
-Nanopb uses the Google's protoc compiler to parse the .proto file, and then a
+Nanopb uses the Google's protoc compiler to parse the .proto file, and then a python script to generate the C header and source code from it::
 python script to generate the C header and source code from it::
    user@host:~$ protoc -omessage.pb message.proto
    user@host:~$ python ../generator/nanopb_generator.py message.pb
    Writing to message.h and message.c
    user@host:~$
-Modifying generator behaviour
+Compiling .proto files with nanopb options
-----------------------------
+------------------------------------------
-Using generator options, you can set maximum sizes for fields in order to
+Nanopb defines two extensions for message fields described in .proto files: *max_size* and *max_count*.
-allocate them statically. The preferred way to do this is to create an .options
+These are the maximum size of a string and maximum count of items in an array::
 file with the same name as your .proto file::
-   # Foo.proto
+    required string name = 1 [(nanopb).max_size = 40];
-   message Foo {
+    repeated PhoneNumber phone = 4 [(nanopb).max_count = 5];
      required string name = 1;
   }
-::
+To use these extensions, you need to place an import statement in the beginning of the file::
-   # Foo.options
+    import "nanopb.proto";
   Foo.name max_size:16
-For more information on this, see the `Proto file options`_ section in the
+This file, in turn, requires the file *google/protobuf/descriptor.proto*. This is usually installed under */usr/include*. Therefore, to compile a .proto file which uses options, use a protoc command similar to::
 reference manual.
-.. _`Proto file options`: reference.html#proto-file-options
+    protoc -I/usr/include -Inanopb/generator -I. -omessage.pb message.proto
 Streams
 =======
@@ -57,7 +50,6 @@ There are a few generic rules for callback functions:
 #) Use state to store your own data, such as a file descriptor.
 #) *bytes_written* and *bytes_left* are updated by pb_write and pb_read.
 #) Your callback may be used with substreams. In this case *bytes_left*, *bytes_written* and *max_size* have smaller values than the original stream. Don't use these values to calculate pointers.
 #) Always read or write the full requested length of data. For example, POSIX *recv()* needs the *MSG_WAITALL* parameter to accomplish this.
 Output streams
 --------------
@@ -99,8 +91,9 @@ Writing to stdout::
 Input streams
 -------------
-For input streams, there is one extra rule:
+For input streams, there are a few extra rules:
 #) If buf is NULL, read from stream but don't store the data. This is used to skip unknown input.
 #) You don't need to know the length of the message in advance. After getting EOF error when reading, set bytes_left to 0 and return false. Pb_decode will detect this and if the EOF was in a proper position, it will return true.
 Here is the structure::
@@ -174,9 +167,7 @@ Field callbacks
 ===============
 When a field has dynamic length, nanopb cannot statically allocate storage for it. Instead, it allows you to handle the field in whatever way you want, using a callback function.
-The `pb_callback_t`_ structure contains a function pointer and a *void* pointer called *arg* you can use for passing data to the callback. If the function pointer is NULL, the field will be skipped. A pointer to the *arg* is passed to the function, so that it can modify it and retrieve the value.
+The `pb_callback_t`_ structure contains a function pointer and a *void* pointer you can use for passing data to the callback. If the function pointer is NULL, the field will be skipped. The actual behavior of the callback function is different in encoding and decoding modes.
 The actual behavior of the callback function is different in encoding and decoding modes. In encoding mode, the callback is called once and should write out everything, including field tags. In decoding mode, the callback is called repeatedly for every data item.
 .. _`pb_callback_t`: reference.html#pb-callback-t
@@ -184,7 +175,7 @@ Encoding callbacks
 ------------------
 ::
-    bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
+    bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, const void *arg);
 When encoding, the callback should write out complete fields, including the wire type and field number tag. It can write as many or as few fields as it likes. For example, if you want to write out an array as *repeated* field, you should do it all in a single call.
@@ -198,7 +189,7 @@ If the callback is used in a submessage, it will be called multiple times during
 This callback writes out a dynamically sized string::
-    bool write_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
+    bool write_string(pb_ostream_t *stream, const pb_field_t *field, const void *arg)
    {
        char *str = get_string_from_somewhere();
        if (!pb_encode_tag_for_field(stream, field))
@@ -211,7 +202,7 @@ Decoding callbacks
 ------------------
 ::
-    bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void **arg);
+    bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void *arg);
 When decoding, the callback receives a length-limited substring that reads the contents of a single field. The field tag has already been read. For *string* and *bytes*, the length value has already been parsed, and is available at *stream->bytes_left*.
@@ -221,7 +212,7 @@ The callback will be called multiple times for repeated fields. For packed field
 This callback reads multiple integers and prints them::
-    bool read_ints(pb_istream_t *stream, const pb_field_t *field, void **arg)
+    bool read_ints(pb_istream_t *stream, const pb_field_t *field, void *arg)
    {
        while (stream->bytes_left)
        {
@@ -250,67 +241,35 @@ For example this submessage in the Person.proto file::
 generates this field description array for the structure *Person_PhoneNumber*::
 const pb_field_t Person_PhoneNumber_fields[3] = {
-    PB_FIELD(  1, STRING  , REQUIRED, STATIC, Person_PhoneNumber, number, number, 0),
+    {1, PB_HTYPE_REQUIRED | PB_LTYPE_STRING,
-    PB_FIELD(  2, ENUM    , OPTIONAL, STATIC, Person_PhoneNumber, type, number, &Person_PhoneNumber_type_default),
+    offsetof(Person_PhoneNumber, number), 0,
    pb_membersize(Person_PhoneNumber, number), 0, 0},
    {2, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT,
    pb_delta(Person_PhoneNumber, type, number),
    pb_delta(Person_PhoneNumber, has_type, type),
    pb_membersize(Person_PhoneNumber, type), 0,
    &Person_PhoneNumber_type_default},
    PB_LAST_FIELD
 };
 Extension fields
 ================
 Protocol Buffers supports a concept of `extension fields`_, which are
 additional fields to a message, but defined outside the actual message.
 The definition can even be in a completely separate .proto file.
 The base message is declared as extensible by keyword *extensions* in
 the .proto file::
 message MyMessage {
     .. fields ..
     extensions 100 to 199;
 }
 For each extensible message, *nanopb_generator.py* declares an additional
 callback field called *extensions*. The field and associated datatype
 *pb_extension_t* forms a linked list of handlers. When an unknown field is
 encountered, the decoder calls each handler in turn until either one of them
 handles the field, or the list is exhausted.
 The actual extensions are declared using the *extend* keyword in the .proto,
 and are in the global namespace::
 extend MyMessage {
     optional int32 myextension = 100;
 }
 For each extension, *nanopb_generator.py* creates a constant of type
 *pb_extension_type_t*. To link together the base message and the extension,
 you have to:
 1. Allocate storage for your field, matching the datatype in the .proto.
   For example, for a *int32* field, you need a *int32_t* variable to store
   the value.
 2. Create a *pb_extension_t* constant, with pointers to your variable and
   to the generated *pb_extension_type_t*.
 3. Set the *message.extensions* pointer to point to the *pb_extension_t*.
 An example of this is available in *tests/test_encode_extensions.c* and
 *tests/test_decode_extensions.c*.
 .. _`extension fields`: https://developers.google.com/protocol-buffers/docs/proto#extensions
 Return values and error handling
 ================================
-Most functions in nanopb return bool: *true* means success, *false* means failure. There is also some support for error messages for debugging purposes: the error messages go in *stream->errmsg*.
+Most functions in nanopb return bool: *true* means success, *false* means failure. If this is enough for you, skip this section.
-The error messages help in guessing what is the underlying cause of the error. The most common error conditions are:
+For simplicity, nanopb doesn't define it's own error codes. This might be added if there is a compelling need for it. You can however deduce something about the error causes:
-1) Running out of memory, i.e. stack overflow.
+1) Running out of memory. Because everything is allocated from the stack, nanopb can't detect this itself. Encoding or decoding the same type of a message always takes the same amount of stack space. Therefore, if it works once, it works always.
-2) Invalid field descriptors (would usually mean a bug in the generator).
+2) Invalid field description. These are usually stored as constants, so if it works under the debugger, it always does.
-3) IO errors in your own stream callbacks.
+3) IO errors in your own stream callbacks. Because encoding/decoding stops at the first error, you can overwrite the *state* field in the struct and store your own error code there.
-4) Errors that happen in your callback functions.
+4) Errors that happen in your callback functions. You can use the state field in the callback structure.
 5) Exceeding the max_size or bytes_left of a stream.
 6) Exceeding the max_size of a string or array field
-7) Invalid protocol buffers binary message.
+7) Invalid protocol buffers binary message. It's not like you could recover from it anyway, so a simple failure should be enough.
 In my opinion, it is enough that 1. and 2. can be resolved using a debugger.
 However, you may be interested which of the remaining conditions caused the error. For 3. and 4., you can set and check the state. If you have to detect 5. and 6., you should convert the fields to callback type. Any remaining problem is of type 7.
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -36,26 +36,23 @@ Features and limitations
 **Features**
 #) Pure C runtime
-#) Small code size (2–10 kB depending on processor, plus any message definitions)
+#) Small code size (2–10 kB depending on processor)
-#) Small ram usage (typically ~300 bytes, plus any message structs)
+#) Small ram usage (typically 200 bytes)
 #) Allows specifying maximum size for strings and arrays, so that they can be allocated statically.
 #) No malloc needed: everything can be allocated statically or on the stack.
 #) You can use either encoder or decoder alone to cut the code size in half.
 #) Support for most protobuf features, including: all data types, nested submessages, default values, repeated and optional fields, packed arrays, extension fields.
 #) Callback mechanism for handling messages larger than can fit in available RAM.
 #) Extensive set of tests.
 **Limitations**
 #) User must provide callbacks when decoding arrays or strings without maximum size. Malloc support could be added as a separate module.
-#) Some speed has been sacrificed for code size.
+#) Some speed has been sacrificed for code size. For example varint calculations are always done in 64 bits.
 #) Encoding is focused on writing to streams. For memory buffers only it could be made more efficient.
 #) The deprecated Protocol Buffers feature called "groups" is not supported.
 #) Fields in the generated structs are ordered by the tag number, instead of the natural ordering in .proto file.
 #) Unknown fields are not preserved when decoding and re-encoding a message.
 #) Reflection (runtime introspection) is not supported. E.g. you can't request a field by giving its name in a string.
 #) Numeric arrays are always encoded as packed, even if not marked as packed in .proto. This causes incompatibility with decoders that do not support packed format.
-#) Cyclic references between messages are supported only in callback mode.
+#) Cyclic references between messages are not supported. They could be supported in callback-mode if there was an option in the generator to set the mode.
 Getting started
 ===============
@@ -90,37 +87,27 @@ After that, buffer will contain the encoded message.
 The number of bytes in the message is stored in *stream.bytes_written*.
 You can feed the message to *protoc --decode=Example message.proto* to verify its validity.
-For a complete example of the simple case, see *example/simple.c*.
+For complete examples of the simple cases, see *tests/test_decode1.c* and *tests/test_encode1.c*. For an example with network interface, see the *example* subdirectory.
 For a more complex example with network interface, see the *example/network_server* subdirectory.
 Compiler requirements
 =====================
-Nanopb should compile with most ansi-C compatible compilers. It however
+Nanopb should compile with most ansi-C compatible compilers. It however requires a few header files to be available:
 requires a few header files to be available:
 #) *string.h*, with these functions: *strlen*, *memcpy*, *memset*
 #) *stdint.h*, for definitions of *int32_t* etc.
 #) *stddef.h*, for definition of *size_t*
 #) *stdbool.h*, for definition of *bool*
-If these header files do not come with your compiler, you can use the
+If these header files do not come with your compiler, you should be able to find suitable replacements online. Mostly the requirements are very simple, just a few basic functions and typedefs.
 file *compat/pb_syshdr.h* instead. It contains an example of how to provide
 the dependencies. You may have to edit it a bit to suit your custom platform.
-To use the pb_syshdr.h, define *PB_SYSTEM_HEADER* to be the name of your custom
+Debugging and testing
-header file. It should provide all the dependencies listed above.
+=====================
 Extensive unittests are included under the *tests* folder. Just type *make* there to run the tests.
-Running the test cases
+This also generates a file called *breakpoints* which includes all lines returning *false* in nanopb. You can use this in gdb by typing *source breakpoints*, after which gdb will break on first nanopb error.
 ======================
 Extensive unittests and test cases are included under the *tests* folder.
 To build the tests, you will need the `scons`__ build system. The tests should
 be runnable on most platforms. Windows and Linux builds are regularly tested.
 __ http://www.scons.org/
 In addition to the build system, you will also need a working Google Protocol
 Buffers *protoc* compiler, and the Python bindings for Protocol Buffers. On
 Debian-based systems, install the following packages: *protobuf-compiler*,
 *python-protobuf* and *libprotobuf-dev*.
 Wishlist
 ========
 #) A specialized encoder for encoding to a memory buffer. Should serialize in reverse order to avoid having to determine submessage size beforehand.
 #) A cleaner rewrite of the Python-based source generator.
 #) Better performance for 16- and 8-bit platforms: use smaller datatypes where possible.
--- a/docs/reference.rst
+++ b/docs/reference.rst
@@ -6,188 +6,6 @@ Nanopb: API reference
 .. contents ::
 Compilation options
 ===================
 The following options can be specified in one of two ways:
 1. Using the -D switch on the C compiler command line.
 2. By #defining them at the top of pb.h.
 You must have the same settings for the nanopb library and all code that
 includes pb.h.
 ============================  ================================================
 __BIG_ENDIAN__                 Set this if your platform stores integers and
                               floats in big-endian format. Mixed-endian
                               systems (different layout for ints and floats)
                               are currently not supported.
 NANOPB_INTERNALS               Set this to expose the field encoder functions
                               that are hidden since nanopb-0.1.3.
 PB_MAX_REQUIRED_FIELDS         Maximum number of required fields to check for
                               presence. Default value is 64. Increases stack
                               usage 1 byte per every 8 fields. Compiler
                               warning will tell if you need this.
 PB_FIELD_16BIT                 Add support for tag numbers > 255 and fields
                               larger than 255 bytes or 255 array entries.
                               Increases code size 3 bytes per each field.
                               Compiler error will tell if you need this.
 PB_FIELD_32BIT                 Add support for tag numbers > 65535 and fields
                               larger than 65535 bytes or 65535 array entries.
                               Increases code size 9 bytes per each field.
                               Compiler error will tell if you need this.
 PB_NO_ERRMSG                   Disables the support for error messages; only
                               error information is the true/false return
                               value. Decreases the code size by a few hundred
                               bytes.
 PB_BUFFER_ONLY                 Disables the support for custom streams. Only
                               supports encoding and decoding with memory
                               buffers. Speeds up execution and decreases code
                               size slightly.
 PB_OLD_CALLBACK_STYLE          Use the old function signature (void\* instead
                               of void\*\*) for callback fields. This was the
                               default until nanopb-0.2.1.
 PB_SYSTEM_HEADER               Replace the standard header files with a single
                               header file. It should define all the required
                               functions and typedefs listed on the
                               `overview page`_. Value must include quotes,
                               for example *#define PB_SYSTEM_HEADER "foo.h"*.
 ============================  ================================================
 The PB_MAX_REQUIRED_FIELDS, PB_FIELD_16BIT and PB_FIELD_32BIT settings allow
 raising some datatype limits to suit larger messages. Their need is recognized
 automatically by C-preprocessor #if-directives in the generated .pb.h files.
 The default setting is to use the smallest datatypes (least resources used).
 .. _`overview page`: index.html#compiler-requirements
 Proto file options
 ==================
 The generator behaviour can be adjusted using these options, defined in the
 'nanopb.proto' file in the generator folder:
 ============================  ================================================
 max_size                       Allocated size for *bytes* and *string* fields.
 max_count                      Allocated number of entries in arrays
                               (*repeated* fields).
 type                           Type of the generated field. Default value
                               is *FT_DEFAULT*, which selects automatically.
                               You can use *FT_CALLBACK*, *FT_STATIC* or
                               *FT_IGNORE* to force a callback field, a static
                               field or to completely ignore the field.
 long_names                     Prefix the enum name to the enum value in
                               definitions, i.e. *EnumName_EnumValue*. Enabled
                               by default.
 packed_struct                  Make the generated structures packed.
                               NOTE: This cannot be used on CPUs that break
                               on unaligned accesses to variables.
 ============================  ================================================
 These options can be defined for the .proto files before they are converted
 using the nanopb-generatory.py. There are three ways to define the options:
 1. Using a separate .options file.
   This is the preferred way as of nanopb-0.2.1, because it has the best
   compatibility with other protobuf libraries.
 2. Defining the options on the command line of nanopb_generator.py.
   This only makes sense for settings that apply to a whole file.
 3. Defining the options in the .proto file using the nanopb extensions.
   This is the way used in nanopb-0.1, and will remain supported in the
   future. It however sometimes causes trouble when using the .proto file
   with other protobuf libraries.
 The effect of the options is the same no matter how they are given. The most
 common purpose is to define maximum size for string fields in order to
 statically allocate them.
 Defining the options in a .options file
 ---------------------------------------
 The preferred way to define options is to have a separate file
 'myproto.options' in the same directory as the 'myproto.proto'. ::
    # myproto.proto
    message MyMessage {
        required string name = 1;
        repeated int32 ids = 4;
    }
 ::
    # myproto.options
    MyMessage.name         max_size:40
    MyMessage.ids          max_count:5
 The generator will automatically search for this file and read the
 options from it. The file format is as follows:
 * Lines starting with '#' or '//' are regarded as comments.
 * Blank lines are ignored.
 * All other lines should start with a field name pattern, followed by one or
  more options. For example: *"MyMessage.myfield max_size:5 max_count:10"*.
 * The field name pattern is matched against a string of form *'Message.field'*.
  For nested messages, the string is *'Message.SubMessage.field'*.
 * The field name pattern may use the notation recognized by Python fnmatch():
  - *\** matches any part of string, like 'Message.\*' for all fields
  - *\?* matches any single character
  - *[seq]* matches any of characters 's', 'e' and 'q'
  - *[!seq]* matches any other character
 * The options are written as *'option_name:option_value'* and several options
  can be defined on same line, separated by whitespace.
 * Options defined later in the file override the ones specified earlier, so
  it makes sense to define wildcard options first in the file and more specific
  ones later.
 If preferred, the name of the options file can be set using the command line
 switch *-f* to nanopb_generator.py.
 Defining the options on command line
 ------------------------------------
 The nanopb_generator.py has a simple command line option *-s OPTION:VALUE*.
 The setting applies to the whole file that is being processed.
 Defining the options in the .proto file
 ---------------------------------------
 The .proto file format allows defining custom options for the fields.
 The nanopb library comes with *nanopb.proto* which does exactly that, allowing
 you do define the options directly in the .proto file::
    import "nanopb.proto";
    message MyMessage {
        required string name = 1 [(nanopb).max_size = 40];
        repeated int32 ids = 4   [(nanopb).max_count = 5];
    }
 A small complication is that you have to set the include path of protoc so that
 nanopb.proto can be found. This file, in turn, requires the file
 *google/protobuf/descriptor.proto*. This is usually installed under
 */usr/include*. Therefore, to compile a .proto file which uses options, use a
 protoc command similar to::
    protoc -I/usr/include -Inanopb/generator -I. -omessage.pb message.proto
 The options can be defined in file, message and field scopes::
    option (nanopb_fileopt).max_size = 20; // File scope
    message Message
    {
        option (nanopb_msgopt).max_size = 30; // Message scope
        required string fieldsize = 1 [(nanopb).max_size = 40]; // Field scope
    }
 pb.h
 ====
@@ -195,23 +13,22 @@ pb_type_t
 ---------
 Defines the encoder/decoder behaviour that should be used for a field. ::
-    typedef uint8_t pb_type_t;
+    typedef enum { ... } pb_type_t;
-The low-order nibble of the enumeration values defines the function that can be used for encoding and decoding the field data:
+The low-order byte of the enumeration values defines the function that can be used for encoding and decoding the field data:
 ==================== ===== ================================================
 LTYPE identifier     Value Storage format
 ==================== ===== ================================================
 PB_LTYPE_VARINT      0x00  Integer.
 PB_LTYPE_SVARINT     0x01  Integer, zigzag encoded.
-PB_LTYPE_FIXED32     0x02  32-bit integer or floating point.
+PB_LTYPE_FIXED       0x02  Integer or floating point.
-PB_LTYPE_FIXED64     0x03  64-bit integer or floating point.
+PB_LTYPE_BYTES       0x03  Structure with *size_t* field and byte array.
-PB_LTYPE_BYTES       0x04  Structure with *size_t* field and byte array.
+PB_LTYPE_STRING      0x04  Null-terminated string.
-PB_LTYPE_STRING      0x05  Null-terminated string.
+PB_LTYPE_SUBMESSAGE  0x05  Submessage structure.
 PB_LTYPE_SUBMESSAGE  0x06  Submessage structure.
 ==================== ===== ================================================
-The bits 4-5 define whether the field is required, optional or repeated:
+The high-order byte defines whether the field is required, optional, repeated or callback:
 ==================== ===== ================================================
 HTYPE identifier     Value Field handling
@@ -219,24 +36,13 @@ HTYPE identifier     Value Field handling
 PB_HTYPE_REQUIRED    0x00  Verify that field exists in decoded message.
 PB_HTYPE_OPTIONAL    0x10  Use separate *has_<field>* boolean to specify
                           whether the field is present.
-                           (Unless it is a callback)
+PB_HTYPE_ARRAY       0x20  A repeated field with preallocated array.
 PB_HTYPE_REPEATED    0x20  A repeated field with preallocated array.
                           Separate *<field>_count* for number of items.
-                           (Unless it is a callback)
+PB_HTYPE_CALLBACK    0x30  A field with dynamic storage size, data is
                           actually a pointer to a structure containing a
                           callback function.
 ==================== ===== ================================================
 The bits 6-7 define the how the storage for the field is allocated:
 ==================== ===== ================================================
 ATYPE identifier     Value Allocation method
 ==================== ===== ================================================
 PB_ATYPE_STATIC      0x00  Statically allocated storage in the structure.
 PB_ATYPE_CALLBACK    0x40  A field with dynamic storage size. Struct field
                           actually contains a pointer to a callback
                           function.
 ==================== ===== ================================================
 pb_field_t
 ----------
 Describes a single structure field with memory position in relation to others. The descriptions are usually autogenerated. ::
@@ -253,14 +59,14 @@ Describes a single structure field with memory position in relation to others. T
    } pb_packed;
 :tag:           Tag number of the field or 0 to terminate a list of fields.
-:type:          LTYPE, HTYPE and ATYPE of the field.
+:type:          LTYPE and HTYPE of the field.
 :data_offset:   Offset of field data, relative to the end of the previous field.
 :size_offset:   Offset of *bool* flag for optional fields or *size_t* count for arrays, relative to field data.
 :data_size:     Size of a single data entry, in bytes. For PB_LTYPE_BYTES, the size of the byte array inside the containing structure. For PB_HTYPE_CALLBACK, size of the C data type if known.
 :array_size:    Maximum number of entries in an array, if it is an array type.
 :ptr:           Pointer to default value for optional fields, or to submessage description for PB_LTYPE_SUBMESSAGE.
-The *uint8_t* datatypes limit the maximum size of a single item to 255 bytes and arrays to 255 items. Compiler will give error if the values are too large. The types can be changed to larger ones by defining *PB_FIELD_16BIT*.
+The *uint8_t* datatypes limit the maximum size of a single item to 255 bytes and arrays to 255 items. Compiler will warn "Initializer too large for type" if the limits are exceeded. The types can be changed to larger ones if necessary.
 pb_bytes_array_t
 ----------------
@@ -280,16 +86,14 @@ Part of a message structure, for fields with type PB_HTYPE_CALLBACK::
    typedef struct _pb_callback_t pb_callback_t;
    struct _pb_callback_t {
        union {
-            bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void **arg);
+            bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void *arg);
-            bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
+            bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, const void *arg);
        } funcs;
        void *arg;
    };
-A pointer to the *arg* is passed to the callback when calling. It can be used to store any information that the callback might need.
+The *arg* is passed to the callback when calling. It can be used to store any information that the callback might need.
 Previously the function received just the value of *arg* instead of a pointer to it. This old behaviour can be enabled by defining *PB_OLD_CALLBACK_STYLE*.
 When calling `pb_encode`_, *funcs.encode* is used, and similarly when calling `pb_decode`_, *funcs.decode* is used. The function pointers are stored in the same memory location but are of incompatible types. You can set the function pointer to NULL to skip the field.
@@ -304,76 +108,6 @@ Protocol Buffers wire types. These are used with `pb_encode_tag`_. ::
        PB_WT_32BIT  = 5
    } pb_wire_type_t;
 pb_extension_type_t
 -------------------
 Defines the handler functions and auxiliary data for a field that extends
 another message. Usually autogenerated by *nanopb_generator.py*::
    typedef struct {
        bool (*decode)(pb_istream_t *stream, pb_extension_t *extension,
                   uint32_t tag, pb_wire_type_t wire_type);
        bool (*encode)(pb_ostream_t *stream, const pb_extension_t *extension);
        const void *arg;
    } pb_extension_type_t;
 In the normal case, the function pointers are *NULL* and the decoder and
 encoder use their internal implementations. The internal implementations
 assume that *arg* points to a *pb_field_t* that describes the field in question.
 To implement custom processing of unknown fields, you can provide pointers
 to your own functions. Their functionality is mostly the same as for normal
 callback fields, except that they get called for any unknown field when decoding.
 pb_extension_t
 --------------
 Ties together the extension field type and the storage for the field value::
    typedef struct {
        const pb_extension_type_t *type;
        void *dest;
        pb_extension_t *next;
    } pb_extension_t;
 :type:      Pointer to the structure that defines the callback functions.
 :dest:      Pointer to the variable that stores the field value
            (as used by the default extension callback functions.)
 :next:      Pointer to the next extension handler, or *NULL*.
 PB_GET_ERROR
 ------------
 Get the current error message from a stream, or a placeholder string if
 there is no error message::
    #define PB_GET_ERROR(stream) (string expression)
 This should be used for printing errors, for example::
    if (!pb_decode(...))
    {
        printf("Decode failed: %s\n", PB_GET_ERROR(stream));
    }
 The macro only returns pointers to constant strings (in code memory),
 so that there is no need to release the returned pointer.
 PB_RETURN_ERROR
 ---------------
 Set the error message and return false::
    #define PB_RETURN_ERROR(stream,msg) (sets error and returns false)
 This should be used to handle error conditions inside nanopb functions
 and user callback functions::
    if (error_condition)
    {
        PB_RETURN_ERROR(stream, "something went wrong");
    }
 The *msg* parameter must be a constant string.
 pb_encode.h
 ===========
@@ -415,13 +149,17 @@ Encodes the contents of a structure as a protocol buffers message and writes it
 Normally pb_encode simply walks through the fields description array and serializes each field in turn. However, submessages must be serialized twice: first to calculate their size and then to actually write them to output. This causes some constraints for callback fields, which must return the same data on every call.
-.. sidebar:: Encoding fields manually
+pb_encode_varint
 ----------------
 Encodes an unsigned integer in the varint_ format. ::
-    The functions with names *pb_encode_\** are used when dealing with callback fields. The typical reason for using callbacks is to have an array of unlimited size. In that case, `pb_encode`_ will call your callback function, which in turn will call *pb_encode_\** functions repeatedly to write out values.
+    bool pb_encode_varint(pb_ostream_t *stream, uint64_t value);
-    The tag of a field must be encoded separately with `pb_encode_tag_for_field`_. After that, you can call exactly one of the content-writing functions to encode the payload of the field. For repeated fields, you can repeat this process multiple times.
+:stream:        Output stream to write to. 1-10 bytes will be written.
 :value:         Value to encode.
 :returns:       True on success, false on IO error.
-    Writing packed arrays is a little bit more involved: you need to use `pb_encode_tag` and specify `PB_WT_STRING` as the wire type. Then you need to know exactly how much data you are going to write, and use `pb_encode_varint`_ to write out the number of bytes before writing the actual data. Substreams can be used to determine the number of bytes beforehand; see `pb_encode_submessage`_ source code for an example.
+.. _varint: http://code.google.com/apis/protocolbuffers/docs/encoding.html#varints
 pb_encode_tag
 -------------
@@ -431,7 +169,7 @@ Starts a field in the Protocol Buffers binary format: encodes the field number a
 :stream:        Output stream to write to. 1-5 bytes will be written.
 :wiretype:      PB_WT_VARINT, PB_WT_64BIT, PB_WT_STRING or PB_WT_32BIT
-:field_number:  Identifier for the field, defined in the .proto file. You can get it from field->tag.
+:field_number:  Identifier for the field, defined in the .proto file.
 :returns:       True on success, false on IO error.
 pb_encode_tag_for_field
@@ -457,82 +195,107 @@ STRING, BYTES, SUBMESSAGE PB_WT_STRING
 FIXED32                   PB_WT_32BIT
 ========================= ============
 pb_encode_varint
 ----------------
 Encodes a signed or unsigned integer in the varint_ format. Works for fields of type `bool`, `enum`, `int32`, `int64`, `uint32` and `uint64`::
    bool pb_encode_varint(pb_ostream_t *stream, uint64_t value);
 :stream:        Output stream to write to. 1-10 bytes will be written.
 :value:         Value to encode. Just cast e.g. int32_t directly to uint64_t.
 :returns:       True on success, false on IO error.
 .. _varint: http://code.google.com/apis/protocolbuffers/docs/encoding.html#varints
 pb_encode_svarint
 -----------------
 Encodes a signed integer in the 'zig-zagged' format. Works for fields of type `sint32` and `sint64`::
    bool pb_encode_svarint(pb_ostream_t *stream, int64_t value);
 (parameters are the same as for `pb_encode_varint`_
 pb_encode_string
 ----------------
-Writes the length of a string as varint and then contents of the string. Works for fields of type `bytes` and `string`::
+Writes the length of a string as varint and then contents of the string. Used for writing fields with wire type PB_WT_STRING. ::
    bool pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size);
 :stream:        Output stream to write to.
 :buffer:        Pointer to string data.
-:size:          Number of bytes in the string. Pass `strlen(s)` for strings.
+:size:          Number of bytes in the string.
 :returns:       True on success, false on IO error.
-pb_encode_fixed32
+.. sidebar:: Field encoders
 -----------------
 Writes 4 bytes to stream and swaps bytes on big-endian architectures. Works for fields of type `fixed32`, `sfixed32` and `float`::
-    bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
+    The functions with names beginning with *pb_enc_* are called field encoders. Each PB_LTYPE has an own field encoder, which handles translating from C data into Protocol Buffers data.
-:stream:    Output stream to write to.
+    By using the *data_size* in the field description and by taking advantage of C casting rules, it has been possible to combine many data types to a single LTYPE. For example, *int32*, *uint32*, *int64*, *uint64*, *bool* and *enum* are all handled by *pb_enc_varint*.
 :value:     Pointer to a 4-bytes large C variable, for example `uint32_t foo;`.
 :returns:   True on success, false on IO error.
-pb_encode_fixed64
+    Each field encoder only encodes the contents of the field. The tag must be encoded separately with `pb_encode_tag_for_field`_.
 -----------------
 Writes 8 bytes to stream and swaps bytes on big-endian architecture. Works for fields of type `fixed64`, `sfixed64` and `double`::
-    bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
+    You can use the field encoders from your callbacks. Just be aware that the pb_field_t passed to the callback is not directly compatible with most of the encoders. Instead, you must create a new pb_field_t structure and set the data_size according to the data type you pass to *src*.
-:stream:    Output stream to write to.
+pb_enc_varint
-:value:     Pointer to a 8-bytes large C variable, for example `uint64_t foo;`.
+-------------
-:returns:   True on success, false on IO error.
+Field encoder for PB_LTYPE_VARINT. Takes the first *field->data_size* bytes from src, casts them as *uint64_t* and calls `pb_encode_varint`_. ::
-pb_encode_submessage
+    bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 --------------------
 Encodes a submessage field, including the size header for it. Works for fields of any message type::
    bool pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
 :stream:        Output stream to write to.
-:fields:        Pointer to the autogenerated field description array for the submessage type, e.g. `MyMessage_fields`.
+:field:         Field description structure. Only *data_size* matters.
 :src:           Pointer to start of the field data.
 :returns:       True on success, false on IO error.
 pb_enc_svarint
 --------------
 Field encoder for PB_LTYPE_SVARINT. Similar to `pb_enc_varint`_, except first zig-zag encodes the value for more efficient negative number encoding. ::
    bool pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 (parameters are the same as for `pb_enc_varint`_)
 The number is considered negative if the high-order bit of the value is set. On big endian computers, it is the highest bit of *\*src*. On little endian computers, it is the highest bit of *\*(src + field->data_size - 1)*.
 pb_enc_fixed32
 --------------
 Field encoder for PB_LTYPE_FIXED32. Writes the data in little endian order. On big endian computers, reverses the order of bytes. ::
    bool pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 :stream:        Output stream to write to.
 :field:         Not used.
 :src:           Pointer to start of the field data.
 :returns:       True on success, false on IO error.
 pb_enc_fixed64
 --------------
 Field encoder for PB_LTYPE_FIXED64. Writes the data in little endian order. On big endian computers, reverses the order of bytes. ::
    bool pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 (parameters are the same as for `pb_enc_fixed32`_)
 The same function is used for both integers and doubles. This breaks encoding of double values on architectures where they are mixed endian (primarily some arm processors with hardware FPU).
 pb_enc_bytes
 ------------
 Field encoder for PB_LTYPE_BYTES. Just calls `pb_encode_string`_. ::
    bool pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 :stream:        Output stream to write to.
 :field:         Not used.
 :src:           Pointer to a structure similar to pb_bytes_array_t.
 :returns:       True on success, false on IO error.
 This function expects a pointer to a structure with a *size_t* field at start, and a variable sized byte array after it. The platform-specific field offset is inferred from *pb_bytes_array_t*, which has a byte array of size 1.
 pb_enc_string
 -------------
 Field encoder for PB_LTYPE_STRING. Determines size of string with strlen() and then calls `pb_encode_string`_. ::
    bool pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 :stream:        Output stream to write to.
 :field:         Not used.
 :src:           Pointer to a null-terminated string.
 :returns:       True on success, false on IO error.
 pb_enc_submessage
 -----------------
 Field encoder for PB_LTYPE_SUBMESSAGE. Calls `pb_encode`_ to perform the actual encoding. ::
    bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 :stream:        Output stream to write to.
 :field:         Field description structure. The *ptr* field must be a pointer to a field description array for the submessage.
 :src:           Pointer to the structure where submessage data is.
 :returns:       True on success, false on IO errors, pb_encode errors or if submessage size changes between calls.
 In Protocol Buffers format, the submessage size must be written before the submessage contents. Therefore, this function has to encode the submessage twice in order to know the size beforehand.
-If the submessage contains callback fields, the callback function might misbehave and write out a different amount of data on the second call. This situation is recognized and *false* is returned, but garbage will be written to the output before the problem is detected.
+If the submessage contains callback fields, the callback function might misbehave and write out a different amount of data on the second call. This situation is recognized and *false* is returned, but it is up to the caller to ensure that the receiver of the message does not interpret it as valid data.
 pb_decode.h
 ===========
@@ -560,32 +323,15 @@ Read data from input stream. Always use this function, don't try to call the str
 End of file is signalled by *stream->bytes_left* being zero after pb_read returns false.
-pb_decode
+pb_decode_varint
 ---------
 Read and decode all fields of a structure. Reads until EOF on input stream. ::
    bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
 :stream:        Input stream to read from.
 :fields:        A field description array. Usually autogenerated.
 :dest_struct:   Pointer to structure where data will be stored.
 :returns:       True on success, false on IO error, on detectable errors in field description, if a field encoder returns false or if a required field is missing.
 In Protocol Buffers binary format, EOF is only allowed between fields. If it happens anywhere else, pb_decode will return *false*. If pb_decode returns false, you cannot trust any of the data in the structure.
 In addition to EOF, the pb_decode implementation supports terminating a message with a 0 byte. This is compatible with the official Protocol Buffers because 0 is never a valid field tag.
 For optional fields, this function applies the default value and sets *has_<field>* to false if the field is not present.
 pb_decode_noinit
 ----------------
-Same as `pb_decode`_, except does not apply the default values to fields. ::
+Read and decode a varint_ encoded integer. ::
-    bool pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
+    bool pb_decode_varint(pb_istream_t *stream, uint64_t *dest);
-(parameters are the same as for `pb_decode`_.)
+:stream:        Input stream to read from. 1-10 bytes will be read.
-
+:dest:          Storage for the decoded integer. Value is undefined on error.
-The destination structure should be filled with zeros before calling this function. Doing a *memset* manually can be slightly faster than using `pb_decode`_ if you don't need any default values.
+:returns:       True on success, false if value exceeds uint64_t range or an IO error happens.
 pb_skip_varint
 --------------
@@ -605,66 +351,67 @@ Skip a varint-length-prefixed string. This means skipping a value with wire type
 :stream:        Input stream to read from.
 :returns:       True on success, false on IO error or length exceeding uint32_t.
-pb_decode_tag
+pb_decode
-------------
+---------
-Decode the tag that comes before field in the protobuf encoding::
+Read and decode all fields of a structure. Reads until EOF on input stream. ::
-    bool pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, int *tag, bool *eof);
+    bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
 :stream:        Input stream to read from.
-:wire_type:     Pointer to variable where to store the wire type of the field.
+:fields:        A field description array. Usually autogenerated.
-:tag:           Pointer to variable where to store the tag of the field.
+:dest_struct:   Pointer to structure where data will be stored.
-:eof:           Pointer to variable where to store end-of-file status.
+:returns:       True on success, false on IO error, on detectable errors in field description, if a field encoder returns false or if a required field is missing.
 :returns:       True on success, false on error or EOF.
-When the message (stream) ends, this function will return false and set *eof* to true. On other
+In Protocol Buffers binary format, EOF is only allowed between fields. If it happens anywhere else, pb_decode will return *false*. If pb_decode returns false, you cannot trust any of the data in the structure.
 errors, *eof* will be set to false.
-pb_skip_field
+In addition to EOF, the pb_decode implementation supports terminating a message with a 0 byte. This is compatible with the official Protocol Buffers because 0 is never a valid field tag.
 -------------
 Remove the data for a field from the stream, without actually decoding it::
-    bool pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type);
+For optional fields, this function applies the default value and sets *has_<field>* to false if the field is not present.
-:stream:        Input stream to read from.
+Because of memory concerns, the detection of missing required fields is not perfect if the structure contains more than 32 fields.
 :wire_type:     Type of field to skip.
 :returns:       True on success, false on IO error.
-.. sidebar:: Decoding fields manually
+.. sidebar:: Field decoders
-    The functions with names beginning with *pb_decode_* are used when dealing with callback fields. The typical reason for using callbacks is to have an array of unlimited size. In that case, `pb_decode`_ will call your callback function repeatedly, which can then store the values into e.g. filesystem in the order received in.
+    The functions with names beginning with *pb_dec_* are called field decoders. Each PB_LTYPE has an own field decoder, which handles translating from Protocol Buffers data to C data.
-    For decoding numeric (including enumerated and boolean) values, use `pb_decode_varint`_, `pb_decode_svarint`_, `pb_decode_fixed32`_ and `pb_decode_fixed64`_. They take a pointer to a 32- or 64-bit C variable, which you may then cast to smaller datatype for storage.
+    Each field decoder reads and decodes a single value. For arrays, the decoder is called repeatedly.
-    For decoding strings and bytes fields, the length has already been decoded. You can therefore check the total length in *stream->bytes_left* and read the data using `pb_read`_.
+    You can use the decoders from your callbacks. Just be aware that the pb_field_t passed to the callback is not directly compatible 
    with the *varint* field decoders. Instead, you must create a new pb_field_t structure and set the data_size according to the data type 
    you pass to *dest*, e.g. *field.data_size = sizeof(int);*. Other fields in the *pb_field_t* don't matter.
-    Finally, for decoding submessages in a callback, simply use `pb_decode`_ and pass it the *SubMessage_fields* descriptor array.
+    The field decoder interface is a bit messy as a result of the interface required inside the nanopb library.
    Eventually they may be replaced by separate wrapper functions with a more friendly interface.
-pb_decode_varint
+pb_dec_varint
----------------
+-------------
-Read and decode a varint_ encoded integer. ::
+Field decoder for PB_LTYPE_VARINT. ::
-    bool pb_decode_varint(pb_istream_t *stream, uint64_t *dest);
+    bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 :stream:        Input stream to read from. 1-10 bytes will be read.
-:dest:          Storage for the decoded integer. Value is undefined on error.
+:field:         Field description structure. Only *field->data_size* matters.
-:returns:       True on success, false if value exceeds uint64_t range or an IO error happens.
+:dest:          Pointer to destination integer. Must have size of *field->data_size* bytes.
 :returns:       True on success, false on IO errors or if `pb_decode_varint`_ fails.
-pb_decode_svarint
+This function first calls `pb_decode_varint`_. It then copies the first bytes of the 64-bit result value to *dest*, or on big endian architectures, the last bytes.
 -----------------
 Similar to `pb_decode_varint`_, except that it performs zigzag-decoding on the value. This corresponds to the Protocol Buffers *sint32* and *sint64* datatypes. ::
-    bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest);
+pb_dec_svarint
 --------------
 Field decoder for PB_LTYPE_SVARINT. Similar to `pb_dec_varint`_, except that it performs zigzag-decoding on the value. ::
-(parameters are the same as `pb_decode_varint`_)
+    bool pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest);
-pb_decode_fixed32
+(parameters are the same as `pb_dec_varint`_)
 -----------------
 Decode a *fixed32*, *sfixed32* or *float* value. ::
-    bool pb_decode_fixed32(pb_istream_t *stream, void *dest);
+pb_dec_fixed32
 --------------
 Field decoder for PB_LTYPE_FIXED32. ::
    bool pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest);
 :stream:        Input stream to read from. 4 bytes will be read.
 :field:         Not used.
 :dest:          Pointer to destination *int32_t*, *uint32_t* or *float*.
 :returns:       True on success, false on IO errors.
@@ -672,9 +419,9 @@ This function reads 4 bytes from the input stream.
 On big endian architectures, it then reverses the order of the bytes.
 Finally, it writes the bytes to *dest*.
-pb_decode_fixed64
+pb_dec_fixed64
-----------------
+--------------
-Decode a *fixed64*, *sfixed64* or *double* value. ::
+Field decoder for PB_LTYPE_FIXED64. ::
    bool pb_dec_fixed(pb_istream_t *stream, const pb_field_t *field, void *dest);
@@ -683,28 +430,53 @@ Decode a *fixed64*, *sfixed64* or *double* value. ::
 :dest:          Pointer to destination *int64_t*, *uint64_t* or *double*.
 :returns:       True on success, false on IO errors.
-Same as `pb_decode_fixed32`_, except this reads 8 bytes.
+Same as `pb_dec_fixed32`_, except this reads 8 bytes.
-pb_make_string_substream
+pb_dec_bytes
------------------------
+------------
-Decode the length for a field with wire type *PB_WT_STRING* and create a substream for reading the data. ::
+Field decoder for PB_LTYPE_BYTES. Reads a length-prefixed block of bytes. ::
-    bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream);
+    bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest);
-:stream:        Original input stream to read the length and data from.
+**Note:** This is an internal function that is not useful in decoder callbacks. To read bytes fields in callbacks, use 
-:substream:     New substream that has limited length. Filled in by the function.
+*stream->bytes_left* and `pb_read`_.
 :returns:       True on success, false if reading the length fails.
-This function uses `pb_decode_varint`_ to read an integer from the stream. This is interpreted as a number of bytes, and the substream is set up so that its `bytes_left` is initially the same as the length, and its callback function and state the same as the parent stream.
+:stream:        Input stream to read from.
 :field:         Field description structure. Only *field->data_size* matters.
 :dest:          Pointer to a structure similar to pb_bytes_array_t.
 :returns:       True on success, false on IO error or if length exceeds the array size.
-pb_close_string_substream
+This function expects a pointer to a structure with a *size_t* field at start, and a variable sized byte array after it. It will deduce the maximum size of the array from *field->data_size*.
 -------------------------
 Close the substream created with `pb_make_string_substream`_. ::
-    void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream);
+pb_dec_string
 -------------
 Field decoder for PB_LTYPE_STRING. Reads a length-prefixed string. ::
-:stream:        Original input stream to read the length and data from.
+    bool pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest);
-:substream:     Substream to close
+
 **Note:** This is an internal function that is not useful in decoder callbacks. To read string fields in callbacks, use 
 *stream->bytes_left* and `pb_read`_.
 :stream:        Input stream to read from.
 :field:         Field description structure. Only *field->data_size* matters.
 :dest:          Pointer to a character array of size *field->data_size*.
 :returns:       True on success, false on IO error or if length exceeds the array size.
 This function null-terminates the string when successful. On error, the contents of the destination array is undefined.
 pb_dec_submessage
 -----------------
 Field decoder for PB_LTYPE_SUBMESSAGE. Calls `pb_decode`_ to perform the actual decoding. ::
    bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 **Note:** This is an internal function that is not useful in decoder callbacks. To read submessage fields in callbacks, use 
 `pb_decode`_ directly.
 :stream:        Input stream to read from.
 :field:         Field description structure. Only *field->ptr* matters.
 :dest:          Pointer to the destination structure.
 :returns:       True on success, false on IO error or if `pb_decode`_ fails.
 The *field->ptr* should be a pointer to *pb_field_t* array describing the submessage.
 This function copies back the state from the substream to the parent stream.
 It must be called after done with the substream.
--- a/example/Makefile
+++ b/example/Makefile
@@ -0,0 +1,24 @@
 CFLAGS=-ansi -Wall -Werror -I .. -g -O0
 DEPS=../pb_decode.c ../pb_decode.h ../pb_encode.c ../pb_field.c ../pb_encode.h ../pb.h ../pb_field.h
 CC_VER := $(shell gcc --version | grep gcc)
 ifneq "$(CC_VER)" ""
 CFLAGS += -m32
 endif
 ifndef PB_PATH
 PBPATHOPT=-I/usr/include -I/usr/local/include
 else
 PBPATHOPT=-I$(PB_PATH)
 endif
 all: server client
 clean:
 	rm -f server client fileproto.pb.c fileproto.pb.h fileproto.pb
 %: %.c $(DEPS) fileproto.pb.h fileproto.pb.c
 	$(CC) $(CFLAGS) -o $@ $< ../pb_decode.c ../pb_encode.c ../pb_field.c fileproto.pb.c common.c
 fileproto.pb.c fileproto.pb.h: fileproto.proto ../generator/nanopb_generator.py
 	protoc -I. -I../generator $(PBPATHOPT) -ofileproto.pb $<
 	python ../generator/nanopb_generator.py fileproto.pb
--- a/examples/network_server/client.c
+++ b/examples/network_server/client.c
@@ -23,14 +23,14 @@
 #include "fileproto.pb.h"
 #include "common.h"
-bool printfile_callback(pb_istream_t *stream, const pb_field_t *field, void **arg)
+bool printfile_callback(pb_istream_t *stream, const pb_field_t *field, void *arg)
 {
    FileInfo fileinfo;
    if (!pb_decode(stream, FileInfo_fields, &fileinfo))
        return false;
-    printf("%-10lld %s\n", (long long)fileinfo.inode, fileinfo.name);
+    printf("%-10lld %s\n", fileinfo.inode, fileinfo.name);
    return true;
 }
@@ -72,7 +72,7 @@ bool listdir(int fd, char *path)
    if (!pb_decode(&input, ListFilesResponse_fields, &response))
    {
-        fprintf(stderr, "Decode failed: %s\n", PB_GET_ERROR(&input));
+        fprintf(stderr, "Decoding failed.\n");
        return false;
    }
--- a/examples/network_server/common.c
+++ b/examples/network_server/common.c
@@ -10,15 +10,24 @@
 static bool write_callback(pb_ostream_t *stream, const uint8_t *buf, size_t count)
 {
-    int fd = (intptr_t)stream->state;
+    int fd = (int)stream->state;
    return send(fd, buf, count, 0) == count;
 }
 static bool read_callback(pb_istream_t *stream, uint8_t *buf, size_t count)
 {
-    int fd = (intptr_t)stream->state;
+    int fd = (int)stream->state;
    int result;
    if (buf == NULL)
    {
        /* Well, this is a really inefficient way to skip input. */
        /* It is only used when there are unknown fields. */
        char dummy;
        while (count-- && recv(fd, &dummy, 1, 0) == 1);
        return count == 0;
    }
    result = recv(fd, buf, count, MSG_WAITALL);
    if (result == 0)
@@ -29,12 +38,12 @@ static bool read_callback(pb_istream_t *stream, uint8_t *buf, size_t count)
 pb_ostream_t pb_ostream_from_socket(int fd)
 {
-    pb_ostream_t stream = {&write_callback, (void*)(intptr_t)fd, SIZE_MAX, 0};
+    pb_ostream_t stream = {&write_callback, (void*)fd, SIZE_MAX, 0};
    return stream;
 }
 pb_istream_t pb_istream_from_socket(int fd)
 {
-    pb_istream_t stream = {&read_callback, (void*)(intptr_t)fd, SIZE_MAX};
+    pb_istream_t stream = {&read_callback, (void*)fd, SIZE_MAX};
    return stream;
 }
--- a/examples/network_server/common.h
+++ b/examples/network_server/common.h
@@ -6,4 +6,5 @@
 pb_ostream_t pb_ostream_from_socket(int fd);
 pb_istream_t pb_istream_from_socket(int fd);
-#endif
+#endif
--- a/example/fileproto.proto
+++ b/example/fileproto.proto
@@ -0,0 +1,26 @@
 import "nanopb.proto";
 // This defines protocol for a simple server that lists files.
 //
 // If you come from high-level programming background, the hardcoded
 // maximum lengths may disgust you. However, if your microcontroller only
 // has a few kB of ram to begin with, setting reasonable limits for
 // filenames is ok.
 //
 // On the other hand, using the callback interface, it is not necessary
 // to set a limit on the number of files in the response.
 message ListFilesRequest {
    optional string path = 1 [default = "/", (nanopb).max_size = 128];
 }
 message FileInfo {
    required uint64 inode = 1;
    required string name = 2 [(nanopb).max_size = 128];
 }
 message ListFilesResponse {
    optional bool path_error = 1 [default = false];
    repeated FileInfo file = 2;
 }
--- a/examples/network_server/server.c
+++ b/examples/network_server/server.c
@@ -23,9 +23,9 @@
 #include "fileproto.pb.h"
 #include "common.h"
-bool listdir_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
+bool listdir_callback(pb_ostream_t *stream, const pb_field_t *field, const void *arg)
 {
-    DIR *dir = (DIR*) *arg;
+    DIR *dir = (DIR*) arg;
    struct dirent *file;
    FileInfo fileinfo;
@@ -38,7 +38,7 @@ bool listdir_callback(pb_ostream_t *stream, const pb_field_t *field, void * cons
        if (!pb_encode_tag_for_field(stream, field))
            return false;
-        if (!pb_encode_submessage(stream, FileInfo_fields, &fileinfo))
+        if (!pb_enc_submessage(stream, field, &fileinfo))
            return false;
    }
@@ -55,7 +55,7 @@ void handle_connection(int connfd)
    if (!pb_decode(&input, ListFilesRequest_fields, &request))
    {
-        printf("Decode failed: %s\n", PB_GET_ERROR(&input));
+        printf("Decoding failed.\n");
        return;
    }
--- a/examples/network_server/Makefile
+++ b/examples/network_server/Makefile
@@ -1,19 +0,0 @@
 CFLAGS = -ansi -Wall -Werror -g -O0
 # Path to the nanopb root folder
 NANOPB_DIR = ../..
 DEPS = $(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_decode.h \
       $(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_encode.h $(NANOPB_DIR)/pb.h
 CFLAGS += -I$(NANOPB_DIR)
 all: server client
 clean:
 	rm -f server client fileproto.pb.c fileproto.pb.h
 %: %.c $(DEPS) fileproto.pb.h fileproto.pb.c
 	$(CC) $(CFLAGS) -o $@ $< $(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_encode.c fileproto.pb.c common.c
 fileproto.pb.c fileproto.pb.h: fileproto.proto $(NANOPB_DIR)/generator/nanopb_generator.py
 	protoc -ofileproto.pb $<
 	python $(NANOPB_DIR)/generator/nanopb_generator.py fileproto.pb
--- a/examples/network_server/README
+++ b/examples/network_server/README
@@ -1,60 +0,0 @@
 Nanopb example "network_server"
 ===============================
 This example demonstrates the use of nanopb to communicate over network
 connections. It consists of a server that sends file listings, and of
 a client that requests the file list from the server.
 Example usage
 -------------
 user@host:~/nanopb/examples/network_server$ make        # Build the example
 protoc -ofileproto.pb fileproto.proto
 python ../../generator/nanopb_generator.py fileproto.pb
 Writing to fileproto.pb.h and fileproto.pb.c
 cc -ansi -Wall -Werror -I .. -g -O0 -I../.. -o server server.c
    ../../pb_decode.c ../../pb_encode.c fileproto.pb.c common.c
 cc -ansi -Wall -Werror -I .. -g -O0 -I../.. -o client client.c
    ../../pb_decode.c ../../pb_encode.c fileproto.pb.c common.c
 user@host:~/nanopb/examples/network_server$ ./server &  # Start the server on background
 [1] 24462
 petteri@oddish:~/nanopb/examples/network_server$ ./client /bin  # Request the server to list /bin
 Got connection.
 Listing directory: /bin
 1327119    bzdiff
 1327126    bzless
 1327147    ps
 1327178    ntfsmove
 1327271    mv
 1327187    mount
 1327259    false
 1327266    tempfile
 1327285    zfgrep
 1327165    gzexe
 1327204    nc.openbsd
 1327260    uname
 Details of implementation
 -------------------------
 fileproto.proto contains the portable Google Protocol Buffers protocol definition.
 It could be used as-is to implement a server or a client in any other language, for
 example Python or Java.
 fileproto.options contains the nanopb-specific options for the protocol file. This
 sets the amount of space allocated for file names when decoding messages.
 common.c/h contains functions that allow nanopb to read and write directly from
 network socket. This way there is no need to allocate a separate buffer to store
 the message.
 server.c contains the code to open a listening socket, to respond to clients and
 to list directory contents.
 client.c contains the code to connect to a server, to send a request and to print
 the response message.
 The code is implemented using the POSIX socket api, but it should be easy enough
 to port into any other socket api, such as lwip.
--- a/examples/network_server/fileproto.options
+++ b/examples/network_server/fileproto.options
@@ -1,13 +0,0 @@
 # This file defines the nanopb-specific options for the messages defined
 # in fileproto.proto.
 #
 # If you come from high-level programming background, the hardcoded
 # maximum lengths may disgust you. However, if your microcontroller only
 # has a few kB of ram to begin with, setting reasonable limits for
 # filenames is ok.
 #
 # On the other hand, using the callback interface, it is not necessary
 # to set a limit on the number of files in the response.
 ListFilesRequest.path 	max_size:128
 FileInfo.name 		max_size:128
--- a/examples/network_server/fileproto.proto
+++ b/examples/network_server/fileproto.proto
@@ -1,18 +0,0 @@
 // This defines protocol for a simple server that lists files.
 //
 // See also the nanopb-specific options in fileproto.options.
 message ListFilesRequest {
    optional string path = 1 [default = "/"];
 }
 message FileInfo {
    required uint64 inode = 1;
    required string name = 2;
 }
 message ListFilesResponse {
    optional bool path_error = 1 [default = false];
    repeated FileInfo file = 2;
 }
--- a/examples/simple/Makefile
+++ b/examples/simple/Makefile
@@ -1,22 +0,0 @@
 # Compiler flags to enable all warnings & debug info
 CFLAGS = -Wall -Werror -g -O0
 # Path to the nanopb root folder
 NANOPB_DIR = ../..
 CFLAGS += -I$(NANOPB_DIR)
 # C source code files that are required
 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
 # Build rule for the main program
 simple: $(CSRC)
 	$(CC) $(CFLAGS) -osimple $(CSRC)
 # Build rule for the protocol
 simple.pb.c: simple.proto
 	protoc -osimple.pb simple.proto
 	python $(NANOPB_DIR)/generator/nanopb_generator.py simple.pb
--- a/examples/simple/README
+++ b/examples/simple/README
@@ -1,30 +0,0 @@
 Nanopb example "simple"
 =======================
 This example demonstrates the very basic use of nanopb. It encodes and
 decodes a simple message.
 The code uses four different API functions:
  * pb_ostream_from_buffer() to declare the output buffer that is to be used
  * pb_encode() to encode a message
  * pb_istream_from_buffer() to declare the input buffer that is to be used
  * pb_decode() to decode a message
 Example usage
 -------------
 On Linux, simply type "make" to build the example. After that, you can
 run it with the command: ./simple
 On other platforms, you first have to compile the protocol definition using
 the following two commands::
  protoc -osimple.pb simple.proto
  python nanopb_generator.py simple.pb
 After that, add the following four files to your project and compile:
  simple.c  simple.pb.c  pb_encode.c  pb_decode.c
--- a/examples/simple/simple.c
+++ b/examples/simple/simple.c
@@ -1,68 +0,0 @@
 #include <stdio.h>
 #include <pb_encode.h>
 #include <pb_decode.h>
 #include "simple.pb.h"
 int main()
 {
    /* This is the buffer where we will store our message. */
    uint8_t buffer[128];
    size_t message_length;
    bool status;
    /* Encode our message */
    {
        /* Allocate space on the stack to store the message data.
         *
         * Nanopb generates simple struct definitions for all the messages.
         * - check out the contents of simple.pb.h! */
        SimpleMessage message;
        /* Create a stream that will write to our buffer. */
        pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
        /* Fill in the lucky number */
        message.lucky_number = 13;
        /* Now we are ready to encode the message! */
        status = pb_encode(&stream, SimpleMessage_fields, &message);
        message_length = stream.bytes_written;
        /* Then just check for any errors.. */
        if (!status)
        {
            printf("Encoding failed: %s\n", PB_GET_ERROR(&stream));
            return 1;
        }
    }
    /* Now we could transmit the message over network, store it in a file or
     * wrap it to a pigeon's leg.
     */
    /* But because we are lazy, we will just decode it immediately. */
    {
        /* Allocate space for the decoded message. */
        SimpleMessage message;
        /* Create a stream that reads from the buffer. */
        pb_istream_t stream = pb_istream_from_buffer(buffer, message_length);
        /* Now we are ready to decode the message. */
        status = pb_decode(&stream, SimpleMessage_fields, &message);
        /* Check for errors... */
        if (!status)
        {
            printf("Decoding failed: %s\n", PB_GET_ERROR(&stream));
            return 1;
        }
        /* Print the data contained in the message. */
        printf("Your lucky number was %d!\n", message.lucky_number);
    }
    return 0;
 }
--- a/examples/simple/simple.proto
+++ b/examples/simple/simple.proto
@@ -1,7 +0,0 @@
 // A very simple protocol definition, consisting of only
 // one message.
 message SimpleMessage {
    required int32 lucky_number = 1;
 }
--- a/examples/using_double_on_avr/Makefile
+++ b/examples/using_double_on_avr/Makefile
@@ -1,29 +0,0 @@
 CFLAGS = -Wall -Werror -g -O0
 # Path to the nanopb root directory
 NANOPB_DIR = ../..
 DEPS = double_conversion.c $(NANOPB_DIR)/pb.h \
 	$(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_decode.h \
 	$(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_encode.h
 CFLAGS += -I$(NANOPB_DIR)
 all: run_tests
 clean:
 	rm -f test_conversions encode_double decode_double doubleproto.pb.c doubleproto.pb.h
 test_conversions: test_conversions.c double_conversion.c
 	$(CC) $(CFLAGS) -o $@ $^
 %: %.c $(DEPS) doubleproto.pb.h doubleproto.pb.c
 	$(CC) $(CFLAGS) -o $@ $< double_conversion.c \
 		$(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_encode.c doubleproto.pb.c
 doubleproto.pb.c doubleproto.pb.h: doubleproto.proto $(NANOPB_DIR)/generator/nanopb_generator.py
 	protoc -odoubleproto.pb $<
 	python $(NANOPB_DIR)/generator/nanopb_generator.py doubleproto.pb
 run_tests: test_conversions encode_double decode_double
 	./test_conversions
 	./encode_double | ./decode_double
--- a/examples/using_double_on_avr/README
+++ b/examples/using_double_on_avr/README
@@ -1,25 +0,0 @@
 Nanopb example "using_double_on_avr"
 ====================================
 Some processors/compilers, such as AVR-GCC, do not support the double
 datatype. Instead, they have sizeof(double) == 4. Because protocol
 binary format uses the double encoding directly, this causes trouble
 if the protocol in .proto requires double fields.
 This directory contains a solution to this problem. It uses uint64_t
 to store the raw wire values, because its size is correct on all
 platforms. The file double_conversion.c provides functions that
 convert these values to/from floats, without relying on compiler
 support.
 To use this method, you need to make some modifications to your code:
 1) Change all 'double' fields into 'fixed64' in the .proto.
 2) Whenever writing to a 'double' field, use float_to_double().
 3) Whenever reading a 'double' field, use double_to_float().
 The conversion routines are as accurate as the float datatype can
 be. Furthermore, they should handle all special values (NaN, inf, denormalized
 numbers) correctly. There are testcases in test_conversions.c.
--- a/examples/using_double_on_avr/decode_double.c
+++ b/examples/using_double_on_avr/decode_double.c
@@ -1,33 +0,0 @@
 /* Decodes a double value into a float variable.
 * Used to read double values with AVR code, which doesn't support double directly.
 */
 #include <stdio.h>
 #include <pb_decode.h>
 #include "double_conversion.h"
 #include "doubleproto.pb.h"
 int main()
 {
    uint8_t buffer[32];
    size_t count = fread(buffer, 1, sizeof(buffer), stdin);
    pb_istream_t stream = pb_istream_from_buffer(buffer, count);
    AVRDoubleMessage message;
    pb_decode(&stream, AVRDoubleMessage_fields, &message);
    float v1 = double_to_float(message.field1);
    float v2 = double_to_float(message.field2);
    printf("Values: %f %f\n", v1, v2);
    if (v1 == 1234.5678f &&
        v2 == 0.00001f)
    {
        return 0;
    }
    else
    {
        return 1;
    }
 }
--- a/examples/using_double_on_avr/double_conversion.c
+++ b/examples/using_double_on_avr/double_conversion.c
@@ -1,123 +0,0 @@
 /* Conversion routines for platforms that do not support 'double' directly. */
 #include "double_conversion.h"
 #include <math.h>
 typedef union {
    float f;
    uint32_t i;
 } conversion_t;
 /* Note: IEE 754 standard specifies float formats as follows:
 * Single precision: sign,  8-bit exp, 23-bit frac.
 * Double precision: sign, 11-bit exp, 52-bit frac.
 */
 uint64_t float_to_double(float value)
 {
    conversion_t in;
    in.f = value;
    uint8_t sign;
    int16_t exponent;
    uint64_t mantissa;
    /* Decompose input value */
    sign = (in.i >> 31) & 1;
    exponent = ((in.i >> 23) & 0xFF) - 127;
    mantissa = in.i & 0x7FFFFF;
    if (exponent == 128)
    {
        /* Special value (NaN etc.) */
        exponent = 1024;
    }
    else if (exponent == -127)
    {
        if (!mantissa)
        {
            /* Zero */
            exponent = -1023;
        }
        else
        {
            /* Denormalized */
            mantissa <<= 1;
            while (!(mantissa & 0x800000))
            {
                mantissa <<= 1;
                exponent--;
            }
            mantissa &= 0x7FFFFF;
        }
    }
    /* Combine fields */
    mantissa <<= 29;
    mantissa |= (uint64_t)(exponent + 1023) << 52;
    mantissa |= (uint64_t)sign << 63;
    return mantissa;
 }
 float double_to_float(uint64_t value)
 {
    uint8_t sign;
    int16_t exponent;
    uint32_t mantissa;
    conversion_t out;
    /* Decompose input value */
    sign = (value >> 63) & 1;
    exponent = ((value >> 52) & 0x7FF) - 1023;
    mantissa = (value >> 28) & 0xFFFFFF; /* Highest 24 bits */
    /* Figure if value is in range representable by floats. */
    if (exponent == 1024)
    {
        /* Special value */
        exponent = 128;
    }
    else if (exponent > 127)
    {
        /* Too large */        
        if (sign)
            return -INFINITY;
        else
            return INFINITY;
    }
    else if (exponent < -150)
    {
        /* Too small */
        if (sign)
            return -0.0f;
        else
            return 0.0f;
    }
    else if (exponent < -126)
    {
        /* Denormalized */
        mantissa |= 0x1000000;
        mantissa >>= (-126 - exponent);
        exponent = -127;
    }
    /* Round off mantissa */
    mantissa = (mantissa + 1) >> 1;
    /* Check if mantissa went over 2.0 */
    if (mantissa & 0x800000)
    {
        exponent += 1;
        mantissa &= 0x7FFFFF;
        mantissa >>= 1;
    }
    /* Combine fields */
    out.i = mantissa;
    out.i |= (uint32_t)(exponent + 127) << 23;
    out.i |= (uint32_t)sign << 31;
    return out.f;
 }
--- a/examples/using_double_on_avr/double_conversion.h
+++ b/examples/using_double_on_avr/double_conversion.h
@@ -1,26 +0,0 @@
 /* AVR-GCC does not have real double datatype. Instead its double
 * is equal to float, i.e. 32 bit value. If you need to communicate
 * with other systems that use double in their .proto files, you
 * need to do some conversion.
 *
 * These functions use bitwise operations to mangle floats into doubles
 * and then store them in uint64_t datatype.
 */
 #ifndef DOUBLE_CONVERSION
 #define DOUBLE_CONVERSION
 #include <stdint.h>
 /* Convert native 4-byte float into a 8-byte double. */
 extern uint64_t float_to_double(float value);
 /* Convert 8-byte double into native 4-byte float.
 * Values are rounded to nearest, 0.5 away from zero.
 * Overflowing values are converted to Inf or -Inf.
 */
 extern float double_to_float(uint64_t value);
 #endif
--- a/examples/using_double_on_avr/doubleproto.proto
+++ b/examples/using_double_on_avr/doubleproto.proto
@@ -1,13 +0,0 @@
 // A message containing doubles, as used by other applications.
 message DoubleMessage {
    required double field1 = 1;
    required double field2 = 2;
 }
 // A message containing doubles, but redefined using uint64_t.
 // For use in AVR code.
 message AVRDoubleMessage {
    required fixed64 field1 = 1;
    required fixed64 field2 = 2;
 }
--- a/examples/using_double_on_avr/encode_double.c
+++ b/examples/using_double_on_avr/encode_double.c
@@ -1,25 +0,0 @@
 /* Encodes a float value into a double on the wire.
 * Used to emit doubles from AVR code, which doesn't support double directly.
 */
 #include <stdio.h>
 #include <pb_encode.h>
 #include "double_conversion.h"
 #include "doubleproto.pb.h"
 int main()
 {
    AVRDoubleMessage message = {
        float_to_double(1234.5678f),
        float_to_double(0.00001f)
    };
    uint8_t buffer[32];
    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    pb_encode(&stream, AVRDoubleMessage_fields, &message);
    fwrite(buffer, 1, stream.bytes_written, stdout);
    return 0;
 }
--- a/examples/using_double_on_avr/test_conversions.c
+++ b/examples/using_double_on_avr/test_conversions.c
@@ -1,56 +0,0 @@
 #include "double_conversion.h"
 #include <math.h>
 #include <stdio.h>
 static const double testvalues[] = {
           0.0,        -0.0,         0.1,         -0.1,
          M_PI,       -M_PI,  123456.789,  -123456.789,
      INFINITY,   -INFINITY,         NAN, INFINITY - INFINITY,
          1e38,       -1e38,        1e39,        -1e39,
         1e-38,      -1e-38,       1e-39,       -1e-39,
   3.14159e-37,-3.14159e-37, 3.14159e-43, -3.14159e-43,
         1e-60,      -1e-60,       1e-45,       -1e-45,
    0.99999999999999, -0.99999999999999, 127.999999999999, -127.999999999999
 };
 #define TESTVALUES_COUNT (sizeof(testvalues)/sizeof(testvalues[0]))
 int main()
 {
    int status = 0;
    int i;
    for (i = 0; i < TESTVALUES_COUNT; i++)
    {
        double orig = testvalues[i];
        float expected_float = (float)orig;
        double expected_double = (double)expected_float;
        float got_float = double_to_float(*(uint64_t*)&orig);
        uint64_t got_double = float_to_double(got_float);
        uint32_t e1 = *(uint32_t*)&expected_float;
        uint32_t g1 = *(uint32_t*)&got_float;
        uint64_t e2 = *(uint64_t*)&expected_double;
        uint64_t g2 = got_double;
        if (g1 != e1)
        {
            printf("%3d double_to_float fail: %08x != %08x\n", i, g1, e1);
            status = 1;
        }
        if (g2 != e2)
        {
            printf("%3d float_to_double fail: %016llx != %016llx\n", i,
                (unsigned long long)g2,
                (unsigned long long)e2);
            status = 1;
        }
    }
    return status;
 }
--- a/examples/using_union_messages/Makefile
+++ b/examples/using_union_messages/Makefile
@@ -1,22 +0,0 @@
 CFLAGS = -ansi -Wall -Werror -g -O0
 # Path to the nanopb root folder
 NANOPB_DIR = ../..
 DEPS = $(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_decode.h \
       $(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_encode.h $(NANOPB_DIR)/pb.h
 CFLAGS += -I$(NANOPB_DIR)
 all: encode decode
 	./encode 1 | ./decode
 	./encode 2 | ./decode
 	./encode 3 | ./decode
 clean:
 	rm -f encode unionproto.pb.h unionproto.pb.c
 %: %.c $(DEPS) unionproto.pb.h unionproto.pb.c
 	$(CC) $(CFLAGS) -o $@ $< $(NANOPB_DIR)/pb_decode.c $(NANOPB_DIR)/pb_encode.c unionproto.pb.c
 unionproto.pb.h unionproto.pb.c: unionproto.proto $(NANOPB_DIR)/generator/nanopb_generator.py
 	protoc -ounionproto.pb $<
 	python $(NANOPB_DIR)/generator/nanopb_generator.py unionproto.pb
--- a/examples/using_union_messages/README
+++ b/examples/using_union_messages/README
@@ -1,52 +0,0 @@
 Nanopb example "using_union_messages"
 =====================================
 Union messages is a common technique in Google Protocol Buffers used to
 represent a group of messages, only one of which is passed at a time.
 It is described in Google's documentation:
 https://developers.google.com/protocol-buffers/docs/techniques#union
 This directory contains an example on how to encode and decode union messages
 with minimal memory usage. Usually, nanopb would allocate space to store
 all of the possible messages at the same time, even though at most one of
 them will be used at a time.
 By using some of the lower level nanopb APIs, we can manually generate the
 top level message, so that we only need to allocate the one submessage that
 we actually want. Similarly when decoding, we can manually read the tag of
 the top level message, and only then allocate the memory for the submessage
 after we already know its type.
 Example usage
 -------------
 Type `make` to run the example. It will build it and run commands like
 following:
 ./encode 1 | ./decode
 Got MsgType1: 42
 ./encode 2 | ./decode
 Got MsgType2: true
 ./encode 3 | ./decode
 Got MsgType3: 3 1415
 This simply demonstrates that the "decode" program has correctly identified
 the type of the received message, and managed to decode it.
 Details of implementation
 -------------------------
 unionproto.proto contains the protocol used in the example. It consists of
 three messages: MsgType1, MsgType2 and MsgType3, which are collected together
 into UnionMessage.
 encode.c takes one command line argument, which should be a number 1-3. It
 then fills in and encodes the corresponding message, and writes it to stdout.
 decode.c reads a UnionMessage from stdin. Then it calls the function
 decode_unionmessage_type() to determine the type of the message. After that,
 the corresponding message is decoded and the contents of it printed to the
 screen.
--- a/examples/using_union_messages/decode.c
+++ b/examples/using_union_messages/decode.c
@@ -1,96 +0,0 @@
 /* This program reads a message from stdin, detects its type and decodes it.
 */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <pb_decode.h>
 #include "unionproto.pb.h"
 /* This function reads manually the first tag from the stream and finds the
 * corresponding message type. It doesn't yet decode the actual message.
 *
 * Returns a pointer to the MsgType_fields array, as an identifier for the
 * message type. Returns null if the tag is of unknown type or an error occurs.
 */
 const pb_field_t* decode_unionmessage_type(pb_istream_t *stream)
 {
    pb_wire_type_t wire_type;
    uint32_t tag;
    bool eof;
    while (pb_decode_tag(stream, &wire_type, &tag, &eof))
    {
        if (wire_type == PB_WT_STRING)
        {
            const pb_field_t *field;
            for (field = UnionMessage_fields; field->tag != 0; field++)
            {
                if (field->tag == tag && (field->type & PB_LTYPE_SUBMESSAGE))
                {
                    /* Found our field. */
                    return field->ptr;
                }
            }
        }
        /* Wasn't our field.. */
        pb_skip_field(stream, wire_type);
    }
    return NULL;
 }
 bool decode_unionmessage_contents(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 {
    pb_istream_t substream;
    bool status;
    if (!pb_make_string_substream(stream, &substream))
        return false;
    status = pb_decode(&substream, fields, dest_struct);
    pb_close_string_substream(stream, &substream);
    return status;
 }
 int main()
 {
    /* Read the data into buffer */
    uint8_t buffer[512];
    size_t count = fread(buffer, 1, sizeof(buffer), stdin);
    pb_istream_t stream = pb_istream_from_buffer(buffer, count);
    const pb_field_t *type = decode_unionmessage_type(&stream);
    bool status = false;
    if (type == MsgType1_fields)
    {
        MsgType1 msg = {};
        status = decode_unionmessage_contents(&stream, MsgType1_fields, &msg);
        printf("Got MsgType1: %d\n", msg.value);
    }
    else if (type == MsgType2_fields)
    {
        MsgType2 msg = {};
        status = decode_unionmessage_contents(&stream, MsgType2_fields, &msg);
        printf("Got MsgType2: %s\n", msg.value ? "true" : "false");
    }
    else if (type == MsgType3_fields)
    {
        MsgType3 msg = {};
        status = decode_unionmessage_contents(&stream, MsgType3_fields, &msg);
        printf("Got MsgType3: %d %d\n", msg.value1, msg.value2);    
    }
    if (!status)
    {
        printf("Decode failed: %s\n", PB_GET_ERROR(&stream));
        return 1;
    }
    return 0;
 }
--- a/examples/using_union_messages/encode.c
+++ b/examples/using_union_messages/encode.c
@@ -1,85 +0,0 @@
 /* This program takes a command line argument and encodes a message in
 * one of MsgType1, MsgType2 or MsgType3.
 */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <pb_encode.h>
 #include "unionproto.pb.h"
 /* This function is the core of the union encoding process. It handles
 * the top-level pb_field_t array manually, in order to encode a correct
 * field tag before the message. The pointer to MsgType_fields array is
 * used as an unique identifier for the message type.
 */
 bool encode_unionmessage(pb_ostream_t *stream, const pb_field_t messagetype[], const void *message)
 {
    const pb_field_t *field;
    for (field = UnionMessage_fields; field->tag != 0; field++)
    {
        if (field->ptr == messagetype)
        {
            /* This is our field, encode the message using it. */
            if (!pb_encode_tag_for_field(stream, field))
                return false;
            return pb_encode_submessage(stream, messagetype, message);
        }
    }
    /* Didn't find the field for messagetype */
    return false;
 }
 int main(int argc, char **argv)
 {
    if (argc != 2)
    {
        fprintf(stderr, "Usage: %s (1|2|3)\n", argv[0]);
        return 1;
    }
    uint8_t buffer[512];
    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    bool status = false;
    int msgtype = atoi(argv[1]);
    if (msgtype == 1)
    {
        /* Send message of type 1 */
        MsgType1 msg = {42};
        status = encode_unionmessage(&stream, MsgType1_fields, &msg);
    }
    else if (msgtype == 2)
    {
        /* Send message of type 2 */
        MsgType2 msg = {true};
        status = encode_unionmessage(&stream, MsgType2_fields, &msg);
    }
    else if (msgtype == 3)
    {
        /* Send message of type 3 */
        MsgType3 msg = {3, 1415};
        status = encode_unionmessage(&stream, MsgType3_fields, &msg);
    }
    else
    {
        fprintf(stderr, "Unknown message type: %d\n", msgtype);
        return 2;
    }
    if (!status)
    {
        fprintf(stderr, "Encoding failed!\n");
        return 3;
    }
    else
    {
        fwrite(buffer, 1, stream.bytes_written, stdout);
        return 0; /* Success */
    }
 }
--- a/examples/using_union_messages/unionproto.proto
+++ b/examples/using_union_messages/unionproto.proto
@@ -1,30 +0,0 @@
 // This is an example of how to handle 'union' style messages
 // with nanopb, without allocating memory for all the message types.
 //
 // There is no official type in Protocol Buffers for describing unions,
 // but they are commonly implemented by filling out exactly one of
 // several optional fields.
 message MsgType1
 {
    required int32 value = 1;
 }
 message MsgType2
 {
    required bool value = 1;
 }
 message MsgType3
 {
    required int32 value1 = 1;
    required int32 value2 = 2;
 }
 message UnionMessage
 {
    optional MsgType1 msg1 = 1;
    optional MsgType2 msg2 = 2;
    optional MsgType3 msg3 = 3;
 }
--- a/generator/Makefile
+++ b/generator/Makefile
@@ -1,5 +1,8 @@
-nanopb_pb2.py: nanopb.proto
+ifndef PB_PATH
-	protoc --python_out=. -I /usr/include -I . nanopb.proto
+PBPATHOPT=-I/usr/include -I/usr/local/include
 else
 PBPATHOPT=-I$(PB_PATH)
 endif
-plugin_pb2.py: plugin.proto
+nanopb_pb2.py: nanopb.proto
-	protoc --python_out=. -I /usr/include -I . plugin.proto
+	protoc --python_out=. $(PBPATHOPT) -I . nanopb.proto
--- a/generator/nanopb.proto
+++ b/generator/nanopb.proto
@@ -7,62 +7,20 @@
 import "google/protobuf/descriptor.proto";
 option java_package = "fi.kapsi.koti.jpa.nanopb";
 enum FieldType {
    FT_DEFAULT = 0; // Automatically decide field type, generate static field if possible.
    FT_CALLBACK = 1; // Always generate a callback field.
    FT_STATIC = 2; // Generate a static field or raise an exception if not possible.
    FT_IGNORE = 3; // Ignore the field completely.
 }
 // This is the inner options message, which basically defines options for
 // a field. When it is used in message or file scope, it applies to all
 // fields.
 message NanoPBOptions {
  // Allocated size for 'bytes' and 'string' fields.
  optional int32 max_size = 1;
  // Allocated number of entries in arrays ('repeated' fields)
  optional int32 max_count = 2;
  // Force type of field (callback or static allocation)
  optional FieldType type = 3 [default = FT_DEFAULT];
  // Use long names for enums, i.e. EnumName_EnumValue.
  optional bool long_names = 4 [default = true];
  // Add 'packed' attribute to generated structs.
  // Note: this cannot be used on CPUs that break on unaligned
  // accesses to variables.
  optional bool packed_struct = 5 [default = false];
 }
 // Extensions to protoc 'Descriptor' type in order to define options
 // inside a .proto file.
 //
 // Protocol Buffers extension number registry
-// --------------------------------
+// --------------------------------                                                                                                            
-// Project:  Nanopb
+// Project:  Nanopb                                                                                                                            
-// Contact:  Petteri Aimonen <jpa@kapsi.fi>
+// Contact:  Petteri Aimonen <jpa@kapsi.fi>                                                                                                    
-// Web site: http://kapsi.fi/~jpa/nanopb
+// Web site: http://kapsi.fi/~jpa/nanopb                                                                                                       
-// Extensions: 1010 (all types)
+// Extensions: 1010 (all types)                                                                                                                
-// --------------------------------
+// --------------------------------   
 extend google.protobuf.FileOptions {
    optional NanoPBOptions nanopb_fileopt = 1010;
 }
 extend google.protobuf.MessageOptions {
    optional NanoPBOptions nanopb_msgopt = 1010;
 }
 extend google.protobuf.EnumOptions {
    optional NanoPBOptions nanopb_enumopt = 1010;
 }
 extend google.protobuf.FieldOptions {
    optional NanoPBOptions nanopb = 1010;
 }
--- a/generator/nanopb_generator.py
+++ b/generator/nanopb_generator.py
--- a/generator/nanopb_pb2.py
+++ b/generator/nanopb_pb2.py
@@ -7,75 +7,15 @@ from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 import google.protobuf.descriptor_pb2
 DESCRIPTOR = descriptor.FileDescriptor(
  name='nanopb.proto',
  package='',
-  serialized_pb='\n\x0cnanopb.proto\x1a google/protobuf/descriptor.proto\"\x92\x01\n\rNanoPBOptions\x12\x10\n\x08max_size\x18\x01 \x01(\x05\x12\x11\n\tmax_count\x18\x02 \x01(\x05\x12$\n\x04type\x18\x03 \x01(\x0e\x32\n.FieldType:\nFT_DEFAULT\x12\x18\n\nlong_names\x18\x04 \x01(\x08:\x04true\x12\x1c\n\rpacked_struct\x18\x05 \x01(\x08:\x05\x66\x61lse*J\n\tFieldType\x12\x0e\n\nFT_DEFAULT\x10\x00\x12\x0f\n\x0b\x46T_CALLBACK\x10\x01\x12\r\n\tFT_STATIC\x10\x02\x12\r\n\tFT_IGNORE\x10\x03:E\n\x0enanopb_fileopt\x12\x1c.google.protobuf.FileOptions\x18\xf2\x07 \x01(\x0b\x32\x0e.NanoPBOptions:G\n\rnanopb_msgopt\x12\x1f.google.protobuf.MessageOptions\x18\xf2\x07 \x01(\x0b\x32\x0e.NanoPBOptions:E\n\x0enanopb_enumopt\x12\x1c.google.protobuf.EnumOptions\x18\xf2\x07 \x01(\x0b\x32\x0e.NanoPBOptions:>\n\x06nanopb\x12\x1d.google.protobuf.FieldOptions\x18\xf2\x07 \x01(\x0b\x32\x0e.NanoPBOptions')
+  serialized_pb='\n\x0cnanopb.proto\x1a google/protobuf/descriptor.proto\"4\n\rNanoPBOptions\x12\x10\n\x08max_size\x18\x01 \x01(\x05\x12\x11\n\tmax_count\x18\x02 \x01(\x05:>\n\x06nanopb\x12\x1d.google.protobuf.FieldOptions\x18\xf2\x07 \x01(\x0b\x32\x0e.NanoPBOptions')
 _FIELDTYPE = descriptor.EnumDescriptor(
  name='FieldType',
  full_name='FieldType',
  filename=None,
  file=DESCRIPTOR,
  values=[
    descriptor.EnumValueDescriptor(
      name='FT_DEFAULT', index=0, number=0,
      options=None,
      type=None),
    descriptor.EnumValueDescriptor(
      name='FT_CALLBACK', index=1, number=1,
      options=None,
      type=None),
    descriptor.EnumValueDescriptor(
      name='FT_STATIC', index=2, number=2,
      options=None,
      type=None),
    descriptor.EnumValueDescriptor(
      name='FT_IGNORE', index=3, number=3,
      options=None,
      type=None),
  ],
  containing_type=None,
  options=None,
  serialized_start=199,
  serialized_end=273,
 )
 FT_DEFAULT = 0
 FT_CALLBACK = 1
 FT_STATIC = 2
 FT_IGNORE = 3
 NANOPB_FILEOPT_FIELD_NUMBER = 1010
 nanopb_fileopt = descriptor.FieldDescriptor(
  name='nanopb_fileopt', full_name='nanopb_fileopt', index=0,
  number=1010, type=11, cpp_type=10, label=1,
  has_default_value=False, default_value=None,
  message_type=None, enum_type=None, containing_type=None,
  is_extension=True, extension_scope=None,
  options=None)
 NANOPB_MSGOPT_FIELD_NUMBER = 1010
 nanopb_msgopt = descriptor.FieldDescriptor(
  name='nanopb_msgopt', full_name='nanopb_msgopt', index=1,
  number=1010, type=11, cpp_type=10, label=1,
  has_default_value=False, default_value=None,
  message_type=None, enum_type=None, containing_type=None,
  is_extension=True, extension_scope=None,
  options=None)
 NANOPB_ENUMOPT_FIELD_NUMBER = 1010
 nanopb_enumopt = descriptor.FieldDescriptor(
  name='nanopb_enumopt', full_name='nanopb_enumopt', index=2,
  number=1010, type=11, cpp_type=10, label=1,
  has_default_value=False, default_value=None,
  message_type=None, enum_type=None, containing_type=None,
  is_extension=True, extension_scope=None,
  options=None)
 NANOPB_FIELD_NUMBER = 1010
 nanopb = descriptor.FieldDescriptor(
-  name='nanopb', full_name='nanopb', index=3,
+  name='nanopb', full_name='nanopb', index=0,
  number=1010, type=11, cpp_type=10, label=1,
  has_default_value=False, default_value=None,
  message_type=None, enum_type=None, containing_type=None,
@@ -104,27 +44,6 @@ _NANOPBOPTIONS = descriptor.Descriptor(
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='type', full_name='NanoPBOptions.type', index=2,
      number=3, type=14, cpp_type=8, label=1,
      has_default_value=True, default_value=0,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='long_names', full_name='NanoPBOptions.long_names', index=3,
      number=4, type=8, cpp_type=7, label=1,
      has_default_value=True, default_value=True,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='packed_struct', full_name='NanoPBOptions.packed_struct', index=4,
      number=5, type=8, cpp_type=7, label=1,
      has_default_value=True, default_value=False,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
  ],
  extensions=[
  ],
@@ -134,12 +53,12 @@ _NANOPBOPTIONS = descriptor.Descriptor(
  options=None,
  is_extendable=False,
  extension_ranges=[],
-  serialized_start=51,
+  serialized_start=50,
-  serialized_end=197,
+  serialized_end=102,
 )
-_NANOPBOPTIONS.fields_by_name['type'].enum_type = _FIELDTYPE
+import google.protobuf.descriptor_pb2
-DESCRIPTOR.message_types_by_name['NanoPBOptions'] = _NANOPBOPTIONS
+
 class NanoPBOptions(message.Message):
  __metaclass__ = reflection.GeneratedProtocolMessageType
@@ -147,12 +66,6 @@ class NanoPBOptions(message.Message):
  # @@protoc_insertion_point(class_scope:NanoPBOptions)
 nanopb_fileopt.message_type = _NANOPBOPTIONS
 google.protobuf.descriptor_pb2.FileOptions.RegisterExtension(nanopb_fileopt)
 nanopb_msgopt.message_type = _NANOPBOPTIONS
 google.protobuf.descriptor_pb2.MessageOptions.RegisterExtension(nanopb_msgopt)
 nanopb_enumopt.message_type = _NANOPBOPTIONS
 google.protobuf.descriptor_pb2.EnumOptions.RegisterExtension(nanopb_enumopt)
 nanopb.message_type = _NANOPBOPTIONS
 google.protobuf.descriptor_pb2.FieldOptions.RegisterExtension(nanopb)
 # @@protoc_insertion_point(module_scope)
--- a/generator/plugin.proto
+++ b/generator/plugin.proto
@@ -1,145 +0,0 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // http://code.google.com/p/protobuf/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // Author: kenton@google.com (Kenton Varda)
 //
 // WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to
 //   change.
 //
 // protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is
 // just a program that reads a CodeGeneratorRequest from stdin and writes a
 // CodeGeneratorResponse to stdout.
 //
 // Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
 // of dealing with the raw protocol defined here.
 //
 // A plugin executable needs only to be placed somewhere in the path.  The
 // plugin should be named "protoc-gen-$NAME", and will then be used when the
 // flag "--${NAME}_out" is passed to protoc.
 package google.protobuf.compiler;
 import "google/protobuf/descriptor.proto";
 // An encoded CodeGeneratorRequest is written to the plugin's stdin.
 message CodeGeneratorRequest {
  // The .proto files that were explicitly listed on the command-line.  The
  // code generator should generate code only for these files.  Each file's
  // descriptor will be included in proto_file, below.
  repeated string file_to_generate = 1;
  // The generator parameter passed on the command-line.
  optional string parameter = 2;
  // FileDescriptorProtos for all files in files_to_generate and everything
  // they import.  The files will appear in topological order, so each file
  // appears before any file that imports it.
  //
  // protoc guarantees that all proto_files will be written after
  // the fields above, even though this is not technically guaranteed by the
  // protobuf wire format.  This theoretically could allow a plugin to stream
  // in the FileDescriptorProtos and handle them one by one rather than read
  // the entire set into memory at once.  However, as of this writing, this
  // is not similarly optimized on protoc's end -- it will store all fields in
  // memory at once before sending them to the plugin.
  repeated FileDescriptorProto proto_file = 15;
 }
 // The plugin writes an encoded CodeGeneratorResponse to stdout.
 message CodeGeneratorResponse {
  // Error message.  If non-empty, code generation failed.  The plugin process
  // should exit with status code zero even if it reports an error in this way.
  //
  // This should be used to indicate errors in .proto files which prevent the
  // code generator from generating correct code.  Errors which indicate a
  // problem in protoc itself -- such as the input CodeGeneratorRequest being
  // unparseable -- should be reported by writing a message to stderr and
  // exiting with a non-zero status code.
  optional string error = 1;
  // Represents a single generated file.
  message File {
    // The file name, relative to the output directory.  The name must not
    // contain "." or ".." components and must be relative, not be absolute (so,
    // the file cannot lie outside the output directory).  "/" must be used as
    // the path separator, not "\".
    //
    // If the name is omitted, the content will be appended to the previous
    // file.  This allows the generator to break large files into small chunks,
    // and allows the generated text to be streamed back to protoc so that large
    // files need not reside completely in memory at one time.  Note that as of
    // this writing protoc does not optimize for this -- it will read the entire
    // CodeGeneratorResponse before writing files to disk.
    optional string name = 1;
    // If non-empty, indicates that the named file should already exist, and the
    // content here is to be inserted into that file at a defined insertion
    // point.  This feature allows a code generator to extend the output
    // produced by another code generator.  The original generator may provide
    // insertion points by placing special annotations in the file that look
    // like:
    //   @@protoc_insertion_point(NAME)
    // The annotation can have arbitrary text before and after it on the line,
    // which allows it to be placed in a comment.  NAME should be replaced with
    // an identifier naming the point -- this is what other generators will use
    // as the insertion_point.  Code inserted at this point will be placed
    // immediately above the line containing the insertion point (thus multiple
    // insertions to the same point will come out in the order they were added).
    // The double-@ is intended to make it unlikely that the generated code
    // could contain things that look like insertion points by accident.
    //
    // For example, the C++ code generator places the following line in the
    // .pb.h files that it generates:
    //   // @@protoc_insertion_point(namespace_scope)
    // This line appears within the scope of the file's package namespace, but
    // outside of any particular class.  Another plugin can then specify the
    // insertion_point "namespace_scope" to generate additional classes or
    // other declarations that should be placed in this scope.
    //
    // Note that if the line containing the insertion point begins with
    // whitespace, the same whitespace will be added to every line of the
    // inserted text.  This is useful for languages like Python, where
    // indentation matters.  In these languages, the insertion point comment
    // should be indented the same amount as any inserted code will need to be
    // in order to work correctly in that context.
    //
    // The code generator that generates the initial file and the one which
    // inserts into it must both run as part of a single invocation of protoc.
    // Code generators are executed in the order in which they appear on the
    // command line.
    //
    // If |insertion_point| is present, |name| must also be present.
    optional string insertion_point = 2;
    // The file contents.
    optional string content = 15;
  }
  repeated File file = 15;
 }
--- a/generator/plugin_pb2.py
+++ b/generator/plugin_pb2.py
@@ -1,161 +0,0 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 from google.protobuf import descriptor
 from google.protobuf import message
 from google.protobuf import reflection
 from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 import google.protobuf.descriptor_pb2
 DESCRIPTOR = descriptor.FileDescriptor(
  name='plugin.proto',
  package='google.protobuf.compiler',
  serialized_pb='\n\x0cplugin.proto\x12\x18google.protobuf.compiler\x1a google/protobuf/descriptor.proto\"}\n\x14\x43odeGeneratorRequest\x12\x18\n\x10\x66ile_to_generate\x18\x01 \x03(\t\x12\x11\n\tparameter\x18\x02 \x01(\t\x12\x38\n\nproto_file\x18\x0f \x03(\x0b\x32$.google.protobuf.FileDescriptorProto\"\xaa\x01\n\x15\x43odeGeneratorResponse\x12\r\n\x05\x65rror\x18\x01 \x01(\t\x12\x42\n\x04\x66ile\x18\x0f \x03(\x0b\x32\x34.google.protobuf.compiler.CodeGeneratorResponse.File\x1a>\n\x04\x46ile\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x17\n\x0finsertion_point\x18\x02 \x01(\t\x12\x0f\n\x07\x63ontent\x18\x0f \x01(\t')
 _CODEGENERATORREQUEST = descriptor.Descriptor(
  name='CodeGeneratorRequest',
  full_name='google.protobuf.compiler.CodeGeneratorRequest',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    descriptor.FieldDescriptor(
      name='file_to_generate', full_name='google.protobuf.compiler.CodeGeneratorRequest.file_to_generate', index=0,
      number=1, type=9, cpp_type=9, label=3,
      has_default_value=False, default_value=[],
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='parameter', full_name='google.protobuf.compiler.CodeGeneratorRequest.parameter', index=1,
      number=2, type=9, cpp_type=9, label=1,
      has_default_value=False, default_value=unicode("", "utf-8"),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='proto_file', full_name='google.protobuf.compiler.CodeGeneratorRequest.proto_file', index=2,
      number=15, type=11, cpp_type=10, label=3,
      has_default_value=False, default_value=[],
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
  ],
  extensions=[
  ],
  nested_types=[],
  enum_types=[
  ],
  options=None,
  is_extendable=False,
  extension_ranges=[],
  serialized_start=76,
  serialized_end=201,
 )
 _CODEGENERATORRESPONSE_FILE = descriptor.Descriptor(
  name='File',
  full_name='google.protobuf.compiler.CodeGeneratorResponse.File',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    descriptor.FieldDescriptor(
      name='name', full_name='google.protobuf.compiler.CodeGeneratorResponse.File.name', index=0,
      number=1, type=9, cpp_type=9, label=1,
      has_default_value=False, default_value=unicode("", "utf-8"),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='insertion_point', full_name='google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point', index=1,
      number=2, type=9, cpp_type=9, label=1,
      has_default_value=False, default_value=unicode("", "utf-8"),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='content', full_name='google.protobuf.compiler.CodeGeneratorResponse.File.content', index=2,
      number=15, type=9, cpp_type=9, label=1,
      has_default_value=False, default_value=unicode("", "utf-8"),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
  ],
  extensions=[
  ],
  nested_types=[],
  enum_types=[
  ],
  options=None,
  is_extendable=False,
  extension_ranges=[],
  serialized_start=312,
  serialized_end=374,
 )
 _CODEGENERATORRESPONSE = descriptor.Descriptor(
  name='CodeGeneratorResponse',
  full_name='google.protobuf.compiler.CodeGeneratorResponse',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    descriptor.FieldDescriptor(
      name='error', full_name='google.protobuf.compiler.CodeGeneratorResponse.error', index=0,
      number=1, type=9, cpp_type=9, label=1,
      has_default_value=False, default_value=unicode("", "utf-8"),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    descriptor.FieldDescriptor(
      name='file', full_name='google.protobuf.compiler.CodeGeneratorResponse.file', index=1,
      number=15, type=11, cpp_type=10, label=3,
      has_default_value=False, default_value=[],
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
  ],
  extensions=[
  ],
  nested_types=[_CODEGENERATORRESPONSE_FILE, ],
  enum_types=[
  ],
  options=None,
  is_extendable=False,
  extension_ranges=[],
  serialized_start=204,
  serialized_end=374,
 )
 _CODEGENERATORREQUEST.fields_by_name['proto_file'].message_type = google.protobuf.descriptor_pb2._FILEDESCRIPTORPROTO
 _CODEGENERATORRESPONSE_FILE.containing_type = _CODEGENERATORRESPONSE;
 _CODEGENERATORRESPONSE.fields_by_name['file'].message_type = _CODEGENERATORRESPONSE_FILE
 DESCRIPTOR.message_types_by_name['CodeGeneratorRequest'] = _CODEGENERATORREQUEST
 DESCRIPTOR.message_types_by_name['CodeGeneratorResponse'] = _CODEGENERATORRESPONSE
 class CodeGeneratorRequest(message.Message):
  __metaclass__ = reflection.GeneratedProtocolMessageType
  DESCRIPTOR = _CODEGENERATORREQUEST
  # @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
 class CodeGeneratorResponse(message.Message):
  __metaclass__ = reflection.GeneratedProtocolMessageType
  class File(message.Message):
    __metaclass__ = reflection.GeneratedProtocolMessageType
    DESCRIPTOR = _CODEGENERATORRESPONSE_FILE
    # @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
  DESCRIPTOR = _CODEGENERATORRESPONSE
  # @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
 # @@protoc_insertion_point(module_scope)
--- a/pb.h
+++ b/pb.h
@@ -1,241 +1,11 @@
 /* Common parts of the nanopb library. Most of these are quite low-level
 * stuff. For the high-level interface, see pb_encode.h and pb_decode.h.
 */
 #ifndef _PB_H_
 #define _PB_H_
-/*****************************************************************
+/* pb.h: Common parts for nanopb library.
- * Nanopb compilation time options. You can change these here by *
+ * Most of these are quite low-level stuff. For the high-level interface,
- * uncommenting the lines, or on the compiler command line.      *
+ * see pb_encode.h or pb_decode.h
 *****************************************************************/
 /* Define this if your CPU architecture is big endian, i.e. it
 * stores the most-significant byte first. */
 /* #define __BIG_ENDIAN__ 1 */
 /* Increase the number of required fields that are tracked.
 * A compiler warning will tell if you need this. */
 /* #define PB_MAX_REQUIRED_FIELDS 256 */
 /* Add support for tag numbers > 255 and fields larger than 255 bytes. */
 /* #define PB_FIELD_16BIT 1 */
 /* Add support for tag numbers > 65536 and fields larger than 65536 bytes. */
 /* #define PB_FIELD_32BIT 1 */
 /* Disable support for error messages in order to save some code space. */
 /* #define PB_NO_ERRMSG 1 */
 /* Disable support for custom streams (support only memory buffers). */
 /* #define PB_BUFFER_ONLY 1 */
 /* Switch back to the old-style callback function signature.
 * This was the default until nanopb-0.2.1. */
 /* #define PB_OLD_CALLBACK_STYLE */
 /******************************************************************
 * You usually don't need to change anything below this line.     *
 * Feel free to look around and use the defined macros, though.   *
 ******************************************************************/
 /* Version of the nanopb library. Just in case you want to check it in
 * your own program. */
 #define NANOPB_VERSION nanopb-0.2.3
 /* Include all the system headers needed by nanopb. You will need the
 * definitions of the following:
 * - strlen, memcpy, memset functions
 * - [u]int8_t, [u]int16_t, [u]int32_t, [u]int64_t
 * - size_t
 * - bool
 *
 * If you don't have the standard header files, you can instead provide
 * a custom header that defines or includes all this. In that case,
 * define PB_SYSTEM_HEADER to the path of this file.
 */
-#ifdef PB_SYSTEM_HEADER
+#include <pb_field.h>
 #include PB_SYSTEM_HEADER
 #else
 #include <stdint.h>
 #include <stddef.h>
 #include <stdbool.h>
 #include <string.h>
 #endif
 /* Macro for defining packed structures (compiler dependent).
 * This just reduces memory requirements, but is not required.
 */
 #if defined(__GNUC__) || defined(__clang__)
    /* For GCC and clang */
 #   define PB_PACKED_STRUCT_START
 #   define PB_PACKED_STRUCT_END
 #   define pb_packed __attribute__((packed))
 #elif defined(__ICCARM__)
    /* For IAR ARM compiler */
 #   define PB_PACKED_STRUCT_START _Pragma("pack(push, 1)")
 #   define PB_PACKED_STRUCT_END _Pragma("pack(pop)")
 #   define pb_packed
 #elif defined(_MSC_VER) && (_MSC_VER >= 1500)
    /* For Microsoft Visual C++ */
 #   define PB_PACKED_STRUCT_START __pragma(pack(push, 1))
 #   define PB_PACKED_STRUCT_END __pragma(pack(pop))
 #   define pb_packed
 #else
    /* Unknown compiler */
 #   define PB_PACKED_STRUCT_START
 #   define PB_PACKED_STRUCT_END
 #   define pb_packed
 #endif
 /* Handly macro for suppressing unreferenced-parameter compiler warnings. */
 #ifndef UNUSED
 #define UNUSED(x) (void)(x)
 #endif
 /* Compile-time assertion, used for checking compatible compilation options.
 * If this fails on your compiler for some reason, use #define STATIC_ASSERT
 * to disable it. */
 #ifndef STATIC_ASSERT
 #define STATIC_ASSERT(COND,MSG) typedef char STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1];
 #define STATIC_ASSERT_MSG(MSG, LINE, COUNTER) STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
 #define STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) static_assertion_##MSG##LINE##COUNTER
 #endif
 /* Number of required fields to keep track of. */
 #ifndef PB_MAX_REQUIRED_FIELDS
 #define PB_MAX_REQUIRED_FIELDS 64
 #endif
 #if PB_MAX_REQUIRED_FIELDS < 64
 #error You should not lower PB_MAX_REQUIRED_FIELDS from the default value (64).
 #endif
 /* List of possible field types. These are used in the autogenerated code.
 * Least-significant 4 bits tell the scalar type
 * Most-significant 4 bits specify repeated/required/packed etc.
 * 
 * INT32 and UINT32 are treated the same, as are (U)INT64 and (S)FIXED*
 * These types are simply casted to correct field type when they are
 * assigned to the memory pointer.
 * SINT* is different, though, because it is zig-zag coded.
 */
 typedef uint8_t pb_type_t;
 /**** Field data types ****/
 /* Numeric types */
 #define PB_LTYPE_VARINT 0x00 /* int32, uint32, int64, uint64, bool, enum */
 #define PB_LTYPE_SVARINT 0x01 /* sint32, sint64 */
 #define PB_LTYPE_FIXED32 0x02 /* fixed32, sfixed32, float */
 #define PB_LTYPE_FIXED64 0x03 /* fixed64, sfixed64, double */
 /* Marker for last packable field type. */
 #define PB_LTYPE_LAST_PACKABLE 0x03
 /* Byte array with pre-allocated buffer.
 * data_size is the length of the allocated PB_BYTES_ARRAY structure. */
 #define PB_LTYPE_BYTES 0x04
 /* String with pre-allocated buffer.
 * data_size is the maximum length. */
 #define PB_LTYPE_STRING 0x05
 /* Submessage
 * submsg_fields is pointer to field descriptions */
 #define PB_LTYPE_SUBMESSAGE 0x06
 /* Extension pseudo-field
 * The field contains a pointer to pb_extension_t */
 #define PB_LTYPE_EXTENSION 0x07
 /* Number of declared LTYPES */
 #define PB_LTYPES_COUNT 8
 #define PB_LTYPE_MASK 0x0F
 /**** Field repetition rules ****/
 #define PB_HTYPE_REQUIRED 0x00
 #define PB_HTYPE_OPTIONAL 0x10
 #define PB_HTYPE_REPEATED 0x20
 #define PB_HTYPE_MASK     0x30
 /**** Field allocation types ****/
 #define PB_ATYPE_STATIC   0x00
 #define PB_ATYPE_CALLBACK 0x40
 #define PB_ATYPE_MASK     0xC0
 #define PB_ATYPE(x) ((x) & PB_ATYPE_MASK)
 #define PB_HTYPE(x) ((x) & PB_HTYPE_MASK)
 #define PB_LTYPE(x) ((x) & PB_LTYPE_MASK)
 /* This structure is used in auto-generated constants
 * to specify struct fields.
 * You can change field sizes if you need structures
 * larger than 256 bytes or field tags larger than 256.
 * The compiler should complain if your .proto has such
 * structures. Fix that by defining PB_FIELD_16BIT or
 * PB_FIELD_32BIT.
 */
 PB_PACKED_STRUCT_START
 typedef struct _pb_field_t pb_field_t;
 struct _pb_field_t {
 #if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
    uint8_t tag;
    pb_type_t type;
    uint8_t data_offset; /* Offset of field data, relative to previous field. */
    int8_t size_offset; /* Offset of array size or has-boolean, relative to data */
    uint8_t data_size; /* Data size in bytes for a single item */
    uint8_t array_size; /* Maximum number of entries in array */
 #elif defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
    uint16_t tag;
    pb_type_t type;
    uint8_t data_offset;
    int8_t size_offset;
    uint16_t data_size;
    uint16_t array_size;
 #else
    uint32_t tag;
    pb_type_t type;
    uint8_t data_offset;
    int8_t size_offset;
    uint32_t data_size;
    uint32_t array_size;
 #endif
    /* Field definitions for submessage
     * OR default value for all other non-array, non-callback types
     * If null, then field will zeroed. */
    const void *ptr;
 } pb_packed;
 PB_PACKED_STRUCT_END
 /* Make sure that the standard integer types are of the expected sizes.
 * All kinds of things may break otherwise.. atleast all fixed* types. */
 STATIC_ASSERT(sizeof(int8_t) == 1, INT8_T_WRONG_SIZE)
 STATIC_ASSERT(sizeof(uint8_t) == 1, UINT8_T_WRONG_SIZE)
 STATIC_ASSERT(sizeof(int16_t) == 2, INT16_T_WRONG_SIZE)
 STATIC_ASSERT(sizeof(uint16_t) == 2, UINT16_T_WRONG_SIZE)
 STATIC_ASSERT(sizeof(int32_t) == 4, INT32_T_WRONG_SIZE)
 STATIC_ASSERT(sizeof(uint32_t) == 4, UINT32_T_WRONG_SIZE)
 STATIC_ASSERT(sizeof(int64_t) == 8, INT64_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.
 */
 struct _pb_bytes_array_t {
    size_t size;
    uint8_t bytes[1];
 };
 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
@@ -259,19 +29,10 @@ typedef struct _pb_istream_t pb_istream_t;
 typedef struct _pb_ostream_t pb_ostream_t;
 typedef struct _pb_callback_t pb_callback_t;
 struct _pb_callback_t {
 #ifdef PB_OLD_CALLBACK_STYLE
    /* Deprecated since nanopb-0.2.1 */
    union {
        bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void *arg);
        bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, const void *arg);
    } funcs;
 #else
    /* New function signature, which allows modifying arg contents in callback. */
    union {
        bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void **arg);
        bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
    } funcs;
 #endif    
    /* Free arg for use by callback */
    void *arg;
@@ -285,187 +46,4 @@ typedef enum {
    PB_WT_32BIT  = 5
 } pb_wire_type_t;
 /* Structure for defining the handling of unknown/extension fields.
 * Usually the pb_extension_type_t structure is automatically generated,
 * while the pb_extension_t structure is created by the user. However,
 * if you want to catch all unknown fields, you can also create a custom
 * pb_extension_type_t with your own callback.
 */
 typedef struct _pb_extension_type_t pb_extension_type_t;
 typedef struct _pb_extension_t pb_extension_t;
 struct _pb_extension_type_t {
    /* Called for each unknown field in the message.
     * If you handle the field, read off all of its data and return true.
     * If you do not handle the field, do not read anything and return true.
     * If you run into an error, return false.
     * Set to NULL for default handler.
     */
    bool (*decode)(pb_istream_t *stream, pb_extension_t *extension,
                   uint32_t tag, pb_wire_type_t wire_type);
    /* Called once after all regular fields have been encoded.
     * If you have something to write, do so and return true.
     * If you do not have anything to write, just return true.
     * If you run into an error, return false.
     * Set to NULL for default handler.
     */
    bool (*encode)(pb_ostream_t *stream, const pb_extension_t *extension);
    /* Free field for use by the callback. */
    const void *arg;
 };
 struct _pb_extension_t {
    /* Type describing the extension field. Usually you'll initialize
     * this to a pointer to the automatically generated structure. */
    const pb_extension_type_t *type;
    /* Destination for the decoded data. This must match the datatype
     * of the extension field. */
    void *dest;
    /* Pointer to the next extension handler, or NULL.
     * If this extension does not match a field, the next handler is
     * automatically called. */
    pb_extension_t *next;
 };
 /* These macros are used to declare pb_field_t's in the constant array. */
 /* Size of a structure member, in bytes. */
 #define pb_membersize(st, m) (sizeof ((st*)0)->m)
 /* Number of entries in an array. */
 #define pb_arraysize(st, m) (pb_membersize(st, m) / pb_membersize(st, m[0]))
 /* Delta from start of one member to the start of another member. */
 #define pb_delta(st, m1, m2) ((int)offsetof(st, m1) - (int)offsetof(st, m2))
 /* Marks the end of the field list */
 #define PB_LAST_FIELD {0,(pb_type_t) 0,0,0,0,0,0}
 /* Macros for filling in the data_offset field */
 /* data_offset for first field in a message */
 #define PB_DATAOFFSET_FIRST(st, m1, m2) (offsetof(st, m1))
 /* data_offset for subsequent fields */
 #define PB_DATAOFFSET_OTHER(st, m1, m2) (offsetof(st, m1) - offsetof(st, m2) - pb_membersize(st, m2))
 /* Choose first/other based on m1 == m2 (deprecated, remains for backwards compatibility) */
 #define PB_DATAOFFSET_CHOOSE(st, m1, m2) (int)(offsetof(st, m1) == offsetof(st, m2) \
                                  ? PB_DATAOFFSET_FIRST(st, m1, m2) \
                                  : PB_DATAOFFSET_OTHER(st, m1, m2))
 /* Required fields are the simplest. They just have delta (padding) from
 * previous field end, and the size of the field. Pointer is used for
 * submessages and default values.
 */
 #define PB_REQUIRED_STATIC(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_STATIC | PB_HTYPE_REQUIRED | ltype, \
    fd, 0, pb_membersize(st, m), 0, ptr}
 /* Optional fields add the delta to the has_ variable. */
 #define PB_OPTIONAL_STATIC(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_STATIC | PB_HTYPE_OPTIONAL | ltype, \
    fd, \
    pb_delta(st, has_ ## m, m), \
    pb_membersize(st, m), 0, ptr}
 /* Repeated fields have a _count field and also the maximum number of entries. */
 #define PB_REPEATED_STATIC(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_STATIC | PB_HTYPE_REPEATED | ltype, \
    fd, \
    pb_delta(st, m ## _count, m), \
    pb_membersize(st, m[0]), \
    pb_arraysize(st, m), ptr}
 /* Callbacks are much like required fields except with special datatype. */
 #define PB_REQUIRED_CALLBACK(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_CALLBACK | PB_HTYPE_REQUIRED | ltype, \
    fd, 0, pb_membersize(st, m), 0, ptr}
 #define PB_OPTIONAL_CALLBACK(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_CALLBACK | PB_HTYPE_OPTIONAL | ltype, \
    fd, 0, pb_membersize(st, m), 0, ptr}
 #define PB_REPEATED_CALLBACK(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_CALLBACK | PB_HTYPE_REPEATED | ltype, \
    fd, 0, pb_membersize(st, m), 0, ptr}
 /* Optional extensions don't have the has_ field, as that would be redundant. */
 #define PB_OPTEXT_STATIC(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_STATIC | PB_HTYPE_OPTIONAL | ltype, \
    0, \
    0, \
    pb_membersize(st, m), 0, ptr}
 #define PB_OPTEXT_CALLBACK(tag, st, m, fd, ltype, ptr) \
    {tag, PB_ATYPE_CALLBACK | PB_HTYPE_OPTIONAL | ltype, \
    0, 0, pb_membersize(st, m), 0, ptr}
 /* The mapping from protobuf types to LTYPEs is done using these macros. */
 #define PB_LTYPE_MAP_BOOL       PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_BYTES      PB_LTYPE_BYTES
 #define PB_LTYPE_MAP_DOUBLE     PB_LTYPE_FIXED64
 #define PB_LTYPE_MAP_ENUM       PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_FIXED32    PB_LTYPE_FIXED32
 #define PB_LTYPE_MAP_FIXED64    PB_LTYPE_FIXED64
 #define PB_LTYPE_MAP_FLOAT      PB_LTYPE_FIXED32
 #define PB_LTYPE_MAP_INT32      PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_INT64      PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_MESSAGE    PB_LTYPE_SUBMESSAGE
 #define PB_LTYPE_MAP_SFIXED32   PB_LTYPE_FIXED32
 #define PB_LTYPE_MAP_SFIXED64   PB_LTYPE_FIXED64
 #define PB_LTYPE_MAP_SINT32     PB_LTYPE_SVARINT
 #define PB_LTYPE_MAP_SINT64     PB_LTYPE_SVARINT
 #define PB_LTYPE_MAP_STRING     PB_LTYPE_STRING
 #define PB_LTYPE_MAP_UINT32     PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_UINT64     PB_LTYPE_VARINT
 #define PB_LTYPE_MAP_EXTENSION  PB_LTYPE_EXTENSION
 /* This is the actual macro used in field descriptions.
 * It takes these arguments:
 * - Field tag number
 * - Field type:   BOOL, BYTES, DOUBLE, ENUM, FIXED32, FIXED64,
 *                 FLOAT, INT32, INT64, MESSAGE, SFIXED32, SFIXED64
 *                 SINT32, SINT64, STRING, UINT32, UINT64 or EXTENSION
 * - Field rules:  REQUIRED, OPTIONAL or REPEATED
 * - Allocation:   STATIC or CALLBACK
 * - 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, message, field, prevfield, ptr) \
    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)
 /* These macros are used for giving out error messages.
 * They are mostly a debugging aid; the main error information
 * is the true/false return value from functions.
 * Some code space can be saved by disabling the error
 * messages if not used.
 */
 #ifdef PB_NO_ERRMSG
 #define PB_RETURN_ERROR(stream,msg) return false
 #define PB_GET_ERROR(stream) "(errmsg disabled)"
 #else
 #define PB_RETURN_ERROR(stream,msg) \
    do {\
        if ((stream)->errmsg == NULL) \
            (stream)->errmsg = (msg); \
        return false; \
    } while(0)
 #define PB_GET_ERROR(stream) ((stream)->errmsg ? (stream)->errmsg : "(none)")
 #endif
 #endif
--- a/pb_decode.c
+++ b/pb_decode.c
@@ -3,17 +3,17 @@
 * 2011 Petteri Aimonen <jpa@kapsi.fi>
 */
-/* The warn_unused_result attribute appeared first in gcc-3.4.0 */
+
-#if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
+#ifdef __GNUC__
-    #define checkreturn
+/* Verify that we remember to check all return values for proper error propagation */
 #define checkreturn __attribute__((warn_unused_result))
 #else
-    /* Verify that we remember to check all return values for proper error propagation */
+#define checkreturn
    #define checkreturn __attribute__((warn_unused_result))
 #endif
 #define NANOPB_INTERNALS
 #include "pb.h"
 #include "pb_decode.h"
 #include <string.h>
 typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
@@ -28,75 +28,42 @@ static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
    &pb_dec_bytes,
    &pb_dec_string,
-    &pb_dec_submessage,
+    &pb_dec_submessage
    NULL /* extensions */
 };
 /**************
 * pb_istream *
 **************/
-static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count)
+bool checkreturn pb_read(pb_istream_t *stream, uint8_t *buf, size_t count)
 {
-    uint8_t *source = (uint8_t*)stream->state;
+    if (stream->bytes_left < count)
-    stream->state = source + count;
+        return false;
-    if (buf != NULL)
+    if (!stream->callback(stream, buf, count))
-    {
+        return false;
        while (count--)
            *buf++ = *source++;
    }
    stream->bytes_left -= count;
    return true;
 }
-bool checkreturn pb_read(pb_istream_t *stream, uint8_t *buf, size_t count)
+static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count)
 {
-#ifndef PB_BUFFER_ONLY
+    uint8_t *source = (uint8_t*)stream->state;
 	if (buf == NULL && stream->callback != buf_read)
 	{
 		/* Skip input bytes */
 		uint8_t tmp[16];
 		while (count > 16)
 		{
 			if (!pb_read(stream, tmp, 16))
 				return false;
 			count -= 16;
 		}
 		return pb_read(stream, tmp, count);
 	}
 #endif
    if (stream->bytes_left < count)
        PB_RETURN_ERROR(stream, "end-of-stream");
-#ifndef PB_BUFFER_ONLY
+    if (buf != NULL)
-    if (!stream->callback(stream, buf, count))
+        memcpy(buf, source, count);
        PB_RETURN_ERROR(stream, "io error");
 #else
    if (!buf_read(stream, buf, count))
        return false;
 #endif
-    stream->bytes_left -= count;
+    stream->state = source + count;
    return true;
 }
 pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize)
 {
    pb_istream_t stream;
 #ifdef PB_BUFFER_ONLY
    stream.callback = NULL;
 #else
    stream.callback = &buf_read;
 #endif
    stream.state = buf;
    stream.bytes_left = bufsize;
 #ifndef PB_NO_ERRMSG
    stream.errmsg = NULL;
 #endif
    return stream;
 }
@@ -106,60 +73,28 @@ pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize)
 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest)
 {
-    uint8_t byte;
+    uint64_t temp;
-    uint32_t result;
+    bool status = pb_decode_varint(stream, &temp);
-    
+    *dest = temp;
-    if (!pb_read(stream, &byte, 1))
+    return status;
        return false;
    if (!(byte & 0x80))
    {
        /* Quick case, 1 byte value */
        result = byte;
    }
    else
    {
        /* Multibyte case */
        uint8_t bitpos = 7;
        result = byte & 0x7F;
        do
        {
            if (bitpos >= 32)
                PB_RETURN_ERROR(stream, "varint overflow");
            if (!pb_read(stream, &byte, 1))
                return false;
            result |= (uint32_t)(byte & 0x7F) << bitpos;
            bitpos = (uint8_t)(bitpos + 7);
        } while (byte & 0x80);
   }
   *dest = result;
   return true;
 }
 bool checkreturn pb_decode_varint(pb_istream_t *stream, uint64_t *dest)
 {
    uint8_t byte;
    uint8_t bitpos = 0;
-    uint64_t result = 0;
+    *dest = 0;
-    do
+    while (bitpos < 64 && pb_read(stream, &byte, 1))
    {
-        if (bitpos >= 64)
+        *dest |= (uint64_t)(byte & 0x7F) << bitpos;
-            PB_RETURN_ERROR(stream, "varint overflow");
+        bitpos += 7;
-        if (!pb_read(stream, &byte, 1))
+        if (!(byte & 0x80))
-            return false;
+            return true;
-
+    }
        result |= (uint64_t)(byte & 0x7F) << bitpos;
        bitpos = (uint8_t)(bitpos + 7);
    } while (byte & 0x80);
-    *dest = result;
+    return false;
    return true;
 }
 bool checkreturn pb_skip_varint(pb_istream_t *stream)
@@ -182,33 +117,12 @@ bool checkreturn pb_skip_string(pb_istream_t *stream)
    return pb_read(stream, NULL, length);
 }
-bool checkreturn pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof)
+/* Currently the wire type related stuff is kept hidden from
-{
+ * callbacks. They shouldn't need it. It's better for performance
-    uint32_t temp;
+ * to just assume the correct type and fail safely on corrupt message.
-    *eof = false;
+ */
    *wire_type = (pb_wire_type_t) 0;
    *tag = 0;
    if (!pb_decode_varint32(stream, &temp))
    {
        if (stream->bytes_left == 0)
            *eof = true;
-        return false;
+static bool checkreturn skip(pb_istream_t *stream, pb_wire_type_t wire_type)
    }
    if (temp == 0)
    {
        *eof = true; /* Special feature: allow 0-terminated messages. */
        return false;
    }
    *tag = temp >> 3;
    *wire_type = (pb_wire_type_t)(temp & 7);
    return true;
 }
 bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type)
 {
    switch (wire_type)
    {
@@ -216,7 +130,7 @@ bool checkreturn pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type)
        case PB_WT_64BIT: return pb_read(stream, NULL, 8);
        case PB_WT_STRING: return pb_skip_string(stream);
        case PB_WT_32BIT: return pb_read(stream, NULL, 4);
-        default: PB_RETURN_ERROR(stream, "invalid wire_type");
+        default: return false;
    }
 }
@@ -246,14 +160,15 @@ static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire
            *size = 4;
            return pb_read(stream, buf, 4);
-        default: PB_RETURN_ERROR(stream, "invalid wire_type");
+        default: return false;
    }
 }
 /* Decode string length from stream and return a substream with limited length.
- * Remember to close the substream using pb_close_string_substream().
+ * Before disposing the substream, remember to copy the substream->state back
 * to stream->state.
 */
-bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
+static bool checkreturn make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 {
    uint32_t size;
    if (!pb_decode_varint32(stream, &size))
@@ -261,331 +176,147 @@ bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *su
    *substream = *stream;
    if (substream->bytes_left < size)
-        PB_RETURN_ERROR(stream, "parent stream too short");
+        return false;
    substream->bytes_left = size;
    stream->bytes_left -= size;
    return true;
 }
 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
 {
    stream->state = substream->state;
 #ifndef PB_NO_ERRMSG
    stream->errmsg = substream->errmsg;
 #endif
 }
 /* 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;
 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;
    }
    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;
        }
        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_iterator_t *iter)
+static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
-    pb_type_t type;
+    pb_decoder_t func = PB_DECODERS[PB_LTYPE(iter->current.type)];
    pb_decoder_t func;
-    type = iter->pos->type;
+    switch (PB_HTYPE(iter->current.type))
    func = PB_DECODERS[PB_LTYPE(type)];
    switch (PB_HTYPE(type))
    {
        case PB_HTYPE_REQUIRED:
-            return func(stream, iter->pos, iter->pData);
+            return func(stream, &iter->current, iter->pData);
        case PB_HTYPE_OPTIONAL:
            *(bool*)iter->pSize = true;
-            return func(stream, iter->pos, iter->pData);
+            return func(stream, &iter->current, iter->pData);
-        case PB_HTYPE_REPEATED:
+        case PB_HTYPE_ARRAY:
            if (wire_type == PB_WT_STRING
-                && PB_LTYPE(type) <= PB_LTYPE_LAST_PACKABLE)
+                && PB_LTYPE(iter->current.type) <= PB_LTYPE_LAST_PACKABLE)
            {
                /* Packed array */
                bool status = true;
                size_t *size = (size_t*)iter->pSize;
                pb_istream_t substream;
-                if (!pb_make_string_substream(stream, &substream))
+                if (!make_string_substream(stream, &substream))
                    return false;
-                while (substream.bytes_left && *size < iter->pos->array_size)
+                while (substream.bytes_left && *size < iter->current.array_size)
                {
-                    void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size);
+                    void *pItem = (uint8_t*)iter->pData + iter->current.data_size * (*size);
-                    if (!func(&substream, iter->pos, pItem))
+                    if (!func(&substream, &iter->current, pItem))
-                    {
+                        return false;
                        status = false;
                        break;
                    }
                    (*size)++;
                }
-                pb_close_string_substream(stream, &substream);
+                return (substream.bytes_left == 0);
                if (substream.bytes_left != 0)
                    PB_RETURN_ERROR(stream, "array overflow");
                return status;
            }
            else
            {
                /* Repeated field */
                size_t *size = (size_t*)iter->pSize;
-                void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size);
+                void *pItem = (uint8_t*)iter->pData + iter->current.data_size * (*size);
-                if (*size >= iter->pos->array_size)
+                if (*size >= iter->current.array_size)
-                    PB_RETURN_ERROR(stream, "array overflow");
+                    return false;
                (*size)++;
-                return func(stream, iter->pos, pItem);
+                return func(stream, &iter->current, pItem);
            }
        default:
            PB_RETURN_ERROR(stream, "invalid field type");
    }
 }
 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;
 #ifdef PB_OLD_CALLBACK_STYLE
    void *arg = pCallback->arg;
 #else
    void **arg = &(pCallback->arg);
 #endif
    if (pCallback->funcs.decode == NULL)
        return pb_skip_field(stream, wire_type);
    if (wire_type == PB_WT_STRING)
    {
        pb_istream_t substream;
-        if (!pb_make_string_substream(stream, &substream))
+        case PB_HTYPE_CALLBACK:
            return false;
        do
        {
-            if (!pCallback->funcs.decode(&substream, iter->pos, arg))
+            pb_callback_t *pCallback = (pb_callback_t*)iter->pData;
-                PB_RETURN_ERROR(stream, "callback failed");
+            
-        } while (substream.bytes_left);
+            if (pCallback->funcs.decode == NULL)
-        
+                return skip(stream, wire_type);
-        pb_close_string_substream(stream, &substream);
+            
-        return true;
+            if (wire_type == PB_WT_STRING)
-    }
+            {
-    else
+                pb_istream_t substream;
-    {
+                
-        /* Copy the single scalar value to stack.
+                if (!make_string_substream(stream, &substream))
-         * This is required so that we can limit the stream length,
+                    return false;
-         * which in turn allows to use same callback for packed and
+                
-         * not-packed fields. */
+                while (substream.bytes_left)
-        pb_istream_t substream;
+                {
-        uint8_t buffer[10];
+                    if (!pCallback->funcs.decode(&substream, &iter->current, pCallback->arg))
-        size_t size = sizeof(buffer);
+                        return false;
-        
+                }
-        if (!read_raw_value(stream, wire_type, buffer, &size))
+                
-            return false;
+                stream->state = substream.state;
-        substream = pb_istream_from_buffer(buffer, size);
+                return true;
-        
+            }
-        return pCallback->funcs.decode(&substream, iter->pos, arg);
+            else
-    }
+            {
-}
+                /* Copy the single scalar value to stack.
-
+                 * This is required so that we can limit the stream length,
-static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
+                 * which in turn allows to use same callback for packed and
-{
+                 * not-packed fields. */
-    switch (PB_ATYPE(iter->pos->type))
+                pb_istream_t substream;
-    {
+                uint8_t buffer[10];
-        case PB_ATYPE_STATIC:
+                size_t size = sizeof(buffer);
-            return decode_static_field(stream, wire_type, iter);
+                
-        
+                if (!read_raw_value(stream, wire_type, buffer, &size))
-        case PB_ATYPE_CALLBACK:
+                    return false;
-            return decode_callback_field(stream, wire_type, iter);
+                substream = pb_istream_from_buffer(buffer, size);
                return pCallback->funcs.decode(&substream, &iter->current, pCallback->arg);
            }
        }
        default:
            PB_RETURN_ERROR(stream, "invalid field type");
    }
 }
 /* Default handler for extension fields. Expects a pb_field_t structure
 * in extension->type->arg. */
 static bool checkreturn default_extension_handler(pb_istream_t *stream,
    pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type)
 {
    const pb_field_t *field = (const pb_field_t*)extension->type->arg;
    pb_field_iterator_t iter;
    bool dummy;
    if (field->tag != tag)
        return true;
    iter.start = field;
    iter.pos = field;
    iter.field_index = 0;
    iter.required_field_index = 0;
    iter.dest_struct = extension->dest;
    iter.pData = extension->dest;
    iter.pSize = &dummy;
    return decode_field(stream, wire_type, &iter);
 }
 /* Try to decode an unknown field as an extension field. Tries each extension
 * decoder in turn, until one of them handles the field or loop ends. */
 static bool checkreturn decode_extension(pb_istream_t *stream,
    uint32_t tag, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
    pb_extension_t *extension = *(pb_extension_t* const *)iter->pData;
    size_t pos = stream->bytes_left;
    while (extension && pos == stream->bytes_left)
    {
        bool status;
        if (extension->type->decode)
            status = extension->type->decode(stream, extension, tag, wire_type);
        else
            status = default_extension_handler(stream, extension, tag, wire_type);
        if (!status)
            return false;
        extension = extension->next;
    }
    return true;
 }
 /* Step through the iterator until an extension field is found or until all
 * entries have been checked. There can be only one extension field per
 * message. Returns false if no extension field is found. */
 static bool checkreturn find_extension_field(pb_field_iterator_t *iter)
 {
    unsigned start = iter->field_index;
    do {
        if (PB_LTYPE(iter->pos->type) == PB_LTYPE_EXTENSION)
            return true;
        pb_field_next(iter);
    } while (iter->field_index != start);
    return false;
 }
 /* Initialize message fields to default values, recursively */
-static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_struct)
+static void pb_message_set_to_defaults(const pb_field_info_t *fields, void *dest_struct)
 {
    pb_field_iterator_t iter;
    if (fields->field_keys == NULL) return;
    pb_field_init(&iter, fields, dest_struct);
    /* Initialize size/has fields and apply default values */
    do
    {
-        pb_type_t type;
+        /* Initialize the size field for optional/repeated fields to 0. */
-        type = iter.pos->type;
+        if (PB_HTYPE(iter.current.type) == PB_HTYPE_OPTIONAL)
        if (iter.pos->tag == 0)
            continue;
        if (PB_ATYPE(type) == PB_ATYPE_STATIC)
        {
-            /* Initialize the size field for optional/repeated fields to 0. */
+            *(bool*)iter.pSize = false;
            if (PB_HTYPE(type) == PB_HTYPE_OPTIONAL)
            {
                *(bool*)iter.pSize = false;
            }
            else if (PB_HTYPE(type) == PB_HTYPE_REPEATED)
            {
                *(size_t*)iter.pSize = 0;
                continue; /* Array is empty, no need to initialize contents */
            }
            /* Initialize field contents to default value */
            if (PB_LTYPE(iter.pos->type) == PB_LTYPE_SUBMESSAGE)
            {
                pb_message_set_to_defaults((const pb_field_t *) iter.pos->ptr, iter.pData);
            }
            else if (iter.pos->ptr != NULL)
            {
                memcpy(iter.pData, iter.pos->ptr, iter.pos->data_size);
            }
            else
            {
                memset(iter.pData, 0, iter.pos->data_size);
            }
        }
-        else if (PB_ATYPE(type) == PB_ATYPE_CALLBACK)
+        else if (PB_HTYPE(iter.current.type) == PB_HTYPE_ARRAY)
        {
            *(size_t*)iter.pSize = 0;
            continue; /* Array is empty, no need to initialize contents */
        }
        /* Initialize field contents to default value */
        if (PB_HTYPE(iter.current.type) == PB_HTYPE_CALLBACK)
        {
            continue; /* Don't overwrite callback */
        }
        else if (PB_LTYPE(iter.current.type) == PB_LTYPE_SUBMESSAGE)
        {
            pb_message_set_to_defaults(iter.current.ptr, iter.pData);
        }
        else if (iter.current.ptr != NULL)
        {
            memcpy(iter.pData, iter.current.ptr, iter.current.data_size);
        }
        else
        {
            memset(iter.pData, 0, iter.current.data_size);
        }
    } while (pb_field_next(&iter));
 }
@@ -593,223 +324,126 @@ static void pb_message_set_to_defaults(const pb_field_t fields[], void *dest_str
 * Decode all fields *
 *********************/
-bool checkreturn pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
+bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_info_t *fields, void *dest_struct)
 {
-    uint8_t fields_seen[(PB_MAX_REQUIRED_FIELDS + 7) / 8] = {0}; /* Used to check for required fields */
+    uint32_t fields_seen = 0; /* Used to check for required fields */
    uint32_t extension_range_start = 0;
    pb_field_iterator_t iter;
    const pb_field_key_t *field_keys = fields->field_keys;
    int i;
    pb_message_set_to_defaults(fields, dest_struct);
    pb_field_init(&iter, fields, dest_struct);
    while (stream->bytes_left)
    {
-        uint32_t tag;
+        uint32_t temp;
        int tag;
        pb_wire_type_t wire_type;
-        bool eof;
+        if (!pb_decode_varint32(stream, &temp))
        if (!pb_decode_tag(stream, &wire_type, &tag, &eof))
        {
-            if (eof)
+            if (stream->bytes_left == 0)
-                break;
+                break; /* It was EOF */
            else
-                return false;
+                return false; /* It was error */
        }
        if (temp == 0)
            break; /* Special feature: allow 0-terminated messages. */
        tag = temp >> 3;
        wire_type = (pb_wire_type_t)(temp & 7);
        if (!pb_field_find(&iter, tag))
        {
            /* No match found, check if it matches an extension. */
            if (tag >= extension_range_start)
            {
                if (!find_extension_field(&iter))
                    extension_range_start = (uint32_t)-1;
                else
                    extension_range_start = iter.pos->tag;
                if (tag >= extension_range_start)
                {
                    size_t pos = stream->bytes_left;
                    if (!decode_extension(stream, tag, wire_type, &iter))
                        return false;
                    if (pos != stream->bytes_left)
                    {
                        /* The field was handled */
                        continue;                    
                    }
                }
            }
            /* No match found, skip data */
-            if (!pb_skip_field(stream, wire_type))
+            if (!skip(stream, wire_type))
                return false;
            continue;
        }
-        if (PB_HTYPE(iter.pos->type) == PB_HTYPE_REQUIRED
+        fields_seen |= 1 << (iter.field_index & 31);
            && iter.required_field_index < PB_MAX_REQUIRED_FIELDS)
        {
            fields_seen[iter.required_field_index >> 3] |= (uint8_t)(1 << (iter.required_field_index & 7));
        }
        if (!decode_field(stream, wire_type, &iter))
            return false;
    }
-    /* Check that all required fields were present. */
+    /* Check that all required fields (mod 31) were present. */
    for (i = 0; field_keys != NULL; i++)
    {
-        /* First figure out the number of required fields by
+        if (PB_HTYPE(PB_FIELD_INFO(&field_keys[i], fields->field_info)->type) == PB_HTYPE_REQUIRED &&
-         * seeking to the end of the field array. Usually we
+            !(fields_seen & (1 << (i & 31))))
         * are already close to end after decoding.
         */
        unsigned req_field_count;
        pb_type_t last_type;
        unsigned i;
        do {
            req_field_count = iter.required_field_index;
            last_type = iter.pos->type;
        } while (pb_field_next(&iter));
        /* Fixup if last field was also required. */
        if (PB_HTYPE(last_type) == PB_HTYPE_REQUIRED && iter.pos->tag)
            req_field_count++;
        /* Check the whole bytes */
        for (i = 0; i < (req_field_count >> 3); i++)
        {
-            if (fields_seen[i] != 0xFF)
+            return false;
                PB_RETURN_ERROR(stream, "missing required field");
        }
-        
+        if (PB_IS_LAST(&field_keys[i])) break;
        /* Check the remaining bits */
        if (fields_seen[req_field_count >> 3] != (0xFF >> (8 - (req_field_count & 7))))
            PB_RETURN_ERROR(stream, "missing required field");
    }
    return true;
 }
 bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 {
    pb_message_set_to_defaults(fields, dest_struct);
    return pb_decode_noinit(stream, fields, dest_struct);
 }
 bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 {
    pb_istream_t substream;
    bool status;
    if (!pb_make_string_substream(stream, &substream))
        return false;
    status = pb_decode(&substream, fields, dest_struct);
    pb_close_string_substream(stream, &substream);
    return status;
 }
 /* Field decoders */
-bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest)
+/* Copy destsize bytes from src so that values are casted properly.
 * On little endian machine, copy first n bytes of src
 * On big endian machine, copy last n bytes of src
 * srcsize must always be larger than destsize
 */
 static void endian_copy(void *dest, void *src, size_t destsize, size_t srcsize)
 {
-    uint64_t value;
+#ifdef __BIG_ENDIAN__
-    if (!pb_decode_varint(stream, &value))
+    memcpy(dest, (char*)src + (srcsize - destsize), destsize);
-        return false;
+#else
-    
+    memcpy(dest, src, destsize);
-    if (value & 1)
+#endif
        *dest = (int64_t)(~(value >> 1));
    else
        *dest = (int64_t)(value >> 1);
    return true;
 }
 bool pb_decode_fixed32(pb_istream_t *stream, void *dest)
 {
    #ifdef __BIG_ENDIAN__
    uint8_t *bytes = (uint8_t*)dest;
    uint8_t lebytes[4];
    if (!pb_read(stream, lebytes, 4))
        return false;
    bytes[0] = lebytes[3];
    bytes[1] = lebytes[2];
    bytes[2] = lebytes[1];
    bytes[3] = lebytes[0];
    return true;
    #else
    return pb_read(stream, (uint8_t*)dest, 4);
    #endif   
 }
 bool pb_decode_fixed64(pb_istream_t *stream, void *dest)
 {
    #ifdef __BIG_ENDIAN__
    uint8_t *bytes = (uint8_t*)dest;
    uint8_t lebytes[8];
    if (!pb_read(stream, lebytes, 8))
        return false;
    bytes[0] = lebytes[7];
    bytes[1] = lebytes[6];
    bytes[2] = lebytes[5];
    bytes[3] = lebytes[4];
    bytes[4] = lebytes[3];
    bytes[5] = lebytes[2];
    bytes[6] = lebytes[1];
    bytes[7] = lebytes[0];
    return true;
    #else
    return pb_read(stream, (uint8_t*)dest, 8);
    #endif   
 }
 bool checkreturn pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    uint64_t value;
+    uint64_t temp;
-    if (!pb_decode_varint(stream, &value))
+    bool status = pb_decode_varint(stream, &temp);
-        return false;
+    endian_copy(dest, &temp, field->data_size, sizeof(temp));
-    
+    return status;
    switch (field->data_size)
    {
        case 1: *(uint8_t*)dest = (uint8_t)value; break;
        case 2: *(uint16_t*)dest = (uint16_t)value; break;
        case 4: *(uint32_t*)dest = (uint32_t)value; break;
        case 8: *(uint64_t*)dest = value; break;
        default: PB_RETURN_ERROR(stream, "invalid data_size");
    }
    return true;
 }
 bool checkreturn pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    int64_t value;
+    uint64_t temp;
-    if (!pb_decode_svarint(stream, &value))
+    bool status = pb_decode_varint(stream, &temp);
-        return false;
+    temp = (temp >> 1) ^ -(int64_t)(temp & 1);
-    
+    endian_copy(dest, &temp, field->data_size, sizeof(temp));
-    switch (field->data_size)
+    return status;
    {
        case 4: *(int32_t*)dest = (int32_t)value; break;
        case 8: *(int64_t*)dest = value; break;
        default: PB_RETURN_ERROR(stream, "invalid data_size");
    }
    return true;
 }
 bool checkreturn pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    UNUSED(field);
+#ifdef __BIG_ENDIAN__
-    return pb_decode_fixed32(stream, dest);
+    uint8_t bytes[4] = {0};
    bool status = pb_read(stream, bytes, 4);
    if (status) {
      uint8_t bebytes[4] = {bytes[3], bytes[2], bytes[1], bytes[0]};
      memcpy(dest, bebytes, 4);
    }
    return status;
 #else
    return pb_read(stream, (uint8_t*)dest, 4);
 #endif
 }
 bool checkreturn pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
-    UNUSED(field);
+#ifdef __BIG_ENDIAN__
-    return pb_decode_fixed64(stream, dest);
+    uint8_t bytes[8] = {0};
    bool status = pb_read(stream, bytes, 8);
    if (status) {
      uint8_t bebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4], 
                            bytes[3], bytes[2], bytes[1], bytes[0]};
      memcpy(dest, bebytes, 8);
    }
    return status;
 #else
    return pb_read(stream, (uint8_t*)dest, 8);
 #endif
 }
 bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest)
@@ -823,7 +457,7 @@ bool checkreturn pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, voi
    /* Check length, noting the space taken by the size_t header. */
    if (x->size > field->data_size - offsetof(pb_bytes_array_t, bytes))
-        PB_RETURN_ERROR(stream, "bytes overflow");
+        return false;    
    return pb_read(stream, x->bytes, x->size);
 }
@@ -835,9 +469,8 @@ bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, vo
    if (!pb_decode_varint32(stream, &size))
        return false;
-    /* Check length, noting the null terminator */
+    if ((int) size > field->data_size - 1)
-    if (size + 1 > field->data_size)
+        return false;
        PB_RETURN_ERROR(stream, "string overflow");
    status = pb_read(stream, (uint8_t*)dest, size);
    *((uint8_t*)dest + size) = 0;
@@ -848,21 +481,14 @@ bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field
 {
    bool status;
    pb_istream_t substream;
    const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr;
-    if (!pb_make_string_substream(stream, &substream))
+    if (!make_string_substream(stream, &substream))
        return false;
    if (field->ptr == NULL)
-        PB_RETURN_ERROR(stream, "invalid field descriptor");
+        return false;
-    /* New array entries need to be initialized, while required and optional
+    status = pb_decode(&substream, (pb_field_info_t*)field->ptr, dest);
-     * submessages have already been initialized in the top-level pb_decode. */
+    stream->state = substream.state;
    if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
        status = pb_decode(&substream, submsg_fields, dest);
    else
        status = pb_decode_noinit(&substream, submsg_fields, dest);
    pb_close_string_substream(stream, &substream);
    return status;
 }
--- a/pb_decode.h
+++ b/pb_decode.h
@@ -1,142 +1,64 @@
 /* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
 * The main function is pb_decode. You also need an input stream, and the
 * field descriptions created by nanopb_generator.py.
 */
 #ifndef _PB_DECODE_H_
 #define _PB_DECODE_H_
 /* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
 * The main function is pb_decode. You will also need to create an input
 * stream, which is easiest to do with pb_istream_t.
 * 
 * You also need structures and their corresponding pb_field_t descriptions.
 * These are usually generated from .proto-files with a script.
 */
 #include <stdbool.h>
 #include "pb.h"
-#ifdef __cplusplus
+/* Lightweight input stream.
-extern "C" {
+ * You can provide a callback function for reading or use
-#endif
+ * pb_istream_from_buffer.
 /* Structure for defining custom input streams. You will need to provide
 * a callback function to read the bytes from your storage, which can be
 * for example a file or a network socket.
 * 
- * The callback must conform to these rules:
+ * Rules for callback:
 *
 * 1) Return false on IO errors. This will cause decoding to abort.
- * 2) You can use state to store your own data (e.g. buffer pointer),
+ * 
- *    and rely on pb_read to verify that no-body reads past bytes_left.
+ * 2) If buf is NULL, read but don't store bytes ("skip input").
- * 3) Your callback may be used with substreams, in which case bytes_left
+ * 
- *    is different than from the main stream. Don't use bytes_left to compute
+ * 3) You can use state to store your own data (e.g. buffer pointer),
- *    any pointers.
+ * and rely on pb_read to verify that no-body reads past bytes_left.
 * 
 * 4) Your callback may be used with substreams, in which case bytes_left
 * is different than from the main stream. Don't use bytes_left to compute
 * any pointers.
 */
 struct _pb_istream_t
 {
 #ifdef PB_BUFFER_ONLY
    /* Callback pointer is not used in buffer-only configuration.
     * Having an int pointer here allows binary compatibility but
     * gives an error if someone tries to assign callback function.
     */
    int *callback;
 #else
    bool (*callback)(pb_istream_t *stream, uint8_t *buf, size_t count);
 #endif
    void *state; /* Free field for use by callback implementation */
    size_t bytes_left;
 #ifndef PB_NO_ERRMSG
    const char *errmsg;
 #endif
 };
 /***************************
 * Main decoding functions *
 ***************************/
 /* Decode a single protocol buffers message from input stream into a C structure.
 * Returns true on success, false on any failure.
 * The actual struct pointed to by dest must match the description in fields.
 * Callback fields of the destination structure must be initialized by caller.
 * All other fields will be initialized by this function.
 *
 * Example usage:
 *    MyMessage msg = {};
 *    uint8_t buffer[64];
 *    pb_istream_t stream;
 *    
 *    // ... read some data into buffer ...
 *
 *    stream = pb_istream_from_buffer(buffer, count);
 *    pb_decode(&stream, MyMessage_fields, &msg);
 */
 bool pb_decode(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
 /* Same as pb_decode, except does not initialize the destination structure
 * to default values. This is slightly faster if you need no default values
 * and just do memset(struct, 0, sizeof(struct)) yourself.
 *
 * This can also be used for 'merging' two messages, i.e. update only the
 * fields that exist in the new message.
 */
 bool pb_decode_noinit(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
 /* Same as pb_decode, except expects the stream to start with the message size
 * encoded as varint. Corresponds to parseDelimitedFrom() in Google's
 * protobuf API.
 */
 bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
 /**************************************
 * Functions for manipulating streams *
 **************************************/
 /* Create an input stream for reading from a memory buffer.
 *
 * Alternatively, you can use a custom stream that reads directly from e.g.
 * a file or a network socket.
 */
 pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize);
 /* Function to read from a pb_istream_t. You can use this if you need to
 * read some custom header data, or to read data in field callbacks.
 */
 bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count);
 /* Decode from stream to destination struct.
 * Returns true on success, false on any failure.
 * The actual struct pointed to by dest must match the description in fields.
 */
 bool pb_decode(pb_istream_t *stream, const pb_field_info_t *fields, void *dest_struct);
-/************************************************
+/* --- Helper functions ---
- * Helper functions for writing field callbacks *
+ * You may want to use these from your caller or callbacks.
- ************************************************/
+ */
 /* Decode the tag for the next field in the stream. Gives the wire type and
 * field tag. At end of the message, returns false and sets eof to true. */
 bool pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof);
 /* Skip the field payload data, given the wire type. */
 bool pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type);
 /* Decode an integer in the varint format. This works for bool, enum, int32,
 * int64, uint32 and uint64 field types. */
 bool pb_decode_varint(pb_istream_t *stream, uint64_t *dest);
-/* Decode an integer in the zig-zagged svarint format. This works for sint32
+bool pb_skip_varint(pb_istream_t *stream);
- * and sint64. */
+bool pb_skip_string(pb_istream_t *stream);
 bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest);
-/* Decode a fixed32, sfixed32 or float value. You need to pass a pointer to
+/* --- Field decoders ---
- * a 4-byte wide C variable. */
+ * Each decoder takes stream and field description, and a pointer to the field
-bool pb_decode_fixed32(pb_istream_t *stream, void *dest);
+ * in the destination struct (dest = struct_addr + field->data_offset).
 * For arrays, these functions are called repeatedly.
 */
 /* Decode a fixed64, sfixed64 or double value. You need to pass a pointer to
 * a 8-byte wide C variable. */
 bool pb_decode_fixed64(pb_istream_t *stream, void *dest);
 /* Make a limited-length substream for reading a PB_WT_STRING field. */
 bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 /*******************************
 * Internal / legacy functions *
 *******************************/
 #ifdef NANOPB_INTERNALS
 bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest);
 bool pb_dec_svarint(pb_istream_t *stream, const pb_field_t *field, void *dest);
 bool pb_dec_fixed32(pb_istream_t *stream, const pb_field_t *field, void *dest);
@@ -146,12 +68,6 @@ bool pb_dec_bytes(pb_istream_t *stream, const pb_field_t *field, void *dest);
 bool pb_dec_string(pb_istream_t *stream, const pb_field_t *field, void *dest);
 bool pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest);
-bool pb_skip_varint(pb_istream_t *stream);
+#define PB_ISTREAM_INIT {0,0,0}
 bool pb_skip_string(pb_istream_t *stream);
 #endif
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 #endif
--- a/pb_encode.c
+++ b/pb_encode.c
@@ -3,18 +3,18 @@
 * 2011 Petteri Aimonen <jpa@kapsi.fi>
 */
 #define NANOPB_INTERNALS
 #include "pb.h"
 #include "pb_encode.h"
 #include <string.h>
-/* The warn_unused_result attribute appeared first in gcc-3.4.0 */
+#ifdef __GNUC__
-#if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
+/* Verify that we remember to check all return values for proper error propagation */
-    #define checkreturn
+#define checkreturn __attribute__((warn_unused_result))
 #else
-    /* Verify that we remember to check all return values for proper error propagation */
+#define checkreturn
    #define checkreturn __attribute__((warn_unused_result))
 #endif
 typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src) checkreturn;
 /* --- Function pointers to field encoders ---
@@ -28,8 +28,7 @@ static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
    &pb_enc_bytes,
    &pb_enc_string,
-    &pb_enc_submessage,
+    &pb_enc_submessage
    NULL /* extensions */
 };
 /* pb_ostream_t implementation */
@@ -37,28 +36,18 @@ static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
 static bool checkreturn buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
 {
    uint8_t *dest = (uint8_t*)stream->state;
    memcpy(dest, buf, count);
    stream->state = dest + count;
    while (count--)
        *dest++ = *buf++;
    return true;
 }
 pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize)
 {
    pb_ostream_t stream;
 #ifdef PB_BUFFER_ONLY
    stream.callback = (void*)1; /* Just some marker value */
 #else
    stream.callback = &buf_write;
 #endif
    stream.state = buf;
    stream.max_size = bufsize;
    stream.bytes_written = 0;
 #ifndef PB_NO_ERRMSG
    stream.errmsg = NULL;
 #endif
    return stream;
 }
@@ -67,15 +56,10 @@ bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count
    if (stream->callback != NULL)
    {
        if (stream->bytes_written + count > stream->max_size)
-            PB_RETURN_ERROR(stream, "stream full");
+            return false;
-
+        
 #ifdef PB_BUFFER_ONLY
        if (!buf_write(stream, buf, count))
            PB_RETURN_ERROR(stream, "io error");
 #else        
        if (!stream->callback(stream, buf, count))
-            PB_RETURN_ERROR(stream, "io error");
+            return false;
 #endif
    }
    stream->bytes_written += count;
@@ -84,7 +68,10 @@ bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count
 /* Main encoding stuff */
-/* Encode a static array. Handles the size calculations and possible packing. */
+/* Callbacks don't need this function because they usually know the data type
 * without examining the field structure.
 * Therefore it is static for now.
 */
 static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field,
                         const void *pData, size_t count, pb_encoder_t func)
 {
@@ -95,7 +82,6 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
    if (count == 0)
        return true;
    /* We always pack arrays if the datatype allows it. */
    if (PB_LTYPE(field->type) <= PB_LTYPE_LAST_PACKABLE)
    {
        if (!pb_encode_tag(stream, PB_WT_STRING, field->tag))
@@ -111,8 +97,8 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
            size = 8 * count;
        }
        else
-        { 
+        {
-            pb_ostream_t sizestream = PB_OSTREAM_SIZING;
+            pb_ostream_t sizestream = PB_OSTREAM_INIT;
            p = pData;
            for (i = 0; i < count; i++)
            {
@@ -123,7 +109,7 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
            size = sizestream.bytes_written;
        }
-        if (!pb_encode_varint(stream, (uint64_t)size))
+        if (!pb_encode_varint(stream, size))
            return false;
        if (stream->callback == NULL)
@@ -154,180 +140,89 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
    return true;
 }
-/* Encode a field with static allocation, i.e. one whose data is stored
+bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_info_t *fields, const void *src_struct)
 * in the structure itself. */
 static bool checkreturn encode_static_field(pb_ostream_t *stream,
    const pb_field_t *field, const void *pData)
 {
-    pb_encoder_t func;
+    const pb_field_t *field;
-    const void *pSize;
+    const pb_field_key_t *field_key = fields->field_keys;
    bool dummy = true;
    func = PB_ENCODERS[PB_LTYPE(field->type)];
    if (field->size_offset)
        pSize = (const char*)pData + field->size_offset;
    else
        pSize = &dummy;
    switch (PB_HTYPE(field->type))
    {
        case PB_HTYPE_REQUIRED:
            if (!pb_encode_tag_for_field(stream, field))
                return false;
            if (!func(stream, field, pData))
                return false;
            break;
        case PB_HTYPE_OPTIONAL:
            if (*(const bool*)pSize)
            {
                if (!pb_encode_tag_for_field(stream, field))
                    return false;
                if (!func(stream, field, pData))
                    return false;
            }
            break;
        case PB_HTYPE_REPEATED:
            if (!encode_array(stream, field, pData, *(const size_t*)pSize, func))
                return false;
            break;
        default:
            PB_RETURN_ERROR(stream, "invalid field type");
    }
    return true;
 }
 /* Encode a field with callback semantics. This means that a user function is
 * called to provide and encode the actual data. */
 static bool checkreturn encode_callback_field(pb_ostream_t *stream,
    const pb_field_t *field, const void *pData)
 {
    const pb_callback_t *callback = (const pb_callback_t*)pData;
 #ifdef PB_OLD_CALLBACK_STYLE
    const void *arg = callback->arg;
 #else
    void * const *arg = &(callback->arg);
 #endif    
    if (callback->funcs.encode != NULL)
    {
        if (!callback->funcs.encode(stream, field, arg))
            PB_RETURN_ERROR(stream, "callback error");
    }
    return true;
 }
 /* Encode a single field of any callback or static type. */
 static bool checkreturn encode_field(pb_ostream_t *stream,
    const pb_field_t *field, const void *pData)
 {
    switch (PB_ATYPE(field->type))
    {
        case PB_ATYPE_STATIC:
            return encode_static_field(stream, field, pData);
        case PB_ATYPE_CALLBACK:
            return encode_callback_field(stream, field, pData);
        default:
            PB_RETURN_ERROR(stream, "invalid field type");
    }
 }
 /* Default handler for extension fields. Expects to have a pb_field_t
 * pointer in the extension->type->arg field. */
 static bool checkreturn default_extension_handler(pb_ostream_t *stream,
    const pb_extension_t *extension)
 {
    const pb_field_t *field = (const pb_field_t*)extension->type->arg;
    return encode_field(stream, field, extension->dest);
 }
 /* Walk through all the registered extensions and give them a chance
 * to encode themselves. */
 static bool checkreturn encode_extension_field(pb_ostream_t *stream,
    const pb_field_t *field, const void *pData)
 {
    const pb_extension_t *extension = *(const pb_extension_t* const *)pData;
    UNUSED(field);
    while (extension)
    {
        bool status;
        if (extension->type->encode)
            status = extension->type->encode(stream, extension);
        else
            status = default_extension_handler(stream, extension);
        if (!status)
            return false;
        extension = extension->next;
    }
    return true;
 }
 bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 {
    const pb_field_t *field = fields;
    const void *pData = src_struct;
    const void *pSize;
    size_t prev_size = 0;
-    while (field->tag != 0)
+    while(field_key != NULL)
    {
        pb_field_t f = *(PB_FIELD_INFO(field_key, fields->field_info));
        f.tag = PB_TAG_VAL(field_key);
        field = &f;
        pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)];
        pData = (const char*)pData + prev_size + field->data_offset;
        pSize = (const char*)pData + field->size_offset;
        prev_size = field->data_size;
-        
+        if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY)
        /* 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;
-        }
+                
-        
+        switch (PB_HTYPE(field->type))
        if (PB_LTYPE(field->type) == PB_LTYPE_EXTENSION)
        {
-            /* Special case for the extension field placeholder */
+            case PB_HTYPE_REQUIRED:
-            if (!encode_extension_field(stream, field, pData))
+                if (!pb_encode_tag_for_field(stream, field))
-                return false;
+                    return false;
                if (!func(stream, field, pData))
                    return false;
                break;
            case PB_HTYPE_OPTIONAL:
                if (*(bool*)pSize)
                {
                    if (!pb_encode_tag_for_field(stream, field))
                        return false;
                    if (!func(stream, field, pData))
                        return false;
                }
                break;
            case PB_HTYPE_ARRAY:
                if (!encode_array(stream, field, pData, *(size_t*)pSize, func))
                    return false;
                break;
            case PB_HTYPE_CALLBACK:
            {
                pb_callback_t *callback = (pb_callback_t*)pData;
                if (callback->funcs.encode != NULL)
                {
                    if (!callback->funcs.encode(stream, field, callback->arg))
                        return false;
                }
                break;
            }
        }
-        else
+        if (PB_IS_LAST(field_key++)) break;
        {
            /* Regular field */
            if (!encode_field(stream, field, pData))
                return false;
        }
        field++;
    }
    return true;
 }
-bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
+int checkreturn pb_get_message_size(const pb_field_info_t *fields, const void *src_struct)
 {
-    return pb_encode_submessage(stream, fields, src_struct);
+    pb_ostream_t ostream = PB_OSTREAM_INIT;
    if (pb_encode(&ostream, fields, src_struct))
        return ostream.bytes_written;
    return -1;
 }
 /* Helper functions */
 bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value)
 {
    uint8_t buffer[10];
-    size_t i = 0;
+    int i = 0;
    if (value == 0)
        return pb_write(stream, (uint8_t*)&value, 1);
    while (value)
    {
-        buffer[i] = (uint8_t)((value & 0x7F) | 0x80);
+        buffer[i] = (value & 0x7F) | 0x80;
        value >>= 7;
        i++;
    }
@@ -336,54 +231,9 @@ bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value)
    return pb_write(stream, buffer, i);
 }
-bool checkreturn pb_encode_svarint(pb_ostream_t *stream, int64_t value)
+bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number)
 {
-    uint64_t zigzagged;
+    int tag = wiretype | (field_number << 3);
    if (value < 0)
        zigzagged = (uint64_t)(~(value << 1));
    else
        zigzagged = (uint64_t)(value << 1);
    return pb_encode_varint(stream, zigzagged);
 }
 bool checkreturn pb_encode_fixed32(pb_ostream_t *stream, const void *value)
 {
    #ifdef __BIG_ENDIAN__
    const uint8_t *bytes = value;
    uint8_t lebytes[4];
    lebytes[0] = bytes[3];
    lebytes[1] = bytes[2];
    lebytes[2] = bytes[1];
    lebytes[3] = bytes[0];
    return pb_write(stream, lebytes, 4);
    #else
    return pb_write(stream, (const uint8_t*)value, 4);
    #endif
 }
 bool checkreturn pb_encode_fixed64(pb_ostream_t *stream, const void *value)
 {
    #ifdef __BIG_ENDIAN__
    const uint8_t *bytes = value;
    uint8_t lebytes[8];
    lebytes[0] = bytes[7];
    lebytes[1] = bytes[6];
    lebytes[2] = bytes[5];
    lebytes[3] = bytes[4];
    lebytes[4] = bytes[3];
    lebytes[5] = bytes[2];
    lebytes[6] = bytes[1];
    lebytes[7] = bytes[0];
    return pb_write(stream, lebytes, 8);
    #else
    return pb_write(stream, (const uint8_t*)value, 8);
    #endif
 }
 bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number)
 {
    uint64_t tag = wiretype | (field_number << 3);
    return pb_encode_varint(stream, tag);
 }
@@ -412,7 +262,7 @@ bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t
            break;
        default:
-            PB_RETURN_ERROR(stream, "invalid field type");
+            return false;
    }
    return pb_encode_tag(stream, wiretype, field->tag);
@@ -420,32 +270,112 @@ bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t
 bool checkreturn pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size)
 {
-    if (!pb_encode_varint(stream, (uint64_t)size))
+    if (!pb_encode_varint(stream, size))
        return false;
    return pb_write(stream, buffer, size);
 }
-bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
+/* Field encoders */
 /* Copy srcsize bytes from src so that values are casted properly.
 * On little endian machine, copy to start of dest
 * On big endian machine, copy to end of dest
 * destsize must always be larger than srcsize
 * 
 * Note: This is the reverse of the endian_copy in pb_decode.c.
 */
 static void endian_copy(void *dest, const void *src, size_t destsize, size_t srcsize)
 {
-    /* First calculate the message size using a non-writing substream. */
+#ifdef __BIG_ENDIAN__
-    pb_ostream_t substream = PB_OSTREAM_SIZING;
+    memcpy((char*)dest + (destsize - srcsize), src, srcsize);
 #else
    memcpy(dest, src, srcsize);
 #endif
 }
 bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    uint64_t value = 0;
    endian_copy(&value, src, sizeof(value), field->data_size);
    return pb_encode_varint(stream, value);
 }
 bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    uint64_t value = 0;
    uint64_t zigzagged;
    uint64_t signbitmask, xormask;
    endian_copy(&value, src, sizeof(value), field->data_size);
    signbitmask = (uint64_t)0x80 << (field->data_size * 8 - 8);
    xormask = ((uint64_t)-1) >> (64 - field->data_size * 8);
    if (value & signbitmask)
        zigzagged = ((value ^ xormask) << 1) | 1;
    else
        zigzagged = value << 1;
    return pb_encode_varint(stream, zigzagged);
 }
 bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    #ifdef __BIG_ENDIAN__
    uint8_t bytes[8] = {0};
    memcpy(bytes, src, 8);
    uint8_t lebytes[8] = {bytes[7], bytes[6], bytes[5], bytes[4], 
                          bytes[3], bytes[2], bytes[1], bytes[0]};
    return pb_write(stream, lebytes, 8);
    #else
    return pb_write(stream, (uint8_t*)src, 8);
    #endif
 }
 bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    #ifdef __BIG_ENDIAN__
    uint8_t bytes[4] = {0};
    memcpy(bytes, src, 4);
    uint8_t lebytes[4] = {bytes[3], bytes[2], bytes[1], bytes[0]};
    return pb_write(stream, lebytes, 4);
    #else
    return pb_write(stream, (uint8_t*)src, 4);
    #endif
 }
 bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    pb_bytes_array_t *bytes = (pb_bytes_array_t*)src;
    return pb_encode_string(stream, bytes->bytes, bytes->size);
 }
 bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    return pb_encode_string(stream, (uint8_t*)src, strlen((char*)src));
 }
 bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    pb_ostream_t substream = {0, 0, 0, 0};
    size_t size;
    bool status;
-    if (!pb_encode(&substream, fields, src_struct))
+    if (field->ptr == NULL)
        return false;
    if (!pb_encode(&substream, (pb_field_info_t*)field->ptr, src))
        return false;
    size = substream.bytes_written;
-    if (!pb_encode_varint(stream, (uint64_t)size))
+    if (!pb_encode_varint(stream, size))
        return false;
    if (stream->callback == NULL)
        return pb_write(stream, NULL, size); /* Just sizing */
    if (stream->bytes_written + size > stream->max_size)
-        PB_RETURN_ERROR(stream, "stream full");
+        return false;
    /* Use a substream to verify that a callback doesn't write more than
     * what it did the first time. */
@@ -453,94 +383,15 @@ bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fie
    substream.state = stream->state;
    substream.max_size = size;
    substream.bytes_written = 0;
 #ifndef PB_NO_ERRMSG
    substream.errmsg = NULL;
 #endif
-    status = pb_encode(&substream, fields, src_struct);
+    status = pb_encode(&substream, (pb_field_info_t*)field->ptr, src);
    stream->bytes_written += substream.bytes_written;
    stream->state = substream.state;
 #ifndef PB_NO_ERRMSG
    stream->errmsg = substream.errmsg;
 #endif
    if (substream.bytes_written != size)
-        PB_RETURN_ERROR(stream, "submsg size changed");
+        return false;
    return status;
 }
 /* Field encoders */
 bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    uint64_t value = 0;
    switch (field->data_size)
    {
        case 1: value = *(const uint8_t*)src; break;
        case 2: value = *(const uint16_t*)src; break;
        case 4: value = *(const uint32_t*)src; break;
        case 8: value = *(const uint64_t*)src; break;
        default: PB_RETURN_ERROR(stream, "invalid data_size");
    }
    return pb_encode_varint(stream, value);
 }
 bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    int64_t value = 0;
    switch (field->data_size)
    {
        case 4: value = *(const int32_t*)src; break;
        case 8: value = *(const int64_t*)src; break;
        default: PB_RETURN_ERROR(stream, "invalid data_size");
    }
    return pb_encode_svarint(stream, value);
 }
 bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    UNUSED(field);
    return pb_encode_fixed64(stream, src);
 }
 bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    UNUSED(field);
    return pb_encode_fixed32(stream, src);
 }
 bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    const pb_bytes_array_t *bytes = (const pb_bytes_array_t*)src;
    UNUSED(field);
    return pb_encode_string(stream, bytes->bytes, bytes->size);
 }
 bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    /* strnlen() is not always available, so just use a for-loop */
    size_t size = 0;
    const char *p = (const char*)src;
    while (size < field->data_size && *p != '\0')
    {
        size++;
        p++;
    }
    return pb_encode_string(stream, (const uint8_t*)src, size);
 }
 bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
    if (field->ptr == NULL)
        PB_RETURN_ERROR(stream, "invalid field descriptor");
    return pb_encode_submessage(stream, (const pb_field_t*)field->ptr, src);
 }
--- a/pb_encode.h
+++ b/pb_encode.h
@@ -1,168 +1,75 @@
 /* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
 * The main function is pb_encode. You also need an output stream, and the
 * field descriptions created by nanopb_generator.py.
 */
 #ifndef _PB_ENCODE_H_
 #define _PB_ENCODE_H_
 /* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
 * The main function is pb_encode. You also need an output stream, structures
 * and their field descriptions (just like with pb_decode).
 */
 #include <stdbool.h>
 #include "pb.h"
-#ifdef __cplusplus
+/* Lightweight output stream.
-extern "C" {
+ * You can provide callback for writing or use pb_ostream_from_buffer.
-#endif
+ * 
-
+ * Alternatively, callback can be NULL in which case the stream will just
-/* Structure for defining custom output streams. You will need to provide
+ * count the number of bytes that would have been written. In this case
- * a callback function to write the bytes to your storage, which can be
+ * max_size is not checked.
 * for example a file or a network socket.
 *
 * The callback must conform to these rules:
 *
 * Rules for callback:
 * 1) Return false on IO errors. This will cause encoding to abort.
 * 
 * 2) You can use state to store your own data (e.g. buffer pointer).
 * 
 * 3) pb_write will update bytes_written after your callback runs.
- * 4) Substreams will modify max_size and bytes_written. Don't use them
+ * 
- *    to calculate any pointers.
+ * 4) Substreams will modify max_size and bytes_written. Don't use them to
 * calculate any pointers.
 */
 struct _pb_ostream_t
 {
 #ifdef PB_BUFFER_ONLY
    /* Callback pointer is not used in buffer-only configuration.
     * Having an int pointer here allows binary compatibility but
     * gives an error if someone tries to assign callback function.
     * Also, NULL pointer marks a 'sizing stream' that does not
     * write anything.
     */
    int *callback;
 #else
    bool (*callback)(pb_ostream_t *stream, const uint8_t *buf, size_t count);
-#endif
+    void *state; /* Free field for use by callback implementation */
-    void *state;          /* Free field for use by callback implementation. */
+    size_t max_size; /* Limit number of output bytes written (or use SIZE_MAX). */
-    size_t max_size;      /* Limit number of output bytes written (or use SIZE_MAX). */
+    size_t bytes_written;
    size_t bytes_written; /* Number of bytes written so far. */
 #ifndef PB_NO_ERRMSG
    const char *errmsg;
 #endif
 };
-/***************************
+pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize);
- * Main encoding functions *
+bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 ***************************/
-/* Encode a single protocol buffers message from C structure into a stream.
+/* Encode struct to given output stream.
 * Returns true on success, false on any failure.
 * The actual struct pointed to by src_struct must match the description in fields.
 * All required fields in the struct are assumed to have been filled in.
 *
 * Example usage:
 *    MyMessage msg = {};
 *    uint8_t buffer[64];
 *    pb_ostream_t stream;
 *
 *    msg.field1 = 42;
 *    stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
 *    pb_encode(&stream, MyMessage_fields, &msg);
 */
-bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
+bool pb_encode(pb_ostream_t *stream, const pb_field_info_t *fields, const void *src_struct);
-/* Same as pb_encode, but prepends the length of the message as a varint.
+int pb_get_message_size(const pb_field_info_t *fields, const void *src_struct);
- * Corresponds to writeDelimitedTo() in Google's protobuf API.
+
 /* --- Helper functions ---
 * You may want to use these from your caller or callbacks.
 */
 bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
 /**************************************
 * Functions for manipulating streams *
 **************************************/
 /* Create an output stream for writing into a memory buffer.
 * The number of bytes written can be found in stream.bytes_written after
 * encoding the message.
 *
 * Alternatively, you can use a custom stream that writes directly to e.g.
 * a file or a network socket.
 */
 pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize);
 /* Pseudo-stream for measuring the size of a message without actually storing
 * the encoded data.
 * 
 * Example usage:
 *    MyMessage msg = {};
 *    pb_ostream_t stream = PB_OSTREAM_SIZING;
 *    pb_encode(&stream, MyMessage_fields, &msg);
 *    printf("Message size is %d\n", stream.bytes_written);
 */
 #ifndef PB_NO_ERRMSG
 #define PB_OSTREAM_SIZING {0,0,0,0,0}
 #else
 #define PB_OSTREAM_SIZING {0,0,0,0}
 #endif
 /* Function to write into a pb_ostream_t stream. You can use this if you need
 * to append or prepend some custom headers to the message.
 */
 bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 /************************************************
 * Helper functions for writing field callbacks *
 ************************************************/
 /* Encode field header based on type and field number defined in the field
 * structure. Call this from the callback before writing out field contents. */
 bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field);
 /* Encode field header by manually specifing wire type. You need to use this
 * if you want to write out packed arrays from a callback field. */
 bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number);
 /* Encode an integer in the varint format.
 * This works for bool, enum, int32, int64, uint32 and uint64 field types. */
 bool pb_encode_varint(pb_ostream_t *stream, uint64_t value);
-
+bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, int field_number);
-/* Encode an integer in the zig-zagged svarint format.
+/* Encode tag based on LTYPE and field number defined in the field structure. */
- * This works for sint32 and sint64. */
+bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field);
-bool pb_encode_svarint(pb_ostream_t *stream, int64_t value);
+/* Write length as varint and then the contents of buffer. */
 /* Encode a string or bytes type field. For strings, pass strlen(s) as size. */
 bool pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, size_t size);
-/* Encode a fixed32, sfixed32 or float value.
+/* --- Field encoders ---
- * You need to pass a pointer to a 4-byte wide C variable. */
+ * Each encoder writes the content for the field.
-bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
+ * The tag/wire type has been written already.
 /* Encode a fixed64, sfixed64 or double value.
 * You need to pass a pointer to a 8-byte wide C variable. */
 bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
 /* Encode a submessage field.
 * You need to pass the pb_field_t array and pointer to struct, just like
 * with pb_encode(). This internally encodes the submessage twice, first to
 * calculate message size and then to actually write it out.
 */
 bool pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
 /*******************************
 * Internal / legacy functions *
 *******************************/
 #ifdef NANOPB_INTERNALS
 bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 bool pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 bool pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 bool pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 bool pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 bool pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 #endif
 /* This function is not recommended for new programs. Use pb_encode_submessage()
 * instead, it has the same functionality with a less confusing interface. */
 bool pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-#ifdef __cplusplus
+#define PB_OSTREAM_INIT {0,0,0,0}
 } /* extern "C" */
 #endif
 #endif
--- a/pb_field.c
+++ b/pb_field.c
@@ -0,0 +1,98 @@
 #include "pb_field.h"
 #ifdef __GNUC__
 /* Verify that we remember to check all return values for proper error propagation */
 #define checkreturn __attribute__((warn_unused_result))
 #else
 #define checkreturn
 #endif
 /**
 * pb_common_aligned_field_info array holds the common field info that can be shared
 * by any numeric fields whose previous field is memory aligned
 */
 const pb_field_t pb_common_aligned_field_info[NUM_COMMON_FIELD_INFO] = {
 	/* REQUIRED bool */
    {0, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT, 0, 0, sizeof(bool), 0, 0},
    /* OPTIONAL bool */
    {0, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT, 1, -1, sizeof(bool), 0, 0},
 	/* REQUIRED int32, uint32, enum */
    {0, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT, 0, 0, sizeof(uint32_t), 0, 0},
    /* OPTIONAL int32, uint32, enum */
    {0, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT, 4, -4, sizeof(uint32_t), 0, 0},
 	/* REQUIRED int64, uint64 */
    {0, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT, 0, 0, sizeof(uint64_t), 0, 0},
    /* OPTIONAL int64, uint64 */
    {0, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT, 4, -4, sizeof(uint64_t), 0, 0},
    /* REQUIRED sint32 */
    {0, PB_HTYPE_REQUIRED | PB_LTYPE_SVARINT, 0, 0, sizeof(int32_t), 0, 0},
    /* OPTIONAL sint32 */
    {0, PB_HTYPE_OPTIONAL | PB_LTYPE_SVARINT, 4, -4, sizeof(int32_t), 0, 0},
    /* REQUIRED sint64 */
    {0, PB_HTYPE_REQUIRED | PB_LTYPE_SVARINT, 0, 0, sizeof(int64_t), 0, 0},
    /* OPTIONAL sint64 */
    {0, PB_HTYPE_OPTIONAL | PB_LTYPE_SVARINT, 4, -4, sizeof(int64_t), 0, 0},
    /* REQUIRED fixed32, sfixed32, float */
    {0, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED32, 0, 0, sizeof(uint32_t), 0, 0},
    /* OPTIONAL fixed32, sfixed32, float */
    {0, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED32, 4, -4, sizeof(uint32_t), 0, 0},
    /* REQUIRED fixed64, sfixed64, double */
    {0, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED64, 0, 0, sizeof(uint64_t), 0, 0},
    /* OPTIONAL fixed64, sfixed64, double */
    {0, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED64, 4, -4, sizeof(uint64_t), 0, 0}
 };
 void pb_field_init(pb_field_iterator_t *iter, const pb_field_info_t *fields, void *dest_struct)
 {
    if (fields->field_keys == NULL) return;
    iter->start_key = iter->current_key = fields->field_keys;
    iter->field_info = fields->field_info;
    iter->current = *(PB_FIELD_INFO(iter->current_key, iter->field_info));
    iter->current.tag = PB_TAG_VAL(iter->current_key);
    iter->field_index = 0;
    iter->pData = (char*)dest_struct + iter->current.data_offset;
    iter->pSize = (char*)iter->pData + iter->current.size_offset;
    iter->dest_struct = dest_struct;
 }
 bool pb_field_next(pb_field_iterator_t *iter)
 {
    bool notwrapped = true;
    size_t prev_size = iter->current.data_size;
    if (PB_HTYPE(iter->current.type) == PB_HTYPE_ARRAY)
        prev_size *= iter->current.array_size;
    iter->field_index++;
    if (PB_IS_LAST(iter->current_key))
    {
        iter->current_key = iter->start_key;
        iter->current = *(PB_FIELD_INFO(iter->current_key, iter->field_info));
        iter->current.tag = PB_TAG_VAL(iter->current_key);
        iter->field_index = 0;
        iter->pData = iter->dest_struct;
        prev_size = 0;
        notwrapped = false;
    } else {
        iter->current_key++;
        iter->current = *(PB_FIELD_INFO(iter->current_key, iter->field_info));
        iter->current.tag = PB_TAG_VAL(iter->current_key);
    }
    iter->pData = (char*)iter->pData + prev_size + iter->current.data_offset;
    iter->pSize = (char*)iter->pData + iter->current.size_offset;
    return notwrapped;
 }
 bool checkreturn pb_field_find(pb_field_iterator_t *iter, int tag)
 {
    int start = iter->field_index;
    do {
        if (iter->current.tag == tag)
            return true;
        pb_field_next(iter);
    } while (iter->field_index != start);
    return false;
 }
--- a/pb_field.h
+++ b/pb_field.h
@@ -0,0 +1,211 @@
 #ifndef _PB_FIELD_H_
 #define _PB_FIELD_H_
 #include <stdint.h>
 #include <stddef.h>
 #include <stdbool.h>
 #ifdef __GNUC__
 /* This just reduces memory requirements, but is not required. */
 #define pb_packed __attribute__((packed))
 #else
 #define pb_packed
 #endif
 /* List of possible field types. These are used in the autogenerated code.
 * Least-significant 4 bits tell the scalar type
 * Most-significant 4 bits specify repeated/required/packed etc.
 *
 * INT32 and UINT32 are treated the same, as are (U)INT64 and (S)FIXED*
 * These types are simply casted to correct field type when they are
 * assigned to the memory pointer.
 * SINT* is different, though, because it is zig-zag coded.
 */
 typedef enum {
    /************************
     * Field contents types *
     ************************/
    /* Numeric types */
    PB_LTYPE_VARINT = 0x00, /* int32, uint32, int64, uint64, bool, enum */
    PB_LTYPE_SVARINT = 0x01, /* sint32, sint64 */
    PB_LTYPE_FIXED32 = 0x02, /* fixed32, sfixed32, float */
    PB_LTYPE_FIXED64 = 0x03, /* fixed64, sfixed64, double */
    /* Marker for last packable field type. */
    PB_LTYPE_LAST_PACKABLE = 0x03,
    /* Byte array with pre-allocated buffer.
     * data_size is the length of the allocated PB_BYTES_ARRAY structure. */
    PB_LTYPE_BYTES = 0x04,
    /* String with pre-allocated buffer.
     * data_size is the maximum length. */
    PB_LTYPE_STRING = 0x05,
    /* Submessage
     * submsg_fields is pointer to field descriptions */
    PB_LTYPE_SUBMESSAGE = 0x06,
    /* Number of declared LTYPES */
    PB_LTYPES_COUNT = 7,
    /******************
     * Modifier flags *
     ******************/
    /* Just the basic, write data at data_offset */
    PB_HTYPE_REQUIRED = 0x00,
    /* Write true at size_offset */
    PB_HTYPE_OPTIONAL = 0x10,
    /* Read to pre-allocated array
     * Maximum number of entries is array_size,
     * actual number is stored at size_offset */
    PB_HTYPE_ARRAY = 0x20,
    /* Works for all required/optional/repeated fields.
     * data_offset points to pb_callback_t structure.
     * LTYPE should be 0 (it is ignored, but sometimes
     * used to speculatively index an array). */
    PB_HTYPE_CALLBACK = 0x30
 } pb_packed pb_type_t;
 #define PB_HTYPE(x) ((x) & 0xF0)
 #define PB_LTYPE(x) ((x) & 0x0F)
 /* 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.
 */
 typedef struct {
    size_t size;
    uint8_t bytes[1];
 } pb_bytes_array_t;
 /* The next three pb_field_ structures are used in auto-generated constants
 * to specify struct fields.
 */
 typedef struct _pb_field_key_t pb_field_key_t;
 typedef struct _pb_field_t pb_field_t;
 typedef struct _pb_field_info_t pb_field_info_t;
 /* pb_field_key_t is a structure for storing the tag and an index into an array
 * that stores the actual field info. This approach is used to reduce code size
 * as many numeric fields have the same field info.
 *
 * A uint8_t tag will limit the field tag to 128 as the MSB bit is used to indicate
 * whether or not it's the last field in the message. You may change it to uint16_t
 * if you want to specify larger field tag. Please also change the corresponding
 * tag in pb_field_t
 */
 typedef uint8_t tag_t;
 struct _pb_field_key_t {
    tag_t tag;     /* The MSB bit of the tag is used to indicate it's the last field in the message */
    /* The MSB bit of the info_index is used to indicate the field info is retrieved
     * from the global pb_common_aligned_field_info array instead of the auto-generated field
     * info.
     */
    uint8_t info_index;
 } pb_packed;
 /* pb_field_t is a structure for storing the pb field descriptor information
 * You can change field sizes here if you need structures
 * larger than 256 bytes
 */
 struct _pb_field_t {
    tag_t tag;
    pb_type_t type;
    uint8_t data_offset; /* Offset of field data, relative to previous field. */
    int8_t size_offset; /* Offset of array size or has-boolean, relative to data */
    uint8_t data_size; /* Data size in bytes for a single item */
    uint8_t array_size; /* Maximum number of entries in array */
    /* Field definitions for submessage
     * OR default value for all other non-array, non-callback types
     * If null, then field will zeroed. */
    const void *ptr;
 } pb_packed;
 /* pb_field_info_t is the structure for holding together the key and the field info arrays.
 * This is the structure that will be passed to pb_encode and pb_decode
 */
 struct _pb_field_info_t {
    const pb_field_key_t *field_keys;
    const pb_field_t *field_info;
 };
 /* Iterator for pb_field_t list */
 typedef struct {
    const pb_field_key_t *start_key;
    const pb_field_key_t *current_key;
    pb_field_t current;
    const pb_field_t *field_info;
    int field_index;
    void *dest_struct;
    void *pData;
    void *pSize;
 } pb_field_iterator_t;
 /* Functions for iterating through the field */
 void pb_field_init(pb_field_iterator_t *iter, const pb_field_info_t *fields, void *dest_struct);
 bool pb_field_next(pb_field_iterator_t *iter);
 bool pb_field_find(pb_field_iterator_t *iter, int tag);
 /* These macros are used to declare pb_field_t's in the constant array. */
 #define pb_membersize(st, m) (sizeof ((st*)0)->m)
 #define pb_arraysize(st, m) (pb_membersize(st, m) / pb_membersize(st, m[0]))
 #define pb_delta(st, m1, m2) ((int)offsetof(st, m1) - (int)offsetof(st, m2))
 #define pb_delta_end(st, m1, m2) (offsetof(st, m1) - offsetof(st, m2) - pb_membersize(st, m2))
 /* The MSB bit of the pb_field_key_t.tag indicates whether or not it's the last element */
 #define PB_LAST_FIELD (0x1 << (pb_membersize(pb_field_key_t, tag) * 8 - 1))
 #define PB_IS_LAST(key) ((key)->tag & PB_LAST_FIELD)
 #define PB_TAG_VAL(key) ((key)->tag & ~PB_LAST_FIELD)
 /* The MSB bit of the pb_field_key_tag.info_index indicates whether it's a common or generated field info */
 #define PB_COMMON_INFO_FLAG (0x1 << (pb_membersize(pb_field_key_t, info_index) * 8 -1))
 /* A common field info is retrieved from the globally declared pb_common_aligned_field_info array or
 * locally auto-generated field info array */
 #define PB_FIELD_INFO(key, info) (((key)->info_index & PB_COMMON_INFO_FLAG) ? \
    &pb_common_aligned_field_info[(key)->info_index ^ PB_COMMON_INFO_FLAG] : \
    &((info)[(key)->info_index]))
 /* Defines the indices for pb_common_aligned_field_info array
 * Note that MSB bit PB_COMMON_INFO_FLAG is set to indicate the index
 * should be used on pb_common_aligned_field_info instead of generated
 * array
 * */
 enum {
    REQUIRED_BOOL_INFO = 0 | PB_COMMON_INFO_FLAG,
    OPTIONAL_BOOL_INFO = 1 | PB_COMMON_INFO_FLAG,
    REQUIRED_INT32_INFO = 2 | PB_COMMON_INFO_FLAG,
    OPTIONAL_INT32_INFO = 3 | PB_COMMON_INFO_FLAG,
    REQUIRED_INT64_INFO = 4 | PB_COMMON_INFO_FLAG,
    OPTIONAL_INT64_INFO = 5 | PB_COMMON_INFO_FLAG,
    REQUIRED_SINT32_INFO = 6 | PB_COMMON_INFO_FLAG,
    OPTIONAL_SINT32_INFO = 7 | PB_COMMON_INFO_FLAG,
    REQUIRED_SINT64_INFO = 8 | PB_COMMON_INFO_FLAG,
    OPTIONAL_SINT64_INFO = 9 | PB_COMMON_INFO_FLAG,
    REQUIRED_FIXED32_INFO = 10 | PB_COMMON_INFO_FLAG,
    OPTIONAL_FIXED32_INFO = 11 | PB_COMMON_INFO_FLAG,
    REQUIRED_FIXED64_INFO = 12 | PB_COMMON_INFO_FLAG,
    OPTIONAL_FIXED64_INFO = 13 | PB_COMMON_INFO_FLAG,
    /* leave this enum to determine num of elements */
    MAX_COMMON_FIELD_INFO
 };
 #define NUM_COMMON_FIELD_INFO (MAX_COMMON_FIELD_INFO ^ PB_COMMON_INFO_FLAG)
 /* pb_common_aligned_field_info array holds the common field info that can be shared
 * by any numeric fields whose previous field is memory aligned
 */
 extern const pb_field_t pb_common_aligned_field_info[NUM_COMMON_FIELD_INFO];
 #endif /* _PB_FIELD_H_ */
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,6 +1,84 @@
-all:
+CFLAGS=-ansi -Wall -Werror -I .. -g -O0 --coverage
-	scons
+LDFLAGS=--coverage
 DEPS=../pb_decode.h ../pb_encode.h ../pb.h ../pb_field.h person.pb.h callbacks.pb.h unittests.h unittestproto.pb.h alltypes.pb.h aligntype.pb.h
 TESTS=test_decode1 test_encode1 test_encode2 test_decode2 test_encode3 test_decode3 test_encode4 test_decode4 decode_unittests encode_unittests test_encode_callbacks test_decode_callbacks
 CC_VER := $(shell gcc --version | grep gcc)
 ifneq "$(CC_VER)" ""
 CFLAGS += -m32
 LDFLAGS += -m32
 endif
 ifndef PB_PATH
 PBPATHOPT=-I/usr/include -I/usr/local/include
 else
 PBPATHOPT=-I$(PB_PATH)
 endif
 all: breakpoints $(TESTS) run_unittests
 clean:
-	scons -c
+	rm -f breakpoints $(TESTS) *.pb *.pb.c *.pb.h *.o *.gcda *.gcno
 %.o: %.c
 %.o: %.c $(DEPS)
 	$(CC) $(CFLAGS) -c -o $@ $<
 pb_encode.o: ../pb_encode.c $(DEPS)
 	$(CC) $(CFLAGS) -c -o $@ $<
 pb_decode.o: ../pb_decode.c $(DEPS)
 	$(CC) $(CFLAGS) -c -o $@ $<
 pb_field.o: ../pb_field.c $(DEPS)
 	$(CC) $(CFLAGS) -c -o $@ $<
 test_decode1: test_decode1.o pb_decode.o pb_field.o person.pb.o
 test_decode2: test_decode2.o pb_decode.o pb_field.o person.pb.o
 test_decode3: test_decode3.o pb_decode.o pb_field.o alltypes.pb.o
 test_decode4: test_decode4.o pb_decode.o pb_field.o aligntype.pb.o
 test_encode1: test_encode1.o pb_encode.o pb_field.o person.pb.o
 test_encode2: test_encode2.o pb_encode.o pb_field.o person.pb.o
 test_encode3: test_encode3.o pb_encode.o pb_field.o alltypes.pb.o
 test_encode4: test_encode4.o pb_encode.o pb_field.o aligntype.pb.o
 test_decode_callbacks: test_decode_callbacks.o pb_decode.o pb_field.o callbacks.pb.o
 test_encode_callbacks: test_encode_callbacks.o pb_encode.o pb_field.o callbacks.pb.o
 decode_unittests: decode_unittests.o pb_decode.o pb_field.o unittestproto.pb.o
 encode_unittests: encode_unittests.o pb_encode.o pb_field.o unittestproto.pb.o
 %.pb: %.proto
 	protoc -I. -I../generator $(PBPATHOPT) -o$@ $<
 %.pb.c %.pb.h: %.pb ../generator/nanopb_generator.py
 	python ../generator/nanopb_generator.py $<
 breakpoints: ../*.c *.c
 	grep -n 'return false;' $^ | cut -d: -f-2 | xargs -n 1 echo b > $@
 coverage: run_unittests
 	gcov pb_encode.gcda
 	gcov pb_decode.gcda
 run_unittests: $(TESTS)
 	rm -f *.gcda
 	./decode_unittests > /dev/null
 	./encode_unittests > /dev/null
 	[ "`./test_encode1 | ./test_decode1`" = \
 	"`./test_encode1 | protoc --decode=Person -I. -I../generator $(PBPATHOPT) person.proto`" ]
 	[ "`./test_encode2 | ./test_decode1`" = \
 	"`./test_encode2 | protoc --decode=Person -I. -I../generator $(PBPATHOPT) person.proto`" ]
 	[ "`./test_encode2 | ./test_decode2`" = \
 	"`./test_encode2 | protoc --decode=Person -I. -I../generator $(PBPATHOPT) person.proto`" ]
 	[ "`./test_encode_callbacks | ./test_decode_callbacks`" = \
 	"`./test_encode_callbacks | protoc --decode=TestMessage callbacks.proto`" ]
 	./test_encode3 | ./test_decode3
 	./test_encode3 | protoc --decode=AllTypes -I. -I../generator $(PBPATHOPT) alltypes.proto >/dev/null
 	./test_encode4 | ./test_decode4
 	./test_encode4 | protoc --decode=AlignTypes -I. -I../generator $(PBPATHOPT) aligntype.proto >/dev/null
 run_fuzztest: test_decode2
 	bash -c 'I=1; while true; do cat /dev/urandom | ./test_decode2 > /dev/null; I=$$(($$I+1)); echo -en "\r$$I"; done'
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -1,112 +0,0 @@
 Help('''
 Type 'scons' to build and run all the available test cases.
 It will automatically detect your platform and C compiler and
 build appropriately.
 You can modify the behavious using following options:
 CC          Name of C compiler
 CXX         Name of C++ compiler
 CCFLAGS     Flags to pass to the C compiler
 CXXFLAGS    Flags to pass to the C++ compiler
 For example, for a clang build, use:
 scons CC=clang CXX=clang++
 ''')
 import os
 env = Environment(ENV = os.environ)
 # Allow overriding the compiler with scons CC=???
 if 'CC' in ARGUMENTS: env.Replace(CC = ARGUMENTS['CC'])
 if 'CXX' in ARGUMENTS: env.Replace(CXX = ARGUMENTS['CXX'])
 if 'CFLAGS' in ARGUMENTS: env.Append(CCFLAGS = ARGUMENTS['CFLAGS'])
 if 'CXXFLAGS' in ARGUMENTS: env.Append(CCFLAGS = ARGUMENTS['CXXFLAGS'])
 # Add the builders defined in site_init.py
 add_nanopb_builders(env)
 # Path to the files shared by tests, and to the nanopb core.
 env.Append(CPPPATH = ["#../", "#common"])
 # Path for finding nanopb.proto
 env.Append(PROTOCPATH = '#../generator')
 # Check the compilation environment, unless we are just cleaning up.
 if not env.GetOption('clean'):
    conf = Configure(env)
    # If the platform doesn't support C99, use our own header file instead.
    stdbool = conf.CheckCHeader('stdbool.h')
    stdint = conf.CheckCHeader('stdint.h')
    stddef = conf.CheckCHeader('stddef.h')
    string = conf.CheckCHeader('string.h')
    if not stdbool or not stdint or not stddef or not string:
        conf.env.Append(CPPDEFINES = {'PB_SYSTEM_HEADER': '\\"pb_syshdr.h\\"'})
        conf.env.Append(CPPPATH = "#../compat")
        if stdbool: conf.env.Append(CPPDEFINES = {'HAVE_STDBOOL_H': 1})
        if stdint: conf.env.Append(CPPDEFINES = {'HAVE_STDINT_H': 1})
        if stddef: conf.env.Append(CPPDEFINES = {'HAVE_STDDEF_H': 1})
        if string: conf.env.Append(CPPDEFINES = {'HAVE_STRING_H': 1})
    # Check if we can use pkg-config to find protobuf include path
    status, output = conf.TryAction('pkg-config protobuf --variable=includedir > $TARGET')
    if status:
        conf.env.Append(PROTOCPATH = output.strip())
    else:
        conf.env.Append(PROTOCPATH = '/usr/include')
    # Check if libmudflap is available (only with GCC)
    if 'gcc' in env['CC']:
        if conf.CheckLib('mudflap'):
            conf.env.Append(CCFLAGS = '-fmudflap')
            conf.env.Append(LINKFLAGS = '-lmudflap -fmudflap')
    # End the config stuff
    env = conf.Finish()
 # Initialize the CCFLAGS according to the compiler
 if 'gcc' in env['CC']:
    # GNU Compiler Collection
    # Debug info, warnings as errors
    env.Append(CFLAGS = '-ansi -pedantic -g -O0 -Wall -Werror --coverage -fstack-protector-all')
    env.Append(LINKFLAGS = '--coverage')
    # We currently need uint64_t anyway, even though ANSI C90 otherwise..
    env.Append(CFLAGS = '-Wno-long-long')
    # More strict checks on the nanopb core
    env.Append(CORECFLAGS = '-Wextra -Wcast-qual -Wlogical-op -Wconversion')
 elif 'clang' in env['CC']:
    # CLang
    env.Append(CFLAGS = '-ansi -g -O0 -Wall -Werror')
    env.Append(CORECFLAGS = ' -Wextra -Wcast-qual -Wconversion')
 elif 'cl' in env['CC']:
    # Microsoft Visual C++
    # Debug info on, warning level 2 for tests, warnings as errors
    env.Append(CFLAGS = '/Zi /W2 /WX')
    env.Append(LINKFLAGS = '/DEBUG')
    # More strict checks on the nanopb core
    env.Append(CORECFLAGS = '/W4')
    # PB_RETURN_ERROR triggers C4127 because of while(0)
    env.Append(CFLAGS = '/wd4127')
 elif 'tcc' in env['CC']:
    # Tiny C Compiler
    env.Append(CFLAGS = '-Wall -Werror -g')
 env.SetDefault(CORECFLAGS = '')
 if 'clang++' in env['CXX']:
    env.Append(CXXFLAGS = '-g -O0 -Wall -Werror -Wextra -Wno-missing-field-initializers')
 elif 'g++' in env['CXX']:
    env.Append(CXXFLAGS = '-g -O0 -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
 SConscript(Glob('*/SConscript'), exports = 'env')
--- a/tests/aligntype.proto
+++ b/tests/aligntype.proto
@@ -0,0 +1,80 @@
 import "nanopb.proto";
 message SubMessage {
    required string substuff1 = 1 [(nanopb).max_size = 16];
    required int32 substuff2 = 2;
 }
 enum MyEnum {
    First = 1;
    Second = 2;
    Truth = 42;
 }
 message AlignTypes {
    required bool       req_bool    = 1;
    required int32      req_int32   = 2;
    required SubMessage req_submsg  = 3;
    required int64      req_int64   = 4;
    required string     req_string  = 5 [(nanopb).max_size = 16];
    required MyEnum     req_enum    = 6;
    required bytes      req_bytes   = 7 [(nanopb).max_size = 16];
    required sint32     req_sint32  = 8;
    required bool       req_bool_2  = 9;
    required sint64     req_sint64  = 10;
    required bool       req_bool_3  = 11;
    required fixed32    req_fixed32 = 12;
    required bool       req_bool_4  = 13;
    required fixed64    req_fixed64 = 14;
    required bool       req_bool_5  = 15;
    required float      req_float   = 16;
    required bool       req_bool_6  = 17;
    required double     req_double  = 18;
    optional bool       opt_bool    = 19;
    optional int32      opt_int32   = 20;
    optional SubMessage opt_submsg  = 21;
    optional int64      opt_int64   = 22;
    optional string     opt_string  = 23 [(nanopb).max_size = 16];
    optional MyEnum     opt_enum    = 24;
    optional bytes      opt_bytes   = 25 [(nanopb).max_size = 16];
    optional sint32     opt_sint32  = 26;
    optional bool       opt_bool_2  = 27;
    optional sint64     opt_sint64  = 28;
    optional bool       opt_bool_3  = 29;
    optional fixed32    opt_fixed32 = 30;
    optional bool       opt_bool_4  = 31;
    optional fixed64    opt_fixed64 = 32;
    optional bool       opt_bool_5  = 33;
    optional float      opt_float   = 34;
    optional bool       opt_bool_6  = 35;
    optional double     opt_double  = 36;
    required bool       req_bool_aligned    = 37; 
    required int32      req_int32_aligned   = 38;
    required int64      req_int64_aligned   = 39;
    required MyEnum     req_enum_aligned    = 40;
    required sint32     req_sint32_aligned  = 41;
    required sint64     req_sint64_aligned  = 42;
    required fixed32    req_fixed32_aligned = 43;
    required fixed64    req_fixed64_aligned = 44;
    required float      req_float_aligned   = 45;
    required double     req_double_aligned  = 46;
    optional bool       opt_bool_aligned    = 47;
    optional int32      opt_int32_aligned   = 48;
    optional int64      opt_int64_aligned   = 49;
    optional MyEnum     opt_enum_aligned    = 50;
    optional sint32     opt_sint32_aligned  = 51;
    optional sint64     opt_sint64_aligned  = 52;
    optional fixed32    opt_fixed32_aligned = 53;
    optional fixed64    opt_fixed64_aligned = 54;
    optional float      opt_float_aligned   = 55;
    optional double     opt_double_aligned  = 56;
    // 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;
 }
--- a/tests/alltypes.proto
+++ b/tests/alltypes.proto
@@ -0,0 +1,40 @@
 import "nanopb.proto";
 message SubMessage {
    required string substuff1 = 1 [(nanopb).max_size = 16];
    required int32 substuff2 = 2;
 }
 enum MyEnum {
    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 [(nanopb).max_size = 16];
    required bytes      req_bytes   = 15 [(nanopb).max_size = 16];
    required SubMessage req_submsg  = 16;
    required MyEnum     req_enum    = 17;
    // 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;
 }
--- a/tests/alltypes/SConscript
+++ b/tests/alltypes/SConscript
@@ -1,12 +0,0 @@
 # Build and run a test that encodes and decodes a message that contains
 # all of the Protocol Buffers data types.
 Import("env")
 env.NanopbProto("alltypes")
 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"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/alltypes/alltypes.options
+++ b/tests/alltypes/alltypes.options
@@ -1,3 +0,0 @@
 * max_size:16
 * max_count:5
--- a/tests/alltypes/alltypes.proto
+++ b/tests/alltypes/alltypes.proto
@@ -1,93 +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 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;
    required EmptyMessage req_emptymsg = 18;
    repeated int32      rep_int32   = 21;
    repeated int64      rep_int64   = 22;
    repeated uint32     rep_uint32  = 23;
    repeated uint64     rep_uint64  = 24;
    repeated sint32     rep_sint32  = 25;
    repeated sint64     rep_sint64  = 26;
    repeated bool       rep_bool    = 27;
    repeated fixed32    rep_fixed32 = 28;
    repeated sfixed32   rep_sfixed32= 29;
    repeated float      rep_float   = 30;
    repeated fixed64    rep_fixed64 = 31;
    repeated sfixed64   rep_sfixed64= 32;
    repeated double     rep_double  = 33;
    repeated string     rep_string  = 34;
    repeated bytes      rep_bytes   = 35;
    repeated SubMessage rep_submsg  = 36;
    repeated MyEnum     rep_enum    = 37;
    repeated EmptyMessage rep_emptymsg = 38;
    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];
    optional EmptyMessage opt_emptymsg = 58;
    // 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;
 }
--- a/tests/alltypes/decode_alltypes.c
+++ b/tests/alltypes/decode_alltypes.c
@@ -1,202 +0,0 @@
 /* Tests the decoding of all types.
 * This is the counterpart of test_encode3.
 * Run e.g. ./test_encode3 | ./test_decode3
 */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <pb_decode.h>
 #include "alltypes.pb.h"
 #include "test_helpers.h"
 #define TEST(x) if (!(x)) { \
    printf("Test " #x " failed.\n"); \
    return false; \
    }
 /* This function is called once from main(), it handles
   the decoding and checks the fields. */
 bool check_alltypes(pb_istream_t *stream, int mode)
 {
    AllTypes alltypes;
    /* Fill with garbage to better detect initialization errors */
    memset(&alltypes, 0xAA, sizeof(alltypes));
    if (!pb_decode(stream, AllTypes_fields, &alltypes))
        return false;
    TEST(alltypes.req_int32         == -1001);
    TEST(alltypes.req_int64         == -1002);
    TEST(alltypes.req_uint32        == 1003);
    TEST(alltypes.req_uint64        == 1004);
    TEST(alltypes.req_sint32        == -1005);
    TEST(alltypes.req_sint64        == -1006);
    TEST(alltypes.req_bool          == true);
    TEST(alltypes.req_fixed32       == 1008);
    TEST(alltypes.req_sfixed32      == -1009);
    TEST(alltypes.req_float         == 1010.0f);
    TEST(alltypes.req_fixed64       == 1011);
    TEST(alltypes.req_sfixed64      == -1012);
    TEST(alltypes.req_double        == 1013.0f);
    TEST(strcmp(alltypes.req_string, "1014") == 0);
    TEST(alltypes.req_bytes.size == 4);
    TEST(memcmp(alltypes.req_bytes.bytes, "1015", 4) == 0);
    TEST(strcmp(alltypes.req_submsg.substuff1, "1016") == 0);
    TEST(alltypes.req_submsg.substuff2 == 1016);
    TEST(alltypes.req_submsg.substuff3 == 3);
    TEST(alltypes.req_enum == MyEnum_Truth);
    TEST(alltypes.rep_int32_count == 5 && alltypes.rep_int32[4] == -2001 && alltypes.rep_int32[0] == 0);
    TEST(alltypes.rep_int64_count == 5 && alltypes.rep_int64[4] == -2002 && alltypes.rep_int64[0] == 0);
    TEST(alltypes.rep_uint32_count == 5 && alltypes.rep_uint32[4] == 2003 && alltypes.rep_uint32[0] == 0);
    TEST(alltypes.rep_uint64_count == 5 && alltypes.rep_uint64[4] == 2004 && alltypes.rep_uint64[0] == 0);
    TEST(alltypes.rep_sint32_count == 5 && alltypes.rep_sint32[4] == -2005 && alltypes.rep_sint32[0] == 0);
    TEST(alltypes.rep_sint64_count == 5 && alltypes.rep_sint64[4] == -2006 && alltypes.rep_sint64[0] == 0);
    TEST(alltypes.rep_bool_count == 5 && alltypes.rep_bool[4] == true && alltypes.rep_bool[0] == false);
    TEST(alltypes.rep_fixed32_count == 5 && alltypes.rep_fixed32[4] == 2008 && alltypes.rep_fixed32[0] == 0);
    TEST(alltypes.rep_sfixed32_count == 5 && alltypes.rep_sfixed32[4] == -2009 && alltypes.rep_sfixed32[0] == 0);
    TEST(alltypes.rep_float_count == 5 && alltypes.rep_float[4] == 2010.0f && alltypes.rep_float[0] == 0.0f);
    TEST(alltypes.rep_fixed64_count == 5 && alltypes.rep_fixed64[4] == 2011 && alltypes.rep_fixed64[0] == 0);
    TEST(alltypes.rep_sfixed64_count == 5 && alltypes.rep_sfixed64[4] == -2012 && alltypes.rep_sfixed64[0] == 0);
    TEST(alltypes.rep_double_count == 5 && alltypes.rep_double[4] == 2013.0 && alltypes.rep_double[0] == 0.0);
    TEST(alltypes.rep_string_count == 5 && strcmp(alltypes.rep_string[4], "2014") == 0 && alltypes.rep_string[0][0] == '\0');
    TEST(alltypes.rep_bytes_count == 5 && alltypes.rep_bytes[4].size == 4 && alltypes.rep_bytes[0].size == 0);
    TEST(memcmp(alltypes.rep_bytes[4].bytes, "2015", 4) == 0);
    TEST(alltypes.rep_submsg_count == 5);
    TEST(strcmp(alltypes.rep_submsg[4].substuff1, "2016") == 0 && alltypes.rep_submsg[0].substuff1[0] == '\0');
    TEST(alltypes.rep_submsg[4].substuff2 == 2016 && alltypes.rep_submsg[0].substuff2 == 0);
    TEST(alltypes.rep_submsg[4].substuff3 == 2016 && alltypes.rep_submsg[0].substuff3 == 3);
    TEST(alltypes.rep_enum_count == 5 && alltypes.rep_enum[4] == MyEnum_Truth && alltypes.rep_enum[0] == MyEnum_Zero);
    TEST(alltypes.rep_emptymsg_count == 5);
    if (mode == 0)
    {
        /* Expect default values */
        TEST(alltypes.has_opt_int32     == false);
        TEST(alltypes.opt_int32         == 4041);
        TEST(alltypes.has_opt_int64     == false);
        TEST(alltypes.opt_int64         == 4042);
        TEST(alltypes.has_opt_uint32    == false);
        TEST(alltypes.opt_uint32        == 4043);
        TEST(alltypes.has_opt_uint64    == false);
        TEST(alltypes.opt_uint64        == 4044);
        TEST(alltypes.has_opt_sint32    == false);
        TEST(alltypes.opt_sint32        == 4045);
        TEST(alltypes.has_opt_sint64    == false);
        TEST(alltypes.opt_sint64        == 4046);
        TEST(alltypes.has_opt_bool      == false);
        TEST(alltypes.opt_bool          == false);
        TEST(alltypes.has_opt_fixed32   == false);
        TEST(alltypes.opt_fixed32       == 4048);
        TEST(alltypes.has_opt_sfixed32  == false);
        TEST(alltypes.opt_sfixed32      == 4049);
        TEST(alltypes.has_opt_float     == false);
        TEST(alltypes.opt_float         == 4050.0f);
        TEST(alltypes.has_opt_fixed64   == false);
        TEST(alltypes.opt_fixed64       == 4051);
        TEST(alltypes.has_opt_sfixed64  == false);
        TEST(alltypes.opt_sfixed64      == 4052);
        TEST(alltypes.has_opt_double    == false);
        TEST(alltypes.opt_double        == 4053.0);
        TEST(alltypes.has_opt_string    == false);
        TEST(strcmp(alltypes.opt_string, "4054") == 0);
        TEST(alltypes.has_opt_bytes     == false);
        TEST(alltypes.opt_bytes.size == 4);
        TEST(memcmp(alltypes.opt_bytes.bytes, "4055", 4) == 0);
        TEST(alltypes.has_opt_submsg    == false);
        TEST(strcmp(alltypes.opt_submsg.substuff1, "1") == 0);
        TEST(alltypes.opt_submsg.substuff2 == 2);
        TEST(alltypes.opt_submsg.substuff3 == 3);
        TEST(alltypes.has_opt_enum     == false);
        TEST(alltypes.opt_enum == MyEnum_Second);
        TEST(alltypes.has_opt_emptymsg == false);
    }
    else
    {
        /* Expect filled-in values */
        TEST(alltypes.has_opt_int32     == true);
        TEST(alltypes.opt_int32         == 3041);
        TEST(alltypes.has_opt_int64     == true);
        TEST(alltypes.opt_int64         == 3042);
        TEST(alltypes.has_opt_uint32    == true);
        TEST(alltypes.opt_uint32        == 3043);
        TEST(alltypes.has_opt_uint64    == true);
        TEST(alltypes.opt_uint64        == 3044);
        TEST(alltypes.has_opt_sint32    == true);
        TEST(alltypes.opt_sint32        == 3045);
        TEST(alltypes.has_opt_sint64    == true);
        TEST(alltypes.opt_sint64        == 3046);
        TEST(alltypes.has_opt_bool      == true);
        TEST(alltypes.opt_bool          == true);
        TEST(alltypes.has_opt_fixed32   == true);
        TEST(alltypes.opt_fixed32       == 3048);
        TEST(alltypes.has_opt_sfixed32  == true);
        TEST(alltypes.opt_sfixed32      == 3049);
        TEST(alltypes.has_opt_float     == true);
        TEST(alltypes.opt_float         == 3050.0f);
        TEST(alltypes.has_opt_fixed64   == true);
        TEST(alltypes.opt_fixed64       == 3051);
        TEST(alltypes.has_opt_sfixed64  == true);
        TEST(alltypes.opt_sfixed64      == 3052);
        TEST(alltypes.has_opt_double    == true);
        TEST(alltypes.opt_double        == 3053.0);
        TEST(alltypes.has_opt_string    == true);
        TEST(strcmp(alltypes.opt_string, "3054") == 0);
        TEST(alltypes.has_opt_bytes     == true);
        TEST(alltypes.opt_bytes.size == 4);
        TEST(memcmp(alltypes.opt_bytes.bytes, "3055", 4) == 0);
        TEST(alltypes.has_opt_submsg    == true);
        TEST(strcmp(alltypes.opt_submsg.substuff1, "3056") == 0);
        TEST(alltypes.opt_submsg.substuff2 == 3056);
        TEST(alltypes.opt_submsg.substuff3 == 3);
        TEST(alltypes.has_opt_enum      == true);
        TEST(alltypes.opt_enum == MyEnum_Truth);
        TEST(alltypes.has_opt_emptymsg  == true);
    }
    TEST(alltypes.end == 1099);
    return true;
 }
 int main(int argc, char **argv)
 {
    uint8_t buffer[1024];
    size_t count;
    pb_istream_t stream;
    /* Whether to expect the optional values or the default values. */
    int mode = (argc > 1) ? atoi(argv[1]) : 0;
    /* Read the data into buffer */
    SET_BINARY_MODE(stdin);
    count = fread(buffer, 1, sizeof(buffer), stdin);
    /* Construct a pb_istream_t for reading from the buffer */
    stream = pb_istream_from_buffer(buffer, count);
    /* Decode and print out the stuff */
    if (!check_alltypes(&stream, mode))
    {
        printf("Parsing failed: %s\n", PB_GET_ERROR(&stream));
        return 1;
    } else {
        return 0;
    }
 }
--- a/tests/alltypes/encode_alltypes.c
+++ b/tests/alltypes/encode_alltypes.c
@@ -1,134 +0,0 @@
 /* Attempts to test all the datatypes supported by ProtoBuf.
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pb_encode.h>
 #include "alltypes.pb.h"
 #include "test_helpers.h"
 int main(int argc, char **argv)
 {
    int mode = (argc > 1) ? atoi(argv[1]) : 0;
    /* Initialize the structure with constants */
    AllTypes alltypes = {0};
    alltypes.req_int32         = -1001;
    alltypes.req_int64         = -1002;
    alltypes.req_uint32        = 1003;
    alltypes.req_uint64        = 1004;
    alltypes.req_sint32        = -1005;
    alltypes.req_sint64        = -1006;
    alltypes.req_bool          = true;
    alltypes.req_fixed32       = 1008;
    alltypes.req_sfixed32      = -1009;
    alltypes.req_float         = 1010.0f;
    alltypes.req_fixed64       = 1011;
    alltypes.req_sfixed64      = -1012;
    alltypes.req_double        = 1013.0;
    strcpy(alltypes.req_string, "1014");
    alltypes.req_bytes.size = 4;
    memcpy(alltypes.req_bytes.bytes, "1015", 4);
    strcpy(alltypes.req_submsg.substuff1, "1016");
    alltypes.req_submsg.substuff2 = 1016;
    alltypes.req_enum = MyEnum_Truth;
    alltypes.rep_int32_count = 5; alltypes.rep_int32[4] = -2001;
    alltypes.rep_int64_count = 5; alltypes.rep_int64[4] = -2002;
    alltypes.rep_uint32_count = 5; alltypes.rep_uint32[4] = 2003;
    alltypes.rep_uint64_count = 5; alltypes.rep_uint64[4] = 2004;
    alltypes.rep_sint32_count = 5; alltypes.rep_sint32[4] = -2005;
    alltypes.rep_sint64_count = 5; alltypes.rep_sint64[4] = -2006;
    alltypes.rep_bool_count = 5; alltypes.rep_bool[4] = true;
    alltypes.rep_fixed32_count = 5; alltypes.rep_fixed32[4] = 2008;
    alltypes.rep_sfixed32_count = 5; alltypes.rep_sfixed32[4] = -2009;
    alltypes.rep_float_count = 5; alltypes.rep_float[4] = 2010.0f;
    alltypes.rep_fixed64_count = 5; alltypes.rep_fixed64[4] = 2011;
    alltypes.rep_sfixed64_count = 5; alltypes.rep_sfixed64[4] = -2012;
    alltypes.rep_double_count = 5; alltypes.rep_double[4] = 2013.0;
    alltypes.rep_string_count = 5; strcpy(alltypes.rep_string[4], "2014");
    alltypes.rep_bytes_count = 5; alltypes.rep_bytes[4].size = 4;
    memcpy(alltypes.rep_bytes[4].bytes, "2015", 4);
    alltypes.rep_submsg_count = 5;
    strcpy(alltypes.rep_submsg[4].substuff1, "2016");
    alltypes.rep_submsg[4].substuff2 = 2016;
    alltypes.rep_submsg[4].has_substuff3 = true;
    alltypes.rep_submsg[4].substuff3 = 2016;
    alltypes.rep_enum_count = 5; alltypes.rep_enum[4] = MyEnum_Truth;
    alltypes.rep_emptymsg_count = 5;
    if (mode != 0)
    {
        /* Fill in values for optional fields */
        alltypes.has_opt_int32 = true;
        alltypes.opt_int32         = 3041;
        alltypes.has_opt_int64 = true;
        alltypes.opt_int64         = 3042;
        alltypes.has_opt_uint32 = true;
        alltypes.opt_uint32        = 3043;
        alltypes.has_opt_uint64 = true;
        alltypes.opt_uint64        = 3044;
        alltypes.has_opt_sint32 = true;
        alltypes.opt_sint32        = 3045;
        alltypes.has_opt_sint64 = true;
        alltypes.opt_sint64        = 3046;
        alltypes.has_opt_bool = true;
        alltypes.opt_bool          = true;
        alltypes.has_opt_fixed32 = true;
        alltypes.opt_fixed32       = 3048;
        alltypes.has_opt_sfixed32 = true;
        alltypes.opt_sfixed32      = 3049;
        alltypes.has_opt_float = true;
        alltypes.opt_float         = 3050.0f;
        alltypes.has_opt_fixed64 = true;
        alltypes.opt_fixed64       = 3051;
        alltypes.has_opt_sfixed64 = true;
        alltypes.opt_sfixed64      = 3052;
        alltypes.has_opt_double = true;
        alltypes.opt_double        = 3053.0;
        alltypes.has_opt_string = true;
        strcpy(alltypes.opt_string, "3054");
        alltypes.has_opt_bytes = true;
        alltypes.opt_bytes.size = 4;
        memcpy(alltypes.opt_bytes.bytes, "3055", 4);
        alltypes.has_opt_submsg = true;
        strcpy(alltypes.opt_submsg.substuff1, "3056");
        alltypes.opt_submsg.substuff2 = 3056;
        alltypes.has_opt_enum = true;
        alltypes.opt_enum = MyEnum_Truth;
        alltypes.has_opt_emptymsg = true;
    }
    alltypes.end = 1099;
    {
        uint8_t buffer[1024];
        pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
        /* Now encode it and check if we succeeded. */
        if (pb_encode(&stream, AllTypes_fields, &alltypes))
        {
            SET_BINARY_MODE(stdout);
            fwrite(buffer, 1, stream.bytes_written, stdout);
            return 0; /* Success */
        }
        else
        {
            fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&stream));
            return 1; /* Failure */
        }
    }
 }
--- a/tests/backwards_compatibility/SConscript
+++ b/tests/backwards_compatibility/SConscript
@@ -1,11 +0,0 @@
 # Check that the old generated .pb.c/.pb.h files are still compatible with the
 # current version of nanopb.
 Import("env")
 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"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_legacy.output"])
--- a/tests/backwards_compatibility/alltypes_legacy.c
+++ b/tests/backwards_compatibility/alltypes_legacy.c
@@ -1,93 +0,0 @@
 /* Automatically generated nanopb constant definitions */
 /* 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"
 const char SubMessage_substuff1_default[16] = "1";
 const int32_t SubMessage_substuff2_default = 2;
 const uint32_t SubMessage_substuff3_default = 3;
 const int32_t AllTypes_opt_int32_default = 4041;
 const int64_t AllTypes_opt_int64_default = 4042;
 const uint32_t AllTypes_opt_uint32_default = 4043;
 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 = 4048;
 const int32_t AllTypes_opt_sfixed32_default = 4049;
 const float AllTypes_opt_float_default = 4050;
 const uint64_t AllTypes_opt_fixed64_default = 4051;
 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}};
 const MyEnum AllTypes_opt_enum_default = MyEnum_Second;
 const pb_field_t SubMessage_fields[4] = {
    PB_FIELD(  1, STRING  , REQUIRED, STATIC, SubMessage, substuff1, substuff1, &SubMessage_substuff1_default),
    PB_FIELD(  2, INT32   , REQUIRED, STATIC, SubMessage, substuff2, substuff1, &SubMessage_substuff2_default),
    PB_FIELD(  3, FIXED32 , OPTIONAL, STATIC, SubMessage, substuff3, substuff2, &SubMessage_substuff3_default),
    PB_LAST_FIELD
 };
 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
 };
--- a/tests/backwards_compatibility/alltypes_legacy.h
+++ b/tests/backwards_compatibility/alltypes_legacy.h
@@ -1,178 +0,0 @@
 /* Automatically generated nanopb header */
 /* 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_PB_H_
 #define _PB_ALLTYPES_PB_H_
 #include <pb.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 /* Enum definitions */
 typedef enum _MyEnum {
    MyEnum_Zero = 0,
    MyEnum_First = 1,
    MyEnum_Second = 2,
    MyEnum_Truth = 42
 } MyEnum;
 /* Struct definitions */
 typedef struct _SubMessage {
    char substuff1[16];
    int32_t substuff2;
    bool has_substuff3;
    uint32_t substuff3;
 } SubMessage;
 typedef struct {
    size_t size;
    uint8_t bytes[16];
 } AllTypes_req_bytes_t;
 typedef struct {
    size_t size;
    uint8_t bytes[16];
 } AllTypes_rep_bytes_t;
 typedef struct {
    size_t size;
    uint8_t bytes[16];
 } AllTypes_opt_bytes_t;
 typedef struct _AllTypes {
    int32_t req_int32;
    int64_t req_int64;
    uint32_t req_uint32;
    uint64_t req_uint64;
    int32_t req_sint32;
    int64_t req_sint64;
    bool req_bool;
    uint32_t req_fixed32;
    int32_t req_sfixed32;
    float req_float;
    uint64_t req_fixed64;
    int64_t req_sfixed64;
    double req_double;
    char req_string[16];
    AllTypes_req_bytes_t req_bytes;
    SubMessage req_submsg;
    MyEnum req_enum;
    size_t rep_int32_count;
    int32_t rep_int32[5];
    size_t rep_int64_count;
    int64_t rep_int64[5];
    size_t rep_uint32_count;
    uint32_t rep_uint32[5];
    size_t rep_uint64_count;
    uint64_t rep_uint64[5];
    size_t rep_sint32_count;
    int32_t rep_sint32[5];
    size_t rep_sint64_count;
    int64_t rep_sint64[5];
    size_t rep_bool_count;
    bool rep_bool[5];
    size_t rep_fixed32_count;
    uint32_t rep_fixed32[5];
    size_t rep_sfixed32_count;
    int32_t rep_sfixed32[5];
    size_t rep_float_count;
    float rep_float[5];
    size_t rep_fixed64_count;
    uint64_t rep_fixed64[5];
    size_t rep_sfixed64_count;
    int64_t rep_sfixed64[5];
    size_t rep_double_count;
    double rep_double[5];
    size_t rep_string_count;
    char rep_string[5][16];
    size_t rep_bytes_count;
    AllTypes_rep_bytes_t rep_bytes[5];
    size_t rep_submsg_count;
    SubMessage rep_submsg[5];
    size_t rep_enum_count;
    MyEnum rep_enum[5];
    bool has_opt_int32;
    int32_t opt_int32;
    bool has_opt_int64;
    int64_t opt_int64;
    bool has_opt_uint32;
    uint32_t opt_uint32;
    bool has_opt_uint64;
    uint64_t opt_uint64;
    bool has_opt_sint32;
    int32_t opt_sint32;
    bool has_opt_sint64;
    int64_t opt_sint64;
    bool has_opt_bool;
    bool opt_bool;
    bool has_opt_fixed32;
    uint32_t opt_fixed32;
    bool has_opt_sfixed32;
    int32_t opt_sfixed32;
    bool has_opt_float;
    float opt_float;
    bool has_opt_fixed64;
    uint64_t opt_fixed64;
    bool has_opt_sfixed64;
    int64_t opt_sfixed64;
    bool has_opt_double;
    double opt_double;
    bool has_opt_string;
    char opt_string[16];
    bool has_opt_bytes;
    AllTypes_opt_bytes_t opt_bytes;
    bool has_opt_submsg;
    SubMessage opt_submsg;
    bool has_opt_enum;
    MyEnum opt_enum;
    int32_t end;
 } 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 AllTypes_opt_int32_default;
 extern const int64_t AllTypes_opt_int64_default;
 extern const uint32_t AllTypes_opt_uint32_default;
 extern const uint64_t AllTypes_opt_uint64_default;
 extern const int32_t AllTypes_opt_sint32_default;
 extern const int64_t AllTypes_opt_sint64_default;
 extern const bool AllTypes_opt_bool_default;
 extern const uint32_t AllTypes_opt_fixed32_default;
 extern const int32_t AllTypes_opt_sfixed32_default;
 extern const float AllTypes_opt_float_default;
 extern const uint64_t AllTypes_opt_fixed64_default;
 extern const int64_t AllTypes_opt_sfixed64_default;
 extern const double AllTypes_opt_double_default;
 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;
 /* Struct field encoding specification for nanopb */
 extern const pb_field_t SubMessage_fields[4];
 extern const pb_field_t AllTypes_fields[53];
 /* Check that field information fits in pb_field_t */
 #if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
 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)
 #endif
 #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" */
 #endif
 #endif
--- a/tests/backwards_compatibility/decode_legacy.c
+++ b/tests/backwards_compatibility/decode_legacy.c
@@ -1,197 +0,0 @@
 /* Tests the decoding of all types.
 * This is a backwards-compatibility test, using alltypes_legacy.h.
 * It is similar to decode_alltypes, but duplicated in order to allow
 * decode_alltypes to test any new features introduced later.
 *
 * Run e.g. ./encode_legacy | ./decode_legacy
 */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <pb_decode.h>
 #include "alltypes_legacy.h"
 #define TEST(x) if (!(x)) { \
    printf("Test " #x " failed.\n"); \
    return false; \
    }
 /* This function is called once from main(), it handles
   the decoding and checks the fields. */
 bool check_alltypes(pb_istream_t *stream, int mode)
 {
    AllTypes alltypes;
    /* Fill with garbage to better detect initialization errors */
    memset(&alltypes, 0xAA, sizeof(alltypes));
    if (!pb_decode(stream, AllTypes_fields, &alltypes))
        return false;
    TEST(alltypes.req_int32         == -1001);
    TEST(alltypes.req_int64         == -1002);
    TEST(alltypes.req_uint32        == 1003);
    TEST(alltypes.req_uint64        == 1004);
    TEST(alltypes.req_sint32        == -1005);
    TEST(alltypes.req_sint64        == -1006);
    TEST(alltypes.req_bool          == true);
    TEST(alltypes.req_fixed32       == 1008);
    TEST(alltypes.req_sfixed32      == -1009);
    TEST(alltypes.req_float         == 1010.0f);
    TEST(alltypes.req_fixed64       == 1011);
    TEST(alltypes.req_sfixed64      == -1012);
    TEST(alltypes.req_double        == 1013.0f);
    TEST(strcmp(alltypes.req_string, "1014") == 0);
    TEST(alltypes.req_bytes.size == 4);
    TEST(memcmp(alltypes.req_bytes.bytes, "1015", 4) == 0);
    TEST(strcmp(alltypes.req_submsg.substuff1, "1016") == 0);
    TEST(alltypes.req_submsg.substuff2 == 1016);
    TEST(alltypes.req_submsg.substuff3 == 3);
    TEST(alltypes.req_enum == MyEnum_Truth);
    TEST(alltypes.rep_int32_count == 5 && alltypes.rep_int32[4] == -2001 && alltypes.rep_int32[0] == 0);
    TEST(alltypes.rep_int64_count == 5 && alltypes.rep_int64[4] == -2002 && alltypes.rep_int64[0] == 0);
    TEST(alltypes.rep_uint32_count == 5 && alltypes.rep_uint32[4] == 2003 && alltypes.rep_uint32[0] == 0);
    TEST(alltypes.rep_uint64_count == 5 && alltypes.rep_uint64[4] == 2004 && alltypes.rep_uint64[0] == 0);
    TEST(alltypes.rep_sint32_count == 5 && alltypes.rep_sint32[4] == -2005 && alltypes.rep_sint32[0] == 0);
    TEST(alltypes.rep_sint64_count == 5 && alltypes.rep_sint64[4] == -2006 && alltypes.rep_sint64[0] == 0);
    TEST(alltypes.rep_bool_count == 5 && alltypes.rep_bool[4] == true && alltypes.rep_bool[0] == false);
    TEST(alltypes.rep_fixed32_count == 5 && alltypes.rep_fixed32[4] == 2008 && alltypes.rep_fixed32[0] == 0);
    TEST(alltypes.rep_sfixed32_count == 5 && alltypes.rep_sfixed32[4] == -2009 && alltypes.rep_sfixed32[0] == 0);
    TEST(alltypes.rep_float_count == 5 && alltypes.rep_float[4] == 2010.0f && alltypes.rep_float[0] == 0.0f);
    TEST(alltypes.rep_fixed64_count == 5 && alltypes.rep_fixed64[4] == 2011 && alltypes.rep_fixed64[0] == 0);
    TEST(alltypes.rep_sfixed64_count == 5 && alltypes.rep_sfixed64[4] == -2012 && alltypes.rep_sfixed64[0] == 0);
    TEST(alltypes.rep_double_count == 5 && alltypes.rep_double[4] == 2013.0 && alltypes.rep_double[0] == 0.0);
    TEST(alltypes.rep_string_count == 5 && strcmp(alltypes.rep_string[4], "2014") == 0 && alltypes.rep_string[0][0] == '\0');
    TEST(alltypes.rep_bytes_count == 5 && alltypes.rep_bytes[4].size == 4 && alltypes.rep_bytes[0].size == 0);
    TEST(memcmp(alltypes.rep_bytes[4].bytes, "2015", 4) == 0);
    TEST(alltypes.rep_submsg_count == 5);
    TEST(strcmp(alltypes.rep_submsg[4].substuff1, "2016") == 0 && alltypes.rep_submsg[0].substuff1[0] == '\0');
    TEST(alltypes.rep_submsg[4].substuff2 == 2016 && alltypes.rep_submsg[0].substuff2 == 0);
    TEST(alltypes.rep_submsg[4].substuff3 == 2016 && alltypes.rep_submsg[0].substuff3 == 3);
    TEST(alltypes.rep_enum_count == 5 && alltypes.rep_enum[4] == MyEnum_Truth && alltypes.rep_enum[0] == MyEnum_Zero);
    if (mode == 0)
    {
        /* Expect default values */
        TEST(alltypes.has_opt_int32     == false);
        TEST(alltypes.opt_int32         == 4041);
        TEST(alltypes.has_opt_int64     == false);
        TEST(alltypes.opt_int64         == 4042);
        TEST(alltypes.has_opt_uint32    == false);
        TEST(alltypes.opt_uint32        == 4043);
        TEST(alltypes.has_opt_uint64    == false);
        TEST(alltypes.opt_uint64        == 4044);
        TEST(alltypes.has_opt_sint32    == false);
        TEST(alltypes.opt_sint32        == 4045);
        TEST(alltypes.has_opt_sint64    == false);
        TEST(alltypes.opt_sint64        == 4046);
        TEST(alltypes.has_opt_bool      == false);
        TEST(alltypes.opt_bool          == false);
        TEST(alltypes.has_opt_fixed32   == false);
        TEST(alltypes.opt_fixed32       == 4048);
        TEST(alltypes.has_opt_sfixed32  == false);
        TEST(alltypes.opt_sfixed32      == 4049);
        TEST(alltypes.has_opt_float     == false);
        TEST(alltypes.opt_float         == 4050.0f);
        TEST(alltypes.has_opt_fixed64   == false);
        TEST(alltypes.opt_fixed64       == 4051);
        TEST(alltypes.has_opt_sfixed64  == false);
        TEST(alltypes.opt_sfixed64      == 4052);
        TEST(alltypes.has_opt_double    == false);
        TEST(alltypes.opt_double        == 4053.0);
        TEST(alltypes.has_opt_string    == false);
        TEST(strcmp(alltypes.opt_string, "4054") == 0);
        TEST(alltypes.has_opt_bytes     == false);
        TEST(alltypes.opt_bytes.size == 4);
        TEST(memcmp(alltypes.opt_bytes.bytes, "4055", 4) == 0);
        TEST(alltypes.has_opt_submsg    == false);
        TEST(strcmp(alltypes.opt_submsg.substuff1, "1") == 0);
        TEST(alltypes.opt_submsg.substuff2 == 2);
        TEST(alltypes.opt_submsg.substuff3 == 3);
        TEST(alltypes.has_opt_enum     == false);
        TEST(alltypes.opt_enum == MyEnum_Second);
    }
    else
    {
        /* Expect filled-in values */
        TEST(alltypes.has_opt_int32     == true);
        TEST(alltypes.opt_int32         == 3041);
        TEST(alltypes.has_opt_int64     == true);
        TEST(alltypes.opt_int64         == 3042);
        TEST(alltypes.has_opt_uint32    == true);
        TEST(alltypes.opt_uint32        == 3043);
        TEST(alltypes.has_opt_uint64    == true);
        TEST(alltypes.opt_uint64        == 3044);
        TEST(alltypes.has_opt_sint32    == true);
        TEST(alltypes.opt_sint32        == 3045);
        TEST(alltypes.has_opt_sint64    == true);
        TEST(alltypes.opt_sint64        == 3046);
        TEST(alltypes.has_opt_bool      == true);
        TEST(alltypes.opt_bool          == true);
        TEST(alltypes.has_opt_fixed32   == true);
        TEST(alltypes.opt_fixed32       == 3048);
        TEST(alltypes.has_opt_sfixed32  == true);
        TEST(alltypes.opt_sfixed32      == 3049);
        TEST(alltypes.has_opt_float     == true);
        TEST(alltypes.opt_float         == 3050.0f);
        TEST(alltypes.has_opt_fixed64   == true);
        TEST(alltypes.opt_fixed64       == 3051);
        TEST(alltypes.has_opt_sfixed64  == true);
        TEST(alltypes.opt_sfixed64      == 3052);
        TEST(alltypes.has_opt_double    == true);
        TEST(alltypes.opt_double        == 3053.0);
        TEST(alltypes.has_opt_string    == true);
        TEST(strcmp(alltypes.opt_string, "3054") == 0);
        TEST(alltypes.has_opt_bytes     == true);
        TEST(alltypes.opt_bytes.size == 4);
        TEST(memcmp(alltypes.opt_bytes.bytes, "3055", 4) == 0);
        TEST(alltypes.has_opt_submsg    == true);
        TEST(strcmp(alltypes.opt_submsg.substuff1, "3056") == 0);
        TEST(alltypes.opt_submsg.substuff2 == 3056);
        TEST(alltypes.opt_submsg.substuff3 == 3);
        TEST(alltypes.has_opt_enum      == true);
        TEST(alltypes.opt_enum == MyEnum_Truth);
    }
    TEST(alltypes.end == 1099);
    return true;
 }
 int main(int argc, char **argv)
 {
    /* Whether to expect the optional values or the default values. */
    int mode = (argc > 1) ? atoi(argv[1]) : 0;
    /* Read the data into buffer */
    uint8_t buffer[1024];
    size_t count = fread(buffer, 1, sizeof(buffer), stdin);
    /* Construct a pb_istream_t for reading from the buffer */
    pb_istream_t stream = pb_istream_from_buffer(buffer, count);
    /* Decode and print out the stuff */
    if (!check_alltypes(&stream, mode))
    {
        printf("Parsing failed: %s\n", PB_GET_ERROR(&stream));
        return 1;
    } else {
        return 0;
    }
 }
--- a/tests/backwards_compatibility/encode_legacy.c
+++ b/tests/backwards_compatibility/encode_legacy.c
@@ -1,135 +0,0 @@
 /* Attempts to test all the datatypes supported by ProtoBuf.
 * This is a backwards-compatibility test, using alltypes_legacy.h.
 * It is similar to encode_alltypes, but duplicated in order to allow
 * encode_alltypes to test any new features introduced later.
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pb_encode.h>
 #include "alltypes_legacy.h"
 #include "test_helpers.h"
 int main(int argc, char **argv)
 {
    int mode = (argc > 1) ? atoi(argv[1]) : 0;
    /* Initialize the structure with constants */
    AllTypes alltypes = {0};
    alltypes.req_int32         = -1001;
    alltypes.req_int64         = -1002;
    alltypes.req_uint32        = 1003;
    alltypes.req_uint64        = 1004;
    alltypes.req_sint32        = -1005;
    alltypes.req_sint64        = -1006;
    alltypes.req_bool          = true;
    alltypes.req_fixed32       = 1008;
    alltypes.req_sfixed32      = -1009;
    alltypes.req_float         = 1010.0f;
    alltypes.req_fixed64       = 1011;
    alltypes.req_sfixed64      = -1012;
    alltypes.req_double        = 1013.0;
    strcpy(alltypes.req_string, "1014");
    alltypes.req_bytes.size = 4;
    memcpy(alltypes.req_bytes.bytes, "1015", 4);
    strcpy(alltypes.req_submsg.substuff1, "1016");
    alltypes.req_submsg.substuff2 = 1016;
    alltypes.req_enum = MyEnum_Truth;
    alltypes.rep_int32_count = 5; alltypes.rep_int32[4] = -2001;
    alltypes.rep_int64_count = 5; alltypes.rep_int64[4] = -2002;
    alltypes.rep_uint32_count = 5; alltypes.rep_uint32[4] = 2003;
    alltypes.rep_uint64_count = 5; alltypes.rep_uint64[4] = 2004;
    alltypes.rep_sint32_count = 5; alltypes.rep_sint32[4] = -2005;
    alltypes.rep_sint64_count = 5; alltypes.rep_sint64[4] = -2006;
    alltypes.rep_bool_count = 5; alltypes.rep_bool[4] = true;
    alltypes.rep_fixed32_count = 5; alltypes.rep_fixed32[4] = 2008;
    alltypes.rep_sfixed32_count = 5; alltypes.rep_sfixed32[4] = -2009;
    alltypes.rep_float_count = 5; alltypes.rep_float[4] = 2010.0f;
    alltypes.rep_fixed64_count = 5; alltypes.rep_fixed64[4] = 2011;
    alltypes.rep_sfixed64_count = 5; alltypes.rep_sfixed64[4] = -2012;
    alltypes.rep_double_count = 5; alltypes.rep_double[4] = 2013.0;
    alltypes.rep_string_count = 5; strcpy(alltypes.rep_string[4], "2014");
    alltypes.rep_bytes_count = 5; alltypes.rep_bytes[4].size = 4;
    memcpy(alltypes.rep_bytes[4].bytes, "2015", 4);
    alltypes.rep_submsg_count = 5;
    strcpy(alltypes.rep_submsg[4].substuff1, "2016");
    alltypes.rep_submsg[4].substuff2 = 2016;
    alltypes.rep_submsg[4].has_substuff3 = true;
    alltypes.rep_submsg[4].substuff3 = 2016;
    alltypes.rep_enum_count = 5; alltypes.rep_enum[4] = MyEnum_Truth;
    if (mode != 0)
    {
        /* Fill in values for optional fields */
        alltypes.has_opt_int32 = true;
        alltypes.opt_int32         = 3041;
        alltypes.has_opt_int64 = true;
        alltypes.opt_int64         = 3042;
        alltypes.has_opt_uint32 = true;
        alltypes.opt_uint32        = 3043;
        alltypes.has_opt_uint64 = true;
        alltypes.opt_uint64        = 3044;
        alltypes.has_opt_sint32 = true;
        alltypes.opt_sint32        = 3045;
        alltypes.has_opt_sint64 = true;
        alltypes.opt_sint64        = 3046;
        alltypes.has_opt_bool = true;
        alltypes.opt_bool          = true;
        alltypes.has_opt_fixed32 = true;
        alltypes.opt_fixed32       = 3048;
        alltypes.has_opt_sfixed32 = true;
        alltypes.opt_sfixed32      = 3049;
        alltypes.has_opt_float = true;
        alltypes.opt_float         = 3050.0f;
        alltypes.has_opt_fixed64 = true;
        alltypes.opt_fixed64       = 3051;
        alltypes.has_opt_sfixed64 = true;
        alltypes.opt_sfixed64      = 3052;
        alltypes.has_opt_double = true;
        alltypes.opt_double        = 3053.0;
        alltypes.has_opt_string = true;
        strcpy(alltypes.opt_string, "3054");
        alltypes.has_opt_bytes = true;
        alltypes.opt_bytes.size = 4;
        memcpy(alltypes.opt_bytes.bytes, "3055", 4);
        alltypes.has_opt_submsg = true;
        strcpy(alltypes.opt_submsg.substuff1, "3056");
        alltypes.opt_submsg.substuff2 = 3056;
        alltypes.has_opt_enum = true;
        alltypes.opt_enum = MyEnum_Truth;
    }
    alltypes.end = 1099;
    {    
        uint8_t buffer[1024];
        pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
        /* Now encode it and check if we succeeded. */
        if (pb_encode(&stream, AllTypes_fields, &alltypes))
        {
            SET_BINARY_MODE(stdout);
            fwrite(buffer, 1, stream.bytes_written, stdout);
            return 0; /* Success */
        }
        else
        {
            fprintf(stderr, "Encoding failed!\n");
            return 1; /* Failure */
        }
    }
 }
--- a/tests/basic_buffer/SConscript
+++ b/tests/basic_buffer/SConscript
@@ -1,12 +0,0 @@
 # Build and run a basic round-trip test using memory buffer encoding.
 Import("env")
 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"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_buffer.output"])
 env.Decode(["encode_buffer.output", "#common/person.proto"], MESSAGE = "Person")
 env.Compare(["decode_buffer.output", "encode_buffer.decoded"])
--- a/tests/basic_stream/SConscript
+++ b/tests/basic_stream/SConscript
@@ -1,12 +0,0 @@
 # Build and run a basic round-trip test using direct stream encoding.
 Import("env")
 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"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_stream.output"])
 env.Decode(["encode_stream.output", "#common/person.proto"], MESSAGE = "Person")
 env.Compare(["decode_stream.output", "encode_stream.decoded"])
--- a/tests/buffer_only/SConscript
+++ b/tests/buffer_only/SConscript
@@ -1,23 +0,0 @@
 # Run the alltypes test case, but compile with PB_BUFFER_ONLY=1
 Import("env")
 # Take copy of the files for custom build.
 c = Copy("$TARGET", "$SOURCE")
 env.Command("pb_encode.c", "#../pb_encode.c", c)
 env.Command("pb_decode.c", "#../pb_decode.c", c)
 env.Command("alltypes.pb.h", "#alltypes/alltypes.pb.h", c)
 env.Command("alltypes.pb.c", "#alltypes/alltypes.pb.c", c)
 env.Command("encode_alltypes.c", "#alltypes/encode_alltypes.c", c)
 env.Command("decode_alltypes.c", "#alltypes/decode_alltypes.c", c)
 # Define the compilation options
 opts = env.Clone()
 opts.Append(CPPDEFINES = {'PB_BUFFER_ONLY': 1})
 # Now build and run the test normally.
 enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode.c"])
 dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode.c"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/callbacks/callbacks.proto
+++ b/tests/callbacks/callbacks.proto
@@ -11,6 +11,5 @@ message TestMessage {
    repeated fixed32 fixed32value = 3;
    repeated fixed64 fixed64value = 4;
    optional SubMessage submsg = 5;
    repeated string repeatedstring = 6;
 }
--- a/tests/callbacks/SConscript
+++ b/tests/callbacks/SConscript
@@ -1,14 +0,0 @@
 # Test the functionality of the callback fields.
 Import("env")
 env.NanopbProto("callbacks")
 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"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_callbacks.output"])
 env.Decode(["encode_callbacks.output", "callbacks.proto"], MESSAGE = "TestMessage")
 env.Compare(["decode_callbacks.output", "encode_callbacks.decoded"])
--- a/tests/common/SConscript
+++ b/tests/common/SConscript
@@ -1,17 +0,0 @@
 # Build the common files needed by multiple test cases
 Import('env')
 # Protocol definitions for the encode/decode_unittests
 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", "#../pb_decode.c")
 strict.Object("pb_encode.o", "#../pb_encode.c")
--- a/tests/common/test_helpers.h
+++ b/tests/common/test_helpers.h
@@ -1,17 +0,0 @@
 /* Compatibility helpers for the test programs. */
 #ifndef _TEST_HELPERS_H_
 #define _TEST_HELPERS_H_
 #ifdef _WIN32
 #include <io.h>
 #include <fcntl.h>
 #define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
 #else
 #define SET_BINARY_MODE(file)
 #endif
 #endif
--- a/tests/cxx_main_program/SConscript
+++ b/tests/cxx_main_program/SConscript
@@ -1,20 +0,0 @@
 # Run the alltypes test case, but compile it as C++ instead.
 # In fact, compile the entire nanopb using C++ compiler.
 Import("env")
 # Copy the files to .cxx extension in order to force C++ build.
 c = Copy("$TARGET", "$SOURCE")
 env.Command("pb_encode.cxx", "#../pb_encode.c", c)
 env.Command("pb_decode.cxx", "#../pb_decode.c", c)
 env.Command("alltypes.pb.h", "#alltypes/alltypes.pb.h", c)
 env.Command("alltypes.pb.cxx", "#alltypes/alltypes.pb.c", c)
 env.Command("encode_alltypes.cxx", "#alltypes/encode_alltypes.c", c)
 env.Command("decode_alltypes.cxx", "#alltypes/decode_alltypes.c", c)
 # Now build and run the test normally.
 enc = env.Program(["encode_alltypes.cxx", "alltypes.pb.cxx", "pb_encode.cxx"])
 dec = env.Program(["decode_alltypes.cxx", "alltypes.pb.cxx", "pb_decode.cxx"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/decode_unittests/decode_unittests.c
+++ b/tests/decode_unittests/decode_unittests.c
@@ -1,5 +1,3 @@
 #define NANOPB_INTERNALS
 #include <stdio.h>
 #include <string.h>
 #include "pb_decode.h"
@@ -19,11 +17,11 @@ bool stream_callback(pb_istream_t *stream, uint8_t *buf, size_t count)
 }
 /* Verifies that the stream passed to callback matches the byte array pointed to by arg. */
-bool callback_check(pb_istream_t *stream, const pb_field_t *field, void **arg)
+bool callback_check(pb_istream_t *stream, const pb_field_t *field, void *arg)
 {
    int i;
    uint8_t byte;
-    pb_bytes_array_t *ref = (pb_bytes_array_t*) *arg;
+    pb_bytes_array_t *ref = (pb_bytes_array_t*) arg;
    for (i = 0; i < ref->size; i++)
    {
@@ -289,16 +287,6 @@ int main()
        TEST((s = S("\x08"), !pb_decode(&s, IntegerArray_fields, &dest)))
    }
    {
        pb_istream_t s;
        IntegerContainer dest = {{0}};
        COMMENT("Testing pb_decode_delimited")
        TEST((s = S("\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"),
              pb_decode_delimited(&s, IntegerContainer_fields, &dest)) &&
              dest.submsg.data_count == 5)
    }
    if (status != 0)
        fprintf(stdout, "\n\nSome tests FAILED!\n");
--- a/tests/decode_unittests/SConscript
+++ b/tests/decode_unittests/SConscript
@@ -1,4 +0,0 @@
 Import('env')
 p = env.Program(["decode_unittests.c", "#common/unittestproto.pb.c", "#common/pb_decode.o"])
 env.RunTest(p)
--- a/tests/encode_unittests/encode_unittests.c
+++ b/tests/encode_unittests/encode_unittests.c
@@ -1,5 +1,3 @@
 #define NANOPB_INTERNALS
 #include <stdio.h>
 #include <string.h>
 #include "pb_encode.h"
@@ -17,7 +15,7 @@ bool streamcallback(pb_ostream_t *stream, const uint8_t *buf, size_t count)
    return true;
 }
-bool fieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
+bool fieldcallback(pb_ostream_t *stream, const pb_field_t *field, const void *arg)
 {
    int value = 0x55;
    if (!pb_encode_tag_for_field(stream, field))
@@ -25,7 +23,7 @@ bool fieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *
    return pb_encode_varint(stream, value);
 }
-bool crazyfieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
+bool crazyfieldcallback(pb_ostream_t *stream, const pb_field_t *field, const void *arg)
 {
    /* This callback writes different amount of data the second time. */
    uint32_t *state = (uint32_t*)arg;
@@ -125,6 +123,7 @@ int main()
        uint8_t buffer[30];
        pb_ostream_t s;
        uint8_t value = 1;
        int8_t svalue = -1;
        int32_t max = INT32_MAX;
        int32_t min = INT32_MIN;
        int64_t lmax = INT64_MAX;
@@ -133,6 +132,8 @@ int main()
        COMMENT("Test pb_enc_varint and pb_enc_svarint")
        TEST(WRITES(pb_enc_varint(&s, &field, &value), "\x01"));
        TEST(WRITES(pb_enc_svarint(&s, &field, &svalue), "\x01"));
        TEST(WRITES(pb_enc_svarint(&s, &field, &value), "\x02"));
        field.data_size = sizeof(max);
        TEST(WRITES(pb_enc_svarint(&s, &field, &max), "\xfe\xff\xff\xff\x0f"));
@@ -180,14 +181,12 @@ int main()
    {
        uint8_t buffer[30];
        pb_ostream_t s;
-        char value[30] = "xyzzy";
+        char value[] = "xyzzy";
        COMMENT("Test pb_enc_string")
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x05xyzzy"))
+        TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x05xyzzy"))
        value[0] = '\0';
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x00"))
+        TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x00"))
        memset(value, 'x', 30);
        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x0Axxxxxxxxxx"))
    }
    {
@@ -244,16 +243,6 @@ int main()
                    "\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
    }
    {
        uint8_t buffer[20];
        pb_ostream_t s;
        IntegerContainer msg = {{5, {1,2,3,4,5}}};
        COMMENT("Test pb_encode_delimited.")
        TEST(WRITES(pb_encode_delimited(&s, IntegerContainer_fields, &msg),
                    "\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
    }
    {
        uint8_t buffer[10];
        pb_ostream_t s;
--- a/tests/encode_unittests/SConscript
+++ b/tests/encode_unittests/SConscript
@@ -1,5 +0,0 @@
 # Build and run the stand-alone unit tests for the nanopb encoder part.
 Import('env')
 p = env.Program(["encode_unittests.c", "#common/unittestproto.pb.c", "#common/pb_encode.o"])
 env.RunTest(p)
--- a/tests/extensions/SConscript
+++ b/tests/extensions/SConscript
@@ -1,16 +0,0 @@
 # Test the support for extension fields.
 Import("env")
 # We use the files from the alltypes test case
 incpath = env.Clone()
 incpath.Append(PROTOCPATH = '#alltypes')
 incpath.Append(CPPPATH = '#alltypes')
 incpath.NanopbProto("extensions")
 enc = incpath.Program(["encode_extensions.c", "extensions.pb.c", "#alltypes/alltypes.pb$OBJSUFFIX", "#common/pb_encode.o"])
 dec = incpath.Program(["decode_extensions.c", "extensions.pb.c", "#alltypes/alltypes.pb$OBJSUFFIX", "#common/pb_decode.o"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_extensions.output"])
--- a/tests/extensions/decode_extensions.c
+++ b/tests/extensions/decode_extensions.c
@@ -1,58 +0,0 @@
 /* Test decoding of extension fields. */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <pb_decode.h>
 #include "alltypes.pb.h"
 #include "extensions.pb.h"
 #include "test_helpers.h"
 #define TEST(x) if (!(x)) { \
    printf("Test " #x " failed.\n"); \
    return 2; \
    }
 int main(int argc, char **argv)
 {
    uint8_t buffer[1024];
    size_t count;
    pb_istream_t stream;
    AllTypes alltypes = {0};
    int32_t extensionfield1;
    pb_extension_t ext1;
    ExtensionMessage extensionfield2;
    pb_extension_t ext2;
    /* Read the message data */
    SET_BINARY_MODE(stdin);
    count = fread(buffer, 1, sizeof(buffer), stdin);
    stream = pb_istream_from_buffer(buffer, count);
    /* Add the extensions */
    alltypes.extensions = &ext1;        
    ext1.type = &AllTypes_extensionfield1;
    ext1.dest = &extensionfield1;
    ext1.next = &ext2;
    ext2.type = &ExtensionMessage_AllTypes_extensionfield2;
    ext2.dest = &extensionfield2;
    ext2.next = NULL;
    /* Decode the message */
    if (!pb_decode(&stream, AllTypes_fields, &alltypes))
    {
        printf("Parsing failed: %s\n", PB_GET_ERROR(&stream));
        return 1;
    }
    /* Check that the extensions decoded properly */
    TEST(extensionfield1 == 12345)
    TEST(strcmp(extensionfield2.test1, "test") == 0)
    TEST(extensionfield2.test2 == 54321)
    return 0;
 }
--- a/tests/extensions/encode_extensions.c
+++ b/tests/extensions/encode_extensions.c
@@ -1,50 +0,0 @@
 /* Tests extension fields.
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pb_encode.h>
 #include "alltypes.pb.h"
 #include "extensions.pb.h"
 #include "test_helpers.h"
 int main(int argc, char **argv)
 {
    uint8_t buffer[1024];
    pb_ostream_t stream;
    AllTypes alltypes = {0};
    int32_t extensionfield1 = 12345;
    pb_extension_t ext1;
    ExtensionMessage extensionfield2 = {"test", 54321};
    pb_extension_t ext2;
    /* Set up the extensions */
    alltypes.extensions = &ext1;
    ext1.type = &AllTypes_extensionfield1;
    ext1.dest = &extensionfield1;
    ext1.next = &ext2;
    ext2.type = &ExtensionMessage_AllTypes_extensionfield2;
    ext2.dest = &extensionfield2;
    ext2.next = NULL;
    /* Set up the output stream */
    stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    /* Now encode the message and check if we succeeded. */
    if (pb_encode(&stream, AllTypes_fields, &alltypes))
    {
        SET_BINARY_MODE(stdout);
        fwrite(buffer, 1, stream.bytes_written, stdout);
        return 0; /* Success */
    }
    else
    {
        fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&stream));
        return 1; /* Failure */
    }
 }
--- a/tests/extensions/extensions.options
+++ b/tests/extensions/extensions.options
@@ -1 +0,0 @@
 * max_size:16
--- a/tests/extensions/extensions.proto
+++ b/tests/extensions/extensions.proto
@@ -1,17 +0,0 @@
 import 'alltypes.proto';
 extend AllTypes {
    optional int32 AllTypes_extensionfield1 = 255;
 }
 message ExtensionMessage {
    extend AllTypes {
        optional ExtensionMessage AllTypes_extensionfield2 = 254;
 	required ExtensionMessage AllTypes_extensionfield3 = 253;
 	repeated ExtensionMessage AllTypes_extensionfield4 = 252;
    }
    required string test1 = 1;
    required int32 test2 = 2;
 }
--- a/tests/extra_fields/SConscript
+++ b/tests/extra_fields/SConscript
@@ -1,14 +0,0 @@
 # Test that the decoder properly handles unknown fields in the input.
 Import("env")
 dec = env.GetBuildPath('#basic_buffer/${PROGPREFIX}decode_buffer${PROGSUFFIX}')
 env.RunTest('person_with_extra_field.output', [dec, "person_with_extra_field.pb"])
 env.Compare(["person_with_extra_field.output", "person_with_extra_field.expected"])
 dec = env.GetBuildPath('#basic_stream/${PROGPREFIX}decode_stream${PROGSUFFIX}')
 env.RunTest('person_with_extra_field_stream.output', [dec, "person_with_extra_field.pb"])
 env.Compare(["person_with_extra_field_stream.output", "person_with_extra_field.expected"])
 dec2 = env.GetBuildPath('#alltypes/${PROGPREFIX}decode_alltypes${PROGSUFFIX}')
 env.RunTest('alltypes_with_extra_fields.output', [dec2, 'alltypes_with_extra_fields.pb'])
--- a/tests/extra_fields/alltypes_with_extra_fields.pb
+++ b/tests/extra_fields/alltypes_with_extra_fields.pb
--- a/tests/extra_fields/person_with_extra_field.expected
+++ b/tests/extra_fields/person_with_extra_field.expected
@@ -1,14 +0,0 @@
 name: "Test Person 99"
 id: 99
 email: "test@person.com"
 phone {
  number: "555-12345678"
  type: MOBILE
 }
 phone {
  number: "99-2342"
 }
 phone {
  number: "1234-5678"
  type: WORK
 }
--- a/tests/extra_fields/person_with_extra_field.pb
+++ b/tests/extra_fields/person_with_extra_field.pb
--- a/tests/field_size_16/SConscript
+++ b/tests/field_size_16/SConscript
@@ -1,24 +0,0 @@
 # Run the alltypes test case, but compile with PB_FIELD_16BIT=1.
 # Also the .proto file has been modified to have high indexes.
 Import("env")
 # Take copy of the files for custom build.
 c = Copy("$TARGET", "$SOURCE")
 env.Command("pb_encode.c", "#../pb_encode.c", c)
 env.Command("pb_decode.c", "#../pb_decode.c", c)
 env.Command("encode_alltypes.c", "#alltypes/encode_alltypes.c", c)
 env.Command("decode_alltypes.c", "#alltypes/decode_alltypes.c", c)
 env.NanopbProto("alltypes")
 # Define the compilation options
 opts = env.Clone()
 opts.Append(CPPDEFINES = {'PB_FIELD_16BIT': 1})
 # Now build and run the test normally.
 enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode.c"])
 dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode.c"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/field_size_16/alltypes.options
+++ b/tests/field_size_16/alltypes.options
@@ -1,3 +0,0 @@
 * max_size:16
 * max_count:5
--- a/tests/field_size_16/alltypes.proto
+++ b/tests/field_size_16/alltypes.proto
@@ -1,90 +0,0 @@
 message SubMessage {
    required string substuff1 = 1 [default = "1"];
    required int32 substuff2 = 2 [default = 2];
    optional fixed32 substuff3 = 65535 [default = 3];
 }
 message EmptyMessage {
 }
 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;
    required EmptyMessage req_emptymsg = 18;
    repeated int32      rep_int32   = 21;
    repeated int64      rep_int64   = 22;
    repeated uint32     rep_uint32  = 23;
    repeated uint64     rep_uint64  = 24;
    repeated sint32     rep_sint32  = 25;
    repeated sint64     rep_sint64  = 26;
    repeated bool       rep_bool    = 27;
    repeated fixed32    rep_fixed32 = 28;
    repeated sfixed32   rep_sfixed32= 29;
    repeated float      rep_float   = 30;
    repeated fixed64    rep_fixed64 = 10031;
    repeated sfixed64   rep_sfixed64= 10032;
    repeated double     rep_double  = 10033;
    repeated string     rep_string  = 10034;
    repeated bytes      rep_bytes   = 10035;
    repeated SubMessage rep_submsg  = 10036;
    repeated MyEnum     rep_enum    = 10037;
    repeated EmptyMessage rep_emptymsg = 10038;
    optional int32      opt_int32   = 10041 [default = 4041];
    optional int64      opt_int64   = 10042 [default = 4042];
    optional uint32     opt_uint32  = 10043 [default = 4043];
    optional uint64     opt_uint64  = 10044 [default = 4044];
    optional sint32     opt_sint32  = 10045 [default = 4045];
    optional sint64     opt_sint64  = 10046 [default = 4046];
    optional bool       opt_bool    = 10047 [default = false];
    optional fixed32    opt_fixed32 = 10048 [default = 4048];
    optional sfixed32   opt_sfixed32= 10049 [default = 4049];
    optional float      opt_float   = 10050 [default = 4050];
    optional fixed64    opt_fixed64 = 10051 [default = 4051];
    optional sfixed64   opt_sfixed64= 10052 [default = 4052];
    optional double     opt_double  = 10053 [default = 4053];
    optional string     opt_string  = 10054 [default = "4054"];
    optional bytes      opt_bytes   = 10055 [default = "4055"];
    optional SubMessage opt_submsg  = 10056;
    optional MyEnum     opt_enum    = 10057 [default = Second];
    optional EmptyMessage opt_emptymsg = 10058;
    // 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 = 10099;
 }
--- a/tests/field_size_32/SConscript
+++ b/tests/field_size_32/SConscript
@@ -1,24 +0,0 @@
 # Run the alltypes test case, but compile with PB_FIELD_32BIT=1.
 # Also the .proto file has been modified to have high indexes.
 Import("env")
 # Take copy of the files for custom build.
 c = Copy("$TARGET", "$SOURCE")
 env.Command("pb_encode.c", "#../pb_encode.c", c)
 env.Command("pb_decode.c", "#../pb_decode.c", c)
 env.Command("encode_alltypes.c", "#alltypes/encode_alltypes.c", c)
 env.Command("decode_alltypes.c", "#alltypes/decode_alltypes.c", c)
 env.NanopbProto("alltypes")
 # Define the compilation options
 opts = env.Clone()
 opts.Append(CPPDEFINES = {'PB_FIELD_32BIT': 1})
 # Now build and run the test normally.
 enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode.c"])
 dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode.c"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/field_size_32/alltypes.options
+++ b/tests/field_size_32/alltypes.options
@@ -1,3 +0,0 @@
 * max_size:16
 * max_count:5
--- a/tests/field_size_32/alltypes.proto
+++ b/tests/field_size_32/alltypes.proto
@@ -1,90 +0,0 @@
 message SubMessage {
    required string substuff1 = 1 [default = "1"];
    required int32 substuff2 = 2 [default = 2];
    optional fixed32 substuff3 = 12365535 [default = 3];
 }
 message EmptyMessage {
 }
 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;
    required EmptyMessage req_emptymsg = 18;
    repeated int32      rep_int32   = 21;
    repeated int64      rep_int64   = 22;
    repeated uint32     rep_uint32  = 23;
    repeated uint64     rep_uint64  = 24;
    repeated sint32     rep_sint32  = 25;
    repeated sint64     rep_sint64  = 26;
    repeated bool       rep_bool    = 27;
    repeated fixed32    rep_fixed32 = 28;
    repeated sfixed32   rep_sfixed32= 29;
    repeated float      rep_float   = 30;
    repeated fixed64    rep_fixed64 = 10031;
    repeated sfixed64   rep_sfixed64= 10032;
    repeated double     rep_double  = 10033;
    repeated string     rep_string  = 10034;
    repeated bytes      rep_bytes   = 10035;
    repeated SubMessage rep_submsg  = 10036;
    repeated MyEnum     rep_enum    = 10037;
    repeated EmptyMessage rep_emptymsg = 10038;
    optional int32      opt_int32   = 10041 [default = 4041];
    optional int64      opt_int64   = 10042 [default = 4042];
    optional uint32     opt_uint32  = 10043 [default = 4043];
    optional uint64     opt_uint64  = 10044 [default = 4044];
    optional sint32     opt_sint32  = 10045 [default = 4045];
    optional sint64     opt_sint64  = 10046 [default = 4046];
    optional bool       opt_bool    = 10047 [default = false];
    optional fixed32    opt_fixed32 = 10048 [default = 4048];
    optional sfixed32   opt_sfixed32= 10049 [default = 4049];
    optional float      opt_float   = 10050 [default = 4050];
    optional fixed64    opt_fixed64 = 10051 [default = 4051];
    optional sfixed64   opt_sfixed64= 10052 [default = 4052];
    optional double     opt_double  = 10053 [default = 4053];
    optional string     opt_string  = 10054 [default = "4054"];
    optional bytes      opt_bytes   = 10055 [default = "4055"];
    optional SubMessage opt_submsg  = 10056;
    optional MyEnum     opt_enum    = 10057 [default = Second];
    optional EmptyMessage opt_emptymsg = 10058;
    // 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 = 13432099;
 }
--- a/tests/missing_fields/SConscript
+++ b/tests/missing_fields/SConscript
@@ -1,8 +0,0 @@
 # Check that the decoder properly detects when required fields are missing.
 Import("env")
 env.NanopbProto("missing_fields")
 test = env.Program(["missing_fields.c", "missing_fields.pb.c", "#common/pb_encode.o", "#common/pb_decode.o"])
 env.RunTest(test)
--- a/tests/missing_fields/missing_fields.c
+++ b/tests/missing_fields/missing_fields.c
@@ -1,50 +0,0 @@
 /* Checks that missing required fields are detected properly */
 #include <stdio.h>
 #include <pb_encode.h>
 #include <pb_decode.h>
 #include "missing_fields.pb.h"
 int main()
 {
    uint8_t buffer[512];
    /* Create a message with one missing field */
    {
        MissingField msg = {0};
        pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
        if (!pb_encode(&stream, MissingField_fields, &msg))
        {
            printf("Encode failed.\n");
            return 1;
        }
    }
    /* Test that it decodes properly if we don't require that field */
    {
        MissingField msg = {0};
        pb_istream_t stream = pb_istream_from_buffer(buffer, sizeof(buffer));
        if (!pb_decode(&stream, MissingField_fields, &msg))
        {
            printf("Decode failed: %s\n", PB_GET_ERROR(&stream));
            return 2;
        }
    }
    /* Test that it does *not* decode properly if we require the field */
    {
        AllFields msg = {0};
        pb_istream_t stream = pb_istream_from_buffer(buffer, sizeof(buffer));
        if (pb_decode(&stream, AllFields_fields, &msg))
        {
            printf("Decode didn't detect missing field.\n");
            return 3;
        }
    }
    return 0; /* All ok */
 }
--- a/tests/missing_fields/missing_fields.proto
+++ b/tests/missing_fields/missing_fields.proto
@@ -1,138 +0,0 @@
 /* Test for one missing field among many */
 message AllFields
 {
    required int32 field1 = 1;
    required int32 field2 = 2;
    required int32 field3 = 3;
    required int32 field4 = 4;
    required int32 field5 = 5;
    required int32 field6 = 6;
    required int32 field7 = 7;
    required int32 field8 = 8;
    required int32 field9 = 9;
    required int32 field10 = 10;
    required int32 field11 = 11;
    required int32 field12 = 12;
    required int32 field13 = 13;
    required int32 field14 = 14;
    required int32 field15 = 15;
    required int32 field16 = 16;
    required int32 field17 = 17;
    required int32 field18 = 18;
    required int32 field19 = 19;
    required int32 field20 = 20;
    required int32 field21 = 21;
    required int32 field22 = 22;
    required int32 field23 = 23;
    required int32 field24 = 24;
    required int32 field25 = 25;
    required int32 field26 = 26;
    required int32 field27 = 27;
    required int32 field28 = 28;
    required int32 field29 = 29;
    required int32 field30 = 30;
    required int32 field31 = 31;
    required int32 field32 = 32;
    required int32 field33 = 33;
    required int32 field34 = 34;
    required int32 field35 = 35;
    required int32 field36 = 36;
    required int32 field37 = 37;
    required int32 field38 = 38;
    required int32 field39 = 39;
    required int32 field40 = 40;
    required int32 field41 = 41;
    required int32 field42 = 42;
    required int32 field43 = 43;
    required int32 field44 = 44;
    required int32 field45 = 45;
    required int32 field46 = 46;
    required int32 field47 = 47;
    required int32 field48 = 48;
    required int32 field49 = 49;
    required int32 field50 = 50;
    required int32 field51 = 51;
    required int32 field52 = 52;
    required int32 field53 = 53;
    required int32 field54 = 54;
    required int32 field55 = 55;
    required int32 field56 = 56;
    required int32 field57 = 57;
    required int32 field58 = 58;
    required int32 field59 = 59;
    required int32 field60 = 60;
    required int32 field61 = 61;
    required int32 field62 = 62;
    required int32 field63 = 63;
    required int32 field64 = 64;
 }
 message MissingField
 {
    required int32 field1 = 1;
    required int32 field2 = 2;
    required int32 field3 = 3;
    required int32 field4 = 4;
    required int32 field5 = 5;
    required int32 field6 = 6;
    required int32 field7 = 7;
    required int32 field8 = 8;
    required int32 field9 = 9;
    required int32 field10 = 10;
    required int32 field11 = 11;
    required int32 field12 = 12;
    required int32 field13 = 13;
    required int32 field14 = 14;
    required int32 field15 = 15;
    required int32 field16 = 16;
    required int32 field17 = 17;
    required int32 field18 = 18;
    required int32 field19 = 19;
    required int32 field20 = 20;
    required int32 field21 = 21;
    required int32 field22 = 22;
    required int32 field23 = 23;
    required int32 field24 = 24;
    required int32 field25 = 25;
    required int32 field26 = 26;
    required int32 field27 = 27;
    required int32 field28 = 28;
    required int32 field29 = 29;
    required int32 field30 = 30;
    required int32 field31 = 31;
    required int32 field32 = 32;
    required int32 field33 = 33;
    required int32 field34 = 34;
    required int32 field35 = 35;
    required int32 field36 = 36;
    required int32 field37 = 37;
    required int32 field38 = 38;
    required int32 field39 = 39;
    required int32 field40 = 40;
    required int32 field41 = 41;
    required int32 field42 = 42;
    required int32 field43 = 43;
    required int32 field44 = 44;
    required int32 field45 = 45;
    required int32 field46 = 46;
    required int32 field47 = 47;
    required int32 field48 = 48;
    required int32 field49 = 49;
    required int32 field50 = 50;
    required int32 field51 = 51;
    required int32 field52 = 52;
    required int32 field53 = 53;
    required int32 field54 = 54;
    required int32 field55 = 55;
    required int32 field56 = 56;
    required int32 field57 = 57;
    required int32 field58 = 58;
    required int32 field59 = 59;
    required int32 field60 = 60;
    required int32 field61 = 61;
    required int32 field62 = 62;
 /*    required int32 field63 = 63; */
    required int32 field64 = 64;
 }
--- a/tests/multiple_files/SConscript
+++ b/tests/multiple_files/SConscript
@@ -1,13 +0,0 @@
 # Test that multiple .proto files don't cause name collisions.
 Import("env")
 incpath = env.Clone()
 incpath.Append(PROTOCPATH = '#multiple_files')
 incpath.NanopbProto("callbacks")
 incpath.NanopbProto("callbacks2")
 test = incpath.Program(["test_multiple_files.c", "callbacks.pb.c", "callbacks2.pb.c"])
 env.RunTest(test)
--- a/tests/multiple_files/callbacks.proto
+++ b/tests/multiple_files/callbacks.proto
@@ -1,16 +0,0 @@
 message SubMessage {
    optional string stringvalue = 1;
    repeated int32 int32value = 2;
    repeated fixed32 fixed32value = 3;
    repeated fixed64 fixed64value = 4;
 }
 message TestMessage {
    optional string stringvalue = 1;
    repeated int32 int32value = 2;
    repeated fixed32 fixed32value = 3;
    repeated fixed64 fixed64value = 4;
    optional SubMessage submsg = 5;
    repeated string repeatedstring = 6;
 }
--- a/tests/multiple_files/callbacks2.proto
+++ b/tests/multiple_files/callbacks2.proto
@@ -1,9 +0,0 @@
 // Test if including generated header file for this file + implicit include of
 // callbacks.pb.h still compiles. Used with test_compiles.c.
 import "callbacks.proto";
 message Callback2Message {
    required TestMessage tstmsg = 1;
    required SubMessage submsg = 2;
 }
--- a/tests/multiple_files/test_multiple_files.c
+++ b/tests/multiple_files/test_multiple_files.c
@@ -1,12 +0,0 @@
 /*
 * Tests if this still compiles when multiple .proto files are involved.
 */
 #include <stdio.h>
 #include <pb_encode.h>
 #include "callbacks2.pb.h"
 int main()
 {
 	return 0;
 }
--- a/tests/no_errmsg/SConscript
+++ b/tests/no_errmsg/SConscript
@@ -1,23 +0,0 @@
 # Run the alltypes test case, but compile with PB_NO_ERRMSG=1
 Import("env")
 # Take copy of the files for custom build.
 c = Copy("$TARGET", "$SOURCE")
 env.Command("pb_encode.c", "#../pb_encode.c", c)
 env.Command("pb_decode.c", "#../pb_decode.c", c)
 env.Command("alltypes.pb.h", "#alltypes/alltypes.pb.h", c)
 env.Command("alltypes.pb.c", "#alltypes/alltypes.pb.c", c)
 env.Command("encode_alltypes.c", "#alltypes/encode_alltypes.c", c)
 env.Command("decode_alltypes.c", "#alltypes/decode_alltypes.c", c)
 # Define the compilation options
 opts = env.Clone()
 opts.Append(CPPDEFINES = {'PB_NO_ERRMSG': 1})
 # Now build and run the test normally.
 enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode.c"])
 dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode.c"])
 env.RunTest(enc)
 env.RunTest([dec, "encode_alltypes.output"])
--- a/tests/no_messages/SConscript
+++ b/tests/no_messages/SConscript
@@ -1,7 +0,0 @@
 # Test that a .proto file without any messages compiles fine.
 Import("env")
 env.NanopbProto("no_messages")
 env.Object('no_messages.pb.c')
--- a/tests/no_messages/no_messages.proto
+++ b/tests/no_messages/no_messages.proto
@@ -1,7 +0,0 @@
 /* Test that a file without any messages works. */
 enum Test {
    First = 1;
 }
--- a/tests/options/SConscript
+++ b/tests/options/SConscript
@@ -1,9 +0,0 @@
 # Test that the generator options work as expected.
 Import("env")
 env.NanopbProto("options")
 env.Object('options.pb.c')
 env.Match(['options.pb.h', 'options.expected'])
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel Kan	6d010fb7c4	Fixed pb_get_message_size	2012-02-27 14:46:38 -08:00
Daniel Kan	34aa2031c4	Code reduction optimization by sharing common field descriptor information for numeric field types	2012-02-24 13:46:36 -08:00