Remove the PB_ENCODERS array.

Reduces code size by 2% and is overall cleaner.

generator/nanopb.proto

@@ -12,7 +12,6 @@ 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.
 }

generator/nanopb_generator.py

@@ -189,34 +189,6 @@ class Field:
         else:
             raise NotImplementedError(desc.label)
         
-        # Check if the field can be implemented with static allocation
-        # i.e. whether the data size is known.
-        if desc.type == FieldD.TYPE_STRING and self.max_size is None:
-            can_be_static = False
-        
-        if desc.type == FieldD.TYPE_BYTES and self.max_size is None:
-            can_be_static = False
-        
-        # Decide how the field data will be allocated
-        if field_options.type == nanopb_pb2.FT_DEFAULT:
-            if can_be_static:
-                field_options.type = nanopb_pb2.FT_STATIC
-            else:
-                field_options.type = nanopb_pb2.FT_CALLBACK
-        
-        if field_options.type == nanopb_pb2.FT_STATIC and not can_be_static:
-            raise Exception("Field %s is defined as static, but max_size or "
-                            "max_count is not given." % self.name)
-        
-        if field_options.type == nanopb_pb2.FT_STATIC:
-            self.allocation = 'STATIC'
-        elif field_options.type == nanopb_pb2.FT_POINTER:
-            self.allocation = 'POINTER'
-        elif field_options.type == nanopb_pb2.FT_CALLBACK:
-            self.allocation = 'CALLBACK'
-        else:
-            raise NotImplementedError(field_options.type)
-        
         # Decide the C data type to use in the struct.
         if datatypes.has_key(desc.type):
             self.ctype, self.pbtype, self.enc_size = datatypes[desc.type]
@@ -228,18 +200,19 @@ class Field:
             self.enc_size = 5 # protoc rejects enum values > 32 bits
         elif desc.type == FieldD.TYPE_STRING:
             self.pbtype = 'STRING'
-            self.ctype = 'char'
+            if self.max_size is None:
-            if self.allocation == 'STATIC':
+                can_be_static = False
+            else:
                 self.ctype = 'char'
                 self.array_decl += '[%d]' % self.max_size
                 self.enc_size = varint_max_size(self.max_size) + self.max_size
         elif desc.type == FieldD.TYPE_BYTES:
             self.pbtype = 'BYTES'
-            if self.allocation == 'STATIC':
+            if self.max_size is None:
+                can_be_static = False
+            else:
                 self.ctype = self.struct_name + self.name + 't'
                 self.enc_size = varint_max_size(self.max_size) + self.max_size
-            elif self.allocation == 'POINTER':
-                self.ctype = 'pb_bytes_ptr_t'
         elif desc.type == FieldD.TYPE_MESSAGE:
             self.pbtype = 'MESSAGE'
             self.ctype = self.submsgname = names_from_type_name(desc.type_name)
@@ -247,30 +220,34 @@ class Field:
         else:
             raise NotImplementedError(desc.type)
         
+        if field_options.type == nanopb_pb2.FT_DEFAULT:
+            if can_be_static:
+                field_options.type = nanopb_pb2.FT_STATIC
+            else:
+                field_options.type = nanopb_pb2.FT_CALLBACK
+        
+        if field_options.type == nanopb_pb2.FT_STATIC and not can_be_static:
+            raise Exception("Field %s is defined as static, but max_size or max_count is not given." % self.name)
+        
+        if field_options.type == nanopb_pb2.FT_STATIC:
+            self.allocation = 'STATIC'
+        elif field_options.type == nanopb_pb2.FT_CALLBACK:
+            self.allocation = 'CALLBACK'
+            self.ctype = 'pb_callback_t'
+            self.array_decl = ''
+        else:
+            raise NotImplementedError(field_options.type)
+    
     def __cmp__(self, other):
         return cmp(self.tag, other.tag)
     
     def __str__(self):
