Publishing nanopb-0.1.9.1

Possible consequences of bug:
1) Denial of service by causing a crash
   Possible when all of the following apply:
      - Untrusted data is passed to pb_decode()
      - The top-level message contains a static string field as the first field.
   Causes a single write of '0' byte to 1 byte before the message struct.

2) Remote code execution
   Possible when all of the following apply:
      - 64-bit platform
      - The message or a submessage contains a static string field.
      - Decoding directly from a custom pb_istream_t
      - bytes_left on the stream is set to larger than 4 GB
   Causes a write of up to 4 GB of data past the string field.

--

Detailed analysis follows

In the following consideration, I define "platform bitness" as equal to
number of bits in size_t datatype. Therefore most 8-bit platforms are
regarded as 16-bit for the purposes of this discussion.

1. The overflow in pb_dec_string

The overflow happens in this computation:

uint32_t size;
size_t alloc_size;
alloc_size = size + 1;

There are two ways in which the overflow can occur: In the uint32_t
addition, or in the cast to size_t. This depends on the platform
bitness.

On 32- and 64-bit platforms, the size has to be UINT32_MAX for the
overflow to occur. In that case alloc_size will be 0.

On 16-bit platforms, overflow will happen whenever size is more than
UINT16_MAX, and resulting alloc_size is attacker controlled.

For static fields, the alloc_size value is just checked against the
field data size. For pointer fields, the alloc_size value is passed to
malloc(). End result in both cases is the same, the storage is 0 or
just a few bytes in length.

On 16-bit platforms, another overflow occurs in the call to pb_read(),
when passing the original size. An attacker will want the passed value
to be larger than the alloc_size, therefore the only reasonable choice
is to have size = UINT16_MAX and alloc_size = 0. Any larger multiple
will truncate to the same values.

At this point we have read atleast the tag and the string length of the
message, i.e. atleast 3 bytes. The maximum initial value for stream
bytes_left is SIZE_MAX, thus at this point at most SIZE_MAX-3 bytes are
remaining.

On 32-bit and 16-bit platforms this means that the size passed to
pb_read() is always larger than the number of remaining bytes. This
causes pb_read() to fail immediately, before reading any bytes.

On 64-bit platforms, it is possible for the bytes_left value to be set
to a value larger than UINT32_MAX, which is the wraparound point in
size calculation. In this case pb_read() will succeed and write up to 4
GB of attacker controlled data over the RAM that comes after the string
field.

On all platforms, there is an unconditional write of a terminating null
byte. Because the size of size_t typically reflects the size of the
processor address space, a write at UINT16_MAX or UINT32_MAX bytes
after the string field actually wraps back to before the string field.
Consequently, on 32-bit and 16-bit platforms, the bug causes a single
write of '0' byte at one byte before the string field.

If the string field is in the middle of a message, this will just
corrupt other data in the message struct. Because the message contents
is attacker controlled anyway, this is a non-issue. However, if the
string field is the first field in the top-level message, it can
corrupt other data on the stack/heap before it. Typically a single '0'
write at a location not controlled by attacker is enough only for a
denial-of-service attack.

When using pointer fields and malloc(), the attacker controlled
alloc_size will cause a 0-size allocation to happen. By the same logic
as before, on 32-bit and 16-bit platforms this causes a '0' byte write
only. On 64-bit platforms, however, it will again allow up to 4 GB of
malicious data to be written over memory, if the stream length allows
the read.

2. The overflow in pb_dec_bytes

This overflow happens in the PB_BYTES_ARRAY_T_ALLOCSIZE macro:

The computation is done in size_t data type this time. This means that
an overflow is possible only when n is larger than SIZE_MAX -
offsetof(..). The offsetof value in this case is equal to
sizeof(pb_size_t) bytes.

Because the incoming size value is limited to 32 bits, no overflow can
happen here on 64-bit platforms.

The size will be passed to pb_read(). Like before, on 32-bit and 16-bit
platforms the read will always fail before writing anything.

This leaves only the write of bdest->size as exploitable. On statically
allocated fields, the size field will always be allocated, regardless
of alloc_size. In this case, no buffer overflow is possible here, but
user code could possibly use the attacker controlled size value and
read past a buffer.

If the field is allocated through malloc(), this will allow a write of
sizeof(pb_size_t) attacker controlled bytes to past a 0-byte long
buffer. In typical malloc implementations, this will either fit in
unused alignment padding area, or cause a heap corruption and a crash.
Under very exceptional situation it could allow attacker to influence
the behaviour of malloc(), possibly jumping into an attacker-controlled
location and thus leading to remote code execution.

.gitignore

@@ -1,28 +0,0 @@
-*.gcda
-*.gcno
-*.gcov
-*.o
-*.pb.c
-*.pb.h
-*.pb
-*.pyc
-*_pb2.py
-*~
-*.tar.gz
-.sconsign.dblite
-config.log
-.sconf_temp
-tests/build
-julkaisu.txt
-dist
-docs/*.html
-docs/generator_flow.png
-examples/simple/simple
-examples/network_server/client
-examples/network_server/server
-examples/using_double_on_avr/decode_double
-examples/using_double_on_avr/encode_double
-examples/using_double_on_avr/test_conversions
-examples/using_union_messages/decode
-examples/using_union_messages/encode
-generator/nanopb_pb2.pyc

CHANGELOG

@@ -0,0 +1,70 @@
+nanopb-0.1.9.1
+ Fix security issue due to size_t overflows. (issue 132)
+
+ NOTE: nanopb-0.1.x is and will remain affected by issue 97.
+       A fix would be too intrusive for a support release.
+
+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.

CHANGELOG.txt

@@ -1,168 +0,0 @@
-nanopb-0.2.9.1 (2014-09-11)
- Fix security issue due to size_t overflows. (issue 132)
- Fix memory leak with duplicated fields and PB_ENABLE_MALLOC
- Fix crash if pb_release() is called twice.
-
-nanopb-0.2.9 (2014-08-09)
- NOTE: If you are using the -e option with the generator, you have
- to prepend . to the argument to get the same behaviour as before.
-
- Do not automatically add a dot with generator -e option. (issue 122)
- Fix problem with .options file and extension fields. (issue 125)
- Don't use SIZE_MAX macro, as it is not in C89. (issue 120)
- Generate #defines for initializing message structures. (issue 79)
- Add skip_message option to generator. (issue 121)
- Add PB_PACKED_STRUCT support for Keil MDK-ARM toolchain (issue 119)
- Give better messages about the .options file path. (issue 124)
- Improved tests
-
-nanopb-0.2.8 (2014-05-20)
- Fix security issue with PB_ENABLE_MALLOC. (issue 117)
- Add option to not add timestamps to .pb.h and .pb.c preambles. (issue 115)
- Documentation updates
- Improved tests
-
-nanopb-0.2.7 (2014-04-07)
- Fix bug with default values for extension fields (issue 111)
- Fix some MISRA-C warnings (issue 91)
- Implemented optional malloc() support (issue 80)
- Changed pointer-type bytes field datatype
- Add a "found" field to pb_extension_t (issue 112)
- Add convenience function pb_get_encoded_size() (issue 16)
-
-nanopb-0.2.6 (2014-02-15)
- Fix generator error with bytes callback fields (issue 99)
- Fix warnings about large integer constants (issue 102)
- Add comments to where STATIC_ASSERT is used (issue 96)
- Add warning about unknown field names on .options (issue 105)
- Move descriptor.proto to google/protobuf subdirectory (issue 104)
- Improved tests
-
-nanopb-0.2.5 (2014-01-01)
- Fix a bug with encoding negative values in int32 fields (issue 97)
- Create binary packages of the generator + dependencies (issue 47)
- Add support for pointer-type fields to the encoder (part of issue 80)
- Fixed path in FindNanopb.cmake (issue 94)
- Improved tests
-
-nanopb-0.2.4 (2013-11-07)
- Remove the deprecated NANOPB_INTERNALS functions from public API.
- Document the security model.
- Check array and bytes max sizes when encoding (issue 90)
- Add #defines for maximum encoded message size (issue 89)
- Add #define tags for extension fields (issue 93)
- Fix MISRA C violations (issue 91)
- Clean up pb_field_t definition with typedefs.
-
-nanopb-0.2.3 (2013-09-18)
- 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 (2013-08-18)
- 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 (2013-04-14)
- 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 (2013-03-02)
- 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 (2013-02-13)
- 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 (2012-12-13)
- 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 (2012-11-11)
- 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 (2012-09-02)
- 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 (2012-08-04)
- Fix bug in decoder with packed arrays (issue 23).
- Extended testcases.
- Fix some compiler warnings.
-
-nanopb-0.1.4 (2012-07-05)
- 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 (2012-06-12)
- 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 (2012-02-15)
- Make the generator to generate include for other .proto files (issue 4).
- Fixed generator not working on Windows (issue 3)
-
-nanopb-0.1.1 (2012-01-14)
- 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 (2012-01-06)
- First stable release.

README

@@ -0,0 +1,11 @@
+Nanopb is a small code-size Protocol Buffers implementation.
+
+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.

README.txt

@@ -1,61 +0,0 @@
-Nanopb is a small code-size Protocol Buffers implementation in ansi C. It is
-especially suitable for use in microcontrollers, but fits any memory
-restricted system.
-
-Homepage: http://kapsi.fi/~jpa/nanopb/
-
-
-
-
-Using the nanopb library
-========================
-To use the nanopb library, you need to do two things:
-
-1) Compile your .proto files for nanopb, using protoc.
-2) Include pb_encode.c and pb_decode.c in your project.
-
-The easiest way to get started is to study the project in "examples/simple".
-It contains a Makefile, which should work directly under most Linux systems.
-However, for any other kind of build system, see the manual steps in
-README.txt in that folder.
-
-
-
-Using the Protocol Buffers compiler (protoc)
-============================================
-The nanopb generator is implemented as a plugin for the Google's own protoc
-compiler. This has the advantage that there is no need to reimplement the
-basic parsing of .proto files. However, it does mean that you need the
-Google's protobuf library in order to run the generator.
-
-If you have downloaded a binary package for nanopb (either Windows, Linux or
-Mac OS X version), the 'protoc' binary is included in the 'generator-bin'
-folder. In this case, you are ready to go. Simply run this command:
-
-    generator-bin/protoc --nanopb_out=. myprotocol.proto
-
-However, if you are using a git checkout or a plain source distribution, you
-need to provide your own version of protoc and the Google's protobuf library.
-On Linux, the necessary packages are protobuf-compiler and python-protobuf.
-On Windows, you can either build Google's protobuf library from source or use
-one of the binary distributions of it. In either case, if you use a separate
-protoc, you need to manually give the path to nanopb generator:
-
-    protoc --plugin=protoc-gen-nanopb=nanopb/generator/protoc-gen-nanopb ...
-
-
-
-Running the tests
-=================
-If you want to perform further development of the nanopb core, or to verify
-its functionality using your compiler and platform, you'll want to run the
-test suite. The build rules for the test suite are implemented using Scons,
-so you need to have that installed. To run the tests:
-
-    cd tests
-    scons
-
-This will show the progress of various test cases. If the output does not
-end in an error, the test cases were successful.
-
-

docs/Makefile

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

docs/concepts.rst

@@ -10,40 +10,47 @@ The things outlined here are the underlying concepts of the nanopb design.
 
 Proto files
 ===========
-All Protocol Buffers implementations use .proto files to describe the message
-format. The point of these files is to be a portable interface description
-language.
+All Protocol Buffers implementations use .proto files to describe the message format.
+The point of these files is to be a portable interface description language.
 
 Compiling .proto files for nanopb
 ---------------------------------
-Nanopb uses the Google's protoc compiler to parse the .proto file, and then a
-python script to generate the C header and source code from it::
+Nanopb uses the Google's protoc compiler to parse the .proto file, and then a python script to generate the C header and source code from it::
 
     user@host:~$ protoc -omessage.pb message.proto
     user@host:~$ python ../generator/nanopb_generator.py message.pb
     Writing to message.h and message.c
     user@host:~$
 
-Modifying generator behaviour
------------------------------
-Using generator options, you can set maximum sizes for fields in order to
-allocate them statically. The preferred way to do this is to create an .options
-file with the same name as your .proto file::
+Compiling .proto files with nanopb options
+------------------------------------------
+Nanopb defines two extensions for message fields described in .proto files: *max_size* and *max_count*.
+These are the maximum size of a string and maximum count of items in an array::
 
-   # Foo.proto
-   message Foo {
-      required string name = 1;
-   }
+    required string name = 1 [(nanopb).max_size = 40];
+    repeated PhoneNumber phone = 4 [(nanopb).max_count = 5];
 
-::
+To use these extensions, you need to place an import statement in the beginning of the file::
 
-   # Foo.options
-   Foo.name max_size:16
+    import "nanopb.proto";
 
-For more information on this, see the `Proto file options`_ section in the
-reference manual.
+This file, in turn, requires the file *google/protobuf/descriptor.proto*. This is usually installed under */usr/include*. Therefore, to compile a .proto file which uses options, use a protoc command similar to::
+
+    protoc -I/usr/include -Inanopb/generator -I. -omessage.pb message.proto
+
+The options can be defined in file, message and field scopes::
+
+    option (nanopb_fileopt).max_size = 20; // File scope
+    message Message
+    {
+        option (nanopb_msgopt).max_size = 30; // Message scope
+        required string fieldsize = 1 [(nanopb).max_size = 40]; // Field scope
+    }
+
+It is also possible to give the options on command line, but then they will affect the whole file. For example::
+
+    user@host:~$ python ../generator/nanopb_generator.py -s 'max_size: 20' message.pb
 
-.. _`Proto file options`: reference.html#proto-file-options
 
 Streams
 =======
@@ -174,9 +181,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 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.
+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.
 
 .. _`pb_callback_t`: reference.html#pb-callback-t
 
@@ -184,7 +189,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 +203,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 +216,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 +226,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,56 +255,20 @@ 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),
-    PB_FIELD(  2, ENUM    , OPTIONAL, STATIC, Person_PhoneNumber, type, number, &Person_PhoneNumber_type_default),
+    {1, PB_HTYPE_REQUIRED | PB_LTYPE_STRING,
+    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
 ================================
 
@@ -307,8 +276,8 @@ Most functions in nanopb return bool: *true* means success, *false* means failur
 
 The error messages help in guessing what is the underlying cause of the error. The most common error conditions are:
 
-1) Running out of memory, i.e. stack overflow.
-2) Invalid field descriptors (would usually mean a bug in the generator).
+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 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.
 4) Errors that happen in your callback functions.
 5) Exceeding the max_size or bytes_left of a stream.

docs/index.rst

@@ -36,25 +36,23 @@ Features and limitations
 **Features**
 
 #) Pure C runtime
-#) Small code size (2–10 kB depending on processor, plus any message definitions)
-#) Small ram usage (typically ~300 bytes, plus any message structs)
+#) Small code size (2–10 kB depending on processor)
+#) 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**
 
-#) Some speed has been sacrificed for code size.
+#) 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. 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
 ===============
@@ -89,38 +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 a more complex example with network interface, see the *example/network_server* subdirectory.
+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.
 
 Compiler requirements
 =====================
-Nanopb should compile with most ansi-C compatible compilers. It however
-requires a few header files to be available:
+Nanopb should compile with most ansi-C compatible compilers. It however 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
-file *extra/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.
+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.
 
-To use the pb_syshdr.h, define *PB_SYSTEM_HEADER* as *"pb_syshdr.h"* (including the quotes).
-Similarly, you can provide a custom include file, which should provide all the dependencies
-listed above.
+Debugging and testing
+=====================
+Extensive unittests are included under the *tests* folder. Just type *make* there to run the tests.
 
-Running the test cases
-======================
-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*.
+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.
 
+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.

docs/menu.rst

@@ -3,9 +3,8 @@
     1) `Overview`_
     2) `Concepts`_
     3) `API reference`_
-    4) `Security model`_
     
 .. _`Overview`: index.html
 .. _`Concepts`: concepts.html
 .. _`API reference`: reference.html
-.. _`Security model`: security.html
+

docs/reference.rst

@@ -6,188 +6,29 @@ 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.
-PB_ENABLE_MALLOC               Set this to enable dynamic allocation support
-                               in the decoder.
-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_POINTER*,
-                               *FT_STATIC* or *FT_IGNORE* to force a callback
-                               field, a dynamically allocated field, a static
-                               field or to completely ignore the field.
-long_names                     Prefix the enum name to the enum value in
-                               definitions, i.e. *EnumName_EnumValue*. Enabled
-                               by default.
-packed_struct                  Make the generated structures packed.
-                               NOTE: This cannot be used on CPUs that break
-                               on unaligned accesses to variables.
-============================  ================================================
-
-These options can be defined for the .proto files before they are converted
-using the nanopb-generatory.py. There are three ways to define the options:
-
-1. Using a separate .options file.
-   This is the preferred way as of nanopb-0.2.1, because it has the best
-   compatibility with other protobuf libraries.
-2. Defining the options on the command line of nanopb_generator.py.
-   This only makes sense for settings that apply to a whole file.
-3. Defining the options in the .proto file using the nanopb extensions.
-   This is the way used in nanopb-0.1, and will remain supported in the
-   future. It however sometimes causes trouble when using the .proto file
-   with other protobuf libraries.
-
-The effect of the options is the same no matter how they are given. The most
-common purpose is to define maximum size for string fields in order to
-statically allocate them.
-
-Defining the options in a .options file
----------------------------------------
-The preferred way to define options is to have a separate file
-'myproto.options' in the same directory as the 'myproto.proto'. ::
-
-    # myproto.proto
-    message MyMessage {
-        required string name = 1;
-        repeated int32 ids = 4;
-    }
-
-::
-
-    # myproto.options
-    MyMessage.name         max_size:40
-    MyMessage.ids          max_count:5
-
-The generator will automatically search for this file and read the
-options from it. The file format is as follows:
-
-* Lines starting with '#' or '//' are regarded as comments.
-* Blank lines are ignored.
-* All other lines should start with a field name pattern, followed by one or
-  more options. For example: *"MyMessage.myfield max_size:5 max_count:10"*.
-* The field name pattern is matched against a string of form *'Message.field'*.
-  For nested messages, the string is *'Message.SubMessage.field'*.
-* The field name pattern may use the notation recognized by Python fnmatch():
-
-  - *\** matches any part of string, like 'Message.\*' for all fields
-  - *\?* matches any single character
-  - *[seq]* matches any of characters 's', 'e' and 'q'
-  - *[!seq]* matches any other character
-
-* The options are written as *'option_name:option_value'* and several options
-  can be defined on same line, separated by whitespace.
-* Options defined later in the file override the ones specified earlier, so
-  it makes sense to define wildcard options first in the file and more specific
-  ones later.
-  
-If preferred, the name of the options file can be set using the command line
-switch *-f* to nanopb_generator.py.
-
-Defining the options on command line
-------------------------------------
-The nanopb_generator.py has a simple command line option *-s OPTION:VALUE*.
-The setting applies to the whole file that is being processed.
-
-Defining the options in the .proto file
----------------------------------------
-The .proto file format allows defining custom options for the fields.
-The nanopb library comes with *nanopb.proto* which does exactly that, allowing
-you do define the options directly in the .proto file::
-
-    import "nanopb.proto";
-    
-    message MyMessage {
-        required string name = 1 [(nanopb).max_size = 40];
-        repeated int32 ids = 4   [(nanopb).max_count = 5];
-    }
-
-A small complication is that you have to set the include path of protoc so that
-nanopb.proto can be found. This file, in turn, requires the file
-*google/protobuf/descriptor.proto*. This is usually installed under
-*/usr/include*. Therefore, to compile a .proto file which uses options, use a
-protoc command similar to::
-
-    protoc -I/usr/include -Inanopb/generator -I. -omessage.pb message.proto
-
-The options can be defined in file, message and field scopes::
-
-    option (nanopb_fileopt).max_size = 20; // File scope
-    message Message
-    {
-        option (nanopb_msgopt).max_size = 30; // Message scope
-        required string fieldsize = 1 [(nanopb).max_size = 40]; // Field scope
-    }
-
-
-
-
-
-
+The following options can be specified using -D switch given to the C compiler:
 
+============================  ================================================================================================
+__BIG_ENDIAN__                 Set this if your platform stores integers and floats in big-endian format.
+                               Mixed-endian systems (different layout for ints and floats) are currently not supported.
+NANOPB_INTERNALS               Set this to expose the field encoder functions that are hidden since nanopb-0.1.3.
+PB_MAX_REQUIRED_FIELDS         Maximum number of required fields to check for presence. Default value is 64. Increases stack
+                               usage 1 byte per every 8 fields. Compiler warning will tell if you need this.
+PB_FIELD_16BIT                 Add support for tag numbers > 255 and fields larger than 255 bytes or 255 array entries.
+                               Increases code size 3 bytes per each field. Compiler error will tell if you need this.
+PB_FIELD_32BIT                 Add support for tag numbers > 65535 and fields larger than 65535 bytes or 65535 array entries.
+                               Increases code size 9 bytes per each field. Compiler error will tell if you need this.
+PB_NO_ERRMSG                   Disables the support for error messages; only error information is the true/false return value.
+                               Decreases the code size by a few hundred bytes.
+PB_BUFFER_ONLY                 Disables the support for custom streams. Only supports encoding to memory buffers.
+                               Speeds up execution and decreases code size slightly.
+============================  ================================================================================================
 
+The PB_MAX_REQUIRED_FIELDS, PB_FIELD_16BIT and PB_FIELD_32BIT settings allow raising some datatype limits to suit larger messages.
+Their need is recognized automatically by C-preprocessor #if-directives in the generated .pb.h files. The default setting is to use
+the smallest datatypes (least resources used).
 
 pb.h
 ====
