tests/tests-asn1c-compiler/119-per-strings-OK.asn1.-Pgen-PER

   1
   2 /*** <<< INCLUDES [PDU] >>> ***/
   3
   4 #include <IA5String.h>
   5 #include <VisibleString.h>
   6 #include <PrintableString.h>
   7 #include <NumericString.h>
   8 #include <UTF8String.h>
   9 #include <BMPString.h>
  10 #include <UniversalString.h>
  11 #include <NativeReal.h>
  12 #include <OBJECT_IDENTIFIER.h>
  13 #include <asn_SEQUENCE_OF.h>
  14 #include <constr_SEQUENCE_OF.h>
  15 #include <constr_SEQUENCE.h>
  16
  17 /*** <<< FWD-DECLS [PDU] >>> ***/
  18
  19 struct PDU;
  20
  21 /*** <<< TYPE-DECLS [PDU] >>> ***/
  22
  23 typedef struct PDU {
  24         struct many {
  25                 A_SEQUENCE_OF(struct PDU) list;
  26
  27                 /* Context for parsing across buffer boundaries */
  28                 asn_struct_ctx_t _asn_ctx;
  29         } *many;
  30         IA5String_t     *ia5;   /* OPTIONAL */
  31         IA5String_t     *ia5_c; /* OPTIONAL */
  32         IA5String_t     *ia5_ce;        /* OPTIONAL */
  33         IA5String_t     *ia5_ir;        /* OPTIONAL */
  34         VisibleString_t *vs;    /* OPTIONAL */
  35         VisibleString_t *vs_c;  /* OPTIONAL */
  36         VisibleString_t *vs_ce; /* OPTIONAL */
  37         VisibleString_t *vs_ir; /* OPTIONAL */
  38         PrintableString_t       *pr;    /* OPTIONAL */
  39         PrintableString_t       *pr_c;  /* OPTIONAL */
  40         PrintableString_t       *pr_ir; /* OPTIONAL */
  41         NumericString_t *ns;    /* OPTIONAL */
  42         NumericString_t *ns_c;  /* OPTIONAL */
  43         NumericString_t *ns_ce; /* OPTIONAL */
  44         NumericString_t *ns_ir; /* OPTIONAL */
  45         UTF8String_t    *ut_c;  /* OPTIONAL */
  46         UTF8String_t    *ut_ce; /* OPTIONAL */
  47         UTF8String_t    *ut_ir; /* OPTIONAL */
  48         BMPString_t     *bm;    /* OPTIONAL */
  49         BMPString_t     *bm_c;  /* OPTIONAL */
  50         BMPString_t     *bm_cs; /* OPTIONAL */
  51         BMPString_t     *bm_ce; /* OPTIONAL */
  52         BMPString_t     *bm_ir; /* OPTIONAL */
  53         UniversalString_t       *us;    /* OPTIONAL */
  54         UniversalString_t       *us_c;  /* OPTIONAL */
  55         UniversalString_t       *us_cs; /* OPTIONAL */
  56         UniversalString_t       *us_ce; /* OPTIONAL */
  57         UniversalString_t       *us_ir; /* OPTIONAL */
  58         double  *real;  /* OPTIONAL */
  59         OBJECT_IDENTIFIER_t     *oid;   /* OPTIONAL */
  60
  61         /* Context for parsing across buffer boundaries */
  62         asn_struct_ctx_t _asn_ctx;
  63 } PDU_t;
  64
  65 /*** <<< FUNC-DECLS [PDU] >>> ***/
  66
  67 extern asn_TYPE_descriptor_t asn_DEF_PDU;
  68 extern asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1;
  69 extern asn_TYPE_member_t asn_MBR_PDU_1[31];
  70
  71 /*** <<< POST-INCLUDE [PDU] >>> ***/
  72
  73 #include "PDU.h"
  74
  75 /*** <<< CTABLES [PDU] >>> ***/
  76
  77 static int check_permitted_alphabet_5(const void *sptr) {
  78         /* The underlying type is IA5String */
  79         const IA5String_t *st = (const IA5String_t *)sptr;
  80         const uint8_t *ch = st->buf;
  81         const uint8_t *end = ch + st->size;
  82
  83         for(; ch < end; ch++) {
  84                 uint8_t cv = *ch;
  85                 if(!(cv >= 65 && cv <= 90)) return -1;
  86         }
  87         return 0;
  88 }
  89
  90 static int check_permitted_alphabet_6(const void *sptr) {
  91         /* The underlying type is IA5String */
  92         const IA5String_t *st = (const IA5String_t *)sptr;
  93         const uint8_t *ch = st->buf;
  94         const uint8_t *end = ch + st->size;
  95
  96         for(; ch < end; ch++) {
  97                 uint8_t cv = *ch;
  98                 if(!(cv >= 65 && cv <= 90)) return -1;
  99         }
 100         return 0;
 101 }
 102
 103 static const int permitted_alphabet_table_7[256] = {
 104  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 105  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 106  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 107  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 108  0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*  AB              */
 109  0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 0, 0, 0, 0, 0,        /*         XYZ      */
 110 };
 111 static const int permitted_alphabet_code2value_7[5] = {
 112 65,66,88,89,90,};
 113
 114
 115 static int check_permitted_alphabet_7(const void *sptr) {
 116         const int *table = permitted_alphabet_table_7;
 117         /* The underlying type is IA5String */
 118         const IA5String_t *st = (const IA5String_t *)sptr;
 119         const uint8_t *ch = st->buf;
 120         const uint8_t *end = ch + st->size;
 121
 122         for(; ch < end; ch++) {
 123                 uint8_t cv = *ch;
 124                 if(!table[cv]) return -1;
 125         }
 126         return 0;
 127 }
 128
 129 static int check_permitted_alphabet_9(const void *sptr) {
 130         /* The underlying type is VisibleString */
 131         const VisibleString_t *st = (const VisibleString_t *)sptr;
 132         const uint8_t *ch = st->buf;
 133         const uint8_t *end = ch + st->size;
 134
 135         for(; ch < end; ch++) {
 136                 uint8_t cv = *ch;
 137                 if(!(cv >= 65 && cv <= 90)) return -1;
 138         }
 139         return 0;
 140 }
 141
 142 static int check_permitted_alphabet_10(const void *sptr) {
 143         /* The underlying type is VisibleString */
 144         const VisibleString_t *st = (const VisibleString_t *)sptr;
 145         const uint8_t *ch = st->buf;
 146         const uint8_t *end = ch + st->size;
 147
 148         for(; ch < end; ch++) {
 149                 uint8_t cv = *ch;
 150                 if(!(cv >= 65 && cv <= 90)) return -1;
 151         }
 152         return 0;
 153 }
 154
 155 static const int permitted_alphabet_table_11[256] = {
 156  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 157  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 158  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 159  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 160  0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*  AB              */
 161  0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 0, 0, 0, 0, 0,        /*         XYZ      */
 162 };
 163 static const int permitted_alphabet_code2value_11[5] = {
 164 65,66,88,89,90,};
 165
 166
 167 static int check_permitted_alphabet_11(const void *sptr) {
 168         const int *table = permitted_alphabet_table_11;
 169         /* The underlying type is VisibleString */
 170         const VisibleString_t *st = (const VisibleString_t *)sptr;
 171         const uint8_t *ch = st->buf;
 172         const uint8_t *end = ch + st->size;
 173
 174         for(; ch < end; ch++) {
 175                 uint8_t cv = *ch;
 176                 if(!table[cv]) return -1;
 177         }
 178         return 0;
 179 }
 180
 181 static int check_permitted_alphabet_13(const void *sptr) {
 182         /* The underlying type is PrintableString */
 183         const PrintableString_t *st = (const PrintableString_t *)sptr;
 184         const uint8_t *ch = st->buf;
 185         const uint8_t *end = ch + st->size;
 186
 187         for(; ch < end; ch++) {
 188                 uint8_t cv = *ch;
 189                 if(!(cv >= 65 && cv <= 90)) return -1;
 190         }
 191         return 0;
 192 }
 193
 194 static const int permitted_alphabet_table_14[256] = {
 195  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 196  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 197  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 198  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 199  0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*  AB              */
 200  0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 0, 0, 0, 0, 0,        /*         XYZ      */
 201 };
 202 static const int permitted_alphabet_code2value_14[5] = {
 203 65,66,88,89,90,};
 204
 205
 206 static int check_permitted_alphabet_14(const void *sptr) {
 207         const int *table = permitted_alphabet_table_14;
 208         /* The underlying type is PrintableString */
 209         const PrintableString_t *st = (const PrintableString_t *)sptr;
 210         const uint8_t *ch = st->buf;
 211         const uint8_t *end = ch + st->size;
 212
 213         for(; ch < end; ch++) {
 214                 uint8_t cv = *ch;
 215                 if(!table[cv]) return -1;
 216         }
 217         return 0;
 218 }
 219
 220 static int check_permitted_alphabet_16(const void *sptr) {
 221         /* The underlying type is NumericString */
 222         const NumericString_t *st = (const NumericString_t *)sptr;
 223         const uint8_t *ch = st->buf;
 224         const uint8_t *end = ch + st->size;
 225
 226         for(; ch < end; ch++) {
 227                 uint8_t cv = *ch;
 228                 if(!(cv >= 53 && cv <= 57)) return -1;
 229         }
 230         return 0;
 231 }
 232
 233 static int check_permitted_alphabet_17(const void *sptr) {
 234         /* The underlying type is NumericString */
 235         const NumericString_t *st = (const NumericString_t *)sptr;
 236         const uint8_t *ch = st->buf;
 237         const uint8_t *end = ch + st->size;
 238
 239         for(; ch < end; ch++) {
 240                 uint8_t cv = *ch;
 241                 if(!(cv >= 53 && cv <= 57)) return -1;
 242         }
 243         return 0;
 244 }
 245
 246 static const int permitted_alphabet_table_18[256] = {
 247  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 248  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 249  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 250  0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,        /*  1       9       */
 251 };
 252 static const int permitted_alphabet_code2value_18[2] = {
 253 49,57,};
 254
 255
 256 static int check_permitted_alphabet_18(const void *sptr) {
 257         const int *table = permitted_alphabet_table_18;
 258         /* The underlying type is NumericString */
 259         const NumericString_t *st = (const NumericString_t *)sptr;
 260         const uint8_t *ch = st->buf;
 261         const uint8_t *end = ch + st->size;
 262
 263         for(; ch < end; ch++) {
 264                 uint8_t cv = *ch;
 265                 if(!table[cv]) return -1;
 266         }
 267         return 0;
 268 }
 269
 270 static const int permitted_alphabet_table_21[128] = {
 271  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 272  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 273  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 274  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 275  0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*  A               */
 276  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,        /*           Z      */
 277 };
 278
 279 static int check_permitted_alphabet_21(const void *sptr) {
 280         const int *table = permitted_alphabet_table_21;
 281         /* The underlying type is UTF8String */
 282         const UTF8String_t *st = (const UTF8String_t *)sptr;
 283         const uint8_t *ch = st->buf;
 284         const uint8_t *end = ch + st->size;
 285
 286         for(; ch < end; ch++) {
 287                 uint8_t cv = *ch;
 288                 if(cv >= 0x80) return -1;
 289                 if(!table[cv]) return -1;
 290         }
 291         return 0;
 292 }
 293
 294 static int check_permitted_alphabet_23(const void *sptr) {
 295         /* The underlying type is BMPString */
 296         const BMPString_t *st = (const BMPString_t *)sptr;
 297         const uint8_t *ch = st->buf;
 298         const uint8_t *end = ch + st->size;
 299
 300         if(st->size % 2) return -1; /* (size%2)! */
 301         for(; ch < end; ch += 2) {
 302                 uint16_t cv = (ch[0] << 8)
 303                                 | ch[1];
 304                 if(!(cv >= 65 && cv <= 90)) return -1;
 305         }
 306         return 0;
 307 }
 308
 309 static int check_permitted_alphabet_24(const void *sptr) {
 310         /* The underlying type is BMPString */
 311         const BMPString_t *st = (const BMPString_t *)sptr;
 312         const uint8_t *ch = st->buf;
 313         const uint8_t *end = ch + st->size;
 314
 315         if(st->size % 2) return -1; /* (size%2)! */
 316         for(; ch < end; ch += 2) {
 317                 uint16_t cv = (ch[0] << 8)
 318                                 | ch[1];
 319                 if(!(cv <= 65533)) return -1;
 320         }
 321         return 0;
 322 }
 323
 324 static int check_permitted_alphabet_25(const void *sptr) {
 325         /* The underlying type is BMPString */
 326         const BMPString_t *st = (const BMPString_t *)sptr;
 327         const uint8_t *ch = st->buf;
 328         const uint8_t *end = ch + st->size;
 329
 330         if(st->size % 2) return -1; /* (size%2)! */
 331         for(; ch < end; ch += 2) {
 332                 uint16_t cv = (ch[0] << 8)
 333                                 | ch[1];
 334                 if(!(cv >= 65 && cv <= 90)) return -1;
 335         }
 336         return 0;
 337 }
 338
 339 static const int permitted_alphabet_table_26[256] = {
 340  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 341  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 342  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 343  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 344  0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*  AB              */
 345  0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 0, 0, 0, 0, 0,        /*         XYZ      */
 346 };
 347 static const int permitted_alphabet_code2value_26[5] = {
 348 65,66,88,89,90,};
 349
 350
 351 static int check_permitted_alphabet_26(const void *sptr) {
 352         const int *table = permitted_alphabet_table_26;
 353         /* The underlying type is BMPString */
 354         const BMPString_t *st = (const BMPString_t *)sptr;
 355         const uint8_t *ch = st->buf;
 356         const uint8_t *end = ch + st->size;
 357
 358         if(st->size % 2) return -1; /* (size%2)! */
 359         for(; ch < end; ch += 2) {
 360                 uint16_t cv = (ch[0] << 8)
 361                                 | ch[1];
 362                 if(cv > 255) return -1;
 363                 if(!table[cv]) return -1;
 364         }
 365         return 0;
 366 }
 367
 368 static int check_permitted_alphabet_28(const void *sptr) {
 369         /* The underlying type is UniversalString */
 370         const UniversalString_t *st = (const UniversalString_t *)sptr;
 371         const uint8_t *ch = st->buf;
 372         const uint8_t *end = ch + st->size;
 373
 374         if(st->size % 4) return -1; /* (size%4)! */
 375         for(; ch < end; ch += 4) {
 376                 uint32_t cv = (ch[0] << 24)
 377                                 | (ch[1] << 16)
 378                                 | (ch[2] << 8)
 379                                 |  ch[3];
 380                 if(!(cv >= 65 && cv <= 90)) return -1;
 381         }
 382         return 0;
 383 }
 384
 385 static int check_permitted_alphabet_29(const void *sptr) {
 386         /* The underlying type is UniversalString */
 387         const UniversalString_t *st = (const UniversalString_t *)sptr;
 388         const uint8_t *ch = st->buf;
 389         const uint8_t *end = ch + st->size;
 390
 391         if(st->size % 4) return -1; /* (size%4)! */
 392         for(; ch < end; ch += 4) {
 393                 uint32_t cv = (ch[0] << 24)
 394                                 | (ch[1] << 16)
 395                                 | (ch[2] << 8)
 396                                 |  ch[3];
 397                 (void)cv; /* Unused variable */
 398         }
 399         return 0;
 400 }
 401
 402 static int check_permitted_alphabet_30(const void *sptr) {
 403         /* The underlying type is UniversalString */
 404         const UniversalString_t *st = (const UniversalString_t *)sptr;
 405         const uint8_t *ch = st->buf;
 406         const uint8_t *end = ch + st->size;
 407
 408         if(st->size % 4) return -1; /* (size%4)! */
 409         for(; ch < end; ch += 4) {
 410                 uint32_t cv = (ch[0] << 24)
 411                                 | (ch[1] << 16)
 412                                 | (ch[2] << 8)
 413                                 |  ch[3];
 414                 if(!(cv >= 65 && cv <= 90)) return -1;
 415         }
 416         return 0;
 417 }
 418
 419 static const int permitted_alphabet_table_31[256] = {
 420  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 421  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 422  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 423  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*                  */
 424  0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        /*  AB              */
 425  0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 5, 0, 0, 0, 0, 0,        /*         XYZ      */
 426 };
 427 static const int permitted_alphabet_code2value_31[5] = {
 428 65,66,88,89,90,};
 429
 430
 431 static int check_permitted_alphabet_31(const void *sptr) {
 432         const int *table = permitted_alphabet_table_31;
 433         /* The underlying type is UniversalString */
 434         const UniversalString_t *st = (const UniversalString_t *)sptr;
 435         const uint8_t *ch = st->buf;
 436         const uint8_t *end = ch + st->size;
 437
 438         if(st->size % 4) return -1; /* (size%4)! */
 439         for(; ch < end; ch += 4) {
 440                 uint32_t cv = (ch[0] << 24)
 441                                 | (ch[1] << 16)
 442                                 | (ch[2] << 8)
 443                                 |  ch[3];
 444                 if(cv > 255) return -1;
 445                 if(!table[cv]) return -1;
 446         }
 447         return 0;
 448 }
 449
 450
 451 /*** <<< CODE [PDU] >>> ***/
 452
 453 static int
 454 memb_ia5_c_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 455                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 456         const IA5String_t *st = (const IA5String_t *)sptr;
 457
 458         if(!sptr) {
 459                 ASN__CTFAIL(app_key, td, sptr,
 460                         "%s: value not given (%s:%d)",
 461                         td->name, __FILE__, __LINE__);
 462                 return -1;
 463         }
 464
 465
 466         if(!check_permitted_alphabet_5(st)) {
 467                 /* Constraint check succeeded */
 468                 return 0;
 469         } else {
 470                 ASN__CTFAIL(app_key, td, sptr,
 471                         "%s: constraint failed (%s:%d)",
 472                         td->name, __FILE__, __LINE__);
 473                 return -1;
 474         }
 475 }
 476
 477 static int
 478 memb_ia5_ce_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 479                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 480         const IA5String_t *st = (const IA5String_t *)sptr;
 481
 482         if(!sptr) {
 483                 ASN__CTFAIL(app_key, td, sptr,
 484                         "%s: value not given (%s:%d)",
 485                         td->name, __FILE__, __LINE__);
 486                 return -1;
 487         }
 488
 489
 490         if(!check_permitted_alphabet_6(st)) {
 491                 /* Constraint check succeeded */
 492                 return 0;
 493         } else {
 494                 ASN__CTFAIL(app_key, td, sptr,
 495                         "%s: constraint failed (%s:%d)",
 496                         td->name, __FILE__, __LINE__);
 497                 return -1;
 498         }
 499 }
 500
 501 static int
 502 memb_ia5_ir_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 503                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 504         const IA5String_t *st = (const IA5String_t *)sptr;
 505
 506         if(!sptr) {
 507                 ASN__CTFAIL(app_key, td, sptr,
 508                         "%s: value not given (%s:%d)",
 509                         td->name, __FILE__, __LINE__);
 510                 return -1;
 511         }
 512
 513
 514         if(!check_permitted_alphabet_7(st)) {
 515                 /* Constraint check succeeded */
 516                 return 0;
 517         } else {
 518                 ASN__CTFAIL(app_key, td, sptr,
 519                         "%s: constraint failed (%s:%d)",
 520                         td->name, __FILE__, __LINE__);
 521                 return -1;
 522         }
 523 }
 524
 525 static int asn_PER_MAP_ia5_ir_7_v2c(unsigned int value) {
 526         if(value >= sizeof(permitted_alphabet_table_7)/sizeof(permitted_alphabet_table_7[0]))
 527                 return -1;
 528         return permitted_alphabet_table_7[value] - 1;
 529 }
 530 static int asn_PER_MAP_ia5_ir_7_c2v(unsigned int code) {
 531         if(code >= sizeof(permitted_alphabet_code2value_7)/sizeof(permitted_alphabet_code2value_7[0]))
 532                 return -1;
 533         return permitted_alphabet_code2value_7[code];
 534 }
 535 static int
 536 memb_vs_c_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 537                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 538         const VisibleString_t *st = (const VisibleString_t *)sptr;
 539
 540         if(!sptr) {
 541                 ASN__CTFAIL(app_key, td, sptr,
 542                         "%s: value not given (%s:%d)",
 543                         td->name, __FILE__, __LINE__);
 544                 return -1;
 545         }
 546
 547
 548         if(!check_permitted_alphabet_9(st)) {
 549                 /* Constraint check succeeded */
 550                 return 0;
 551         } else {
 552                 ASN__CTFAIL(app_key, td, sptr,
 553                         "%s: constraint failed (%s:%d)",
 554                         td->name, __FILE__, __LINE__);
 555                 return -1;
 556         }
 557 }
 558
 559 static int
 560 memb_vs_ce_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 561                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 562         const VisibleString_t *st = (const VisibleString_t *)sptr;
 563
 564         if(!sptr) {
 565                 ASN__CTFAIL(app_key, td, sptr,
 566                         "%s: value not given (%s:%d)",
 567                         td->name, __FILE__, __LINE__);
 568                 return -1;
 569         }
 570
 571
 572         if(!check_permitted_alphabet_10(st)) {
 573                 /* Constraint check succeeded */
 574                 return 0;
 575         } else {
 576                 ASN__CTFAIL(app_key, td, sptr,
 577                         "%s: constraint failed (%s:%d)",
 578                         td->name, __FILE__, __LINE__);
 579                 return -1;
 580         }
 581 }
 582
 583 static int
 584 memb_vs_ir_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 585                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 586         const VisibleString_t *st = (const VisibleString_t *)sptr;
 587
 588         if(!sptr) {
 589                 ASN__CTFAIL(app_key, td, sptr,
 590                         "%s: value not given (%s:%d)",
 591                         td->name, __FILE__, __LINE__);
 592                 return -1;
 593         }
 594
 595
 596         if(!check_permitted_alphabet_11(st)) {
 597                 /* Constraint check succeeded */
 598                 return 0;
 599         } else {
 600                 ASN__CTFAIL(app_key, td, sptr,
 601                         "%s: constraint failed (%s:%d)",
 602                         td->name, __FILE__, __LINE__);
 603                 return -1;
 604         }
 605 }
 606
 607 static int asn_PER_MAP_vs_ir_11_v2c(unsigned int value) {
 608         if(value >= sizeof(permitted_alphabet_table_11)/sizeof(permitted_alphabet_table_11[0]))
 609                 return -1;
 610         return permitted_alphabet_table_11[value] - 1;
 611 }
 612 static int asn_PER_MAP_vs_ir_11_c2v(unsigned int code) {
 613         if(code >= sizeof(permitted_alphabet_code2value_11)/sizeof(permitted_alphabet_code2value_11[0]))
 614                 return -1;
 615         return permitted_alphabet_code2value_11[code];
 616 }
 617 static int
 618 memb_pr_c_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 619                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 620         const PrintableString_t *st = (const PrintableString_t *)sptr;
 621
 622         if(!sptr) {
 623                 ASN__CTFAIL(app_key, td, sptr,
 624                         "%s: value not given (%s:%d)",
 625                         td->name, __FILE__, __LINE__);
 626                 return -1;
 627         }
 628
 629
 630         if(!check_permitted_alphabet_13(st)) {
 631                 /* Constraint check succeeded */
 632                 return 0;
 633         } else {
 634                 ASN__CTFAIL(app_key, td, sptr,
 635                         "%s: constraint failed (%s:%d)",
 636                         td->name, __FILE__, __LINE__);
 637                 return -1;
 638         }
 639 }
 640
 641 static int
 642 memb_pr_ir_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 643                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 644         const PrintableString_t *st = (const PrintableString_t *)sptr;
 645
 646         if(!sptr) {
 647                 ASN__CTFAIL(app_key, td, sptr,
 648                         "%s: value not given (%s:%d)",
 649                         td->name, __FILE__, __LINE__);
 650                 return -1;
 651         }
 652
 653
 654         if(!check_permitted_alphabet_14(st)) {
 655                 /* Constraint check succeeded */
 656                 return 0;
 657         } else {
 658                 ASN__CTFAIL(app_key, td, sptr,
 659                         "%s: constraint failed (%s:%d)",
 660                         td->name, __FILE__, __LINE__);
 661                 return -1;
 662         }
 663 }
 664
 665 static int asn_PER_MAP_pr_ir_14_v2c(unsigned int value) {
 666         if(value >= sizeof(permitted_alphabet_table_14)/sizeof(permitted_alphabet_table_14[0]))
 667                 return -1;
 668         return permitted_alphabet_table_14[value] - 1;
 669 }
 670 static int asn_PER_MAP_pr_ir_14_c2v(unsigned int code) {
 671         if(code >= sizeof(permitted_alphabet_code2value_14)/sizeof(permitted_alphabet_code2value_14[0]))
 672                 return -1;
 673         return permitted_alphabet_code2value_14[code];
 674 }
 675 static int
 676 memb_ns_c_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 677                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 678         const NumericString_t *st = (const NumericString_t *)sptr;
 679
 680         if(!sptr) {
 681                 ASN__CTFAIL(app_key, td, sptr,
 682                         "%s: value not given (%s:%d)",
 683                         td->name, __FILE__, __LINE__);
 684                 return -1;
 685         }
 686
 687
 688         if(!check_permitted_alphabet_16(st)) {
 689                 /* Constraint check succeeded */
 690                 return 0;
 691         } else {
 692                 ASN__CTFAIL(app_key, td, sptr,
 693                         "%s: constraint failed (%s:%d)",
 694                         td->name, __FILE__, __LINE__);
 695                 return -1;
 696         }
 697 }
 698
 699 static int
 700 memb_ns_ce_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 701                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 702         const NumericString_t *st = (const NumericString_t *)sptr;
 703
 704         if(!sptr) {
 705                 ASN__CTFAIL(app_key, td, sptr,
 706                         "%s: value not given (%s:%d)",
 707                         td->name, __FILE__, __LINE__);
 708                 return -1;
 709         }
 710
 711
 712         if(!check_permitted_alphabet_17(st)) {
 713                 /* Constraint check succeeded */
 714                 return 0;
 715         } else {
 716                 ASN__CTFAIL(app_key, td, sptr,
 717                         "%s: constraint failed (%s:%d)",
 718                         td->name, __FILE__, __LINE__);
 719                 return -1;
 720         }
 721 }
 722
 723 static int
 724 memb_ns_ir_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 725                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 726         const NumericString_t *st = (const NumericString_t *)sptr;
 727
 728         if(!sptr) {
 729                 ASN__CTFAIL(app_key, td, sptr,
 730                         "%s: value not given (%s:%d)",
 731                         td->name, __FILE__, __LINE__);
 732                 return -1;
 733         }
 734
 735
 736         if(!check_permitted_alphabet_18(st)) {
 737                 /* Constraint check succeeded */
 738                 return 0;
 739         } else {
 740                 ASN__CTFAIL(app_key, td, sptr,
 741                         "%s: constraint failed (%s:%d)",
 742                         td->name, __FILE__, __LINE__);
 743                 return -1;
 744         }
 745 }
 746
 747 static int asn_PER_MAP_ns_ir_18_v2c(unsigned int value) {
 748         if(value >= sizeof(permitted_alphabet_table_18)/sizeof(permitted_alphabet_table_18[0]))
 749                 return -1;
 750         return permitted_alphabet_table_18[value] - 1;
 751 }
 752 static int asn_PER_MAP_ns_ir_18_c2v(unsigned int code) {
 753         if(code >= sizeof(permitted_alphabet_code2value_18)/sizeof(permitted_alphabet_code2value_18[0]))
 754                 return -1;
 755         return permitted_alphabet_code2value_18[code];
 756 }
 757 static int
 758 memb_ut_c_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 759                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 760         const UTF8String_t *st = (const UTF8String_t *)sptr;
 761         size_t size;
 762
 763         if(!sptr) {
 764                 ASN__CTFAIL(app_key, td, sptr,
 765                         "%s: value not given (%s:%d)",
 766                         td->name, __FILE__, __LINE__);
 767                 return -1;
 768         }
 769
 770         size = UTF8String_length(st);
 771         if((ssize_t)size < 0) {
 772                 ASN__CTFAIL(app_key, td, sptr,
 773                         "%s: UTF-8: broken encoding (%s:%d)",
 774                         td->name, __FILE__, __LINE__);
 775                 return -1;
 776         }
 777
 778         if((size == 6)) {
 779                 /* Constraint check succeeded */
 780                 return 0;
 781         } else {
 782                 ASN__CTFAIL(app_key, td, sptr,
 783                         "%s: constraint failed (%s:%d)",
 784                         td->name, __FILE__, __LINE__);
 785                 return -1;
 786         }
 787 }
 788
 789 static int
 790 memb_ut_ce_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 791                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 792         const UTF8String_t *st = (const UTF8String_t *)sptr;
 793         size_t size;
 794
 795         if(!sptr) {
 796                 ASN__CTFAIL(app_key, td, sptr,
 797                         "%s: value not given (%s:%d)",
 798                         td->name, __FILE__, __LINE__);
 799                 return -1;
 800         }
 801
 802         size = UTF8String_length(st);
 803         if((ssize_t)size < 0) {
 804                 ASN__CTFAIL(app_key, td, sptr,
 805                         "%s: UTF-8: broken encoding (%s:%d)",
 806                         td->name, __FILE__, __LINE__);
 807                 return -1;
 808         }
 809
 810         if((size == 6)) {
 811                 /* Constraint check succeeded */
 812                 return 0;
 813         } else {
 814                 ASN__CTFAIL(app_key, td, sptr,
 815                         "%s: constraint failed (%s:%d)",
 816                         td->name, __FILE__, __LINE__);
 817                 return -1;
 818         }
 819 }
 820
 821 static int
 822 memb_ut_ir_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 823                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 824         const UTF8String_t *st = (const UTF8String_t *)sptr;
 825
 826         if(!sptr) {
 827                 ASN__CTFAIL(app_key, td, sptr,
 828                         "%s: value not given (%s:%d)",
 829                         td->name, __FILE__, __LINE__);
 830                 return -1;
 831         }
 832
 833
 834         if(!check_permitted_alphabet_21(st)) {
 835                 /* Constraint check succeeded */
 836                 return 0;
 837         } else {
 838                 ASN__CTFAIL(app_key, td, sptr,
 839                         "%s: constraint failed (%s:%d)",
 840                         td->name, __FILE__, __LINE__);
 841                 return -1;
 842         }
 843 }
 844
 845 static int
 846 memb_bm_c_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 847                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 848         const BMPString_t *st = (const BMPString_t *)sptr;
 849
 850         if(!sptr) {
 851                 ASN__CTFAIL(app_key, td, sptr,
 852                         "%s: value not given (%s:%d)",
 853                         td->name, __FILE__, __LINE__);
 854                 return -1;
 855         }
 856
 857
 858         if(!check_permitted_alphabet_23(st)) {
 859                 /* Constraint check succeeded */
 860                 return 0;
 861         } else {
 862                 ASN__CTFAIL(app_key, td, sptr,
 863                         "%s: constraint failed (%s:%d)",
 864                         td->name, __FILE__, __LINE__);
 865                 return -1;
 866         }
 867 }
 868
 869 static int
 870 memb_bm_cs_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 871                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 872         const BMPString_t *st = (const BMPString_t *)sptr;
 873         size_t size;
 874
 875         if(!sptr) {
 876                 ASN__CTFAIL(app_key, td, sptr,
 877                         "%s: value not given (%s:%d)",
 878                         td->name, __FILE__, __LINE__);
 879                 return -1;
 880         }
 881
 882         size = st->size >> 1;   /* 2 byte per character */
 883
 884         if((size == 6)
 885                  && !check_permitted_alphabet_24(st)) {
 886                 /* Constraint check succeeded */
 887                 return 0;
 888         } else {
 889                 ASN__CTFAIL(app_key, td, sptr,
 890                         "%s: constraint failed (%s:%d)",
 891                         td->name, __FILE__, __LINE__);
 892                 return -1;
 893         }
 894 }
 895
 896 static int
 897 memb_bm_ce_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 898                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 899         const BMPString_t *st = (const BMPString_t *)sptr;
 900
 901         if(!sptr) {
 902                 ASN__CTFAIL(app_key, td, sptr,
 903                         "%s: value not given (%s:%d)",
 904                         td->name, __FILE__, __LINE__);
 905                 return -1;
 906         }
 907
 908
 909         if(!check_permitted_alphabet_25(st)) {
 910                 /* Constraint check succeeded */
 911                 return 0;
 912         } else {
 913                 ASN__CTFAIL(app_key, td, sptr,
 914                         "%s: constraint failed (%s:%d)",
 915                         td->name, __FILE__, __LINE__);
 916                 return -1;
 917         }
 918 }
 919
 920 static int
 921 memb_bm_ir_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 922                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 923         const BMPString_t *st = (const BMPString_t *)sptr;
 924
 925         if(!sptr) {
 926                 ASN__CTFAIL(app_key, td, sptr,
 927                         "%s: value not given (%s:%d)",
 928                         td->name, __FILE__, __LINE__);
 929                 return -1;
 930         }
 931
 932
 933         if(!check_permitted_alphabet_26(st)) {
 934                 /* Constraint check succeeded */
 935                 return 0;
 936         } else {
 937                 ASN__CTFAIL(app_key, td, sptr,
 938                         "%s: constraint failed (%s:%d)",
 939                         td->name, __FILE__, __LINE__);
 940                 return -1;
 941         }
 942 }
 943
 944 static int asn_PER_MAP_bm_ir_26_v2c(unsigned int value) {
 945         if(value >= sizeof(permitted_alphabet_table_26)/sizeof(permitted_alphabet_table_26[0]))
 946                 return -1;
 947         return permitted_alphabet_table_26[value] - 1;
 948 }
 949 static int asn_PER_MAP_bm_ir_26_c2v(unsigned int code) {
 950         if(code >= sizeof(permitted_alphabet_code2value_26)/sizeof(permitted_alphabet_code2value_26[0]))
 951                 return -1;
 952         return permitted_alphabet_code2value_26[code];
 953 }
 954 static int
 955 memb_us_c_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 956                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 957         const UniversalString_t *st = (const UniversalString_t *)sptr;
 958
 959         if(!sptr) {
 960                 ASN__CTFAIL(app_key, td, sptr,
 961                         "%s: value not given (%s:%d)",
 962                         td->name, __FILE__, __LINE__);
 963                 return -1;
 964         }
 965
 966
 967         if(!check_permitted_alphabet_28(st)) {
 968                 /* Constraint check succeeded */
 969                 return 0;
 970         } else {
 971                 ASN__CTFAIL(app_key, td, sptr,
 972                         "%s: constraint failed (%s:%d)",
 973                         td->name, __FILE__, __LINE__);
 974                 return -1;
 975         }
 976 }
 977
 978 static int
 979 memb_us_cs_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 980                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 981         const UniversalString_t *st = (const UniversalString_t *)sptr;
 982         size_t size;
 983
 984         if(!sptr) {
 985                 ASN__CTFAIL(app_key, td, sptr,
 986                         "%s: value not given (%s:%d)",
 987                         td->name, __FILE__, __LINE__);
 988                 return -1;
 989         }
 990
 991         size = st->size >> 2;   /* 4 byte per character */
 992
 993         if((size == 6)
 994                  && !check_permitted_alphabet_29(st)) {
 995                 /* Constraint check succeeded */
 996                 return 0;
 997         } else {
 998                 ASN__CTFAIL(app_key, td, sptr,
 999                         "%s: constraint failed (%s:%d)",
1000                         td->name, __FILE__, __LINE__);
1001                 return -1;
1002         }
1003 }
1004
1005 static int
1006 memb_us_ce_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
1007                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1008         const UniversalString_t *st = (const UniversalString_t *)sptr;
1009
1010         if(!sptr) {
1011                 ASN__CTFAIL(app_key, td, sptr,
1012                         "%s: value not given (%s:%d)",
1013                         td->name, __FILE__, __LINE__);
1014                 return -1;
1015         }
1016
1017
1018         if(!check_permitted_alphabet_30(st)) {
1019                 /* Constraint check succeeded */
1020                 return 0;
1021         } else {
1022                 ASN__CTFAIL(app_key, td, sptr,
1023                         "%s: constraint failed (%s:%d)",
1024                         td->name, __FILE__, __LINE__);
1025                 return -1;
1026         }
1027 }
1028
1029 static int
1030 memb_us_ir_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
1031                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
1032         const UniversalString_t *st = (const UniversalString_t *)sptr;
1033
1034         if(!sptr) {
1035                 ASN__CTFAIL(app_key, td, sptr,
1036                         "%s: value not given (%s:%d)",
1037                         td->name, __FILE__, __LINE__);
1038                 return -1;
1039         }
1040
1041
1042         if(!check_permitted_alphabet_31(st)) {
1043                 /* Constraint check succeeded */
1044                 return 0;
1045         } else {
1046                 ASN__CTFAIL(app_key, td, sptr,
1047                         "%s: constraint failed (%s:%d)",
1048                         td->name, __FILE__, __LINE__);
1049                 return -1;
1050         }
1051 }
1052
1053 static int asn_PER_MAP_us_ir_31_v2c(unsigned int value) {
1054         if(value >= sizeof(permitted_alphabet_table_31)/sizeof(permitted_alphabet_table_31[0]))
1055                 return -1;
1056         return permitted_alphabet_table_31[value] - 1;
1057 }
1058 static int asn_PER_MAP_us_ir_31_c2v(unsigned int code) {
1059         if(code >= sizeof(permitted_alphabet_code2value_31)/sizeof(permitted_alphabet_code2value_31[0]))
1060                 return -1;
1061         return permitted_alphabet_code2value_31[code];
1062 }
1063
1064 /*** <<< CTDEFS [PDU] >>> ***/
1065
1066 static asn_per_constraints_t asn_PER_memb_ia5_c_constr_5 CC_NOTUSED = {
1067         { APC_CONSTRAINED,       5,  5,  65,  90 }      /* (65..90) */,
1068         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1069         0, 0    /* No PER character map necessary */
1070 };
1071 static asn_per_constraints_t asn_PER_memb_ia5_ce_constr_6 CC_NOTUSED = {
1072         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1073         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1074         0, 0    /* No PER character map necessary */
1075 };
1076 static asn_per_constraints_t asn_PER_memb_ia5_ir_constr_7 CC_NOTUSED = {
1077         { APC_CONSTRAINED,       3,  3,  65,  90 }      /* (65..90) */,
1078         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1079         asn_PER_MAP_ia5_ir_7_v2c,       /* Value to PER code map */
1080         asn_PER_MAP_ia5_ir_7_c2v        /* PER code to value map */
1081 };
1082 static asn_per_constraints_t asn_PER_memb_vs_c_constr_9 CC_NOTUSED = {
1083         { APC_CONSTRAINED,       5,  5,  65,  90 }      /* (65..90) */,
1084         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1085         0, 0    /* No PER character map necessary */
1086 };
1087 static asn_per_constraints_t asn_PER_memb_vs_ce_constr_10 CC_NOTUSED = {
1088         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1089         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1090         0, 0    /* No PER character map necessary */
1091 };
1092 static asn_per_constraints_t asn_PER_memb_vs_ir_constr_11 CC_NOTUSED = {
1093         { APC_CONSTRAINED,       3,  3,  65,  90 }      /* (65..90) */,
1094         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1095         asn_PER_MAP_vs_ir_11_v2c,       /* Value to PER code map */
1096         asn_PER_MAP_vs_ir_11_c2v        /* PER code to value map */
1097 };
1098 static asn_per_constraints_t asn_PER_memb_pr_c_constr_13 CC_NOTUSED = {
1099         { APC_CONSTRAINED,       5,  5,  65,  90 }      /* (65..90) */,
1100         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1101         0, 0    /* No PER character map necessary */
1102 };
1103 static asn_per_constraints_t asn_PER_memb_pr_ir_constr_14 CC_NOTUSED = {
1104         { APC_CONSTRAINED,       3,  3,  65,  90 }      /* (65..90) */,
1105         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1106         asn_PER_MAP_pr_ir_14_v2c,       /* Value to PER code map */
1107         asn_PER_MAP_pr_ir_14_c2v        /* PER code to value map */
1108 };
1109 static asn_per_constraints_t asn_PER_memb_ns_c_constr_16 CC_NOTUSED = {
1110         { APC_CONSTRAINED,       3,  3,  53,  57 }      /* (53..57) */,
1111         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1112         0, 0    /* No PER character map necessary */
1113 };
1114 static asn_per_constraints_t asn_PER_memb_ns_ce_constr_17 CC_NOTUSED = {
1115         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1116         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1117         0, 0    /* No PER character map necessary */
1118 };
1119 static asn_per_constraints_t asn_PER_memb_ns_ir_constr_18 CC_NOTUSED = {
1120         { APC_CONSTRAINED,       1,  1,  49,  57 }      /* (49..57) */,
1121         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1122         asn_PER_MAP_ns_ir_18_v2c,       /* Value to PER code map */
1123         asn_PER_MAP_ns_ir_18_c2v        /* PER code to value map */
1124 };
1125 static asn_per_constraints_t asn_PER_memb_ut_c_constr_19 CC_NOTUSED = {
1126         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1127         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1128         0, 0    /* No PER value map */
1129 };
1130 static asn_per_constraints_t asn_PER_memb_ut_ce_constr_20 CC_NOTUSED = {
1131         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1132         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1133         0, 0    /* No PER value map */
1134 };
1135 static asn_per_constraints_t asn_PER_memb_ut_ir_constr_21 CC_NOTUSED = {
1136         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1137         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
1138         0, 0    /* No PER value map */
1139 };
1140 static asn_per_constraints_t asn_PER_memb_bm_c_constr_23 CC_NOTUSED = {
1141         { APC_CONSTRAINED,       5,  5,  65,  90 }      /* (65..90) */,
1142         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1143         0, 0    /* No PER character map necessary */
1144 };
1145 static asn_per_constraints_t asn_PER_memb_bm_cs_constr_24 CC_NOTUSED = {
1146         { APC_CONSTRAINED,       16,  16,  0,  65533 }  /* (0..65533) */,
1147         { APC_CONSTRAINED,       0,  0,  6,  6 }        /* (SIZE(6..6)) */,
1148         0, 0    /* No PER character map necessary */
1149 };
1150 static asn_per_constraints_t asn_PER_memb_bm_ce_constr_25 CC_NOTUSED = {
1151         { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
1152         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1153         0, 0    /* No PER character map necessary */
1154 };
1155 static asn_per_constraints_t asn_PER_memb_bm_ir_constr_26 CC_NOTUSED = {
1156         { APC_CONSTRAINED,       3,  3,  65,  90 }      /* (65..90) */,
1157         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1158         asn_PER_MAP_bm_ir_26_v2c,       /* Value to PER code map */
1159         asn_PER_MAP_bm_ir_26_c2v        /* PER code to value map */
1160 };
1161 static asn_per_constraints_t asn_PER_memb_us_c_constr_28 CC_NOTUSED = {
1162         { APC_CONSTRAINED,       5,  5,  65,  90 }      /* (65..90) */,
1163         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1164         0, 0    /* No PER character map necessary */
1165 };
1166 static asn_per_constraints_t asn_PER_memb_us_cs_constr_29 CC_NOTUSED = {
1167         { APC_CONSTRAINED,       32,  32,  0,  2147483647 }     /* (0..4294967295) */,
1168         { APC_CONSTRAINED,       0,  0,  6,  6 }        /* (SIZE(6..6)) */,
1169         0, 0    /* No PER character map necessary */
1170 };
1171 static asn_per_constraints_t asn_PER_memb_us_ce_constr_30 CC_NOTUSED = {
1172         { APC_CONSTRAINED,      32, 32, 0, 2147483647 } /* special case 1 */
1173         ,
1174         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1175         0, 0    /* No PER character map necessary */
1176 };
1177 static asn_per_constraints_t asn_PER_memb_us_ir_constr_31 CC_NOTUSED = {
1178         { APC_CONSTRAINED,       3,  3,  65,  90 }      /* (65..90) */,
1179         { APC_SEMI_CONSTRAINED, -1, -1,  0,  0 }        /* (SIZE(0..MAX)) */,
1180         asn_PER_MAP_us_ir_31_v2c,       /* Value to PER code map */
1181         asn_PER_MAP_us_ir_31_c2v        /* PER code to value map */
1182 };
1183
1184 /*** <<< STAT-DEFS [PDU] >>> ***/
1185
1186 static asn_TYPE_member_t asn_MBR_many_2[] = {
1187         { ATF_POINTER, 0, 0,
1188                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
1189                 .tag_mode = 0,
1190                 .type = &asn_DEF_PDU,
1191                 .type_selector = 0,
1192                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1193                 0, 0, /* No default value */
1194                 .name = ""
1195                 },
1196 };
1197 static const ber_tlv_tag_t asn_DEF_many_tags_2[] = {
1198         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1199         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1200 };
1201 static asn_SET_OF_specifics_t asn_SPC_many_specs_2 = {
1202         sizeof(struct many),
1203         offsetof(struct many, _asn_ctx),
1204         0,      /* XER encoding is XMLDelimitedItemList */
1205 };
1206 static /* Use -fall-defs-global to expose */
1207 asn_TYPE_descriptor_t asn_DEF_many_2 = {
1208         "many",
1209         "many",
1210         &asn_OP_SEQUENCE_OF,
1211         asn_DEF_many_tags_2,
1212         sizeof(asn_DEF_many_tags_2)
1213                 /sizeof(asn_DEF_many_tags_2[0]) - 1, /* 1 */
1214         asn_DEF_many_tags_2,    /* Same as above */
1215         sizeof(asn_DEF_many_tags_2)
1216                 /sizeof(asn_DEF_many_tags_2[0]), /* 2 */
1217         { 0, 0, SEQUENCE_OF_constraint },
1218         asn_MBR_many_2,
1219         1,      /* Single element */
1220         &asn_SPC_many_specs_2   /* Additional specs */
1221 };
1222
1223 asn_TYPE_member_t asn_MBR_PDU_1[] = {
1224         { ATF_POINTER, 31, offsetof(struct PDU, many),
1225                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1226                 .tag_mode = 0,
1227                 .type = &asn_DEF_many_2,
1228                 .type_selector = 0,
1229                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1230                 0, 0, /* No default value */
1231                 .name = "many"
1232                 },
1233         { ATF_POINTER, 30, offsetof(struct PDU, ia5),
1234                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1235                 .tag_mode = -1, /* IMPLICIT tag at current level */
1236                 .type = &asn_DEF_IA5String,
1237                 .type_selector = 0,
1238                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1239                 0, 0, /* No default value */
1240                 .name = "ia5"
1241                 },
1242         { ATF_POINTER, 29, offsetof(struct PDU, ia5_c),
1243                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
1244                 .tag_mode = -1, /* IMPLICIT tag at current level */
1245                 .type = &asn_DEF_IA5String,
1246                 .type_selector = 0,
1247                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ia5_c_constr_5, .general_constraints =  memb_ia5_c_constraint_1 },
1248                 0, 0, /* No default value */
1249                 .name = "ia5-c"
1250                 },
1251         { ATF_POINTER, 28, offsetof(struct PDU, ia5_ce),
1252                 .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
1253                 .tag_mode = -1, /* IMPLICIT tag at current level */
1254                 .type = &asn_DEF_IA5String,
1255                 .type_selector = 0,
1256                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ia5_ce_constr_6, .general_constraints =  memb_ia5_ce_constraint_1 },
1257                 0, 0, /* No default value */
1258                 .name = "ia5-ce"
1259                 },
1260         { ATF_POINTER, 27, offsetof(struct PDU, ia5_ir),
1261                 .tag = (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
1262                 .tag_mode = -1, /* IMPLICIT tag at current level */
1263                 .type = &asn_DEF_IA5String,
1264                 .type_selector = 0,
1265                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ia5_ir_constr_7, .general_constraints =  memb_ia5_ir_constraint_1 },
1266                 0, 0, /* No default value */
1267                 .name = "ia5-ir"
1268                 },
1269         { ATF_POINTER, 26, offsetof(struct PDU, vs),
1270                 .tag = (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
1271                 .tag_mode = -1, /* IMPLICIT tag at current level */
1272                 .type = &asn_DEF_VisibleString,
1273                 .type_selector = 0,
1274                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1275                 0, 0, /* No default value */
1276                 .name = "vs"
1277                 },
1278         { ATF_POINTER, 25, offsetof(struct PDU, vs_c),
1279                 .tag = (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
1280                 .tag_mode = -1, /* IMPLICIT tag at current level */
1281                 .type = &asn_DEF_VisibleString,
1282                 .type_selector = 0,
1283                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_vs_c_constr_9, .general_constraints =  memb_vs_c_constraint_1 },
1284                 0, 0, /* No default value */
1285                 .name = "vs-c"
1286                 },
1287         { ATF_POINTER, 24, offsetof(struct PDU, vs_ce),
1288                 .tag = (ASN_TAG_CLASS_CONTEXT | (7 << 2)),
1289                 .tag_mode = -1, /* IMPLICIT tag at current level */
1290                 .type = &asn_DEF_VisibleString,
1291                 .type_selector = 0,
1292                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_vs_ce_constr_10, .general_constraints =  memb_vs_ce_constraint_1 },
1293                 0, 0, /* No default value */
1294                 .name = "vs-ce"
1295                 },
1296         { ATF_POINTER, 23, offsetof(struct PDU, vs_ir),
1297                 .tag = (ASN_TAG_CLASS_CONTEXT | (8 << 2)),
1298                 .tag_mode = -1, /* IMPLICIT tag at current level */
1299                 .type = &asn_DEF_VisibleString,
1300                 .type_selector = 0,
1301                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_vs_ir_constr_11, .general_constraints =  memb_vs_ir_constraint_1 },
1302                 0, 0, /* No default value */
1303                 .name = "vs-ir"
1304                 },
1305         { ATF_POINTER, 22, offsetof(struct PDU, pr),
1306                 .tag = (ASN_TAG_CLASS_CONTEXT | (9 << 2)),
1307                 .tag_mode = -1, /* IMPLICIT tag at current level */
1308                 .type = &asn_DEF_PrintableString,
1309                 .type_selector = 0,
1310                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1311                 0, 0, /* No default value */
1312                 .name = "pr"
1313                 },
1314         { ATF_POINTER, 21, offsetof(struct PDU, pr_c),
1315                 .tag = (ASN_TAG_CLASS_CONTEXT | (10 << 2)),
1316                 .tag_mode = -1, /* IMPLICIT tag at current level */
1317                 .type = &asn_DEF_PrintableString,
1318                 .type_selector = 0,
1319                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_pr_c_constr_13, .general_constraints =  memb_pr_c_constraint_1 },
1320                 0, 0, /* No default value */
1321                 .name = "pr-c"
1322                 },
1323         { ATF_POINTER, 20, offsetof(struct PDU, pr_ir),
1324                 .tag = (ASN_TAG_CLASS_CONTEXT | (11 << 2)),
1325                 .tag_mode = -1, /* IMPLICIT tag at current level */
1326                 .type = &asn_DEF_PrintableString,
1327                 .type_selector = 0,
1328                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_pr_ir_constr_14, .general_constraints =  memb_pr_ir_constraint_1 },
1329                 0, 0, /* No default value */
1330                 .name = "pr-ir"
1331                 },
1332         { ATF_POINTER, 19, offsetof(struct PDU, ns),
1333                 .tag = (ASN_TAG_CLASS_CONTEXT | (12 << 2)),
1334                 .tag_mode = -1, /* IMPLICIT tag at current level */
1335                 .type = &asn_DEF_NumericString,
1336                 .type_selector = 0,
1337                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1338                 0, 0, /* No default value */
1339                 .name = "ns"
1340                 },
1341         { ATF_POINTER, 18, offsetof(struct PDU, ns_c),
1342                 .tag = (ASN_TAG_CLASS_CONTEXT | (13 << 2)),
1343                 .tag_mode = -1, /* IMPLICIT tag at current level */
1344                 .type = &asn_DEF_NumericString,
1345                 .type_selector = 0,
1346                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ns_c_constr_16, .general_constraints =  memb_ns_c_constraint_1 },
1347                 0, 0, /* No default value */
1348                 .name = "ns-c"
1349                 },
1350         { ATF_POINTER, 17, offsetof(struct PDU, ns_ce),
1351                 .tag = (ASN_TAG_CLASS_CONTEXT | (14 << 2)),
1352                 .tag_mode = -1, /* IMPLICIT tag at current level */
1353                 .type = &asn_DEF_NumericString,
1354                 .type_selector = 0,
1355                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ns_ce_constr_17, .general_constraints =  memb_ns_ce_constraint_1 },
1356                 0, 0, /* No default value */
1357                 .name = "ns-ce"
1358                 },
1359         { ATF_POINTER, 16, offsetof(struct PDU, ns_ir),
1360                 .tag = (ASN_TAG_CLASS_CONTEXT | (15 << 2)),
1361                 .tag_mode = -1, /* IMPLICIT tag at current level */
1362                 .type = &asn_DEF_NumericString,
1363                 .type_selector = 0,
1364                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ns_ir_constr_18, .general_constraints =  memb_ns_ir_constraint_1 },
1365                 0, 0, /* No default value */
1366                 .name = "ns-ir"
1367                 },
1368         { ATF_POINTER, 15, offsetof(struct PDU, ut_c),
1369                 .tag = (ASN_TAG_CLASS_CONTEXT | (16 << 2)),
1370                 .tag_mode = -1, /* IMPLICIT tag at current level */
1371                 .type = &asn_DEF_UTF8String,
1372                 .type_selector = 0,
1373                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ut_c_constr_19, .general_constraints =  memb_ut_c_constraint_1 },
1374                 0, 0, /* No default value */
1375                 .name = "ut-c"
1376                 },
1377         { ATF_POINTER, 14, offsetof(struct PDU, ut_ce),
1378                 .tag = (ASN_TAG_CLASS_CONTEXT | (17 << 2)),
1379                 .tag_mode = -1, /* IMPLICIT tag at current level */
1380                 .type = &asn_DEF_UTF8String,
1381                 .type_selector = 0,
1382                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ut_ce_constr_20, .general_constraints =  memb_ut_ce_constraint_1 },
1383                 0, 0, /* No default value */
1384                 .name = "ut-ce"
1385                 },
1386         { ATF_POINTER, 13, offsetof(struct PDU, ut_ir),
1387                 .tag = (ASN_TAG_CLASS_CONTEXT | (18 << 2)),
1388                 .tag_mode = -1, /* IMPLICIT tag at current level */
1389                 .type = &asn_DEF_UTF8String,
1390                 .type_selector = 0,
1391                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_ut_ir_constr_21, .general_constraints =  memb_ut_ir_constraint_1 },
1392                 0, 0, /* No default value */
1393                 .name = "ut-ir"
1394                 },
1395         { ATF_POINTER, 12, offsetof(struct PDU, bm),
1396                 .tag = (ASN_TAG_CLASS_CONTEXT | (19 << 2)),
1397                 .tag_mode = -1, /* IMPLICIT tag at current level */
1398                 .type = &asn_DEF_BMPString,
1399                 .type_selector = 0,
1400                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1401                 0, 0, /* No default value */
1402                 .name = "bm"
1403                 },
1404         { ATF_POINTER, 11, offsetof(struct PDU, bm_c),
1405                 .tag = (ASN_TAG_CLASS_CONTEXT | (20 << 2)),
1406                 .tag_mode = -1, /* IMPLICIT tag at current level */
1407                 .type = &asn_DEF_BMPString,
1408                 .type_selector = 0,
1409                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_bm_c_constr_23, .general_constraints =  memb_bm_c_constraint_1 },
1410                 0, 0, /* No default value */
1411                 .name = "bm-c"
1412                 },
1413         { ATF_POINTER, 10, offsetof(struct PDU, bm_cs),
1414                 .tag = (ASN_TAG_CLASS_CONTEXT | (21 << 2)),
1415                 .tag_mode = -1, /* IMPLICIT tag at current level */
1416                 .type = &asn_DEF_BMPString,
1417                 .type_selector = 0,
1418                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_bm_cs_constr_24, .general_constraints =  memb_bm_cs_constraint_1 },
1419                 0, 0, /* No default value */
1420                 .name = "bm-cs"
1421                 },
1422         { ATF_POINTER, 9, offsetof(struct PDU, bm_ce),
1423                 .tag = (ASN_TAG_CLASS_CONTEXT | (22 << 2)),
1424                 .tag_mode = -1, /* IMPLICIT tag at current level */
1425                 .type = &asn_DEF_BMPString,
1426                 .type_selector = 0,
1427                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_bm_ce_constr_25, .general_constraints =  memb_bm_ce_constraint_1 },
1428                 0, 0, /* No default value */
1429                 .name = "bm-ce"
1430                 },
1431         { ATF_POINTER, 8, offsetof(struct PDU, bm_ir),
1432                 .tag = (ASN_TAG_CLASS_CONTEXT | (23 << 2)),
1433                 .tag_mode = -1, /* IMPLICIT tag at current level */
1434                 .type = &asn_DEF_BMPString,
1435                 .type_selector = 0,
1436                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_bm_ir_constr_26, .general_constraints =  memb_bm_ir_constraint_1 },
1437                 0, 0, /* No default value */
1438                 .name = "bm-ir"
1439                 },
1440         { ATF_POINTER, 7, offsetof(struct PDU, us),
1441                 .tag = (ASN_TAG_CLASS_CONTEXT | (24 << 2)),
1442                 .tag_mode = -1, /* IMPLICIT tag at current level */
1443                 .type = &asn_DEF_UniversalString,
1444                 .type_selector = 0,
1445                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1446                 0, 0, /* No default value */
1447                 .name = "us"
1448                 },
1449         { ATF_POINTER, 6, offsetof(struct PDU, us_c),
1450                 .tag = (ASN_TAG_CLASS_CONTEXT | (25 << 2)),
1451                 .tag_mode = -1, /* IMPLICIT tag at current level */
1452                 .type = &asn_DEF_UniversalString,
1453                 .type_selector = 0,
1454                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_us_c_constr_28, .general_constraints =  memb_us_c_constraint_1 },
1455                 0, 0, /* No default value */
1456                 .name = "us-c"
1457                 },
1458         { ATF_POINTER, 5, offsetof(struct PDU, us_cs),
1459                 .tag = (ASN_TAG_CLASS_CONTEXT | (26 << 2)),
1460                 .tag_mode = -1, /* IMPLICIT tag at current level */
1461                 .type = &asn_DEF_UniversalString,
1462                 .type_selector = 0,
1463                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_us_cs_constr_29, .general_constraints =  memb_us_cs_constraint_1 },
1464                 0, 0, /* No default value */
1465                 .name = "us-cs"
1466                 },
1467         { ATF_POINTER, 4, offsetof(struct PDU, us_ce),
1468                 .tag = (ASN_TAG_CLASS_CONTEXT | (27 << 2)),
1469                 .tag_mode = -1, /* IMPLICIT tag at current level */
1470                 .type = &asn_DEF_UniversalString,
1471                 .type_selector = 0,
1472                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_us_ce_constr_30, .general_constraints =  memb_us_ce_constraint_1 },
1473                 0, 0, /* No default value */
1474                 .name = "us-ce"
1475                 },
1476         { ATF_POINTER, 3, offsetof(struct PDU, us_ir),
1477                 .tag = (ASN_TAG_CLASS_CONTEXT | (28 << 2)),
1478                 .tag_mode = -1, /* IMPLICIT tag at current level */
1479                 .type = &asn_DEF_UniversalString,
1480                 .type_selector = 0,
1481                 { .oer_constraints = 0, .per_constraints = &asn_PER_memb_us_ir_constr_31, .general_constraints =  memb_us_ir_constraint_1 },
1482                 0, 0, /* No default value */
1483                 .name = "us-ir"
1484                 },
1485         { ATF_POINTER, 2, offsetof(struct PDU, real),
1486                 .tag = (ASN_TAG_CLASS_CONTEXT | (29 << 2)),
1487                 .tag_mode = -1, /* IMPLICIT tag at current level */
1488                 .type = &asn_DEF_NativeReal,
1489                 .type_selector = 0,
1490                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1491                 0, 0, /* No default value */
1492                 .name = "real"
1493                 },
1494         { ATF_POINTER, 1, offsetof(struct PDU, oid),
1495                 .tag = (ASN_TAG_CLASS_CONTEXT | (30 << 2)),
1496                 .tag_mode = -1, /* IMPLICIT tag at current level */
1497                 .type = &asn_DEF_OBJECT_IDENTIFIER,
1498                 .type_selector = 0,
1499                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1500                 0, 0, /* No default value */
1501                 .name = "oid"
1502                 },
1503 };
1504 static const int asn_MAP_PDU_oms_1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 };
1505 static const ber_tlv_tag_t asn_DEF_PDU_tags_1[] = {
1506         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1507 };
1508 static const asn_TYPE_tag2member_t asn_MAP_PDU_tag2el_1[] = {
1509     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* many */
1510     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ia5 */
1511     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ia5-c */
1512     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* ia5-ce */
1513     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* ia5-ir */
1514     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* vs */
1515     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* vs-c */
1516     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* vs-ce */
1517     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* vs-ir */
1518     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 }, /* pr */
1519     { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 10, 0, 0 }, /* pr-c */
1520     { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 11, 0, 0 }, /* pr-ir */
1521     { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 12, 0, 0 }, /* ns */
1522     { (ASN_TAG_CLASS_CONTEXT | (13 << 2)), 13, 0, 0 }, /* ns-c */
1523     { (ASN_TAG_CLASS_CONTEXT | (14 << 2)), 14, 0, 0 }, /* ns-ce */
1524     { (ASN_TAG_CLASS_CONTEXT | (15 << 2)), 15, 0, 0 }, /* ns-ir */
1525     { (ASN_TAG_CLASS_CONTEXT | (16 << 2)), 16, 0, 0 }, /* ut-c */
1526     { (ASN_TAG_CLASS_CONTEXT | (17 << 2)), 17, 0, 0 }, /* ut-ce */
1527     { (ASN_TAG_CLASS_CONTEXT | (18 << 2)), 18, 0, 0 }, /* ut-ir */
1528     { (ASN_TAG_CLASS_CONTEXT | (19 << 2)), 19, 0, 0 }, /* bm */
1529     { (ASN_TAG_CLASS_CONTEXT | (20 << 2)), 20, 0, 0 }, /* bm-c */
1530     { (ASN_TAG_CLASS_CONTEXT | (21 << 2)), 21, 0, 0 }, /* bm-cs */
1531     { (ASN_TAG_CLASS_CONTEXT | (22 << 2)), 22, 0, 0 }, /* bm-ce */
1532     { (ASN_TAG_CLASS_CONTEXT | (23 << 2)), 23, 0, 0 }, /* bm-ir */
1533     { (ASN_TAG_CLASS_CONTEXT | (24 << 2)), 24, 0, 0 }, /* us */
1534     { (ASN_TAG_CLASS_CONTEXT | (25 << 2)), 25, 0, 0 }, /* us-c */
1535     { (ASN_TAG_CLASS_CONTEXT | (26 << 2)), 26, 0, 0 }, /* us-cs */
1536     { (ASN_TAG_CLASS_CONTEXT | (27 << 2)), 27, 0, 0 }, /* us-ce */
1537     { (ASN_TAG_CLASS_CONTEXT | (28 << 2)), 28, 0, 0 }, /* us-ir */
1538     { (ASN_TAG_CLASS_CONTEXT | (29 << 2)), 29, 0, 0 }, /* real */
1539     { (ASN_TAG_CLASS_CONTEXT | (30 << 2)), 30, 0, 0 } /* oid */
1540 };
1541 asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1 = {
1542         sizeof(struct PDU),
1543         offsetof(struct PDU, _asn_ctx),
1544         .tag2el = asn_MAP_PDU_tag2el_1,
1545         .tag2el_count = 31,     /* Count of tags in the map */
1546         asn_MAP_PDU_oms_1,      /* Optional members */
1547         31, 0,  /* Root/Additions */
1548         -1,     /* First extension addition */
1549 };
1550 asn_TYPE_descriptor_t asn_DEF_PDU = {
1551         "PDU",
1552         "PDU",
1553         &asn_OP_SEQUENCE,
1554         asn_DEF_PDU_tags_1,
1555         sizeof(asn_DEF_PDU_tags_1)
1556                 /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */
1557         asn_DEF_PDU_tags_1,     /* Same as above */
1558         sizeof(asn_DEF_PDU_tags_1)
1559                 /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */
1560         { 0, 0, SEQUENCE_constraint },
1561         asn_MBR_PDU_1,
1562         31,     /* Elements count */
1563         &asn_SPC_PDU_specs_1    /* Additional specs */
1564 };
1565