do not use reserved identifiers, contd

39 files changed, 330 insertions, 330 deletions

diff --git a/skeletons/ANY.c b/skeletons/ANY.c
index 0ad60d0a..77024bdc 100644
--- a/skeletons/ANY.c
+++ b/skeletons/ANY.c
@@ -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 */
diff --git a/skeletons/BIT_STRING.c b/skeletons/BIT_STRING.c
index a19f50fb..997ff416 100644
--- a/skeletons/BIT_STRING.c
+++ b/skeletons/BIT_STRING.c
@@ -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;
 }
 
 
diff --git a/skeletons/BMPString.c b/skeletons/BMPString.c
index 458622cd..8beaabda 100644
--- a/skeletons/BMPString.c
+++ b/skeletons/BMPString.c
@@ -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
diff --git a/skeletons/BOOLEAN.c b/skeletons/BOOLEAN.c
index 2ba07840..6e55b3e6 100644
--- a/skeletons/BOOLEAN.c
+++ b/skeletons/BOOLEAN.c
@@ -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);
 }
diff --git a/skeletons/ENUMERATED.c b/skeletons/ENUMERATED.c
index 045554bb..ccb003e4 100644
--- a/skeletons/ENUMERATED.c
+++ b/skeletons/ENUMERATED.c
@@ -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);
 }
diff --git a/skeletons/GeneralizedTime.c b/skeletons/GeneralizedTime.c
index cd36f034..a3008aa1 100644
--- a/skeletons/GeneralizedTime.c
+++ b/skeletons/GeneralizedTime.c
@@ -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,
diff --git a/skeletons/IA5String.c b/skeletons/IA5String.c
index 0fdc0748..b856d304 100644
--- a/skeletons/IA5String.c
+++ b/skeletons/IA5String.c
@@ -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;
diff --git a/skeletons/INTEGER.c b/skeletons/INTEGER.c
index 5d992d96..eed82176 100644
--- a/skeletons/INTEGER.c
+++ b/skeletons/INTEGER.c
@@ -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 */
diff --git a/skeletons/NULL.c b/skeletons/NULL.c
index 8dcb6aa9..62bc91e0 100644
--- a/skeletons/NULL.c
+++ b/skeletons/NULL.c
@@ -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);
 }
diff --git a/skeletons/NativeEnumerated.c b/skeletons/NativeEnumerated.c
index ecf66d1b..78366af3 100644
--- a/skeletons/NativeEnumerated.c
+++ b/skeletons/NativeEnumerated.c
@@ -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);
 }
 