@@ -196,23 +37,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_FIXED64     0x03  64-bit integer or floating point.
-PB_LTYPE_BYTES       0x04  Structure with *size_t* field and byte array.
-PB_LTYPE_STRING      0x05  Null-terminated string.
-PB_LTYPE_SUBMESSAGE  0x06  Submessage structure.
+PB_LTYPE_FIXED       0x02  Integer or floating point.
+PB_LTYPE_BYTES       0x03  Structure with *size_t* field and byte array.
+PB_LTYPE_STRING      0x04  Null-terminated string.
+PB_LTYPE_SUBMESSAGE  0x05  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
@@ -220,24 +60,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_REPEATED    0x20  A repeated field with preallocated array.
+PB_HTYPE_ARRAY       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. ::
@@ -254,7 +83,7 @@ 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.
@@ -281,16 +110,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 (*encode)(pb_ostream_t *stream, const pb_field_t *field, void * const *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, 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.
-
-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*.
+The *arg* is passed to the callback when calling. It can be used to store any information that the callback might need.
 
 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.
 
@@ -305,76 +132,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
 ===========
 
@@ -416,17 +173,6 @@ 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.
 
-pb_encode_delimited
--------------------
-Calculates the length of the message, encodes it as varint and then encodes the message. ::
-
-    bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
-
-(parameters are the same as for `pb_encode`_.)
-
-A common way to indicate the message length in Protocol Buffers is to prefix it with a varint.
-This function does this, and it is compatible with *parseDelimitedFrom* in Google's protobuf library.
-
 .. sidebar:: Encoding fields manually
 
     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.
@@ -535,17 +281,6 @@ In Protocol Buffers format, the submessage size must be written before the subme
 
 If the submessage contains callback fields, the callback function might misbehave and write out a different amount of data on the second call. This situation is recognized and *false* is returned, but garbage will be written to the output before the problem is detected.
 
-
-
-
-
-
-
-
-
-
-
-
 pb_decode.h
 ===========
 
@@ -589,10 +324,6 @@ In addition to EOF, the pb_decode implementation supports terminating a message
 
 For optional fields, this function applies the default value and sets *has_<field>* to false if the field is not present.
 
-If *PB_ENABLE_MALLOC* is defined, this function may allocate storage for any pointer type fields.
-In this case, you have to call `pb_release`_ to release the memory after you are done with the message.
-On error return `pb_decode` will release the memory itself.
-
 pb_decode_noinit
 ----------------
 Same as `pb_decode`_, except does not apply the default values to fields. ::
@@ -603,35 +334,6 @@ Same as `pb_decode`_, except does not apply the default values to fields. ::
 
 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.
 
-In addition to decoding a single message, this function can be used to merge two messages, so that
-values from previous message will remain if the new message does not contain a field.
-
-This function *will not* release the message even on error return. If you use *PB_ENABLE_MALLOC*,
-you will need to call `pb_release`_ yourself.
-
-pb_decode_delimited
--------------------
-Same as `pb_decode`_, except that it first reads a varint with the length of the message. ::
-
-    bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
-
-(parameters are the same as for `pb_decode`_.)
-
-A common method to indicate message size in Protocol Buffers is to prefix it with a varint.
-This function is compatible with *writeDelimitedTo* in the Google's Protocol Buffers library.
-
-pb_release
-----------
-Releases any dynamically allocated fields.
-
-    void pb_release(const pb_field_t fields[], void *dest_struct);
-
-:fields:        A field description array. Usually autogenerated.
-:dest_struct:   Pointer to structure where data will be stored.
-
-This function is only available if *PB_ENABLE_MALLOC* is defined. It will release any
-pointer type fields in the structure and set the pointers to NULL.
-
 pb_skip_varint
 --------------
 Skip a varint_ encoded integer without decoding it. ::

docs/security.rst

@@ -1,79 +0,0 @@
-======================
-Nanopb: Security model
-======================
-
-.. include :: menu.rst
-
-.. contents ::
-
-
-
-Importance of security in a Protocol Buffers library
-====================================================
-In the context of protocol buffers, security comes into play when decoding
-untrusted data. Naturally, if the attacker can modify the contents of a
-protocol buffers message, he can feed the application any values possible.
-Therefore the application itself must be prepared to receive untrusted values.
-
-Where nanopb plays a part is preventing the attacker from running arbitrary
-code on the target system. Mostly this means that there must not be any
-possibility to cause buffer overruns, memory corruption or invalid pointers
-by the means of crafting a malicious message.
-
-Division of trusted and untrusted data
-======================================
-The following data is regarded as **trusted**. It must be under the control of
-the application writer. Malicious data in these structures could cause
-security issues, such as execution of arbitrary code:
-
-1. Callback and extension fields in message structures given to pb_encode()
-   and pb_decode(). These fields are memory pointers, and are generated
-   depending on the .proto file.
-2. The automatically generated field definitions, i.e. *pb_field_t* lists.
-3. Contents of the *pb_istream_t* and *pb_ostream_t* structures (this does not
-   mean the contents of the stream itself, just the stream definition).
-
-The following data is regarded as **untrusted**. Invalid/malicious data in
-these will cause "garbage in, garbage out" behaviour. It will not cause
-buffer overflows, information disclosure or other security problems:
-
-1. All data read from *pb_istream_t*.
-2. All fields in message structures, except callbacks and extensions.
-   (Beginning with nanopb-0.2.4, in earlier versions the field sizes are partially unchecked.)
-
-Invariants
-==========
-The following invariants are maintained during operation, even if the
-untrusted data has been maliciously crafted:
-
-1. Nanopb will never read more than *bytes_left* bytes from *pb_istream_t*.
-2. Nanopb will never write more than *max_size* bytes to *pb_ostream_t*.
-3. Nanopb will never access memory out of bounds of the message structure.
-4. After pb_decode() returns successfully, the message structure will be
-   internally consistent:
-
-   - The *count* fields of arrays will not exceed the array size.
-   - The *size* field of bytes will not exceed the allocated size.
-   - All string fields will have null terminator.
-
-5. After pb_encode() returns successfully, the resulting message is a valid
-   protocol buffers message. (Except if user-defined callbacks write incorrect
-   data.)
-
-Further considerations
-======================
-Even if the nanopb library is free of any security issues, there are still
-several possible attack vectors that the application author must consider.
-The following list is not comprehensive:
-
-1. Stack usage may depend on the contents of the message. The message
-   definition places an upper bound on how much stack will be used. Tests
-   should be run with all fields present, to record the maximum possible
-   stack usage.
-2. Callbacks can do anything. The code for the callbacks must be carefully
-   checked if they are used with untrusted data.
-3. If using stream input, a maximum size should be set in *pb_istream_t* to
-   stop a denial of service attack from using an infinite message.
-4. If using network sockets as streams, a timeout should be set to stop
-   denial of service attacks.
-

example/Makefile

@@ -0,0 +1,14 @@
+CFLAGS=-ansi -Wall -Werror -I .. -g -O0
+DEPS=../pb_decode.c ../pb_decode.h ../pb_encode.c ../pb_encode.h ../pb.h
+
+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 $@ $< ../pb_decode.c ../pb_encode.c fileproto.pb.c common.c
+
+fileproto.pb.c fileproto.pb.h: fileproto.proto ../generator/nanopb_generator.py
+	protoc -I. -I../generator -I/usr/include -ofileproto.pb $<
+	python ../generator/nanopb_generator.py fileproto.pb

example/client.c

@@ -0,0 +1,116 @@
+/* This is a simple TCP client that connects to port 1234 and prints a list
+ * of files in a given directory.
+ *
+ * It directly deserializes and serializes messages from network, minimizing
+ * memory use.
+ * 
+ * For flexibility, this example is implemented using posix api.
+ * In a real embedded system you would typically use some other kind of
+ * a communication and filesystem layer.
+ */
+
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <pb_encode.h>
+#include <pb_decode.h>
+
+#include "fileproto.pb.h"
+#include "common.h"
+
+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);
+    
+    return true;
+}
+
+bool listdir(int fd, char *path)
+{
+    ListFilesRequest request;
+    ListFilesResponse response;
+    pb_istream_t input = pb_istream_from_socket(fd);
+    pb_ostream_t output = pb_ostream_from_socket(fd);
+    uint8_t zero = 0;
+    
+    if (path == NULL)
+    {
+        request.has_path = false;
+    }
+    else
+    {
+        request.has_path = true;
+        if (strlen(path) + 1 > sizeof(request.path))
+        {
+            fprintf(stderr, "Too long path.\n");
+            return false;
+        }
+        
+        strcpy(request.path, path);
+    }
+    
+    if (!pb_encode(&output, ListFilesRequest_fields, &request))
+    {
+        fprintf(stderr, "Encoding failed.\n");
+        return false;
+    }
+    
+    /* We signal the end of request with a 0 tag. */
+    pb_write(&output, &zero, 1);
+    
+    response.file.funcs.decode = &printfile_callback;
+    
+    if (!pb_decode(&input, ListFilesResponse_fields, &response))
+    {
+        fprintf(stderr, "Decode failed: %s\n", PB_GET_ERROR(&input));
+        return false;
+    }
+    
+    if (response.path_error)
+    {
+        fprintf(stderr, "Server reported error.\n");
+        return false;
+    }
+    
+    return true;
+}
+
+int main(int argc, char **argv)
+{
+    int sockfd;
+    struct sockaddr_in servaddr;
+    char *path = NULL;
+    
+    if (argc > 1)
+        path = argv[1];
+    
+    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    
+    memset(&servaddr, 0, sizeof(servaddr));
+    servaddr.sin_family = AF_INET;
+    servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    servaddr.sin_port = htons(1234);
+    
+    if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0)
+    {
+        perror("connect");
+        return 1;
+    }
+    
+    if (!listdir(sockfd, path))
+        return 2;
+    
+    close(sockfd);
+    
+    return 0;
+}

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;
+}
+

example/server.c

@@ -23,16 +23,11 @@
 #include "fileproto.pb.h"
 #include "common.h"
 
-/* This callback function will be called once during the encoding.
- * It will write out any number of FileInfo entries, without consuming unnecessary memory.
- * This is accomplished by fetching the filenames one at a time and encoding them
- * immediately.
- */
-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 = {};
+    FileInfo fileinfo;
     
     while ((file = readdir(dir)) != NULL)
     {
@@ -40,12 +35,9 @@ bool listdir_callback(pb_ostream_t *stream, const pb_field_t *field, void * cons
         strncpy(fileinfo.name, file->d_name, sizeof(fileinfo.name));
         fileinfo.name[sizeof(fileinfo.name) - 1] = '\0';
         
-        /* This encodes the header for the field, based on the constant info
-         * from pb_field_t. */
         if (!pb_encode_tag_for_field(stream, field))
             return false;
         
-        /* This encodes the data for the field, based on our FileInfo structure. */
         if (!pb_encode_submessage(stream, FileInfo_fields, &fileinfo))
             return false;
     }
@@ -53,59 +45,43 @@ bool listdir_callback(pb_ostream_t *stream, const pb_field_t *field, void * cons
     return true;
 }
 
-/* Handle one arriving client connection.
- * Clients are expected to send a ListFilesRequest, terminated by a '0'.
- * Server will respond with a ListFilesResponse message.
- */
 void handle_connection(int connfd)
 {
-    DIR *directory = NULL;
+    ListFilesRequest request;
+    ListFilesResponse response;
+    pb_istream_t input = pb_istream_from_socket(connfd);
+    pb_ostream_t output = pb_ostream_from_socket(connfd);
+    DIR *directory;
     
-    /* Decode the message from the client and open the requested directory. */
+    if (!pb_decode(&input, ListFilesRequest_fields, &request))
     {
-        ListFilesRequest request = {};
-        pb_istream_t input = pb_istream_from_socket(connfd);
-        
-        if (!pb_decode(&input, ListFilesRequest_fields, &request))
-        {
-            printf("Decode failed: %s\n", PB_GET_ERROR(&input));
-            return;
-        }
-        
-        directory = opendir(request.path);
-        printf("Listing directory: %s\n", request.path);
+        printf("Decode failed: %s\n", PB_GET_ERROR(&input));
+        return;
     }
     
-    /* List the files in the directory and transmit the response to client */
+    directory = opendir(request.path);
+    
+    printf("Listing directory: %s\n", request.path);
+    
+    if (directory == NULL)
     {
-        ListFilesResponse response = {};
-        pb_ostream_t output = pb_ostream_from_socket(connfd);
+        perror("opendir");
         
-        if (directory == NULL)
-        {
-            perror("opendir");
-            
-            /* Directory was not found, transmit error status */
-            response.has_path_error = true;
-            response.path_error = true;
-            response.file.funcs.encode = NULL;
-        }
-        else
-        {
-            /* Directory was found, transmit filenames */
-            response.has_path_error = false;
-            response.file.funcs.encode = &listdir_callback;
-            response.file.arg = directory;
-        }
-        
-        if (!pb_encode(&output, ListFilesResponse_fields, &response))
-        {
-            printf("Encoding failed: %s\n", PB_GET_ERROR(&output));
-        }
+        response.has_path_error = true;
+        response.path_error = true;
+        response.file.funcs.encode = NULL;
+    }
+    else
+    {
+        response.has_path_error = false;
+        response.file.funcs.encode = &listdir_callback;
+        response.file.arg = directory;
     }
     
-    if (directory != NULL)
-        closedir(directory);
+    if (!pb_encode(&output, ListFilesResponse_fields, &response))
+    {
+        printf("Encoding failed.\n");
+    }
 }
 
 int main(int argc, char **argv)
@@ -114,8 +90,8 @@ int main(int argc, char **argv)
     struct sockaddr_in servaddr;
     int reuse = 1;
     
-    /* Listen on localhost:1234 for TCP connections */
     listenfd = socket(AF_INET, SOCK_STREAM, 0);
+    
     setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
     
     memset(&servaddr, 0, sizeof(servaddr));
@@ -136,7 +112,6 @@ int main(int argc, char **argv)
     
     for(;;)
     {
-        /* Wait for a client */
         connfd = accept(listenfd, NULL, NULL);
         
         if (connfd < 0)
@@ -153,6 +128,4 @@ int main(int argc, char **argv)
         
         close(connfd);
     }
-    
-    return 0;
 }

example_avr_double/Makefile

@@ -0,0 +1,22 @@
+CFLAGS=-Wall -Werror -I .. -g -O0
+DEPS=double_conversion.c ../pb_decode.c ../pb_decode.h ../pb_encode.c ../pb_encode.h ../pb.h
+
+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 ../pb_decode.c ../pb_encode.c doubleproto.pb.c
+
+doubleproto.pb.c doubleproto.pb.h: doubleproto.proto ../generator/nanopb_generator.py
+	protoc -I. -I../generator -I/usr/include -odoubleproto.pb $<
+	python ../generator/nanopb_generator.py doubleproto.pb
+
+run_tests: test_conversions encode_double decode_double
+	./test_conversions
+	./encode_double | ./decode_double
+    

example_avr_double/README.txt

@@ -1,6 +1,3 @@
-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
@@ -12,7 +9,7 @@ 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:
+To use this method, you need to make two modifications to your code:
 
 1) Change all 'double' fields into 'fixed64' in the .proto.
 
@@ -20,6 +17,6 @@ To use this method, you need to make some modifications to your code:
 
 3) Whenever reading a 'double' field, use double_to_float().
 
-The conversion routines are as accurate as the float datatype can
+The conversion routines should be 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.

example_unions/Makefile

@@ -0,0 +1,17 @@
+CFLAGS=-ansi -Wall -Werror -I .. -g -O0
+DEPS=../pb_decode.c ../pb_decode.h ../pb_encode.c ../pb_encode.h ../pb.h
+
+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 $@ $< ../pb_decode.c ../pb_encode.c unionproto.pb.c
+
+unionproto.pb.h unionproto.pb.c: unionproto.proto ../generator/nanopb_generator.py
+	protoc -I. -I../generator -I/usr/include -ounionproto.pb $<
+	python ../generator/nanopb_generator.py unionproto.pb

examples/network_server/Makefile

@@ -1,17 +0,0 @@
-# Include the nanopb provided Makefile rules
-include ../../extra/nanopb.mk
-
-# Compiler flags to enable all warnings & debug info
-CFLAGS = -ansi -Wall -Werror -g -O0
-CFLAGS += -I$(NANOPB_DIR)
-
-all: server client
-
-.SUFFIXES:
-
-clean:
-	rm -f server client fileproto.pb.c fileproto.pb.h
-
-%: %.c common.c fileproto.pb.c
-	$(CC) $(CFLAGS) -o $@ $^ $(NANOPB_CORE)
-

examples/network_server/README.txt

@@ -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.

examples/network_server/client.c

@@ -1,142 +0,0 @@
-/* This is a simple TCP client that connects to port 1234 and prints a list
- * of files in a given directory.
- *
- * It directly deserializes and serializes messages from network, minimizing
- * memory use.
- * 
- * For flexibility, this example is implemented using posix api.
- * In a real embedded system you would typically use some other kind of
- * a communication and filesystem layer.
- */
-
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#include <dirent.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <pb_encode.h>
-#include <pb_decode.h>
-
-#include "fileproto.pb.h"
-#include "common.h"
-
-/* This callback function will be called once for each filename received
- * from the server. The filenames will be printed out immediately, so that
- * no memory has to be allocated for them.
- */
-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);
-    
-    return true;
-}
-
-/* This function sends a request to socket 'fd' to list the files in
- * directory given in 'path'. The results received from server will
- * be printed to stdout.
- */
-bool listdir(int fd, char *path)
-{
-    /* Construct and send the request to server */
-    {
-        ListFilesRequest request = {};
-        pb_ostream_t output = pb_ostream_from_socket(fd);
-        uint8_t zero = 0;
-        
-        /* In our protocol, path is optional. If it is not given,
-         * the server will list the root directory. */
-        if (path == NULL)
-        {
-            request.has_path = false;
-        }
-        else
-        {
-            request.has_path = true;
-            if (strlen(path) + 1 > sizeof(request.path))
-            {
-                fprintf(stderr, "Too long path.\n");
-                return false;
-            }
-            
-            strcpy(request.path, path);
-        }
-        
-        /* Encode the request. It is written to the socket immediately
-         * through our custom stream. */
-        if (!pb_encode(&output, ListFilesRequest_fields, &request))
-        {
-            fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&output));
-            return false;
-        }
-        
-        /* We signal the end of request with a 0 tag. */
-        pb_write(&output, &zero, 1);
-    }
-    
-    /* Read back the response from server */
-    {
-        ListFilesResponse response = {};
-        pb_istream_t input = pb_istream_from_socket(fd);
-        
-        /* Give a pointer to our callback function, which will handle the
-         * filenames as they arrive. */
-        response.file.funcs.decode = &printfile_callback;
-        
-        if (!pb_decode(&input, ListFilesResponse_fields, &response))
-        {
-            fprintf(stderr, "Decode failed: %s\n", PB_GET_ERROR(&input));
-            return false;
-        }
-        
-        /* If the message from server decodes properly, but directory was
-         * not found on server side, we get path_error == true. */
-        if (response.path_error)
-        {
-            fprintf(stderr, "Server reported error.\n");
-            return false;
-        }
-    }
-    
-    return true;
-}
-
-int main(int argc, char **argv)
-{
-    int sockfd;
-    struct sockaddr_in servaddr;
-    char *path = NULL;
-    
-    if (argc > 1)
-        path = argv[1];
-    
-    sockfd = socket(AF_INET, SOCK_STREAM, 0);
-    
-    /* Connect to server running on localhost:1234 */
-    memset(&servaddr, 0, sizeof(servaddr));
-    servaddr.sin_family = AF_INET;
-    servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-    servaddr.sin_port = htons(1234);
-    
-    if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) != 0)
-    {
-        perror("connect");
-        return 1;
-    }
-    
-    /* Send the directory listing request */
-    if (!listdir(sockfd, path))
-        return 2;
-    
-    /* Close connection */
-    close(sockfd);
-    
-    return 0;
-}

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

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;
-}
-

examples/simple/Makefile

@@ -1,21 +0,0 @@
-# Include the nanopb provided Makefile rules
-include ../../extra/nanopb.mk
-
-# Compiler flags to enable all warnings & debug info
-CFLAGS = -Wall -Werror -g -O0
-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) $(PROTOC_OPTS) --nanopb_out=. simple.proto
-

examples/simple/README.txt

@@ -1,29 +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 command::
-
-  ../../generator-bin/protoc --nanopb_out=. simple.proto
-
-After that, add the following four files to your project and compile:
-
-  simple.c  simple.pb.c  pb_encode.c  pb_decode.c
-
-

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;
-}
-

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;
-}
-

examples/using_double_on_avr/Makefile

@@ -1,24 +0,0 @@
-# Include the nanopb provided Makefile rules
-include ../../extra/nanopb.mk
-
-# Compiler flags to enable all warnings & debug info
-CFLAGS = -Wall -Werror -g -O0
-CFLAGS += -I$(NANOPB_DIR)
-
-all: run_tests
-
-.SUFFIXES:
-
-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 double_conversion.c doubleproto.pb.c
-	$(CC) $(CFLAGS) -o $@ $^ $(NANOPB_CORE)
-
-run_tests: test_conversions encode_double decode_double
-	./test_conversions
-	./encode_double | ./decode_double
-    

examples/using_union_messages/Makefile

@@ -1,20 +0,0 @@
-# Include the nanopb provided Makefile rules
-include ../../extra/nanopb.mk
-
-# Compiler flags to enable all warnings & debug info
-CFLAGS = -ansi -Wall -Werror -g -O0
-CFLAGS += -I$(NANOPB_DIR)
-
-all: encode decode
-	./encode 1 | ./decode
-	./encode 2 | ./decode
-	./encode 3 | ./decode
-
-.SUFFIXES:
-
-clean:
-	rm -f encode unionproto.pb.h unionproto.pb.c
-
-%: %.c unionproto.pb.c
-	$(CC) $(CFLAGS) -o $@ $^ $(NANOPB_CORE)
-

examples/using_union_messages/README.txt

@@ -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.
-

extra/FindNanopb.cmake

@@ -1,225 +0,0 @@
-# This is an example script for use with CMake projects for locating and configuring
-# 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 "${CMAKE_CURRENT_BINARY_DIR}/${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
-  )

extra/nanopb.mk

@@ -1,37 +0,0 @@
-# This is an include file for Makefiles. It provides rules for building
-# .pb.c and .pb.h files out of .proto, as well the path to nanopb core.
-
-# Path to the nanopb root directory
-NANOPB_DIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST)))../)
-
-# Files for the nanopb core
-NANOPB_CORE = $(NANOPB_DIR)/pb_encode.c $(NANOPB_DIR)/pb_decode.c
-
-# Check if we are running on Windows
-ifdef windir
-WINDOWS = 1
-endif
-ifdef WINDIR
-WINDOWS = 1
-endif
-
-# Check whether to use binary version of nanopb_generator or the
-# system-supplied python interpreter.
-ifneq "$(wildcard $(NANOPB_DIR)/generator-bin)" ""
-	# Binary package
-	PROTOC = $(NANOPB_DIR)/generator-bin/protoc
-	PROTOC_OPTS = 
-else
-	# Source only or git checkout
-	PROTOC = protoc
-	ifdef WINDOWS
-		PROTOC_OPTS = --plugin=protoc-gen-nanopb=$(NANOPB_DIR)/generator/protoc-gen-nanopb.bat
-	else
-		PROTOC_OPTS = --plugin=protoc-gen-nanopb=$(NANOPB_DIR)/generator/protoc-gen-nanopb
-	endif
-endif
-
-# Rule for building .pb.c and .pb.h
-%.pb.c %.pb.h: %.proto $(wildcard %.options)
-	$(PROTOC) $(PROTOC_OPTS) --nanopb_out=. $<
-

extra/pb_syshdr.h

@@ -1,104 +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
- * extra 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
-
-/* stdlib.h subset */
-#ifdef PB_ENABLE_MALLOC
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#else
-void *realloc(void *ptr, size_t size);
-void free(void *ptr);
-#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

generator/Makefile

@@ -0,0 +1,2 @@
+nanopb_pb2.py: nanopb.proto
+	protoc --python_out=. -I /usr/include -I . nanopb.proto

generator/nanopb.proto

@@ -12,14 +12,10 @@ 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_POINTER = 4; // Always generate a dynamically allocated 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;
@@ -34,17 +30,9 @@ message NanoPBOptions {
   optional bool long_names = 4 [default = true];
   
   // Add 'packed' attribute to generated structs.
-  // Note: this cannot be used on CPUs that break on unaligned
-  // accesses to variables.
   optional bool packed_struct = 5 [default = false];
-  
-  // Skip this message
-  optional bool skip_message = 6 [default = false];
 }
 
-// Extensions to protoc 'Descriptor' type in order to define options
-// inside a .proto file.
-//
 // Protocol Buffers extension number registry
 // --------------------------------
 // Project:  Nanopb

generator/nanopb_pb2.py

