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

blob: 89acc3fb76e3c13508920d823dc735de52885fc1 [file] [log] [blame]

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