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

   1
   2 /*** <<< INCLUDES [CN-IntegerUnlimited] >>> ***/
   3
   4 #include <NativeInteger.h>
   5
   6 /*** <<< TYPE-DECLS [CN-IntegerUnlimited] >>> ***/
   7
   8 typedef long     CN_IntegerUnlimited_t;
   9
  10 /*** <<< FUNC-DECLS [CN-IntegerUnlimited] >>> ***/
  11
  12 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited;
  13 asn_struct_free_f CN_IntegerUnlimited_free;
  14 asn_struct_print_f CN_IntegerUnlimited_print;
  15 asn_constr_check_f CN_IntegerUnlimited_constraint;
  16 ber_type_decoder_f CN_IntegerUnlimited_decode_ber;
  17 der_type_encoder_f CN_IntegerUnlimited_encode_der;
  18 xer_type_decoder_f CN_IntegerUnlimited_decode_xer;
  19 xer_type_encoder_f CN_IntegerUnlimited_encode_xer;
  20
  21 /*** <<< CODE [CN-IntegerUnlimited] >>> ***/
  22
  23 /*
  24  * This type is implemented using NativeInteger,
  25  * so here we adjust the DEF accordingly.
  26  */
  27
  28 /*** <<< STAT-DEFS [CN-IntegerUnlimited] >>> ***/
  29
  30 static const ber_tlv_tag_t asn_DEF_CN_IntegerUnlimited_tags_1[] = {
  31         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
  32 };
  33 asn_TYPE_descriptor_t asn_DEF_CN_IntegerUnlimited = {
  34         "CN-IntegerUnlimited",
  35         "CN-IntegerUnlimited",
  36         &asn_OP_NativeInteger,
  37         asn_DEF_CN_IntegerUnlimited_tags_1,
  38         sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
  39                 /sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
  40         asn_DEF_CN_IntegerUnlimited_tags_1,     /* Same as above */
  41         sizeof(asn_DEF_CN_IntegerUnlimited_tags_1)
  42                 /sizeof(asn_DEF_CN_IntegerUnlimited_tags_1[0]), /* 1 */
  43         { 0, 0, NativeInteger_constraint },
  44         0, 0,   /* No members */
  45         0       /* No specifics */
  46 };
  47
  48
  49 /*** <<< INCLUDES [CN-IntegerMinMax] >>> ***/
  50
  51 #include <NativeInteger.h>
  52
  53 /*** <<< TYPE-DECLS [CN-IntegerMinMax] >>> ***/
  54
  55 typedef long     CN_IntegerMinMax_t;
  56
  57 /*** <<< FUNC-DECLS [CN-IntegerMinMax] >>> ***/
  58
  59 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax;
  60 asn_struct_free_f CN_IntegerMinMax_free;
  61 asn_struct_print_f CN_IntegerMinMax_print;
  62 asn_constr_check_f CN_IntegerMinMax_constraint;
  63 ber_type_decoder_f CN_IntegerMinMax_decode_ber;
  64 der_type_encoder_f CN_IntegerMinMax_encode_der;
  65 xer_type_decoder_f CN_IntegerMinMax_decode_xer;
  66 xer_type_encoder_f CN_IntegerMinMax_encode_xer;
  67
  68 /*** <<< CODE [CN-IntegerMinMax] >>> ***/
  69
  70 int
  71 CN_IntegerMinMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
  72                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  73
  74         if(!sptr) {
  75                 ASN__CTFAIL(app_key, td, sptr,
  76                         "%s: value not given (%s:%d)",
  77                         td->name, __FILE__, __LINE__);
  78                 return -1;
  79         }
  80
  81
  82         if(1 /* No applicable constraints whatsoever */) {
  83                 /* Nothing is here. See below */
  84         }
  85
  86         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
  87 }
  88
  89 /*
  90  * This type is implemented using NativeInteger,
  91  * so here we adjust the DEF accordingly.
  92  */
  93
  94 /*** <<< STAT-DEFS [CN-IntegerMinMax] >>> ***/
  95
  96 static const ber_tlv_tag_t asn_DEF_CN_IntegerMinMax_tags_1[] = {
  97         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
  98 };
  99 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinMax = {
 100         "CN-IntegerMinMax",
 101         "CN-IntegerMinMax",
 102         &asn_OP_NativeInteger,
 103         asn_DEF_CN_IntegerMinMax_tags_1,
 104         sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
 105                 /sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
 106         asn_DEF_CN_IntegerMinMax_tags_1,        /* Same as above */
 107         sizeof(asn_DEF_CN_IntegerMinMax_tags_1)
 108                 /sizeof(asn_DEF_CN_IntegerMinMax_tags_1[0]), /* 1 */
 109         { 0, 0, CN_IntegerMinMax_constraint },
 110         0, 0,   /* No members */
 111         0       /* No specifics */
 112 };
 113
 114
 115 /*** <<< INCLUDES [CN-IntegerMinLow] >>> ***/
 116
 117 #include <NativeInteger.h>
 118
 119 /*** <<< TYPE-DECLS [CN-IntegerMinLow] >>> ***/
 120
 121 typedef long     CN_IntegerMinLow_t;
 122
 123 /*** <<< FUNC-DECLS [CN-IntegerMinLow] >>> ***/
 124
 125 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow;
 126 asn_struct_free_f CN_IntegerMinLow_free;
 127 asn_struct_print_f CN_IntegerMinLow_print;
 128 asn_constr_check_f CN_IntegerMinLow_constraint;
 129 ber_type_decoder_f CN_IntegerMinLow_decode_ber;
 130 der_type_encoder_f CN_IntegerMinLow_encode_der;
 131 xer_type_decoder_f CN_IntegerMinLow_decode_xer;
 132 xer_type_encoder_f CN_IntegerMinLow_encode_xer;
 133
 134 /*** <<< CODE [CN-IntegerMinLow] >>> ***/
 135
 136 int
 137 CN_IntegerMinLow_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 138                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 139         long value;
 140
 141         if(!sptr) {
 142                 ASN__CTFAIL(app_key, td, sptr,
 143                         "%s: value not given (%s:%d)",
 144                         td->name, __FILE__, __LINE__);
 145                 return -1;
 146         }
 147
 148         value = *(const long *)sptr;
 149
 150         if((value <= 1)) {
 151                 /* Constraint check succeeded */
 152                 return 0;
 153         } else {
 154                 ASN__CTFAIL(app_key, td, sptr,
 155                         "%s: constraint failed (%s:%d)",
 156                         td->name, __FILE__, __LINE__);
 157                 return -1;
 158         }
 159 }
 160
 161 /*
 162  * This type is implemented using NativeInteger,
 163  * so here we adjust the DEF accordingly.
 164  */
 165
 166 /*** <<< STAT-DEFS [CN-IntegerMinLow] >>> ***/
 167
 168 static const ber_tlv_tag_t asn_DEF_CN_IntegerMinLow_tags_1[] = {
 169         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 170 };
 171 asn_TYPE_descriptor_t asn_DEF_CN_IntegerMinLow = {
 172         "CN-IntegerMinLow",
 173         "CN-IntegerMinLow",
 174         &asn_OP_NativeInteger,
 175         asn_DEF_CN_IntegerMinLow_tags_1,
 176         sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
 177                 /sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
 178         asn_DEF_CN_IntegerMinLow_tags_1,        /* Same as above */
 179         sizeof(asn_DEF_CN_IntegerMinLow_tags_1)
 180                 /sizeof(asn_DEF_CN_IntegerMinLow_tags_1[0]), /* 1 */
 181         { 0, 0, CN_IntegerMinLow_constraint },
 182         0, 0,   /* No members */
 183         0       /* No specifics */
 184 };
 185
 186
 187 /*** <<< INCLUDES [NO-IntegerMinHigh] >>> ***/
 188
 189 #include <INTEGER.h>
 190
 191 /*** <<< TYPE-DECLS [NO-IntegerMinHigh] >>> ***/
 192
 193 typedef INTEGER_t        NO_IntegerMinHigh_t;
 194
 195 /*** <<< FUNC-DECLS [NO-IntegerMinHigh] >>> ***/
 196
 197 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh;
 198 asn_struct_free_f NO_IntegerMinHigh_free;
 199 asn_struct_print_f NO_IntegerMinHigh_print;
 200 asn_constr_check_f NO_IntegerMinHigh_constraint;
 201 ber_type_decoder_f NO_IntegerMinHigh_decode_ber;
 202 der_type_encoder_f NO_IntegerMinHigh_encode_der;
 203 xer_type_decoder_f NO_IntegerMinHigh_decode_xer;
 204 xer_type_encoder_f NO_IntegerMinHigh_encode_xer;
 205
 206 /*** <<< CODE [NO-IntegerMinHigh] >>> ***/
 207
 208 int
 209 NO_IntegerMinHigh_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 210                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 211         const INTEGER_t *st = (const INTEGER_t *)sptr;
 212         long value;
 213
 214         if(!sptr) {
 215                 ASN__CTFAIL(app_key, td, sptr,
 216                         "%s: value not given (%s:%d)",
 217                         td->name, __FILE__, __LINE__);
 218                 return -1;
 219         }
 220
 221         if(asn_INTEGER2long(st, &value)) {
 222                 ASN__CTFAIL(app_key, td, sptr,
 223                         "%s: value too large (%s:%d)",
 224                         td->name, __FILE__, __LINE__);
 225                 return -1;
 226         }
 227
 228         if((value <= 3000000000)) {
 229                 /* Constraint check succeeded */
 230                 return 0;
 231         } else {
 232                 ASN__CTFAIL(app_key, td, sptr,
 233                         "%s: constraint failed (%s:%d)",
 234                         td->name, __FILE__, __LINE__);
 235                 return -1;
 236         }
 237 }
 238
 239 /*
 240  * This type is implemented using INTEGER,
 241  * so here we adjust the DEF accordingly.
 242  */
 243
 244 /*** <<< STAT-DEFS [NO-IntegerMinHigh] >>> ***/
 245
 246 static const ber_tlv_tag_t asn_DEF_NO_IntegerMinHigh_tags_1[] = {
 247         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 248 };
 249 asn_TYPE_descriptor_t asn_DEF_NO_IntegerMinHigh = {
 250         "NO-IntegerMinHigh",
 251         "NO-IntegerMinHigh",
 252         &asn_OP_INTEGER,
 253         asn_DEF_NO_IntegerMinHigh_tags_1,
 254         sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
 255                 /sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
 256         asn_DEF_NO_IntegerMinHigh_tags_1,       /* Same as above */
 257         sizeof(asn_DEF_NO_IntegerMinHigh_tags_1)
 258                 /sizeof(asn_DEF_NO_IntegerMinHigh_tags_1[0]), /* 1 */
 259         { 0, 0, NO_IntegerMinHigh_constraint },
 260         0, 0,   /* No members */
 261         0       /* No specifics */
 262 };
 263
 264
 265 /*** <<< INCLUDES [NO-IntegerLowHigh] >>> ***/
 266
 267 #include <NativeInteger.h>
 268
 269 /*** <<< TYPE-DECLS [NO-IntegerLowHigh] >>> ***/
 270
 271 typedef unsigned long    NO_IntegerLowHigh_t;
 272
 273 /*** <<< FUNC-DECLS [NO-IntegerLowHigh] >>> ***/
 274
 275 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh;
 276 asn_struct_free_f NO_IntegerLowHigh_free;
 277 asn_struct_print_f NO_IntegerLowHigh_print;
 278 asn_constr_check_f NO_IntegerLowHigh_constraint;
 279 ber_type_decoder_f NO_IntegerLowHigh_decode_ber;
 280 der_type_encoder_f NO_IntegerLowHigh_encode_der;
 281 xer_type_decoder_f NO_IntegerLowHigh_decode_xer;
 282 xer_type_encoder_f NO_IntegerLowHigh_encode_xer;
 283
 284 /*** <<< CODE [NO-IntegerLowHigh] >>> ***/
 285
 286 int
 287 NO_IntegerLowHigh_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 288                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 289         unsigned long value;
 290
 291         if(!sptr) {
 292                 ASN__CTFAIL(app_key, td, sptr,
 293                         "%s: value not given (%s:%d)",
 294                         td->name, __FILE__, __LINE__);
 295                 return -1;
 296         }
 297
 298         value = *(const unsigned long *)sptr;
 299
 300         if((value >= 1 && value <= 3000000000)) {
 301                 /* Constraint check succeeded */
 302                 return 0;
 303         } else {
 304                 ASN__CTFAIL(app_key, td, sptr,
 305                         "%s: constraint failed (%s:%d)",
 306                         td->name, __FILE__, __LINE__);
 307                 return -1;
 308         }
 309 }
 310
 311 /*
 312  * This type is implemented using NativeInteger,
 313  * so here we adjust the DEF accordingly.
 314  */
 315
 316 /*** <<< STAT-DEFS [NO-IntegerLowHigh] >>> ***/
 317
 318 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerLowHigh_specs_1 = {
 319         0,      0,      0,      0,      0,
 320         0,      /* Native long size */
 321         1       /* Unsigned representation */
 322 };
 323 static const ber_tlv_tag_t asn_DEF_NO_IntegerLowHigh_tags_1[] = {
 324         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 325 };
 326 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowHigh = {
 327         "NO-IntegerLowHigh",
 328         "NO-IntegerLowHigh",
 329         &asn_OP_NativeInteger,
 330         asn_DEF_NO_IntegerLowHigh_tags_1,
 331         sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
 332                 /sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
 333         asn_DEF_NO_IntegerLowHigh_tags_1,       /* Same as above */
 334         sizeof(asn_DEF_NO_IntegerLowHigh_tags_1)
 335                 /sizeof(asn_DEF_NO_IntegerLowHigh_tags_1[0]), /* 1 */
 336         { 0, 0, NO_IntegerLowHigh_constraint },
 337         0, 0,   /* No members */
 338         &asn_SPC_NO_IntegerLowHigh_specs_1      /* Additional specs */
 339 };
 340
 341
 342 /*** <<< INCLUDES [CN-IntegerLowMax] >>> ***/
 343
 344 #include <NativeInteger.h>
 345
 346 /*** <<< TYPE-DECLS [CN-IntegerLowMax] >>> ***/
 347
 348 typedef unsigned long    CN_IntegerLowMax_t;
 349
 350 /*** <<< FUNC-DECLS [CN-IntegerLowMax] >>> ***/
 351
 352 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax;
 353 asn_struct_free_f CN_IntegerLowMax_free;
 354 asn_struct_print_f CN_IntegerLowMax_print;
 355 asn_constr_check_f CN_IntegerLowMax_constraint;
 356 ber_type_decoder_f CN_IntegerLowMax_decode_ber;
 357 der_type_encoder_f CN_IntegerLowMax_encode_der;
 358 xer_type_decoder_f CN_IntegerLowMax_decode_xer;
 359 xer_type_encoder_f CN_IntegerLowMax_encode_xer;
 360
 361 /*** <<< CODE [CN-IntegerLowMax] >>> ***/
 362
 363 int
 364 CN_IntegerLowMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 365                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 366         unsigned long value;
 367
 368         if(!sptr) {
 369                 ASN__CTFAIL(app_key, td, sptr,
 370                         "%s: value not given (%s:%d)",
 371                         td->name, __FILE__, __LINE__);
 372                 return -1;
 373         }
 374
 375         value = *(const unsigned long *)sptr;
 376
 377         if((value >= 1)) {
 378                 /* Constraint check succeeded */
 379                 return 0;
 380         } else {
 381                 ASN__CTFAIL(app_key, td, sptr,
 382                         "%s: constraint failed (%s:%d)",
 383                         td->name, __FILE__, __LINE__);
 384                 return -1;
 385         }
 386 }
 387
 388 /*
 389  * This type is implemented using NativeInteger,
 390  * so here we adjust the DEF accordingly.
 391  */
 392
 393 /*** <<< STAT-DEFS [CN-IntegerLowMax] >>> ***/
 394
 395 static const asn_INTEGER_specifics_t asn_SPC_CN_IntegerLowMax_specs_1 = {
 396         0,      0,      0,      0,      0,
 397         0,      /* Native long size */
 398         1       /* Unsigned representation */
 399 };
 400 static const ber_tlv_tag_t asn_DEF_CN_IntegerLowMax_tags_1[] = {
 401         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 402 };
 403 asn_TYPE_descriptor_t asn_DEF_CN_IntegerLowMax = {
 404         "CN-IntegerLowMax",
 405         "CN-IntegerLowMax",
 406         &asn_OP_NativeInteger,
 407         asn_DEF_CN_IntegerLowMax_tags_1,
 408         sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
 409                 /sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
 410         asn_DEF_CN_IntegerLowMax_tags_1,        /* Same as above */
 411         sizeof(asn_DEF_CN_IntegerLowMax_tags_1)
 412                 /sizeof(asn_DEF_CN_IntegerLowMax_tags_1[0]), /* 1 */
 413         { 0, 0, CN_IntegerLowMax_constraint },
 414         0, 0,   /* No members */
 415         &asn_SPC_CN_IntegerLowMax_specs_1       /* Additional specs */
 416 };
 417
 418
 419 /*** <<< INCLUDES [NO-IntegerHighMax] >>> ***/
 420
 421 #include <INTEGER.h>
 422
 423 /*** <<< TYPE-DECLS [NO-IntegerHighMax] >>> ***/
 424
 425 typedef INTEGER_t        NO_IntegerHighMax_t;
 426
 427 /*** <<< FUNC-DECLS [NO-IntegerHighMax] >>> ***/
 428
 429 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax;
 430 asn_struct_free_f NO_IntegerHighMax_free;
 431 asn_struct_print_f NO_IntegerHighMax_print;
 432 asn_constr_check_f NO_IntegerHighMax_constraint;
 433 ber_type_decoder_f NO_IntegerHighMax_decode_ber;
 434 der_type_encoder_f NO_IntegerHighMax_encode_der;
 435 xer_type_decoder_f NO_IntegerHighMax_decode_xer;
 436 xer_type_encoder_f NO_IntegerHighMax_encode_xer;
 437
 438 /*** <<< CODE [NO-IntegerHighMax] >>> ***/
 439
 440 int
 441 NO_IntegerHighMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 442                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 443         const INTEGER_t *st = (const INTEGER_t *)sptr;
 444         long value;
 445
 446         if(!sptr) {
 447                 ASN__CTFAIL(app_key, td, sptr,
 448                         "%s: value not given (%s:%d)",
 449                         td->name, __FILE__, __LINE__);
 450                 return -1;
 451         }
 452
 453         if(asn_INTEGER2long(st, &value)) {
 454                 ASN__CTFAIL(app_key, td, sptr,
 455                         "%s: value too large (%s:%d)",
 456                         td->name, __FILE__, __LINE__);
 457                 return -1;
 458         }
 459
 460         if((value >= 3000000000)) {
 461                 /* Constraint check succeeded */
 462                 return 0;
 463         } else {
 464                 ASN__CTFAIL(app_key, td, sptr,
 465                         "%s: constraint failed (%s:%d)",
 466                         td->name, __FILE__, __LINE__);
 467                 return -1;
 468         }
 469 }
 470
 471 /*
 472  * This type is implemented using INTEGER,
 473  * so here we adjust the DEF accordingly.
 474  */
 475
 476 /*** <<< STAT-DEFS [NO-IntegerHighMax] >>> ***/
 477
 478 static const ber_tlv_tag_t asn_DEF_NO_IntegerHighMax_tags_1[] = {
 479         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 480 };
 481 asn_TYPE_descriptor_t asn_DEF_NO_IntegerHighMax = {
 482         "NO-IntegerHighMax",
 483         "NO-IntegerHighMax",
 484         &asn_OP_INTEGER,
 485         asn_DEF_NO_IntegerHighMax_tags_1,
 486         sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
 487                 /sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
 488         asn_DEF_NO_IntegerHighMax_tags_1,       /* Same as above */
 489         sizeof(asn_DEF_NO_IntegerHighMax_tags_1)
 490                 /sizeof(asn_DEF_NO_IntegerHighMax_tags_1[0]), /* 1 */
 491         { 0, 0, NO_IntegerHighMax_constraint },
 492         0, 0,   /* No members */
 493         0       /* No specifics */
 494 };
 495
 496
 497 /*** <<< INCLUDES [NO-IntegerLowestMax] >>> ***/
 498
 499 #include <INTEGER.h>
 500
 501 /*** <<< TYPE-DECLS [NO-IntegerLowestMax] >>> ***/
 502
 503 typedef INTEGER_t        NO_IntegerLowestMax_t;
 504
 505 /*** <<< FUNC-DECLS [NO-IntegerLowestMax] >>> ***/
 506
 507 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax;
 508 asn_struct_free_f NO_IntegerLowestMax_free;
 509 asn_struct_print_f NO_IntegerLowestMax_print;
 510 asn_constr_check_f NO_IntegerLowestMax_constraint;
 511 ber_type_decoder_f NO_IntegerLowestMax_decode_ber;
 512 der_type_encoder_f NO_IntegerLowestMax_encode_der;
 513 xer_type_decoder_f NO_IntegerLowestMax_decode_xer;
 514 xer_type_encoder_f NO_IntegerLowestMax_encode_xer;
 515
 516 /*** <<< CODE [NO-IntegerLowestMax] >>> ***/
 517
 518 int
 519 NO_IntegerLowestMax_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 520                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 521         const INTEGER_t *st = (const INTEGER_t *)sptr;
 522         long value;
 523
 524         if(!sptr) {
 525                 ASN__CTFAIL(app_key, td, sptr,
 526                         "%s: value not given (%s:%d)",
 527                         td->name, __FILE__, __LINE__);
 528                 return -1;
 529         }
 530
 531         if(asn_INTEGER2long(st, &value)) {
 532                 ASN__CTFAIL(app_key, td, sptr,
 533                         "%s: value too large (%s:%d)",
 534                         td->name, __FILE__, __LINE__);
 535                 return -1;
 536         }
 537
 538         if((value >= -3000000000)) {
 539                 /* Constraint check succeeded */
 540                 return 0;
 541         } else {
 542                 ASN__CTFAIL(app_key, td, sptr,
 543                         "%s: constraint failed (%s:%d)",
 544                         td->name, __FILE__, __LINE__);
 545                 return -1;
 546         }
 547 }
 548
 549 /*
 550  * This type is implemented using INTEGER,
 551  * so here we adjust the DEF accordingly.
 552  */
 553
 554 /*** <<< STAT-DEFS [NO-IntegerLowestMax] >>> ***/
 555
 556 static const ber_tlv_tag_t asn_DEF_NO_IntegerLowestMax_tags_1[] = {
 557         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 558 };
 559 asn_TYPE_descriptor_t asn_DEF_NO_IntegerLowestMax = {
 560         "NO-IntegerLowestMax",
 561         "NO-IntegerLowestMax",
 562         &asn_OP_INTEGER,
 563         asn_DEF_NO_IntegerLowestMax_tags_1,
 564         sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
 565                 /sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
 566         asn_DEF_NO_IntegerLowestMax_tags_1,     /* Same as above */
 567         sizeof(asn_DEF_NO_IntegerLowestMax_tags_1)
 568                 /sizeof(asn_DEF_NO_IntegerLowestMax_tags_1[0]), /* 1 */
 569         { 0, 0, NO_IntegerLowestMax_constraint },
 570         0, 0,   /* No members */
 571         0       /* No specifics */
 572 };
 573
 574
 575 /*** <<< INCLUDES [NO-IntegerOutRange] >>> ***/
 576
 577 #include <NativeInteger.h>
 578
 579 /*** <<< TYPE-DECLS [NO-IntegerOutRange] >>> ***/
 580
 581 typedef unsigned long    NO_IntegerOutRange_t;
 582
 583 /*** <<< FUNC-DECLS [NO-IntegerOutRange] >>> ***/
 584
 585 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange;
 586 asn_struct_free_f NO_IntegerOutRange_free;
 587 asn_struct_print_f NO_IntegerOutRange_print;
 588 asn_constr_check_f NO_IntegerOutRange_constraint;
 589 ber_type_decoder_f NO_IntegerOutRange_decode_ber;
 590 der_type_encoder_f NO_IntegerOutRange_encode_der;
 591 xer_type_decoder_f NO_IntegerOutRange_decode_xer;
 592 xer_type_encoder_f NO_IntegerOutRange_encode_xer;
 593
 594 /*** <<< CODE [NO-IntegerOutRange] >>> ***/
 595
 596 int
 597 NO_IntegerOutRange_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 598                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 599         unsigned long value;
 600
 601         if(!sptr) {
 602                 ASN__CTFAIL(app_key, td, sptr,
 603                         "%s: value not given (%s:%d)",
 604                         td->name, __FILE__, __LINE__);
 605                 return -1;
 606         }
 607
 608         value = *(const unsigned long *)sptr;
 609
 610         if((value >= 3000000000 && value <= 3000000001)) {
 611                 /* Constraint check succeeded */
 612                 return 0;
 613         } else {
 614                 ASN__CTFAIL(app_key, td, sptr,
 615                         "%s: constraint failed (%s:%d)",
 616                         td->name, __FILE__, __LINE__);
 617                 return -1;
 618         }
 619 }
 620
 621 /*
 622  * This type is implemented using NativeInteger,
 623  * so here we adjust the DEF accordingly.
 624  */
 625
 626 /*** <<< STAT-DEFS [NO-IntegerOutRange] >>> ***/
 627
 628 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutRange_specs_1 = {
 629         0,      0,      0,      0,      0,
 630         0,      /* Native long size */
 631         1       /* Unsigned representation */
 632 };
 633 static const ber_tlv_tag_t asn_DEF_NO_IntegerOutRange_tags_1[] = {
 634         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 635 };
 636 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutRange = {
 637         "NO-IntegerOutRange",
 638         "NO-IntegerOutRange",
 639         &asn_OP_NativeInteger,
 640         asn_DEF_NO_IntegerOutRange_tags_1,
 641         sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
 642                 /sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
 643         asn_DEF_NO_IntegerOutRange_tags_1,      /* Same as above */
 644         sizeof(asn_DEF_NO_IntegerOutRange_tags_1)
 645                 /sizeof(asn_DEF_NO_IntegerOutRange_tags_1[0]), /* 1 */
 646         { 0, 0, NO_IntegerOutRange_constraint },
 647         0, 0,   /* No members */
 648         &asn_SPC_NO_IntegerOutRange_specs_1     /* Additional specs */
 649 };
 650
 651
 652 /*** <<< INCLUDES [NO-IntegerOutValue] >>> ***/
 653
 654 #include <NativeInteger.h>
 655
 656 /*** <<< TYPE-DECLS [NO-IntegerOutValue] >>> ***/
 657
 658 typedef unsigned long    NO_IntegerOutValue_t;
 659
 660 /*** <<< FUNC-DECLS [NO-IntegerOutValue] >>> ***/
 661
 662 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue;
 663 asn_struct_free_f NO_IntegerOutValue_free;
 664 asn_struct_print_f NO_IntegerOutValue_print;
 665 asn_constr_check_f NO_IntegerOutValue_constraint;
 666 ber_type_decoder_f NO_IntegerOutValue_decode_ber;
 667 der_type_encoder_f NO_IntegerOutValue_encode_der;
 668 xer_type_decoder_f NO_IntegerOutValue_decode_xer;
 669 xer_type_encoder_f NO_IntegerOutValue_encode_xer;
 670
 671 /*** <<< CODE [NO-IntegerOutValue] >>> ***/
 672
 673 int
 674 NO_IntegerOutValue_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 675                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 676         unsigned long value;
 677
 678         if(!sptr) {
 679                 ASN__CTFAIL(app_key, td, sptr,
 680                         "%s: value not given (%s:%d)",
 681                         td->name, __FILE__, __LINE__);
 682                 return -1;
 683         }
 684
 685         value = *(const unsigned long *)sptr;
 686
 687         if((value == 3000000000)) {
 688                 /* Constraint check succeeded */
 689                 return 0;
 690         } else {
 691                 ASN__CTFAIL(app_key, td, sptr,
 692                         "%s: constraint failed (%s:%d)",
 693                         td->name, __FILE__, __LINE__);
 694                 return -1;
 695         }
 696 }
 697
 698 /*
 699  * This type is implemented using NativeInteger,
 700  * so here we adjust the DEF accordingly.
 701  */
 702
 703 /*** <<< STAT-DEFS [NO-IntegerOutValue] >>> ***/
 704
 705 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerOutValue_specs_1 = {
 706         0,      0,      0,      0,      0,
 707         0,      /* Native long size */
 708         1       /* Unsigned representation */
 709 };
 710 static const ber_tlv_tag_t asn_DEF_NO_IntegerOutValue_tags_1[] = {
 711         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 712 };
 713 asn_TYPE_descriptor_t asn_DEF_NO_IntegerOutValue = {
 714         "NO-IntegerOutValue",
 715         "NO-IntegerOutValue",
 716         &asn_OP_NativeInteger,
 717         asn_DEF_NO_IntegerOutValue_tags_1,
 718         sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
 719                 /sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
 720         asn_DEF_NO_IntegerOutValue_tags_1,      /* Same as above */
 721         sizeof(asn_DEF_NO_IntegerOutValue_tags_1)
 722                 /sizeof(asn_DEF_NO_IntegerOutValue_tags_1[0]), /* 1 */
 723         { 0, 0, NO_IntegerOutValue_constraint },
 724         0, 0,   /* No members */
 725         &asn_SPC_NO_IntegerOutValue_specs_1     /* Additional specs */
 726 };
 727
 728
 729 /*** <<< INCLUDES [OK-IntegerInRange1] >>> ***/
 730
 731 #include <NativeInteger.h>
 732
 733 /*** <<< TYPE-DECLS [OK-IntegerInRange1] >>> ***/
 734
 735 typedef long     OK_IntegerInRange1_t;
 736
 737 /*** <<< FUNC-DECLS [OK-IntegerInRange1] >>> ***/
 738
 739 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1;
 740 asn_struct_free_f OK_IntegerInRange1_free;
 741 asn_struct_print_f OK_IntegerInRange1_print;
 742 asn_constr_check_f OK_IntegerInRange1_constraint;
 743 ber_type_decoder_f OK_IntegerInRange1_decode_ber;
 744 der_type_encoder_f OK_IntegerInRange1_encode_der;
 745 xer_type_decoder_f OK_IntegerInRange1_decode_xer;
 746 xer_type_encoder_f OK_IntegerInRange1_encode_xer;
 747
 748 /*** <<< CODE [OK-IntegerInRange1] >>> ***/
 749
 750 int
 751 OK_IntegerInRange1_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 752                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 753         long value;
 754
 755         if(!sptr) {
 756                 ASN__CTFAIL(app_key, td, sptr,
 757                         "%s: value not given (%s:%d)",
 758                         td->name, __FILE__, __LINE__);
 759                 return -1;
 760         }
 761
 762         value = *(const long *)sptr;
 763
 764         if((value >= -100 && value <= 100)) {
 765                 /* Constraint check succeeded */
 766                 return 0;
 767         } else {
 768                 ASN__CTFAIL(app_key, td, sptr,
 769                         "%s: constraint failed (%s:%d)",
 770                         td->name, __FILE__, __LINE__);
 771                 return -1;
 772         }
 773 }
 774
 775 /*
 776  * This type is implemented using NativeInteger,
 777  * so here we adjust the DEF accordingly.
 778  */
 779
 780 /*** <<< STAT-DEFS [OK-IntegerInRange1] >>> ***/
 781
 782 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange1_tags_1[] = {
 783         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 784 };
 785 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange1 = {
 786         "OK-IntegerInRange1",
 787         "OK-IntegerInRange1",
 788         &asn_OP_NativeInteger,
 789         asn_DEF_OK_IntegerInRange1_tags_1,
 790         sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
 791                 /sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
 792         asn_DEF_OK_IntegerInRange1_tags_1,      /* Same as above */
 793         sizeof(asn_DEF_OK_IntegerInRange1_tags_1)
 794                 /sizeof(asn_DEF_OK_IntegerInRange1_tags_1[0]), /* 1 */
 795         { 0, 0, OK_IntegerInRange1_constraint },
 796         0, 0,   /* No members */
 797         0       /* No specifics */
 798 };
 799
 800
 801 /*** <<< INCLUDES [OK-IntegerInRange2] >>> ***/
 802
 803 #include <NativeInteger.h>
 804
 805 /*** <<< TYPE-DECLS [OK-IntegerInRange2] >>> ***/
 806
 807 typedef long     OK_IntegerInRange2_t;
 808
 809 /*** <<< FUNC-DECLS [OK-IntegerInRange2] >>> ***/
 810
 811 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2;
 812 asn_struct_free_f OK_IntegerInRange2_free;
 813 asn_struct_print_f OK_IntegerInRange2_print;
 814 asn_constr_check_f OK_IntegerInRange2_constraint;
 815 ber_type_decoder_f OK_IntegerInRange2_decode_ber;
 816 der_type_encoder_f OK_IntegerInRange2_encode_der;
 817 xer_type_decoder_f OK_IntegerInRange2_decode_xer;
 818 xer_type_encoder_f OK_IntegerInRange2_encode_xer;
 819
 820 /*** <<< CODE [OK-IntegerInRange2] >>> ***/
 821
 822 int
 823 OK_IntegerInRange2_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 824                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 825         long value;
 826
 827         if(!sptr) {
 828                 ASN__CTFAIL(app_key, td, sptr,
 829                         "%s: value not given (%s:%d)",
 830                         td->name, __FILE__, __LINE__);
 831                 return -1;
 832         }
 833
 834         value = *(const long *)sptr;
 835
 836         if(((value == -100) || (value == 100))) {
 837                 /* Constraint check succeeded */
 838                 return 0;
 839         } else {
 840                 ASN__CTFAIL(app_key, td, sptr,
 841                         "%s: constraint failed (%s:%d)",
 842                         td->name, __FILE__, __LINE__);
 843                 return -1;
 844         }
 845 }
 846
 847 /*
 848  * This type is implemented using NativeInteger,
 849  * so here we adjust the DEF accordingly.
 850  */
 851
 852 /*** <<< STAT-DEFS [OK-IntegerInRange2] >>> ***/
 853
 854 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange2_tags_1[] = {
 855         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 856 };
 857 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange2 = {
 858         "OK-IntegerInRange2",
 859         "OK-IntegerInRange2",
 860         &asn_OP_NativeInteger,
 861         asn_DEF_OK_IntegerInRange2_tags_1,
 862         sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
 863                 /sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
 864         asn_DEF_OK_IntegerInRange2_tags_1,      /* Same as above */
 865         sizeof(asn_DEF_OK_IntegerInRange2_tags_1)
 866                 /sizeof(asn_DEF_OK_IntegerInRange2_tags_1[0]), /* 1 */
 867         { 0, 0, OK_IntegerInRange2_constraint },
 868         0, 0,   /* No members */
 869         0       /* No specifics */
 870 };
 871
 872
 873 /*** <<< INCLUDES [OK-IntegerInRange3] >>> ***/
 874
 875 #include <NativeInteger.h>
 876
 877 /*** <<< TYPE-DECLS [OK-IntegerInRange3] >>> ***/
 878
 879 typedef long     OK_IntegerInRange3_t;
 880
 881 /*** <<< FUNC-DECLS [OK-IntegerInRange3] >>> ***/
 882
 883 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3;
 884 asn_struct_free_f OK_IntegerInRange3_free;
 885 asn_struct_print_f OK_IntegerInRange3_print;
 886 asn_constr_check_f OK_IntegerInRange3_constraint;
 887 ber_type_decoder_f OK_IntegerInRange3_decode_ber;
 888 der_type_encoder_f OK_IntegerInRange3_encode_der;
 889 xer_type_decoder_f OK_IntegerInRange3_decode_xer;
 890 xer_type_encoder_f OK_IntegerInRange3_encode_xer;
 891
 892 /*** <<< CODE [OK-IntegerInRange3] >>> ***/
 893
 894 int
 895 OK_IntegerInRange3_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 896                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 897         long value;
 898
 899         if(!sptr) {
 900                 ASN__CTFAIL(app_key, td, sptr,
 901                         "%s: value not given (%s:%d)",
 902                         td->name, __FILE__, __LINE__);
 903                 return -1;
 904         }
 905
 906         value = *(const long *)sptr;
 907
 908         if((value >= (-2147483647L - 1) && value <= 2147483647)) {
 909                 /* Constraint check succeeded */
 910                 return 0;
 911         } else {
 912                 ASN__CTFAIL(app_key, td, sptr,
 913                         "%s: constraint failed (%s:%d)",
 914                         td->name, __FILE__, __LINE__);
 915                 return -1;
 916         }
 917 }
 918
 919 /*
 920  * This type is implemented using NativeInteger,
 921  * so here we adjust the DEF accordingly.
 922  */
 923
 924 /*** <<< STAT-DEFS [OK-IntegerInRange3] >>> ***/
 925
 926 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange3_tags_1[] = {
 927         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 928 };
 929 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange3 = {
 930         "OK-IntegerInRange3",
 931         "OK-IntegerInRange3",
 932         &asn_OP_NativeInteger,
 933         asn_DEF_OK_IntegerInRange3_tags_1,
 934         sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
 935                 /sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
 936         asn_DEF_OK_IntegerInRange3_tags_1,      /* Same as above */
 937         sizeof(asn_DEF_OK_IntegerInRange3_tags_1)
 938                 /sizeof(asn_DEF_OK_IntegerInRange3_tags_1[0]), /* 1 */
 939         { 0, 0, OK_IntegerInRange3_constraint },
 940         0, 0,   /* No members */
 941         0       /* No specifics */
 942 };
 943
 944
 945 /*** <<< INCLUDES [OK-IntegerInRange4] >>> ***/
 946
 947 #include <NativeInteger.h>
 948
 949 /*** <<< TYPE-DECLS [OK-IntegerInRange4] >>> ***/
 950
 951 typedef long     OK_IntegerInRange4_t;
 952
 953 /*** <<< FUNC-DECLS [OK-IntegerInRange4] >>> ***/
 954
 955 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4;
 956 asn_struct_free_f OK_IntegerInRange4_free;
 957 asn_struct_print_f OK_IntegerInRange4_print;
 958 asn_constr_check_f OK_IntegerInRange4_constraint;
 959 ber_type_decoder_f OK_IntegerInRange4_decode_ber;
 960 der_type_encoder_f OK_IntegerInRange4_encode_der;
 961 xer_type_decoder_f OK_IntegerInRange4_decode_xer;
 962 xer_type_encoder_f OK_IntegerInRange4_encode_xer;
 963
 964 /*** <<< CODE [OK-IntegerInRange4] >>> ***/
 965
 966 int
 967 OK_IntegerInRange4_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 968                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 969         long value;
 970
 971         if(!sptr) {
 972                 ASN__CTFAIL(app_key, td, sptr,
 973                         "%s: value not given (%s:%d)",
 974                         td->name, __FILE__, __LINE__);
 975                 return -1;
 976         }
 977
 978         value = *(const long *)sptr;
 979
 980         if(((value == (-2147483647L - 1)) || (value == 2147483647))) {
 981                 /* Constraint check succeeded */
 982                 return 0;
 983         } else {
 984                 ASN__CTFAIL(app_key, td, sptr,
 985                         "%s: constraint failed (%s:%d)",
 986                         td->name, __FILE__, __LINE__);
 987                 return -1;
 988         }
 989 }
 990
 991 /*
 992  * This type is implemented using NativeInteger,
 993  * so here we adjust the DEF accordingly.
 994  */
 995
 996 /*** <<< STAT-DEFS [OK-IntegerInRange4] >>> ***/
 997
 998 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange4_tags_1[] = {
 999         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1000 };