@@ -0,0 +1,158 @@
+# 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='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')
+
+_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,
+  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)
+
+
+_NANOPBOPTIONS = descriptor.Descriptor(
+  name='NanoPBOptions',
+  full_name='NanoPBOptions',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='max_size', full_name='NanoPBOptions.max_size', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='max_count', full_name='NanoPBOptions.max_count', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      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=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=51,
+  serialized_end=197,
+)
+
+_NANOPBOPTIONS.fields_by_name['type'].enum_type = _FIELDTYPE
+DESCRIPTOR.message_types_by_name['NanoPBOptions'] = _NANOPBOPTIONS
+
+class NanoPBOptions(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _NANOPBOPTIONS
+  
+  # @@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)

generator/proto/Makefile

@@ -1,4 +0,0 @@
-all: nanopb_pb2.py plugin_pb2.py
-
-%_pb2.py: %.proto
-	protoc --python_out=. $<

generator/proto/google/protobuf/descriptor.proto

@@ -1,620 +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)
-//  Based on original Protocol Buffers design by
-//  Sanjay Ghemawat, Jeff Dean, and others.
-//
-// The messages in this file describe the definitions found in .proto files.
-// A valid .proto file can be translated directly to a FileDescriptorProto
-// without any other information (e.g. without reading its imports).
-
-
-
-package google.protobuf;
-option java_package = "com.google.protobuf";
-option java_outer_classname = "DescriptorProtos";
-
-// descriptor.proto must be optimized for speed because reflection-based
-// algorithms don't work during bootstrapping.
-option optimize_for = SPEED;
-
-// The protocol compiler can output a FileDescriptorSet containing the .proto
-// files it parses.
-message FileDescriptorSet {
-  repeated FileDescriptorProto file = 1;
-}
-
-// Describes a complete .proto file.
-message FileDescriptorProto {
-  optional string name = 1;       // file name, relative to root of source tree
-  optional string package = 2;    // e.g. "foo", "foo.bar", etc.
-
-  // Names of files imported by this file.
-  repeated string dependency = 3;
-  // Indexes of the public imported files in the dependency list above.
-  repeated int32 public_dependency = 10;
-  // Indexes of the weak imported files in the dependency list.
-  // For Google-internal migration only. Do not use.
-  repeated int32 weak_dependency = 11;
-
-  // All top-level definitions in this file.
-  repeated DescriptorProto message_type = 4;
-  repeated EnumDescriptorProto enum_type = 5;
-  repeated ServiceDescriptorProto service = 6;
-  repeated FieldDescriptorProto extension = 7;
-
-  optional FileOptions options = 8;
-
-  // This field contains optional information about the original source code.
-  // You may safely remove this entire field whithout harming runtime
-  // functionality of the descriptors -- the information is needed only by
-  // development tools.
-  optional SourceCodeInfo source_code_info = 9;
-}
-
-// Describes a message type.
-message DescriptorProto {
-  optional string name = 1;
-
-  repeated FieldDescriptorProto field = 2;
-  repeated FieldDescriptorProto extension = 6;
-
-  repeated DescriptorProto nested_type = 3;
-  repeated EnumDescriptorProto enum_type = 4;
-
-  message ExtensionRange {
-    optional int32 start = 1;
-    optional int32 end = 2;
-  }
-  repeated ExtensionRange extension_range = 5;
-
-  optional MessageOptions options = 7;
-}
-
-// Describes a field within a message.
-message FieldDescriptorProto {
-  enum Type {
-    // 0 is reserved for errors.
-    // Order is weird for historical reasons.
-    TYPE_DOUBLE         = 1;
-    TYPE_FLOAT          = 2;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-    // negative values are likely.
-    TYPE_INT64          = 3;
-    TYPE_UINT64         = 4;
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-    // negative values are likely.
-    TYPE_INT32          = 5;
-    TYPE_FIXED64        = 6;
-    TYPE_FIXED32        = 7;
-    TYPE_BOOL           = 8;
-    TYPE_STRING         = 9;
-    TYPE_GROUP          = 10;  // Tag-delimited aggregate.
-    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
-
-    // New in version 2.
-    TYPE_BYTES          = 12;
-    TYPE_UINT32         = 13;
-    TYPE_ENUM           = 14;
-    TYPE_SFIXED32       = 15;
-    TYPE_SFIXED64       = 16;
-    TYPE_SINT32         = 17;  // Uses ZigZag encoding.
-    TYPE_SINT64         = 18;  // Uses ZigZag encoding.
-  };
-
-  enum Label {
-    // 0 is reserved for errors
-    LABEL_OPTIONAL      = 1;
-    LABEL_REQUIRED      = 2;
-    LABEL_REPEATED      = 3;
-    // TODO(sanjay): Should we add LABEL_MAP?
-  };
-
-  optional string name = 1;
-  optional int32 number = 3;
-  optional Label label = 4;
-
-  // If type_name is set, this need not be set.  If both this and type_name
-  // are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
-  optional Type type = 5;
-
-  // For message and enum types, this is the name of the type.  If the name
-  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
-  // rules are used to find the type (i.e. first the nested types within this
-  // message are searched, then within the parent, on up to the root
-  // namespace).
-  optional string type_name = 6;
-
-  // For extensions, this is the name of the type being extended.  It is
-  // resolved in the same manner as type_name.
-  optional string extendee = 2;
-
-  // For numeric types, contains the original text representation of the value.
-  // For booleans, "true" or "false".
-  // For strings, contains the default text contents (not escaped in any way).
-  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
-  // TODO(kenton):  Base-64 encode?
-  optional string default_value = 7;
-
-  optional FieldOptions options = 8;
-}
-
-// Describes an enum type.
-message EnumDescriptorProto {
-  optional string name = 1;
-
-  repeated EnumValueDescriptorProto value = 2;
-
-  optional EnumOptions options = 3;
-}
-
-// Describes a value within an enum.
-message EnumValueDescriptorProto {
-  optional string name = 1;
-  optional int32 number = 2;
-
-  optional EnumValueOptions options = 3;
-}
-
-// Describes a service.
-message ServiceDescriptorProto {
-  optional string name = 1;
-  repeated MethodDescriptorProto method = 2;
-
-  optional ServiceOptions options = 3;
-}
-
-// Describes a method of a service.
-message MethodDescriptorProto {
-  optional string name = 1;
-
-  // Input and output type names.  These are resolved in the same way as
-  // FieldDescriptorProto.type_name, but must refer to a message type.
-  optional string input_type = 2;
-  optional string output_type = 3;
-
-  optional MethodOptions options = 4;
-}
-
-
-// ===================================================================
-// Options
-
-// Each of the definitions above may have "options" attached.  These are
-// just annotations which may cause code to be generated slightly differently
-// or may contain hints for code that manipulates protocol messages.
-//
-// Clients may define custom options as extensions of the *Options messages.
-// These extensions may not yet be known at parsing time, so the parser cannot
-// store the values in them.  Instead it stores them in a field in the *Options
-// message called uninterpreted_option. This field must have the same name
-// across all *Options messages. We then use this field to populate the
-// extensions when we build a descriptor, at which point all protos have been
-// parsed and so all extensions are known.
-//
-// Extension numbers for custom options may be chosen as follows:
-// * For options which will only be used within a single application or
-//   organization, or for experimental options, use field numbers 50000
-//   through 99999.  It is up to you to ensure that you do not use the
-//   same number for multiple options.
-// * For options which will be published and used publicly by multiple
-//   independent entities, e-mail protobuf-global-extension-registry@google.com
-//   to reserve extension numbers. Simply provide your project name (e.g.
-//   Object-C plugin) and your porject website (if available) -- there's no need
-//   to explain how you intend to use them. Usually you only need one extension
-//   number. You can declare multiple options with only one extension number by
-//   putting them in a sub-message. See the Custom Options section of the docs
-//   for examples:
-//   http://code.google.com/apis/protocolbuffers/docs/proto.html#options
-//   If this turns out to be popular, a web service will be set up
-//   to automatically assign option numbers.
-
-
-message FileOptions {
-
-  // Sets the Java package where classes generated from this .proto will be
-  // placed.  By default, the proto package is used, but this is often
-  // inappropriate because proto packages do not normally start with backwards
-  // domain names.
-  optional string java_package = 1;
-
-
-  // If set, all the classes from the .proto file are wrapped in a single
-  // outer class with the given name.  This applies to both Proto1
-  // (equivalent to the old "--one_java_file" option) and Proto2 (where
-  // a .proto always translates to a single class, but you may want to
-  // explicitly choose the class name).
-  optional string java_outer_classname = 8;
-
-  // If set true, then the Java code generator will generate a separate .java
-  // file for each top-level message, enum, and service defined in the .proto
-  // file.  Thus, these types will *not* be nested inside the outer class
-  // named by java_outer_classname.  However, the outer class will still be
-  // generated to contain the file's getDescriptor() method as well as any
-  // top-level extensions defined in the file.
-  optional bool java_multiple_files = 10 [default=false];
-
-  // If set true, then the Java code generator will generate equals() and
-  // hashCode() methods for all messages defined in the .proto file. This is
-  // purely a speed optimization, as the AbstractMessage base class includes
-  // reflection-based implementations of these methods.
-  optional bool java_generate_equals_and_hash = 20 [default=false];
-
-  // Generated classes can be optimized for speed or code size.
-  enum OptimizeMode {
-    SPEED = 1;        // Generate complete code for parsing, serialization,
-                      // etc.
-    CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
-    LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
-  }
-  optional OptimizeMode optimize_for = 9 [default=SPEED];
-
-  // Sets the Go package where structs generated from this .proto will be
-  // placed.  There is no default.
-  optional string go_package = 11;
-
-
-
-  // Should generic services be generated in each language?  "Generic" services
-  // are not specific to any particular RPC system.  They are generated by the
-  // main code generators in each language (without additional plugins).
-  // Generic services were the only kind of service generation supported by
-  // early versions of proto2.
-  //
-  // Generic services are now considered deprecated in favor of using plugins
-  // that generate code specific to your particular RPC system.  Therefore,
-  // these default to false.  Old code which depends on generic services should
-  // explicitly set them to true.
-  optional bool cc_generic_services = 16 [default=false];
-  optional bool java_generic_services = 17 [default=false];
-  optional bool py_generic_services = 18 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message MessageOptions {
-  // Set true to use the old proto1 MessageSet wire format for extensions.
-  // This is provided for backwards-compatibility with the MessageSet wire
-  // format.  You should not use this for any other reason:  It's less
-  // efficient, has fewer features, and is more complicated.
-  //
-  // The message must be defined exactly as follows:
-  //   message Foo {
-  //     option message_set_wire_format = true;
-  //     extensions 4 to max;
-  //   }
-  // Note that the message cannot have any defined fields; MessageSets only
-  // have extensions.
-  //
-  // All extensions of your type must be singular messages; e.g. they cannot
-  // be int32s, enums, or repeated messages.
-  //
-  // Because this is an option, the above two restrictions are not enforced by
-  // the protocol compiler.
-  optional bool message_set_wire_format = 1 [default=false];
-
-  // Disables the generation of the standard "descriptor()" accessor, which can
-  // conflict with a field of the same name.  This is meant to make migration
-  // from proto1 easier; new code should avoid fields named "descriptor".
-  optional bool no_standard_descriptor_accessor = 2 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message FieldOptions {
-  // The ctype option instructs the C++ code generator to use a different
-  // representation of the field than it normally would.  See the specific
-  // options below.  This option is not yet implemented in the open source
-  // release -- sorry, we'll try to include it in a future version!
-  optional CType ctype = 1 [default = STRING];
-  enum CType {
-    // Default mode.
-    STRING = 0;
-
-    CORD = 1;
-
-    STRING_PIECE = 2;
-  }
-  // The packed option can be enabled for repeated primitive fields to enable
-  // a more efficient representation on the wire. Rather than repeatedly
-  // writing the tag and type for each element, the entire array is encoded as
-  // a single length-delimited blob.
-  optional bool packed = 2;
-
-
-
-  // Should this field be parsed lazily?  Lazy applies only to message-type
-  // fields.  It means that when the outer message is initially parsed, the
-  // inner message's contents will not be parsed but instead stored in encoded
-  // form.  The inner message will actually be parsed when it is first accessed.
-  //
-  // This is only a hint.  Implementations are free to choose whether to use
-  // eager or lazy parsing regardless of the value of this option.  However,
-  // setting this option true suggests that the protocol author believes that
-  // using lazy parsing on this field is worth the additional bookkeeping
-  // overhead typically needed to implement it.
-  //
-  // This option does not affect the public interface of any generated code;
-  // all method signatures remain the same.  Furthermore, thread-safety of the
-  // interface is not affected by this option; const methods remain safe to
-  // call from multiple threads concurrently, while non-const methods continue
-  // to require exclusive access.
-  //
-  //
-  // Note that implementations may choose not to check required fields within
-  // a lazy sub-message.  That is, calling IsInitialized() on the outher message
-  // may return true even if the inner message has missing required fields.
-  // This is necessary because otherwise the inner message would have to be
-  // parsed in order to perform the check, defeating the purpose of lazy
-  // parsing.  An implementation which chooses not to check required fields
-  // must be consistent about it.  That is, for any particular sub-message, the
-  // implementation must either *always* check its required fields, or *never*
-  // check its required fields, regardless of whether or not the message has
-  // been parsed.
-  optional bool lazy = 5 [default=false];
-
-  // Is this field deprecated?
-  // Depending on the target platform, this can emit Deprecated annotations
-  // for accessors, or it will be completely ignored; in the very least, this
-  // is a formalization for deprecating fields.
-  optional bool deprecated = 3 [default=false];
-
-  // EXPERIMENTAL.  DO NOT USE.
-  // For "map" fields, the name of the field in the enclosed type that
-  // is the key for this map.  For example, suppose we have:
-  //   message Item {
-  //     required string name = 1;
-  //     required string value = 2;
-  //   }
-  //   message Config {
-  //     repeated Item items = 1 [experimental_map_key="name"];
-  //   }
-  // In this situation, the map key for Item will be set to "name".
-  // TODO: Fully-implement this, then remove the "experimental_" prefix.
-  optional string experimental_map_key = 9;
-
-  // For Google-internal migration only. Do not use.
-  optional bool weak = 10 [default=false];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumOptions {
-
-  // Set this option to false to disallow mapping different tag names to a same
-  // value.
-  optional bool allow_alias = 2 [default=true];
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message EnumValueOptions {
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message ServiceOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-message MethodOptions {
-
-  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
-  //   framework.  We apologize for hoarding these numbers to ourselves, but
-  //   we were already using them long before we decided to release Protocol
-  //   Buffers.
-
-  // The parser stores options it doesn't recognize here. See above.
-  repeated UninterpretedOption uninterpreted_option = 999;
-
-  // Clients can define custom options in extensions of this message. See above.
-  extensions 1000 to max;
-}
-
-
-// A message representing a option the parser does not recognize. This only
-// appears in options protos created by the compiler::Parser class.
-// DescriptorPool resolves these when building Descriptor objects. Therefore,
-// options protos in descriptor objects (e.g. returned by Descriptor::options(),
-// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
-// in them.
-message UninterpretedOption {
-  // The name of the uninterpreted option.  Each string represents a segment in
-  // a dot-separated name.  is_extension is true iff a segment represents an
-  // extension (denoted with parentheses in options specs in .proto files).
-  // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
-  // "foo.(bar.baz).qux".
-  message NamePart {
-    required string name_part = 1;
-    required bool is_extension = 2;
-  }
-  repeated NamePart name = 2;
-
-  // The value of the uninterpreted option, in whatever type the tokenizer
-  // identified it as during parsing. Exactly one of these should be set.
-  optional string identifier_value = 3;
-  optional uint64 positive_int_value = 4;
-  optional int64 negative_int_value = 5;
-  optional double double_value = 6;
-  optional bytes string_value = 7;
-  optional string aggregate_value = 8;
-}
-
-// ===================================================================
-// Optional source code info
-
-// Encapsulates information about the original source file from which a
-// FileDescriptorProto was generated.
-message SourceCodeInfo {
-  // A Location identifies a piece of source code in a .proto file which
-  // corresponds to a particular definition.  This information is intended
-  // to be useful to IDEs, code indexers, documentation generators, and similar
-  // tools.
-  //
-  // For example, say we have a file like:
-  //   message Foo {
-  //     optional string foo = 1;
-  //   }
-  // Let's look at just the field definition:
-  //   optional string foo = 1;
-  //   ^       ^^     ^^  ^  ^^^
-  //   a       bc     de  f  ghi
-  // We have the following locations:
-  //   span   path               represents
-  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
-  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
-  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
-  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
-  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
-  //
-  // Notes:
-  // - A location may refer to a repeated field itself (i.e. not to any
-  //   particular index within it).  This is used whenever a set of elements are
-  //   logically enclosed in a single code segment.  For example, an entire
-  //   extend block (possibly containing multiple extension definitions) will
-  //   have an outer location whose path refers to the "extensions" repeated
-  //   field without an index.
-  // - Multiple locations may have the same path.  This happens when a single
-  //   logical declaration is spread out across multiple places.  The most
-  //   obvious example is the "extend" block again -- there may be multiple
-  //   extend blocks in the same scope, each of which will have the same path.
-  // - A location's span is not always a subset of its parent's span.  For
-  //   example, the "extendee" of an extension declaration appears at the
-  //   beginning of the "extend" block and is shared by all extensions within
-  //   the block.
-  // - Just because a location's span is a subset of some other location's span
-  //   does not mean that it is a descendent.  For example, a "group" defines
-  //   both a type and a field in a single declaration.  Thus, the locations
-  //   corresponding to the type and field and their components will overlap.
-  // - Code which tries to interpret locations should probably be designed to
-  //   ignore those that it doesn't understand, as more types of locations could
-  //   be recorded in the future.
-  repeated Location location = 1;
-  message Location {
-    // Identifies which part of the FileDescriptorProto was defined at this
-    // location.
-    //
-    // Each element is a field number or an index.  They form a path from
-    // the root FileDescriptorProto to the place where the definition.  For
-    // example, this path:
-    //   [ 4, 3, 2, 7, 1 ]
-    // refers to:
-    //   file.message_type(3)  // 4, 3
-    //       .field(7)         // 2, 7
-    //       .name()           // 1
-    // This is because FileDescriptorProto.message_type has field number 4:
-    //   repeated DescriptorProto message_type = 4;
-    // and DescriptorProto.field has field number 2:
-    //   repeated FieldDescriptorProto field = 2;
-    // and FieldDescriptorProto.name has field number 1:
-    //   optional string name = 1;
-    //
-    // Thus, the above path gives the location of a field name.  If we removed
-    // the last element:
-    //   [ 4, 3, 2, 7 ]
-    // this path refers to the whole field declaration (from the beginning
-    // of the label to the terminating semicolon).
-    repeated int32 path = 1 [packed=true];
-
-    // Always has exactly three or four elements: start line, start column,
-    // end line (optional, otherwise assumed same as start line), end column.
-    // These are packed into a single field for efficiency.  Note that line
-    // and column numbers are zero-based -- typically you will want to add
-    // 1 to each before displaying to a user.
-    repeated int32 span = 2 [packed=true];
-
-    // If this SourceCodeInfo represents a complete declaration, these are any
-    // comments appearing before and after the declaration which appear to be
-    // attached to the declaration.
-    //
-    // A series of line comments appearing on consecutive lines, with no other
-    // tokens appearing on those lines, will be treated as a single comment.
-    //
-    // Only the comment content is provided; comment markers (e.g. //) are
-    // stripped out.  For block comments, leading whitespace and an asterisk
-    // will be stripped from the beginning of each line other than the first.
-    // Newlines are included in the output.
-    //
-    // Examples:
-    //
-    //   optional int32 foo = 1;  // Comment attached to foo.
-    //   // Comment attached to bar.
-    //   optional int32 bar = 2;
-    //
-    //   optional string baz = 3;
-    //   // Comment attached to baz.
-    //   // Another line attached to baz.
-    //
-    //   // Comment attached to qux.
-    //   //
-    //   // Another line attached to qux.
-    //   optional double qux = 4;
-    //
-    //   optional string corge = 5;
-    //   /* Block comment attached
-    //    * to corge.  Leading asterisks
-    //    * will be removed. */
-    //   /* Block comment attached to
-    //    * grault. */
-    //   optional int32 grault = 6;
-    optional string leading_comments = 3;
-    optional string trailing_comments = 4;
-  }
-}

generator/proto/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;
-}

generator/protoc-gen-nanopb

@@ -1,13 +0,0 @@
-#!/bin/sh
-
-# This file is used to invoke nanopb_generator.py as a plugin
-# to protoc on Linux and other *nix-style systems.
-# Use it like this:
-# protoc --plugin=nanopb=..../protoc-gen-nanopb --nanopb_out=dir foo.proto
-#
-# Note that if you use the binary package of nanopb, the protoc
-# path is already set up properly and there is no need to give
-# --plugin= on the command line.
-
-MYPATH=$(dirname "$0")
-exec python "$MYPATH/nanopb_generator.py" --protoc-plugin

generator/protoc-gen-nanopb.bat

@@ -1,12 +0,0 @@
-@echo off
-:: This file is used to invoke nanopb_generator.py as a plugin
-:: to protoc on Windows.
-:: Use it like this:
-:: protoc --plugin=nanopb=..../protoc-gen-nanopb.bat --nanopb_out=dir foo.proto
-::
-:: Note that if you use the binary package of nanopb, the protoc
-:: path is already set up properly and there is no need to give
-:: --plugin= on the command line.
-
-set mydir=%~dp0
-python "%mydir%\nanopb_generator.py" --protoc-plugin

pb.h

@@ -1,123 +1,40 @@
-/* Common parts of the nanopb library. Most of these are quite low-level
- * stuff. For the high-level interface, see pb_encode.h and pb_decode.h.
- */
-
 #ifndef _PB_H_
 #define _PB_H_
 
-/*****************************************************************
- * Nanopb compilation time options. You can change these here by *
- * uncommenting the lines, or on the compiler command line.      *
- *****************************************************************/
-
-/* Enable support for dynamically allocated fields */
-/* #define PB_ENABLE_MALLOC 1 */
-
-/* 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.9.1
-
-/* Include all the system headers needed by nanopb. You will need the
- * definitions of the following:
- * - strlen, memcpy, memset functions
- * - [u]int8_t, [u]int16_t, [u]int32_t, [u]int64_t
- * - size_t
- * - bool
- *
- * If you don't have the standard header files, you can instead provide
- * a custom header that defines or includes all this. In that case,
- * define PB_SYSTEM_HEADER to the path of this file.
+/* pb.h: Common parts for nanopb library.
+ * Most of these are quite low-level stuff. For the high-level interface,
+ * see pb_encode.h or pb_decode.h
  */
-#ifdef PB_SYSTEM_HEADER
-#include PB_SYSTEM_HEADER
-#else
+
+#define NANOPB_VERSION nanopb-0.1.9.1
+
 #include <stdint.h>
 #include <stddef.h>
 #include <stdbool.h>
-#include <string.h>
 
-#ifdef PB_ENABLE_MALLOC
-#include <stdlib.h>
-#endif
-#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__) || defined(__CC_ARM)
-    /* For IAR ARM and Keil MDK-ARM compilers */
-#   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
+#ifdef __GNUC__
+/* This just reduces memory requirements, but is not required. */
+#define pb_packed __attribute__((packed))
 #else
-    /* Unknown compiler */
-#   define PB_PACKED_STRUCT_START
-#   define PB_PACKED_STRUCT_END
-#   define pb_packed
+#define pb_packed
 #endif
 
-/* Handly macro for suppressing unreferenced-parameter compiler warnings. */
+/* 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 does not work properly on your compiler, use #define STATIC_ASSERT
- * to disable it.
- *
- * But before doing that, check carefully the error message / place where it
- * comes from to see if the error has a real cause. Unfortunately the error
- * message is not always very clear to read, but you can see the reason better
- * in the place where the STATIC_ASSERT macro was called.
- */
+ * 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. */
+/* Number of required fields to keep track of
+ * (change here or on compiler command line). */
 #ifndef PB_MAX_REQUIRED_FIELDS
 #define PB_MAX_REQUIRED_FIELDS 64
 #endif
@@ -129,74 +46,70 @@
 /* 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;
+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,
+    PB_LTYPE_MASK = 0x0F,
+    
+    /******************
+     * 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 valid or 0 (it is ignored, but
+     * sometimes used to speculatively index an array). */
+    PB_HTYPE_CALLBACK = 0x30,
+    
+    PB_HTYPE_MASK = 0xF0
+} pb_packed pb_type_t;
 
-/**** Field data types ****/
-
-/* Numeric types */
-#define PB_LTYPE_VARINT  0x00 /* int32, int64, enum, bool */
-#define PB_LTYPE_UVARINT 0x01 /* uint32, uint64 */
-#define PB_LTYPE_SVARINT 0x02 /* sint32, sint64 */
-#define PB_LTYPE_FIXED32 0x03 /* fixed32, sfixed32, float */
-#define PB_LTYPE_FIXED64 0x04 /* fixed64, sfixed64, double */
-
-/* Marker for last packable field type. */
-#define PB_LTYPE_LAST_PACKABLE 0x04
-
-/* Byte array with pre-allocated buffer.
- * data_size is the length of the allocated PB_BYTES_ARRAY structure. */
-#define PB_LTYPE_BYTES 0x05
-
-/* String with pre-allocated buffer.
- * data_size is the maximum length. */
-#define PB_LTYPE_STRING 0x06
-
-/* Submessage
- * submsg_fields is pointer to field descriptions */
-#define PB_LTYPE_SUBMESSAGE 0x07
-
-/* Extension pseudo-field
- * The field contains a pointer to pb_extension_t */
-#define PB_LTYPE_EXTENSION 0x08
-
-/* Number of declared LTYPES */
-#define PB_LTYPES_COUNT 9
-#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_POINTER  0x80
-#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)
 
-/* Data type used for storing sizes of struct fields
- * and array counts.
- */
-#if defined(PB_FIELD_32BIT)
-    typedef uint32_t pb_size_t;
-    typedef int32_t pb_ssize_t;
-#elif defined(PB_FIELD_16BIT)
-    typedef uint16_t pb_size_t;
-    typedef int16_t pb_ssize_t;
-#else
-    typedef uint8_t pb_size_t;
-    typedef int8_t pb_ssize_t;
-#endif
-
 /* This structure is used in auto-generated constants
  * to specify struct fields.
  * You can change field sizes if you need structures
@@ -205,49 +118,47 @@ typedef uint8_t pb_type_t;
  * 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 {
-    pb_size_t tag;
+
+#if !defined(PB_FIELD_16BIT) && !defined(PB_FIELD_32BIT)
+    uint8_t tag;
     pb_type_t type;
-    pb_size_t data_offset; /* Offset of field data, relative to previous field. */
-    pb_ssize_t size_offset; /* Offset of array size or has-boolean, relative to data */
-    pb_size_t data_size; /* Data size in bytes for a single item */
-    pb_size_t array_size; /* Maximum number of entries in array */
+    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.
- *
- * If you get errors here, it probably means that your stdint.h is not
- * correct for your platform.
- */
-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.
  */
-#define PB_BYTES_ARRAY_T(n) struct { size_t size; uint8_t bytes[n]; }
-#define PB_BYTES_ARRAY_T_ALLOCSIZE(n) ((size_t)n + offsetof(pb_bytes_array_t, bytes))
-
 struct _pb_bytes_array_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.
@@ -272,19 +183,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;
@@ -298,201 +200,13 @@ 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;
-
-    /* The decoder sets this to true if the extension was found.
-     * Ignored for encoding. */
-    bool found;
-};
-
-/* Memory allocation functions to use. You can define pb_realloc and
- * pb_free to custom functions if you want. */
-#ifdef PB_ENABLE_MALLOC
-#   ifndef pb_realloc
-#       define pb_realloc(ptr, size) realloc(ptr, size)
-#   endif
-#   ifndef pb_free
-#       define pb_free(ptr) free(ptr)
-#   endif
-#endif
-
 /* 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_delta_end(st, m1, m2) (offsetof(st, m1) - offsetof(st, m2) - pb_membersize(st, m2))
 #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}
-
-/* Allocated fields carry the size of the actual data, not the pointer */
-#define PB_REQUIRED_POINTER(tag, st, m, fd, ltype, ptr) \
-    {tag, PB_ATYPE_POINTER | PB_HTYPE_REQUIRED | ltype, \
-    fd, 0, pb_membersize(st, m[0]), 0, ptr}
-
-/* Optional fields don't need a has_ variable, as information would be redundant */
-#define PB_OPTIONAL_POINTER(tag, st, m, fd, ltype, ptr) \
-    {tag, PB_ATYPE_POINTER | PB_HTYPE_OPTIONAL | ltype, \
-    fd, 0, pb_membersize(st, m[0]), 0, ptr}
-
-/* Repeated fields have a _count field and a pointer to array of pointers */
-#define PB_REPEATED_POINTER(tag, st, m, fd, ltype, ptr) \
-    {tag, PB_ATYPE_POINTER | PB_HTYPE_REPEATED | ltype, \
-    fd, pb_delta(st, m ## _count, m), \
-    pb_membersize(st, m[0]), 0, 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_UVARINT
-#define PB_LTYPE_MAP_UINT64     PB_LTYPE_UVARINT
-#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.
@@ -500,11 +214,7 @@ struct _pb_extension_t {
  * messages if not used.
  */
 #ifdef PB_NO_ERRMSG
-#define PB_RETURN_ERROR(stream,msg) \
-    do {\
-        UNUSED(stream); \
-        return false; \
-    } while(0)
+#define PB_RETURN_ERROR(stream,msg) return false
 #define PB_GET_ERROR(stream) "(errmsg disabled)"
 #else
 #define PB_RETURN_ERROR(stream,msg) \

pb_decode.h

@@ -1,29 +1,34 @@
-/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
- * The main function is pb_decode. You also need an input stream, and the
- * field descriptions created by nanopb_generator.py.
- */
-
 #ifndef _PB_DECODE_H_
 #define _PB_DECODE_H_
 
+/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
+ * The main function is pb_decode. You will also need to create an input
+ * stream, which is easiest to do with pb_istream_from_buffer().
+ * 
+ * You also need structures and their corresponding pb_field_t descriptions.
+ * These are usually generated from .proto-files with a script.
+ */
+
+#include <stdbool.h>
 #include "pb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* 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.
+/* Lightweight input stream.
+ * You can provide a callback function for reading or use
+ * pb_istream_from_buffer.
  * 
- * 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.
+ * and rely on pb_read to verify that no-body reads past bytes_left.
+ * 
  * 3) Your callback may be used with substreams, in which case bytes_left
- *    is different than from the main stream. Don't use bytes_left to compute
- *    any pointers.
+ * is different than from the main stream. Don't use bytes_left to compute
+ * any pointers.
  */
 struct _pb_istream_t
 {
@@ -45,75 +50,24 @@ struct _pb_istream_t
 #endif
 };
 
-/***************************
- * Main decoding functions *
- ***************************/
- 
-/* Decode a single protocol buffers message from input stream into a C structure.
+pb_istream_t pb_istream_from_buffer(uint8_t *buf, size_t bufsize);
+bool pb_read(pb_istream_t *stream, uint8_t *buf, size_t count);
+
+/* 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.
- * 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.
- *
- * Note: If this function returns with an error, it will not release any
- * dynamically allocated fields. You will need to call pb_release() yourself.
  */
 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.
+/* --- Helper functions ---
+ * You may want to use these from your caller or callbacks.
  */
-bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct);
-
-#ifdef PB_ENABLE_MALLOC
-/* Release any allocated pointer fields. If you use dynamic allocation, you should
- * call this for any successfully decoded message when you are done with it. If
- * pb_decode() returns with an error, the message is already released.
- */
-void pb_release(const pb_field_t fields[], void *dest_struct);
-#endif
-
-
-/**************************************
- * 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);
-
-
-/************************************************
- * Helper functions for writing field 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. */
@@ -142,6 +96,25 @@ bool pb_decode_fixed64(pb_istream_t *stream, void *dest);
 bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream);
 
+/* --- Internal functions ---
+ * These functions are not terribly useful for the average library user, but
+ * are exported to make the unit testing and extending nanopb easier.
+ */
+
+#ifdef NANOPB_INTERNALS
+bool pb_dec_varint(pb_istream_t *stream, const pb_field_t *field, void *dest);
+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);
+bool pb_dec_fixed64(pb_istream_t *stream, const pb_field_t *field, void *dest);
+
+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);
+bool pb_skip_string(pb_istream_t *stream);
+#endif
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

pb_encode.c

@@ -3,57 +3,36 @@
  * 2011 Petteri Aimonen <jpa@kapsi.fi>
  */
 
+#define NANOPB_INTERNALS
 #include "pb.h"
 #include "pb_encode.h"
+#include <string.h>
 
-/* Use the GCC warn_unused_result attribute to check that all return values
- * are propagated correctly. On other compilers and gcc before 3.4.0 just
- * ignore the annotation.
- */
+/* The warn_unused_result attribute appeared first in gcc-3.4.0 */
 #if !defined(__GNUC__) || ( __GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
     #define checkreturn
 #else
+    /* Verify that we remember to check all return values for proper error propagation */
     #define checkreturn __attribute__((warn_unused_result))
 #endif
 
-/**************************************
- * Declarations internal to this file *
- **************************************/
 typedef bool (*pb_encoder_t)(pb_ostream_t *stream, const pb_field_t *field, const void *src) checkreturn;
 
-static bool checkreturn buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
-static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field, const void *pData, size_t count, pb_encoder_t func);
-static bool checkreturn encode_field(pb_ostream_t *stream, const pb_field_t *field, const void *pData);
-static bool checkreturn default_extension_encoder(pb_ostream_t *stream, const pb_extension_t *extension);
-static bool checkreturn encode_extension_field(pb_ostream_t *stream, const pb_field_t *field, const void *pData);
-static bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-static bool checkreturn pb_enc_uvarint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-static bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-static bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-static bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-static bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-static bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src);
-
 /* --- Function pointers to field encoders ---
  * Order in the array must match pb_action_t LTYPE numbering.
  */
 static const pb_encoder_t PB_ENCODERS[PB_LTYPES_COUNT] = {
     &pb_enc_varint,
-    &pb_enc_uvarint,
     &pb_enc_svarint,
     &pb_enc_fixed32,
     &pb_enc_fixed64,
     
     &pb_enc_bytes,
     &pb_enc_string,
-    &pb_enc_submessage,
-    NULL /* extensions */
+    &pb_enc_submessage
 };
 
