unsigned integer of 32-bit widtth support for per

git-svn-id: https://asn1c.svn.sourceforge.net/svnroot/asn1c/trunk@1401 59561ff5-6e30-0410-9f3c-9617f08c8826
git-svn
vlm 15 years ago
parent 3811ffc9c3
commit 12164c45ff
  1. 48
      asn1c/tests/check-127.-fnative-types.-gen-PER.c
  2. 32
      libasn1compiler/asn1c_C.c
  3. 61
      libasn1compiler/asn1c_constraint.c
  4. 17
      libasn1compiler/asn1c_misc.c
  5. 6
      libasn1compiler/asn1c_misc.h
  6. 58
      skeletons/INTEGER.c
  7. 2
      skeletons/INTEGER.h
  8. 2
      skeletons/NativeEnumerated.c
  9. 30
      skeletons/NativeInteger.c
  10. 4
      tests/110-param-3-OK.asn1.-P
  11. 4
      tests/127-per-long-OK.asn1
  12. 507
      tests/127-per-long-OK.asn1.-Pgen-PER
  13. 4
      tests/42-real-life-OK.asn1.-PR
  14. 12
      tests/50-constraint-OK.asn1.-P
  15. 12
      tests/50-constraint-OK.asn1.-Pgen-PER
  16. 4
      tests/66-ref-simple-OK.asn1.-P
  17. 12
      tests/70-xer-test-OK.asn1.-P
  18. 4
      tests/73-circular-OK.asn1.-P
  19. 199
      tests/90-cond-int-type-OK.asn1.-P
  20. 199
      tests/90-cond-int-type-OK.asn1.-Pfnative-types
  21. 199
      tests/90-cond-int-type-OK.asn1.-Pgen-PER