-        result = ''
-        if self.allocation == 'POINTER':
-            if self.rules == 'REPEATED':
-                result += '    size_t ' + self.name + '_count;\n'
-            
-            if self.pbtype == 'MESSAGE':
-                # Use struct definition, so recursive submessages are possible
-                result += '    struct _%s *%s;' % (self.ctype, self.name)
-            elif self.rules == 'REPEATED' and self.pbtype == 'STRING':
-                # String arrays need to be defined as pointers to pointers
-                result += '    %s **%s;' % (self.ctype, self.name)
-            else:
-                result += '    %s *%s;' % (self.ctype, self.name)
-        elif self.allocation == 'CALLBACK':
-            result += '    pb_callback_t %s;' % self.name
-        else:
         if self.rules == 'OPTIONAL' and self.allocation == 'STATIC':
-                result += '    bool has_' + self.name + ';\n'
+            result = '    bool has_' + self.name + ';\n'
         elif self.rules == 'REPEATED' and self.allocation == 'STATIC':
-                result += '    size_t ' + self.name + '_count;\n'
+            result = '    size_t ' + self.name + '_count;\n'
+        else:
+            result = ''
         result += '    %s %s%s;' % (self.ctype, self.name, self.array_decl)
         return result
     
@@ -326,7 +303,7 @@ class Field:
         result  = '    PB_FIELD2(%3d, ' % self.tag
         result += '%-8s, ' % self.pbtype
         result += '%s, ' % self.rules
-        result += '%-8s, ' % self.allocation
+        result += '%s, ' % self.allocation
         result += '%s, ' % ("FIRST" if not prev_field_name else "OTHER")
         result += '%s, ' % self.struct_name
         result += '%s, ' % self.name

generator/nanopb_pb2.py

@@ -12,7 +12,7 @@ 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*Z\n\tFieldType\x12\x0e\n\nFT_DEFAULT\x10\x00\x12\x0f\n\x0b\x46T_CALLBACK\x10\x01\x12\x0e\n\nFT_POINTER\x10\x04\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.NanoPBOptionsB\x1a\n\x18\x66i.kapsi.koti.jpa.nanopb')
+  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',
@@ -29,28 +29,23 @@ _FIELDTYPE = descriptor.EnumDescriptor(
       options=None,
       type=None),
     descriptor.EnumValueDescriptor(
-      name='FT_POINTER', index=2, number=4,
+      name='FT_STATIC', index=2, number=2,
       options=None,
       type=None),
     descriptor.EnumValueDescriptor(
-      name='FT_STATIC', index=3, number=2,
+      name='FT_IGNORE', index=3, number=3,
-      options=None,
-      type=None),
-    descriptor.EnumValueDescriptor(
-      name='FT_IGNORE', index=4, number=3,
       options=None,
       type=None),
   ],
   containing_type=None,
   options=None,
   serialized_start=199,
-  serialized_end=289,
+  serialized_end=273,
 )
 
 
 FT_DEFAULT = 0
 FT_CALLBACK = 1
-FT_POINTER = 4
 FT_STATIC = 2
 FT_IGNORE = 3
 

pb.h

@@ -166,7 +166,6 @@ typedef uint8_t pb_type_t;
 /**** Field allocation types ****/
  
 #define PB_ATYPE_STATIC   0x00
-#define PB_ATYPE_POINTER  0x80
 #define PB_ATYPE_CALLBACK 0x40
 #define PB_ATYPE_MASK     0xC0
 
@@ -232,16 +231,8 @@ struct _pb_bytes_array_t {
     size_t size;
     uint8_t bytes[1];
 };
-typedef struct _pb_bytes_array_t pb_bytes_array_t;
 