-/*******************************
- * pb_ostream_t implementation *
- *******************************/
+/* pb_ostream_t implementation */
 
 static bool checkreturn buf_write(pb_ostream_t *stream, const uint8_t *buf, size_t count)
 {
@@ -70,16 +49,13 @@ 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 a marker value */
+    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;
 }
 
@@ -88,14 +64,14 @@ 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");
+            return false;
 #else        
         if (!stream->callback(stream, buf, count))
-            PB_RETURN_ERROR(stream, "io error");
+            return false;
 #endif
     }
     
@@ -103,11 +79,12 @@ bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count
     return true;
 }
 
-/*************************
- * Encode a single field *
- *************************/
+/* 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)
 {
@@ -117,11 +94,7 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
     
     if (count == 0)
         return true;
-
-    if (PB_ATYPE(field->type) != PB_ATYPE_POINTER && count > field->array_size)
-        PB_RETURN_ERROR(stream, "array max size exceeded");
     
-    /* 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))
@@ -137,8 +110,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 = {0,0,0,0};
             p = pData;
             for (i = 0; i < count; i++)
             {
@@ -171,23 +144,8 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
         {
             if (!pb_encode_tag_for_field(stream, field))
                 return false;
-
-            /* Normally the data is stored directly in the array entries, but
-             * for pointer-type string and bytes fields, the array entries are
-             * actually pointers themselves also. So we have to dereference once
-             * more to get to the actual data. */
-            if (PB_ATYPE(field->type) == PB_ATYPE_POINTER &&
-                (PB_LTYPE(field->type) == PB_LTYPE_STRING ||
-                 PB_LTYPE(field->type) == PB_LTYPE_BYTES))
-            {
-                if (!func(stream, field, *(const void* const*)p))
-                    return false;      
-            }
-            else
-            {
-                if (!func(stream, field, p))
-                    return false;
-            }
+            if (!func(stream, field, p))
+                return false;
             p = (const char*)p + field->data_size;
         }
     }
@@ -195,176 +153,58 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
     return true;
 }
 
-/* Encode a field with static or pointer allocation, i.e. one whose data
- * is available to the encoder directly. */
-static bool checkreturn encode_basic_field(pb_ostream_t *stream,
-    const pb_field_t *field, const void *pData)
-{
-    pb_encoder_t func;
-    const void *pSize;
-    bool implicit_has = true;
-    
-    func = PB_ENCODERS[PB_LTYPE(field->type)];
-    
-    if (field->size_offset)
-        pSize = (const char*)pData + field->size_offset;
-    else
-        pSize = &implicit_has;
-
-    if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
-    {
-        /* pData is a pointer to the field, which contains pointer to
-         * the data. If the 2nd pointer is NULL, it is interpreted as if
-         * the has_field was false.
-         */
-        
-        pData = *(const void* const*)pData;
-        implicit_has = (pData != NULL);
-    }
-
-    switch (PB_HTYPE(field->type))
-    {
-        case PB_HTYPE_REQUIRED:
-            if (!pData)
-                PB_RETURN_ERROR(stream, "missing required field");
-            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:
-        case PB_ATYPE_POINTER:
-            return encode_basic_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_encoder(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_encoder(stream, extension);
-
-        if (!status)
-            return false;
-        
-        extension = extension->next;
-    }
-    
-    return true;
-}
-
-/*********************
- * Encode all fields *
- *********************/
-
 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)
     {
+        pb_encoder_t func = PB_ENCODERS[PB_LTYPE(field->type)];
         pData = (const char*)pData + prev_size + field->data_offset;
-        if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
-            prev_size = sizeof(const void*);
-        else
-            prev_size = field->data_size;
+        pSize = (const char*)pData + field->size_offset;
         
-        /* Special case for static arrays */
-        if (PB_ATYPE(field->type) == PB_ATYPE_STATIC &&
-            PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
-        {
+        prev_size = field->data_size;
+        if (PB_HTYPE(field->type) == PB_HTYPE_ARRAY)
             prev_size *= field->array_size;
-        }
-        
-        if (PB_LTYPE(field->type) == PB_LTYPE_EXTENSION)
+                
+        switch (PB_HTYPE(field->type))
         {
-            /* Special case for the extension field placeholder */
-            if (!encode_extension_field(stream, field, pData))
-                return false;
-        }
-        else
-        {
-            /* Regular field */
-            if (!encode_field(stream, field, pData))
-                return false;
+            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_ARRAY:
+                if (!encode_array(stream, field, pData, *(const size_t*)pSize, func))
+                    return false;
+                break;
+            
+            case PB_HTYPE_CALLBACK:
+            {
+                const pb_callback_t *callback = (const pb_callback_t*)pData;
+                if (callback->funcs.encode != NULL)
+                {
+                    if (!callback->funcs.encode(stream, field, callback->arg))
+                        return false;
+                }
+                break;
+            }
         }
     
         field++;
@@ -373,25 +213,7 @@ bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], cons
     return true;
 }
 
-bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
-{
-    return pb_encode_submessage(stream, fields, src_struct);
-}
-
-bool pb_get_encoded_size(size_t *size, const pb_field_t fields[], const void *src_struct)
-{
-    pb_ostream_t stream = PB_OSTREAM_SIZING;
-    
-    if (!pb_encode(&stream, fields, src_struct))
-        return false;
-    
-    *size = stream.bytes_written;
-    return true;
-}
-
-/********************
- * Helper functions *
- ********************/
+/* Helper functions */
 bool checkreturn pb_encode_varint(pb_ostream_t *stream, uint64_t value)
 {
     uint8_t buffer[10];
@@ -415,9 +237,9 @@ bool checkreturn pb_encode_svarint(pb_ostream_t *stream, int64_t value)
 {
     uint64_t zigzagged;
     if (value < 0)
-        zigzagged = ~((uint64_t)value << 1);
+        zigzagged = (uint64_t)(~(value << 1));
     else
-        zigzagged = (uint64_t)value << 1;
+        zigzagged = (uint64_t)(value << 1);
     
     return pb_encode_varint(stream, zigzagged);
 }
@@ -458,7 +280,7 @@ bool checkreturn pb_encode_fixed64(pb_ostream_t *stream, const void *value)
 
 bool checkreturn pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number)
 {
-    uint64_t tag = ((uint64_t)field_number << 3) | wiretype;
+    uint64_t tag = wiretype | (field_number << 3);
     return pb_encode_varint(stream, tag);
 }
 
@@ -468,7 +290,6 @@ bool checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t
     switch (PB_LTYPE(field->type))
     {
         case PB_LTYPE_VARINT:
-        case PB_LTYPE_UVARINT:
         case PB_LTYPE_SVARINT:
             wiretype = PB_WT_VARINT;
             break;
@@ -488,7 +309,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);
@@ -505,17 +326,12 @@ bool checkreturn pb_encode_string(pb_ostream_t *stream, const uint8_t *buffer, s
 bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct)
 {
     /* First calculate the message size using a non-writing substream. */
-    pb_ostream_t substream = PB_OSTREAM_SIZING;
+    pb_ostream_t substream = {0,0,0,0};
     size_t size;
     bool status;
     
     if (!pb_encode(&substream, fields, src_struct))
-    {
-#ifndef PB_NO_ERRMSG
-        stream->errmsg = substream.errmsg;
-#endif
         return false;
-    }
     
     size = substream.bytes_written;
     
@@ -526,7 +342,7 @@ bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fie
         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. */
@@ -534,59 +350,37 @@ 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);
     
     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 */
 
-static bool checkreturn pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
-{
-    int64_t value = 0;
-    
-    /* Cases 1 and 2 are for compilers that have smaller types for bool
-     * or enums. */
-    switch (field->data_size)
-    {
-        case 1: value = *(const int8_t*)src; break;
-        case 2: value = *(const int16_t*)src; break;
-        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_varint(stream, (uint64_t)value);
-}
-
-static bool checkreturn pb_enc_uvarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+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");
+        default: return false;
     }
     
     return pb_encode_varint(stream, value);
 }
 
-static bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
     int64_t value = 0;
     
@@ -594,73 +388,41 @@ static bool checkreturn pb_enc_svarint(pb_ostream_t *stream, const pb_field_t *f
     {
         case 4: value = *(const int32_t*)src; break;
         case 8: value = *(const int64_t*)src; break;
-        default: PB_RETURN_ERROR(stream, "invalid data_size");
+        default: return false;
     }
     
     return pb_encode_svarint(stream, value);
 }
 
-static bool checkreturn pb_enc_fixed64(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+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);
 }
 
-static bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, const void *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);
 }
 
-static bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *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;
-    
-    if (src == NULL)
-    {
-        /* Threat null pointer as an empty bytes field */
-        return pb_encode_string(stream, NULL, 0);
-    }
-    
-    if (PB_ATYPE(field->type) == PB_ATYPE_STATIC &&
-        PB_BYTES_ARRAY_T_ALLOCSIZE(bytes->size) > field->data_size)
-    {
-        PB_RETURN_ERROR(stream, "bytes size exceeded");
-    }
-    
+    UNUSED(field);
     return pb_encode_string(stream, bytes->bytes, bytes->size);
 }
 
-static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
-    /* strnlen() is not always available, so just use a loop */
-    size_t size = 0;
-    size_t max_size = field->data_size;
-    const char *p = (const char*)src;
-    
-    if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
-        max_size = (size_t)-1;
-
-    if (src == NULL)
-    {
-        size = 0; /* Threat null pointer as an empty string */
-    }
-    else
-    {
-        while (size < max_size && *p != '\0')
-        {
-            size++;
-            p++;
-        }
-    }
-
-    return pb_encode_string(stream, (const uint8_t*)src, size);
+    UNUSED(field);
+    return pb_encode_string(stream, (const uint8_t*)src, strlen((const char*)src));
 }
 
-static bool checkreturn pb_enc_submessage(pb_ostream_t *stream, const pb_field_t *field, const void *src)
+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 false;
     
     return pb_encode_submessage(stream, (const pb_field_t*)field->ptr, src);
 }

pb_encode.h

@@ -1,28 +1,34 @@
-/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
- * The main function is pb_encode. You also need an output stream, and the
- * field descriptions created by nanopb_generator.py.
- */
-
 #ifndef _PB_ENCODE_H_
 #define _PB_ENCODE_H_
 
+/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
+ * The main function is pb_encode. You also need an output stream, structures
+ * and their field descriptions (just like with pb_decode).
+ */
+
+#include <stdbool.h>
 #include "pb.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* Structure for defining custom output streams. You will need to provide
- * a callback function to write the bytes to your storage, which can be
- * for example a file or a network socket.
- *
- * The callback must conform to these rules:
+/* Lightweight output stream.
+ * You can provide callback for writing or use pb_ostream_from_buffer.
+ * 
+ * Alternatively, callback can be NULL in which case the stream will just
+ * count the number of bytes that would have been written. In this case
+ * max_size is not checked.
  *
+ * Rules for callback:
  * 1) Return false on IO errors. This will cause encoding to abort.
+ * 
  * 2) You can use state to store your own data (e.g. buffer pointer).
+ * 
  * 3) pb_write will update bytes_written after your callback runs.
- * 4) Substreams will modify max_size and bytes_written. Don't use them
- *    to calculate any pointers.
+ * 
+ * 4) Substreams will modify max_size and bytes_written. Don't use them to
+ * calculate any pointers.
  */
 struct _pb_ostream_t
 {
@@ -37,88 +43,31 @@ struct _pb_ostream_t
 #else
     bool (*callback)(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 #endif
-    void *state;          /* Free field for use by callback implementation. */
-    size_t max_size;      /* Limit number of output bytes written (or use SIZE_MAX). */
-    size_t bytes_written; /* Number of bytes written so far. */
-    
-#ifndef PB_NO_ERRMSG
-    const char *errmsg;
-#endif
+    void *state; /* Free field for use by callback implementation */
+    size_t max_size; /* Limit number of output bytes written (or use SIZE_MAX). */
+    size_t bytes_written;
 };
 
-/***************************
- * Main encoding functions *
- ***************************/
+pb_ostream_t pb_ostream_from_buffer(uint8_t *buf, size_t bufsize);
+bool pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count);
 
-/* 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);
 
-/* Same as pb_encode, but prepends the length of the message as a varint.
- * 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);
 
-/* Encode the message to get the size of the encoded data, but do not store
- * the data. */
-bool pb_get_encoded_size(size_t *size, 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. */
+/* Encode field header based on LTYPE and field number defined in the field structure.
+ * Call this from the callback before writing out field contents. */
 bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field);
 
-/* Encode field header by manually specifing wire type. You need to use this
- * if you want to write out packed arrays from a callback field. */
+/* Encode field header by manually specifing wire type. You need to use this if
+ * you want to write out packed arrays from a callback field. */
 bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number);
 
 /* Encode an integer in the varint format.
@@ -141,12 +90,29 @@ bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
 bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
 
 /* Encode a submessage field.
- * You need to pass the pb_field_t array and pointer to struct, just like
- * with pb_encode(). This internally encodes the submessage twice, first to
- * calculate message size and then to actually write it out.
+ * You need to pass the pb_field_t array and pointer to struct, just like with pb_encode().
+ * This internally encodes the submessage twice, first to calculate message size and then to actually write it out.
  */
 bool pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
 
+/* --- Internal functions ---
+ * These functions are not terribly useful for the average library user, but
+ * are exported to make the unit testing and extending nanopb easier.
+ */
+
+#ifdef NANOPB_INTERNALS
+bool pb_enc_varint(pb_ostream_t *stream, const pb_field_t *field, const void *src);
+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
 } /* extern "C" */
 #endif

