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

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