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

do not use reserved identifiers, contd

This commit is contained in:
Lev Walkin 2016-03-14 03:08:15 -07:00
parent c6cac8e958
commit 7c1dc05f0e
60 changed files with 656 additions and 655 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ChangeLog
View File

@ -9,6 +9,7 @@
* Fix autoreconf-2.69 failure by github.com/brchiu
* Fix C99 warnings. Fix by Adrien Destugues (github.com/pulkomandy).
* C89 compliance fix by Jaroslav Imrich (github.com/jariq).
* C standard compliance fixes by Markus Elfring (github.com/elfring).
0.9.27: 2014-Sep-17
* Build structure fixes for portability.

12
libasn1compiler/asn1c_constraint.c
View File

@ -130,7 +130,7 @@ asn1c_emit_constraint_checking_code(arg_t *arg) {
*/
OUT("if(!sptr) {\n");
INDENT(+1);
OUT("_ASN_CTFAIL(app_key, td, sptr,\n");
OUT("ASN__CTFAIL(app_key, td, sptr,\n");
OUT("\t\"%%s: value not given (%%s:%%d)\",\n");
OUT("\ttd->name, __FILE__, __LINE__);\n");
OUT("return -1;\n");
@ -215,7 +215,7 @@ asn1c_emit_constraint_checking_code(arg_t *arg) {
INDENT(-1);
OUT("} else {\n");
INDENT(+1);
OUT("_ASN_CTFAIL(app_key, td, sptr,\n");
OUT("ASN__CTFAIL(app_key, td, sptr,\n");
OUT("\t\"%%s: constraint failed (%%s:%%d)\",\n");
OUT("\ttd->name, __FILE__, __LINE__);\n");
OUT("return -1;\n");
@ -567,7 +567,7 @@ emit_size_determination_code(arg_t *arg, asn1p_expr_type_e etype) {
case ASN_STRING_UTF8String:
OUT("size = UTF8String_length(st);\n");
OUT("if((ssize_t)size < 0) {\n");
OUT("\t_ASN_CTFAIL(app_key, td, sptr,\n");
OUT("\tASN__CTFAIL(app_key, td, sptr,\n");
OUT("\t\t\"%%s: UTF-8: broken encoding (%%s:%%d)\",\n");
OUT("\t\ttd->name, __FILE__, __LINE__);\n");
OUT("\treturn -1;\n");
@ -637,7 +637,7 @@ emit_value_determination_code(arg_t *arg, asn1p_expr_type_e etype, asn1cnst_rang
/* Special case for treating unsigned longs */
OUT("if(asn_INTEGER2ulong(st, &value)) {\n");
INDENT(+1);
OUT("_ASN_CTFAIL(app_key, td, sptr,\n");
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");
@ -646,7 +646,7 @@ emit_value_determination_code(arg_t *arg, asn1p_expr_type_e etype, asn1cnst_rang
} else {
OUT("if(asn_INTEGER2long(st, &value)) {\n");
INDENT(+1);
OUT("_ASN_CTFAIL(app_key, td, sptr,\n");
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");
@ -659,7 +659,7 @@ emit_value_determination_code(arg_t *arg, asn1p_expr_type_e etype, asn1cnst_rang
if(arg->flags & A1C_USE_WIDE_TYPES) {
OUT("if(asn_REAL2double(st, &value)) {\n");
INDENT(+1);
OUT("_ASN_CTFAIL(app_key, td, sptr,\n");
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");

2
skeletons/ANY.c
View File

@ -39,7 +39,7 @@ ANY_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
/*
* Canonical XER-encoding of ANY type is not supported.
*/
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
/* Dump as binary */

16
skeletons/BIT_STRING.c
View File

@ -52,13 +52,13 @@ BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
if(st && st->buf) {
if((st->size == 0 && st->bits_unused)
|| st->bits_unused < 0 || st->bits_unused > 7) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: invalid padding byte (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -86,7 +86,7 @@ BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
uint8_t *end;
if(!st || !st->buf)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = 0;
@ -101,7 +101,7 @@ BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int nline = xcan?0:(((buf - st->buf) % 8) == 0);
if(p >= scend || nline) {
er.encoded += p - scratch;
_ASN_CALLBACK(scratch, p - scratch);
ASN__CALLBACK(scratch, p - scratch);
p = scratch;
if(nline) ASN__TEXT_INDENT(1, ilevel);
}
@ -113,7 +113,7 @@ BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(!xcan && ((buf - st->buf) % 8) == 0)
ASN__TEXT_INDENT(1, ilevel);
er.encoded += p - scratch;
_ASN_CALLBACK(scratch, p - scratch);
ASN__CALLBACK(scratch, p - scratch);
p = scratch;
if(buf == end) {
@ -123,14 +123,14 @@ BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
for(i = 7; i >= ubits; i--)
*p++ = (v & (1 << i)) ? 0x31 : 0x30;
er.encoded += p - scratch;
_ASN_CALLBACK(scratch, p - scratch);
ASN__CALLBACK(scratch, p - scratch);
}
if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}

6
skeletons/BMPString.c
View File

@ -165,12 +165,12 @@ BMPString_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)flags;
if(!st || !st->buf)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = BMPString__dump(st, cb, app_key);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
if(er.encoded < 0) ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
int

22
skeletons/BOOLEAN.c
View File

@ -129,7 +129,7 @@ BOOLEAN_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
erval.encoded += 1;
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
@ -186,19 +186,19 @@ BOOLEAN_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)ilevel;
(void)flags;
if(!st) _ASN_ENCODE_FAILED;
if(!st) ASN__ENCODE_FAILED;
if(*st) {
_ASN_CALLBACK("<true/>", 7);
ASN__CALLBACK("<true/>", 7);
er.encoded = 7;
} else {
_ASN_CALLBACK("<false/>", 8);
ASN__CALLBACK("<false/>", 8);
er.encoded = 8;
}
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
int
@ -245,7 +245,7 @@ BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
if(!st) {
st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
if(!st) _ASN_DECODE_FAILED;
if(!st) ASN__DECODE_FAILED;
}
/*
@ -254,7 +254,7 @@ BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
switch(per_get_few_bits(pd, 1)) {
case 1: *st = 1; break;
case 0: *st = 0; break;
case -1: default: _ASN_DECODE_STARVED;
case -1: default: ASN__DECODE_STARVED;
}
ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
@ -273,10 +273,10 @@ BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
(void)constraints;
if(!st) _ASN_ENCODE_FAILED;
if(!st) ASN__ENCODE_FAILED;
if(per_put_few_bits(po, *st ? 1 : 0, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}

4
skeletons/ENUMERATED.c
View File

@ -46,7 +46,7 @@ ENUMERATED_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td
if(!st) {
st = (ENUMERATED_t *)(*sptr = CALLOC(1, sizeof(*st)));
if(!st) _ASN_DECODE_FAILED;
if(!st) ASN__DECODE_FAILED;
}
rval = NativeEnumerated_decode_uper(opt_codec_ctx, td, constraints,
@ -64,7 +64,7 @@ ENUMERATED_encode_uper(asn_TYPE_descriptor_t *td,
long value;
if(asn_INTEGER2long(st, &value))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
return NativeEnumerated_encode_uper(td, constraints, &value, po);
}

18
skeletons/GeneralizedTime.c
View File

@ -151,7 +151,7 @@ static time_t timegm(struct tm *tm) {
#endif
#ifndef __ASN_INTERNAL_TEST_MODE__
#ifndef ASN___INTERNAL_TEST_MODE
/*
* GeneralizedTime basic type description.
@ -190,7 +190,7 @@ asn_TYPE_descriptor_t asn_DEF_GeneralizedTime = {
0 /* No specifics */
};
#endif /* __ASN_INTERNAL_TEST_MODE__ */
#endif /* ASN___INTERNAL_TEST_MODE */
/*
* Check that the time looks like the time.
@ -204,7 +204,7 @@ GeneralizedTime_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
errno = EPERM; /* Just an unlikely error code */
tloc = asn_GT2time(st, 0, 0);
if(tloc == -1 && errno != EPERM) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: Invalid time format: %s (%s:%d)",
td->name, strerror(errno), __FILE__, __LINE__);
return -1;
@ -230,10 +230,10 @@ GeneralizedTime_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
tloc = asn_GT2time_frac(st, &fv, &fd, &tm, 1); /* Recognize time */
if(tloc == -1 && errno != EPERM)
/* Failed to recognize time. Fail completely. */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
st = asn_time2GT_frac(0, &tm, fv, fd, 1); /* Save time canonically */
if(!st) _ASN_ENCODE_FAILED; /* Memory allocation failure. */
if(!st) ASN__ENCODE_FAILED; /* Memory allocation failure. */
erval = OCTET_STRING_encode_der(td, st, tag_mode, tag, cb, app_key);
@ -243,7 +243,7 @@ GeneralizedTime_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
return erval;
}
#ifndef __ASN_INTERNAL_TEST_MODE__
#ifndef ASN___INTERNAL_TEST_MODE
asn_enc_rval_t
GeneralizedTime_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
@ -260,10 +260,10 @@ GeneralizedTime_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(asn_GT2time_frac((GeneralizedTime_t *)sptr,
&fv, &fd, &tm, 1) == -1
&& errno != EPERM)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
gt = asn_time2GT_frac(0, &tm, fv, fd, 1);
if(!gt) _ASN_ENCODE_FAILED;
if(!gt) ASN__ENCODE_FAILED;
rv = OCTET_STRING_encode_xer_utf8(td, sptr, ilevel, flags,
cb, app_key);
@ -275,7 +275,7 @@ GeneralizedTime_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
}
}
#endif /* __ASN_INTERNAL_TEST_MODE__ */
#endif /* ASN___INTERNAL_TEST_MODE */
int
GeneralizedTime_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,

4
skeletons/IA5String.c
View File

@ -55,7 +55,7 @@ IA5String_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
*/
for(; buf < end; buf++) {
if(*buf > 0x7F) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value byte %ld out of range: "
"%d > 127 (%s:%d)",
td->name,
@ -66,7 +66,7 @@ IA5String_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
}
}
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

