diff options
Diffstat (limited to 'tests/70-xer-test-OK.asn1.-Pfwide-types')
| -rw-r--r-- | tests/70-xer-test-OK.asn1.-Pfwide-types | 1911 |
1 files changed, 1911 insertions, 0 deletions
diff --git a/tests/70-xer-test-OK.asn1.-Pfwide-types b/tests/70-xer-test-OK.asn1.-Pfwide-types new file mode 100644 index 00000000..e109a8b3 --- /dev/null +++ b/tests/70-xer-test-OK.asn1.-Pfwide-types @@ -0,0 +1,1911 @@ + +/*** <<< INCLUDES [PDU] >>> ***/ + +#include "Sequence.h" +#include "Set.h" +#include "SequenceOf.h" +#include "ExtensibleSet.h" +#include "ExtensibleSequence.h" +#include "ExtensibleSequence2.h" +#include "SetOfNULL.h" +#include "SetOfREAL.h" +#include "SetOfEnums.h" +#include "NamedSetOfNULL.h" +#include "NamedSetOfREAL.h" +#include "NamedSetOfEnums.h" +#include "SeqOfZuka.h" +#include "SetOfChoice.h" +#include "NamedSetOfChoice.h" +#include <constr_CHOICE.h> + +/*** <<< DEPS [PDU] >>> ***/ + +typedef enum PDU_PR { + PDU_PR_NOTHING, /* No components present */ + PDU_PR_sequence, + PDU_PR_set, + PDU_PR_sequenceOf, + PDU_PR_extensibleSet, + PDU_PR_extensibleSequence, + PDU_PR_extensibleSequence2, + PDU_PR_setOfNULL, + PDU_PR_setOfREAL, + PDU_PR_setOfEnums, + PDU_PR_namedSetOfNULL, + PDU_PR_namedSetOfREAL, + PDU_PR_namedSetOfEnums, + PDU_PR_seqOfZuka, + PDU_PR_setOfChoice, + PDU_PR_namedSetOfChoice, + /* Extensions may appear below */ + +} PDU_PR; + +/*** <<< TYPE-DECLS [PDU] >>> ***/ + +typedef struct PDU { + PDU_PR present; + union PDU_u { + Sequence_t sequence; + Set_t set; + SequenceOf_t sequenceOf; + ExtensibleSet_t extensibleSet; + ExtensibleSequence_t extensibleSequence; + ExtensibleSequence2_t extensibleSequence2; + SetOfNULL_t setOfNULL; + SetOfREAL_t setOfREAL; + SetOfEnums_t setOfEnums; + NamedSetOfNULL_t namedSetOfNULL; + NamedSetOfREAL_t namedSetOfREAL; + NamedSetOfEnums_t namedSetOfEnums; + SeqOfZuka_t seqOfZuka; + SetOfChoice_t setOfChoice; + NamedSetOfChoice_t namedSetOfChoice; + /* + * This type is extensible, + * possible extensions are below. + */ + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} PDU_t; + +/*** <<< FUNC-DECLS [PDU] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_PDU; + +/*** <<< STAT-DEFS [PDU] >>> ***/ + +static asn_TYPE_member_t asn_MBR_PDU_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.sequence), + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_Sequence, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "sequence" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.set), + .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_Set, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "set" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.sequenceOf), + .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_SequenceOf, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "sequenceOf" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSet), + .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_ExtensibleSet, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "extensibleSet" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSequence), + .tag = (ASN_TAG_CLASS_CONTEXT | (4 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_ExtensibleSequence, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "extensibleSequence" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSequence2), + .tag = (ASN_TAG_CLASS_CONTEXT | (5 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_ExtensibleSequence2, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "extensibleSequence2" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfNULL), + .tag = (ASN_TAG_CLASS_CONTEXT | (6 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_SetOfNULL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "setOfNULL" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfREAL), + .tag = (ASN_TAG_CLASS_CONTEXT | (7 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_SetOfREAL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "setOfREAL" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfEnums), + .tag = (ASN_TAG_CLASS_CONTEXT | (8 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_SetOfEnums, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "setOfEnums" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfNULL), + .tag = (ASN_TAG_CLASS_CONTEXT | (9 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_NamedSetOfNULL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "namedSetOfNULL" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfREAL), + .tag = (ASN_TAG_CLASS_CONTEXT | (10 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_NamedSetOfREAL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "namedSetOfREAL" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfEnums), + .tag = (ASN_TAG_CLASS_CONTEXT | (11 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_NamedSetOfEnums, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "namedSetOfEnums" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.seqOfZuka), + .tag = (ASN_TAG_CLASS_CONTEXT | (12 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_SeqOfZuka, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "seqOfZuka" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfChoice), + .tag = (ASN_TAG_CLASS_CONTEXT | (13 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_SetOfChoice, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "setOfChoice" + }, + { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfChoice), + .tag = (ASN_TAG_CLASS_CONTEXT | (14 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_NamedSetOfChoice, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "namedSetOfChoice" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_PDU_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* sequence at 19 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* set at 20 */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* sequenceOf at 21 */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* extensibleSet at 22 */ + { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* extensibleSequence at 23 */ + { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* extensibleSequence2 at 24 */ + { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* setOfNULL at 25 */ + { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* setOfREAL at 26 */ + { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* setOfEnums at 27 */ + { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 }, /* namedSetOfNULL at 28 */ + { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 10, 0, 0 }, /* namedSetOfREAL at 29 */ + { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 11, 0, 0 }, /* namedSetOfEnums at 30 */ + { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 12, 0, 0 }, /* seqOfZuka at 31 */ + { (ASN_TAG_CLASS_CONTEXT | (13 << 2)), 13, 0, 0 }, /* setOfChoice at 32 */ + { (ASN_TAG_CLASS_CONTEXT | (14 << 2)), 14, 0, 0 } /* namedSetOfChoice at 33 */ +}; +static asn_CHOICE_specifics_t asn_SPC_PDU_specs_1 = { + sizeof(struct PDU), + offsetof(struct PDU, _asn_ctx), + offsetof(struct PDU, present), + sizeof(((struct PDU *)0)->present), + asn_MAP_PDU_tag2el_1, + 15, /* Count of tags in the map */ + .canonical_order = 0, + .ext_start = 15 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_PDU = { + "PDU", + "PDU", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_PDU_1, + 15, /* Elements count */ + &asn_SPC_PDU_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [Sequence] >>> ***/ + +#include <INTEGER.h> +#include <BIT_STRING.h> +#include <UTF8String.h> +#include <constr_SEQUENCE.h> + +/*** <<< FWD-DECLS [Sequence] >>> ***/ + +struct Sequence; + +/*** <<< TYPE-DECLS [Sequence] >>> ***/ + +typedef struct Sequence { + INTEGER_t integer; + struct Sequence *sequence /* OPTIONAL */; + BIT_STRING_t *bits /* OPTIONAL */; + UTF8String_t string; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} Sequence_t; + +/*** <<< FUNC-DECLS [Sequence] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_Sequence; + +/*** <<< POST-INCLUDE [Sequence] >>> ***/ + +#include "Sequence.h" + +/*** <<< STAT-DEFS [Sequence] >>> ***/ + +static asn_TYPE_member_t asn_MBR_Sequence_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct Sequence, integer), + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_INTEGER, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "integer" + }, + { ATF_POINTER, 2, offsetof(struct Sequence, sequence), + .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_Sequence, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "sequence" + }, + { ATF_POINTER, 1, offsetof(struct Sequence, bits), + .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_BIT_STRING, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "bits" + }, + { ATF_NOFLAGS, 0, offsetof(struct Sequence, string), + .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_UTF8String, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "string" + }, +}; +static ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* integer at 38 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* sequence at 39 */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* bits at 40 */ + { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* string at 41 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = { + sizeof(struct Sequence), + offsetof(struct Sequence, _asn_ctx), + asn_MAP_Sequence_tag2el_1, + 4, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_Sequence = { + "Sequence", + "Sequence", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Sequence_tags_1, + sizeof(asn_DEF_Sequence_tags_1) + /sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */ + asn_DEF_Sequence_tags_1, /* Same as above */ + sizeof(asn_DEF_Sequence_tags_1) + /sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_Sequence_1, + 4, /* Elements count */ + &asn_SPC_Sequence_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [Set] >>> ***/ + +#include <RELATIVE-OID.h> +#include <OCTET_STRING.h> +#include <constr_SET.h> + +/*** <<< DEPS [Set] >>> ***/ + + +/* + * Method of determining the components presence + */ +typedef enum Set_PR { + Set_PR_roid, /* Member roid is present */ + Set_PR_opaque, /* Member opaque is present */ +} Set_PR; + +/*** <<< TYPE-DECLS [Set] >>> ***/ + +typedef struct Set { + RELATIVE_OID_t roid; + OCTET_STRING_t *opaque /* OPTIONAL */; + + /* Presence bitmask: ASN_SET_ISPRESENT(pSet, Set_PR_x) */ + unsigned int _presence_map + [((2+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))]; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} Set_t; + +/*** <<< FUNC-DECLS [Set] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_Set; + +/*** <<< STAT-DEFS [Set] >>> ***/ + +static asn_TYPE_member_t asn_MBR_Set_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct Set, roid), + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_RELATIVE_OID, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "roid" + }, + { ATF_POINTER, 1, offsetof(struct Set, opaque), + .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_OCTET_STRING, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "opaque" + }, +}; +static ber_tlv_tag_t asn_DEF_Set_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_Set_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* roid at 45 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* opaque at 46 */ +}; +static uint8_t asn_MAP_Set_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = { + (1 << 7) | (0 << 6) +}; +static asn_SET_specifics_t asn_SPC_Set_specs_1 = { + sizeof(struct Set), + offsetof(struct Set, _asn_ctx), + offsetof(struct Set, _presence_map), + asn_MAP_Set_tag2el_1, + 2, /* Count of tags in the map */ + asn_MAP_Set_tag2el_1, /* Same as above */ + 2, /* Count of tags in the CXER map */ + 0, /* Whether extensible */ + (unsigned int *)asn_MAP_Set_mmap_1 /* Mandatory elements map */ +}; +asn_TYPE_descriptor_t asn_DEF_Set = { + "Set", + "Set", + SET_free, + SET_print, + SET_constraint, + SET_decode_ber, + SET_encode_der, + SET_decode_xer, + SET_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Set_tags_1, + sizeof(asn_DEF_Set_tags_1) + /sizeof(asn_DEF_Set_tags_1[0]), /* 1 */ + asn_DEF_Set_tags_1, /* Same as above */ + sizeof(asn_DEF_Set_tags_1) + /sizeof(asn_DEF_Set_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_Set_1, + 2, /* Elements count */ + &asn_SPC_Set_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [ExtensibleSet] >>> ***/ + +#include <UTF8String.h> +#include <ENUMERATED.h> +#include <constr_SET.h> + +/*** <<< DEPS [ExtensibleSet] >>> ***/ + + +/* + * Method of determining the components presence + */ +typedef enum ExtensibleSet_PR { + ExtensibleSet_PR_string, /* Member string is present */ + ExtensibleSet_PR_enum, /* Member enum is present */ +} ExtensibleSet_PR; +typedef enum Enum { + enum_b = 0, + enum_a = 1 +} e_enum; + +/*** <<< TYPE-DECLS [ExtensibleSet] >>> ***/ + +typedef struct ExtensibleSet { + UTF8String_t *string /* OPTIONAL */; + /* + * This type is extensible, + * possible extensions are below. + */ + ENUMERATED_t *Enum; + + /* Presence bitmask: ASN_SET_ISPRESENT(pExtensibleSet, ExtensibleSet_PR_x) */ + unsigned int _presence_map + [((2+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))]; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} ExtensibleSet_t; + +/*** <<< FUNC-DECLS [ExtensibleSet] >>> ***/ + +/* extern asn_TYPE_descriptor_t asn_DEF_enum_4; // (Use -fall-defs-global to expose) */ +extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSet; + +/*** <<< CODE [ExtensibleSet] >>> ***/ + +static int +enum_4_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_ENUMERATED.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using ENUMERATED, + * so here we adjust the DEF accordingly. + */ +static void +enum_4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_ENUMERATED.free_struct; + td->print_struct = asn_DEF_ENUMERATED.print_struct; + td->ber_decoder = asn_DEF_ENUMERATED.ber_decoder; + td->der_encoder = asn_DEF_ENUMERATED.der_encoder; + td->xer_decoder = asn_DEF_ENUMERATED.xer_decoder; + td->xer_encoder = asn_DEF_ENUMERATED.xer_encoder; + td->uper_decoder = asn_DEF_ENUMERATED.uper_decoder; + td->uper_encoder = asn_DEF_ENUMERATED.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_ENUMERATED.per_constraints; + td->elements = asn_DEF_ENUMERATED.elements; + td->elements_count = asn_DEF_ENUMERATED.elements_count; + /* td->specifics = asn_DEF_ENUMERATED.specifics; // Defined explicitly */ +} + +static void +enum_4_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + enum_4_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +static int +enum_4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + enum_4_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +static asn_dec_rval_t +enum_4_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) { + enum_4_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +static asn_enc_rval_t +enum_4_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) { + enum_4_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +static asn_dec_rval_t +enum_4_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) { + enum_4_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +static asn_enc_rval_t +enum_4_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) { + enum_4_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + + +/*** <<< STAT-DEFS [ExtensibleSet] >>> ***/ + +static asn_INTEGER_enum_map_t asn_MAP_enum_value2enum_4[] = { + { 0, 1, "b" }, + { 1, 1, "a" } +}; +static unsigned int asn_MAP_enum_enum2value_4[] = { + 1, /* a(1) */ + 0 /* b(0) */ +}; +static asn_INTEGER_specifics_t asn_SPC_enum_specs_4 = { + asn_MAP_enum_value2enum_4, /* "tag" => N; sorted by tag */ + asn_MAP_enum_enum2value_4, /* N => "tag"; sorted by N */ + 2, /* Number of elements in the maps */ + 0, /* Enumeration is not extensible */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static ber_tlv_tag_t asn_DEF_enum_tags_4[] = { + (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_enum_4 = { + "enum", + "enum", + enum_4_free, + enum_4_print, + enum_4_constraint, + enum_4_decode_ber, + enum_4_encode_der, + enum_4_decode_xer, + enum_4_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_enum_tags_4, + sizeof(asn_DEF_enum_tags_4) + /sizeof(asn_DEF_enum_tags_4[0]) - 1, /* 1 */ + asn_DEF_enum_tags_4, /* Same as above */ + sizeof(asn_DEF_enum_tags_4) + /sizeof(asn_DEF_enum_tags_4[0]), /* 2 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + &asn_SPC_enum_specs_4 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_ExtensibleSet_1[] = { + { ATF_POINTER, 2, offsetof(struct ExtensibleSet, string), + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_UTF8String, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "string" + }, + { ATF_POINTER, 1, offsetof(struct ExtensibleSet, Enum), + .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_enum_4, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "enum" + }, +}; +static ber_tlv_tag_t asn_DEF_ExtensibleSet_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_ExtensibleSet_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string at 50 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* enum at 52 */ +}; +static uint8_t asn_MAP_ExtensibleSet_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = { + (0 << 7) | (0 << 6) +}; +static asn_SET_specifics_t asn_SPC_ExtensibleSet_specs_1 = { + sizeof(struct ExtensibleSet), + offsetof(struct ExtensibleSet, _asn_ctx), + offsetof(struct ExtensibleSet, _presence_map), + asn_MAP_ExtensibleSet_tag2el_1, + 2, /* Count of tags in the map */ + asn_MAP_ExtensibleSet_tag2el_1, /* Same as above */ + 2, /* Count of tags in the CXER map */ + 1, /* Whether extensible */ + (unsigned int *)asn_MAP_ExtensibleSet_mmap_1 /* Mandatory elements map */ +}; +asn_TYPE_descriptor_t asn_DEF_ExtensibleSet = { + "ExtensibleSet", + "ExtensibleSet", + SET_free, + SET_print, + SET_constraint, + SET_decode_ber, + SET_encode_der, + SET_decode_xer, + SET_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_ExtensibleSet_tags_1, + sizeof(asn_DEF_ExtensibleSet_tags_1) + /sizeof(asn_DEF_ExtensibleSet_tags_1[0]), /* 1 */ + asn_DEF_ExtensibleSet_tags_1, /* Same as above */ + sizeof(asn_DEF_ExtensibleSet_tags_1) + /sizeof(asn_DEF_ExtensibleSet_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_ExtensibleSet_1, + 2, /* Elements count */ + &asn_SPC_ExtensibleSet_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [ExtensibleSequence] >>> ***/ + +#include <UTF8String.h> +#include <INTEGER.h> +#include <GeneralizedTime.h> +#include <constr_SEQUENCE.h> + +/*** <<< TYPE-DECLS [ExtensibleSequence] >>> ***/ + +typedef struct ExtensibleSequence { + UTF8String_t *string /* OPTIONAL */; + /* + * This type is extensible, + * possible extensions are below. + */ + INTEGER_t *integer /* OPTIONAL */; + GeneralizedTime_t *gtime; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} ExtensibleSequence_t; + +/*** <<< FUNC-DECLS [ExtensibleSequence] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence; + +/*** <<< STAT-DEFS [ExtensibleSequence] >>> ***/ + +static asn_TYPE_member_t asn_MBR_ExtensibleSequence_1[] = { + { ATF_POINTER, 3, offsetof(struct ExtensibleSequence, string), + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_UTF8String, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "string" + }, + { ATF_POINTER, 2, offsetof(struct ExtensibleSequence, integer), + .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_INTEGER, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "integer" + }, + { ATF_POINTER, 1, offsetof(struct ExtensibleSequence, gtime), + .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_GeneralizedTime, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "gtime" + }, +}; +static ber_tlv_tag_t asn_DEF_ExtensibleSequence_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string at 56 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* integer at 58 */ + { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* gtime at 59 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_specs_1 = { + sizeof(struct ExtensibleSequence), + offsetof(struct ExtensibleSequence, _asn_ctx), + asn_MAP_ExtensibleSequence_tag2el_1, + 3, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 4 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence = { + "ExtensibleSequence", + "ExtensibleSequence", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_ExtensibleSequence_tags_1, + sizeof(asn_DEF_ExtensibleSequence_tags_1) + /sizeof(asn_DEF_ExtensibleSequence_tags_1[0]), /* 1 */ + asn_DEF_ExtensibleSequence_tags_1, /* Same as above */ + sizeof(asn_DEF_ExtensibleSequence_tags_1) + /sizeof(asn_DEF_ExtensibleSequence_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_ExtensibleSequence_1, + 3, /* Elements count */ + &asn_SPC_ExtensibleSequence_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [ExtensibleSequence2] >>> ***/ + +#include <UTF8String.h> +#include <INTEGER.h> +#include <constr_SEQUENCE.h> + +/*** <<< TYPE-DECLS [ExtensibleSequence2] >>> ***/ + +typedef struct ExtensibleSequence2 { + UTF8String_t *string /* OPTIONAL */; + /* + * This type is extensible, + * possible extensions are below. + */ + INTEGER_t *integer /* OPTIONAL */; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} ExtensibleSequence2_t; + +/*** <<< FUNC-DECLS [ExtensibleSequence2] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence2; + +/*** <<< STAT-DEFS [ExtensibleSequence2] >>> ***/ + +static asn_TYPE_member_t asn_MBR_ExtensibleSequence2_1[] = { + { ATF_POINTER, 2, offsetof(struct ExtensibleSequence2, string), + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_UTF8String, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "string" + }, + { ATF_POINTER, 1, offsetof(struct ExtensibleSequence2, integer), + .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_INTEGER, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "integer" + }, +}; +static ber_tlv_tag_t asn_DEF_ExtensibleSequence2_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence2_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string at 63 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* integer at 65 */ +}; +static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_specs_1 = { + sizeof(struct ExtensibleSequence2), + offsetof(struct ExtensibleSequence2, _asn_ctx), + asn_MAP_ExtensibleSequence2_tag2el_1, + 2, /* Count of tags in the map */ + 0, 0, 0, /* Optional elements (not needed) */ + 0, /* Start extensions */ + 3 /* Stop extensions */ +}; +asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence2 = { + "ExtensibleSequence2", + "ExtensibleSequence2", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + SEQUENCE_decode_xer, + SEQUENCE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_ExtensibleSequence2_tags_1, + sizeof(asn_DEF_ExtensibleSequence2_tags_1) + /sizeof(asn_DEF_ExtensibleSequence2_tags_1[0]), /* 1 */ + asn_DEF_ExtensibleSequence2_tags_1, /* Same as above */ + sizeof(asn_DEF_ExtensibleSequence2_tags_1) + /sizeof(asn_DEF_ExtensibleSequence2_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_ExtensibleSequence2_1, + 2, /* Elements count */ + &asn_SPC_ExtensibleSequence2_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [SetOfNULL] >>> ***/ + +#include <NULL.h> +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< TYPE-DECLS [SetOfNULL] >>> ***/ + +typedef struct SetOfNULL { + A_SET_OF(NULL_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SetOfNULL_t; + +/*** <<< FUNC-DECLS [SetOfNULL] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_SetOfNULL; + +/*** <<< STAT-DEFS [SetOfNULL] >>> ***/ + +static asn_TYPE_member_t asn_MBR_SetOfNULL_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), + .tag_mode = 0, + .type = &asn_DEF_NULL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "" + }, +}; +static ber_tlv_tag_t asn_DEF_SetOfNULL_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_SetOfNULL_specs_1 = { + sizeof(struct SetOfNULL), + offsetof(struct SetOfNULL, _asn_ctx), + 1, /* XER encoding is XMLValueList */ +}; +asn_TYPE_descriptor_t asn_DEF_SetOfNULL = { + "SetOfNULL", + "SetOfNULL", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SetOfNULL_tags_1, + sizeof(asn_DEF_SetOfNULL_tags_1) + /sizeof(asn_DEF_SetOfNULL_tags_1[0]), /* 1 */ + asn_DEF_SetOfNULL_tags_1, /* Same as above */ + sizeof(asn_DEF_SetOfNULL_tags_1) + /sizeof(asn_DEF_SetOfNULL_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_SetOfNULL_1, + 1, /* Single element */ + &asn_SPC_SetOfNULL_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [SetOfREAL] >>> ***/ + +#include <REAL.h> +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< TYPE-DECLS [SetOfREAL] >>> ***/ + +typedef struct SetOfREAL { + A_SET_OF(REAL_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SetOfREAL_t; + +/*** <<< FUNC-DECLS [SetOfREAL] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_SetOfREAL; + +/*** <<< STAT-DEFS [SetOfREAL] >>> ***/ + +static asn_TYPE_member_t asn_MBR_SetOfREAL_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), + .tag_mode = 0, + .type = &asn_DEF_REAL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "" + }, +}; +static ber_tlv_tag_t asn_DEF_SetOfREAL_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_SetOfREAL_specs_1 = { + sizeof(struct SetOfREAL), + offsetof(struct SetOfREAL, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +asn_TYPE_descriptor_t asn_DEF_SetOfREAL = { + "SetOfREAL", + "SetOfREAL", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SetOfREAL_tags_1, + sizeof(asn_DEF_SetOfREAL_tags_1) + /sizeof(asn_DEF_SetOfREAL_tags_1[0]), /* 1 */ + asn_DEF_SetOfREAL_tags_1, /* Same as above */ + sizeof(asn_DEF_SetOfREAL_tags_1) + /sizeof(asn_DEF_SetOfREAL_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_SetOfREAL_1, + 1, /* Single element */ + &asn_SPC_SetOfREAL_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [SetOfEnums] >>> ***/ + +#include <ENUMERATED.h> +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< DEPS [SetOfEnums] >>> ***/ + +typedef enum Member { + Member_one = 0, + Member_oneMore = 1 +} e_Member; + +/*** <<< TYPE-DECLS [SetOfEnums] >>> ***/ + +typedef struct SetOfEnums { + A_SET_OF(ENUMERATED_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SetOfEnums_t; + +/*** <<< FUNC-DECLS [SetOfEnums] >>> ***/ + +/* extern asn_TYPE_descriptor_t asn_DEF_Member_2; // (Use -fall-defs-global to expose) */ +extern asn_TYPE_descriptor_t asn_DEF_SetOfEnums; + +/*** <<< CODE [SetOfEnums] >>> ***/ + +static int +Member_2_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_ENUMERATED.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using ENUMERATED, + * so here we adjust the DEF accordingly. + */ +static void +Member_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_ENUMERATED.free_struct; + td->print_struct = asn_DEF_ENUMERATED.print_struct; + td->ber_decoder = asn_DEF_ENUMERATED.ber_decoder; + td->der_encoder = asn_DEF_ENUMERATED.der_encoder; + td->xer_decoder = asn_DEF_ENUMERATED.xer_decoder; + td->xer_encoder = asn_DEF_ENUMERATED.xer_encoder; + td->uper_decoder = asn_DEF_ENUMERATED.uper_decoder; + td->uper_encoder = asn_DEF_ENUMERATED.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_ENUMERATED.per_constraints; + td->elements = asn_DEF_ENUMERATED.elements; + td->elements_count = asn_DEF_ENUMERATED.elements_count; + /* td->specifics = asn_DEF_ENUMERATED.specifics; // Defined explicitly */ +} + +static void +Member_2_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Member_2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +static int +Member_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Member_2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +static asn_dec_rval_t +Member_2_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) { + Member_2_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +static asn_enc_rval_t +Member_2_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) { + Member_2_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +static asn_dec_rval_t +Member_2_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) { + Member_2_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +static asn_enc_rval_t +Member_2_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) { + Member_2_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + + +/*** <<< STAT-DEFS [SetOfEnums] >>> ***/ + +static asn_INTEGER_enum_map_t asn_MAP_Member_value2enum_2[] = { + { 0, 3, "one" }, + { 1, 7, "oneMore" } +}; +static unsigned int asn_MAP_Member_enum2value_2[] = { + 0, /* one(0) */ + 1 /* oneMore(1) */ +}; +static asn_INTEGER_specifics_t asn_SPC_Member_specs_2 = { + asn_MAP_Member_value2enum_2, /* "tag" => N; sorted by tag */ + asn_MAP_Member_enum2value_2, /* N => "tag"; sorted by N */ + 2, /* Number of elements in the maps */ + 0, /* Enumeration is not extensible */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static ber_tlv_tag_t asn_DEF_Member_tags_2[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_Member_2 = { + "ENUMERATED", + "ENUMERATED", + Member_2_free, + Member_2_print, + Member_2_constraint, + Member_2_decode_ber, + Member_2_encode_der, + Member_2_decode_xer, + Member_2_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_Member_tags_2, + sizeof(asn_DEF_Member_tags_2) + /sizeof(asn_DEF_Member_tags_2[0]), /* 1 */ + asn_DEF_Member_tags_2, /* Same as above */ + sizeof(asn_DEF_Member_tags_2) + /sizeof(asn_DEF_Member_tags_2[0]), /* 1 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + &asn_SPC_Member_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_SetOfEnums_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), + .tag_mode = 0, + .type = &asn_DEF_Member_2, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "" + }, +}; +static ber_tlv_tag_t asn_DEF_SetOfEnums_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_SetOfEnums_specs_1 = { + sizeof(struct SetOfEnums), + offsetof(struct SetOfEnums, _asn_ctx), + 1, /* XER encoding is XMLValueList */ +}; +asn_TYPE_descriptor_t asn_DEF_SetOfEnums = { + "SetOfEnums", + "SetOfEnums", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SetOfEnums_tags_1, + sizeof(asn_DEF_SetOfEnums_tags_1) + /sizeof(asn_DEF_SetOfEnums_tags_1[0]), /* 1 */ + asn_DEF_SetOfEnums_tags_1, /* Same as above */ + sizeof(asn_DEF_SetOfEnums_tags_1) + /sizeof(asn_DEF_SetOfEnums_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_SetOfEnums_1, + 1, /* Single element */ + &asn_SPC_SetOfEnums_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [NamedSetOfNULL] >>> ***/ + +#include <NULL.h> +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< TYPE-DECLS [NamedSetOfNULL] >>> ***/ + +typedef struct NamedSetOfNULL { + A_SET_OF(NULL_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} NamedSetOfNULL_t; + +/*** <<< FUNC-DECLS [NamedSetOfNULL] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfNULL; + +/*** <<< STAT-DEFS [NamedSetOfNULL] >>> ***/ + +static asn_TYPE_member_t asn_MBR_NamedSetOfNULL_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), + .tag_mode = 0, + .type = &asn_DEF_NULL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "y" + }, +}; +static ber_tlv_tag_t asn_DEF_NamedSetOfNULL_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_NamedSetOfNULL_specs_1 = { + sizeof(struct NamedSetOfNULL), + offsetof(struct NamedSetOfNULL, _asn_ctx), + 1, /* XER encoding is XMLValueList */ +}; +asn_TYPE_descriptor_t asn_DEF_NamedSetOfNULL = { + "NamedSetOfNULL", + "NamedSetOfNULL", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_NamedSetOfNULL_tags_1, + sizeof(asn_DEF_NamedSetOfNULL_tags_1) + /sizeof(asn_DEF_NamedSetOfNULL_tags_1[0]), /* 1 */ + asn_DEF_NamedSetOfNULL_tags_1, /* Same as above */ + sizeof(asn_DEF_NamedSetOfNULL_tags_1) + /sizeof(asn_DEF_NamedSetOfNULL_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_NamedSetOfNULL_1, + 1, /* Single element */ + &asn_SPC_NamedSetOfNULL_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [NamedSetOfREAL] >>> ***/ + +#include <REAL.h> +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< TYPE-DECLS [NamedSetOfREAL] >>> ***/ + +typedef struct NamedSetOfREAL { + A_SET_OF(REAL_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} NamedSetOfREAL_t; + +/*** <<< FUNC-DECLS [NamedSetOfREAL] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfREAL; + +/*** <<< STAT-DEFS [NamedSetOfREAL] >>> ***/ + +static asn_TYPE_member_t asn_MBR_NamedSetOfREAL_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), + .tag_mode = 0, + .type = &asn_DEF_REAL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "name" + }, +}; +static ber_tlv_tag_t asn_DEF_NamedSetOfREAL_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_NamedSetOfREAL_specs_1 = { + sizeof(struct NamedSetOfREAL), + offsetof(struct NamedSetOfREAL, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +asn_TYPE_descriptor_t asn_DEF_NamedSetOfREAL = { + "NamedSetOfREAL", + "NamedSetOfREAL", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_NamedSetOfREAL_tags_1, + sizeof(asn_DEF_NamedSetOfREAL_tags_1) + /sizeof(asn_DEF_NamedSetOfREAL_tags_1[0]), /* 1 */ + asn_DEF_NamedSetOfREAL_tags_1, /* Same as above */ + sizeof(asn_DEF_NamedSetOfREAL_tags_1) + /sizeof(asn_DEF_NamedSetOfREAL_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_NamedSetOfREAL_1, + 1, /* Single element */ + &asn_SPC_NamedSetOfREAL_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [NamedSetOfEnums] >>> ***/ + +#include <ENUMERATED.h> +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< DEPS [NamedSetOfEnums] >>> ***/ + +typedef enum name { + name_one = 0, + name_oneMore = 1 +} e_name; + +/*** <<< TYPE-DECLS [NamedSetOfEnums] >>> ***/ + +typedef struct NamedSetOfEnums { + A_SET_OF(ENUMERATED_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} NamedSetOfEnums_t; + +/*** <<< FUNC-DECLS [NamedSetOfEnums] >>> ***/ + +/* extern asn_TYPE_descriptor_t asn_DEF_name_2; // (Use -fall-defs-global to expose) */ +extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfEnums; + +/*** <<< CODE [NamedSetOfEnums] >>> ***/ + +static int +name_2_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_ENUMERATED.check_constraints; + return td->check_constraints(td, sptr, ctfailcb, app_key); +} + +/* + * This type is implemented using ENUMERATED, + * so here we adjust the DEF accordingly. + */ +static void +name_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { + td->free_struct = asn_DEF_ENUMERATED.free_struct; + td->print_struct = asn_DEF_ENUMERATED.print_struct; + td->ber_decoder = asn_DEF_ENUMERATED.ber_decoder; + td->der_encoder = asn_DEF_ENUMERATED.der_encoder; + td->xer_decoder = asn_DEF_ENUMERATED.xer_decoder; + td->xer_encoder = asn_DEF_ENUMERATED.xer_encoder; + td->uper_decoder = asn_DEF_ENUMERATED.uper_decoder; + td->uper_encoder = asn_DEF_ENUMERATED.uper_encoder; + if(!td->per_constraints) + td->per_constraints = asn_DEF_ENUMERATED.per_constraints; + td->elements = asn_DEF_ENUMERATED.elements; + td->elements_count = asn_DEF_ENUMERATED.elements_count; + /* td->specifics = asn_DEF_ENUMERATED.specifics; // Defined explicitly */ +} + +static void +name_2_free(asn_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + name_2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +static int +name_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + name_2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + +static asn_dec_rval_t +name_2_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) { + name_2_inherit_TYPE_descriptor(td); + return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); +} + +static asn_enc_rval_t +name_2_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) { + name_2_inherit_TYPE_descriptor(td); + return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); +} + +static asn_dec_rval_t +name_2_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) { + name_2_inherit_TYPE_descriptor(td); + return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); +} + +static asn_enc_rval_t +name_2_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) { + name_2_inherit_TYPE_descriptor(td); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); +} + + +/*** <<< STAT-DEFS [NamedSetOfEnums] >>> ***/ + +static asn_INTEGER_enum_map_t asn_MAP_name_value2enum_2[] = { + { 0, 3, "one" }, + { 1, 7, "oneMore" } +}; +static unsigned int asn_MAP_name_enum2value_2[] = { + 0, /* one(0) */ + 1 /* oneMore(1) */ +}; +static asn_INTEGER_specifics_t asn_SPC_name_specs_2 = { + asn_MAP_name_value2enum_2, /* "tag" => N; sorted by tag */ + asn_MAP_name_enum2value_2, /* N => "tag"; sorted by N */ + 2, /* Number of elements in the maps */ + 0, /* Enumeration is not extensible */ + 1, /* Strict enumeration */ + 0, /* Native long size */ + 0 +}; +static ber_tlv_tag_t asn_DEF_name_tags_2[] = { + (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) +}; +static /* Use -fall-defs-global to expose */ +asn_TYPE_descriptor_t asn_DEF_name_2 = { + "ENUMERATED", + "ENUMERATED", + name_2_free, + name_2_print, + name_2_constraint, + name_2_decode_ber, + name_2_encode_der, + name_2_decode_xer, + name_2_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_name_tags_2, + sizeof(asn_DEF_name_tags_2) + /sizeof(asn_DEF_name_tags_2[0]), /* 1 */ + asn_DEF_name_tags_2, /* Same as above */ + sizeof(asn_DEF_name_tags_2) + /sizeof(asn_DEF_name_tags_2[0]), /* 1 */ + 0, /* No PER visible constraints */ + 0, 0, /* Defined elsewhere */ + &asn_SPC_name_specs_2 /* Additional specs */ +}; + +static asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), + .tag_mode = 0, + .type = &asn_DEF_name_2, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "name" + }, +}; +static ber_tlv_tag_t asn_DEF_NamedSetOfEnums_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_NamedSetOfEnums_specs_1 = { + sizeof(struct NamedSetOfEnums), + offsetof(struct NamedSetOfEnums, _asn_ctx), + 1, /* XER encoding is XMLValueList */ +}; +asn_TYPE_descriptor_t asn_DEF_NamedSetOfEnums = { + "NamedSetOfEnums", + "NamedSetOfEnums", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_NamedSetOfEnums_tags_1, + sizeof(asn_DEF_NamedSetOfEnums_tags_1) + /sizeof(asn_DEF_NamedSetOfEnums_tags_1[0]), /* 1 */ + asn_DEF_NamedSetOfEnums_tags_1, /* Same as above */ + sizeof(asn_DEF_NamedSetOfEnums_tags_1) + /sizeof(asn_DEF_NamedSetOfEnums_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_NamedSetOfEnums_1, + 1, /* Single element */ + &asn_SPC_NamedSetOfEnums_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [SequenceOf] >>> ***/ + +#include <INTEGER.h> +#include <asn_SEQUENCE_OF.h> +#include <constr_SEQUENCE_OF.h> + +/*** <<< TYPE-DECLS [SequenceOf] >>> ***/ + +typedef struct SequenceOf { + A_SEQUENCE_OF(INTEGER_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SequenceOf_t; + +/*** <<< FUNC-DECLS [SequenceOf] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_SequenceOf; + +/*** <<< STAT-DEFS [SequenceOf] >>> ***/ + +static asn_TYPE_member_t asn_MBR_SequenceOf_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), + .tag_mode = 0, + .type = &asn_DEF_INTEGER, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "id" + }, +}; +static ber_tlv_tag_t asn_DEF_SequenceOf_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1 = { + sizeof(struct SequenceOf), + offsetof(struct SequenceOf, _asn_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +asn_TYPE_descriptor_t asn_DEF_SequenceOf = { + "SequenceOf", + "SequenceOf", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SequenceOf_tags_1, + sizeof(asn_DEF_SequenceOf_tags_1) + /sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */ + asn_DEF_SequenceOf_tags_1, /* Same as above */ + sizeof(asn_DEF_SequenceOf_tags_1) + /sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_SequenceOf_1, + 1, /* Single element */ + &asn_SPC_SequenceOf_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [SeqOfZuka] >>> ***/ + +#include <NULL.h> +#include <asn_SEQUENCE_OF.h> +#include <constr_SEQUENCE_OF.h> + +/*** <<< TYPE-DECLS [SeqOfZuka] >>> ***/ + +typedef struct SeqOfZuka { + A_SEQUENCE_OF(NULL_t) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SeqOfZuka_t; + +/*** <<< FUNC-DECLS [SeqOfZuka] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_SeqOfZuka; + +/*** <<< STAT-DEFS [SeqOfZuka] >>> ***/ + +static asn_TYPE_member_t asn_MBR_SeqOfZuka_1[] = { + { ATF_POINTER, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), + .tag_mode = 0, + .type = &asn_DEF_NULL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "zuka" + }, +}; +static ber_tlv_tag_t asn_DEF_SeqOfZuka_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_specs_1 = { + sizeof(struct SeqOfZuka), + offsetof(struct SeqOfZuka, _asn_ctx), + 1, /* XER encoding is XMLValueList */ +}; +asn_TYPE_descriptor_t asn_DEF_SeqOfZuka = { + "SeqOfZuka", + "SeqOfZuka", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + SEQUENCE_OF_decode_xer, + SEQUENCE_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SeqOfZuka_tags_1, + sizeof(asn_DEF_SeqOfZuka_tags_1) + /sizeof(asn_DEF_SeqOfZuka_tags_1[0]), /* 1 */ + asn_DEF_SeqOfZuka_tags_1, /* Same as above */ + sizeof(asn_DEF_SeqOfZuka_tags_1) + /sizeof(asn_DEF_SeqOfZuka_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_SeqOfZuka_1, + 1, /* Single element */ + &asn_SPC_SeqOfZuka_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [SetOfChoice] >>> ***/ + +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< FWD-DECLS [SetOfChoice] >>> ***/ + +struct SimpleChoice; + +/*** <<< TYPE-DECLS [SetOfChoice] >>> ***/ + +typedef struct SetOfChoice { + A_SET_OF(struct SimpleChoice) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SetOfChoice_t; + +/*** <<< FUNC-DECLS [SetOfChoice] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_SetOfChoice; + +/*** <<< POST-INCLUDE [SetOfChoice] >>> ***/ + +#include "SimpleChoice.h" + +/*** <<< STAT-DEFS [SetOfChoice] >>> ***/ + +static asn_TYPE_member_t asn_MBR_SetOfChoice_1[] = { + { ATF_POINTER, 0, 0, + .tag = -1 /* Ambiguous tag (CHOICE?) */, + .tag_mode = 0, + .type = &asn_DEF_SimpleChoice, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "" + }, +}; +static ber_tlv_tag_t asn_DEF_SetOfChoice_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_SetOfChoice_specs_1 = { + sizeof(struct SetOfChoice), + offsetof(struct SetOfChoice, _asn_ctx), + 2, /* XER encoding is XMLValueList */ +}; +asn_TYPE_descriptor_t asn_DEF_SetOfChoice = { + "SetOfChoice", + "SetOfChoice", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_SetOfChoice_tags_1, + sizeof(asn_DEF_SetOfChoice_tags_1) + /sizeof(asn_DEF_SetOfChoice_tags_1[0]), /* 1 */ + asn_DEF_SetOfChoice_tags_1, /* Same as above */ + sizeof(asn_DEF_SetOfChoice_tags_1) + /sizeof(asn_DEF_SetOfChoice_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_SetOfChoice_1, + 1, /* Single element */ + &asn_SPC_SetOfChoice_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [NamedSetOfChoice] >>> ***/ + +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< FWD-DECLS [NamedSetOfChoice] >>> ***/ + +struct SimpleChoice; + +/*** <<< TYPE-DECLS [NamedSetOfChoice] >>> ***/ + +typedef struct NamedSetOfChoice { + A_SET_OF(struct SimpleChoice) list; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} NamedSetOfChoice_t; + +/*** <<< FUNC-DECLS [NamedSetOfChoice] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfChoice; + +/*** <<< POST-INCLUDE [NamedSetOfChoice] >>> ***/ + +#include "SimpleChoice.h" + +/*** <<< STAT-DEFS [NamedSetOfChoice] >>> ***/ + +static asn_TYPE_member_t asn_MBR_NamedSetOfChoice_1[] = { + { ATF_POINTER, 0, 0, + .tag = -1 /* Ambiguous tag (CHOICE?) */, + .tag_mode = 0, + .type = &asn_DEF_SimpleChoice, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "whatever" + }, +}; +static ber_tlv_tag_t asn_DEF_NamedSetOfChoice_tags_1[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn_SET_OF_specifics_t asn_SPC_NamedSetOfChoice_specs_1 = { + sizeof(struct NamedSetOfChoice), + offsetof(struct NamedSetOfChoice, _asn_ctx), + 2, /* XER encoding is XMLValueList */ +}; +asn_TYPE_descriptor_t asn_DEF_NamedSetOfChoice = { + "NamedSetOfChoice", + "NamedSetOfChoice", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + SET_OF_decode_xer, + SET_OF_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + 0, /* Use generic outmost tag fetcher */ + asn_DEF_NamedSetOfChoice_tags_1, + sizeof(asn_DEF_NamedSetOfChoice_tags_1) + /sizeof(asn_DEF_NamedSetOfChoice_tags_1[0]), /* 1 */ + asn_DEF_NamedSetOfChoice_tags_1, /* Same as above */ + sizeof(asn_DEF_NamedSetOfChoice_tags_1) + /sizeof(asn_DEF_NamedSetOfChoice_tags_1[0]), /* 1 */ + 0, /* No PER visible constraints */ + asn_MBR_NamedSetOfChoice_1, + 1, /* Single element */ + &asn_SPC_NamedSetOfChoice_specs_1 /* Additional specs */ +}; + + +/*** <<< INCLUDES [SimpleChoice] >>> ***/ + +#include <NULL.h> +#include <INTEGER.h> +#include <constr_CHOICE.h> + +/*** <<< DEPS [SimpleChoice] >>> ***/ + +typedef enum SimpleChoice_PR { + SimpleChoice_PR_NOTHING, /* No components present */ + SimpleChoice_PR_a, + SimpleChoice_PR_b +} SimpleChoice_PR; + +/*** <<< TYPE-DECLS [SimpleChoice] >>> ***/ + +typedef struct SimpleChoice { + SimpleChoice_PR present; + union SimpleChoice_u { + NULL_t a; + INTEGER_t b; + } choice; + + /* Context for parsing across buffer boundaries */ + asn_struct_ctx_t _asn_ctx; +} SimpleChoice_t; + +/*** <<< FUNC-DECLS [SimpleChoice] >>> ***/ + +extern asn_TYPE_descriptor_t asn_DEF_SimpleChoice; + +/*** <<< STAT-DEFS [SimpleChoice] >>> ***/ + +static asn_TYPE_member_t asn_MBR_SimpleChoice_1[] = { + { ATF_NOFLAGS, 0, offsetof(struct SimpleChoice, choice.a), + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_NULL, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "a" + }, + { ATF_NOFLAGS, 0, offsetof(struct SimpleChoice, choice.b), + .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = &asn_DEF_INTEGER, + .memb_constraints = 0, /* Defer constraints checking to the member type */ + .per_constraints = 0, /* PER is not compiled, use -gen-PER */ + .default_value = 0, + .name = "b" + }, +}; +static asn_TYPE_tag2member_t asn_MAP_SimpleChoice_tag2el_1[] = { + { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a at 79 */ + { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b at 79 */ +}; +static asn_CHOICE_specifics_t asn_SPC_SimpleChoice_specs_1 = { + sizeof(struct SimpleChoice), + offsetof(struct SimpleChoice, _asn_ctx), + offsetof(struct SimpleChoice, present), + sizeof(((struct SimpleChoice *)0)->present), + asn_MAP_SimpleChoice_tag2el_1, + 2, /* Count of tags in the map */ + .canonical_order = 0, + .ext_start = -1 /* Extensions start */ +}; +asn_TYPE_descriptor_t asn_DEF_SimpleChoice = { + "SimpleChoice", + "SimpleChoice", + CHOICE_free, + CHOICE_print, + CHOICE_constraint, + CHOICE_decode_ber, + CHOICE_encode_der, + CHOICE_decode_xer, + CHOICE_encode_xer, + 0, 0, /* No PER support, use "-gen-PER" to enable */ + CHOICE_outmost_tag, + 0, /* No effective tags (pointer) */ + 0, /* No effective tags (count) */ + 0, /* No tags (pointer) */ + 0, /* No tags (count) */ + 0, /* No PER visible constraints */ + asn_MBR_SimpleChoice_1, + 2, /* Elements count */ + &asn_SPC_SimpleChoice_specs_1 /* Additional specs */ +}; + |