parameterization: direct assignment

git-svn-id: https://asn1c.svn.sourceforge.net/svnroot/asn1c/trunk@1103 59561ff5-6e30-0410-9f3c-9617f08c8826

libasn1fix/asn1fix.c

@@ -490,6 +490,9 @@ asn1f_check_duplicate(arg_t *arg) {
 			assert(tmparg.expr->Identifier);
 			assert(arg->expr->Identifier);
 
+			if(arg->expr->spec_index != -1)
+				continue;
+
 			if(tmparg.expr == arg->expr) break;
 
 			if(strcmp(tmparg.expr->Identifier,

libasn1fix/asn1fix_param.c

@@ -18,11 +18,9 @@ asn1f_parameterization_fork(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *rhs_ps
 	resolver_arg_t rarg;	/* resolver argument */
 	asn1p_expr_t *exc;	/* expr clone */
 	asn1p_expr_t *rpc;	/* rhs_pspecs clone */
-	asn1p_expr_t *target;
 	void *p;
 	struct asn1p_pspec_s *pspec;
 	int npspecs;
-	int i;
 
 	assert(rhs_pspecs);
 	assert(expr->lhs_params);
@@ -70,24 +68,6 @@ asn1f_parameterization_fork(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *rhs_ps
 	pspec->my_clone = exc;
 	exc->spec_index = npspecs;
 
-	/* Update LHS->RHS specialization in target */
-	target = TQ_FIRST(&rpc->members);
-	for(i = 0; i < exc->lhs_params->params_count;
-			i++, target = TQ_NEXT(target, next)) {
-		if(!target) { target = (void *)0xdeadbeef; break; }
-
-		assert(exc->lhs_params->params[i].into_expr == 0);
-		exc->lhs_params->params[i].into_expr = target;
-	}
-	if(target) {
-		asn1p_expr_free(exc);
-		asn1p_expr_free(rpc);
-		FATAL("Parameterization of %s failed: "
-			"parameters number mismatch", expr->Identifier);
-		errno = EPERM;
-		return NULL;
-	}
-
 	DEBUG("Forked new parameterization for %s", expr->Identifier);
 
 	/* Commit */

libasn1parser/asn1p_expr.c

@@ -75,8 +75,22 @@ asn1p_expr_clone_impl(asn1p_expr_t *expr, int skip_extensions, asn1p_expr_t *(*r
 				} else {
 					clone->constraints = tmpct;
 				}
+				assert(expr->combined_constraints == 0);
+			}
+			/* Merge defaults */
+			CLCOPY(marker.flags);
+			CLVRCLONE(marker.default_value,
+				asn1p_value_clone_with_resolver);
+			if(clone->tag.tag_class == TC_NOCLASS) {
+				CLCOPY(tag);
+			} else if(expr->tag.tag_class != TC_NOCLASS) {
+				fprintf(stderr, "asn1c does not support "
+					"nested tagging in parameterization, "
+					"necessary at line %d\n",
+					expr->_lineno);
+				asn1p_expr_free(clone);
+				return NULL;
 			}
-			assert(expr->combined_constraints == 0);
 			return clone;
 		} else if(errno != ESRCH) {
 			return NULL;	/* Hard error */
@@ -107,7 +121,7 @@ asn1p_expr_clone_impl(asn1p_expr_t *expr, int skip_extensions, asn1p_expr_t *(*r
 	CLVRCLONE(combined_constraints, asn1p_constraint_clone_with_resolver);
 	CLCLONE(lhs_params, asn1p_paramlist_clone);
 	CLVRCLONE(value, asn1p_value_clone_with_resolver);
-	CLCLONE(marker.default_value, asn1p_value_clone);
+	CLVRCLONE(marker.default_value, asn1p_value_clone_with_resolver);
 	CLCLONE(with_syntax, asn1p_wsyntx_clone);
 
 	/*

libasn1parser/asn1p_param.c

@@ -62,7 +62,8 @@ asn1p_paramlist_add_param(asn1p_paramlist_t *pl, asn1p_ref_t *gov, char *arg) {
 			pl->params = p;
 			pl->params_size = newsize;
 			memset(&pl->params[pl->params_count], 0,
-				sizeof(pl->params[0]));
+				(newsize - pl->params_size)
+				* sizeof(pl->params[0]));
 		} else {
 			return -1;
 		}
@@ -104,7 +105,6 @@ asn1p_paramlist_clone(asn1p_paramlist_t *pl) {
 				newpl = NULL;
 				break;
 			}
-			newpl->params[i].into_expr = pl->params[i].into_expr;
 		}
 	}
 

libasn1parser/asn1p_param.h

@@ -11,8 +11,6 @@ typedef struct asn1p_paramlist_s {
 		/* Translated from */
 		asn1p_ref_t	*governor;
 		char		*argument;
-		/* Translated into */
-		struct asn1p_expr_s	*into_expr;
 	} *params;
 	int params_count;
 	int params_size;

libasn1parser/asn1p_y.y

@@ -250,10 +250,11 @@ static void _fixup_anonymous_identifier(asn1p_expr_t *expr);
 %type	<a_expr>		ObjectClass
 %type	<a_expr>		Type
 %type	<a_expr>		DataTypeReference	/* Type1 ::= Type2 */
-%type	<a_expr>		DefinedTypeRef
+%type	<a_expr>		DefinedType
 %type	<a_expr>		ValueSetDefinition  /* Val INTEGER ::= {1|2} */
 %type	<a_expr>		ValueDefinition		/* val INTEGER ::= 1*/
 %type	<a_value>		Value
+%type	<a_value>		SimpleValue
 %type	<a_value>		DefinedValue
 %type	<a_value>		SignedNumber
 %type	<a_expr>		optComponentTypeLists
@@ -712,7 +713,7 @@ ExportsElement:
 
 
 ValueSetDefinition:
-	TypeRefName DefinedTypeRef TOK_PPEQ
+	TypeRefName DefinedType TOK_PPEQ
 		'{' { asn1p_lexer_hack_push_opaque_state(); } Opaque /* '}' */ {
 		$$ = $2;
 		assert($$->Identifier == 0);
@@ -722,19 +723,37 @@ ValueSetDefinition:
 	}
 	;
 
-DefinedTypeRef:
+DefinedType:
-	ComplexTypeReference {
+	BasicType {
+		$$ = $1;
+	}
+	/*
+	 * A DefinedType reference.
+	 * "CLASS1.&id.&id2"
+	 * or
+	 * "Module.Type"
+	 * or
+	 * "Module.identifier"
+	 * or
+	 * "Type"
+	 */
+	| ComplexTypeReference {
 		$$ = asn1p_expr_new(yylineno);
 		checkmem($$);
 		$$->reference = $1;
 		$$->expr_type = A1TC_REFERENCE;
 		$$->meta_type = AMT_TYPEREF;
 	}
-	| BasicTypeId {
+	/*
+	 * A parametrized assignment.
+	 */
+	| ComplexTypeReference '{' Specializations '}' {
 		$$ = asn1p_expr_new(yylineno);
 		checkmem($$);
-		$$->expr_type = $1;
+		$$->reference = $1;
-		$$->meta_type = AMT_TYPE;
+		$$->rhs_pspecs = $3;
+		$$->expr_type = A1TC_REFERENCE;
+		$$->meta_type = AMT_TYPEREF;
 	}
 	;
 
@@ -843,6 +862,14 @@ Specialization:
 	Type {
 		$$ = $1;
 	}
+	| SimpleValue {
+		$$ = asn1p_expr_new(yylineno);
+		checkmem($$);
+		$$->Identifier = "?";
+		$$->expr_type = A1TC_REFERENCE;
+		$$->meta_type = AMT_VALUE;
+		$$->value = $1;
+	}
 	| Identifier {
 		asn1p_ref_t *ref;
 		$$ = asn1p_expr_new(yylineno);
@@ -1168,7 +1195,7 @@ TypeDeclaration:
 	;
 
 TypeDeclarationSet:
-	BasicType {
+	DefinedType {
 		$$ = $1;
 	}
 	| TOK_CHOICE '{' AlternativeTypeLists '}' {
@@ -1226,34 +1253,7 @@ TypeDeclarationSet:
 		$$->expr_type = ASN_TYPE_ANY;
 		$$->meta_type = AMT_TYPE;
 	}
-	/*
+
-	 * A DefinedType reference.
-	 * "CLASS1.&id.&id2"
-	 * or
-	 * "Module.Type"
-	 * or
-	 * "Module.identifier"
-	 * or
-	 * "Type"
-	 */
-	| ComplexTypeReference {
-		$$ = asn1p_expr_new(yylineno);
-		checkmem($$);
-		$$->reference = $1;
-		$$->expr_type = A1TC_REFERENCE;
-		$$->meta_type = AMT_TYPEREF;
-	}
-	/*
-	 * A parametrized assignment.
-	 */
-	| ComplexTypeReference '{' Specializations '}' {
-		$$ = asn1p_expr_new(yylineno);
-		checkmem($$);
-		$$->reference = $1;
-		$$->rhs_pspecs = $3;
-		$$->expr_type = A1TC_REFERENCE;
-		$$->meta_type = AMT_TYPEREF;
-	}
 	| TOK_INSTANCE TOK_OF ComplexTypeReference {
 		$$ = asn1p_expr_new(yylineno);
 		checkmem($$);
@@ -1407,7 +1407,7 @@ DefinedObjectClass:
  * === EOF ===
  */
 ValueDefinition:
-	Identifier DefinedTypeRef TOK_PPEQ Value {
+	Identifier DefinedType TOK_PPEQ Value {
 		$$ = $2;
 		assert($$->Identifier == NULL);
 		$$->Identifier = $1;
@@ -1417,7 +1417,9 @@ ValueDefinition:
 	;
 
 Value:
-	Identifier ':' Value {
+	SimpleValue
+	| DefinedValue
+	| Identifier ':' Value {
 		$$ = asn1p_value_fromint(0);
 		checkmem($$);
 		$$->type = ATV_CHOICE_IDENTIFIER;
@@ -1434,7 +1436,10 @@ Value:
 		checkmem($$);
 		$$->type = ATV_NULL;
 	}
-	| TOK_FALSE {
+	;
+
+SimpleValue:
+	TOK_FALSE {
 		$$ = asn1p_value_fromint(0);
 		checkmem($$);
 		$$->type = ATV_FALSE;
@@ -1458,9 +1463,6 @@ Value:
 	| SignedNumber {
 		$$ = $1;
 	}
-	| DefinedValue {
-		$$ = $1;
-	}
 	;
 
 DefinedValue:

libasn1print/asn1print.c

@@ -668,6 +668,7 @@ asn1print_expr(asn1p_t *asn, asn1p_module_t *mod, asn1p_expr_t *tc, enum asn1pri
 		printf("{");
 		TQ_FOR(se, &(tc->rhs_pspecs->members), next) {
 			asn1print_expr(asn, mod, se, flags, level + 1);
+			if(TQ_NEXT(se, next)) printf(", ");
 		}
 		printf("}");
 	}

tests/106-param-constr-OK.asn1

@@ -11,10 +11,12 @@ ModuleParametrizationWithConstraints
 	DEFINITIONS ::=
 BEGIN
 
-	Narrow {Type} ::= SEQUENCE {
+	Narrow {Type, INTEGER:value} ::= SEQUENCE {
-		narrower	Type (2..5)
+		narrow1	Type (1..5)	DEFAULT value,
+		narrow2	[0] Type (2..5),
+		narrow3	[1] Type (3..5)	OPTIONAL
 	}
 
-	NarrowInteger ::= Narrow {INTEGER (0..10)}
+	NarrowInteger ::= Narrow {INTEGER (0..10), 3}
 
 END

tests/106-param-constr-OK.asn1.-P

@@ -6,21 +6,48 @@
 
 /*** <<< TYPE-DECLS [Narrow] >>> ***/
 
-typedef struct Narrow_16P0 {
+typedef struct Narrow_15P0 {
-	long	 narrower;
+	long	*narrow1	/* DEFAULT 3 */;
+	long	 narrow2;
+	long	*narrow3	/* OPTIONAL */;
 	
 	/* Context for parsing across buffer boundaries */
 	asn_struct_ctx_t _asn_ctx;
-} Narrow_16P0_t;
+} Narrow_15P0_t;
 
 /*** <<< FUNC-DECLS [Narrow] >>> ***/
 
-extern asn_TYPE_descriptor_t asn_DEF_Narrow_16P0;
+extern asn_TYPE_descriptor_t asn_DEF_Narrow_15P0;
 
 /*** <<< CODE [Narrow] >>> ***/
 
 static int
-memb_narrower_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_narrow1_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 1 && value <= 5)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_narrow2_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	long value;
 	
@@ -44,36 +71,93 @@ memb_narrower_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 	}
 }
 
+static int
+memb_narrow3_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_consume_bytes_f *app_errlog, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 3 && value <= 5)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_ERRLOG(app_errlog, app_key,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
 
 /*** <<< STAT-DEFS [Narrow] >>> ***/
 
-static asn_TYPE_member_t asn_MBR_Narrow_16P0_1[] = {
+static int asn_DFL_2_set_3(void **sptr) {
-	{ ATF_NOFLAGS, 0, offsetof(struct Narrow_16P0, narrower),
+	long *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 3 */
+	*st = 3;
+	return 0;
+}
+static asn_TYPE_member_t asn_MBR_Narrow_15P0_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct Narrow_15P0, narrow1),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_NativeInteger,
-		.memb_constraints = memb_narrower_constraint_1,
+		.memb_constraints = memb_narrow1_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = asn_DFL_2_set_3,	/* DEFAULT 3 */
+		.name = "narrow1"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Narrow_15P0, narrow2),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_NativeInteger,
+		.memb_constraints = memb_narrow2_constraint_1,
 		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
 		.default_value = 0,
-		.name = "narrower"
+		.name = "narrow2"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Narrow_15P0, narrow3),
+		.tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		.tag_mode = +1,	/* EXPLICIT tag at current level */
+		.type = &asn_DEF_NativeInteger,
+		.memb_constraints = memb_narrow3_constraint_1,
+		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
+		.default_value = 0,
+		.name = "narrow3"
 		},
 };
-static ber_tlv_tag_t asn_DEF_Narrow_16P0_tags_1[] = {
+static ber_tlv_tag_t asn_DEF_Narrow_15P0_tags_1[] = {
 	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_TYPE_tag2member_t asn_MAP_Narrow_16P0_tag2el_1[] = {
+static asn_TYPE_tag2member_t asn_MAP_Narrow_15P0_tag2el_1[] = {
-    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 } /* narrower at 18 */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* narrow1 at 20 */
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 }, /* narrow2 at 20 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 2, 0, 0 } /* narrow3 at 20 */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Narrow_16P0_specs_1 = {
+static asn_SEQUENCE_specifics_t asn_SPC_Narrow_15P0_specs_1 = {
-	sizeof(struct Narrow_16P0),
+	sizeof(struct Narrow_15P0),
-	offsetof(struct Narrow_16P0, _asn_ctx),
+	offsetof(struct Narrow_15P0, _asn_ctx),
-	asn_MAP_Narrow_16P0_tag2el_1,
+	asn_MAP_Narrow_15P0_tag2el_1,
-	1,	/* Count of tags in the map */
+	3,	/* Count of tags in the map */
 	0, 0, 0,	/* Optional elements (not needed) */
 	-1,	/* Start extensions */
 	-1	/* Stop extensions */
 };
-asn_TYPE_descriptor_t asn_DEF_Narrow_16P0 = {
+asn_TYPE_descriptor_t asn_DEF_Narrow_15P0 = {
 	"Narrow",
 	"Narrow",
 	SEQUENCE_free,
@@ -85,16 +169,16 @@ asn_TYPE_descriptor_t asn_DEF_Narrow_16P0 = {
 	SEQUENCE_encode_xer,
 	0,	/* No PER decoder, -gen-PER to enable */
 	0,	/* Use generic outmost tag fetcher */
-	asn_DEF_Narrow_16P0_tags_1,
+	asn_DEF_Narrow_15P0_tags_1,
-	sizeof(asn_DEF_Narrow_16P0_tags_1)
+	sizeof(asn_DEF_Narrow_15P0_tags_1)
-		/sizeof(asn_DEF_Narrow_16P0_tags_1[0]), /* 1 */
+		/sizeof(asn_DEF_Narrow_15P0_tags_1[0]), /* 1 */
-	asn_DEF_Narrow_16P0_tags_1,	/* Same as above */
+	asn_DEF_Narrow_15P0_tags_1,	/* Same as above */
-	sizeof(asn_DEF_Narrow_16P0_tags_1)
+	sizeof(asn_DEF_Narrow_15P0_tags_1)
-		/sizeof(asn_DEF_Narrow_16P0_tags_1[0]), /* 1 */
+		/sizeof(asn_DEF_Narrow_15P0_tags_1[0]), /* 1 */
 	0,	/* No PER visible constraints */
-	asn_MBR_Narrow_16P0_1,
+	asn_MBR_Narrow_15P0_1,
-	1,	/* Elements count */
+	3,	/* Elements count */
-	&asn_SPC_Narrow_16P0_specs_1	/* Additional specs */
+	&asn_SPC_Narrow_15P0_specs_1	/* Additional specs */
 };
 
 
@@ -104,7 +188,7 @@ asn_TYPE_descriptor_t asn_DEF_Narrow_16P0 = {
 
 /*** <<< TYPE-DECLS [NarrowInteger] >>> ***/
 
-typedef Narrow_16P0_t	 NarrowInteger_t;
+typedef Narrow_15P0_t	 NarrowInteger_t;
 
 /*** <<< FUNC-DECLS [NarrowInteger] >>> ***/
 
@@ -123,28 +207,28 @@ int
 NarrowInteger_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
 			asn_app_consume_bytes_f *app_errlog, void *app_key) {
 	/* Replace with underlying type checker */
-	td->check_constraints = asn_DEF_Narrow_16P0.check_constraints;
+	td->check_constraints = asn_DEF_Narrow_15P0.check_constraints;
 	return td->check_constraints(td, sptr, app_errlog, app_key);
 }
 
 /*
- * This type is implemented using Narrow_16P0,
+ * This type is implemented using Narrow_15P0,
  * so here we adjust the DEF accordingly.
  */
 static void
 NarrowInteger_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-	td->free_struct    = asn_DEF_Narrow_16P0.free_struct;
+	td->free_struct    = asn_DEF_Narrow_15P0.free_struct;
-	td->print_struct   = asn_DEF_Narrow_16P0.print_struct;
+	td->print_struct   = asn_DEF_Narrow_15P0.print_struct;
-	td->ber_decoder    = asn_DEF_Narrow_16P0.ber_decoder;
+	td->ber_decoder    = asn_DEF_Narrow_15P0.ber_decoder;
-	td->der_encoder    = asn_DEF_Narrow_16P0.der_encoder;
+	td->der_encoder    = asn_DEF_Narrow_15P0.der_encoder;
-	td->xer_decoder    = asn_DEF_Narrow_16P0.xer_decoder;
+	td->xer_decoder    = asn_DEF_Narrow_15P0.xer_decoder;
-	td->xer_encoder    = asn_DEF_Narrow_16P0.xer_encoder;
+	td->xer_encoder    = asn_DEF_Narrow_15P0.xer_encoder;
-	td->uper_decoder   = asn_DEF_Narrow_16P0.uper_decoder;
+	td->uper_decoder   = asn_DEF_Narrow_15P0.uper_decoder;
 	if(!td->per_constraints)
-		td->per_constraints = asn_DEF_Narrow_16P0.per_constraints;
+		td->per_constraints = asn_DEF_Narrow_15P0.per_constraints;
-	td->elements       = asn_DEF_Narrow_16P0.elements;
+	td->elements       = asn_DEF_Narrow_15P0.elements;
-	td->elements_count = asn_DEF_Narrow_16P0.elements_count;
+	td->elements_count = asn_DEF_Narrow_15P0.elements_count;
-	td->specifics      = asn_DEF_Narrow_16P0.specifics;
+	td->specifics      = asn_DEF_Narrow_15P0.specifics;
 }
 
 void

tests/107-param-constr-2-OK.asn1

@@ -0,0 +1,18 @@
+
+-- OK: Everything is fine
+
+-- iso.org.dod.internet.private.enterprise (1.3.6.1.4.1)
+-- .spelio.software.asn1c.test (9363.1.5.1)
+-- .107
+
+ModuleParametrizationWithConstraints2
+	{ iso org(3) dod(6) internet (1) private(4) enterprise(1)
+		spelio(9363) software(1) asn1c(5) test(1) 107 }
+	DEFINITIONS ::=
+BEGIN
+
+	Narrow {Type} ::= Type (2..5)
+
+	NarrowInteger ::= Narrow {INTEGER}
+
+END

tests/84-param-tags-OK.asn1.-P

@@ -8,13 +8,13 @@
 /*** <<< TYPE-DECLS [TestType] >>> ***/
 
 typedef struct TestType_16P0 {
-	long	 common;
+	long	 common	/* DEFAULT 0 */;
 	
 	/* Context for parsing across buffer boundaries */
 	asn_struct_ctx_t _asn_ctx;
 } TestType_16P0_t;
 typedef struct TestType_16P1 {
-	BOOLEAN_t	 common;
+	BOOLEAN_t	 common	/* DEFAULT 0 */;
 	
 	/* Context for parsing across buffer boundaries */
 	asn_struct_ctx_t _asn_ctx;
@@ -55,14 +55,26 @@ memb_common_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 
 /*** <<< STAT-DEFS [TestType] >>> ***/
 
+static int asn_DFL_2_set_0(void **sptr) {
+	long *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 0 */
+	*st = 0;
+	return 0;
+}
 static asn_TYPE_member_t asn_MBR_TestType_16P0_1[] = {
-	{ ATF_NOFLAGS, 0, offsetof(struct TestType_16P0, common),
+	{ ATF_NOFLAGS, 1, offsetof(struct TestType_16P0, common),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_NativeInteger,
 		.memb_constraints = memb_common_constraint_1,
 		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
-		.default_value = 0,
+		.default_value = asn_DFL_2_set_0,	/* DEFAULT 0 */
 		.name = "common"
 		},
 };
@@ -105,14 +117,26 @@ asn_TYPE_descriptor_t asn_DEF_TestType_16P0 = {
 	&asn_SPC_TestType_16P0_specs_1	/* Additional specs */
 };
 
+static int asn_DFL_4_set_0(void **sptr) {
+	BOOLEAN_t *st = *sptr;
+	
+	if(!st) {
+		st = (*sptr = CALLOC(1, sizeof(*st)));
+		if(!st) return -1;
+	}
+	
+	/* Install default value 0 */
+	*st = 0;
+	return 0;
+}
 static asn_TYPE_member_t asn_MBR_TestType_16P1_3[] = {
-	{ ATF_NOFLAGS, 0, offsetof(struct TestType_16P1, common),
+	{ ATF_NOFLAGS, 1, offsetof(struct TestType_16P1, common),
 		.tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
 		.tag_mode = 0,
 		.type = &asn_DEF_BOOLEAN,
 		.memb_constraints = 0,	/* Defer constraints checking to the member type */
 		.per_constraints = 0,	/* PER is not compiled, use -gen-PER */
-		.default_value = 0,
+		.default_value = asn_DFL_4_set_0,	/* DEFAULT 0 */
 		.name = "common"
 		},
 };