56
skeletons/INTEGER.c
View File

@ -544,12 +544,12 @@ INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)flags;
if(!st || !st->buf)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
if(er.encoded < 0) ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
#ifndef ASN_DISABLE_PER_SUPPORT
@ -567,7 +567,7 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
if(!st) {
st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
if(!st) _ASN_DECODE_FAILED;
if(!st) ASN__DECODE_FAILED;
}
if(!constraints) constraints = td->per_constraints;
@ -575,7 +575,7 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
if(ct && ct->flags & APC_EXTENSIBLE) {
int inext = per_get_few_bits(pd, 1);
if(inext < 0) _ASN_DECODE_STARVED;
if(inext < 0) ASN__DECODE_STARVED;
if(inext) ct = 0;
}
@ -585,12 +585,12 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
if(ct) {
if(ct->flags & APC_SEMI_CONSTRAINED) {
st->buf = (uint8_t *)CALLOC(1, 2);
if(!st->buf) _ASN_DECODE_FAILED;
if(!st->buf) ASN__DECODE_FAILED;
st->size = 1;
} else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
size_t size = (ct->range_bits + 7) >> 3;
st->buf = (uint8_t *)MALLOC(1 + size + 1);
if(!st->buf) _ASN_DECODE_FAILED;
if(!st->buf) ASN__DECODE_FAILED;
st->size = size;
}
}
@ -601,28 +601,28 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
ASN_DEBUG("Integer with range %d bits", ct->range_bits);
if(ct->range_bits >= 0) {
if((size_t)ct->range_bits > 8 * sizeof(unsigned long))
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
if(specs && specs->field_unsigned) {
unsigned long uvalue;
if(uper_get_constrained_whole_number(pd,
&uvalue, ct->range_bits))
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
ASN_DEBUG("Got value %lu + low %ld",
uvalue, ct->lower_bound);
uvalue += ct->lower_bound;
if(asn_ulong2INTEGER(st, uvalue))
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
} else {
unsigned long svalue;
if(uper_get_constrained_whole_number(pd,
&svalue, ct->range_bits))
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
ASN_DEBUG("Got value %ld + low %ld",
svalue, ct->lower_bound);
svalue += ct->lower_bound;
if(asn_long2INTEGER(st, svalue))
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
return rval;
}
@ -638,14 +638,14 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
/* Get the PER length */
len = uper_get_length(pd, -1, &repeat);
if(len < 0) _ASN_DECODE_STARVED;
if(len < 0) ASN__DECODE_STARVED;
p = REALLOC(st->buf, st->size + len + 1);
if(!p) _ASN_DECODE_FAILED;
if(!p) ASN__DECODE_FAILED;
st->buf = (uint8_t *)p;
ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
if(ret < 0) _ASN_DECODE_STARVED;
if(ret < 0) ASN__DECODE_STARVED;
st->size += len;
} while(repeat);
st->buf[st->size] = 0; /* JIC */
@ -657,9 +657,9 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
*/
long value;
if(asn_INTEGER2long(st, &value))
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
if(asn_long2INTEGER(st, value + ct->lower_bound))
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
return rval;
@ -677,7 +677,7 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
long value = 0;
unsigned long v = 0;
if(!st || st->size == 0) _ASN_ENCODE_FAILED;
if(!st || st->size == 0) ASN__ENCODE_FAILED;
if(!constraints) constraints = td->per_constraints;
ct = constraints ? &constraints->value : 0;
@ -689,7 +689,7 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
if(specs && specs->field_unsigned) {
unsigned long uval;
if(asn_INTEGER2ulong(st, &uval))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
/* Check proper range */
if(ct->flags & APC_SEMI_CONSTRAINED) {
if(uval < (unsigned long)ct->lower_bound)
@ -706,7 +706,7 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
value = uval;
} else {
if(asn_INTEGER2long(st, &value))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
/* Check proper range */
if(ct->flags & APC_SEMI_CONSTRAINED) {
if(value < ct->lower_bound)
@ -723,10 +723,10 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
}
if(ct->flags & APC_EXTENSIBLE) {
if(per_put_few_bits(po, inext, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(inext) ct = 0;
} else if(inext) {
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
}
@ -738,26 +738,26 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
value, value - ct->lower_bound, ct->range_bits);
v = value - ct->lower_bound;
if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
_ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODE_FAILED;
ASN__ENCODED_OK(er);
}
if(ct && ct->lower_bound) {
ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
/* TODO: adjust lower bound */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
for(buf = st->buf, end = st->buf + st->size; buf < end;) {
ssize_t mayEncode = uper_put_length(po, end - buf);
if(mayEncode < 0)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(per_put_many_bits(po, buf, 8 * mayEncode))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
buf += mayEncode;
}
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
#endif /* ASN_DISABLE_PER_SUPPORT */

8
skeletons/NULL.c
View File

@ -47,7 +47,7 @@ NULL_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
erval.structure_ptr = ptr;
}
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
asn_enc_rval_t
@ -65,7 +65,7 @@ NULL_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
/* XMLNullValue is empty */
er.encoded = 0;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
@ -123,7 +123,7 @@ NULL_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
if(*sptr) {
*(NULL_t *)*sptr = 0;
} else {
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
}
@ -147,5 +147,5 @@ NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
(void)po;
er.encoded = 0;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}

50
skeletons/NativeEnumerated.c
View File

@ -52,7 +52,7 @@ NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)ilevel;
(void)flags;
if(!native) _ASN_ENCODE_FAILED;
if(!native) ASN__ENCODE_FAILED;
el = INTEGER_map_value2enum(specs, *native);
if(el) {
@ -61,12 +61,12 @@ NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name);
assert(er.encoded > 0 && (size_t)er.encoded < srcsize);
if(cb(src, er.encoded, app_key) < 0) _ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
if(cb(src, er.encoded, app_key) < 0) ASN__ENCODE_FAILED;
ASN__ENCODED_OK(er);
} else {
ASN_DEBUG("ASN.1 forbids dealing with "
"unknown value of ENUMERATED type");
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
}
@ -84,39 +84,39 @@ NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
if(constraints) ct = &constraints->value;
else if(td->per_constraints) ct = &td->per_constraints->value;
else _ASN_DECODE_FAILED; /* Mandatory! */
if(!specs) _ASN_DECODE_FAILED;
else ASN__DECODE_FAILED; /* Mandatory! */
if(!specs) ASN__DECODE_FAILED;
if(!native) {
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
if(!native) _ASN_DECODE_FAILED;
if(!native) ASN__DECODE_FAILED;
}
ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
if(ct->flags & APC_EXTENSIBLE) {
int inext = per_get_few_bits(pd, 1);
if(inext < 0) _ASN_DECODE_STARVED;
if(inext < 0) ASN__DECODE_STARVED;
if(inext) ct = 0;
}
if(ct && ct->range_bits >= 0) {
value = per_get_few_bits(pd, ct->range_bits);
if(value < 0) _ASN_DECODE_STARVED;
if(value < 0) ASN__DECODE_STARVED;
if(value >= (specs->extension
? specs->extension - 1 : specs->map_count))
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
} else {
if(!specs->extension)
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
/*
* X.691, #10.6: normally small non-negative whole number;
*/
value = uper_get_nsnnwn(pd);
if(value < 0) _ASN_DECODE_STARVED;
if(value < 0) ASN__DECODE_STARVED;
value += specs->extension - 1;
if(value >= specs->map_count)
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
*native = specs->value2enum[value].nat_value;
@ -147,26 +147,26 @@ NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
asn_INTEGER_enum_map_t key;
const asn_INTEGER_enum_map_t *kf;
if(!sptr) _ASN_ENCODE_FAILED;
if(!specs) _ASN_ENCODE_FAILED;
if(!sptr) ASN__ENCODE_FAILED;
if(!specs) ASN__ENCODE_FAILED;
if(constraints) ct = &constraints->value;
else if(td->per_constraints) ct = &td->per_constraints->value;
else _ASN_ENCODE_FAILED; /* Mandatory! */
else ASN__ENCODE_FAILED; /* Mandatory! */
ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
er.encoded = 0;
native = *(long *)sptr;
if(native < 0) _ASN_ENCODE_FAILED;
if(native < 0) ASN__ENCODE_FAILED;
key.nat_value = native;
kf = bsearch(&key, specs->value2enum, specs->map_count,
sizeof(key), NativeEnumerated__compar_value2enum);
if(!kf) {
ASN_DEBUG("No element corresponds to %ld", native);
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
value = kf - specs->value2enum;
@ -178,20 +178,20 @@ NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
}
if(ct->flags & APC_EXTENSIBLE) {
if(per_put_few_bits(po, inext, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(inext) ct = 0;
} else if(inext) {
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
if(ct && ct->range_bits >= 0) {
if(per_put_few_bits(po, value, ct->range_bits))
_ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODE_FAILED;
ASN__ENCODED_OK(er);
}
if(!specs->extension)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
/*
* X.691, #10.6: normally small non-negative whole number;
@ -200,8 +200,8 @@ NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
value, specs->extension, inext,
value - (inext ? (specs->extension - 1) : 0));
if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}

14
skeletons/NativeInteger.c
View File

@ -178,7 +178,7 @@ NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
if(!native) {
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
if(!native) _ASN_DECODE_FAILED;
if(!native) ASN__DECODE_FAILED;
}
memset(&st, 0, sizeof(st));
@ -219,16 +219,16 @@ NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)ilevel;
(void)flags;
if(!native) _ASN_ENCODE_FAILED;
if(!native) ASN__ENCODE_FAILED;
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;
ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
asn_dec_rval_t
@ -247,7 +247,7 @@ NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
if(!native) {
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
if(!native) _ASN_DECODE_FAILED;
if(!native) ASN__DECODE_FAILED;
}
memset(&tmpint, 0, sizeof tmpint);
@ -275,7 +275,7 @@ NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
long native;
INTEGER_t tmpint;
if(!sptr) _ASN_ENCODE_FAILED;
if(!sptr) ASN__ENCODE_FAILED;
native = *(long *)sptr;
@ -285,7 +285,7 @@ NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
if((specs&&specs->field_unsigned)
? asn_ulong2INTEGER(&tmpint, native)
: asn_long2INTEGER(&tmpint, native))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er = INTEGER_encode_uper(td, constraints, &tmpint, po);
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
return er;

12
skeletons/NativeReal.c
View File

@ -210,7 +210,7 @@ NativeReal_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
*dbl_ptr = CALLOC(1, sizeof(*Dbl));
Dbl = (double *)*dbl_ptr;
if(Dbl == NULL)
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
memset(&tmp, 0, sizeof(tmp));
@ -223,7 +223,7 @@ NativeReal_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
ret = asn_REAL2double(&tmp, Dbl);
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_REAL, &tmp);
if(ret) _ASN_DECODE_FAILED;
if(ret) ASN__DECODE_FAILED;
return rval;
}
@ -244,7 +244,7 @@ NativeReal_encode_uper(asn_TYPE_descriptor_t *td,
memset(&tmp, 0, sizeof(tmp));
if(asn_double2REAL(&tmp, Dbl))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
/* Encode a DER REAL */
erval = OCTET_STRING_encode_uper(td, NULL, &tmp, po);
@ -302,12 +302,12 @@ NativeReal_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)ilevel;
if(!Dbl) _ASN_ENCODE_FAILED;
if(!Dbl) ASN__ENCODE_FAILED;
er.encoded = REAL__dump(*Dbl, flags & XER_F_CANONICAL, cb, app_key);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
if(er.encoded < 0) ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
/*

4
skeletons/NumericString.c
View File

@ -81,7 +81,7 @@ NumericString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
continue;
}
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value byte %ld (%d) "
"not in NumericString alphabet (%s:%d)",
td->name,
@ -91,7 +91,7 @@ NumericString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
return -1;
}
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

10
skeletons/OBJECT_IDENTIFIER.c
View File

@ -47,14 +47,14 @@ OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
if(st && st->buf) {
if(st->size < 1) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: at least one numerical value "
"expected (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -330,12 +330,12 @@ OBJECT_IDENTIFIER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)flags;
if(!st || !st->buf)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
if(er.encoded < 0) ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
int

58
skeletons/OCTET_STRING.c
View File

@ -548,7 +548,7 @@ OCTET_STRING_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
if(!cb) {
er.encoded += (type_variant == ASN_OSUBV_BIT) + st->size;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
/*
@ -557,23 +557,23 @@ OCTET_STRING_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
if(type_variant == ASN_OSUBV_BIT) {
uint8_t b = st->bits_unused & 0x07;
if(b && st->size) fix_last_byte = 1;
_ASN_CALLBACK(&b, 1);
ASN__CALLBACK(&b, 1);
er.encoded++;
}
/* Invoke callback for the main part of the buffer */
_ASN_CALLBACK(st->buf, st->size - fix_last_byte);
ASN__CALLBACK(st->buf, st->size - fix_last_byte);
/* The last octet should be stripped off the unused bits */
if(fix_last_byte) {
uint8_t b = st->buf[st->size-1] & (0xff << st->bits_unused);
_ASN_CALLBACK(&b, 1);
ASN__CALLBACK(&b, 1);
}
er.encoded += st->size;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
asn_enc_rval_t
@ -590,7 +590,7 @@ OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
size_t i;
if(!st || (!st->buf && st->size))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = 0;
@ -603,7 +603,7 @@ OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
char *scend = scratch + (sizeof(scratch) - 2);
for(; buf < end; buf++) {
if(p >= scend) {
_ASN_CALLBACK(scratch, p - scratch);
ASN__CALLBACK(scratch, p - scratch);
er.encoded += p - scratch;
p = scratch;
}
@ -611,12 +611,12 @@ OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
*p++ = h2c[*buf & 0x0F];
}
_ASN_CALLBACK(scratch, p-scratch); /* Dump the rest */
ASN__CALLBACK(scratch, p-scratch); /* Dump the rest */
er.encoded += p - scratch;
} else {
for(i = 0; buf < end; buf++, i++) {
if(!(i % 16) && (i || st->size > 16)) {
_ASN_CALLBACK(scratch, p-scratch);
ASN__CALLBACK(scratch, p-scratch);
er.encoded += (p-scratch);
p = scratch;
ASN__TEXT_INDENT(1, ilevel);
@ -627,16 +627,16 @@ OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
}
if(p - scratch) {
p--; /* Remove the tail space */
_ASN_CALLBACK(scratch, p-scratch); /* Dump the rest */
ASN__CALLBACK(scratch, p-scratch); /* Dump the rest */
er.encoded += p - scratch;
if(st->size > 16)
ASN__TEXT_INDENT(1, ilevel-1);
}
}
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
static const struct OCTET_STRING__xer_escape_table_s {
@ -746,7 +746,7 @@ OCTET_STRING_encode_xer_utf8(asn_TYPE_descriptor_t *td, void *sptr,
(void)flags; /* Unused argument */
if(!st || (!st->buf && st->size))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
buf = st->buf;
end = buf + st->size;
@ -763,7 +763,7 @@ OCTET_STRING_encode_xer_utf8(asn_TYPE_descriptor_t *td, void *sptr,
if(((buf - ss) && cb(ss, buf - ss, app_key) < 0)
|| cb(OCTET_STRING__xer_escape_table[ch].string, s_len,
app_key) < 0)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
encoded_len += (buf - ss) + s_len;
ss = buf + 1;
}
@ -771,10 +771,10 @@ OCTET_STRING_encode_xer_utf8(asn_TYPE_descriptor_t *td, void *sptr,
encoded_len += (buf - ss);
if((buf - ss) && cb(ss, buf - ss, app_key) < 0)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = encoded_len;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
/*
@ -1520,7 +1520,7 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
int ct_extensible;
if(!st || (!st->buf && st->size))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(pc) {
cval = &pc->value;
@ -1534,7 +1534,7 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
switch(specs->subvariant) {
default:
case ASN_OSUBV_ANY:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
case ASN_OSUBV_BIT:
canonical_unit_bits = unit_bits = 1;
bpc = OS__BPC_BIT;
@ -1582,7 +1582,7 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
unit_bits = canonical_unit_bits;
inext = 1;
} else
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
} else {
inext = 0;
@ -1591,7 +1591,7 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
if(ct_extensible) {
/* Declare whether length is [not] within extension root */
if(per_put_few_bits(po, inext, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
/* X.691, #16.5: zero-length encoding */
@ -1603,7 +1603,7 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
csiz->effective_bits);
ret = per_put_few_bits(po, sizeinunits - csiz->lower_bound,
csiz->effective_bits);
if(ret) _ASN_ENCODE_FAILED;
if(ret) ASN__ENCODE_FAILED;
if(bpc) {
ret = OCTET_STRING_per_put_characters(po, st->buf,
sizeinunits, bpc, unit_bits,
@ -1612,22 +1612,22 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
ret = per_put_many_bits(po, st->buf,
sizeinunits * unit_bits);
}
if(ret) _ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
if(ret) ASN__ENCODE_FAILED;
ASN__ENCODED_OK(er);
}
ASN_DEBUG("Encoding %d bytes", st->size);
if(sizeinunits == 0) {
if(uper_put_length(po, 0))
_ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODE_FAILED;
ASN__ENCODED_OK(er);
}
buf = st->buf;
while(sizeinunits) {
ssize_t maySave = uper_put_length(po, sizeinunits);
if(maySave < 0) _ASN_ENCODE_FAILED;
if(maySave < 0) ASN__ENCODE_FAILED;
ASN_DEBUG("Encoding %ld of %ld",
(long)maySave, (long)sizeinunits);
@ -1639,7 +1639,7 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
} else {
ret = per_put_many_bits(po, buf, maySave * unit_bits);
}
if(ret) _ASN_ENCODE_FAILED;
if(ret) ASN__ENCODE_FAILED;
if(bpc)
buf += maySave * bpc;
@ -1649,7 +1649,7 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
assert(!(maySave & 0x07) || !sizeinunits);
}
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
int

4
skeletons/PrintableString.c
View File

@ -87,7 +87,7 @@ PrintableString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
*/
for(; buf < end; buf++) {
if(!_PrintableString_alphabet[*buf]) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value byte %ld (%d) "
"not in PrintableString alphabet "
"(%s:%d)",
@ -99,7 +99,7 @@ PrintableString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
}
}
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

6
skeletons/REAL.c
View File

@ -288,12 +288,12 @@ REAL_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)ilevel;
if(!st || !st->buf || asn_REAL2double(st, &d))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = REAL__dump(d, flags & XER_F_CANONICAL, cb, app_key);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
if(er.encoded < 0) ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}

6
skeletons/RELATIVE-OID.c
View File

@ -153,12 +153,12 @@ RELATIVE_OID_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)flags; /* Unused argument */
if(!st || !st->buf)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = RELATIVE_OID__dump_body(st, cb, app_key);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
if(er.encoded < 0) ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
int

14
skeletons/UTCTime.c
View File

@ -13,7 +13,7 @@
#include <time.h>
#endif /* __CYGWIN__ */
#ifndef __ASN_INTERNAL_TEST_MODE__
#ifndef ASN___INTERNAL_TEST_MODE
/*
* UTCTime basic type description.
@ -52,7 +52,7 @@ asn_TYPE_descriptor_t asn_DEF_UTCTime = {
0 /* No specifics */
};
#endif /* __ASN_INTERNAL_TEST_MODE__ */
#endif /* ASN___INTERNAL_TEST_MODE */
/*
* Check that the time looks like the time.
@ -66,7 +66,7 @@ UTCTime_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
errno = EPERM; /* Just an unlikely error code */
tloc = asn_UT2time(st, 0, 0);
if(tloc == -1 && errno != EPERM) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: Invalid time format: %s (%s:%d)",
td->name, strerror(errno), __FILE__, __LINE__);
return -1;
@ -75,7 +75,7 @@ UTCTime_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
return 0;
}
#ifndef __ASN_INTERNAL_TEST_MODE__
#ifndef ASN___INTERNAL_TEST_MODE
asn_enc_rval_t
UTCTime_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
@ -90,11 +90,11 @@ UTCTime_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
errno = EPERM;
if(asn_UT2time((UTCTime_t *)sptr, &tm, 1) == -1
&& errno != EPERM)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
/* Fractions are not allowed in UTCTime */
ut = asn_time2GT(0, 0, 1);
if(!ut) _ASN_ENCODE_FAILED;
if(!ut) ASN__ENCODE_FAILED;
rv = OCTET_STRING_encode_xer_utf8(td, sptr, ilevel, flags,
cb, app_key);
@ -106,7 +106,7 @@ UTCTime_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
}
}
#endif /* __ASN_INTERNAL_TEST_MODE__ */
#endif /* ASN___INTERNAL_TEST_MODE */
int
UTCTime_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,

