tests/tests-asn1c-compiler/70-xer-test-OK.asn1.-Pfwide-types

   1
   2 /*** <<< INCLUDES [PDU] >>> ***/
   3
   4 #include "Sequence.h"
   5 #include "Set.h"
   6 #include "SequenceOf.h"
   7 #include "ExtensibleSet.h"
   8 #include "ExtensibleSequence.h"
   9 #include "ExtensibleSequence2.h"
  10 #include "SetOfNULL.h"
  11 #include "SetOfREAL.h"
  12 #include "SetOfEnums.h"
  13 #include "NamedSetOfNULL.h"
  14 #include "NamedSetOfREAL.h"
  15 #include "NamedSetOfEnums.h"
  16 #include "SeqOfZuka.h"
  17 #include "SetOfChoice.h"
  18 #include "NamedSetOfChoice.h"
  19 #include <constr_CHOICE.h>
  20
  21 /*** <<< DEPS [PDU] >>> ***/
  22
  23 typedef enum PDU_PR {
  24         PDU_PR_NOTHING, /* No components present */
  25         PDU_PR_sequence,
  26         PDU_PR_set,
  27         PDU_PR_sequenceOf,
  28         PDU_PR_extensibleSet,
  29         PDU_PR_extensibleSequence,
  30         PDU_PR_extensibleSequence2,
  31         PDU_PR_setOfNULL,
  32         PDU_PR_setOfREAL,
  33         PDU_PR_setOfEnums,
  34         PDU_PR_namedSetOfNULL,
  35         PDU_PR_namedSetOfREAL,
  36         PDU_PR_namedSetOfEnums,
  37         PDU_PR_seqOfZuka,
  38         PDU_PR_setOfChoice,
  39         PDU_PR_namedSetOfChoice
  40         /* Extensions may appear below */
  41
  42 } PDU_PR;
  43
  44 /*** <<< TYPE-DECLS [PDU] >>> ***/
  45
  46 typedef struct PDU {
  47         PDU_PR present;
  48         union PDU_u {
  49                 Sequence_t       sequence;
  50                 Set_t    set;
  51                 SequenceOf_t     sequenceOf;
  52                 ExtensibleSet_t  extensibleSet;
  53                 ExtensibleSequence_t     extensibleSequence;
  54                 ExtensibleSequence2_t    extensibleSequence2;
  55                 SetOfNULL_t      setOfNULL;
  56                 SetOfREAL_t      setOfREAL;
  57                 SetOfEnums_t     setOfEnums;
  58                 NamedSetOfNULL_t         namedSetOfNULL;
  59                 NamedSetOfREAL_t         namedSetOfREAL;
  60                 NamedSetOfEnums_t        namedSetOfEnums;
  61                 SeqOfZuka_t      seqOfZuka;
  62                 SetOfChoice_t    setOfChoice;
  63                 NamedSetOfChoice_t       namedSetOfChoice;
  64                 /*
  65                  * This type is extensible,
  66                  * possible extensions are below.
  67                  */
  68         } choice;
  69
  70         /* Context for parsing across buffer boundaries */
  71         asn_struct_ctx_t _asn_ctx;
  72 } PDU_t;
  73
  74 /*** <<< FUNC-DECLS [PDU] >>> ***/
  75
  76 extern asn_TYPE_descriptor_t asn_DEF_PDU;
  77
  78 /*** <<< STAT-DEFS [PDU] >>> ***/
  79
  80 static asn_TYPE_member_t asn_MBR_PDU_1[] = {
  81         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.sequence),
  82                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
  83                 .tag_mode = -1, /* IMPLICIT tag at current level */
  84                 .type = &asn_DEF_Sequence,
  85                 .type_selector = 0,
  86                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  87                 0, 0, /* No default value */
  88                 .name = "sequence"
  89                 },
  90         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.set),
  91                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
  92                 .tag_mode = -1, /* IMPLICIT tag at current level */
  93                 .type = &asn_DEF_Set,
  94                 .type_selector = 0,
  95                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  96                 0, 0, /* No default value */
  97                 .name = "set"
  98                 },
  99         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.sequenceOf),
 100                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 101                 .tag_mode = -1, /* IMPLICIT tag at current level */
 102                 .type = &asn_DEF_SequenceOf,
 103                 .type_selector = 0,
 104                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 105                 0, 0, /* No default value */
 106                 .name = "sequenceOf"
 107                 },
 108         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSet),
 109                 .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 110                 .tag_mode = -1, /* IMPLICIT tag at current level */
 111                 .type = &asn_DEF_ExtensibleSet,
 112                 .type_selector = 0,
 113                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 114                 0, 0, /* No default value */
 115                 .name = "extensibleSet"
 116                 },
 117         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSequence),
 118                 .tag = (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 119                 .tag_mode = -1, /* IMPLICIT tag at current level */
 120                 .type = &asn_DEF_ExtensibleSequence,
 121                 .type_selector = 0,
 122                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 123                 0, 0, /* No default value */
 124                 .name = "extensibleSequence"
 125                 },
 126         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.extensibleSequence2),
 127                 .tag = (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
 128                 .tag_mode = -1, /* IMPLICIT tag at current level */
 129                 .type = &asn_DEF_ExtensibleSequence2,
 130                 .type_selector = 0,
 131                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 132                 0, 0, /* No default value */
 133                 .name = "extensibleSequence2"
 134                 },
 135         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfNULL),
 136                 .tag = (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 137                 .tag_mode = -1, /* IMPLICIT tag at current level */
 138                 .type = &asn_DEF_SetOfNULL,
 139                 .type_selector = 0,
 140                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 141                 0, 0, /* No default value */
 142                 .name = "setOfNULL"
 143                 },
 144         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfREAL),
 145                 .tag = (ASN_TAG_CLASS_CONTEXT | (7 << 2)),
 146                 .tag_mode = -1, /* IMPLICIT tag at current level */
 147                 .type = &asn_DEF_SetOfREAL,
 148                 .type_selector = 0,
 149                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 150                 0, 0, /* No default value */
 151                 .name = "setOfREAL"
 152                 },
 153         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfEnums),
 154                 .tag = (ASN_TAG_CLASS_CONTEXT | (8 << 2)),
 155                 .tag_mode = -1, /* IMPLICIT tag at current level */
 156                 .type = &asn_DEF_SetOfEnums,
 157                 .type_selector = 0,
 158                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 159                 0, 0, /* No default value */
 160                 .name = "setOfEnums"
 161                 },
 162         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfNULL),
 163                 .tag = (ASN_TAG_CLASS_CONTEXT | (9 << 2)),
 164                 .tag_mode = -1, /* IMPLICIT tag at current level */
 165                 .type = &asn_DEF_NamedSetOfNULL,
 166                 .type_selector = 0,
 167                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 168                 0, 0, /* No default value */
 169                 .name = "namedSetOfNULL"
 170                 },
 171         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfREAL),
 172                 .tag = (ASN_TAG_CLASS_CONTEXT | (10 << 2)),
 173                 .tag_mode = -1, /* IMPLICIT tag at current level */
 174                 .type = &asn_DEF_NamedSetOfREAL,
 175                 .type_selector = 0,
 176                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 177                 0, 0, /* No default value */
 178                 .name = "namedSetOfREAL"
 179                 },
 180         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfEnums),
 181                 .tag = (ASN_TAG_CLASS_CONTEXT | (11 << 2)),
 182                 .tag_mode = -1, /* IMPLICIT tag at current level */
 183                 .type = &asn_DEF_NamedSetOfEnums,
 184                 .type_selector = 0,
 185                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 186                 0, 0, /* No default value */
 187                 .name = "namedSetOfEnums"
 188                 },
 189         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.seqOfZuka),
 190                 .tag = (ASN_TAG_CLASS_CONTEXT | (12 << 2)),
 191                 .tag_mode = -1, /* IMPLICIT tag at current level */
 192                 .type = &asn_DEF_SeqOfZuka,
 193                 .type_selector = 0,
 194                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 195                 0, 0, /* No default value */
 196                 .name = "seqOfZuka"
 197                 },
 198         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.setOfChoice),
 199                 .tag = (ASN_TAG_CLASS_CONTEXT | (13 << 2)),
 200                 .tag_mode = -1, /* IMPLICIT tag at current level */
 201                 .type = &asn_DEF_SetOfChoice,
 202                 .type_selector = 0,
 203                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 204                 0, 0, /* No default value */
 205                 .name = "setOfChoice"
 206                 },
 207         { ATF_NOFLAGS, 0, offsetof(struct PDU, choice.namedSetOfChoice),
 208                 .tag = (ASN_TAG_CLASS_CONTEXT | (14 << 2)),
 209                 .tag_mode = -1, /* IMPLICIT tag at current level */
 210                 .type = &asn_DEF_NamedSetOfChoice,
 211                 .type_selector = 0,
 212                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 213                 0, 0, /* No default value */
 214                 .name = "namedSetOfChoice"
 215                 },
 216 };
 217 static const asn_TYPE_tag2member_t asn_MAP_PDU_tag2el_1[] = {
 218     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* sequence */
 219     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* set */
 220     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* sequenceOf */
 221     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* extensibleSet */
 222     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* extensibleSequence */
 223     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* extensibleSequence2 */
 224     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* setOfNULL */
 225     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* setOfREAL */
 226     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* setOfEnums */
 227     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 }, /* namedSetOfNULL */
 228     { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 10, 0, 0 }, /* namedSetOfREAL */
 229     { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 11, 0, 0 }, /* namedSetOfEnums */
 230     { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 12, 0, 0 }, /* seqOfZuka */
 231     { (ASN_TAG_CLASS_CONTEXT | (13 << 2)), 13, 0, 0 }, /* setOfChoice */
 232     { (ASN_TAG_CLASS_CONTEXT | (14 << 2)), 14, 0, 0 } /* namedSetOfChoice */
 233 };
 234 static asn_CHOICE_specifics_t asn_SPC_PDU_specs_1 = {
 235         sizeof(struct PDU),
 236         offsetof(struct PDU, _asn_ctx),
 237         offsetof(struct PDU, present),
 238         sizeof(((struct PDU *)0)->present),
 239         .tag2el = asn_MAP_PDU_tag2el_1,
 240         .tag2el_count = 15,     /* Count of tags in the map */
 241         0, 0,
 242         .first_extension = 15   /* Extensions start */
 243 };
 244 asn_TYPE_descriptor_t asn_DEF_PDU = {
 245         "PDU",
 246         "PDU",
 247         &asn_OP_CHOICE,
 248         0,      /* No effective tags (pointer) */
 249         0,      /* No effective tags (count) */
 250         0,      /* No tags (pointer) */
 251         0,      /* No tags (count) */
 252         { 0, 0, CHOICE_constraint },
 253         asn_MBR_PDU_1,
 254         15,     /* Elements count */
 255         &asn_SPC_PDU_specs_1    /* Additional specs */
 256 };
 257
 258
 259 /*** <<< INCLUDES [Sequence] >>> ***/
 260
 261 #include <INTEGER.h>
 262 #include <BIT_STRING.h>
 263 #include <UTF8String.h>
 264 #include <constr_SEQUENCE.h>
 265
 266 /*** <<< FWD-DECLS [Sequence] >>> ***/
 267
 268 struct Sequence;
 269
 270 /*** <<< TYPE-DECLS [Sequence] >>> ***/
 271
 272 typedef struct Sequence {
 273         INTEGER_t        integer;
 274         struct Sequence *sequence;      /* OPTIONAL */
 275         BIT_STRING_t    *bits;  /* OPTIONAL */
 276         UTF8String_t     string;
 277
 278         /* Context for parsing across buffer boundaries */
 279         asn_struct_ctx_t _asn_ctx;
 280 } Sequence_t;
 281
 282 /*** <<< FUNC-DECLS [Sequence] >>> ***/
 283
 284 extern asn_TYPE_descriptor_t asn_DEF_Sequence;
 285 extern asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1;
 286 extern asn_TYPE_member_t asn_MBR_Sequence_1[4];
 287
 288 /*** <<< POST-INCLUDE [Sequence] >>> ***/
 289
 290 #include "Sequence.h"
 291
 292 /*** <<< STAT-DEFS [Sequence] >>> ***/
 293
 294 asn_TYPE_member_t asn_MBR_Sequence_1[] = {
 295         { ATF_NOFLAGS, 0, offsetof(struct Sequence, integer),
 296                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 297                 .tag_mode = -1, /* IMPLICIT tag at current level */
 298                 .type = &asn_DEF_INTEGER,
 299                 .type_selector = 0,
 300                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 301                 0, 0, /* No default value */
 302                 .name = "integer"
 303                 },
 304         { ATF_POINTER, 2, offsetof(struct Sequence, sequence),
 305                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 306                 .tag_mode = -1, /* IMPLICIT tag at current level */
 307                 .type = &asn_DEF_Sequence,
 308                 .type_selector = 0,
 309                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 310                 0, 0, /* No default value */
 311                 .name = "sequence"
 312                 },
 313         { ATF_POINTER, 1, offsetof(struct Sequence, bits),
 314                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 315                 .tag_mode = -1, /* IMPLICIT tag at current level */
 316                 .type = &asn_DEF_BIT_STRING,
 317                 .type_selector = 0,
 318                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 319                 0, 0, /* No default value */
 320                 .name = "bits"
 321                 },
 322         { ATF_NOFLAGS, 0, offsetof(struct Sequence, string),
 323                 .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 324                 .tag_mode = -1, /* IMPLICIT tag at current level */
 325                 .type = &asn_DEF_UTF8String,
 326                 .type_selector = 0,
 327                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 328                 0, 0, /* No default value */
 329                 .name = "string"
 330                 },
 331 };
 332 static const ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
 333         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 334 };
 335 static const asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
 336     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* integer */
 337     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* sequence */
 338     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* bits */
 339     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* string */
 340 };
 341 asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
 342         sizeof(struct Sequence),
 343         offsetof(struct Sequence, _asn_ctx),
 344         .tag2el = asn_MAP_Sequence_tag2el_1,
 345         .tag2el_count = 4,      /* Count of tags in the map */
 346         0, 0, 0,        /* Optional elements (not needed) */
 347         -1,     /* First extension addition */
 348 };
 349 asn_TYPE_descriptor_t asn_DEF_Sequence = {
 350         "Sequence",
 351         "Sequence",
 352         &asn_OP_SEQUENCE,
 353         asn_DEF_Sequence_tags_1,
 354         sizeof(asn_DEF_Sequence_tags_1)
 355                 /sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
 356         asn_DEF_Sequence_tags_1,        /* Same as above */
 357         sizeof(asn_DEF_Sequence_tags_1)
 358                 /sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
 359         { 0, 0, SEQUENCE_constraint },
 360         asn_MBR_Sequence_1,
 361         4,      /* Elements count */
 362         &asn_SPC_Sequence_specs_1       /* Additional specs */
 363 };
 364
 365
 366 /*** <<< INCLUDES [Set] >>> ***/
 367
 368 #include <RELATIVE-OID.h>
 369 #include <OCTET_STRING.h>
 370 #include <constr_SET.h>
 371
 372 /*** <<< DEPS [Set] >>> ***/
 373
 374
 375 /*
 376  * Method of determining the components presence
 377  */
 378 typedef enum Set_PR {
 379         Set_PR_roid,    /* Member roid is present */
 380         Set_PR_opaque,  /* Member opaque is present */
 381 } Set_PR;
 382
 383 /*** <<< TYPE-DECLS [Set] >>> ***/
 384
 385 typedef struct Set {
 386         RELATIVE_OID_t   roid;
 387         OCTET_STRING_t  *opaque;        /* OPTIONAL */
 388
 389         /* Presence bitmask: ASN_SET_ISPRESENT(pSet, Set_PR_x) */
 390         unsigned int _presence_map
 391                 [((2+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))];
 392
 393         /* Context for parsing across buffer boundaries */
 394         asn_struct_ctx_t _asn_ctx;
 395 } Set_t;
 396
 397 /*** <<< FUNC-DECLS [Set] >>> ***/
 398
 399 extern asn_TYPE_descriptor_t asn_DEF_Set;
 400 extern asn_SET_specifics_t asn_SPC_Set_specs_1;
 401 extern asn_TYPE_member_t asn_MBR_Set_1[2];
 402
 403 /*** <<< STAT-DEFS [Set] >>> ***/
 404
 405 asn_TYPE_member_t asn_MBR_Set_1[] = {
 406         { ATF_NOFLAGS, 0, offsetof(struct Set, roid),
 407                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 408                 .tag_mode = -1, /* IMPLICIT tag at current level */
 409                 .type = &asn_DEF_RELATIVE_OID,
 410                 .type_selector = 0,
 411                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 412                 0, 0, /* No default value */
 413                 .name = "roid"
 414                 },
 415         { ATF_POINTER, 1, offsetof(struct Set, opaque),
 416                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 417                 .tag_mode = -1, /* IMPLICIT tag at current level */
 418                 .type = &asn_DEF_OCTET_STRING,
 419                 .type_selector = 0,
 420                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 421                 0, 0, /* No default value */
 422                 .name = "opaque"
 423                 },
 424 };
 425 static const ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
 426         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 427 };
 428 static const asn_TYPE_tag2member_t asn_MAP_Set_tag2el_1[] = {
 429     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* roid */
 430     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* opaque */
 431 };
 432 static const uint8_t asn_MAP_Set_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 433         (1 << 7) | (0 << 6)
 434 };
 435 asn_SET_specifics_t asn_SPC_Set_specs_1 = {
 436         sizeof(struct Set),
 437         offsetof(struct Set, _asn_ctx),
 438         offsetof(struct Set, _presence_map),
 439         .tag2el = asn_MAP_Set_tag2el_1,
 440         .tag2el_count = 2,      /* Count of tags in the map */
 441         asn_MAP_Set_tag2el_1,   /* Same as above */
 442         2,      /* Count of tags in the CXER map */
 443         0,      /* Whether extensible */
 444         (const unsigned int *)asn_MAP_Set_mmap_1        /* Mandatory elements map */
 445 };
 446 asn_TYPE_descriptor_t asn_DEF_Set = {
 447         "Set",
 448         "Set",
 449         &asn_OP_SET,
 450         asn_DEF_Set_tags_1,
 451         sizeof(asn_DEF_Set_tags_1)
 452                 /sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
 453         asn_DEF_Set_tags_1,     /* Same as above */
 454         sizeof(asn_DEF_Set_tags_1)
 455                 /sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
 456         { 0, 0, SET_constraint },
 457         asn_MBR_Set_1,
 458         2,      /* Elements count */
 459         &asn_SPC_Set_specs_1    /* Additional specs */
 460 };
 461
 462
 463 /*** <<< INCLUDES [ExtensibleSet] >>> ***/
 464
 465 #include <UTF8String.h>
 466 #include <ENUMERATED.h>
 467 #include <constr_SET.h>
 468
 469 /*** <<< DEPS [ExtensibleSet] >>> ***/
 470
 471
 472 /*
 473  * Method of determining the components presence
 474  */
 475 typedef enum ExtensibleSet_PR {
 476         ExtensibleSet_PR_string,        /* Member string is present */
 477         ExtensibleSet_PR_enum,  /* Member enum is present */
 478 } ExtensibleSet_PR;
 479 typedef enum Enum {
 480         enum_b  = 0,
 481         enum_a  = 1
 482 } e_enum;
 483
 484 /*** <<< TYPE-DECLS [ExtensibleSet] >>> ***/
 485
 486 typedef struct ExtensibleSet {
 487         UTF8String_t    *string;        /* OPTIONAL */
 488         /*
 489          * This type is extensible,
 490          * possible extensions are below.
 491          */
 492         ENUMERATED_t    *Enum;
 493
 494         /* Presence bitmask: ASN_SET_ISPRESENT(pExtensibleSet, ExtensibleSet_PR_x) */
 495         unsigned int _presence_map
 496                 [((2+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))];
 497
 498         /* Context for parsing across buffer boundaries */
 499         asn_struct_ctx_t _asn_ctx;
 500 } ExtensibleSet_t;
 501
 502 /*** <<< FUNC-DECLS [ExtensibleSet] >>> ***/
 503
 504 /* extern asn_TYPE_descriptor_t asn_DEF_enum_4; // (Use -fall-defs-global to expose) */
 505 extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSet;
 506 extern asn_SET_specifics_t asn_SPC_ExtensibleSet_specs_1;
 507 extern asn_TYPE_member_t asn_MBR_ExtensibleSet_1[2];
 508
 509 /*** <<< CODE [ExtensibleSet] >>> ***/
 510
 511 /*
 512  * This type is implemented using ENUMERATED,
 513  * so here we adjust the DEF accordingly.
 514  */
 515
 516 /*** <<< STAT-DEFS [ExtensibleSet] >>> ***/
 517
 518 static const asn_INTEGER_enum_map_t asn_MAP_enum_value2enum_4[] = {
 519         { 0,    1,      "b" },
 520         { 1,    1,      "a" }
 521 };
 522 static const unsigned int asn_MAP_enum_enum2value_4[] = {
 523         1,      /* a(1) */
 524         0       /* b(0) */
 525 };
 526 static const asn_INTEGER_specifics_t asn_SPC_enum_specs_4 = {
 527         asn_MAP_enum_value2enum_4,      /* "tag" => N; sorted by tag */
 528         asn_MAP_enum_enum2value_4,      /* N => "tag"; sorted by N */
 529         2,      /* Number of elements in the maps */
 530         0,      /* Enumeration is not extensible */
 531         1,      /* Strict enumeration */
 532         0,      /* Native long size */
 533         0
 534 };
 535 static const ber_tlv_tag_t asn_DEF_enum_tags_4[] = {
 536         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 537         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 538 };
 539 static /* Use -fall-defs-global to expose */
 540 asn_TYPE_descriptor_t asn_DEF_enum_4 = {
 541         "enum",
 542         "enum",
 543         &asn_OP_ENUMERATED,
 544         asn_DEF_enum_tags_4,
 545         sizeof(asn_DEF_enum_tags_4)
 546                 /sizeof(asn_DEF_enum_tags_4[0]) - 1, /* 1 */
 547         asn_DEF_enum_tags_4,    /* Same as above */
 548         sizeof(asn_DEF_enum_tags_4)
 549                 /sizeof(asn_DEF_enum_tags_4[0]), /* 2 */
 550         { 0, 0, ENUMERATED_constraint },
 551         0, 0,   /* Defined elsewhere */
 552         &asn_SPC_enum_specs_4   /* Additional specs */
 553 };
 554
 555 asn_TYPE_member_t asn_MBR_ExtensibleSet_1[] = {
 556         { ATF_POINTER, 2, offsetof(struct ExtensibleSet, string),
 557                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 558                 .tag_mode = -1, /* IMPLICIT tag at current level */
 559                 .type = &asn_DEF_UTF8String,
 560                 .type_selector = 0,
 561                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 562                 0, 0, /* No default value */
 563                 .name = "string"
 564                 },
 565         { ATF_POINTER, 1, offsetof(struct ExtensibleSet, Enum),
 566                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 567                 .tag_mode = -1, /* IMPLICIT tag at current level */
 568                 .type = &asn_DEF_enum_4,
 569                 .type_selector = 0,
 570                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 571                 0, 0, /* No default value */
 572                 .name = "enum"
 573                 },
 574 };
 575 static const ber_tlv_tag_t asn_DEF_ExtensibleSet_tags_1[] = {
 576         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 577 };
 578 static const asn_TYPE_tag2member_t asn_MAP_ExtensibleSet_tag2el_1[] = {
 579     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string */
 580     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* enum */
 581 };
 582 static const uint8_t asn_MAP_ExtensibleSet_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
 583         (0 << 7) | (0 << 6)
 584 };
 585 asn_SET_specifics_t asn_SPC_ExtensibleSet_specs_1 = {
 586         sizeof(struct ExtensibleSet),
 587         offsetof(struct ExtensibleSet, _asn_ctx),
 588         offsetof(struct ExtensibleSet, _presence_map),
 589         .tag2el = asn_MAP_ExtensibleSet_tag2el_1,
 590         .tag2el_count = 2,      /* Count of tags in the map */
 591         asn_MAP_ExtensibleSet_tag2el_1, /* Same as above */
 592         2,      /* Count of tags in the CXER map */
 593         1,      /* Whether extensible */
 594         (const unsigned int *)asn_MAP_ExtensibleSet_mmap_1      /* Mandatory elements map */
 595 };
 596 asn_TYPE_descriptor_t asn_DEF_ExtensibleSet = {
 597         "ExtensibleSet",
 598         "ExtensibleSet",
 599         &asn_OP_SET,
 600         asn_DEF_ExtensibleSet_tags_1,
 601         sizeof(asn_DEF_ExtensibleSet_tags_1)
 602                 /sizeof(asn_DEF_ExtensibleSet_tags_1[0]), /* 1 */
 603         asn_DEF_ExtensibleSet_tags_1,   /* Same as above */
 604         sizeof(asn_DEF_ExtensibleSet_tags_1)
 605                 /sizeof(asn_DEF_ExtensibleSet_tags_1[0]), /* 1 */
 606         { 0, 0, SET_constraint },
 607         asn_MBR_ExtensibleSet_1,
 608         2,      /* Elements count */
 609         &asn_SPC_ExtensibleSet_specs_1  /* Additional specs */
 610 };
 611
 612
 613 /*** <<< INCLUDES [ExtensibleSequence] >>> ***/
 614
 615 #include <UTF8String.h>
 616 #include <INTEGER.h>
 617 #include <GeneralizedTime.h>
 618 #include <constr_SEQUENCE.h>
 619
 620 /*** <<< TYPE-DECLS [ExtensibleSequence] >>> ***/
 621
 622 typedef struct ExtensibleSequence {
 623         UTF8String_t    *string;        /* OPTIONAL */
 624         /*
 625          * This type is extensible,
 626          * possible extensions are below.
 627          */
 628         INTEGER_t       *integer;       /* OPTIONAL */
 629         GeneralizedTime_t       *gtime;
 630
 631         /* Context for parsing across buffer boundaries */
 632         asn_struct_ctx_t _asn_ctx;
 633 } ExtensibleSequence_t;
 634
 635 /*** <<< FUNC-DECLS [ExtensibleSequence] >>> ***/
 636
 637 extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence;
 638 extern asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_specs_1;
 639 extern asn_TYPE_member_t asn_MBR_ExtensibleSequence_1[3];
 640
 641 /*** <<< STAT-DEFS [ExtensibleSequence] >>> ***/
 642
 643 asn_TYPE_member_t asn_MBR_ExtensibleSequence_1[] = {
 644         { ATF_POINTER, 3, offsetof(struct ExtensibleSequence, string),
 645                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 646                 .tag_mode = -1, /* IMPLICIT tag at current level */
 647                 .type = &asn_DEF_UTF8String,
 648                 .type_selector = 0,
 649                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 650                 0, 0, /* No default value */
 651                 .name = "string"
 652                 },
 653         { ATF_POINTER, 2, offsetof(struct ExtensibleSequence, integer),
 654                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 655                 .tag_mode = -1, /* IMPLICIT tag at current level */
 656                 .type = &asn_DEF_INTEGER,
 657                 .type_selector = 0,
 658                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 659                 0, 0, /* No default value */
 660                 .name = "integer"
 661                 },
 662         { ATF_POINTER, 1, offsetof(struct ExtensibleSequence, gtime),
 663                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 664                 .tag_mode = -1, /* IMPLICIT tag at current level */
 665                 .type = &asn_DEF_GeneralizedTime,
 666                 .type_selector = 0,
 667                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 668                 0, 0, /* No default value */
 669                 .name = "gtime"
 670                 },
 671 };
 672 static const ber_tlv_tag_t asn_DEF_ExtensibleSequence_tags_1[] = {
 673         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 674 };
 675 static const asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence_tag2el_1[] = {
 676     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string */
 677     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* integer */
 678     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* gtime */
 679 };
 680 asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence_specs_1 = {
 681         sizeof(struct ExtensibleSequence),
 682         offsetof(struct ExtensibleSequence, _asn_ctx),
 683         .tag2el = asn_MAP_ExtensibleSequence_tag2el_1,
 684         .tag2el_count = 3,      /* Count of tags in the map */
 685         0, 0, 0,        /* Optional elements (not needed) */
 686         1,      /* First extension addition */
 687 };
 688 asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence = {
 689         "ExtensibleSequence",
 690         "ExtensibleSequence",
 691         &asn_OP_SEQUENCE,
 692         asn_DEF_ExtensibleSequence_tags_1,
 693         sizeof(asn_DEF_ExtensibleSequence_tags_1)
 694                 /sizeof(asn_DEF_ExtensibleSequence_tags_1[0]), /* 1 */
 695         asn_DEF_ExtensibleSequence_tags_1,      /* Same as above */
 696         sizeof(asn_DEF_ExtensibleSequence_tags_1)
 697                 /sizeof(asn_DEF_ExtensibleSequence_tags_1[0]), /* 1 */
 698         { 0, 0, SEQUENCE_constraint },
 699         asn_MBR_ExtensibleSequence_1,
 700         3,      /* Elements count */
 701         &asn_SPC_ExtensibleSequence_specs_1     /* Additional specs */
 702 };
 703
 704
 705 /*** <<< INCLUDES [ExtensibleSequence2] >>> ***/
 706
 707 #include <UTF8String.h>
 708 #include <INTEGER.h>
 709 #include <constr_SEQUENCE.h>
 710
 711 /*** <<< TYPE-DECLS [ExtensibleSequence2] >>> ***/
 712
 713 typedef struct ExtensibleSequence2 {
 714         UTF8String_t    *string;        /* OPTIONAL */
 715         /*
 716          * This type is extensible,
 717          * possible extensions are below.
 718          */
 719         INTEGER_t       *integer;       /* OPTIONAL */
 720
 721         /* Context for parsing across buffer boundaries */
 722         asn_struct_ctx_t _asn_ctx;
 723 } ExtensibleSequence2_t;
 724
 725 /*** <<< FUNC-DECLS [ExtensibleSequence2] >>> ***/
 726
 727 extern asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence2;
 728 extern asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_specs_1;
 729 extern asn_TYPE_member_t asn_MBR_ExtensibleSequence2_1[2];
 730
 731 /*** <<< STAT-DEFS [ExtensibleSequence2] >>> ***/
 732
 733 asn_TYPE_member_t asn_MBR_ExtensibleSequence2_1[] = {
 734         { ATF_POINTER, 2, offsetof(struct ExtensibleSequence2, string),
 735                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 736                 .tag_mode = -1, /* IMPLICIT tag at current level */
 737                 .type = &asn_DEF_UTF8String,
 738                 .type_selector = 0,
 739                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 740                 0, 0, /* No default value */
 741                 .name = "string"
 742                 },
 743         { ATF_POINTER, 1, offsetof(struct ExtensibleSequence2, integer),
 744                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 745                 .tag_mode = -1, /* IMPLICIT tag at current level */
 746                 .type = &asn_DEF_INTEGER,
 747                 .type_selector = 0,
 748                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 749                 0, 0, /* No default value */
 750                 .name = "integer"
 751                 },
 752 };
 753 static const ber_tlv_tag_t asn_DEF_ExtensibleSequence2_tags_1[] = {
 754         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 755 };
 756 static const asn_TYPE_tag2member_t asn_MAP_ExtensibleSequence2_tag2el_1[] = {
 757     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* string */
 758     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* integer */
 759 };
 760 asn_SEQUENCE_specifics_t asn_SPC_ExtensibleSequence2_specs_1 = {
 761         sizeof(struct ExtensibleSequence2),
 762         offsetof(struct ExtensibleSequence2, _asn_ctx),
 763         .tag2el = asn_MAP_ExtensibleSequence2_tag2el_1,
 764         .tag2el_count = 2,      /* Count of tags in the map */
 765         0, 0, 0,        /* Optional elements (not needed) */
 766         1,      /* First extension addition */
 767 };
 768 asn_TYPE_descriptor_t asn_DEF_ExtensibleSequence2 = {
 769         "ExtensibleSequence2",
 770         "ExtensibleSequence2",
 771         &asn_OP_SEQUENCE,
 772         asn_DEF_ExtensibleSequence2_tags_1,
 773         sizeof(asn_DEF_ExtensibleSequence2_tags_1)
 774                 /sizeof(asn_DEF_ExtensibleSequence2_tags_1[0]), /* 1 */
 775         asn_DEF_ExtensibleSequence2_tags_1,     /* Same as above */
 776         sizeof(asn_DEF_ExtensibleSequence2_tags_1)
 777                 /sizeof(asn_DEF_ExtensibleSequence2_tags_1[0]), /* 1 */
 778         { 0, 0, SEQUENCE_constraint },
 779         asn_MBR_ExtensibleSequence2_1,
 780         2,      /* Elements count */
 781         &asn_SPC_ExtensibleSequence2_specs_1    /* Additional specs */
 782 };
 783
 784
 785 /*** <<< INCLUDES [SetOfNULL] >>> ***/
 786
 787 #include <NULL.h>
 788 #include <asn_SET_OF.h>
 789 #include <constr_SET_OF.h>
 790
 791 /*** <<< TYPE-DECLS [SetOfNULL] >>> ***/
 792
 793 typedef struct SetOfNULL {
 794         A_SET_OF(NULL_t) list;
 795
 796         /* Context for parsing across buffer boundaries */
 797         asn_struct_ctx_t _asn_ctx;
 798 } SetOfNULL_t;
 799
 800 /*** <<< FUNC-DECLS [SetOfNULL] >>> ***/
 801
 802 extern asn_TYPE_descriptor_t asn_DEF_SetOfNULL;
 803 extern asn_SET_OF_specifics_t asn_SPC_SetOfNULL_specs_1;
 804 extern asn_TYPE_member_t asn_MBR_SetOfNULL_1[1];
 805
 806 /*** <<< STAT-DEFS [SetOfNULL] >>> ***/
 807
 808 asn_TYPE_member_t asn_MBR_SetOfNULL_1[] = {
 809         { ATF_POINTER, 0, 0,
 810                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
 811                 .tag_mode = 0,
 812                 .type = &asn_DEF_NULL,
 813                 .type_selector = 0,
 814                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 815                 0, 0, /* No default value */
 816                 .name = ""
 817                 },
 818 };
 819 static const ber_tlv_tag_t asn_DEF_SetOfNULL_tags_1[] = {
 820         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 821 };
 822 asn_SET_OF_specifics_t asn_SPC_SetOfNULL_specs_1 = {
 823         sizeof(struct SetOfNULL),
 824         offsetof(struct SetOfNULL, _asn_ctx),
 825         1,      /* XER encoding is XMLValueList */
 826 };
 827 asn_TYPE_descriptor_t asn_DEF_SetOfNULL = {
 828         "SetOfNULL",
 829         "SetOfNULL",
 830         &asn_OP_SET_OF,
 831         asn_DEF_SetOfNULL_tags_1,
 832         sizeof(asn_DEF_SetOfNULL_tags_1)
 833                 /sizeof(asn_DEF_SetOfNULL_tags_1[0]), /* 1 */
 834         asn_DEF_SetOfNULL_tags_1,       /* Same as above */
 835         sizeof(asn_DEF_SetOfNULL_tags_1)
 836                 /sizeof(asn_DEF_SetOfNULL_tags_1[0]), /* 1 */
 837         { 0, 0, SET_OF_constraint },
 838         asn_MBR_SetOfNULL_1,
 839         1,      /* Single element */
 840         &asn_SPC_SetOfNULL_specs_1      /* Additional specs */
 841 };
 842
 843
 844 /*** <<< INCLUDES [SetOfREAL] >>> ***/
 845
 846 #include <REAL.h>
 847 #include <asn_SET_OF.h>
 848 #include <constr_SET_OF.h>
 849
 850 /*** <<< TYPE-DECLS [SetOfREAL] >>> ***/
 851
 852 typedef struct SetOfREAL {
 853         A_SET_OF(REAL_t) list;
 854
 855         /* Context for parsing across buffer boundaries */
 856         asn_struct_ctx_t _asn_ctx;
 857 } SetOfREAL_t;
 858
 859 /*** <<< FUNC-DECLS [SetOfREAL] >>> ***/
 860
 861 extern asn_TYPE_descriptor_t asn_DEF_SetOfREAL;
 862 extern asn_SET_OF_specifics_t asn_SPC_SetOfREAL_specs_1;
 863 extern asn_TYPE_member_t asn_MBR_SetOfREAL_1[1];
 864
 865 /*** <<< STAT-DEFS [SetOfREAL] >>> ***/
 866
 867 asn_TYPE_member_t asn_MBR_SetOfREAL_1[] = {
 868         { ATF_POINTER, 0, 0,
 869                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 870                 .tag_mode = 0,
 871                 .type = &asn_DEF_REAL,
 872                 .type_selector = 0,
 873                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 874                 0, 0, /* No default value */
 875                 .name = ""
 876                 },
 877 };
 878 static const ber_tlv_tag_t asn_DEF_SetOfREAL_tags_1[] = {
 879         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 880 };
 881 asn_SET_OF_specifics_t asn_SPC_SetOfREAL_specs_1 = {
 882         sizeof(struct SetOfREAL),
 883         offsetof(struct SetOfREAL, _asn_ctx),
 884         0,      /* XER encoding is XMLDelimitedItemList */
 885 };
 886 asn_TYPE_descriptor_t asn_DEF_SetOfREAL = {
 887         "SetOfREAL",
 888         "SetOfREAL",
 889         &asn_OP_SET_OF,
 890         asn_DEF_SetOfREAL_tags_1,
 891         sizeof(asn_DEF_SetOfREAL_tags_1)
 892                 /sizeof(asn_DEF_SetOfREAL_tags_1[0]), /* 1 */
 893         asn_DEF_SetOfREAL_tags_1,       /* Same as above */
 894         sizeof(asn_DEF_SetOfREAL_tags_1)
 895                 /sizeof(asn_DEF_SetOfREAL_tags_1[0]), /* 1 */
 896         { 0, 0, SET_OF_constraint },
 897         asn_MBR_SetOfREAL_1,
 898         1,      /* Single element */
 899         &asn_SPC_SetOfREAL_specs_1      /* Additional specs */
 900 };
 901
 902
 903 /*** <<< INCLUDES [SetOfEnums] >>> ***/
 904
 905 #include <ENUMERATED.h>
 906 #include <asn_SET_OF.h>
 907 #include <constr_SET_OF.h>
 908
 909 /*** <<< DEPS [SetOfEnums] >>> ***/
 910
 911 typedef enum Member {
 912         Member_one      = 0,
 913         Member_oneMore  = 1
 914 } e_Member;
 915
 916 /*** <<< TYPE-DECLS [SetOfEnums] >>> ***/
 917
 918 typedef struct SetOfEnums {
 919         A_SET_OF(ENUMERATED_t) list;
 920
 921         /* Context for parsing across buffer boundaries */
 922         asn_struct_ctx_t _asn_ctx;
 923 } SetOfEnums_t;
 924
 925 /*** <<< FUNC-DECLS [SetOfEnums] >>> ***/
 926
 927 /* extern asn_TYPE_descriptor_t asn_DEF_Member_2;       // (Use -fall-defs-global to expose) */
 928 extern asn_TYPE_descriptor_t asn_DEF_SetOfEnums;
 929 extern asn_SET_OF_specifics_t asn_SPC_SetOfEnums_specs_1;
 930 extern asn_TYPE_member_t asn_MBR_SetOfEnums_1[1];
 931
 932 /*** <<< CODE [SetOfEnums] >>> ***/
 933
 934 /*
 935  * This type is implemented using ENUMERATED,
 936  * so here we adjust the DEF accordingly.
 937  */
 938
 939 /*** <<< STAT-DEFS [SetOfEnums] >>> ***/
 940
 941 static const asn_INTEGER_enum_map_t asn_MAP_Member_value2enum_2[] = {
 942         { 0,    3,      "one" },
 943         { 1,    7,      "oneMore" }
 944 };
 945 static const unsigned int asn_MAP_Member_enum2value_2[] = {
 946         0,      /* one(0) */
 947         1       /* oneMore(1) */
 948 };
 949 static const asn_INTEGER_specifics_t asn_SPC_Member_specs_2 = {
 950         asn_MAP_Member_value2enum_2,    /* "tag" => N; sorted by tag */
 951         asn_MAP_Member_enum2value_2,    /* N => "tag"; sorted by N */
 952         2,      /* Number of elements in the maps */
 953         0,      /* Enumeration is not extensible */
 954         1,      /* Strict enumeration */
 955         0,      /* Native long size */
 956         0
 957 };
 958 static const ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
 959         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 960 };
 961 static /* Use -fall-defs-global to expose */
 962 asn_TYPE_descriptor_t asn_DEF_Member_2 = {
 963         "ENUMERATED",
 964         "ENUMERATED",
 965         &asn_OP_ENUMERATED,
 966         asn_DEF_Member_tags_2,
 967         sizeof(asn_DEF_Member_tags_2)
 968                 /sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
 969         asn_DEF_Member_tags_2,  /* Same as above */
 970         sizeof(asn_DEF_Member_tags_2)
 971                 /sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
 972         { 0, 0, ENUMERATED_constraint },
 973         0, 0,   /* Defined elsewhere */
 974         &asn_SPC_Member_specs_2 /* Additional specs */
 975 };
 976
 977 asn_TYPE_member_t asn_MBR_SetOfEnums_1[] = {
 978         { ATF_POINTER, 0, 0,
 979                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
 980                 .tag_mode = 0,
 981                 .type = &asn_DEF_Member_2,
 982                 .type_selector = 0,
 983                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 984                 0, 0, /* No default value */
 985                 .name = ""
 986                 },
 987 };
 988 static const ber_tlv_tag_t asn_DEF_SetOfEnums_tags_1[] = {
 989         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 990 };
 991 asn_SET_OF_specifics_t asn_SPC_SetOfEnums_specs_1 = {
 992         sizeof(struct SetOfEnums),
 993         offsetof(struct SetOfEnums, _asn_ctx),
 994         1,      /* XER encoding is XMLValueList */
 995 };
 996 asn_TYPE_descriptor_t asn_DEF_SetOfEnums = {
 997         "SetOfEnums",
 998         "SetOfEnums",
 999         &asn_OP_SET_OF,
1000         asn_DEF_SetOfEnums_tags_1,
1001         sizeof(asn_DEF_SetOfEnums_tags_1)
1002                 /sizeof(asn_DEF_SetOfEnums_tags_1[0]), /* 1 */
1003         asn_DEF_SetOfEnums_tags_1,      /* Same as above */
1004         sizeof(asn_DEF_SetOfEnums_tags_1)
1005                 /sizeof(asn_DEF_SetOfEnums_tags_1[0]), /* 1 */
1006         { 0, 0, SET_OF_constraint },
1007         asn_MBR_SetOfEnums_1,
1008         1,      /* Single element */
1009         &asn_SPC_SetOfEnums_specs_1     /* Additional specs */
1010 };
1011
1012
1013 /*** <<< INCLUDES [NamedSetOfNULL] >>> ***/
1014
1015 #include <NULL.h>
1016 #include <asn_SET_OF.h>
1017 #include <constr_SET_OF.h>
1018
1019 /*** <<< TYPE-DECLS [NamedSetOfNULL] >>> ***/
1020
1021 typedef struct NamedSetOfNULL {
1022         A_SET_OF(NULL_t) list;
1023
1024         /* Context for parsing across buffer boundaries */
1025         asn_struct_ctx_t _asn_ctx;
1026 } NamedSetOfNULL_t;
1027
1028 /*** <<< FUNC-DECLS [NamedSetOfNULL] >>> ***/
1029
1030 extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfNULL;
1031 extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfNULL_specs_1;
1032 extern asn_TYPE_member_t asn_MBR_NamedSetOfNULL_1[1];
1033
1034 /*** <<< STAT-DEFS [NamedSetOfNULL] >>> ***/
1035
1036 asn_TYPE_member_t asn_MBR_NamedSetOfNULL_1[] = {
1037         { ATF_POINTER, 0, 0,
1038                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
1039                 .tag_mode = 0,
1040                 .type = &asn_DEF_NULL,
1041                 .type_selector = 0,
1042                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1043                 0, 0, /* No default value */
1044                 .name = "y"
1045                 },
1046 };
1047 static const ber_tlv_tag_t asn_DEF_NamedSetOfNULL_tags_1[] = {
1048         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1049 };
1050 asn_SET_OF_specifics_t asn_SPC_NamedSetOfNULL_specs_1 = {
1051         sizeof(struct NamedSetOfNULL),
1052         offsetof(struct NamedSetOfNULL, _asn_ctx),
1053         1,      /* XER encoding is XMLValueList */
1054 };
1055 asn_TYPE_descriptor_t asn_DEF_NamedSetOfNULL = {
1056         "NamedSetOfNULL",
1057         "NamedSetOfNULL",
1058         &asn_OP_SET_OF,
1059         asn_DEF_NamedSetOfNULL_tags_1,
1060         sizeof(asn_DEF_NamedSetOfNULL_tags_1)
1061                 /sizeof(asn_DEF_NamedSetOfNULL_tags_1[0]), /* 1 */
1062         asn_DEF_NamedSetOfNULL_tags_1,  /* Same as above */
1063         sizeof(asn_DEF_NamedSetOfNULL_tags_1)
1064                 /sizeof(asn_DEF_NamedSetOfNULL_tags_1[0]), /* 1 */
1065         { 0, 0, SET_OF_constraint },
1066         asn_MBR_NamedSetOfNULL_1,
1067         1,      /* Single element */
1068         &asn_SPC_NamedSetOfNULL_specs_1 /* Additional specs */
1069 };
1070
1071
1072 /*** <<< INCLUDES [NamedSetOfREAL] >>> ***/
1073
1074 #include <REAL.h>
1075 #include <asn_SET_OF.h>
1076 #include <constr_SET_OF.h>
1077
1078 /*** <<< TYPE-DECLS [NamedSetOfREAL] >>> ***/
1079
1080 typedef struct NamedSetOfREAL {
1081         A_SET_OF(REAL_t) list;
1082
1083         /* Context for parsing across buffer boundaries */
1084         asn_struct_ctx_t _asn_ctx;
1085 } NamedSetOfREAL_t;
1086
1087 /*** <<< FUNC-DECLS [NamedSetOfREAL] >>> ***/
1088
1089 extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfREAL;
1090 extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfREAL_specs_1;
1091 extern asn_TYPE_member_t asn_MBR_NamedSetOfREAL_1[1];
1092
1093 /*** <<< STAT-DEFS [NamedSetOfREAL] >>> ***/
1094
1095 asn_TYPE_member_t asn_MBR_NamedSetOfREAL_1[] = {
1096         { ATF_POINTER, 0, 0,
1097                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
1098                 .tag_mode = 0,
1099                 .type = &asn_DEF_REAL,
1100                 .type_selector = 0,
1101                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1102                 0, 0, /* No default value */
1103                 .name = "name"
1104                 },
1105 };
1106 static const ber_tlv_tag_t asn_DEF_NamedSetOfREAL_tags_1[] = {
1107         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1108 };
1109 asn_SET_OF_specifics_t asn_SPC_NamedSetOfREAL_specs_1 = {
1110         sizeof(struct NamedSetOfREAL),
1111         offsetof(struct NamedSetOfREAL, _asn_ctx),
1112         0,      /* XER encoding is XMLDelimitedItemList */
1113 };
1114 asn_TYPE_descriptor_t asn_DEF_NamedSetOfREAL = {
1115         "NamedSetOfREAL",
1116         "NamedSetOfREAL",
1117         &asn_OP_SET_OF,
1118         asn_DEF_NamedSetOfREAL_tags_1,
1119         sizeof(asn_DEF_NamedSetOfREAL_tags_1)
1120                 /sizeof(asn_DEF_NamedSetOfREAL_tags_1[0]), /* 1 */
1121         asn_DEF_NamedSetOfREAL_tags_1,  /* Same as above */
1122         sizeof(asn_DEF_NamedSetOfREAL_tags_1)
1123                 /sizeof(asn_DEF_NamedSetOfREAL_tags_1[0]), /* 1 */
1124         { 0, 0, SET_OF_constraint },
1125         asn_MBR_NamedSetOfREAL_1,
1126         1,      /* Single element */
1127         &asn_SPC_NamedSetOfREAL_specs_1 /* Additional specs */
1128 };
1129
1130
1131 /*** <<< INCLUDES [NamedSetOfEnums] >>> ***/
1132
1133 #include <ENUMERATED.h>
1134 #include <asn_SET_OF.h>
1135 #include <constr_SET_OF.h>
1136
1137 /*** <<< DEPS [NamedSetOfEnums] >>> ***/
1138
1139 typedef enum name {
1140         name_one        = 0,
1141         name_oneMore    = 1
1142 } e_name;
1143
1144 /*** <<< TYPE-DECLS [NamedSetOfEnums] >>> ***/
1145
1146 typedef struct NamedSetOfEnums {
1147         A_SET_OF(ENUMERATED_t) list;
1148
1149         /* Context for parsing across buffer boundaries */
1150         asn_struct_ctx_t _asn_ctx;
1151 } NamedSetOfEnums_t;
1152
1153 /*** <<< FUNC-DECLS [NamedSetOfEnums] >>> ***/
1154
1155 /* extern asn_TYPE_descriptor_t asn_DEF_name_2; // (Use -fall-defs-global to expose) */
1156 extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfEnums;
1157 extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfEnums_specs_1;
1158 extern asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[1];
1159
1160 /*** <<< CODE [NamedSetOfEnums] >>> ***/
1161
1162 /*
1163  * This type is implemented using ENUMERATED,
1164  * so here we adjust the DEF accordingly.
1165  */
1166
1167 /*** <<< STAT-DEFS [NamedSetOfEnums] >>> ***/
1168
1169 static const asn_INTEGER_enum_map_t asn_MAP_name_value2enum_2[] = {
1170         { 0,    3,      "one" },
1171         { 1,    7,      "oneMore" }
1172 };
1173 static const unsigned int asn_MAP_name_enum2value_2[] = {
1174         0,      /* one(0) */
1175         1       /* oneMore(1) */
1176 };
1177 static const asn_INTEGER_specifics_t asn_SPC_name_specs_2 = {
1178         asn_MAP_name_value2enum_2,      /* "tag" => N; sorted by tag */
1179         asn_MAP_name_enum2value_2,      /* N => "tag"; sorted by N */
1180         2,      /* Number of elements in the maps */
1181         0,      /* Enumeration is not extensible */
1182         1,      /* Strict enumeration */
1183         0,      /* Native long size */
1184         0
1185 };
1186 static const ber_tlv_tag_t asn_DEF_name_tags_2[] = {
1187         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
1188 };
1189 static /* Use -fall-defs-global to expose */
1190 asn_TYPE_descriptor_t asn_DEF_name_2 = {
1191         "ENUMERATED",
1192         "ENUMERATED",
1193         &asn_OP_ENUMERATED,
1194         asn_DEF_name_tags_2,
1195         sizeof(asn_DEF_name_tags_2)
1196                 /sizeof(asn_DEF_name_tags_2[0]), /* 1 */
1197         asn_DEF_name_tags_2,    /* Same as above */
1198         sizeof(asn_DEF_name_tags_2)
1199                 /sizeof(asn_DEF_name_tags_2[0]), /* 1 */
1200         { 0, 0, ENUMERATED_constraint },
1201         0, 0,   /* Defined elsewhere */
1202         &asn_SPC_name_specs_2   /* Additional specs */
1203 };
1204
1205 asn_TYPE_member_t asn_MBR_NamedSetOfEnums_1[] = {
1206         { ATF_POINTER, 0, 0,
1207                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
1208                 .tag_mode = 0,
1209                 .type = &asn_DEF_name_2,
1210                 .type_selector = 0,
1211                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1212                 0, 0, /* No default value */
1213                 .name = "name"
1214                 },
1215 };
1216 static const ber_tlv_tag_t asn_DEF_NamedSetOfEnums_tags_1[] = {
1217         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1218 };
1219 asn_SET_OF_specifics_t asn_SPC_NamedSetOfEnums_specs_1 = {
1220         sizeof(struct NamedSetOfEnums),
1221         offsetof(struct NamedSetOfEnums, _asn_ctx),
1222         1,      /* XER encoding is XMLValueList */
1223 };
1224 asn_TYPE_descriptor_t asn_DEF_NamedSetOfEnums = {
1225         "NamedSetOfEnums",
1226         "NamedSetOfEnums",
1227         &asn_OP_SET_OF,
1228         asn_DEF_NamedSetOfEnums_tags_1,
1229         sizeof(asn_DEF_NamedSetOfEnums_tags_1)
1230                 /sizeof(asn_DEF_NamedSetOfEnums_tags_1[0]), /* 1 */
1231         asn_DEF_NamedSetOfEnums_tags_1, /* Same as above */
1232         sizeof(asn_DEF_NamedSetOfEnums_tags_1)
1233                 /sizeof(asn_DEF_NamedSetOfEnums_tags_1[0]), /* 1 */
1234         { 0, 0, SET_OF_constraint },
1235         asn_MBR_NamedSetOfEnums_1,
1236         1,      /* Single element */
1237         &asn_SPC_NamedSetOfEnums_specs_1        /* Additional specs */
1238 };
1239
1240
1241 /*** <<< INCLUDES [SequenceOf] >>> ***/
1242
1243 #include <INTEGER.h>
1244 #include <asn_SEQUENCE_OF.h>
1245 #include <constr_SEQUENCE_OF.h>
1246
1247 /*** <<< TYPE-DECLS [SequenceOf] >>> ***/
1248
1249 typedef struct SequenceOf {
1250         A_SEQUENCE_OF(INTEGER_t) list;
1251
1252         /* Context for parsing across buffer boundaries */
1253         asn_struct_ctx_t _asn_ctx;
1254 } SequenceOf_t;
1255
1256 /*** <<< FUNC-DECLS [SequenceOf] >>> ***/
1257
1258 extern asn_TYPE_descriptor_t asn_DEF_SequenceOf;
1259 extern asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1;
1260 extern asn_TYPE_member_t asn_MBR_SequenceOf_1[1];
1261
1262 /*** <<< STAT-DEFS [SequenceOf] >>> ***/
1263
1264 asn_TYPE_member_t asn_MBR_SequenceOf_1[] = {
1265         { ATF_POINTER, 0, 0,
1266                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
1267                 .tag_mode = 0,
1268                 .type = &asn_DEF_INTEGER,
1269                 .type_selector = 0,
1270                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1271                 0, 0, /* No default value */
1272                 .name = "id"
1273                 },
1274 };
1275 static const ber_tlv_tag_t asn_DEF_SequenceOf_tags_1[] = {
1276         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1277 };
1278 asn_SET_OF_specifics_t asn_SPC_SequenceOf_specs_1 = {
1279         sizeof(struct SequenceOf),
1280         offsetof(struct SequenceOf, _asn_ctx),
1281         0,      /* XER encoding is XMLDelimitedItemList */
1282 };
1283 asn_TYPE_descriptor_t asn_DEF_SequenceOf = {
1284         "SequenceOf",
1285         "SequenceOf",
1286         &asn_OP_SEQUENCE_OF,
1287         asn_DEF_SequenceOf_tags_1,
1288         sizeof(asn_DEF_SequenceOf_tags_1)
1289                 /sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
1290         asn_DEF_SequenceOf_tags_1,      /* Same as above */
1291         sizeof(asn_DEF_SequenceOf_tags_1)
1292                 /sizeof(asn_DEF_SequenceOf_tags_1[0]), /* 1 */
1293         { 0, 0, SEQUENCE_OF_constraint },
1294         asn_MBR_SequenceOf_1,
1295         1,      /* Single element */
1296         &asn_SPC_SequenceOf_specs_1     /* Additional specs */
1297 };
1298
1299
1300 /*** <<< INCLUDES [SeqOfZuka] >>> ***/
1301
1302 #include <NULL.h>
1303 #include <asn_SEQUENCE_OF.h>
1304 #include <constr_SEQUENCE_OF.h>
1305
1306 /*** <<< TYPE-DECLS [SeqOfZuka] >>> ***/
1307
1308 typedef struct SeqOfZuka {
1309         A_SEQUENCE_OF(NULL_t) list;
1310
1311         /* Context for parsing across buffer boundaries */
1312         asn_struct_ctx_t _asn_ctx;
1313 } SeqOfZuka_t;
1314
1315 /*** <<< FUNC-DECLS [SeqOfZuka] >>> ***/
1316
1317 extern asn_TYPE_descriptor_t asn_DEF_SeqOfZuka;
1318 extern asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_specs_1;
1319 extern asn_TYPE_member_t asn_MBR_SeqOfZuka_1[1];
1320
1321 /*** <<< STAT-DEFS [SeqOfZuka] >>> ***/
1322
1323 asn_TYPE_member_t asn_MBR_SeqOfZuka_1[] = {
1324         { ATF_POINTER, 0, 0,
1325                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
1326                 .tag_mode = 0,
1327                 .type = &asn_DEF_NULL,
1328                 .type_selector = 0,
1329                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1330                 0, 0, /* No default value */
1331                 .name = "zuka"
1332                 },
1333 };
1334 static const ber_tlv_tag_t asn_DEF_SeqOfZuka_tags_1[] = {
1335         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1336 };
1337 asn_SET_OF_specifics_t asn_SPC_SeqOfZuka_specs_1 = {
1338         sizeof(struct SeqOfZuka),
1339         offsetof(struct SeqOfZuka, _asn_ctx),
1340         1,      /* XER encoding is XMLValueList */
1341 };
1342 asn_TYPE_descriptor_t asn_DEF_SeqOfZuka = {
1343         "SeqOfZuka",
1344         "SeqOfZuka",
1345         &asn_OP_SEQUENCE_OF,
1346         asn_DEF_SeqOfZuka_tags_1,
1347         sizeof(asn_DEF_SeqOfZuka_tags_1)
1348                 /sizeof(asn_DEF_SeqOfZuka_tags_1[0]), /* 1 */
1349         asn_DEF_SeqOfZuka_tags_1,       /* Same as above */
1350         sizeof(asn_DEF_SeqOfZuka_tags_1)
1351                 /sizeof(asn_DEF_SeqOfZuka_tags_1[0]), /* 1 */
1352         { 0, 0, SEQUENCE_OF_constraint },
1353         asn_MBR_SeqOfZuka_1,
1354         1,      /* Single element */
1355         &asn_SPC_SeqOfZuka_specs_1      /* Additional specs */
1356 };
1357
1358
1359 /*** <<< INCLUDES [SetOfChoice] >>> ***/
1360
1361 #include <asn_SET_OF.h>
1362 #include <constr_SET_OF.h>
1363
1364 /*** <<< FWD-DECLS [SetOfChoice] >>> ***/
1365
1366 struct SimpleChoice;
1367
1368 /*** <<< TYPE-DECLS [SetOfChoice] >>> ***/
1369
1370 typedef struct SetOfChoice {
1371         A_SET_OF(struct SimpleChoice) list;
1372
1373         /* Context for parsing across buffer boundaries */
1374         asn_struct_ctx_t _asn_ctx;
1375 } SetOfChoice_t;
1376
1377 /*** <<< FUNC-DECLS [SetOfChoice] >>> ***/
1378
1379 extern asn_TYPE_descriptor_t asn_DEF_SetOfChoice;
1380 extern asn_SET_OF_specifics_t asn_SPC_SetOfChoice_specs_1;
1381 extern asn_TYPE_member_t asn_MBR_SetOfChoice_1[1];
1382
1383 /*** <<< POST-INCLUDE [SetOfChoice] >>> ***/
1384
1385 #include "SimpleChoice.h"
1386
1387 /*** <<< STAT-DEFS [SetOfChoice] >>> ***/
1388
1389 asn_TYPE_member_t asn_MBR_SetOfChoice_1[] = {
1390         { ATF_POINTER, 0, 0,
1391                 .tag = -1 /* Ambiguous tag (CHOICE?) */,
1392                 .tag_mode = 0,
1393                 .type = &asn_DEF_SimpleChoice,
1394                 .type_selector = 0,
1395                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1396                 0, 0, /* No default value */
1397                 .name = ""
1398                 },
1399 };
1400 static const ber_tlv_tag_t asn_DEF_SetOfChoice_tags_1[] = {
1401         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1402 };
1403 asn_SET_OF_specifics_t asn_SPC_SetOfChoice_specs_1 = {
1404         sizeof(struct SetOfChoice),
1405         offsetof(struct SetOfChoice, _asn_ctx),
1406         2,      /* XER encoding is XMLValueList */
1407 };
1408 asn_TYPE_descriptor_t asn_DEF_SetOfChoice = {
1409         "SetOfChoice",
1410         "SetOfChoice",
1411         &asn_OP_SET_OF,
1412         asn_DEF_SetOfChoice_tags_1,
1413         sizeof(asn_DEF_SetOfChoice_tags_1)
1414                 /sizeof(asn_DEF_SetOfChoice_tags_1[0]), /* 1 */
1415         asn_DEF_SetOfChoice_tags_1,     /* Same as above */
1416         sizeof(asn_DEF_SetOfChoice_tags_1)
1417                 /sizeof(asn_DEF_SetOfChoice_tags_1[0]), /* 1 */
1418         { 0, 0, SET_OF_constraint },
1419         asn_MBR_SetOfChoice_1,
1420         1,      /* Single element */
1421         &asn_SPC_SetOfChoice_specs_1    /* Additional specs */
1422 };
1423
1424
1425 /*** <<< INCLUDES [NamedSetOfChoice] >>> ***/
1426
1427 #include <asn_SET_OF.h>
1428 #include <constr_SET_OF.h>
1429
1430 /*** <<< FWD-DECLS [NamedSetOfChoice] >>> ***/
1431
1432 struct SimpleChoice;
1433
1434 /*** <<< TYPE-DECLS [NamedSetOfChoice] >>> ***/
1435
1436 typedef struct NamedSetOfChoice {
1437         A_SET_OF(struct SimpleChoice) list;
1438
1439         /* Context for parsing across buffer boundaries */
1440         asn_struct_ctx_t _asn_ctx;
1441 } NamedSetOfChoice_t;
1442
1443 /*** <<< FUNC-DECLS [NamedSetOfChoice] >>> ***/
1444
1445 extern asn_TYPE_descriptor_t asn_DEF_NamedSetOfChoice;
1446 extern asn_SET_OF_specifics_t asn_SPC_NamedSetOfChoice_specs_1;
1447 extern asn_TYPE_member_t asn_MBR_NamedSetOfChoice_1[1];
1448
1449 /*** <<< POST-INCLUDE [NamedSetOfChoice] >>> ***/
1450
1451 #include "SimpleChoice.h"
1452
1453 /*** <<< STAT-DEFS [NamedSetOfChoice] >>> ***/
1454
1455 asn_TYPE_member_t asn_MBR_NamedSetOfChoice_1[] = {
1456         { ATF_POINTER, 0, 0,
1457                 .tag = -1 /* Ambiguous tag (CHOICE?) */,
1458                 .tag_mode = 0,
1459                 .type = &asn_DEF_SimpleChoice,
1460                 .type_selector = 0,
1461                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1462                 0, 0, /* No default value */
1463                 .name = "whatever"
1464                 },
1465 };
1466 static const ber_tlv_tag_t asn_DEF_NamedSetOfChoice_tags_1[] = {
1467         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1468 };
1469 asn_SET_OF_specifics_t asn_SPC_NamedSetOfChoice_specs_1 = {
1470         sizeof(struct NamedSetOfChoice),
1471         offsetof(struct NamedSetOfChoice, _asn_ctx),
1472         2,      /* XER encoding is XMLValueList */
1473 };
1474 asn_TYPE_descriptor_t asn_DEF_NamedSetOfChoice = {
1475         "NamedSetOfChoice",
1476         "NamedSetOfChoice",
1477         &asn_OP_SET_OF,
1478         asn_DEF_NamedSetOfChoice_tags_1,
1479         sizeof(asn_DEF_NamedSetOfChoice_tags_1)
1480                 /sizeof(asn_DEF_NamedSetOfChoice_tags_1[0]), /* 1 */
1481         asn_DEF_NamedSetOfChoice_tags_1,        /* Same as above */
1482         sizeof(asn_DEF_NamedSetOfChoice_tags_1)
1483                 /sizeof(asn_DEF_NamedSetOfChoice_tags_1[0]), /* 1 */
1484         { 0, 0, SET_OF_constraint },
1485         asn_MBR_NamedSetOfChoice_1,
1486         1,      /* Single element */
1487         &asn_SPC_NamedSetOfChoice_specs_1       /* Additional specs */
1488 };
1489
1490
1491 /*** <<< INCLUDES [SimpleChoice] >>> ***/
1492
1493 #include <NULL.h>
1494 #include <INTEGER.h>
1495 #include <constr_CHOICE.h>
1496
1497 /*** <<< DEPS [SimpleChoice] >>> ***/
1498
1499 typedef enum SimpleChoice_PR {
1500         SimpleChoice_PR_NOTHING,        /* No components present */
1501         SimpleChoice_PR_a,
1502         SimpleChoice_PR_b
1503 } SimpleChoice_PR;
1504
1505 /*** <<< TYPE-DECLS [SimpleChoice] >>> ***/
1506
1507 typedef struct SimpleChoice {
1508         SimpleChoice_PR present;
1509         union SimpleChoice_u {
1510                 NULL_t   a;
1511                 INTEGER_t        b;
1512         } choice;
1513
1514         /* Context for parsing across buffer boundaries */
1515         asn_struct_ctx_t _asn_ctx;
1516 } SimpleChoice_t;
1517
1518 /*** <<< FUNC-DECLS [SimpleChoice] >>> ***/
1519
1520 extern asn_TYPE_descriptor_t asn_DEF_SimpleChoice;
1521 extern asn_CHOICE_specifics_t asn_SPC_SimpleChoice_specs_1;
1522 extern asn_TYPE_member_t asn_MBR_SimpleChoice_1[2];
1523
1524 /*** <<< STAT-DEFS [SimpleChoice] >>> ***/
1525
1526 asn_TYPE_member_t asn_MBR_SimpleChoice_1[] = {
1527         { ATF_NOFLAGS, 0, offsetof(struct SimpleChoice, choice.a),
1528                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1529                 .tag_mode = -1, /* IMPLICIT tag at current level */
1530                 .type = &asn_DEF_NULL,
1531                 .type_selector = 0,
1532                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1533                 0, 0, /* No default value */
1534                 .name = "a"
1535                 },
1536         { ATF_NOFLAGS, 0, offsetof(struct SimpleChoice, choice.b),
1537                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1538                 .tag_mode = -1, /* IMPLICIT tag at current level */
1539                 .type = &asn_DEF_INTEGER,
1540                 .type_selector = 0,
1541                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1542                 0, 0, /* No default value */
1543                 .name = "b"
1544                 },
1545 };
1546 static const asn_TYPE_tag2member_t asn_MAP_SimpleChoice_tag2el_1[] = {
1547     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a */
1548     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b */
1549 };
1550 asn_CHOICE_specifics_t asn_SPC_SimpleChoice_specs_1 = {
1551         sizeof(struct SimpleChoice),
1552         offsetof(struct SimpleChoice, _asn_ctx),
1553         offsetof(struct SimpleChoice, present),
1554         sizeof(((struct SimpleChoice *)0)->present),
1555         .tag2el = asn_MAP_SimpleChoice_tag2el_1,
1556         .tag2el_count = 2,      /* Count of tags in the map */
1557         0, 0,
1558         .first_extension = -1   /* Extensions start */
1559 };
1560 asn_TYPE_descriptor_t asn_DEF_SimpleChoice = {
1561         "SimpleChoice",
1562         "SimpleChoice",
1563         &asn_OP_CHOICE,
1564         0,      /* No effective tags (pointer) */
1565         0,      /* No effective tags (count) */
1566         0,      /* No tags (pointer) */
1567         0,      /* No tags (count) */
1568         { 0, 0, CHOICE_constraint },
1569         asn_MBR_SimpleChoice_1,
1570         2,      /* Elements count */
1571         &asn_SPC_SimpleChoice_specs_1   /* Additional specs */
1572 };
1573