-/* Same, except for pointer-type fields. There is no need to variable struct
+typedef struct _pb_bytes_array_t pb_bytes_array_t;
- * length in this case.
- */
-struct _pb_bytes_ptr_t {
-    size_t size;
-    uint8_t *bytes;
-};
-typedef struct _pb_bytes_ptr_t pb_bytes_ptr_t;
 
 /* This structure is used for giving the callback function.
  * It is stored in the message structure and filled in by the method that
@@ -379,22 +370,6 @@ struct _pb_extension_t {
     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, \

pb_decode.c

@@ -32,7 +32,6 @@ typedef struct {
     void *pSize; /* Pointer where to store the size of current array field */
 } pb_field_iterator_t;
 
-typedef bool (*pb_decoder_t)(pb_istream_t *stream, const pb_field_t *field, void *dest) checkreturn;
 
 static bool checkreturn buf_read(pb_istream_t *stream, uint8_t *buf, size_t count);
 static bool checkreturn pb_decode_varint32(pb_istream_t *stream, uint32_t *dest);
@@ -40,6 +39,7 @@ static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire
 static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct);
 static bool pb_field_next(pb_field_iterator_t *iter);
 static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag);
+static bool checkreturn decode_ltype(pb_istream_t *stream, const pb_field_t *field, void *dest, pb_type_t type);
 static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
 static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
 static bool checkreturn decode_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter);
@@ -57,21 +57,6 @@ static bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t
 static bool checkreturn pb_skip_varint(pb_istream_t *stream);
 static bool checkreturn pb_skip_string(pb_istream_t *stream);
 
-/* --- Function pointers to field decoders ---
- * Order in the array must match pb_action_t LTYPE numbering.
- */
-static const pb_decoder_t PB_DECODERS[PB_LTYPES_COUNT] = {
-    &pb_dec_varint,
-    &pb_dec_svarint,
-    &pb_dec_fixed32,
-    &pb_dec_fixed64,
-    
-    &pb_dec_bytes,
-    &pb_dec_string,
-    &pb_dec_submessage,
-    NULL /* extensions */
-};
-
 /*******************************
  * pb_istream_t implementation *
  *******************************/
@@ -313,28 +298,23 @@ static bool checkreturn read_raw_value(pb_istream_t *stream, pb_wire_type_t wire
 /* Decode string length from stream and return a substream with limited length.
  * Remember to close the substream using pb_close_string_substream().
  */
-bool checkreturn pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream)
+bool checkreturn pb_make_string_substream(pb_istream_t *stream, size_t *remaining_length)
 {
     uint32_t size;
     if (!pb_decode_varint32(stream, &size))
         return false;
 
-    *substream = *stream;
+    if (stream->bytes_left < size)
-    if (substream->bytes_left < size)
         PB_RETURN_ERROR(stream, "parent stream too short");
     
-    substream->bytes_left = size;
+    *remaining_length = stream->bytes_left - size;
-    stream->bytes_left -= size;
+    stream->bytes_left = size;
     return true;
 }
 
-void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream)
+void pb_close_string_substream(pb_istream_t *stream, size_t remaining_length)
 {
-    stream->state = substream->state;
+    stream->bytes_left += remaining_length;
-
-#ifndef PB_NO_ERRMSG
-    stream->errmsg = substream->errmsg;
-#endif
 }
 
 static void pb_field_init(pb_field_iterator_t *iter, const pb_field_t *fields, void *dest_struct)
@@ -401,22 +381,37 @@ static bool checkreturn pb_field_find(pb_field_iterator_t *iter, uint32_t tag)
  * Decode a single field *
  *************************/
 