1001 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange4 = {
1002         "OK-IntegerInRange4",
1003         "OK-IntegerInRange4",
1004         &asn_OP_NativeInteger,
1005         asn_DEF_OK_IntegerInRange4_tags_1,
1006         sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
1007                 /sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
1008         asn_DEF_OK_IntegerInRange4_tags_1,      /* Same as above */
1009         sizeof(asn_DEF_OK_IntegerInRange4_tags_1)
1010                 /sizeof(asn_DEF_OK_IntegerInRange4_tags_1[0]), /* 1 */
1011         { 0, 0, OK_IntegerInRange4_constraint },
1012         0, 0,   /* No members */
1013         0       /* No specifics */
1014 };
1015
1016
1017 /*** <<< INCLUDES [OK-IntegerInRange5] >>> ***/
1018
1019 #include <NativeInteger.h>
1020
1021 /*** <<< TYPE-DECLS [OK-IntegerInRange5] >>> ***/
1022
1023 typedef long     OK_IntegerInRange5_t;
1024
1025 /*** <<< FUNC-DECLS [OK-IntegerInRange5] >>> ***/
1026
1027 extern asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5;
1028 asn_struct_free_f OK_IntegerInRange5_free;
1029 asn_struct_print_f OK_IntegerInRange5_print;
1030 asn_constr_check_f OK_IntegerInRange5_constraint;
1031 ber_type_decoder_f OK_IntegerInRange5_decode_ber;
1032 der_type_encoder_f OK_IntegerInRange5_encode_der;
1033 xer_type_decoder_f OK_IntegerInRange5_decode_xer;
1034 xer_type_encoder_f OK_IntegerInRange5_encode_xer;
1035
1036 /*** <<< CODE [OK-IntegerInRange5] >>> ***/
1037
1038 int
1039 OK_IntegerInRange5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1040                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1041         long value;
1042
1043         if(!sptr) {
1044                 ASN__CTFAIL(app_key, td, sptr,
1045                         "%s: value not given (%s:%d)",
1046                         td->name, __FILE__, __LINE__);
1047                 return -1;
1048         }
1049
1050         value = *(const long *)sptr;
1051
1052         if(((value == (-2147483647L - 1)) || (value == 2147483647))) {
1053                 /* Constraint check succeeded */
1054                 return 0;
1055         } else {
1056                 ASN__CTFAIL(app_key, td, sptr,
1057                         "%s: constraint failed (%s:%d)",
1058                         td->name, __FILE__, __LINE__);
1059                 return -1;
1060         }
1061 }
1062
1063 /*
1064  * This type is implemented using NativeInteger,
1065  * so here we adjust the DEF accordingly.
1066  */
1067
1068 /*** <<< STAT-DEFS [OK-IntegerInRange5] >>> ***/
1069
1070 static const ber_tlv_tag_t asn_DEF_OK_IntegerInRange5_tags_1[] = {
1071         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1072 };
1073 asn_TYPE_descriptor_t asn_DEF_OK_IntegerInRange5 = {
1074         "OK-IntegerInRange5",
1075         "OK-IntegerInRange5",
1076         &asn_OP_NativeInteger,
1077         asn_DEF_OK_IntegerInRange5_tags_1,
1078         sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
1079                 /sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
1080         asn_DEF_OK_IntegerInRange5_tags_1,      /* Same as above */
1081         sizeof(asn_DEF_OK_IntegerInRange5_tags_1)
1082                 /sizeof(asn_DEF_OK_IntegerInRange5_tags_1[0]), /* 1 */
1083         { 0, 0, OK_IntegerInRange5_constraint },
1084         0, 0,   /* No members */
1085         0       /* No specifics */
1086 };
1087
1088
1089 /*** <<< INCLUDES [NO-IntegerInRange6] >>> ***/
1090
1091 #include <NativeInteger.h>
1092
1093 /*** <<< TYPE-DECLS [NO-IntegerInRange6] >>> ***/
1094
1095 typedef unsigned long    NO_IntegerInRange6_t;
1096
1097 /*** <<< FUNC-DECLS [NO-IntegerInRange6] >>> ***/
1098
1099 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6;
1100 asn_struct_free_f NO_IntegerInRange6_free;
1101 asn_struct_print_f NO_IntegerInRange6_print;
1102 asn_constr_check_f NO_IntegerInRange6_constraint;
1103 ber_type_decoder_f NO_IntegerInRange6_decode_ber;
1104 der_type_encoder_f NO_IntegerInRange6_encode_der;
1105 xer_type_decoder_f NO_IntegerInRange6_decode_xer;
1106 xer_type_encoder_f NO_IntegerInRange6_encode_xer;
1107
1108 /*** <<< CODE [NO-IntegerInRange6] >>> ***/
1109
1110 int
1111 NO_IntegerInRange6_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
1112                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1113
1114         if(!sptr) {
1115                 ASN__CTFAIL(app_key, td, sptr,
1116                         "%s: value not given (%s:%d)",
1117                         td->name, __FILE__, __LINE__);
1118                 return -1;
1119         }
1120
1121
1122         /* Constraint check succeeded */
1123         return 0;
1124 }
1125
1126 /*
1127  * This type is implemented using NativeInteger,
1128  * so here we adjust the DEF accordingly.
1129  */
1130
1131 /*** <<< STAT-DEFS [NO-IntegerInRange6] >>> ***/
1132
1133 static const asn_INTEGER_specifics_t asn_SPC_NO_IntegerInRange6_specs_1 = {
1134         0,      0,      0,      0,      0,
1135         0,      /* Native long size */
1136         1       /* Unsigned representation */
1137 };
1138 static const ber_tlv_tag_t asn_DEF_NO_IntegerInRange6_tags_1[] = {
1139         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1140 };
1141 asn_TYPE_descriptor_t asn_DEF_NO_IntegerInRange6 = {
1142         "NO-IntegerInRange6",
1143         "NO-IntegerInRange6",
1144         &asn_OP_NativeInteger,
1145         asn_DEF_NO_IntegerInRange6_tags_1,
1146         sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
1147                 /sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
1148         asn_DEF_NO_IntegerInRange6_tags_1,      /* Same as above */
1149         sizeof(asn_DEF_NO_IntegerInRange6_tags_1)
1150                 /sizeof(asn_DEF_NO_IntegerInRange6_tags_1[0]), /* 1 */
1151         { 0, 0, NO_IntegerInRange6_constraint },
1152         0, 0,   /* No members */
1153         &asn_SPC_NO_IntegerInRange6_specs_1     /* Additional specs */
1154 };
1155
1156
1157 /*** <<< INCLUDES [CN-IntegerEnumerated1] >>> ***/
1158
1159 #include <NativeInteger.h>
1160
1161 /*** <<< DEPS [CN-IntegerEnumerated1] >>> ***/
1162
1163 typedef enum CN_IntegerEnumerated1 {
1164         CN_IntegerEnumerated1_a = 1,
1165         CN_IntegerEnumerated1_b = 2
1166 } e_CN_IntegerEnumerated1;
1167
1168 /*** <<< TYPE-DECLS [CN-IntegerEnumerated1] >>> ***/
1169
1170 typedef long     CN_IntegerEnumerated1_t;
1171
1172 /*** <<< FUNC-DECLS [CN-IntegerEnumerated1] >>> ***/
1173
1174 extern asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1;
1175 asn_struct_free_f CN_IntegerEnumerated1_free;
1176 asn_struct_print_f CN_IntegerEnumerated1_print;
1177 asn_constr_check_f CN_IntegerEnumerated1_constraint;
1178 ber_type_decoder_f CN_IntegerEnumerated1_decode_ber;
1179 der_type_encoder_f CN_IntegerEnumerated1_encode_der;
1180 xer_type_decoder_f CN_IntegerEnumerated1_decode_xer;
1181 xer_type_encoder_f CN_IntegerEnumerated1_encode_xer;
1182
1183 /*** <<< CODE [CN-IntegerEnumerated1] >>> ***/
1184
1185 /*
1186  * This type is implemented using NativeInteger,
1187  * so here we adjust the DEF accordingly.
1188  */
1189
1190 /*** <<< STAT-DEFS [CN-IntegerEnumerated1] >>> ***/
1191
1192 static const ber_tlv_tag_t asn_DEF_CN_IntegerEnumerated1_tags_1[] = {
1193         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1194 };
1195 asn_TYPE_descriptor_t asn_DEF_CN_IntegerEnumerated1 = {
1196         "CN-IntegerEnumerated1",
1197         "CN-IntegerEnumerated1",
1198         &asn_OP_NativeInteger,
1199         asn_DEF_CN_IntegerEnumerated1_tags_1,
1200         sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
1201                 /sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
1202         asn_DEF_CN_IntegerEnumerated1_tags_1,   /* Same as above */
1203         sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1)
1204                 /sizeof(asn_DEF_CN_IntegerEnumerated1_tags_1[0]), /* 1 */
1205         { 0, 0, NativeInteger_constraint },
1206         0, 0,   /* Defined elsewhere */
1207         0       /* No specifics */
1208 };
1209
1210
1211 /*** <<< INCLUDES [NO-IntegerEnumerated2] >>> ***/
1212
1213 #include <INTEGER.h>
1214
1215 /*** <<< DEPS [NO-IntegerEnumerated2] >>> ***/
1216
1217 typedef enum NO_IntegerEnumerated2 {
1218         NO_IntegerEnumerated2_a = 1,
1219         NO_IntegerEnumerated2_b = 3000000000
1220 } e_NO_IntegerEnumerated2;
1221
1222 /*** <<< TYPE-DECLS [NO-IntegerEnumerated2] >>> ***/
1223
1224 typedef INTEGER_t        NO_IntegerEnumerated2_t;
1225
1226 /*** <<< FUNC-DECLS [NO-IntegerEnumerated2] >>> ***/
1227
1228 extern asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2;
1229 asn_struct_free_f NO_IntegerEnumerated2_free;
1230 asn_struct_print_f NO_IntegerEnumerated2_print;
1231 asn_constr_check_f NO_IntegerEnumerated2_constraint;
1232 ber_type_decoder_f NO_IntegerEnumerated2_decode_ber;
1233 der_type_encoder_f NO_IntegerEnumerated2_encode_der;
1234 xer_type_decoder_f NO_IntegerEnumerated2_decode_xer;
1235 xer_type_encoder_f NO_IntegerEnumerated2_encode_xer;
1236
1237 /*** <<< CODE [NO-IntegerEnumerated2] >>> ***/
1238
1239 /*
1240  * This type is implemented using INTEGER,
1241  * so here we adjust the DEF accordingly.
1242  */
1243
1244 /*** <<< STAT-DEFS [NO-IntegerEnumerated2] >>> ***/
1245
1246 static const ber_tlv_tag_t asn_DEF_NO_IntegerEnumerated2_tags_1[] = {
1247         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
1248 };
1249 asn_TYPE_descriptor_t asn_DEF_NO_IntegerEnumerated2 = {
1250         "NO-IntegerEnumerated2",
1251         "NO-IntegerEnumerated2",
1252         &asn_OP_INTEGER,
1253         asn_DEF_NO_IntegerEnumerated2_tags_1,
1254         sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
1255                 /sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
1256         asn_DEF_NO_IntegerEnumerated2_tags_1,   /* Same as above */
1257         sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1)
1258                 /sizeof(asn_DEF_NO_IntegerEnumerated2_tags_1[0]), /* 1 */
1259         { 0, 0, INTEGER_constraint },
1260         0, 0,   /* Defined elsewhere */
1261         0       /* No specifics */
1262 };
1263