10
skeletons/UTF8String.c
View File

@ -73,26 +73,26 @@ UTF8String_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
ssize_t len = UTF8String_length((const UTF8String_t *)sptr);
switch(len) {
case U8E_EINVAL:
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given", td->name);
break;
case U8E_TRUNC:
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: truncated UTF-8 sequence (%s:%d)",
td->name, __FILE__, __LINE__);
break;
case U8E_ILLSTART:
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8 illegal start of encoding (%s:%d)",
td->name, __FILE__, __LINE__);
break;
case U8E_NOTCONT:
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8 not continuation (%s:%d)",
td->name, __FILE__, __LINE__);
break;
case U8E_NOTMIN:
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8 not minimal sequence (%s:%d)",
td->name, __FILE__, __LINE__);
break;

6
skeletons/UniversalString.c
View File

@ -175,12 +175,12 @@ UniversalString_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
(void)flags;
if(!st || !st->buf)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = UniversalString__dump(st, cb, app_key);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
if(er.encoded < 0) ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
int

4
skeletons/VisibleString.c
View File

@ -58,7 +58,7 @@ VisibleString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
*/
for(; buf < end; buf++) {
if(*buf < 0x20 || *buf > 0x7e) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value byte %ld (%d) "
"not in VisibleString alphabet (%s:%d)",
td->name,
@ -69,7 +69,7 @@ VisibleString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
}
}
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

