2 /*** <<< INCLUDES [CN-IntegerUnlimited] >>> ***/
4 #include <NativeInteger.h>
6 /*** <<< TYPE-DECLS [CN-IntegerUnlimited] >>> ***/
8 typedef long CN_IntegerUnlimited_t;
10 /*** <<< FUNC-DECLS [CN-IntegerUnlimited] >>> ***/
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 per_type_decoder_f CN_IntegerUnlimited_decode_uper;
21 per_type_encoder_f CN_IntegerUnlimited_encode_uper;
22 per_type_decoder_f CN_IntegerUnlimited_decode_aper;
23 per_type_encoder_f CN_IntegerUnlimited_encode_aper;
25 /*** <<< CODE [CN-IntegerUnlimited] >>> ***/
28 * This type is implemented using NativeInteger,
29 * so here we adjust the DEF accordingly.
32 /*** <<< STAT-DEFS [CN-IntegerUnlimited] >>> ***/
34 static const ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_tags_1[] = {
35 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
37 asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
38 "CN-IntegerUnlimited",
39 "CN-IntegerUnlimited",
40 &asn_OP_NativeInteger,
41 asn_DEF_CN_IntegerUnlimited_tags_1,
42 sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
43 /sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
44 asn_DEF_CN_IntegerUnlimited_tags_1, /* Same as above */
45 sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
46 /sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
47 { 0, 0, NativeInteger_constraint },
48 0, 0, /* No members */
53 /*** <<< INCLUDES [CN-IntegerMinMax] >>> ***/
55 #include <NativeInteger.h>
57 /*** <<< TYPE-DECLS [CN-IntegerMinMax] >>> ***/
59 typedef long CN_IntegerMinMax_t;
61 /*** <<< FUNC-DECLS [CN-IntegerMinMax] >>> ***/
63 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax;
64 asn_struct_free_f CN_IntegerMinMax_free;
65 asn_struct_print_f CN_IntegerMinMax_print;
66 asn_constr_check_f CN_IntegerMinMax_constraint;
67 ber_type_decoder_f CN_IntegerMinMax_decode_ber;
68 der_type_encoder_f CN_IntegerMinMax_encode_der;
69 xer_type_decoder_f CN_IntegerMinMax_decode_xer;
70 xer_type_encoder_f CN_IntegerMinMax_encode_xer;
71 per_type_decoder_f CN_IntegerMinMax_decode_uper;
72 per_type_encoder_f CN_IntegerMinMax_encode_uper;
73 per_type_decoder_f CN_IntegerMinMax_decode_aper;
74 per_type_encoder_f CN_IntegerMinMax_encode_aper;
76 /*** <<< CODE [CN-IntegerMinMax] >>> ***/
79 CN_IntegerMinMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
80 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
83 ASN__CTFAIL(app_key, td, sptr,
84 "%s: value not given (%s:%d)",
85 td->name, __FILE__, __LINE__);
90 if(1 /* No applicable constraints whatsoever */) {
91 /* Nothing is here. See below */
94 return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
98 * This type is implemented using NativeInteger,
99 * so here we adjust the DEF accordingly.
102 /*** <<< CTDEFS [CN-IntegerMinMax] >>> ***/
104 static asn_per_constraints_t asn_PER_type_CN_IntegerMinMax_constr_1 CC_NOTUSED = {
105 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
106 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
107 0, 0 /* No PER value map */
110 /*** <<< STAT-DEFS [CN-IntegerMinMax] >>> ***/
112 static const ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_tags_1[] = {
113 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
115 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
118 &asn_OP_NativeInteger,
119 asn_DEF_CN_IntegerMinMax_tags_1,
120 sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
121 /sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
122 asn_DEF_CN_IntegerMinMax_tags_1, /* Same as above */
123 sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
124 /sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
125 { 0, &asn_PER_type_CN_IntegerMinMax_constr_1, CN_IntegerMinMax_constraint },
126 0, 0, /* No members */
131 /*** <<< INCLUDES [CN-IntegerMinLow] >>> ***/
133 #include <NativeInteger.h>
135 /*** <<< TYPE-DECLS [CN-IntegerMinLow] >>> ***/
137 typedef long CN_IntegerMinLow_t;
139 /*** <<< FUNC-DECLS [CN-IntegerMinLow] >>> ***/
141 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow;
142 asn_struct_free_f CN_IntegerMinLow_free;
143 asn_struct_print_f CN_IntegerMinLow_print;
144 asn_constr_check_f CN_IntegerMinLow_constraint;
145 ber_type_decoder_f CN_IntegerMinLow_decode_ber;
146 der_type_encoder_f CN_IntegerMinLow_encode_der;
147 xer_type_decoder_f CN_IntegerMinLow_decode_xer;
148 xer_type_encoder_f CN_IntegerMinLow_encode_xer;
149 per_type_decoder_f CN_IntegerMinLow_decode_uper;
150 per_type_encoder_f CN_IntegerMinLow_encode_uper;
151 per_type_decoder_f CN_IntegerMinLow_decode_aper;
152 per_type_encoder_f CN_IntegerMinLow_encode_aper;
154 /*** <<< CODE [CN-IntegerMinLow] >>> ***/
157 CN_IntegerMinLow_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
158 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
162 ASN__CTFAIL(app_key, td, sptr,
163 "%s: value not given (%s:%d)",
164 td->name, __FILE__, __LINE__);
168 value = *(const long *)sptr;
171 /* Constraint check succeeded */
174 ASN__CTFAIL(app_key, td, sptr,
175 "%s: constraint failed (%s:%d)",
176 td->name, __FILE__, __LINE__);
182 * This type is implemented using NativeInteger,
183 * so here we adjust the DEF accordingly.
186 /*** <<< CTDEFS [CN-IntegerMinLow] >>> ***/
188 static asn_per_constraints_t asn_PER_type_CN_IntegerMinLow_constr_1 CC_NOTUSED = {
189 { APC_UNCONSTRAINED, -1, -1, 0, 0 } /* (MIN..1) */,
190 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
191 0, 0 /* No PER value map */
194 /*** <<< STAT-DEFS [CN-IntegerMinLow] >>> ***/
196 static const ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_tags_1[] = {
197 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
199 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
202 &asn_OP_NativeInteger,
203 asn_DEF_CN_IntegerMinLow_tags_1,
204 sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
205 /sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
206 asn_DEF_CN_IntegerMinLow_tags_1, /* Same as above */
207 sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
208 /sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
209 { 0, &asn_PER_type_CN_IntegerMinLow_constr_1, CN_IntegerMinLow_constraint },
210 0, 0, /* No members */
215 /*** <<< INCLUDES [NO-IntegerMinHigh] >>> ***/
219 /*** <<< TYPE-DECLS [NO-IntegerMinHigh] >>> ***/
221 typedef INTEGER_t NO_IntegerMinHigh_t;
223 /*** <<< FUNC-DECLS [NO-IntegerMinHigh] >>> ***/
225 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh;
226 asn_struct_free_f NO_IntegerMinHigh_free;
227 asn_struct_print_f NO_IntegerMinHigh_print;
228 asn_constr_check_f NO_IntegerMinHigh_constraint;
229 ber_type_decoder_f NO_IntegerMinHigh_decode_ber;
230 der_type_encoder_f NO_IntegerMinHigh_encode_der;
231 xer_type_decoder_f NO_IntegerMinHigh_decode_xer;
232 xer_type_encoder_f NO_IntegerMinHigh_encode_xer;
233 per_type_decoder_f NO_IntegerMinHigh_decode_uper;
234 per_type_encoder_f NO_IntegerMinHigh_encode_uper;
235 per_type_decoder_f NO_IntegerMinHigh_decode_aper;
236 per_type_encoder_f NO_IntegerMinHigh_encode_aper;
238 /*** <<< CODE [NO-IntegerMinHigh] >>> ***/
241 NO_IntegerMinHigh_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
242 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
243 const INTEGER_t *st = (const INTEGER_t *)sptr;
247 ASN__CTFAIL(app_key, td, sptr,
248 "%s: value not given (%s:%d)",
249 td->name, __FILE__, __LINE__);
253 if(asn_INTEGER2long(st, &value)) {
254 ASN__CTFAIL(app_key, td, sptr,
255 "%s: value too large (%s:%d)",
256 td->name, __FILE__, __LINE__);
260 if((value <= 3000000000)) {
261 /* Constraint check succeeded */
264 ASN__CTFAIL(app_key, td, sptr,
265 "%s: constraint failed (%s:%d)",
266 td->name, __FILE__, __LINE__);
272 * This type is implemented using INTEGER,
273 * so here we adjust the DEF accordingly.
276 /*** <<< CTDEFS [NO-IntegerMinHigh] >>> ***/
278 static asn_per_constraints_t asn_PER_type_NO_IntegerMinHigh_constr_1 CC_NOTUSED = {
279 { APC_UNCONSTRAINED, -1, -1, 0, 0 } /* (MIN..3000000000) */,
280 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
281 0, 0 /* No PER value map */
284 /*** <<< STAT-DEFS [NO-IntegerMinHigh] >>> ***/
286 static const ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_tags_1[] = {
287 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
289 asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
293 asn_DEF_NO_IntegerMinHigh_tags_1,
294 sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
295 /sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
296 asn_DEF_NO_IntegerMinHigh_tags_1, /* Same as above */
297 sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
298 /sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
299 { 0, &asn_PER_type_NO_IntegerMinHigh_constr_1, NO_IntegerMinHigh_constraint },
300 0, 0, /* No members */
305 /*** <<< INCLUDES [NO-IntegerLowHigh] >>> ***/
307 #include <NativeInteger.h>
309 /*** <<< TYPE-DECLS [NO-IntegerLowHigh] >>> ***/
311 typedef unsigned long NO_IntegerLowHigh_t;
313 /*** <<< FUNC-DECLS [NO-IntegerLowHigh] >>> ***/
315 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh;
316 asn_struct_free_f NO_IntegerLowHigh_free;
317 asn_struct_print_f NO_IntegerLowHigh_print;
318 asn_constr_check_f NO_IntegerLowHigh_constraint;
319 ber_type_decoder_f NO_IntegerLowHigh_decode_ber;
320 der_type_encoder_f NO_IntegerLowHigh_encode_der;
321 xer_type_decoder_f NO_IntegerLowHigh_decode_xer;
322 xer_type_encoder_f NO_IntegerLowHigh_encode_xer;
323 per_type_decoder_f NO_IntegerLowHigh_decode_uper;
324 per_type_encoder_f NO_IntegerLowHigh_encode_uper;
325 per_type_decoder_f NO_IntegerLowHigh_decode_aper;
326 per_type_encoder_f NO_IntegerLowHigh_encode_aper;
328 /*** <<< CODE [NO-IntegerLowHigh] >>> ***/
331 NO_IntegerLowHigh_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
332 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
336 ASN__CTFAIL(app_key, td, sptr,
337 "%s: value not given (%s:%d)",
338 td->name, __FILE__, __LINE__);
342 value = *(const unsigned long *)sptr;
344 if((value >= 1 && value <= 3000000000)) {
345 /* Constraint check succeeded */
348 ASN__CTFAIL(app_key, td, sptr,
349 "%s: constraint failed (%s:%d)",
350 td->name, __FILE__, __LINE__);
356 * This type is implemented using NativeInteger,
357 * so here we adjust the DEF accordingly.
360 /*** <<< CTDEFS [NO-IntegerLowHigh] >>> ***/
362 static asn_per_constraints_t asn_PER_type_NO_IntegerLowHigh_constr_1 CC_NOTUSED = {
363 { APC_CONSTRAINED, 32, -1, 1, 3000000000 } /* (1..3000000000) */,
364 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
365 0, 0 /* No PER value map */
368 /*** <<< STAT-DEFS [NO-IntegerLowHigh] >>> ***/
370 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerLowHigh_specs_1 = {
372 0, /* Native long size */
373 1 /* Unsigned representation */
375 static const ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_tags_1[] = {
376 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
378 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
381 &asn_OP_NativeInteger,
382 asn_DEF_NO_IntegerLowHigh_tags_1,
383 sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
384 /sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
385 asn_DEF_NO_IntegerLowHigh_tags_1, /* Same as above */
386 sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
387 /sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
388 { 0, &asn_PER_type_NO_IntegerLowHigh_constr_1, NO_IntegerLowHigh_constraint },
389 0, 0, /* No members */
390 &asn_SPC_NO_IntegerLowHigh_specs_1 /* Additional specs */
394 /*** <<< INCLUDES [CN-IntegerLowMax] >>> ***/
396 #include <NativeInteger.h>
398 /*** <<< TYPE-DECLS [CN-IntegerLowMax] >>> ***/
400 typedef unsigned long CN_IntegerLowMax_t;
402 /*** <<< FUNC-DECLS [CN-IntegerLowMax] >>> ***/
404 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax;
405 asn_struct_free_f CN_IntegerLowMax_free;
406 asn_struct_print_f CN_IntegerLowMax_print;
407 asn_constr_check_f CN_IntegerLowMax_constraint;
408 ber_type_decoder_f CN_IntegerLowMax_decode_ber;
409 der_type_encoder_f CN_IntegerLowMax_encode_der;
410 xer_type_decoder_f CN_IntegerLowMax_decode_xer;
411 xer_type_encoder_f CN_IntegerLowMax_encode_xer;
412 per_type_decoder_f CN_IntegerLowMax_decode_uper;
413 per_type_encoder_f CN_IntegerLowMax_encode_uper;
414 per_type_decoder_f CN_IntegerLowMax_decode_aper;
415 per_type_encoder_f CN_IntegerLowMax_encode_aper;
417 /*** <<< CODE [CN-IntegerLowMax] >>> ***/
420 CN_IntegerLowMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
421 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
425 ASN__CTFAIL(app_key, td, sptr,
426 "%s: value not given (%s:%d)",
427 td->name, __FILE__, __LINE__);
431 value = *(const unsigned long *)sptr;
434 /* Constraint check succeeded */
437 ASN__CTFAIL(app_key, td, sptr,
438 "%s: constraint failed (%s:%d)",
439 td->name, __FILE__, __LINE__);
445 * This type is implemented using NativeInteger,
446 * so here we adjust the DEF accordingly.
449 /*** <<< CTDEFS [CN-IntegerLowMax] >>> ***/
451 static asn_per_constraints_t asn_PER_type_CN_IntegerLowMax_constr_1 CC_NOTUSED = {
452 { APC_SEMI_CONSTRAINED, -1, -1, 1, 0 } /* (1..MAX) */,
453 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
454 0, 0 /* No PER value map */
457 /*** <<< STAT-DEFS [CN-IntegerLowMax] >>> ***/
459 static const asn_INTEGER_specifics_t asn_SPC_CN_IntegerLowMax_specs_1 = {
461 0, /* Native long size */
462 1 /* Unsigned representation */
464 static const ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_tags_1[] = {
465 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
467 asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
470 &asn_OP_NativeInteger,
471 asn_DEF_CN_IntegerLowMax_tags_1,
472 sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
473 /sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
474 asn_DEF_CN_IntegerLowMax_tags_1, /* Same as above */
475 sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
476 /sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
477 { 0, &asn_PER_type_CN_IntegerLowMax_constr_1, CN_IntegerLowMax_constraint },
478 0, 0, /* No members */
479 &asn_SPC_CN_IntegerLowMax_specs_1 /* Additional specs */
483 /*** <<< INCLUDES [NO-IntegerHighMax] >>> ***/
487 /*** <<< TYPE-DECLS [NO-IntegerHighMax] >>> ***/
489 typedef INTEGER_t NO_IntegerHighMax_t;
491 /*** <<< FUNC-DECLS [NO-IntegerHighMax] >>> ***/
493 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax;
494 asn_struct_free_f NO_IntegerHighMax_free;
495 asn_struct_print_f NO_IntegerHighMax_print;
496 asn_constr_check_f NO_IntegerHighMax_constraint;
497 ber_type_decoder_f NO_IntegerHighMax_decode_ber;
498 der_type_encoder_f NO_IntegerHighMax_encode_der;
499 xer_type_decoder_f NO_IntegerHighMax_decode_xer;
500 xer_type_encoder_f NO_IntegerHighMax_encode_xer;
501 per_type_decoder_f NO_IntegerHighMax_decode_uper;
502 per_type_encoder_f NO_IntegerHighMax_encode_uper;
503 per_type_decoder_f NO_IntegerHighMax_decode_aper;
504 per_type_encoder_f NO_IntegerHighMax_encode_aper;
506 /*** <<< CODE [NO-IntegerHighMax] >>> ***/
509 NO_IntegerHighMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
510 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
511 const INTEGER_t *st = (const INTEGER_t *)sptr;
515 ASN__CTFAIL(app_key, td, sptr,
516 "%s: value not given (%s:%d)",
517 td->name, __FILE__, __LINE__);
521 if(asn_INTEGER2long(st, &value)) {
522 ASN__CTFAIL(app_key, td, sptr,
523 "%s: value too large (%s:%d)",
524 td->name, __FILE__, __LINE__);
528 if((value >= 3000000000)) {
529 /* Constraint check succeeded */
532 ASN__CTFAIL(app_key, td, sptr,
533 "%s: constraint failed (%s:%d)",
534 td->name, __FILE__, __LINE__);
540 * This type is implemented using INTEGER,
541 * so here we adjust the DEF accordingly.
544 /*** <<< CTDEFS [NO-IntegerHighMax] >>> ***/
546 static asn_per_constraints_t asn_PER_type_NO_IntegerHighMax_constr_1 CC_NOTUSED = {
547 { APC_SEMI_CONSTRAINED, -1, -1, 3000000000, 0 } /* (3000000000..MAX) */,
548 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
549 0, 0 /* No PER value map */
552 /*** <<< STAT-DEFS [NO-IntegerHighMax] >>> ***/
554 static const ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_tags_1[] = {
555 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
557 asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
561 asn_DEF_NO_IntegerHighMax_tags_1,
562 sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
563 /sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
564 asn_DEF_NO_IntegerHighMax_tags_1, /* Same as above */
565 sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
566 /sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
567 { 0, &asn_PER_type_NO_IntegerHighMax_constr_1, NO_IntegerHighMax_constraint },
568 0, 0, /* No members */
573 /*** <<< INCLUDES [NO-IntegerLowestMax] >>> ***/
577 /*** <<< TYPE-DECLS [NO-IntegerLowestMax] >>> ***/
579 typedef INTEGER_t NO_IntegerLowestMax_t;
581 /*** <<< FUNC-DECLS [NO-IntegerLowestMax] >>> ***/
583 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax;
584 asn_struct_free_f NO_IntegerLowestMax_free;
585 asn_struct_print_f NO_IntegerLowestMax_print;
586 asn_constr_check_f NO_IntegerLowestMax_constraint;
587 ber_type_decoder_f NO_IntegerLowestMax_decode_ber;
588 der_type_encoder_f NO_IntegerLowestMax_encode_der;
589 xer_type_decoder_f NO_IntegerLowestMax_decode_xer;
590 xer_type_encoder_f NO_IntegerLowestMax_encode_xer;
591 per_type_decoder_f NO_IntegerLowestMax_decode_uper;
592 per_type_encoder_f NO_IntegerLowestMax_encode_uper;
593 per_type_decoder_f NO_IntegerLowestMax_decode_aper;
594 per_type_encoder_f NO_IntegerLowestMax_encode_aper;
596 /*** <<< CODE [NO-IntegerLowestMax] >>> ***/
599 NO_IntegerLowestMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
600 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
601 const INTEGER_t *st = (const INTEGER_t *)sptr;
605 ASN__CTFAIL(app_key, td, sptr,
606 "%s: value not given (%s:%d)",
607 td->name, __FILE__, __LINE__);
611 if(asn_INTEGER2long(st, &value)) {
612 ASN__CTFAIL(app_key, td, sptr,
613 "%s: value too large (%s:%d)",
614 td->name, __FILE__, __LINE__);
618 if((value >= -3000000000)) {
619 /* Constraint check succeeded */
622 ASN__CTFAIL(app_key, td, sptr,
623 "%s: constraint failed (%s:%d)",
624 td->name, __FILE__, __LINE__);
630 * This type is implemented using INTEGER,
631 * so here we adjust the DEF accordingly.
634 /*** <<< CTDEFS [NO-IntegerLowestMax] >>> ***/
636 static asn_per_constraints_t asn_PER_type_NO_IntegerLowestMax_constr_1 CC_NOTUSED = {
637 { APC_SEMI_CONSTRAINED, -1, -1, -3000000000, 0 } /* (-3000000000..MAX) */,
638 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
639 0, 0 /* No PER value map */
642 /*** <<< STAT-DEFS [NO-IntegerLowestMax] >>> ***/
644 static const ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_tags_1[] = {
645 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
647 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
648 "NO-IntegerLowestMax",
649 "NO-IntegerLowestMax",
651 asn_DEF_NO_IntegerLowestMax_tags_1,
652 sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
653 /sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
654 asn_DEF_NO_IntegerLowestMax_tags_1, /* Same as above */
655 sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
656 /sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
657 { 0, &asn_PER_type_NO_IntegerLowestMax_constr_1, NO_IntegerLowestMax_constraint },
658 0, 0, /* No members */
663 /*** <<< INCLUDES [NO-IntegerOutRange] >>> ***/
665 #include <NativeInteger.h>
667 /*** <<< TYPE-DECLS [NO-IntegerOutRange] >>> ***/
669 typedef unsigned long NO_IntegerOutRange_t;
671 /*** <<< FUNC-DECLS [NO-IntegerOutRange] >>> ***/
673 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange;
674 asn_struct_free_f NO_IntegerOutRange_free;
675 asn_struct_print_f NO_IntegerOutRange_print;
676 asn_constr_check_f NO_IntegerOutRange_constraint;
677 ber_type_decoder_f NO_IntegerOutRange_decode_ber;
678 der_type_encoder_f NO_IntegerOutRange_encode_der;
679 xer_type_decoder_f NO_IntegerOutRange_decode_xer;
680 xer_type_encoder_f NO_IntegerOutRange_encode_xer;
681 per_type_decoder_f NO_IntegerOutRange_decode_uper;
682 per_type_encoder_f NO_IntegerOutRange_encode_uper;
683 per_type_decoder_f NO_IntegerOutRange_decode_aper;
684 per_type_encoder_f NO_IntegerOutRange_encode_aper;
686 /*** <<< CODE [NO-IntegerOutRange] >>> ***/
689 NO_IntegerOutRange_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
690 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
694 ASN__CTFAIL(app_key, td, sptr,
695 "%s: value not given (%s:%d)",
696 td->name, __FILE__, __LINE__);
700 value = *(const unsigned long *)sptr;
702 if((value >= 3000000000 && value <= 3000000001)) {
703 /* Constraint check succeeded */
706 ASN__CTFAIL(app_key, td, sptr,
707 "%s: constraint failed (%s:%d)",
708 td->name, __FILE__, __LINE__);
714 * This type is implemented using NativeInteger,
715 * so here we adjust the DEF accordingly.
718 /*** <<< CTDEFS [NO-IntegerOutRange] >>> ***/
720 static asn_per_constraints_t asn_PER_type_NO_IntegerOutRange_constr_1 CC_NOTUSED = {
721 { APC_CONSTRAINED, 1, -1, 3000000000, 3000000001 } /* (3000000000..3000000001) */,
722 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
723 0, 0 /* No PER value map */
726 /*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
728 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutRange_specs_1 = {
730 0, /* Native long size */
731 1 /* Unsigned representation */
733 static const ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
734 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
736 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
737 "NO-IntegerOutRange",
738 "NO-IntegerOutRange",
739 &asn_OP_NativeInteger,
740 asn_DEF_NO_IntegerOutRange_tags_1,
741 sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
742 /sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
743 asn_DEF_NO_IntegerOutRange_tags_1, /* Same as above */
744 sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
745 /sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
746 { 0, &asn_PER_type_NO_IntegerOutRange_constr_1, NO_IntegerOutRange_constraint },
747 0, 0, /* No members */
748 &asn_SPC_NO_IntegerOutRange_specs_1 /* Additional specs */
752 /*** <<< INCLUDES [NO-IntegerOutValue] >>> ***/
754 #include <NativeInteger.h>
756 /*** <<< TYPE-DECLS [NO-IntegerOutValue] >>> ***/
758 typedef unsigned long NO_IntegerOutValue_t;
760 /*** <<< FUNC-DECLS [NO-IntegerOutValue] >>> ***/
762 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue;
763 asn_struct_free_f NO_IntegerOutValue_free;
764 asn_struct_print_f NO_IntegerOutValue_print;
765 asn_constr_check_f NO_IntegerOutValue_constraint;
766 ber_type_decoder_f NO_IntegerOutValue_decode_ber;
767 der_type_encoder_f NO_IntegerOutValue_encode_der;
768 xer_type_decoder_f NO_IntegerOutValue_decode_xer;
769 xer_type_encoder_f NO_IntegerOutValue_encode_xer;
770 per_type_decoder_f NO_IntegerOutValue_decode_uper;
771 per_type_encoder_f NO_IntegerOutValue_encode_uper;
772 per_type_decoder_f NO_IntegerOutValue_decode_aper;
773 per_type_encoder_f NO_IntegerOutValue_encode_aper;
775 /*** <<< CODE [NO-IntegerOutValue] >>> ***/
778 NO_IntegerOutValue_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
779 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
783 ASN__CTFAIL(app_key, td, sptr,
784 "%s: value not given (%s:%d)",
785 td->name, __FILE__, __LINE__);
789 value = *(const unsigned long *)sptr;
791 if((value == 3000000000)) {
792 /* Constraint check succeeded */
795 ASN__CTFAIL(app_key, td, sptr,
796 "%s: constraint failed (%s:%d)",
797 td->name, __FILE__, __LINE__);
803 * This type is implemented using NativeInteger,
804 * so here we adjust the DEF accordingly.
807 /*** <<< CTDEFS [NO-IntegerOutValue] >>> ***/
809 static asn_per_constraints_t asn_PER_type_NO_IntegerOutValue_constr_1 CC_NOTUSED = {
810 { APC_CONSTRAINED, 0, -1, 3000000000, 3000000000 } /* (3000000000..3000000000) */,
811 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
812 0, 0 /* No PER value map */
815 /*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
817 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutValue_specs_1 = {
819 0, /* Native long size */
820 1 /* Unsigned representation */
822 static const ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
823 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
825 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
826 "NO-IntegerOutValue",
827 "NO-IntegerOutValue",
828 &asn_OP_NativeInteger,
829 asn_DEF_NO_IntegerOutValue_tags_1,
830 sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
831 /sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
832 asn_DEF_NO_IntegerOutValue_tags_1, /* Same as above */
833 sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
834 /sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
835 { 0, &asn_PER_type_NO_IntegerOutValue_constr_1, NO_IntegerOutValue_constraint },
836 0, 0, /* No members */
837 &asn_SPC_NO_IntegerOutValue_specs_1 /* Additional specs */
841 /*** <<< INCLUDES [OK-IntegerInRange1] >>> ***/
843 #include <NativeInteger.h>
845 /*** <<< TYPE-DECLS [OK-IntegerInRange1] >>> ***/
847 typedef long OK_IntegerInRange1_t;
849 /*** <<< FUNC-DECLS [OK-IntegerInRange1] >>> ***/
851 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1;
852 asn_struct_free_f OK_IntegerInRange1_free;
853 asn_struct_print_f OK_IntegerInRange1_print;
854 asn_constr_check_f OK_IntegerInRange1_constraint;
855 ber_type_decoder_f OK_IntegerInRange1_decode_ber;
856 der_type_encoder_f OK_IntegerInRange1_encode_der;
857 xer_type_decoder_f OK_IntegerInRange1_decode_xer;
858 xer_type_encoder_f OK_IntegerInRange1_encode_xer;
859 per_type_decoder_f OK_IntegerInRange1_decode_uper;
860 per_type_encoder_f OK_IntegerInRange1_encode_uper;
861 per_type_decoder_f OK_IntegerInRange1_decode_aper;
862 per_type_encoder_f OK_IntegerInRange1_encode_aper;
864 /*** <<< CODE [OK-IntegerInRange1] >>> ***/
867 OK_IntegerInRange1_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
868 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
872 ASN__CTFAIL(app_key, td, sptr,
873 "%s: value not given (%s:%d)",
874 td->name, __FILE__, __LINE__);
878 value = *(const long *)sptr;
880 if((value >= -100 && value <= 100)) {
881 /* Constraint check succeeded */
884 ASN__CTFAIL(app_key, td, sptr,
885 "%s: constraint failed (%s:%d)",
886 td->name, __FILE__, __LINE__);
892 * This type is implemented using NativeInteger,
893 * so here we adjust the DEF accordingly.
896 /*** <<< CTDEFS [OK-IntegerInRange1] >>> ***/
898 static asn_per_constraints_t asn_PER_type_OK_IntegerInRange1_constr_1 CC_NOTUSED = {
899 { APC_CONSTRAINED, 8, 8, -100, 100 } /* (-100..100) */,
900 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
901 0, 0 /* No PER value map */
904 /*** <<< STAT-DEFS [OK-IntegerInRange1] >>> ***/
906 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_tags_1[] = {
907 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
909 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
910 "OK-IntegerInRange1",
911 "OK-IntegerInRange1",
912 &asn_OP_NativeInteger,
913 asn_DEF_OK_IntegerInRange1_tags_1,
914 sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
915 /sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
916 asn_DEF_OK_IntegerInRange1_tags_1, /* Same as above */
917 sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
918 /sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
919 { 0, &asn_PER_type_OK_IntegerInRange1_constr_1, OK_IntegerInRange1_constraint },
920 0, 0, /* No members */
925 /*** <<< INCLUDES [OK-IntegerInRange2] >>> ***/
927 #include <NativeInteger.h>
929 /*** <<< TYPE-DECLS [OK-IntegerInRange2] >>> ***/
931 typedef long OK_IntegerInRange2_t;
933 /*** <<< FUNC-DECLS [OK-IntegerInRange2] >>> ***/
935 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2;
936 asn_struct_free_f OK_IntegerInRange2_free;
937 asn_struct_print_f OK_IntegerInRange2_print;
938 asn_constr_check_f OK_IntegerInRange2_constraint;
939 ber_type_decoder_f OK_IntegerInRange2_decode_ber;
940 der_type_encoder_f OK_IntegerInRange2_encode_der;
941 xer_type_decoder_f OK_IntegerInRange2_decode_xer;
942 xer_type_encoder_f OK_IntegerInRange2_encode_xer;
943 per_type_decoder_f OK_IntegerInRange2_decode_uper;
944 per_type_encoder_f OK_IntegerInRange2_encode_uper;
945 per_type_decoder_f OK_IntegerInRange2_decode_aper;
946 per_type_encoder_f OK_IntegerInRange2_encode_aper;
948 /*** <<< CODE [OK-IntegerInRange2] >>> ***/
951 OK_IntegerInRange2_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
952 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
956 ASN__CTFAIL(app_key, td, sptr,
957 "%s: value not given (%s:%d)",
958 td->name, __FILE__, __LINE__);
962 value = *(const long *)sptr;
964 if(((value == -100) || (value == 100))) {
965 /* Constraint check succeeded */
968 ASN__CTFAIL(app_key, td, sptr,
969 "%s: constraint failed (%s:%d)",
970 td->name, __FILE__, __LINE__);
976 * This type is implemented using NativeInteger,
977 * so here we adjust the DEF accordingly.
980 /*** <<< CTDEFS [OK-IntegerInRange2] >>> ***/
982 static asn_per_constraints_t asn_PER_type_OK_IntegerInRange2_constr_1 CC_NOTUSED = {
983 { APC_CONSTRAINED, 8, 8, -100, 100 } /* (-100..100) */,
984 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
985 0, 0 /* No PER value map */
988 /*** <<< STAT-DEFS [OK-IntegerInRange2] >>> ***/
990 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_tags_1[] = {
991 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
993 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
994 "OK-IntegerInRange2",
995 "OK-IntegerInRange2",
996 &asn_OP_NativeInteger,
997 asn_DEF_OK_IntegerInRange2_tags_1,
998 sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
999 /sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
1000 asn_DEF_OK_IntegerInRange2_tags_1, /* Same as above */
1001 sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
1002 /sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
1003 { 0, &asn_PER_type_OK_IntegerInRange2_constr_1, OK_IntegerInRange2_constraint },
1004 0, 0, /* No members */
1005 0 /* No specifics */
1009 /*** <<< INCLUDES [OK-IntegerInRange3] >>> ***/
1011 #include <NativeInteger.h>
1013 /*** <<< TYPE-DECLS [OK-IntegerInRange3] >>> ***/
1015 typedef long OK_IntegerInRange3_t;
1017 /*** <<< FUNC-DECLS [OK-IntegerInRange3] >>> ***/
1019 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3;
1020 asn_struct_free_f OK_IntegerInRange3_free;
1021 asn_struct_print_f OK_IntegerInRange3_print;
1022 asn_constr_check_f OK_IntegerInRange3_constraint;
1023 ber_type_decoder_f OK_IntegerInRange3_decode_ber;
1024 der_type_encoder_f OK_IntegerInRange3_encode_der;
1025 xer_type_decoder_f OK_IntegerInRange3_decode_xer;
1026 xer_type_encoder_f OK_IntegerInRange3_encode_xer;
1027 per_type_decoder_f OK_IntegerInRange3_decode_uper;
1028 per_type_encoder_f OK_IntegerInRange3_encode_uper;
1029 per_type_decoder_f OK_IntegerInRange3_decode_aper;
1030 per_type_encoder_f OK_IntegerInRange3_encode_aper;
1032 /*** <<< CODE [OK-IntegerInRange3] >>> ***/
1035 OK_IntegerInRange3_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1036 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1040 ASN__CTFAIL(app_key, td, sptr,
1041 "%s: value not given (%s:%d)",
1042 td->name, __FILE__, __LINE__);
1046 value = *(const long *)sptr;
1048 if((value >= (-2147483647L - 1) && value <= 2147483647)) {
1049 /* Constraint check succeeded */
1052 ASN__CTFAIL(app_key, td, sptr,
1053 "%s: constraint failed (%s:%d)",
1054 td->name, __FILE__, __LINE__);
1060 * This type is implemented using NativeInteger,
1061 * so here we adjust the DEF accordingly.
1064 /*** <<< CTDEFS [OK-IntegerInRange3] >>> ***/
1066 static asn_per_constraints_t asn_PER_type_OK_IntegerInRange3_constr_1 CC_NOTUSED = {
1067 { APC_CONSTRAINED, 32, -1, (-2147483647L - 1), 2147483647 } /* (-2147483648..2147483647) */,
1068 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
1069 0, 0 /* No PER value map */
1072 /*** <<< STAT-DEFS [OK-IntegerInRange3] >>> ***/
1074 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_tags_1[] = {
1075 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1077 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
1078 "OK-IntegerInRange3",
1079 "OK-IntegerInRange3",
1080 &asn_OP_NativeInteger,
1081 asn_DEF_OK_IntegerInRange3_tags_1,
1082 sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
1083 /sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
1084 asn_DEF_OK_IntegerInRange3_tags_1, /* Same as above */
1085 sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
1086 /sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
1087 { 0, &asn_PER_type_OK_IntegerInRange3_constr_1, OK_IntegerInRange3_constraint },
1088 0, 0, /* No members */
1089 0 /* No specifics */
1093 /*** <<< INCLUDES [OK-IntegerInRange4] >>> ***/
1095 #include <NativeInteger.h>
1097 /*** <<< TYPE-DECLS [OK-IntegerInRange4] >>> ***/
1099 typedef long OK_IntegerInRange4_t;
1101 /*** <<< FUNC-DECLS [OK-IntegerInRange4] >>> ***/
1103 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4;
1104 asn_struct_free_f OK_IntegerInRange4_free;
1105 asn_struct_print_f OK_IntegerInRange4_print;
1106 asn_constr_check_f OK_IntegerInRange4_constraint;
1107 ber_type_decoder_f OK_IntegerInRange4_decode_ber;
1108 der_type_encoder_f OK_IntegerInRange4_encode_der;
1109 xer_type_decoder_f OK_IntegerInRange4_decode_xer;
1110 xer_type_encoder_f OK_IntegerInRange4_encode_xer;
1111 per_type_decoder_f OK_IntegerInRange4_decode_uper;
1112 per_type_encoder_f OK_IntegerInRange4_encode_uper;
1113 per_type_decoder_f OK_IntegerInRange4_decode_aper;
1114 per_type_encoder_f OK_IntegerInRange4_encode_aper;
1116 /*** <<< CODE [OK-IntegerInRange4] >>> ***/
1119 OK_IntegerInRange4_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1120 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1124 ASN__CTFAIL(app_key, td, sptr,
1125 "%s: value not given (%s:%d)",
1126 td->name, __FILE__, __LINE__);
1130 value = *(const long *)sptr;
1132 if(((value == (-2147483647L - 1)) || (value == 2147483647))) {
1133 /* Constraint check succeeded */
1136 ASN__CTFAIL(app_key, td, sptr,
1137 "%s: constraint failed (%s:%d)",
1138 td->name, __FILE__, __LINE__);
1144 * This type is implemented using NativeInteger,
1145 * so here we adjust the DEF accordingly.
1148 /*** <<< CTDEFS [OK-IntegerInRange4] >>> ***/
1150 static asn_per_constraints_t asn_PER_type_OK_IntegerInRange4_constr_1 CC_NOTUSED = {
1151 { APC_CONSTRAINED, 32, -1, (-2147483647L - 1), 2147483647 } /* (-2147483648..2147483647) */,
1152 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
1153 0, 0 /* No PER value map */
1156 /*** <<< STAT-DEFS [OK-IntegerInRange4] >>> ***/
1158 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_tags_1[] = {
1159 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1161 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
1162 "OK-IntegerInRange4",
1163 "OK-IntegerInRange4",
1164 &asn_OP_NativeInteger,
1165 asn_DEF_OK_IntegerInRange4_tags_1,
1166 sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
1167 /sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
1168 asn_DEF_OK_IntegerInRange4_tags_1, /* Same as above */
1169 sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
1170 /sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
1171 { 0, &asn_PER_type_OK_IntegerInRange4_constr_1, OK_IntegerInRange4_constraint },
1172 0, 0, /* No members */
1173 0 /* No specifics */
1177 /*** <<< INCLUDES [OK-IntegerInRange5] >>> ***/
1179 #include <NativeInteger.h>
1181 /*** <<< TYPE-DECLS [OK-IntegerInRange5] >>> ***/
1183 typedef long OK_IntegerInRange5_t;
1185 /*** <<< FUNC-DECLS [OK-IntegerInRange5] >>> ***/
1187 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5;
1188 asn_struct_free_f OK_IntegerInRange5_free;
1189 asn_struct_print_f OK_IntegerInRange5_print;
1190 asn_constr_check_f OK_IntegerInRange5_constraint;
1191 ber_type_decoder_f OK_IntegerInRange5_decode_ber;
1192 der_type_encoder_f OK_IntegerInRange5_encode_der;
1193 xer_type_decoder_f OK_IntegerInRange5_decode_xer;
1194 xer_type_encoder_f OK_IntegerInRange5_encode_xer;
1195 per_type_decoder_f OK_IntegerInRange5_decode_uper;
1196 per_type_encoder_f OK_IntegerInRange5_encode_uper;
1197 per_type_decoder_f OK_IntegerInRange5_decode_aper;
1198 per_type_encoder_f OK_IntegerInRange5_encode_aper;
1200 /*** <<< CODE [OK-IntegerInRange5] >>> ***/
1203 OK_IntegerInRange5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1204 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1208 ASN__CTFAIL(app_key, td, sptr,
1209 "%s: value not given (%s:%d)",
1210 td->name, __FILE__, __LINE__);
1214 value = *(const long *)sptr;
1216 if(((value == (-2147483647L - 1)) || (value == 2147483647))) {
1217 /* Constraint check succeeded */
1220 ASN__CTFAIL(app_key, td, sptr,
1221 "%s: constraint failed (%s:%d)",
1222 td->name, __FILE__, __LINE__);
1228 * This type is implemented using NativeInteger,
1229 * so here we adjust the DEF accordingly.
1232 /*** <<< CTDEFS [OK-IntegerInRange5] >>> ***/
1234 static asn_per_constraints_t asn_PER_type_OK_IntegerInRange5_constr_1 CC_NOTUSED = {
1235 { APC_CONSTRAINED | APC_EXTENSIBLE, 32, -1, (-2147483647L - 1), 2147483647 } /* (-2147483648..2147483647,...) */,
1236 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
1237 0, 0 /* No PER value map */
1240 /*** <<< STAT-DEFS [OK-IntegerInRange5] >>> ***/
1242 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_tags_1[] = {
1243 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1245 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
1246 "OK-IntegerInRange5",
1247 "OK-IntegerInRange5",
1248 &asn_OP_NativeInteger,
1249 asn_DEF_OK_IntegerInRange5_tags_1,
1250 sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
1251 /sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
1252 asn_DEF_OK_IntegerInRange5_tags_1, /* Same as above */
1253 sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
1254 /sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
1255 { 0, &asn_PER_type_OK_IntegerInRange5_constr_1, OK_IntegerInRange5_constraint },
1256 0, 0, /* No members */
1257 0 /* No specifics */
1261 /*** <<< INCLUDES [NO-IntegerInRange6] >>> ***/
1263 #include <NativeInteger.h>
1265 /*** <<< TYPE-DECLS [NO-IntegerInRange6] >>> ***/
1267 typedef unsigned long NO_IntegerInRange6_t;
1269 /*** <<< FUNC-DECLS [NO-IntegerInRange6] >>> ***/
1271 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6;
1272 asn_struct_free_f NO_IntegerInRange6_free;
1273 asn_struct_print_f NO_IntegerInRange6_print;
1274 asn_constr_check_f NO_IntegerInRange6_constraint;
1275 ber_type_decoder_f NO_IntegerInRange6_decode_ber;
1276 der_type_encoder_f NO_IntegerInRange6_encode_der;
1277 xer_type_decoder_f NO_IntegerInRange6_decode_xer;
1278 xer_type_encoder_f NO_IntegerInRange6_encode_xer;
1279 per_type_decoder_f NO_IntegerInRange6_decode_uper;
1280 per_type_encoder_f NO_IntegerInRange6_encode_uper;
1281 per_type_decoder_f NO_IntegerInRange6_decode_aper;
1282 per_type_encoder_f NO_IntegerInRange6_encode_aper;
1284 /*** <<< CODE [NO-IntegerInRange6] >>> ***/
1287 NO_IntegerInRange6_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1288 asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1291 ASN__CTFAIL(app_key, td, sptr,
1292 "%s: value not given (%s:%d)",
1293 td->name, __FILE__, __LINE__);
1298 /* Constraint check succeeded */
1303 * This type is implemented using NativeInteger,
1304 * so here we adjust the DEF accordingly.
1307 /*** <<< CTDEFS [NO-IntegerInRange6] >>> ***/
1309 static asn_per_constraints_t asn_PER_type_NO_IntegerInRange6_constr_1 CC_NOTUSED = {
1310 { APC_CONSTRAINED, 32, -1, 0, 4294967295 } /* (0..4294967295) */,
1311 { APC_UNCONSTRAINED, -1, -1, 0, 0 },
1312 0, 0 /* No PER value map */
1315 /*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
1317 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerInRange6_specs_1 = {
1319 0, /* Native long size */
1320 1 /* Unsigned representation */
1322 static const ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
1323 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1325 asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
1326 "NO-IntegerInRange6",
1327 "NO-IntegerInRange6",
1328 &asn_OP_NativeInteger,
1329 asn_DEF_NO_IntegerInRange6_tags_1,
1330 sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
1331 /sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
1332 asn_DEF_NO_IntegerInRange6_tags_1, /* Same as above */
1333 sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
1334 /sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
1335 { 0, &asn_PER_type_NO_IntegerInRange6_constr_1, NO_IntegerInRange6_constraint },
1336 0, 0, /* No members */
1337 &asn_SPC_NO_IntegerInRange6_specs_1 /* Additional specs */
1341 /*** <<< INCLUDES [CN-IntegerEnumerated1] >>> ***/
1343 #include <NativeInteger.h>
1345 /*** <<< DEPS [CN-IntegerEnumerated1] >>> ***/
1347 typedef enum CN_IntegerEnumerated1 {
1348 CN_IntegerEnumerated1_a = 1,
1349 CN_IntegerEnumerated1_b = 2
1350 } e_CN_IntegerEnumerated1;
1352 /*** <<< TYPE-DECLS [CN-IntegerEnumerated1] >>> ***/
1354 typedef long CN_IntegerEnumerated1_t;
1356 /*** <<< FUNC-DECLS [CN-IntegerEnumerated1] >>> ***/
1358 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1;
1359 asn_struct_free_f CN_IntegerEnumerated1_free;
1360 asn_struct_print_f CN_IntegerEnumerated1_print;
1361 asn_constr_check_f CN_IntegerEnumerated1_constraint;
1362 ber_type_decoder_f CN_IntegerEnumerated1_decode_ber;
1363 der_type_encoder_f CN_IntegerEnumerated1_encode_der;
1364 xer_type_decoder_f CN_IntegerEnumerated1_decode_xer;
1365 xer_type_encoder_f CN_IntegerEnumerated1_encode_xer;
1366 per_type_decoder_f CN_IntegerEnumerated1_decode_uper;
1367 per_type_encoder_f CN_IntegerEnumerated1_encode_uper;
1368 per_type_decoder_f CN_IntegerEnumerated1_decode_aper;
1369 per_type_encoder_f CN_IntegerEnumerated1_encode_aper;
1371 /*** <<< CODE [CN-IntegerEnumerated1] >>> ***/
1374 * This type is implemented using NativeInteger,
1375 * so here we adjust the DEF accordingly.
1378 /*** <<< STAT-DEFS [CN-IntegerEnumerated1] >>> ***/
1380 static const ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_tags_1[] = {
1381 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1383 asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1 = {
1384 "CN-IntegerEnumerated1",
1385 "CN-IntegerEnumerated1",
1386 &asn_OP_NativeInteger,
1387 asn_DEF_CN_IntegerEnumerated1_tags_1,
1388 sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
1389 /sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
1390 asn_DEF_CN_IntegerEnumerated1_tags_1, /* Same as above */
1391 sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
1392 /sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
1393 { 0, 0, NativeInteger_constraint },
1394 0, 0, /* Defined elsewhere */
1395 0 /* No specifics */
1399 /*** <<< INCLUDES [NO-IntegerEnumerated2] >>> ***/
1401 #include <INTEGER.h>
1403 /*** <<< DEPS [NO-IntegerEnumerated2] >>> ***/
1405 typedef enum NO_IntegerEnumerated2 {
1406 NO_IntegerEnumerated2_a = 1,
1407 NO_IntegerEnumerated2_b = 3000000000
1408 } e_NO_IntegerEnumerated2;
1410 /*** <<< TYPE-DECLS [NO-IntegerEnumerated2] >>> ***/
1412 typedef INTEGER_t NO_IntegerEnumerated2_t;
1414 /*** <<< FUNC-DECLS [NO-IntegerEnumerated2] >>> ***/
1416 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2;
1417 asn_struct_free_f NO_IntegerEnumerated2_free;
1418 asn_struct_print_f NO_IntegerEnumerated2_print;
1419 asn_constr_check_f NO_IntegerEnumerated2_constraint;
1420 ber_type_decoder_f NO_IntegerEnumerated2_decode_ber;
1421 der_type_encoder_f NO_IntegerEnumerated2_encode_der;
1422 xer_type_decoder_f NO_IntegerEnumerated2_decode_xer;
1423 xer_type_encoder_f NO_IntegerEnumerated2_encode_xer;
1424 per_type_decoder_f NO_IntegerEnumerated2_decode_uper;
1425 per_type_encoder_f NO_IntegerEnumerated2_encode_uper;
1426 per_type_decoder_f NO_IntegerEnumerated2_decode_aper;
1427 per_type_encoder_f NO_IntegerEnumerated2_encode_aper;
1429 /*** <<< CODE [NO-IntegerEnumerated2] >>> ***/
1432 * This type is implemented using INTEGER,
1433 * so here we adjust the DEF accordingly.
1436 /*** <<< STAT-DEFS [NO-IntegerEnumerated2] >>> ***/
1438 static const ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_tags_1[] = {
1439 (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1441 asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2 = {
1442 "NO-IntegerEnumerated2",
1443 "NO-IntegerEnumerated2",
1445 asn_DEF_NO_IntegerEnumerated2_tags_1,
1446 sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
1447 /sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
1448 asn_DEF_NO_IntegerEnumerated2_tags_1, /* Same as above */
1449 sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
1450 /sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
1451 { 0, 0, INTEGER_constraint },
1452 0, 0, /* Defined elsewhere */
1453 0 /* No specifics */