Blame - tests/90-cond-int-type-OK.asn1.-Pfnative-types - asn1c

blob: eaf0f53ca22ae6281908124a6d6caec02c24313a [file] [log] [blame]

Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1
				2	/* <<< INCLUDES [CN-IntegerUnlimited] >>> */
				3
				4	#include <NativeInteger.h>
				5
				6	/* <<< TYPE-DECLS [CN-IntegerUnlimited] >>> */
				7
				8	typedef long CN_IntegerUnlimited_t;
				9
				10	/* <<< FUNC-DECLS [CN-IntegerUnlimited] >>> */
				11
				12	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited;
				13	asn_struct_free_f CN_IntegerUnlimited_free;
				14	asn_struct_print_f CN_IntegerUnlimited_print;
				15	asn_constr_check_f CN_IntegerUnlimited_constraint;
				16	ber_type_decoder_f CN_IntegerUnlimited_decode_ber;
				17	der_type_encoder_f CN_IntegerUnlimited_encode_der;
				18	xer_type_decoder_f CN_IntegerUnlimited_decode_xer;
				19	xer_type_encoder_f CN_IntegerUnlimited_encode_xer;
				20
				21	/* <<< CODE [CN-IntegerUnlimited] >>> */
				22
				23	int
				24	CN_IntegerUnlimited_constraint(asn_TYPE_descriptor_t td, const void sptr,
				25	asn_app_consume_bytes_f app_errlog, void app_key) {
				26	/* Replace with underlying type checker */
				27	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
				28	return td->check_constraints(td, sptr, app_errlog, app_key);
				29	}
				30
				31	/*
				32	* This type is implemented using NativeInteger,
				33	* so here we adjust the DEF accordingly.
				34	*/
				35	static void
				36	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				37	td->free_struct = asn_DEF_NativeInteger.free_struct;
				38	td->print_struct = asn_DEF_NativeInteger.print_struct;
				39	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				40	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				41	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				42	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				43	td->elements = asn_DEF_NativeInteger.elements;
				44	td->elements_count = asn_DEF_NativeInteger.elements_count;
				45	td->specifics = asn_DEF_NativeInteger.specifics;
				46	}
				47
				48	void
				49	CN_IntegerUnlimited_free(asn_TYPE_descriptor_t *td,
				50	void *struct_ptr, int contents_only) {
				51	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				52	td->free_struct(td, struct_ptr, contents_only);
				53	}
				54
				55	int
				56	CN_IntegerUnlimited_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				57	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				58	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				59	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				60	}
				61
				62	asn_dec_rval_t
				63	CN_IntegerUnlimited_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				64	void *structure, const void bufptr, size_t size, int tag_mode) {
				65	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				66	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				67	}
				68
				69	asn_enc_rval_t
				70	CN_IntegerUnlimited_encode_der(asn_TYPE_descriptor_t *td,
				71	void *structure, int tag_mode, ber_tlv_tag_t tag,
				72	asn_app_consume_bytes_f cb, void app_key) {
				73	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				74	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				75	}
				76
				77	asn_dec_rval_t
				78	CN_IntegerUnlimited_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				79	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				80	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				81	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				82	}
				83
				84	asn_enc_rval_t
				85	CN_IntegerUnlimited_encode_xer(asn_TYPE_descriptor_t td, void structure,
				86	int ilevel, enum xer_encoder_flags_e flags,
				87	asn_app_consume_bytes_f cb, void app_key) {
				88	CN_IntegerUnlimited_1_inherit_TYPE_descriptor(td);
				89	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				90	}
				91
				92
				93	/* <<< STAT-DEFS [CN-IntegerUnlimited] >>> */
				94
				95	static ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_1_tags[] = {
				96	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				97	};
				98	asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
				99	"CN-IntegerUnlimited",
				100	"CN-IntegerUnlimited",
				101	CN_IntegerUnlimited_free,
				102	CN_IntegerUnlimited_print,
				103	CN_IntegerUnlimited_constraint,
				104	CN_IntegerUnlimited_decode_ber,
				105	CN_IntegerUnlimited_encode_der,
				106	CN_IntegerUnlimited_decode_xer,
				107	CN_IntegerUnlimited_encode_xer,
				108	0, /* Use generic outmost tag fetcher */
				109	asn_DEF_CN_IntegerUnlimited_1_tags,
				110	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
				111	/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
				112	asn_DEF_CN_IntegerUnlimited_1_tags, /* Same as above */
				113	sizeof(asn_DEF_CN_IntegerUnlimited_1_tags)
				114	/sizeof(asn_DEF_CN_IntegerUnlimited_1_tags[0]), /* 1 */
				115	0, 0, /* No members */
				116	0 /* No specifics */
				117	};
				118
				119
				120	/* <<< INCLUDES [CN-IntegerMinMax] >>> */
				121
				122	#include <NativeInteger.h>
				123
				124	/* <<< TYPE-DECLS [CN-IntegerMinMax] >>> */
				125
				126	typedef long CN_IntegerMinMax_t;
				127
				128	/* <<< FUNC-DECLS [CN-IntegerMinMax] >>> */
				129
				130	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax;
				131	asn_struct_free_f CN_IntegerMinMax_free;
				132	asn_struct_print_f CN_IntegerMinMax_print;
				133	asn_constr_check_f CN_IntegerMinMax_constraint;
				134	ber_type_decoder_f CN_IntegerMinMax_decode_ber;
				135	der_type_encoder_f CN_IntegerMinMax_encode_der;
				136	xer_type_decoder_f CN_IntegerMinMax_decode_xer;
				137	xer_type_encoder_f CN_IntegerMinMax_encode_xer;
				138
				139	/* <<< CODE [CN-IntegerMinMax] >>> */
				140
				141	int
				142	CN_IntegerMinMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				143	asn_app_consume_bytes_f app_errlog, void app_key) {
				144
				145	if(!sptr) {
				146	_ASN_ERRLOG(app_errlog, app_key,
				147	"%s: value not given (%s:%d)",
				148	td->name, __FILE__, __LINE__);
				149	return -1;
				150	}
				151
				152
				153	if(1 /* No applicable constraints whatsoever */) {
				154	/* Nothing is here. See below */
				155	}
				156
				157	/* Replace with underlying type checker */
				158	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
				159	return td->check_constraints(td, sptr, app_errlog, app_key);
				160	}
				161
				162	/*
				163	* This type is implemented using NativeInteger,
				164	* so here we adjust the DEF accordingly.
				165	*/
				166	static void
				167	CN_IntegerMinMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				168	td->free_struct = asn_DEF_NativeInteger.free_struct;
				169	td->print_struct = asn_DEF_NativeInteger.print_struct;
				170	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				171	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				172	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				173	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				174	td->elements = asn_DEF_NativeInteger.elements;
				175	td->elements_count = asn_DEF_NativeInteger.elements_count;
				176	td->specifics = asn_DEF_NativeInteger.specifics;
				177	}
				178
				179	void
				180	CN_IntegerMinMax_free(asn_TYPE_descriptor_t *td,
				181	void *struct_ptr, int contents_only) {
				182	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				183	td->free_struct(td, struct_ptr, contents_only);
				184	}
				185
				186	int
				187	CN_IntegerMinMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				188	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				189	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				190	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				191	}
				192
				193	asn_dec_rval_t
				194	CN_IntegerMinMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				195	void *structure, const void bufptr, size_t size, int tag_mode) {
				196	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				197	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				198	}
				199
				200	asn_enc_rval_t
				201	CN_IntegerMinMax_encode_der(asn_TYPE_descriptor_t *td,
				202	void *structure, int tag_mode, ber_tlv_tag_t tag,
				203	asn_app_consume_bytes_f cb, void app_key) {
				204	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				205	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				206	}
				207
				208	asn_dec_rval_t
				209	CN_IntegerMinMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				210	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				211	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				212	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				213	}
				214
				215	asn_enc_rval_t
				216	CN_IntegerMinMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				217	int ilevel, enum xer_encoder_flags_e flags,
				218	asn_app_consume_bytes_f cb, void app_key) {
				219	CN_IntegerMinMax_1_inherit_TYPE_descriptor(td);
				220	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				221	}
				222
				223
				224	/* <<< STAT-DEFS [CN-IntegerMinMax] >>> */
				225
				226	static ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_1_tags[] = {
				227	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				228	};
				229	asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
				230	"CN-IntegerMinMax",
				231	"CN-IntegerMinMax",
				232	CN_IntegerMinMax_free,
				233	CN_IntegerMinMax_print,
				234	CN_IntegerMinMax_constraint,
				235	CN_IntegerMinMax_decode_ber,
				236	CN_IntegerMinMax_encode_der,
				237	CN_IntegerMinMax_decode_xer,
				238	CN_IntegerMinMax_encode_xer,
				239	0, /* Use generic outmost tag fetcher */
				240	asn_DEF_CN_IntegerMinMax_1_tags,
				241	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
				242	/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
				243	asn_DEF_CN_IntegerMinMax_1_tags, /* Same as above */
				244	sizeof(asn_DEF_CN_IntegerMinMax_1_tags)
				245	/sizeof(asn_DEF_CN_IntegerMinMax_1_tags[0]), /* 1 */
				246	0, 0, /* No members */
				247	0 /* No specifics */
				248	};
				249
				250
				251	/* <<< INCLUDES [CN-IntegerMinLow] >>> */
				252
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	253	#include <NativeInteger.h>
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	254
				255	/* <<< TYPE-DECLS [CN-IntegerMinLow] >>> */
				256
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	257	typedef long CN_IntegerMinLow_t;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	258
				259	/* <<< FUNC-DECLS [CN-IntegerMinLow] >>> */
				260
				261	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow;
				262	asn_struct_free_f CN_IntegerMinLow_free;
				263	asn_struct_print_f CN_IntegerMinLow_print;
				264	asn_constr_check_f CN_IntegerMinLow_constraint;
				265	ber_type_decoder_f CN_IntegerMinLow_decode_ber;
				266	der_type_encoder_f CN_IntegerMinLow_encode_der;
				267	xer_type_decoder_f CN_IntegerMinLow_decode_xer;
				268	xer_type_encoder_f CN_IntegerMinLow_encode_xer;
				269
				270	/* <<< CODE [CN-IntegerMinLow] >>> */
				271
				272	int
				273	CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t td, const void sptr,
				274	asn_app_consume_bytes_f app_errlog, void app_key) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	275	long value;
				276
				277	if(!sptr) {
				278	_ASN_ERRLOG(app_errlog, app_key,
				279	"%s: value not given (%s:%d)",
				280	td->name, __FILE__, __LINE__);
				281	return -1;
				282	}
				283
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	284	value = (const long )sptr;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	285
				286	if((value <= 1)) {
				287	/* Constraint check succeeded */
				288	return 0;
				289	} else {
				290	_ASN_ERRLOG(app_errlog, app_key,
				291	"%s: constraint failed (%s:%d)",
				292	td->name, __FILE__, __LINE__);
				293	return -1;
				294	}
				295	}
				296
				297	/*
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	298	* This type is implemented using NativeInteger,
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	299	* so here we adjust the DEF accordingly.
				300	*/
				301	static void
				302	CN_IntegerMinLow_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	303	td->free_struct = asn_DEF_NativeInteger.free_struct;
				304	td->print_struct = asn_DEF_NativeInteger.print_struct;
				305	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				306	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				307	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				308	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				309	td->elements = asn_DEF_NativeInteger.elements;
				310	td->elements_count = asn_DEF_NativeInteger.elements_count;
				311	td->specifics = asn_DEF_NativeInteger.specifics;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	312	}
				313
				314	void
				315	CN_IntegerMinLow_free(asn_TYPE_descriptor_t *td,
				316	void *struct_ptr, int contents_only) {
				317	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				318	td->free_struct(td, struct_ptr, contents_only);
				319	}
				320
				321	int
				322	CN_IntegerMinLow_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				323	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				324	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				325	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				326	}
				327
				328	asn_dec_rval_t
				329	CN_IntegerMinLow_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				330	void *structure, const void bufptr, size_t size, int tag_mode) {
				331	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				332	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				333	}
				334
				335	asn_enc_rval_t
				336	CN_IntegerMinLow_encode_der(asn_TYPE_descriptor_t *td,
				337	void *structure, int tag_mode, ber_tlv_tag_t tag,
				338	asn_app_consume_bytes_f cb, void app_key) {
				339	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				340	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				341	}
				342
				343	asn_dec_rval_t
				344	CN_IntegerMinLow_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				345	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				346	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				347	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				348	}
				349
				350	asn_enc_rval_t
				351	CN_IntegerMinLow_encode_xer(asn_TYPE_descriptor_t td, void structure,
				352	int ilevel, enum xer_encoder_flags_e flags,
				353	asn_app_consume_bytes_f cb, void app_key) {
				354	CN_IntegerMinLow_1_inherit_TYPE_descriptor(td);
				355	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				356	}
				357
				358
				359	/* <<< STAT-DEFS [CN-IntegerMinLow] >>> */
				360
				361	static ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_1_tags[] = {
				362	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				363	};
				364	asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
				365	"CN-IntegerMinLow",
				366	"CN-IntegerMinLow",
				367	CN_IntegerMinLow_free,
				368	CN_IntegerMinLow_print,
				369	CN_IntegerMinLow_constraint,
				370	CN_IntegerMinLow_decode_ber,
				371	CN_IntegerMinLow_encode_der,
				372	CN_IntegerMinLow_decode_xer,
				373	CN_IntegerMinLow_encode_xer,
				374	0, /* Use generic outmost tag fetcher */
				375	asn_DEF_CN_IntegerMinLow_1_tags,
				376	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
				377	/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
				378	asn_DEF_CN_IntegerMinLow_1_tags, /* Same as above */
				379	sizeof(asn_DEF_CN_IntegerMinLow_1_tags)
				380	/sizeof(asn_DEF_CN_IntegerMinLow_1_tags[0]), /* 1 */
				381	0, 0, /* No members */
				382	0 /* No specifics */
				383	};
				384
				385
				386	/* <<< INCLUDES [NO-IntegerMinHigh] >>> */
				387
				388	#include <INTEGER.h>
				389
				390	/* <<< TYPE-DECLS [NO-IntegerMinHigh] >>> */
				391
				392	typedef INTEGER_t NO_IntegerMinHigh_t;
				393
				394	/* <<< FUNC-DECLS [NO-IntegerMinHigh] >>> */
				395
				396	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh;
				397	asn_struct_free_f NO_IntegerMinHigh_free;
				398	asn_struct_print_f NO_IntegerMinHigh_print;
				399	asn_constr_check_f NO_IntegerMinHigh_constraint;
				400	ber_type_decoder_f NO_IntegerMinHigh_decode_ber;
				401	der_type_encoder_f NO_IntegerMinHigh_encode_der;
				402	xer_type_decoder_f NO_IntegerMinHigh_decode_xer;
				403	xer_type_encoder_f NO_IntegerMinHigh_encode_xer;
				404
				405	/* <<< CODE [NO-IntegerMinHigh] >>> */
				406
				407	int
				408	NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t td, const void sptr,
				409	asn_app_consume_bytes_f app_errlog, void app_key) {
				410	const INTEGER_t st = (const INTEGER_t )sptr;
				411	long value;
				412
				413	if(!sptr) {
				414	_ASN_ERRLOG(app_errlog, app_key,
				415	"%s: value not given (%s:%d)",
				416	td->name, __FILE__, __LINE__);
				417	return -1;
				418	}
				419
				420	if(asn_INTEGER2long(st, &value)) {
				421	_ASN_ERRLOG(app_errlog, app_key,
				422	"%s: value too large (%s:%d)",
				423	td->name, __FILE__, __LINE__);
				424	return -1;
				425	}
				426
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	427	if((value <= 3000000000)) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	428	/* Constraint check succeeded */
				429	return 0;
				430	} else {
				431	_ASN_ERRLOG(app_errlog, app_key,
				432	"%s: constraint failed (%s:%d)",
				433	td->name, __FILE__, __LINE__);
				434	return -1;
				435	}
				436	}
				437
				438	/*
				439	* This type is implemented using INTEGER,
				440	* so here we adjust the DEF accordingly.
				441	*/
				442	static void
				443	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				444	td->free_struct = asn_DEF_INTEGER.free_struct;
				445	td->print_struct = asn_DEF_INTEGER.print_struct;
				446	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				447	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				448	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				449	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				450	td->elements = asn_DEF_INTEGER.elements;
				451	td->elements_count = asn_DEF_INTEGER.elements_count;
				452	td->specifics = asn_DEF_INTEGER.specifics;
				453	}
				454
				455	void
				456	NO_IntegerMinHigh_free(asn_TYPE_descriptor_t *td,
				457	void *struct_ptr, int contents_only) {
				458	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				459	td->free_struct(td, struct_ptr, contents_only);
				460	}
				461
				462	int
				463	NO_IntegerMinHigh_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				464	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				465	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				466	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				467	}
				468
				469	asn_dec_rval_t
				470	NO_IntegerMinHigh_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				471	void *structure, const void bufptr, size_t size, int tag_mode) {
				472	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				473	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				474	}
				475
				476	asn_enc_rval_t
				477	NO_IntegerMinHigh_encode_der(asn_TYPE_descriptor_t *td,
				478	void *structure, int tag_mode, ber_tlv_tag_t tag,
				479	asn_app_consume_bytes_f cb, void app_key) {
				480	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				481	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				482	}
				483
				484	asn_dec_rval_t
				485	NO_IntegerMinHigh_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				486	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				487	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				488	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				489	}
				490
				491	asn_enc_rval_t
				492	NO_IntegerMinHigh_encode_xer(asn_TYPE_descriptor_t td, void structure,
				493	int ilevel, enum xer_encoder_flags_e flags,
				494	asn_app_consume_bytes_f cb, void app_key) {
				495	NO_IntegerMinHigh_1_inherit_TYPE_descriptor(td);
				496	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				497	}
				498
				499
				500	/* <<< STAT-DEFS [NO-IntegerMinHigh] >>> */
				501
				502	static ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_1_tags[] = {
				503	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				504	};
				505	asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
				506	"NO-IntegerMinHigh",
				507	"NO-IntegerMinHigh",
				508	NO_IntegerMinHigh_free,
				509	NO_IntegerMinHigh_print,
				510	NO_IntegerMinHigh_constraint,
				511	NO_IntegerMinHigh_decode_ber,
				512	NO_IntegerMinHigh_encode_der,
				513	NO_IntegerMinHigh_decode_xer,
				514	NO_IntegerMinHigh_encode_xer,
				515	0, /* Use generic outmost tag fetcher */
				516	asn_DEF_NO_IntegerMinHigh_1_tags,
				517	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
				518	/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
				519	asn_DEF_NO_IntegerMinHigh_1_tags, /* Same as above */
				520	sizeof(asn_DEF_NO_IntegerMinHigh_1_tags)
				521	/sizeof(asn_DEF_NO_IntegerMinHigh_1_tags[0]), /* 1 */
				522	0, 0, /* No members */
				523	0 /* No specifics */
				524	};
				525
				526
				527	/* <<< INCLUDES [NO-IntegerLowHigh] >>> */
				528
				529	#include <INTEGER.h>
				530
				531	/* <<< TYPE-DECLS [NO-IntegerLowHigh] >>> */
				532
				533	typedef INTEGER_t NO_IntegerLowHigh_t;
				534
				535	/* <<< FUNC-DECLS [NO-IntegerLowHigh] >>> */
				536
				537	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh;
				538	asn_struct_free_f NO_IntegerLowHigh_free;
				539	asn_struct_print_f NO_IntegerLowHigh_print;
				540	asn_constr_check_f NO_IntegerLowHigh_constraint;
				541	ber_type_decoder_f NO_IntegerLowHigh_decode_ber;
				542	der_type_encoder_f NO_IntegerLowHigh_encode_der;
				543	xer_type_decoder_f NO_IntegerLowHigh_decode_xer;
				544	xer_type_encoder_f NO_IntegerLowHigh_encode_xer;
				545
				546	/* <<< CODE [NO-IntegerLowHigh] >>> */
				547
				548	int
				549	NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t td, const void sptr,
				550	asn_app_consume_bytes_f app_errlog, void app_key) {
				551	const INTEGER_t st = (const INTEGER_t )sptr;
				552	long value;
				553
				554	if(!sptr) {
				555	_ASN_ERRLOG(app_errlog, app_key,
				556	"%s: value not given (%s:%d)",
				557	td->name, __FILE__, __LINE__);
				558	return -1;
				559	}
				560
				561	if(asn_INTEGER2long(st, &value)) {
				562	_ASN_ERRLOG(app_errlog, app_key,
				563	"%s: value too large (%s:%d)",
				564	td->name, __FILE__, __LINE__);
				565	return -1;
				566	}
				567
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	568	if((value >= 1 && value <= 3000000000)) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	569	/* Constraint check succeeded */
				570	return 0;
				571	} else {
				572	_ASN_ERRLOG(app_errlog, app_key,
				573	"%s: constraint failed (%s:%d)",
				574	td->name, __FILE__, __LINE__);
				575	return -1;
				576	}
				577	}
				578
				579	/*
				580	* This type is implemented using INTEGER,
				581	* so here we adjust the DEF accordingly.
				582	*/
				583	static void
				584	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				585	td->free_struct = asn_DEF_INTEGER.free_struct;
				586	td->print_struct = asn_DEF_INTEGER.print_struct;
				587	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				588	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				589	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				590	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				591	td->elements = asn_DEF_INTEGER.elements;
				592	td->elements_count = asn_DEF_INTEGER.elements_count;
				593	td->specifics = asn_DEF_INTEGER.specifics;
				594	}
				595
				596	void
				597	NO_IntegerLowHigh_free(asn_TYPE_descriptor_t *td,
				598	void *struct_ptr, int contents_only) {
				599	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				600	td->free_struct(td, struct_ptr, contents_only);
				601	}
				602
				603	int
				604	NO_IntegerLowHigh_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				605	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				606	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				607	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				608	}
				609
				610	asn_dec_rval_t
				611	NO_IntegerLowHigh_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				612	void *structure, const void bufptr, size_t size, int tag_mode) {
				613	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				614	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				615	}
				616
				617	asn_enc_rval_t
				618	NO_IntegerLowHigh_encode_der(asn_TYPE_descriptor_t *td,
				619	void *structure, int tag_mode, ber_tlv_tag_t tag,
				620	asn_app_consume_bytes_f cb, void app_key) {
				621	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				622	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				623	}
				624
				625	asn_dec_rval_t
				626	NO_IntegerLowHigh_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				627	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				628	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				629	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				630	}
				631
				632	asn_enc_rval_t
				633	NO_IntegerLowHigh_encode_xer(asn_TYPE_descriptor_t td, void structure,
				634	int ilevel, enum xer_encoder_flags_e flags,
				635	asn_app_consume_bytes_f cb, void app_key) {
				636	NO_IntegerLowHigh_1_inherit_TYPE_descriptor(td);
				637	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				638	}
				639
				640
				641	/* <<< STAT-DEFS [NO-IntegerLowHigh] >>> */
				642
				643	static ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_1_tags[] = {
				644	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				645	};
				646	asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
				647	"NO-IntegerLowHigh",
				648	"NO-IntegerLowHigh",
				649	NO_IntegerLowHigh_free,
				650	NO_IntegerLowHigh_print,
				651	NO_IntegerLowHigh_constraint,
				652	NO_IntegerLowHigh_decode_ber,
				653	NO_IntegerLowHigh_encode_der,
				654	NO_IntegerLowHigh_decode_xer,
				655	NO_IntegerLowHigh_encode_xer,
				656	0, /* Use generic outmost tag fetcher */
				657	asn_DEF_NO_IntegerLowHigh_1_tags,
				658	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
				659	/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
				660	asn_DEF_NO_IntegerLowHigh_1_tags, /* Same as above */
				661	sizeof(asn_DEF_NO_IntegerLowHigh_1_tags)
				662	/sizeof(asn_DEF_NO_IntegerLowHigh_1_tags[0]), /* 1 */
				663	0, 0, /* No members */
				664	0 /* No specifics */
				665	};
				666
				667
				668	/* <<< INCLUDES [CN-IntegerLowMax] >>> */
				669
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	670	#include <NativeInteger.h>
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	671
				672	/* <<< TYPE-DECLS [CN-IntegerLowMax] >>> */
				673
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	674	typedef long CN_IntegerLowMax_t;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	675
				676	/* <<< FUNC-DECLS [CN-IntegerLowMax] >>> */
				677
				678	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax;
				679	asn_struct_free_f CN_IntegerLowMax_free;
				680	asn_struct_print_f CN_IntegerLowMax_print;
				681	asn_constr_check_f CN_IntegerLowMax_constraint;
				682	ber_type_decoder_f CN_IntegerLowMax_decode_ber;
				683	der_type_encoder_f CN_IntegerLowMax_encode_der;
				684	xer_type_decoder_f CN_IntegerLowMax_decode_xer;
				685	xer_type_encoder_f CN_IntegerLowMax_encode_xer;
				686
				687	/* <<< CODE [CN-IntegerLowMax] >>> */
				688
				689	int
				690	CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				691	asn_app_consume_bytes_f app_errlog, void app_key) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	692	long value;
				693
				694	if(!sptr) {
				695	_ASN_ERRLOG(app_errlog, app_key,
				696	"%s: value not given (%s:%d)",
				697	td->name, __FILE__, __LINE__);
				698	return -1;
				699	}
				700
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	701	value = (const long )sptr;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	702
				703	if((value >= 1)) {
				704	/* Constraint check succeeded */
				705	return 0;
				706	} else {
				707	_ASN_ERRLOG(app_errlog, app_key,
				708	"%s: constraint failed (%s:%d)",
				709	td->name, __FILE__, __LINE__);
				710	return -1;
				711	}
				712	}
				713
				714	/*
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	715	* This type is implemented using NativeInteger,
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	716	* so here we adjust the DEF accordingly.
				717	*/
				718	static void
				719	CN_IntegerLowMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	720	td->free_struct = asn_DEF_NativeInteger.free_struct;
				721	td->print_struct = asn_DEF_NativeInteger.print_struct;
				722	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				723	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				724	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				725	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				726	td->elements = asn_DEF_NativeInteger.elements;
				727	td->elements_count = asn_DEF_NativeInteger.elements_count;
				728	td->specifics = asn_DEF_NativeInteger.specifics;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	729	}
				730
				731	void
				732	CN_IntegerLowMax_free(asn_TYPE_descriptor_t *td,
				733	void *struct_ptr, int contents_only) {
				734	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				735	td->free_struct(td, struct_ptr, contents_only);
				736	}
				737
				738	int
				739	CN_IntegerLowMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				740	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				741	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				742	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				743	}
				744
				745	asn_dec_rval_t
				746	CN_IntegerLowMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				747	void *structure, const void bufptr, size_t size, int tag_mode) {
				748	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				749	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				750	}
				751
				752	asn_enc_rval_t
				753	CN_IntegerLowMax_encode_der(asn_TYPE_descriptor_t *td,
				754	void *structure, int tag_mode, ber_tlv_tag_t tag,
				755	asn_app_consume_bytes_f cb, void app_key) {
				756	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				757	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				758	}
				759
				760	asn_dec_rval_t
				761	CN_IntegerLowMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				762	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				763	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				764	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				765	}
				766
				767	asn_enc_rval_t
				768	CN_IntegerLowMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				769	int ilevel, enum xer_encoder_flags_e flags,
				770	asn_app_consume_bytes_f cb, void app_key) {
				771	CN_IntegerLowMax_1_inherit_TYPE_descriptor(td);
				772	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				773	}
				774
				775
				776	/* <<< STAT-DEFS [CN-IntegerLowMax] >>> */
				777
				778	static ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_1_tags[] = {
				779	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				780	};
				781	asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
				782	"CN-IntegerLowMax",
				783	"CN-IntegerLowMax",
				784	CN_IntegerLowMax_free,
				785	CN_IntegerLowMax_print,
				786	CN_IntegerLowMax_constraint,
				787	CN_IntegerLowMax_decode_ber,
				788	CN_IntegerLowMax_encode_der,
				789	CN_IntegerLowMax_decode_xer,
				790	CN_IntegerLowMax_encode_xer,
				791	0, /* Use generic outmost tag fetcher */
				792	asn_DEF_CN_IntegerLowMax_1_tags,
				793	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
				794	/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
				795	asn_DEF_CN_IntegerLowMax_1_tags, /* Same as above */
				796	sizeof(asn_DEF_CN_IntegerLowMax_1_tags)
				797	/sizeof(asn_DEF_CN_IntegerLowMax_1_tags[0]), /* 1 */
				798	0, 0, /* No members */
				799	0 /* No specifics */
				800	};
				801
				802
				803	/* <<< INCLUDES [NO-IntegerHighMax] >>> */
				804
				805	#include <INTEGER.h>
				806
				807	/* <<< TYPE-DECLS [NO-IntegerHighMax] >>> */
				808
				809	typedef INTEGER_t NO_IntegerHighMax_t;
				810
				811	/* <<< FUNC-DECLS [NO-IntegerHighMax] >>> */
				812
				813	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax;
				814	asn_struct_free_f NO_IntegerHighMax_free;
				815	asn_struct_print_f NO_IntegerHighMax_print;
				816	asn_constr_check_f NO_IntegerHighMax_constraint;
				817	ber_type_decoder_f NO_IntegerHighMax_decode_ber;
				818	der_type_encoder_f NO_IntegerHighMax_encode_der;
				819	xer_type_decoder_f NO_IntegerHighMax_decode_xer;
				820	xer_type_encoder_f NO_IntegerHighMax_encode_xer;
				821
				822	/* <<< CODE [NO-IntegerHighMax] >>> */
				823
				824	int
				825	NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				826	asn_app_consume_bytes_f app_errlog, void app_key) {
				827	const INTEGER_t st = (const INTEGER_t )sptr;
				828	long value;
				829
				830	if(!sptr) {
				831	_ASN_ERRLOG(app_errlog, app_key,
				832	"%s: value not given (%s:%d)",
				833	td->name, __FILE__, __LINE__);
				834	return -1;
				835	}
				836
				837	if(asn_INTEGER2long(st, &value)) {
				838	_ASN_ERRLOG(app_errlog, app_key,
				839	"%s: value too large (%s:%d)",
				840	td->name, __FILE__, __LINE__);
				841	return -1;
				842	}
				843
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	844	if((value >= 3000000000)) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	845	/* Constraint check succeeded */
				846	return 0;
				847	} else {
				848	_ASN_ERRLOG(app_errlog, app_key,
				849	"%s: constraint failed (%s:%d)",
				850	td->name, __FILE__, __LINE__);
				851	return -1;
				852	}
				853	}
				854
				855	/*
				856	* This type is implemented using INTEGER,
				857	* so here we adjust the DEF accordingly.
				858	*/
				859	static void
				860	NO_IntegerHighMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				861	td->free_struct = asn_DEF_INTEGER.free_struct;
				862	td->print_struct = asn_DEF_INTEGER.print_struct;
				863	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				864	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				865	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				866	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				867	td->elements = asn_DEF_INTEGER.elements;
				868	td->elements_count = asn_DEF_INTEGER.elements_count;
				869	td->specifics = asn_DEF_INTEGER.specifics;
				870	}
				871
				872	void
				873	NO_IntegerHighMax_free(asn_TYPE_descriptor_t *td,
				874	void *struct_ptr, int contents_only) {
				875	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				876	td->free_struct(td, struct_ptr, contents_only);
				877	}
				878
				879	int
				880	NO_IntegerHighMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				881	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				882	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				883	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				884	}
				885
				886	asn_dec_rval_t
				887	NO_IntegerHighMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				888	void *structure, const void bufptr, size_t size, int tag_mode) {
				889	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				890	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				891	}
				892
				893	asn_enc_rval_t
				894	NO_IntegerHighMax_encode_der(asn_TYPE_descriptor_t *td,
				895	void *structure, int tag_mode, ber_tlv_tag_t tag,
				896	asn_app_consume_bytes_f cb, void app_key) {
				897	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				898	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				899	}
				900
				901	asn_dec_rval_t
				902	NO_IntegerHighMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				903	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				904	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				905	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				906	}
				907
				908	asn_enc_rval_t
				909	NO_IntegerHighMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				910	int ilevel, enum xer_encoder_flags_e flags,
				911	asn_app_consume_bytes_f cb, void app_key) {
				912	NO_IntegerHighMax_1_inherit_TYPE_descriptor(td);
				913	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				914	}
				915
				916
				917	/* <<< STAT-DEFS [NO-IntegerHighMax] >>> */
				918
				919	static ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_1_tags[] = {
				920	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				921	};
				922	asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
				923	"NO-IntegerHighMax",
				924	"NO-IntegerHighMax",
				925	NO_IntegerHighMax_free,
				926	NO_IntegerHighMax_print,
				927	NO_IntegerHighMax_constraint,
				928	NO_IntegerHighMax_decode_ber,
				929	NO_IntegerHighMax_encode_der,
				930	NO_IntegerHighMax_decode_xer,
				931	NO_IntegerHighMax_encode_xer,
				932	0, /* Use generic outmost tag fetcher */
				933	asn_DEF_NO_IntegerHighMax_1_tags,
				934	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
				935	/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
				936	asn_DEF_NO_IntegerHighMax_1_tags, /* Same as above */
				937	sizeof(asn_DEF_NO_IntegerHighMax_1_tags)
				938	/sizeof(asn_DEF_NO_IntegerHighMax_1_tags[0]), /* 1 */
				939	0, 0, /* No members */
				940	0 /* No specifics */
				941	};
				942
				943
				944	/* <<< INCLUDES [NO-IntegerLowestMax] >>> */
				945
				946	#include <INTEGER.h>
				947
				948	/* <<< TYPE-DECLS [NO-IntegerLowestMax] >>> */
				949
				950	typedef INTEGER_t NO_IntegerLowestMax_t;
				951
				952	/* <<< FUNC-DECLS [NO-IntegerLowestMax] >>> */
				953
				954	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax;
				955	asn_struct_free_f NO_IntegerLowestMax_free;
				956	asn_struct_print_f NO_IntegerLowestMax_print;
				957	asn_constr_check_f NO_IntegerLowestMax_constraint;
				958	ber_type_decoder_f NO_IntegerLowestMax_decode_ber;
				959	der_type_encoder_f NO_IntegerLowestMax_encode_der;
				960	xer_type_decoder_f NO_IntegerLowestMax_decode_xer;
				961	xer_type_encoder_f NO_IntegerLowestMax_encode_xer;
				962
				963	/* <<< CODE [NO-IntegerLowestMax] >>> */
				964
				965	int
				966	NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t td, const void sptr,
				967	asn_app_consume_bytes_f app_errlog, void app_key) {
				968	const INTEGER_t st = (const INTEGER_t )sptr;
				969	long value;
				970
				971	if(!sptr) {
				972	_ASN_ERRLOG(app_errlog, app_key,
				973	"%s: value not given (%s:%d)",
				974	td->name, __FILE__, __LINE__);
				975	return -1;
				976	}
				977
				978	if(asn_INTEGER2long(st, &value)) {
				979	_ASN_ERRLOG(app_errlog, app_key,
				980	"%s: value too large (%s:%d)",
				981	td->name, __FILE__, __LINE__);
				982	return -1;
				983	}
				984
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	985	if((value >= -3000000000)) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	986	/* Constraint check succeeded */
				987	return 0;
				988	} else {
				989	_ASN_ERRLOG(app_errlog, app_key,
				990	"%s: constraint failed (%s:%d)",
				991	td->name, __FILE__, __LINE__);
				992	return -1;
				993	}
				994	}
				995
				996	/*
				997	* This type is implemented using INTEGER,
				998	* so here we adjust the DEF accordingly.
				999	*/
				1000	static void
				1001	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1002	td->free_struct = asn_DEF_INTEGER.free_struct;
				1003	td->print_struct = asn_DEF_INTEGER.print_struct;
				1004	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1005	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1006	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1007	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1008	td->elements = asn_DEF_INTEGER.elements;
				1009	td->elements_count = asn_DEF_INTEGER.elements_count;
				1010	td->specifics = asn_DEF_INTEGER.specifics;
				1011	}
				1012
				1013	void
				1014	NO_IntegerLowestMax_free(asn_TYPE_descriptor_t *td,
				1015	void *struct_ptr, int contents_only) {
				1016	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1017	td->free_struct(td, struct_ptr, contents_only);
				1018	}
				1019
				1020	int
				1021	NO_IntegerLowestMax_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1022	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1023	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1024	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1025	}
				1026
				1027	asn_dec_rval_t
				1028	NO_IntegerLowestMax_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1029	void *structure, const void bufptr, size_t size, int tag_mode) {
				1030	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1031	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1032	}
				1033
				1034	asn_enc_rval_t
				1035	NO_IntegerLowestMax_encode_der(asn_TYPE_descriptor_t *td,
				1036	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1037	asn_app_consume_bytes_f cb, void app_key) {
				1038	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1039	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1040	}
				1041
				1042	asn_dec_rval_t
				1043	NO_IntegerLowestMax_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1044	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1045	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1046	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1047	}
				1048
				1049	asn_enc_rval_t
				1050	NO_IntegerLowestMax_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1051	int ilevel, enum xer_encoder_flags_e flags,
				1052	asn_app_consume_bytes_f cb, void app_key) {
				1053	NO_IntegerLowestMax_1_inherit_TYPE_descriptor(td);
				1054	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1055	}
				1056
				1057
				1058	/* <<< STAT-DEFS [NO-IntegerLowestMax] >>> */
				1059
				1060	static ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_1_tags[] = {
				1061	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1062	};
				1063	asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
				1064	"NO-IntegerLowestMax",
				1065	"NO-IntegerLowestMax",
				1066	NO_IntegerLowestMax_free,
				1067	NO_IntegerLowestMax_print,
				1068	NO_IntegerLowestMax_constraint,
				1069	NO_IntegerLowestMax_decode_ber,
				1070	NO_IntegerLowestMax_encode_der,
				1071	NO_IntegerLowestMax_decode_xer,
				1072	NO_IntegerLowestMax_encode_xer,
				1073	0, /* Use generic outmost tag fetcher */
				1074	asn_DEF_NO_IntegerLowestMax_1_tags,
				1075	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
				1076	/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
				1077	asn_DEF_NO_IntegerLowestMax_1_tags, /* Same as above */
				1078	sizeof(asn_DEF_NO_IntegerLowestMax_1_tags)
				1079	/sizeof(asn_DEF_NO_IntegerLowestMax_1_tags[0]), /* 1 */
				1080	0, 0, /* No members */
				1081	0 /* No specifics */
				1082	};
				1083
				1084
				1085	/* <<< INCLUDES [NO-IntegerOutRange] >>> */
				1086
				1087	#include <INTEGER.h>
				1088
				1089	/* <<< TYPE-DECLS [NO-IntegerOutRange] >>> */
				1090
				1091	typedef INTEGER_t NO_IntegerOutRange_t;
				1092
				1093	/* <<< FUNC-DECLS [NO-IntegerOutRange] >>> */
				1094
				1095	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange;
				1096	asn_struct_free_f NO_IntegerOutRange_free;
				1097	asn_struct_print_f NO_IntegerOutRange_print;
				1098	asn_constr_check_f NO_IntegerOutRange_constraint;
				1099	ber_type_decoder_f NO_IntegerOutRange_decode_ber;
				1100	der_type_encoder_f NO_IntegerOutRange_encode_der;
				1101	xer_type_decoder_f NO_IntegerOutRange_decode_xer;
				1102	xer_type_encoder_f NO_IntegerOutRange_encode_xer;
				1103
				1104	/* <<< CODE [NO-IntegerOutRange] >>> */
				1105
				1106	int
				1107	NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1108	asn_app_consume_bytes_f app_errlog, void app_key) {
				1109	const INTEGER_t st = (const INTEGER_t )sptr;
				1110	long value;
				1111
				1112	if(!sptr) {
				1113	_ASN_ERRLOG(app_errlog, app_key,
				1114	"%s: value not given (%s:%d)",
				1115	td->name, __FILE__, __LINE__);
				1116	return -1;
				1117	}
				1118
				1119	if(asn_INTEGER2long(st, &value)) {
				1120	_ASN_ERRLOG(app_errlog, app_key,
				1121	"%s: value too large (%s:%d)",
				1122	td->name, __FILE__, __LINE__);
				1123	return -1;
				1124	}
				1125
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1126	if((value >= 3000000000 && value <= 3000000001)) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1127	/* Constraint check succeeded */
				1128	return 0;
				1129	} else {
				1130	_ASN_ERRLOG(app_errlog, app_key,
				1131	"%s: constraint failed (%s:%d)",
				1132	td->name, __FILE__, __LINE__);
				1133	return -1;
				1134	}
				1135	}
				1136
				1137	/*
				1138	* This type is implemented using INTEGER,
				1139	* so here we adjust the DEF accordingly.
				1140	*/
				1141	static void
				1142	NO_IntegerOutRange_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1143	td->free_struct = asn_DEF_INTEGER.free_struct;
				1144	td->print_struct = asn_DEF_INTEGER.print_struct;
				1145	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1146	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1147	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1148	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1149	td->elements = asn_DEF_INTEGER.elements;
				1150	td->elements_count = asn_DEF_INTEGER.elements_count;
				1151	td->specifics = asn_DEF_INTEGER.specifics;
				1152	}
				1153
				1154	void
				1155	NO_IntegerOutRange_free(asn_TYPE_descriptor_t *td,
				1156	void *struct_ptr, int contents_only) {
				1157	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1158	td->free_struct(td, struct_ptr, contents_only);
				1159	}
				1160
				1161	int
				1162	NO_IntegerOutRange_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1163	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1164	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1165	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1166	}
				1167
				1168	asn_dec_rval_t
				1169	NO_IntegerOutRange_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1170	void *structure, const void bufptr, size_t size, int tag_mode) {
				1171	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1172	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1173	}
				1174
				1175	asn_enc_rval_t
				1176	NO_IntegerOutRange_encode_der(asn_TYPE_descriptor_t *td,
				1177	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1178	asn_app_consume_bytes_f cb, void app_key) {
				1179	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1180	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1181	}
				1182
				1183	asn_dec_rval_t
				1184	NO_IntegerOutRange_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1185	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1186	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1187	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1188	}
				1189
				1190	asn_enc_rval_t
				1191	NO_IntegerOutRange_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1192	int ilevel, enum xer_encoder_flags_e flags,
				1193	asn_app_consume_bytes_f cb, void app_key) {
				1194	NO_IntegerOutRange_1_inherit_TYPE_descriptor(td);
				1195	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1196	}
				1197
				1198
				1199	/* <<< STAT-DEFS [NO-IntegerOutRange] >>> */
				1200
				1201	static ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_1_tags[] = {
				1202	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1203	};
				1204	asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
				1205	"NO-IntegerOutRange",
				1206	"NO-IntegerOutRange",
				1207	NO_IntegerOutRange_free,
				1208	NO_IntegerOutRange_print,
				1209	NO_IntegerOutRange_constraint,
				1210	NO_IntegerOutRange_decode_ber,
				1211	NO_IntegerOutRange_encode_der,
				1212	NO_IntegerOutRange_decode_xer,
				1213	NO_IntegerOutRange_encode_xer,
				1214	0, /* Use generic outmost tag fetcher */
				1215	asn_DEF_NO_IntegerOutRange_1_tags,
				1216	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
				1217	/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
				1218	asn_DEF_NO_IntegerOutRange_1_tags, /* Same as above */
				1219	sizeof(asn_DEF_NO_IntegerOutRange_1_tags)
				1220	/sizeof(asn_DEF_NO_IntegerOutRange_1_tags[0]), /* 1 */
				1221	0, 0, /* No members */
				1222	0 /* No specifics */
				1223	};
				1224
				1225
				1226	/* <<< INCLUDES [NO-IntegerOutValue] >>> */
				1227
				1228	#include <INTEGER.h>
				1229
				1230	/* <<< TYPE-DECLS [NO-IntegerOutValue] >>> */
				1231
				1232	typedef INTEGER_t NO_IntegerOutValue_t;
				1233
				1234	/* <<< FUNC-DECLS [NO-IntegerOutValue] >>> */
				1235
				1236	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue;
				1237	asn_struct_free_f NO_IntegerOutValue_free;
				1238	asn_struct_print_f NO_IntegerOutValue_print;
				1239	asn_constr_check_f NO_IntegerOutValue_constraint;
				1240	ber_type_decoder_f NO_IntegerOutValue_decode_ber;
				1241	der_type_encoder_f NO_IntegerOutValue_encode_der;
				1242	xer_type_decoder_f NO_IntegerOutValue_decode_xer;
				1243	xer_type_encoder_f NO_IntegerOutValue_encode_xer;
				1244
				1245	/* <<< CODE [NO-IntegerOutValue] >>> */
				1246
				1247	int
				1248	NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1249	asn_app_consume_bytes_f app_errlog, void app_key) {
				1250	const INTEGER_t st = (const INTEGER_t )sptr;
				1251	long value;
				1252
				1253	if(!sptr) {
				1254	_ASN_ERRLOG(app_errlog, app_key,
				1255	"%s: value not given (%s:%d)",
				1256	td->name, __FILE__, __LINE__);
				1257	return -1;
				1258	}
				1259
				1260	if(asn_INTEGER2long(st, &value)) {
				1261	_ASN_ERRLOG(app_errlog, app_key,
				1262	"%s: value too large (%s:%d)",
				1263	td->name, __FILE__, __LINE__);
				1264	return -1;
				1265	}
				1266
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1267	if((value == 3000000000)) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1268	/* Constraint check succeeded */
				1269	return 0;
				1270	} else {
				1271	_ASN_ERRLOG(app_errlog, app_key,
				1272	"%s: constraint failed (%s:%d)",
				1273	td->name, __FILE__, __LINE__);
				1274	return -1;
				1275	}
				1276	}
				1277
				1278	/*
				1279	* This type is implemented using INTEGER,
				1280	* so here we adjust the DEF accordingly.
				1281	*/
				1282	static void
				1283	NO_IntegerOutValue_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				1284	td->free_struct = asn_DEF_INTEGER.free_struct;
				1285	td->print_struct = asn_DEF_INTEGER.print_struct;
				1286	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				1287	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				1288	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				1289	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				1290	td->elements = asn_DEF_INTEGER.elements;
				1291	td->elements_count = asn_DEF_INTEGER.elements_count;
				1292	td->specifics = asn_DEF_INTEGER.specifics;
				1293	}
				1294
				1295	void
				1296	NO_IntegerOutValue_free(asn_TYPE_descriptor_t *td,
				1297	void *struct_ptr, int contents_only) {
				1298	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1299	td->free_struct(td, struct_ptr, contents_only);
				1300	}
				1301
				1302	int
				1303	NO_IntegerOutValue_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1304	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1305	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1306	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1307	}
				1308
				1309	asn_dec_rval_t
				1310	NO_IntegerOutValue_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1311	void *structure, const void bufptr, size_t size, int tag_mode) {
				1312	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1313	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1314	}
				1315
				1316	asn_enc_rval_t
				1317	NO_IntegerOutValue_encode_der(asn_TYPE_descriptor_t *td,
				1318	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1319	asn_app_consume_bytes_f cb, void app_key) {
				1320	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1321	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1322	}
				1323
				1324	asn_dec_rval_t
				1325	NO_IntegerOutValue_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1326	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1327	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1328	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1329	}
				1330
				1331	asn_enc_rval_t
				1332	NO_IntegerOutValue_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1333	int ilevel, enum xer_encoder_flags_e flags,
				1334	asn_app_consume_bytes_f cb, void app_key) {
				1335	NO_IntegerOutValue_1_inherit_TYPE_descriptor(td);
				1336	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1337	}
				1338
				1339
				1340	/* <<< STAT-DEFS [NO-IntegerOutValue] >>> */
				1341
				1342	static ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_1_tags[] = {
				1343	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1344	};
				1345	asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
				1346	"NO-IntegerOutValue",
				1347	"NO-IntegerOutValue",
				1348	NO_IntegerOutValue_free,
				1349	NO_IntegerOutValue_print,
				1350	NO_IntegerOutValue_constraint,
				1351	NO_IntegerOutValue_decode_ber,
				1352	NO_IntegerOutValue_encode_der,
				1353	NO_IntegerOutValue_decode_xer,
				1354	NO_IntegerOutValue_encode_xer,
				1355	0, /* Use generic outmost tag fetcher */
				1356	asn_DEF_NO_IntegerOutValue_1_tags,
				1357	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
				1358	/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
				1359	asn_DEF_NO_IntegerOutValue_1_tags, /* Same as above */
				1360	sizeof(asn_DEF_NO_IntegerOutValue_1_tags)
				1361	/sizeof(asn_DEF_NO_IntegerOutValue_1_tags[0]), /* 1 */
				1362	0, 0, /* No members */
				1363	0 /* No specifics */
				1364	};
				1365
				1366
				1367	/* <<< INCLUDES [OK-IntegerInRange1] >>> */
				1368
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1369	#include <NativeInteger.h>
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1370
				1371	/* <<< TYPE-DECLS [OK-IntegerInRange1] >>> */
				1372
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1373	typedef long OK_IntegerInRange1_t;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1374
				1375	/* <<< FUNC-DECLS [OK-IntegerInRange1] >>> */
				1376
				1377	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1;
				1378	asn_struct_free_f OK_IntegerInRange1_free;
				1379	asn_struct_print_f OK_IntegerInRange1_print;
				1380	asn_constr_check_f OK_IntegerInRange1_constraint;
				1381	ber_type_decoder_f OK_IntegerInRange1_decode_ber;
				1382	der_type_encoder_f OK_IntegerInRange1_encode_der;
				1383	xer_type_decoder_f OK_IntegerInRange1_decode_xer;
				1384	xer_type_encoder_f OK_IntegerInRange1_encode_xer;
				1385
				1386	/* <<< CODE [OK-IntegerInRange1] >>> */
				1387
				1388	int
				1389	OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1390	asn_app_consume_bytes_f app_errlog, void app_key) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1391	long value;
				1392
				1393	if(!sptr) {
				1394	_ASN_ERRLOG(app_errlog, app_key,
				1395	"%s: value not given (%s:%d)",
				1396	td->name, __FILE__, __LINE__);
				1397	return -1;
				1398	}
				1399
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1400	value = (const long )sptr;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1401
				1402	if((value >= -100 && value <= 100)) {
				1403	/* Constraint check succeeded */
				1404	return 0;
				1405	} else {
				1406	_ASN_ERRLOG(app_errlog, app_key,
				1407	"%s: constraint failed (%s:%d)",
				1408	td->name, __FILE__, __LINE__);
				1409	return -1;
				1410	}
				1411	}
				1412
				1413	/*
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1414	* This type is implemented using NativeInteger,
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1415	* so here we adjust the DEF accordingly.
				1416	*/
				1417	static void
				1418	OK_IntegerInRange1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1419	td->free_struct = asn_DEF_NativeInteger.free_struct;
				1420	td->print_struct = asn_DEF_NativeInteger.print_struct;
				1421	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				1422	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				1423	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				1424	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				1425	td->elements = asn_DEF_NativeInteger.elements;
				1426	td->elements_count = asn_DEF_NativeInteger.elements_count;
				1427	td->specifics = asn_DEF_NativeInteger.specifics;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1428	}
				1429
				1430	void
				1431	OK_IntegerInRange1_free(asn_TYPE_descriptor_t *td,
				1432	void *struct_ptr, int contents_only) {
				1433	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1434	td->free_struct(td, struct_ptr, contents_only);
				1435	}
				1436
				1437	int
				1438	OK_IntegerInRange1_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1439	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1440	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1441	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1442	}
				1443
				1444	asn_dec_rval_t
				1445	OK_IntegerInRange1_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1446	void *structure, const void bufptr, size_t size, int tag_mode) {
				1447	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1448	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1449	}
				1450
				1451	asn_enc_rval_t
				1452	OK_IntegerInRange1_encode_der(asn_TYPE_descriptor_t *td,
				1453	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1454	asn_app_consume_bytes_f cb, void app_key) {
				1455	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1456	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1457	}
				1458
				1459	asn_dec_rval_t
				1460	OK_IntegerInRange1_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1461	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1462	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1463	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1464	}
				1465
				1466	asn_enc_rval_t
				1467	OK_IntegerInRange1_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1468	int ilevel, enum xer_encoder_flags_e flags,
				1469	asn_app_consume_bytes_f cb, void app_key) {
				1470	OK_IntegerInRange1_1_inherit_TYPE_descriptor(td);
				1471	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1472	}
				1473
				1474
				1475	/* <<< STAT-DEFS [OK-IntegerInRange1] >>> */
				1476
				1477	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_1_tags[] = {
				1478	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1479	};
				1480	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
				1481	"OK-IntegerInRange1",
				1482	"OK-IntegerInRange1",
				1483	OK_IntegerInRange1_free,
				1484	OK_IntegerInRange1_print,
				1485	OK_IntegerInRange1_constraint,
				1486	OK_IntegerInRange1_decode_ber,
				1487	OK_IntegerInRange1_encode_der,
				1488	OK_IntegerInRange1_decode_xer,
				1489	OK_IntegerInRange1_encode_xer,
				1490	0, /* Use generic outmost tag fetcher */
				1491	asn_DEF_OK_IntegerInRange1_1_tags,
				1492	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
				1493	/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
				1494	asn_DEF_OK_IntegerInRange1_1_tags, /* Same as above */
				1495	sizeof(asn_DEF_OK_IntegerInRange1_1_tags)
				1496	/sizeof(asn_DEF_OK_IntegerInRange1_1_tags[0]), /* 1 */
				1497	0, 0, /* No members */
				1498	0 /* No specifics */
				1499	};
				1500
				1501
				1502	/* <<< INCLUDES [OK-IntegerInRange2] >>> */
				1503
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1504	#include <NativeInteger.h>
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1505
				1506	/* <<< TYPE-DECLS [OK-IntegerInRange2] >>> */
				1507
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1508	typedef long OK_IntegerInRange2_t;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1509
				1510	/* <<< FUNC-DECLS [OK-IntegerInRange2] >>> */
				1511
				1512	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2;
				1513	asn_struct_free_f OK_IntegerInRange2_free;
				1514	asn_struct_print_f OK_IntegerInRange2_print;
				1515	asn_constr_check_f OK_IntegerInRange2_constraint;
				1516	ber_type_decoder_f OK_IntegerInRange2_decode_ber;
				1517	der_type_encoder_f OK_IntegerInRange2_encode_der;
				1518	xer_type_decoder_f OK_IntegerInRange2_decode_xer;
				1519	xer_type_encoder_f OK_IntegerInRange2_encode_xer;
				1520
				1521	/* <<< CODE [OK-IntegerInRange2] >>> */
				1522
				1523	int
				1524	OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1525	asn_app_consume_bytes_f app_errlog, void app_key) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1526	long value;
				1527
				1528	if(!sptr) {
				1529	_ASN_ERRLOG(app_errlog, app_key,
				1530	"%s: value not given (%s:%d)",
				1531	td->name, __FILE__, __LINE__);
				1532	return -1;
				1533	}
				1534
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1535	value = (const long )sptr;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1536
				1537	if(((value == -100) \|\| (value == 100))) {
				1538	/* Constraint check succeeded */
				1539	return 0;
				1540	} else {
				1541	_ASN_ERRLOG(app_errlog, app_key,
				1542	"%s: constraint failed (%s:%d)",
				1543	td->name, __FILE__, __LINE__);
				1544	return -1;
				1545	}
				1546	}
				1547
				1548	/*
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1549	* This type is implemented using NativeInteger,
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1550	* so here we adjust the DEF accordingly.
				1551	*/
				1552	static void
				1553	OK_IntegerInRange2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1554	td->free_struct = asn_DEF_NativeInteger.free_struct;
				1555	td->print_struct = asn_DEF_NativeInteger.print_struct;
				1556	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				1557	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				1558	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				1559	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				1560	td->elements = asn_DEF_NativeInteger.elements;
				1561	td->elements_count = asn_DEF_NativeInteger.elements_count;
				1562	td->specifics = asn_DEF_NativeInteger.specifics;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1563	}
				1564
				1565	void
				1566	OK_IntegerInRange2_free(asn_TYPE_descriptor_t *td,
				1567	void *struct_ptr, int contents_only) {
				1568	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1569	td->free_struct(td, struct_ptr, contents_only);
				1570	}
				1571
				1572	int
				1573	OK_IntegerInRange2_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1574	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1575	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1576	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1577	}
				1578
				1579	asn_dec_rval_t
				1580	OK_IntegerInRange2_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1581	void *structure, const void bufptr, size_t size, int tag_mode) {
				1582	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1583	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1584	}
				1585
				1586	asn_enc_rval_t
				1587	OK_IntegerInRange2_encode_der(asn_TYPE_descriptor_t *td,
				1588	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1589	asn_app_consume_bytes_f cb, void app_key) {
				1590	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1591	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1592	}
				1593
				1594	asn_dec_rval_t
				1595	OK_IntegerInRange2_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1596	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1597	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1598	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1599	}
				1600
				1601	asn_enc_rval_t
				1602	OK_IntegerInRange2_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1603	int ilevel, enum xer_encoder_flags_e flags,
				1604	asn_app_consume_bytes_f cb, void app_key) {
				1605	OK_IntegerInRange2_1_inherit_TYPE_descriptor(td);
				1606	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1607	}
				1608
				1609
				1610	/* <<< STAT-DEFS [OK-IntegerInRange2] >>> */
				1611
				1612	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_1_tags[] = {
				1613	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1614	};
				1615	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
				1616	"OK-IntegerInRange2",
				1617	"OK-IntegerInRange2",
				1618	OK_IntegerInRange2_free,
				1619	OK_IntegerInRange2_print,
				1620	OK_IntegerInRange2_constraint,
				1621	OK_IntegerInRange2_decode_ber,
				1622	OK_IntegerInRange2_encode_der,
				1623	OK_IntegerInRange2_decode_xer,
				1624	OK_IntegerInRange2_encode_xer,
				1625	0, /* Use generic outmost tag fetcher */
				1626	asn_DEF_OK_IntegerInRange2_1_tags,
				1627	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
				1628	/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
				1629	asn_DEF_OK_IntegerInRange2_1_tags, /* Same as above */
				1630	sizeof(asn_DEF_OK_IntegerInRange2_1_tags)
				1631	/sizeof(asn_DEF_OK_IntegerInRange2_1_tags[0]), /* 1 */
				1632	0, 0, /* No members */
				1633	0 /* No specifics */
				1634	};
				1635
				1636
				1637	/* <<< INCLUDES [OK-IntegerInRange3] >>> */
				1638
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1639	#include <NativeInteger.h>
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1640
				1641	/* <<< TYPE-DECLS [OK-IntegerInRange3] >>> */
				1642
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1643	typedef long OK_IntegerInRange3_t;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1644
				1645	/* <<< FUNC-DECLS [OK-IntegerInRange3] >>> */
				1646
				1647	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3;
				1648	asn_struct_free_f OK_IntegerInRange3_free;
				1649	asn_struct_print_f OK_IntegerInRange3_print;
				1650	asn_constr_check_f OK_IntegerInRange3_constraint;
				1651	ber_type_decoder_f OK_IntegerInRange3_decode_ber;
				1652	der_type_encoder_f OK_IntegerInRange3_encode_der;
				1653	xer_type_decoder_f OK_IntegerInRange3_decode_xer;
				1654	xer_type_encoder_f OK_IntegerInRange3_encode_xer;
				1655
				1656	/* <<< CODE [OK-IntegerInRange3] >>> */
				1657
				1658	int
				1659	OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1660	asn_app_consume_bytes_f app_errlog, void app_key) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1661	long value;
				1662
				1663	if(!sptr) {
				1664	_ASN_ERRLOG(app_errlog, app_key,
				1665	"%s: value not given (%s:%d)",
				1666	td->name, __FILE__, __LINE__);
				1667	return -1;
				1668	}
				1669
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1670	value = (const long )sptr;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1671
				1672	if((value >= -2147483648 && value <= 2147483647)) {
				1673	/* Constraint check succeeded */
				1674	return 0;
				1675	} else {
				1676	_ASN_ERRLOG(app_errlog, app_key,
				1677	"%s: constraint failed (%s:%d)",
				1678	td->name, __FILE__, __LINE__);
				1679	return -1;
				1680	}
				1681	}
				1682
				1683	/*
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1684	* This type is implemented using NativeInteger,
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1685	* so here we adjust the DEF accordingly.
				1686	*/
				1687	static void
				1688	OK_IntegerInRange3_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1689	td->free_struct = asn_DEF_NativeInteger.free_struct;
				1690	td->print_struct = asn_DEF_NativeInteger.print_struct;
				1691	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				1692	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				1693	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				1694	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				1695	td->elements = asn_DEF_NativeInteger.elements;
				1696	td->elements_count = asn_DEF_NativeInteger.elements_count;
				1697	td->specifics = asn_DEF_NativeInteger.specifics;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1698	}
				1699
				1700	void
				1701	OK_IntegerInRange3_free(asn_TYPE_descriptor_t *td,
				1702	void *struct_ptr, int contents_only) {
				1703	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1704	td->free_struct(td, struct_ptr, contents_only);
				1705	}
				1706
				1707	int
				1708	OK_IntegerInRange3_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1709	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1710	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1711	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1712	}
				1713
				1714	asn_dec_rval_t
				1715	OK_IntegerInRange3_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1716	void *structure, const void bufptr, size_t size, int tag_mode) {
				1717	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1718	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1719	}
				1720
				1721	asn_enc_rval_t
				1722	OK_IntegerInRange3_encode_der(asn_TYPE_descriptor_t *td,
				1723	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1724	asn_app_consume_bytes_f cb, void app_key) {
				1725	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1726	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1727	}
				1728
				1729	asn_dec_rval_t
				1730	OK_IntegerInRange3_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1731	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1732	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1733	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1734	}
				1735
				1736	asn_enc_rval_t
				1737	OK_IntegerInRange3_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1738	int ilevel, enum xer_encoder_flags_e flags,
				1739	asn_app_consume_bytes_f cb, void app_key) {
				1740	OK_IntegerInRange3_1_inherit_TYPE_descriptor(td);
				1741	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1742	}
				1743
				1744
				1745	/* <<< STAT-DEFS [OK-IntegerInRange3] >>> */
				1746
				1747	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_1_tags[] = {
				1748	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1749	};
				1750	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
				1751	"OK-IntegerInRange3",
				1752	"OK-IntegerInRange3",
				1753	OK_IntegerInRange3_free,
				1754	OK_IntegerInRange3_print,
				1755	OK_IntegerInRange3_constraint,
				1756	OK_IntegerInRange3_decode_ber,
				1757	OK_IntegerInRange3_encode_der,
				1758	OK_IntegerInRange3_decode_xer,
				1759	OK_IntegerInRange3_encode_xer,
				1760	0, /* Use generic outmost tag fetcher */
				1761	asn_DEF_OK_IntegerInRange3_1_tags,
				1762	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
				1763	/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
				1764	asn_DEF_OK_IntegerInRange3_1_tags, /* Same as above */
				1765	sizeof(asn_DEF_OK_IntegerInRange3_1_tags)
				1766	/sizeof(asn_DEF_OK_IntegerInRange3_1_tags[0]), /* 1 */
				1767	0, 0, /* No members */
				1768	0 /* No specifics */
				1769	};
				1770
				1771
				1772	/* <<< INCLUDES [OK-IntegerInRange4] >>> */
				1773
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1774	#include <NativeInteger.h>
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1775
				1776	/* <<< TYPE-DECLS [OK-IntegerInRange4] >>> */
				1777
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1778	typedef long OK_IntegerInRange4_t;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1779
				1780	/* <<< FUNC-DECLS [OK-IntegerInRange4] >>> */
				1781
				1782	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4;
				1783	asn_struct_free_f OK_IntegerInRange4_free;
				1784	asn_struct_print_f OK_IntegerInRange4_print;
				1785	asn_constr_check_f OK_IntegerInRange4_constraint;
				1786	ber_type_decoder_f OK_IntegerInRange4_decode_ber;
				1787	der_type_encoder_f OK_IntegerInRange4_encode_der;
				1788	xer_type_decoder_f OK_IntegerInRange4_decode_xer;
				1789	xer_type_encoder_f OK_IntegerInRange4_encode_xer;
				1790
				1791	/* <<< CODE [OK-IntegerInRange4] >>> */
				1792
				1793	int
				1794	OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1795	asn_app_consume_bytes_f app_errlog, void app_key) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1796	long value;
				1797
				1798	if(!sptr) {
				1799	_ASN_ERRLOG(app_errlog, app_key,
				1800	"%s: value not given (%s:%d)",
				1801	td->name, __FILE__, __LINE__);
				1802	return -1;
				1803	}
				1804
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1805	value = (const long )sptr;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1806
				1807	if(((value == -2147483648) \|\| (value == 2147483647))) {
				1808	/* Constraint check succeeded */
				1809	return 0;
				1810	} else {
				1811	_ASN_ERRLOG(app_errlog, app_key,
				1812	"%s: constraint failed (%s:%d)",
				1813	td->name, __FILE__, __LINE__);
				1814	return -1;
				1815	}
				1816	}
				1817
				1818	/*
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1819	* This type is implemented using NativeInteger,
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1820	* so here we adjust the DEF accordingly.
				1821	*/
				1822	static void
				1823	OK_IntegerInRange4_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1824	td->free_struct = asn_DEF_NativeInteger.free_struct;
				1825	td->print_struct = asn_DEF_NativeInteger.print_struct;
				1826	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				1827	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				1828	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				1829	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				1830	td->elements = asn_DEF_NativeInteger.elements;
				1831	td->elements_count = asn_DEF_NativeInteger.elements_count;
				1832	td->specifics = asn_DEF_NativeInteger.specifics;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1833	}
				1834
				1835	void
				1836	OK_IntegerInRange4_free(asn_TYPE_descriptor_t *td,
				1837	void *struct_ptr, int contents_only) {
				1838	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1839	td->free_struct(td, struct_ptr, contents_only);
				1840	}
				1841
				1842	int
				1843	OK_IntegerInRange4_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1844	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1845	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1846	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1847	}
				1848
				1849	asn_dec_rval_t
				1850	OK_IntegerInRange4_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1851	void *structure, const void bufptr, size_t size, int tag_mode) {
				1852	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1853	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1854	}
				1855
				1856	asn_enc_rval_t
				1857	OK_IntegerInRange4_encode_der(asn_TYPE_descriptor_t *td,
				1858	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1859	asn_app_consume_bytes_f cb, void app_key) {
				1860	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1861	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1862	}
				1863
				1864	asn_dec_rval_t
				1865	OK_IntegerInRange4_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1866	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				1867	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1868	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				1869	}
				1870
				1871	asn_enc_rval_t
				1872	OK_IntegerInRange4_encode_xer(asn_TYPE_descriptor_t td, void structure,
				1873	int ilevel, enum xer_encoder_flags_e flags,
				1874	asn_app_consume_bytes_f cb, void app_key) {
				1875	OK_IntegerInRange4_1_inherit_TYPE_descriptor(td);
				1876	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				1877	}
				1878
				1879
				1880	/* <<< STAT-DEFS [OK-IntegerInRange4] >>> */
				1881
				1882	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_1_tags[] = {
				1883	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				1884	};
				1885	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
				1886	"OK-IntegerInRange4",
				1887	"OK-IntegerInRange4",
				1888	OK_IntegerInRange4_free,
				1889	OK_IntegerInRange4_print,
				1890	OK_IntegerInRange4_constraint,
				1891	OK_IntegerInRange4_decode_ber,
				1892	OK_IntegerInRange4_encode_der,
				1893	OK_IntegerInRange4_decode_xer,
				1894	OK_IntegerInRange4_encode_xer,
				1895	0, /* Use generic outmost tag fetcher */
				1896	asn_DEF_OK_IntegerInRange4_1_tags,
				1897	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
				1898	/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
				1899	asn_DEF_OK_IntegerInRange4_1_tags, /* Same as above */
				1900	sizeof(asn_DEF_OK_IntegerInRange4_1_tags)
				1901	/sizeof(asn_DEF_OK_IntegerInRange4_1_tags[0]), /* 1 */
				1902	0, 0, /* No members */
				1903	0 /* No specifics */
				1904	};
				1905
				1906
				1907	/* <<< INCLUDES [OK-IntegerInRange5] >>> */
				1908
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1909	#include <NativeInteger.h>
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1910
				1911	/* <<< TYPE-DECLS [OK-IntegerInRange5] >>> */
				1912
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1913	typedef long OK_IntegerInRange5_t;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1914
				1915	/* <<< FUNC-DECLS [OK-IntegerInRange5] >>> */
				1916
				1917	extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5;
				1918	asn_struct_free_f OK_IntegerInRange5_free;
				1919	asn_struct_print_f OK_IntegerInRange5_print;
				1920	asn_constr_check_f OK_IntegerInRange5_constraint;
				1921	ber_type_decoder_f OK_IntegerInRange5_decode_ber;
				1922	der_type_encoder_f OK_IntegerInRange5_encode_der;
				1923	xer_type_decoder_f OK_IntegerInRange5_decode_xer;
				1924	xer_type_encoder_f OK_IntegerInRange5_encode_xer;
				1925
				1926	/* <<< CODE [OK-IntegerInRange5] >>> */
				1927
				1928	int
				1929	OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t td, const void sptr,
				1930	asn_app_consume_bytes_f app_errlog, void app_key) {
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1931	long value;
				1932
				1933	if(!sptr) {
				1934	_ASN_ERRLOG(app_errlog, app_key,
				1935	"%s: value not given (%s:%d)",
				1936	td->name, __FILE__, __LINE__);
				1937	return -1;
				1938	}
				1939
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1940	value = (const long )sptr;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1941
				1942	if(((value == -2147483648) \|\| (value == 2147483647))) {
				1943	/* Constraint check succeeded */
				1944	return 0;
				1945	} else {
				1946	_ASN_ERRLOG(app_errlog, app_key,
				1947	"%s: constraint failed (%s:%d)",
				1948	td->name, __FILE__, __LINE__);
				1949	return -1;
				1950	}
				1951	}
				1952
				1953	/*
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1954	* This type is implemented using NativeInteger,
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1955	* so here we adjust the DEF accordingly.
				1956	*/
				1957	static void
				1958	OK_IntegerInRange5_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	1959	td->free_struct = asn_DEF_NativeInteger.free_struct;
				1960	td->print_struct = asn_DEF_NativeInteger.print_struct;
				1961	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				1962	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				1963	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				1964	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				1965	td->elements = asn_DEF_NativeInteger.elements;
				1966	td->elements_count = asn_DEF_NativeInteger.elements_count;
				1967	td->specifics = asn_DEF_NativeInteger.specifics;