tests/Makefile

@@ -1,21 +1,131 @@
-all:
-	scons
+CFLAGS=-ansi -Wall -Werror -I .. -g -O0
+DEPS=../pb_decode.h ../pb_encode.h ../pb.h person.pb.h \
+	callbacks2.pb.h callbacks.pb.h unittests.h unittestproto.pb.h \
+	alltypes.pb.h missing_fields.pb.h
+TESTS=  decode_unittests encode_unittests \
+	test_decode1 test_decode2 test_decode3 test_decode3_buf \
+	test_encode1 test_encode2 test_encode3 test_encode3_buf \
+	test_decode_callbacks test_encode_callbacks \
+	test_missing_fields test_no_messages test_funny_name \
+	test_multiple_files test_cxxcompile test_options \
+	bc_encode bc_decode
+
+# More strict checks for the core part of nanopb
+CC_VERSION=$(shell $(CC) -v 2>&1)
+CFLAGS_CORE=
+ifneq (,$(findstring gcc,$(CC_VERSION)))
+	CFLAGS_CORE=-pedantic -Wextra -Wcast-qual -Wlogical-op -Wconversion
+        CFLAGS+=--coverage
+        LDFLAGS+=--coverage
+endif
+ifneq (,$(findstring clang,$(CC_VERSION)))
+	CFLAGS_CORE=-pedantic -Wextra -Wcast-qual -Wconversion
+endif
+
+all: breakpoints $(TESTS) run_unittests
 
 clean:
-	scons -c
+	rm -f $(TESTS) person.pb* alltypes.pb* *.o *.gcda *.gcno *.pb.h *.pb.c
 
-coverage:
-	rm -rf build coverage
+%.pb.o: %.pb.c %.pb.h
+	$(CC) $(CFLAGS) $(CFLAGS_CORE) -c -o $@ $<
 
-	# LCOV does not like the newer gcov format
-	scons CC=gcc-4.6 CXX=gcc-4.6
+%.o: %.c
+%.o: %.c $(DEPS)
+	$(CC) $(CFLAGS) -c -o $@ $<
 
-	# We are only interested in pb_encode.o and pb_decode.o
-	find build -name '*.gcda' -and \! \( -name '*pb_encode*' -or -name '*pb_decode*' \) -exec rm '{}' \;
+pb_encode.o: ../pb_encode.c $(DEPS)
+	$(CC) $(CFLAGS) $(CFLAGS_CORE) -c -o $@ $<
+pb_decode.o: ../pb_decode.c $(DEPS)
+	$(CC) $(CFLAGS) $(CFLAGS_CORE) -c -o $@ $<
 
-	# Collect the data
-	mkdir build/coverage
-	lcov --base-directory . --directory build/ --gcov-tool gcov-4.6 -c -o build/coverage/nanopb.info
+# Test for compilability with c++ compiler
 