+/* Invoke a decoder function based on the ltype of a field. */
+static bool checkreturn decode_ltype(pb_istream_t *stream,
+    const pb_field_t *field, void *dest, pb_type_t type)
+{
+    switch (PB_LTYPE(type))
+    {
+        case PB_LTYPE_VARINT:       return pb_dec_varint(stream, field, dest);
+        case PB_LTYPE_SVARINT:      return pb_dec_svarint(stream, field, dest);
+        case PB_LTYPE_FIXED32:      return pb_dec_fixed32(stream, field, dest);
+        case PB_LTYPE_FIXED64:      return pb_dec_fixed64(stream, field, dest);
+        case PB_LTYPE_BYTES:        return pb_dec_bytes(stream, field, dest);
+        case PB_LTYPE_STRING:       return pb_dec_string(stream, field, dest);
+        case PB_LTYPE_SUBMESSAGE:   return pb_dec_submessage(stream, field, dest);
+        
+        default: PB_RETURN_ERROR(stream, "invalid field type");
+    }
+}
+
 static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iterator_t *iter)
 {
     pb_type_t type;
-    pb_decoder_t func;
-    
     type = iter->pos->type;
-    func = PB_DECODERS[PB_LTYPE(type)];
 
     switch (PB_HTYPE(type))
     {
         case PB_HTYPE_REQUIRED:
-            return func(stream, iter->pos, iter->pData);
+            return decode_ltype(stream, iter->pos, iter->pData, type);
             
         case PB_HTYPE_OPTIONAL:
             *(bool*)iter->pSize = true;
-            return func(stream, iter->pos, iter->pData);
+            return decode_ltype(stream, iter->pos, iter->pData, type);
     
         case PB_HTYPE_REPEATED:
             if (wire_type == PB_WT_STRING
@@ -425,24 +420,25 @@ static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t
                 /* Packed array */
                 bool status = true;
                 size_t *size = (size_t*)iter->pSize;
-                pb_istream_t substream;
+                size_t remaining_length;
-                if (!pb_make_string_substream(stream, &substream))
+                if (!pb_make_string_substream(stream, &remaining_length))
                     return false;
                 
-                while (substream.bytes_left && *size < iter->pos->array_size)
+                while (stream->bytes_left)
                 {
                     void *pItem = (uint8_t*)iter->pData + iter->pos->data_size * (*size);
-                    if (!func(&substream, iter->pos, pItem))
+                    
+                    if (*size >= iter->pos->array_size)
+                        PB_RETURN_ERROR(stream, "array overflow");
+                
+                    if (!decode_ltype(stream, iter->pos, pItem, type))
                     {
                         status = false;
                         break;
                     }
                     (*size)++;
                 }
-                pb_close_string_substream(stream, &substream);
+                pb_close_string_substream(stream, remaining_length);
-                
-                if (substream.bytes_left != 0)
-                    PB_RETURN_ERROR(stream, "array overflow");
                 
                 return status;
             }
@@ -455,7 +451,7 @@ static bool checkreturn decode_static_field(pb_istream_t *stream, pb_wire_type_t
                     PB_RETURN_ERROR(stream, "array overflow");
                 
                 (*size)++;
-                return func(stream, iter->pos, pItem);
+                return decode_ltype(stream, iter->pos, pItem, type);
             }
 
         default:
@@ -478,18 +474,18 @@ static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type
     
     if (wire_type == PB_WT_STRING)
     {
-        pb_istream_t substream;
+        size_t remaining_length;
         
-        if (!pb_make_string_substream(stream, &substream))
+        if (!pb_make_string_substream(stream, &remaining_length))
             return false;
         
         do
         {
-            if (!pCallback->funcs.decode(&substream, iter->pos, arg))
+            if (!pCallback->funcs.decode(stream, iter->pos, arg))
                 PB_RETURN_ERROR(stream, "callback failed");
-        } while (substream.bytes_left);
+        } while (stream->bytes_left);
         
-        pb_close_string_substream(stream, &substream);
+        pb_close_string_substream(stream, remaining_length);
         return true;
     }
     else
@@ -746,14 +742,14 @@ bool checkreturn pb_decode(pb_istream_t *stream, const pb_field_t fields[], void
 
 bool pb_decode_delimited(pb_istream_t *stream, const pb_field_t fields[], void *dest_struct)
 {
-    pb_istream_t substream;
+    size_t remaining_length;
     bool status;
     
-    if (!pb_make_string_substream(stream, &substream))
+    if (!pb_make_string_substream(stream, &remaining_length))
         return false;
     
-    status = pb_decode(&substream, fields, dest_struct);
+    status = pb_decode(stream, fields, dest_struct);
-    pb_close_string_substream(stream, &substream);
+    pb_close_string_substream(stream, remaining_length);
     return status;
 }
 
@@ -896,10 +892,10 @@ bool checkreturn pb_dec_string(pb_istream_t *stream, const pb_field_t *field, vo
 bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field, void *dest)
 {
     bool status;
-    pb_istream_t substream;
+    size_t remaining_length;
     const pb_field_t* submsg_fields = (const pb_field_t*)field->ptr;
     
-    if (!pb_make_string_substream(stream, &substream))
+    if (!pb_make_string_substream(stream, &remaining_length))
         return false;
     
     if (field->ptr == NULL)
@@ -908,10 +904,10 @@ bool checkreturn pb_dec_submessage(pb_istream_t *stream, const pb_field_t *field
     /* New array entries need to be initialized, while required and optional
      * submessages have already been initialized in the top-level pb_decode. */
     if (PB_HTYPE(field->type) == PB_HTYPE_REPEATED)
-        status = pb_decode(&substream, submsg_fields, dest);
+        status = pb_decode(stream, submsg_fields, dest);
     else
-        status = pb_decode_noinit(&substream, submsg_fields, dest);
+        status = pb_decode_noinit(stream, submsg_fields, dest);
     
-    pb_close_string_substream(stream, &substream);
+    pb_close_string_substream(stream, remaining_length);
     return status;
 }

pb_decode.h

@@ -128,8 +128,8 @@ bool pb_decode_fixed32(pb_istream_t *stream, void *dest);
 bool pb_decode_fixed64(pb_istream_t *stream, void *dest);
 
 /* Make a limited-length substream for reading a PB_WT_STRING field. */
-bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream);
+bool pb_make_string_substream(pb_istream_t *stream, size_t *remaining_length);
-void pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream);
+void pb_close_string_substream(pb_istream_t *stream, size_t remaining_length);
 
 #ifdef __cplusplus
 } /* extern "C" */

