Remove obsolete __BIG_ENDIAN__ compilation option.

[apps/agl-service-can-low-level.git] / generator / nanopb_generator.py

diff --git a/generator/nanopb_generator.py b/generator/nanopb_generator.py
index 2dad4ec..0748e63 100755 (executable)
--- a/generator/nanopb_generator.py
+++ b/generator/nanopb_generator.py
@@ -125,11 +125,15 @@ class EncodedSize:
     '''Class used to represent the encoded size of a field or a message.
     Consists of a combination of symbolic sizes and integer sizes.'''
     def __init__(self, value = 0, symbols = []):
-        if isinstance(value, strtypes + (Names,)):
-            symbols = [str(value)]
-            value = 0
-        self.value = value
-        self.symbols = symbols
+        if isinstance(value, EncodedSize):
+            self.value = value.value
+            self.symbols = value.symbols
+        elif isinstance(value, strtypes + (Names,)):
+            self.symbols = [str(value)]
+            self.value = 0
+        else:
+            self.value = value
+            self.symbols = symbols
 
     def __add__(self, other):
         if isinstance(other, int):
@@ -463,7 +467,10 @@ class Field:
         '''
 
         if self.rules == 'ONEOF':
-            result = '    PB_ONEOF_FIELD(%s, ' % self.union_name
+            if self.anonymous:
+                result = '    PB_ANONYMOUS_ONEOF_FIELD(%s, ' % self.union_name
+            else:
+                result = '    PB_ONEOF_FIELD(%s, ' % self.union_name
         else:
             result = '    PB_FIELD('
 
@@ -489,6 +496,9 @@ class Field:
 
         return result
 
+    def get_last_field_name(self):
+        return self.name
+
     def largest_field_value(self):
         '''Determine if this field needs 16bit or 32bit pb_field_t structure to compile properly.
         Returns numeric value or a C-expression for assert.'''
@@ -497,7 +507,10 @@ class Field:
             if self.rules == 'REPEATED' and self.allocation == 'STATIC':
                 check.append('pb_membersize(%s, %s[0])' % (self.struct_name, self.name))
             elif self.rules == 'ONEOF':
-                check.append('pb_membersize(%s, %s.%s)' % (self.struct_name, self.union_name, self.name))
+                if self.anonymous:
+                    check.append('pb_membersize(%s, %s)' % (self.struct_name, self.name))
+                else:
+                    check.append('pb_membersize(%s, %s.%s)' % (self.struct_name, self.union_name, self.name))
             else:
                 check.append('pb_membersize(%s, %s)' % (self.struct_name, self.name))
 
@@ -653,6 +666,7 @@ class OneOf(Field):
         self.allocation = 'ONEOF'
         self.default = None
         self.rules = 'ONEOF'
+        self.anonymous = False
 
     def add_field(self, field):
         if field.allocation == 'CALLBACK':
@@ -661,6 +675,7 @@ class OneOf(Field):
 
         field.union_name = self.name
         field.rules = 'ONEOF'
+        field.anonymous = self.anonymous
         self.fields.append(field)
         self.fields.sort(key = lambda f: f.tag)
 
@@ -674,7 +689,10 @@ class OneOf(Field):
             result += '    union {\n'
             for f in self.fields:
                 result += '    ' + str(f).replace('\n', '\n    ') + '\n'
-            result += '    } ' + self.name + ';'
+            if self.anonymous:
+                result += '    };'
+            else:
+                result += '    } ' + self.name + ';'
         return result
 
     def types(self):
@@ -693,12 +711,18 @@ class OneOf(Field):
         return None
 
     def tags(self):
-        return '\n'.join([f.tags() for f in self.fields])
+        return ''.join([f.tags() for f in self.fields])
 
     def pb_field_t(self, prev_field_name):
         result = ',\n'.join([f.pb_field_t(prev_field_name) for f in self.fields])
         return result
 
+    def get_last_field_name(self):
+        if self.anonymous:
+            return self.fields[-1].name
+        else:
+            return self.name + '.' + self.fields[-1].name
+
     def largest_field_value(self):
         largest = FieldMaxSize()
         for f in self.fields:
@@ -706,10 +730,11 @@ class OneOf(Field):
         return largest
 
     def encoded_size(self, dependencies):
+        '''Returns the size of the largest oneof field.'''
         largest = EncodedSize(0)
         for f in self.fields:
-            size = f.encoded_size(dependencies)
-            if size is None:
+            size = EncodedSize(f.encoded_size(dependencies))
+            if size.value is None:
                 return None
             elif size.symbols:
                 return None # Cannot resolve maximum of symbols
@@ -742,6 +767,8 @@ class Message:
                     pass # No union and skip fields also
                 else:
                     oneof = OneOf(self.name, f)
+                    if oneof_options.anonymous_oneof:
+                        oneof.anonymous = True
                     self.oneofs[i] = oneof
                     self.fields.append(oneof)
 
@@ -847,10 +874,7 @@ class Message:
         for field in self.ordered_fields:
             result += field.pb_field_t(prev)
             result += ',\n'
-            if isinstance(field, OneOf):
-                prev = field.name + '.' + field.fields[-1].name
-            else:
-                prev = field.name
+            prev = field.get_last_field_name()
 
         result += '    PB_LAST_FIELD\n};'
         return result