/*** <<< INCLUDES [Type] >>> ***/ #include #include #include /*** <<< FWD-DECLS [Type] >>> ***/ struct EpytRef; /*** <<< TYPE-DECLS [Type] >>> ***/ typedef struct Type { struct data { A_SEQUENCE_OF(struct EpytRef) list; /* Context for parsing across buffer boundaries */ asn_struct_ctx_t _asn_ctx; } data; /* Context for parsing across buffer boundaries */ asn_struct_ctx_t _asn_ctx; } Type_t; /*** <<< FUNC-DECLS [Type] >>> ***/ extern asn_TYPE_descriptor_t asn_DEF_Type; extern asn_SEQUENCE_specifics_t asn_SPC_Type_specs_1; extern asn_TYPE_member_t asn_MBR_Type_1[1]; /*** <<< POST-INCLUDE [Type] >>> ***/ #include "EpytRef.h" /*** <<< STAT-DEFS [Type] >>> ***/ static asn_TYPE_member_t asn_MBR_data_2[] = { { ATF_POINTER, 0, 0, .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), .tag_mode = 0, .type = &asn_DEF_EpytRef, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "" }, }; static const ber_tlv_tag_t asn_DEF_data_tags_2[] = { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) }; static asn_SET_OF_specifics_t asn_SPC_data_specs_2 = { sizeof(struct data), offsetof(struct data, _asn_ctx), 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn_TYPE_descriptor_t asn_DEF_data_2 = { "data", "data", &asn_OP_SEQUENCE_OF, asn_DEF_data_tags_2, sizeof(asn_DEF_data_tags_2) /sizeof(asn_DEF_data_tags_2[0]), /* 1 */ asn_DEF_data_tags_2, /* Same as above */ sizeof(asn_DEF_data_tags_2) /sizeof(asn_DEF_data_tags_2[0]), /* 1 */ { 0, 0, SEQUENCE_OF_constraint }, asn_MBR_data_2, 1, /* Single element */ &asn_SPC_data_specs_2 /* Additional specs */ }; asn_TYPE_member_t asn_MBR_Type_1[] = { { ATF_NOFLAGS, 0, offsetof(struct Type, data), .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), .tag_mode = 0, .type = &asn_DEF_data_2, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "data" }, }; static const ber_tlv_tag_t asn_DEF_Type_tags_1[] = { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) }; static const asn_TYPE_tag2member_t asn_MAP_Type_tag2el_1[] = { { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* data */ }; asn_SEQUENCE_specifics_t asn_SPC_Type_specs_1 = { sizeof(struct Type), offsetof(struct Type, _asn_ctx), .tag2el = asn_MAP_Type_tag2el_1, .tag2el_count = 1, /* 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_Type = { "Type", "Type", &asn_OP_SEQUENCE, asn_DEF_Type_tags_1, sizeof(asn_DEF_Type_tags_1) /sizeof(asn_DEF_Type_tags_1[0]), /* 1 */ asn_DEF_Type_tags_1, /* Same as above */ sizeof(asn_DEF_Type_tags_1) /sizeof(asn_DEF_Type_tags_1[0]), /* 1 */ { 0, 0, SEQUENCE_constraint }, asn_MBR_Type_1, 1, /* Elements count */ &asn_SPC_Type_specs_1 /* Additional specs */ }; /*** <<< INCLUDES [EpytRef] >>> ***/ #include "Epyt.h" /*** <<< TYPE-DECLS [EpytRef] >>> ***/ typedef Epyt_t EpytRef_t; /*** <<< FUNC-DECLS [EpytRef] >>> ***/ extern asn_TYPE_descriptor_t asn_DEF_EpytRef; asn_struct_free_f EpytRef_free; asn_struct_print_f EpytRef_print; asn_constr_check_f EpytRef_constraint; ber_type_decoder_f EpytRef_decode_ber; der_type_encoder_f EpytRef_encode_der; xer_type_decoder_f EpytRef_decode_xer; xer_type_encoder_f EpytRef_encode_xer; /*** <<< CODE [EpytRef] >>> ***/ /* * This type is implemented using Epyt, * so here we adjust the DEF accordingly. */ /*** <<< STAT-DEFS [EpytRef] >>> ***/ static const ber_tlv_tag_t asn_DEF_EpytRef_tags_1[] = { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) }; asn_TYPE_descriptor_t asn_DEF_EpytRef = { "EpytRef", "EpytRef", &asn_OP_SEQUENCE, asn_DEF_EpytRef_tags_1, sizeof(asn_DEF_EpytRef_tags_1) /sizeof(asn_DEF_EpytRef_tags_1[0]), /* 1 */ asn_DEF_EpytRef_tags_1, /* Same as above */ sizeof(asn_DEF_EpytRef_tags_1) /sizeof(asn_DEF_EpytRef_tags_1[0]), /* 1 */ { 0, 0, SEQUENCE_constraint }, asn_MBR_Epyt_1, 3, /* Elements count */ &asn_SPC_Epyt_specs_1 /* Additional specs */ }; /*** <<< INCLUDES [Epyt] >>> ***/ #include #include #include /*** <<< FWD-DECLS [Epyt] >>> ***/ struct Type; struct Ypet; /*** <<< TYPE-DECLS [Epyt] >>> ***/ typedef struct Epyt { struct stype { A_SET_OF(struct Type) list; /* Context for parsing across buffer boundaries */ asn_struct_ctx_t _asn_ctx; } stype; struct Type *type /* OPTIONAL */; struct Ypet *ypet /* OPTIONAL */; /* Context for parsing across buffer boundaries */ asn_struct_ctx_t _asn_ctx; } Epyt_t; /*** <<< FUNC-DECLS [Epyt] >>> ***/ extern asn_TYPE_descriptor_t asn_DEF_Epyt; extern asn_SEQUENCE_specifics_t asn_SPC_Epyt_specs_1; extern asn_TYPE_member_t asn_MBR_Epyt_1[3]; /*** <<< POST-INCLUDE [Epyt] >>> ***/ #include "Type.h" #include "Ypet.h" /*** <<< STAT-DEFS [Epyt] >>> ***/ static asn_TYPE_member_t asn_MBR_stype_2[] = { { ATF_POINTER, 0, 0, .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), .tag_mode = 0, .type = &asn_DEF_Type, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "" }, }; static const ber_tlv_tag_t asn_DEF_stype_tags_2[] = { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) }; static asn_SET_OF_specifics_t asn_SPC_stype_specs_2 = { sizeof(struct stype), offsetof(struct stype, _asn_ctx), 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn_TYPE_descriptor_t asn_DEF_stype_2 = { "stype", "stype", &asn_OP_SET_OF, asn_DEF_stype_tags_2, sizeof(asn_DEF_stype_tags_2) /sizeof(asn_DEF_stype_tags_2[0]), /* 1 */ asn_DEF_stype_tags_2, /* Same as above */ sizeof(asn_DEF_stype_tags_2) /sizeof(asn_DEF_stype_tags_2[0]), /* 1 */ { 0, 0, SET_OF_constraint }, asn_MBR_stype_2, 1, /* Single element */ &asn_SPC_stype_specs_2 /* Additional specs */ }; asn_TYPE_member_t asn_MBR_Epyt_1[] = { { ATF_NOFLAGS, 0, offsetof(struct Epyt, stype), .tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), .tag_mode = 0, .type = &asn_DEF_stype_2, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "stype" }, { ATF_POINTER, 2, offsetof(struct Epyt, type), .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), .tag_mode = 0, .type = &asn_DEF_Type, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "type" }, { ATF_POINTER, 1, offsetof(struct Epyt, ypet), .tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), .tag_mode = 0, .type = &asn_DEF_Ypet, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "ypet" }, }; static const ber_tlv_tag_t asn_DEF_Epyt_tags_1[] = { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) }; static const asn_TYPE_tag2member_t asn_MAP_Epyt_tag2el_1[] = { { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* type */ { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 1 }, /* stype */ { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, -1, 0 } /* ypet */ }; asn_SEQUENCE_specifics_t asn_SPC_Epyt_specs_1 = { sizeof(struct Epyt), offsetof(struct Epyt, _asn_ctx), .tag2el = asn_MAP_Epyt_tag2el_1, .tag2el_count = 3, /* 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_Epyt = { "Epyt", "Epyt", &asn_OP_SEQUENCE, asn_DEF_Epyt_tags_1, sizeof(asn_DEF_Epyt_tags_1) /sizeof(asn_DEF_Epyt_tags_1[0]), /* 1 */ asn_DEF_Epyt_tags_1, /* Same as above */ sizeof(asn_DEF_Epyt_tags_1) /sizeof(asn_DEF_Epyt_tags_1[0]), /* 1 */ { 0, 0, SEQUENCE_constraint }, asn_MBR_Epyt_1, 3, /* Elements count */ &asn_SPC_Epyt_specs_1 /* Additional specs */ }; /*** <<< INCLUDES [Ypet] >>> ***/ #include #include #include "EnumType.h" #include #include #include /*** <<< DEPS [Ypet] >>> ***/ /* * Method of determining the components presence */ typedef enum Ypet_PR { Ypet_PR_epyt, /* Member epyt is present */ Ypet_PR_plain, /* Member plain is present */ Ypet_PR_senums, /* Member senums is present */ Ypet_PR_patest1, /* Member patest1 is present */ Ypet_PR_patest2, /* Member patest2 is present */ } Ypet_PR; /*** <<< FWD-DECLS [Ypet] >>> ***/ struct Epyt; /*** <<< TYPE-DECLS [Ypet] >>> ***/ typedef struct Ypet { struct Epyt *epyt; INTEGER_t *plain /* DEFAULT 7 */; struct senums { A_SET_OF(EnumType_t) list; /* Context for parsing across buffer boundaries */ asn_struct_ctx_t _asn_ctx; } senums; IA5String_t patest1; IA5String_t patest2; /* Presence bitmask: ASN_SET_ISPRESENT(pYpet, Ypet_PR_x) */ unsigned int _presence_map [((5+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))]; /* Context for parsing across buffer boundaries */ asn_struct_ctx_t _asn_ctx; } Ypet_t; /*** <<< FUNC-DECLS [Ypet] >>> ***/ extern asn_TYPE_descriptor_t asn_DEF_Ypet; extern asn_SET_specifics_t asn_SPC_Ypet_specs_1; extern asn_TYPE_member_t asn_MBR_Ypet_1[5]; /*** <<< POST-INCLUDE [Ypet] >>> ***/ #include "Epyt.h" /*** <<< CTABLES [Ypet] >>> ***/ static int check_permitted_alphabet_6(const void *sptr) { /* The underlying type is IA5String */ const IA5String_t *st = (const IA5String_t *)sptr; const uint8_t *ch = st->buf; const uint8_t *end = ch + st->size; for(; ch < end; ch++) { uint8_t cv = *ch; if(!(cv >= 65 && cv <= 90)) return -1; } return 0; } static int check_permitted_alphabet_7(const void *sptr) { /* The underlying type is IA5String */ const IA5String_t *st = (const IA5String_t *)sptr; const uint8_t *ch = st->buf; const uint8_t *end = ch + st->size; for(; ch < end; ch++) { uint8_t cv = *ch; if(!(cv >= 97 && cv <= 122)) return -1; } return 0; } /*** <<< CODE [Ypet] >>> ***/ static int memb_patest1_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr, asn_app_constraint_failed_f *ctfailcb, void *app_key) { const IA5String_t *st = (const IA5String_t *)sptr; if(!sptr) { ASN__CTFAIL(app_key, td, sptr, "%s: value not given (%s:%d)", td->name, __FILE__, __LINE__); return -1; } if(!check_permitted_alphabet_6(st)) { /* Constraint check succeeded */ return 0; } else { ASN__CTFAIL(app_key, td, sptr, "%s: constraint failed (%s:%d)", td->name, __FILE__, __LINE__); return -1; } } static int memb_patest2_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr, asn_app_constraint_failed_f *ctfailcb, void *app_key) { const IA5String_t *st = (const IA5String_t *)sptr; if(!sptr) { ASN__CTFAIL(app_key, td, sptr, "%s: value not given (%s:%d)", td->name, __FILE__, __LINE__); return -1; } if(!check_permitted_alphabet_7(st)) { /* Constraint check succeeded */ return 0; } else { ASN__CTFAIL(app_key, td, sptr, "%s: constraint failed (%s:%d)", td->name, __FILE__, __LINE__); return -1; } } /*** <<< STAT-DEFS [Ypet] >>> ***/ static int asn_DFL_3_cmp_7(const void *sptr) { const INTEGER_t *st = sptr; if(!st) { return -1; /* No value is not a default value */ } /* Test default value 7 */ long value; if(asn_INTEGER2long(st, &value)) return -1; return (value != 7); } static int asn_DFL_3_set_7(void **sptr) { INTEGER_t *st = *sptr; if(!st) { st = (*sptr = CALLOC(1, sizeof(*st))); if(!st) return -1; } /* Install default value 7 */ return asn_long2INTEGER(st, 7); } static asn_TYPE_member_t asn_MBR_senums_4[] = { { ATF_POINTER, 0, 0, .tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), .tag_mode = 0, .type = &asn_DEF_EnumType, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "" }, }; static const ber_tlv_tag_t asn_DEF_senums_tags_4[] = { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) }; static asn_SET_OF_specifics_t asn_SPC_senums_specs_4 = { sizeof(struct senums), offsetof(struct senums, _asn_ctx), 1, /* XER encoding is XMLValueList */ }; static /* Use -fall-defs-global to expose */ asn_TYPE_descriptor_t asn_DEF_senums_4 = { "senums", "senums", &asn_OP_SET_OF, asn_DEF_senums_tags_4, sizeof(asn_DEF_senums_tags_4) /sizeof(asn_DEF_senums_tags_4[0]), /* 1 */ asn_DEF_senums_tags_4, /* Same as above */ sizeof(asn_DEF_senums_tags_4) /sizeof(asn_DEF_senums_tags_4[0]), /* 1 */ { 0, 0, SET_OF_constraint }, asn_MBR_senums_4, 1, /* Single element */ &asn_SPC_senums_specs_4 /* Additional specs */ }; asn_TYPE_member_t asn_MBR_Ypet_1[] = { { ATF_POINTER, 0, offsetof(struct Ypet, epyt), .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), .tag_mode = 0, .type = &asn_DEF_Epyt, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "epyt" }, { ATF_POINTER, 1, offsetof(struct Ypet, plain), .tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), .tag_mode = 0, .type = &asn_DEF_INTEGER, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, .default_value_cmp = &asn_DFL_3_cmp_7, /* Compare DEFAULT 7 */ .default_value_set = &asn_DFL_3_set_7, /* Set DEFAULT 7 */ .name = "plain" }, { ATF_NOFLAGS, 0, offsetof(struct Ypet, senums), .tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), .tag_mode = 0, .type = &asn_DEF_senums_4, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 }, 0, 0, /* No default value */ .name = "senums" }, { ATF_NOFLAGS, 0, offsetof(struct Ypet, patest1), .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)), .tag_mode = +1, /* EXPLICIT tag at current level */ .type = &asn_DEF_IA5String, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = memb_patest1_constraint_1 }, 0, 0, /* No default value */ .name = "patest1" }, { ATF_NOFLAGS, 0, offsetof(struct Ypet, patest2), .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)), .tag_mode = +1, /* EXPLICIT tag at current level */ .type = &asn_DEF_IA5String, .type_selector = 0, { .oer_constraints = 0, .per_constraints = 0, .general_constraints = memb_patest2_constraint_1 }, 0, 0, /* No default value */ .name = "patest2" }, }; static const ber_tlv_tag_t asn_DEF_Ypet_tags_1[] = { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) }; static const asn_TYPE_tag2member_t asn_MAP_Ypet_tag2el_1[] = { { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* plain */ { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* epyt */ { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, 0, 0 }, /* senums */ { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* patest1 */ { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 4, 0, 0 } /* patest2 */ }; static const uint8_t asn_MAP_Ypet_mmap_1[(5 + (8 * sizeof(unsigned int)) - 1) / 8] = { (1 << 7) | (0 << 6) | (1 << 5) | (1 << 4) | (1 << 3) }; asn_SET_specifics_t asn_SPC_Ypet_specs_1 = { sizeof(struct Ypet), offsetof(struct Ypet, _asn_ctx), offsetof(struct Ypet, _presence_map), .tag2el = asn_MAP_Ypet_tag2el_1, .tag2el_count = 5, /* Count of tags in the map */ asn_MAP_Ypet_tag2el_1, /* Same as above */ 5, /* Count of tags in the CXER map */ 0, /* Whether extensible */ (const unsigned int *)asn_MAP_Ypet_mmap_1 /* Mandatory elements map */ }; asn_TYPE_descriptor_t asn_DEF_Ypet = { "Ypet", "Ypet", &asn_OP_SET, asn_DEF_Ypet_tags_1, sizeof(asn_DEF_Ypet_tags_1) /sizeof(asn_DEF_Ypet_tags_1[0]), /* 1 */ asn_DEF_Ypet_tags_1, /* Same as above */ sizeof(asn_DEF_Ypet_tags_1) /sizeof(asn_DEF_Ypet_tags_1[0]), /* 1 */ { 0, 0, SET_constraint }, asn_MBR_Ypet_1, 5, /* Elements count */ &asn_SPC_Ypet_specs_1 /* Additional specs */ }; /*** <<< INCLUDES [EnumType] >>> ***/ #include /*** <<< DEPS [EnumType] >>> ***/ typedef enum EnumType { EnumType_one = 0, EnumType_two = 1 } e_EnumType; /*** <<< TYPE-DECLS [EnumType] >>> ***/ typedef ENUMERATED_t EnumType_t; /*** <<< FUNC-DECLS [EnumType] >>> ***/ extern asn_TYPE_descriptor_t asn_DEF_EnumType; extern const asn_INTEGER_specifics_t asn_SPC_EnumType_specs_1; asn_struct_free_f EnumType_free; asn_struct_print_f EnumType_print; asn_constr_check_f EnumType_constraint; ber_type_decoder_f EnumType_decode_ber; der_type_encoder_f EnumType_encode_der; xer_type_decoder_f EnumType_decode_xer; xer_type_encoder_f EnumType_encode_xer; /*** <<< CODE [EnumType] >>> ***/ /* * This type is implemented using ENUMERATED, * so here we adjust the DEF accordingly. */ /*** <<< STAT-DEFS [EnumType] >>> ***/ static const asn_INTEGER_enum_map_t asn_MAP_EnumType_value2enum_1[] = { { 0, 3, "one" }, { 1, 3, "two" } }; static const unsigned int asn_MAP_EnumType_enum2value_1[] = { 0, /* one(0) */ 1 /* two(1) */ }; const asn_INTEGER_specifics_t asn_SPC_EnumType_specs_1 = { asn_MAP_EnumType_value2enum_1, /* "tag" => N; sorted by tag */ asn_MAP_EnumType_enum2value_1, /* 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 const ber_tlv_tag_t asn_DEF_EnumType_tags_1[] = { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) }; asn_TYPE_descriptor_t asn_DEF_EnumType = { "EnumType", "EnumType", &asn_OP_ENUMERATED, asn_DEF_EnumType_tags_1, sizeof(asn_DEF_EnumType_tags_1) /sizeof(asn_DEF_EnumType_tags_1[0]), /* 1 */ asn_DEF_EnumType_tags_1, /* Same as above */ sizeof(asn_DEF_EnumType_tags_1) /sizeof(asn_DEF_EnumType_tags_1[0]), /* 1 */ { 0, 0, ENUMERATED_constraint }, 0, 0, /* Defined elsewhere */ &asn_SPC_EnumType_specs_1 /* Additional specs */ };