pb_encode.c

@@ -20,10 +20,9 @@
 /**************************************
  * 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_ltype(pb_ostream_t *stream, const pb_field_t *field, const void *src, pb_type_t type);
+static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field, const void *pData, size_t count);
 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);
@@ -35,21 +34,6 @@ static bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *fie
 static bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src);
 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_svarint,
-    &pb_enc_fixed32,
-    &pb_enc_fixed64,
-    
-    &pb_enc_bytes,
-    &pb_enc_string,
-    &pb_enc_submessage,
-    NULL /* extensions */
-};
-
 /*******************************
  * pb_ostream_t implementation *
  *******************************/
@@ -106,9 +90,28 @@ bool checkreturn pb_write(pb_ostream_t *stream, const uint8_t *buf, size_t count
  * Encode a single field *
  *************************/
 
+/* Invoke an encoder function based on the ltype of a field. */
+static bool checkreturn encode_ltype(pb_ostream_t *stream,
+    const pb_field_t *field, const void *src, pb_type_t type)
+{
+    switch (PB_LTYPE(type))
+    {
+        case PB_LTYPE_VARINT:       return pb_enc_varint(stream, field, src);
+        case PB_LTYPE_SVARINT:      return pb_enc_svarint(stream, field, src);
+        case PB_LTYPE_FIXED32:      return pb_enc_fixed32(stream, field, src);
+        case PB_LTYPE_FIXED64:      return pb_enc_fixed64(stream, field, src);
+        case PB_LTYPE_BYTES:        return pb_enc_bytes(stream, field, src);
+        case PB_LTYPE_STRING:       return pb_enc_string(stream, field, src);
+        case PB_LTYPE_SUBMESSAGE:   return pb_enc_submessage(stream, field, src);
+        
+        default: PB_RETURN_ERROR(stream, "invalid field type");
+    }
+}
+    
+
 /* Encode a static array. Handles the size calculations and possible packing. */
 static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *field,
-                         const void *pData, size_t count, pb_encoder_t func)
+                         const void *pData, size_t count)
 {
     size_t i;
     const void *p;
@@ -117,7 +120,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)
+    if (count > field->array_size)
         PB_RETURN_ERROR(stream, "array max size exceeded");
     
     /* We always pack arrays if the datatype allows it. */