Lev Walkin	082cadc	2005-08-14 02:18:27 +0000	[diff] [blame]	1968	}
				1969
				1970	void
				1971	OK_IntegerInRange5_free(asn_TYPE_descriptor_t *td,
				1972	void *struct_ptr, int contents_only) {
				1973	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				1974	td->free_struct(td, struct_ptr, contents_only);
				1975	}
				1976
				1977	int
				1978	OK_IntegerInRange5_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				1979	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				1980	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				1981	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				1982	}
				1983
				1984	asn_dec_rval_t
				1985	OK_IntegerInRange5_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				1986	void *structure, const void bufptr, size_t size, int tag_mode) {
				1987	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				1988	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				1989	}
				1990
				1991	asn_enc_rval_t
				1992	OK_IntegerInRange5_encode_der(asn_TYPE_descriptor_t *td,
				1993	void *structure, int tag_mode, ber_tlv_tag_t tag,
				1994	asn_app_consume_bytes_f cb, void app_key) {
				1995	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				1996	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				1997	}
				1998
				1999	asn_dec_rval_t
				2000	OK_IntegerInRange5_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2001	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				2002	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2003	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				2004	}
				2005
				2006	asn_enc_rval_t
				2007	OK_IntegerInRange5_encode_xer(asn_TYPE_descriptor_t td, void structure,
				2008	int ilevel, enum xer_encoder_flags_e flags,
				2009	asn_app_consume_bytes_f cb, void app_key) {
				2010	OK_IntegerInRange5_1_inherit_TYPE_descriptor(td);
				2011	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				2012	}
				2013
				2014
				2015	/* <<< STAT-DEFS [OK-IntegerInRange5] >>> */
				2016
				2017	static ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_1_tags[] = {
				2018	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				2019	};
				2020	asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
				2021	"OK-IntegerInRange5",
				2022	"OK-IntegerInRange5",
				2023	OK_IntegerInRange5_free,
				2024	OK_IntegerInRange5_print,
				2025	OK_IntegerInRange5_constraint,
				2026	OK_IntegerInRange5_decode_ber,
				2027	OK_IntegerInRange5_encode_der,
				2028	OK_IntegerInRange5_decode_xer,
				2029	OK_IntegerInRange5_encode_xer,
				2030	0, /* Use generic outmost tag fetcher */
				2031	asn_DEF_OK_IntegerInRange5_1_tags,
				2032	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
				2033	/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
				2034	asn_DEF_OK_IntegerInRange5_1_tags, /* Same as above */
				2035	sizeof(asn_DEF_OK_IntegerInRange5_1_tags)
				2036	/sizeof(asn_DEF_OK_IntegerInRange5_1_tags[0]), /* 1 */
				2037	0, 0, /* No members */
				2038	0 /* No specifics */
				2039	};
				2040
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	2041
Lev Walkin	fee6f71	2005-08-27 03:13:51 +0000	[diff] [blame^]	2042	/* <<< INCLUDES [NO-IntegerInRange6] >>> */
				2043
				2044	#include <INTEGER.h>
				2045
				2046	/* <<< TYPE-DECLS [NO-IntegerInRange6] >>> */
				2047
				2048	typedef INTEGER_t NO_IntegerInRange6_t;
				2049
				2050	/* <<< FUNC-DECLS [NO-IntegerInRange6] >>> */
				2051
				2052	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6;
				2053	asn_struct_free_f NO_IntegerInRange6_free;
				2054	asn_struct_print_f NO_IntegerInRange6_print;
				2055	asn_constr_check_f NO_IntegerInRange6_constraint;
				2056	ber_type_decoder_f NO_IntegerInRange6_decode_ber;
				2057	der_type_encoder_f NO_IntegerInRange6_encode_der;
				2058	xer_type_decoder_f NO_IntegerInRange6_decode_xer;
				2059	xer_type_encoder_f NO_IntegerInRange6_encode_xer;
				2060
				2061	/* <<< CODE [NO-IntegerInRange6] >>> */
				2062
				2063	int
				2064	NO_IntegerInRange6_constraint(asn_TYPE_descriptor_t td, const void sptr,
				2065	asn_app_consume_bytes_f app_errlog, void app_key) {
				2066	const INTEGER_t st = (const INTEGER_t )sptr;
				2067	long value;
				2068
				2069	if(!sptr) {
				2070	_ASN_ERRLOG(app_errlog, app_key,
				2071	"%s: value not given (%s:%d)",
				2072	td->name, __FILE__, __LINE__);
				2073	return -1;
				2074	}
				2075
				2076	if(asn_INTEGER2long(st, &value)) {
				2077	_ASN_ERRLOG(app_errlog, app_key,
				2078	"%s: value too large (%s:%d)",
				2079	td->name, __FILE__, __LINE__);
				2080	return -1;
				2081	}
				2082
				2083	if((value >= 0 && value <= 4294967295)) {
				2084	/* Constraint check succeeded */
				2085	return 0;
				2086	} else {
				2087	_ASN_ERRLOG(app_errlog, app_key,
				2088	"%s: constraint failed (%s:%d)",
				2089	td->name, __FILE__, __LINE__);
				2090	return -1;
				2091	}
				2092	}
				2093
				2094	/*
				2095	* This type is implemented using INTEGER,
				2096	* so here we adjust the DEF accordingly.
				2097	*/
				2098	static void
				2099	NO_IntegerInRange6_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				2100	td->free_struct = asn_DEF_INTEGER.free_struct;
				2101	td->print_struct = asn_DEF_INTEGER.print_struct;
				2102	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				2103	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				2104	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				2105	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				2106	td->elements = asn_DEF_INTEGER.elements;
				2107	td->elements_count = asn_DEF_INTEGER.elements_count;
				2108	td->specifics = asn_DEF_INTEGER.specifics;
				2109	}
				2110
				2111	void
				2112	NO_IntegerInRange6_free(asn_TYPE_descriptor_t *td,
				2113	void *struct_ptr, int contents_only) {
				2114	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
				2115	td->free_struct(td, struct_ptr, contents_only);
				2116	}
				2117
				2118	int
				2119	NO_IntegerInRange6_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				2120	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				2121	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
				2122	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				2123	}
				2124
				2125	asn_dec_rval_t
				2126	NO_IntegerInRange6_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2127	void *structure, const void bufptr, size_t size, int tag_mode) {
				2128	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
				2129	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				2130	}
				2131
				2132	asn_enc_rval_t
				2133	NO_IntegerInRange6_encode_der(asn_TYPE_descriptor_t *td,
				2134	void *structure, int tag_mode, ber_tlv_tag_t tag,
				2135	asn_app_consume_bytes_f cb, void app_key) {
				2136	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
				2137	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				2138	}
				2139
				2140	asn_dec_rval_t
				2141	NO_IntegerInRange6_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2142	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				2143	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
				2144	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				2145	}
				2146
				2147	asn_enc_rval_t
				2148	NO_IntegerInRange6_encode_xer(asn_TYPE_descriptor_t td, void structure,
				2149	int ilevel, enum xer_encoder_flags_e flags,
				2150	asn_app_consume_bytes_f cb, void app_key) {
				2151	NO_IntegerInRange6_1_inherit_TYPE_descriptor(td);
				2152	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				2153	}
				2154
				2155
				2156	/* <<< STAT-DEFS [NO-IntegerInRange6] >>> */
				2157
				2158	static ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_1_tags[] = {
				2159	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				2160	};
				2161	asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
				2162	"NO-IntegerInRange6",
				2163	"NO-IntegerInRange6",
				2164	NO_IntegerInRange6_free,
				2165	NO_IntegerInRange6_print,
				2166	NO_IntegerInRange6_constraint,
				2167	NO_IntegerInRange6_decode_ber,
				2168	NO_IntegerInRange6_encode_der,
				2169	NO_IntegerInRange6_decode_xer,
				2170	NO_IntegerInRange6_encode_xer,
				2171	0, /* Use generic outmost tag fetcher */
				2172	asn_DEF_NO_IntegerInRange6_1_tags,
				2173	sizeof(asn_DEF_NO_IntegerInRange6_1_tags)
				2174	/sizeof(asn_DEF_NO_IntegerInRange6_1_tags[0]), /* 1 */
				2175	asn_DEF_NO_IntegerInRange6_1_tags, /* Same as above */
				2176	sizeof(asn_DEF_NO_IntegerInRange6_1_tags)
				2177	/sizeof(asn_DEF_NO_IntegerInRange6_1_tags[0]), /* 1 */
				2178	0, 0, /* No members */
				2179	0 /* No specifics */
				2180	};
				2181
				2182
