| |
| /*** <<< INCLUDES [Type] >>> ***/ |
| |
| #include <asn_SEQUENCE_OF.h> |
| #include <constr_SEQUENCE_OF.h> |
| #include <constr_SEQUENCE.h> |
| |
| /*** <<< FWD-DECLS [Type] >>> ***/ |
| |
| struct Epyt; |
| |
| /*** <<< TYPE-DECLS [Type] >>> ***/ |
| |
| typedef struct Type { |
| struct data { |
| A_SEQUENCE_OF(struct Epyt) 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; |
| |
| /*** <<< 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, |
| .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_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", |
| 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, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| asn_MBR_data_2, |
| 1, /* Single element */ |
| &asn_SPC_data_specs_2 /* Additional specs */ |
| }; |
| |
| static 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, |
| .memb_constraints = 0, /* Defer constraints checking to the member type */ |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .name = "data" |
| }, |
| }; |
| static ber_tlv_tag_t asn_DEF_Type_tags_1[] = { |
| (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) |
| }; |
| static asn_TYPE_tag2member_t asn_MAP_Type_tag2el_1[] = { |
| { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* data at 16 */ |
| }; |
| static asn_SEQUENCE_specifics_t asn_SPC_Type_specs_1 = { |
| sizeof(struct Type), |
| offsetof(struct Type, _asn_ctx), |
| asn_MAP_Type_tag2el_1, |
| 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", |
| SEQUENCE_free, |
| SEQUENCE_print, |
| SEQUENCE_constraint, |
| SEQUENCE_decode_ber, |
| SEQUENCE_encode_der, |
| SEQUENCE_decode_xer, |
| SEQUENCE_encode_xer, |
| 0, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| 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] >>> ***/ |
| |
| int |
| EpytRef_constraint(asn_TYPE_descriptor_t *td, const void *sptr, |
| asn_app_consume_bytes_f *app_errlog, void *app_key) { |
| /* Replace with underlying type checker */ |
| td->check_constraints = asn_DEF_Epyt.check_constraints; |
| return td->check_constraints(td, sptr, app_errlog, app_key); |
| } |
| |
| /* |
| * This type is implemented using Epyt, |
| * so here we adjust the DEF accordingly. |
| */ |
| static void |
| EpytRef_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) { |
| td->free_struct = asn_DEF_Epyt.free_struct; |
| td->print_struct = asn_DEF_Epyt.print_struct; |
| td->ber_decoder = asn_DEF_Epyt.ber_decoder; |
| td->der_encoder = asn_DEF_Epyt.der_encoder; |
| td->xer_decoder = asn_DEF_Epyt.xer_decoder; |
| td->xer_encoder = asn_DEF_Epyt.xer_encoder; |
| td->uper_decoder = asn_DEF_Epyt.uper_decoder; |
| if(!td->per_constraints) |
| td->per_constraints = asn_DEF_Epyt.per_constraints; |
| td->elements = asn_DEF_Epyt.elements; |
| td->elements_count = asn_DEF_Epyt.elements_count; |
| td->specifics = asn_DEF_Epyt.specifics; |
| } |
| |
| void |
| EpytRef_free(asn_TYPE_descriptor_t *td, |
| void *struct_ptr, int contents_only) { |
| EpytRef_1_inherit_TYPE_descriptor(td); |
| td->free_struct(td, struct_ptr, contents_only); |
| } |
| |
| int |
| EpytRef_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, |
| int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { |
| EpytRef_1_inherit_TYPE_descriptor(td); |
| return td->print_struct(td, struct_ptr, ilevel, cb, app_key); |
| } |
| |
| asn_dec_rval_t |
| EpytRef_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) { |
| EpytRef_1_inherit_TYPE_descriptor(td); |
| return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); |
| } |
| |
| asn_enc_rval_t |
| EpytRef_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) { |
| EpytRef_1_inherit_TYPE_descriptor(td); |
| return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); |
| } |
| |
| asn_dec_rval_t |
| EpytRef_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) { |
| EpytRef_1_inherit_TYPE_descriptor(td); |
| return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); |
| } |
| |
| asn_enc_rval_t |
| EpytRef_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) { |
| EpytRef_1_inherit_TYPE_descriptor(td); |
| return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); |
| } |
| |
| |
| /*** <<< STAT-DEFS [EpytRef] >>> ***/ |
| |
| static ber_tlv_tag_t asn_DEF_EpytRef_tags_1[] = { |
| (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) |
| }; |
| asn_TYPE_descriptor_t asn_DEF_EpytRef = { |
| "EpytRef", |
| "EpytRef", |
| EpytRef_free, |
| EpytRef_print, |
| EpytRef_constraint, |
| EpytRef_decode_ber, |
| EpytRef_encode_der, |
| EpytRef_decode_xer, |
| EpytRef_encode_xer, |
| 0, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| 0, 0, /* Defined elsewhere */ |
| 0 /* No specifics */ |
| }; |
| |
| |
| /*** <<< INCLUDES [Epyt] >>> ***/ |
| |
| #include <asn_SET_OF.h> |
| #include <constr_SET_OF.h> |
| #include <constr_SEQUENCE.h> |
| |
| /*** <<< 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; |
| |
| /*** <<< 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, |
| .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_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", |
| 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, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| asn_MBR_stype_2, |
| 1, /* Single element */ |
| &asn_SPC_stype_specs_2 /* Additional specs */ |
| }; |
| |
| static 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, |
| .memb_constraints = 0, /* Defer constraints checking to the member type */ |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .name = "stype" |
| }, |
| { ATF_POINTER, 2, offsetof(struct Epyt, type), |
| .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), |
| .tag_mode = 0, |
| .type = &asn_DEF_Type, |
| .memb_constraints = 0, /* Defer constraints checking to the member type */ |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .name = "type" |
| }, |
| { ATF_POINTER, 1, offsetof(struct Epyt, ypet), |
| .tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), |
| .tag_mode = 0, |
| .type = &asn_DEF_Ypet, |
| .memb_constraints = 0, /* Defer constraints checking to the member type */ |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .name = "ypet" |
| }, |
| }; |
| static ber_tlv_tag_t asn_DEF_Epyt_tags_1[] = { |
| (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) |
| }; |
| static asn_TYPE_tag2member_t asn_MAP_Epyt_tag2el_1[] = { |
| { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* type at 22 */ |
| { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 1 }, /* stype at 21 */ |
| { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, -1, 0 } /* ypet at 23 */ |
| }; |
| static asn_SEQUENCE_specifics_t asn_SPC_Epyt_specs_1 = { |
| sizeof(struct Epyt), |
| offsetof(struct Epyt, _asn_ctx), |
| asn_MAP_Epyt_tag2el_1, |
| 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", |
| SEQUENCE_free, |
| SEQUENCE_print, |
| SEQUENCE_constraint, |
| SEQUENCE_decode_ber, |
| SEQUENCE_encode_der, |
| SEQUENCE_decode_xer, |
| SEQUENCE_encode_xer, |
| 0, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| asn_MBR_Epyt_1, |
| 3, /* Elements count */ |
| &asn_SPC_Epyt_specs_1 /* Additional specs */ |
| }; |
| |
| |
| /*** <<< INCLUDES [Ypet] >>> ***/ |
| |
| #include <INTEGER.h> |
| #include <IA5String.h> |
| #include <EnumType.h> |
| #include <asn_SET_OF.h> |
| #include <constr_SET_OF.h> |
| #include <constr_SET.h> |
| |
| /*** <<< 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; |
| |
| /*** <<< 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(asn_TYPE_descriptor_t *td, const void *sptr, |
| asn_app_consume_bytes_f *app_errlog, void *app_key) { |
| const IA5String_t *st = (const IA5String_t *)sptr; |
| |
| if(!sptr) { |
| _ASN_ERRLOG(app_errlog, app_key, |
| "%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_ERRLOG(app_errlog, app_key, |
| "%s: constraint failed (%s:%d)", |
| td->name, __FILE__, __LINE__); |
| return -1; |
| } |
| } |
| |
| static int |
| memb_patest2_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr, |
| asn_app_consume_bytes_f *app_errlog, void *app_key) { |
| const IA5String_t *st = (const IA5String_t *)sptr; |
| |
| if(!sptr) { |
| _ASN_ERRLOG(app_errlog, app_key, |
| "%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_ERRLOG(app_errlog, app_key, |
| "%s: constraint failed (%s:%d)", |
| td->name, __FILE__, __LINE__); |
| return -1; |
| } |
| } |
| |
| |
| /*** <<< STAT-DEFS [Ypet] >>> ***/ |
| |
| 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, |
| .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_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", |
| 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, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| asn_MBR_senums_4, |
| 1, /* Single element */ |
| &asn_SPC_senums_specs_4 /* Additional specs */ |
| }; |
| |
| static 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, |
| .memb_constraints = 0, /* Defer constraints checking to the member type */ |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .name = "epyt" |
| }, |
| { ATF_POINTER, 1, offsetof(struct Ypet, plain), |
| .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 = asn_DFL_3_set_7, /* 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, |
| .memb_constraints = 0, /* Defer constraints checking to the member type */ |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .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, |
| .memb_constraints = memb_patest1_constraint_1, |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .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, |
| .memb_constraints = memb_patest2_constraint_1, |
| .per_constraints = 0, /* PER is not compiled, use -gen-PER */ |
| .default_value = 0, |
| .name = "patest2" |
| }, |
| }; |
| static ber_tlv_tag_t asn_DEF_Ypet_tags_1[] = { |
| (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) |
| }; |
| static asn_TYPE_tag2member_t asn_MAP_Ypet_tag2el_1[] = { |
| { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* plain at 28 */ |
| { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* epyt at 27 */ |
| { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, 0, 0 }, /* senums at 29 */ |
| { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 3, 0, 0 }, /* patest1 at 30 */ |
| { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 4, 0, 0 } /* patest2 at 31 */ |
| }; |
| static uint8_t asn_MAP_Ypet_mmap_1[(5 + (8 * sizeof(unsigned int)) - 1) / 8] = { |
| (1 << 7) | (0 << 6) | (1 << 5) | (1 << 4) | (1 << 3) |
| }; |
| static asn_SET_specifics_t asn_SPC_Ypet_specs_1 = { |
| sizeof(struct Ypet), |
| offsetof(struct Ypet, _asn_ctx), |
| offsetof(struct Ypet, _presence_map), |
| asn_MAP_Ypet_tag2el_1, |
| 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 */ |
| (unsigned int *)asn_MAP_Ypet_mmap_1 /* Mandatory elements map */ |
| }; |
| asn_TYPE_descriptor_t asn_DEF_Ypet = { |
| "Ypet", |
| "Ypet", |
| SET_free, |
| SET_print, |
| SET_constraint, |
| SET_decode_ber, |
| SET_encode_der, |
| SET_decode_xer, |
| SET_encode_xer, |
| 0, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| asn_MBR_Ypet_1, |
| 5, /* Elements count */ |
| &asn_SPC_Ypet_specs_1 /* Additional specs */ |
| }; |
| |
| |
| /*** <<< INCLUDES [EnumType] >>> ***/ |
| |
| #include <ENUMERATED.h> |
| |
| /*** <<< DEPS [EnumType] >>> ***/ |
| |
| typedef enum EnumType { |
| EnumType_one = 0, |
| EnumType_two = 1 |
| } EnumType_e; |
| |
| /*** <<< TYPE-DECLS [EnumType] >>> ***/ |
| |
| typedef ENUMERATED_t EnumType_t; |
| |
| /*** <<< FUNC-DECLS [EnumType] >>> ***/ |
| |
| extern asn_TYPE_descriptor_t asn_DEF_EnumType; |
| 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] >>> ***/ |
| |
| int |
| EnumType_constraint(asn_TYPE_descriptor_t *td, const void *sptr, |
| asn_app_consume_bytes_f *app_errlog, void *app_key) { |
| /* Replace with underlying type checker */ |
| td->check_constraints = asn_DEF_ENUMERATED.check_constraints; |
| return td->check_constraints(td, sptr, app_errlog, app_key); |
| } |
| |
| /* |
| * This type is implemented using ENUMERATED, |
| * so here we adjust the DEF accordingly. |
| */ |
| static void |
| EnumType_1_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; |
| 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 */ |
| } |
| |
| void |
| EnumType_free(asn_TYPE_descriptor_t *td, |
| void *struct_ptr, int contents_only) { |
| EnumType_1_inherit_TYPE_descriptor(td); |
| td->free_struct(td, struct_ptr, contents_only); |
| } |
| |
| int |
| EnumType_print(asn_TYPE_descriptor_t *td, const void *struct_ptr, |
| int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { |
| EnumType_1_inherit_TYPE_descriptor(td); |
| return td->print_struct(td, struct_ptr, ilevel, cb, app_key); |
| } |
| |
| asn_dec_rval_t |
| EnumType_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) { |
| EnumType_1_inherit_TYPE_descriptor(td); |
| return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode); |
| } |
| |
| asn_enc_rval_t |
| EnumType_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) { |
| EnumType_1_inherit_TYPE_descriptor(td); |
| return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); |
| } |
| |
| asn_dec_rval_t |
| EnumType_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) { |
| EnumType_1_inherit_TYPE_descriptor(td); |
| return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size); |
| } |
| |
| asn_enc_rval_t |
| EnumType_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) { |
| EnumType_1_inherit_TYPE_descriptor(td); |
| return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); |
| } |
| |
| |
| /*** <<< STAT-DEFS [EnumType] >>> ***/ |
| |
| static asn_INTEGER_enum_map_t asn_MAP_EnumType_value2enum_1[] = { |
| { 0, 3, "one" }, |
| { 1, 3, "two" } |
| }; |
| static unsigned int asn_MAP_EnumType_enum2value_1[] = { |
| 0, /* one(0) */ |
| 1 /* two(1) */ |
| }; |
| static 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 */ |
| }; |
| static ber_tlv_tag_t asn_DEF_EnumType_tags_1[] = { |
| (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)) |
| }; |
| asn_TYPE_descriptor_t asn_DEF_EnumType = { |
| "EnumType", |
| "EnumType", |
| EnumType_free, |
| EnumType_print, |
| EnumType_constraint, |
| EnumType_decode_ber, |
| EnumType_encode_der, |
| EnumType_decode_xer, |
| EnumType_encode_xer, |
| 0, /* No PER decoder, -gen-PER to enable */ |
| 0, /* Use generic outmost tag fetcher */ |
| 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, /* No PER visible constraints */ |
| 0, 0, /* Defined elsewhere */ |
| &asn_SPC_EnumType_specs_1 /* Additional specs */ |
| }; |
| |