@@ -141,7 +144,7 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
             p = pData;
             for (i = 0; i < count; i++)
             {
-                if (!func(&sizestream, field, p))
+                if (!encode_ltype(&sizestream, field, p, field->type))
                     return false;
                 p = (const char*)p + field->data_size;
             }
@@ -158,7 +161,7 @@ static bool checkreturn encode_array(pb_ostream_t *stream, const pb_field_t *fie
         p = pData;
         for (i = 0; i < count; i++)
         {
-            if (!func(stream, field, p))
+            if (!encode_ltype(stream, field, p, field->type))
                 return false;
             p = (const char*)p + field->data_size;
         }
@@ -170,22 +173,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;
-
+            if (!encode_ltype(stream, field, p, field->type))
-            /* Normally the data is stored directly in the array entries, but
-             * for pointer-type string fields, the array entries are actually
-             * string pointers. So we have to dereference once more to get to
-             * the character data. */
-            if (PB_ATYPE(field->type) == PB_ATYPE_POINTER &&
-                PB_LTYPE(field->type) == PB_LTYPE_STRING)
-            {
-                if (!func(stream, field, *(const void* const*)p))
                 return false;
-            }
-            else
-            {
-                if (!func(stream, field, p))
-                    return false;
-            }
             p = (const char*)p + field->data_size;
         }
     }
@@ -193,41 +182,25 @@ 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
+/* Encode a field with static allocation, i.e. one whose data is stored
- * is available to the encoder directly. */
+ * in the structure itself. */
-static bool checkreturn encode_basic_field(pb_ostream_t *stream,
+static bool checkreturn encode_static_field(pb_ostream_t *stream,
     const pb_field_t *field, const void *pData)
 {
-    pb_encoder_t func;
     const void *pSize;
-    bool implicit_has = true;
+    bool dummy = true;
-    
-    func = PB_ENCODERS[PB_LTYPE(field->type)];
     
     if (field->size_offset)
         pSize = (const char*)pData + field->size_offset;
     else
-        pSize = &implicit_has;
+        pSize = &dummy;
-
-    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))
+            if (!encode_ltype(stream, field, pData, field->type))
                 return false;
             break;
         
@@ -237,13 +210,13 @@ static bool checkreturn encode_basic_field(pb_ostream_t *stream,
                 if (!pb_encode_tag_for_field(stream, field))
                     return false;
             
-                if (!func(stream, field, pData))
+                if (!encode_ltype(stream, field, pData, field->type))
                     return false;
             }
             break;
         
         case PB_HTYPE_REPEATED:
-            if (!encode_array(stream, field, pData, *(const size_t*)pSize, func))
+            if (!encode_array(stream, field, pData, *(const size_t*)pSize))
                 return false;
             break;
         
