Commit 8bb57a29 authored by Lev Walkin's avatar Lev Walkin
Browse files

unsigned integer of 32-bit widtth support for per

parent f3c089ee
......@@ -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
/*** <<< 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;
}
/*