Lev Walkin	c3f0b89	2005-08-14 02:40:04 +0000	[diff] [blame]	2183	/* <<< INCLUDES [CN-IntegerEnumerated1] >>> */
				2184
				2185	#include <NativeInteger.h>
				2186
				2187	/* <<< DEPS [CN-IntegerEnumerated1] >>> */
				2188
				2189	typedef enum CN_IntegerEnumerated1 {
				2190	CN_IntegerEnumerated1_a = 1,
				2191	CN_IntegerEnumerated1_b = 2
				2192	} CN_IntegerEnumerated1_e;
				2193
				2194	/* <<< TYPE-DECLS [CN-IntegerEnumerated1] >>> */
				2195
				2196	typedef long CN_IntegerEnumerated1_t;
				2197
				2198	/* <<< FUNC-DECLS [CN-IntegerEnumerated1] >>> */
				2199
				2200	extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1;
				2201	asn_struct_free_f CN_IntegerEnumerated1_free;
				2202	asn_struct_print_f CN_IntegerEnumerated1_print;
				2203	asn_constr_check_f CN_IntegerEnumerated1_constraint;
				2204	ber_type_decoder_f CN_IntegerEnumerated1_decode_ber;
				2205	der_type_encoder_f CN_IntegerEnumerated1_encode_der;
				2206	xer_type_decoder_f CN_IntegerEnumerated1_decode_xer;
				2207	xer_type_encoder_f CN_IntegerEnumerated1_encode_xer;
				2208
				2209	/* <<< CODE [CN-IntegerEnumerated1] >>> */
				2210
				2211	int
				2212	CN_IntegerEnumerated1_constraint(asn_TYPE_descriptor_t td, const void sptr,
				2213	asn_app_consume_bytes_f app_errlog, void app_key) {
				2214	/* Replace with underlying type checker */
				2215	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
				2216	return td->check_constraints(td, sptr, app_errlog, app_key);
				2217	}
				2218
				2219	/*
				2220	* This type is implemented using NativeInteger,
				2221	* so here we adjust the DEF accordingly.
				2222	*/
				2223	static void
				2224	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				2225	td->free_struct = asn_DEF_NativeInteger.free_struct;
				2226	td->print_struct = asn_DEF_NativeInteger.print_struct;
				2227	td->ber_decoder = asn_DEF_NativeInteger.ber_decoder;
				2228	td->der_encoder = asn_DEF_NativeInteger.der_encoder;
				2229	td->xer_decoder = asn_DEF_NativeInteger.xer_decoder;
				2230	td->xer_encoder = asn_DEF_NativeInteger.xer_encoder;
				2231	td->elements = asn_DEF_NativeInteger.elements;
				2232	td->elements_count = asn_DEF_NativeInteger.elements_count;
				2233	td->specifics = asn_DEF_NativeInteger.specifics;
				2234	}
				2235
				2236	void
				2237	CN_IntegerEnumerated1_free(asn_TYPE_descriptor_t *td,
				2238	void *struct_ptr, int contents_only) {
				2239	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
				2240	td->free_struct(td, struct_ptr, contents_only);
				2241	}
				2242
				2243	int
				2244	CN_IntegerEnumerated1_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				2245	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				2246	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
				2247	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				2248	}
				2249
				2250	asn_dec_rval_t
				2251	CN_IntegerEnumerated1_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2252	void *structure, const void bufptr, size_t size, int tag_mode) {
				2253	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
				2254	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				2255	}
				2256
				2257	asn_enc_rval_t
				2258	CN_IntegerEnumerated1_encode_der(asn_TYPE_descriptor_t *td,
				2259	void *structure, int tag_mode, ber_tlv_tag_t tag,
				2260	asn_app_consume_bytes_f cb, void app_key) {
				2261	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
				2262	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				2263	}
				2264
				2265	asn_dec_rval_t
				2266	CN_IntegerEnumerated1_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2267	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				2268	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
				2269	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				2270	}
				2271
				2272	asn_enc_rval_t
				2273	CN_IntegerEnumerated1_encode_xer(asn_TYPE_descriptor_t td, void structure,
				2274	int ilevel, enum xer_encoder_flags_e flags,
				2275	asn_app_consume_bytes_f cb, void app_key) {
				2276	CN_IntegerEnumerated1_1_inherit_TYPE_descriptor(td);
				2277	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				2278	}
				2279
				2280
				2281	/* <<< STAT-DEFS [CN-IntegerEnumerated1] >>> */
				2282
				2283	static ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_1_tags[] = {
				2284	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				2285	};
				2286	asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1 = {
				2287	"CN-IntegerEnumerated1",
				2288	"CN-IntegerEnumerated1",
				2289	CN_IntegerEnumerated1_free,
				2290	CN_IntegerEnumerated1_print,
				2291	CN_IntegerEnumerated1_constraint,
				2292	CN_IntegerEnumerated1_decode_ber,
				2293	CN_IntegerEnumerated1_encode_der,
				2294	CN_IntegerEnumerated1_decode_xer,
				2295	CN_IntegerEnumerated1_encode_xer,
				2296	0, /* Use generic outmost tag fetcher */
				2297	asn_DEF_CN_IntegerEnumerated1_1_tags,
				2298	sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags)
				2299	/sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags[0]), /* 1 */
				2300	asn_DEF_CN_IntegerEnumerated1_1_tags, /* Same as above */
				2301	sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags)
				2302	/sizeof(asn_DEF_CN_IntegerEnumerated1_1_tags[0]), /* 1 */
				2303	0, 0, /* Defined elsewhere */
				2304	0 /* No specifics */
				2305	};
				2306
				2307
				2308	/* <<< INCLUDES [NO-IntegerEnumerated2] >>> */
				2309
				2310	#include <INTEGER.h>
				2311
				2312	/* <<< DEPS [NO-IntegerEnumerated2] >>> */
				2313
				2314	typedef enum NO_IntegerEnumerated2 {
				2315	NO_IntegerEnumerated2_a = 1,
				2316	NO_IntegerEnumerated2_b = 3000000000
				2317	} NO_IntegerEnumerated2_e;
				2318
				2319	/* <<< TYPE-DECLS [NO-IntegerEnumerated2] >>> */
				2320
				2321	typedef INTEGER_t NO_IntegerEnumerated2_t;
				2322
				2323	/* <<< FUNC-DECLS [NO-IntegerEnumerated2] >>> */
				2324
				2325	extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2;
				2326	asn_struct_free_f NO_IntegerEnumerated2_free;
				2327	asn_struct_print_f NO_IntegerEnumerated2_print;
				2328	asn_constr_check_f NO_IntegerEnumerated2_constraint;
				2329	ber_type_decoder_f NO_IntegerEnumerated2_decode_ber;
				2330	der_type_encoder_f NO_IntegerEnumerated2_encode_der;
				2331	xer_type_decoder_f NO_IntegerEnumerated2_decode_xer;
				2332	xer_type_encoder_f NO_IntegerEnumerated2_encode_xer;
				2333
				2334	/* <<< CODE [NO-IntegerEnumerated2] >>> */
				2335
				2336	int
				2337	NO_IntegerEnumerated2_constraint(asn_TYPE_descriptor_t td, const void sptr,
				2338	asn_app_consume_bytes_f app_errlog, void app_key) {
				2339	/* Replace with underlying type checker */
				2340	td->check_constraints = asn_DEF_INTEGER.check_constraints;
				2341	return td->check_constraints(td, sptr, app_errlog, app_key);
				2342	}
				2343
				2344	/*
				2345	* This type is implemented using INTEGER,
				2346	* so here we adjust the DEF accordingly.
				2347	*/
				2348	static void
				2349	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
				2350	td->free_struct = asn_DEF_INTEGER.free_struct;
				2351	td->print_struct = asn_DEF_INTEGER.print_struct;
				2352	td->ber_decoder = asn_DEF_INTEGER.ber_decoder;
				2353	td->der_encoder = asn_DEF_INTEGER.der_encoder;
				2354	td->xer_decoder = asn_DEF_INTEGER.xer_decoder;
				2355	td->xer_encoder = asn_DEF_INTEGER.xer_encoder;
				2356	td->elements = asn_DEF_INTEGER.elements;
				2357	td->elements_count = asn_DEF_INTEGER.elements_count;
				2358	td->specifics = asn_DEF_INTEGER.specifics;
				2359	}
				2360
				2361	void
				2362	NO_IntegerEnumerated2_free(asn_TYPE_descriptor_t *td,
				2363	void *struct_ptr, int contents_only) {
				2364	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
				2365	td->free_struct(td, struct_ptr, contents_only);
				2366	}
				2367
				2368	int
				2369	NO_IntegerEnumerated2_print(asn_TYPE_descriptor_t td, const void struct_ptr,
				2370	int ilevel, asn_app_consume_bytes_f cb, void app_key) {
				2371	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
				2372	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
				2373	}
				2374
				2375	asn_dec_rval_t
				2376	NO_IntegerEnumerated2_decode_ber(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2377	void *structure, const void bufptr, size_t size, int tag_mode) {
				2378	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
				2379	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
				2380	}
				2381
				2382	asn_enc_rval_t
				2383	NO_IntegerEnumerated2_encode_der(asn_TYPE_descriptor_t *td,
				2384	void *structure, int tag_mode, ber_tlv_tag_t tag,
				2385	asn_app_consume_bytes_f cb, void app_key) {
				2386	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
				2387	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
				2388	}
				2389
				2390	asn_dec_rval_t
				2391	NO_IntegerEnumerated2_decode_xer(asn_codec_ctx_t opt_codec_ctx, asn_TYPE_descriptor_t td,
				2392	void *structure, const char opt_mname, const void *bufptr, size_t size) {
				2393	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
				2394	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
				2395	}
				2396
				2397	asn_enc_rval_t
				2398	NO_IntegerEnumerated2_encode_xer(asn_TYPE_descriptor_t td, void structure,
				2399	int ilevel, enum xer_encoder_flags_e flags,
				2400	asn_app_consume_bytes_f cb, void app_key) {
				2401	NO_IntegerEnumerated2_1_inherit_TYPE_descriptor(td);
				2402	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
				2403	}
				2404
				2405
				2406	/* <<< STAT-DEFS [NO-IntegerEnumerated2] >>> */
				2407
				2408	static ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_1_tags[] = {
				2409	(ASN_TAG_CLASS_UNIVERSAL \| (2 << 2))
				2410	};
				2411	asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2 = {
				2412	"NO-IntegerEnumerated2",
				2413	"NO-IntegerEnumerated2",
				2414	NO_IntegerEnumerated2_free,
				2415	NO_IntegerEnumerated2_print,
				2416	NO_IntegerEnumerated2_constraint,
				2417	NO_IntegerEnumerated2_decode_ber,
				2418	NO_IntegerEnumerated2_encode_der,
				2419	NO_IntegerEnumerated2_decode_xer,
				2420	NO_IntegerEnumerated2_encode_xer,
				2421	0, /* Use generic outmost tag fetcher */
				2422	asn_DEF_NO_IntegerEnumerated2_1_tags,
				2423	sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags)
				2424	/sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags[0]), /* 1 */
				2425	asn_DEF_NO_IntegerEnumerated2_1_tags, /* Same as above */
				2426	sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags)
				2427	/sizeof(asn_DEF_NO_IntegerEnumerated2_1_tags[0]), /* 1 */
				2428	0, 0, /* Defined elsewhere */
				2429	0 /* No specifics */
				2430	};
				2431