90-cond-int-type-OK.asn1.-P 35.5 KB
Newer Older
1 2 3

/*** <<< INCLUDES [CN-IntegerUnlimited] >>> ***/

4
#include <NativeInteger.h>
5 6 7

/*** <<< TYPE-DECLS [CN-IntegerUnlimited] >>> ***/

8
typedef long	 CN_IntegerUnlimited_t;
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

/*** <<< FUNC-DECLS [CN-IntegerUnlimited] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited;
asn_struct_free_f CN_IntegerUnlimited_free;
asn_struct_print_f CN_IntegerUnlimited_print;
asn_constr_check_f CN_IntegerUnlimited_constraint;
ber_type_decoder_f CN_IntegerUnlimited_decode_ber;
der_type_encoder_f CN_IntegerUnlimited_encode_der;
xer_type_decoder_f CN_IntegerUnlimited_decode_xer;
xer_type_encoder_f CN_IntegerUnlimited_encode_xer;

/*** <<< CODE [CN-IntegerUnlimited] >>> ***/

/*
24
 * This type is implemented using NativeInteger,
25 26 27 28 29
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [CN-IntegerUnlimited] >>> ***/

30
static const ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_tags_1[] = {
31 32 33 34 35
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
	"CN-IntegerUnlimited",
	"CN-IntegerUnlimited",
36
	&asn_OP_NativeInteger,
37
	NativeInteger_constraint,
Lev Walkin's avatar
Lev Walkin committed
38 39 40 41 42 43
	asn_DEF_CN_IntegerUnlimited_tags_1,
	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
	asn_DEF_CN_IntegerUnlimited_tags_1,	/* Same as above */
	sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
		/sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
44
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
45
	0,	/* No PER visible constraints */
46 47 48 49 50 51 52
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [CN-IntegerMinMax] >>> ***/

53
#include <NativeInteger.h>
54 55 56

/*** <<< TYPE-DECLS [CN-IntegerMinMax] >>> ***/

57
typedef long	 CN_IntegerMinMax_t;
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

/*** <<< FUNC-DECLS [CN-IntegerMinMax] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax;
asn_struct_free_f CN_IntegerMinMax_free;
asn_struct_print_f CN_IntegerMinMax_print;
asn_constr_check_f CN_IntegerMinMax_constraint;
ber_type_decoder_f CN_IntegerMinMax_decode_ber;
der_type_encoder_f CN_IntegerMinMax_encode_der;
xer_type_decoder_f CN_IntegerMinMax_decode_xer;
xer_type_encoder_f CN_IntegerMinMax_encode_xer;

/*** <<< CODE [CN-IntegerMinMax] >>> ***/

int
CN_IntegerMinMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
74
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
75 76
	
	if(!sptr) {
77
		ASN__CTFAIL(app_key, td, sptr,
78 79 80 81 82 83 84 85 86 87 88
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
	if(1 /* No applicable constraints whatsoever */) {
		/* Nothing is here. See below */
	}
	
	/* Replace with underlying type checker */
89
	return td->check_constraints(td, sptr, ctfailcb, app_key);
90 91 92
}

/*
93
 * This type is implemented using NativeInteger,
94 95 96 97 98
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [CN-IntegerMinMax] >>> ***/

99
static const ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_tags_1[] = {
100 101 102 103 104
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
	"CN-IntegerMinMax",
	"CN-IntegerMinMax",
105
	&asn_OP_NativeInteger,
106
	CN_IntegerMinMax_constraint,
Lev Walkin's avatar
Lev Walkin committed
107 108 109 110 111 112
	asn_DEF_CN_IntegerMinMax_tags_1,
	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
	asn_DEF_CN_IntegerMinMax_tags_1,	/* Same as above */
	sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
		/sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
113
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
114
	0,	/* No PER visible constraints */
115 116 117 118 119 120 121
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [CN-IntegerMinLow] >>> ***/

122
#include <NativeInteger.h>
123 124 125

/*** <<< TYPE-DECLS [CN-IntegerMinLow] >>> ***/

126
typedef long	 CN_IntegerMinLow_t;
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142

/*** <<< FUNC-DECLS [CN-IntegerMinLow] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow;
asn_struct_free_f CN_IntegerMinLow_free;
asn_struct_print_f CN_IntegerMinLow_print;
asn_constr_check_f CN_IntegerMinLow_constraint;
ber_type_decoder_f CN_IntegerMinLow_decode_ber;
der_type_encoder_f CN_IntegerMinLow_encode_der;
xer_type_decoder_f CN_IntegerMinLow_decode_xer;
xer_type_encoder_f CN_IntegerMinLow_encode_xer;

/*** <<< CODE [CN-IntegerMinLow] >>> ***/

int
CN_IntegerMinLow_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
143
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
144 145 146
	long value;
	
	if(!sptr) {
147
		ASN__CTFAIL(app_key, td, sptr,
148 149 150 151 152
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
153
	value = *(const long *)sptr;
154 155 156 157 158
	
	if((value <= 1)) {
		/* Constraint check succeeded */
		return 0;
	} else {
159
		ASN__CTFAIL(app_key, td, sptr,
160 161 162 163 164 165 166
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
167
 * This type is implemented using NativeInteger,
168 169 170 171 172
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [CN-IntegerMinLow] >>> ***/

173
static const ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_tags_1[] = {
174 175 176 177 178
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
	"CN-IntegerMinLow",
	"CN-IntegerMinLow",
179
	&asn_OP_NativeInteger,
180
	CN_IntegerMinLow_constraint,
Lev Walkin's avatar
Lev Walkin committed
181 182 183 184 185 186
	asn_DEF_CN_IntegerMinLow_tags_1,
	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
	asn_DEF_CN_IntegerMinLow_tags_1,	/* Same as above */
	sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
		/sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
187
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
188
	0,	/* No PER visible constraints */
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [NO-IntegerMinHigh] >>> ***/

#include <INTEGER.h>

/*** <<< TYPE-DECLS [NO-IntegerMinHigh] >>> ***/

typedef INTEGER_t	 NO_IntegerMinHigh_t;

/*** <<< FUNC-DECLS [NO-IntegerMinHigh] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh;
asn_struct_free_f NO_IntegerMinHigh_free;
asn_struct_print_f NO_IntegerMinHigh_print;
asn_constr_check_f NO_IntegerMinHigh_constraint;
ber_type_decoder_f NO_IntegerMinHigh_decode_ber;
der_type_encoder_f NO_IntegerMinHigh_encode_der;
xer_type_decoder_f NO_IntegerMinHigh_decode_xer;
xer_type_encoder_f NO_IntegerMinHigh_encode_xer;

/*** <<< CODE [NO-IntegerMinHigh] >>> ***/

int
NO_IntegerMinHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
217
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
218 219 220 221
	const INTEGER_t *st = (const INTEGER_t *)sptr;
	long value;
	
	if(!sptr) {
222
		ASN__CTFAIL(app_key, td, sptr,
223 224 225 226 227 228
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	if(asn_INTEGER2long(st, &value)) {
229
		ASN__CTFAIL(app_key, td, sptr,
230 231 232 233 234
			"%s: value too large (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
235
	if((value <= 3000000000)) {
236 237 238
		/* Constraint check succeeded */
		return 0;
	} else {
239
		ASN__CTFAIL(app_key, td, sptr,
240 241 242 243 244 245 246 247 248 249 250 251 252
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
 * This type is implemented using INTEGER,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerMinHigh] >>> ***/

253
static const ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_tags_1[] = {
254 255 256 257 258
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
	"NO-IntegerMinHigh",
	"NO-IntegerMinHigh",
259
	&asn_OP_INTEGER,
260
	NO_IntegerMinHigh_constraint,
Lev Walkin's avatar
Lev Walkin committed
261 262 263 264 265 266
	asn_DEF_NO_IntegerMinHigh_tags_1,
	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerMinHigh_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
		/sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
267
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
268
	0,	/* No PER visible constraints */
269 270 271 272 273 274 275
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [NO-IntegerLowHigh] >>> ***/

276
#include <NativeInteger.h>
277 278 279

/*** <<< TYPE-DECLS [NO-IntegerLowHigh] >>> ***/

280
typedef unsigned long	 NO_IntegerLowHigh_t;
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296

/*** <<< FUNC-DECLS [NO-IntegerLowHigh] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh;
asn_struct_free_f NO_IntegerLowHigh_free;
asn_struct_print_f NO_IntegerLowHigh_print;
asn_constr_check_f NO_IntegerLowHigh_constraint;
ber_type_decoder_f NO_IntegerLowHigh_decode_ber;
der_type_encoder_f NO_IntegerLowHigh_encode_der;
xer_type_decoder_f NO_IntegerLowHigh_decode_xer;
xer_type_encoder_f NO_IntegerLowHigh_encode_xer;

/*** <<< CODE [NO-IntegerLowHigh] >>> ***/

int
NO_IntegerLowHigh_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
297
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
298
	unsigned long value;
299 300
	
	if(!sptr) {
301
		ASN__CTFAIL(app_key, td, sptr,
302 303 304 305 306
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
307
	value = *(const unsigned long *)sptr;
308
	
309
	if((value >= 1 && value <= 3000000000)) {
310 311 312
		/* Constraint check succeeded */
		return 0;
	} else {
313
		ASN__CTFAIL(app_key, td, sptr,
314 315 316 317 318 319 320
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
321
 * This type is implemented using NativeInteger,
322 323 324 325 326
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerLowHigh] >>> ***/

327
static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerLowHigh_specs_1 = {
328 329 330 331
	0,	0,	0,	0,	0,
	0,	/* Native long size */
	1	/* Unsigned representation */
};
332
static const ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_tags_1[] = {
333 334 335 336 337
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
	"NO-IntegerLowHigh",
	"NO-IntegerLowHigh",
338
	&asn_OP_NativeInteger,
339
	NO_IntegerLowHigh_constraint,
Lev Walkin's avatar
Lev Walkin committed
340 341 342 343 344 345
	asn_DEF_NO_IntegerLowHigh_tags_1,
	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerLowHigh_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
		/sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
346
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
347
	0,	/* No PER visible constraints */
348
	0, 0,	/* No members */
349
	&asn_SPC_NO_IntegerLowHigh_specs_1	/* Additional specs */
350 351 352 353 354
};


/*** <<< INCLUDES [CN-IntegerLowMax] >>> ***/

355
#include <NativeInteger.h>
356 357 358

/*** <<< TYPE-DECLS [CN-IntegerLowMax] >>> ***/

359
typedef unsigned long	 CN_IntegerLowMax_t;
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375

/*** <<< FUNC-DECLS [CN-IntegerLowMax] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax;
asn_struct_free_f CN_IntegerLowMax_free;
asn_struct_print_f CN_IntegerLowMax_print;
asn_constr_check_f CN_IntegerLowMax_constraint;
ber_type_decoder_f CN_IntegerLowMax_decode_ber;
der_type_encoder_f CN_IntegerLowMax_encode_der;
xer_type_decoder_f CN_IntegerLowMax_decode_xer;
xer_type_encoder_f CN_IntegerLowMax_encode_xer;

/*** <<< CODE [CN-IntegerLowMax] >>> ***/

int
CN_IntegerLowMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
376
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
377
	unsigned long value;
378 379
	
	if(!sptr) {
380
		ASN__CTFAIL(app_key, td, sptr,
381 382 383 384 385
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
386
	value = *(const unsigned long *)sptr;
387 388 389 390 391
	
	if((value >= 1)) {
		/* Constraint check succeeded */
		return 0;
	} else {
392
		ASN__CTFAIL(app_key, td, sptr,
393 394 395 396 397 398 399
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
400
 * This type is implemented using NativeInteger,
401 402 403 404 405
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [CN-IntegerLowMax] >>> ***/

406 407 408 409 410
static const asn_INTEGER_specifics_t asn_SPC_CN_IntegerLowMax_specs_1 = {
	0,	0,	0,	0,	0,
	0,	/* Native long size */
	1	/* Unsigned representation */
};
411
static const ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_tags_1[] = {
412 413 414 415 416
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
	"CN-IntegerLowMax",
	"CN-IntegerLowMax",
417
	&asn_OP_NativeInteger,
418
	CN_IntegerLowMax_constraint,
Lev Walkin's avatar
Lev Walkin committed
419 420 421 422 423 424
	asn_DEF_CN_IntegerLowMax_tags_1,
	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
	asn_DEF_CN_IntegerLowMax_tags_1,	/* Same as above */
	sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
		/sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
425
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
426
	0,	/* No PER visible constraints */
427
	0, 0,	/* No members */
428
	&asn_SPC_CN_IntegerLowMax_specs_1	/* Additional specs */
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
};


/*** <<< INCLUDES [NO-IntegerHighMax] >>> ***/

#include <INTEGER.h>

/*** <<< TYPE-DECLS [NO-IntegerHighMax] >>> ***/

typedef INTEGER_t	 NO_IntegerHighMax_t;

/*** <<< FUNC-DECLS [NO-IntegerHighMax] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax;
asn_struct_free_f NO_IntegerHighMax_free;
asn_struct_print_f NO_IntegerHighMax_print;
asn_constr_check_f NO_IntegerHighMax_constraint;
ber_type_decoder_f NO_IntegerHighMax_decode_ber;
der_type_encoder_f NO_IntegerHighMax_encode_der;
xer_type_decoder_f NO_IntegerHighMax_decode_xer;
xer_type_encoder_f NO_IntegerHighMax_encode_xer;

/*** <<< CODE [NO-IntegerHighMax] >>> ***/

int
NO_IntegerHighMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
455
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
456 457 458 459
	const INTEGER_t *st = (const INTEGER_t *)sptr;
	long value;
	
	if(!sptr) {
460
		ASN__CTFAIL(app_key, td, sptr,
461 462 463 464 465 466
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	if(asn_INTEGER2long(st, &value)) {
467
		ASN__CTFAIL(app_key, td, sptr,
468 469 470 471 472
			"%s: value too large (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
473
	if((value >= 3000000000)) {
474 475 476
		/* Constraint check succeeded */
		return 0;
	} else {
477
		ASN__CTFAIL(app_key, td, sptr,
478 479 480 481 482 483 484 485 486 487 488 489 490
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
 * This type is implemented using INTEGER,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerHighMax] >>> ***/

491
static const ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_tags_1[] = {
492 493 494 495 496
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
	"NO-IntegerHighMax",
	"NO-IntegerHighMax",
497
	&asn_OP_INTEGER,
498
	NO_IntegerHighMax_constraint,
Lev Walkin's avatar
Lev Walkin committed
499 500 501 502 503 504
	asn_DEF_NO_IntegerHighMax_tags_1,
	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerHighMax_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
		/sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
505
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
506
	0,	/* No PER visible constraints */
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [NO-IntegerLowestMax] >>> ***/

#include <INTEGER.h>

/*** <<< TYPE-DECLS [NO-IntegerLowestMax] >>> ***/

typedef INTEGER_t	 NO_IntegerLowestMax_t;

/*** <<< FUNC-DECLS [NO-IntegerLowestMax] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax;
asn_struct_free_f NO_IntegerLowestMax_free;
asn_struct_print_f NO_IntegerLowestMax_print;
asn_constr_check_f NO_IntegerLowestMax_constraint;
ber_type_decoder_f NO_IntegerLowestMax_decode_ber;
der_type_encoder_f NO_IntegerLowestMax_encode_der;
xer_type_decoder_f NO_IntegerLowestMax_decode_xer;
xer_type_encoder_f NO_IntegerLowestMax_encode_xer;

/*** <<< CODE [NO-IntegerLowestMax] >>> ***/

int
NO_IntegerLowestMax_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
535
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
536 537 538 539
	const INTEGER_t *st = (const INTEGER_t *)sptr;
	long value;
	
	if(!sptr) {
540
		ASN__CTFAIL(app_key, td, sptr,
541 542 543 544 545 546
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	if(asn_INTEGER2long(st, &value)) {
547
		ASN__CTFAIL(app_key, td, sptr,
548 549 550 551 552
			"%s: value too large (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
553
	if((value >= -3000000000)) {
554 555 556
		/* Constraint check succeeded */
		return 0;
	} else {
557
		ASN__CTFAIL(app_key, td, sptr,
558 559 560 561 562 563 564 565 566 567 568 569 570
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
 * This type is implemented using INTEGER,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerLowestMax] >>> ***/

571
static const ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_tags_1[] = {
572 573 574 575 576
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
	"NO-IntegerLowestMax",
	"NO-IntegerLowestMax",
577
	&asn_OP_INTEGER,
578
	NO_IntegerLowestMax_constraint,
Lev Walkin's avatar
Lev Walkin committed
579 580 581 582 583 584
	asn_DEF_NO_IntegerLowestMax_tags_1,
	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerLowestMax_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
		/sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
585
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
586
	0,	/* No PER visible constraints */
587 588 589 590 591 592 593
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [NO-IntegerOutRange] >>> ***/

594
#include <NativeInteger.h>
595 596 597

/*** <<< TYPE-DECLS [NO-IntegerOutRange] >>> ***/

598
typedef unsigned long	 NO_IntegerOutRange_t;
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614

/*** <<< FUNC-DECLS [NO-IntegerOutRange] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange;
asn_struct_free_f NO_IntegerOutRange_free;
asn_struct_print_f NO_IntegerOutRange_print;
asn_constr_check_f NO_IntegerOutRange_constraint;
ber_type_decoder_f NO_IntegerOutRange_decode_ber;
der_type_encoder_f NO_IntegerOutRange_encode_der;
xer_type_decoder_f NO_IntegerOutRange_decode_xer;
xer_type_encoder_f NO_IntegerOutRange_encode_xer;

/*** <<< CODE [NO-IntegerOutRange] >>> ***/

int
NO_IntegerOutRange_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
615
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
616
	unsigned long value;
617 618
	
	if(!sptr) {
619
		ASN__CTFAIL(app_key, td, sptr,
620 621 622 623 624
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
625
	value = *(const unsigned long *)sptr;
626
	
627
	if((value >= 3000000000 && value <= 3000000001)) {
628 629 630
		/* Constraint check succeeded */
		return 0;
	} else {
631
		ASN__CTFAIL(app_key, td, sptr,
632 633 634 635 636 637 638
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
639
 * This type is implemented using NativeInteger,
640 641 642 643 644
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/

645
static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutRange_specs_1 = {
646 647 648 649
	0,	0,	0,	0,	0,
	0,	/* Native long size */
	1	/* Unsigned representation */
};
650
static const ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
651 652 653 654 655
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
	"NO-IntegerOutRange",
	"NO-IntegerOutRange",
656
	&asn_OP_NativeInteger,
657
	NO_IntegerOutRange_constraint,
Lev Walkin's avatar
Lev Walkin committed
658 659 660 661 662 663
	asn_DEF_NO_IntegerOutRange_tags_1,
	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerOutRange_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
		/sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
664
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
665
	0,	/* No PER visible constraints */
666
	0, 0,	/* No members */
667
	&asn_SPC_NO_IntegerOutRange_specs_1	/* Additional specs */
668 669 670 671 672
};


/*** <<< INCLUDES [NO-IntegerOutValue] >>> ***/

673
#include <NativeInteger.h>
674 675 676

/*** <<< TYPE-DECLS [NO-IntegerOutValue] >>> ***/

677
typedef unsigned long	 NO_IntegerOutValue_t;
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693

/*** <<< FUNC-DECLS [NO-IntegerOutValue] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue;
asn_struct_free_f NO_IntegerOutValue_free;
asn_struct_print_f NO_IntegerOutValue_print;
asn_constr_check_f NO_IntegerOutValue_constraint;
ber_type_decoder_f NO_IntegerOutValue_decode_ber;
der_type_encoder_f NO_IntegerOutValue_encode_der;
xer_type_decoder_f NO_IntegerOutValue_decode_xer;
xer_type_encoder_f NO_IntegerOutValue_encode_xer;

/*** <<< CODE [NO-IntegerOutValue] >>> ***/

int
NO_IntegerOutValue_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
694
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
695
	unsigned long value;
696 697
	
	if(!sptr) {
698
		ASN__CTFAIL(app_key, td, sptr,
699 700 701 702 703
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
704
	value = *(const unsigned long *)sptr;
705
	
706
	if((value == 3000000000)) {
707 708 709
		/* Constraint check succeeded */
		return 0;
	} else {
710
		ASN__CTFAIL(app_key, td, sptr,
711 712 713 714 715 716 717
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
718
 * This type is implemented using NativeInteger,
719 720 721 722 723
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/

724
static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutValue_specs_1 = {
725 726 727 728
	0,	0,	0,	0,	0,
	0,	/* Native long size */
	1	/* Unsigned representation */
};
729
static const ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
730 731 732 733 734
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
	"NO-IntegerOutValue",
	"NO-IntegerOutValue",
735
	&asn_OP_NativeInteger,
736
	NO_IntegerOutValue_constraint,
Lev Walkin's avatar
Lev Walkin committed
737 738 739 740 741 742
	asn_DEF_NO_IntegerOutValue_tags_1,
	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerOutValue_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
		/sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
743
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
744
	0,	/* No PER visible constraints */
745
	0, 0,	/* No members */
746
	&asn_SPC_NO_IntegerOutValue_specs_1	/* Additional specs */
747 748 749 750 751
};


/*** <<< INCLUDES [OK-IntegerInRange1] >>> ***/

752
#include <NativeInteger.h>
753 754 755

/*** <<< TYPE-DECLS [OK-IntegerInRange1] >>> ***/

756
typedef long	 OK_IntegerInRange1_t;
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772

/*** <<< FUNC-DECLS [OK-IntegerInRange1] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1;
asn_struct_free_f OK_IntegerInRange1_free;
asn_struct_print_f OK_IntegerInRange1_print;
asn_constr_check_f OK_IntegerInRange1_constraint;
ber_type_decoder_f OK_IntegerInRange1_decode_ber;
der_type_encoder_f OK_IntegerInRange1_encode_der;
xer_type_decoder_f OK_IntegerInRange1_decode_xer;
xer_type_encoder_f OK_IntegerInRange1_encode_xer;

/*** <<< CODE [OK-IntegerInRange1] >>> ***/

int
OK_IntegerInRange1_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
773
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
774 775 776
	long value;
	
	if(!sptr) {
777
		ASN__CTFAIL(app_key, td, sptr,
778 779 780 781 782
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
783
	value = *(const long *)sptr;
784 785 786 787 788
	
	if((value >= -100 && value <= 100)) {
		/* Constraint check succeeded */
		return 0;
	} else {
789
		ASN__CTFAIL(app_key, td, sptr,
790 791 792 793 794 795 796
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
797
 * This type is implemented using NativeInteger,
798 799 800 801 802
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [OK-IntegerInRange1] >>> ***/

803
static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_tags_1[] = {
804 805 806 807 808
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
	"OK-IntegerInRange1",
	"OK-IntegerInRange1",
809
	&asn_OP_NativeInteger,
810
	OK_IntegerInRange1_constraint,
Lev Walkin's avatar
Lev Walkin committed
811 812 813 814 815 816
	asn_DEF_OK_IntegerInRange1_tags_1,
	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
	asn_DEF_OK_IntegerInRange1_tags_1,	/* Same as above */
	sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
817
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
818
	0,	/* No PER visible constraints */
819 820 821 822 823 824 825
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [OK-IntegerInRange2] >>> ***/

826
#include <NativeInteger.h>
827 828 829

/*** <<< TYPE-DECLS [OK-IntegerInRange2] >>> ***/

830
typedef long	 OK_IntegerInRange2_t;
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846

/*** <<< FUNC-DECLS [OK-IntegerInRange2] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2;
asn_struct_free_f OK_IntegerInRange2_free;
asn_struct_print_f OK_IntegerInRange2_print;
asn_constr_check_f OK_IntegerInRange2_constraint;
ber_type_decoder_f OK_IntegerInRange2_decode_ber;
der_type_encoder_f OK_IntegerInRange2_encode_der;
xer_type_decoder_f OK_IntegerInRange2_decode_xer;
xer_type_encoder_f OK_IntegerInRange2_encode_xer;

/*** <<< CODE [OK-IntegerInRange2] >>> ***/

int
OK_IntegerInRange2_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
847
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
848 849 850
	long value;
	
	if(!sptr) {
851
		ASN__CTFAIL(app_key, td, sptr,
852 853 854 855 856
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
857
	value = *(const long *)sptr;
858 859 860 861 862
	
	if(((value == -100) || (value == 100))) {
		/* Constraint check succeeded */
		return 0;
	} else {
863
		ASN__CTFAIL(app_key, td, sptr,
864 865 866 867 868 869 870
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
871
 * This type is implemented using NativeInteger,
872 873 874 875 876
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [OK-IntegerInRange2] >>> ***/

877
static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_tags_1[] = {
878 879 880 881 882
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
	"OK-IntegerInRange2",
	"OK-IntegerInRange2",
883
	&asn_OP_NativeInteger,
884
	OK_IntegerInRange2_constraint,
Lev Walkin's avatar
Lev Walkin committed
885 886 887 888 889 890
	asn_DEF_OK_IntegerInRange2_tags_1,
	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
	asn_DEF_OK_IntegerInRange2_tags_1,	/* Same as above */
	sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
891
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
892
	0,	/* No PER visible constraints */
893 894 895 896 897 898 899
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [OK-IntegerInRange3] >>> ***/

900
#include <NativeInteger.h>
901 902 903

/*** <<< TYPE-DECLS [OK-IntegerInRange3] >>> ***/

904
typedef long	 OK_IntegerInRange3_t;
905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920

/*** <<< FUNC-DECLS [OK-IntegerInRange3] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3;
asn_struct_free_f OK_IntegerInRange3_free;
asn_struct_print_f OK_IntegerInRange3_print;
asn_constr_check_f OK_IntegerInRange3_constraint;
ber_type_decoder_f OK_IntegerInRange3_decode_ber;
der_type_encoder_f OK_IntegerInRange3_encode_der;
xer_type_decoder_f OK_IntegerInRange3_decode_xer;
xer_type_encoder_f OK_IntegerInRange3_encode_xer;

/*** <<< CODE [OK-IntegerInRange3] >>> ***/

int
OK_IntegerInRange3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
921
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
922 923 924
	long value;
	
	if(!sptr) {
925
		ASN__CTFAIL(app_key, td, sptr,
926 927 928 929 930
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
931
	value = *(const long *)sptr;
932
	
Lev Walkin's avatar
Lev Walkin committed
933
	if((value >= (-2147483647L - 1) && value <= 2147483647)) {
934 935 936
		/* Constraint check succeeded */
		return 0;
	} else {
937
		ASN__CTFAIL(app_key, td, sptr,
938 939 940 941 942 943 944
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
945
 * This type is implemented using NativeInteger,
946 947 948 949 950
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [OK-IntegerInRange3] >>> ***/

951
static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_tags_1[] = {
952 953 954 955 956
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
	"OK-IntegerInRange3",
	"OK-IntegerInRange3",
957
	&asn_OP_NativeInteger,
958
	OK_IntegerInRange3_constraint,
Lev Walkin's avatar
Lev Walkin committed
959 960 961 962 963 964
	asn_DEF_OK_IntegerInRange3_tags_1,
	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
	asn_DEF_OK_IntegerInRange3_tags_1,	/* Same as above */
	sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
965
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
966
	0,	/* No PER visible constraints */
967 968 969 970 971 972 973
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [OK-IntegerInRange4] >>> ***/

974
#include <NativeInteger.h>
975 976 977

/*** <<< TYPE-DECLS [OK-IntegerInRange4] >>> ***/

978
typedef long	 OK_IntegerInRange4_t;
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994

/*** <<< FUNC-DECLS [OK-IntegerInRange4] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4;
asn_struct_free_f OK_IntegerInRange4_free;
asn_struct_print_f OK_IntegerInRange4_print;
asn_constr_check_f OK_IntegerInRange4_constraint;
ber_type_decoder_f OK_IntegerInRange4_decode_ber;
der_type_encoder_f OK_IntegerInRange4_encode_der;
xer_type_decoder_f OK_IntegerInRange4_decode_xer;
xer_type_encoder_f OK_IntegerInRange4_encode_xer;

/*** <<< CODE [OK-IntegerInRange4] >>> ***/

int
OK_IntegerInRange4_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
995
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
996 997 998
	long value;
	
	if(!sptr) {
999
		ASN__CTFAIL(app_key, td, sptr,
1000 1001 1002 1003 1004
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
1005
	value = *(const long *)sptr;
1006
	
Lev Walkin's avatar
Lev Walkin committed
1007
	if(((value == (-2147483647L - 1)) || (value == 2147483647))) {
1008 1009 1010
		/* Constraint check succeeded */
		return 0;
	} else {
1011
		ASN__CTFAIL(app_key, td, sptr,
1012 1013 1014 1015 1016 1017 1018
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
1019
 * This type is implemented using NativeInteger,
1020 1021 1022 1023 1024
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [OK-IntegerInRange4] >>> ***/

1025
static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_tags_1[] = {
1026 1027 1028 1029 1030
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
	"OK-IntegerInRange4",
	"OK-IntegerInRange4",
1031
	&asn_OP_NativeInteger,
1032
	OK_IntegerInRange4_constraint,
Lev Walkin's avatar
Lev Walkin committed
1033 1034 1035 1036 1037 1038
	asn_DEF_OK_IntegerInRange4_tags_1,
	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
	asn_DEF_OK_IntegerInRange4_tags_1,	/* Same as above */
	sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
1039
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
1040
	0,	/* No PER visible constraints */
1041 1042 1043 1044 1045 1046 1047
	0, 0,	/* No members */
	0	/* No specifics */
};


/*** <<< INCLUDES [OK-IntegerInRange5] >>> ***/

1048
#include <NativeInteger.h>
1049 1050 1051

/*** <<< TYPE-DECLS [OK-IntegerInRange5] >>> ***/

1052
typedef long	 OK_IntegerInRange5_t;
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068

/*** <<< FUNC-DECLS [OK-IntegerInRange5] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5;
asn_struct_free_f OK_IntegerInRange5_free;
asn_struct_print_f OK_IntegerInRange5_print;
asn_constr_check_f OK_IntegerInRange5_constraint;
ber_type_decoder_f OK_IntegerInRange5_decode_ber;
der_type_encoder_f OK_IntegerInRange5_encode_der;
xer_type_decoder_f OK_IntegerInRange5_decode_xer;
xer_type_encoder_f OK_IntegerInRange5_encode_xer;

/*** <<< CODE [OK-IntegerInRange5] >>> ***/

int
OK_IntegerInRange5_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
1069
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1070 1071 1072
	long value;
	
	if(!sptr) {
1073
		ASN__CTFAIL(app_key, td, sptr,
1074 1075 1076 1077 1078
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
1079
	value = *(const long *)sptr;
1080
	
Lev Walkin's avatar
Lev Walkin committed
1081
	if(((value == (-2147483647L - 1)) || (value == 2147483647))) {
1082 1083 1084
		/* Constraint check succeeded */
		return 0;
	} else {
1085
		ASN__CTFAIL(app_key, td, sptr,
1086 1087 1088 1089 1090 1091 1092
			"%s: constraint failed (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
}

/*
1093
 * This type is implemented using NativeInteger,
1094 1095 1096 1097 1098
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [OK-IntegerInRange5] >>> ***/

1099
static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_tags_1[] = {
1100 1101 1102 1103 1104
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
	"OK-IntegerInRange5",
	"OK-IntegerInRange5",
1105
	&asn_OP_NativeInteger,
1106
	OK_IntegerInRange5_constraint,
Lev Walkin's avatar
Lev Walkin committed
1107 1108 1109 1110 1111 1112
	asn_DEF_OK_IntegerInRange5_tags_1,
	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
	asn_DEF_OK_IntegerInRange5_tags_1,	/* Same as above */
	sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
		/sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
1113
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
1114
	0,	/* No PER visible constraints */
1115 1116 1117 1118
	0, 0,	/* No members */
	0	/* No specifics */
};

1119

Lev Walkin's avatar
Lev Walkin committed
1120 1121
/*** <<< INCLUDES [NO-IntegerInRange6] >>> ***/

1122
#include <NativeInteger.h>
Lev Walkin's avatar
Lev Walkin committed
1123 1124 1125

/*** <<< TYPE-DECLS [NO-IntegerInRange6] >>> ***/

1126
typedef unsigned long	 NO_IntegerInRange6_t;
Lev Walkin's avatar
Lev Walkin committed
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142

/*** <<< FUNC-DECLS [NO-IntegerInRange6] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6;
asn_struct_free_f NO_IntegerInRange6_free;
asn_struct_print_f NO_IntegerInRange6_print;
asn_constr_check_f NO_IntegerInRange6_constraint;
ber_type_decoder_f NO_IntegerInRange6_decode_ber;
der_type_encoder_f NO_IntegerInRange6_encode_der;
xer_type_decoder_f NO_IntegerInRange6_decode_xer;
xer_type_encoder_f NO_IntegerInRange6_encode_xer;

/*** <<< CODE [NO-IntegerInRange6] >>> ***/

int
NO_IntegerInRange6_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
Lev Walkin's avatar
Lev Walkin committed
1143
			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
Lev Walkin's avatar
Lev Walkin committed
1144 1145
	
	if(!sptr) {
1146
		ASN__CTFAIL(app_key, td, sptr,
Lev Walkin's avatar
Lev Walkin committed
1147 1148 1149 1150 1151 1152
			"%s: value not given (%s:%d)",
			td->name, __FILE__, __LINE__);
		return -1;
	}
	
	
1153 1154
	/* Constraint check succeeded */
	return 0;
Lev Walkin's avatar
Lev Walkin committed
1155 1156 1157
}

/*
1158
 * This type is implemented using NativeInteger,
Lev Walkin's avatar
Lev Walkin committed
1159 1160 1161 1162 1163
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/

1164
static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerInRange6_specs_1 = {
1165 1166 1167 1168
	0,	0,	0,	0,	0,
	0,	/* Native long size */
	1	/* Unsigned representation */
};
1169
static const ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
Lev Walkin's avatar
Lev Walkin committed
1170 1171 1172 1173 1174
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
	"NO-IntegerInRange6",
	"NO-IntegerInRange6",
1175
	&asn_OP_NativeInteger,
Lev Walkin's avatar
Lev Walkin committed
1176
	NO_IntegerInRange6_constraint,
Lev Walkin's avatar
Lev Walkin committed
1177 1178 1179 1180 1181 1182
	asn_DEF_NO_IntegerInRange6_tags_1,
	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerInRange6_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
		/sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
1183
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
1184
	0,	/* No PER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
1185
	0, 0,	/* No members */
1186
	&asn_SPC_NO_IntegerInRange6_specs_1	/* Additional specs */
Lev Walkin's avatar
Lev Walkin committed
1187 1188 1189
};


1190 1191
/*** <<< INCLUDES [CN-IntegerEnumerated1] >>> ***/

1192
#include <NativeInteger.h>
1193 1194 1195 1196 1197 1198

/*** <<< DEPS [CN-IntegerEnumerated1] >>> ***/

typedef enum CN_IntegerEnumerated1 {
	CN_IntegerEnumerated1_a	= 1,
	CN_IntegerEnumerated1_b	= 2
Lev Walkin's avatar
Lev Walkin committed
1199
} e_CN_IntegerEnumerated1;
1200 1201 1202

/*** <<< TYPE-DECLS [CN-IntegerEnumerated1] >>> ***/

1203
typedef long	 CN_IntegerEnumerated1_t;
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218

/*** <<< FUNC-DECLS [CN-IntegerEnumerated1] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1;
asn_struct_free_f CN_IntegerEnumerated1_free;
asn_struct_print_f CN_IntegerEnumerated1_print;
asn_constr_check_f CN_IntegerEnumerated1_constraint;
ber_type_decoder_f CN_IntegerEnumerated1_decode_ber;
der_type_encoder_f CN_IntegerEnumerated1_encode_der;
xer_type_decoder_f CN_IntegerEnumerated1_decode_xer;
xer_type_encoder_f CN_IntegerEnumerated1_encode_xer;

/*** <<< CODE [CN-IntegerEnumerated1] >>> ***/

/*
1219
 * This type is implemented using NativeInteger,
1220 1221 1222 1223 1224
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [CN-IntegerEnumerated1] >>> ***/

1225
static const ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_tags_1[] = {
1226 1227 1228 1229 1230
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1 = {
	"CN-IntegerEnumerated1",
	"CN-IntegerEnumerated1",
1231
	&asn_OP_NativeInteger,
1232
	NativeInteger_constraint,
Lev Walkin's avatar
Lev Walkin committed
1233 1234 1235 1236 1237 1238
	asn_DEF_CN_IntegerEnumerated1_tags_1,
	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
	asn_DEF_CN_IntegerEnumerated1_tags_1,	/* Same as above */
	sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
		/sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
1239
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
1240
	0,	/* No PER visible constraints */
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
	0, 0,	/* Defined elsewhere */
	0	/* No specifics */
};


/*** <<< INCLUDES [NO-IntegerEnumerated2] >>> ***/

#include <INTEGER.h>

/*** <<< DEPS [NO-IntegerEnumerated2] >>> ***/

typedef enum NO_IntegerEnumerated2 {
	NO_IntegerEnumerated2_a	= 1,
	NO_IntegerEnumerated2_b	= 3000000000
Lev Walkin's avatar
Lev Walkin committed
1255
} e_NO_IntegerEnumerated2;
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280

/*** <<< TYPE-DECLS [NO-IntegerEnumerated2] >>> ***/

typedef INTEGER_t	 NO_IntegerEnumerated2_t;

/*** <<< FUNC-DECLS [NO-IntegerEnumerated2] >>> ***/

extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2;
asn_struct_free_f NO_IntegerEnumerated2_free;
asn_struct_print_f NO_IntegerEnumerated2_print;
asn_constr_check_f NO_IntegerEnumerated2_constraint;
ber_type_decoder_f NO_IntegerEnumerated2_decode_ber;
der_type_encoder_f NO_IntegerEnumerated2_encode_der;
xer_type_decoder_f NO_IntegerEnumerated2_decode_xer;
xer_type_encoder_f NO_IntegerEnumerated2_encode_xer;

/*** <<< CODE [NO-IntegerEnumerated2] >>> ***/

/*
 * This type is implemented using INTEGER,
 * so here we adjust the DEF accordingly.
 */

/*** <<< STAT-DEFS [NO-IntegerEnumerated2] >>> ***/

1281
static const ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_tags_1[] = {
1282 1283 1284 1285 1286
	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
};
asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2 = {
	"NO-IntegerEnumerated2",
	"NO-IntegerEnumerated2",
1287
	&asn_OP_INTEGER,
1288
	INTEGER_constraint,
Lev Walkin's avatar
Lev Walkin committed
1289 1290 1291 1292 1293 1294
	asn_DEF_NO_IntegerEnumerated2_tags_1,
	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
	asn_DEF_NO_IntegerEnumerated2_tags_1,	/* Same as above */
	sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
		/sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
Lev Walkin's avatar
Lev Walkin committed
1295
	0,	/* No OER visible constraints */
Lev Walkin's avatar
Lev Walkin committed
1296
	0,	/* No PER visible constraints */
1297 1298 1299 1300
	0, 0,	/* Defined elsewhere */
	0	/* No specifics */
};