Fix issue #1: All constraints are now code-genned.

diff --git a/asn1ate/parser.py b/asn1ate/parser.py
index cf1a8bd..f58f85c 100644 (file)
--- a/asn1ate/parser.py
+++ b/asn1ate/parser.py
@@ -262,13 +262,13 @@ def _build_asn1_grammar():
 
     set_type = SET + braced_list(component_type | extension_marker)
     sequence_type = SEQUENCE + braced_list(component_type | extension_marker)
-    sequenceof_type = Suppress(SEQUENCE) + Optional(size_constraint) + Suppress(OF) + (type_ | named_type)
-    setof_type = Suppress(SET) + Optional(size_constraint) + Suppress(OF) + (type_ | named_type)
+    sequenceof_type = Suppress(SEQUENCE) + Optional(size_constraint, default=None) + Suppress(OF) + (type_ | named_type)
+    setof_type = Suppress(SET) + Optional(size_constraint, default=None) + Suppress(OF) + (type_ | named_type)
     choice_type = CHOICE + braced_list(named_type | extension_marker)
     enumerated_type = ENUMERATED + braced_list(enumeration | extension_marker)
     bitstring_type = BIT_STRING + Optional(braced_list(named_number), default=[]) + Optional(single_value_constraint | size_constraint, default=None)
     plain_integer_type = INTEGER
-    restricted_integer_type = INTEGER + braced_list(named_number) + Optional(single_value_constraint)
+    restricted_integer_type = INTEGER + braced_list(named_number) + Optional(single_value_constraint, default=None)
     boolean_type = BOOLEAN
     real_type = REAL
     null_type = NULL

diff --git a/asn1ate/pyasn1gen.py b/asn1ate/pyasn1gen.py
index 499d6eb..5c72331 100644 (file)
--- a/asn1ate/pyasn1gen.py
+++ b/asn1ate/pyasn1gen.py
@@ -93,13 +93,13 @@ class Pyasn1Backend(object):
             ChoiceType: self.defn_constructed_type,
             SequenceType: self.defn_constructed_type,
             SetType: self.defn_constructed_type,
+            SequenceOfType: self.defn_collection_type,
+            SetOfType: self.defn_collection_type,
             TaggedType: self.defn_tagged_type,
             SimpleType: self.defn_simple_type,
             ReferencedType: self.defn_referenced_type,
             ValueListType: self.defn_value_list_type,
             BitStringType: self.defn_bitstring_type,
-            SequenceOfType: self.defn_sequenceof_type,
-            SetOfType: self.defn_setof_type,
         }
 
         self.inline_generators = {
@@ -214,8 +214,9 @@ class Pyasn1Backend(object):
         return str(fragment)
 
     def defn_value_list_type(self, class_name, t):
+        fragment = self.writer.get_fragment()
+
         if t.named_values:
-            fragment = self.writer.get_fragment()
             fragment.write_line('%s.namedValues = namedval.NamedValues(' % class_name)
             fragment.push_indent()
 
@@ -224,30 +225,36 @@ class Pyasn1Backend(object):
 
             fragment.pop_indent()
             fragment.write_line(')')
-            return str(fragment)
 
-        return None
+        if t.constraint:
+            fragment.write_line('%s.subtypeSpec=%s' % (class_name, self.build_constraint_expr(t.constraint)))
+
+        return str(fragment)
 
     def defn_bitstring_type(self, class_name, t):
+        fragment = self.writer.get_fragment()
+
         if t.named_bits:
-            fragment = self.writer.get_fragment()
             fragment.write_line('%s.namedValues = namedval.NamedValues(' % class_name)
             fragment.push_indent()
-
-            named_bit_list = list(map(lambda v: '(\'%s\', %s)' % (v.identifier, v.value), t.named_bits))
-            fragment.write_enumeration(named_bit_list)
-
+            named_bits = ['(\'%s\', %s)' % (b.identifier, b.value) for b in t.named_bits]
+            fragment.write_enumeration(named_bits)
             fragment.pop_indent()
             fragment.write_line(')')
-            return str(fragment)
 
-        return None
+        if t.constraint:
+            fragment.write_line('%s.subtypeSpec=%s' % (class_name, self.build_constraint_expr(t.constraint)))
+
+        return str(fragment)
+
+    def defn_collection_type(self, class_name, t):
+        fragment = self.writer.get_fragment()
+        fragment.write_line('%s.componentType = %s' % (class_name, self.generate_expr(t.type_decl)))
 
-    def defn_sequenceof_type(self, class_name, t):
-        return '%s.componentType = %s' % (class_name, self.generate_expr(t.type_decl))
+        if t.size_constraint:
+            fragment.write_line('%s.subtypeSpec=%s' % (class_name, self.build_constraint_expr(t.size_constraint)))
 
-    def defn_setof_type(self, class_name, t):
-        return '%s.componentType = %s' % (class_name, self.generate_expr(t.type_decl))
+        return str(fragment)
 
     def inline_simple_type(self, t):
         type_expr = _translate_type(t.type_name) + '()'

diff --git a/asn1ate/sema.py b/asn1ate/sema.py
index fe0f2e1..af37982 100644 (file)
--- a/asn1ate/sema.py
+++ b/asn1ate/sema.py
@@ -349,15 +349,8 @@ class CollectionType(SemaNode):
     def __init__(self, kind, elements):
         self.kind = kind
         self.type_name = self.kind + ' OF'
-
-        if elements[0].ty == 'Type':
-            self.size_constraint = None
-            self.type_decl = _create_sema_node(elements[0])
-        elif elements[0].ty == 'SizeConstraint':
-            self.size_constraint = _create_sema_node(elements[0])
-            self.type_decl = _create_sema_node(elements[1])
-        else:
-            assert False, 'Unknown form of %s OF declaration: %s' % (self.kind, elements)
+        self.size_constraint = _maybe_create_sema_node(elements[0])
+        self.type_decl = _create_sema_node(elements[1])
 
     def __str__(self):
         if self.size_constraint:
@@ -576,21 +569,19 @@ class NamedType(SemaNode):
 
 class ValueListType(SemaNode):
     def __init__(self, elements):
-        self.type_name = elements[0]
-        self.named_values = None
         self.constraint = None
+        self.type_name = elements[0]
 
-        if len(elements) > 1:
-            self.named_values = [_create_sema_node(token) for token in elements[1]]
-            for idx, n in enumerate(self.named_values):
-                if isinstance(n, NamedValue) and n.value is None:
-                    if idx == 0:
-                        n.value = str(0)
-                    else:
-                        n.value = str(int(self.named_values[idx-1].value) + 1)
+        self.named_values = [_create_sema_node(token) for token in elements[1]]
+        for idx, n in enumerate(self.named_values):
+            if isinstance(n, NamedValue) and n.value is None:
+                if idx == 0:
+                    n.value = str(0)
+                else:
+                    n.value = str(int(self.named_values[idx-1].value) + 1)
 
         if len(elements) > 2:
-            self.constraint = _create_sema_node(elements[2])
+            self.constraint = _maybe_create_sema_node(elements[2])
 
     def __str__(self):
         named_value_list = ''