tests/tests-asn1c-compiler/138-oer-constraints-OK.asn1.-Pgen-OER

   1
   2 /*** <<< INCLUDES [A-noc] >>> ***/
   3
   4 #include <NativeInteger.h>
   5
   6 /*** <<< TYPE-DECLS [A-noc] >>> ***/
   7
   8 typedef long     A_noc_t;
   9
  10 /*** <<< FUNC-DECLS [A-noc] >>> ***/
  11
  12 extern asn_TYPE_descriptor_t asn_DEF_A_noc;
  13 asn_struct_free_f A_noc_free;
  14 asn_struct_print_f A_noc_print;
  15 asn_constr_check_f A_noc_constraint;
  16 ber_type_decoder_f A_noc_decode_ber;
  17 der_type_encoder_f A_noc_encode_der;
  18 xer_type_decoder_f A_noc_decode_xer;
  19 xer_type_encoder_f A_noc_encode_xer;
  20 oer_type_decoder_f A_noc_decode_oer;
  21 oer_type_encoder_f A_noc_encode_oer;
  22
  23 /*** <<< CODE [A-noc] >>> ***/
  24
  25 /*
  26  * This type is implemented using NativeInteger,
  27  * so here we adjust the DEF accordingly.
  28  */
  29
  30 /*** <<< STAT-DEFS [A-noc] >>> ***/
  31
  32 static const ber_tlv_tag_t asn_DEF_A_noc_tags_1[] = {
  33         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
  34 };
  35 asn_TYPE_descriptor_t asn_DEF_A_noc = {
  36         "A-noc",
  37         "A-noc",
  38         &asn_OP_NativeInteger,
  39         asn_DEF_A_noc_tags_1,
  40         sizeof(asn_DEF_A_noc_tags_1)
  41                 /sizeof(asn_DEF_A_noc_tags_1[0]), /* 1 */
  42         asn_DEF_A_noc_tags_1,   /* Same as above */
  43         sizeof(asn_DEF_A_noc_tags_1)
  44                 /sizeof(asn_DEF_A_noc_tags_1[0]), /* 1 */
  45         { 0, 0, NativeInteger_constraint },
  46         0, 0,   /* No members */
  47         0       /* No specifics */
  48 };
  49
  50
  51 /*** <<< INCLUDES [B-0-0] >>> ***/
  52
  53 #include <NativeInteger.h>
  54
  55 /*** <<< TYPE-DECLS [B-0-0] >>> ***/
  56
  57 typedef long     B_0_0_t;
  58
  59 /*** <<< FUNC-DECLS [B-0-0] >>> ***/
  60
  61 extern asn_TYPE_descriptor_t asn_DEF_B_0_0;
  62 asn_struct_free_f B_0_0_free;
  63 asn_struct_print_f B_0_0_print;
  64 asn_constr_check_f B_0_0_constraint;
  65 ber_type_decoder_f B_0_0_decode_ber;
  66 der_type_encoder_f B_0_0_encode_der;
  67 xer_type_decoder_f B_0_0_decode_xer;
  68 xer_type_encoder_f B_0_0_encode_xer;
  69 oer_type_decoder_f B_0_0_decode_oer;
  70 oer_type_encoder_f B_0_0_encode_oer;
  71
  72 /*** <<< CODE [B-0-0] >>> ***/
  73
  74 int
  75 B_0_0_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
  76                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  77         long value;
  78
  79         if(!sptr) {
  80                 ASN__CTFAIL(app_key, td, sptr,
  81                         "%s: value not given (%s:%d)",
  82                         td->name, __FILE__, __LINE__);
  83                 return -1;
  84         }
  85
  86         value = *(const long *)sptr;
  87
  88         if((value == 0)) {
  89                 /* Constraint check succeeded */
  90                 return 0;
  91         } else {
  92                 ASN__CTFAIL(app_key, td, sptr,
  93                         "%s: constraint failed (%s:%d)",
  94                         td->name, __FILE__, __LINE__);
  95                 return -1;
  96         }
  97 }
  98
  99 /*
 100  * This type is implemented using NativeInteger,
 101  * so here we adjust the DEF accordingly.
 102  */
 103
 104 /*** <<< CTDEFS [B-0-0] >>> ***/
 105
 106 static asn_oer_constraints_t asn_OER_type_B_0_0_constr_1 CC_NOTUSED = {
 107         { 1, 1 }        /* (0..0) */,
 108         -1};
 109
 110 /*** <<< STAT-DEFS [B-0-0] >>> ***/
 111
 112 static const ber_tlv_tag_t asn_DEF_B_0_0_tags_1[] = {
 113         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 114 };
 115 asn_TYPE_descriptor_t asn_DEF_B_0_0 = {
 116         "B-0-0",
 117         "B-0-0",
 118         &asn_OP_NativeInteger,
 119         asn_DEF_B_0_0_tags_1,
 120         sizeof(asn_DEF_B_0_0_tags_1)
 121                 /sizeof(asn_DEF_B_0_0_tags_1[0]), /* 1 */
 122         asn_DEF_B_0_0_tags_1,   /* Same as above */
 123         sizeof(asn_DEF_B_0_0_tags_1)
 124                 /sizeof(asn_DEF_B_0_0_tags_1[0]), /* 1 */
 125         { &asn_OER_type_B_0_0_constr_1, 0, B_0_0_constraint },
 126         0, 0,   /* No members */
 127         0       /* No specifics */
 128 };
 129
 130
 131 /*** <<< INCLUDES [C-1-2] >>> ***/
 132
 133 #include <NativeInteger.h>
 134
 135 /*** <<< TYPE-DECLS [C-1-2] >>> ***/
 136
 137 typedef long     C_1_2_t;
 138
 139 /*** <<< FUNC-DECLS [C-1-2] >>> ***/
 140
 141 extern asn_TYPE_descriptor_t asn_DEF_C_1_2;
 142 asn_struct_free_f C_1_2_free;
 143 asn_struct_print_f C_1_2_print;
 144 asn_constr_check_f C_1_2_constraint;
 145 ber_type_decoder_f C_1_2_decode_ber;
 146 der_type_encoder_f C_1_2_encode_der;
 147 xer_type_decoder_f C_1_2_decode_xer;
 148 xer_type_encoder_f C_1_2_encode_xer;
 149 oer_type_decoder_f C_1_2_decode_oer;
 150 oer_type_encoder_f C_1_2_encode_oer;
 151
 152 /*** <<< CODE [C-1-2] >>> ***/
 153
 154 int
 155 C_1_2_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 156                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 157         long value;
 158
 159         if(!sptr) {
 160                 ASN__CTFAIL(app_key, td, sptr,
 161                         "%s: value not given (%s:%d)",
 162                         td->name, __FILE__, __LINE__);
 163                 return -1;
 164         }
 165
 166         value = *(const long *)sptr;
 167
 168         if((value >= 1 && value <= 2)) {
 169                 /* Constraint check succeeded */
 170                 return 0;
 171         } else {
 172                 ASN__CTFAIL(app_key, td, sptr,
 173                         "%s: constraint failed (%s:%d)",
 174                         td->name, __FILE__, __LINE__);
 175                 return -1;
 176         }
 177 }
 178
 179 /*
 180  * This type is implemented using NativeInteger,
 181  * so here we adjust the DEF accordingly.
 182  */
 183
 184 /*** <<< CTDEFS [C-1-2] >>> ***/
 185
 186 static asn_oer_constraints_t asn_OER_type_C_1_2_constr_1 CC_NOTUSED = {
 187         { 1, 1 }        /* (1..2) */,
 188         -1};
 189
 190 /*** <<< STAT-DEFS [C-1-2] >>> ***/
 191
 192 static const ber_tlv_tag_t asn_DEF_C_1_2_tags_1[] = {
 193         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 194 };
 195 asn_TYPE_descriptor_t asn_DEF_C_1_2 = {
 196         "C-1-2",
 197         "C-1-2",
 198         &asn_OP_NativeInteger,
 199         asn_DEF_C_1_2_tags_1,
 200         sizeof(asn_DEF_C_1_2_tags_1)
 201                 /sizeof(asn_DEF_C_1_2_tags_1[0]), /* 1 */
 202         asn_DEF_C_1_2_tags_1,   /* Same as above */
 203         sizeof(asn_DEF_C_1_2_tags_1)
 204                 /sizeof(asn_DEF_C_1_2_tags_1[0]), /* 1 */
 205         { &asn_OER_type_C_1_2_constr_1, 0, C_1_2_constraint },
 206         0, 0,   /* No members */
 207         0       /* No specifics */
 208 };
 209
 210
 211 /*** <<< INCLUDES [D-inv] >>> ***/
 212
 213 #include <NativeInteger.h>
 214
 215 /*** <<< TYPE-DECLS [D-inv] >>> ***/
 216
 217 typedef long     D_inv_t;
 218
 219 /*** <<< FUNC-DECLS [D-inv] >>> ***/
 220
 221 extern asn_TYPE_descriptor_t asn_DEF_D_inv;
 222 asn_struct_free_f D_inv_free;
 223 asn_struct_print_f D_inv_print;
 224 asn_constr_check_f D_inv_constraint;
 225 ber_type_decoder_f D_inv_decode_ber;
 226 der_type_encoder_f D_inv_encode_der;
 227 xer_type_decoder_f D_inv_decode_xer;
 228 xer_type_encoder_f D_inv_encode_xer;
 229 oer_type_decoder_f D_inv_decode_oer;
 230 oer_type_encoder_f D_inv_encode_oer;
 231
 232 /*** <<< CODE [D-inv] >>> ***/
 233
 234 int
 235 D_inv_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 236                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 237         long value;
 238
 239         if(!sptr) {
 240                 ASN__CTFAIL(app_key, td, sptr,
 241                         "%s: value not given (%s:%d)",
 242                         td->name, __FILE__, __LINE__);
 243                 return -1;
 244         }
 245
 246         value = *(const long *)sptr;
 247
 248         if((value >= 0 && value <= 10)) {
 249                 /* Constraint check succeeded */
 250                 return 0;
 251         } else {
 252                 ASN__CTFAIL(app_key, td, sptr,
 253                         "%s: constraint failed (%s:%d)",
 254                         td->name, __FILE__, __LINE__);
 255                 return -1;
 256         }
 257 }
 258
 259 /*
 260  * This type is implemented using NativeInteger,
 261  * so here we adjust the DEF accordingly.
 262  */
 263
 264 /*** <<< CTDEFS [D-inv] >>> ***/
 265
 266 static asn_oer_constraints_t asn_OER_type_D_inv_constr_1 CC_NOTUSED = {
 267         { 0, 0 },
 268         -1};
 269
 270 /*** <<< STAT-DEFS [D-inv] >>> ***/
 271
 272 static const ber_tlv_tag_t asn_DEF_D_inv_tags_1[] = {
 273         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 274 };
 275 asn_TYPE_descriptor_t asn_DEF_D_inv = {
 276         "D-inv",
 277         "D-inv",
 278         &asn_OP_NativeInteger,
 279         asn_DEF_D_inv_tags_1,
 280         sizeof(asn_DEF_D_inv_tags_1)
 281                 /sizeof(asn_DEF_D_inv_tags_1[0]), /* 1 */
 282         asn_DEF_D_inv_tags_1,   /* Same as above */
 283         sizeof(asn_DEF_D_inv_tags_1)
 284                 /sizeof(asn_DEF_D_inv_tags_1[0]), /* 1 */
 285         { &asn_OER_type_D_inv_constr_1, 0, D_inv_constraint },
 286         0, 0,   /* No members */
 287         0       /* No specifics */
 288 };
 289
 290
 291 /*** <<< INCLUDES [E-2-5] >>> ***/
 292
 293 #include <NativeInteger.h>
 294
 295 /*** <<< TYPE-DECLS [E-2-5] >>> ***/
 296
 297 typedef long     E_2_5_t;
 298
 299 /*** <<< FUNC-DECLS [E-2-5] >>> ***/
 300
 301 extern asn_TYPE_descriptor_t asn_DEF_E_2_5;
 302 asn_struct_free_f E_2_5_free;
 303 asn_struct_print_f E_2_5_print;
 304 asn_constr_check_f E_2_5_constraint;
 305 ber_type_decoder_f E_2_5_decode_ber;
 306 der_type_encoder_f E_2_5_encode_der;
 307 xer_type_decoder_f E_2_5_decode_xer;
 308 xer_type_encoder_f E_2_5_encode_xer;
 309 oer_type_decoder_f E_2_5_decode_oer;
 310 oer_type_encoder_f E_2_5_encode_oer;
 311
 312 /*** <<< CODE [E-2-5] >>> ***/
 313
 314 int
 315 E_2_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 316                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 317         long value;
 318
 319         if(!sptr) {
 320                 ASN__CTFAIL(app_key, td, sptr,
 321                         "%s: value not given (%s:%d)",
 322                         td->name, __FILE__, __LINE__);
 323                 return -1;
 324         }
 325
 326         value = *(const long *)sptr;
 327
 328         if((value >= 2 && value <= 5)) {
 329                 /* Constraint check succeeded */
 330                 return 0;
 331         } else {
 332                 ASN__CTFAIL(app_key, td, sptr,
 333                         "%s: constraint failed (%s:%d)",
 334                         td->name, __FILE__, __LINE__);
 335                 return -1;
 336         }
 337 }
 338
 339 /*
 340  * This type is implemented using NativeInteger,
 341  * so here we adjust the DEF accordingly.
 342  */
 343
 344 /*** <<< CTDEFS [E-2-5] >>> ***/
 345
 346 static asn_oer_constraints_t asn_OER_type_E_2_5_constr_1 CC_NOTUSED = {
 347         { 1, 1 }        /* (2..5) */,
 348         -1};
 349
 350 /*** <<< STAT-DEFS [E-2-5] >>> ***/
 351
 352 static const ber_tlv_tag_t asn_DEF_E_2_5_tags_1[] = {
 353         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 354 };
 355 asn_TYPE_descriptor_t asn_DEF_E_2_5 = {
 356         "E-2-5",
 357         "E-2-5",
 358         &asn_OP_NativeInteger,
 359         asn_DEF_E_2_5_tags_1,
 360         sizeof(asn_DEF_E_2_5_tags_1)
 361                 /sizeof(asn_DEF_E_2_5_tags_1[0]), /* 1 */
 362         asn_DEF_E_2_5_tags_1,   /* Same as above */
 363         sizeof(asn_DEF_E_2_5_tags_1)
 364                 /sizeof(asn_DEF_E_2_5_tags_1[0]), /* 1 */
 365         { &asn_OER_type_E_2_5_constr_1, 0, E_2_5_constraint },
 366         0, 0,   /* No members */
 367         0       /* No specifics */
 368 };
 369
 370
 371 /*** <<< INCLUDES [F-inv] >>> ***/
 372
 373 #include <NativeInteger.h>
 374
 375 /*** <<< TYPE-DECLS [F-inv] >>> ***/
 376
 377 typedef long     F_inv_t;
 378
 379 /*** <<< FUNC-DECLS [F-inv] >>> ***/
 380
 381 extern asn_TYPE_descriptor_t asn_DEF_F_inv;
 382 asn_struct_free_f F_inv_free;
 383 asn_struct_print_f F_inv_print;
 384 asn_constr_check_f F_inv_constraint;
 385 ber_type_decoder_f F_inv_decode_ber;
 386 der_type_encoder_f F_inv_encode_der;
 387 xer_type_decoder_f F_inv_decode_xer;
 388 xer_type_encoder_f F_inv_encode_xer;
 389 oer_type_decoder_f F_inv_decode_oer;
 390 oer_type_encoder_f F_inv_encode_oer;
 391
 392 /*** <<< CODE [F-inv] >>> ***/
 393
 394 int
 395 F_inv_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 396                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 397         long value;
 398
 399         if(!sptr) {
 400                 ASN__CTFAIL(app_key, td, sptr,
 401                         "%s: value not given (%s:%d)",
 402                         td->name, __FILE__, __LINE__);
 403                 return -1;
 404         }
 405
 406         value = *(const long *)sptr;
 407
 408         if((value >= 2 && value <= 5)) {
 409                 /* Constraint check succeeded */
 410                 return 0;
 411         } else {
 412                 ASN__CTFAIL(app_key, td, sptr,
 413                         "%s: constraint failed (%s:%d)",
 414                         td->name, __FILE__, __LINE__);
 415                 return -1;
 416         }
 417 }
 418
 419 /*
 420  * This type is implemented using NativeInteger,
 421  * so here we adjust the DEF accordingly.
 422  */
 423
 424 /*** <<< CTDEFS [F-inv] >>> ***/
 425
 426 static asn_oer_constraints_t asn_OER_type_F_inv_constr_1 CC_NOTUSED = {
 427         { 1, 1 }        /* (0..10) */,
 428         -1};
 429
 430 /*** <<< STAT-DEFS [F-inv] >>> ***/
 431
 432 static const ber_tlv_tag_t asn_DEF_F_inv_tags_1[] = {
 433         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 434 };
 435 asn_TYPE_descriptor_t asn_DEF_F_inv = {
 436         "F-inv",
 437         "F-inv",
 438         &asn_OP_NativeInteger,
 439         asn_DEF_F_inv_tags_1,
 440         sizeof(asn_DEF_F_inv_tags_1)
 441                 /sizeof(asn_DEF_F_inv_tags_1[0]), /* 1 */
 442         asn_DEF_F_inv_tags_1,   /* Same as above */
 443         sizeof(asn_DEF_F_inv_tags_1)
 444                 /sizeof(asn_DEF_F_inv_tags_1[0]), /* 1 */
 445         { &asn_OER_type_F_inv_constr_1, 0, F_inv_constraint },
 446         0, 0,   /* No members */
 447         0       /* No specifics */
 448 };
 449
 450
 451 /*** <<< INCLUDES [G-3-3] >>> ***/
 452
 453 #include <NativeInteger.h>
 454
 455 /*** <<< TYPE-DECLS [G-3-3] >>> ***/
 456
 457 typedef long     G_3_3_t;
 458
 459 /*** <<< FUNC-DECLS [G-3-3] >>> ***/
 460
 461 extern asn_TYPE_descriptor_t asn_DEF_G_3_3;
 462 asn_struct_free_f G_3_3_free;
 463 asn_struct_print_f G_3_3_print;
 464 asn_constr_check_f G_3_3_constraint;
 465 ber_type_decoder_f G_3_3_decode_ber;
 466 der_type_encoder_f G_3_3_encode_der;
 467 xer_type_decoder_f G_3_3_decode_xer;
 468 xer_type_encoder_f G_3_3_encode_xer;
 469 oer_type_decoder_f G_3_3_decode_oer;
 470 oer_type_encoder_f G_3_3_encode_oer;
 471
 472 /*** <<< CODE [G-3-3] >>> ***/
 473
 474 int
 475 G_3_3_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 476                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 477         long value;
 478
 479         if(!sptr) {
 480                 ASN__CTFAIL(app_key, td, sptr,
 481                         "%s: value not given (%s:%d)",
 482                         td->name, __FILE__, __LINE__);
 483                 return -1;
 484         }
 485
 486         value = *(const long *)sptr;
 487
 488         if((value == 3)) {
 489                 /* Constraint check succeeded */
 490                 return 0;
 491         } else {
 492                 ASN__CTFAIL(app_key, td, sptr,
 493                         "%s: constraint failed (%s:%d)",
 494                         td->name, __FILE__, __LINE__);
 495                 return -1;
 496         }
 497 }
 498
 499 /*
 500  * This type is implemented using NativeInteger,
 501  * so here we adjust the DEF accordingly.
 502  */
 503
 504 /*** <<< CTDEFS [G-3-3] >>> ***/
 505
 506 static asn_oer_constraints_t asn_OER_type_G_3_3_constr_1 CC_NOTUSED = {
 507         { 1, 1 }        /* (3..3) */,
 508         -1};
 509
 510 /*** <<< STAT-DEFS [G-3-3] >>> ***/
 511
 512 static const ber_tlv_tag_t asn_DEF_G_3_3_tags_1[] = {
 513         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 514 };
 515 asn_TYPE_descriptor_t asn_DEF_G_3_3 = {
 516         "G-3-3",
 517         "G-3-3",
 518         &asn_OP_NativeInteger,
 519         asn_DEF_G_3_3_tags_1,
 520         sizeof(asn_DEF_G_3_3_tags_1)
 521                 /sizeof(asn_DEF_G_3_3_tags_1[0]), /* 1 */
 522         asn_DEF_G_3_3_tags_1,   /* Same as above */
 523         sizeof(asn_DEF_G_3_3_tags_1)
 524                 /sizeof(asn_DEF_G_3_3_tags_1[0]), /* 1 */
 525         { &asn_OER_type_G_3_3_constr_1, 0, G_3_3_constraint },
 526         0, 0,   /* No members */
 527         0       /* No specifics */
 528 };
 529
 530
 531 /*** <<< INCLUDES [H-4-5] >>> ***/
 532
 533 #include <NativeInteger.h>
 534
 535 /*** <<< TYPE-DECLS [H-4-5] >>> ***/
 536
 537 typedef long     H_4_5_t;
 538
 539 /*** <<< FUNC-DECLS [H-4-5] >>> ***/
 540
 541 extern asn_TYPE_descriptor_t asn_DEF_H_4_5;
 542 asn_struct_free_f H_4_5_free;
 543 asn_struct_print_f H_4_5_print;
 544 asn_constr_check_f H_4_5_constraint;
 545 ber_type_decoder_f H_4_5_decode_ber;
 546 der_type_encoder_f H_4_5_encode_der;
 547 xer_type_decoder_f H_4_5_decode_xer;
 548 xer_type_encoder_f H_4_5_encode_xer;
 549 oer_type_decoder_f H_4_5_decode_oer;
 550 oer_type_encoder_f H_4_5_encode_oer;
 551
 552 /*** <<< CODE [H-4-5] >>> ***/
 553
 554 int
 555 H_4_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 556                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 557         long value;
 558
 559         if(!sptr) {
 560                 ASN__CTFAIL(app_key, td, sptr,
 561                         "%s: value not given (%s:%d)",
 562                         td->name, __FILE__, __LINE__);
 563                 return -1;
 564         }
 565
 566         value = *(const long *)sptr;
 567
 568         if((value >= 4 && value <= 5)) {
 569                 /* Constraint check succeeded */
 570                 return 0;
 571         } else {
 572                 ASN__CTFAIL(app_key, td, sptr,
 573                         "%s: constraint failed (%s:%d)",
 574                         td->name, __FILE__, __LINE__);
 575                 return -1;
 576         }
 577 }
 578
 579 /*
 580  * This type is implemented using NativeInteger,
 581  * so here we adjust the DEF accordingly.
 582  */
 583
 584 /*** <<< CTDEFS [H-4-5] >>> ***/
 585
 586 static asn_oer_constraints_t asn_OER_type_H_4_5_constr_1 CC_NOTUSED = {
 587         { 1, 1 }        /* (4..5) */,
 588         -1};
 589
 590 /*** <<< STAT-DEFS [H-4-5] >>> ***/
 591
 592 static const ber_tlv_tag_t asn_DEF_H_4_5_tags_1[] = {
 593         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 594 };
 595 asn_TYPE_descriptor_t asn_DEF_H_4_5 = {
 596         "H-4-5",
 597         "H-4-5",
 598         &asn_OP_NativeInteger,
 599         asn_DEF_H_4_5_tags_1,
 600         sizeof(asn_DEF_H_4_5_tags_1)
 601                 /sizeof(asn_DEF_H_4_5_tags_1[0]), /* 1 */
 602         asn_DEF_H_4_5_tags_1,   /* Same as above */
 603         sizeof(asn_DEF_H_4_5_tags_1)
 604                 /sizeof(asn_DEF_H_4_5_tags_1[0]), /* 1 */
 605         { &asn_OER_type_H_4_5_constr_1, 0, H_4_5_constraint },
 606         0, 0,   /* No members */
 607         0       /* No specifics */
 608 };
 609
 610
 611 /*** <<< INCLUDES [I-1-5] >>> ***/
 612
 613 #include <NativeInteger.h>
 614
 615 /*** <<< TYPE-DECLS [I-1-5] >>> ***/
 616
 617 typedef long     I_1_5_t;
 618
 619 /*** <<< FUNC-DECLS [I-1-5] >>> ***/
 620
 621 extern asn_TYPE_descriptor_t asn_DEF_I_1_5;
 622 asn_struct_free_f I_1_5_free;
 623 asn_struct_print_f I_1_5_print;
 624 asn_constr_check_f I_1_5_constraint;
 625 ber_type_decoder_f I_1_5_decode_ber;
 626 der_type_encoder_f I_1_5_encode_der;
 627 xer_type_decoder_f I_1_5_decode_xer;
 628 xer_type_encoder_f I_1_5_encode_xer;
 629 oer_type_decoder_f I_1_5_decode_oer;
 630 oer_type_encoder_f I_1_5_encode_oer;
 631
 632 /*** <<< CODE [I-1-5] >>> ***/
 633
 634 int
 635 I_1_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 636                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 637         long value;
 638
 639         if(!sptr) {
 640                 ASN__CTFAIL(app_key, td, sptr,
 641                         "%s: value not given (%s:%d)",
 642                         td->name, __FILE__, __LINE__);
 643                 return -1;
 644         }
 645
 646         value = *(const long *)sptr;
 647
 648         if((value >= 1 && value <= 5)) {
 649                 /* Constraint check succeeded */
 650                 return 0;
 651         } else {
 652                 ASN__CTFAIL(app_key, td, sptr,
 653                         "%s: constraint failed (%s:%d)",
 654                         td->name, __FILE__, __LINE__);
 655                 return -1;
 656         }
 657 }
 658
 659 /*
 660  * This type is implemented using NativeInteger,
 661  * so here we adjust the DEF accordingly.
 662  */
 663
 664 /*** <<< CTDEFS [I-1-5] >>> ***/
 665
 666 static asn_oer_constraints_t asn_OER_type_I_1_5_constr_1 CC_NOTUSED = {
 667         { 1, 1 }        /* (1..5) */,
 668         -1};
 669
 670 /*** <<< STAT-DEFS [I-1-5] >>> ***/
 671
 672 static const ber_tlv_tag_t asn_DEF_I_1_5_tags_1[] = {
 673         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 674 };
 675 asn_TYPE_descriptor_t asn_DEF_I_1_5 = {
 676         "I-1-5",
 677         "I-1-5",
 678         &asn_OP_NativeInteger,
 679         asn_DEF_I_1_5_tags_1,
 680         sizeof(asn_DEF_I_1_5_tags_1)
 681                 /sizeof(asn_DEF_I_1_5_tags_1[0]), /* 1 */
 682         asn_DEF_I_1_5_tags_1,   /* Same as above */
 683         sizeof(asn_DEF_I_1_5_tags_1)
 684                 /sizeof(asn_DEF_I_1_5_tags_1[0]), /* 1 */
 685         { &asn_OER_type_I_1_5_constr_1, 0, I_1_5_constraint },
 686         0, 0,   /* No members */
 687         0       /* No specifics */
 688 };
 689
 690
 691 /*** <<< INCLUDES [J-4-5] >>> ***/
 692
 693 #include <NativeInteger.h>
 694
 695 /*** <<< TYPE-DECLS [J-4-5] >>> ***/
 696
 697 typedef long     J_4_5_t;
 698
 699 /*** <<< FUNC-DECLS [J-4-5] >>> ***/
 700
 701 extern asn_TYPE_descriptor_t asn_DEF_J_4_5;
 702 asn_struct_free_f J_4_5_free;
 703 asn_struct_print_f J_4_5_print;
 704 asn_constr_check_f J_4_5_constraint;
 705 ber_type_decoder_f J_4_5_decode_ber;
 706 der_type_encoder_f J_4_5_encode_der;
 707 xer_type_decoder_f J_4_5_decode_xer;
 708 xer_type_encoder_f J_4_5_encode_xer;
 709 oer_type_decoder_f J_4_5_decode_oer;
 710 oer_type_encoder_f J_4_5_encode_oer;
 711
 712 /*** <<< CODE [J-4-5] >>> ***/
 713
 714 int
 715 J_4_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 716                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 717         long value;
 718
 719         if(!sptr) {
 720                 ASN__CTFAIL(app_key, td, sptr,
 721                         "%s: value not given (%s:%d)",
 722                         td->name, __FILE__, __LINE__);
 723                 return -1;
 724         }
 725
 726         value = *(const long *)sptr;
 727
 728         if((value >= 4 && value <= 5)) {
 729                 /* Constraint check succeeded */
 730                 return 0;
 731         } else {
 732                 ASN__CTFAIL(app_key, td, sptr,
 733                         "%s: constraint failed (%s:%d)",
 734                         td->name, __FILE__, __LINE__);
 735                 return -1;
 736         }
 737 }
 738
 739 /*
 740  * This type is implemented using NativeInteger,
 741  * so here we adjust the DEF accordingly.
 742  */
 743
 744 /*** <<< CTDEFS [J-4-5] >>> ***/
 745
 746 static asn_oer_constraints_t asn_OER_type_J_4_5_constr_1 CC_NOTUSED = {
 747         { 1, 1 }        /* (4..5) */,
 748         -1};
 749
 750 /*** <<< STAT-DEFS [J-4-5] >>> ***/
 751
 752 static const ber_tlv_tag_t asn_DEF_J_4_5_tags_1[] = {
 753         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 754 };
 755 asn_TYPE_descriptor_t asn_DEF_J_4_5 = {
 756         "J-4-5",
 757         "J-4-5",
 758         &asn_OP_NativeInteger,
 759         asn_DEF_J_4_5_tags_1,
 760         sizeof(asn_DEF_J_4_5_tags_1)
 761                 /sizeof(asn_DEF_J_4_5_tags_1[0]), /* 1 */
 762         asn_DEF_J_4_5_tags_1,   /* Same as above */
 763         sizeof(asn_DEF_J_4_5_tags_1)
 764                 /sizeof(asn_DEF_J_4_5_tags_1[0]), /* 1 */
 765         { &asn_OER_type_J_4_5_constr_1, 0, J_4_5_constraint },
 766         0, 0,   /* No members */
 767         0       /* No specifics */
 768 };
 769
 770
 771 /*** <<< INCLUDES [K-1-4] >>> ***/
 772
 773 #include <NativeInteger.h>
 774
 775 /*** <<< TYPE-DECLS [K-1-4] >>> ***/
 776
 777 typedef long     K_1_4_t;
 778
 779 /*** <<< FUNC-DECLS [K-1-4] >>> ***/
 780
 781 extern asn_TYPE_descriptor_t asn_DEF_K_1_4;
 782 asn_struct_free_f K_1_4_free;
 783 asn_struct_print_f K_1_4_print;
 784 asn_constr_check_f K_1_4_constraint;
 785 ber_type_decoder_f K_1_4_decode_ber;
 786 der_type_encoder_f K_1_4_encode_der;
 787 xer_type_decoder_f K_1_4_decode_xer;
 788 xer_type_encoder_f K_1_4_encode_xer;
 789 oer_type_decoder_f K_1_4_decode_oer;
 790 oer_type_encoder_f K_1_4_encode_oer;
 791
 792 /*** <<< CODE [K-1-4] >>> ***/
 793
 794 int
 795 K_1_4_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 796                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 797         long value;
 798
 799         if(!sptr) {
 800                 ASN__CTFAIL(app_key, td, sptr,
 801                         "%s: value not given (%s:%d)",
 802                         td->name, __FILE__, __LINE__);
 803                 return -1;
 804         }
 805
 806         value = *(const long *)sptr;
 807
 808         if((value >= 1 && value <= 4)) {
 809                 /* Constraint check succeeded */
 810                 return 0;
 811         } else {
 812                 ASN__CTFAIL(app_key, td, sptr,
 813                         "%s: constraint failed (%s:%d)",
 814                         td->name, __FILE__, __LINE__);
 815                 return -1;
 816         }
 817 }
 818
 819 /*
 820  * This type is implemented using NativeInteger,
 821  * so here we adjust the DEF accordingly.
 822  */
 823
 824 /*** <<< CTDEFS [K-1-4] >>> ***/
 825
 826 static asn_oer_constraints_t asn_OER_type_K_1_4_constr_1 CC_NOTUSED = {
 827         { 1, 1 }        /* (1..4) */,
 828         -1};
 829
 830 /*** <<< STAT-DEFS [K-1-4] >>> ***/
 831
 832 static const ber_tlv_tag_t asn_DEF_K_1_4_tags_1[] = {
 833         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 834 };
 835 asn_TYPE_descriptor_t asn_DEF_K_1_4 = {
 836         "K-1-4",
 837         "K-1-4",
 838         &asn_OP_NativeInteger,
 839         asn_DEF_K_1_4_tags_1,
 840         sizeof(asn_DEF_K_1_4_tags_1)
 841                 /sizeof(asn_DEF_K_1_4_tags_1[0]), /* 1 */
 842         asn_DEF_K_1_4_tags_1,   /* Same as above */
 843         sizeof(asn_DEF_K_1_4_tags_1)
 844                 /sizeof(asn_DEF_K_1_4_tags_1[0]), /* 1 */
 845         { &asn_OER_type_K_1_4_constr_1, 0, K_1_4_constraint },
 846         0, 0,   /* No members */
 847         0       /* No specifics */
 848 };
 849
 850
 851 /*** <<< INCLUDES [L-0-5] >>> ***/
 852
 853 #include <NativeInteger.h>
 854
 855 /*** <<< TYPE-DECLS [L-0-5] >>> ***/
 856
 857 typedef long     L_0_5_t;
 858
 859 /*** <<< FUNC-DECLS [L-0-5] >>> ***/
 860
 861 extern asn_TYPE_descriptor_t asn_DEF_L_0_5;
 862 asn_struct_free_f L_0_5_free;
 863 asn_struct_print_f L_0_5_print;
 864 asn_constr_check_f L_0_5_constraint;
 865 ber_type_decoder_f L_0_5_decode_ber;
 866 der_type_encoder_f L_0_5_encode_der;
 867 xer_type_decoder_f L_0_5_decode_xer;
 868 xer_type_encoder_f L_0_5_encode_xer;
 869 oer_type_decoder_f L_0_5_decode_oer;
 870 oer_type_encoder_f L_0_5_encode_oer;
 871
 872 /*** <<< CODE [L-0-5] >>> ***/
 873
 874 int
 875 L_0_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 876                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 877         long value;
 878
 879         if(!sptr) {
 880                 ASN__CTFAIL(app_key, td, sptr,
 881                         "%s: value not given (%s:%d)",
 882                         td->name, __FILE__, __LINE__);
 883                 return -1;
 884         }
 885
 886         value = *(const long *)sptr;
 887
 888         if(((value == 0) || (value == 5))) {
 889                 /* Constraint check succeeded */
 890                 return 0;
 891         } else {
 892                 ASN__CTFAIL(app_key, td, sptr,
 893                         "%s: constraint failed (%s:%d)",
 894                         td->name, __FILE__, __LINE__);
 895                 return -1;
 896         }
 897 }
 898
 899 /*
 900  * This type is implemented using NativeInteger,
 901  * so here we adjust the DEF accordingly.
 902  */
 903
 904 /*** <<< CTDEFS [L-0-5] >>> ***/
 905
 906 static asn_oer_constraints_t asn_OER_type_L_0_5_constr_1 CC_NOTUSED = {
 907         { 1, 1 }        /* (0..5) */,
 908         -1};
 909
 910 /*** <<< STAT-DEFS [L-0-5] >>> ***/
 911
 912 static const ber_tlv_tag_t asn_DEF_L_0_5_tags_1[] = {
 913         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 914 };
 915 asn_TYPE_descriptor_t asn_DEF_L_0_5 = {
 916         "L-0-5",
 917         "L-0-5",
 918         &asn_OP_NativeInteger,
 919         asn_DEF_L_0_5_tags_1,
 920         sizeof(asn_DEF_L_0_5_tags_1)
 921                 /sizeof(asn_DEF_L_0_5_tags_1[0]), /* 1 */
 922         asn_DEF_L_0_5_tags_1,   /* Same as above */
 923         sizeof(asn_DEF_L_0_5_tags_1)
 924                 /sizeof(asn_DEF_L_0_5_tags_1[0]), /* 1 */
 925         { &asn_OER_type_L_0_5_constr_1, 0, L_0_5_constraint },
 926         0, 0,   /* No members */
 927         0       /* No specifics */
 928 };
 929
 930
 931 /*** <<< INCLUDES [M-inv] >>> ***/
 932
 933 #include <NativeInteger.h>
 934
 935 /*** <<< TYPE-DECLS [M-inv] >>> ***/
 936
 937 typedef long     M_inv_t;
 938
 939 /*** <<< FUNC-DECLS [M-inv] >>> ***/
 940
 941 extern asn_TYPE_descriptor_t asn_DEF_M_inv;
 942 asn_struct_free_f M_inv_free;
 943 asn_struct_print_f M_inv_print;
 944 asn_constr_check_f M_inv_constraint;
 945 ber_type_decoder_f M_inv_decode_ber;
 946 der_type_encoder_f M_inv_encode_der;
 947 xer_type_decoder_f M_inv_decode_xer;
 948 xer_type_encoder_f M_inv_encode_xer;
 949 oer_type_decoder_f M_inv_decode_oer;
 950 oer_type_encoder_f M_inv_encode_oer;
 951
 952 /*** <<< CODE [M-inv] >>> ***/
 953
 954 int
 955 M_inv_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 956                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 957         long value;
 958
 959         if(!sptr) {
 960                 ASN__CTFAIL(app_key, td, sptr,
 961                         "%s: value not given (%s:%d)",
 962                         td->name, __FILE__, __LINE__);
 963                 return -1;
 964         }
 965
 966         value = *(const long *)sptr;
 967
 968         if((value >= 0 && value <= 5)) {
 969                 /* Constraint check succeeded */
 970                 return 0;
 971         } else {
 972                 ASN__CTFAIL(app_key, td, sptr,
 973                         "%s: constraint failed (%s:%d)",
 974                         td->name, __FILE__, __LINE__);
 975                 return -1;
 976         }
 977 }
 978
 979 /*
 980  * This type is implemented using NativeInteger,
 981  * so here we adjust the DEF accordingly.
 982  */
 983
 984 /*** <<< CTDEFS [M-inv] >>> ***/
 985
 986 static asn_oer_constraints_t asn_OER_type_M_inv_constr_1 CC_NOTUSED = {
 987         { 0, 0 },
 988         -1};
 989
 990 /*** <<< STAT-DEFS [M-inv] >>> ***/
 991
 992 static const ber_tlv_tag_t asn_DEF_M_inv_tags_1[] = {
 993         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 994 };
 995 asn_TYPE_descriptor_t asn_DEF_M_inv = {
 996         "M-inv",
 997         "M-inv",
 998         &asn_OP_NativeInteger,
 999         asn_DEF_M_inv_tags_1,
1000         sizeof(asn_DEF_M_inv_tags_1)
1001                 /sizeof(asn_DEF_M_inv_tags_1[0]), /* 1 */
1002         asn_DEF_M_inv_tags_1,   /* Same as above */
1003         sizeof(asn_DEF_M_inv_tags_1)
1004                 /sizeof(asn_DEF_M_inv_tags_1[0]), /* 1 */
1005         { &asn_OER_type_M_inv_constr_1, 0, M_inv_constraint },
1006         0, 0,   /* No members */
1007         0       /* No specifics */
1008 };
1009
1010
1011 /*** <<< INCLUDES [N-0-5] >>> ***/
1012
1013 #include <NativeInteger.h>
1014
1015 /*** <<< TYPE-DECLS [N-0-5] >>> ***/
1016
1017 typedef long     N_0_5_t;
1018
1019 /*** <<< FUNC-DECLS [N-0-5] >>> ***/
1020
1021 extern asn_TYPE_descriptor_t asn_DEF_N_0_5;
1022 asn_struct_free_f N_0_5_free;
1023 asn_struct_print_f N_0_5_print;
1024 asn_constr_check_f N_0_5_constraint;
1025 ber_type_decoder_f N_0_5_decode_ber;
1026 der_type_encoder_f N_0_5_encode_der;
1027 xer_type_decoder_f N_0_5_decode_xer;
1028 xer_type_encoder_f N_0_5_encode_xer;
1029 oer_type_decoder_f N_0_5_decode_oer;
1030 oer_type_encoder_f N_0_5_encode_oer;
1031
1032 /*** <<< CODE [N-0-5] >>> ***/
1033
1034 int
1035 N_0_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1036                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1037         long value;
1038
1039         if(!sptr) {
1040                 ASN__CTFAIL(app_key, td, sptr,
1041                         "%s: value not given (%s:%d)",
1042                         td->name, __FILE__, __LINE__);
1043                 return -1;
1044         }
1045
1046         value = *(const long *)sptr;
1047
1048         if((value >= 0 && value <= 5)) {
1049                 /* Constraint check succeeded */
1050                 return 0;
1051         } else {
1052                 ASN__CTFAIL(app_key, td, sptr,
1053                         "%s: constraint failed (%s:%d)",
1054                         td->name, __FILE__, __LINE__);
1055                 return -1;
1056         }
1057 }
1058
1059 /*
1060  * This type is implemented using NativeInteger,
1061  * so here we adjust the DEF accordingly.
1062  */
1063
1064 /*** <<< CTDEFS [N-0-5] >>> ***/
1065
1066 static asn_oer_constraints_t asn_OER_type_N_0_5_constr_1 CC_NOTUSED = {
1067         { 1, 1 }        /* (0..5) */,
1068         -1};
1069
1070 /*** <<< STAT-DEFS [N-0-5] >>> ***/
1071
1072 static const ber_tlv_tag_t asn_DEF_N_0_5_tags_1[] = {
1073         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1074 };
1075 asn_TYPE_descriptor_t asn_DEF_N_0_5 = {
1076         "N-0-5",
1077         "N-0-5",
1078         &asn_OP_NativeInteger,
1079         asn_DEF_N_0_5_tags_1,
1080         sizeof(asn_DEF_N_0_5_tags_1)
1081                 /sizeof(asn_DEF_N_0_5_tags_1[0]), /* 1 */
1082         asn_DEF_N_0_5_tags_1,   /* Same as above */
1083         sizeof(asn_DEF_N_0_5_tags_1)
1084                 /sizeof(asn_DEF_N_0_5_tags_1[0]), /* 1 */
1085         { &asn_OER_type_N_0_5_constr_1, 0, N_0_5_constraint },
1086         0, 0,   /* No members */
1087         0       /* No specifics */
1088 };
1089
1090
1091 /*** <<< INCLUDES [O-inv] >>> ***/
1092
1093 #include <NativeInteger.h>
1094
1095 /*** <<< TYPE-DECLS [O-inv] >>> ***/
1096
1097 typedef long     O_inv_t;
1098
1099 /*** <<< FUNC-DECLS [O-inv] >>> ***/
1100
1101 extern asn_TYPE_descriptor_t asn_DEF_O_inv;
1102 asn_struct_free_f O_inv_free;
1103 asn_struct_print_f O_inv_print;
1104 asn_constr_check_f O_inv_constraint;
1105 ber_type_decoder_f O_inv_decode_ber;
1106 der_type_encoder_f O_inv_encode_der;
1107 xer_type_decoder_f O_inv_decode_xer;
1108 xer_type_encoder_f O_inv_encode_xer;
1109 oer_type_decoder_f O_inv_decode_oer;
1110 oer_type_encoder_f O_inv_encode_oer;
1111
1112 /*** <<< CODE [O-inv] >>> ***/
1113
1114 int
1115 O_inv_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1116                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1117         long value;
1118
1119         if(!sptr) {
1120                 ASN__CTFAIL(app_key, td, sptr,
1121                         "%s: value not given (%s:%d)",
1122                         td->name, __FILE__, __LINE__);
1123                 return -1;
1124         }
1125
1126         value = *(const long *)sptr;
1127
1128         if((value >= 0 && value <= 5)) {
1129                 /* Constraint check succeeded */
1130                 return 0;
1131         } else {
1132                 ASN__CTFAIL(app_key, td, sptr,
1133                         "%s: constraint failed (%s:%d)",
1134                         td->name, __FILE__, __LINE__);
1135                 return -1;
1136         }
1137 }
1138
1139 /*
1140  * This type is implemented using NativeInteger,
1141  * so here we adjust the DEF accordingly.
1142  */
1143
1144 /*** <<< CTDEFS [O-inv] >>> ***/
1145
1146 static asn_oer_constraints_t asn_OER_type_O_inv_constr_1 CC_NOTUSED = {
1147         { 0, 0 },
1148         -1};
1149
1150 /*** <<< STAT-DEFS [O-inv] >>> ***/
1151
1152 static const ber_tlv_tag_t asn_DEF_O_inv_tags_1[] = {
1153         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1154 };
1155 asn_TYPE_descriptor_t asn_DEF_O_inv = {
1156         "O-inv",
1157         "O-inv",
1158         &asn_OP_NativeInteger,
1159         asn_DEF_O_inv_tags_1,
1160         sizeof(asn_DEF_O_inv_tags_1)
1161                 /sizeof(asn_DEF_O_inv_tags_1[0]), /* 1 */
1162         asn_DEF_O_inv_tags_1,   /* Same as above */
1163         sizeof(asn_DEF_O_inv_tags_1)
1164                 /sizeof(asn_DEF_O_inv_tags_1[0]), /* 1 */
1165         { &asn_OER_type_O_inv_constr_1, 0, O_inv_constraint },
1166         0, 0,   /* No members */
1167         0       /* No specifics */
1168 };
1169
1170
1171 /*** <<< INCLUDES [EConstr] >>> ***/
1172
1173 #include <NativeInteger.h>
1174
1175 /*** <<< TYPE-DECLS [EConstr] >>> ***/
1176
1177 typedef long     EConstr_t;
1178
1179 /*** <<< FUNC-DECLS [EConstr] >>> ***/
1180
1181 extern asn_TYPE_descriptor_t asn_DEF_EConstr;
1182 asn_struct_free_f EConstr_free;
1183 asn_struct_print_f EConstr_print;
1184 asn_constr_check_f EConstr_constraint;
1185 ber_type_decoder_f EConstr_decode_ber;
1186 der_type_encoder_f EConstr_encode_der;
1187 xer_type_decoder_f EConstr_decode_xer;
1188 xer_type_encoder_f EConstr_encode_xer;
1189 oer_type_decoder_f EConstr_decode_oer;
1190 oer_type_encoder_f EConstr_encode_oer;
1191
1192 /*** <<< CODE [EConstr] >>> ***/
1193
1194 int
1195 EConstr_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1196                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1197         long value;
1198
1199         if(!sptr) {
1200                 ASN__CTFAIL(app_key, td, sptr,
1201                         "%s: value not given (%s:%d)",
1202                         td->name, __FILE__, __LINE__);
1203                 return -1;
1204         }
1205
1206         value = *(const long *)sptr;
1207
1208         if((value >= 1 && value <= 5)) {
1209                 /* Constraint check succeeded */
1210                 return 0;
1211         } else {
1212                 ASN__CTFAIL(app_key, td, sptr,
1213                         "%s: constraint failed (%s:%d)",
1214                         td->name, __FILE__, __LINE__);
1215                 return -1;
1216         }
1217 }
1218
1219 /*
1220  * This type is implemented using NativeInteger,
1221  * so here we adjust the DEF accordingly.
1222  */
1223
1224 /*** <<< CTDEFS [EConstr] >>> ***/
1225
1226 static asn_oer_constraints_t asn_OER_type_EConstr_constr_1 CC_NOTUSED = {
1227         { 0, 0 },
1228         -1};
1229
1230 /*** <<< STAT-DEFS [EConstr] >>> ***/
1231
1232 static const ber_tlv_tag_t asn_DEF_EConstr_tags_1[] = {
1233         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1234 };
1235 asn_TYPE_descriptor_t asn_DEF_EConstr = {
1236         "EConstr",
1237         "EConstr",
1238         &asn_OP_NativeInteger,
1239         asn_DEF_EConstr_tags_1,
1240         sizeof(asn_DEF_EConstr_tags_1)
1241                 /sizeof(asn_DEF_EConstr_tags_1[0]), /* 1 */
1242         asn_DEF_EConstr_tags_1, /* Same as above */
1243         sizeof(asn_DEF_EConstr_tags_1)
1244                 /sizeof(asn_DEF_EConstr_tags_1[0]), /* 1 */
1245         { &asn_OER_type_EConstr_constr_1, 0, EConstr_constraint },
1246         0, 0,   /* No members */
1247         0       /* No specifics */
1248 };
1249
1250
1251 /*** <<< INCLUDES [FConstr] >>> ***/
1252
1253 #include <NativeInteger.h>
1254
1255 /*** <<< TYPE-DECLS [FConstr] >>> ***/
1256
1257 typedef long     FConstr_t;
1258
1259 /*** <<< FUNC-DECLS [FConstr] >>> ***/
1260
1261 extern asn_TYPE_descriptor_t asn_DEF_FConstr;
1262 asn_struct_free_f FConstr_free;
1263 asn_struct_print_f FConstr_print;
1264 asn_constr_check_f FConstr_constraint;
1265 ber_type_decoder_f FConstr_decode_ber;
1266 der_type_encoder_f FConstr_encode_der;
1267 xer_type_decoder_f FConstr_decode_xer;
1268 xer_type_encoder_f FConstr_encode_xer;
1269 oer_type_decoder_f FConstr_decode_oer;
1270 oer_type_encoder_f FConstr_encode_oer;
1271
1272 /*** <<< CODE [FConstr] >>> ***/
1273
1274 int
1275 FConstr_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1276                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1277         long value;
1278
1279         if(!sptr) {
1280                 ASN__CTFAIL(app_key, td, sptr,
1281                         "%s: value not given (%s:%d)",
1282                         td->name, __FILE__, __LINE__);
1283                 return -1;
1284         }
1285
1286         value = *(const long *)sptr;
1287
1288         if((value >= 0 && value <= 4)) {
1289                 /* Constraint check succeeded */
1290                 return 0;
1291         } else {
1292                 ASN__CTFAIL(app_key, td, sptr,
1293                         "%s: constraint failed (%s:%d)",
1294                         td->name, __FILE__, __LINE__);
1295                 return -1;
1296         }
1297 }
1298
1299 /*
1300  * This type is implemented using NativeInteger,
1301  * so here we adjust the DEF accordingly.
1302  */
1303
1304 /*** <<< CTDEFS [FConstr] >>> ***/
1305
1306 static asn_oer_constraints_t asn_OER_type_FConstr_constr_1 CC_NOTUSED = {
1307         { 1, 1 }        /* (0..4) */,
1308         -1};
1309
1310 /*** <<< STAT-DEFS [FConstr] >>> ***/
1311
1312 static const ber_tlv_tag_t asn_DEF_FConstr_tags_1[] = {
1313         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1314 };
1315 asn_TYPE_descriptor_t asn_DEF_FConstr = {
1316         "FConstr",
1317         "FConstr",
1318         &asn_OP_NativeInteger,
1319         asn_DEF_FConstr_tags_1,
1320         sizeof(asn_DEF_FConstr_tags_1)
1321                 /sizeof(asn_DEF_FConstr_tags_1[0]), /* 1 */
1322         asn_DEF_FConstr_tags_1, /* Same as above */
1323         sizeof(asn_DEF_FConstr_tags_1)
1324                 /sizeof(asn_DEF_FConstr_tags_1[0]), /* 1 */
1325         { &asn_OER_type_FConstr_constr_1, 0, FConstr_constraint },
1326         0, 0,   /* No members */
1327         0       /* No specifics */
1328 };
1329