@@ -282,8 +255,7 @@ static bool checkreturn encode_field(pb_ostream_t *stream,
     switch (PB_ATYPE(field->type))
     {
         case PB_ATYPE_STATIC:
-        case PB_ATYPE_POINTER:
+            return encode_static_field(stream, field, pData);
-            return encode_basic_field(stream, field, pData);
         
         case PB_ATYPE_CALLBACK:
             return encode_callback_field(stream, field, pData);
@@ -340,9 +312,6 @@ bool checkreturn pb_encode(pb_ostream_t *stream, const pb_field_t fields[], cons
     while (field->tag != 0)
     {
         pData = (const char*)pData + prev_size + field->data_offset;
-        if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
-            prev_size = sizeof(const void*);
-        else
         prev_size = field->data_size;
         
         /* Special case for static arrays */
@@ -496,12 +465,7 @@ bool checkreturn pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fie
     bool status;
     
     if (!pb_encode(&substream, fields, src_struct))
-    {
-#ifndef PB_NO_ERRMSG
-        stream->errmsg = substream.errmsg;
-#endif
         return false;
-    }
     
     size = substream.bytes_written;
     
@@ -583,33 +547,21 @@ bool checkreturn pb_enc_fixed32(pb_ostream_t *stream, const pb_field_t *field, c
 }
 
 bool checkreturn pb_enc_bytes(pb_ostream_t *stream, const pb_field_t *field, const void *src)
-{
-    if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
-    {
-        const pb_bytes_ptr_t *bytes = (const pb_bytes_ptr_t*)src;
-        return pb_encode_string(stream, bytes->bytes, bytes->size);
-    }
-    else
 {
     const pb_bytes_array_t *bytes = (const pb_bytes_array_t*)src;
+
     if (bytes->size + offsetof(pb_bytes_array_t, bytes) > field->data_size)
         PB_RETURN_ERROR(stream, "bytes size exceeded");
     
     return pb_encode_string(stream, bytes->bytes, bytes->size);
 }
-}
 
 bool checkreturn pb_enc_string(pb_ostream_t *stream, const pb_field_t *field, const void *src)
 {
-    /* strnlen() is not always available, so just use a loop */
+    /* strnlen() is not always available, so just use a for-loop */
     size_t size = 0;
-    size_t max_size = field->data_size;
     const char *p = (const char*)src;
-    
+    while (size < field->data_size && *p != '\0')
-    if (PB_ATYPE(field->type) == PB_ATYPE_POINTER)
-        max_size = (size_t)-1;
-
-    while (size < max_size && *p != '\0')
     {
         size++;
         p++;

tests/alltypes_pointer/SConscript

@@ -1,18 +0,0 @@
-# Encode the AllTypes message using pointers for all fields, and verify the
-# output against the normal AllTypes test case.
-
-Import("env")
-
-env.NanopbProto(["alltypes", "alltypes.options"])
-enc = env.Program(["encode_alltypes_pointer.c", "alltypes.pb.c", "$COMMON/pb_encode.o"])
-
-# Encode and compare results
-env.RunTest(enc)
-env.RunTest("decode_alltypes.output", ["$BUILD/alltypes/decode_alltypes", "encode_alltypes_pointer.output"])
-env.Compare(["encode_alltypes_pointer.output", "$BUILD/alltypes/encode_alltypes.output"])
-
-# Do the same thing with the optional fields present
-#env.RunTest("optionals.output", enc, ARGS = ['1'])
-#env.RunTest("optionals.decout", ["$BUILD/alltypes/decode_alltypes", "optionals.output"], ARGS = ['1'])
-#env.Compare(["optionals.output", "$BUILD/alltypes/optionals.output"])
-

tests/alltypes_pointer/alltypes.options

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

tests/alltypes_pointer/alltypes.proto

@@ -1,93 +0,0 @@
-message SubMessage {
-    required string substuff1 = 1 [default = "1"];
-    required int32 substuff2 = 2 [default = 2];
-    optional fixed32 substuff3 = 3 [default = 3];
-}
-
-message EmptyMessage {
-
-}
-
-enum MyEnum {
-    Zero = 0;
-    First = 1;
-    Second = 2;
-    Truth = 42;
-}
-
-message AllTypes {
-    required int32      req_int32   = 1;
-    required int64      req_int64   = 2;
-    required uint32     req_uint32  = 3;
-    required uint64     req_uint64  = 4;
-    required sint32     req_sint32  = 5;
-    required sint64     req_sint64  = 6;
-    required bool       req_bool    = 7;
-    
-    required fixed32    req_fixed32 = 8;
-    required sfixed32   req_sfixed32= 9;
-    required float      req_float   = 10;
-    
-    required fixed64    req_fixed64 = 11;
-    required sfixed64   req_sfixed64= 12;
-    required double     req_double  = 13;
-    
-    required string     req_string  = 14;
-    required bytes      req_bytes   = 15;
-    required SubMessage req_submsg  = 16;
-    required MyEnum     req_enum    = 17;
-    required EmptyMessage req_emptymsg = 18;
-    
-    
-    repeated int32      rep_int32   = 21;
-    repeated int64      rep_int64   = 22;
-    repeated uint32     rep_uint32  = 23;
-    repeated uint64     rep_uint64  = 24;
-    repeated sint32     rep_sint32  = 25;
-    repeated sint64     rep_sint64  = 26;
-    repeated bool       rep_bool    = 27;
-    
-    repeated fixed32    rep_fixed32 = 28;
-    repeated sfixed32   rep_sfixed32= 29;
-    repeated float      rep_float   = 30;
-    
-    repeated fixed64    rep_fixed64 = 31;
-    repeated sfixed64   rep_sfixed64= 32;
-    repeated double     rep_double  = 33;
-    
-    repeated string     rep_string  = 34;
-    repeated bytes      rep_bytes   = 35;
-    repeated SubMessage rep_submsg  = 36;
-    repeated MyEnum     rep_enum    = 37;
-    repeated EmptyMessage rep_emptymsg = 38;
-    
-    optional int32      opt_int32   = 41 [default = 4041];
-    optional int64      opt_int64   = 42 [default = 4042];
-    optional uint32     opt_uint32  = 43 [default = 4043];
-    optional uint64     opt_uint64  = 44 [default = 4044];
-    optional sint32     opt_sint32  = 45 [default = 4045];
-    optional sint64     opt_sint64  = 46 [default = 4046];
-    optional bool       opt_bool    = 47 [default = false];
-    
-    optional fixed32    opt_fixed32 = 48 [default = 4048];
-    optional sfixed32   opt_sfixed32= 49 [default = 4049];
-    optional float      opt_float   = 50 [default = 4050];
-    
-    optional fixed64    opt_fixed64 = 51 [default = 4051];
-    optional sfixed64   opt_sfixed64= 52 [default = 4052];
-    optional double     opt_double  = 53 [default = 4053];
-    
-    optional string     opt_string  = 54 [default = "4054"];
-    optional bytes      opt_bytes   = 55 [default = "4055"];
-    optional SubMessage opt_submsg  = 56;
-    optional MyEnum     opt_enum    = 57 [default = Second];
-    optional EmptyMessage opt_emptymsg = 58;
-
-    // Just to make sure that the size of the fields has been calculated
-    // properly, i.e. otherwise a bug in last field might not be detected.
-    required int32      end = 99;
-
-
-    extensions 200 to 255;
-}
-

tests/alltypes_pointer/encode_alltypes_pointer.c

@@ -1,169 +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_ptr_t req_bytes      = {4, (uint8_t*)"1015"};
-    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"};
-    pb_bytes_ptr_t rep_bytes[5]   = {{0,0}, {0,0}, {0,0}, {0,0}, {4, (uint8_t*)"2015"}};
-    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_ptr_t opt_bytes      = {4, (uint8_t*)"3055"};
-    static int32_t opt_substuff   = 3056;
-    SubMessage  opt_submsg        = {"3056", &opt_substuff};
-    MyEnum      opt_enum          = MyEnum_Truth;
-    EmptyMessage opt_emptymsg     = {0};
-
-    /* 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         = &req_bytes;
-    alltypes.req_submsg        = &req_submsg;
-    alltypes.req_enum          = &req_enum;
-    alltypes.req_emptymsg      = &req_emptymsg;
-    
-    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         = &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 */
-        }
-    }
-}