diff --git a/skeletons/NativeInteger.c b/skeletons/NativeInteger.c
index 7f8e9276..e8ce6d2c 100644
--- a/skeletons/NativeInteger.c
+++ b/skeletons/NativeInteger.c
@@ -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;
diff --git a/skeletons/NativeReal.c b/skeletons/NativeReal.c
index 3fd51a4c..ad6f28c9 100644
--- a/skeletons/NativeReal.c
+++ b/skeletons/NativeReal.c
@@ -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);
 }
 
 /*
diff --git a/skeletons/NumericString.c b/skeletons/NumericString.c
index b669f571..887b3f52 100644
--- a/skeletons/NumericString.c
+++ b/skeletons/NumericString.c
@@ -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;
diff --git a/skeletons/OBJECT_IDENTIFIER.c b/skeletons/OBJECT_IDENTIFIER.c
index 776c095c..36882f91 100644
--- a/skeletons/OBJECT_IDENTIFIER.c
+++ b/skeletons/OBJECT_IDENTIFIER.c
@@ -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
diff --git a/skeletons/OCTET_STRING.c b/skeletons/OCTET_STRING.c
index 5d603290..5420dede 100644
--- a/skeletons/OCTET_STRING.c
+++ b/skeletons/OCTET_STRING.c
@@ -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
diff --git a/skeletons/PrintableString.c b/skeletons/PrintableString.c
index 5a3525ea..7b6828dc 100644
--- a/skeletons/PrintableString.c
+++ b/skeletons/PrintableString.c
@@ -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;
diff --git a/skeletons/REAL.c b/skeletons/REAL.c
index af72167f..0a250620 100644
--- a/skeletons/REAL.c
+++ b/skeletons/REAL.c
@@ -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);
 }
 
 
diff --git a/skeletons/RELATIVE-OID.c b/skeletons/RELATIVE-OID.c
index 44f27587..352ce79f 100644
--- a/skeletons/RELATIVE-OID.c
+++ b/skeletons/RELATIVE-OID.c
@@ -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
diff --git a/skeletons/UTCTime.c b/skeletons/UTCTime.c
index edcbaf19..3983d764 100644
--- a/skeletons/UTCTime.c
+++ b/skeletons/UTCTime.c
@@ -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,
diff --git a/skeletons/UTF8String.c b/skeletons/UTF8String.c
index 5e4f2506..d666a4e9 100644
--- a/skeletons/UTF8String.c
+++ b/skeletons/UTF8String.c
@@ -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;
diff --git a/skeletons/UniversalString.c b/skeletons/UniversalString.c
index b758be02..21753eb4 100644
--- a/skeletons/UniversalString.c
+++ b/skeletons/UniversalString.c
@@ -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
diff --git a/skeletons/VisibleString.c b/skeletons/VisibleString.c
index baf8d0c9..0f4dec56 100644
--- a/skeletons/VisibleString.c
+++ b/skeletons/VisibleString.c
@@ -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;
diff --git a/skeletons/asn_codecs.h b/skeletons/asn_codecs.h
index f2b8489f..4b2a2942 100644
--- a/skeletons/asn_codecs.h
+++ b/skeletons/asn_codecs.h
@@ -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;					\
diff --git a/skeletons/asn_codecs_prim.c b/skeletons/asn_codecs_prim.c
index 3beb9f2a..426339c9 100644
--- a/skeletons/asn_codecs_prim.c
+++ b/skeletons/asn_codecs_prim.c
@@ -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;
diff --git a/skeletons/asn_internal.h b/skeletons/asn_internal.h
index b7faefbf..9c94ca6c 100644
--- a/skeletons/asn_internal.h
+++ b/skeletons/asn_internal.h
@@ -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 */
diff --git a/skeletons/ber_decoder.c b/skeletons/ber_decoder.c
index 0f994009..b3a6329e 100644
--- a/skeletons/ber_decoder.c
+++ b/skeletons/ber_decoder.c
@@ -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);
 
 	/*
diff --git a/skeletons/ber_tlv_length.c b/skeletons/ber_tlv_length.c
index b87e75e0..4c2f1e5f 100644
--- a/skeletons/ber_tlv_length.c
+++ b/skeletons/ber_tlv_length.c
@@ -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;
 
 	/*
diff --git a/skeletons/constr_CHOICE.c b/skeletons/constr_CHOICE.c
index d463e8d2..6116e6a6 100644
--- a/skeletons/constr_CHOICE.c
+++ b/skeletons/constr_CHOICE.c
@@ -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);
 	}
 }
    
diff --git a/skeletons/constr_SEQUENCE.c b/skeletons/constr_SEQUENCE.c
index 56400d5f..5923023d 100644
--- a/skeletons/constr_SEQUENCE.c
+++ b/skeletons/constr_SEQUENCE.c
@@ -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);
 }
 
diff --git a/skeletons/constr_SEQUENCE_OF.c b/skeletons/constr_SEQUENCE_OF.c
index cba92424..8a08ee8a 100644
--- a/skeletons/constr_SEQUENCE_OF.c
+++ b/skeletons/constr_SEQUENCE_OF.c
@@ -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);
 }
 
diff --git a/skeletons/constr_SET.c b/skeletons/constr_SET.c
index f2a585d6..55a0badc 100644
--- a/skeletons/constr_SET.c
+++ b/skeletons/constr_SET.c
@@ -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;
diff --git a/skeletons/constr_SET_OF.c b/skeletons/constr_SET_OF.c
index de5e6287..2dbc6e51 100644
--- a/skeletons/constr_SET_OF.c
+++ b/skeletons/constr_SET_OF.c
@@ -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++) {
diff --git a/skeletons/constraints.h b/skeletons/constraints.h
index f7813495..48d49e24 100644
--- a/skeletons/constraints.h
+++ b/skeletons/constraints.h
@@ -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
 }
diff --git a/skeletons/converter-sample.c b/skeletons/converter-sample.c
index 2f74a800..de42326d 100644
--- a/skeletons/converter-sample.c
+++ b/skeletons/converter-sample.c
@@ -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);
 	}
 
diff --git a/skeletons/per_decoder.c b/skeletons/per_decoder.c
index 220d7f9f..461b7262 100644
--- a/skeletons/per_decoder.c
+++ b/skeletons/per_decoder.c
@@ -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 */
diff --git a/skeletons/per_encoder.c b/skeletons/per_encoder.c
index e76ef74a..47f3c916 100644
--- a/skeletons/per_encoder.c
+++ b/skeletons/per_encoder.c
@@ -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;
diff --git a/skeletons/per_opentype.c b/skeletons/per_opentype.c
index ec404cf9..404aa726 100644
--- a/skeletons/per_opentype.c
+++ b/skeletons/per_opentype.c
@@ -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;
 	}
diff --git a/skeletons/xer_decoder.c b/skeletons/xer_decoder.c
index f63e1e91..299a7c1e 100644
--- a/skeletons/xer_decoder.c
+++ b/skeletons/xer_decoder.c
@@ -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;
 	}
 
diff --git a/skeletons/xer_encoder.c b/skeletons/xer_encoder.c
index aa7cf040..46065758 100644
--- a/skeletons/xer_encoder.c
+++ b/skeletons/xer_encoder.c
@@ -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;
 }
 
 /*