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

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