Add support for SEQUENCE OF ... DEFAULT

asn1tools/codecs/compiler.py

@@ -252,6 +252,7 @@ def pre_process(self):
             self.pre_process_extensibility_implied(module, type_descriptors)
             self.pre_process_tags(module, module_name)
             self.pre_process_default_value(type_descriptors, module_name)
+            self.pre_process_default_value_sequenceof(type_descriptors, module_name)
 
         for module_name, module in self._specification.items():
             self.pre_process_parameterization_step_1(module['types'],
@@ -457,6 +458,19 @@ def pre_process_default_value(self, type_descriptors, module_name):
                             member['default'] = value
                             break
 
+    def pre_process_default_value_sequenceof(self, type_descriptors, module_name):
+        sequences_and_sets = self.get_type_descriptors(
+            type_descriptors,
+            ['SEQUENCE OF'])
+
+        for type_descriptor in sequences_and_sets:
+            if 'default' not in type_descriptor:
+                continue
+
+            if type_descriptor['element']['type'] == 'OCTET STRING':
+                self.pre_process_default_value_octet_string_sequenceof(type_descriptor)
+
+
     def pre_process_default_value_bit_string(self, member, resolved_member):
         default = member['default']
 
@@ -516,6 +530,32 @@ def pre_process_default_value_octet_string(self, member):
                 default += '0'
             member['default'] = binascii.unhexlify(default)
 
+    def pre_process_default_value_octet_string_sequenceof(self, type_descriptor):
+        defaults = type_descriptor['default']
+        new_defaults = []
+
+        if not defaults:
+            return
+
+        if sys.version_info[0] > 2 and isinstance(defaults[0], bytes):
+            # Already pre-processed.
+            return
+
+        for default in defaults:
+            if default.startswith('0b'):
+                default = default[2:]
+                if len(default) % 8 != 0:
+                    default += '0' * (-len(default) % 8)
+                new_defaults.append(binascii.unhexlify(
+                    hex(int('11111111' + default, 2))[4:]
+                ))
+            elif default.startswith('0x'):
+                default = default[2:]
+                if len(default) % 2 == 1:
+                    default += '0'
+                new_defaults.append(binascii.unhexlify(default))
+        type_descriptor['default'] = new_defaults
+
     def pre_process_parameterization_step_1(self, types, module_name):
         """X.683 parameterization pre processing - step 1.
 

asn1tools/parser.py

@@ -385,6 +385,13 @@ def convert_sequence_of_type(_s, _l, tokens):
     if tag:
         converted_type['element']['tag'] = tag
 
+    if len(tokens) > 5 and len(tokens[5]) > 0 and len(tokens[5]) > 0:
+        converted_type['default'] = []
+        for t in tokens[5][1]:
+            value = convert_value([t[0]], converted_type['type'])
+            converted_type['default'].append(value)
+
+
     return converted_type
 
 
@@ -1444,7 +1451,13 @@ def create_grammar():
                         + OF
                         + Optional(Suppress(identifier))
                         - tag
-                        - type_)
+                        - type_
+                        + Optional(Group(DEFAULT
+                            - Suppress(left_brace)
+                            + Group(delimitedList(value))
+                            + Suppress(right_brace)
+                            ))
+                        )
     sequence_of_type.setName('SEQUENCE OF')
 
     # X.680: 24. Notation for the sequence types