further runtime support for information object classes
diff --git a/skeletons/BOOLEAN.c b/skeletons/BOOLEAN.c
index 57e7c06..ffad24e 100644
--- a/skeletons/BOOLEAN.c
+++ b/skeletons/BOOLEAN.c
@@ -242,7 +242,7 @@
}
void
-BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+BOOLEAN_free(const asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
if(td && ptr && !contents_only) {
FREEMEM(ptr);
}
diff --git a/skeletons/NativeInteger.c b/skeletons/NativeInteger.c
index 38d6f5c..d5c0279 100644
--- a/skeletons/NativeInteger.c
+++ b/skeletons/NativeInteger.c
@@ -336,9 +336,9 @@
}
void
-NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
-
- if(!td || !ptr)
+NativeInteger_free(const asn_TYPE_descriptor_t *td, void *ptr,
+ int contents_only) {
+ if(!td || !ptr)
return;
ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
@@ -356,7 +356,7 @@
if(aptr && bptr) {
const asn_INTEGER_specifics_t *specs =
(const asn_INTEGER_specifics_t *)td->specifics;
- if(specs->field_unsigned) {
+ if(specs && specs->field_unsigned) {
const unsigned long *a = aptr;
const unsigned long *b = bptr;
if(*a < *b) {
@@ -364,7 +364,7 @@
} else if(*a > *b) {
return 1;
} else {
- return 1;
+ return 0;
}
} else {
const long *a = aptr;
@@ -374,7 +374,7 @@
} else if(*a > *b) {
return 1;
} else {
- return 1;
+ return 0;
}
}
} else if(!aptr) {
diff --git a/skeletons/NativeReal.c b/skeletons/NativeReal.c
index d9eac63..f305d8b 100644
--- a/skeletons/NativeReal.c
+++ b/skeletons/NativeReal.c
@@ -377,9 +377,8 @@
}
void
-NativeReal_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
-
- if(!td || !ptr)
+NativeReal_free(const asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+ if(!td || !ptr)
return;
ASN_DEBUG("Freeing %s as REAL (%d, %p, Native)",
diff --git a/skeletons/OCTET_STRING.c b/skeletons/OCTET_STRING.c
index 7cc7ebd..57a0c1e 100644
--- a/skeletons/OCTET_STRING.c
+++ b/skeletons/OCTET_STRING.c
@@ -1726,8 +1726,9 @@
}
void
-OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
- OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
+OCTET_STRING_free(const asn_TYPE_descriptor_t *td, void *sptr,
+ int contents_only) {
+ OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
asn_OCTET_STRING_specifics_t *specs;
asn_struct_ctx_t *ctx;
struct _stack *stck;
diff --git a/skeletons/OPEN_TYPE.c b/skeletons/OPEN_TYPE.c
new file mode 100644
index 0000000..7a53ac3
--- /dev/null
+++ b/skeletons/OPEN_TYPE.c
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OPEN_TYPE.h>
+#include <constr_CHOICE.h>
+#include <per_opentype.h>
+#include <errno.h>
+
+
+asn_dec_rval_t
+OPEN_TYPE_uper_get(asn_codec_ctx_t *opt_codec_ctx,
+ asn_TYPE_descriptor_t *td, void *sptr,
+ asn_TYPE_member_t *elm, asn_per_data_t *pd) {
+ asn_type_selector_result_t selected;
+ void *memb_ptr; /* Pointer to the member */
+ void **memb_ptr2; /* Pointer to that pointer */
+ asn_dec_rval_t rv;
+
+ if(!(elm->flags & ATF_OPEN_TYPE) || !elm->type_selector) {
+ ASN__DECODE_FAILED;
+ }
+
+ selected = elm->type_selector(td, sptr);
+ if(!selected.presence_index) {
+ ASN__DECODE_FAILED;
+ }
+
+ /* Fetch the pointer to this member */
+ assert(elm->flags == ATF_OPEN_TYPE);
+ if(elm->flags & ATF_POINTER) {
+ memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+ } else {
+ memb_ptr = (char *)sptr + elm->memb_offset;
+ memb_ptr2 = &memb_ptr;
+ }
+ if(*memb_ptr2 != NULL) {
+ /* Make sure we reset the structure first before encoding */
+ if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
+ != 0) {
+ ASN__DECODE_FAILED;
+ }
+ }
+
+ void *inner_value =
+ (char *)*memb_ptr2
+ + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+ rv = uper_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
+ &inner_value, pd);
+ switch(rv.code) {
+ case RC_OK:
+ if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+ selected.presence_index)
+ == 0) {
+ break;
+ } else {
+ rv.code = RC_FAIL;
+ }
+ /* Fall through */
+ case RC_WMORE:
+ case RC_FAIL:
+ if(*memb_ptr2) {
+ asn_CHOICE_specifics_t *specs = selected.type_descriptor->specifics;
+ if(elm->flags & ATF_POINTER) {
+ ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+ *memb_ptr2 = NULL;
+ } else {
+ ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+ inner_value);
+ memset(*memb_ptr2, 0, specs->struct_size);
+ }
+ }
+ }
+ return rv;
+}
+
+asn_dec_rval_t
+OPEN_TYPE_oer_get(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void *sptr, asn_TYPE_member_t *elm, const void *ptr,
+ size_t size) {
+ asn_type_selector_result_t selected;
+ void *memb_ptr; /* Pointer to the member */
+ void **memb_ptr2; /* Pointer to that pointer */
+ asn_dec_rval_t rv;
+ size_t ot_ret;
+
+ if(!(elm->flags & ATF_OPEN_TYPE) || !elm->type_selector) {
+ ASN__DECODE_FAILED;
+ }
+
+ selected = elm->type_selector(td, sptr);
+ if(!selected.presence_index) {
+ ASN__DECODE_FAILED;
+ }
+
+ /* Fetch the pointer to this member */
+ if(elm->flags & ATF_POINTER) {
+ memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+ } else {
+ memb_ptr = (char *)sptr + elm->memb_offset;
+ memb_ptr2 = &memb_ptr;
+ }
+ if(*memb_ptr2 != NULL) {
+ /* Make sure we reset the structure first before encoding */
+ if(CHOICE_variant_set_presence(selected.type_descriptor, *memb_ptr2, 0)
+ != 0) {
+ ASN__DECODE_FAILED;
+ }
+ }
+
+ ot_ret = oer_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
+ memb_ptr2, ptr, size);
+ switch(ot_ret) {
+ default:
+ if(CHOICE_variant_set_presence(selected.type_descriptor, *memb_ptr2,
+ selected.presence_index)
+ == 0) {
+ rv.code = RC_OK;
+ rv.consumed = ot_ret;
+ return rv;
+ } else {
+ /* Oh, now a full-blown failure failure */
+ }
+ /* Fall through */
+ case -1:
+ rv.code = RC_FAIL;
+ rv.consumed = 0;
+ break;
+ case 0:
+ rv.code = RC_WMORE;
+ rv.consumed = 0;
+ break;
+ }
+
+ if(*memb_ptr2) {
+ asn_CHOICE_specifics_t *specs = selected.type_descriptor->specifics;
+ if(elm->flags & ATF_POINTER) {
+ ASN_STRUCT_FREE(*selected.type_descriptor, *memb_ptr2);
+ *memb_ptr2 = NULL;
+ } else {
+ ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+ *memb_ptr2);
+ memset(*memb_ptr2, 0, specs->struct_size);
+ }
+ }
+ return rv;
+}
diff --git a/skeletons/asn_codecs_prim.c b/skeletons/asn_codecs_prim.c
index 426339c..cf7ea02 100644
--- a/skeletons/asn_codecs_prim.c
+++ b/skeletons/asn_codecs_prim.c
@@ -115,9 +115,9 @@
}
void
-ASN__PRIMITIVE_TYPE_free(asn_TYPE_descriptor_t *td, void *sptr,
- int contents_only) {
- ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
+ASN__PRIMITIVE_TYPE_free(const asn_TYPE_descriptor_t *td, void *sptr,
+ int contents_only) {
+ ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
if(!td || !sptr)
return;
diff --git a/skeletons/constr_CHOICE.c b/skeletons/constr_CHOICE.c
index 435d592..71936c9 100644
--- a/skeletons/constr_CHOICE.c
+++ b/skeletons/constr_CHOICE.c
@@ -63,8 +63,10 @@
/*
* See the definitions.
*/
-static signed _fetch_present_idx(const void *struct_ptr, int off, int size);
-static void _set_present_idx(void *sptr, int offset, int size, int pres);
+static unsigned _fetch_present_idx(const void *struct_ptr, unsigned off,
+ unsigned size);
+static void _set_present_idx(void *sptr, unsigned offset, unsigned size,
+ unsigned pres);
static const void *_get_member_ptr(const asn_TYPE_descriptor_t *,
const void *sptr, asn_TYPE_member_t **elm,
unsigned *present);
@@ -1035,8 +1037,8 @@
}
void
-CHOICE_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
- asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+CHOICE_free(const asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+ asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
unsigned present;
if(!td || !ptr)
@@ -1081,17 +1083,18 @@
* is guaranteed to be aligned properly. ASN.1 compiler itself does not
* produce packed code.
*/
-static signed
-_fetch_present_idx(const void *struct_ptr, int pres_offset, int pres_size) {
- const void *present_ptr;
+static unsigned
+_fetch_present_idx(const void *struct_ptr, unsigned pres_offset,
+ unsigned pres_size) {
+ const void *present_ptr;
unsigned present;
present_ptr = ((const char *)struct_ptr) + pres_offset;
switch(pres_size) {
- case sizeof(int): present = *(const int *)present_ptr; break;
- case sizeof(short): present = *(const short *)present_ptr; break;
- case sizeof(char): present = *(const char *)present_ptr; break;
+ case sizeof(int): present = *(const unsigned int *)present_ptr; break;
+ case sizeof(short): present = *(const unsigned short *)present_ptr; break;
+ case sizeof(char): present = *(const unsigned char *)present_ptr; break;
default:
/* ANSI C mandates enum to be equivalent to integer */
assert(pres_size != sizeof(int));
@@ -1102,14 +1105,15 @@
}
static void
-_set_present_idx(void *struct_ptr, int pres_offset, int pres_size, int present) {
- void *present_ptr;
+_set_present_idx(void *struct_ptr, unsigned pres_offset, unsigned pres_size,
+ unsigned present) {
+ void *present_ptr;
present_ptr = ((char *)struct_ptr) + pres_offset;
switch(pres_size) {
- case sizeof(int): *(int *)present_ptr = present; break;
- case sizeof(short): *(short *)present_ptr = present; break;
- case sizeof(char): *(char *)present_ptr = present; break;
+ case sizeof(int): *(unsigned int *)present_ptr = present; break;
+ case sizeof(short): *(unsigned short *)present_ptr = present; break;
+ case sizeof(char): *(unsigned char *)present_ptr = present; break;
default:
/* ANSI C mandates enum to be equivalent to integer */
assert(pres_size != sizeof(int));
@@ -1181,3 +1185,50 @@
return 1;
}
}
+
+/*
+ * Return the 1-based choice variant presence index.
+ * Returns 0 in case of error.
+ */
+unsigned
+CHOICE_variant_get_presence(const asn_TYPE_descriptor_t *td, const void *sptr) {
+ asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+ return _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
+}
+
+/*
+ * Sets or resets the 1-based choice variant presence index.
+ * In case a previous index is not zero, the currently selected structure
+ * member is freed and zeroed-out first.
+ * Returns 0 on success and -1 on error.
+ */
+int
+CHOICE_variant_set_presence(const asn_TYPE_descriptor_t *td, void *sptr,
+ unsigned present) {
+ extern asn_CHOICE_specifics_t asn_SPC_value_specs_3;
+ asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+ unsigned old_present;
+
+ if(!sptr) {
+ return -1;
+ }
+
+ if(present > td->elements_count)
+ return -1;
+
+ old_present =
+ _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
+ if(present == old_present)
+ return 0;
+
+ if(old_present == 0) {
+ assert(old_present <= td->elements_count);
+ ASN_STRUCT_FREE_CONTENTS_ONLY(*td, sptr);
+ memset(sptr, 0, specs->struct_size);
+ }
+
+ _set_present_idx(sptr, specs->pres_offset, specs->pres_size, present);
+
+ return 0;
+}
+
diff --git a/skeletons/constr_CHOICE.h b/skeletons/constr_CHOICE.h
index 3c3b6ca..0aedcf7 100644
--- a/skeletons/constr_CHOICE.h
+++ b/skeletons/constr_CHOICE.h
@@ -28,7 +28,7 @@
unsigned tag2el_count;
/* Canonical ordering of CHOICE elements, for PER */
- const int *canonical_order;
+ const unsigned *canonical_order;
/*
* Extensions-related stuff.
@@ -51,6 +51,22 @@
per_type_encoder_f CHOICE_encode_uper;
asn_outmost_tag_f CHOICE_outmost_tag;
+/*
+ * Return the 1-based choice variant presence index.
+ * Returns 0 in case of error.
+ */
+unsigned CHOICE_variant_get_presence(const asn_TYPE_descriptor_t *td,
+ const void *structure_ptr);
+
+/*
+ * Sets or resets the 1-based choice variant presence index.
+ * In case a previous index is not zero, the currently selected structure
+ * member is freed and zeroed-out first.
+ * Returns 0 on success and -1 on error.
+ */
+int CHOICE_variant_set_presence(const asn_TYPE_descriptor_t *td,
+ void *structure_ptr, unsigned present);
+
#ifdef __cplusplus
}
#endif
diff --git a/skeletons/constr_SEQUENCE.c b/skeletons/constr_SEQUENCE.c
index 9859e25..e1c57d3 100644
--- a/skeletons/constr_SEQUENCE.c
+++ b/skeletons/constr_SEQUENCE.c
@@ -5,6 +5,7 @@
*/
#include <asn_internal.h>
#include <constr_SEQUENCE.h>
+#include <OPEN_TYPE.h>
#include <per_opentype.h>
/*
@@ -201,7 +202,7 @@
/*
* MICROPHASE 1: Synchronize decoding.
*/
- ASN_DEBUG("In %s SEQUENCE left %d, edx=%d flags=%d"
+ ASN_DEBUG("In %s SEQUENCE left %d, edx=%u flags=%d"
" opt=%d ec=%d",
td->name, (int)ctx->left, edx,
elements[edx].flags, elements[edx].optional,
@@ -948,8 +949,8 @@
}
void
-SEQUENCE_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
- size_t edx;
+SEQUENCE_free(const asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
+ size_t edx;
if(!td || !sptr)
return;
@@ -1118,15 +1119,10 @@
}
/* Fetch the member from the stream */
- ASN_DEBUG("Decoding member %s in %s", elm->name, td->name);
+ ASN_DEBUG("Decoding member \"%s\" in %s", elm->name, td->name);
if((elm->flags & ATF_OPEN_TYPE) && elm->type_selector) {
- asn_TYPE_descriptor_t *et = elm->type_selector(td, st);
- if(!et) {
- FREEMEM(opres);
- ASN__DECODE_FAILED;
- }
- rv = uper_open_type_get(opt_codec_ctx, et, NULL, memb_ptr2, pd);
+ rv = OPEN_TYPE_uper_get(opt_codec_ctx, td, st, elm, pd);
} else {
rv = elm->type->uper_decoder(opt_codec_ctx, elm->type,
elm->per_constraints, memb_ptr2, pd);
diff --git a/skeletons/constr_SEQUENCE_oer.c b/skeletons/constr_SEQUENCE_oer.c
index 84b0db9..7f162ae 100644
--- a/skeletons/constr_SEQUENCE_oer.c
+++ b/skeletons/constr_SEQUENCE_oer.c
@@ -7,6 +7,7 @@
#include <asn_internal.h>
#include <constr_SEQUENCE.h>
+#include <OPEN_TYPE.h>
#include <errno.h>
/*
@@ -150,8 +151,6 @@
for(edx = (ctx->step >> 1); edx < td->elements_count;
edx++, ctx->step = (ctx->step & ~1) + 2) {
asn_TYPE_member_t *elm = &td->elements[edx];
- void *memb_tmpptr; /* Temporary reference. */
- void **memb_ptr2; /* Pointer to a pointer to a memmber */
ASN_DEBUG("Decoding %s->%s", td->name, elm->name);
@@ -188,37 +187,20 @@
*/
ctx->step |= 1; /* Confirm entering next microphase */
microphase2_decode_continues:
- if(elm->flags & ATF_POINTER) {
- /* Member is a pointer to another structure */
- memb_ptr2 = (void **)((char *)st + elm->memb_offset);
- } else {
- memb_tmpptr = (char *)st + elm->memb_offset;
- memb_ptr2 = &memb_tmpptr; /* Ensure this & remains in scope! */
- }
-
if((elm->flags & ATF_OPEN_TYPE) && elm->type_selector) {
- asn_TYPE_descriptor_t *et = elm->type_selector(td, st);
- ssize_t ot_ret;
- if(!et) {
- ASN__DECODE_FAILED;
- }
- ot_ret = oer_open_type_get(opt_codec_ctx, et, NULL, memb_ptr2,
- ptr, size);
- switch(ot_ret) {
- case -1:
- rval.code = RC_FAIL;
- rval.consumed = 0;
- break;
- case 0:
- rval.code = RC_WMORE;
- rval.consumed = 1;
- break;
- default:
- rval.code = RC_OK;
- rval.consumed = ot_ret;
- break;
- }
+ rval = OPEN_TYPE_oer_get(opt_codec_ctx, td, st, elm, ptr, size);
} else {
+ void *memb_tmpptr; /* Temporary reference. */
+ void **memb_ptr2; /* Pointer to a pointer to a memmber */
+
+ if(elm->flags & ATF_POINTER) {
+ /* Member is a pointer to another structure */
+ memb_ptr2 = (void **)((char *)st + elm->memb_offset);
+ } else {
+ memb_tmpptr = (char *)st + elm->memb_offset;
+ memb_ptr2 = &memb_tmpptr; /* Ensure remains in scope! */
+ }
+
rval = elm->type->oer_decoder(opt_codec_ctx, elm->type,
elm->oer_constraints, memb_ptr2,
ptr, size);
diff --git a/skeletons/constr_SET.c b/skeletons/constr_SET.c
index 226bef3..4f370bf 100644
--- a/skeletons/constr_SET.c
+++ b/skeletons/constr_SET.c
@@ -910,8 +910,8 @@
}
void
-SET_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
- size_t edx;
+SET_free(const asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+ size_t edx;
if(!td || !ptr)
return;
diff --git a/skeletons/constr_SET_OF.c b/skeletons/constr_SET_OF.c
index 62973ac..1a268df 100644
--- a/skeletons/constr_SET_OF.c
+++ b/skeletons/constr_SET_OF.c
@@ -788,7 +788,7 @@
}
void
-SET_OF_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+SET_OF_free(const asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
if(td && ptr) {
asn_SET_OF_specifics_t *specs;
asn_TYPE_member_t *elm = td->elements;
diff --git a/skeletons/constr_TYPE.h b/skeletons/constr_TYPE.h
index d11b859..a7db7b0 100644
--- a/skeletons/constr_TYPE.h
+++ b/skeletons/constr_TYPE.h
@@ -53,7 +53,7 @@
* dynamically.)
*/
typedef void (asn_struct_free_f)(
- struct asn_TYPE_descriptor_s *type_descriptor,
+ const struct asn_TYPE_descriptor_s *type_descriptor,
void *struct_ptr, int free_contents_only);
#define ASN_STRUCT_FREE(asn_DEF, ptr) (asn_DEF).free_struct(&(asn_DEF),ptr,0)
#define ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF, ptr) \
@@ -95,7 +95,11 @@
* Fetch the desired type of the Open Type based on the
* Information Object Set driven constraints.
*/
-typedef struct asn_TYPE_descriptor_s *(asn_type_selector_f)(
+typedef struct asn_type_selector_result_s {
+ struct asn_TYPE_descriptor_s *type_descriptor; /* Type encoded. */
+ unsigned presence_index; /* Associated choice variant. */
+} asn_type_selector_result_t;
+typedef asn_type_selector_result_t(asn_type_selector_f)(
const struct asn_TYPE_descriptor_s *parent_type_descriptor,
const void *parent_structure_ptr);
@@ -168,7 +172,7 @@
ber_tlv_tag_t tag; /* Outmost (most immediate) tag */
int tag_mode; /* IMPLICIT/no/EXPLICIT tag at current level */
asn_TYPE_descriptor_t *type; /* Member type descriptor */
- asn_type_selector_f *type_selector; /* IoS selector */
+ asn_type_selector_f *type_selector; /* IoS runtime type selector */
asn_constr_check_f *memb_constraints; /* Constraints validator */
asn_oer_constraints_t *oer_constraints; /* OER compiled constraints */
asn_per_constraints_t *per_constraints; /* PER compiled constraints */
diff --git a/skeletons/file-dependencies b/skeletons/file-dependencies
index d3c4d0e..10022f5 100644
--- a/skeletons/file-dependencies
+++ b/skeletons/file-dependencies
@@ -5,6 +5,7 @@
#
ANY.h ANY.c
+OPEN_TYPE.h OPEN_TYPE.c constr_CHOICE.h
BMPString.h BMPString.c UTF8String.h
BOOLEAN.h BOOLEAN.c
ENUMERATED.h ENUMERATED.c INTEGER.h NativeEnumerated.h
@@ -34,7 +35,7 @@
asn_SEQUENCE_OF.h asn_SEQUENCE_OF.c asn_SET_OF.h
asn_SET_OF.h asn_SET_OF.c
constr_CHOICE.h constr_CHOICE.c
-constr_SEQUENCE.h constr_SEQUENCE.c
+constr_SEQUENCE.h constr_SEQUENCE.c OPEN_TYPE.h
constr_SEQUENCE_OF.h constr_SEQUENCE_OF.c asn_SEQUENCE_OF.h constr_SET_OF.h
constr_SET.h constr_SET.c
constr_SET_OF.h constr_SET_OF.c asn_SET_OF.h