-	# Generate HTML
-	genhtml -o build/coverage build/coverage/nanopb.info
+pb_encode.cxx.o: ../pb_encode.c $(DEPS)
+	$(CXX) $(CFLAGS) $(CFLAGS_CORE) -c -o $@ $<
+pb_decode.cxx.o: ../pb_decode.c $(DEPS)
+	$(CXX) $(CFLAGS) $(CFLAGS_CORE) -c -o $@ $<
+
+# Test for PB_BUF_ONLY compilation option
+
+pb_encode.buf.o: ../pb_encode.c $(DEPS)
+	$(CC) -DPB_BUFFER_ONLY $(CFLAGS) $(CFLAGS_CORE) -c -o $@ $<
+pb_decode.buf.o: ../pb_decode.c $(DEPS)
+	$(CC) -DPB_BUFFER_ONLY $(CFLAGS) $(CFLAGS_CORE) -c -o $@ $<
+%.buf.o: %.c $(DEPS)
+	$(CC) -DPB_BUFFER_ONLY $(CFLAGS) -c -o $@ $<	
+test_encode3_buf: test_encode3.buf.o pb_encode.buf.o alltypes.pb.o
+	$(CC) $(LDFLAGS) $^ -o $@
+test_decode3_buf: test_decode3.buf.o pb_decode.buf.o alltypes.pb.o
+	$(CC) $(LDFLAGS) $^ -o $@
+
+test_cxxcompile: pb_encode.cxx.o pb_decode.cxx.o
+test_decode1: test_decode1.o pb_decode.o person.pb.o
+test_decode2: test_decode2.o pb_decode.o person.pb.o
+test_decode3: test_decode3.o pb_decode.o alltypes.pb.o
+test_encode1: test_encode1.o pb_encode.o person.pb.o
+test_encode2: test_encode2.o pb_encode.o person.pb.o
+test_encode3: test_encode3.o pb_encode.o alltypes.pb.o
+test_multiple_files: test_multiple_files.o pb_encode.o callbacks2.pb.o callbacks.pb.o
+test_decode_callbacks: test_decode_callbacks.o pb_decode.o callbacks.pb.o
+test_encode_callbacks: test_encode_callbacks.o pb_encode.o callbacks.pb.o
+test_missing_fields: test_missing_fields.o pb_encode.o pb_decode.o missing_fields.pb.o
+decode_unittests: decode_unittests.o pb_decode.o unittestproto.pb.o
+encode_unittests: encode_unittests.o pb_encode.o unittestproto.pb.o
+test_no_messages: no_messages.pb.h no_messages.pb.c no_messages.pb.o
+test_funny_name: funny-proto+name.pb.h funny-proto+name.pb.o
+bc_encode: bc_alltypes.pb.o pb_encode.o bc_encode.o
+bc_decode: bc_alltypes.pb.o pb_decode.o bc_decode.o
+
+%.pb: %.proto
+	protoc -I. -I../generator -I/usr/include -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 -I/usr/include person.proto`" ]
+
+	[ "`./test_encode2 | ./test_decode1`" = \
+	"`./test_encode2 | protoc --decode=Person -I. -I../generator -I/usr/include person.proto`" ]
+
+	[ "`./test_encode2 | ./test_decode2`" = \
+	"`./test_encode2 | protoc --decode=Person -I. -I../generator -I/usr/include person.proto`" ]
+	
+	[ "`./test_decode2 < person_with_extra_field.pb`" = \
+	"`./test_encode2 | ./test_decode2`" ]
+	
+	[ "`./test_encode_callbacks | ./test_decode_callbacks`" = \
+	"`./test_encode_callbacks | protoc --decode=TestMessage callbacks.proto`" ]
+
+	./test_encode3 | ./test_decode3
+	./test_encode3 1 | ./test_decode3 1
+	./test_encode3 1 | protoc --decode=AllTypes -I. -I../generator -I/usr/include alltypes.proto >/dev/null
+	./test_encode3_buf 1 | ./test_decode3_buf 1
+	./bc_encode | ./bc_decode
+	
+	./test_missing_fields
+
+test_options: options.pb.h options.expected options.pb.o
+	cat options.expected | while read -r p; do \
+	    if ! grep -q "$$p" $<; then \
+	        echo Expected: "$$p"; \
+	        exit 1; \
+	    fi \
+	done
+
+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'

tests/SConstruct

@@ -1,147 +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, tools = ['default', 'nanopb'])
-
-# 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 'CCFLAGS' in ARGUMENTS: env.Append(CCFLAGS = ARGUMENTS['CCFLAGS'])
-if 'CXXFLAGS' in ARGUMENTS: env.Append(CXXFLAGS = 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'):
-    def check_ccflags(context, flags, linkflags = ''):
-        '''Check if given CCFLAGS are supported'''
-        context.Message('Checking support for CCFLAGS="%s"... ' % flags)
-        oldflags = context.env['CCFLAGS']
-        oldlinkflags = context.env['CCFLAGS']
-        context.env.Append(CCFLAGS = flags)
-        context.env.Append(LINKFLAGS = linkflags)
-        result = context.TryCompile("int main() {return 0;}", '.c')
-        context.env.Replace(CCFLAGS = oldflags)
-        context.env.Replace(LINKFLAGS = oldlinkflags)
-        context.Result(result)
-        return result
-    
-    conf = Configure(env, custom_tests = {'CheckCCFLAGS': check_ccflags})
-
-    # 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')
-    stdlib = conf.CheckCHeader('stdlib.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 = "#../extra")
-	conf.env.Append(SYSHDR = '\\"pb_syshdr.h\\"')
-        
-        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})
-        if stdlib: conf.env.Append(CPPDEFINES = {'HAVE_STDLIB_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 = '-fmudflap')
-    
-    # Check if we can use extra strict warning flags (only with GCC)
-    extra = '-Wcast-qual -Wlogical-op -Wconversion'
-    extra += ' -fstrict-aliasing -Wstrict-aliasing=1'
-    extra += ' -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls'
-    extra += ' -Wstack-protector '
-    if 'gcc' in env['CC']:
-        if conf.CheckCCFLAGS(extra):
-            conf.env.Append(CORECFLAGS = extra)
-    
-    # Check if we can use undefined behaviour sanitizer (only with clang)
-    extra = '-fsanitize=undefined '
-    if 'clang' in env['CC']:
-        if conf.CheckCCFLAGS(extra, linkflags = extra):
-            conf.env.Append(CORECFLAGS = extra)
-            conf.env.Append(LINKFLAGS = extra)
-    
-    # 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 -Wall -Werror -fprofile-arcs -ftest-coverage ')
-    env.Append(CORECFLAGS = '-Wextra')
-    env.Append(LINKFLAGS = '-g --coverage')
-    
-    # We currently need uint64_t anyway, even though ANSI C90 otherwise..
-    env.Append(CFLAGS = '-Wno-long-long')
-elif 'clang' in env['CC']:
-    # CLang
-    env.Append(CFLAGS = '-ansi -g -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 -Wall -Werror -Wextra -Wno-missing-field-initializers')
-elif 'g++' in env['CXX'] or 'gcc' in env['CXX']:
-    env.Append(CXXFLAGS = '-g -Wall -Werror -Wextra -Wno-missing-field-initializers')
-elif 'cl' in env['CXX']:
-    env.Append(CXXFLAGS = '/Zi /W2 /WX')
-    
-# Now include the SConscript files from all subdirectories
-import os.path
-env['VARIANT_DIR'] = 'build'
-env['BUILD'] = '#' + env['VARIANT_DIR']
-env['COMMON'] = '#' + env['VARIANT_DIR'] + '/common'
-for subdir in Glob('*/SConscript') + Glob('regression/*/SConscript'):
-    SConscript(subdir, exports = 'env', variant_dir = env['VARIANT_DIR'] + '/' + os.path.dirname(str(subdir)))
-

tests/alltypes.proto

@@ -0,0 +1,85 @@
+import "nanopb.proto";
+
+message SubMessage {
+    required string substuff1 = 1 [(nanopb).max_size = 16, default = "1"];
+    required int32 substuff2 = 2 [default = 2];
+    optional fixed32 substuff3 = 3 [default = 3];
+}
+
+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 [(nanopb).max_size = 16];
+    required bytes      req_bytes   = 15 [(nanopb).max_size = 16];
+    required SubMessage req_submsg  = 16;
+    required MyEnum     req_enum    = 17;
+    
+    
+    repeated int32      rep_int32   = 21 [(nanopb).max_count = 5];
+    repeated int64      rep_int64   = 22 [(nanopb).max_count = 5];
+    repeated uint32     rep_uint32  = 23 [(nanopb).max_count = 5];
+    repeated uint64     rep_uint64  = 24 [(nanopb).max_count = 5];
+    repeated sint32     rep_sint32  = 25 [(nanopb).max_count = 5];
+    repeated sint64     rep_sint64  = 26 [(nanopb).max_count = 5];
+    repeated bool       rep_bool    = 27 [(nanopb).max_count = 5];
+    
+    repeated fixed32    rep_fixed32 = 28 [(nanopb).max_count = 5];
+    repeated sfixed32   rep_sfixed32= 29 [(nanopb).max_count = 5];
+    repeated float      rep_float   = 30 [(nanopb).max_count = 5];
+    
+    repeated fixed64    rep_fixed64 = 31 [(nanopb).max_count = 5];
+    repeated sfixed64   rep_sfixed64= 32 [(nanopb).max_count = 5];
+    repeated double     rep_double  = 33 [(nanopb).max_count = 5];
+    
+    repeated string     rep_string  = 34 [(nanopb).max_size = 16, (nanopb).max_count = 5];
+    repeated bytes      rep_bytes   = 35 [(nanopb).max_size = 16, (nanopb).max_count = 5];
+    repeated SubMessage rep_submsg  = 36 [(nanopb).max_count = 5];
+    repeated MyEnum     rep_enum    = 37 [(nanopb).max_count = 5];
+    
+    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 [(nanopb).max_size = 16, default = "4054"];
+    optional bytes      opt_bytes   = 55 [(nanopb).max_size = 16, default = "4055"];
+    optional SubMessage opt_submsg  = 56;
+    optional MyEnum     opt_enum    = 57 [default = Second];
+
+    // Just to make sure that the size of the fields has been calculated
+    // properly, i.e. otherwise a bug in last field might not be detected.
+    required int32      end = 99;
+}
+

tests/alltypes/SConscript

@@ -1,35 +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", "alltypes.options"])
-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"])
-
-# Test the round-trip from nanopb encoder to nanopb decoder
-env.RunTest(enc)
-env.RunTest([dec, "encode_alltypes.output"])
-
-# Re-encode the data using protoc, and check that the results from nanopb
-# match byte-per-byte to the protoc output.
-env.Decode("encode_alltypes.output.decoded",
-           ["encode_alltypes.output", "alltypes.proto"],
-           MESSAGE='AllTypes')
-env.Encode("encode_alltypes.output.recoded",
-           ["encode_alltypes.output.decoded", "alltypes.proto"],
-           MESSAGE='AllTypes')
-env.Compare(["encode_alltypes.output", "encode_alltypes.output.recoded"])
-
-# Do the same checks with the optional fields present.
-env.RunTest("optionals.output", enc, ARGS = ['1'])
-env.RunTest("optionals.decout", [dec, "optionals.output"], ARGS = ['1'])
-env.Decode("optionals.output.decoded",
-           ["optionals.output", "alltypes.proto"],
-           MESSAGE='AllTypes')
-env.Encode("optionals.output.recoded",
-           ["optionals.output.decoded", "alltypes.proto"],
-           MESSAGE='AllTypes')
-env.Compare(["optionals.output", "optionals.output.recoded"])
-
-

tests/alltypes/alltypes.options

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

tests/alltypes/alltypes.proto

@@ -1,114 +0,0 @@
-message SubMessage {
-    required string substuff1 = 1 [default = "1"];
-    required int32 substuff2 = 2 [default = 2];
-    optional fixed32 substuff3 = 3 [default = 3];
-}
-
-message EmptyMessage {
-
-}
-
-enum HugeEnum {
-    Negative = -2147483647; /* protoc doesn't accept -2147483648 here */
-    Positive =  2147483647;
-}
-
-message Limits {
-    required int32      int32_min  =  1 [default = 2147483647];
-    required int32      int32_max  =  2 [default = -2147483647];
-    required uint32     uint32_min =  3 [default = 4294967295];
-    required uint32     uint32_max =  4 [default = 0];
-    required int64      int64_min  =  5 [default = 9223372036854775807];
-    required int64      int64_max  =  6 [default = -9223372036854775807];
-    required uint64     uint64_min =  7 [default = 18446744073709551615];
-    required uint64     uint64_max =  8 [default = 0];
-    required HugeEnum   enum_min   =  9 [default = Positive];
-    required HugeEnum   enum_max   = 10 [default = Negative];
-}
-
-enum MyEnum {
-    Zero = 0;
-    First = 1;
-    Second = 2;
-    Truth = 42;
-}
-
-message AllTypes {
-    required int32      req_int32   = 1;
-    required int64      req_int64   = 2;
-    required uint32     req_uint32  = 3;
-    required uint64     req_uint64  = 4;
-    required sint32     req_sint32  = 5;
-    required sint64     req_sint64  = 6;
-    required bool       req_bool    = 7;
-    
-    required fixed32    req_fixed32 = 8;
-    required sfixed32   req_sfixed32= 9;
-    required float      req_float   = 10;
-    
-    required fixed64    req_fixed64 = 11;
-    required sfixed64   req_sfixed64= 12;
-    required double     req_double  = 13;
-    
-    required string     req_string  = 14;
-    required bytes      req_bytes   = 15;
-    required SubMessage req_submsg  = 16;
-    required MyEnum     req_enum    = 17;
-    required EmptyMessage req_emptymsg = 18;
-    
-    
-    repeated int32      rep_int32   = 21 [packed = true];
-    repeated int64      rep_int64   = 22 [packed = true];
-    repeated uint32     rep_uint32  = 23 [packed = true];
-    repeated uint64     rep_uint64  = 24 [packed = true];
-    repeated sint32     rep_sint32  = 25 [packed = true];
-    repeated sint64     rep_sint64  = 26 [packed = true];
-    repeated bool       rep_bool    = 27 [packed = true];
-    
-    repeated fixed32    rep_fixed32 = 28 [packed = true];
-    repeated sfixed32   rep_sfixed32= 29 [packed = true];
-    repeated float      rep_float   = 30 [packed = true];
-    
-    repeated fixed64    rep_fixed64 = 31 [packed = true];
-    repeated sfixed64   rep_sfixed64= 32 [packed = true];
-    repeated double     rep_double  = 33 [packed = true];
-    
-    repeated string     rep_string  = 34;
-    repeated bytes      rep_bytes   = 35;
-    repeated SubMessage rep_submsg  = 36;
-    repeated MyEnum     rep_enum    = 37 [packed = true];
-    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;
-
-    // Check that extreme integer values are handled correctly
-    required Limits     req_limits = 98;
-
-    // Just to make sure that the size of the fields has been calculated
-    // properly, i.e. otherwise a bug in last field might not be detected.
-    required int32      end = 99;
-
-
-    extensions 200 to 255;
-}
-

tests/alltypes_callback/SConscript

@@ -1,23 +0,0 @@
-# Test the AllTypes encoding & decoding using callbacks for all fields.
-
-Import("env")
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
-
-env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
-dec = env.Program(["decode_alltypes_callback.c", "alltypes.pb.c", "$COMMON/pb_decode.o"])
-
-refdec = "$BUILD/alltypes/decode_alltypes$PROGSUFFIX"
-
-# Encode and compare results
-env.RunTest(enc)
-env.RunTest("decode_alltypes.output", [refdec, "encode_alltypes_callback.output"])
-env.RunTest("decode_alltypes_callback.output", [dec, "encode_alltypes_callback.output"])
-
-# Do the same thing with the optional fields present
-env.RunTest("optionals.output", enc, ARGS = ['1'])
-env.RunTest("optionals.refdecout", [refdec, "optionals.output"], ARGS = ['1'])
-env.RunTest("optionals.decout", [dec, "optionals.output"], ARGS = ['1'])
-

tests/alltypes_callback/alltypes.options

@@ -1,3 +0,0 @@
-# Generate all fields as callbacks.
-AllTypes.*              type:FT_CALLBACK
-SubMessage.substuff1    max_size:16

tests/alltypes_callback/decode_alltypes_callback.c

@@ -1,424 +0,0 @@
-/* Attempts to test all the datatypes supported by ProtoBuf when used as callback fields.
- * Note that normally there would be no reason to use callback fields for this,
- * because each encoder defined here only gives a single field.
- */
-
-#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 (in field %d).\n", field->tag); \
-    return false; \
-    }
-
-static bool read_varint(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    uint64_t value;
-    if (!pb_decode_varint(stream, &value))
-        return false;
-    
-    TEST((int64_t)value == (long)*arg);
-    return true;
-}
-
-static bool read_svarint(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    int64_t value;
-    if (!pb_decode_svarint(stream, &value))
-        return false;
-    
-    TEST(value == (long)*arg);
-    return true;
-}
-
-static bool read_fixed32(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    uint32_t value;
-    if (!pb_decode_fixed32(stream, &value))
-        return false;
-    
-    TEST(value == *(uint32_t*)*arg);
-    return true;
-}
-
-static bool read_fixed64(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    uint64_t value;
-    if (!pb_decode_fixed64(stream, &value))
-        return false;
-    
-    TEST(value == *(uint64_t*)*arg);
-    return true;
-}
-
-static bool read_string(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    uint8_t buf[16] = {0};
-    size_t len = stream->bytes_left;
-    
-    if (len > sizeof(buf) - 1 || !pb_read(stream, buf, len))
-        return false;
-    
-    TEST(strcmp((char*)buf, *arg) == 0);
-    return true;
-}
-
-static bool read_submsg(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    SubMessage submsg = {""};
-    
-    if (!pb_decode(stream, SubMessage_fields, &submsg))
-        return false;
-    
-    TEST(memcmp(&submsg, *arg, sizeof(submsg)));
-    return true;
-}
-
-static bool read_emptymsg(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    EmptyMessage emptymsg = {0};
-    return pb_decode(stream, EmptyMessage_fields, &emptymsg);
-}
-
-static bool read_repeated_varint(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    int32_t** expected = (int32_t**)arg;
-    uint64_t value;
-    if (!pb_decode_varint(stream, &value))
-        return false;
-
-    TEST(*(*expected)++ == value);
-    return true;
-}
-
-static bool read_repeated_svarint(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    int32_t** expected = (int32_t**)arg;
-    int64_t value;
-    if (!pb_decode_svarint(stream, &value))
-        return false;
-
-    TEST(*(*expected)++ == value);
-    return true;
-}
-
-static bool read_repeated_fixed32(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    uint32_t** expected = (uint32_t**)arg;
-    uint32_t value;
-    if (!pb_decode_fixed32(stream, &value))
-        return false;
-
-    TEST(*(*expected)++ == value);
-    return true;
-}
-
-static bool read_repeated_fixed64(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    uint64_t** expected = (uint64_t**)arg;
-    uint64_t value;
-    if (!pb_decode_fixed64(stream, &value))
-        return false;
-
-    TEST(*(*expected)++ == value);
-    return true;
-}
-
-static bool read_repeated_string(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    uint8_t*** expected = (uint8_t***)arg;
-    uint8_t buf[16] = {0};
-    size_t len = stream->bytes_left;
-    
-    if (len > sizeof(buf) - 1 || !pb_read(stream, buf, len))
-        return false;
-    
-    TEST(strcmp((char*)*(*expected)++, (char*)buf) == 0);
-    return true;
-}
-
-static bool read_repeated_submsg(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    SubMessage** expected = (SubMessage**)arg;
-    SubMessage decoded = {""};
-    if (!pb_decode(stream, SubMessage_fields, &decoded))
-        return false;
-
-    TEST(memcmp((*expected)++, &decoded, sizeof(decoded)) == 0);
-    return true;
-}
-
-static bool read_limits(pb_istream_t *stream, const pb_field_t *field, void **arg)
-{
-    Limits decoded = {0};
-    if (!pb_decode(stream, Limits_fields, &decoded))
-        return false;
-
-    TEST(decoded.int32_min  == INT32_MIN);
-    TEST(decoded.int32_max  == INT32_MAX);
-    TEST(decoded.uint32_min == 0);
-    TEST(decoded.uint32_max == UINT32_MAX);
-    TEST(decoded.int64_min  == INT64_MIN);
-    TEST(decoded.int64_max  == INT64_MAX);
-    TEST(decoded.uint64_min == 0);
-    TEST(decoded.uint64_max == UINT64_MAX);
-    TEST(decoded.enum_min   == HugeEnum_Negative);
-    TEST(decoded.enum_max   == HugeEnum_Positive);
-    
-    return true;
-}
-
-/* This function is called once from main(), it handles
-   the decoding and checks the fields. */
-bool check_alltypes(pb_istream_t *stream, int mode)
-{
-    /* Values for use from callbacks through pointers. */
-    uint32_t    req_fixed32     = 1008;
-    int32_t     req_sfixed32    = -1009;
-    float       req_float       = 1010.0f;
-    uint64_t    req_fixed64     = 1011;
-    int64_t     req_sfixed64    = -1012;
-    double      req_double      = 1013.0;
-    SubMessage  req_submsg      = {"1016", 1016};
-    
-    int32_t     rep_int32[5]    = {0, 0, 0, 0, -2001};
-    int32_t     rep_int64[5]    = {0, 0, 0, 0, -2002};
-    int32_t     rep_uint32[5]   = {0, 0, 0, 0,  2003};
-    int32_t     rep_uint64[5]   = {0, 0, 0, 0,  2004};
-    int32_t     rep_sint32[5]   = {0, 0, 0, 0, -2005};
-    int32_t     rep_sint64[5]   = {0, 0, 0, 0, -2006};
-    int32_t     rep_bool[5]     = {false, false, false, false, true};
-    uint32_t    rep_fixed32[5]  = {0, 0, 0, 0,  2008};
-    int32_t     rep_sfixed32[5] = {0, 0, 0, 0, -2009};
-    float       rep_float[5]    = {0, 0, 0, 0,  2010.0f};
-    uint64_t    rep_fixed64[5]  = {0, 0, 0, 0,  2011};
-    int64_t     rep_sfixed64[5] = {0, 0, 0, 0, -2012};
-    double      rep_double[5]   = {0, 0, 0, 0,  2013.0};
-    char*       rep_string[5]   = {"", "", "", "", "2014"};
-    char*       rep_bytes[5]    = {"", "", "", "", "2015"};
-    SubMessage  rep_submsg[5]   = {{"", 0, 0, 3},
-                                   {"", 0, 0, 3},
-                                   {"", 0, 0, 3},
-                                   {"", 0, 0, 3},
-                                   {"2016", 2016, true, 2016}};
-    int32_t     rep_enum[5]     = {0, 0, 0, 0, MyEnum_Truth};
-    
-    uint32_t    opt_fixed32     = 3048;
-    int32_t     opt_sfixed32    = 3049;
-    float       opt_float       = 3050.0f;
-    uint64_t    opt_fixed64     = 3051;
-    int64_t     opt_sfixed64    = 3052;
-    double      opt_double      = 3053.0f;
-    SubMessage  opt_submsg      = {"3056", 3056};
-    
-    /* Bind callbacks for required fields */
-    AllTypes alltypes;
-    
-    /* Fill with garbage to better detect initialization errors */
-    memset(&alltypes, 0xAA, sizeof(alltypes));
-    alltypes.extensions = 0;
-    
-    alltypes.req_int32.funcs.decode = &read_varint;
-    alltypes.req_int32.arg = (void*)-1001;
-    
-    alltypes.req_int64.funcs.decode = &read_varint;
-    alltypes.req_int64.arg = (void*)-1002;
-    
-    alltypes.req_uint32.funcs.decode = &read_varint;
-    alltypes.req_uint32.arg = (void*)1003;
-
-    alltypes.req_uint32.funcs.decode = &read_varint;
-    alltypes.req_uint32.arg = (void*)1003;    
-    
-    alltypes.req_uint64.funcs.decode = &read_varint;
-    alltypes.req_uint64.arg = (void*)1004;
-    
-    alltypes.req_sint32.funcs.decode = &read_svarint;
-    alltypes.req_sint32.arg = (void*)-1005;   
-    
-    alltypes.req_sint64.funcs.decode = &read_svarint;
-    alltypes.req_sint64.arg = (void*)-1006;   
-    
-    alltypes.req_bool.funcs.decode = &read_varint;
-    alltypes.req_bool.arg = (void*)true;   
-    
-    alltypes.req_fixed32.funcs.decode = &read_fixed32;
-    alltypes.req_fixed32.arg = &req_fixed32;
-    
-    alltypes.req_sfixed32.funcs.decode = &read_fixed32;
-    alltypes.req_sfixed32.arg = &req_sfixed32;
-    
-    alltypes.req_float.funcs.decode = &read_fixed32;
-    alltypes.req_float.arg = &req_float;
-    
-    alltypes.req_fixed64.funcs.decode = &read_fixed64;
-    alltypes.req_fixed64.arg = &req_fixed64;
-    
-    alltypes.req_sfixed64.funcs.decode = &read_fixed64;
-    alltypes.req_sfixed64.arg = &req_sfixed64;
-    
-    alltypes.req_double.funcs.decode = &read_fixed64;
-    alltypes.req_double.arg = &req_double;
-    
-    alltypes.req_string.funcs.decode = &read_string;
-    alltypes.req_string.arg = "1014";
-    
-    alltypes.req_bytes.funcs.decode = &read_string;
-    alltypes.req_bytes.arg = "1015";
-    
-    alltypes.req_submsg.funcs.decode = &read_submsg;
-    alltypes.req_submsg.arg = &req_submsg;
-    
-    alltypes.req_enum.funcs.decode = &read_varint;
-    alltypes.req_enum.arg = (void*)MyEnum_Truth;
-    
-    alltypes.req_emptymsg.funcs.decode = &read_emptymsg;
-    
-    /* Bind callbacks for repeated fields */
-    alltypes.rep_int32.funcs.decode = &read_repeated_varint;
-    alltypes.rep_int32.arg = rep_int32;
-    
-    alltypes.rep_int64.funcs.decode = &read_repeated_varint;
-    alltypes.rep_int64.arg = rep_int64;
-    
-    alltypes.rep_uint32.funcs.decode = &read_repeated_varint;
-    alltypes.rep_uint32.arg = rep_uint32;
-    
-    alltypes.rep_uint64.funcs.decode = &read_repeated_varint;
-    alltypes.rep_uint64.arg = rep_uint64;
-    
-    alltypes.rep_sint32.funcs.decode = &read_repeated_svarint;
-    alltypes.rep_sint32.arg = rep_sint32;
-    
-    alltypes.rep_sint64.funcs.decode = &read_repeated_svarint;
-    alltypes.rep_sint64.arg = rep_sint64;
-    
-    alltypes.rep_bool.funcs.decode = &read_repeated_varint;
-    alltypes.rep_bool.arg = rep_bool;
-    
-    alltypes.rep_fixed32.funcs.decode = &read_repeated_fixed32;
-    alltypes.rep_fixed32.arg = rep_fixed32;
-    
-    alltypes.rep_sfixed32.funcs.decode = &read_repeated_fixed32;
-    alltypes.rep_sfixed32.arg = rep_sfixed32;
-    
-    alltypes.rep_float.funcs.decode = &read_repeated_fixed32;
-    alltypes.rep_float.arg = rep_float;
-    
-    alltypes.rep_fixed64.funcs.decode = &read_repeated_fixed64;
-    alltypes.rep_fixed64.arg = rep_fixed64;
-    
-    alltypes.rep_sfixed64.funcs.decode = &read_repeated_fixed64;
-    alltypes.rep_sfixed64.arg = rep_sfixed64;
-    
-    alltypes.rep_double.funcs.decode = &read_repeated_fixed64;
-    alltypes.rep_double.arg = rep_double;
-    
-    alltypes.rep_string.funcs.decode = &read_repeated_string;
-    alltypes.rep_string.arg = rep_string;
-    
-    alltypes.rep_bytes.funcs.decode = &read_repeated_string;
-    alltypes.rep_bytes.arg = rep_bytes;
-    
-    alltypes.rep_submsg.funcs.decode = &read_repeated_submsg;
-    alltypes.rep_submsg.arg = rep_submsg;
-    
-    alltypes.rep_enum.funcs.decode = &read_repeated_varint;
-    alltypes.rep_enum.arg = rep_enum;
-    
-    alltypes.rep_emptymsg.funcs.decode = &read_emptymsg;
-    
-    alltypes.req_limits.funcs.decode = &read_limits;
-    
-    alltypes.end.funcs.decode = &read_varint;
-    alltypes.end.arg = (void*)1099;
-    
-    /* Bind callbacks for optional fields */
-    if (mode == 1)
-    {
-        alltypes.opt_int32.funcs.decode = &read_varint;
-        alltypes.opt_int32.arg = (void*)3041;
-        
-        alltypes.opt_int64.funcs.decode = &read_varint;
-        alltypes.opt_int64.arg = (void*)3042;
-        
-        alltypes.opt_uint32.funcs.decode = &read_varint;
-        alltypes.opt_uint32.arg = (void*)3043;
-        
-        alltypes.opt_uint64.funcs.decode = &read_varint;
-        alltypes.opt_uint64.arg = (void*)3044;
-        
-        alltypes.opt_sint32.funcs.decode = &read_svarint;
-        alltypes.opt_sint32.arg = (void*)3045;
-        
-        alltypes.opt_sint64.funcs.decode = &read_svarint;
-        alltypes.opt_sint64.arg = (void*)3046;
-        
-        alltypes.opt_bool.funcs.decode = &read_varint;
-        alltypes.opt_bool.arg = (void*)true;
-
-        alltypes.opt_fixed32.funcs.decode = &read_fixed32;
-        alltypes.opt_fixed32.arg = &opt_fixed32;
-        
-        alltypes.opt_sfixed32.funcs.decode = &read_fixed32;
-        alltypes.opt_sfixed32.arg = &opt_sfixed32;
-        
-        alltypes.opt_float.funcs.decode = &read_fixed32;
-        alltypes.opt_float.arg = &opt_float;
-        
-        alltypes.opt_fixed64.funcs.decode = &read_fixed64;
-        alltypes.opt_fixed64.arg = &opt_fixed64;
-        
-        alltypes.opt_sfixed64.funcs.decode = &read_fixed64;
-        alltypes.opt_sfixed64.arg = &opt_sfixed64;
-        
-        alltypes.opt_double.funcs.decode = &read_fixed64;
-        alltypes.opt_double.arg = &opt_double;
-        
-        alltypes.opt_string.funcs.decode = &read_string;
-        alltypes.opt_string.arg = "3054";
-        
-        alltypes.opt_bytes.funcs.decode = &read_string;
-        alltypes.opt_bytes.arg = "3055";
-        
-        alltypes.opt_submsg.funcs.decode = &read_submsg;
-        alltypes.opt_submsg.arg = &opt_submsg;
-        
-        alltypes.opt_enum.funcs.decode = &read_varint;
-        alltypes.opt_enum.arg = (void*)MyEnum_Truth;
-        
-        alltypes.opt_emptymsg.funcs.decode = &read_emptymsg;
-    }
-    
-    return pb_decode(stream, AllTypes_fields, &alltypes);
-}
-
-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;
-    }
-}

tests/alltypes_callback/encode_alltypes_callback.c

@@ -1,397 +0,0 @@
-/* Attempts to test all the datatypes supported by ProtoBuf when used as callback fields.
- * Note that normally there would be no reason to use callback fields for this,
- * because each encoder defined here only gives a single field.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <pb_encode.h>
-#include "alltypes.pb.h"
-#include "test_helpers.h"
-
-static bool write_varint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_varint(stream, (long)*arg);
-}
-
-static bool write_svarint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_svarint(stream, (long)*arg);
-}
-
-static bool write_fixed32(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_fixed32(stream, *arg);
-}
-
-static bool write_fixed64(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_fixed64(stream, *arg);
-}
-
-static bool write_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_string(stream, *arg, strlen(*arg));
-}
-
-static bool write_submsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-   
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, SubMessage_fields, *arg);
-}
-
-static bool write_emptymsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    EmptyMessage emptymsg = {0};
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg);
-}
-
-static bool write_repeated_varint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_varint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_varint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_varint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_varint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_varint(stream, (long)*arg);
-}
-
-static bool write_repeated_svarint(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_svarint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_svarint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_svarint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_svarint(stream, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_svarint(stream, (long)*arg);
-}
-
-static bool write_repeated_fixed32(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    uint32_t dummy = 0;
-
-    /* Make it a packed field */
-    return pb_encode_tag(stream, PB_WT_STRING, field->tag) &&
-           pb_encode_varint(stream, 5 * 4) && /* Number of bytes */
-           pb_encode_fixed32(stream, &dummy) &&
-           pb_encode_fixed32(stream, &dummy) &&
-           pb_encode_fixed32(stream, &dummy) &&
-           pb_encode_fixed32(stream, &dummy) &&
-           pb_encode_fixed32(stream, *arg);
-}
-
-static bool write_repeated_fixed64(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    uint64_t dummy = 0;
-
-    /* Make it a packed field */
-    return pb_encode_tag(stream, PB_WT_STRING, field->tag) &&
-           pb_encode_varint(stream, 5 * 8) && /* Number of bytes */
-           pb_encode_fixed64(stream, &dummy) &&
-           pb_encode_fixed64(stream, &dummy) &&
-           pb_encode_fixed64(stream, &dummy) &&
-           pb_encode_fixed64(stream, &dummy) &&
-           pb_encode_fixed64(stream, *arg);
-}
-
-static bool write_repeated_string(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_string(stream, 0, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_string(stream, 0, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_string(stream, 0, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_string(stream, 0, 0) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_string(stream, *arg, strlen(*arg));
-}
-
-static bool write_repeated_submsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    SubMessage dummy = {""};
-
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, SubMessage_fields, &dummy) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, SubMessage_fields, *arg);
-}
-
-static bool write_limits(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    Limits limits = {0};
-    limits.int32_min  = INT32_MIN;
-    limits.int32_max  = INT32_MAX;
-    limits.uint32_min = 0;
-    limits.uint32_max = UINT32_MAX;
-    limits.int64_min  = INT64_MIN;
-    limits.int64_max  = INT64_MAX;
-    limits.uint64_min = 0;
-    limits.uint64_max = UINT64_MAX;
-    limits.enum_min   = HugeEnum_Negative;
-    limits.enum_max   = HugeEnum_Positive;
-   
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, Limits_fields, &limits);
-}
-
-static bool write_repeated_emptymsg(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
-{
-    EmptyMessage emptymsg = {0};
-    return pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg) &&
-           pb_encode_tag_for_field(stream, field) &&
-           pb_encode_submessage(stream, EmptyMessage_fields, &emptymsg);
-}
-
-int main(int argc, char **argv)
-{
-    int mode = (argc > 1) ? atoi(argv[1]) : 0;
-
-    /* Values for use from callbacks through pointers. */
-    uint32_t    req_fixed32     = 1008;
-    int32_t     req_sfixed32    = -1009;
-    float       req_float       = 1010.0f;
-    uint64_t    req_fixed64     = 1011;
-    int64_t     req_sfixed64    = -1012;
-    double      req_double      = 1013.0;
-    SubMessage  req_submsg      = {"1016", 1016};
-    
-    uint32_t    rep_fixed32     = 2008;
-    int32_t     rep_sfixed32    = -2009;
-    float       rep_float       = 2010.0f;
-    uint64_t    rep_fixed64     = 2011;
-    int64_t     rep_sfixed64    = -2012;
-    double      rep_double      = 2013.0;
-    SubMessage  rep_submsg      = {"2016", 2016, true, 2016};
-    
-    uint32_t    opt_fixed32     = 3048;
-    int32_t     opt_sfixed32    = 3049;
-    float       opt_float       = 3050.0f;
-    uint64_t    opt_fixed64     = 3051;
-    int64_t     opt_sfixed64    = 3052;
-    double      opt_double      = 3053.0f;
-    SubMessage  opt_submsg      = {"3056", 3056};
-    
-    /* Bind callbacks for required fields */
-    AllTypes alltypes = {{{0}}};
-    
-    alltypes.req_int32.funcs.encode = &write_varint;
-    alltypes.req_int32.arg = (void*)-1001;
-    
-    alltypes.req_int64.funcs.encode = &write_varint;
-    alltypes.req_int64.arg = (void*)-1002;
-    
-    alltypes.req_uint32.funcs.encode = &write_varint;
-    alltypes.req_uint32.arg = (void*)1003;
-
-    alltypes.req_uint32.funcs.encode = &write_varint;
-    alltypes.req_uint32.arg = (void*)1003;    
-    
-    alltypes.req_uint64.funcs.encode = &write_varint;
-    alltypes.req_uint64.arg = (void*)1004;
-    
-    alltypes.req_sint32.funcs.encode = &write_svarint;
-    alltypes.req_sint32.arg = (void*)-1005;   
-    
-    alltypes.req_sint64.funcs.encode = &write_svarint;
-    alltypes.req_sint64.arg = (void*)-1006;   
-    
-    alltypes.req_bool.funcs.encode = &write_varint;
-    alltypes.req_bool.arg = (void*)true;   
-    
-    alltypes.req_fixed32.funcs.encode = &write_fixed32;
-    alltypes.req_fixed32.arg = &req_fixed32;
-    
-    alltypes.req_sfixed32.funcs.encode = &write_fixed32;
-    alltypes.req_sfixed32.arg = &req_sfixed32;
-    
-    alltypes.req_float.funcs.encode = &write_fixed32;
-    alltypes.req_float.arg = &req_float;
-    
-    alltypes.req_fixed64.funcs.encode = &write_fixed64;
-    alltypes.req_fixed64.arg = &req_fixed64;
-    
-    alltypes.req_sfixed64.funcs.encode = &write_fixed64;
-    alltypes.req_sfixed64.arg = &req_sfixed64;
-    
-    alltypes.req_double.funcs.encode = &write_fixed64;
-    alltypes.req_double.arg = &req_double;
-    
-    alltypes.req_string.funcs.encode = &write_string;
-    alltypes.req_string.arg = "1014";
-    
-    alltypes.req_bytes.funcs.encode = &write_string;
-    alltypes.req_bytes.arg = "1015";
-    
-    alltypes.req_submsg.funcs.encode = &write_submsg;
-    alltypes.req_submsg.arg = &req_submsg;
-    
-    alltypes.req_enum.funcs.encode = &write_varint;
-    alltypes.req_enum.arg = (void*)MyEnum_Truth;
-    
-    alltypes.req_emptymsg.funcs.encode = &write_emptymsg;
-    
-    /* Bind callbacks for repeated fields */
-    alltypes.rep_int32.funcs.encode = &write_repeated_varint;
-    alltypes.rep_int32.arg = (void*)-2001;
-    
-    alltypes.rep_int64.funcs.encode = &write_repeated_varint;
-    alltypes.rep_int64.arg = (void*)-2002;
-    
-    alltypes.rep_uint32.funcs.encode = &write_repeated_varint;
-    alltypes.rep_uint32.arg = (void*)2003;
-    
-    alltypes.rep_uint64.funcs.encode = &write_repeated_varint;
-    alltypes.rep_uint64.arg = (void*)2004;
-    
-    alltypes.rep_sint32.funcs.encode = &write_repeated_svarint;
-    alltypes.rep_sint32.arg = (void*)-2005;
-    
-    alltypes.rep_sint64.funcs.encode = &write_repeated_svarint;
-    alltypes.rep_sint64.arg = (void*)-2006;
-    
-    alltypes.rep_bool.funcs.encode = &write_repeated_varint;
-    alltypes.rep_bool.arg = (void*)true;
-    
-    alltypes.rep_fixed32.funcs.encode = &write_repeated_fixed32;
-    alltypes.rep_fixed32.arg = &rep_fixed32;
-
-    alltypes.rep_sfixed32.funcs.encode = &write_repeated_fixed32;
-    alltypes.rep_sfixed32.arg = &rep_sfixed32;
-    
-    alltypes.rep_float.funcs.encode = &write_repeated_fixed32;
-    alltypes.rep_float.arg = &rep_float;
-    
-    alltypes.rep_fixed64.funcs.encode = &write_repeated_fixed64;
-    alltypes.rep_fixed64.arg = &rep_fixed64;
-
-    alltypes.rep_sfixed64.funcs.encode = &write_repeated_fixed64;
-    alltypes.rep_sfixed64.arg = &rep_sfixed64;
-    
-    alltypes.rep_double.funcs.encode = &write_repeated_fixed64;
-    alltypes.rep_double.arg = &rep_double;
-    
-    alltypes.rep_string.funcs.encode = &write_repeated_string;
-    alltypes.rep_string.arg = "2014";
-    
-    alltypes.rep_bytes.funcs.encode = &write_repeated_string;
-    alltypes.rep_bytes.arg = "2015";
-    
-    alltypes.rep_submsg.funcs.encode = &write_repeated_submsg;
-    alltypes.rep_submsg.arg = &rep_submsg;
-    
-    alltypes.rep_enum.funcs.encode = &write_repeated_varint;
-    alltypes.rep_enum.arg = (void*)MyEnum_Truth;
-    
-    alltypes.rep_emptymsg.funcs.encode = &write_repeated_emptymsg;
-    
-    alltypes.req_limits.funcs.encode = &write_limits;
-    
-    /* Bind callbacks for optional fields */
-    if (mode != 0)
-    {
-        alltypes.opt_int32.funcs.encode = &write_varint;
-        alltypes.opt_int32.arg = (void*)3041;
-        
-        alltypes.opt_int64.funcs.encode = &write_varint;
-        alltypes.opt_int64.arg = (void*)3042;
-        
-        alltypes.opt_uint32.funcs.encode = &write_varint;
-        alltypes.opt_uint32.arg = (void*)3043;
-        
-        alltypes.opt_uint64.funcs.encode = &write_varint;
-        alltypes.opt_uint64.arg = (void*)3044;
-        
-        alltypes.opt_sint32.funcs.encode = &write_svarint;
-        alltypes.opt_sint32.arg = (void*)3045;
-        
-        alltypes.opt_sint64.funcs.encode = &write_svarint;
-        alltypes.opt_sint64.arg = (void*)3046;
-        
-        alltypes.opt_bool.funcs.encode = &write_varint;
-        alltypes.opt_bool.arg = (void*)true;
-
-        alltypes.opt_fixed32.funcs.encode = &write_fixed32;
-        alltypes.opt_fixed32.arg = &opt_fixed32;
-        
-        alltypes.opt_sfixed32.funcs.encode = &write_fixed32;
-        alltypes.opt_sfixed32.arg = &opt_sfixed32;
-        
-        alltypes.opt_float.funcs.encode = &write_fixed32;
-        alltypes.opt_float.arg = &opt_float;
-        
-        alltypes.opt_fixed64.funcs.encode = &write_fixed64;
-        alltypes.opt_fixed64.arg = &opt_fixed64;
-        
-        alltypes.opt_sfixed64.funcs.encode = &write_fixed64;
-        alltypes.opt_sfixed64.arg = &opt_sfixed64;
-        
-        alltypes.opt_double.funcs.encode = &write_fixed64;
-        alltypes.opt_double.arg = &opt_double;
-        
-        alltypes.opt_string.funcs.encode = &write_string;
-        alltypes.opt_string.arg = "3054";
-        
-        alltypes.opt_bytes.funcs.encode = &write_string;
-        alltypes.opt_bytes.arg = "3055";
-        
-        alltypes.opt_submsg.funcs.encode = &write_submsg;
-        alltypes.opt_submsg.arg = &opt_submsg;
-        
-        alltypes.opt_enum.funcs.encode = &write_varint;
-        alltypes.opt_enum.arg = (void*)MyEnum_Truth;
-        
-        alltypes.opt_emptymsg.funcs.encode = &write_emptymsg;
-    }
-    
-    alltypes.end.funcs.encode = &write_varint;
-    alltypes.end.arg = (void*)1099;
-    
-    {
-        uint8_t buffer[2048];
-        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 */
-        }
-    }
-}

tests/alltypes_pointer/SConscript

@@ -1,48 +0,0 @@
-# Encode the AllTypes message using pointers for all fields, and verify the
-# output against the normal AllTypes test case.
-
-Import("env")
-
-# We need our own pb_decode.o for the malloc support
-env = env.Clone()
-env.Append(CPPDEFINES = {'PB_ENABLE_MALLOC': 1});
-
-# Disable libmudflap, because it will confuse valgrind
-# and other memory leak detection tools.
-if '-fmudflap' in env["CCFLAGS"]:
-    env["CCFLAGS"].remove("-fmudflap")
-    env["LINKFLAGS"].remove("-fmudflap")
-    env["LIBS"].remove("mudflap")
-
-strict = env.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_with_malloc.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_with_malloc.o", "$NANOPB/pb_encode.c")
-
-c = Copy("$TARGET", "$SOURCE")
-env.Command("alltypes.proto", "#alltypes/alltypes.proto", c)
-
-env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes_pointer.c", "alltypes.pb.c", "pb_encode_with_malloc.o"])
-dec = env.Program(["decode_alltypes_pointer.c", "alltypes.pb.c", "pb_decode_with_malloc.o"])
-
-# Encode and compare results to non-pointer alltypes test case
-env.RunTest(enc)
-env.Compare(["encode_alltypes_pointer.output", "$BUILD/alltypes/encode_alltypes.output"])
-
-# Decode (under valgrind if available)
-valgrind = env.WhereIs('valgrind')
-kwargs = {}
-if valgrind:
-    kwargs['COMMAND'] = valgrind
-    kwargs['ARGS'] = ["-q", dec[0].abspath]
-
-env.RunTest("decode_alltypes.output", [dec, "encode_alltypes_pointer.output"], **kwargs)
-
-# Do the same thing with the optional fields present
-env.RunTest("optionals.output", enc, ARGS = ['1'])
-env.Compare(["optionals.output", "$BUILD/alltypes/optionals.output"])
-
-kwargs['ARGS'] = kwargs.get('ARGS', []) + ['1']
-env.RunTest("optionals.decout", [dec, "optionals.output"], **kwargs)
-

tests/alltypes_pointer/alltypes.options

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

tests/alltypes_pointer/decode_alltypes_pointer.c

@@ -1,174 +0,0 @@
-#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)) { \
-    fprintf(stderr, "Test " #x " failed.\n"); \
-    status = 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)
-{
-    bool status = true;
-    AllTypes alltypes;
-    
-    /* Fill with garbage to better detect initialization errors */
-    memset(&alltypes, 0xAA, sizeof(alltypes));
-    alltypes.extensions = 0;
-    
-    if (!pb_decode(stream, AllTypes_fields, &alltypes))
-        return false;
-    
-    TEST(alltypes.req_int32     && *alltypes.req_int32         == -1001);
-    TEST(alltypes.req_int64     && *alltypes.req_int64         == -1002);
-    TEST(alltypes.req_uint32    && *alltypes.req_uint32        == 1003);
-    TEST(alltypes.req_uint64    && *alltypes.req_uint64        == 1004);
-    TEST(alltypes.req_sint32    && *alltypes.req_sint32        == -1005);
-    TEST(alltypes.req_sint64    && *alltypes.req_sint64        == -1006);
-    TEST(alltypes.req_bool      && *alltypes.req_bool          == true);
-    
-    TEST(alltypes.req_fixed32   && *alltypes.req_fixed32       == 1008);
-    TEST(alltypes.req_sfixed32  && *alltypes.req_sfixed32      == -1009);
-    TEST(alltypes.req_float     && *alltypes.req_float         == 1010.0f);
-    
-    TEST(alltypes.req_fixed64   && *alltypes.req_fixed64       == 1011);
-    TEST(alltypes.req_sfixed64  && *alltypes.req_sfixed64      == -1012);
-    TEST(alltypes.req_double    && *alltypes.req_double        == 1013.0f);
-    
-    TEST(alltypes.req_string    && strcmp(alltypes.req_string, "1014") == 0);
-    TEST(alltypes.req_bytes     && alltypes.req_bytes->size == 4);
-    TEST(alltypes.req_bytes     && memcmp(&alltypes.req_bytes->bytes, "1015", 4) == 0);
-    TEST(alltypes.req_submsg    && alltypes.req_submsg->substuff1
-                                && strcmp(alltypes.req_submsg->substuff1, "1016") == 0);
-    TEST(alltypes.req_submsg    && alltypes.req_submsg->substuff2
-                                && *alltypes.req_submsg->substuff2 == 1016);
-    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 == NULL);
-    
-    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 that optional values are not present */
-        TEST(alltypes.opt_int32         == NULL);
-        TEST(alltypes.opt_int64         == NULL);
-        TEST(alltypes.opt_uint32        == NULL);
-        TEST(alltypes.opt_uint64        == NULL);
-        TEST(alltypes.opt_sint32        == NULL);
-        TEST(alltypes.opt_sint64        == NULL);
-        TEST(alltypes.opt_bool          == NULL);
-        
-        TEST(alltypes.opt_fixed32       == NULL);
-        TEST(alltypes.opt_sfixed32      == NULL);
-        TEST(alltypes.opt_float         == NULL);
-        TEST(alltypes.opt_fixed64       == NULL);
-        TEST(alltypes.opt_sfixed64      == NULL);
-        TEST(alltypes.opt_double        == NULL);
-        
-        TEST(alltypes.opt_string        == NULL);
-        TEST(alltypes.opt_bytes         == NULL);
-        TEST(alltypes.opt_submsg        == NULL);
-        TEST(alltypes.opt_enum          == NULL);
-    }
-    else
-    {
-        /* Expect filled-in values */
-        TEST(alltypes.opt_int32 && *alltypes.opt_int32      == 3041);
-        TEST(alltypes.opt_int64 && *alltypes.opt_int64      == 3042);
-        TEST(alltypes.opt_uint32 && *alltypes.opt_uint32    == 3043);
-        TEST(alltypes.opt_uint64 && *alltypes.opt_uint64    == 3044);
-        TEST(alltypes.opt_sint32 && *alltypes.opt_sint32    == 3045);
-        TEST(alltypes.opt_sint64 && *alltypes.opt_sint64    == 3046);
-        TEST(alltypes.opt_bool && *alltypes.opt_bool        == true);
-        
-        TEST(alltypes.opt_fixed32 && *alltypes.opt_fixed32  == 3048);
-        TEST(alltypes.opt_sfixed32 && *alltypes.opt_sfixed32== 3049);
-        TEST(alltypes.opt_float && *alltypes.opt_float      == 3050.0f);
-        TEST(alltypes.opt_fixed64 && *alltypes.opt_fixed64  == 3051);
-        TEST(alltypes.opt_sfixed64 && *alltypes.opt_sfixed64== 3052);
-        TEST(alltypes.opt_double && *alltypes.opt_double    == 3053.0);
-        
-        TEST(alltypes.opt_string && strcmp(alltypes.opt_string, "3054") == 0);
-        TEST(alltypes.opt_bytes && alltypes.opt_bytes->size == 4);
-        TEST(alltypes.opt_bytes && memcmp(&alltypes.opt_bytes->bytes, "3055", 4) == 0);
-        TEST(alltypes.opt_submsg && strcmp(alltypes.opt_submsg->substuff1, "3056") == 0);
-        TEST(alltypes.opt_submsg && *alltypes.opt_submsg->substuff2 == 3056);
-        TEST(alltypes.opt_enum && *alltypes.opt_enum == MyEnum_Truth);
-        TEST(alltypes.opt_emptymsg);
-    }
-    
-    TEST(alltypes.req_limits->int32_min && *alltypes.req_limits->int32_min   == INT32_MIN);
-    TEST(alltypes.req_limits->int32_max && *alltypes.req_limits->int32_max   == INT32_MAX);
-    TEST(alltypes.req_limits->uint32_min && *alltypes.req_limits->uint32_min == 0);
-    TEST(alltypes.req_limits->uint32_max && *alltypes.req_limits->uint32_max == UINT32_MAX);
-    TEST(alltypes.req_limits->int64_min && *alltypes.req_limits->int64_min   == INT64_MIN);
-    TEST(alltypes.req_limits->int64_max && *alltypes.req_limits->int64_max   == INT64_MAX);
-    TEST(alltypes.req_limits->uint64_min && *alltypes.req_limits->uint64_min == 0);
-    TEST(alltypes.req_limits->uint64_max && *alltypes.req_limits->uint64_max == UINT64_MAX);
-    TEST(alltypes.req_limits->enum_min && *alltypes.req_limits->enum_min     == HugeEnum_Negative);
-    TEST(alltypes.req_limits->enum_max && *alltypes.req_limits->enum_max     == HugeEnum_Positive);
-    
-    TEST(alltypes.end && *alltypes.end == 1099);
-
-    pb_release(AllTypes_fields, &alltypes);
-
-    return status;
-}
-
-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 verify the message */
-    if (!check_alltypes(&stream, mode))
-    {
-        fprintf(stderr, "Test failed: %s\n", PB_GET_ERROR(&stream));
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
-}

tests/alltypes_pointer/encode_alltypes_pointer.c

@@ -1,188 +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;
-    
-    /* Values for required fields */
-    int32_t     req_int32         = -1001;
-    int64_t     req_int64         = -1002;
-    uint32_t    req_uint32        = 1003;
-    uint64_t    req_uint64        = 1004;
-    int32_t     req_sint32        = -1005;
-    int64_t     req_sint64        = -1006;
-    bool        req_bool          = true;
-    uint32_t    req_fixed32       = 1008;
-    int32_t     req_sfixed32      = -1009;
-    float       req_float         = 1010.0f;
-    uint64_t    req_fixed64       = 1011;
-    int64_t     req_sfixed64      = -1012;
-    double      req_double        = 1013.0;
-    char*       req_string        = "1014";
-    PB_BYTES_ARRAY_T(4) req_bytes = {4, {'1', '0', '1', '5'}};
-    static int32_t req_substuff   = 1016;
-    SubMessage  req_submsg        = {"1016", &req_substuff};
-    MyEnum      req_enum          = MyEnum_Truth;
-    EmptyMessage req_emptymsg     = {0};
-    
-    int32_t     end               = 1099;
-
-    /* Values for repeated fields */
-    int32_t     rep_int32[5]      = {0, 0, 0, 0, -2001};
-    int64_t     rep_int64[5]      = {0, 0, 0, 0, -2002};
-    uint32_t    rep_uint32[5]     = {0, 0, 0, 0, 2003};
-    uint64_t    rep_uint64[5]     = {0, 0, 0, 0, 2004};
-    int32_t     rep_sint32[5]     = {0, 0, 0, 0, -2005};
-    int64_t     rep_sint64[5]     = {0, 0, 0, 0, -2006};
-    bool        rep_bool[5]       = {false, false, false, false, true};
-    uint32_t    rep_fixed32[5]    = {0, 0, 0, 0, 2008};
-    int32_t     rep_sfixed32[5]   = {0, 0, 0, 0, -2009};
-    float       rep_float[5]      = {0, 0, 0, 0, 2010.0f};
-    uint64_t    rep_fixed64[5]    = {0, 0, 0, 0, 2011};
-    int64_t     rep_sfixed64[5]   = {0, 0, 0, 0, -2012};
-    double      rep_double[5]     = {0, 0, 0, 0, 2013.0f};
-    char*       rep_string[5]     = {"", "", "", "", "2014"};
-    static PB_BYTES_ARRAY_T(4) rep_bytes_4 = {4, {'2', '0', '1', '5'}};
-    pb_bytes_array_t *rep_bytes[5]= {NULL, NULL, NULL, NULL, (pb_bytes_array_t*)&rep_bytes_4};
-    static int32_t rep_sub2zero   = 0;
-    static int32_t rep_substuff2  = 2016;
-    static uint32_t rep_substuff3 = 2016;
-    SubMessage  rep_submsg[5]     = {{"", &rep_sub2zero},
-                                     {"", &rep_sub2zero},
-                                     {"", &rep_sub2zero},
-                                     {"", &rep_sub2zero},
-                                     {"2016", &rep_substuff2, &rep_substuff3}};
-    MyEnum      rep_enum[5]       = {0, 0, 0, 0, MyEnum_Truth};
-    EmptyMessage rep_emptymsg[5]  = {{0}, {0}, {0}, {0}, {0}};
-
-    /* Values for optional fields */
-    int32_t     opt_int32         = 3041;
-    int64_t     opt_int64         = 3042;
-    uint32_t    opt_uint32        = 3043;
-    uint64_t    opt_uint64        = 3044;
-    int32_t     opt_sint32        = 3045;
-    int64_t     opt_sint64        = 3046;
-    bool        opt_bool          = true;
-    uint32_t    opt_fixed32       = 3048;
-    int32_t     opt_sfixed32      = 3049;
-    float       opt_float         = 3050.0f;
-    uint64_t    opt_fixed64       = 3051;
-    int64_t     opt_sfixed64      = 3052;
-    double      opt_double        = 3053.0;
-    char*       opt_string        = "3054";
-    PB_BYTES_ARRAY_T(4) opt_bytes = {4, {'3', '0', '5', '5'}};
-    static int32_t opt_substuff   = 3056;
-    SubMessage  opt_submsg        = {"3056", &opt_substuff};
-    MyEnum      opt_enum          = MyEnum_Truth;
-    EmptyMessage opt_emptymsg     = {0};
-
-    /* Values for the Limits message. */
-    static int32_t  int32_min  = INT32_MIN;
-    static int32_t  int32_max  = INT32_MAX;
-    static uint32_t uint32_min = 0;
-    static uint32_t uint32_max = UINT32_MAX;
-    static int64_t  int64_min  = INT64_MIN;
-    static int64_t  int64_max  = INT64_MAX;
-    static uint64_t uint64_min = 0;
-    static uint64_t uint64_max = UINT64_MAX;
-    static HugeEnum enum_min   = HugeEnum_Negative;
-    static HugeEnum enum_max   = HugeEnum_Positive;
-    Limits req_limits = {&int32_min,    &int32_max,
-                         &uint32_min,   &uint32_max,
-                         &int64_min,    &int64_max,
-                         &uint64_min,   &uint64_max,
-                         &enum_min,     &enum_max};
-
-    /* Initialize the message struct with pointers to the fields. */
-    AllTypes alltypes = {0};
-
-    alltypes.req_int32         = &req_int32;
-    alltypes.req_int64         = &req_int64;
-    alltypes.req_uint32        = &req_uint32;
-    alltypes.req_uint64        = &req_uint64;
-    alltypes.req_sint32        = &req_sint32;
-    alltypes.req_sint64        = &req_sint64;
-    alltypes.req_bool          = &req_bool;
-    alltypes.req_fixed32       = &req_fixed32;
-    alltypes.req_sfixed32      = &req_sfixed32;
-    alltypes.req_float         = &req_float;
-    alltypes.req_fixed64       = &req_fixed64;
-    alltypes.req_sfixed64      = &req_sfixed64;
-    alltypes.req_double        = &req_double;
-    alltypes.req_string        = req_string;
-    alltypes.req_bytes         = (pb_bytes_array_t*)&req_bytes;
-    alltypes.req_submsg        = &req_submsg;
-    alltypes.req_enum          = &req_enum;
-    alltypes.req_emptymsg      = &req_emptymsg;
-    alltypes.req_limits        = &req_limits;
-    
-    alltypes.rep_int32_count    = 5; alltypes.rep_int32     = rep_int32;
-    alltypes.rep_int64_count    = 5; alltypes.rep_int64     = rep_int64;
-    alltypes.rep_uint32_count   = 5; alltypes.rep_uint32    = rep_uint32;
-    alltypes.rep_uint64_count   = 5; alltypes.rep_uint64    = rep_uint64;
-    alltypes.rep_sint32_count   = 5; alltypes.rep_sint32    = rep_sint32;
-    alltypes.rep_sint64_count   = 5; alltypes.rep_sint64    = rep_sint64;
-    alltypes.rep_bool_count     = 5; alltypes.rep_bool      = rep_bool;
-    alltypes.rep_fixed32_count  = 5; alltypes.rep_fixed32   = rep_fixed32;
-    alltypes.rep_sfixed32_count = 5; alltypes.rep_sfixed32  = rep_sfixed32;
-    alltypes.rep_float_count    = 5; alltypes.rep_float     = rep_float;
-    alltypes.rep_fixed64_count  = 5; alltypes.rep_fixed64   = rep_fixed64;
-    alltypes.rep_sfixed64_count = 5; alltypes.rep_sfixed64  = rep_sfixed64;
-    alltypes.rep_double_count   = 5; alltypes.rep_double    = rep_double;
-    alltypes.rep_string_count   = 5; alltypes.rep_string    = rep_string;
-    alltypes.rep_bytes_count    = 5; alltypes.rep_bytes     = rep_bytes;
-    alltypes.rep_submsg_count   = 5; alltypes.rep_submsg    = rep_submsg;
-    alltypes.rep_enum_count     = 5; alltypes.rep_enum      = rep_enum;
-    alltypes.rep_emptymsg_count = 5; alltypes.rep_emptymsg  = rep_emptymsg;
-    
-    if (mode != 0)
-    {
-        /* Fill in values for optional fields */
-        alltypes.opt_int32         = &opt_int32;
-        alltypes.opt_int64         = &opt_int64;
-        alltypes.opt_uint32        = &opt_uint32;
-        alltypes.opt_uint64        = &opt_uint64;
-        alltypes.opt_sint32        = &opt_sint32;
-        alltypes.opt_sint64        = &opt_sint64;
-        alltypes.opt_bool          = &opt_bool;
-        alltypes.opt_fixed32       = &opt_fixed32;
-        alltypes.opt_sfixed32      = &opt_sfixed32;
-        alltypes.opt_float         = &opt_float;
-        alltypes.opt_fixed64       = &opt_fixed64;
-        alltypes.opt_sfixed64      = &opt_sfixed64;
-        alltypes.opt_double        = &opt_double;
-        alltypes.opt_string        = opt_string;
-        alltypes.opt_bytes         = (pb_bytes_array_t*)&opt_bytes;
-        alltypes.opt_submsg        = &opt_submsg;
-        alltypes.opt_enum          = &opt_enum;
-        alltypes.opt_emptymsg      = &opt_emptymsg;
-    }
-    
-    alltypes.end = &end;
-    
-    {
-        uint8_t buffer[4096];
-        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 */
-        }
-    }
-}

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"])
-

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
-};
-

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"])
-

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"])
-

tests/bc_alltypes.pb.c

@@ -0,0 +1,326 @@
+/* Automatically generated nanopb constant definitions */
+#include "bc_alltypes.pb.h"
+
+const char SubMessage_substuff1_default[17] = "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[17] = "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] = {
+    {1, PB_HTYPE_REQUIRED | PB_LTYPE_STRING,
+    offsetof(SubMessage, substuff1), 0,
+    pb_membersize(SubMessage, substuff1), 0,
+    &SubMessage_substuff1_default},
+
+    {2, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    pb_delta_end(SubMessage, substuff2, substuff1), 0,
+    pb_membersize(SubMessage, substuff2), 0,
+    &SubMessage_substuff2_default},
+
+    {3, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED32,
+    pb_delta_end(SubMessage, substuff3, substuff2),
+    pb_delta(SubMessage, has_substuff3, substuff3),
+    pb_membersize(SubMessage, substuff3), 0,
+    &SubMessage_substuff3_default},
+
+    PB_LAST_FIELD
+};
+
+const pb_field_t AllTypes_fields[53] = {
+    {1, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    offsetof(AllTypes, req_int32), 0,
+    pb_membersize(AllTypes, req_int32), 0, 0},
+
+    {2, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, req_int64, req_int32), 0,
+    pb_membersize(AllTypes, req_int64), 0, 0},
+
+    {3, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, req_uint32, req_int64), 0,
+    pb_membersize(AllTypes, req_uint32), 0, 0},
+
+    {4, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, req_uint64, req_uint32), 0,
+    pb_membersize(AllTypes, req_uint64), 0, 0},
+
+    {5, PB_HTYPE_REQUIRED | PB_LTYPE_SVARINT,
+    pb_delta_end(AllTypes, req_sint32, req_uint64), 0,
+    pb_membersize(AllTypes, req_sint32), 0, 0},
+
+    {6, PB_HTYPE_REQUIRED | PB_LTYPE_SVARINT,
+    pb_delta_end(AllTypes, req_sint64, req_sint32), 0,
+    pb_membersize(AllTypes, req_sint64), 0, 0},
+
+    {7, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, req_bool, req_sint64), 0,
+    pb_membersize(AllTypes, req_bool), 0, 0},
+
+    {8, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, req_fixed32, req_bool), 0,
+    pb_membersize(AllTypes, req_fixed32), 0, 0},
+
+    {9, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, req_sfixed32, req_fixed32), 0,
+    pb_membersize(AllTypes, req_sfixed32), 0, 0},
+
+    {10, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, req_float, req_sfixed32), 0,
+    pb_membersize(AllTypes, req_float), 0, 0},
+
+    {11, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, req_fixed64, req_float), 0,
+    pb_membersize(AllTypes, req_fixed64), 0, 0},
+
+    {12, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, req_sfixed64, req_fixed64), 0,
+    pb_membersize(AllTypes, req_sfixed64), 0, 0},
+
+    {13, PB_HTYPE_REQUIRED | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, req_double, req_sfixed64), 0,
+    pb_membersize(AllTypes, req_double), 0, 0},
+
+    {14, PB_HTYPE_REQUIRED | PB_LTYPE_STRING,
+    pb_delta_end(AllTypes, req_string, req_double), 0,
+    pb_membersize(AllTypes, req_string), 0, 0},
+
+    {15, PB_HTYPE_REQUIRED | PB_LTYPE_BYTES,
+    pb_delta_end(AllTypes, req_bytes, req_string), 0,
+    pb_membersize(AllTypes, req_bytes), 0, 0},
+
+    {16, PB_HTYPE_REQUIRED | PB_LTYPE_SUBMESSAGE,
+    pb_delta_end(AllTypes, req_submsg, req_bytes), 0,
+    pb_membersize(AllTypes, req_submsg), 0,
+    &SubMessage_fields},
+
+    {17, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, req_enum, req_submsg), 0,
+    pb_membersize(AllTypes, req_enum), 0, 0},
+
+    {21, PB_HTYPE_ARRAY | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, rep_int32, req_enum),
+    pb_delta(AllTypes, rep_int32_count, rep_int32),
+    pb_membersize(AllTypes, rep_int32[0]),
+    pb_membersize(AllTypes, rep_int32) / pb_membersize(AllTypes, rep_int32[0]), 0},
+
+    {22, PB_HTYPE_ARRAY | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, rep_int64, rep_int32),
+    pb_delta(AllTypes, rep_int64_count, rep_int64),
+    pb_membersize(AllTypes, rep_int64[0]),
+    pb_membersize(AllTypes, rep_int64) / pb_membersize(AllTypes, rep_int64[0]), 0},
+
+    {23, PB_HTYPE_ARRAY | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, rep_uint32, rep_int64),
+    pb_delta(AllTypes, rep_uint32_count, rep_uint32),
+    pb_membersize(AllTypes, rep_uint32[0]),
+    pb_membersize(AllTypes, rep_uint32) / pb_membersize(AllTypes, rep_uint32[0]), 0},
+
+    {24, PB_HTYPE_ARRAY | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, rep_uint64, rep_uint32),
+    pb_delta(AllTypes, rep_uint64_count, rep_uint64),
+    pb_membersize(AllTypes, rep_uint64[0]),
+    pb_membersize(AllTypes, rep_uint64) / pb_membersize(AllTypes, rep_uint64[0]), 0},
+
+    {25, PB_HTYPE_ARRAY | PB_LTYPE_SVARINT,
+    pb_delta_end(AllTypes, rep_sint32, rep_uint64),
+    pb_delta(AllTypes, rep_sint32_count, rep_sint32),
+    pb_membersize(AllTypes, rep_sint32[0]),
+    pb_membersize(AllTypes, rep_sint32) / pb_membersize(AllTypes, rep_sint32[0]), 0},
+
+    {26, PB_HTYPE_ARRAY | PB_LTYPE_SVARINT,
+    pb_delta_end(AllTypes, rep_sint64, rep_sint32),
+    pb_delta(AllTypes, rep_sint64_count, rep_sint64),
+    pb_membersize(AllTypes, rep_sint64[0]),
+    pb_membersize(AllTypes, rep_sint64) / pb_membersize(AllTypes, rep_sint64[0]), 0},
+
+    {27, PB_HTYPE_ARRAY | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, rep_bool, rep_sint64),
+    pb_delta(AllTypes, rep_bool_count, rep_bool),
+    pb_membersize(AllTypes, rep_bool[0]),
+    pb_membersize(AllTypes, rep_bool) / pb_membersize(AllTypes, rep_bool[0]), 0},
+
+    {28, PB_HTYPE_ARRAY | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, rep_fixed32, rep_bool),
+    pb_delta(AllTypes, rep_fixed32_count, rep_fixed32),
+    pb_membersize(AllTypes, rep_fixed32[0]),
+    pb_membersize(AllTypes, rep_fixed32) / pb_membersize(AllTypes, rep_fixed32[0]), 0},
+
+    {29, PB_HTYPE_ARRAY | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, rep_sfixed32, rep_fixed32),
+    pb_delta(AllTypes, rep_sfixed32_count, rep_sfixed32),
+    pb_membersize(AllTypes, rep_sfixed32[0]),
+    pb_membersize(AllTypes, rep_sfixed32) / pb_membersize(AllTypes, rep_sfixed32[0]), 0},
+
+    {30, PB_HTYPE_ARRAY | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, rep_float, rep_sfixed32),
+    pb_delta(AllTypes, rep_float_count, rep_float),
+    pb_membersize(AllTypes, rep_float[0]),
+    pb_membersize(AllTypes, rep_float) / pb_membersize(AllTypes, rep_float[0]), 0},
+
+    {31, PB_HTYPE_ARRAY | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, rep_fixed64, rep_float),
+    pb_delta(AllTypes, rep_fixed64_count, rep_fixed64),
+    pb_membersize(AllTypes, rep_fixed64[0]),
+    pb_membersize(AllTypes, rep_fixed64) / pb_membersize(AllTypes, rep_fixed64[0]), 0},
+
+    {32, PB_HTYPE_ARRAY | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, rep_sfixed64, rep_fixed64),
+    pb_delta(AllTypes, rep_sfixed64_count, rep_sfixed64),
+    pb_membersize(AllTypes, rep_sfixed64[0]),
+    pb_membersize(AllTypes, rep_sfixed64) / pb_membersize(AllTypes, rep_sfixed64[0]), 0},
+
+    {33, PB_HTYPE_ARRAY | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, rep_double, rep_sfixed64),
+    pb_delta(AllTypes, rep_double_count, rep_double),
+    pb_membersize(AllTypes, rep_double[0]),
+    pb_membersize(AllTypes, rep_double) / pb_membersize(AllTypes, rep_double[0]), 0},
+
+    {34, PB_HTYPE_ARRAY | PB_LTYPE_STRING,
+    pb_delta_end(AllTypes, rep_string, rep_double),
+    pb_delta(AllTypes, rep_string_count, rep_string),
+    pb_membersize(AllTypes, rep_string[0]),
+    pb_membersize(AllTypes, rep_string) / pb_membersize(AllTypes, rep_string[0]), 0},
+
+    {35, PB_HTYPE_ARRAY | PB_LTYPE_BYTES,
+    pb_delta_end(AllTypes, rep_bytes, rep_string),
+    pb_delta(AllTypes, rep_bytes_count, rep_bytes),
+    pb_membersize(AllTypes, rep_bytes[0]),
+    pb_membersize(AllTypes, rep_bytes) / pb_membersize(AllTypes, rep_bytes[0]), 0},
+
+    {36, PB_HTYPE_ARRAY | PB_LTYPE_SUBMESSAGE,
+    pb_delta_end(AllTypes, rep_submsg, rep_bytes),
+    pb_delta(AllTypes, rep_submsg_count, rep_submsg),
+    pb_membersize(AllTypes, rep_submsg[0]),
+    pb_membersize(AllTypes, rep_submsg) / pb_membersize(AllTypes, rep_submsg[0]),
+    &SubMessage_fields},
+
+    {37, PB_HTYPE_ARRAY | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, rep_enum, rep_submsg),
+    pb_delta(AllTypes, rep_enum_count, rep_enum),
+    pb_membersize(AllTypes, rep_enum[0]),
+    pb_membersize(AllTypes, rep_enum) / pb_membersize(AllTypes, rep_enum[0]), 0},
+
+    {41, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, opt_int32, rep_enum),
+    pb_delta(AllTypes, has_opt_int32, opt_int32),
+    pb_membersize(AllTypes, opt_int32), 0,
+    &AllTypes_opt_int32_default},
+
+    {42, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, opt_int64, opt_int32),
+    pb_delta(AllTypes, has_opt_int64, opt_int64),
+    pb_membersize(AllTypes, opt_int64), 0,
+    &AllTypes_opt_int64_default},
+
+    {43, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, opt_uint32, opt_int64),
+    pb_delta(AllTypes, has_opt_uint32, opt_uint32),
+    pb_membersize(AllTypes, opt_uint32), 0,
+    &AllTypes_opt_uint32_default},
+
+    {44, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, opt_uint64, opt_uint32),
+    pb_delta(AllTypes, has_opt_uint64, opt_uint64),
+    pb_membersize(AllTypes, opt_uint64), 0,
+    &AllTypes_opt_uint64_default},
+
+    {45, PB_HTYPE_OPTIONAL | PB_LTYPE_SVARINT,
+    pb_delta_end(AllTypes, opt_sint32, opt_uint64),
+    pb_delta(AllTypes, has_opt_sint32, opt_sint32),
+    pb_membersize(AllTypes, opt_sint32), 0,
+    &AllTypes_opt_sint32_default},
+
+    {46, PB_HTYPE_OPTIONAL | PB_LTYPE_SVARINT,
+    pb_delta_end(AllTypes, opt_sint64, opt_sint32),
+    pb_delta(AllTypes, has_opt_sint64, opt_sint64),
+    pb_membersize(AllTypes, opt_sint64), 0,
+    &AllTypes_opt_sint64_default},
+
+    {47, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, opt_bool, opt_sint64),
+    pb_delta(AllTypes, has_opt_bool, opt_bool),
+    pb_membersize(AllTypes, opt_bool), 0,
+    &AllTypes_opt_bool_default},
+
+    {48, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, opt_fixed32, opt_bool),
+    pb_delta(AllTypes, has_opt_fixed32, opt_fixed32),
+    pb_membersize(AllTypes, opt_fixed32), 0,
+    &AllTypes_opt_fixed32_default},
+
+    {49, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, opt_sfixed32, opt_fixed32),
+    pb_delta(AllTypes, has_opt_sfixed32, opt_sfixed32),
+    pb_membersize(AllTypes, opt_sfixed32), 0,
+    &AllTypes_opt_sfixed32_default},
+
+    {50, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED32,
+    pb_delta_end(AllTypes, opt_float, opt_sfixed32),
+    pb_delta(AllTypes, has_opt_float, opt_float),
+    pb_membersize(AllTypes, opt_float), 0,
+    &AllTypes_opt_float_default},
+
+    {51, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, opt_fixed64, opt_float),
+    pb_delta(AllTypes, has_opt_fixed64, opt_fixed64),
+    pb_membersize(AllTypes, opt_fixed64), 0,
+    &AllTypes_opt_fixed64_default},
+
+    {52, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, opt_sfixed64, opt_fixed64),
+    pb_delta(AllTypes, has_opt_sfixed64, opt_sfixed64),
+    pb_membersize(AllTypes, opt_sfixed64), 0,
+    &AllTypes_opt_sfixed64_default},
+
+    {53, PB_HTYPE_OPTIONAL | PB_LTYPE_FIXED64,
+    pb_delta_end(AllTypes, opt_double, opt_sfixed64),
+    pb_delta(AllTypes, has_opt_double, opt_double),
+    pb_membersize(AllTypes, opt_double), 0,
+    &AllTypes_opt_double_default},
+
+    {54, PB_HTYPE_OPTIONAL | PB_LTYPE_STRING,
+    pb_delta_end(AllTypes, opt_string, opt_double),
+    pb_delta(AllTypes, has_opt_string, opt_string),
+    pb_membersize(AllTypes, opt_string), 0,
+    &AllTypes_opt_string_default},
+
+    {55, PB_HTYPE_OPTIONAL | PB_LTYPE_BYTES,
+    pb_delta_end(AllTypes, opt_bytes, opt_string),
+    pb_delta(AllTypes, has_opt_bytes, opt_bytes),
+    pb_membersize(AllTypes, opt_bytes), 0,
+    &AllTypes_opt_bytes_default},
+
+    {56, PB_HTYPE_OPTIONAL | PB_LTYPE_SUBMESSAGE,
+    pb_delta_end(AllTypes, opt_submsg, opt_bytes),
+    pb_delta(AllTypes, has_opt_submsg, opt_submsg),
+    pb_membersize(AllTypes, opt_submsg), 0,
+    &SubMessage_fields},
+
+    {57, PB_HTYPE_OPTIONAL | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, opt_enum, opt_submsg),
+    pb_delta(AllTypes, has_opt_enum, opt_enum),
+    pb_membersize(AllTypes, opt_enum), 0,
+    &AllTypes_opt_enum_default},
+
+    {99, PB_HTYPE_REQUIRED | PB_LTYPE_VARINT,
+    pb_delta_end(AllTypes, end, opt_enum), 0,
+    pb_membersize(AllTypes, end), 0, 0},
+
+    PB_LAST_FIELD
+};
+

tests/bc_alltypes.pb.h

@@ -1,19 +1,14 @@
 /* Automatically generated nanopb header */
-/* This is a file generated using nanopb-0.2.0-dev.
+/* This is a file generated using nanopb-0.1.1.
  * 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_
+#ifndef _PB_BC_ALLTYPES_PB_H_
+#define _PB_BC_ALLTYPES_PB_H_
 #include <pb.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* Enum definitions */
-typedef enum _MyEnum {
+typedef enum {
     MyEnum_Zero = 0,
     MyEnum_First = 1,
     MyEnum_Second = 2,
@@ -21,7 +16,7 @@ typedef enum _MyEnum {
 } MyEnum;
 
 /* Struct definitions */
-typedef struct _SubMessage {
+typedef struct {
     char substuff1[16];
     int32_t substuff2;
     bool has_substuff3;
@@ -43,7 +38,7 @@ typedef struct {
     uint8_t bytes[16];
 } AllTypes_opt_bytes_t;
 
-typedef struct _AllTypes {
+typedef struct {
     int32_t req_int32;
     int64_t req_int64;
     uint32_t req_uint32;
@@ -133,7 +128,7 @@ typedef struct _AllTypes {
 } AllTypes;
 
 /* Default values for struct fields */
-extern const char SubMessage_substuff1_default[16];
+extern const char SubMessage_substuff1_default[17];
 extern const int32_t SubMessage_substuff2_default;
 extern const uint32_t SubMessage_substuff3_default;
 extern const int32_t AllTypes_opt_int32_default;
@@ -149,7 +144,7 @@ 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 char AllTypes_opt_string_default[17];
 extern const AllTypes_opt_bytes_t AllTypes_opt_bytes_default;
 extern const MyEnum AllTypes_opt_enum_default;
 
@@ -157,22 +152,4 @@ extern const MyEnum AllTypes_opt_enum_default;
 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

tests/bc_decode.c

@@ -1,17 +1,16 @@
 /* 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.
+ * This is a backwards-compatibility test, using bc_alltypes.pb.h.
+ * It is similar to test_decode3, but duplicated in order to allow
+ * test_decode3 to test any new features introduced later.
  *
- * Run e.g. ./encode_legacy | ./decode_legacy
+ * Run e.g. ./bc_encode | ./bc_decode
  */
 
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <pb_decode.h>
-#include "alltypes_legacy.h"
-#include "test_helpers.h"
+#include "bc_alltypes.pb.h"
 
 #define TEST(x) if (!(x)) { \
     printf("Test " #x " failed.\n"); \
@@ -177,19 +176,15 @@ bool check_alltypes(pb_istream_t *stream, int mode)
 
 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);
+    uint8_t buffer[1024];
+    size_t count = fread(buffer, 1, sizeof(buffer), stdin);
     
     /* Construct a pb_istream_t for reading from the buffer */
-    stream = pb_istream_from_buffer(buffer, count);
+    pb_istream_t stream = pb_istream_from_buffer(buffer, count);
     
     /* Decode and print out the stuff */
     if (!check_alltypes(&stream, mode))

tests/bc_encode.c

@@ -1,15 +1,14 @@
 /* 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.
+ * This is a backwards-compatibility test, using bc_alltypes.pb.h.
+ * It is similar to test_encode3, but duplicated in order to allow
+ * test_encode3 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"
+#include "bc_alltypes.pb.h"
 
 int main(int argc, char **argv)
 {
@@ -114,22 +113,19 @@ int main(int argc, char **argv)
     }
     
     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 */
-        }
+    
+    uint8_t buffer[1024];
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+    
+    /* Now encode it and check if we succeeded. */
+    if (pb_encode(&stream, AllTypes_fields, &alltypes))
+    {
+        fwrite(buffer, 1, stream.bytes_written, stdout);
+        return 0; /* Success */
+    }
+    else
+    {
+        fprintf(stderr, "Encoding failed!\n");
+        return 1; /* Failure */
     }
 }

tests/buffer_only/SConscript

@@ -1,27 +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("alltypes.pb.h", "$BUILD/alltypes/alltypes.pb.h", c)
-env.Command("alltypes.pb.c", "$BUILD/alltypes/alltypes.pb.c", c)
-env.Command("encode_alltypes.c", "$BUILD/alltypes/encode_alltypes.c", c)
-env.Command("decode_alltypes.c", "$BUILD/alltypes/decode_alltypes.c", c)
-
-# Define the compilation options
-opts = env.Clone()
-opts.Append(CPPDEFINES = {'PB_BUFFER_ONLY': 1})
-
-# Build new version of core
-strict = opts.Clone()
-strict.Append(CFLAGS = strict['CORECFLAGS'])
-strict.Object("pb_decode_bufonly.o", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode_bufonly.o", "$NANOPB/pb_encode.c")
-
-# Now build and run the test normally.
-enc = opts.Program(["encode_alltypes.c", "alltypes.pb.c", "pb_encode_bufonly.o"])
-dec = opts.Program(["decode_alltypes.c", "alltypes.pb.c", "pb_decode_bufonly.o"])
-
-env.RunTest(enc)
-env.RunTest([dec, "encode_alltypes.output"])

tests/callbacks.proto

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

tests/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"])
-

tests/callbacks/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;
-}
-

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", "$NANOPB/pb_decode.c")
-strict.Object("pb_encode.o", "$NANOPB/pb_encode.c")
-

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

tests/cxx_main_program/SConscript

@@ -1,24 +0,0 @@
-# Run the alltypes test case, but compile it as C++ instead.
-# In fact, compile the entire nanopb using C++ compiler.
-
-Import("env")
-
-# This is needed to get INT32_MIN etc. macros defined
-env = env.Clone()
-env.Append(CPPDEFINES = ['__STDC_LIMIT_MACROS'])
-
-# 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", "$BUILD/alltypes/alltypes.pb.h", c)
-env.Command("alltypes.pb.cxx", "$BUILD/alltypes/alltypes.pb.c", c)
-env.Command("encode_alltypes.cxx", "$BUILD/alltypes/encode_alltypes.c", c)
-env.Command("decode_alltypes.cxx", "$BUILD/alltypes/decode_alltypes.c", c)
-
-# Now build and run the test normally.
-enc = env.Program(["encode_alltypes.cxx", "alltypes.pb.cxx", "pb_encode.cxx"])
-dec = env.Program(["decode_alltypes.cxx", "alltypes.pb.cxx", "pb_decode.cxx"])
-
-env.RunTest(enc)
-env.RunTest([dec, "encode_alltypes.output"])

tests/decode_unittests.c

@@ -1,9 +1,8 @@
-/* This includes the whole .c file to get access to static functions. */
-#define PB_ENABLE_MALLOC
-#include "pb_decode.c"
+#define NANOPB_INTERNALS
 
 #include <stdio.h>
 #include <string.h>
+#include "pb_decode.h"
 #include "unittests.h"
 #include "unittestproto.pb.h"
 
@@ -20,11 +19,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++)
     {
@@ -290,38 +289,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)
-    }
-    
-    {
-        pb_istream_t s = {0};
-        void *data = NULL;
-        
-        COMMENT("Testing allocate_field")
-        TEST(allocate_field(&s, &data, 10, 10) && data != NULL);
-        TEST(allocate_field(&s, &data, 10, 20) && data != NULL);
-        
-        {
-            void *oldvalue = data;
-            size_t very_big = (size_t)-1;
-            size_t somewhat_big = very_big / 2 + 1;
-            size_t not_so_big = (size_t)1 << (4 * sizeof(size_t));
-        
-            TEST(!allocate_field(&s, &data, very_big, 2) && data == oldvalue);
-            TEST(!allocate_field(&s, &data, somewhat_big, 2) && data == oldvalue);
-            TEST(!allocate_field(&s, &data, not_so_big, not_so_big) && data == oldvalue);
-        }
-        
-        pb_free(data);
-    }
-    
     if (status != 0)
         fprintf(stdout, "\n\nSome tests FAILED!\n");
     

tests/decode_unittests/SConscript

@@ -1,4 +0,0 @@
-Import('env')
-p = env.Program(["decode_unittests.c", "$COMMON/unittestproto.pb.c"])
-env.RunTest(p)
-

tests/encode_unittests.c

@@ -1,8 +1,8 @@
-/* This includes the whole .c file to get access to static functions. */
-#include "pb_encode.c"
+#define NANOPB_INTERNALS
 
 #include <stdio.h>
 #include <string.h>
+#include "pb_encode.h"
 #include "unittests.h"
 #include "unittestproto.pb.h"
 
@@ -17,7 +17,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 +25,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;
@@ -172,22 +172,20 @@ int main()
         struct { size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
     
         COMMENT("Test pb_enc_bytes")
-        TEST(WRITES(pb_enc_bytes(&s, &BytesMessage_fields[0], &value), "\x05xyzzy"))
+        TEST(WRITES(pb_enc_bytes(&s, NULL, &value), "\x05xyzzy"))
         value.size = 0;
-        TEST(WRITES(pb_enc_bytes(&s, &BytesMessage_fields[0], &value), "\x00"))
+        TEST(WRITES(pb_enc_bytes(&s, NULL, &value), "\x00"))
     }
     
     {
         uint8_t buffer[30];
         pb_ostream_t s;
-        char value[30] = "xyzzy";
+        char value[] = "xyzzy";
         
         COMMENT("Test pb_enc_string")
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x05xyzzy"))
+        TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x05xyzzy"))
         value[0] = '\0';
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x00"))
-        memset(value, 'x', 30);
-        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x0Axxxxxxxxxx"))
+        TEST(WRITES(pb_enc_string(&s, NULL, &value), "\x00"))
     }
     
     {
@@ -223,20 +221,6 @@ int main()
         TEST(!pb_encode(&s, FloatArray_fields, &msg))
     }
     
-    {
-        uint8_t buffer[50];
-        pb_ostream_t s;
-        FloatArray msg = {1, {99.0f}};
-        
-        COMMENT("Test array size limit in pb_encode")
-        
-        s = pb_ostream_from_buffer(buffer, sizeof(buffer));
-        TEST((msg.data_count = 10) && pb_encode(&s, FloatArray_fields, &msg))
-        
-        s = pb_ostream_from_buffer(buffer, sizeof(buffer));
-        TEST((msg.data_count = 11) && !pb_encode(&s, FloatArray_fields, &msg))
-    }
-    
     {
         uint8_t buffer[10];
         pb_ostream_t s;
@@ -258,39 +242,6 @@ int main()
                     "\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
     }
     
-    {
-        uint8_t buffer[32];
-        pb_ostream_t s;
-        BytesMessage msg = {{3, "xyz"}};
-        
-        COMMENT("Test pb_encode with bytes message.")
-        TEST(WRITES(pb_encode(&s, BytesMessage_fields, &msg),
-                    "\x0A\x03xyz"))
-        
-        msg.data.size = 17; /* More than maximum */
-        TEST(!pb_encode(&s, BytesMessage_fields, &msg))
-    }
-        
-    
-    {
-        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"))
-    }
-
-    {
-        IntegerContainer msg = {{5, {1,2,3,4,5}}};
-        size_t size;
-        
-        COMMENT("Test pb_get_encoded_size.")
-        TEST(pb_get_encoded_size(&size, IntegerContainer_fields, &msg) &&
-             size == 9);
-    }
-    
     {
         uint8_t buffer[10];
         pb_ostream_t s;
@@ -317,19 +268,6 @@ int main()
         TEST(!pb_encode(&s, CallbackContainerContainer_fields, &msg2))
     }
     
-    {
-        uint8_t buffer[StringMessage_size];
-        pb_ostream_t s;
-        StringMessage msg = {"0123456789"};
-        
-        s = pb_ostream_from_buffer(buffer, sizeof(buffer));
-        
-        COMMENT("Test that StringMessage_size is correct")
-
-        TEST(pb_encode(&s, StringMessage_fields, &msg));
-        TEST(s.bytes_written == StringMessage_size);
-    }
-    
     if (status != 0)
         fprintf(stdout, "\n\nSome tests FAILED!\n");
     

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"])
-env.RunTest(p)

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 = '$BUILD/alltypes')
-incpath.Append(CPPPATH = '$BUILD/alltypes')
-
-incpath.NanopbProto(["extensions", "extensions.options"])
-enc = incpath.Program(["encode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_encode.o"])
-dec = incpath.Program(["decode_extensions.c", "extensions.pb.c", "$BUILD/alltypes/alltypes.pb$OBJSUFFIX", "$COMMON/pb_decode.o"])
-
-env.RunTest(enc)
-env.RunTest([dec, "encode_extensions.output"])
-

tests/extensions/decode_extensions.c

@@ -1,60 +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(ext1.found)
-    TEST(extensionfield1 == 12345)
-    TEST(ext2.found)
-    TEST(strcmp(extensionfield2.test1, "test") == 0)
-    TEST(extensionfield2.test2 == 54321)
-    
-    return 0;
-}
-

tests/extensions/encode_extensions.c

@@ -1,54 +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 */
-    }
-    
-    /* Check that the field tags are properly generated */
-    (void)AllTypes_extensionfield1_tag;
-    (void)ExtensionMessage_AllTypes_extensionfield2_tag;
-}
-

tests/extensions/extensions.options

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

tests/extensions/extensions.proto

@@ -1,17 +0,0 @@
-import 'alltypes.proto';
-
-extend AllTypes {
-    optional int32 AllTypes_extensionfield1 = 255 [default = 5];
-}
-
-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;
-}
-

tests/extra_fields/SConscript

@@ -1,16 +0,0 @@
-# Test that the decoder properly handles unknown fields in the input.
-
-Import("env")
-
-dec = env.GetBuildPath('$BUILD/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('$BUILD/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"])
-
-# This uses the backwards compatibility alltypes test, so that
-# alltypes_with_extra_fields.pb doesn't have to be remade so often.
-dec2 = env.GetBuildPath('$BUILD/backwards_compatibility/${PROGPREFIX}decode_legacy${PROGSUFFIX}')
-env.RunTest('alltypes_with_extra_fields.output', [dec2, 'alltypes_with_extra_fields.pb'])