8
skeletons/asn_codecs.h
View File

@ -57,7 +57,7 @@ typedef struct asn_enc_rval_s {
/* Pointer to the structure of that type */
void *structure_ptr;
} asn_enc_rval_t;
#define _ASN_ENCODE_FAILED do { \
#define ASN__ENCODE_FAILED do { \
asn_enc_rval_t tmp_error; \
tmp_error.encoded = -1; \
tmp_error.failed_type = td; \
@ -65,7 +65,7 @@ typedef struct asn_enc_rval_s {
ASN_DEBUG("Failed to encode element %s", td ? td->name : ""); \
return tmp_error; \
} while(0)
#define _ASN_ENCODED_OK(rval) do { \
#define ASN__ENCODED_OK(rval) do { \
rval.structure_ptr = 0; \
rval.failed_type = 0; \
return rval; \
@ -88,14 +88,14 @@ typedef struct asn_dec_rval_s {
enum asn_dec_rval_code_e code; /* Result code */
size_t consumed; /* Number of bytes consumed */
} asn_dec_rval_t;
#define _ASN_DECODE_FAILED do { \
#define ASN__DECODE_FAILED do { \
asn_dec_rval_t tmp_error; \
tmp_error.code = RC_FAIL; \
tmp_error.consumed = 0; \
ASN_DEBUG("Failed to decode element %s", td ? td->name : ""); \
return tmp_error; \
} while(0)
#define _ASN_DECODE_STARVED do { \
#define ASN__DECODE_STARVED do { \
asn_dec_rval_t tmp_error; \
tmp_error.code = RC_WMORE; \
tmp_error.consumed = 0; \

14
skeletons/asn_codecs_prim.c
View File

@ -22,7 +22,7 @@ ber_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
*/
if(st == NULL) {
st = (ASN__PRIMITIVE_TYPE_t *)CALLOC(1, sizeof(*st));
if(st == NULL) _ASN_DECODE_FAILED;
if(st == NULL) ASN__DECODE_FAILED;
*sptr = (void *)st;
}
@ -55,13 +55,13 @@ ber_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
if(sizeof(st->size) != sizeof(length)
&& (ber_tlv_len_t)st->size != length) {
st->size = 0;
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
st->buf = (uint8_t *)MALLOC(length + 1);
if(!st->buf) {
st->size = 0;
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
memcpy(st->buf, buf_ptr, length);
@ -111,7 +111,7 @@ der_encode_primitive(asn_TYPE_descriptor_t *td, void *sptr,
}
erval.encoded += st->size;
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
void
@ -258,7 +258,7 @@ xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
*/
if(!*sptr) {
*sptr = CALLOC(1, struct_size);
if(!*sptr) _ASN_DECODE_FAILED;
if(!*sptr) ASN__DECODE_FAILED;
}
memset(&s_ctx, 0, sizeof(s_ctx));
@ -288,7 +288,7 @@ xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
/*
* This decoder does not like empty stuff.
*/
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
}
break;
@ -304,7 +304,7 @@ xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
if(s_arg.want_more)
rc.code = RC_WMORE;
else
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
break;
}
return rc;

14
skeletons/asn_internal.h
View File

