osmocom
/
asn1c
mirror of https://gerrit.osmocom.org/asn1c
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

Simplify the logic of accessing codec function for specific TYPE

This commit is contained in:
Bi-Ruei, Chiu 2016-05-16 13:50:09 +08:00 committed by Lev Walkin
parent 6bc7a11d9e
commit 1fa31c9e3e
81 changed files with 2114 additions and 14511 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
asn1c/check-parsing-log2diff.pl Normal file
View File

@ -0,0 +1,32 @@
#!/usr/bin/env perl
#
# Convert check-parsing.sh's log to diff format.
#
if(-t STDIN && $#ARGV == -1) {
print STDERR "Usage: check-parsing-log2diff.pl < check-parsing.sh.log > diff.patch\n";
exit(1);
}
$state = 0;
while(<>) {
if ($state == 0) {
if (/^Checking\s*(.+?)\s*against\s*(.+?)$/) {
$source = $1;
$target = $2;
} elsif (/^\-\-\-\s(.+?)\s.*/) {
print "--- a/dev/null " . "\n";
} elsif (/^\+\+\+\s(.+?)\s.*/) {
print "+++ b" . $target . "\n";
$state = 1;
}
} else {
if (/^Checking\s*(.+?)\s*against\s*(.+?)$/) {
$source = $1;
$target = $2;
$state = 0;
} else {
print $_;
}
}
}

170
libasn1compiler/asn1c_C.c
View File