@ -9,30 +9,36 @@
#include <T.h>
void
verify(T_t *ti) {
static void
verify(int testNo, T_t *ti) {
asn_enc_rval_t er;
asn_dec_rval_t rv;
unsigned char buf[8];
unsigned char buf[16];
T_t *to = 0;
fprintf(stderr, "IN: { %ld, %ld }\n",
ti->small32range, ti->full32range);
fprintf(stderr, "%d IN: { %ld, %ld, %lu, %lu }\n", testNo,
ti->small32range, ti->full32range,
ti->unsigned32, ti->unsplit32);
er = uper_encode_to_buffer(&asn_DEF_T, ti, buf, sizeof buf);
assert(er.encoded == 64);
assert(er.encoded == 8 * sizeof(buf));
rv = uper_decode(0, &asn_DEF_T, (void *)&to, buf, sizeof buf, 0, 0);
assert(rv.code == RC_OK);
fprintf(stderr, "ENC: %2x%2x%2x%2x %2x%2x%2x%2x\n",
fprintf(stderr, "%d ENC: %2x%2x%2x%2x %2x%2x%2x%2x\n", testNo,
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7]);
fprintf(stderr, "OUT: { %ld, %ld } vs { %ld, %ld }\n",
fprintf(stderr, "%d OUT: { %ld, %ld, %lu, %lu } vs { %ld, %ld, %lu, %lu }\n",
testNo,
ti->small32range, ti->full32range,
to->small32range, to->full32range);
ti->unsigned32, ti->unsplit32,
to->small32range, to->full32range,
to->unsigned32, to->unsplit32);
assert(ti->small32range == to->small32range);
assert(ti->full32range == to->full32range);
assert(ti->unsigned32 == to->unsigned32);
assert(ti->unsplit32 == to->unsplit32);
xer_fprint(stderr, &asn_DEF_T, ti);
xer_fprint(stderr, &asn_DEF_T, to);
@ -43,27 +49,39 @@ int main() {
ti.small32range = 0;
ti.full32range = 0;
verify(&ti);
ti.unsigned32 = 0;
ti.unsplit32 = 5;
verify(1, &ti);
ti.small32range = -1;
ti.full32range = -1;
verify(&ti);
ti.unsigned32 = 1;
ti.unsplit32 = 300;
verify(2, &ti);
ti.small32range = -2000000000;
ti.full32range = (-2147483647L - 1);
verify(&ti);
ti.unsigned32 = 4000000000;
ti.unsplit32 = 500;
verify(3, &ti);
ti.small32range = -1999999999;
ti.full32range = (-2147483647L);
verify(&ti);
ti.unsigned32 = 4294967295UL;
ti.unsplit32 = 600;
verify(4, &ti);
ti.small32range = 2000000000;
ti.full32range = 2147483647;
verify(&ti);
ti.unsigned32 = 4294967295UL - 100;
ti.unsplit32 = 4294967290UL;
verify(5, &ti);
ti.small32range = 1999999999;
ti.full32range = 2147483647 - 1;
verify(&ti);
ti.unsigned32 = 4294967295UL - 1;
ti.unsplit32 = 4294967290UL - 1;
verify(6, &ti);
return 0;
}

@ -222,9 +222,28 @@ asn1c_lang_C_type_common_INTEGER(arg_t *arg) {
OUT("0,\t/* Enumeration is not extensible */\n");
}
if(expr->expr_type == ASN_BASIC_ENUMERATED)
OUT("1\t/* Strict enumeration */\n");
OUT("1,\t/* Strict enumeration */\n");
else
OUT("0\n");
OUT("0,\n");
OUT("0,\t/* Native long size */\n");
OUT("0\n");
INDENT(-1);
OUT("};\n");
}
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",
MKID(expr), expr->_type_unique_index);
INDENT(+1);
OUT("0,\t");
OUT("0,\t");
OUT("0,\t");
OUT("0,\t");
OUT("0,\n");
OUT("0,\t/* Native long size */\n");
OUT("1\t/* Unsigned representation */\n");
INDENT(-1);
OUT("};\n");
}
@ -1112,7 +1131,10 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) {
if((expr->expr_type == ASN_BASIC_ENUMERATED)
|| (0 /* -- prohibited by X.693:8.3.4 */
&& expr->expr_type == ASN_BASIC_INTEGER
&& expr_elements_count(arg, expr)))
&& expr_elements_count(arg, expr))
|| (expr->expr_type == ASN_BASIC_INTEGER
&& asn1c_type_fits_long(arg, expr) == FL_FITS_UNSIGN)
)
etd_spec = ETD_HAS_SPECIFICS;
else
etd_spec = ETD_NO_SPECIFICS;
@ -2289,7 +2311,9 @@ emit_member_table(arg_t *arg, asn1p_expr_t *expr) {
|| expr->expr_type == ASN_BASIC_ENUMERATED
|| (0 /* -- prohibited by X.693:8.3.4 */
&& expr->expr_type == ASN_BASIC_INTEGER
&& expr_elements_count(arg, expr));
&& expr_elements_count(arg, expr))
|| (expr->expr_type == ASN_BASIC_INTEGER
&& asn1c_type_fits_long(arg, expr) == FL_FITS_UNSIGN);
if(C99_MODE) OUT(".type = ");
OUT("&asn_DEF_");
if(complex_contents) {

@ -12,6 +12,7 @@ static int emit_value_determination_code(arg_t *arg, asn1p_expr_type_e etype, as
static int emit_size_determination_code(arg_t *arg, asn1p_expr_type_e etype);
static asn1p_expr_type_e _find_terminal_type(arg_t *arg);
static int emit_range_comparison_code(arg_t *arg, asn1cnst_range_t *range, const char *varname, asn1c_integer_t natural_start, asn1c_integer_t natural_stop);
static int native_long_sign(asn1cnst_range_t *r); /* -1, 0, 1 */
int
asn1c_emit_constraint_checking_code(arg_t *arg) {
@ -91,7 +92,11 @@ asn1c_emit_constraint_checking_code(arg_t *arg) {
switch(etype) {
case ASN_BASIC_INTEGER:
case ASN_BASIC_ENUMERATED:
OUT("long value;\n");
if(native_long_sign(r_value) >= 0) {
OUT("unsigned long value;\n");
} else {
OUT("long value;\n");
}
break;
case ASN_BASIC_REAL:
OUT("double value;\n");
@ -132,6 +137,19 @@ asn1c_emit_constraint_checking_code(arg_t *arg) {
REDIR(OT_CODE);
INDENT(+1);
/*
* Optimization for unsigned longs.
*/
if(!r_size && r_value
&& (etype == ASN_BASIC_INTEGER
|| etype == ASN_BASIC_ENUMERATED)
&& native_long_sign(r_value) == 0) {
OUT("\n");
OUT("/* Constraint check succeeded */\n");
OUT("return 0;\n");
return 0;
}
/*
* Here is an if() {} else {} consrtaint checking code.
*/
@ -578,9 +596,15 @@ emit_value_determination_code(arg_t *arg, asn1p_expr_type_e etype, asn1cnst_rang
switch(etype) {
case ASN_BASIC_INTEGER:
case ASN_BASIC_ENUMERATED:
if(asn1c_type_fits_long(arg, arg->expr) != FL_NOTFIT) {
if(asn1c_type_fits_long(arg, arg->expr) == FL_FITS_UNSIGN) {
OUT("value = *(const unsigned long *)sptr;\n");
} else if(asn1c_type_fits_long(arg, arg->expr) != FL_NOTFIT) {
OUT("value = *(const long *)sptr;\n");
} else {
/*
* In some cases we can explore our knowledge of
* underlying INTEGER_t->buf format.
*/
if(r_value->el_count == 0
&& (
/* Speed-up common case: (0..MAX) */
@ -598,14 +622,26 @@ emit_value_determination_code(arg_t *arg, asn1p_expr_type_e etype, asn1cnst_rang
break;
}
OUT("if(asn_INTEGER2long(st, &value)) {\n");
if(native_long_sign(r_value) >= 0) {
/* Special case for treating unsigned longs */
OUT("if(asn_INTEGER2ulong(st, &value)) {\n");
INDENT(+1);
OUT("_ASN_CTFAIL(app_key, td, sptr,\n");
OUT("\t\"%%s: value too large (%%s:%%d)\",\n");
OUT("\ttd->name, __FILE__, __LINE__);\n");
OUT("return -1;\n");
INDENT(-1);
OUT("}\n");
OUT("}\n");
} else {
OUT("if(asn_INTEGER2long(st, &value)) {\n");
INDENT(+1);
OUT("_ASN_CTFAIL(app_key, td, sptr,\n");
OUT("\t\"%%s: value too large (%%s:%%d)\",\n");
OUT("\ttd->name, __FILE__, __LINE__);\n");
OUT("return -1;\n");
INDENT(-1);
OUT("}\n");
}
}
break;
case ASN_BASIC_REAL:
@ -652,3 +688,20 @@ _find_terminal_type(arg_t *arg) {
return A1TC_INVALID;
}
static int
native_long_sign(asn1cnst_range_t *r) {
if(r->left.type == ARE_VALUE
&& r->left.value >= 0
&& r->right.type == ARE_VALUE
&& r->right.value > 2147483647UL
&& r->right.value <= 4294967295UL) {
if(r->el_count == 0
&& r->left.value == 0
&& r->right.value == 4294967295UL)
return 0;
else
return 1;
} else {
return -1;
}
}

@ -215,6 +215,8 @@ asn1c_type_name(arg_t *arg, asn1p_expr_t *expr, enum tnfmt _format) {
case TNF_RSAFE:
if(expr->expr_type == ASN_BASIC_REAL)
return "double";
else if(asn1c_type_fits_long(arg, expr) == FL_FITS_UNSIGN)
return "unsigned long";
else
return "long";
default:
@ -278,7 +280,7 @@ asn1c_type_name(arg_t *arg, asn1p_expr_t *expr, enum tnfmt _format) {
/*
* Check whether the specified INTEGER or ENUMERATED type can be represented
* using the generic 'long' type.
* using the generic 'long' or 'unsigned long' type.
*/
enum asn1c_fitslong_e
asn1c_type_fits_long(arg_t *arg, asn1p_expr_t *expr) {
@ -339,7 +341,7 @@ asn1c_type_fits_long(arg_t *arg, asn1p_expr_t *expr) {
right = range->right;
/* Use 4 instead of sizeof(long) is justified! */
if(right.type == ARE_VALUE && right.value <= 4)
return FL_FITSOK;
return FL_FITS_SIGNED;
}
asn1constraint_range_free(range);
}
@ -364,6 +366,15 @@ asn1c_type_fits_long(arg_t *arg, asn1p_expr_t *expr) {
right = range->right;
asn1constraint_range_free(range);
/* Special case for unsigned */
if(left.type == ARE_VALUE
&& left.value >= 0
&& right.type == ARE_VALUE
&& right.value > 2147483647
&& right.value <= 4294967295UL)
return FL_FITS_UNSIGN;
/* If some fixed value is outside of target range, not fit */
if(left.type == ARE_VALUE
&& (left.value < LEFTMIN || left.value > RIGHTMAX))
@ -378,6 +389,6 @@ asn1c_type_fits_long(arg_t *arg, asn1p_expr_t *expr) {
? FL_FORCED : FL_NOTFIT;
}
return FL_FITSOK;
return FL_FITS_SIGNED;
}

@ -30,12 +30,14 @@ char *asn1c_type_name(arg_t *arg, asn1p_expr_t *expr, enum tnfmt _format);
* using the generic 'long' type.
* Return values:
* FL_NOTFIT: No, it cannot be represented using long.
* FL_FITSOK: It can be represented using long.
* FL_FITS_SIGNED: It can be represented using signed long.
* FL_FITS_UNSIGN: It can be represented using unsigned long.
* FL_FORCED: Probably can't, but -fnative-types is in force.
*/
enum asn1c_fitslong_e {
FL_NOTFIT,
FL_FITSOK,
FL_FITS_SIGNED,
FL_FITS_UNSIGN,
FL_FORCED,
};
enum asn1c_fitslong_e asn1c_type_fits_long(arg_t *arg, asn1p_expr_t *expr);

@ -158,7 +158,9 @@ INTEGER__dump(asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_by
} else {
scrsize = sizeof(scratch);
scr = scratch;
ret = snprintf(scr, scrsize, "%ld", accum);
ret = snprintf(scr, scrsize,
(specs && specs->field_unsigned)
?"%lu":"%ld", accum);
}
assert(ret > 0 && (size_t)ret < scrsize);
return (cb(scr, ret, app_key) < 0) ? -1 : ret;
@ -554,6 +556,7 @@ INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
asn_dec_rval_t
INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
asn_dec_rval_t rval = { RC_OK, 0 };
INTEGER_t *st = (INTEGER_t *)*sptr;
asn_per_constraint_t *ct;
@ -611,7 +614,9 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
ASN_DEBUG("Got value %ld + low %ld",
value, ct->lower_bound);
value += ct->lower_bound;
if(asn_long2INTEGER(st, value))
if((specs && specs->field_unsigned)
? asn_ulong2INTEGER(st, value)
: asn_long2INTEGER(st, value))
_ASN_DECODE_FAILED;
return rval;
}
@ -657,6 +662,7 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
asn_enc_rval_t
INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
asn_enc_rval_t er;
INTEGER_t *st = (INTEGER_t *)sptr;
const uint8_t *buf;
@ -673,21 +679,41 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
if(ct) {
int inext = 0;
if(asn_INTEGER2long(st, &value))
_ASN_ENCODE_FAILED;
/* Check proper range */
if(ct->flags & APC_SEMI_CONSTRAINED) {
if(value < ct->lower_bound)
inext = 1;
} else if(ct->range_bits >= 0) {
if(value < ct->lower_bound
|| value > ct->upper_bound)
inext = 1;
if(specs && specs->field_unsigned) {
unsigned long uval;
if(asn_INTEGER2ulong(st, &uval))
_ASN_ENCODE_FAILED;
/* Check proper range */
if(ct->flags & APC_SEMI_CONSTRAINED) {
if(uval < (unsigned long)ct->lower_bound)
inext = 1;
} else if(ct->range_bits >= 0) {
if(uval < (unsigned long)ct->lower_bound
|| uval > (unsigned long)ct->upper_bound)
inext = 1;
}
ASN_DEBUG("Value %lu (%02x/%d) lb %lu ub %lu %s",
uval, st->buf[0], st->size,
ct->lower_bound, ct->upper_bound,
inext ? "ext" : "fix");
value = uval;
} else {
if(asn_INTEGER2long(st, &value))
_ASN_ENCODE_FAILED;
/* Check proper range */
if(ct->flags & APC_SEMI_CONSTRAINED) {
if(value < ct->lower_bound)
inext = 1;
} else if(ct->range_bits >= 0) {
if(value < ct->lower_bound
|| value > ct->upper_bound)
inext = 1;
}
ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s",
value, st->buf[0], st->size,
ct->lower_bound, ct->upper_bound,
inext ? "ext" : "fix");
}
ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s",
value, st->buf[0], st->size,
ct->lower_bound, ct->upper_bound,
inext ? "ext" : "fix");
if(ct->flags & APC_EXTENSIBLE) {
if(per_put_few_bits(po, inext, 1))
_ASN_ENCODE_FAILED;

@ -30,6 +30,8 @@ typedef struct asn_INTEGER_specifics_s {
int map_count; /* Elements in either map */
int extension; /* This map is extensible */
int strict_enumeration; /* Enumeration set is fixed */
int field_width; /* Size of native integer */
int field_unsigned; /* Signed=0, unsigned=1 */
} asn_INTEGER_specifics_t;
asn_struct_print_f INTEGER_print;

@ -196,7 +196,7 @@ NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
/*
* X.691, #10.6: normally small non-negative whole number;
*/
ASN_DEBUG("value = %d, ext = %d, inext = %d, res = %d",
ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld",
value, specs->extension, inext,
value - (inext ? (specs->extension - 1) : 0));
if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))

@ -48,6 +48,7 @@ asn_dec_rval_t
NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
asn_TYPE_descriptor_t *td,
void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
long *native = (long *)*nint_ptr;
asn_dec_rval_t rval;
ber_tlv_len_t length;
@ -105,7 +106,9 @@ NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
tmp.size = length;
if(asn_INTEGER2long(&tmp, &l)) {
if((specs&&specs->field_unsigned)
? asn_INTEGER2ulong(&tmp, &l)
: asn_INTEGER2long(&tmp, &l)) {
rval.code = RC_FAIL;
rval.consumed = 0;
return rval;
@ -167,6 +170,7 @@ asn_dec_rval_t
NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
const void *buf_ptr, size_t size) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
asn_dec_rval_t rval;
INTEGER_t st;
void *st_ptr = (void *)&st;
@ -182,7 +186,9 @@ NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
opt_mname, buf_ptr, size);
if(rval.code == RC_OK) {
long l;
if(asn_INTEGER2long(&st, &l)) {
if((specs&&specs->field_unsigned)
? asn_INTEGER2ulong(&st, &l)
: asn_INTEGER2long(&st, &l)) {
rval.code = RC_FAIL;
rval.consumed = 0;
} else {
@ -205,6 +211,7 @@ asn_enc_rval_t
NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
char scratch[32]; /* Enough for 64-bit int */
asn_enc_rval_t er;
const long *native = (const long *)sptr;
@ -214,7 +221,9 @@ NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(!native) _ASN_ENCODE_FAILED;
er.encoded = snprintf(scratch, sizeof(scratch), "%ld", *native);
er.encoded = snprintf(scratch, sizeof(scratch),
(specs && specs->field_unsigned)
? "%lu" : "%ld", *native);
if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)
|| cb(scratch, er.encoded, app_key) < 0)
_ASN_ENCODE_FAILED;
@ -227,6 +236,7 @@ NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
asn_dec_rval_t rval;
long *native = (long *)*sptr;
INTEGER_t tmpint;
@ -244,7 +254,9 @@ NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,
&tmpintptr, pd);
if(rval.code == RC_OK) {
if(asn_INTEGER2long(&tmpint, native))
if((specs&&specs->field_unsigned)
? asn_INTEGER2ulong(&tmpint, native)
: asn_INTEGER2long(&tmpint, native))
rval.code = RC_FAIL;
else
ASN_DEBUG("NativeInteger %s got value %ld",
@ -258,6 +270,7 @@ NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
asn_enc_rval_t
NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
asn_enc_rval_t er;
long native;
INTEGER_t tmpint;
@ -269,7 +282,9 @@ NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
memset(&tmpint, 0, sizeof(tmpint));
if(asn_long2INTEGER(&tmpint, native))
if((specs&&specs->field_unsigned)
? asn_ulong2INTEGER(&tmpint, native)
: asn_long2INTEGER(&tmpint, native))
_ASN_ENCODE_FAILED;
er = INTEGER_encode_uper(td, constraints, &tmpint, po);
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
@ -282,6 +297,7 @@ NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
int
NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
const long *native = (const long *)sptr;
char scratch[32]; /* Enough for 64-bit int */
int ret;
@ -290,7 +306,9 @@ NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
(void)ilevel; /* Unused argument */
if(native) {
ret = snprintf(scratch, sizeof(scratch), "%ld", *native);
ret = snprintf(scratch, sizeof(scratch),
(specs && specs->field_unsigned)
? "%lu" : "%ld", *native);
assert(ret > 0 && (size_t)ret < sizeof(scratch));
return (cb(scratch, ret, app_key) < 0) ? -1 : 0;
} else {

@ -222,7 +222,9 @@ static asn_INTEGER_specifics_t asn_SPC_field_specs_7 = {
asn_MAP_field_enum2value_7, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_field_tags_7[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))

@ -13,7 +13,9 @@ BEGIN
T ::= SEQUENCE {
small32range INTEGER (-2000000000..2000000000),
full32range INTEGER (-2147483648..2147483647)
full32range INTEGER (-2147483648..2147483647),
unsigned32 INTEGER (0..4294967295),
unsplit32 INTEGER (5..500|600..4294967290)
}
END

@ -0,0 +1,507 @@
/*** <<< INCLUDES [T] >>> ***/
#include <NativeInteger.h>
#include <constr_SEQUENCE.h>
/*** <<< TYPE-DECLS [T] >>> ***/
typedef struct T {
long small32range;
long full32range;
unsigned long unsigned32;
unsigned long unsplit32;
/* Context for parsing across buffer boundaries */
asn_struct_ctx_t _asn_ctx;
} T_t;
/*** <<< FUNC-DECLS [T] >>> ***/
/* extern asn_TYPE_descriptor_t asn_DEF_unsigned32_4; // (Use -fall-defs-global to expose) */
/* extern asn_TYPE_descriptor_t asn_DEF_unsplit32_5; // (Use -fall-defs-global to expose) */
extern asn_TYPE_descriptor_t asn_DEF_T;
/*** <<< CODE [T] >>> ***/
static int
unsigned32_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
value = *(const unsigned long *)sptr;
/* Constraint check succeeded */
return 0;
}
/*
* 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->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;
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) {
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
value = *(const unsigned long *)sptr;
if(((value >= 5 && value <= 500) || (value >= 600 && value <= 4294967290))) {
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
}
/*
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
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->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;
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) {
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
value = *(const long *)sptr;
if((value >= -2000000000 && value <= 2000000000)) {
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
}
static int
memb_full32range_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
value = *(const long *)sptr;
if((value >= (-2147483647L - 1) && value <= 2147483647)) {
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
}
static int
memb_unsigned32_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
value = *(const unsigned long *)sptr;
/* Constraint check succeeded */
return 0;
}
static int
memb_unsplit32_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
value = *(const unsigned long *)sptr;
if(((value >= 5 && value <= 500) || (value >= 600 && value <= 4294967290))) {
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
}
/*** <<< CTDEFS [T] >>> ***/
static asn_per_constraints_t asn_PER_type_unsigned32_constr_4 = {
{ APC_CONSTRAINED, 32, -1, 0, 4294967295 } /* (0..4294967295) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
};
static asn_per_constraints_t asn_PER_type_unsplit32_constr_5 = {
{ APC_CONSTRAINED, 32, -1, 5, 4294967290 } /* (5..4294967290) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
};
static asn_per_constraints_t asn_PER_memb_small32range_constr_2 = {
{ APC_CONSTRAINED, 32, -1, -2000000000, 2000000000 } /* (-2000000000..2000000000) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
};
static asn_per_constraints_t asn_PER_memb_full32range_constr_3 = {
{ APC_CONSTRAINED, 32, -1, (-2147483647L - 1), 2147483647 } /* (-2147483648..2147483647) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
};
static asn_per_constraints_t asn_PER_memb_unsigned32_constr_4 = {
{ APC_CONSTRAINED, 32, -1, 0, 4294967295 } /* (0..4294967295) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
};
static asn_per_constraints_t asn_PER_memb_unsplit32_constr_5 = {
{ APC_CONSTRAINED, 32, -1, 5, 4294967290 } /* (5..4294967290) */,
{ APC_UNCONSTRAINED, -1, -1, 0, 0 },
0, 0 /* No PER value map */
};
/*** <<< STAT-DEFS [T] >>> ***/
static asn_INTEGER_specifics_t asn_SPC_unsigned32_specs_4 = {
0, 0, 0, 0, 0,
0, /* Native long size */
1 /* Unsigned representation */
};
static ber_tlv_tag_t asn_DEF_unsigned32_tags_4[] = {
(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_unsigned32_4 = {
"unsigned32",
"unsigned32",
unsigned32_4_free,
unsigned32_4_print,
unsigned32_4_constraint,
unsigned32_4_decode_ber,
unsigned32_4_encode_der,
unsigned32_4_decode_xer,
unsigned32_4_encode_xer,
unsigned32_4_decode_uper,
unsigned32_4_encode_uper,
0, /* Use generic outmost tag fetcher */
asn_DEF_unsigned32_tags_4,
sizeof(asn_DEF_unsigned32_tags_4)
/sizeof(asn_DEF_unsigned32_tags_4[0]) - 1, /* 1 */
asn_DEF_unsigned32_tags_4, /* Same as above */
sizeof(asn_DEF_unsigned32_tags_4)
/sizeof(asn_DEF_unsigned32_tags_4[0]), /* 2 */
&asn_PER_type_unsigned32_constr_4,
0, 0, /* No members */
&asn_SPC_unsigned32_specs_4 /* Additional specs */
};
static asn_INTEGER_specifics_t asn_SPC_unsplit32_specs_5 = {
0, 0, 0, 0, 0,
0, /* Native long size */
1 /* Unsigned representation */
};
static ber_tlv_tag_t asn_DEF_unsplit32_tags_5[] = {
(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
static /* Use -fall-defs-global to expose */
asn_TYPE_descriptor_t asn_DEF_unsplit32_5 = {
"unsplit32",
"unsplit32",
unsplit32_5_free,
unsplit32_5_print,
unsplit32_5_constraint,
unsplit32_5_decode_ber,
unsplit32_5_encode_der,
unsplit32_5_decode_xer,
unsplit32_5_encode_xer,
unsplit32_5_decode_uper,
unsplit32_5_encode_uper,
0, /* Use generic outmost tag fetcher */
asn_DEF_unsplit32_tags_5,
sizeof(asn_DEF_unsplit32_tags_5)
/sizeof(asn_DEF_unsplit32_tags_5[0]) - 1, /* 1 */
asn_DEF_unsplit32_tags_5, /* Same as above */
sizeof(asn_DEF_unsplit32_tags_5)
/sizeof(asn_DEF_unsplit32_tags_5[0]), /* 2 */
&asn_PER_type_unsplit32_constr_5,
0, 0, /* No members */
&asn_SPC_unsplit32_specs_5 /* Additional specs */
};
static asn_TYPE_member_t asn_MBR_T_1[] = {
{ ATF_NOFLAGS, 0, offsetof(struct T, small32range),
.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
.type = &asn_DEF_NativeInteger,
.memb_constraints = memb_small32range_constraint_1,
.per_constraints = &asn_PER_memb_small32range_constr_2,
.default_value = 0,
.name = "small32range"
},
{ ATF_NOFLAGS, 0, offsetof(struct T, full32range),
.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
.type = &asn_DEF_NativeInteger,
.memb_constraints = memb_full32range_constraint_1,
.per_constraints = &asn_PER_memb_full32range_constr_3,
.default_value = 0,
.name = "full32range"
},
{ ATF_NOFLAGS, 0, offsetof(struct T, unsigned32),
.tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
.type = &asn_DEF_unsigned32_4,
.memb_constraints = memb_unsigned32_constraint_1,
.per_constraints = &asn_PER_memb_unsigned32_constr_4,
.default_value = 0,
.name = "unsigned32"
},
{ ATF_NOFLAGS, 0, offsetof(struct T, unsplit32),
.tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
.tag_mode = -1, /* IMPLICIT tag at current level */
.type = &asn_DEF_unsplit32_5,
.memb_constraints = memb_unsplit32_constraint_1,
.per_constraints = &asn_PER_memb_unsplit32_constr_5,
.default_value = 0,
.name = "unsplit32"
},
};
static ber_tlv_tag_t asn_DEF_T_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
};
static asn_TYPE_tag2member_t asn_MAP_T_tag2el_1[] = {
{ (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* small32range at 15 */
{ (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* full32range at 16 */
{ (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* unsigned32 at 17 */
{ (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* unsplit32 at 18 */
};
static asn_SEQUENCE_specifics_t asn_SPC_T_specs_1 = {
sizeof(struct T),
offsetof(struct T, _asn_ctx),
asn_MAP_T_tag2el_1,
4, /* Count of tags in the map */
0, 0, 0, /* Optional elements (not needed) */
-1, /* Start extensions */
-1 /* Stop extensions */
};
asn_TYPE_descriptor_t asn_DEF_T = {
"T",
"T",
SEQUENCE_free,
SEQUENCE_print,
SEQUENCE_constraint,
SEQUENCE_decode_ber,
SEQUENCE_encode_der,
SEQUENCE_decode_xer,
SEQUENCE_encode_xer,
SEQUENCE_decode_uper,
SEQUENCE_encode_uper,
0, /* Use generic outmost tag fetcher */
asn_DEF_T_tags_1,
sizeof(asn_DEF_T_tags_1)
/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
asn_DEF_T_tags_1, /* Same as above */
sizeof(asn_DEF_T_tags_1)
/sizeof(asn_DEF_T_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
asn_MBR_T_1,
4, /* Elements count */
&asn_SPC_T_specs_1 /* Additional specs */
};

@ -736,7 +736,9 @@ static asn_INTEGER_specifics_t asn_SPC_accept_as_specs_2 = {
asn_MAP_accept_as_enum2value_2, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
4, /* Extensions before this member */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_accept_as_tags_2[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))

@ -3759,7 +3759,9 @@ static asn_INTEGER_specifics_t asn_SPC_enum_c_specs_6 = {
asn_MAP_enum_c_enum2value_6, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
3, /* Extensions before this member */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_enum_c_tags_6[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
@ -4088,7 +4090,9 @@ static asn_INTEGER_specifics_t asn_SPC_Enum0_specs_1 = {
asn_MAP_Enum0_enum2value_1, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_Enum0_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
@ -4251,7 +4255,9 @@ static asn_INTEGER_specifics_t asn_SPC_Enum1_specs_1 = {
asn_MAP_Enum1_enum2value_1, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_Enum1_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))

@ -4384,7 +4384,9 @@ static asn_INTEGER_specifics_t asn_SPC_enum_c_specs_6 = {
asn_MAP_enum_c_enum2value_6, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
3, /* Extensions before this member */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_enum_c_tags_6[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
@ -4751,7 +4753,9 @@ static asn_INTEGER_specifics_t asn_SPC_Enum0_specs_1 = {
asn_MAP_Enum0_enum2value_1, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_Enum0_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
@ -4940,7 +4944,9 @@ static asn_INTEGER_specifics_t asn_SPC_Enum1_specs_1 = {
asn_MAP_Enum1_enum2value_1, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_Enum1_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))

@ -184,7 +184,9 @@ static asn_INTEGER_specifics_t asn_SPC_SimpleType_specs_1 = {
asn_MAP_SimpleType_enum2value_1, /* N => "tag"; sorted by N */
3, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_SimpleType_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))

@ -616,7 +616,9 @@ static asn_INTEGER_specifics_t asn_SPC_enum_specs_4 = {
asn_MAP_enum_enum2value_4, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_enum_tags_4[] = {
(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
@ -1146,7 +1148,9 @@ static asn_INTEGER_specifics_t asn_SPC_Member_specs_2 = {
asn_MAP_Member_enum2value_2, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
@ -1467,7 +1471,9 @@ static asn_INTEGER_specifics_t asn_SPC_name_specs_2 = {
asn_MAP_name_enum2value_2, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_name_tags_2[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))

@ -821,7 +821,9 @@ static asn_INTEGER_specifics_t asn_SPC_EnumType_specs_1 = {
asn_MAP_EnumType_enum2value_1, /* N => "tag"; sorted by N */
2, /* Number of elements in the maps */
0, /* Enumeration is not extensible */
1 /* Strict enumeration */
1, /* Strict enumeration */
0, /* Native long size */
0
};
static ber_tlv_tag_t asn_DEF_EnumType_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))

@ -557,11 +557,11 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
/*** <<< INCLUDES [NO-IntegerLowHigh] >>> ***/
#include <INTEGER.h>
#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerLowHigh] >>> ***/
typedef INTEGER_t NO_IntegerLowHigh_t;
typedef unsigned long NO_IntegerLowHigh_t;
/*** <<< FUNC-DECLS [NO-IntegerLowHigh] >>> ***/
@ -579,8 +579,7 @@ xer_type_encoder_f NO_IntegerLowHigh_encode_xer;
int
NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
const INTEGER_t *st = (const INTEGER_t *)sptr;
long value;
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
@ -589,12 +588,7 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
value = *(const unsigned long *)sptr;
if((value >= 1 && value <= 3000000000)) {
/* Constraint check succeeded */
@ -608,24 +602,24 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
}
/*
* This type is implemented using INTEGER,
* This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
NO_IntegerLowHigh_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->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->free_struct = asn_DEF_NativeInteger.free_struct;
td->print_struct = asn_DEF_NativeInteger.print_struct;
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;
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;
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 */
}
void
@ -675,6 +669,11 @@ NO_IntegerLowHigh_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
/*** <<< STAT-DEFS [NO-IntegerLowHigh] >>> ***/
static asn_INTEGER_specifics_t asn_SPC_NO_IntegerLowHigh_specs_1 = {
0, 0, 0, 0, 0,
0, /* Native long size */
1 /* Unsigned representation */
};
static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@ -698,7 +697,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
0, 0, /* No members */
0 /* No specifics */
&asn_SPC_NO_IntegerLowHigh_specs_1 /* Additional specs */
};
@ -1145,11 +1144,11 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
/*** <<< INCLUDES [NO-IntegerOutRange] >>> ***/