@ -70,11 +70,11 @@ static void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
#define ASN__E_CALLBACK(foo) do { \
if(foo) goto cb_failed; \
} while(0)
#define _ASN_CALLBACK(buf, size) \
#define ASN__CALLBACK(buf, size) \
ASN__E_CALLBACK(ASN__E_cbc(buf, size))
#define _ASN_CALLBACK2(buf1, size1, buf2, size2) \
#define ASN__CALLBACK2(buf1, size1, buf2, size2) \
ASN__E_CALLBACK(ASN__E_cbc(buf1, size1) || ASN__E_cbc(buf2, size2))
#define _ASN_CALLBACK3(buf1, size1, buf2, size2, buf3, size3) \
#define ASN__CALLBACK3(buf1, size1, buf2, size2, buf3, size3) \
ASN__E_CALLBACK(ASN__E_cbc(buf1, size1) \
|| ASN__E_cbc(buf2, size2) \
|| ASN__E_cbc(buf3, size3))
@ -83,10 +83,10 @@ static void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
int tmp_level = (level); \
int tmp_nl = ((nl) != 0); \
int tmp_i; \
if(tmp_nl) _ASN_CALLBACK("\n", 1); \
if(tmp_nl) ASN__CALLBACK("\n", 1); \
if(tmp_level < 0) tmp_level = 0; \
for(tmp_i = 0; tmp_i < tmp_level; tmp_i++) \
_ASN_CALLBACK(" ", 4); \
ASN__CALLBACK(" ", 4); \
er.encoded += tmp_nl + 4 * tmp_level; \
} while(0)
@ -102,9 +102,9 @@ static void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
/*
* Check stack against overflow, if limit is set.
*/
#define _ASN_DEFAULT_STACK_MAX (30000)
#define ASN__DEFAULT_STACK_MAX (30000)
static int __attribute__((unused))
_ASN_STACK_OVERFLOW_CHECK(asn_codec_ctx_t *ctx) {
ASN__STACK_OVERFLOW_CHECK(asn_codec_ctx_t *ctx) {
if(ctx && ctx->max_stack_size) {
/* ctx MUST be allocated on the stack */

4
skeletons/ber_decoder.c
View File

@ -44,7 +44,7 @@ ber_decode(asn_codec_ctx_t *opt_codec_ctx,
} else {
/* If context is not given, be security-conscious anyway */
memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
s_codec_ctx.max_stack_size = ASN__DEFAULT_STACK_MAX;
opt_codec_ctx = &s_codec_ctx;
}
@ -80,7 +80,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
/*
* Make sure we didn't exceed the maximum stack size.
*/
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
RETURN(RC_FAIL);
/*

2
skeletons/ber_tlv_length.c
View File

@ -85,7 +85,7 @@ ber_skip_length(asn_codec_ctx_t *opt_codec_ctx,
/*
* Make sure we didn't exceed the maximum stack size.
*/
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
return -1;
/*

72
skeletons/constr_CHOICE.c
View File

@ -364,7 +364,7 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
size_t computed_size = 0;
int present;
if(!sptr) _ASN_ENCODE_FAILED;
if(!sptr) ASN__ENCODE_FAILED;
ASN_DEBUG("%s %s as CHOICE",
cb?"Encoding":"Estimating", td->name);
@ -380,9 +380,9 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
if(present == 0 && td->elements_count == 0) {
/* The CHOICE is empty?! */
erval.encoded = 0;
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
/*
@ -394,10 +394,10 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
if(memb_ptr == 0) {
if(elm->optional) {
erval.encoded = 0;
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
/* Mandatory element absent */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
@ -424,7 +424,7 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
ret = der_write_tags(td, erval.encoded, tag_mode, 1, tag,
cb, app_key);
if(ret == -1)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
computed_size += ret;
}
@ -483,7 +483,7 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
int present;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -502,7 +502,7 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
if(!memb_ptr) {
if(elm->optional)
return 0;
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: mandatory CHOICE element %s absent (%s:%d)",
td->name, elm->name, __FILE__, __LINE__);
return -1;
@ -525,7 +525,7 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
return ret;
}
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: no CHOICE element given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -781,7 +781,7 @@ CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int present;
if(!sptr)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
/*
* Figure out which CHOICE element is encoded.
@ -789,7 +789,7 @@ CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
if(present <= 0 || present > td->elements_count) {
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
} else {
asn_enc_rval_t tmper;
asn_TYPE_member_t *elm = &td->elements[present-1];
@ -799,7 +799,7 @@ CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(elm->flags & ATF_POINTER) {
memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
if(!memb_ptr) _ASN_ENCODE_FAILED;
if(!memb_ptr) ASN__ENCODE_FAILED;
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
}
@ -807,22 +807,22 @@ CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
er.encoded = 0;
if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
tmper = elm->type->xer_encoder(elm->type, memb_ptr,
ilevel + 1, flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
er.encoded += 5 + (2 * mlen) + tmper.encoded;
}
if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel - 1);
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
asn_dec_rval_t
@ -837,15 +837,15 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
void *st = *sptr;
int value;
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
_ASN_DECODE_FAILED;
if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
ASN__DECODE_FAILED;
/*
* Create the target structure if it is not present already.
*/
if(!st) {
st = *sptr = CALLOC(1, specs->struct_size);
if(!st) _ASN_DECODE_FAILED;
if(!st) ASN__DECODE_FAILED;
}
if(constraints) ct = &constraints->value;
@ -854,25 +854,25 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
if(ct && ct->flags & APC_EXTENSIBLE) {
value = per_get_few_bits(pd, 1);
if(value < 0) _ASN_DECODE_STARVED;
if(value < 0) ASN__DECODE_STARVED;
if(value) ct = 0; /* Not restricted */
}
if(ct && ct->range_bits >= 0) {
value = per_get_few_bits(pd, ct->range_bits);
if(value < 0) _ASN_DECODE_STARVED;
if(value < 0) ASN__DECODE_STARVED;
ASN_DEBUG("CHOICE %s got index %d in range %d",
td->name, value, ct->range_bits);
if(value > ct->upper_bound)
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
} else {
if(specs->ext_start == -1)
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
value = uper_get_nsnnwn(pd);
if(value < 0) _ASN_DECODE_STARVED;
if(value < 0) ASN__DECODE_STARVED;
value += specs->ext_start;
if(value >= td->elements_count)
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
/* Adjust if canonical order is different from natural order */
@ -916,7 +916,7 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
int present;
int present_enc;
if(!sptr) _ASN_ENCODE_FAILED;
if(!sptr) ASN__ENCODE_FAILED;
ASN_DEBUG("Encoding %s as CHOICE", td->name);
@ -932,7 +932,7 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
* can't deduce what to encode in the choice type.
*/
if(present <= 0 || present > td->elements_count)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
else
present--;
@ -949,43 +949,43 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
|| present_enc > ct->upper_bound) {
if(ct->flags & APC_EXTENSIBLE) {
if(per_put_few_bits(po, 1, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
} else {
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
ct = 0;
}
}
if(ct && ct->flags & APC_EXTENSIBLE)
if(per_put_few_bits(po, 0, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
elm = &td->elements[present];
if(elm->flags & ATF_POINTER) {
/* Member is a pointer to another structure */
memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
if(!memb_ptr) _ASN_ENCODE_FAILED;
if(!memb_ptr) ASN__ENCODE_FAILED;
} else {
memb_ptr = (char *)sptr + elm->memb_offset;
}
if(ct && ct->range_bits >= 0) {
if(per_put_few_bits(po, present_enc, ct->range_bits))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
return elm->type->uper_encoder(elm->type, elm->per_constraints,
memb_ptr, po);
} else {
asn_enc_rval_t rval;
if(specs->ext_start == -1)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(uper_put_nsnnwn(po, present_enc - specs->ext_start))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(uper_open_type_put(elm->type, elm->per_constraints,
memb_ptr, po))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
rval.encoded = 0;
_ASN_ENCODED_OK(rval);
ASN__ENCODED_OK(rval);
}
}

66
skeletons/constr_SEQUENCE.c
View File

@ -532,7 +532,7 @@ SEQUENCE_encode_der(asn_TYPE_descriptor_t *td,
if(!memb_ptr) {
if(elm->optional) continue;
/* Mandatory element is missing */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
@ -553,10 +553,10 @@ SEQUENCE_encode_der(asn_TYPE_descriptor_t *td,
ret = der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);
ASN_DEBUG("Wrote tags: %ld (+%ld)", (long)ret, (long)computed_size);
if(ret == -1)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
erval.encoded = computed_size + ret;
if(!cb) _ASN_ENCODED_OK(erval);
if(!cb) ASN__ENCODED_OK(erval);
/*
* Encode all members.
@ -586,9 +586,9 @@ SEQUENCE_encode_der(asn_TYPE_descriptor_t *td,
/*
* Encoded size is not equal to the computed size.
*/
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
@ -858,7 +858,7 @@ SEQUENCE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int edx;
if(!sptr)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = 0;
@ -875,29 +875,29 @@ SEQUENCE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(elm->optional)
continue;
/* Mandatory element is missing */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
}
if(!xcan) ASN__TEXT_INDENT(1, ilevel);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
/* Print the member itself */
tmper = elm->type->xer_encoder(elm->type, memb_ptr,
ilevel + 1, flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
er.encoded += 5 + (2 * mlen) + tmper.encoded;
}
if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
int
@ -981,7 +981,7 @@ SEQUENCE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
int edx;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -999,7 +999,7 @@ SEQUENCE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
if(!memb_ptr) {
if(elm->optional)
continue;
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: mandatory element %s absent (%s:%d)",
td->name, elm->name, __FILE__, __LINE__);
return -1;
@ -1040,12 +1040,12 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
(void)constraints;
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
_ASN_DECODE_FAILED;
if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
ASN__DECODE_FAILED;
if(!st) {
st = *sptr = CALLOC(1, specs->struct_size);
if(!st) _ASN_DECODE_FAILED;
if(!st) ASN__DECODE_FAILED;
}
ASN_DEBUG("Decoding %s as SEQUENCE (UPER)", td->name);
@ -1053,7 +1053,7 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
/* Handle extensions */
if(specs->ext_before >= 0) {
extpresent = per_get_few_bits(pd, 1);
if(extpresent < 0) _ASN_DECODE_STARVED;
if(extpresent < 0) ASN__DECODE_STARVED;
} else {
extpresent = 0;
}
@ -1062,11 +1062,11 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
memset(&opmd, 0, sizeof(opmd));
if(specs->roms_count) {
opres = (uint8_t *)MALLOC(((specs->roms_count + 7) >> 3) + 1);
if(!opres) _ASN_DECODE_FAILED;
if(!opres) ASN__DECODE_FAILED;
/* Get the presence map */
if(per_get_many_bits(pd, opres, 0, specs->roms_count)) {
FREEMEM(opres);
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
}
opmd.buffer = opres;
opmd.nbits = specs->roms_count;
@ -1107,7 +1107,7 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
/* Fill-in DEFAULT */
if(elm->default_value(1, memb_ptr2)) {
FREEMEM(opres);
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
ASN_DEBUG("Filled-in default");
}
@ -1141,17 +1141,17 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
asn_per_data_t epmd;
bmlength = uper_get_nslength(pd);
if(bmlength < 0) _ASN_DECODE_STARVED;
if(bmlength < 0) ASN__DECODE_STARVED;
ASN_DEBUG("Extensions %ld present in %s", (long)bmlength, td->name);
epres = (uint8_t *)MALLOC((bmlength + 15) >> 3);
if(!epres) _ASN_DECODE_STARVED;
if(!epres) ASN__DECODE_STARVED;
/* Get the extensions map */
if(per_get_many_bits(pd, epres, 0, bmlength)) {
FREEMEM(epres);
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
}
memset(&epmd, 0, sizeof(epmd));
@ -1205,7 +1205,7 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
default:
if(uper_open_type_skip(opt_codec_ctx, pd)) {
FREEMEM(epres);
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
}
}
break;
@ -1233,7 +1233,7 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
/* Set default value */
if(elm->default_value(1, memb_ptr2)) {
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
}
@ -1307,7 +1307,7 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
(void)constraints;
if(!sptr)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
er.encoded = 0;
@ -1355,7 +1355,7 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
elm->default_value ? "def" : "wtv",
td->name, elm->name, present ? "present" : "absent");
if(per_put_few_bits(po, present, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
/*
@ -1383,7 +1383,7 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
if(elm->optional)
continue;
/* Mandatory element is missing */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
@ -1402,24 +1402,24 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
}
/* No extensions to encode */
if(!n_extensions) _ASN_ENCODED_OK(er);
if(!n_extensions) ASN__ENCODED_OK(er);
ASN_DEBUG("Length of %d bit-map", n_extensions);
/* #18.8. Write down the presence bit-map length. */
if(uper_put_nslength(po, n_extensions))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
ASN_DEBUG("Bit-map of %d elements", n_extensions);
/* #18.7. Encoding the extensions presence bit-map. */
/* TODO: act upon NOTE in #18.7 for canonical PER */
if(SEQUENCE_handle_extensions(td, sptr, po, 0) != n_extensions)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
ASN_DEBUG("Writing %d extensions", n_extensions);
/* #18.9. Encode extensions as open type fields. */
if(SEQUENCE_handle_extensions(td, sptr, 0, po) != n_extensions)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}

30
skeletons/constr_SEQUENCE_OF.c
View File

@ -52,7 +52,7 @@ SEQUENCE_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
computed_size += encoding_size;
if(!cb) {
erval.encoded = computed_size;
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
ASN_DEBUG("Encoding members of SEQUENCE OF %s", td->name);
@ -101,7 +101,7 @@ SEQUENCE_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int xcan = (flags & XER_F_CANONICAL);
int i;
if(!sptr) _ASN_ENCODE_FAILED;
if(!sptr) ASN__ENCODE_FAILED;
er.encoded = 0;
@ -112,7 +112,7 @@ SEQUENCE_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(mname) {
if(!xcan) ASN__TEXT_INDENT(1, ilevel);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
}
tmper = elm->type->xer_encoder(elm->type, memb_ptr,
@ -122,11 +122,11 @@ SEQUENCE_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
const char *name = elm->type->xml_tag;
size_t len = strlen(name);
if(!xcan) ASN__TEXT_INDENT(1, ilevel + 1);
_ASN_CALLBACK3("<", 1, name, len, "/>", 2);
ASN__CALLBACK3("<", 1, name, len, "/>", 2);
}
if(mname) {
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
er.encoded += 5;
}
@ -135,9 +135,9 @@ SEQUENCE_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
asn_enc_rval_t
@ -149,7 +149,7 @@ SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td,
asn_TYPE_member_t *elm = td->elements;
int seq;
if(!sptr) _ASN_ENCODE_FAILED;
if(!sptr) ASN__ENCODE_FAILED;
list = _A_SEQUENCE_FROM_VOID(sptr);
er.encoded = 0;
@ -170,17 +170,17 @@ SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td,
if(ct->flags & APC_EXTENSIBLE) {
/* Declare whether size is in extension root */
if(per_put_few_bits(po, not_in_root, 1))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(not_in_root) ct = 0;
} else if(not_in_root && ct->effective_bits >= 0)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
if(ct && ct->effective_bits >= 0) {
/* X.691, #19.5: No length determinant */
if(per_put_few_bits(po, list->count - ct->lower_bound,
ct->effective_bits))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
for(seq = -1; seq < list->count;) {
@ -190,19 +190,19 @@ SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td,
mayEncode = list->count;
} else {
mayEncode = uper_put_length(po, list->count - seq);
if(mayEncode < 0) _ASN_ENCODE_FAILED;
if(mayEncode < 0) ASN__ENCODE_FAILED;
}
while(mayEncode--) {
void *memb_ptr = list->array[seq++];
if(!memb_ptr) _ASN_ENCODE_FAILED;
if(!memb_ptr) ASN__ENCODE_FAILED;
er = elm->type->uper_encoder(elm->type,
elm->per_constraints, memb_ptr, po);
if(er.encoded == -1)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
}
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}

32
skeletons/constr_SET.c
View File

@ -116,8 +116,8 @@ SET_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
ASN_DEBUG("Decoding %s as SET", td->name);
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
_ASN_DECODE_FAILED;
if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
ASN__DECODE_FAILED;
/*
* Create the target structure if it is not present already.
@ -451,7 +451,7 @@ SET_encode_der(asn_TYPE_descriptor_t *td,
if(t2m_build_own) {
t2m_build = (asn_TYPE_tag2member_t *)alloca(
td->elements_count * sizeof(t2m_build[0]));
if(!t2m_build) _ASN_ENCODE_FAILED; /* There are such platforms */
if(!t2m_build) ASN__ENCODE_FAILED; /* There are such platforms */
t2m_count = 0;
} else {
t2m_build = NULL;
@ -477,7 +477,7 @@ SET_encode_der(asn_TYPE_descriptor_t *td,
if(!memb_ptr) {
if(!elm->optional)
/* Mandatory elements missing */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
if(t2m_build_own) {
t2m_build[t2m_count].el_no = edx;
t2m_build[t2m_count].el_tag = 0;
@ -533,10 +533,10 @@ SET_encode_der(asn_TYPE_descriptor_t *td,
* Encode the TLV for the sequence itself.
*/
ret = der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);
if(ret == -1) _ASN_ENCODE_FAILED;
if(ret == -1) ASN__ENCODE_FAILED;
er.encoded = computed_size + ret;
if(!cb) _ASN_ENCODED_OK(er);
if(!cb) ASN__ENCODED_OK(er);
/*
* Encode all members.
@ -567,10 +567,10 @@ SET_encode_der(asn_TYPE_descriptor_t *td,
/*
* Encoded size is not equal to the computed size.
*/
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
#undef XER_ADVANCE
@ -812,7 +812,7 @@ SET_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int edx;
if(!sptr)
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
assert(t2m_count == td->elements_count);
@ -835,7 +835,7 @@ SET_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(elm->optional)
continue;
/* Mandatory element missing */
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
@ -843,23 +843,23 @@ SET_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(!xcan)
ASN__TEXT_INDENT(1, ilevel);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
/* Print the member itself */
tmper = elm->type->xer_encoder(elm->type, memb_ptr,
ilevel + 1, flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
er.encoded += 5 + (2 * mlen) + tmper.encoded;
}
if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
int
@ -942,7 +942,7 @@ SET_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
int edx;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -960,7 +960,7 @@ SET_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
if(!memb_ptr) {
if(elm->optional)
continue;
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: mandatory element %s absent (%s:%d)",
td->name, elm->name, __FILE__, __LINE__);
return -1;

32
skeletons/constr_SET_OF.c
View File

@ -359,7 +359,7 @@ SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
if(!cb || list->count == 0) {
erval.encoded = computed_size;
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
/*
@ -451,7 +451,7 @@ SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
erval.encoded = computed_size;
}
_ASN_ENCODED_OK(erval);
ASN__ENCODED_OK(erval);
}
#undef XER_ADVANCE
@ -668,11 +668,11 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
asn_app_consume_bytes_f *original_cb = cb;
int i;
if(!sptr) _ASN_ENCODE_FAILED;
if(!sptr) ASN__ENCODE_FAILED;
if(xcan) {
encs = (xer_tmp_enc_t *)MALLOC(list->count * sizeof(encs[0]));
if(!encs) _ASN_ENCODE_FAILED;
if(!encs) ASN__ENCODE_FAILED;
cb = SET_OF_encode_xer_callback;
}
@ -692,7 +692,7 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(mname) {
if(!xcan) ASN__TEXT_INDENT(1, ilevel);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
}
if(!xcan && specs->as_XMLValueList == 1)
@ -708,11 +708,11 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
if(tmper.encoded == 0 && specs->as_XMLValueList) {
const char *name = elm->type->xml_tag;
size_t len = strlen(name);
_ASN_CALLBACK3("<", 1, name, len, "/>", 2);
ASN__CALLBACK3("<", 1, name, len, "/>", 2);
}
if(mname) {
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
er.encoded += 5;
}
@ -731,7 +731,7 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);
for(; enc < end; enc++) {
_ASN_CALLBACK(enc->buffer, enc->offset);
ASN__CALLBACK(enc->buffer, enc->offset);
FREEMEM(enc->buffer);
enc->buffer = 0;
control_size += enc->offset;
@ -752,7 +752,7 @@ cleanup:
}
FREEMEM(encs);
}
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
}
int
@ -831,7 +831,7 @@ SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
int i;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -876,15 +876,15 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
int repeat = 0;
ssize_t nelems;
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
_ASN_DECODE_FAILED;
if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
ASN__DECODE_FAILED;
/*
* Create the target structure if it is not present already.
*/
if(!st) {
st = *sptr = CALLOC(1, specs->struct_size);
if(!st) _ASN_DECODE_FAILED;
if(!st) ASN__DECODE_FAILED;
}
list = _A_SET_FROM_VOID(st);
@ -895,7 +895,7 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
if(ct && ct->flags & APC_EXTENSIBLE) {
int value = per_get_few_bits(pd, 1);
if(value < 0) _ASN_DECODE_STARVED;
if(value < 0) ASN__DECODE_STARVED;
if(value) ct = 0; /* Not restricted! */
}
@ -904,7 +904,7 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
nelems = per_get_few_bits(pd, ct->effective_bits);
ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",
(long)nelems, ct->lower_bound, td->name);
if(nelems < 0) _ASN_DECODE_STARVED;
if(nelems < 0) ASN__DECODE_STARVED;
nelems += ct->lower_bound;
} else {
nelems = -1;
@ -917,7 +917,7 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
ct ? ct->effective_bits : -1, &repeat);
ASN_DEBUG("Got to decode %d elements (eff %d)",
(int)nelems, (int)(ct ? ct->effective_bits : -1));
if(nelems < 0) _ASN_DECODE_STARVED;
if(nelems < 0) ASN__DECODE_STARVED;
}
for(i = 0; i < nelems; i++) {

2
skeletons/constraints.h
View File

@ -54,7 +54,7 @@ asn_constr_check_f asn_generic_unknown_constraint; /* Not fully supported */
/*
* Invoke the callback with a complete error message.
*/
#define _ASN_CTFAIL if(ctfailcb) ctfailcb
#define ASN__CTFAIL if(ctfailcb) ctfailcb
#ifdef __cplusplus
}

4
skeletons/converter-sample.c
View File

@ -19,7 +19,7 @@
#include <errno.h> /* for errno */
#include <asn_application.h>
#include <asn_internal.h> /* for _ASN_DEFAULT_STACK_MAX */
#include <asn_internal.h> /* for ASN__DEFAULT_STACK_MAX */
/* Convert "Type" defined by -DPDU into "asn_DEF_Type" */
#define ASN_DEF_PDU(t) asn_DEF_ ## t
@ -228,7 +228,7 @@ main(int ac, char *av[]) {
#ifdef JUNKTEST
" -J <prob> Set random junk test bit garbaging probability\n"
#endif
, (long)suggested_bufsize, _ASN_DEFAULT_STACK_MAX);
, (long)suggested_bufsize, ASN__DEFAULT_STACK_MAX);
exit(EX_USAGE);
}

8
skeletons/per_decoder.c
View File

@ -45,7 +45,7 @@ uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sp
if(skip_bits < 0 || skip_bits > 7
|| unused_bits < 0 || unused_bits > 7
|| (unused_bits > 0 && !size))
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
/*
* Stack checker requires that the codec context
@ -59,7 +59,7 @@ uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sp
} else {
/* If context is not given, be security-conscious anyway */
memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
s_codec_ctx.max_stack_size = ASN__DEFAULT_STACK_MAX;
opt_codec_ctx = &s_codec_ctx;
}
@ -69,13 +69,13 @@ uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sp
pd.nboff = skip_bits;
pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from <limits.h> */
if(pd.nboff > pd.nbits)
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
/*
* Invoke type-specific decoder.
*/
if(!td->uper_decoder)
_ASN_DECODE_FAILED; /* PER is not compiled in */
ASN__DECODE_FAILED; /* PER is not compiled in */
rval = td->uper_decoder(opt_codec_ctx, td, 0, sptr, &pd);
if(rval.code == RC_OK) {
/* Return the number of consumed bits */

4
skeletons/per_encoder.c
View File

@ -124,7 +124,7 @@ uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constrain
* Invoke type-specific encoder.
*/
if(!td || !td->uper_encoder)
_ASN_ENCODE_FAILED; /* PER is not compiled in */
ASN__ENCODE_FAILED; /* PER is not compiled in */
po.buffer = po.tmpspace;
po.nboff = 0;
@ -143,7 +143,7 @@ uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constrain
er.encoded = (po.flushed_bytes << 3) + bits_to_flush;
if(_uper_encode_flush_outp(&po))
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
return er;

24
skeletons/per_opentype.c
View File

@ -65,7 +65,7 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
asn_per_data_t spd;
size_t padding;
_ASN_STACK_OVERFLOW_CHECK(ctx);
ASN__STACK_OVERFLOW_CHECK(ctx);
ASN_DEBUG("Getting open type %s...", td->name);
@ -73,7 +73,7 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
chunk_bytes = uper_get_length(pd, -1, &repeat);
if(chunk_bytes < 0) {
FREEMEM(buf);
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
}
if(bufLen + chunk_bytes > bufSize) {
void *ptr;
@ -81,13 +81,13 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
ptr = REALLOC(buf, bufSize);
if(!ptr) {
FREEMEM(buf);
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
buf = ptr;
}
if(per_get_many_bits(pd, buf + bufLen, 0, chunk_bytes << 3)) {
FREEMEM(buf);
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
}
bufLen += chunk_bytes;
} while(repeat);
@ -117,10 +117,10 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
FREEMEM(buf);
if(padding >= 8) {
ASN_DEBUG("Too large padding %d in open type", (int)padding);
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
} else {
ASN_DEBUG("Non-zero padding");
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
} else {
FREEMEM(buf);
@ -138,7 +138,7 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
asn_dec_rval_t rv;
ssize_t padding;
_ASN_STACK_OVERFLOW_CHECK(ctx);
ASN__STACK_OVERFLOW_CHECK(ctx);
ASN_DEBUG("Getting open type %s from %s", td->name,
per_data_string(pd));
@ -190,13 +190,13 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
case -1:
ASN_DEBUG("Padding skip failed");
UPDRESTOREPD;
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
case 0: break;
default:
ASN_DEBUG("Non-blank padding (%d bits 0x%02x)",
(int)padding, (int)pvalue);
UPDRESTOREPD;
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
}
if(pd->nboff != pd->nbits) {
@ -204,7 +204,7 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
per_data_string(pd), per_data_string(&arg.oldpd));
if(1) {
UPDRESTOREPD;
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
} else {
arg.unclaimed += pd->nbits - pd->nboff;
}
@ -219,14 +219,14 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
switch(per_skip_bits(pd, arg.unclaimed)) {
case -1:
ASN_DEBUG("Claim of %d failed", (int)arg.unclaimed);
_ASN_DECODE_STARVED;
ASN__DECODE_STARVED;
case 0:
ASN_DEBUG("Got claim of %d", (int)arg.unclaimed);
break;
default:
/* Padding must be blank */
ASN_DEBUG("Non-blank unconsumed padding");
_ASN_DECODE_FAILED;
ASN__DECODE_FAILED;
}
arg.unclaimed = 0;
}

2
skeletons/xer_decoder.c
View File

@ -27,7 +27,7 @@ xer_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
} else {
/* If context is not given, be security-conscious anyway */
memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
s_codec_ctx.max_stack_size = ASN__DEFAULT_STACK_MAX;
opt_codec_ctx = &s_codec_ctx;
}

8
skeletons/xer_encoder.c
View File

@ -23,18 +23,18 @@ xer_encode(asn_TYPE_descriptor_t *td, void *sptr,
mname = td->xml_tag;
mlen = strlen(mname);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
tmper = td->xer_encoder(td, sptr, 1, xer_flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
_ASN_CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
ASN__CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
er.encoded = 4 + xcan + (2 * mlen) + tmper.encoded;
_ASN_ENCODED_OK(er);
ASN__ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
ASN__ENCODE_FAILED;
}
/*

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

@ -27,7 +27,7 @@ memb_narrow1_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -39,7 +39,7 @@ memb_narrow1_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -52,7 +52,7 @@ memb_narrow2_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -64,7 +64,7 @@ memb_narrow2_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -77,7 +77,7 @@ memb_narrow3_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -89,7 +89,7 @@ memb_narrow3_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -27,14 +27,14 @@ MinMax_16P0_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -44,7 +44,7 @@ MinMax_16P0_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -175,14 +175,14 @@ ThreePlus_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -192,7 +192,7 @@ ThreePlus_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -454,7 +454,7 @@ memb_ia5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -465,7 +465,7 @@ memb_ia5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -478,7 +478,7 @@ memb_ia5_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -489,7 +489,7 @@ memb_ia5_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -502,7 +502,7 @@ memb_ia5_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -513,7 +513,7 @@ memb_ia5_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -536,7 +536,7 @@ memb_vs_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const VisibleString_t *st = (const VisibleString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -547,7 +547,7 @@ memb_vs_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -560,7 +560,7 @@ memb_vs_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const VisibleString_t *st = (const VisibleString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -571,7 +571,7 @@ memb_vs_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -584,7 +584,7 @@ memb_vs_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const VisibleString_t *st = (const VisibleString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -595,7 +595,7 @@ memb_vs_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -618,7 +618,7 @@ memb_pr_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const PrintableString_t *st = (const PrintableString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -629,7 +629,7 @@ memb_pr_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -642,7 +642,7 @@ memb_pr_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const PrintableString_t *st = (const PrintableString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -653,7 +653,7 @@ memb_pr_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -676,7 +676,7 @@ memb_ns_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const NumericString_t *st = (const NumericString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -687,7 +687,7 @@ memb_ns_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -700,7 +700,7 @@ memb_ns_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const NumericString_t *st = (const NumericString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -711,7 +711,7 @@ memb_ns_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -724,7 +724,7 @@ memb_ns_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const NumericString_t *st = (const NumericString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -735,7 +735,7 @@ memb_ns_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -759,7 +759,7 @@ memb_ut_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -767,7 +767,7 @@ memb_ut_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size = UTF8String_length(st);
if((ssize_t)size < 0) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8: broken encoding (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -777,7 +777,7 @@ memb_ut_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -791,7 +791,7 @@ memb_ut_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -799,7 +799,7 @@ memb_ut_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size = UTF8String_length(st);
if((ssize_t)size < 0) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8: broken encoding (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -809,7 +809,7 @@ memb_ut_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -822,7 +822,7 @@ memb_ut_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const UTF8String_t *st = (const UTF8String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -833,7 +833,7 @@ memb_ut_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -846,7 +846,7 @@ memb_bm_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const BMPString_t *st = (const BMPString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -857,7 +857,7 @@ memb_bm_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -871,7 +871,7 @@ memb_bm_cs_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -884,7 +884,7 @@ memb_bm_cs_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -897,7 +897,7 @@ memb_bm_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const BMPString_t *st = (const BMPString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -908,7 +908,7 @@ memb_bm_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -921,7 +921,7 @@ memb_bm_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const BMPString_t *st = (const BMPString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -932,7 +932,7 @@ memb_bm_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -955,7 +955,7 @@ memb_us_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const UniversalString_t *st = (const UniversalString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -966,7 +966,7 @@ memb_us_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -980,7 +980,7 @@ memb_us_cs_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -993,7 +993,7 @@ memb_us_cs_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1006,7 +1006,7 @@ memb_us_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const UniversalString_t *st = (const UniversalString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1017,7 +1017,7 @@ memb_us_ce_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1030,7 +1030,7 @@ memb_us_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const UniversalString_t *st = (const UniversalString_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1041,7 +1041,7 @@ memb_us_ir_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -34,7 +34,7 @@ T_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -29,7 +29,7 @@ unsigned32_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -127,7 +127,7 @@ unsplit32_5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -139,7 +139,7 @@ unsplit32_5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -233,7 +233,7 @@ memb_small32range_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -245,7 +245,7 @@ memb_small32range_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -258,7 +258,7 @@ memb_full32range_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -270,7 +270,7 @@ memb_full32range_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -282,7 +282,7 @@ memb_unsigned32_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -299,7 +299,7 @@ memb_unsplit32_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -311,7 +311,7 @@ memb_unsplit32_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

24
tests/134-per-long-OK.asn1.-Pgen-PER
View File

@ -29,14 +29,14 @@ memb_unsigned33_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -46,7 +46,7 @@ memb_unsigned33_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -60,14 +60,14 @@ memb_unsigned42_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -77,7 +77,7 @@ memb_unsigned42_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -91,14 +91,14 @@ memb_signed33_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -108,7 +108,7 @@ memb_signed33_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -122,14 +122,14 @@ memb_signed33ext_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -139,7 +139,7 @@ memb_signed33ext_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -38,7 +38,7 @@ memb_signature_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -55,7 +55,7 @@ memb_signature_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -459,7 +459,7 @@ memb_IA5String_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -470,7 +470,7 @@ memb_IA5String_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -45,7 +45,7 @@ memb_varsets_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -58,7 +58,7 @@ memb_varsets_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Perform validation of the inner elements */
return td->check_constraints(td, sptr, ctfailcb, app_key);
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -218,7 +218,7 @@ memb_vparts_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -402,7 +402,7 @@ memb_vset_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -415,7 +415,7 @@ memb_vset_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Perform validation of the inner elements */
return td->check_constraints(td, sptr, ctfailcb, app_key);
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -152,7 +152,7 @@ Int2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -165,7 +165,7 @@ Int2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -296,14 +296,14 @@ Int3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -313,7 +313,7 @@ Int3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -444,14 +444,14 @@ Int4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -461,7 +461,7 @@ Int4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -592,14 +592,14 @@ Int5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -609,7 +609,7 @@ Int5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -740,14 +740,14 @@ ExtensibleExtensions_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -757,7 +757,7 @@ ExtensibleExtensions_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1029,7 +1029,7 @@ Str2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1042,7 +1042,7 @@ Str2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1200,7 +1200,7 @@ Str3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1213,7 +1213,7 @@ Str3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1359,7 +1359,7 @@ Str4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1370,7 +1370,7 @@ Str4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1516,7 +1516,7 @@ PER_Visible_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1527,7 +1527,7 @@ PER_Visible_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1673,7 +1673,7 @@ PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1684,7 +1684,7 @@ PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1830,7 +1830,7 @@ Not_PER_Visible_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1841,7 +1841,7 @@ Not_PER_Visible_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1987,7 +1987,7 @@ Not_PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1998,7 +1998,7 @@ Not_PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2144,7 +2144,7 @@ Not_PER_Visible_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2155,7 +2155,7 @@ Not_PER_Visible_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2302,7 +2302,7 @@ SIZE_but_not_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2315,7 +2315,7 @@ SIZE_but_not_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2462,7 +2462,7 @@ SIZE_and_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2475,7 +2475,7 @@ SIZE_and_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2621,7 +2621,7 @@ Neither_SIZE_nor_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2632,7 +2632,7 @@ Neither_SIZE_nor_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2772,7 +2772,7 @@ Utf8_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const UTF8String_t *st = (const UTF8String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2783,7 +2783,7 @@ Utf8_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2943,7 +2943,7 @@ Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2951,7 +2951,7 @@ Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size = UTF8String_length(st);
if((ssize_t)size < 0) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8: broken encoding (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2962,7 +2962,7 @@ Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3093,7 +3093,7 @@ Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3101,7 +3101,7 @@ Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size = UTF8String_length(st);
if((ssize_t)size < 0) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8: broken encoding (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3111,7 +3111,7 @@ Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3395,7 +3395,7 @@ VisibleIdentifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3408,7 +3408,7 @@ VisibleIdentifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3639,14 +3639,14 @@ memb_int1_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3656,7 +3656,7 @@ memb_int1_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3670,14 +3670,14 @@ memb_int4_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3687,7 +3687,7 @@ memb_int4_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3701,14 +3701,14 @@ memb_int5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3718,7 +3718,7 @@ memb_int5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4180,7 +4180,7 @@ Enum1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4192,7 +4192,7 @@ Enum1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4368,7 +4368,7 @@ Identifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4381,7 +4381,7 @@ Identifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -171,7 +171,7 @@ Int2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -183,7 +183,7 @@ Int2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -339,7 +339,7 @@ Int3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -351,7 +351,7 @@ Int3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -507,7 +507,7 @@ Int4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -519,7 +519,7 @@ Int4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -675,7 +675,7 @@ Int5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -687,7 +687,7 @@ Int5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -843,7 +843,7 @@ ExtensibleExtensions_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -855,7 +855,7 @@ ExtensibleExtensions_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1171,7 +1171,7 @@ Str2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1184,7 +1184,7 @@ Str2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1371,7 +1371,7 @@ Str3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1384,7 +1384,7 @@ Str3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1567,7 +1567,7 @@ Str4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1578,7 +1578,7 @@ Str4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1750,7 +1750,7 @@ PER_Visible_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1761,7 +1761,7 @@ PER_Visible_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1933,7 +1933,7 @@ PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1944,7 +1944,7 @@ PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2116,7 +2116,7 @@ Not_PER_Visible_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2127,7 +2127,7 @@ Not_PER_Visible_1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2299,7 +2299,7 @@ Not_PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2310,7 +2310,7 @@ Not_PER_Visible_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2482,7 +2482,7 @@ Not_PER_Visible_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2493,7 +2493,7 @@ Not_PER_Visible_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2666,7 +2666,7 @@ SIZE_but_not_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2679,7 +2679,7 @@ SIZE_but_not_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2852,7 +2852,7 @@ SIZE_and_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2865,7 +2865,7 @@ SIZE_and_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3037,7 +3037,7 @@ Neither_SIZE_nor_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const PER_Visible_t *st = (const PER_Visible_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3048,7 +3048,7 @@ Neither_SIZE_nor_FROM_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3214,7 +3214,7 @@ Utf8_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const UTF8String_t *st = (const UTF8String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3225,7 +3225,7 @@ Utf8_4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3411,7 +3411,7 @@ Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3419,7 +3419,7 @@ Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size = UTF8String_length(st);
if((ssize_t)size < 0) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8: broken encoding (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3430,7 +3430,7 @@ Utf8_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3587,7 +3587,7 @@ Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3595,7 +3595,7 @@ Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size = UTF8String_length(st);
if((ssize_t)size < 0) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: UTF-8: broken encoding (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3605,7 +3605,7 @@ Utf8_2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3940,7 +3940,7 @@ VisibleIdentifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -3953,7 +3953,7 @@ VisibleIdentifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4214,7 +4214,7 @@ memb_int1_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4226,7 +4226,7 @@ memb_int1_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4239,7 +4239,7 @@ memb_int4_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4251,7 +4251,7 @@ memb_int4_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4264,7 +4264,7 @@ memb_int5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4276,7 +4276,7 @@ memb_int5_c_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4800,7 +4800,7 @@ Enum1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -4812,7 +4812,7 @@ Enum1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -5021,7 +5021,7 @@ Identifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -5034,7 +5034,7 @@ Identifier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -53,7 +53,7 @@ memb_char_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -65,7 +65,7 @@ memb_char_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -416,7 +416,7 @@ memb_a_constraint_3(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -433,7 +433,7 @@ memb_a_constraint_3(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -447,7 +447,7 @@ memb_a_constraint_8(asn_TYPE_descriptor_t *td, const void *sptr,
size_t size;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -464,7 +464,7 @@ memb_a_constraint_8(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -500,7 +500,7 @@ memb_patest1_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -511,7 +511,7 @@ memb_patest1_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -524,7 +524,7 @@ memb_patest2_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
const IA5String_t *st = (const IA5String_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -535,7 +535,7 @@ memb_patest2_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -33,7 +33,7 @@ memb_common_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -45,7 +45,7 @@ memb_common_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -315,7 +315,7 @@ memb_common_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -327,7 +327,7 @@ memb_common_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -340,7 +340,7 @@ memb_common_constraint_3(asn_TYPE_descriptor_t *td, const void *sptr,
BOOLEAN_t value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -352,7 +352,7 @@ memb_common_constraint_3(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -150,7 +150,7 @@ CN_IntegerMinMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -289,7 +289,7 @@ CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -301,7 +301,7 @@ CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -432,14 +432,14 @@ NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -449,7 +449,7 @@ NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -579,7 +579,7 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -591,7 +591,7 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -726,7 +726,7 @@ CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -738,7 +738,7 @@ CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -869,14 +869,14 @@ NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -886,7 +886,7 @@ NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1017,14 +1017,14 @@ NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1034,7 +1034,7 @@ NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1164,7 +1164,7 @@ NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1176,7 +1176,7 @@ NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1311,7 +1311,7 @@ NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1323,7 +1323,7 @@ NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1458,7 +1458,7 @@ OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1470,7 +1470,7 @@ OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1600,7 +1600,7 @@ OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1612,7 +1612,7 @@ OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1742,7 +1742,7 @@ OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1754,7 +1754,7 @@ OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1884,7 +1884,7 @@ OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1896,7 +1896,7 @@ OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2026,7 +2026,7 @@ OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2038,7 +2038,7 @@ OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2167,7 +2167,7 @@ NO_IntegerInRange6_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -151,7 +151,7 @@ CN_IntegerMinMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
const INTEGER_t *st = (const INTEGER_t *)sptr;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -291,14 +291,14 @@ CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -308,7 +308,7 @@ CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -439,14 +439,14 @@ NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -456,7 +456,7 @@ NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -586,7 +586,7 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -598,7 +598,7 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -734,14 +734,14 @@ CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -751,7 +751,7 @@ CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -882,14 +882,14 @@ NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -899,7 +899,7 @@ NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1030,14 +1030,14 @@ NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1047,7 +1047,7 @@ NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1177,7 +1177,7 @@ NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1189,7 +1189,7 @@ NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1324,7 +1324,7 @@ NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1336,7 +1336,7 @@ NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1471,7 +1471,7 @@ OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1483,7 +1483,7 @@ OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1613,7 +1613,7 @@ OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1625,7 +1625,7 @@ OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1755,7 +1755,7 @@ OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1767,7 +1767,7 @@ OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1897,7 +1897,7 @@ OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1909,7 +1909,7 @@ OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2040,14 +2040,14 @@ OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2057,7 +2057,7 @@ OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2186,7 +2186,7 @@ NO_IntegerInRange6_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -170,7 +170,7 @@ CN_IntegerMinMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -335,7 +335,7 @@ CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -347,7 +347,7 @@ CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -504,14 +504,14 @@ NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -521,7 +521,7 @@ NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -677,7 +677,7 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -689,7 +689,7 @@ NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -850,7 +850,7 @@ CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -862,7 +862,7 @@ CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1019,14 +1019,14 @@ NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1036,7 +1036,7 @@ NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1193,14 +1193,14 @@ NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
if(asn_INTEGER2long(st, &value)) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value too large (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1210,7 +1210,7 @@ NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1366,7 +1366,7 @@ NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1378,7 +1378,7 @@ NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1539,7 +1539,7 @@ NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
unsigned long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1551,7 +1551,7 @@ NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1712,7 +1712,7 @@ OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1724,7 +1724,7 @@ OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1880,7 +1880,7 @@ OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -1892,7 +1892,7 @@ OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2048,7 +2048,7 @@ OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2060,7 +2060,7 @@ OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2216,7 +2216,7 @@ OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2228,7 +2228,7 @@ OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2384,7 +2384,7 @@ OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
long value;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2396,7 +2396,7 @@ OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
/* Constraint check succeeded */
return 0;
} else {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: constraint failed (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -2551,7 +2551,7 @@ NO_IntegerInRange6_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

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

@ -25,7 +25,7 @@ OK_Integer1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -163,7 +163,7 @@ OK_Integer2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -301,7 +301,7 @@ OK_Integer3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -439,7 +439,7 @@ OK_Integer4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
@ -577,7 +577,7 @@ NO_Integer5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;

2
tests/98-attribute-class-OK.asn1.-P
View File

@ -26,7 +26,7 @@ memb_identifier_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;