@ -206,7 +206,8 @@ asn1c_lang_C_type_common_INTEGER(arg_t *arg) {
OUT("\t/* This list is extensible */\n");
OUT("};\n");
OUT("static asn_INTEGER_specifics_t asn_SPC_%s_specs_%d = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("const asn_INTEGER_specifics_t asn_SPC_%s_specs_%d = {\n",
MKID(expr), expr->_type_unique_index);
INDENT(+1);
OUT("asn_MAP_%s_value2enum_%d,\t"
@ -238,7 +239,8 @@ asn1c_lang_C_type_common_INTEGER(arg_t *arg) {
if(expr->expr_type == ASN_BASIC_INTEGER
&& asn1c_type_fits_long(arg, expr) == FL_FITS_UNSIGN) {
REDIR(OT_STAT_DEFS);
OUT("static asn_INTEGER_specifics_t asn_SPC_%s_specs_%d = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("const asn_INTEGER_specifics_t asn_SPC_%s_specs_%d = {\n",
MKID(expr), expr->_type_unique_index);
INDENT(+1);
OUT("0,\t");
@ -379,7 +381,7 @@ asn1c_lang_C_type_SEQUENCE_def(arg_t *arg) {
GEN_INCLUDE_STD("constr_SEQUENCE");
if(!arg->embed)
GEN_DECLARE(expr); /* asn_DEF_xxx */
GEN_DECLARE("SEQUENCE", expr); /* asn_DEF_xxx */
REDIR(OT_STAT_DEFS);
@ -389,7 +391,8 @@ asn1c_lang_C_type_SEQUENCE_def(arg_t *arg) {
if(expr_elements_count(arg, expr)) {
int comp_mode = 0; /* {root,ext=1,root,root,...} */
OUT("static asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
MKID(expr), expr->_type_unique_index);
elements = 0;
@ -471,7 +474,8 @@ asn1c_lang_C_type_SEQUENCE_def(arg_t *arg) {
*/
emit_tag2member_map(arg, tag2el, tag2el_count, 0);
OUT("static asn_SEQUENCE_specifics_t asn_SPC_%s_specs_%d = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_SEQUENCE_specifics_t asn_SPC_%s_specs_%d = {\n",
MKID(expr), expr->_type_unique_index);
INDENT(+1);
OUT("sizeof(struct ");
@ -638,7 +642,7 @@ asn1c_lang_C_type_SET_def(arg_t *arg) {
GEN_INCLUDE_STD("constr_SET");
if(!arg->embed)
GEN_DECLARE(expr); /* asn_DEF_xxx */
GEN_DECLARE("SET", expr); /* asn_DEF_xxx */
REDIR(OT_STAT_DEFS);
@ -648,7 +652,8 @@ asn1c_lang_C_type_SET_def(arg_t *arg) {
if(expr_elements_count(arg, expr)) {
int comp_mode = 0; /* {root,ext=1,root,root,...} */
OUT("static asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
MKID(expr), expr->_type_unique_index);
elements = 0;
@ -708,7 +713,8 @@ asn1c_lang_C_type_SET_def(arg_t *arg) {
OUT("\n");
OUT("};\n");
OUT("static asn_SET_specifics_t asn_SPC_%s_specs_%d = {\n",
if(!(expr->_type_referenced)) OUT("static \n");
OUT("asn_SET_specifics_t asn_SPC_%s_specs_%d = {\n",
MKID(expr), expr->_type_unique_index);
INDENTED(
OUT("sizeof(struct ");
@ -863,14 +869,15 @@ asn1c_lang_C_type_SEx_OF_def(arg_t *arg, int seq_of) {
GEN_INCLUDE_STD("constr_SET_OF");
}
if(!arg->embed)
GEN_DECLARE(expr); /* asn_DEF_xxx */
GEN_DECLARE("SET_OF", expr); /* asn_DEF_xxx */
REDIR(OT_STAT_DEFS);
/*
* Print out the table according to which parsing is performed.
*/
OUT("static asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
MKID(expr), expr->_type_unique_index);
INDENT(+1);
v = TQ_FIRST(&(expr->members));
@ -892,7 +899,8 @@ asn1c_lang_C_type_SEx_OF_def(arg_t *arg, int seq_of) {
*/
tv_mode = emit_tags_vectors(arg, expr, &tags_count, &all_tags_count);
OUT("static asn_SET_OF_specifics_t asn_SPC_%s_specs_%d = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_SET_OF_specifics_t asn_SPC_%s_specs_%d = {\n",
MKID(expr), expr->_type_unique_index);
INDENTED(
OUT("sizeof(struct ");
@ -1031,7 +1039,7 @@ asn1c_lang_C_type_CHOICE_def(arg_t *arg) {
GEN_INCLUDE_STD("constr_CHOICE");
if(!arg->embed)
GEN_DECLARE(expr); /* asn_DEF_xxx */
GEN_DECLARE("CHOICE", expr); /* asn_DEF_xxx */
REDIR(OT_STAT_DEFS);
@ -1040,7 +1048,8 @@ asn1c_lang_C_type_CHOICE_def(arg_t *arg) {
*/
if(expr_elements_count(arg, expr)) {
OUT("static asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_TYPE_member_t asn_MBR_%s_%d[] = {\n",
MKID(expr), expr->_type_unique_index);
elements = 0;
@ -1088,7 +1097,8 @@ asn1c_lang_C_type_CHOICE_def(arg_t *arg) {
*/
emit_tag2member_map(arg, tag2el, tag2el_count, 0);
OUT("static asn_CHOICE_specifics_t asn_SPC_%s_specs_%d = {\n",
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_CHOICE_specifics_t asn_SPC_%s_specs_%d = {\n",
MKID(expr), expr->_type_unique_index);
INDENTED(
OUT("sizeof(struct ");
@ -1275,7 +1285,7 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) {
/*
* Constraint checking.
*/
if(!(arg->flags & A1C_NO_CONSTRAINTS)) {
if(!(arg->flags & A1C_NO_CONSTRAINTS) && expr->combined_constraints) {
p = MKID(expr);
if(HIDE_INNER_DEFS) OUT("static ");
OUT("int\n");
@ -1327,6 +1337,8 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) {
asn1c_type_name(arg, expr, TNF_SAFE));
OUT(" * so here we adjust the DEF accordingly.\n");
OUT(" */\n");
#if 0 /* remove unnecessary functions */
OUT("static void\n");
OUT("%s_%d_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {\n",
MKID(expr), expr->_type_unique_index);
@ -1535,7 +1547,7 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) {
OUT("}\n");
OUT("\n");
}
#endif
REDIR(OT_FUNC_DECLS);
p = MKID(expr);
@ -1545,6 +1557,20 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) {
p, expr->_type_unique_index);
} else {
OUT("extern asn_TYPE_descriptor_t asn_DEF_%s;\n", p);
if (etd_spec == ETD_HAS_SPECIFICS) {
if((expr->expr_type == ASN_BASIC_ENUMERATED) ||
(expr->expr_type == ASN_BASIC_INTEGER)) {
if(expr->_type_referenced) {
OUT("extern asn_INTEGER_specifics_t "
"asn_SPC_%s_specs_%d;\n", p, expr->_type_unique_index);
}
} else {
asn1p_expr_t *terminal = asn1f_find_terminal_type_ex(arg->asn, expr);
OUT("extern asn_%s_specifics_t ", asn1c_type_name(arg, terminal, TNF_SAFE));
OUT("asn_SPC_%s_specs_%d;\n", MKID(expr), expr->_type_unique_index);
}
}
OUT("asn_struct_free_f %s_free;\n", p);
OUT("asn_struct_print_f %s_print;\n", p);
OUT("asn_constr_check_f %s_constraint;\n", p);
@ -2246,9 +2272,18 @@ emit_member_PER_constraints(arg_t *arg, asn1p_expr_t *expr, const char *pfx) {
return 0;
}
if(expr->_type_referenced) {
REDIR(OT_FUNC_DECLS);
OUT("extern asn_per_constraints_t "
"asn_PER_%s_%s_constr_%d;\n",
pfx, MKID(expr), expr->_type_unique_index);
}
REDIR(OT_CTDEFS);
OUT("static asn_per_constraints_t "
if(!(expr->_type_referenced)) OUT("static ");
OUT("asn_per_constraints_t "
"asn_PER_%s_%s_constr_%d GCC_NOTUSED = {\n",
pfx, MKID(expr), expr->_type_unique_index);
@ -2723,6 +2758,7 @@ emit_type_DEF(arg_t *arg, asn1p_expr_t *expr, enum tvm_compat tv_mode, int tags_
asn1p_expr_t *terminal;
int using_type_name = 0;
char *p = MKID(expr);
char *p2 = (char *)0;
terminal = asn1f_find_terminal_type_ex(arg->asn, expr);
@ -2754,8 +2790,15 @@ emit_type_DEF(arg_t *arg, asn1p_expr_t *expr, enum tvm_compat tv_mode, int tags_
using_type_name = 1;
p = asn1c_type_name(arg, arg->expr, TNF_SAFE);
} else {
if (expr->expr_type == A1TC_REFERENCE) {
p2 = strdup(asn1c_type_name(arg, terminal, TNF_SAFE));
} else {
p2 = strdup(asn1c_type_name(arg, expr, TNF_SAFE));
}
p = MKID(expr);
}
if (!p2)
p2 = strdup(p);
#define FUNCREF(foo) do { \
OUT("%s", p); \
@ -2764,29 +2807,38 @@ emit_type_DEF(arg_t *arg, asn1p_expr_t *expr, enum tvm_compat tv_mode, int tags_
OUT("_" #foo ",\n"); \
} while(0)
FUNCREF(free);
FUNCREF(print);
FUNCREF(constraint);
FUNCREF(decode_ber);
FUNCREF(encode_der);
FUNCREF(decode_xer);
FUNCREF(encode_xer);
#define FUNCREF2(foo) \
do { \
OUT("%s", p2); \
OUT("_" #foo ",\n"); \
} while(0)
FUNCREF2(free);
FUNCREF2(print);
if (!expr->combined_constraints)
FUNCREF2(constraint);
else
FUNCREF(constraint);
FUNCREF2(decode_ber);
FUNCREF2(encode_der);
FUNCREF2(decode_xer);
FUNCREF2(encode_xer);
if(arg->flags & A1C_GEN_OER) {
FUNCREF(decode_oer);
FUNCREF(encode_oer);
FUNCREF2(decode_oer);
FUNCREF2(encode_oer);
} else {
OUT("0, 0,\t/* No OER support, "
"use \"-gen-OER\" to enable */\n");
}
if(arg->flags & A1C_GEN_PER) {
FUNCREF(decode_uper);
FUNCREF(encode_uper);
FUNCREF2(decode_uper);
FUNCREF2(encode_uper);
} else {
OUT("0, 0,\t/* No PER support, "
"use \"-gen-PER\" to enable */\n");
}
if (p2) free(p2);
if(!terminal || terminal->expr_type == ASN_CONSTR_CHOICE) {
//if(expr->expr_type == ASN_CONSTR_CHOICE) {
@ -2857,16 +2909,35 @@ emit_type_DEF(arg_t *arg, asn1p_expr_t *expr, enum tvm_compat tv_mode, int tags_
OUT("0,\t/* No PER visible constraints */\n");
}
if(elements_count) {
OUT("asn_MBR_%s_%d,\n", p, expr->_type_unique_index);
if(expr->expr_type == ASN_CONSTR_SEQUENCE_OF
|| expr->expr_type == ASN_CONSTR_SET_OF) {
OUT("%d,\t/* Single element */\n",
elements_count);
assert(elements_count == 1);
if(elements_count ||
((expr->expr_type == A1TC_REFERENCE) &&
(terminal->expr_type & ASN_CONSTR_MASK) &&
expr_elements_count(arg, terminal))) {
if (expr->expr_type == A1TC_REFERENCE) {
OUT("asn_MBR_%s_%d,\n", MKID(terminal), terminal->_type_unique_index);
if(terminal->expr_type == ASN_CONSTR_SEQUENCE_OF
|| terminal->expr_type == ASN_CONSTR_SET_OF) {
OUT("%d,\t/* Single element */\n",
expr_elements_count(arg, terminal));
assert(expr_elements_count(arg, terminal) == 1);
} else {
OUT("%d,\t/* Elements count */\n",
expr_elements_count(arg, terminal));
}
} else {
OUT("%d,\t/* Elements count */\n",
elements_count);
OUT("asn_MBR_%s_%d,\n", p, expr->_type_unique_index);
if(expr->expr_type == ASN_CONSTR_SEQUENCE_OF
|| expr->expr_type == ASN_CONSTR_SET_OF) {
OUT("%d,\t/* Single element */\n",
elements_count);
assert(elements_count == 1);
} else {
OUT("%d,\t/* Elements count */\n",
elements_count);
}
}
} else {
if(expr_elements_count(arg, expr))
@ -2877,7 +2948,28 @@ emit_type_DEF(arg_t *arg, asn1p_expr_t *expr, enum tvm_compat tv_mode, int tags_
switch(spec) {
case ETD_NO_SPECIFICS:
OUT("0\t/* No specifics */\n");
if ((expr->expr_type == A1TC_REFERENCE) &&
((terminal->expr_type & ASN_CONSTR_MASK) ||
(terminal->expr_type == ASN_BASIC_ENUMERATED) ||
((terminal->expr_type == ASN_BASIC_INTEGER) &&
(asn1c_type_fits_long(arg, terminal) == FL_FITS_UNSIGN)))) {
OUT("&asn_SPC_%s_specs_%d\t/* Additional specs */\n", MKID(terminal), terminal->_type_unique_index);
} else if ((expr->expr_type == ASN_TYPE_ANY) ||
(expr->expr_type == ASN_BASIC_BIT_STRING) ||
(expr->expr_type == ASN_STRING_BMPString) ||
(expr->expr_type == ASN_BASIC_OCTET_STRING) ||
(expr->expr_type == ASN_STRING_UniversalString)) {
OUT("&asn_SPC_%s_specs\t/* Additional specs */\n", asn1c_type_name(arg, expr, TNF_SAFE));
} else if ((expr->expr_type == A1TC_REFERENCE) &&
((terminal->expr_type == ASN_TYPE_ANY) ||
(terminal->expr_type == ASN_BASIC_BIT_STRING) ||
(terminal->expr_type == ASN_STRING_BMPString) ||
(terminal->expr_type == ASN_BASIC_OCTET_STRING) ||
(terminal->expr_type == ASN_STRING_UniversalString))) {
OUT("&asn_SPC_%s_specs\t/* Additional specs */\n", asn1c_type_name(arg, terminal, TNF_SAFE));
} else {
OUT("0\t/* No specifics */\n");
}
break;
case ETD_HAS_SPECIFICS:
OUT("&asn_SPC_%s_specs_%d\t/* Additional specs */\n",

22
libasn1compiler/asn1c_out.h
View File

@ -104,12 +104,22 @@ int asn1c_compiled_output(arg_t *arg, const char *fmt, ...);
} while(0)
/* Generate ASN.1 type declaration */
#define GEN_DECLARE(expr) do { \
int saved_target = arg->target->target; \
REDIR(OT_FUNC_DECLS); \
OUT_NOINDENT("extern asn_TYPE_descriptor_t " \
"asn_DEF_%s;\n", MKID(expr)); \
REDIR(saved_target); \
#define GEN_DECLARE(type_name, expr) do { \
int saved_target = arg->target->target; \
REDIR(OT_FUNC_DECLS); \
OUT_NOINDENT("extern asn_TYPE_descriptor_t " \
"asn_DEF_%s;\n", MKID(expr)); \
if (expr->_type_referenced) { \
OUT_NOINDENT("extern asn_%s_specifics_t " \
"asn_SPC_%s_specs_%d;\n", type_name, \
MKID(expr), expr->_type_unique_index); \
if(expr_elements_count(arg, expr)) \
OUT_NOINDENT("extern asn_TYPE_member_t " \
"asn_MBR_%s_%d[%d];\n", \
MKID(expr), expr->_type_unique_index, \
expr_elements_count(arg, expr)); \
} \
REDIR(saved_target); \
} while(0)
/*

15
libasn1fix/asn1fix_export.c
View File

@ -57,6 +57,21 @@ asn1f_find_terminal_type_ex(asn1p_t *asn, asn1p_expr_t *expr) {
return asn1f_find_terminal_type(&arg, expr);
}
asn1p_expr_t *
asn1f_find_ancestor_type_with_PER_constraint_ex(asn1p_t *asn, asn1p_expr_t *expr) {
arg_t arg;
memset(&arg, 0, sizeof(arg));
arg.asn = asn;
arg.mod = expr->module;
arg.expr = expr;
arg.eh = a1f_replace_me_with_proper_interface_arg.eh;
arg.debug = a1f_replace_me_with_proper_interface_arg.debug;
return asn1f_find_ancestor_type_with_PER_constraint(&arg, expr);
}
int
asn1f_fix_dereference_values_ex(asn1p_t *asn, asn1p_module_t *mod,
asn1p_expr_t *expr) {

6
libasn1fix/asn1fix_export.h
View File

@ -38,4 +38,10 @@ asn1p_expr_t *asn1f_find_terminal_type_ex(asn1p_t *asn, asn1p_expr_t *tc);
int asn1f_fix_dereference_values_ex(asn1p_t *asn, asn1p_module_t *mod,
asn1p_expr_t *expr);
/*
* Exportable version of asn1f_find_ancestor_type_with_PER_constraint().
*/
asn1p_expr_t *asn1f_find_ancestor_type_with_PER_constraint_ex(asn1p_t *asn,
asn1p_expr_t *expr);
#endif /* ASN1FIX_EXPORT_H */

12
libasn1fix/asn1fix_retrieve.c
View File

@ -3,6 +3,7 @@
enum ftt_what {
FTT_TYPE, /* Find the type of the given expression */
FTT_VALUE, /* Find the value of the given expression */
FTT_CONSTR_TYPE /* Find the type of the given expression having constraint */
};
static asn1p_expr_t *asn1f_find_terminal_thing(arg_t *arg, asn1p_expr_t *expr, enum ftt_what);
@ -382,6 +383,11 @@ asn1f_find_terminal_value(arg_t *arg, asn1p_expr_t *expr) {
return asn1f_find_terminal_thing(arg, expr, FTT_VALUE);
}
asn1p_expr_t *
asn1f_find_ancestor_type_with_PER_constraint(arg_t *arg, asn1p_expr_t *expr) {
return asn1f_find_terminal_thing(arg, expr, FTT_CONSTR_TYPE);
}
static asn1p_expr_t *
asn1f_find_terminal_thing(arg_t *arg, asn1p_expr_t *expr, enum ftt_what what) {
asn1p_ref_t *ref = 0;
@ -389,6 +395,7 @@ asn1f_find_terminal_thing(arg_t *arg, asn1p_expr_t *expr, enum ftt_what what) {
switch(what) {
case FTT_TYPE:
case FTT_CONSTR_TYPE:
/* Expression may be a terminal type itself */
if(expr->expr_type != A1TC_REFERENCE)
return expr;
@ -455,6 +462,10 @@ asn1f_find_terminal_thing(arg_t *arg, asn1p_expr_t *expr, enum ftt_what what) {
}
tc->_type_referenced = 1;
if((what == FTT_CONSTR_TYPE) && (tc->constraints))
return tc;
tc->_mark |= TM_RECURSION;
WITH_MODULE(tc->module,
expr = asn1f_find_terminal_thing(arg, tc, what));
@ -463,6 +474,7 @@ asn1f_find_terminal_thing(arg_t *arg, asn1p_expr_t *expr, enum ftt_what what) {
return expr;
}
/*
* Make sure that the specified name is present or otherwise does
* not contradict with the EXPORTS clause of the specified module.

7
libasn1fix/asn1fix_retrieve.h
View File

@ -68,4 +68,11 @@ asn1p_expr_t *asn1f_find_terminal_type(arg_t *arg, asn1p_expr_t *tc);
*/
asn1p_expr_t *asn1f_find_terminal_value(arg_t *arg, asn1p_expr_t *tc);
/*
* Recursively find the original type with constraint for the given
* expression.
*/
asn1p_expr_t *asn1f_find_ancestor_type_with_PER_constraint(arg_t *arg, asn1p_expr_t *tc);
#endif /* ASN1FIX_RETRIEVE_H */

2
skeletons/ANY.c
View File

@ -6,7 +6,7 @@
#include <ANY.h>
#include <errno.h>
static asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs = {
asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs = {
sizeof(ANY_t),
offsetof(ANY_t, _asn_ctx),
ASN_OSUBV_ANY

8
skeletons/ANY.h
View File

@ -19,6 +19,7 @@ typedef struct ANY {
} ANY_t;
extern asn_TYPE_descriptor_t asn_DEF_ANY;
extern asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs;
asn_struct_free_f ANY_free;
asn_struct_print_f ANY_print;
@ -26,6 +27,13 @@ ber_type_decoder_f ANY_decode_ber;
der_type_encoder_f ANY_encode_der;
xer_type_encoder_f ANY_encode_xer;
#define ANY_free OCTET_STRING_free
#define ANY_print OCTET_STRING_print
#define ANY_constraint asn_generic_no_constraint
#define ANY_decode_ber OCTET_STRING_decode_ber
#define ANY_encode_der OCTET_STRING_encode_der
#define ANY_decode_xer OCTET_STRING_decode_xer_hex
/******************************
* Handy conversion routines. *
******************************/

2
skeletons/BIT_STRING.c
View File

@ -12,7 +12,7 @@
static const ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
};
static asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs = {
asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs = {
sizeof(BIT_STRING_t),
offsetof(BIT_STRING_t, _asn_ctx),
ASN_OSUBV_BIT

8
skeletons/BIT_STRING.h
View File

@ -21,11 +21,19 @@ typedef struct BIT_STRING_s {
} BIT_STRING_t;
extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
extern asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs;
asn_struct_print_f BIT_STRING_print; /* Human-readable output */
asn_constr_check_f BIT_STRING_constraint;
xer_type_encoder_f BIT_STRING_encode_xer;
#define BIT_STRING_free OCTET_STRING_free
#define BIT_STRING_decode_ber OCTET_STRING_decode_ber
#define BIT_STRING_encode_der OCTET_STRING_encode_der
#define BIT_STRING_decode_xer OCTET_STRING_decode_xer_binary
#define BIT_STRING_decode_uper OCTET_STRING_decode_uper
#define BIT_STRING_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

2
skeletons/BMPString.c
View File

@ -13,7 +13,7 @@ static const ber_tlv_tag_t asn_DEF_BMPString_tags[] = {
(ASN_TAG_CLASS_UNIVERSAL | (30 << 2)), /* [UNIVERSAL 30] IMPLICIT ...*/
(ASN_TAG_CLASS_UNIVERSAL | (4 << 2)) /* ... OCTET STRING */
};
static asn_OCTET_STRING_specifics_t asn_SPC_BMPString_specs = {
asn_OCTET_STRING_specifics_t asn_SPC_BMPString_specs = {
sizeof(BMPString_t),
offsetof(BMPString_t, _asn_ctx),
ASN_OSUBV_U16 /* 16-bits character */

9
skeletons/BMPString.h
View File

@ -14,11 +14,20 @@ extern "C" {
typedef OCTET_STRING_t BMPString_t; /* Implemented via OCTET STRING */
extern asn_TYPE_descriptor_t asn_DEF_BMPString;
extern asn_OCTET_STRING_specifics_t asn_SPC_BMPString_specs;
asn_struct_print_f BMPString_print; /* Human-readable output */
xer_type_decoder_f BMPString_decode_xer;
xer_type_encoder_f BMPString_encode_xer;
#define BMPString_free OCTET_STRING_free
#define BMPString_print BMPString_print
#define BMPString_constraint asn_generic_no_constraint
#define BMPString_decode_ber OCTET_STRING_decode_ber
#define BMPString_encode_der OCTET_STRING_encode_der
#define BMPString_decode_uper OCTET_STRING_decode_uper
#define BMPString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

2
skeletons/BOOLEAN.h
View File

@ -29,6 +29,8 @@ xer_type_encoder_f BOOLEAN_encode_xer;
per_type_decoder_f BOOLEAN_decode_uper;
per_type_encoder_f BOOLEAN_encode_uper;
#define BOOLEAN_constraint asn_generic_no_constraint
#ifdef __cplusplus
}
#endif

8
skeletons/ENUMERATED.h
View File

@ -18,6 +18,14 @@ extern asn_TYPE_descriptor_t asn_DEF_ENUMERATED;
per_type_decoder_f ENUMERATED_decode_uper;
per_type_encoder_f ENUMERATED_encode_uper;
#define ENUMERATED_free ASN__PRIMITIVE_TYPE_free
#define ENUMERATED_print INTEGER_print
#define ENUMERATED_constraint asn_generic_no_constraint
#define ENUMERATED_decode_ber ber_decode_primitive
#define ENUMERATED_encode_der INTEGER_encode_der
#define ENUMERATED_decode_xer INTEGER_decode_xer
#define ENUMERATED_encode_xer INTEGER_encode_xer
#ifdef __cplusplus
}
#endif

10
skeletons/GeneralString.h
View File

@ -15,6 +15,16 @@ typedef OCTET_STRING_t GeneralString_t; /* Implemented via OCTET STRING */
extern asn_TYPE_descriptor_t asn_DEF_GeneralString;
#define GeneralString_free OCTET_STRING_free
#define GeneralString_print OCTET_STRING_print
#define GeneralString_constraint asn_generic_unknown_constraint
#define GeneralString_decode_ber OCTET_STRING_decode_ber
#define GeneralString_encode_der OCTET_STRING_encode_der
#define GeneralString_decode_xer OCTET_STRING_decode_xer_hex
#define GeneralString_encode_xer OCTET_STRING_encode_xer
#define GeneralString_decode_uper OCTET_STRING_decode_uper
#define GeneralString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

6
skeletons/GeneralizedTime.h
View File

@ -20,6 +20,12 @@ asn_constr_check_f GeneralizedTime_constraint;
der_type_encoder_f GeneralizedTime_encode_der;
xer_type_encoder_f GeneralizedTime_encode_xer;
#define GeneralizedTime_free OCTET_STRING_free
#define GeneralizedTime_decode_ber OCTET_STRING_decode_ber
#define GeneralizedTime_decode_xer OCTET_STRING_decode_xer_utf8
#define GeneralizedTime_decode_uper OCTET_STRING_decode_uper
#define GeneralizedTime_encode_uper OCTET_STRING_encode_uper
/***********************
* Some handy helpers. *
***********************/

10
skeletons/GraphicString.h
View File

@ -15,6 +15,16 @@ typedef OCTET_STRING_t GraphicString_t; /* Implemented via OCTET STRING */
extern asn_TYPE_descriptor_t asn_DEF_GraphicString;
#define GraphicString_free OCTET_STRING_free
#define GraphicString_print OCTET_STRING_print
#define GraphicString_constraint asn_generic_unknown_constraint
#define GraphicString_decode_ber OCTET_STRING_decode_ber
#define GraphicString_encode_der OCTET_STRING_encode_der
#define GraphicString_decode_xer OCTET_STRING_decode_xer_hex
#define GraphicString_encode_xer OCTET_STRING_encode_xer
#define GraphicString_decode_uper OCTET_STRING_decode_uper
#define GraphicString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

9
skeletons/IA5String.h
View File

@ -20,6 +20,15 @@ extern asn_TYPE_descriptor_t asn_DEF_IA5String;
asn_constr_check_f IA5String_constraint;
#define IA5String_free OCTET_STRING_free
#define IA5String_print OCTET_STRING_print_utf8
#define IA5String_decode_ber OCTET_STRING_decode_ber
#define IA5String_encode_der OCTET_STRING_encode_der
#define IA5String_decode_xer OCTET_STRING_decode_xer_utf8
#define IA5String_encode_xer OCTET_STRING_encode_xer_utf8
#define IA5String_decode_uper OCTET_STRING_decode_uper
#define IA5String_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

10
skeletons/ISO646String.h
View File

@ -16,6 +16,16 @@ typedef VisibleString_t ISO646String_t; /* Implemented using VisibleString */
extern asn_TYPE_descriptor_t asn_DEF_ISO646String;
#define ISO646String_free OCTET_STRING_free
#define ISO646String_print OCTET_STRING_print_utf8
#define ISO646String_constraint VisibleString_constraint
#define ISO646String_decode_ber OCTET_STRING_decode_ber
#define ISO646String_encode_der OCTET_STRING_encode_der
#define ISO646String_decode_xer OCTET_STRING_decode_xer_utf8
#define ISO646String_encode_xer OCTET_STRING_encode_xer_utf8
#define ISO646String_decode_uper OCTET_STRING_decode_uper
#define ISO646String_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

5
skeletons/NULL.h
View File

@ -6,6 +6,7 @@
#define ASN_TYPE_NULL_H
#include <asn_application.h>
#include <BOOLEAN.h>
#ifdef __cplusplus
extern "C" {
@ -26,6 +27,10 @@ xer_type_encoder_f NULL_encode_xer;
per_type_decoder_f NULL_decode_uper;
per_type_encoder_f NULL_encode_uper;
#define NULL_free BOOLEAN_free
#define NULL_decode_ber BOOLEAN_decode_ber
#define NULL_constraint asn_generic_no_constraint
#ifdef __cplusplus
}
#endif

7
skeletons/NativeEnumerated.h
View File

@ -25,6 +25,13 @@ xer_type_encoder_f NativeEnumerated_encode_xer;
per_type_decoder_f NativeEnumerated_decode_uper;
per_type_encoder_f NativeEnumerated_encode_uper;
#define NativeEnumerated_free NativeInteger_free
#define NativeEnumerated_print NativeInteger_print
#define NativeEnumerated_constraint asn_generic_no_constraint
#define NativeEnumerated_decode_ber NativeInteger_decode_ber
#define NativeEnumerated_encode_der NativeInteger_encode_der
#define NativeEnumerated_decode_xer NativeInteger_decode_xer
#ifdef __cplusplus
}
#endif

2
skeletons/NativeInteger.h
View File

@ -32,6 +32,8 @@ oer_type_encoder_f NativeInteger_encode_oer;
per_type_decoder_f NativeInteger_decode_uper;
per_type_encoder_f NativeInteger_encode_uper;
#define NativeInteger_constraint asn_generic_no_constraint
#ifdef __cplusplus
}
#endif

2
skeletons/NativeReal.h
View File

@ -28,6 +28,8 @@ xer_type_encoder_f NativeReal_encode_xer;
per_type_decoder_f NativeReal_decode_uper;
per_type_encoder_f NativeReal_encode_uper;
#define NativeReal_constraint asn_generic_no_constraint
#ifdef __cplusplus
}
#endif

9
skeletons/NumericString.h
View File

@ -17,6 +17,15 @@ extern asn_TYPE_descriptor_t asn_DEF_NumericString;
asn_constr_check_f NumericString_constraint;
#define NumericString_free OCTET_STRING_free
#define NumericString_print OCTET_STRING_print_utf8
#define NumericString_decode_ber OCTET_STRING_decode_ber
#define NumericString_encode_der OCTET_STRING_encode_der
#define NumericString_decode_xer OCTET_STRING_decode_xer_utf8
#define NumericString_encode_xer OCTET_STRING_encode_xer_utf8
#define NumericString_decode_uper OCTET_STRING_decode_uper
#define NumericString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

6
skeletons/OBJECT_IDENTIFIER.h
View File

@ -23,6 +23,12 @@ der_type_encoder_f OBJECT_IDENTIFIER_encode_der;
xer_type_decoder_f OBJECT_IDENTIFIER_decode_xer;
xer_type_encoder_f OBJECT_IDENTIFIER_encode_xer;
#define OBJECT_IDENTIFIER_free ASN__PRIMITIVE_TYPE_free
#define OBJECT_IDENTIFIER_decode_ber ber_decode_primitive
#define OBJECT_IDENTIFIER_encode_der der_encode_primitive
#define OBJECT_IDENTIFIER_decode_uper OCTET_STRING_decode_uper
#define OBJECT_IDENTIFIER_encode_uper OCTET_STRING_encode_uper
/**********************************
* Some handy conversion routines *
**********************************/

2
skeletons/OCTET_STRING.c
View File

@ -14,7 +14,7 @@
static const ber_tlv_tag_t asn_DEF_OCTET_STRING_tags[] = {
(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
};
static asn_OCTET_STRING_specifics_t asn_SPC_OCTET_STRING_specs = {
asn_OCTET_STRING_specifics_t asn_SPC_OCTET_STRING_specs = {
sizeof(OCTET_STRING_t),
offsetof(OCTET_STRING_t, _asn_ctx),
ASN_OSUBV_STR

5
skeletons/OCTET_STRING.h
View File

@ -35,6 +35,9 @@ oer_type_encoder_f OCTET_STRING_encode_oer;
per_type_decoder_f OCTET_STRING_decode_uper;
per_type_encoder_f OCTET_STRING_encode_uper;
#define OCTET_STRING_constraint asn_generic_no_constraint
#define OCTET_STRING_decode_xer OCTET_STRING_decode_xer_hex
/******************************
* Handy conversion routines. *
******************************/
@ -81,6 +84,8 @@ typedef const struct asn_OCTET_STRING_specifics_s {
} subvariant;
} asn_OCTET_STRING_specifics_t;
extern asn_OCTET_STRING_specifics_t asn_SPC_OCTET_STRING_specs;
#ifdef __cplusplus
}
#endif

10
skeletons/ObjectDescriptor.h
View File

@ -15,6 +15,16 @@ typedef GraphicString_t ObjectDescriptor_t; /* Implemented via GraphicString */
extern asn_TYPE_descriptor_t asn_DEF_ObjectDescriptor;
#define ObjectDescriptor_free OCTET_STRING_free
#define ObjectDescriptor_print OCTET_STRING_print_utf8
#define ObjectDescriptor_constraint asn_generic_unknown_constraint
#define ObjectDescriptor_decode_ber OCTET_STRING_decode_ber
#define ObjectDescriptor_encode_der OCTET_STRING_encode_der
#define ObjectDescriptor_decode_xer OCTET_STRING_decode_xer_utf8
#define ObjectDescriptor_encode_xer OCTET_STRING_encode_xer_utf8
#define ObjectDescriptor_decode_uper OCTET_STRING_decode_uper
#define ObjectDescriptor_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

9
skeletons/PrintableString.h
View File

@ -17,6 +17,15 @@ extern asn_TYPE_descriptor_t asn_DEF_PrintableString;
asn_constr_check_f PrintableString_constraint;
#define PrintableString_free OCTET_STRING_free
#define PrintableString_print OCTET_STRING_print_utf8
#define PrintableString_decode_ber OCTET_STRING_decode_ber
#define PrintableString_encode_der OCTET_STRING_encode_der
#define PrintableString_decode_xer OCTET_STRING_decode_xer_utf8
#define PrintableString_encode_xer OCTET_STRING_encode_xer_utf8
#define PrintableString_decode_uper OCTET_STRING_decode_uper
#define PrintableString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

5
skeletons/REAL.h
View File

@ -22,6 +22,11 @@ xer_type_encoder_f REAL_encode_xer;
per_type_decoder_f REAL_decode_uper;
per_type_encoder_f REAL_encode_uper;
#define REAL_free ASN__PRIMITIVE_TYPE_free,
#define REAL_constraint asn_generic_no_constraint
#define REAL_decode_ber ber_decode_primitive
#define REAL_encode_der der_encode_primitive
/***********************************
* Some handy conversion routines. *
***********************************/

7
skeletons/RELATIVE-OID.h
View File

@ -20,6 +20,13 @@ asn_struct_print_f RELATIVE_OID_print;
xer_type_decoder_f RELATIVE_OID_decode_xer;
xer_type_encoder_f RELATIVE_OID_encode_xer;
#define RELATIVE_OID_free ASN__PRIMITIVE_TYPE_free
#define RELATIVE_OID_constraint asn_generic_no_constraint
#define RELATIVE_OID_decode_ber ber_decode_primitive
#define RELATIVE_OID_encode_der der_encode_primitive
#define RELATIVE_OID_decode_uper OCTET_STRING_decode_uper
#define RELATIVE_OID_encode_uper OCTET_STRING_encode_uper
/**********************************
* Some handy conversion routines *
**********************************/

10
skeletons/T61String.h
View File

@ -15,6 +15,16 @@ typedef OCTET_STRING_t T61String_t; /* Implemented via OCTET STRING */
extern asn_TYPE_descriptor_t asn_DEF_T61String;
#define T61String_free OCTET_STRING_free
#define T61String_print OCTET_STRING_print
#define T61String_constraint asn_generic_unknown_constraint
#define T61String_decode_ber OCTET_STRING_decode_ber
#define T61String_encode_der OCTET_STRING_encode_der
#define T61String_decode_xer OCTET_STRING_decode_xer_hex
#define T61String_encode_xer OCTET_STRING_encode_xer
#define T61String_decode_uper OCTET_STRING_decode_uper
#define T61String_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

10
skeletons/TeletexString.h
View File

@ -15,6 +15,16 @@ typedef OCTET_STRING_t TeletexString_t; /* Implemented via OCTET STRING */
extern asn_TYPE_descriptor_t asn_DEF_TeletexString;
#define TeletexString_free OCTET_STRING_free
#define TeletexString_print OCTET_STRING_print
#define TeletexString_constraint asn_generic_unknown_constraint
#define TeletexString_decode_ber OCTET_STRING_decode_ber
#define TeletexString_encode_der OCTET_STRING_encode_der
#define TeletexString_decode_xer OCTET_STRING_decode_xer_hex
#define TeletexString_encode_xer OCTET_STRING_encode_xer
#define TeletexString_decode_uper OCTET_STRING_decode_uper
#define TeletexString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

7
skeletons/UTCTime.h
View File

@ -19,6 +19,13 @@ asn_struct_print_f UTCTime_print;
asn_constr_check_f UTCTime_constraint;
xer_type_encoder_f UTCTime_encode_xer;
#define UTCTime_free OCTET_STRING_free
#define UTCTime_decode_ber OCTET_STRING_decode_ber
#define UTCTime_encode_der OCTET_STRING_encode_der
#define UTCTime_decode_xer OCTET_STRING_decode_xer_utf8
#define UTCTime_decode_uper OCTET_STRING_decode_uper
#define UTCTime_encode_uper OCTET_STRING_encode_uper
/***********************
* Some handy helpers. *
***********************/

9
skeletons/UTF8String.h
View File

@ -18,6 +18,15 @@ extern asn_TYPE_descriptor_t asn_DEF_UTF8String;
asn_struct_print_f UTF8String_print;
asn_constr_check_f UTF8String_constraint;
#define UTF8String_free OCTET_STRING_free
#define UTF8String_constraint UTF8String_constraint
#define UTF8String_decode_ber OCTET_STRING_decode_ber
#define UTF8String_encode_der OCTET_STRING_encode_der
#define UTF8String_decode_xer OCTET_STRING_decode_xer_utf8
#define UTF8String_encode_xer OCTET_STRING_encode_xer_utf8
#define UTF8String_decode_uper OCTET_STRING_decode_uper
#define UTF8String_encode_uper OCTET_STRING_encode_uper
/*
* Returns length of the given UTF-8 string in characters,
* or a negative error code:

2
skeletons/UniversalString.c
View File

@ -13,7 +13,7 @@ static const ber_tlv_tag_t asn_DEF_UniversalString_tags[] = {
(ASN_TAG_CLASS_UNIVERSAL | (28 << 2)), /* [UNIVERSAL 28] IMPLICIT ...*/
(ASN_TAG_CLASS_UNIVERSAL | (4 << 2)) /* ... OCTET STRING */
};
static asn_OCTET_STRING_specifics_t asn_SPC_UniversalString_specs = {
asn_OCTET_STRING_specifics_t asn_SPC_UniversalString_specs = {
sizeof(UniversalString_t),
offsetof(UniversalString_t, _asn_ctx),
ASN_OSUBV_U32 /* 32-bits character */

1
skeletons/UniversalString.h
View File

@ -14,6 +14,7 @@ extern "C" {
typedef OCTET_STRING_t UniversalString_t; /* Implemented via OCTET STRING */
extern asn_TYPE_descriptor_t asn_DEF_UniversalString;
extern asn_OCTET_STRING_specifics_t asn_SPC_UniversalString_specs;
asn_struct_print_f UniversalString_print; /* Human-readable output */
xer_type_decoder_f UniversalString_decode_xer;

10
skeletons/VideotexString.h
View File

@ -15,6 +15,16 @@ typedef OCTET_STRING_t VideotexString_t; /* Implemented via OCTET STRING */
extern asn_TYPE_descriptor_t asn_DEF_VideotexString;
#define VideotexString_free OCTET_STRING_free
#define VideotexString_print OCTET_STRING_print
#define VideotexString_constraint asn_generic_unknown_constraint
#define VideotexString_decode_ber OCTET_STRING_decode_ber
#define VideotexString_encode_der OCTET_STRING_encode_der
#define VideotexString_decode_xer OCTET_STRING_decode_xer_hex
#define VideotexString_encode_xer OCTET_STRING_encode_xer
#define VideotexString_decode_uper OCTET_STRING_decode_uper
#define VideotexString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

10
skeletons/VisibleString.h
View File

@ -17,6 +17,16 @@ extern asn_TYPE_descriptor_t asn_DEF_VisibleString;
asn_constr_check_f VisibleString_constraint;
#define VisibleString_free OCTET_STRING_free
#define VisibleString_print OCTET_STRING_print
#define VisibleString_constraint VisibleString_constraint
#define VisibleString_decode_ber OCTET_STRING_decode_ber
#define VisibleString_encode_der OCTET_STRING_encode_der
#define VisibleString_decode_xer OCTET_STRING_decode_xer_hex
#define VisibleString_encode_xer OCTET_STRING_encode_xer
#define VisibleString_decode_uper OCTET_STRING_decode_uper
#define VisibleString_encode_uper OCTET_STRING_encode_uper
#ifdef __cplusplus
}
#endif

450
tests/03-enum-OK.asn1.-Pfwide-types
View File

@ -32,84 +32,10 @@ xer_type_encoder_f Enum1_encode_xer;
/*** <<< CODE [Enum1] >>> ***/
int
Enum1_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
Enum1_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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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
Enum1_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Enum1_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Enum1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Enum1_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Enum1_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) {
Enum1_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Enum1_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) {
Enum1_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Enum1_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) {
Enum1_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Enum1_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) {
Enum1_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Enum1] >>> ***/
@ -127,7 +53,7 @@ static const unsigned int asn_MAP_Enum1_enum2value_1[] = {
0 /* red(0) */
/* This list is extensible */
};
static asn_INTEGER_specifics_t asn_SPC_Enum1_specs_1 = {
static const asn_INTEGER_specifics_t asn_SPC_Enum1_specs_1 = {
asn_MAP_Enum1_value2enum_1, /* "tag" => N; sorted by tag */
asn_MAP_Enum1_enum2value_1, /* N => "tag"; sorted by N */
4, /* Number of elements in the maps */
@ -142,13 +68,13 @@ static const ber_tlv_tag_t asn_DEF_Enum1_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Enum1 = {
"Enum1",
"Enum1",
Enum1_free,
Enum1_print,
Enum1_constraint,
Enum1_decode_ber,
Enum1_encode_der,
Enum1_decode_xer,
Enum1_encode_xer,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -201,84 +127,10 @@ xer_type_encoder_f Enum2_encode_xer;
/*** <<< CODE [Enum2] >>> ***/
int
Enum2_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
Enum2_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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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
Enum2_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Enum2_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Enum2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Enum2_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Enum2_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) {
Enum2_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Enum2_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) {
Enum2_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Enum2_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) {
Enum2_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Enum2_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) {
Enum2_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Enum2] >>> ***/
@ -302,7 +154,7 @@ static const unsigned int asn_MAP_Enum2_enum2value_1[] = {
0 /* red(0) */
/* This list is extensible */
};
static asn_INTEGER_specifics_t asn_SPC_Enum2_specs_1 = {
static const asn_INTEGER_specifics_t asn_SPC_Enum2_specs_1 = {
asn_MAP_Enum2_value2enum_1, /* "tag" => N; sorted by tag */
asn_MAP_Enum2_enum2value_1, /* N => "tag"; sorted by N */
7, /* Number of elements in the maps */
@ -317,13 +169,13 @@ static const ber_tlv_tag_t asn_DEF_Enum2_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Enum2 = {
"Enum2",
"Enum2",
Enum2_free,
Enum2_print,
Enum2_constraint,
Enum2_decode_ber,
Enum2_encode_der,
Enum2_decode_xer,
Enum2_encode_xer,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -372,84 +224,10 @@ xer_type_encoder_f Enum3_encode_xer;
/*** <<< CODE [Enum3] >>> ***/
int
Enum3_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
Enum3_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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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
Enum3_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Enum3_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Enum3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Enum3_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Enum3_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) {
Enum3_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Enum3_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) {
Enum3_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Enum3_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) {
Enum3_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Enum3_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) {
Enum3_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Enum3] >>> ***/
@ -465,7 +243,7 @@ static const unsigned int asn_MAP_Enum3_enum2value_1[] = {
1 /* c(1) */
/* This list is extensible */
};
static asn_INTEGER_specifics_t asn_SPC_Enum3_specs_1 = {
static const asn_INTEGER_specifics_t asn_SPC_Enum3_specs_1 = {
asn_MAP_Enum3_value2enum_1, /* "tag" => N; sorted by tag */
asn_MAP_Enum3_enum2value_1, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
@ -480,13 +258,13 @@ static const ber_tlv_tag_t asn_DEF_Enum3_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Enum3 = {
"Enum3",
"Enum3",
Enum3_free,
Enum3_print,
Enum3_constraint,
Enum3_decode_ber,
Enum3_encode_der,
Enum3_decode_xer,
Enum3_encode_xer,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -536,84 +314,10 @@ xer_type_encoder_f Enum4_encode_xer;
/*** <<< CODE [Enum4] >>> ***/
int
Enum4_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
Enum4_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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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
Enum4_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Enum4_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Enum4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Enum4_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Enum4_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) {
Enum4_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Enum4_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) {
Enum4_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Enum4_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) {
Enum4_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Enum4_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) {
Enum4_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Enum4] >>> ***/
@ -631,7 +335,7 @@ static const unsigned int asn_MAP_Enum4_enum2value_1[] = {
3 /* d(4) */
/* This list is extensible */
};
static asn_INTEGER_specifics_t asn_SPC_Enum4_specs_1 = {
static const asn_INTEGER_specifics_t asn_SPC_Enum4_specs_1 = {
asn_MAP_Enum4_value2enum_1, /* "tag" => N; sorted by tag */
asn_MAP_Enum4_enum2value_1, /* N => "tag"; sorted by N */
4, /* Number of elements in the maps */
@ -646,13 +350,13 @@ static const ber_tlv_tag_t asn_DEF_Enum4_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Enum4 = {
"Enum4",
"Enum4",
Enum4_free,
Enum4_print,
Enum4_constraint,
Enum4_decode_ber,
Enum4_encode_der,
Enum4_decode_xer,
Enum4_encode_xer,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -701,84 +405,10 @@ xer_type_encoder_f Enum5_encode_xer;
/*** <<< CODE [Enum5] >>> ***/
int
Enum5_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
Enum5_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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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
Enum5_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Enum5_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Enum5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Enum5_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Enum5_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) {
Enum5_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Enum5_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) {
Enum5_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Enum5_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) {
Enum5_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Enum5_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) {
Enum5_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Enum5] >>> ***/
@ -794,7 +424,7 @@ static const unsigned int asn_MAP_Enum5_enum2value_1[] = {
1 /* z(25) */
/* This list is extensible */
};
static asn_INTEGER_specifics_t asn_SPC_Enum5_specs_1 = {
static const asn_INTEGER_specifics_t asn_SPC_Enum5_specs_1 = {
asn_MAP_Enum5_value2enum_1, /* "tag" => N; sorted by tag */
asn_MAP_Enum5_enum2value_1, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
@ -809,13 +439,13 @@ static const ber_tlv_tag_t asn_DEF_Enum5_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Enum5 = {
"Enum5",
"Enum5",
Enum5_free,
Enum5_print,
Enum5_constraint,
Enum5_decode_ber,
Enum5_encode_der,
Enum5_decode_xer,
Enum5_encode_xer,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */

12
tests/104-param-1-OK.asn1.-Pfwide-types
View File

@ -24,11 +24,15 @@ typedef struct Collection_16P1 {
/*** <<< FUNC-DECLS [Collection] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Collection_16P0;
extern asn_SET_OF_specifics_t asn_SPC_Collection_16P0_specs_1;
extern asn_TYPE_member_t asn_MBR_Collection_16P0_1[1];
extern asn_TYPE_descriptor_t asn_DEF_Collection_16P1;
extern asn_SET_OF_specifics_t asn_SPC_Collection_16P1_specs_3;
extern asn_TYPE_member_t asn_MBR_Collection_16P1_3[1];
/*** <<< STAT-DEFS [Collection] >>> ***/
static asn_TYPE_member_t asn_MBR_Collection_16P0_1[] = {
asn_TYPE_member_t asn_MBR_Collection_16P0_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
.tag_mode = 0,
@ -43,7 +47,7 @@ static asn_TYPE_member_t asn_MBR_Collection_16P0_1[] = {
static const ber_tlv_tag_t asn_DEF_Collection_16P0_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_Collection_16P0_specs_1 = {
asn_SET_OF_specifics_t asn_SPC_Collection_16P0_specs_1 = {
sizeof(struct Collection_16P0),
offsetof(struct Collection_16P0, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -74,7 +78,7 @@ asn_TYPE_descriptor_t asn_DEF_Collection_16P0 = {
&asn_SPC_Collection_16P0_specs_1 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Collection_16P1_3[] = {
asn_TYPE_member_t asn_MBR_Collection_16P1_3[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
.tag_mode = 0,
@ -89,7 +93,7 @@ static asn_TYPE_member_t asn_MBR_Collection_16P1_3[] = {
static const ber_tlv_tag_t asn_DEF_Collection_16P1_tags_3[] = {
(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_Collection_16P1_specs_3 = {
asn_SET_OF_specifics_t asn_SPC_Collection_16P1_specs_3 = {
sizeof(struct Collection_16P1),
offsetof(struct Collection_16P1, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */

201
tests/105-param-2-OK.asn1.-Pfwide-types
View File

@ -43,11 +43,15 @@ typedef struct SIGNED_16P1 {
/*** <<< FUNC-DECLS [SIGNED] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SIGNED_16P0;
extern asn_SEQUENCE_specifics_t asn_SPC_SIGNED_16P0_specs_1;
extern asn_TYPE_member_t asn_MBR_SIGNED_16P0_1[1];
extern asn_TYPE_descriptor_t asn_DEF_SIGNED_16P1;
extern asn_SEQUENCE_specifics_t asn_SPC_SIGNED_16P1_specs_3;
extern asn_TYPE_member_t asn_MBR_SIGNED_16P1_3[1];
/*** <<< STAT-DEFS [SIGNED] >>> ***/
static asn_TYPE_member_t asn_MBR_SIGNED_16P0_1[] = {
asn_TYPE_member_t asn_MBR_SIGNED_16P0_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct SIGNED_16P0, Signed),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
.tag_mode = 0,
@ -65,7 +69,7 @@ static const ber_tlv_tag_t asn_DEF_SIGNED_16P0_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_SIGNED_16P0_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 0, 0, 0 } /* signed */
};
static asn_SEQUENCE_specifics_t asn_SPC_SIGNED_16P0_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_SIGNED_16P0_specs_1 = {
sizeof(struct SIGNED_16P0),
offsetof(struct SIGNED_16P0, _asn_ctx),
asn_MAP_SIGNED_16P0_tag2el_1,
@ -121,7 +125,8 @@ static const asn_TYPE_tag2member_t asn_MAP_signed_tag2el_4[] = {
static const uint8_t asn_MAP_signed_mmap_4[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_signed_specs_4 = {
static
asn_SET_specifics_t asn_SPC_signed_specs_4 = {
sizeof(struct Signed),
offsetof(struct Signed, _asn_ctx),
offsetof(struct Signed, _presence_map),
@ -159,7 +164,7 @@ asn_TYPE_descriptor_t asn_DEF_signed_4 = {
&asn_SPC_signed_specs_4 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_SIGNED_16P1_3[] = {
asn_TYPE_member_t asn_MBR_SIGNED_16P1_3[] = {
{ ATF_NOFLAGS, 0, offsetof(struct SIGNED_16P1, Signed),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
.tag_mode = 0,
@ -177,7 +182,7 @@ static const ber_tlv_tag_t asn_DEF_SIGNED_16P1_tags_3[] = {
static const asn_TYPE_tag2member_t asn_MAP_SIGNED_16P1_tag2el_3[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* signed */
};
static asn_SEQUENCE_specifics_t asn_SPC_SIGNED_16P1_specs_3 = {
asn_SEQUENCE_specifics_t asn_SPC_SIGNED_16P1_specs_3 = {
sizeof(struct SIGNED_16P1),
offsetof(struct SIGNED_16P1, _asn_ctx),
asn_MAP_SIGNED_16P1_tag2el_3,
@ -234,84 +239,10 @@ xer_type_encoder_f SignedREAL_encode_xer;
/*** <<< CODE [SignedREAL] >>> ***/
int
SignedREAL_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_SIGNED_16P0.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using SIGNED_16P0,
* so here we adjust the DEF accordingly.
*/
static void
SignedREAL_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_SIGNED_16P0.free_struct;
td->print_struct = asn_DEF_SIGNED_16P0.print_struct;
td->check_constraints = asn_DEF_SIGNED_16P0.check_constraints;
td->ber_decoder = asn_DEF_SIGNED_16P0.ber_decoder;
td->der_encoder = asn_DEF_SIGNED_16P0.der_encoder;
td->xer_decoder = asn_DEF_SIGNED_16P0.xer_decoder;
td->xer_encoder = asn_DEF_SIGNED_16P0.xer_encoder;
td->uper_decoder = asn_DEF_SIGNED_16P0.uper_decoder;
td->uper_encoder = asn_DEF_SIGNED_16P0.uper_encoder;
td->oer_decoder = asn_DEF_SIGNED_16P0.oer_decoder;
td->oer_encoder = asn_DEF_SIGNED_16P0.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_SIGNED_16P0.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_SIGNED_16P0.per_constraints;
td->elements = asn_DEF_SIGNED_16P0.elements;
td->elements_count = asn_DEF_SIGNED_16P0.elements_count;
td->specifics = asn_DEF_SIGNED_16P0.specifics;
}
void
SignedREAL_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
SignedREAL_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
SignedREAL_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
SignedREAL_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
SignedREAL_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) {
SignedREAL_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
SignedREAL_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) {
SignedREAL_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
SignedREAL_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) {
SignedREAL_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
SignedREAL_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) {
SignedREAL_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [SignedREAL] >>> ***/
@ -321,13 +252,13 @@ static const ber_tlv_tag_t asn_DEF_SignedREAL_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_SignedREAL = {
"SignedREAL",
"SignedREAL",
SignedREAL_free,
SignedREAL_print,
SignedREAL_constraint,
SignedREAL_decode_ber,
SignedREAL_encode_der,
SignedREAL_decode_xer,
SignedREAL_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -339,8 +270,9 @@ asn_TYPE_descriptor_t asn_DEF_SignedREAL = {
/sizeof(asn_DEF_SignedREAL_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_SIGNED_16P0_1,
1, /* Elements count */
&asn_SPC_SIGNED_16P0_specs_1 /* Additional specs */
};
@ -365,84 +297,10 @@ xer_type_encoder_f SignedSET_encode_xer;
/*** <<< CODE [SignedSET] >>> ***/
int
SignedSET_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_SIGNED_16P1.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using SIGNED_16P1,
* so here we adjust the DEF accordingly.
*/
static void
SignedSET_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_SIGNED_16P1.free_struct;
td->print_struct = asn_DEF_SIGNED_16P1.print_struct;
td->check_constraints = asn_DEF_SIGNED_16P1.check_constraints;
td->ber_decoder = asn_DEF_SIGNED_16P1.ber_decoder;
td->der_encoder = asn_DEF_SIGNED_16P1.der_encoder;
td->xer_decoder = asn_DEF_SIGNED_16P1.xer_decoder;
td->xer_encoder = asn_DEF_SIGNED_16P1.xer_encoder;
td->uper_decoder = asn_DEF_SIGNED_16P1.uper_decoder;
td->uper_encoder = asn_DEF_SIGNED_16P1.uper_encoder;
td->oer_decoder = asn_DEF_SIGNED_16P1.oer_decoder;
td->oer_encoder = asn_DEF_SIGNED_16P1.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_SIGNED_16P1.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_SIGNED_16P1.per_constraints;
td->elements = asn_DEF_SIGNED_16P1.elements;
td->elements_count = asn_DEF_SIGNED_16P1.elements_count;
td->specifics = asn_DEF_SIGNED_16P1.specifics;
}
void
SignedSET_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
SignedSET_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
SignedSET_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
SignedSET_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
SignedSET_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) {
SignedSET_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
SignedSET_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) {
SignedSET_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
SignedSET_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) {
SignedSET_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
SignedSET_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) {
SignedSET_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [SignedSET] >>> ***/
@ -452,13 +310,13 @@ static const ber_tlv_tag_t asn_DEF_SignedSET_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_SignedSET = {
"SignedSET",
"SignedSET",
SignedSET_free,
SignedSET_print,
SignedSET_constraint,
SignedSET_decode_ber,
SignedSET_encode_der,
SignedSET_decode_xer,
SignedSET_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -470,7 +328,8 @@ asn_TYPE_descriptor_t asn_DEF_SignedSET = {
/sizeof(asn_DEF_SignedSET_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_SIGNED_16P1_3,
1, /* Elements count */
&asn_SPC_SIGNED_16P1_specs_3 /* Additional specs */
};

99
tests/106-param-constr-OK.asn1.-P
View File

@ -18,6 +18,8 @@ typedef struct Narrow_15P0 {
/*** <<< FUNC-DECLS [Narrow] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Narrow_15P0;
extern asn_SEQUENCE_specifics_t asn_SPC_Narrow_15P0_specs_1;
extern asn_TYPE_member_t asn_MBR_Narrow_15P0_1[3];
/*** <<< CODE [Narrow] >>> ***/
@ -117,7 +119,7 @@ static int asn_DFL_2_set_3(int set_value, void **sptr) {
return (*st == 3);
}
}
static asn_TYPE_member_t asn_MBR_Narrow_15P0_1[] = {
asn_TYPE_member_t asn_MBR_Narrow_15P0_1[] = {
{ ATF_POINTER, 1, offsetof(struct Narrow_15P0, narrow1),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
.tag_mode = 0,
@ -157,7 +159,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Narrow_15P0_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 }, /* narrow2 */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 } /* narrow3 */
};
static asn_SEQUENCE_specifics_t asn_SPC_Narrow_15P0_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Narrow_15P0_specs_1 = {
sizeof(struct Narrow_15P0),
offsetof(struct Narrow_15P0, _asn_ctx),
asn_MAP_Narrow_15P0_tag2el_1,
@ -214,84 +216,10 @@ xer_type_encoder_f NarrowInteger_encode_xer;
/*** <<< CODE [NarrowInteger] >>> ***/
int
NarrowInteger_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_Narrow_15P0.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Narrow_15P0,
* so here we adjust the DEF accordingly.
*/
static void
NarrowInteger_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Narrow_15P0.free_struct;
td->print_struct = asn_DEF_Narrow_15P0.print_struct;
td->check_constraints = asn_DEF_Narrow_15P0.check_constraints;
td->ber_decoder = asn_DEF_Narrow_15P0.ber_decoder;
td->der_encoder = asn_DEF_Narrow_15P0.der_encoder;
td->xer_decoder = asn_DEF_Narrow_15P0.xer_decoder;
td->xer_encoder = asn_DEF_Narrow_15P0.xer_encoder;
td->uper_decoder = asn_DEF_Narrow_15P0.uper_decoder;
td->uper_encoder = asn_DEF_Narrow_15P0.uper_encoder;
td->oer_decoder = asn_DEF_Narrow_15P0.oer_decoder;
td->oer_encoder = asn_DEF_Narrow_15P0.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Narrow_15P0.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Narrow_15P0.per_constraints;
td->elements = asn_DEF_Narrow_15P0.elements;
td->elements_count = asn_DEF_Narrow_15P0.elements_count;
td->specifics = asn_DEF_Narrow_15P0.specifics;
}
void
NarrowInteger_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
NarrowInteger_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
NarrowInteger_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
NarrowInteger_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
NarrowInteger_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) {
NarrowInteger_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
NarrowInteger_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) {
NarrowInteger_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
NarrowInteger_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) {
NarrowInteger_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
NarrowInteger_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) {
NarrowInteger_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [NarrowInteger] >>> ***/
@ -301,13 +229,13 @@ static const ber_tlv_tag_t asn_DEF_NarrowInteger_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_NarrowInteger = {
"NarrowInteger",
"NarrowInteger",
NarrowInteger_free,
NarrowInteger_print,
NarrowInteger_constraint,
NarrowInteger_decode_ber,
NarrowInteger_encode_der,
NarrowInteger_decode_xer,
NarrowInteger_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -319,7 +247,8 @@ asn_TYPE_descriptor_t asn_DEF_NarrowInteger = {
/sizeof(asn_DEF_NarrowInteger_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Narrow_15P0_1,
3, /* Elements count */
&asn_SPC_Narrow_15P0_specs_1 /* Additional specs */
};

156
tests/108-param-constr-3-OK.asn1.-Pfwide-types
View File

@ -55,72 +55,6 @@ MinMax_16P0_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using INTEGER,
* so here we adjust the DEF accordingly.
*/
static void
MinMax_16P0_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_INTEGER.free_struct;
td->print_struct = asn_DEF_INTEGER.print_struct;
td->check_constraints = asn_DEF_INTEGER.check_constraints;
td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
td->der_encoder = asn_DEF_INTEGER.der_encoder;
td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
td->uper_decoder = asn_DEF_INTEGER.uper_decoder;
td->uper_encoder = asn_DEF_INTEGER.uper_encoder;
td->oer_decoder = asn_DEF_INTEGER.oer_decoder;
td->oer_encoder = asn_DEF_INTEGER.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_INTEGER.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_INTEGER.per_constraints;
td->elements = asn_DEF_INTEGER.elements;
td->elements_count = asn_DEF_INTEGER.elements_count;
td->specifics = asn_DEF_INTEGER.specifics;
}
void
MinMax_16P0_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
MinMax_16P0_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
MinMax_16P0_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
MinMax_16P0_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
MinMax_16P0_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) {
MinMax_16P0_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
MinMax_16P0_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) {
MinMax_16P0_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
MinMax_16P0_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) {
MinMax_16P0_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
MinMax_16P0_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) {
MinMax_16P0_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [MinMax] >>> ***/
@ -130,13 +64,13 @@ static const ber_tlv_tag_t asn_DEF_MinMax_16P0_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_MinMax_16P0 = {
"MinMax",
"MinMax",
MinMax_16P0_free,
MinMax_16P0_print,
INTEGER_free,
INTEGER_print,
MinMax_16P0_constraint,
MinMax_16P0_decode_ber,
MinMax_16P0_encode_der,
MinMax_16P0_decode_xer,
MinMax_16P0_encode_xer,
INTEGER_decode_ber,
INTEGER_encode_der,
INTEGER_decode_xer,
INTEGER_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -209,72 +143,6 @@ ThreePlus_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using MinMax_16P0,
* so here we adjust the DEF accordingly.
*/
static void
ThreePlus_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_MinMax_16P0.free_struct;
td->print_struct = asn_DEF_MinMax_16P0.print_struct;
td->check_constraints = asn_DEF_MinMax_16P0.check_constraints;
td->ber_decoder = asn_DEF_MinMax_16P0.ber_decoder;
td->der_encoder = asn_DEF_MinMax_16P0.der_encoder;
td->xer_decoder = asn_DEF_MinMax_16P0.xer_decoder;
td->xer_encoder = asn_DEF_MinMax_16P0.xer_encoder;
td->uper_decoder = asn_DEF_MinMax_16P0.uper_decoder;
td->uper_encoder = asn_DEF_MinMax_16P0.uper_encoder;
td->oer_decoder = asn_DEF_MinMax_16P0.oer_decoder;
td->oer_encoder = asn_DEF_MinMax_16P0.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_MinMax_16P0.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_MinMax_16P0.per_constraints;
td->elements = asn_DEF_MinMax_16P0.elements;
td->elements_count = asn_DEF_MinMax_16P0.elements_count;
td->specifics = asn_DEF_MinMax_16P0.specifics;
}
void
ThreePlus_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
ThreePlus_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
ThreePlus_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
ThreePlus_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
ThreePlus_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) {
ThreePlus_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
ThreePlus_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) {
ThreePlus_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
ThreePlus_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) {
ThreePlus_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
ThreePlus_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) {
ThreePlus_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [ThreePlus] >>> ***/
@ -284,13 +152,13 @@ static const ber_tlv_tag_t asn_DEF_ThreePlus_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_ThreePlus = {
"ThreePlus",
"ThreePlus",
ThreePlus_free,
ThreePlus_print,
INTEGER_free,
INTEGER_print,
ThreePlus_constraint,
ThreePlus_decode_ber,
ThreePlus_encode_der,
ThreePlus_decode_xer,
ThreePlus_encode_xer,
INTEGER_decode_ber,
INTEGER_encode_der,
INTEGER_decode_xer,
INTEGER_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */

288
tests/110-param-3-OK.asn1.-Pfwide-types
View File

@ -36,89 +36,19 @@ typedef struct Flag_16P1 {
/*** <<< FUNC-DECLS [Flag] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Flag_16P0;
extern asn_SEQUENCE_specifics_t asn_SPC_Flag_16P0_specs_1;
extern asn_TYPE_member_t asn_MBR_Flag_16P0_1[1];
/* extern asn_TYPE_descriptor_t asn_DEF_field_7; // (Use -fall-defs-global to expose) */
extern asn_TYPE_descriptor_t asn_DEF_Flag_16P1;
extern asn_SEQUENCE_specifics_t asn_SPC_Flag_16P1_specs_6;
extern asn_TYPE_member_t asn_MBR_Flag_16P1_6[1];
/*** <<< CODE [Flag] >>> ***/
static int
field_7_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
field_7_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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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
field_7_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
field_7_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
static int
field_7_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
field_7_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
static asn_dec_rval_t
field_7_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) {
field_7_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
static asn_enc_rval_t
field_7_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) {
field_7_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
static asn_dec_rval_t
field_7_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) {
field_7_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
static asn_enc_rval_t
field_7_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) {
field_7_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Flag] >>> ***/
@ -142,7 +72,7 @@ static int asn_DFL_2_set_5(int set_value, void **sptr) {
return (value == 5);
}
}
static asn_TYPE_member_t asn_MBR_Flag_16P0_1[] = {
asn_TYPE_member_t asn_MBR_Flag_16P0_1[] = {
{ ATF_POINTER, 1, offsetof(struct Flag_16P0, field),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
.tag_mode = 0,
@ -160,7 +90,7 @@ static const ber_tlv_tag_t asn_DEF_Flag_16P0_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_Flag_16P0_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* field */
};
static asn_SEQUENCE_specifics_t asn_SPC_Flag_16P0_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Flag_16P0_specs_1 = {
sizeof(struct Flag_16P0),
offsetof(struct Flag_16P0, _asn_ctx),
asn_MAP_Flag_16P0_tag2el_1,
@ -225,7 +155,7 @@ static const unsigned int asn_MAP_field_enum2value_7[] = {
1, /* green(4) */
0 /* red(3) */
};
static asn_INTEGER_specifics_t asn_SPC_field_specs_7 = {
static const asn_INTEGER_specifics_t asn_SPC_field_specs_7 = {
asn_MAP_field_value2enum_7, /* "tag" => N; sorted by tag */
asn_MAP_field_enum2value_7, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
@ -241,13 +171,13 @@ static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_field_7 = {
"field",
"field",
field_7_free,
field_7_print,
field_7_constraint,
field_7_decode_ber,
field_7_encode_der,
field_7_decode_xer,
field_7_encode_xer,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -263,7 +193,7 @@ asn_TYPE_descriptor_t asn_DEF_field_7 = {
&asn_SPC_field_specs_7 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Flag_16P1_6[] = {
asn_TYPE_member_t asn_MBR_Flag_16P1_6[] = {
{ ATF_POINTER, 1, offsetof(struct Flag_16P1, field),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
.tag_mode = 0,
@ -281,7 +211,7 @@ static const ber_tlv_tag_t asn_DEF_Flag_16P1_tags_6[] = {
static const asn_TYPE_tag2member_t asn_MAP_Flag_16P1_tag2el_6[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 0, 0, 0 } /* field */
};
static asn_SEQUENCE_specifics_t asn_SPC_Flag_16P1_specs_6 = {
asn_SEQUENCE_specifics_t asn_SPC_Flag_16P1_specs_6 = {
sizeof(struct Flag_16P1),
offsetof(struct Flag_16P1, _asn_ctx),
asn_MAP_Flag_16P1_tag2el_6,
@ -338,84 +268,10 @@ xer_type_encoder_f IntegerColorFlag_encode_xer;
/*** <<< CODE [IntegerColorFlag] >>> ***/
int
IntegerColorFlag_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_Flag_16P0.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Flag_16P0,
* so here we adjust the DEF accordingly.
*/
static void
IntegerColorFlag_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Flag_16P0.free_struct;
td->print_struct = asn_DEF_Flag_16P0.print_struct;
td->check_constraints = asn_DEF_Flag_16P0.check_constraints;
td->ber_decoder = asn_DEF_Flag_16P0.ber_decoder;
td->der_encoder = asn_DEF_Flag_16P0.der_encoder;
td->xer_decoder = asn_DEF_Flag_16P0.xer_decoder;
td->xer_encoder = asn_DEF_Flag_16P0.xer_encoder;
td->uper_decoder = asn_DEF_Flag_16P0.uper_decoder;
td->uper_encoder = asn_DEF_Flag_16P0.uper_encoder;
td->oer_decoder = asn_DEF_Flag_16P0.oer_decoder;
td->oer_encoder = asn_DEF_Flag_16P0.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Flag_16P0.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Flag_16P0.per_constraints;
td->elements = asn_DEF_Flag_16P0.elements;
td->elements_count = asn_DEF_Flag_16P0.elements_count;
td->specifics = asn_DEF_Flag_16P0.specifics;
}
void
IntegerColorFlag_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
IntegerColorFlag_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
IntegerColorFlag_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
IntegerColorFlag_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
IntegerColorFlag_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) {
IntegerColorFlag_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
IntegerColorFlag_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) {
IntegerColorFlag_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
IntegerColorFlag_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) {
IntegerColorFlag_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
IntegerColorFlag_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) {
IntegerColorFlag_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [IntegerColorFlag] >>> ***/
@ -425,13 +281,13 @@ static const ber_tlv_tag_t asn_DEF_IntegerColorFlag_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_IntegerColorFlag = {
"IntegerColorFlag",
"IntegerColorFlag",
IntegerColorFlag_free,
IntegerColorFlag_print,
IntegerColorFlag_constraint,
IntegerColorFlag_decode_ber,
IntegerColorFlag_encode_der,
IntegerColorFlag_decode_xer,
IntegerColorFlag_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -443,8 +299,9 @@ asn_TYPE_descriptor_t asn_DEF_IntegerColorFlag = {
/sizeof(asn_DEF_IntegerColorFlag_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Flag_16P0_1,
1, /* Elements count */
&asn_SPC_Flag_16P0_specs_1 /* Additional specs */
};
@ -469,84 +326,10 @@ xer_type_encoder_f EnumeratedColorFlag_encode_xer;
/*** <<< CODE [EnumeratedColorFlag] >>> ***/
int
EnumeratedColorFlag_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_Flag_16P1.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Flag_16P1,
* so here we adjust the DEF accordingly.
*/
static void
EnumeratedColorFlag_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Flag_16P1.free_struct;
td->print_struct = asn_DEF_Flag_16P1.print_struct;
td->check_constraints = asn_DEF_Flag_16P1.check_constraints;
td->ber_decoder = asn_DEF_Flag_16P1.ber_decoder;
td->der_encoder = asn_DEF_Flag_16P1.der_encoder;
td->xer_decoder = asn_DEF_Flag_16P1.xer_decoder;
td->xer_encoder = asn_DEF_Flag_16P1.xer_encoder;
td->uper_decoder = asn_DEF_Flag_16P1.uper_decoder;
td->uper_encoder = asn_DEF_Flag_16P1.uper_encoder;
td->oer_decoder = asn_DEF_Flag_16P1.oer_decoder;
td->oer_encoder = asn_DEF_Flag_16P1.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Flag_16P1.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Flag_16P1.per_constraints;
td->elements = asn_DEF_Flag_16P1.elements;
td->elements_count = asn_DEF_Flag_16P1.elements_count;
td->specifics = asn_DEF_Flag_16P1.specifics;
}
void
EnumeratedColorFlag_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
EnumeratedColorFlag_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
EnumeratedColorFlag_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
EnumeratedColorFlag_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
EnumeratedColorFlag_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) {
EnumeratedColorFlag_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
EnumeratedColorFlag_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) {
EnumeratedColorFlag_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
EnumeratedColorFlag_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) {
EnumeratedColorFlag_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
EnumeratedColorFlag_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) {
EnumeratedColorFlag_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [EnumeratedColorFlag] >>> ***/
@ -556,13 +339,13 @@ static const ber_tlv_tag_t asn_DEF_EnumeratedColorFlag_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_EnumeratedColorFlag = {
"EnumeratedColorFlag",
"EnumeratedColorFlag",
EnumeratedColorFlag_free,
EnumeratedColorFlag_print,
EnumeratedColorFlag_constraint,
EnumeratedColorFlag_decode_ber,
EnumeratedColorFlag_encode_der,
EnumeratedColorFlag_decode_xer,
EnumeratedColorFlag_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -574,7 +357,8 @@ asn_TYPE_descriptor_t asn_DEF_EnumeratedColorFlag = {
/sizeof(asn_DEF_EnumeratedColorFlag_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Flag_16P1_6,
1, /* Elements count */
&asn_SPC_Flag_16P1_specs_6 /* Additional specs */
};

6
tests/119-per-strings-OK.asn1.-Pgen-PER
View File

@ -65,6 +65,8 @@ typedef struct PDU {
/*** <<< FUNC-DECLS [PDU] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_PDU;
extern asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1;
extern asn_TYPE_member_t asn_MBR_PDU_1[31];
/*** <<< POST-INCLUDE [PDU] >>> ***/
@ -1230,7 +1232,7 @@ asn_TYPE_descriptor_t asn_DEF_many_2 = {
&asn_SPC_many_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_PDU_1[] = {
asn_TYPE_member_t asn_MBR_PDU_1[] = {
{ ATF_POINTER, 31, offsetof(struct PDU, many),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = 0,
@ -1579,7 +1581,7 @@ static const asn_TYPE_tag2member_t asn_MAP_PDU_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (29 << 2)), 29, 0, 0 }, /* real */
{ (ASN_TAG_CLASS_CONTEXT | (30 << 2)), 30, 0, 0 } /* oid */
};
static asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1 = {
sizeof(struct PDU),
offsetof(struct PDU, _asn_ctx),
asn_MAP_PDU_tag2el_1,

80
tests/125-bitstring-constraint-OK.asn1.-P
View File

@ -55,72 +55,6 @@ T_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using BIT_STRING,
* so here we adjust the DEF accordingly.
*/
static void
T_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_BIT_STRING.free_struct;
td->print_struct = asn_DEF_BIT_STRING.print_struct;
td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
td->ber_decoder = asn_DEF_BIT_STRING.ber_decoder;
td->der_encoder = asn_DEF_BIT_STRING.der_encoder;
td->xer_decoder = asn_DEF_BIT_STRING.xer_decoder;
td->xer_encoder = asn_DEF_BIT_STRING.xer_encoder;
td->uper_decoder = asn_DEF_BIT_STRING.uper_decoder;
td->uper_encoder = asn_DEF_BIT_STRING.uper_encoder;
td->oer_decoder = asn_DEF_BIT_STRING.oer_decoder;
td->oer_encoder = asn_DEF_BIT_STRING.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_BIT_STRING.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
td->elements = asn_DEF_BIT_STRING.elements;
td->elements_count = asn_DEF_BIT_STRING.elements_count;
td->specifics = asn_DEF_BIT_STRING.specifics;
}
void
T_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T] >>> ***/
@ -130,13 +64,13 @@ static const ber_tlv_tag_t asn_DEF_T_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T = {
"T",
"T",
T_free,
T_print,
BIT_STRING_free,
BIT_STRING_print,
T_constraint,
T_decode_ber,
T_encode_der,
T_decode_xer,
T_encode_xer,
BIT_STRING_decode_ber,
BIT_STRING_encode_der,
BIT_STRING_decode_xer,
BIT_STRING_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -149,6 +83,6 @@ asn_TYPE_descriptor_t asn_DEF_T = {
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
&asn_SPC_BIT_STRING_specs /* Additional specs */
};

15
tests/126-per-extensions-OK.asn1.-Pgen-PER
View File

@ -143,6 +143,8 @@ typedef struct Singleton {
/*** <<< FUNC-DECLS [Singleton] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Singleton;
extern asn_SEQUENCE_specifics_t asn_SPC_Singleton_specs_1;
extern asn_TYPE_member_t asn_MBR_Singleton_1[1];
/*** <<< STAT-DEFS [Singleton] >>> ***/
@ -172,7 +174,7 @@ static int asn_DFL_2_set(int set_value, void **sptr) {
}
}
static asn_TYPE_member_t asn_MBR_Singleton_1[] = {
asn_TYPE_member_t asn_MBR_Singleton_1[] = {
{ ATF_POINTER, 1, offsetof(struct Singleton, opt_z),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -191,7 +193,7 @@ static const ber_tlv_tag_t asn_DEF_Singleton_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_Singleton_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* opt-z */
};
static asn_SEQUENCE_specifics_t asn_SPC_Singleton_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Singleton_specs_1 = {
sizeof(struct Singleton),
offsetof(struct Singleton, _asn_ctx),
asn_MAP_Singleton_tag2el_1,
@ -265,10 +267,13 @@ typedef struct PDU_2 {
/*** <<< FUNC-DECLS [PDU-2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_PDU_2;
extern asn_CHOICE_specifics_t asn_SPC_PDU_2_specs_1;
extern asn_TYPE_member_t asn_MBR_PDU_2_1[3];
extern asn_per_constraints_t asn_PER_type_PDU_2_constr_1;
/*** <<< CTDEFS [PDU-2] >>> ***/
static asn_per_constraints_t asn_PER_type_PDU_2_constr_1 GCC_NOTUSED = {
asn_per_constraints_t asn_PER_type_PDU_2_constr_1 GCC_NOTUSED = {
{ APC_CONSTRAINED | APC_EXTENSIBLE, 0, 0, 0, 0 } /* (0..0,...) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
@ -276,7 +281,7 @@ static asn_per_constraints_t asn_PER_type_PDU_2_constr_1 GCC_NOTUSED = {
/*** <<< STAT-DEFS [PDU-2] >>> ***/
static asn_TYPE_member_t asn_MBR_PDU_2_1[] = {
asn_TYPE_member_t asn_MBR_PDU_2_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct PDU_2, choice.main),
.tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -314,7 +319,7 @@ static const asn_TYPE_tag2member_t asn_MAP_PDU_2_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ext1 */
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 0 } /* main */
};
static asn_CHOICE_specifics_t asn_SPC_PDU_2_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_PDU_2_specs_1 = {
sizeof(struct PDU_2),
offsetof(struct PDU_2, _asn_ctx),
offsetof(struct PDU_2, present),

198
tests/127-per-long-OK.asn1.-Pgen-PER
View File

@ -44,87 +44,6 @@ unsigned32_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
unsigned32_4_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
td->check_constraints = asn_DEF_NativeInteger.check_constraints;
td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
td->der_encoder = asn_DEF_NativeInteger.der_encoder;
td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeInteger.per_constraints;
td->elements = asn_DEF_NativeInteger.elements;
td->elements_count = asn_DEF_NativeInteger.elements_count;
/* td->specifics = asn_DEF_NativeInteger.specifics; // Defined explicitly */
}
static void
unsigned32_4_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
unsigned32_4_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
static int
unsigned32_4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
unsigned32_4_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
static asn_dec_rval_t
unsigned32_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) {
unsigned32_4_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
static asn_enc_rval_t
unsigned32_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) {
unsigned32_4_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
static asn_dec_rval_t
unsigned32_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) {
unsigned32_4_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
static asn_enc_rval_t
unsigned32_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) {
unsigned32_4_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
static asn_dec_rval_t
unsigned32_4_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
unsigned32_4_inherit_TYPE_descriptor(td);
return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
}
static asn_enc_rval_t
unsigned32_4_encode_uper(asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints,
void *structure, asn_per_outp_t *per_out) {
unsigned32_4_inherit_TYPE_descriptor(td);
return td->uper_encoder(td, constraints, structure, per_out);
}
static int
unsplit32_5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
@ -154,87 +73,6 @@ unsplit32_5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
unsplit32_5_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
td->check_constraints = asn_DEF_NativeInteger.check_constraints;
td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
td->der_encoder = asn_DEF_NativeInteger.der_encoder;
td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeInteger.per_constraints;
td->elements = asn_DEF_NativeInteger.elements;
td->elements_count = asn_DEF_NativeInteger.elements_count;
/* td->specifics = asn_DEF_NativeInteger.specifics; // Defined explicitly */
}
static void
unsplit32_5_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
unsplit32_5_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
static int
unsplit32_5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
unsplit32_5_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
static asn_dec_rval_t
unsplit32_5_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) {
unsplit32_5_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
static asn_enc_rval_t
unsplit32_5_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) {
unsplit32_5_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
static asn_dec_rval_t
unsplit32_5_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) {
unsplit32_5_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
static asn_enc_rval_t
unsplit32_5_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) {
unsplit32_5_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
static asn_dec_rval_t
unsplit32_5_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
unsplit32_5_inherit_TYPE_descriptor(td);
return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
}
static asn_enc_rval_t
unsplit32_5_encode_uper(asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints,
void *structure, asn_per_outp_t *per_out) {
unsplit32_5_inherit_TYPE_descriptor(td);
return td->uper_encoder(td, constraints, structure, per_out);
}
static int
memb_small32range_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
@ -362,7 +200,7 @@ static asn_per_constraints_t asn_PER_memb_unsplit32_constr_5 GCC_NOTUSED = {
/*** <<< STAT-DEFS [T] >>> ***/
static asn_INTEGER_specifics_t asn_SPC_unsigned32_specs_4 = {
static const asn_INTEGER_specifics_t asn_SPC_unsigned32_specs_4 = {
0, 0, 0, 0, 0,
0, /* Native long size */
1 /* Unsigned representation */
@ -375,16 +213,16 @@ static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_unsigned32_4 = {
"unsigned32",
"unsigned32",
unsigned32_4_free,
unsigned32_4_print,
NativeInteger_free,
NativeInteger_print,
unsigned32_4_constraint,
unsigned32_4_decode_ber,
unsigned32_4_encode_der,
unsigned32_4_decode_xer,
unsigned32_4_encode_xer,
NativeInteger_decode_ber,
NativeInteger_encode_der,
NativeInteger_decode_xer,
NativeInteger_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
unsigned32_4_decode_uper,
unsigned32_4_encode_uper,
NativeInteger_decode_uper,
NativeInteger_encode_uper,
0, /* Use generic outmost tag fetcher */
asn_DEF_unsigned32_tags_4,
sizeof(asn_DEF_unsigned32_tags_4)
@ -398,7 +236,7 @@ asn_TYPE_descriptor_t asn_DEF_unsigned32_4 = {
&asn_SPC_unsigned32_specs_4 /* Additional specs */
};
static asn_INTEGER_specifics_t asn_SPC_unsplit32_specs_5 = {
static const asn_INTEGER_specifics_t asn_SPC_unsplit32_specs_5 = {
0, 0, 0, 0, 0,
0, /* Native long size */
1 /* Unsigned representation */
@ -411,16 +249,16 @@ static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_unsplit32_5 = {
"unsplit32",
"unsplit32",
unsplit32_5_free,
unsplit32_5_print,
NativeInteger_free,
NativeInteger_print,
unsplit32_5_constraint,
unsplit32_5_decode_ber,
unsplit32_5_encode_der,
unsplit32_5_decode_xer,
unsplit32_5_encode_xer,
NativeInteger_decode_ber,
NativeInteger_encode_der,
NativeInteger_decode_xer,
NativeInteger_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
unsplit32_5_decode_uper,
unsplit32_5_encode_uper,
NativeInteger_decode_uper,
NativeInteger_encode_uper,
0, /* Use generic outmost tag fetcher */
asn_DEF_unsplit32_tags_5,
sizeof(asn_DEF_unsplit32_tags_5)

1465
tests/138-oer-constraints-OK.asn1.-Pgen-OER
View File

File diff suppressed because it is too large Load Diff

111
tests/19-param-OK.asn1.-Pfwide-types
View File

@ -28,6 +28,8 @@ typedef struct SIGNED_15P0 {
/*** <<< FUNC-DECLS [SIGNED] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SIGNED_15P0;
extern asn_SEQUENCE_specifics_t asn_SPC_SIGNED_15P0_specs_1;
extern asn_TYPE_member_t asn_MBR_SIGNED_15P0_1[3];
/*** <<< CODE [SIGNED] >>> ***/
@ -141,7 +143,7 @@ asn_TYPE_descriptor_t asn_DEF_toBeSigned_2 = {
&asn_SPC_toBeSigned_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_SIGNED_15P0_1[] = {
asn_TYPE_member_t asn_MBR_SIGNED_15P0_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct SIGNED_15P0, toBeSigned),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
@ -181,7 +183,7 @@ static const asn_TYPE_tag2member_t asn_MAP_SIGNED_15P0_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 1, 0, 0 }, /* algorithm */
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* toBeSigned */
};
static asn_SEQUENCE_specifics_t asn_SPC_SIGNED_15P0_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_SIGNED_15P0_specs_1 = {
sizeof(struct SIGNED_15P0),
offsetof(struct SIGNED_15P0, _asn_ctx),
asn_MAP_SIGNED_15P0_tag2el_1,
@ -238,84 +240,10 @@ xer_type_encoder_f Certificate_encode_xer;
/*** <<< CODE [Certificate] >>> ***/
int
Certificate_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_SIGNED_15P0.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using SIGNED_15P0,
* so here we adjust the DEF accordingly.
*/
static void
Certificate_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_SIGNED_15P0.free_struct;
td->print_struct = asn_DEF_SIGNED_15P0.print_struct;
td->check_constraints = asn_DEF_SIGNED_15P0.check_constraints;
td->ber_decoder = asn_DEF_SIGNED_15P0.ber_decoder;
td->der_encoder = asn_DEF_SIGNED_15P0.der_encoder;
td->xer_decoder = asn_DEF_SIGNED_15P0.xer_decoder;
td->xer_encoder = asn_DEF_SIGNED_15P0.xer_encoder;
td->uper_decoder = asn_DEF_SIGNED_15P0.uper_decoder;
td->uper_encoder = asn_DEF_SIGNED_15P0.uper_encoder;
td->oer_decoder = asn_DEF_SIGNED_15P0.oer_decoder;
td->oer_encoder = asn_DEF_SIGNED_15P0.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_SIGNED_15P0.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_SIGNED_15P0.per_constraints;
td->elements = asn_DEF_SIGNED_15P0.elements;
td->elements_count = asn_DEF_SIGNED_15P0.elements_count;
td->specifics = asn_DEF_SIGNED_15P0.specifics;
}
void
Certificate_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Certificate_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Certificate_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Certificate_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Certificate_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) {
Certificate_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Certificate_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) {
Certificate_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Certificate_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) {
Certificate_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Certificate_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) {
Certificate_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Certificate] >>> ***/
@ -325,13 +253,13 @@ static const ber_tlv_tag_t asn_DEF_Certificate_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Certificate = {
"Certificate",
"Certificate",
Certificate_free,
Certificate_print,
Certificate_constraint,
Certificate_decode_ber,
Certificate_encode_der,
Certificate_decode_xer,
Certificate_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -343,8 +271,9 @@ asn_TYPE_descriptor_t asn_DEF_Certificate = {
/sizeof(asn_DEF_Certificate_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_SIGNED_15P0_1,
3, /* Elements count */
&asn_SPC_SIGNED_15P0_specs_1 /* Additional specs */
};
@ -369,6 +298,8 @@ typedef struct Name {
/*** <<< FUNC-DECLS [Name] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Name;
extern asn_SET_OF_specifics_t asn_SPC_Name_specs_1;
extern asn_TYPE_member_t asn_MBR_Name_1[1];
/*** <<< POST-INCLUDE [Name] >>> ***/
@ -376,7 +307,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Name;
/*** <<< STAT-DEFS [Name] >>> ***/
static asn_TYPE_member_t asn_MBR_Name_1[] = {
asn_TYPE_member_t asn_MBR_Name_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
.tag_mode = 0,
@ -391,7 +322,7 @@ static asn_TYPE_member_t asn_MBR_Name_1[] = {
static const ber_tlv_tag_t asn_DEF_Name_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_Name_specs_1 = {
asn_SET_OF_specifics_t asn_SPC_Name_specs_1 = {
sizeof(struct Name),
offsetof(struct Name, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -441,6 +372,8 @@ typedef struct RelativeDistinguishedName {
/*** <<< FUNC-DECLS [RelativeDistinguishedName] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_RelativeDistinguishedName;
extern asn_SET_OF_specifics_t asn_SPC_RelativeDistinguishedName_specs_1;
extern asn_TYPE_member_t asn_MBR_RelativeDistinguishedName_1[1];
/*** <<< CTABLES [RelativeDistinguishedName] >>> ***/
@ -499,7 +432,7 @@ memb_IA5String_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/*** <<< STAT-DEFS [RelativeDistinguishedName] >>> ***/
static asn_TYPE_member_t asn_MBR_RelativeDistinguishedName_1[] = {
asn_TYPE_member_t asn_MBR_RelativeDistinguishedName_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
.tag_mode = 0,
@ -514,7 +447,7 @@ static asn_TYPE_member_t asn_MBR_RelativeDistinguishedName_1[] = {
static const ber_tlv_tag_t asn_DEF_RelativeDistinguishedName_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_RelativeDistinguishedName_specs_1 = {
asn_SET_OF_specifics_t asn_SPC_RelativeDistinguishedName_specs_1 = {
sizeof(struct RelativeDistinguishedName),
offsetof(struct RelativeDistinguishedName, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */

3
tests/30-set-OK.asn1.-Pfwide-types
View File

@ -86,7 +86,8 @@ static const asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
static const uint8_t asn_MAP_T_mmap_1[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7) | (1 << 6) | (0 << 5)
};
static asn_SET_specifics_t asn_SPC_T_specs_1 = {
static
asn_SET_specifics_t asn_SPC_T_specs_1 = {
sizeof(struct T),
offsetof(struct T, _asn_ctx),
offsetof(struct T, _presence_map),

15
tests/31-set-of-OK.asn1.-Pfwide-types
View File

@ -20,6 +20,8 @@ typedef struct Forest {
/*** <<< FUNC-DECLS [Forest] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Forest;
extern asn_SET_OF_specifics_t asn_SPC_Forest_specs_1;
extern asn_TYPE_member_t asn_MBR_Forest_1[1];
/*** <<< POST-INCLUDE [Forest] >>> ***/
@ -27,7 +29,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Forest;
/*** <<< STAT-DEFS [Forest] >>> ***/
static asn_TYPE_member_t asn_MBR_Forest_1[] = {
asn_TYPE_member_t asn_MBR_Forest_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
@ -42,7 +44,7 @@ static asn_TYPE_member_t asn_MBR_Forest_1[] = {
static const ber_tlv_tag_t asn_DEF_Forest_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_Forest_specs_1 = {
asn_SET_OF_specifics_t asn_SPC_Forest_specs_1 = {
sizeof(struct Forest),
offsetof(struct Forest, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -92,10 +94,12 @@ typedef struct Tree {
/*** <<< FUNC-DECLS [Tree] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Tree;
extern asn_SEQUENCE_specifics_t asn_SPC_Tree_specs_1;
extern asn_TYPE_member_t asn_MBR_Tree_1[2];
/*** <<< STAT-DEFS [Tree] >>> ***/
static asn_TYPE_member_t asn_MBR_Tree_1[] = {
asn_TYPE_member_t asn_MBR_Tree_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Tree, height),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
.tag_mode = 0,
@ -124,7 +128,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Tree_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 1 }, /* height */
{ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, -1, 0 } /* width */
};
static asn_SEQUENCE_specifics_t asn_SPC_Tree_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Tree_specs_1 = {
sizeof(struct Tree),
offsetof(struct Tree, _asn_ctx),
asn_MAP_Tree_tag2el_1,
@ -512,7 +516,8 @@ static const asn_TYPE_tag2member_t asn_MAP_Stuff_tag2el_cxer_1[] = {
static const uint8_t asn_MAP_Stuff_mmap_1[(3 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(0 << 7) | (0 << 6) | (0 << 5)
};
static asn_SET_specifics_t asn_SPC_Stuff_specs_1 = {
static
asn_SET_specifics_t asn_SPC_Stuff_specs_1 = {
sizeof(struct Stuff),
offsetof(struct Stuff, _asn_ctx),
offsetof(struct Stuff, _presence_map),

9
tests/32-sequence-of-OK.asn1.-P
View File

@ -95,6 +95,8 @@ typedef struct Fault {
/*** <<< FUNC-DECLS [Fault] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Fault;
extern asn_SET_OF_specifics_t asn_SPC_Fault_specs_1;
extern asn_TYPE_member_t asn_MBR_Fault_1[1];
/*** <<< POST-INCLUDE [Fault] >>> ***/
@ -102,7 +104,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Fault;
/*** <<< STAT-DEFS [Fault] >>> ***/
static asn_TYPE_member_t asn_MBR_Fault_1[] = {
asn_TYPE_member_t asn_MBR_Fault_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
@ -117,7 +119,7 @@ static asn_TYPE_member_t asn_MBR_Fault_1[] = {
static const ber_tlv_tag_t asn_DEF_Fault_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_Fault_specs_1 = {
asn_SET_OF_specifics_t asn_SPC_Fault_specs_1 = {
sizeof(struct Fault),
offsetof(struct Fault, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -168,13 +170,14 @@ typedef struct Error {
/*** <<< FUNC-DECLS [Error] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Error;
extern asn_SEQUENCE_specifics_t asn_SPC_Error_specs_1;
/*** <<< STAT-DEFS [Error] >>> ***/
static const ber_tlv_tag_t asn_DEF_Error_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static asn_SEQUENCE_specifics_t asn_SPC_Error_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Error_specs_1 = {
sizeof(struct Error),
offsetof(struct Error, _asn_ctx),
0, /* No top level tags */

384
tests/37-indirect-choice-OK.asn1.-Pfwide-types
View File

@ -151,10 +151,12 @@ typedef struct Choice1 {
/*** <<< FUNC-DECLS [Choice1] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice1;
extern asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice1_1[2];
/*** <<< STAT-DEFS [Choice1] >>> ***/
static asn_TYPE_member_t asn_MBR_Choice1_1[] = {
asn_TYPE_member_t asn_MBR_Choice1_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Choice1, choice.c_a),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
.tag_mode = 0,
@ -180,7 +182,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice1_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, 0, 0 }, /* c-b */
{ (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 0, 0, 0 } /* c-a */
};
static asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
sizeof(struct Choice1),
offsetof(struct Choice1, _asn_ctx),
offsetof(struct Choice1, present),
@ -250,10 +252,12 @@ typedef struct Choice2 {
/*** <<< FUNC-DECLS [Choice2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice2;
extern asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice2_1[4];
/*** <<< STAT-DEFS [Choice2] >>> ***/
static asn_TYPE_member_t asn_MBR_Choice2_1[] = {
asn_TYPE_member_t asn_MBR_Choice2_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Choice2, choice.c_a),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
.tag_mode = 0,
@ -304,7 +308,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* c-d */
{ (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* c-e */
};
static asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
sizeof(struct Choice2),
offsetof(struct Choice2, _asn_ctx),
offsetof(struct Choice2, present),
@ -362,84 +366,10 @@ xer_type_encoder_f Choice3_encode_xer;
/*** <<< CODE [Choice3] >>> ***/
int
Choice3_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_Choice2.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Choice2,
* so here we adjust the DEF accordingly.
*/
static void
Choice3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Choice2.free_struct;
td->print_struct = asn_DEF_Choice2.print_struct;
td->check_constraints = asn_DEF_Choice2.check_constraints;
td->ber_decoder = asn_DEF_Choice2.ber_decoder;
td->der_encoder = asn_DEF_Choice2.der_encoder;
td->xer_decoder = asn_DEF_Choice2.xer_decoder;
td->xer_encoder = asn_DEF_Choice2.xer_encoder;
td->uper_decoder = asn_DEF_Choice2.uper_decoder;
td->uper_encoder = asn_DEF_Choice2.uper_encoder;
td->oer_decoder = asn_DEF_Choice2.oer_decoder;
td->oer_encoder = asn_DEF_Choice2.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Choice2.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Choice2.per_constraints;
td->elements = asn_DEF_Choice2.elements;
td->elements_count = asn_DEF_Choice2.elements_count;
td->specifics = asn_DEF_Choice2.specifics;
}
void
Choice3_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Choice3_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Choice3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Choice3_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Choice3_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) {
Choice3_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Choice3_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) {
Choice3_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Choice3_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) {
Choice3_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Choice3_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) {
Choice3_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Choice3] >>> ***/
@ -450,13 +380,13 @@ static const ber_tlv_tag_t asn_DEF_Choice3_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Choice3 = {
"Choice3",
"Choice3",
Choice3_free,
Choice3_print,
Choice3_constraint,
Choice3_decode_ber,
Choice3_encode_der,
Choice3_decode_xer,
Choice3_encode_xer,
CHOICE_free,
CHOICE_print,
CHOICE_constraint,
CHOICE_decode_ber,
CHOICE_encode_der,
CHOICE_decode_xer,
CHOICE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
CHOICE_outmost_tag,
@ -468,8 +398,9 @@ asn_TYPE_descriptor_t asn_DEF_Choice3 = {
/sizeof(asn_DEF_Choice3_tags_1[0]), /* 2 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Choice2_1,
4, /* Elements count */
&asn_SPC_Choice2_specs_1 /* Additional specs */
};
@ -494,84 +425,10 @@ xer_type_encoder_f Choice4_encode_xer;
/*** <<< CODE [Choice4] >>> ***/
int
Choice4_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_Choice2.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Choice2,
* so here we adjust the DEF accordingly.
*/
static void
Choice4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Choice2.free_struct;
td->print_struct = asn_DEF_Choice2.print_struct;
td->check_constraints = asn_DEF_Choice2.check_constraints;
td->ber_decoder = asn_DEF_Choice2.ber_decoder;
td->der_encoder = asn_DEF_Choice2.der_encoder;
td->xer_decoder = asn_DEF_Choice2.xer_decoder;
td->xer_encoder = asn_DEF_Choice2.xer_encoder;
td->uper_decoder = asn_DEF_Choice2.uper_decoder;
td->uper_encoder = asn_DEF_Choice2.uper_encoder;
td->oer_decoder = asn_DEF_Choice2.oer_decoder;
td->oer_encoder = asn_DEF_Choice2.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Choice2.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Choice2.per_constraints;
td->elements = asn_DEF_Choice2.elements;
td->elements_count = asn_DEF_Choice2.elements_count;
td->specifics = asn_DEF_Choice2.specifics;
}
void
Choice4_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Choice4_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Choice4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Choice4_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Choice4_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) {
Choice4_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Choice4_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) {
Choice4_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Choice4_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) {
Choice4_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Choice4_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) {
Choice4_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Choice4] >>> ***/
@ -582,13 +439,13 @@ static const ber_tlv_tag_t asn_DEF_Choice4_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Choice4 = {
"Choice4",
"Choice4",
Choice4_free,
Choice4_print,
Choice4_constraint,
Choice4_decode_ber,
Choice4_encode_der,
Choice4_decode_xer,
Choice4_encode_xer,
CHOICE_free,
CHOICE_print,
CHOICE_constraint,
CHOICE_decode_ber,
CHOICE_encode_der,
CHOICE_decode_xer,
CHOICE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
CHOICE_outmost_tag,
@ -600,8 +457,9 @@ asn_TYPE_descriptor_t asn_DEF_Choice4 = {
/sizeof(asn_DEF_Choice4_tags_1[0]), /* 2 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Choice2_1,
4, /* Elements count */
&asn_SPC_Choice2_specs_1 /* Additional specs */
};
@ -626,84 +484,10 @@ xer_type_encoder_f Choice5_encode_xer;
/*** <<< CODE [Choice5] >>> ***/
int
Choice5_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_Choice2.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Choice2,
* so here we adjust the DEF accordingly.
*/
static void
Choice5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Choice2.free_struct;
td->print_struct = asn_DEF_Choice2.print_struct;
td->check_constraints = asn_DEF_Choice2.check_constraints;
td->ber_decoder = asn_DEF_Choice2.ber_decoder;
td->der_encoder = asn_DEF_Choice2.der_encoder;
td->xer_decoder = asn_DEF_Choice2.xer_decoder;
td->xer_encoder = asn_DEF_Choice2.xer_encoder;
td->uper_decoder = asn_DEF_Choice2.uper_decoder;
td->uper_encoder = asn_DEF_Choice2.uper_encoder;
td->oer_decoder = asn_DEF_Choice2.oer_decoder;
td->oer_encoder = asn_DEF_Choice2.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Choice2.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Choice2.per_constraints;
td->elements = asn_DEF_Choice2.elements;
td->elements_count = asn_DEF_Choice2.elements_count;
td->specifics = asn_DEF_Choice2.specifics;
}
void
Choice5_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Choice5_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Choice5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Choice5_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Choice5_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) {
Choice5_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Choice5_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) {
Choice5_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Choice5_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) {
Choice5_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Choice5_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) {
Choice5_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Choice5] >>> ***/
@ -713,13 +497,13 @@ static const ber_tlv_tag_t asn_DEF_Choice5_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_Choice5 = {
"Choice5",
"Choice5",
Choice5_free,
Choice5_print,
Choice5_constraint,
Choice5_decode_ber,
Choice5_encode_der,
Choice5_decode_xer,
Choice5_encode_xer,
CHOICE_free,
CHOICE_print,
CHOICE_constraint,
CHOICE_decode_ber,
CHOICE_encode_der,
CHOICE_decode_xer,
CHOICE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
CHOICE_outmost_tag,
@ -731,8 +515,9 @@ asn_TYPE_descriptor_t asn_DEF_Choice5 = {
/sizeof(asn_DEF_Choice5_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Choice2_1,
4, /* Elements count */
&asn_SPC_Choice2_specs_1 /* Additional specs */
};
@ -757,97 +542,23 @@ xer_type_encoder_f Choice6_encode_xer;
/*** <<< CODE [Choice6] >>> ***/
int
Choice6_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_Choice1.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Choice1,
* so here we adjust the DEF accordingly.
*/
static void
Choice6_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Choice1.free_struct;
td->print_struct = asn_DEF_Choice1.print_struct;
td->check_constraints = asn_DEF_Choice1.check_constraints;
td->ber_decoder = asn_DEF_Choice1.ber_decoder;
td->der_encoder = asn_DEF_Choice1.der_encoder;
td->xer_decoder = asn_DEF_Choice1.xer_decoder;
td->xer_encoder = asn_DEF_Choice1.xer_encoder;
td->uper_decoder = asn_DEF_Choice1.uper_decoder;
td->uper_encoder = asn_DEF_Choice1.uper_encoder;
td->oer_decoder = asn_DEF_Choice1.oer_decoder;
td->oer_encoder = asn_DEF_Choice1.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Choice1.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Choice1.per_constraints;
td->elements = asn_DEF_Choice1.elements;
td->elements_count = asn_DEF_Choice1.elements_count;
td->specifics = asn_DEF_Choice1.specifics;
}
void
Choice6_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
Choice6_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
Choice6_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
Choice6_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
Choice6_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) {
Choice6_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
Choice6_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) {
Choice6_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
Choice6_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) {
Choice6_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
Choice6_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) {
Choice6_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [Choice6] >>> ***/
asn_TYPE_descriptor_t asn_DEF_Choice6 = {
"Choice6",
"Choice6",
Choice6_free,
Choice6_print,
Choice6_constraint,
Choice6_decode_ber,
Choice6_encode_der,
Choice6_decode_xer,
Choice6_encode_xer,
CHOICE_free,
CHOICE_print,
CHOICE_constraint,
CHOICE_decode_ber,
CHOICE_encode_der,
CHOICE_decode_xer,
CHOICE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
CHOICE_outmost_tag,
@ -857,7 +568,8 @@ asn_TYPE_descriptor_t asn_DEF_Choice6 = {
0, /* No tags (count) */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Choice1_1,
2, /* Elements count */
&asn_SPC_Choice1_specs_1 /* Additional specs */
};

6
tests/39-sequence-of-OK.asn1.-Pfwide-types
View File

@ -166,10 +166,12 @@ typedef struct T2 {
/*** <<< FUNC-DECLS [T2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_T2;
extern asn_SEQUENCE_specifics_t asn_SPC_T2_specs_1;
extern asn_TYPE_member_t asn_MBR_T2_1[2];
/*** <<< STAT-DEFS [T2] >>> ***/
static asn_TYPE_member_t asn_MBR_T2_1[] = {
asn_TYPE_member_t asn_MBR_T2_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct T2, flag),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
.tag_mode = 0,
@ -198,7 +200,7 @@ static const asn_TYPE_tag2member_t asn_MAP_T2_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 0, 0, 0 }, /* flag */
{ (ASN_TAG_CLASS_UNIVERSAL | (12 << 2)), 1, 0, 0 } /* str */
};
static asn_SEQUENCE_specifics_t asn_SPC_T2_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_T2_specs_1 = {
sizeof(struct T2),
offsetof(struct T2, _asn_ctx),
asn_MAP_T2_tag2el_1,

108
tests/42-real-life-OK.asn1.-PR
View File

@ -213,6 +213,8 @@ typedef struct VariablePartSet {
/*** <<< FUNC-DECLS [VariablePartSet] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_VariablePartSet;
extern asn_SEQUENCE_specifics_t asn_SPC_VariablePartSet_specs_1;
extern asn_TYPE_member_t asn_MBR_VariablePartSet_1[2];
/*** <<< POST-INCLUDE [VariablePartSet] >>> ***/
@ -289,7 +291,7 @@ asn_TYPE_descriptor_t asn_DEF_vparts_2 = {
&asn_SPC_vparts_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_VariablePartSet_1[] = {
asn_TYPE_member_t asn_MBR_VariablePartSet_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct VariablePartSet, vparts),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
@ -318,7 +320,7 @@ static const asn_TYPE_tag2member_t asn_MAP_VariablePartSet_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* vparts */
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* resolution */
};
static asn_SEQUENCE_specifics_t asn_SPC_VariablePartSet_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_VariablePartSet_specs_1 = {
sizeof(struct VariablePartSet),
offsetof(struct VariablePartSet, _asn_ctx),
asn_MAP_VariablePartSet_tag2el_1,
@ -407,6 +409,8 @@ typedef struct VariablePart {
/*** <<< FUNC-DECLS [VariablePart] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_VariablePart;
extern asn_CHOICE_specifics_t asn_SPC_VariablePart_specs_1;
extern asn_TYPE_member_t asn_MBR_VariablePart_1[2];
/*** <<< CODE [VariablePart] >>> ***/
@ -551,7 +555,7 @@ asn_TYPE_descriptor_t asn_DEF_vrange_4 = {
&asn_SPC_vrange_specs_4 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_VariablePart_1[] = {
asn_TYPE_member_t asn_MBR_VariablePart_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct VariablePart, choice.vset),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
.tag_mode = 0,
@ -577,7 +581,7 @@ static const asn_TYPE_tag2member_t asn_MAP_VariablePart_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* vrange */
{ (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* vset */
};
static asn_CHOICE_specifics_t asn_SPC_VariablePart_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_VariablePart_specs_1 = {
sizeof(struct VariablePart),
offsetof(struct VariablePart, _asn_ctx),
offsetof(struct VariablePart, present),
@ -665,87 +669,15 @@ typedef struct ActionItem {
/* extern asn_TYPE_descriptor_t asn_DEF_accept_as_2; // (Use -fall-defs-global to expose) */
extern asn_TYPE_descriptor_t asn_DEF_ActionItem;
extern asn_SEQUENCE_specifics_t asn_SPC_ActionItem_specs_1;
extern asn_TYPE_member_t asn_MBR_ActionItem_1[2];
/*** <<< CODE [ActionItem] >>> ***/
static int
accept_as_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_NativeEnumerated.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using NativeEnumerated,
* so here we adjust the DEF accordingly.
*/
static void
accept_as_2_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeEnumerated.free_struct;
td->print_struct = asn_DEF_NativeEnumerated.print_struct;
td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
td->ber_decoder = asn_DEF_NativeEnumerated.ber_decoder;
td->der_encoder = asn_DEF_NativeEnumerated.der_encoder;
td->xer_decoder = asn_DEF_NativeEnumerated.xer_decoder;
td->xer_encoder = asn_DEF_NativeEnumerated.xer_encoder;
td->uper_decoder = asn_DEF_NativeEnumerated.uper_decoder;
td->uper_encoder = asn_DEF_NativeEnumerated.uper_encoder;
td->oer_decoder = asn_DEF_NativeEnumerated.oer_decoder;
td->oer_encoder = asn_DEF_NativeEnumerated.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeEnumerated.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
td->elements = asn_DEF_NativeEnumerated.elements;
td->elements_count = asn_DEF_NativeEnumerated.elements_count;
/* td->specifics = asn_DEF_NativeEnumerated.specifics; // Defined explicitly */
}
static void
accept_as_2_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
accept_as_2_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
static int
accept_as_2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
accept_as_2_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
static asn_dec_rval_t
accept_as_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) {
accept_as_2_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
static asn_enc_rval_t
accept_as_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) {
accept_as_2_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
static asn_dec_rval_t
accept_as_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) {
accept_as_2_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
static asn_enc_rval_t
accept_as_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) {
accept_as_2_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [ActionItem] >>> ***/
@ -761,7 +693,7 @@ static const unsigned int asn_MAP_accept_as_enum2value_2[] = {
2 /* unsafe(2) */
/* This list is extensible */
};
static asn_INTEGER_specifics_t asn_SPC_accept_as_specs_2 = {
static const asn_INTEGER_specifics_t asn_SPC_accept_as_specs_2 = {
asn_MAP_accept_as_value2enum_2, /* "tag" => N; sorted by tag */
asn_MAP_accept_as_enum2value_2, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
@ -777,13 +709,13 @@ static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_accept_as_2 = {
"accept-as",
"accept-as",
accept_as_2_free,
accept_as_2_print,
accept_as_2_constraint,
accept_as_2_decode_ber,
accept_as_2_encode_der,
accept_as_2_decode_xer,
accept_as_2_encode_xer,
NativeEnumerated_free,
NativeEnumerated_print,
NativeEnumerated_constraint,
NativeEnumerated_decode_ber,
NativeEnumerated_encode_der,
NativeEnumerated_decode_xer,
NativeEnumerated_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -911,7 +843,7 @@ asn_TYPE_descriptor_t asn_DEF_notify_7 = {
&asn_SPC_notify_specs_7 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_ActionItem_1[] = {
asn_TYPE_member_t asn_MBR_ActionItem_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct ActionItem, accept_as),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
.tag_mode = 0,
@ -940,7 +872,7 @@ static const asn_TYPE_tag2member_t asn_MAP_ActionItem_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 0, 0, 0 }, /* accept-as */
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 } /* notify */
};
static asn_SEQUENCE_specifics_t asn_SPC_ActionItem_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_ActionItem_specs_1 = {
sizeof(struct ActionItem),
offsetof(struct ActionItem, _asn_ctx),
asn_MAP_ActionItem_tag2el_1,

24
tests/43-recursion-OK.asn1.-Pfwide-types
View File

@ -37,6 +37,8 @@ typedef struct Test_structure_1 {
/*** <<< FUNC-DECLS [Test-structure-1] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Test_structure_1;
extern asn_SEQUENCE_specifics_t asn_SPC_Test_structure_1_specs_1;
extern asn_TYPE_member_t asn_MBR_Test_structure_1_1[4];
/*** <<< POST-INCLUDE [Test-structure-1] >>> ***/
@ -138,7 +140,7 @@ asn_TYPE_descriptor_t asn_DEF_t_member2_4 = {
&asn_SPC_t_member2_specs_4 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Test_structure_1_1[] = {
asn_TYPE_member_t asn_MBR_Test_structure_1_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Test_structure_1, t_member1),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
.tag_mode = 0,
@ -189,7 +191,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Test_structure_1_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 }, /* t-member3 */
{ (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* t-member1 */
};
static asn_SEQUENCE_specifics_t asn_SPC_Test_structure_1_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Test_structure_1_specs_1 = {
sizeof(struct Test_structure_1),
offsetof(struct Test_structure_1, _asn_ctx),
asn_MAP_Test_structure_1_tag2el_1,
@ -269,6 +271,8 @@ typedef struct Choice_1 {
/*** <<< FUNC-DECLS [Choice-1] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice_1;
extern asn_CHOICE_specifics_t asn_SPC_Choice_1_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice_1_1[4];
/*** <<< POST-INCLUDE [Choice-1] >>> ***/
@ -324,7 +328,7 @@ asn_TYPE_descriptor_t asn_DEF_or_3 = {
&asn_SPC_or_specs_3 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Choice_1_1[] = {
asn_TYPE_member_t asn_MBR_Choice_1_1[] = {
{ ATF_POINTER, 0, offsetof(struct Choice_1, choice.And),
.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
.tag_mode = +1, /* EXPLICIT tag at current level */
@ -372,7 +376,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice_1_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* not */
{ (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* other */
};
static asn_CHOICE_specifics_t asn_SPC_Choice_1_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice_1_specs_1 = {
sizeof(struct Choice_1),
offsetof(struct Choice_1, _asn_ctx),
offsetof(struct Choice_1, present),
@ -441,6 +445,8 @@ typedef struct Test_structure_2 {
/*** <<< FUNC-DECLS [Test-structure-2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Test_structure_2;
extern asn_SET_specifics_t asn_SPC_Test_structure_2_specs_1;
extern asn_TYPE_member_t asn_MBR_Test_structure_2_1[1];
/*** <<< POST-INCLUDE [Test-structure-2] >>> ***/
@ -448,7 +454,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Test_structure_2;
/*** <<< STAT-DEFS [Test-structure-2] >>> ***/
static asn_TYPE_member_t asn_MBR_Test_structure_2_1[] = {
asn_TYPE_member_t asn_MBR_Test_structure_2_1[] = {
{ ATF_POINTER, 1, offsetof(struct Test_structure_2, m1),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
.tag_mode = 0,
@ -469,7 +475,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Test_structure_2_tag2el_1[] = {
static const uint8_t asn_MAP_Test_structure_2_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(0 << 7)
};
static asn_SET_specifics_t asn_SPC_Test_structure_2_specs_1 = {
asn_SET_specifics_t asn_SPC_Test_structure_2_specs_1 = {
sizeof(struct Test_structure_2),
offsetof(struct Test_structure_2, _asn_ctx),
offsetof(struct Test_structure_2, _presence_map),
@ -541,6 +547,8 @@ typedef struct Test_structure_3 {
/*** <<< FUNC-DECLS [Test-structure-3] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Test_structure_3;
extern asn_SET_specifics_t asn_SPC_Test_structure_3_specs_1;
extern asn_TYPE_member_t asn_MBR_Test_structure_3_1[1];
/*** <<< POST-INCLUDE [Test-structure-3] >>> ***/
@ -548,7 +556,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Test_structure_3;
/*** <<< STAT-DEFS [Test-structure-3] >>> ***/
static asn_TYPE_member_t asn_MBR_Test_structure_3_1[] = {
asn_TYPE_member_t asn_MBR_Test_structure_3_1[] = {
{ ATF_POINTER, 1, offsetof(struct Test_structure_3, m1),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
.tag_mode = 0,
@ -569,7 +577,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Test_structure_3_tag2el_1[] = {
static const uint8_t asn_MAP_Test_structure_3_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(0 << 7)
};
static asn_SET_specifics_t asn_SPC_Test_structure_3_specs_1 = {
asn_SET_specifics_t asn_SPC_Test_structure_3_specs_1 = {
sizeof(struct Test_structure_3),
offsetof(struct Test_structure_3, _asn_ctx),
offsetof(struct Test_structure_3, _presence_map),

189
tests/46-redefine-OK.asn1.-PR
View File

@ -20,84 +20,10 @@ xer_type_encoder_f PrimitiveType_encode_xer;
/*** <<< CODE [PrimitiveType] >>> ***/
int
PrimitiveType_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_OCTET_STRING.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using OCTET_STRING,
* so here we adjust the DEF accordingly.
*/
static void
PrimitiveType_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_OCTET_STRING.free_struct;
td->print_struct = asn_DEF_OCTET_STRING.print_struct;
td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
td->ber_decoder = asn_DEF_OCTET_STRING.ber_decoder;
td->der_encoder = asn_DEF_OCTET_STRING.der_encoder;
td->xer_decoder = asn_DEF_OCTET_STRING.xer_decoder;
td->xer_encoder = asn_DEF_OCTET_STRING.xer_encoder;
td->uper_decoder = asn_DEF_OCTET_STRING.uper_decoder;
td->uper_encoder = asn_DEF_OCTET_STRING.uper_encoder;
td->oer_decoder = asn_DEF_OCTET_STRING.oer_decoder;
td->oer_encoder = asn_DEF_OCTET_STRING.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_OCTET_STRING.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
td->elements = asn_DEF_OCTET_STRING.elements;
td->elements_count = asn_DEF_OCTET_STRING.elements_count;
td->specifics = asn_DEF_OCTET_STRING.specifics;
}
void
PrimitiveType_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
PrimitiveType_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
PrimitiveType_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
PrimitiveType_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
PrimitiveType_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) {
PrimitiveType_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
PrimitiveType_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) {
PrimitiveType_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
PrimitiveType_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) {
PrimitiveType_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
PrimitiveType_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) {
PrimitiveType_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [PrimitiveType] >>> ***/
@ -107,13 +33,13 @@ static const ber_tlv_tag_t asn_DEF_PrimitiveType_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_PrimitiveType = {
"PrimitiveType",
"PrimitiveType",
PrimitiveType_free,
PrimitiveType_print,
PrimitiveType_constraint,
PrimitiveType_decode_ber,
PrimitiveType_encode_der,
PrimitiveType_decode_xer,
PrimitiveType_encode_xer,
OCTET_STRING_free,
OCTET_STRING_print,
OCTET_STRING_constraint,
OCTET_STRING_decode_ber,
OCTET_STRING_encode_der,
OCTET_STRING_decode_xer,
OCTET_STRING_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -126,7 +52,7 @@ asn_TYPE_descriptor_t asn_DEF_PrimitiveType = {
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* No members */
0 /* No specifics */
&asn_SPC_OCTET_STRING_specs /* Additional specs */
};
@ -147,10 +73,12 @@ typedef struct ConstructedType {
/*** <<< FUNC-DECLS [ConstructedType] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_ConstructedType;
extern asn_SEQUENCE_specifics_t asn_SPC_ConstructedType_specs_1;
extern asn_TYPE_member_t asn_MBR_ConstructedType_1[1];
/*** <<< STAT-DEFS [ConstructedType] >>> ***/
static asn_TYPE_member_t asn_MBR_ConstructedType_1[] = {
asn_TYPE_member_t asn_MBR_ConstructedType_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct ConstructedType, field),
.tag = (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -168,7 +96,7 @@ static const ber_tlv_tag_t asn_DEF_ConstructedType_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_ConstructedType_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 0, 0, 0 } /* field */
};
static asn_SEQUENCE_specifics_t asn_SPC_ConstructedType_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_ConstructedType_specs_1 = {
sizeof(struct ConstructedType),
offsetof(struct ConstructedType, _asn_ctx),
asn_MAP_ConstructedType_tag2el_1,
@ -225,84 +153,10 @@ xer_type_encoder_f T_encode_xer;
/*** <<< CODE [T] >>> ***/
int
T_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_ConstructedType.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using ConstructedType,
* so here we adjust the DEF accordingly.
*/
static void
T_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_ConstructedType.free_struct;
td->print_struct = asn_DEF_ConstructedType.print_struct;
td->check_constraints = asn_DEF_ConstructedType.check_constraints;
td->ber_decoder = asn_DEF_ConstructedType.ber_decoder;
td->der_encoder = asn_DEF_ConstructedType.der_encoder;
td->xer_decoder = asn_DEF_ConstructedType.xer_decoder;
td->xer_encoder = asn_DEF_ConstructedType.xer_encoder;
td->uper_decoder = asn_DEF_ConstructedType.uper_decoder;
td->uper_encoder = asn_DEF_ConstructedType.uper_encoder;
td->oer_decoder = asn_DEF_ConstructedType.oer_decoder;
td->oer_encoder = asn_DEF_ConstructedType.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ConstructedType.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_ConstructedType.per_constraints;
td->elements = asn_DEF_ConstructedType.elements;
td->elements_count = asn_DEF_ConstructedType.elements_count;
td->specifics = asn_DEF_ConstructedType.specifics;
}
void
T_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T] >>> ***/
@ -313,13 +167,13 @@ static const ber_tlv_tag_t asn_DEF_T_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T = {
"T",
"T",
T_free,
T_print,
T_constraint,
T_decode_ber,
T_encode_der,
T_decode_xer,
T_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -331,7 +185,8 @@ asn_TYPE_descriptor_t asn_DEF_T = {
/sizeof(asn_DEF_T_tags_1[0]), /* 2 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_ConstructedType_1,
1, /* Elements count */
&asn_SPC_ConstructedType_specs_1 /* Additional specs */
};

6
tests/47-set-ext-OK.asn1.-Pfwide-types
View File

@ -58,7 +58,8 @@ static const asn_TYPE_tag2member_t asn_MAP_T1_tag2el_1[] = {
static const uint8_t asn_MAP_T1_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_T1_specs_1 = {
static
asn_SET_specifics_t asn_SPC_T1_specs_1 = {
sizeof(struct T1),
offsetof(struct T1, _asn_ctx),
offsetof(struct T1, _presence_map),
@ -155,7 +156,8 @@ static const asn_TYPE_tag2member_t asn_MAP_T2_tag2el_1[] = {
static const uint8_t asn_MAP_T2_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_T2_specs_1 = {
static
asn_SET_specifics_t asn_SPC_T2_specs_1 = {
sizeof(struct T2),
offsetof(struct T2, _asn_ctx),
offsetof(struct T2, _presence_map),

2168
tests/50-constraint-OK.asn1.-Pfwide-types
View File

File diff suppressed because it is too large Load Diff

2705
tests/50-constraint-OK.asn1.-Pgen-PER
View File

File diff suppressed because it is too large Load Diff

6
tests/59-choice-extended-OK.asn1.-Pfwide-types
View File

@ -39,6 +39,8 @@ typedef struct Choice {
/*** <<< FUNC-DECLS [Choice] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice;
extern asn_CHOICE_specifics_t asn_SPC_Choice_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice_1[3];
/*** <<< POST-INCLUDE [Choice] >>> ***/
@ -46,7 +48,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Choice;
/*** <<< STAT-DEFS [Choice] >>> ***/
static asn_TYPE_member_t asn_MBR_Choice_1[] = {
asn_TYPE_member_t asn_MBR_Choice_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Choice, choice.a),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -86,7 +88,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* b */
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* c */
};
static asn_CHOICE_specifics_t asn_SPC_Choice_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice_specs_1 = {
sizeof(struct Choice),
offsetof(struct Choice, _asn_ctx),
offsetof(struct Choice, present),

627
tests/65-multi-tag-OK.asn1.-Pfnative-types
View File

@ -20,84 +20,10 @@ xer_type_encoder_f T1_encode_xer;
/*** <<< CODE [T1] >>> ***/
int
T1_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_T2.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T2,
* so here we adjust the DEF accordingly.
*/
static void
T1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T2.free_struct;
td->print_struct = asn_DEF_T2.print_struct;
td->check_constraints = asn_DEF_T2.check_constraints;
td->ber_decoder = asn_DEF_T2.ber_decoder;
td->der_encoder = asn_DEF_T2.der_encoder;
td->xer_decoder = asn_DEF_T2.xer_decoder;
td->xer_encoder = asn_DEF_T2.xer_encoder;
td->uper_decoder = asn_DEF_T2.uper_decoder;
td->uper_encoder = asn_DEF_T2.uper_encoder;
td->oer_decoder = asn_DEF_T2.oer_decoder;
td->oer_encoder = asn_DEF_T2.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T2.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T2.per_constraints;
td->elements = asn_DEF_T2.elements;
td->elements_count = asn_DEF_T2.elements_count;
td->specifics = asn_DEF_T2.specifics;
}
void
T1_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T1_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T1_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T1] >>> ***/
@ -118,13 +44,13 @@ static const ber_tlv_tag_t asn_DEF_T1_all_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T1 = {
"T1",
"T1",
T1_free,
T1_print,
T1_constraint,
T1_decode_ber,
T1_encode_der,
T1_decode_xer,
T1_encode_xer,
NativeReal_free,
NativeReal_print,
NativeReal_constraint,
NativeReal_decode_ber,
NativeReal_encode_der,
NativeReal_decode_xer,
NativeReal_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -162,84 +88,10 @@ xer_type_encoder_f T2_encode_xer;
/*** <<< CODE [T2] >>> ***/
int
T2_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_T3.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T3,
* so here we adjust the DEF accordingly.
*/
static void
T2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T3.free_struct;
td->print_struct = asn_DEF_T3.print_struct;
td->check_constraints = asn_DEF_T3.check_constraints;
td->ber_decoder = asn_DEF_T3.ber_decoder;
td->der_encoder = asn_DEF_T3.der_encoder;
td->xer_decoder = asn_DEF_T3.xer_decoder;
td->xer_encoder = asn_DEF_T3.xer_encoder;
td->uper_decoder = asn_DEF_T3.uper_decoder;
td->uper_encoder = asn_DEF_T3.uper_encoder;
td->oer_decoder = asn_DEF_T3.oer_decoder;
td->oer_encoder = asn_DEF_T3.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T3.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T3.per_constraints;
td->elements = asn_DEF_T3.elements;
td->elements_count = asn_DEF_T3.elements_count;
td->specifics = asn_DEF_T3.specifics;
}
void
T2_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T2_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T2_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T2] >>> ***/
@ -258,13 +110,13 @@ static const ber_tlv_tag_t asn_DEF_T2_all_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T2 = {
"T2",
"T2",
T2_free,
T2_print,
T2_constraint,
T2_decode_ber,
T2_encode_der,
T2_decode_xer,
T2_encode_xer,
NativeReal_free,
NativeReal_print,
NativeReal_constraint,
NativeReal_decode_ber,
NativeReal_encode_der,
NativeReal_decode_xer,
NativeReal_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -302,84 +154,10 @@ xer_type_encoder_f T3_encode_xer;
/*** <<< CODE [T3] >>> ***/
int
T3_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_T4.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T4,
* so here we adjust the DEF accordingly.
*/
static void
T3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T4.free_struct;
td->print_struct = asn_DEF_T4.print_struct;
td->check_constraints = asn_DEF_T4.check_constraints;
td->ber_decoder = asn_DEF_T4.ber_decoder;
td->der_encoder = asn_DEF_T4.der_encoder;
td->xer_decoder = asn_DEF_T4.xer_decoder;
td->xer_encoder = asn_DEF_T4.xer_encoder;
td->uper_decoder = asn_DEF_T4.uper_decoder;
td->uper_encoder = asn_DEF_T4.uper_encoder;
td->oer_decoder = asn_DEF_T4.oer_decoder;
td->oer_encoder = asn_DEF_T4.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T4.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T4.per_constraints;
td->elements = asn_DEF_T4.elements;
td->elements_count = asn_DEF_T4.elements_count;
td->specifics = asn_DEF_T4.specifics;
}
void
T3_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T3_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T3_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T3] >>> ***/
@ -396,13 +174,13 @@ static const ber_tlv_tag_t asn_DEF_T3_all_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T3 = {
"T3",
"T3",
T3_free,
T3_print,
T3_constraint,
T3_decode_ber,
T3_encode_der,
T3_decode_xer,
T3_encode_xer,
NativeReal_free,
NativeReal_print,
NativeReal_constraint,
NativeReal_decode_ber,
NativeReal_encode_der,
NativeReal_decode_xer,
NativeReal_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -440,84 +218,10 @@ xer_type_encoder_f T4_encode_xer;
/*** <<< CODE [T4] >>> ***/
int
T4_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_T5.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T5,
* so here we adjust the DEF accordingly.
*/
static void
T4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T5.free_struct;
td->print_struct = asn_DEF_T5.print_struct;
td->check_constraints = asn_DEF_T5.check_constraints;
td->ber_decoder = asn_DEF_T5.ber_decoder;
td->der_encoder = asn_DEF_T5.der_encoder;
td->xer_decoder = asn_DEF_T5.xer_decoder;
td->xer_encoder = asn_DEF_T5.xer_encoder;
td->uper_decoder = asn_DEF_T5.uper_decoder;
td->uper_encoder = asn_DEF_T5.uper_encoder;
td->oer_decoder = asn_DEF_T5.oer_decoder;
td->oer_encoder = asn_DEF_T5.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T5.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T5.per_constraints;
td->elements = asn_DEF_T5.elements;
td->elements_count = asn_DEF_T5.elements_count;
td->specifics = asn_DEF_T5.specifics;
}
void
T4_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T4_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T4_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T4] >>> ***/
@ -529,13 +233,13 @@ static const ber_tlv_tag_t asn_DEF_T4_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T4 = {
"T4",
"T4",
T4_free,
T4_print,
T4_constraint,
T4_decode_ber,
T4_encode_der,
T4_decode_xer,
T4_encode_xer,
NativeReal_free,
NativeReal_print,
NativeReal_constraint,
NativeReal_decode_ber,
NativeReal_encode_der,
NativeReal_decode_xer,
NativeReal_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -573,84 +277,10 @@ xer_type_encoder_f T5_encode_xer;
/*** <<< CODE [T5] >>> ***/
int
T5_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_T6.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T6,
* so here we adjust the DEF accordingly.
*/
static void
T5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T6.free_struct;
td->print_struct = asn_DEF_T6.print_struct;
td->check_constraints = asn_DEF_T6.check_constraints;
td->ber_decoder = asn_DEF_T6.ber_decoder;
td->der_encoder = asn_DEF_T6.der_encoder;
td->xer_decoder = asn_DEF_T6.xer_decoder;
td->xer_encoder = asn_DEF_T6.xer_encoder;
td->uper_decoder = asn_DEF_T6.uper_decoder;
td->uper_encoder = asn_DEF_T6.uper_encoder;
td->oer_decoder = asn_DEF_T6.oer_decoder;
td->oer_encoder = asn_DEF_T6.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T6.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T6.per_constraints;
td->elements = asn_DEF_T6.elements;
td->elements_count = asn_DEF_T6.elements_count;
td->specifics = asn_DEF_T6.specifics;
}
void
T5_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T5_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T5_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T5] >>> ***/
@ -661,13 +291,13 @@ static const ber_tlv_tag_t asn_DEF_T5_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T5 = {
"T5",
"T5",
T5_free,
T5_print,
T5_constraint,
T5_decode_ber,
T5_encode_der,
T5_decode_xer,
T5_encode_xer,
NativeReal_free,
NativeReal_print,
NativeReal_constraint,
NativeReal_decode_ber,
NativeReal_encode_der,
NativeReal_decode_xer,
NativeReal_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -705,84 +335,10 @@ xer_type_encoder_f T6_encode_xer;
/*** <<< CODE [T6] >>> ***/
int
T6_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_NativeReal.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using NativeReal,
* so here we adjust the DEF accordingly.
*/
static void
T6_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeReal.free_struct;
td->print_struct = asn_DEF_NativeReal.print_struct;
td->check_constraints = asn_DEF_NativeReal.check_constraints;
td->ber_decoder = asn_DEF_NativeReal.ber_decoder;
td->der_encoder = asn_DEF_NativeReal.der_encoder;
td->xer_decoder = asn_DEF_NativeReal.xer_decoder;
td->xer_encoder = asn_DEF_NativeReal.xer_encoder;
td->uper_decoder = asn_DEF_NativeReal.uper_decoder;
td->uper_encoder = asn_DEF_NativeReal.uper_encoder;
td->oer_decoder = asn_DEF_NativeReal.oer_decoder;
td->oer_encoder = asn_DEF_NativeReal.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeReal.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeReal.per_constraints;
td->elements = asn_DEF_NativeReal.elements;
td->elements_count = asn_DEF_NativeReal.elements_count;
td->specifics = asn_DEF_NativeReal.specifics;
}
void
T6_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T6_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T6_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T6_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T6] >>> ***/
@ -792,13 +348,13 @@ static const ber_tlv_tag_t asn_DEF_T6_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T6 = {
"T6",
"T6",
T6_free,
T6_print,
T6_constraint,
T6_decode_ber,
T6_encode_der,
T6_decode_xer,
T6_encode_xer,
NativeReal_free,
NativeReal_print,
NativeReal_constraint,
NativeReal_decode_ber,
NativeReal_encode_der,
NativeReal_decode_xer,
NativeReal_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -836,84 +392,10 @@ xer_type_encoder_f T_encode_xer;
/*** <<< CODE [T] >>> ***/
int
T_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_Ts.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Ts,
* so here we adjust the DEF accordingly.
*/
static void
T_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Ts.free_struct;
td->print_struct = asn_DEF_Ts.print_struct;
td->check_constraints = asn_DEF_Ts.check_constraints;
td->ber_decoder = asn_DEF_Ts.ber_decoder;
td->der_encoder = asn_DEF_Ts.der_encoder;
td->xer_decoder = asn_DEF_Ts.xer_decoder;
td->xer_encoder = asn_DEF_Ts.xer_encoder;
td->uper_decoder = asn_DEF_Ts.uper_decoder;
td->uper_encoder = asn_DEF_Ts.uper_encoder;
td->oer_decoder = asn_DEF_Ts.oer_decoder;
td->oer_encoder = asn_DEF_Ts.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Ts.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Ts.per_constraints;
td->elements = asn_DEF_Ts.elements;
td->elements_count = asn_DEF_Ts.elements_count;
td->specifics = asn_DEF_Ts.specifics;
}
void
T_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T] >>> ***/
@ -925,13 +407,13 @@ static const ber_tlv_tag_t asn_DEF_T_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T = {
"T",
"T",
T_free,
T_print,
T_constraint,
T_decode_ber,
T_encode_der,
T_decode_xer,
T_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -943,8 +425,9 @@ asn_TYPE_descriptor_t asn_DEF_T = {
/sizeof(asn_DEF_T_tags_1[0]), /* 3 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Ts_1,
3, /* Elements count */
&asn_SPC_Ts_specs_1 /* Additional specs */
};
@ -968,10 +451,12 @@ typedef struct Ts {
/*** <<< FUNC-DECLS [Ts] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Ts;
extern asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1;
extern asn_TYPE_member_t asn_MBR_Ts_1[3];
/*** <<< STAT-DEFS [Ts] >>> ***/
static asn_TYPE_member_t asn_MBR_Ts_1[] = {
asn_TYPE_member_t asn_MBR_Ts_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Ts, m1),
.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1012,7 +497,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Ts_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* m2 */
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 } /* m3 */
};
static asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1 = {
sizeof(struct Ts),
offsetof(struct Ts, _asn_ctx),
asn_MAP_Ts_tag2el_1,

627
tests/65-multi-tag-OK.asn1.-Pfwide-types
View File

@ -20,84 +20,10 @@ xer_type_encoder_f T1_encode_xer;
/*** <<< CODE [T1] >>> ***/
int
T1_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_T2.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T2,
* so here we adjust the DEF accordingly.
*/
static void
T1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T2.free_struct;
td->print_struct = asn_DEF_T2.print_struct;
td->check_constraints = asn_DEF_T2.check_constraints;
td->ber_decoder = asn_DEF_T2.ber_decoder;
td->der_encoder = asn_DEF_T2.der_encoder;
td->xer_decoder = asn_DEF_T2.xer_decoder;
td->xer_encoder = asn_DEF_T2.xer_encoder;
td->uper_decoder = asn_DEF_T2.uper_decoder;
td->uper_encoder = asn_DEF_T2.uper_encoder;
td->oer_decoder = asn_DEF_T2.oer_decoder;
td->oer_encoder = asn_DEF_T2.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T2.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T2.per_constraints;
td->elements = asn_DEF_T2.elements;
td->elements_count = asn_DEF_T2.elements_count;
td->specifics = asn_DEF_T2.specifics;
}
void
T1_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T1_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T1_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T1_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) {
T1_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T1] >>> ***/
@ -118,13 +44,13 @@ static const ber_tlv_tag_t asn_DEF_T1_all_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T1 = {
"T1",
"T1",
T1_free,
T1_print,
T1_constraint,
T1_decode_ber,
T1_encode_der,
T1_decode_xer,
T1_encode_xer,
REAL_free,
REAL_print,
REAL_constraint,
REAL_decode_ber,
REAL_encode_der,
REAL_decode_xer,
REAL_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -162,84 +88,10 @@ xer_type_encoder_f T2_encode_xer;
/*** <<< CODE [T2] >>> ***/
int
T2_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_T3.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T3,
* so here we adjust the DEF accordingly.
*/
static void
T2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T3.free_struct;
td->print_struct = asn_DEF_T3.print_struct;
td->check_constraints = asn_DEF_T3.check_constraints;
td->ber_decoder = asn_DEF_T3.ber_decoder;
td->der_encoder = asn_DEF_T3.der_encoder;
td->xer_decoder = asn_DEF_T3.xer_decoder;
td->xer_encoder = asn_DEF_T3.xer_encoder;
td->uper_decoder = asn_DEF_T3.uper_decoder;
td->uper_encoder = asn_DEF_T3.uper_encoder;
td->oer_decoder = asn_DEF_T3.oer_decoder;
td->oer_encoder = asn_DEF_T3.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T3.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T3.per_constraints;
td->elements = asn_DEF_T3.elements;
td->elements_count = asn_DEF_T3.elements_count;
td->specifics = asn_DEF_T3.specifics;
}
void
T2_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T2_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T2_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T2_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) {
T2_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T2] >>> ***/
@ -258,13 +110,13 @@ static const ber_tlv_tag_t asn_DEF_T2_all_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T2 = {
"T2",
"T2",
T2_free,
T2_print,
T2_constraint,
T2_decode_ber,
T2_encode_der,
T2_decode_xer,
T2_encode_xer,
REAL_free,
REAL_print,
REAL_constraint,
REAL_decode_ber,
REAL_encode_der,
REAL_decode_xer,
REAL_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -302,84 +154,10 @@ xer_type_encoder_f T3_encode_xer;
/*** <<< CODE [T3] >>> ***/
int
T3_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_T4.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T4,
* so here we adjust the DEF accordingly.
*/
static void
T3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T4.free_struct;
td->print_struct = asn_DEF_T4.print_struct;
td->check_constraints = asn_DEF_T4.check_constraints;
td->ber_decoder = asn_DEF_T4.ber_decoder;
td->der_encoder = asn_DEF_T4.der_encoder;
td->xer_decoder = asn_DEF_T4.xer_decoder;
td->xer_encoder = asn_DEF_T4.xer_encoder;
td->uper_decoder = asn_DEF_T4.uper_decoder;
td->uper_encoder = asn_DEF_T4.uper_encoder;
td->oer_decoder = asn_DEF_T4.oer_decoder;
td->oer_encoder = asn_DEF_T4.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T4.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T4.per_constraints;
td->elements = asn_DEF_T4.elements;
td->elements_count = asn_DEF_T4.elements_count;
td->specifics = asn_DEF_T4.specifics;
}
void
T3_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T3_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T3_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T3_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) {
T3_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T3] >>> ***/
@ -396,13 +174,13 @@ static const ber_tlv_tag_t asn_DEF_T3_all_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T3 = {
"T3",
"T3",
T3_free,
T3_print,
T3_constraint,
T3_decode_ber,
T3_encode_der,
T3_decode_xer,
T3_encode_xer,
REAL_free,
REAL_print,
REAL_constraint,
REAL_decode_ber,
REAL_encode_der,
REAL_decode_xer,
REAL_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -440,84 +218,10 @@ xer_type_encoder_f T4_encode_xer;
/*** <<< CODE [T4] >>> ***/
int
T4_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_T5.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T5,
* so here we adjust the DEF accordingly.
*/
static void
T4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T5.free_struct;
td->print_struct = asn_DEF_T5.print_struct;
td->check_constraints = asn_DEF_T5.check_constraints;
td->ber_decoder = asn_DEF_T5.ber_decoder;
td->der_encoder = asn_DEF_T5.der_encoder;
td->xer_decoder = asn_DEF_T5.xer_decoder;
td->xer_encoder = asn_DEF_T5.xer_encoder;
td->uper_decoder = asn_DEF_T5.uper_decoder;
td->uper_encoder = asn_DEF_T5.uper_encoder;
td->oer_decoder = asn_DEF_T5.oer_decoder;
td->oer_encoder = asn_DEF_T5.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T5.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T5.per_constraints;
td->elements = asn_DEF_T5.elements;
td->elements_count = asn_DEF_T5.elements_count;
td->specifics = asn_DEF_T5.specifics;
}
void
T4_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T4_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T4_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T4_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) {
T4_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T4] >>> ***/
@ -529,13 +233,13 @@ static const ber_tlv_tag_t asn_DEF_T4_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T4 = {
"T4",
"T4",
T4_free,
T4_print,
T4_constraint,
T4_decode_ber,
T4_encode_der,
T4_decode_xer,
T4_encode_xer,
REAL_free,
REAL_print,
REAL_constraint,
REAL_decode_ber,
REAL_encode_der,
REAL_decode_xer,
REAL_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -573,84 +277,10 @@ xer_type_encoder_f T5_encode_xer;
/*** <<< CODE [T5] >>> ***/
int
T5_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_T6.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using T6,
* so here we adjust the DEF accordingly.
*/
static void
T5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_T6.free_struct;
td->print_struct = asn_DEF_T6.print_struct;
td->check_constraints = asn_DEF_T6.check_constraints;
td->ber_decoder = asn_DEF_T6.ber_decoder;
td->der_encoder = asn_DEF_T6.der_encoder;
td->xer_decoder = asn_DEF_T6.xer_decoder;
td->xer_encoder = asn_DEF_T6.xer_encoder;
td->uper_decoder = asn_DEF_T6.uper_decoder;
td->uper_encoder = asn_DEF_T6.uper_encoder;
td->oer_decoder = asn_DEF_T6.oer_decoder;
td->oer_encoder = asn_DEF_T6.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_T6.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_T6.per_constraints;
td->elements = asn_DEF_T6.elements;
td->elements_count = asn_DEF_T6.elements_count;
td->specifics = asn_DEF_T6.specifics;
}
void
T5_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T5_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T5_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T5_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) {
T5_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T5] >>> ***/
@ -661,13 +291,13 @@ static const ber_tlv_tag_t asn_DEF_T5_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T5 = {
"T5",
"T5",
T5_free,
T5_print,
T5_constraint,
T5_decode_ber,
T5_encode_der,
T5_decode_xer,
T5_encode_xer,
REAL_free,
REAL_print,
REAL_constraint,
REAL_decode_ber,
REAL_encode_der,
REAL_decode_xer,
REAL_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -705,84 +335,10 @@ xer_type_encoder_f T6_encode_xer;
/*** <<< CODE [T6] >>> ***/
int
T6_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_REAL.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using REAL,
* so here we adjust the DEF accordingly.
*/
static void
T6_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_REAL.free_struct;
td->print_struct = asn_DEF_REAL.print_struct;
td->check_constraints = asn_DEF_REAL.check_constraints;
td->ber_decoder = asn_DEF_REAL.ber_decoder;
td->der_encoder = asn_DEF_REAL.der_encoder;
td->xer_decoder = asn_DEF_REAL.xer_decoder;
td->xer_encoder = asn_DEF_REAL.xer_encoder;
td->uper_decoder = asn_DEF_REAL.uper_decoder;
td->uper_encoder = asn_DEF_REAL.uper_encoder;
td->oer_decoder = asn_DEF_REAL.oer_decoder;
td->oer_encoder = asn_DEF_REAL.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_REAL.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_REAL.per_constraints;
td->elements = asn_DEF_REAL.elements;
td->elements_count = asn_DEF_REAL.elements_count;
td->specifics = asn_DEF_REAL.specifics;
}
void
T6_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T6_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T6_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T6_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T6_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) {
T6_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T6] >>> ***/
@ -792,13 +348,13 @@ static const ber_tlv_tag_t asn_DEF_T6_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T6 = {
"T6",
"T6",
T6_free,
T6_print,
T6_constraint,
T6_decode_ber,
T6_encode_der,
T6_decode_xer,
T6_encode_xer,
REAL_free,
REAL_print,
REAL_constraint,
REAL_decode_ber,
REAL_encode_der,
REAL_decode_xer,
REAL_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -836,84 +392,10 @@ xer_type_encoder_f T_encode_xer;
/*** <<< CODE [T] >>> ***/
int
T_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_Ts.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Ts,
* so here we adjust the DEF accordingly.
*/
static void
T_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Ts.free_struct;
td->print_struct = asn_DEF_Ts.print_struct;
td->check_constraints = asn_DEF_Ts.check_constraints;
td->ber_decoder = asn_DEF_Ts.ber_decoder;
td->der_encoder = asn_DEF_Ts.der_encoder;
td->xer_decoder = asn_DEF_Ts.xer_decoder;
td->xer_encoder = asn_DEF_Ts.xer_encoder;
td->uper_decoder = asn_DEF_Ts.uper_decoder;
td->uper_encoder = asn_DEF_Ts.uper_encoder;
td->oer_decoder = asn_DEF_Ts.oer_decoder;
td->oer_encoder = asn_DEF_Ts.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Ts.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Ts.per_constraints;
td->elements = asn_DEF_Ts.elements;
td->elements_count = asn_DEF_Ts.elements_count;
td->specifics = asn_DEF_Ts.specifics;
}
void
T_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T] >>> ***/
@ -925,13 +407,13 @@ static const ber_tlv_tag_t asn_DEF_T_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T = {
"T",
"T",
T_free,
T_print,
T_constraint,
T_decode_ber,
T_encode_der,
T_decode_xer,
T_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -943,8 +425,9 @@ asn_TYPE_descriptor_t asn_DEF_T = {
/sizeof(asn_DEF_T_tags_1[0]), /* 3 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Ts_1,
3, /* Elements count */
&asn_SPC_Ts_specs_1 /* Additional specs */
};
@ -968,10 +451,12 @@ typedef struct Ts {
/*** <<< FUNC-DECLS [Ts] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Ts;
extern asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1;
extern asn_TYPE_member_t asn_MBR_Ts_1[3];
/*** <<< STAT-DEFS [Ts] >>> ***/
static asn_TYPE_member_t asn_MBR_Ts_1[] = {
asn_TYPE_member_t asn_MBR_Ts_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Ts, m1),
.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1012,7 +497,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Ts_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* m2 */
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 } /* m3 */
};
static asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Ts_specs_1 = {
sizeof(struct Ts),
offsetof(struct Ts, _asn_ctx),
asn_MAP_Ts_tag2el_1,

91
tests/66-ref-simple-OK.asn1.-Pfwide-types
View File

@ -86,6 +86,7 @@ typedef ENUMERATED_t SimpleType_t;
/*** <<< FUNC-DECLS [SimpleType] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SimpleType;
extern asn_INTEGER_specifics_t asn_SPC_SimpleType_specs_1;
asn_struct_free_f SimpleType_free;
asn_struct_print_f SimpleType_print;
asn_constr_check_f SimpleType_constraint;
@ -96,84 +97,10 @@ xer_type_encoder_f SimpleType_encode_xer;
/*** <<< CODE [SimpleType] >>> ***/
int
SimpleType_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
SimpleType_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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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
SimpleType_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
SimpleType_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
SimpleType_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
SimpleType_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
SimpleType_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) {
SimpleType_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
SimpleType_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) {
SimpleType_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
SimpleType_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) {
SimpleType_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
SimpleType_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) {
SimpleType_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [SimpleType] >>> ***/
@ -187,7 +114,7 @@ static const unsigned int asn_MAP_SimpleType_enum2value_1[] = {
2, /* three(2) */
1 /* two(1) */
};
static asn_INTEGER_specifics_t asn_SPC_SimpleType_specs_1 = {
const asn_INTEGER_specifics_t asn_SPC_SimpleType_specs_1 = {
asn_MAP_SimpleType_value2enum_1, /* "tag" => N; sorted by tag */
asn_MAP_SimpleType_enum2value_1, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
@ -202,13 +129,13 @@ static const ber_tlv_tag_t asn_DEF_SimpleType_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_SimpleType = {
"SimpleType",
"SimpleType",
SimpleType_free,
SimpleType_print,
SimpleType_constraint,
SimpleType_decode_ber,
SimpleType_encode_der,
SimpleType_decode_xer,
SimpleType_encode_xer,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */

3
tests/69-reserved-words-OK.asn1.-Pfwide-types
View File

@ -81,7 +81,8 @@ static const ber_tlv_tag_t asn_DEF_class_tags_4[] = {
static const uint8_t asn_MAP_class_mmap_4[(0 + (8 * sizeof(unsigned int)) - 1) / 8] = {
0
};
static asn_SET_specifics_t asn_SPC_class_specs_4 = {
static
asn_SET_specifics_t asn_SPC_class_specs_4 = {
sizeof(struct Class),
offsetof(struct Class, _asn_ctx),
offsetof(struct Class, _presence_map),

366
tests/70-xer-test-OK.asn1.-Pfwide-types
View File

@ -307,6 +307,8 @@ typedef struct Sequence {
/*** <<< FUNC-DECLS [Sequence] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Sequence;
extern asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1;
extern asn_TYPE_member_t asn_MBR_Sequence_1[4];
/*** <<< POST-INCLUDE [Sequence] >>> ***/
@ -314,7 +316,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Sequence;
/*** <<< STAT-DEFS [Sequence] >>> ***/
static asn_TYPE_member_t asn_MBR_Sequence_1[] = {
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 */
@ -365,7 +367,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* bits */
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* string */
};
static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
sizeof(struct Sequence),
offsetof(struct Sequence, _asn_ctx),
asn_MAP_Sequence_tag2el_1,
@ -435,10 +437,12 @@ typedef struct Set {
/*** <<< FUNC-DECLS [Set] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Set;
extern asn_SET_specifics_t asn_SPC_Set_specs_1;
extern asn_TYPE_member_t asn_MBR_Set_1[2];
/*** <<< STAT-DEFS [Set] >>> ***/
static asn_TYPE_member_t asn_MBR_Set_1[] = {
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 */
@ -470,7 +474,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Set_tag2el_1[] = {
static const 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 = {
asn_SET_specifics_t asn_SPC_Set_specs_1 = {
sizeof(struct Set),
offsetof(struct Set, _asn_ctx),
offsetof(struct Set, _presence_map),
@ -551,87 +555,15 @@ typedef struct ExtensibleSet {
/* extern asn_TYPE_descriptor_t asn_DEF_enum_4; // (Use -fall-defs-global to expose) */
extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSet;
extern asn_SET_specifics_t asn_SPC_ExtensibleSet_specs_1;
extern asn_TYPE_member_t asn_MBR_ExtensibleSet_1[2];
/*** <<< 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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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] >>> ***/
@ -643,7 +575,7 @@ static const unsigned int asn_MAP_enum_enum2value_4[] = {
1, /* a(1) */
0 /* b(0) */
};
static asn_INTEGER_specifics_t asn_SPC_enum_specs_4 = {
static const 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 */
@ -660,13 +592,13 @@ 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,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -682,7 +614,7 @@ asn_TYPE_descriptor_t asn_DEF_enum_4 = {
&asn_SPC_enum_specs_4 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_ExtensibleSet_1[] = {
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 */
@ -714,7 +646,7 @@ static const asn_TYPE_tag2member_t asn_MAP_ExtensibleSet_tag2el_1[] = {
static const 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 = {
asn_SET_specifics_t asn_SPC_ExtensibleSet_specs_1 = {
sizeof(struct ExtensibleSet),
offsetof(struct ExtensibleSet, _asn_ctx),
offsetof(struct ExtensibleSet, _presence_map),
@ -777,10 +709,12 @@ typedef struct ExtensibleSequence {
/*** <<< FUNC-DECLS [ExtensibleSequence] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence;
extern asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_specs_1;
extern asn_TYPE_member_t asn_MBR_ExtensibleSequence_1[3];
/*** <<< STAT-DEFS [ExtensibleSequence] >>> ***/
static asn_TYPE_member_t asn_MBR_ExtensibleSequence_1[] = {
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 */
@ -820,7 +754,7 @@ static const asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* integer */
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* gtime */
};
static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_specs_1 = {
sizeof(struct ExtensibleSequence),
offsetof(struct ExtensibleSequence, _asn_ctx),
asn_MAP_ExtensibleSequence_tag2el_1,
@ -879,10 +813,12 @@ typedef struct ExtensibleSequence2 {
/*** <<< FUNC-DECLS [ExtensibleSequence2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence2;
extern asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_specs_1;
extern asn_TYPE_member_t asn_MBR_ExtensibleSequence2_1[2];
/*** <<< STAT-DEFS [ExtensibleSequence2] >>> ***/
static asn_TYPE_member_t asn_MBR_ExtensibleSequence2_1[] = {
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 */
@ -911,7 +847,7 @@ static const asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence2_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* integer */
};
static asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_specs_1 = {
sizeof(struct ExtensibleSequence2),
offsetof(struct ExtensibleSequence2, _asn_ctx),
asn_MAP_ExtensibleSequence2_tag2el_1,
@ -965,10 +901,12 @@ typedef struct SetOfNULL {
/*** <<< FUNC-DECLS [SetOfNULL] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SetOfNULL;
extern asn_SET_OF_specifics_t asn_SPC_SetOfNULL_specs_1;
extern asn_TYPE_member_t asn_MBR_SetOfNULL_1[1];
/*** <<< STAT-DEFS [SetOfNULL] >>> ***/
static asn_TYPE_member_t asn_MBR_SetOfNULL_1[] = {
asn_TYPE_member_t asn_MBR_SetOfNULL_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
.tag_mode = 0,
@ -983,7 +921,7 @@ static asn_TYPE_member_t asn_MBR_SetOfNULL_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_SetOfNULL_specs_1 = {
sizeof(struct SetOfNULL),
offsetof(struct SetOfNULL, _asn_ctx),
1, /* XER encoding is XMLValueList */
@ -1033,10 +971,12 @@ typedef struct SetOfREAL {
/*** <<< FUNC-DECLS [SetOfREAL] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SetOfREAL;
extern asn_SET_OF_specifics_t asn_SPC_SetOfREAL_specs_1;
extern asn_TYPE_member_t asn_MBR_SetOfREAL_1[1];
/*** <<< STAT-DEFS [SetOfREAL] >>> ***/
static asn_TYPE_member_t asn_MBR_SetOfREAL_1[] = {
asn_TYPE_member_t asn_MBR_SetOfREAL_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
.tag_mode = 0,
@ -1051,7 +991,7 @@ static asn_TYPE_member_t asn_MBR_SetOfREAL_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_SetOfREAL_specs_1 = {
sizeof(struct SetOfREAL),
offsetof(struct SetOfREAL, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -1109,87 +1049,15 @@ typedef struct SetOfEnums {
/* extern asn_TYPE_descriptor_t asn_DEF_Member_2; // (Use -fall-defs-global to expose) */
extern asn_TYPE_descriptor_t asn_DEF_SetOfEnums;
extern asn_SET_OF_specifics_t asn_SPC_SetOfEnums_specs_1;
extern asn_TYPE_member_t asn_MBR_SetOfEnums_1[1];
/*** <<< 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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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] >>> ***/
@ -1201,7 +1069,7 @@ static const unsigned int asn_MAP_Member_enum2value_2[] = {
0, /* one(0) */
1 /* oneMore(1) */
};
static asn_INTEGER_specifics_t asn_SPC_Member_specs_2 = {
static const 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 */
@ -1217,13 +1085,13 @@ 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,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -1239,7 +1107,7 @@ asn_TYPE_descriptor_t asn_DEF_Member_2 = {
&asn_SPC_Member_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_SetOfEnums_1[] = {
asn_TYPE_member_t asn_MBR_SetOfEnums_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
.tag_mode = 0,
@ -1254,7 +1122,7 @@ static asn_TYPE_member_t asn_MBR_SetOfEnums_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_SetOfEnums_specs_1 = {
sizeof(struct SetOfEnums),
offsetof(struct SetOfEnums, _asn_ctx),
1, /* XER encoding is XMLValueList */
@ -1304,10 +1172,12 @@ typedef struct NamedSetOfNULL {
/*** <<< FUNC-DECLS [NamedSetOfNULL] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfNULL;
extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfNULL_specs_1;
extern asn_TYPE_member_t asn_MBR_NamedSetOfNULL_1[1];
/*** <<< STAT-DEFS [NamedSetOfNULL] >>> ***/
static asn_TYPE_member_t asn_MBR_NamedSetOfNULL_1[] = {
asn_TYPE_member_t asn_MBR_NamedSetOfNULL_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
.tag_mode = 0,
@ -1322,7 +1192,7 @@ static asn_TYPE_member_t asn_MBR_NamedSetOfNULL_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_NamedSetOfNULL_specs_1 = {
sizeof(struct NamedSetOfNULL),
offsetof(struct NamedSetOfNULL, _asn_ctx),
1, /* XER encoding is XMLValueList */
@ -1372,10 +1242,12 @@ typedef struct NamedSetOfREAL {
/*** <<< FUNC-DECLS [NamedSetOfREAL] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfREAL;
extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfREAL_specs_1;
extern asn_TYPE_member_t asn_MBR_NamedSetOfREAL_1[1];
/*** <<< STAT-DEFS [NamedSetOfREAL] >>> ***/
static asn_TYPE_member_t asn_MBR_NamedSetOfREAL_1[] = {
asn_TYPE_member_t asn_MBR_NamedSetOfREAL_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
.tag_mode = 0,
@ -1390,7 +1262,7 @@ static asn_TYPE_member_t asn_MBR_NamedSetOfREAL_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_NamedSetOfREAL_specs_1 = {
sizeof(struct NamedSetOfREAL),
offsetof(struct NamedSetOfREAL, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -1448,87 +1320,15 @@ typedef struct NamedSetOfEnums {
/* extern asn_TYPE_descriptor_t asn_DEF_name_2; // (Use -fall-defs-global to expose) */
extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfEnums;
extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfEnums_specs_1;
extern asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[1];
/*** <<< 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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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] >>> ***/
@ -1540,7 +1340,7 @@ static const unsigned int asn_MAP_name_enum2value_2[] = {
0, /* one(0) */
1 /* oneMore(1) */
};
static asn_INTEGER_specifics_t asn_SPC_name_specs_2 = {
static const 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 */
@ -1556,13 +1356,13 @@ 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,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -1578,7 +1378,7 @@ asn_TYPE_descriptor_t asn_DEF_name_2 = {
&asn_SPC_name_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[] = {
asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
.tag_mode = 0,
@ -1593,7 +1393,7 @@ static asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_NamedSetOfEnums_specs_1 = {
sizeof(struct NamedSetOfEnums),
offsetof(struct NamedSetOfEnums, _asn_ctx),
1, /* XER encoding is XMLValueList */
@ -1643,10 +1443,12 @@ typedef struct SequenceOf {
/*** <<< FUNC-DECLS [SequenceOf] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SequenceOf;
extern asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1;
extern asn_TYPE_member_t asn_MBR_SequenceOf_1[1];
/*** <<< STAT-DEFS [SequenceOf] >>> ***/
static asn_TYPE_member_t asn_MBR_SequenceOf_1[] = {
asn_TYPE_member_t asn_MBR_SequenceOf_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
.tag_mode = 0,
@ -1661,7 +1463,7 @@ static asn_TYPE_member_t asn_MBR_SequenceOf_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1 = {
sizeof(struct SequenceOf),
offsetof(struct SequenceOf, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -1711,10 +1513,12 @@ typedef struct SeqOfZuka {
/*** <<< FUNC-DECLS [SeqOfZuka] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SeqOfZuka;
extern asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_specs_1;
extern asn_TYPE_member_t asn_MBR_SeqOfZuka_1[1];
/*** <<< STAT-DEFS [SeqOfZuka] >>> ***/
static asn_TYPE_member_t asn_MBR_SeqOfZuka_1[] = {
asn_TYPE_member_t asn_MBR_SeqOfZuka_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
.tag_mode = 0,
@ -1729,7 +1533,7 @@ static asn_TYPE_member_t asn_MBR_SeqOfZuka_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_specs_1 = {
sizeof(struct SeqOfZuka),
offsetof(struct SeqOfZuka, _asn_ctx),
1, /* XER encoding is XMLValueList */
@ -1782,6 +1586,8 @@ typedef struct SetOfChoice {
/*** <<< FUNC-DECLS [SetOfChoice] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SetOfChoice;
extern asn_SET_OF_specifics_t asn_SPC_SetOfChoice_specs_1;
extern asn_TYPE_member_t asn_MBR_SetOfChoice_1[1];
/*** <<< POST-INCLUDE [SetOfChoice] >>> ***/
@ -1789,7 +1595,7 @@ extern asn_TYPE_descriptor_t asn_DEF_SetOfChoice;
/*** <<< STAT-DEFS [SetOfChoice] >>> ***/
static asn_TYPE_member_t asn_MBR_SetOfChoice_1[] = {
asn_TYPE_member_t asn_MBR_SetOfChoice_1[] = {
{ ATF_POINTER, 0, 0,
.tag = -1 /* Ambiguous tag (CHOICE?) */,
.tag_mode = 0,
@ -1804,7 +1610,7 @@ static asn_TYPE_member_t asn_MBR_SetOfChoice_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_SetOfChoice_specs_1 = {
sizeof(struct SetOfChoice),
offsetof(struct SetOfChoice, _asn_ctx),
2, /* XER encoding is XMLValueList */
@ -1857,6 +1663,8 @@ typedef struct NamedSetOfChoice {
/*** <<< FUNC-DECLS [NamedSetOfChoice] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfChoice;
extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfChoice_specs_1;
extern asn_TYPE_member_t asn_MBR_NamedSetOfChoice_1[1];
/*** <<< POST-INCLUDE [NamedSetOfChoice] >>> ***/
@ -1864,7 +1672,7 @@ extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfChoice;
/*** <<< STAT-DEFS [NamedSetOfChoice] >>> ***/
static asn_TYPE_member_t asn_MBR_NamedSetOfChoice_1[] = {
asn_TYPE_member_t asn_MBR_NamedSetOfChoice_1[] = {
{ ATF_POINTER, 0, 0,
.tag = -1 /* Ambiguous tag (CHOICE?) */,
.tag_mode = 0,
@ -1879,7 +1687,7 @@ static asn_TYPE_member_t asn_MBR_NamedSetOfChoice_1[] = {
static const 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 = {
asn_SET_OF_specifics_t asn_SPC_NamedSetOfChoice_specs_1 = {
sizeof(struct NamedSetOfChoice),
offsetof(struct NamedSetOfChoice, _asn_ctx),
2, /* XER encoding is XMLValueList */
@ -1941,10 +1749,12 @@ typedef struct SimpleChoice {
/*** <<< FUNC-DECLS [SimpleChoice] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_SimpleChoice;
extern asn_CHOICE_specifics_t asn_SPC_SimpleChoice_specs_1;
extern asn_TYPE_member_t asn_MBR_SimpleChoice_1[2];
/*** <<< STAT-DEFS [SimpleChoice] >>> ***/
static asn_TYPE_member_t asn_MBR_SimpleChoice_1[] = {
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 */
@ -1970,7 +1780,7 @@ static const asn_TYPE_tag2member_t asn_MAP_SimpleChoice_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b */
};
static asn_CHOICE_specifics_t asn_SPC_SimpleChoice_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_SimpleChoice_specs_1 = {
sizeof(struct SimpleChoice),
offsetof(struct SimpleChoice, _asn_ctx),
offsetof(struct SimpleChoice, present),

15
tests/72-same-names-OK.asn1.-Pfwide-types
View File

@ -184,6 +184,8 @@ typedef struct Type1 {
/*** <<< FUNC-DECLS [Type1] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Type1;
extern asn_SEQUENCE_specifics_t asn_SPC_Type1_specs_1;
extern asn_TYPE_member_t asn_MBR_Type1_1[1];
/*** <<< STAT-DEFS [Type1] >>> ***/
@ -302,7 +304,7 @@ asn_TYPE_descriptor_t asn_DEF_one_name_2 = {
&asn_SPC_one_name_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Type1_1[] = {
asn_TYPE_member_t asn_MBR_Type1_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Type1, one_name),
.tag = -1 /* Ambiguous tag (CHOICE?) */,
.tag_mode = 0,
@ -320,7 +322,7 @@ static const ber_tlv_tag_t asn_DEF_Type1_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_Type1_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* another-name */
};
static asn_SEQUENCE_specifics_t asn_SPC_Type1_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Type1_specs_1 = {
sizeof(struct Type1),
offsetof(struct Type1, _asn_ctx),
asn_MAP_Type1_tag2el_1,
@ -427,6 +429,8 @@ typedef struct Type2 {
/*** <<< FUNC-DECLS [Type2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Type2;
extern asn_CHOICE_specifics_t asn_SPC_Type2_specs_1;
extern asn_TYPE_member_t asn_MBR_Type2_1[2];
/*** <<< CODE [Type2] >>> ***/
@ -700,7 +704,8 @@ static const asn_TYPE_tag2member_t asn_MAP_two_name_tag2el_7[] = {
static const uint8_t asn_MAP_two_name_mmap_7[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_two_name_specs_7 = {
static
asn_SET_specifics_t asn_SPC_two_name_specs_7 = {
sizeof(struct two_name),
offsetof(struct two_name, _asn_ctx),
offsetof(struct two_name, _presence_map),
@ -738,7 +743,7 @@ asn_TYPE_descriptor_t asn_DEF_two_name_7 = {
&asn_SPC_two_name_specs_7 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Type2_1[] = {
asn_TYPE_member_t asn_MBR_Type2_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Type2, choice.one_name),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
@ -764,7 +769,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Type2_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 }, /* one-name */
{ (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 1, 0, 0 } /* two-name */
};
static asn_CHOICE_specifics_t asn_SPC_Type2_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Type2_specs_1 = {
sizeof(struct Type2),
offsetof(struct Type2, _asn_ctx),
offsetof(struct Type2, present),

202
tests/73-circular-OK.asn1.-Pfwide-types
View File

@ -26,6 +26,8 @@ typedef struct Type {
/*** <<< 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] >>> ***/
@ -80,7 +82,7 @@ asn_TYPE_descriptor_t asn_DEF_data_2 = {
&asn_SPC_data_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Type_1[] = {
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,
@ -98,7 +100,7 @@ static const ber_tlv_tag_t asn_DEF_Type_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_Type_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 0 } /* data */
};
static asn_SEQUENCE_specifics_t asn_SPC_Type_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Type_specs_1 = {
sizeof(struct Type),
offsetof(struct Type, _asn_ctx),
asn_MAP_Type_tag2el_1,
@ -155,84 +157,10 @@ xer_type_encoder_f EpytRef_encode_xer;
/*** <<< CODE [EpytRef] >>> ***/
int
EpytRef_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_Epyt.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, 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->check_constraints = asn_DEF_Epyt.check_constraints;
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;
td->uper_encoder = asn_DEF_Epyt.uper_encoder;
td->oer_decoder = asn_DEF_Epyt.oer_decoder;
td->oer_encoder = asn_DEF_Epyt.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Epyt.oer_constraints;
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] >>> ***/
@ -242,13 +170,13 @@ static const ber_tlv_tag_t asn_DEF_EpytRef_tags_1[] = {
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,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -260,8 +188,9 @@ asn_TYPE_descriptor_t asn_DEF_EpytRef = {
/sizeof(asn_DEF_EpytRef_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Epyt_1,
3, /* Elements count */
&asn_SPC_Epyt_specs_1 /* Additional specs */
};
@ -295,6 +224,8 @@ typedef struct Epyt {
/*** <<< 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] >>> ***/
@ -350,7 +281,7 @@ asn_TYPE_descriptor_t asn_DEF_stype_2 = {
&asn_SPC_stype_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Epyt_1[] = {
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,
@ -390,7 +321,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Epyt_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 1 }, /* stype */
{ (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 2, -1, 0 } /* ypet */
};
static asn_SEQUENCE_specifics_t asn_SPC_Epyt_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Epyt_specs_1 = {
sizeof(struct Epyt),
offsetof(struct Epyt, _asn_ctx),
asn_MAP_Epyt_tag2el_1,
@ -478,6 +409,8 @@ typedef struct Ypet {
/*** <<< 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] >>> ***/
@ -632,7 +565,7 @@ asn_TYPE_descriptor_t asn_DEF_senums_4 = {
&asn_SPC_senums_specs_4 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Ypet_1[] = {
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,
@ -697,7 +630,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Ypet_tag2el_1[] = {
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)
};
static asn_SET_specifics_t asn_SPC_Ypet_specs_1 = {
asn_SET_specifics_t asn_SPC_Ypet_specs_1 = {
sizeof(struct Ypet),
offsetof(struct Ypet, _asn_ctx),
offsetof(struct Ypet, _presence_map),
@ -753,6 +686,7 @@ typedef ENUMERATED_t EnumType_t;
/*** <<< FUNC-DECLS [EnumType] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_EnumType;
extern 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;
@ -763,84 +697,10 @@ xer_type_encoder_f EnumType_encode_xer;
/*** <<< CODE [EnumType] >>> ***/
int
EnumType_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
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->check_constraints = asn_DEF_ENUMERATED.check_constraints;
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;
td->oer_decoder = asn_DEF_ENUMERATED.oer_decoder;
td->oer_encoder = asn_DEF_ENUMERATED.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_ENUMERATED.oer_constraints;
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] >>> ***/
@ -852,7 +712,7 @@ static const unsigned int asn_MAP_EnumType_enum2value_1[] = {
0, /* one(0) */
1 /* two(1) */
};
static asn_INTEGER_specifics_t asn_SPC_EnumType_specs_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 */
@ -867,13 +727,13 @@ static const ber_tlv_tag_t asn_DEF_EnumType_tags_1[] = {
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,
ENUMERATED_free,
ENUMERATED_print,
ENUMERATED_constraint,
ENUMERATED_decode_ber,
ENUMERATED_encode_der,
ENUMERATED_decode_xer,
ENUMERATED_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */

24
tests/84-param-tags-OK.asn1.-Pfwide-types
View File

@ -23,7 +23,11 @@ typedef struct TestType_16P1 {
/*** <<< FUNC-DECLS [TestType] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_TestType_16P0;
extern asn_SEQUENCE_specifics_t asn_SPC_TestType_16P0_specs_1;
extern asn_TYPE_member_t asn_MBR_TestType_16P0_1[1];
extern asn_TYPE_descriptor_t asn_DEF_TestType_16P1;
extern asn_SEQUENCE_specifics_t asn_SPC_TestType_16P1_specs_3;
extern asn_TYPE_member_t asn_MBR_TestType_16P1_3[1];
/*** <<< CODE [TestType] >>> ***/
@ -73,7 +77,7 @@ static int asn_DFL_2_set_0(int set_value, void **sptr) {
return (*st == 0);
}
}
static asn_TYPE_member_t asn_MBR_TestType_16P0_1[] = {
asn_TYPE_member_t asn_MBR_TestType_16P0_1[] = {
{ ATF_NOFLAGS, 1, offsetof(struct TestType_16P0, common),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
.tag_mode = 0,
@ -91,7 +95,7 @@ static const ber_tlv_tag_t asn_DEF_TestType_16P0_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_TestType_16P0_tag2el_1[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* common */
};
static asn_SEQUENCE_specifics_t asn_SPC_TestType_16P0_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_TestType_16P0_specs_1 = {
sizeof(struct TestType_16P0),
offsetof(struct TestType_16P0, _asn_ctx),
asn_MAP_TestType_16P0_tag2el_1,
@ -144,7 +148,7 @@ static int asn_DFL_4_set_0(int set_value, void **sptr) {
return (*st == 0);
}
}
static asn_TYPE_member_t asn_MBR_TestType_16P1_3[] = {
asn_TYPE_member_t asn_MBR_TestType_16P1_3[] = {
{ ATF_NOFLAGS, 1, offsetof(struct TestType_16P1, common),
.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
.tag_mode = 0,
@ -162,7 +166,7 @@ static const ber_tlv_tag_t asn_DEF_TestType_16P1_tags_3[] = {
static const asn_TYPE_tag2member_t asn_MAP_TestType_16P1_tag2el_3[] = {
{ (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 0, 0, 0 } /* common */
};
static asn_SEQUENCE_specifics_t asn_SPC_TestType_16P1_specs_3 = {
asn_SEQUENCE_specifics_t asn_SPC_TestType_16P1_specs_3 = {
sizeof(struct TestType_16P1),
offsetof(struct TestType_16P1, _asn_ctx),
asn_MAP_TestType_16P1_tag2el_3,
@ -315,7 +319,11 @@ typedef struct AutoType_34P1 {
/*** <<< FUNC-DECLS [AutoType] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_AutoType_34P0;
extern asn_SEQUENCE_specifics_t asn_SPC_AutoType_34P0_specs_1;
extern asn_TYPE_member_t asn_MBR_AutoType_34P0_1[1];
extern asn_TYPE_descriptor_t asn_DEF_AutoType_34P1;
extern asn_SEQUENCE_specifics_t asn_SPC_AutoType_34P1_specs_3;
extern asn_TYPE_member_t asn_MBR_AutoType_34P1_3[1];
/*** <<< CODE [AutoType] >>> ***/
@ -372,7 +380,7 @@ memb_common_constraint_3(asn_TYPE_descriptor_t *td, const void *sptr,
/*** <<< STAT-DEFS [AutoType] >>> ***/
static asn_TYPE_member_t asn_MBR_AutoType_34P0_1[] = {
asn_TYPE_member_t asn_MBR_AutoType_34P0_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct AutoType_34P0, common),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -390,7 +398,7 @@ static const ber_tlv_tag_t asn_DEF_AutoType_34P0_tags_1[] = {
static const asn_TYPE_tag2member_t asn_MAP_AutoType_34P0_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* common */
};
static asn_SEQUENCE_specifics_t asn_SPC_AutoType_34P0_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_AutoType_34P0_specs_1 = {
sizeof(struct AutoType_34P0),
offsetof(struct AutoType_34P0, _asn_ctx),
asn_MAP_AutoType_34P0_tag2el_1,
@ -425,7 +433,7 @@ asn_TYPE_descriptor_t asn_DEF_AutoType_34P0 = {
&asn_SPC_AutoType_34P0_specs_1 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_AutoType_34P1_3[] = {
asn_TYPE_member_t asn_MBR_AutoType_34P1_3[] = {
{ ATF_NOFLAGS, 0, offsetof(struct AutoType_34P1, common),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -443,7 +451,7 @@ static const ber_tlv_tag_t asn_DEF_AutoType_34P1_tags_3[] = {
static const asn_TYPE_tag2member_t asn_MAP_AutoType_34P1_tag2el_3[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* common */
};
static asn_SEQUENCE_specifics_t asn_SPC_AutoType_34P1_specs_3 = {
asn_SEQUENCE_specifics_t asn_SPC_AutoType_34P1_specs_3 = {
sizeof(struct AutoType_34P1),
offsetof(struct AutoType_34P1, _asn_ctx),
asn_MAP_AutoType_34P1_tag2el_3,

88
tests/88-integer-enum-OK.asn1.-Pfwide-types
View File

@ -27,84 +27,10 @@ xer_type_encoder_f T_encode_xer;
/*** <<< CODE [T] >>> ***/
int
T_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_INTEGER.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using INTEGER,
* so here we adjust the DEF accordingly.
*/
static void
T_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_INTEGER.free_struct;
td->print_struct = asn_DEF_INTEGER.print_struct;
td->check_constraints = asn_DEF_INTEGER.check_constraints;
td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
td->der_encoder = asn_DEF_INTEGER.der_encoder;
td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
td->uper_decoder = asn_DEF_INTEGER.uper_decoder;
td->uper_encoder = asn_DEF_INTEGER.uper_encoder;
td->oer_decoder = asn_DEF_INTEGER.oer_decoder;
td->oer_encoder = asn_DEF_INTEGER.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_INTEGER.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_INTEGER.per_constraints;
td->elements = asn_DEF_INTEGER.elements;
td->elements_count = asn_DEF_INTEGER.elements_count;
td->specifics = asn_DEF_INTEGER.specifics;
}
void
T_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
T_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
T_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
T_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
T_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) {
T_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [T] >>> ***/
@ -114,13 +40,13 @@ static const ber_tlv_tag_t asn_DEF_T_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_T = {
"T",
"T",
T_free,
T_print,
T_constraint,
T_decode_ber,
T_encode_der,
T_decode_xer,
T_encode_xer,
INTEGER_free,
INTEGER_print,
INTEGER_constraint,
INTEGER_decode_ber,
INTEGER_encode_der,
INTEGER_decode_xer,
INTEGER_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */

1442
tests/90-cond-int-type-OK.asn1.-P
View File

File diff suppressed because it is too large Load Diff

1442
tests/90-cond-int-type-OK.asn1.-Pfwide-types
View File

File diff suppressed because it is too large Load Diff

1784
tests/90-cond-int-type-OK.asn1.-Pgen-PER
View File

File diff suppressed because it is too large Load Diff

390
tests/91-cond-int-blessSize-OK.asn1.-Pfbless-SIZE
View File

@ -45,72 +45,6 @@ OK_Integer1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
OK_Integer1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
td->check_constraints = asn_DEF_NativeInteger.check_constraints;
td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
td->der_encoder = asn_DEF_NativeInteger.der_encoder;
td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeInteger.per_constraints;
td->elements = asn_DEF_NativeInteger.elements;
td->elements_count = asn_DEF_NativeInteger.elements_count;
td->specifics = asn_DEF_NativeInteger.specifics;
}
void
OK_Integer1_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
OK_Integer1_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
OK_Integer1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
OK_Integer1_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
OK_Integer1_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) {
OK_Integer1_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
OK_Integer1_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) {
OK_Integer1_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
OK_Integer1_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) {
OK_Integer1_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
OK_Integer1_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) {
OK_Integer1_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [OK-Integer1] >>> ***/
@ -120,13 +54,13 @@ static const ber_tlv_tag_t asn_DEF_OK_Integer1_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_OK_Integer1 = {
"OK-Integer1",
"OK-Integer1",
OK_Integer1_free,
OK_Integer1_print,
NativeInteger_free,
NativeInteger_print,
OK_Integer1_constraint,
OK_Integer1_decode_ber,
OK_Integer1_encode_der,
OK_Integer1_decode_xer,
OK_Integer1_encode_xer,
NativeInteger_decode_ber,
NativeInteger_encode_der,
NativeInteger_decode_xer,
NativeInteger_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -189,72 +123,6 @@ OK_Integer2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
OK_Integer2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
td->check_constraints = asn_DEF_NativeInteger.check_constraints;
td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
td->der_encoder = asn_DEF_NativeInteger.der_encoder;
td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeInteger.per_constraints;
td->elements = asn_DEF_NativeInteger.elements;
td->elements_count = asn_DEF_NativeInteger.elements_count;
td->specifics = asn_DEF_NativeInteger.specifics;
}
void
OK_Integer2_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
OK_Integer2_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
OK_Integer2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
OK_Integer2_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
OK_Integer2_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) {
OK_Integer2_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
OK_Integer2_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) {
OK_Integer2_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
OK_Integer2_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) {
OK_Integer2_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
OK_Integer2_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) {
OK_Integer2_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [OK-Integer2] >>> ***/
@ -264,13 +132,13 @@ static const ber_tlv_tag_t asn_DEF_OK_Integer2_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_OK_Integer2 = {
"OK-Integer2",
"OK-Integer2",
OK_Integer2_free,
OK_Integer2_print,
NativeInteger_free,
NativeInteger_print,
OK_Integer2_constraint,
OK_Integer2_decode_ber,
OK_Integer2_encode_der,
OK_Integer2_decode_xer,
OK_Integer2_encode_xer,
NativeInteger_decode_ber,
NativeInteger_encode_der,
NativeInteger_decode_xer,
NativeInteger_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -333,72 +201,6 @@ OK_Integer3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
OK_Integer3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
td->check_constraints = asn_DEF_NativeInteger.check_constraints;
td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
td->der_encoder = asn_DEF_NativeInteger.der_encoder;
td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeInteger.per_constraints;
td->elements = asn_DEF_NativeInteger.elements;
td->elements_count = asn_DEF_NativeInteger.elements_count;
td->specifics = asn_DEF_NativeInteger.specifics;
}
void
OK_Integer3_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
OK_Integer3_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
OK_Integer3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
OK_Integer3_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
OK_Integer3_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) {
OK_Integer3_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
OK_Integer3_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) {
OK_Integer3_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
OK_Integer3_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) {
OK_Integer3_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
OK_Integer3_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) {
OK_Integer3_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [OK-Integer3] >>> ***/
@ -408,13 +210,13 @@ static const ber_tlv_tag_t asn_DEF_OK_Integer3_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_OK_Integer3 = {
"OK-Integer3",
"OK-Integer3",
OK_Integer3_free,
OK_Integer3_print,
NativeInteger_free,
NativeInteger_print,
OK_Integer3_constraint,
OK_Integer3_decode_ber,
OK_Integer3_encode_der,
OK_Integer3_decode_xer,
OK_Integer3_encode_xer,
NativeInteger_decode_ber,
NativeInteger_encode_der,
NativeInteger_decode_xer,
NativeInteger_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -477,72 +279,6 @@ OK_Integer4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
OK_Integer4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
td->check_constraints = asn_DEF_NativeInteger.check_constraints;
td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
td->der_encoder = asn_DEF_NativeInteger.der_encoder;
td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeInteger.per_constraints;
td->elements = asn_DEF_NativeInteger.elements;
td->elements_count = asn_DEF_NativeInteger.elements_count;
td->specifics = asn_DEF_NativeInteger.specifics;
}
void
OK_Integer4_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
OK_Integer4_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
OK_Integer4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
OK_Integer4_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
OK_Integer4_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) {
OK_Integer4_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
OK_Integer4_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) {
OK_Integer4_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
OK_Integer4_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) {
OK_Integer4_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
OK_Integer4_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) {
OK_Integer4_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [OK-Integer4] >>> ***/
@ -552,13 +288,13 @@ static const ber_tlv_tag_t asn_DEF_OK_Integer4_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_OK_Integer4 = {
"OK-Integer4",
"OK-Integer4",
OK_Integer4_free,
OK_Integer4_print,
NativeInteger_free,
NativeInteger_print,
OK_Integer4_constraint,
OK_Integer4_decode_ber,
OK_Integer4_encode_der,
OK_Integer4_decode_xer,
OK_Integer4_encode_xer,
NativeInteger_decode_ber,
NativeInteger_encode_der,
NativeInteger_decode_xer,
NativeInteger_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -621,72 +357,6 @@ NO_Integer5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
NO_Integer5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
td->check_constraints = asn_DEF_NativeInteger.check_constraints;
td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
td->der_encoder = asn_DEF_NativeInteger.der_encoder;
td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
td->uper_decoder = asn_DEF_NativeInteger.uper_decoder;
td->uper_encoder = asn_DEF_NativeInteger.uper_encoder;
td->oer_decoder = asn_DEF_NativeInteger.oer_decoder;
td->oer_encoder = asn_DEF_NativeInteger.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_NativeInteger.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_NativeInteger.per_constraints;
td->elements = asn_DEF_NativeInteger.elements;
td->elements_count = asn_DEF_NativeInteger.elements_count;
td->specifics = asn_DEF_NativeInteger.specifics;
}
void
NO_Integer5_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
NO_Integer5_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
NO_Integer5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
NO_Integer5_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
NO_Integer5_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) {
NO_Integer5_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
NO_Integer5_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) {
NO_Integer5_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
NO_Integer5_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) {
NO_Integer5_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
NO_Integer5_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) {
NO_Integer5_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [NO-Integer5] >>> ***/
@ -696,13 +366,13 @@ static const ber_tlv_tag_t asn_DEF_NO_Integer5_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_NO_Integer5 = {
"NO-Integer5",
"NO-Integer5",
NO_Integer5_free,
NO_Integer5_print,
NativeInteger_free,
NativeInteger_print,
NO_Integer5_constraint,
NO_Integer5_decode_ber,
NO_Integer5_encode_der,
NO_Integer5_decode_xer,
NO_Integer5_encode_xer,
NativeInteger_decode_ber,
NativeInteger_encode_der,
NativeInteger_decode_xer,
NativeInteger_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */

165
tests/92-circular-loops-OK.asn1.-Pfindirect-choice
View File

@ -37,6 +37,8 @@ typedef struct Everything {
/*** <<< FUNC-DECLS [Everything] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Everything;
extern asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1;
extern asn_TYPE_member_t asn_MBR_Everything_1[10];
/*** <<< POST-INCLUDE [Everything] >>> ***/
@ -46,7 +48,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Everything;
/*** <<< STAT-DEFS [Everything] >>> ***/
static asn_TYPE_member_t asn_MBR_Everything_1[] = {
asn_TYPE_member_t asn_MBR_Everything_1[] = {
{ ATF_POINTER, 0, offsetof(struct Everything, ch1),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = +1, /* EXPLICIT tag at current level */
@ -163,7 +165,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Everything_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* tt */
{ (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* to */
};
static asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1 = {
sizeof(struct Everything),
offsetof(struct Everything, _asn_ctx),
asn_MAP_Everything_tag2el_1,
@ -236,6 +238,8 @@ typedef struct Choice1 {
/*** <<< FUNC-DECLS [Choice1] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice1;
extern asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice1_1[2];
/*** <<< POST-INCLUDE [Choice1] >>> ***/
@ -243,7 +247,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Choice1;
/*** <<< STAT-DEFS [Choice1] >>> ***/
static asn_TYPE_member_t asn_MBR_Choice1_1[] = {
asn_TYPE_member_t asn_MBR_Choice1_1[] = {
{ ATF_POINTER, 0, offsetof(struct Choice1, choice.something),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -269,7 +273,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice1_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* something */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some2 */
};
static asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
sizeof(struct Choice1),
offsetof(struct Choice1, _asn_ctx),
offsetof(struct Choice1, present),
@ -342,6 +346,8 @@ typedef struct Choice2 {
/*** <<< FUNC-DECLS [Choice2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice2;
extern asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice2_1[2];
/*** <<< POST-INCLUDE [Choice2] >>> ***/
@ -350,7 +356,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Choice2;
/*** <<< STAT-DEFS [Choice2] >>> ***/
static asn_TYPE_member_t asn_MBR_Choice2_1[] = {
asn_TYPE_member_t asn_MBR_Choice2_1[] = {
{ ATF_POINTER, 0, offsetof(struct Choice2, choice.typeref),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -376,7 +382,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* typeref */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some3 */
};
static asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
sizeof(struct Choice2),
offsetof(struct Choice2, _asn_ctx),
offsetof(struct Choice2, present),
@ -459,6 +465,8 @@ typedef struct Choice3 {
/*** <<< FUNC-DECLS [Choice3] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice3;
extern asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice3_1[3];
/*** <<< POST-INCLUDE [Choice3] >>> ***/
@ -570,7 +578,7 @@ asn_TYPE_descriptor_t asn_DEF_c_5 = {
&asn_SPC_c_specs_5 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Choice3_1[] = {
asn_TYPE_member_t asn_MBR_Choice3_1[] = {
{ ATF_POINTER, 0, offsetof(struct Choice3, choice.a),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = 0,
@ -607,7 +615,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice3_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* b */
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* c */
};
static asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1 = {
sizeof(struct Choice3),
offsetof(struct Choice3, _asn_ctx),
offsetof(struct Choice3, present),
@ -683,6 +691,8 @@ typedef struct Set {
/*** <<< FUNC-DECLS [Set] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Set;
extern asn_SET_OF_specifics_t asn_SPC_Set_specs_1;
extern asn_TYPE_member_t asn_MBR_Set_1[1];
/*** <<< POST-INCLUDE [Set] >>> ***/
@ -789,7 +799,7 @@ asn_TYPE_descriptor_t asn_DEF_Member_2 = {
&asn_SPC_Member_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Set_1[] = {
asn_TYPE_member_t asn_MBR_Set_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
@ -804,7 +814,7 @@ static asn_TYPE_member_t asn_MBR_Set_1[] = {
static const ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_Set_specs_1 = {
asn_SET_OF_specifics_t asn_SPC_Set_specs_1 = {
sizeof(struct Set),
offsetof(struct Set, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -865,6 +875,8 @@ typedef struct Sequence {
/*** <<< FUNC-DECLS [Sequence] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Sequence;
extern asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1;
extern asn_TYPE_member_t asn_MBR_Sequence_1[4];
/*** <<< POST-INCLUDE [Sequence] >>> ***/
@ -873,7 +885,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Sequence;
/*** <<< STAT-DEFS [Sequence] >>> ***/
static asn_TYPE_member_t asn_MBR_Sequence_1[] = {
asn_TYPE_member_t asn_MBR_Sequence_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Sequence, a),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -924,7 +936,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* b */
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* set */
};
static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
sizeof(struct Sequence),
offsetof(struct Sequence, _asn_ctx),
asn_MAP_Sequence_tag2el_1,
@ -981,84 +993,10 @@ xer_type_encoder_f TypeRef_encode_xer;
/*** <<< CODE [TypeRef] >>> ***/
int
TypeRef_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_Sequence.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Sequence,
* so here we adjust the DEF accordingly.
*/
static void
TypeRef_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Sequence.free_struct;
td->print_struct = asn_DEF_Sequence.print_struct;
td->check_constraints = asn_DEF_Sequence.check_constraints;
td->ber_decoder = asn_DEF_Sequence.ber_decoder;
td->der_encoder = asn_DEF_Sequence.der_encoder;
td->xer_decoder = asn_DEF_Sequence.xer_decoder;
td->xer_encoder = asn_DEF_Sequence.xer_encoder;
td->uper_decoder = asn_DEF_Sequence.uper_decoder;
td->uper_encoder = asn_DEF_Sequence.uper_encoder;
td->oer_decoder = asn_DEF_Sequence.oer_decoder;
td->oer_encoder = asn_DEF_Sequence.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Sequence.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Sequence.per_constraints;
td->elements = asn_DEF_Sequence.elements;
td->elements_count = asn_DEF_Sequence.elements_count;
td->specifics = asn_DEF_Sequence.specifics;
}
void
TypeRef_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
TypeRef_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
TypeRef_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [TypeRef] >>> ***/
@ -1068,13 +1006,13 @@ static const ber_tlv_tag_t asn_DEF_TypeRef_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_TypeRef = {
"TypeRef",
"TypeRef",
TypeRef_free,
TypeRef_print,
TypeRef_constraint,
TypeRef_decode_ber,
TypeRef_encode_der,
TypeRef_decode_xer,
TypeRef_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -1086,8 +1024,9 @@ asn_TYPE_descriptor_t asn_DEF_TypeRef = {
/sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Sequence_1,
4, /* Elements count */
&asn_SPC_Sequence_specs_1 /* Additional specs */
};
@ -1117,6 +1056,8 @@ typedef struct Alpha {
/*** <<< FUNC-DECLS [Alpha] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Alpha;
extern asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1;
extern asn_TYPE_member_t asn_MBR_Alpha_1[2];
/*** <<< POST-INCLUDE [Alpha] >>> ***/
@ -1179,7 +1120,7 @@ asn_TYPE_descriptor_t asn_DEF_b_3 = {
&asn_SPC_b_specs_3 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Alpha_1[] = {
asn_TYPE_member_t asn_MBR_Alpha_1[] = {
{ ATF_POINTER, 0, offsetof(struct Alpha, a),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1208,7 +1149,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Alpha_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b */
};
static asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1 = {
sizeof(struct Alpha),
offsetof(struct Alpha, _asn_ctx),
asn_MAP_Alpha_tag2el_1,
@ -1266,6 +1207,8 @@ typedef struct Beta {
/*** <<< FUNC-DECLS [Beta] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Beta;
extern asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1;
extern asn_TYPE_member_t asn_MBR_Beta_1[2];
/*** <<< POST-INCLUDE [Beta] >>> ***/
@ -1274,7 +1217,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Beta;
/*** <<< STAT-DEFS [Beta] >>> ***/
static asn_TYPE_member_t asn_MBR_Beta_1[] = {
asn_TYPE_member_t asn_MBR_Beta_1[] = {
{ ATF_POINTER, 2, offsetof(struct Beta, b),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1303,7 +1246,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Beta_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* b */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g */
};
static asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1 = {
sizeof(struct Beta),
offsetof(struct Beta, _asn_ctx),
asn_MAP_Beta_tag2el_1,
@ -1363,6 +1306,8 @@ typedef struct Gamma {
/*** <<< FUNC-DECLS [Gamma] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Gamma;
extern asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1;
extern asn_TYPE_member_t asn_MBR_Gamma_1[3];
/*** <<< POST-INCLUDE [Gamma] >>> ***/
@ -1372,7 +1317,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Gamma;
/*** <<< STAT-DEFS [Gamma] >>> ***/
static asn_TYPE_member_t asn_MBR_Gamma_1[] = {
asn_TYPE_member_t asn_MBR_Gamma_1[] = {
{ ATF_POINTER, 0, offsetof(struct Gamma, o),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1412,7 +1357,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Gamma_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* a */
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* b */
};
static asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1 = {
sizeof(struct Gamma),
offsetof(struct Gamma, _asn_ctx),
asn_MAP_Gamma_tag2el_1,
@ -1482,6 +1427,8 @@ typedef struct OneTwo {
/*** <<< FUNC-DECLS [OneTwo] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_OneTwo;
extern asn_SET_specifics_t asn_SPC_OneTwo_specs_1;
extern asn_TYPE_member_t asn_MBR_OneTwo_1[1];
/*** <<< POST-INCLUDE [OneTwo] >>> ***/
@ -1489,7 +1436,7 @@ extern asn_TYPE_descriptor_t asn_DEF_OneTwo;
/*** <<< STAT-DEFS [OneTwo] >>> ***/
static asn_TYPE_member_t asn_MBR_OneTwo_1[] = {
asn_TYPE_member_t asn_MBR_OneTwo_1[] = {
{ ATF_POINTER, 0, offsetof(struct OneTwo, m12),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1510,7 +1457,7 @@ static const asn_TYPE_tag2member_t asn_MAP_OneTwo_tag2el_1[] = {
static const uint8_t asn_MAP_OneTwo_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_OneTwo_specs_1 = {
asn_SET_specifics_t asn_SPC_OneTwo_specs_1 = {
sizeof(struct OneTwo),
offsetof(struct OneTwo, _asn_ctx),
offsetof(struct OneTwo, _presence_map),
@ -1582,6 +1529,8 @@ typedef struct TwoThree {
/*** <<< FUNC-DECLS [TwoThree] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_TwoThree;
extern asn_SET_specifics_t asn_SPC_TwoThree_specs_1;
extern asn_TYPE_member_t asn_MBR_TwoThree_1[1];
/*** <<< POST-INCLUDE [TwoThree] >>> ***/
@ -1589,7 +1538,7 @@ extern asn_TYPE_descriptor_t asn_DEF_TwoThree;
/*** <<< STAT-DEFS [TwoThree] >>> ***/
static asn_TYPE_member_t asn_MBR_TwoThree_1[] = {
asn_TYPE_member_t asn_MBR_TwoThree_1[] = {
{ ATF_POINTER, 0, offsetof(struct TwoThree, m23),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1610,7 +1559,7 @@ static const asn_TYPE_tag2member_t asn_MAP_TwoThree_tag2el_1[] = {
static const uint8_t asn_MAP_TwoThree_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_TwoThree_specs_1 = {
asn_SET_specifics_t asn_SPC_TwoThree_specs_1 = {
sizeof(struct TwoThree),
offsetof(struct TwoThree, _asn_ctx),
offsetof(struct TwoThree, _presence_map),
@ -1685,6 +1634,8 @@ typedef struct ThreeOne {
/*** <<< FUNC-DECLS [ThreeOne] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_ThreeOne;
extern asn_SET_specifics_t asn_SPC_ThreeOne_specs_1;
extern asn_TYPE_member_t asn_MBR_ThreeOne_1[2];
/*** <<< POST-INCLUDE [ThreeOne] >>> ***/
@ -1693,7 +1644,7 @@ extern asn_TYPE_descriptor_t asn_DEF_ThreeOne;
/*** <<< STAT-DEFS [ThreeOne] >>> ***/
static asn_TYPE_member_t asn_MBR_ThreeOne_1[] = {
asn_TYPE_member_t asn_MBR_ThreeOne_1[] = {
{ ATF_POINTER, 0, offsetof(struct ThreeOne, m31),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1725,7 +1676,7 @@ static const asn_TYPE_tag2member_t asn_MAP_ThreeOne_tag2el_1[] = {
static const uint8_t asn_MAP_ThreeOne_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7) | (1 << 6)
};
static asn_SET_specifics_t asn_SPC_ThreeOne_specs_1 = {
asn_SET_specifics_t asn_SPC_ThreeOne_specs_1 = {
sizeof(struct ThreeOne),
offsetof(struct ThreeOne, _asn_ctx),
offsetof(struct ThreeOne, _presence_map),

165
tests/92-circular-loops-OK.asn1.-Pfwide-types
View File

@ -37,6 +37,8 @@ typedef struct Everything {
/*** <<< FUNC-DECLS [Everything] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Everything;
extern asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1;
extern asn_TYPE_member_t asn_MBR_Everything_1[10];
/*** <<< POST-INCLUDE [Everything] >>> ***/
@ -46,7 +48,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Everything;
/*** <<< STAT-DEFS [Everything] >>> ***/
static asn_TYPE_member_t asn_MBR_Everything_1[] = {
asn_TYPE_member_t asn_MBR_Everything_1[] = {
{ ATF_POINTER, 0, offsetof(struct Everything, ch1),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = +1, /* EXPLICIT tag at current level */
@ -163,7 +165,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Everything_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* tt */
{ (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* to */
};
static asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1 = {
sizeof(struct Everything),
offsetof(struct Everything, _asn_ctx),
asn_MAP_Everything_tag2el_1,
@ -236,6 +238,8 @@ typedef struct Choice1 {
/*** <<< FUNC-DECLS [Choice1] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice1;
extern asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice1_1[2];
/*** <<< POST-INCLUDE [Choice1] >>> ***/
@ -243,7 +247,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Choice1;
/*** <<< STAT-DEFS [Choice1] >>> ***/
static asn_TYPE_member_t asn_MBR_Choice1_1[] = {
asn_TYPE_member_t asn_MBR_Choice1_1[] = {
{ ATF_POINTER, 0, offsetof(struct Choice1, choice.something),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -269,7 +273,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice1_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* something */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some2 */
};
static asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
sizeof(struct Choice1),
offsetof(struct Choice1, _asn_ctx),
offsetof(struct Choice1, present),
@ -342,6 +346,8 @@ typedef struct Choice2 {
/*** <<< FUNC-DECLS [Choice2] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice2;
extern asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice2_1[2];
/*** <<< POST-INCLUDE [Choice2] >>> ***/
@ -349,7 +355,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Choice2;
/*** <<< STAT-DEFS [Choice2] >>> ***/
static asn_TYPE_member_t asn_MBR_Choice2_1[] = {
asn_TYPE_member_t asn_MBR_Choice2_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Choice2, choice.typeref),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -375,7 +381,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* typeref */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some3 */
};
static asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
sizeof(struct Choice2),
offsetof(struct Choice2, _asn_ctx),
offsetof(struct Choice2, present),
@ -458,6 +464,8 @@ typedef struct Choice3 {
/*** <<< FUNC-DECLS [Choice3] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Choice3;
extern asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1;
extern asn_TYPE_member_t asn_MBR_Choice3_1[3];
/*** <<< POST-INCLUDE [Choice3] >>> ***/
@ -569,7 +577,7 @@ asn_TYPE_descriptor_t asn_DEF_c_5 = {
&asn_SPC_c_specs_5 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Choice3_1[] = {
asn_TYPE_member_t asn_MBR_Choice3_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Choice3, choice.a),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = 0,
@ -606,7 +614,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Choice3_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* b */
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* c */
};
static asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1 = {
asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1 = {
sizeof(struct Choice3),
offsetof(struct Choice3, _asn_ctx),
offsetof(struct Choice3, present),
@ -682,6 +690,8 @@ typedef struct Set {
/*** <<< FUNC-DECLS [Set] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Set;
extern asn_SET_OF_specifics_t asn_SPC_Set_specs_1;
extern asn_TYPE_member_t asn_MBR_Set_1[1];
/*** <<< POST-INCLUDE [Set] >>> ***/
@ -788,7 +798,7 @@ asn_TYPE_descriptor_t asn_DEF_Member_2 = {
&asn_SPC_Member_specs_2 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Set_1[] = {
asn_TYPE_member_t asn_MBR_Set_1[] = {
{ ATF_POINTER, 0, 0,
.tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
.tag_mode = 0,
@ -803,7 +813,7 @@ static asn_TYPE_member_t asn_MBR_Set_1[] = {
static const ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
};
static asn_SET_OF_specifics_t asn_SPC_Set_specs_1 = {
asn_SET_OF_specifics_t asn_SPC_Set_specs_1 = {
sizeof(struct Set),
offsetof(struct Set, _asn_ctx),
0, /* XER encoding is XMLDelimitedItemList */
@ -864,6 +874,8 @@ typedef struct Sequence {
/*** <<< FUNC-DECLS [Sequence] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Sequence;
extern asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1;
extern asn_TYPE_member_t asn_MBR_Sequence_1[4];
/*** <<< POST-INCLUDE [Sequence] >>> ***/
@ -872,7 +884,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Sequence;
/*** <<< STAT-DEFS [Sequence] >>> ***/
static asn_TYPE_member_t asn_MBR_Sequence_1[] = {
asn_TYPE_member_t asn_MBR_Sequence_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Sequence, a),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -923,7 +935,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* b */
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* set */
};
static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
sizeof(struct Sequence),
offsetof(struct Sequence, _asn_ctx),
asn_MAP_Sequence_tag2el_1,
@ -980,84 +992,10 @@ xer_type_encoder_f TypeRef_encode_xer;
/*** <<< CODE [TypeRef] >>> ***/
int
TypeRef_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_Sequence.check_constraints;
return td->check_constraints(td, sptr, ctfailcb, app_key);
}
/*
* This type is implemented using Sequence,
* so here we adjust the DEF accordingly.
*/
static void
TypeRef_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
td->free_struct = asn_DEF_Sequence.free_struct;
td->print_struct = asn_DEF_Sequence.print_struct;
td->check_constraints = asn_DEF_Sequence.check_constraints;
td->ber_decoder = asn_DEF_Sequence.ber_decoder;
td->der_encoder = asn_DEF_Sequence.der_encoder;
td->xer_decoder = asn_DEF_Sequence.xer_decoder;
td->xer_encoder = asn_DEF_Sequence.xer_encoder;
td->uper_decoder = asn_DEF_Sequence.uper_decoder;
td->uper_encoder = asn_DEF_Sequence.uper_encoder;
td->oer_decoder = asn_DEF_Sequence.oer_decoder;
td->oer_encoder = asn_DEF_Sequence.oer_encoder;
if(!td->oer_constraints)
td->oer_constraints = asn_DEF_Sequence.oer_constraints;
if(!td->per_constraints)
td->per_constraints = asn_DEF_Sequence.per_constraints;
td->elements = asn_DEF_Sequence.elements;
td->elements_count = asn_DEF_Sequence.elements_count;
td->specifics = asn_DEF_Sequence.specifics;
}
void
TypeRef_free(asn_TYPE_descriptor_t *td,
void *struct_ptr, int contents_only) {
TypeRef_1_inherit_TYPE_descriptor(td);
td->free_struct(td, struct_ptr, contents_only);
}
int
TypeRef_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
}
asn_dec_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
}
asn_enc_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
}
asn_dec_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
}
asn_enc_rval_t
TypeRef_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) {
TypeRef_1_inherit_TYPE_descriptor(td);
return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
}
/*** <<< STAT-DEFS [TypeRef] >>> ***/
@ -1067,13 +1005,13 @@ static const ber_tlv_tag_t asn_DEF_TypeRef_tags_1[] = {
asn_TYPE_descriptor_t asn_DEF_TypeRef = {
"TypeRef",
"TypeRef",
TypeRef_free,
TypeRef_print,
TypeRef_constraint,
TypeRef_decode_ber,
TypeRef_encode_der,
TypeRef_decode_xer,
TypeRef_encode_xer,
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
0, 0, /* No OER support, use "-gen-OER" to enable */
0, 0, /* No PER support, use "-gen-PER" to enable */
0, /* Use generic outmost tag fetcher */
@ -1085,8 +1023,9 @@ asn_TYPE_descriptor_t asn_DEF_TypeRef = {
/sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
0, /* No OER visible constraints */
0, /* No PER visible constraints */
0, 0, /* Defined elsewhere */
0 /* No specifics */
asn_MBR_Sequence_1,
4, /* Elements count */
&asn_SPC_Sequence_specs_1 /* Additional specs */
};
@ -1116,6 +1055,8 @@ typedef struct Alpha {
/*** <<< FUNC-DECLS [Alpha] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Alpha;
extern asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1;
extern asn_TYPE_member_t asn_MBR_Alpha_1[2];
/*** <<< POST-INCLUDE [Alpha] >>> ***/
@ -1178,7 +1119,7 @@ asn_TYPE_descriptor_t asn_DEF_b_3 = {
&asn_SPC_b_specs_3 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_Alpha_1[] = {
asn_TYPE_member_t asn_MBR_Alpha_1[] = {
{ ATF_POINTER, 0, offsetof(struct Alpha, a),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1207,7 +1148,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Alpha_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b */
};
static asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1 = {
sizeof(struct Alpha),
offsetof(struct Alpha, _asn_ctx),
asn_MAP_Alpha_tag2el_1,
@ -1265,6 +1206,8 @@ typedef struct Beta {
/*** <<< FUNC-DECLS [Beta] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Beta;
extern asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1;
extern asn_TYPE_member_t asn_MBR_Beta_1[2];
/*** <<< POST-INCLUDE [Beta] >>> ***/
@ -1273,7 +1216,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Beta;
/*** <<< STAT-DEFS [Beta] >>> ***/
static asn_TYPE_member_t asn_MBR_Beta_1[] = {
asn_TYPE_member_t asn_MBR_Beta_1[] = {
{ ATF_POINTER, 2, offsetof(struct Beta, b),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1302,7 +1245,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Beta_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* b */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g */
};
static asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1 = {
sizeof(struct Beta),
offsetof(struct Beta, _asn_ctx),
asn_MAP_Beta_tag2el_1,
@ -1362,6 +1305,8 @@ typedef struct Gamma {
/*** <<< FUNC-DECLS [Gamma] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Gamma;
extern asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1;
extern asn_TYPE_member_t asn_MBR_Gamma_1[3];
/*** <<< POST-INCLUDE [Gamma] >>> ***/
@ -1371,7 +1316,7 @@ extern asn_TYPE_descriptor_t asn_DEF_Gamma;
/*** <<< STAT-DEFS [Gamma] >>> ***/
static asn_TYPE_member_t asn_MBR_Gamma_1[] = {
asn_TYPE_member_t asn_MBR_Gamma_1[] = {
{ ATF_POINTER, 0, offsetof(struct Gamma, o),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1411,7 +1356,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Gamma_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* a */
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* b */
};
static asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1 = {
sizeof(struct Gamma),
offsetof(struct Gamma, _asn_ctx),
asn_MAP_Gamma_tag2el_1,
@ -1481,6 +1426,8 @@ typedef struct OneTwo {
/*** <<< FUNC-DECLS [OneTwo] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_OneTwo;
extern asn_SET_specifics_t asn_SPC_OneTwo_specs_1;
extern asn_TYPE_member_t asn_MBR_OneTwo_1[1];
/*** <<< POST-INCLUDE [OneTwo] >>> ***/
@ -1488,7 +1435,7 @@ extern asn_TYPE_descriptor_t asn_DEF_OneTwo;
/*** <<< STAT-DEFS [OneTwo] >>> ***/
static asn_TYPE_member_t asn_MBR_OneTwo_1[] = {
asn_TYPE_member_t asn_MBR_OneTwo_1[] = {
{ ATF_POINTER, 0, offsetof(struct OneTwo, m12),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1509,7 +1456,7 @@ static const asn_TYPE_tag2member_t asn_MAP_OneTwo_tag2el_1[] = {
static const uint8_t asn_MAP_OneTwo_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_OneTwo_specs_1 = {
asn_SET_specifics_t asn_SPC_OneTwo_specs_1 = {
sizeof(struct OneTwo),
offsetof(struct OneTwo, _asn_ctx),
offsetof(struct OneTwo, _presence_map),
@ -1581,6 +1528,8 @@ typedef struct TwoThree {
/*** <<< FUNC-DECLS [TwoThree] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_TwoThree;
extern asn_SET_specifics_t asn_SPC_TwoThree_specs_1;
extern asn_TYPE_member_t asn_MBR_TwoThree_1[1];
/*** <<< POST-INCLUDE [TwoThree] >>> ***/
@ -1588,7 +1537,7 @@ extern asn_TYPE_descriptor_t asn_DEF_TwoThree;
/*** <<< STAT-DEFS [TwoThree] >>> ***/
static asn_TYPE_member_t asn_MBR_TwoThree_1[] = {
asn_TYPE_member_t asn_MBR_TwoThree_1[] = {
{ ATF_POINTER, 0, offsetof(struct TwoThree, m23),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1609,7 +1558,7 @@ static const asn_TYPE_tag2member_t asn_MAP_TwoThree_tag2el_1[] = {
static const uint8_t asn_MAP_TwoThree_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7)
};
static asn_SET_specifics_t asn_SPC_TwoThree_specs_1 = {
asn_SET_specifics_t asn_SPC_TwoThree_specs_1 = {
sizeof(struct TwoThree),
offsetof(struct TwoThree, _asn_ctx),
offsetof(struct TwoThree, _presence_map),
@ -1684,6 +1633,8 @@ typedef struct ThreeOne {
/*** <<< FUNC-DECLS [ThreeOne] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_ThreeOne;
extern asn_SET_specifics_t asn_SPC_ThreeOne_specs_1;
extern asn_TYPE_member_t asn_MBR_ThreeOne_1[2];
/*** <<< POST-INCLUDE [ThreeOne] >>> ***/
@ -1692,7 +1643,7 @@ extern asn_TYPE_descriptor_t asn_DEF_ThreeOne;
/*** <<< STAT-DEFS [ThreeOne] >>> ***/
static asn_TYPE_member_t asn_MBR_ThreeOne_1[] = {
asn_TYPE_member_t asn_MBR_ThreeOne_1[] = {
{ ATF_POINTER, 0, offsetof(struct ThreeOne, m31),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -1724,7 +1675,7 @@ static const asn_TYPE_tag2member_t asn_MAP_ThreeOne_tag2el_1[] = {
static const uint8_t asn_MAP_ThreeOne_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7) | (1 << 6)
};
static asn_SET_specifics_t asn_SPC_ThreeOne_specs_1 = {
asn_SET_specifics_t asn_SPC_ThreeOne_specs_1 = {
sizeof(struct ThreeOne),
offsetof(struct ThreeOne, _asn_ctx),
offsetof(struct ThreeOne, _presence_map),

9
tests/93-asn1c-controls-OK.asn1.-Pfwide-types
View File

@ -17,10 +17,12 @@ typedef struct Sequence {
/*** <<< FUNC-DECLS [Sequence] >>> ***/
extern asn_TYPE_descriptor_t asn_DEF_Sequence;
extern asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1;
extern asn_TYPE_member_t asn_MBR_Sequence_1[2];
/*** <<< STAT-DEFS [Sequence] >>> ***/
static asn_TYPE_member_t asn_MBR_Sequence_1[] = {
asn_TYPE_member_t asn_MBR_Sequence_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct Sequence, ainl),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
@ -49,7 +51,7 @@ static const asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ainl */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* aptr */
};
static asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
sizeof(struct Sequence),
offsetof(struct Sequence, _asn_ctx),
asn_MAP_Sequence_tag2el_1,
@ -161,7 +163,8 @@ static const asn_TYPE_tag2member_t asn_MAP_Set_tag2el_1[] = {
static const uint8_t asn_MAP_Set_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
(1 << 7) | (1 << 6)
};
static asn_SET_specifics_t asn_SPC_Set_specs_1 = {
static
asn_SET_specifics_t asn_SPC_Set_specs_1 = {
sizeof(struct Set),
offsetof(struct Set, _asn_ctx),
offsetof(struct Set, _presence_map),

3
tests/94-set-optionals-OK.asn1.-P
View File

@ -176,7 +176,8 @@ static const uint8_t asn_MAP_TestSet_mmap_1[(10 + (8 * sizeof(unsigned int)) - 1
(1 << 7) | (0 << 6) | (1 << 5) | (1 << 4) | (0 << 3) | (1 << 2) | (1 << 1) | (1 << 0),
(0 << 7) | (1 << 6)
};
static asn_SET_specifics_t asn_SPC_TestSet_specs_1 = {
static
asn_SET_specifics_t asn_SPC_TestSet_specs_1 = {
sizeof(struct TestSet),
offsetof(struct TestSet, _asn_ctx),
offsetof(struct TestSet, _presence_map),