Enumeration constraints relaxed

12 files changed, 1075 insertions, 9 deletions

diff --git a/ChangeLog b/ChangeLog
index 3c964b35..312b6072 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -7,6 +7,7 @@
 	* Added -fincludes-quoted to asn1c to generate #includes in "double"
 	  instead of <angle> quotes.
 	* PER encoding correctness fix. Reported by Grzegorz Aksamit.
+	* ENUMERATED extension values check relaxed. Reported by Gabriel Burca.
 
 0.9.22:	2008-Nov-19
 
diff --git a/asn1c/tests/check-03.c b/asn1c/tests/check-03.c
new file mode 100644
index 00000000..a821675e
--- /dev/null
+++ b/asn1c/tests/check-03.c
@@ -0,0 +1,62 @@
+#undef	NDEBUG
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <assert.h>
+
+#include "Enum2.h"
+#include "xer_decoder.h"
+
+static char buf[4096];
+static int buf_offset;
+
+static int
+buf_writer(const void *buffer, size_t size, void *app_key) {
+        char *b, *bend;
+        (void)app_key;
+        assert(buf_offset + size < sizeof(buf));
+        memcpy(buf + buf_offset, buffer, size);
+        b = buf + buf_offset;
+        bend = b + size;
+        buf_offset += size;
+        return 0;
+}
+
+static void
+check_xer(e_Enum2 eval, char *xer_string) {
+	asn_dec_rval_t rv;
+	char buf2[128];
+	Enum2_t *e = 0;
+	long val;
+
+	rv = xer_decode(0, &asn_DEF_Enum2, (void **)&e,
+		xer_string, strlen(xer_string));
+	assert(rv.code == RC_OK);
+	assert(rv.consumed == strlen(xer_string));
+
+	asn_INTEGER2long(e, &val);
+	printf("%s -> %ld == %d\n", xer_string, val, eval);
+	assert(val == eval);
+
+	buf_offset = 0;
+	xer_encode(&asn_DEF_Enum2, e, XER_F_CANONICAL, buf_writer, 0);
+	buf[buf_offset] = 0;
+	sprintf(buf2, "<Enum2>%s</Enum2>", xer_string);
+	printf("%ld -> %s == %s\n", eval, buf, buf2);
+	assert(0 == strcmp(buf, buf2));
+}
+
+int
+main() {
+
+	check_xer(Enum2_red, "<red/>");
+	check_xer(Enum2_green, "<green/>");
+	check_xer(Enum2_blue, "<blue/>");
+	check_xer(Enum2_orange, "<orange/>");
+	check_xer(Enum2_alpha, "<alpha/>");
+	check_xer(Enum2_beta, "<beta/>");
+	check_xer(Enum2_gamma, "<gamma/>");
+
+	return 0;
+}
diff --git a/libasn1fix/asn1fix_enum.c b/libasn1fix/asn1fix_enum.c
index 570d23ae..399cb625 100644
--- a/libasn1fix/asn1fix_enum.c
+++ b/libasn1fix/asn1fix_enum.c
@@ -8,15 +8,27 @@ asn1f_fix_enum(arg_t *arg) {
 	asn1p_expr_t *expr = arg->expr;
 	asn1p_expr_t *ev;
 	asn1c_integer_t max_value = -1;
+	asn1c_integer_t max_value_ext = -1;
 	int rvalue = 0;
 	asn1p_expr_t *ext_marker = NULL;	/* "..." position */
 	int ret;
 
+	/* Keep track of value collisions */
+	asn1c_integer_t *used_vals;
+	int used_vals_sz = 50;
+	int used_vals_next = 0;
+
 	if(expr->expr_type != ASN_BASIC_ENUMERATED)
 		return 0;	/* Just ignore it */
 
 	DEBUG("(%s)", expr->Identifier);
 
+	used_vals = (asn1c_integer_t *) malloc(sizeof(asn1c_integer_t) * used_vals_sz);
+	if (!used_vals) {
+		FATAL("Out of memory");
+		return -1;
+	}
+
 	/*
 	 * 1. Scan the enumeration values in search for inconsistencies.
 	 */
@@ -93,12 +105,16 @@ asn1f_fix_enum(arg_t *arg) {
 		/*
 		 * 1.3 Check the applicability of this value.
 		 */
-		if(eval <= max_value) {
-			if(ext_marker) {
-				/*
-				 * Enumeration is allowed to be unordered
-				 * before the first marker.
-				 */
+
+		/*
+		 * Enumeration is allowed to be unordered
+		 * before the first marker, but after the marker
+		 * the values must be ordered.
+		 */
+		if (ext_marker) {
+			if (eval > max_value_ext) {
+				max_value_ext = eval;
+			} else {
 				FATAL(
 					"Enumeration %s at line %d: "
 					"Explicit value \"%s(%" PRIdASN ")\" "
@@ -108,21 +124,59 @@ asn1f_fix_enum(arg_t *arg) {
 					ev->_lineno,
 					ev->Identifier,
 					eval,
-					max_value);
+					max_value_ext);
 				rvalue = -1;
 			}
-		} else if(eval > max_value) {
+		}
+
+		if (eval > max_value) {
 			max_value = eval;
 		}
 
+
+		/*
+		 * 1.4 Check that all identifiers are unique
+		 */
+		int unique = 1;
+		int uv_idx;
+		for (uv_idx = 0; uv_idx < used_vals_next; uv_idx++) {
+			if (used_vals[uv_idx] == eval) {
+				FATAL(
+					"Enumeration %s at line %d: "
+					"Explicit value \"%s(%" PRIdASN ")\" "
+					"collides with previous values",
+					expr->Identifier,
+					ev->_lineno,
+					ev->Identifier,
+					eval);
+				rvalue = -1;
+				unique = 0;
+			}
+		}
+
+		if (unique) {
+			/* Grow the array if needed */
+			if (used_vals_next >= used_vals_sz) {
+				asn1c_integer_t *temp;
+				int new_sz = used_vals_sz + 50;
+				temp = (asn1c_integer_t *) realloc(used_vals,
+							sizeof(asn1c_integer_t) * new_sz);
+				if (!temp) return -1;
+				used_vals = temp;
+				used_vals_sz = new_sz;
+			}
+			used_vals[used_vals_next++] = eval;
+		}
+
 		/*
-		 * 1.4 Check that all identifiers before the current one
+		 * 1.5 Check that all identifiers before the current one
 		 * differs from it.
 		 */
 		ret = asn1f_check_unique_expr_child(arg, ev, 0, "identifier");
 		RET2RVAL(ret, rvalue);
 	}
 
+	free(used_vals);
 
 	/*
 	 * 2. Reorder the first half (before optional "...") of the
diff --git a/tests/03-enum-OK.asn1 b/tests/03-enum-OK.asn1
index 567df26a..a8570a9d 100644
--- a/tests/03-enum-OK.asn1
+++ b/tests/03-enum-OK.asn1
@@ -19,4 +19,19 @@ BEGIN
 		... -- extensible --
 		}
 
+	Enum2 ::= ENUMERATED
+		{ red,	-- will be 0 --
+		green,	-- will be 1 --
+		blue(45),
+		orange(23),	-- Does not have to be ordered --
+		alpha,
+		..., -- extensible --
+		beta(12),	-- May be less than the max value in the root --
+		gamma(103)	-- Must be ordered --
+		}
+
+	Enum3 ::= ENUMERATED { a, b(3), ..., c(1) }
+	Enum4 ::= ENUMERATED { a, b, ..., c(3), d }
+	Enum5 ::= ENUMERATED { a, z(25), ..., d }
+
 END
diff --git a/tests/03-enum-OK.asn1.-EF b/tests/03-enum-OK.asn1.-EF
new file mode 100644
index 00000000..761736ff
--- /dev/null
+++ b/tests/03-enum-OK.asn1.-EF
@@ -0,0 +1,47 @@
+ModuleTestEnum1 { iso org(3) dod(6) internet(1) private(4) enterprise(1)
+	spelio(9363) software(1) asn1c(5) test(1) 3 }
+DEFINITIONS ::=
+BEGIN
+
+Enum1 ::= ENUMERATED {
+    red(0),
+    green(1),
+    blue(4),
+    alpha(5),
+    ...
+}
+
+Enum2 ::= ENUMERATED {
+    red(0),
+    green(1),
+    blue(45),
+    orange(23),
+    alpha(46),
+    ...,
+    beta(12),
+    gamma(103)
+}
+
+Enum3 ::= ENUMERATED {
+    a(0),
+    b(3),
+    ...,
+    c(1)
+}
+
+Enum4 ::= ENUMERATED {
+    a(0),
+    b(1),
+    ...,
+    c(3),
+    d(4)
+}
+
+Enum5 ::= ENUMERATED {
+    a(0),
+    z(25),
+    ...,
+    d(26)
+}
+
+END
diff --git a/tests/03-enum-OK.asn1.-P b/tests/03-enum-OK.asn1.-P
new file mode 100644
index 00000000..d2e8ad0f
--- /dev/null
+++ b/tests/03-enum-OK.asn1.-P
@@ -0,0 +1,798 @@
+
+/*** <<< INCLUDES [Enum1] >>> ***/
+
+#include <ENUMERATED.h>
+
+/*** <<< DEPS [Enum1] >>> ***/
+
+typedef enum Enum1 {
+	Enum1_red	= 0,
+	Enum1_green	= 1,
+	Enum1_blue	= 4,
+	Enum1_alpha	= 5
+	/*
+	 * Enumeration is extensible
+	 */
+} e_Enum1;
+
+/*** <<< TYPE-DECLS [Enum1] >>> ***/
+
+typedef ENUMERATED_t	 Enum1_t;
+
+/*** <<< FUNC-DECLS [Enum1] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum1;
+asn_struct_free_f Enum1_free;
+asn_struct_print_f Enum1_print;
+asn_constr_check_f Enum1_constraint;
+ber_type_decoder_f Enum1_decode_ber;
+der_type_encoder_f Enum1_encode_der;
+xer_type_decoder_f Enum1_decode_xer;
+xer_type_encoder_f Enum1_encode_xer;
+
+/*** <<< CODE [Enum1] >>> ***/
+
+int
+Enum1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+Enum1_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum1_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum1_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum1_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum1_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum1_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum1_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [Enum1] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum1_value2enum_1[] = {
+	{ 0,	3,	"red" },
+	{ 1,	5,	"green" },
+	{ 4,	4,	"blue" },
+	{ 5,	5,	"alpha" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_Enum1_enum2value_1[] = {
+	3,	/* alpha(5) */
+	2,	/* blue(4) */
+	1,	/* green(1) */
+	0	/* red(0) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum1_specs_1 = {
+	asn_MAP_Enum1_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum1_enum2value_1,	/* N => "tag"; sorted by N */
+	4,	/* Number of elements in the maps */
+	5,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_Enum1_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Enum1 = {
+	"Enum1",
+	"Enum1",
+	Enum1_free,
+	Enum1_print,
+	Enum1_constraint,
+	Enum1_decode_ber,
+	Enum1_encode_der,
+	Enum1_decode_xer,
+	Enum1_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum1_tags_1,
+	sizeof(asn_DEF_Enum1_tags_1)
+		/sizeof(asn_DEF_Enum1_tags_1[0]), /* 1 */
+	asn_DEF_Enum1_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum1_tags_1)
+		/sizeof(asn_DEF_Enum1_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum1_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum2] >>> ***/
+
+#include <ENUMERATED.h>
+
+/*** <<< DEPS [Enum2] >>> ***/
+
+typedef enum Enum2 {
+	Enum2_red	= 0,
+	Enum2_green	= 1,
+	Enum2_blue	= 45,
+	Enum2_orange	= 23,
+	Enum2_alpha	= 46,
+	/*
+	 * Enumeration is extensible
+	 */
+	Enum2_beta	= 12,
+	Enum2_gamma	= 103
+} e_Enum2;
+
+/*** <<< TYPE-DECLS [Enum2] >>> ***/
+
+typedef ENUMERATED_t	 Enum2_t;
+
+/*** <<< FUNC-DECLS [Enum2] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum2;
+asn_struct_free_f Enum2_free;
+asn_struct_print_f Enum2_print;
+asn_constr_check_f Enum2_constraint;
+ber_type_decoder_f Enum2_decode_ber;
+der_type_encoder_f Enum2_encode_der;
+xer_type_decoder_f Enum2_decode_xer;
+xer_type_encoder_f Enum2_encode_xer;
+
+/*** <<< CODE [Enum2] >>> ***/
+
+int
+Enum2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+Enum2_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum2_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum2_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum2_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum2_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum2_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum2_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum2_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum2_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum2_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum2_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum2_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [Enum2] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum2_value2enum_1[] = {
+	{ 0,	3,	"red" },
+	{ 1,	5,	"green" },
+	{ 12,	4,	"beta" },
+	{ 23,	6,	"orange" },
+	{ 45,	4,	"blue" },
+	{ 46,	5,	"alpha" },
+	{ 103,	5,	"gamma" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_Enum2_enum2value_1[] = {
+	5,	/* alpha(46) */
+	2,	/* beta(12) */
+	4,	/* blue(45) */
+	6,	/* gamma(103) */
+	1,	/* green(1) */
+	3,	/* orange(23) */
+	0	/* red(0) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum2_specs_1 = {
+	asn_MAP_Enum2_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum2_enum2value_1,	/* N => "tag"; sorted by N */
+	7,	/* Number of elements in the maps */
+	6,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_Enum2_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Enum2 = {
+	"Enum2",
+	"Enum2",
+	Enum2_free,
+	Enum2_print,
+	Enum2_constraint,
+	Enum2_decode_ber,
+	Enum2_encode_der,
+	Enum2_decode_xer,
+	Enum2_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum2_tags_1,
+	sizeof(asn_DEF_Enum2_tags_1)
+		/sizeof(asn_DEF_Enum2_tags_1[0]), /* 1 */
+	asn_DEF_Enum2_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum2_tags_1)
+		/sizeof(asn_DEF_Enum2_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum2_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum3] >>> ***/
+
+#include <ENUMERATED.h>
+
+/*** <<< DEPS [Enum3] >>> ***/
+
+typedef enum Enum3 {
+	Enum3_a	= 0,
+	Enum3_b	= 3,
+	/*
+	 * Enumeration is extensible
+	 */
+	Enum3_c	= 1
+} e_Enum3;
+
+/*** <<< TYPE-DECLS [Enum3] >>> ***/
+
+typedef ENUMERATED_t	 Enum3_t;
+
+/*** <<< FUNC-DECLS [Enum3] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum3;
+asn_struct_free_f Enum3_free;
+asn_struct_print_f Enum3_print;
+asn_constr_check_f Enum3_constraint;
+ber_type_decoder_f Enum3_decode_ber;
+der_type_encoder_f Enum3_encode_der;
+xer_type_decoder_f Enum3_decode_xer;
+xer_type_encoder_f Enum3_encode_xer;
+
+/*** <<< CODE [Enum3] >>> ***/
+
+int
+Enum3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+Enum3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum3_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum3_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum3_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum3_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum3_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum3_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum3_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [Enum3] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum3_value2enum_1[] = {
+	{ 0,	1,	"a" },
+	{ 1,	1,	"c" },
+	{ 3,	1,	"b" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_Enum3_enum2value_1[] = {
+	0,	/* a(0) */
+	2,	/* b(3) */
+	1	/* c(1) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum3_specs_1 = {
+	asn_MAP_Enum3_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum3_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_Enum3_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Enum3 = {
+	"Enum3",
+	"Enum3",
+	Enum3_free,
+	Enum3_print,
+	Enum3_constraint,
+	Enum3_decode_ber,
+	Enum3_encode_der,
+	Enum3_decode_xer,
+	Enum3_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum3_tags_1,
+	sizeof(asn_DEF_Enum3_tags_1)
+		/sizeof(asn_DEF_Enum3_tags_1[0]), /* 1 */
+	asn_DEF_Enum3_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum3_tags_1)
+		/sizeof(asn_DEF_Enum3_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum3_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum4] >>> ***/
+
+#include <ENUMERATED.h>
+
+/*** <<< DEPS [Enum4] >>> ***/
+
+typedef enum Enum4 {
+	Enum4_a	= 0,
+	Enum4_b	= 1,
+	/*
+	 * Enumeration is extensible
+	 */
+	Enum4_c	= 3,
+	Enum4_d	= 4
+} e_Enum4;
+
+/*** <<< TYPE-DECLS [Enum4] >>> ***/
+
+typedef ENUMERATED_t	 Enum4_t;
+
+/*** <<< FUNC-DECLS [Enum4] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum4;
+asn_struct_free_f Enum4_free;
+asn_struct_print_f Enum4_print;
+asn_constr_check_f Enum4_constraint;
+ber_type_decoder_f Enum4_decode_ber;
+der_type_encoder_f Enum4_encode_der;
+xer_type_decoder_f Enum4_decode_xer;
+xer_type_encoder_f Enum4_encode_xer;
+
+/*** <<< CODE [Enum4] >>> ***/
+
+int
+Enum4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+Enum4_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum4_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum4_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum4_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum4_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum4_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum4_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum4_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum4_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum4_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum4_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum4_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [Enum4] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum4_value2enum_1[] = {
+	{ 0,	1,	"a" },
+	{ 1,	1,	"b" },
+	{ 3,	1,	"c" },
+	{ 4,	1,	"d" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_Enum4_enum2value_1[] = {
+	0,	/* a(0) */
+	1,	/* b(1) */
+	2,	/* c(3) */
+	3	/* d(4) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum4_specs_1 = {
+	asn_MAP_Enum4_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum4_enum2value_1,	/* N => "tag"; sorted by N */
+	4,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_Enum4_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Enum4 = {
+	"Enum4",
+	"Enum4",
+	Enum4_free,
+	Enum4_print,
+	Enum4_constraint,
+	Enum4_decode_ber,
+	Enum4_encode_der,
+	Enum4_decode_xer,
+	Enum4_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum4_tags_1,
+	sizeof(asn_DEF_Enum4_tags_1)
+		/sizeof(asn_DEF_Enum4_tags_1[0]), /* 1 */
+	asn_DEF_Enum4_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum4_tags_1)
+		/sizeof(asn_DEF_Enum4_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum4_specs_1	/* Additional specs */
+};
+
+
+/*** <<< INCLUDES [Enum5] >>> ***/
+
+#include <ENUMERATED.h>
+
+/*** <<< DEPS [Enum5] >>> ***/
+
+typedef enum Enum5 {
+	Enum5_a	= 0,
+	Enum5_z	= 25,
+	/*
+	 * Enumeration is extensible
+	 */
+	Enum5_d	= 26
+} e_Enum5;
+
+/*** <<< TYPE-DECLS [Enum5] >>> ***/
+
+typedef ENUMERATED_t	 Enum5_t;
+
+/*** <<< FUNC-DECLS [Enum5] >>> ***/
+
+extern asn_TYPE_descriptor_t asn_DEF_Enum5;
+asn_struct_free_f Enum5_free;
+asn_struct_print_f Enum5_print;
+asn_constr_check_f Enum5_constraint;
+ber_type_decoder_f Enum5_decode_ber;
+der_type_encoder_f Enum5_encode_der;
+xer_type_decoder_f Enum5_decode_xer;
+xer_type_encoder_f Enum5_encode_xer;
+
+/*** <<< CODE [Enum5] >>> ***/
+
+int
+Enum5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Enum5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+Enum5_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Enum5_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Enum5_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum5_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum5_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Enum5_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Enum5_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum5_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Enum5_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Enum5_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Enum5_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Enum5_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+
+/*** <<< STAT-DEFS [Enum5] >>> ***/
+
+static asn_INTEGER_enum_map_t asn_MAP_Enum5_value2enum_1[] = {
+	{ 0,	1,	"a" },
+	{ 25,	1,	"z" },
+	{ 26,	1,	"d" }
+	/* This list is extensible */
+};
+static unsigned int asn_MAP_Enum5_enum2value_1[] = {
+	0,	/* a(0) */
+	2,	/* d(26) */
+	1	/* z(25) */
+	/* This list is extensible */
+};
+static asn_INTEGER_specifics_t asn_SPC_Enum5_specs_1 = {
+	asn_MAP_Enum5_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_Enum5_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	3,	/* Extensions before this member */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_Enum5_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Enum5 = {
+	"Enum5",
+	"Enum5",
+	Enum5_free,
+	Enum5_print,
+	Enum5_constraint,
+	Enum5_decode_ber,
+	Enum5_encode_der,
+	Enum5_decode_xer,
+	Enum5_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Enum5_tags_1,
+	sizeof(asn_DEF_Enum5_tags_1)
+		/sizeof(asn_DEF_Enum5_tags_1[0]), /* 1 */
+	asn_DEF_Enum5_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Enum5_tags_1)
+		/sizeof(asn_DEF_Enum5_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_Enum5_specs_1	/* Additional specs */
+};
+
diff --git a/tests/128-enum-SE.asn1 b/tests/128-enum-SE.asn1
new file mode 100644
index 00000000..40b8caf2
--- /dev/null
+++ b/tests/128-enum-SE.asn1
@@ -0,0 +1,16 @@
+
+-- SE: Semantic error
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .128
+
+ModuleTestEnum1
+	{ iso org(3) dod(6) internet (1) private(4) enterprise(1)
+		spelio(9363) software(1) asn1c(5) test(1) 128 }
+	DEFINITIONS ::=
+BEGIN
+
+	A ::= ENUMERATED {a, b, ..., c, d(2)}
+
+END
diff --git a/tests/129-enum-OK.asn1 b/tests/129-enum-OK.asn1
new file mode 100644
index 00000000..06f5eed9
--- /dev/null
+++ b/tests/129-enum-OK.asn1
@@ -0,0 +1,16 @@
+
+-- OK: Everything is fine
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .129
+
+ModuleTestEnum1
+	{ iso org(3) dod(6) internet (1) private(4) enterprise(1)
+		spelio(9363) software(1) asn1c(5) test(1) 129 }
+	DEFINITIONS ::=
+BEGIN
+
+	A ::= ENUMERATED {a(-5), b(-4), c}
+
+END
diff --git a/tests/129-enum-OK.asn1.-EF b/tests/129-enum-OK.asn1.-EF
new file mode 100644
index 00000000..ebc3d30e
--- /dev/null
+++ b/tests/129-enum-OK.asn1.-EF
@@ -0,0 +1,12 @@
+ModuleTestEnum1 { iso org(3) dod(6) internet(1) private(4) enterprise(1)
+	spelio(9363) software(1) asn1c(5) test(1) 129 }
+DEFINITIONS ::=
+BEGIN
+
+A ::= ENUMERATED {
+    a(-5),
+    b(-4),
+    c(0)
+}
+
+END
diff --git a/tests/129-enum-SE.asn1 b/tests/129-enum-SE.asn1
new file mode 100644
index 00000000..cb85dc9d
--- /dev/null
+++ b/tests/129-enum-SE.asn1
@@ -0,0 +1,16 @@
+
+-- SE: Semantic error
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .129
+
+ModuleTestEnum1
+	{ iso org(3) dod(6) internet (1) private(4) enterprise(1)
+		spelio(9363) software(1) asn1c(5) test(1) 129 }
+	DEFINITIONS ::=
+BEGIN
+
+	A ::= ENUMERATED {a, b, ..., c, d(2)}
+
+END
diff --git a/tests/130-enum-OK.asn1 b/tests/130-enum-OK.asn1
new file mode 100644
index 00000000..d917e398
--- /dev/null
+++ b/tests/130-enum-OK.asn1
@@ -0,0 +1,16 @@
+
+-- OK: Everything is fine
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .130
+
+ModuleTestEnum1
+	{ iso org(3) dod(6) internet (1) private(4) enterprise(1)
+		spelio(9363) software(1) asn1c(5) test(1) 130 }
+	DEFINITIONS ::=
+BEGIN
+
+	A ::= ENUMERATED {a(-5), b(-4),..., c}
+
+END
diff --git a/tests/130-enum-OK.asn1.-EF b/tests/130-enum-OK.asn1.-EF
new file mode 100644
index 00000000..eaa5a51a
--- /dev/null
+++ b/tests/130-enum-OK.asn1.-EF
@@ -0,0 +1,13 @@
+ModuleTestEnum1 { iso org(3) dod(6) internet(1) private(4) enterprise(1)
+	spelio(9363) software(1) asn1c(5) test(1) 130 }
+DEFINITIONS ::=
+BEGIN
+
+A ::= ENUMERATED {
+    a(-5),
+    b(-4),
+    ...,
+    c(0)
+}
+
+END