verify value range constraints for OER
diff --git a/tests/138-oer-constraints-OK.asn1 b/tests/138-oer-constraints-OK.asn1
new file mode 100644
index 0000000..6ea3991
--- /dev/null
+++ b/tests/138-oer-constraints-OK.asn1
@@ -0,0 +1,22 @@
+
+-- OK: Everything is fine
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .138
+
+ModuleOERConstraints
+ { iso org(3) dod(6) internet (1) private(4) enterprise(1)
+ spelio(9363) software(1) asn1c(5) test(1) 138 }
+ DEFINITIONS IMPLICIT TAGS ::=
+BEGIN
+
+ A-noc ::= INTEGER -- No constraints
+ B-vis ::= INTEGER (0) -- Value constraint
+ C-vis ::= INTEGER (-1..1) -- Value range constraint
+ D-inv ::= INTEGER (0..10,...) -- Extensible, not OER-visible
+ E-vis ::= INTEGER (0..10,...)(2..5) -- OER-visible constraint 2..5
+ F-inv ::= INTEGER (0..10,...)(2..5,...) -- Not OER-visible
+ G-vis ::= INTEGER (0..10,...)(2..5,...)(3) -- OER-visible constraint 3
+
+END
diff --git a/tests/138-oer-constraints-OK.asn1.-Pgen-OER b/tests/138-oer-constraints-OK.asn1.-Pgen-OER
new file mode 100644
index 0000000..0024a0d
--- /dev/null
+++ b/tests/138-oer-constraints-OK.asn1.-Pgen-OER
@@ -0,0 +1,1181 @@
+
+/*** <<< INCLUDES [A-noc] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [A-noc] >>> ***/
+
+typedef long A_noc_t;
+
+/*** <<< FUNC-DECLS [A-noc] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_A_noc;
+asn_struct_free_f A_noc_free;
+asn_struct_print_f A_noc_print;
+asn_constr_check_f A_noc_constraint;
+ber_type_decoder_f A_noc_decode_ber;
+der_type_encoder_f A_noc_encode_der;
+xer_type_decoder_f A_noc_decode_xer;
+xer_type_encoder_f A_noc_encode_xer;
+oer_type_decoder_f A_noc_decode_oer;
+oer_type_encoder_f A_noc_encode_oer;
+
+/*** <<< CODE [A-noc] >>> ***/
+
+int
+A_noc_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+ /* Replace with underlying type checker */
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+A_noc_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ td->free_struct = asn_DEF_NativeInteger.free_struct;
+ td->print_struct = asn_DEF_NativeInteger.print_struct;
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
+ td->der_encoder = asn_DEF_NativeInteger.der_encoder;
+ td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
+ td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
+ td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
+ td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
+ td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
+ td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
+ if(!td->oer_constraints)
+ td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+ if(!td->per_constraints)
+ td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+ td->elements = asn_DEF_NativeInteger.elements;
+ td->elements_count = asn_DEF_NativeInteger.elements_count;
+ td->specifics = asn_DEF_NativeInteger.specifics;
+}
+
+void
+A_noc_free(asn_TYPE_descriptor_t *td,
+ void *struct_ptr, int contents_only) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+A_noc_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+A_noc_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const void *bufptr, size_t size, int tag_mode) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+A_noc_encode_der(asn_TYPE_descriptor_t *td,
+ void *structure, int tag_mode, ber_tlv_tag_t tag,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+A_noc_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+A_noc_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+A_noc_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+A_noc_encode_oer(asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints,
+ void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+ A_noc_1_inherit_TYPE_descriptor(td);
+ return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [A-noc] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_A_noc_tags_1[] = {
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_A_noc = {
+ "A-noc",
+ "A-noc",
+ A_noc_free,
+ A_noc_print,
+ A_noc_constraint,
+ A_noc_decode_ber,
+ A_noc_encode_der,
+ A_noc_decode_xer,
+ A_noc_encode_xer,
+ A_noc_decode_oer,
+ A_noc_encode_oer,
+ 0, 0, /* No PER support, use "-gen-PER" to enable */
+ 0, /* Use generic outmost tag fetcher */
+ asn_DEF_A_noc_tags_1,
+ sizeof(asn_DEF_A_noc_tags_1)
+ /sizeof(asn_DEF_A_noc_tags_1[0]), /* 1 */
+ asn_DEF_A_noc_tags_1, /* Same as above */
+ sizeof(asn_DEF_A_noc_tags_1)
+ /sizeof(asn_DEF_A_noc_tags_1[0]), /* 1 */
+ 0, /* No OER visible constraints */
+ 0, /* No PER visible constraints */
+ 0, 0, /* No members */
+ 0 /* No specifics */
+};
+
+
+/*** <<< INCLUDES [B-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [B-vis] >>> ***/
+
+typedef long B_vis_t;
+
+/*** <<< FUNC-DECLS [B-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_B_vis;
+asn_struct_free_f B_vis_free;
+asn_struct_print_f B_vis_print;
+asn_constr_check_f B_vis_constraint;
+ber_type_decoder_f B_vis_decode_ber;
+der_type_encoder_f B_vis_encode_der;
+xer_type_decoder_f B_vis_decode_xer;
+xer_type_encoder_f B_vis_encode_xer;
+oer_type_decoder_f B_vis_decode_oer;
+oer_type_encoder_f B_vis_encode_oer;
+
+/*** <<< CODE [B-vis] >>> ***/
+
+int
+B_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+ long value;
+
+ if(!sptr) {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: value not given (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+
+ value = *(const long *)sptr;
+
+ if((value == 0)) {
+ /* Constraint check succeeded */
+ return 0;
+ } else {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: constraint failed (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+B_vis_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ td->free_struct = asn_DEF_NativeInteger.free_struct;
+ td->print_struct = asn_DEF_NativeInteger.print_struct;
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
+ td->der_encoder = asn_DEF_NativeInteger.der_encoder;
+ td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
+ td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
+ td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
+ td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
+ td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
+ td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
+ if(!td->oer_constraints)
+ td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+ if(!td->per_constraints)
+ td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+ td->elements = asn_DEF_NativeInteger.elements;
+ td->elements_count = asn_DEF_NativeInteger.elements_count;
+ td->specifics = asn_DEF_NativeInteger.specifics;
+}
+
+void
+B_vis_free(asn_TYPE_descriptor_t *td,
+ void *struct_ptr, int contents_only) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+B_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+B_vis_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const void *bufptr, size_t size, int tag_mode) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+B_vis_encode_der(asn_TYPE_descriptor_t *td,
+ void *structure, int tag_mode, ber_tlv_tag_t tag,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+B_vis_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+B_vis_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+B_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+B_vis_encode_oer(asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints,
+ void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+ B_vis_1_inherit_TYPE_descriptor(td);
+ return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [B-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_B_vis_constr_1 GCC_NOTUSED = {
+ { AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 0, 0 } /* (0..0) */,
+ { 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [B-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_B_vis_tags_1[] = {
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_B_vis = {
+ "B-vis",
+ "B-vis",
+ B_vis_free,
+ B_vis_print,
+ B_vis_constraint,
+ B_vis_decode_ber,
+ B_vis_encode_der,
+ B_vis_decode_xer,
+ B_vis_encode_xer,
+ B_vis_decode_oer,
+ B_vis_encode_oer,
+ 0, 0, /* No PER support, use "-gen-PER" to enable */
+ 0, /* Use generic outmost tag fetcher */
+ asn_DEF_B_vis_tags_1,
+ sizeof(asn_DEF_B_vis_tags_1)
+ /sizeof(asn_DEF_B_vis_tags_1[0]), /* 1 */
+ asn_DEF_B_vis_tags_1, /* Same as above */
+ sizeof(asn_DEF_B_vis_tags_1)
+ /sizeof(asn_DEF_B_vis_tags_1[0]), /* 1 */
+ &asn_OER_type_B_vis_constr_1,
+ 0, /* No PER visible constraints */
+ 0, 0, /* No members */
+ 0 /* No specifics */
+};
+
+
+/*** <<< INCLUDES [C-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [C-vis] >>> ***/
+
+typedef long C_vis_t;
+
+/*** <<< FUNC-DECLS [C-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_C_vis;
+asn_struct_free_f C_vis_free;
+asn_struct_print_f C_vis_print;
+asn_constr_check_f C_vis_constraint;
+ber_type_decoder_f C_vis_decode_ber;
+der_type_encoder_f C_vis_encode_der;
+xer_type_decoder_f C_vis_decode_xer;
+xer_type_encoder_f C_vis_encode_xer;
+oer_type_decoder_f C_vis_decode_oer;
+oer_type_encoder_f C_vis_encode_oer;
+
+/*** <<< CODE [C-vis] >>> ***/
+
+int
+C_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+ long value;
+
+ if(!sptr) {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: value not given (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+
+ value = *(const long *)sptr;
+
+ if((value >= -1 && value <= 1)) {
+ /* Constraint check succeeded */
+ return 0;
+ } else {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: constraint failed (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+C_vis_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ td->free_struct = asn_DEF_NativeInteger.free_struct;
+ td->print_struct = asn_DEF_NativeInteger.print_struct;
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
+ td->der_encoder = asn_DEF_NativeInteger.der_encoder;
+ td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
+ td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
+ td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
+ td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
+ td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
+ td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
+ if(!td->oer_constraints)
+ td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+ if(!td->per_constraints)
+ td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+ td->elements = asn_DEF_NativeInteger.elements;
+ td->elements_count = asn_DEF_NativeInteger.elements_count;
+ td->specifics = asn_DEF_NativeInteger.specifics;
+}
+
+void
+C_vis_free(asn_TYPE_descriptor_t *td,
+ void *struct_ptr, int contents_only) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+C_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+C_vis_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const void *bufptr, size_t size, int tag_mode) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+C_vis_encode_der(asn_TYPE_descriptor_t *td,
+ void *structure, int tag_mode, ber_tlv_tag_t tag,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+C_vis_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+C_vis_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+C_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+C_vis_encode_oer(asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints,
+ void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+ C_vis_1_inherit_TYPE_descriptor(td);
+ return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [C-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_C_vis_constr_1 GCC_NOTUSED = {
+ { AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, -1, 1 } /* (-1..1) */,
+ { 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [C-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_C_vis_tags_1[] = {
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_C_vis = {
+ "C-vis",
+ "C-vis",
+ C_vis_free,
+ C_vis_print,
+ C_vis_constraint,
+ C_vis_decode_ber,
+ C_vis_encode_der,
+ C_vis_decode_xer,
+ C_vis_encode_xer,
+ C_vis_decode_oer,
+ C_vis_encode_oer,
+ 0, 0, /* No PER support, use "-gen-PER" to enable */
+ 0, /* Use generic outmost tag fetcher */
+ asn_DEF_C_vis_tags_1,
+ sizeof(asn_DEF_C_vis_tags_1)
+ /sizeof(asn_DEF_C_vis_tags_1[0]), /* 1 */
+ asn_DEF_C_vis_tags_1, /* Same as above */
+ sizeof(asn_DEF_C_vis_tags_1)
+ /sizeof(asn_DEF_C_vis_tags_1[0]), /* 1 */
+ &asn_OER_type_C_vis_constr_1,
+ 0, /* No PER visible constraints */
+ 0, 0, /* No members */
+ 0 /* No specifics */
+};
+
+
+/*** <<< INCLUDES [D-inv] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [D-inv] >>> ***/
+
+typedef long D_inv_t;
+
+/*** <<< FUNC-DECLS [D-inv] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_D_inv;
+asn_struct_free_f D_inv_free;
+asn_struct_print_f D_inv_print;
+asn_constr_check_f D_inv_constraint;
+ber_type_decoder_f D_inv_decode_ber;
+der_type_encoder_f D_inv_encode_der;
+xer_type_decoder_f D_inv_decode_xer;
+xer_type_encoder_f D_inv_encode_xer;
+oer_type_decoder_f D_inv_decode_oer;
+oer_type_encoder_f D_inv_encode_oer;
+
+/*** <<< CODE [D-inv] >>> ***/
+
+int
+D_inv_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+ long value;
+
+ if(!sptr) {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: value not given (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+
+ value = *(const long *)sptr;
+
+ if((value >= 0 && value <= 10)) {
+ /* Constraint check succeeded */
+ return 0;
+ } else {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: constraint failed (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+D_inv_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ td->free_struct = asn_DEF_NativeInteger.free_struct;
+ td->print_struct = asn_DEF_NativeInteger.print_struct;
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
+ td->der_encoder = asn_DEF_NativeInteger.der_encoder;
+ td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
+ td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
+ td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
+ td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
+ td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
+ td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
+ if(!td->oer_constraints)
+ td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+ if(!td->per_constraints)
+ td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+ td->elements = asn_DEF_NativeInteger.elements;
+ td->elements_count = asn_DEF_NativeInteger.elements_count;
+ td->specifics = asn_DEF_NativeInteger.specifics;
+}
+
+void
+D_inv_free(asn_TYPE_descriptor_t *td,
+ void *struct_ptr, int contents_only) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+D_inv_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+D_inv_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const void *bufptr, size_t size, int tag_mode) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+D_inv_encode_der(asn_TYPE_descriptor_t *td,
+ void *structure, int tag_mode, ber_tlv_tag_t tag,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+D_inv_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+D_inv_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+D_inv_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+D_inv_encode_oer(asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints,
+ void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+ D_inv_1_inherit_TYPE_descriptor(td);
+ return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [D-inv] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_D_inv_constr_1 GCC_NOTUSED = {
+ { AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 0, 10 } /* (0..10,...) */,
+ { 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [D-inv] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_D_inv_tags_1[] = {
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_D_inv = {
+ "D-inv",
+ "D-inv",
+ D_inv_free,
+ D_inv_print,
+ D_inv_constraint,
+ D_inv_decode_ber,
+ D_inv_encode_der,
+ D_inv_decode_xer,
+ D_inv_encode_xer,
+ D_inv_decode_oer,
+ D_inv_encode_oer,
+ 0, 0, /* No PER support, use "-gen-PER" to enable */
+ 0, /* Use generic outmost tag fetcher */
+ asn_DEF_D_inv_tags_1,
+ sizeof(asn_DEF_D_inv_tags_1)
+ /sizeof(asn_DEF_D_inv_tags_1[0]), /* 1 */
+ asn_DEF_D_inv_tags_1, /* Same as above */
+ sizeof(asn_DEF_D_inv_tags_1)
+ /sizeof(asn_DEF_D_inv_tags_1[0]), /* 1 */
+ &asn_OER_type_D_inv_constr_1,
+ 0, /* No PER visible constraints */
+ 0, 0, /* No members */
+ 0 /* No specifics */
+};
+
+
+/*** <<< INCLUDES [E-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [E-vis] >>> ***/
+
+typedef long E_vis_t;
+
+/*** <<< FUNC-DECLS [E-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_E_vis;
+asn_struct_free_f E_vis_free;
+asn_struct_print_f E_vis_print;
+asn_constr_check_f E_vis_constraint;
+ber_type_decoder_f E_vis_decode_ber;
+der_type_encoder_f E_vis_encode_der;
+xer_type_decoder_f E_vis_decode_xer;
+xer_type_encoder_f E_vis_encode_xer;
+oer_type_decoder_f E_vis_decode_oer;
+oer_type_encoder_f E_vis_encode_oer;
+
+/*** <<< CODE [E-vis] >>> ***/
+
+int
+E_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+ long value;
+
+ if(!sptr) {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: value not given (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+
+ value = *(const long *)sptr;
+
+ if((value >= 2 && value <= 5)) {
+ /* Constraint check succeeded */
+ return 0;
+ } else {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: constraint failed (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+E_vis_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ td->free_struct = asn_DEF_NativeInteger.free_struct;
+ td->print_struct = asn_DEF_NativeInteger.print_struct;
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
+ td->der_encoder = asn_DEF_NativeInteger.der_encoder;
+ td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
+ td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
+ td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
+ td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
+ td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
+ td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
+ if(!td->oer_constraints)
+ td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+ if(!td->per_constraints)
+ td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+ td->elements = asn_DEF_NativeInteger.elements;
+ td->elements_count = asn_DEF_NativeInteger.elements_count;
+ td->specifics = asn_DEF_NativeInteger.specifics;
+}
+
+void
+E_vis_free(asn_TYPE_descriptor_t *td,
+ void *struct_ptr, int contents_only) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+E_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+E_vis_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const void *bufptr, size_t size, int tag_mode) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+E_vis_encode_der(asn_TYPE_descriptor_t *td,
+ void *structure, int tag_mode, ber_tlv_tag_t tag,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+E_vis_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+E_vis_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+E_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+E_vis_encode_oer(asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints,
+ void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+ E_vis_1_inherit_TYPE_descriptor(td);
+ return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [E-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_E_vis_constr_1 GCC_NOTUSED = {
+ { AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 2, 5 } /* (2..5) */,
+ { 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [E-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_E_vis_tags_1[] = {
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_E_vis = {
+ "E-vis",
+ "E-vis",
+ E_vis_free,
+ E_vis_print,
+ E_vis_constraint,
+ E_vis_decode_ber,
+ E_vis_encode_der,
+ E_vis_decode_xer,
+ E_vis_encode_xer,
+ E_vis_decode_oer,
+ E_vis_encode_oer,
+ 0, 0, /* No PER support, use "-gen-PER" to enable */
+ 0, /* Use generic outmost tag fetcher */
+ asn_DEF_E_vis_tags_1,
+ sizeof(asn_DEF_E_vis_tags_1)
+ /sizeof(asn_DEF_E_vis_tags_1[0]), /* 1 */
+ asn_DEF_E_vis_tags_1, /* Same as above */
+ sizeof(asn_DEF_E_vis_tags_1)
+ /sizeof(asn_DEF_E_vis_tags_1[0]), /* 1 */
+ &asn_OER_type_E_vis_constr_1,
+ 0, /* No PER visible constraints */
+ 0, 0, /* No members */
+ 0 /* No specifics */
+};
+
+
+/*** <<< INCLUDES [F-inv] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [F-inv] >>> ***/
+
+typedef long F_inv_t;
+
+/*** <<< FUNC-DECLS [F-inv] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_F_inv;
+asn_struct_free_f F_inv_free;
+asn_struct_print_f F_inv_print;
+asn_constr_check_f F_inv_constraint;
+ber_type_decoder_f F_inv_decode_ber;
+der_type_encoder_f F_inv_encode_der;
+xer_type_decoder_f F_inv_decode_xer;
+xer_type_encoder_f F_inv_encode_xer;
+oer_type_decoder_f F_inv_decode_oer;
+oer_type_encoder_f F_inv_encode_oer;
+
+/*** <<< CODE [F-inv] >>> ***/
+
+int
+F_inv_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+ long value;
+
+ if(!sptr) {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: value not given (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+
+ value = *(const long *)sptr;
+
+ if((value >= 2 && value <= 5)) {
+ /* Constraint check succeeded */
+ return 0;
+ } else {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: constraint failed (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+F_inv_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ td->free_struct = asn_DEF_NativeInteger.free_struct;
+ td->print_struct = asn_DEF_NativeInteger.print_struct;
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
+ td->der_encoder = asn_DEF_NativeInteger.der_encoder;
+ td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
+ td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
+ td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
+ td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
+ td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
+ td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
+ if(!td->oer_constraints)
+ td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+ if(!td->per_constraints)
+ td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+ td->elements = asn_DEF_NativeInteger.elements;
+ td->elements_count = asn_DEF_NativeInteger.elements_count;
+ td->specifics = asn_DEF_NativeInteger.specifics;
+}
+
+void
+F_inv_free(asn_TYPE_descriptor_t *td,
+ void *struct_ptr, int contents_only) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+F_inv_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+F_inv_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const void *bufptr, size_t size, int tag_mode) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+F_inv_encode_der(asn_TYPE_descriptor_t *td,
+ void *structure, int tag_mode, ber_tlv_tag_t tag,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+F_inv_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+F_inv_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+F_inv_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+F_inv_encode_oer(asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints,
+ void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+ F_inv_1_inherit_TYPE_descriptor(td);
+ return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [F-inv] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_F_inv_constr_1 GCC_NOTUSED = {
+ { AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 2, 5 } /* (2..5,...) */,
+ { 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [F-inv] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_F_inv_tags_1[] = {
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_F_inv = {
+ "F-inv",
+ "F-inv",
+ F_inv_free,
+ F_inv_print,
+ F_inv_constraint,
+ F_inv_decode_ber,
+ F_inv_encode_der,
+ F_inv_decode_xer,
+ F_inv_encode_xer,
+ F_inv_decode_oer,
+ F_inv_encode_oer,
+ 0, 0, /* No PER support, use "-gen-PER" to enable */
+ 0, /* Use generic outmost tag fetcher */
+ asn_DEF_F_inv_tags_1,
+ sizeof(asn_DEF_F_inv_tags_1)
+ /sizeof(asn_DEF_F_inv_tags_1[0]), /* 1 */
+ asn_DEF_F_inv_tags_1, /* Same as above */
+ sizeof(asn_DEF_F_inv_tags_1)
+ /sizeof(asn_DEF_F_inv_tags_1[0]), /* 1 */
+ &asn_OER_type_F_inv_constr_1,
+ 0, /* No PER visible constraints */
+ 0, 0, /* No members */
+ 0 /* No specifics */
+};
+
+
+/*** <<< INCLUDES [G-vis] >>> ***/
+
+#include <NativeInteger.h>
+
+/*** <<< TYPE-DECLS [G-vis] >>> ***/
+
+typedef long G_vis_t;
+
+/*** <<< FUNC-DECLS [G-vis] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_G_vis;
+asn_struct_free_f G_vis_free;
+asn_struct_print_f G_vis_print;
+asn_constr_check_f G_vis_constraint;
+ber_type_decoder_f G_vis_decode_ber;
+der_type_encoder_f G_vis_encode_der;
+xer_type_decoder_f G_vis_decode_xer;
+xer_type_encoder_f G_vis_encode_xer;
+oer_type_decoder_f G_vis_decode_oer;
+oer_type_encoder_f G_vis_encode_oer;
+
+/*** <<< CODE [G-vis] >>> ***/
+
+int
+G_vis_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+ asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+ long value;
+
+ if(!sptr) {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: value not given (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+
+ value = *(const long *)sptr;
+
+ if((value == 3)) {
+ /* Constraint check succeeded */
+ return 0;
+ } else {
+ ASN__CTFAIL(app_key, td, sptr,
+ "%s: constraint failed (%s:%d)",
+ td->name, __FILE__, __LINE__);
+ return -1;
+ }
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+G_vis_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+ td->free_struct = asn_DEF_NativeInteger.free_struct;
+ td->print_struct = asn_DEF_NativeInteger.print_struct;
+ td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+ td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
+ td->der_encoder = asn_DEF_NativeInteger.der_encoder;
+ td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
+ td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
+ td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
+ td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
+ td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
+ td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
+ if(!td->oer_constraints)
+ td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
+ if(!td->per_constraints)
+ td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+ td->elements = asn_DEF_NativeInteger.elements;
+ td->elements_count = asn_DEF_NativeInteger.elements_count;
+ td->specifics = asn_DEF_NativeInteger.specifics;
+}
+
+void
+G_vis_free(asn_TYPE_descriptor_t *td,
+ void *struct_ptr, int contents_only) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+G_vis_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+G_vis_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const void *bufptr, size_t size, int tag_mode) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+G_vis_encode_der(asn_TYPE_descriptor_t *td,
+ void *structure, int tag_mode, ber_tlv_tag_t tag,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+G_vis_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+G_vis_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+ int ilevel, enum xer_encoder_flags_e flags,
+ asn_app_consume_bytes_f *cb, void *app_key) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+G_vis_decode_oer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints, void **structure, const void *buffer, size_t size) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ return td->oer_decoder(opt_codec_ctx, td, constraints, structure, buffer, size);
+}
+
+asn_enc_rval_t
+G_vis_encode_oer(asn_TYPE_descriptor_t *td,
+ asn_oer_constraints_t *constraints,
+ void *structure, asn_app_consume_bytes_f *cb, void *app_key) {
+ G_vis_1_inherit_TYPE_descriptor(td);
+ return td->uper_encoder(td, constraints, structure, cb, app_key);
+}
+
+
+/*** <<< CTDEFS [G-vis] >>> ***/
+
+static asn_oer_constraints_t asn_OER_type_G_vis_constr_1 GCC_NOTUSED = {
+ { AOC_HAS_LOWER_BOUND | AOC_HAS_UPPER_BOUND, 3, 3 } /* (3..3) */,
+ { 0, 0, 0 }};
+
+/*** <<< STAT-DEFS [G-vis] >>> ***/
+
+static const ber_tlv_tag_t asn_DEF_G_vis_tags_1[] = {
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_G_vis = {
+ "G-vis",
+ "G-vis",
+ G_vis_free,
+ G_vis_print,
+ G_vis_constraint,
+ G_vis_decode_ber,
+ G_vis_encode_der,
+ G_vis_decode_xer,
+ G_vis_encode_xer,
+ G_vis_decode_oer,
+ G_vis_encode_oer,
+ 0, 0, /* No PER support, use "-gen-PER" to enable */
+ 0, /* Use generic outmost tag fetcher */
+ asn_DEF_G_vis_tags_1,
+ sizeof(asn_DEF_G_vis_tags_1)
+ /sizeof(asn_DEF_G_vis_tags_1[0]), /* 1 */
+ asn_DEF_G_vis_tags_1, /* Same as above */
+ sizeof(asn_DEF_G_vis_tags_1)
+ /sizeof(asn_DEF_G_vis_tags_1[0]), /* 1 */
+ &asn_OER_type_G_vis_constr_1,
+ 0, /* No PER visible constraints */
+ 0, 0, /* No members */
+ 0 /* No specifics */
+};
+