aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorvlm <vlm@59561ff5-6e30-0410-9f3c-9617f08c8826>2007-12-03 13:41:36 +0000
committervlm <vlm@59561ff5-6e30-0410-9f3c-9617f08c8826>2007-12-03 13:41:36 +0000
commit12164c45ff53facc3a379d64902a1d2c7cc926e7 (patch)
treec453a143c22610048408536ba901a65c1e6a9712
parent3811ffc9c3262340907c22f22f0546d0408837c0 (diff)
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
-rw-r--r--asn1c/tests/check-127.-fnative-types.-gen-PER.c48
-rw-r--r--libasn1compiler/asn1c_C.c32
-rw-r--r--libasn1compiler/asn1c_constraint.c61
-rw-r--r--libasn1compiler/asn1c_misc.c17
-rw-r--r--libasn1compiler/asn1c_misc.h6
-rw-r--r--skeletons/INTEGER.c58
-rw-r--r--skeletons/INTEGER.h2
-rw-r--r--skeletons/NativeEnumerated.c2
-rw-r--r--skeletons/NativeInteger.c30
-rw-r--r--tests/110-param-3-OK.asn1.-P4
-rw-r--r--tests/127-per-long-OK.asn14
-rw-r--r--tests/127-per-long-OK.asn1.-Pgen-PER507
-rw-r--r--tests/42-real-life-OK.asn1.-PR4
-rw-r--r--tests/50-constraint-OK.asn1.-P12
-rw-r--r--tests/50-constraint-OK.asn1.-Pgen-PER12
-rw-r--r--tests/66-ref-simple-OK.asn1.-P4
-rw-r--r--tests/70-xer-test-OK.asn1.-P12
-rw-r--r--tests/73-circular-OK.asn1.-P4
-rw-r--r--tests/90-cond-int-type-OK.asn1.-P199
-rw-r--r--tests/90-cond-int-type-OK.asn1.-Pfnative-types199
-rw-r--r--tests/90-cond-int-type-OK.asn1.-Pgen-PER199
21 files changed, 1036 insertions, 380 deletions
diff --git a/asn1c/tests/check-127.-fnative-types.-gen-PER.c b/asn1c/tests/check-127.-fnative-types.-gen-PER.c
index 9cca644b..34b6d748 100644
--- a/asn1c/tests/check-127.-fnative-types.-gen-PER.c
+++ b/asn1c/tests/check-127.-fnative-types.-gen-PER.c
@@ -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;
}
diff --git a/libasn1compiler/asn1c_C.c b/libasn1compiler/asn1c_C.c
index e2b4401a..be7f059a 100644
--- a/libasn1compiler/asn1c_C.c
+++ b/libasn1compiler/asn1c_C.c
@@ -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) {
diff --git a/libasn1compiler/asn1c_constraint.c b/libasn1compiler/asn1c_constraint.c
index ea9df803..2b1420e8 100644
--- a/libasn1compiler/asn1c_constraint.c
+++ b/libasn1compiler/asn1c_constraint.c
@@ -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");
@@ -133,6 +138,19 @@ asn1c_emit_constraint_checking_code(arg_t *arg) {
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.
*/
OUT("\n");
@@ -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;
+ }
+}
diff --git a/libasn1compiler/asn1c_misc.c b/libasn1compiler/asn1c_misc.c
index 543a165b..f48ab081 100644
--- a/libasn1compiler/asn1c_misc.c
+++ b/libasn1compiler/asn1c_misc.c
@@ -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;
}
diff --git a/libasn1compiler/asn1c_misc.h b/libasn1compiler/asn1c_misc.h
index b14a1555..6e2acb51 100644
--- a/libasn1compiler/asn1c_misc.h
+++ b/libasn1compiler/asn1c_misc.h
@@ -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);
diff --git a/skeletons/INTEGER.c b/skeletons/INTEGER.c
index a51dd11b..54a402b3 100644
--- a/skeletons/INTEGER.c
+++ b/skeletons/INTEGER.c
@@ -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;
diff --git a/skeletons/INTEGER.h b/skeletons/INTEGER.h
index b87c794c..8411bfcd 100644
--- a/skeletons/INTEGER.h
+++ b/skeletons/INTEGER.h
@@ -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;
diff --git a/skeletons/NativeEnumerated.c b/skeletons/NativeEnumerated.c
index b6b47e13..1554220f 100644
--- a/skeletons/NativeEnumerated.c
+++ b/skeletons/NativeEnumerated.c
@@ -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)))
diff --git a/skeletons/NativeInteger.c b/skeletons/NativeInteger.c
index b251ee7a..abdb71a8 100644
--- a/skeletons/NativeInteger.c
+++ b/skeletons/NativeInteger.c
@@ -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 {
diff --git a/tests/110-param-3-OK.asn1.-P b/tests/110-param-3-OK.asn1.-P
index 3cb1058b..9bd39a9b 100644
--- a/tests/110-param-3-OK.asn1.-P
+++ b/tests/110-param-3-OK.asn1.-P
@@ -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))
diff --git a/tests/127-per-long-OK.asn1 b/tests/127-per-long-OK.asn1
index 61d89aae..ad1c5008 100644
--- a/tests/127-per-long-OK.asn1
+++ b/tests/127-per-long-OK.asn1
@@ -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
diff --git a/tests/127-per-long-OK.asn1.-Pgen-PER b/tests/127-per-long-OK.asn1.-Pgen-PER
new file mode 100644
index 00000000..439468bd
--- /dev/null
+++ b/tests/127-per-long-OK.asn1.-Pgen-PER
@@ -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 */
+};
+
diff --git a/tests/42-real-life-OK.asn1.-PR b/tests/42-real-life-OK.asn1.-PR
index 898d941f..0fd30dca 100644
--- a/tests/42-real-life-OK.asn1.-PR
+++ b/tests/42-real-life-OK.asn1.-PR
@@ -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))
diff --git a/tests/50-constraint-OK.asn1.-P b/tests/50-constraint-OK.asn1.-P
index 67923076..5fcd1a91 100644
--- a/tests/50-constraint-OK.asn1.-P
+++ b/tests/50-constraint-OK.asn1.-P
@@ -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))
diff --git a/tests/50-constraint-OK.asn1.-Pgen-PER b/tests/50-constraint-OK.asn1.-Pgen-PER
index 4a959142..74903a6a 100644
--- a/tests/50-constraint-OK.asn1.-Pgen-PER
+++ b/tests/50-constraint-OK.asn1.-Pgen-PER
@@ -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))
diff --git a/tests/66-ref-simple-OK.asn1.-P b/tests/66-ref-simple-OK.asn1.-P
index 2eecf5e1..9d315e24 100644
--- a/tests/66-ref-simple-OK.asn1.-P
+++ b/tests/66-ref-simple-OK.asn1.-P
@@ -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))
diff --git a/tests/70-xer-test-OK.asn1.-P b/tests/70-xer-test-OK.asn1.-P
index aa7e11e1..e109a8b3 100644
--- a/tests/70-xer-test-OK.asn1.-P
+++ b/tests/70-xer-test-OK.asn1.-P
@@ -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))
diff --git a/tests/73-circular-OK.asn1.-P b/tests/73-circular-OK.asn1.-P
index 1ab4dbf4..fe581b66 100644
--- a/tests/73-circular-OK.asn1.-P
+++ b/tests/73-circular-OK.asn1.-P
@@ -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))
diff --git a/tests/90-cond-int-type-OK.asn1.-P b/tests/90-cond-int-type-OK.asn1.-P
index 5055e4d7..08f92d4d 100644
--- a/tests/90-cond-int-type-OK.asn1.-P
+++ b/tests/90-cond-int-type-OK.asn1.-P
@@ -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] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerOutRange] >>> ***/
-typedef INTEGER_t NO_IntegerOutRange_t;
+typedef unsigned long NO_IntegerOutRange_t;
/*** <<< FUNC-DECLS [NO-IntegerOutRange] >>> ***/
@@ -1167,8 +1166,7 @@ xer_type_encoder_f NO_IntegerOutRange_encode_xer;
int
NO_IntegerOutRange_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,
@@ -1177,12 +1175,7 @@ NO_IntegerOutRange_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 >= 3000000000 && value <= 3000000001)) {
/* Constraint check succeeded */
@@ -1196,24 +1189,24 @@ NO_IntegerOutRange_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_IntegerOutRange_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
@@ -1263,6 +1256,11 @@ NO_IntegerOutRange_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
/*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutRange_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -1286,17 +1284,17 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerOutRange_specs_1 /* Additional specs */
};
/*** <<< INCLUDES [NO-IntegerOutValue] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerOutValue] >>> ***/
-typedef INTEGER_t NO_IntegerOutValue_t;
+typedef unsigned long NO_IntegerOutValue_t;
/*** <<< FUNC-DECLS [NO-IntegerOutValue] >>> ***/
@@ -1314,8 +1312,7 @@ xer_type_encoder_f NO_IntegerOutValue_encode_xer;
int
NO_IntegerOutValue_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,
@@ -1324,12 +1321,7 @@ NO_IntegerOutValue_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 == 3000000000)) {
/* Constraint check succeeded */
@@ -1343,24 +1335,24 @@ NO_IntegerOutValue_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_IntegerOutValue_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
@@ -1410,6 +1402,11 @@ NO_IntegerOutValue_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
/*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutValue_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -1433,7 +1430,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerOutValue_specs_1 /* Additional specs */
};
@@ -2150,11 +2147,11 @@ asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
/*** <<< INCLUDES [NO-IntegerInRange6] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerInRange6] >>> ***/
-typedef INTEGER_t NO_IntegerInRange6_t;
+typedef unsigned long NO_IntegerInRange6_t;
/*** <<< FUNC-DECLS [NO-IntegerInRange6] >>> ***/
@@ -2172,8 +2169,7 @@ xer_type_encoder_f NO_IntegerInRange6_encode_xer;
int
NO_IntegerInRange6_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,
@@ -2182,43 +2178,31 @@ NO_IntegerInRange6_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 >= 0 && value <= 4294967295)) {
- /* Constraint check succeeded */
- return 0;
- } else {
- _ASN_CTFAIL(app_key, td, sptr,
- "%s: constraint failed (%s:%d)",
- td->name, __FILE__, __LINE__);
- return -1;
- }
+ /* Constraint check succeeded */
+ return 0;
}
/*
- * This type is implemented using INTEGER,
+ * This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
NO_IntegerInRange6_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
@@ -2268,6 +2252,11 @@ NO_IntegerInRange6_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
/*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerInRange6_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -2291,7 +2280,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerInRange6_specs_1 /* Additional specs */
};
diff --git a/tests/90-cond-int-type-OK.asn1.-Pfnative-types b/tests/90-cond-int-type-OK.asn1.-Pfnative-types
index 461e5eb5..4c898f8f 100644
--- a/tests/90-cond-int-type-OK.asn1.-Pfnative-types
+++ b/tests/90-cond-int-type-OK.asn1.-Pfnative-types
@@ -550,11 +550,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] >>> ***/
@@ -572,8 +572,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,
@@ -582,12 +581,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 */
@@ -601,24 +595,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
@@ -668,6 +662,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))
};
@@ -691,7 +690,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 */
};
@@ -1132,11 +1131,11 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
/*** <<< INCLUDES [NO-IntegerOutRange] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerOutRange] >>> ***/
-typedef INTEGER_t NO_IntegerOutRange_t;
+typedef unsigned long NO_IntegerOutRange_t;
/*** <<< FUNC-DECLS [NO-IntegerOutRange] >>> ***/
@@ -1154,8 +1153,7 @@ xer_type_encoder_f NO_IntegerOutRange_encode_xer;
int
NO_IntegerOutRange_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,
@@ -1164,12 +1162,7 @@ NO_IntegerOutRange_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 >= 3000000000 && value <= 3000000001)) {
/* Constraint check succeeded */
@@ -1183,24 +1176,24 @@ NO_IntegerOutRange_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_IntegerOutRange_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
@@ -1250,6 +1243,11 @@ NO_IntegerOutRange_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
/*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutRange_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -1273,17 +1271,17 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerOutRange_specs_1 /* Additional specs */
};
/*** <<< INCLUDES [NO-IntegerOutValue] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerOutValue] >>> ***/
-typedef INTEGER_t NO_IntegerOutValue_t;
+typedef unsigned long NO_IntegerOutValue_t;
/*** <<< FUNC-DECLS [NO-IntegerOutValue] >>> ***/
@@ -1301,8 +1299,7 @@ xer_type_encoder_f NO_IntegerOutValue_encode_xer;
int
NO_IntegerOutValue_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,
@@ -1311,12 +1308,7 @@ NO_IntegerOutValue_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 == 3000000000)) {
/* Constraint check succeeded */
@@ -1330,24 +1322,24 @@ NO_IntegerOutValue_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_IntegerOutValue_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
@@ -1397,6 +1389,11 @@ NO_IntegerOutValue_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
/*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutValue_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -1420,7 +1417,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerOutValue_specs_1 /* Additional specs */
};
@@ -2131,11 +2128,11 @@ asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
/*** <<< INCLUDES [NO-IntegerInRange6] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerInRange6] >>> ***/
-typedef INTEGER_t NO_IntegerInRange6_t;
+typedef unsigned long NO_IntegerInRange6_t;
/*** <<< FUNC-DECLS [NO-IntegerInRange6] >>> ***/
@@ -2153,8 +2150,7 @@ xer_type_encoder_f NO_IntegerInRange6_encode_xer;
int
NO_IntegerInRange6_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,
@@ -2163,43 +2159,31 @@ NO_IntegerInRange6_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 >= 0 && value <= 4294967295)) {
- /* Constraint check succeeded */
- return 0;
- } else {
- _ASN_CTFAIL(app_key, td, sptr,
- "%s: constraint failed (%s:%d)",
- td->name, __FILE__, __LINE__);
- return -1;
- }
+ /* Constraint check succeeded */
+ return 0;
}
/*
- * This type is implemented using INTEGER,
+ * This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
NO_IntegerInRange6_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
@@ -2249,6 +2233,11 @@ NO_IntegerInRange6_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
/*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerInRange6_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -2272,7 +2261,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
0, /* No PER visible constraints */
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerInRange6_specs_1 /* Additional specs */
};
diff --git a/tests/90-cond-int-type-OK.asn1.-Pgen-PER b/tests/90-cond-int-type-OK.asn1.-Pgen-PER
index d7957cba..5b16f460 100644
--- a/tests/90-cond-int-type-OK.asn1.-Pgen-PER
+++ b/tests/90-cond-int-type-OK.asn1.-Pgen-PER
@@ -653,11 +653,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] >>> ***/
@@ -677,8 +677,7 @@ per_type_encoder_f NO_IntegerLowHigh_encode_uper;
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,
@@ -687,12 +686,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 */
@@ -706,24 +700,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
@@ -796,6 +790,11 @@ static asn_per_constraints_t asn_PER_type_NO_IntegerLowHigh_constr_1 = {
/*** <<< 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))
};
@@ -820,7 +819,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
&asn_PER_type_NO_IntegerLowHigh_constr_1,
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerLowHigh_specs_1 /* Additional specs */
};
@@ -1345,11 +1344,11 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
/*** <<< INCLUDES [NO-IntegerOutRange] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerOutRange] >>> ***/
-typedef INTEGER_t NO_IntegerOutRange_t;
+typedef unsigned long NO_IntegerOutRange_t;
/*** <<< FUNC-DECLS [NO-IntegerOutRange] >>> ***/
@@ -1369,8 +1368,7 @@ per_type_encoder_f NO_IntegerOutRange_encode_uper;
int
NO_IntegerOutRange_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,
@@ -1379,12 +1377,7 @@ NO_IntegerOutRange_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 >= 3000000000 && value <= 3000000001)) {
/* Constraint check succeeded */
@@ -1398,24 +1391,24 @@ NO_IntegerOutRange_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_IntegerOutRange_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
@@ -1488,6 +1481,11 @@ static asn_per_constraints_t asn_PER_type_NO_IntegerOutRange_constr_1 = {
/*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutRange_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -1512,17 +1510,17 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
&asn_PER_type_NO_IntegerOutRange_constr_1,
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerOutRange_specs_1 /* Additional specs */
};
/*** <<< INCLUDES [NO-IntegerOutValue] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerOutValue] >>> ***/
-typedef INTEGER_t NO_IntegerOutValue_t;
+typedef unsigned long NO_IntegerOutValue_t;
/*** <<< FUNC-DECLS [NO-IntegerOutValue] >>> ***/
@@ -1542,8 +1540,7 @@ per_type_encoder_f NO_IntegerOutValue_encode_uper;
int
NO_IntegerOutValue_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,
@@ -1552,12 +1549,7 @@ NO_IntegerOutValue_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 == 3000000000)) {
/* Constraint check succeeded */
@@ -1571,24 +1563,24 @@ NO_IntegerOutValue_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_IntegerOutValue_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
@@ -1661,6 +1653,11 @@ static asn_per_constraints_t asn_PER_type_NO_IntegerOutValue_constr_1 = {
/*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutValue_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -1685,7 +1682,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
&asn_PER_type_NO_IntegerOutValue_constr_1,
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerOutValue_specs_1 /* Additional specs */
};
@@ -2532,11 +2529,11 @@ asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
/*** <<< INCLUDES [NO-IntegerInRange6] >>> ***/
-#include <INTEGER.h>
+#include <NativeInteger.h>
/*** <<< TYPE-DECLS [NO-IntegerInRange6] >>> ***/
-typedef INTEGER_t NO_IntegerInRange6_t;
+typedef unsigned long NO_IntegerInRange6_t;
/*** <<< FUNC-DECLS [NO-IntegerInRange6] >>> ***/
@@ -2556,8 +2553,7 @@ per_type_encoder_f NO_IntegerInRange6_encode_uper;
int
NO_IntegerInRange6_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,
@@ -2566,43 +2562,31 @@ NO_IntegerInRange6_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 >= 0 && value <= 4294967295)) {
- /* Constraint check succeeded */
- return 0;
- } else {
- _ASN_CTFAIL(app_key, td, sptr,
- "%s: constraint failed (%s:%d)",
- td->name, __FILE__, __LINE__);
- return -1;
- }
+ /* Constraint check succeeded */
+ return 0;
}
/*
- * This type is implemented using INTEGER,
+ * This type is implemented using NativeInteger,
* so here we adjust the DEF accordingly.
*/
static void
NO_IntegerInRange6_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
@@ -2675,6 +2659,11 @@ static asn_per_constraints_t asn_PER_type_NO_IntegerInRange6_constr_1 = {
/*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
+static asn_INTEGER_specifics_t asn_SPC_NO_IntegerInRange6_specs_1 = {
+ 0, 0, 0, 0, 0,
+ 0, /* Native long size */
+ 1 /* Unsigned representation */
+};
static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
@@ -2699,7 +2688,7 @@ asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
&asn_PER_type_NO_IntegerInRange6_constr_1,
0, 0, /* No members */
- 0 /* No specifics */
+ &asn_SPC_NO_IntegerInRange6_specs_1 /* Additional specs */
};