tests/tests-asn1c-compiler/92-circular-loops-OK.asn1.-Pfindirect-choice

   1
   2 /*** <<< INCLUDES [Everything] >>> ***/
   3
   4 #include "Set.h"
   5 #include "Alpha.h"
   6 #include "Beta.h"
   7 #include "Gamma.h"
   8 #include "OneTwo.h"
   9 #include "TwoThree.h"
  10 #include "ThreeOne.h"
  11 #include <constr_SEQUENCE.h>
  12
  13 /*** <<< FWD-DECLS [Everything] >>> ***/
  14
  15 struct Choice1;
  16 struct Choice2;
  17 struct Choice3;
  18
  19 /*** <<< TYPE-DECLS [Everything] >>> ***/
  20
  21 typedef struct Everything {
  22         struct Choice1  *ch1;
  23         struct Choice2  *ch2;
  24         struct Choice3  *ch3;
  25         Set_t    set;
  26         Alpha_t  a;
  27         Beta_t   b;
  28         Gamma_t  g;
  29         OneTwo_t         ot;
  30         TwoThree_t       tt;
  31         ThreeOne_t       to;
  32
  33         /* Context for parsing across buffer boundaries */
  34         asn_struct_ctx_t _asn_ctx;
  35 } Everything_t;
  36
  37 /*** <<< FUNC-DECLS [Everything] >>> ***/
  38
  39 extern asn_TYPE_descriptor_t asn_DEF_Everything;
  40 extern asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1;
  41 extern asn_TYPE_member_t asn_MBR_Everything_1[10];
  42
  43 /*** <<< POST-INCLUDE [Everything] >>> ***/
  44
  45 #include "Choice1.h"
  46 #include "Choice2.h"
  47 #include "Choice3.h"
  48
  49 /*** <<< STAT-DEFS [Everything] >>> ***/
  50
  51 asn_TYPE_member_t asn_MBR_Everything_1[] = {
  52         { ATF_POINTER, 0, offsetof(struct Everything, ch1),
  53                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
  54                 .tag_mode = +1, /* EXPLICIT tag at current level */
  55                 .type = &asn_DEF_Choice1,
  56                 .type_selector = 0,
  57                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  58                 0, 0, /* No default value */
  59                 .name = "ch1"
  60                 },
  61         { ATF_POINTER, 0, offsetof(struct Everything, ch2),
  62                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
  63                 .tag_mode = +1, /* EXPLICIT tag at current level */
  64                 .type = &asn_DEF_Choice2,
  65                 .type_selector = 0,
  66                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  67                 0, 0, /* No default value */
  68                 .name = "ch2"
  69                 },
  70         { ATF_POINTER, 0, offsetof(struct Everything, ch3),
  71                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
  72                 .tag_mode = +1, /* EXPLICIT tag at current level */
  73                 .type = &asn_DEF_Choice3,
  74                 .type_selector = 0,
  75                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  76                 0, 0, /* No default value */
  77                 .name = "ch3"
  78                 },
  79         { ATF_NOFLAGS, 0, offsetof(struct Everything, set),
  80                 .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
  81                 .tag_mode = -1, /* IMPLICIT tag at current level */
  82                 .type = &asn_DEF_Set,
  83                 .type_selector = 0,
  84                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  85                 0, 0, /* No default value */
  86                 .name = "set"
  87                 },
  88         { ATF_NOFLAGS, 0, offsetof(struct Everything, a),
  89                 .tag = (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
  90                 .tag_mode = -1, /* IMPLICIT tag at current level */
  91                 .type = &asn_DEF_Alpha,
  92                 .type_selector = 0,
  93                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  94                 0, 0, /* No default value */
  95                 .name = "a"
  96                 },
  97         { ATF_NOFLAGS, 0, offsetof(struct Everything, b),
  98                 .tag = (ASN_TAG_CLASS_CONTEXT | (5 << 2)),
  99                 .tag_mode = -1, /* IMPLICIT tag at current level */
 100                 .type = &asn_DEF_Beta,
 101                 .type_selector = 0,
 102                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 103                 0, 0, /* No default value */
 104                 .name = "b"
 105                 },
 106         { ATF_NOFLAGS, 0, offsetof(struct Everything, g),
 107                 .tag = (ASN_TAG_CLASS_CONTEXT | (6 << 2)),
 108                 .tag_mode = -1, /* IMPLICIT tag at current level */
 109                 .type = &asn_DEF_Gamma,
 110                 .type_selector = 0,
 111                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 112                 0, 0, /* No default value */
 113                 .name = "g"
 114                 },
 115         { ATF_NOFLAGS, 0, offsetof(struct Everything, ot),
 116                 .tag = (ASN_TAG_CLASS_CONTEXT | (7 << 2)),
 117                 .tag_mode = -1, /* IMPLICIT tag at current level */
 118                 .type = &asn_DEF_OneTwo,
 119                 .type_selector = 0,
 120                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 121                 0, 0, /* No default value */
 122                 .name = "ot"
 123                 },
 124         { ATF_NOFLAGS, 0, offsetof(struct Everything, tt),
 125                 .tag = (ASN_TAG_CLASS_CONTEXT | (8 << 2)),
 126                 .tag_mode = -1, /* IMPLICIT tag at current level */
 127                 .type = &asn_DEF_TwoThree,
 128                 .type_selector = 0,
 129                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 130                 0, 0, /* No default value */
 131                 .name = "tt"
 132                 },
 133         { ATF_NOFLAGS, 0, offsetof(struct Everything, to),
 134                 .tag = (ASN_TAG_CLASS_CONTEXT | (9 << 2)),
 135                 .tag_mode = -1, /* IMPLICIT tag at current level */
 136                 .type = &asn_DEF_ThreeOne,
 137                 .type_selector = 0,
 138                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 139                 0, 0, /* No default value */
 140                 .name = "to"
 141                 },
 142 };
 143 static const ber_tlv_tag_t asn_DEF_Everything_tags_1[] = {
 144         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 145 };
 146 static const asn_TYPE_tag2member_t asn_MAP_Everything_tag2el_1[] = {
 147     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* ch1 */
 148     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* ch2 */
 149     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* ch3 */
 150     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* set */
 151     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* a */
 152     { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* b */
 153     { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* g */
 154     { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* ot */
 155     { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* tt */
 156     { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* to */
 157 };
 158 asn_SEQUENCE_specifics_t asn_SPC_Everything_specs_1 = {
 159         sizeof(struct Everything),
 160         offsetof(struct Everything, _asn_ctx),
 161         .tag2el = asn_MAP_Everything_tag2el_1,
 162         .tag2el_count = 10,     /* Count of tags in the map */
 163         0, 0, 0,        /* Optional elements (not needed) */
 164         -1,     /* First extension addition */
 165 };
 166 asn_TYPE_descriptor_t asn_DEF_Everything = {
 167         "Everything",
 168         "Everything",
 169         &asn_OP_SEQUENCE,
 170         asn_DEF_Everything_tags_1,
 171         sizeof(asn_DEF_Everything_tags_1)
 172                 /sizeof(asn_DEF_Everything_tags_1[0]), /* 1 */
 173         asn_DEF_Everything_tags_1,      /* Same as above */
 174         sizeof(asn_DEF_Everything_tags_1)
 175                 /sizeof(asn_DEF_Everything_tags_1[0]), /* 1 */
 176         { 0, 0, SEQUENCE_constraint },
 177         asn_MBR_Everything_1,
 178         10,     /* Elements count */
 179         &asn_SPC_Everything_specs_1     /* Additional specs */
 180 };
 181
 182
 183 /*** <<< INCLUDES [Choice1] >>> ***/
 184
 185 #include <constr_CHOICE.h>
 186
 187 /*** <<< DEPS [Choice1] >>> ***/
 188
 189 typedef enum Choice1_PR {
 190         Choice1_PR_NOTHING,     /* No components present */
 191         Choice1_PR_something,
 192         /* Extensions may appear below */
 193         Choice1_PR_some2
 194 } Choice1_PR;
 195
 196 /*** <<< FWD-DECLS [Choice1] >>> ***/
 197
 198 struct Everything;
 199
 200 /*** <<< TYPE-DECLS [Choice1] >>> ***/
 201
 202 typedef struct Choice1 {
 203         Choice1_PR present;
 204         union Choice1_u {
 205                 struct Everything       *something;
 206                 /*
 207                  * This type is extensible,
 208                  * possible extensions are below.
 209                  */
 210                 struct Everything       *some2;
 211         } choice;
 212
 213         /* Context for parsing across buffer boundaries */
 214         asn_struct_ctx_t _asn_ctx;
 215 } Choice1_t;
 216
 217 /*** <<< FUNC-DECLS [Choice1] >>> ***/
 218
 219 extern asn_TYPE_descriptor_t asn_DEF_Choice1;
 220 extern asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1;
 221 extern asn_TYPE_member_t asn_MBR_Choice1_1[2];
 222
 223 /*** <<< POST-INCLUDE [Choice1] >>> ***/
 224
 225 #include "Everything.h"
 226
 227 /*** <<< STAT-DEFS [Choice1] >>> ***/
 228
 229 asn_TYPE_member_t asn_MBR_Choice1_1[] = {
 230         { ATF_POINTER, 0, offsetof(struct Choice1, choice.something),
 231                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 232                 .tag_mode = -1, /* IMPLICIT tag at current level */
 233                 .type = &asn_DEF_Everything,
 234                 .type_selector = 0,
 235                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 236                 0, 0, /* No default value */
 237                 .name = "something"
 238                 },
 239         { ATF_POINTER, 0, offsetof(struct Choice1, choice.some2),
 240                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 241                 .tag_mode = -1, /* IMPLICIT tag at current level */
 242                 .type = &asn_DEF_Everything,
 243                 .type_selector = 0,
 244                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 245                 0, 0, /* No default value */
 246                 .name = "some2"
 247                 },
 248 };
 249 static const asn_TYPE_tag2member_t asn_MAP_Choice1_tag2el_1[] = {
 250     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* something */
 251     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some2 */
 252 };
 253 asn_CHOICE_specifics_t asn_SPC_Choice1_specs_1 = {
 254         sizeof(struct Choice1),
 255         offsetof(struct Choice1, _asn_ctx),
 256         offsetof(struct Choice1, present),
 257         sizeof(((struct Choice1 *)0)->present),
 258         .tag2el = asn_MAP_Choice1_tag2el_1,
 259         .tag2el_count = 2,      /* Count of tags in the map */
 260         0, 0,
 261         .first_extension = 1    /* Extensions start */
 262 };
 263 asn_TYPE_descriptor_t asn_DEF_Choice1 = {
 264         "Choice1",
 265         "Choice1",
 266         &asn_OP_CHOICE,
 267         0,      /* No effective tags (pointer) */
 268         0,      /* No effective tags (count) */
 269         0,      /* No tags (pointer) */
 270         0,      /* No tags (count) */
 271         { 0, 0, CHOICE_constraint },
 272         asn_MBR_Choice1_1,
 273         2,      /* Elements count */
 274         &asn_SPC_Choice1_specs_1        /* Additional specs */
 275 };
 276
 277
 278 /*** <<< INCLUDES [Choice2] >>> ***/
 279
 280 #include <constr_CHOICE.h>
 281
 282 /*** <<< DEPS [Choice2] >>> ***/
 283
 284 typedef enum Choice2_PR {
 285         Choice2_PR_NOTHING,     /* No components present */
 286         Choice2_PR_typeref,
 287         /* Extensions may appear below */
 288         Choice2_PR_some3
 289 } Choice2_PR;
 290
 291 /*** <<< FWD-DECLS [Choice2] >>> ***/
 292
 293 struct TypeRef;
 294 struct Everything;
 295
 296 /*** <<< TYPE-DECLS [Choice2] >>> ***/
 297
 298 typedef struct Choice2 {
 299         Choice2_PR present;
 300         union Choice2_u {
 301                 struct TypeRef  *typeref;
 302                 /*
 303                  * This type is extensible,
 304                  * possible extensions are below.
 305                  */
 306                 struct Everything       *some3;
 307         } choice;
 308
 309         /* Context for parsing across buffer boundaries */
 310         asn_struct_ctx_t _asn_ctx;
 311 } Choice2_t;
 312
 313 /*** <<< FUNC-DECLS [Choice2] >>> ***/
 314
 315 extern asn_TYPE_descriptor_t asn_DEF_Choice2;
 316 extern asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1;
 317 extern asn_TYPE_member_t asn_MBR_Choice2_1[2];
 318
 319 /*** <<< POST-INCLUDE [Choice2] >>> ***/
 320
 321 #include "TypeRef.h"
 322 #include "Everything.h"
 323
 324 /*** <<< STAT-DEFS [Choice2] >>> ***/
 325
 326 asn_TYPE_member_t asn_MBR_Choice2_1[] = {
 327         { ATF_POINTER, 0, offsetof(struct Choice2, choice.typeref),
 328                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 329                 .tag_mode = -1, /* IMPLICIT tag at current level */
 330                 .type = &asn_DEF_TypeRef,
 331                 .type_selector = 0,
 332                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 333                 0, 0, /* No default value */
 334                 .name = "typeref"
 335                 },
 336         { ATF_POINTER, 0, offsetof(struct Choice2, choice.some3),
 337                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 338                 .tag_mode = -1, /* IMPLICIT tag at current level */
 339                 .type = &asn_DEF_Everything,
 340                 .type_selector = 0,
 341                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 342                 0, 0, /* No default value */
 343                 .name = "some3"
 344                 },
 345 };
 346 static const asn_TYPE_tag2member_t asn_MAP_Choice2_tag2el_1[] = {
 347     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* typeref */
 348     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* some3 */
 349 };
 350 asn_CHOICE_specifics_t asn_SPC_Choice2_specs_1 = {
 351         sizeof(struct Choice2),
 352         offsetof(struct Choice2, _asn_ctx),
 353         offsetof(struct Choice2, present),
 354         sizeof(((struct Choice2 *)0)->present),
 355         .tag2el = asn_MAP_Choice2_tag2el_1,
 356         .tag2el_count = 2,      /* Count of tags in the map */
 357         0, 0,
 358         .first_extension = 1    /* Extensions start */
 359 };
 360 asn_TYPE_descriptor_t asn_DEF_Choice2 = {
 361         "Choice2",
 362         "Choice2",
 363         &asn_OP_CHOICE,
 364         0,      /* No effective tags (pointer) */
 365         0,      /* No effective tags (count) */
 366         0,      /* No tags (pointer) */
 367         0,      /* No tags (count) */
 368         { 0, 0, CHOICE_constraint },
 369         asn_MBR_Choice2_1,
 370         2,      /* Elements count */
 371         &asn_SPC_Choice2_specs_1        /* Additional specs */
 372 };
 373
 374
 375 /*** <<< INCLUDES [Choice3] >>> ***/
 376
 377 #include <constr_SEQUENCE.h>
 378 #include <asn_SEQUENCE_OF.h>
 379 #include <constr_SEQUENCE_OF.h>
 380 #include <constr_CHOICE.h>
 381
 382 /*** <<< DEPS [Choice3] >>> ***/
 383
 384 typedef enum Choice3_PR {
 385         Choice3_PR_NOTHING,     /* No components present */
 386         Choice3_PR_a,
 387         Choice3_PR_b,
 388         Choice3_PR_c
 389 } Choice3_PR;
 390
 391 /*** <<< FWD-DECLS [Choice3] >>> ***/
 392
 393 struct Everything;
 394 struct Choice3;
 395
 396 /*** <<< TYPE-DECLS [Choice3] >>> ***/
 397
 398 typedef struct Choice3 {
 399         Choice3_PR present;
 400         union Choice3_u {
 401                 struct a {
 402                         struct Everything       *aa;
 403
 404                         /* Context for parsing across buffer boundaries */
 405                         asn_struct_ctx_t _asn_ctx;
 406                 } *a;
 407                 struct Everything       *b;
 408                 struct c {
 409                         A_SEQUENCE_OF(struct Choice3) list;
 410
 411                         /* Context for parsing across buffer boundaries */
 412                         asn_struct_ctx_t _asn_ctx;
 413                 } *c;
 414         } choice;
 415
 416         /* Context for parsing across buffer boundaries */
 417         asn_struct_ctx_t _asn_ctx;
 418 } Choice3_t;
 419
 420 /*** <<< FUNC-DECLS [Choice3] >>> ***/
 421
 422 extern asn_TYPE_descriptor_t asn_DEF_Choice3;
 423 extern asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1;
 424 extern asn_TYPE_member_t asn_MBR_Choice3_1[3];
 425
 426 /*** <<< POST-INCLUDE [Choice3] >>> ***/
 427
 428 #include "Everything.h"
 429 #include "Choice3.h"
 430
 431 /*** <<< STAT-DEFS [Choice3] >>> ***/
 432
 433 static asn_TYPE_member_t asn_MBR_a_2[] = {
 434         { ATF_POINTER, 0, offsetof(struct a, aa),
 435                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 436                 .tag_mode = -1, /* IMPLICIT tag at current level */
 437                 .type = &asn_DEF_Everything,
 438                 .type_selector = 0,
 439                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 440                 0, 0, /* No default value */
 441                 .name = "aa"
 442                 },
 443 };
 444 static const ber_tlv_tag_t asn_DEF_a_tags_2[] = {
 445         (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 446         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 447 };
 448 static const asn_TYPE_tag2member_t asn_MAP_a_tag2el_2[] = {
 449     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* aa */
 450 };
 451 static asn_SEQUENCE_specifics_t asn_SPC_a_specs_2 = {
 452         sizeof(struct a),
 453         offsetof(struct a, _asn_ctx),
 454         .tag2el = asn_MAP_a_tag2el_2,
 455         .tag2el_count = 1,      /* Count of tags in the map */
 456         0, 0, 0,        /* Optional elements (not needed) */
 457         -1,     /* First extension addition */
 458 };
 459 static /* Use -fall-defs-global to expose */
 460 asn_TYPE_descriptor_t asn_DEF_a_2 = {
 461         "a",
 462         "a",
 463         &asn_OP_SEQUENCE,
 464         asn_DEF_a_tags_2,
 465         sizeof(asn_DEF_a_tags_2)
 466                 /sizeof(asn_DEF_a_tags_2[0]) - 1, /* 1 */
 467         asn_DEF_a_tags_2,       /* Same as above */
 468         sizeof(asn_DEF_a_tags_2)
 469                 /sizeof(asn_DEF_a_tags_2[0]), /* 2 */
 470         { 0, 0, SEQUENCE_constraint },
 471         asn_MBR_a_2,
 472         1,      /* Elements count */
 473         &asn_SPC_a_specs_2      /* Additional specs */
 474 };
 475
 476 static asn_TYPE_member_t asn_MBR_c_5[] = {
 477         { ATF_POINTER, 0, 0,
 478                 .tag = -1 /* Ambiguous tag (CHOICE?) */,
 479                 .tag_mode = 0,
 480                 .type = &asn_DEF_Choice3,
 481                 .type_selector = 0,
 482                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 483                 0, 0, /* No default value */
 484                 .name = ""
 485                 },
 486 };
 487 static const ber_tlv_tag_t asn_DEF_c_tags_5[] = {
 488         (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 489         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 490 };
 491 static asn_SET_OF_specifics_t asn_SPC_c_specs_5 = {
 492         sizeof(struct c),
 493         offsetof(struct c, _asn_ctx),
 494         2,      /* XER encoding is XMLValueList */
 495 };
 496 static /* Use -fall-defs-global to expose */
 497 asn_TYPE_descriptor_t asn_DEF_c_5 = {
 498         "c",
 499         "c",
 500         &asn_OP_SEQUENCE_OF,
 501         asn_DEF_c_tags_5,
 502         sizeof(asn_DEF_c_tags_5)
 503                 /sizeof(asn_DEF_c_tags_5[0]) - 1, /* 1 */
 504         asn_DEF_c_tags_5,       /* Same as above */
 505         sizeof(asn_DEF_c_tags_5)
 506                 /sizeof(asn_DEF_c_tags_5[0]), /* 2 */
 507         { 0, 0, SEQUENCE_OF_constraint },
 508         asn_MBR_c_5,
 509         1,      /* Single element */
 510         &asn_SPC_c_specs_5      /* Additional specs */
 511 };
 512
 513 asn_TYPE_member_t asn_MBR_Choice3_1[] = {
 514         { ATF_POINTER, 0, offsetof(struct Choice3, choice.a),
 515                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 516                 .tag_mode = 0,
 517                 .type = &asn_DEF_a_2,
 518                 .type_selector = 0,
 519                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 520                 0, 0, /* No default value */
 521                 .name = "a"
 522                 },
 523         { ATF_POINTER, 0, offsetof(struct Choice3, choice.b),
 524                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 525                 .tag_mode = -1, /* IMPLICIT tag at current level */
 526                 .type = &asn_DEF_Everything,
 527                 .type_selector = 0,
 528                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 529                 0, 0, /* No default value */
 530                 .name = "b"
 531                 },
 532         { ATF_POINTER, 0, offsetof(struct Choice3, choice.c),
 533                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 534                 .tag_mode = 0,
 535                 .type = &asn_DEF_c_5,
 536                 .type_selector = 0,
 537                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 538                 0, 0, /* No default value */
 539                 .name = "c"
 540                 },
 541 };
 542 static const asn_TYPE_tag2member_t asn_MAP_Choice3_tag2el_1[] = {
 543     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a */
 544     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* b */
 545     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* c */
 546 };
 547 asn_CHOICE_specifics_t asn_SPC_Choice3_specs_1 = {
 548         sizeof(struct Choice3),
 549         offsetof(struct Choice3, _asn_ctx),
 550         offsetof(struct Choice3, present),
 551         sizeof(((struct Choice3 *)0)->present),
 552         .tag2el = asn_MAP_Choice3_tag2el_1,
 553         .tag2el_count = 3,      /* Count of tags in the map */
 554         0, 0,
 555         .first_extension = -1   /* Extensions start */
 556 };
 557 asn_TYPE_descriptor_t asn_DEF_Choice3 = {
 558         "Choice3",
 559         "Choice3",
 560         &asn_OP_CHOICE,
 561         0,      /* No effective tags (pointer) */
 562         0,      /* No effective tags (count) */
 563         0,      /* No tags (pointer) */
 564         0,      /* No tags (count) */
 565         { 0, 0, CHOICE_constraint },
 566         asn_MBR_Choice3_1,
 567         3,      /* Elements count */
 568         &asn_SPC_Choice3_specs_1        /* Additional specs */
 569 };
 570
 571
 572 /*** <<< INCLUDES [Set] >>> ***/
 573
 574 #include <asn_SET_OF.h>
 575 #include <NativeInteger.h>
 576 #include <constr_SEQUENCE.h>
 577 #include <constr_SET_OF.h>
 578
 579 /*** <<< FWD-DECLS [Set] >>> ***/
 580
 581 struct Set;
 582 struct Sequence;
 583
 584 /*** <<< FWD-DEFS [Set] >>> ***/
 585
 586 typedef struct Member {
 587         long     Int;
 588         struct Set      *set;
 589         struct Sequence *seq;
 590         struct Set      *set2;  /* OPTIONAL */
 591         /*
 592          * This type is extensible,
 593          * possible extensions are below.
 594          */
 595         struct Set      *set3;
 596
 597         /* Context for parsing across buffer boundaries */
 598         asn_struct_ctx_t _asn_ctx;
 599 } Member;
 600
 601 /*** <<< TYPE-DECLS [Set] >>> ***/
 602
 603 typedef struct Set {
 604         A_SET_OF(Member) list;
 605
 606         /* Context for parsing across buffer boundaries */
 607         asn_struct_ctx_t _asn_ctx;
 608 } Set_t;
 609
 610 /*** <<< FUNC-DECLS [Set] >>> ***/
 611
 612 extern asn_TYPE_descriptor_t asn_DEF_Set;
 613 extern asn_SET_OF_specifics_t asn_SPC_Set_specs_1;
 614 extern asn_TYPE_member_t asn_MBR_Set_1[1];
 615
 616 /*** <<< POST-INCLUDE [Set] >>> ***/
 617
 618 #include "Set.h"
 619 #include "Sequence.h"
 620
 621 /*** <<< STAT-DEFS [Set] >>> ***/
 622
 623 static asn_TYPE_member_t asn_MBR_Member_2[] = {
 624         { ATF_NOFLAGS, 0, offsetof(struct Member, Int),
 625                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 626                 .tag_mode = -1, /* IMPLICIT tag at current level */
 627                 .type = &asn_DEF_NativeInteger,
 628                 .type_selector = 0,
 629                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 630                 0, 0, /* No default value */
 631                 .name = "int"
 632                 },
 633         { ATF_POINTER, 0, offsetof(struct Member, set),
 634                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 635                 .tag_mode = -1, /* IMPLICIT tag at current level */
 636                 .type = &asn_DEF_Set,
 637                 .type_selector = 0,
 638                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 639                 0, 0, /* No default value */
 640                 .name = "set"
 641                 },
 642         { ATF_POINTER, 0, offsetof(struct Member, seq),
 643                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 644                 .tag_mode = -1, /* IMPLICIT tag at current level */
 645                 .type = &asn_DEF_Sequence,
 646                 .type_selector = 0,
 647                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 648                 0, 0, /* No default value */
 649                 .name = "seq"
 650                 },
 651         { ATF_POINTER, 2, offsetof(struct Member, set2),
 652                 .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 653                 .tag_mode = -1, /* IMPLICIT tag at current level */
 654                 .type = &asn_DEF_Set,
 655                 .type_selector = 0,
 656                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 657                 0, 0, /* No default value */
 658                 .name = "set2"
 659                 },
 660         { ATF_POINTER, 1, offsetof(struct Member, set3),
 661                 .tag = (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
 662                 .tag_mode = -1, /* IMPLICIT tag at current level */
 663                 .type = &asn_DEF_Set,
 664                 .type_selector = 0,
 665                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 666                 0, 0, /* No default value */
 667                 .name = "set3"
 668                 },
 669 };
 670 static const ber_tlv_tag_t asn_DEF_Member_tags_2[] = {
 671         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 672 };
 673 static const asn_TYPE_tag2member_t asn_MAP_Member_tag2el_2[] = {
 674     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* int */
 675     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* set */
 676     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* seq */
 677     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* set2 */
 678     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* set3 */
 679 };
 680 static asn_SEQUENCE_specifics_t asn_SPC_Member_specs_2 = {
 681         sizeof(struct Member),
 682         offsetof(struct Member, _asn_ctx),
 683         .tag2el = asn_MAP_Member_tag2el_2,
 684         .tag2el_count = 5,      /* Count of tags in the map */
 685         0, 0, 0,        /* Optional elements (not needed) */
 686         4,      /* First extension addition */
 687 };
 688 static /* Use -fall-defs-global to expose */
 689 asn_TYPE_descriptor_t asn_DEF_Member_2 = {
 690         "SEQUENCE",
 691         "SEQUENCE",
 692         &asn_OP_SEQUENCE,
 693         asn_DEF_Member_tags_2,
 694         sizeof(asn_DEF_Member_tags_2)
 695                 /sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
 696         asn_DEF_Member_tags_2,  /* Same as above */
 697         sizeof(asn_DEF_Member_tags_2)
 698                 /sizeof(asn_DEF_Member_tags_2[0]), /* 1 */
 699         { 0, 0, SEQUENCE_constraint },
 700         asn_MBR_Member_2,
 701         5,      /* Elements count */
 702         &asn_SPC_Member_specs_2 /* Additional specs */
 703 };
 704
 705 asn_TYPE_member_t asn_MBR_Set_1[] = {
 706         { ATF_POINTER, 0, 0,
 707                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 708                 .tag_mode = 0,
 709                 .type = &asn_DEF_Member_2,
 710                 .type_selector = 0,
 711                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 712                 0, 0, /* No default value */
 713                 .name = ""
 714                 },
 715 };
 716 static const ber_tlv_tag_t asn_DEF_Set_tags_1[] = {
 717         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 718 };
 719 asn_SET_OF_specifics_t asn_SPC_Set_specs_1 = {
 720         sizeof(struct Set),
 721         offsetof(struct Set, _asn_ctx),
 722         0,      /* XER encoding is XMLDelimitedItemList */
 723 };
 724 asn_TYPE_descriptor_t asn_DEF_Set = {
 725         "Set",
 726         "Set",
 727         &asn_OP_SET_OF,
 728         asn_DEF_Set_tags_1,
 729         sizeof(asn_DEF_Set_tags_1)
 730                 /sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
 731         asn_DEF_Set_tags_1,     /* Same as above */
 732         sizeof(asn_DEF_Set_tags_1)
 733                 /sizeof(asn_DEF_Set_tags_1[0]), /* 1 */
 734         { 0, 0, SET_OF_constraint },
 735         asn_MBR_Set_1,
 736         1,      /* Single element */
 737         &asn_SPC_Set_specs_1    /* Additional specs */
 738 };
 739
 740
 741 /*** <<< INCLUDES [Sequence] >>> ***/
 742
 743 #include <NativeInteger.h>
 744 #include <constr_SEQUENCE.h>
 745
 746 /*** <<< FWD-DECLS [Sequence] >>> ***/
 747
 748 struct Sequence;
 749 struct Set;
 750
 751 /*** <<< TYPE-DECLS [Sequence] >>> ***/
 752
 753 typedef struct Sequence {
 754         long     a;
 755         struct Sequence *seq;   /* OPTIONAL */
 756         /*
 757          * This type is extensible,
 758          * possible extensions are below.
 759          */
 760         long    *b;
 761         struct Set      *set;   /* OPTIONAL */
 762
 763         /* Context for parsing across buffer boundaries */
 764         asn_struct_ctx_t _asn_ctx;
 765 } Sequence_t;
 766
 767 /*** <<< FUNC-DECLS [Sequence] >>> ***/
 768
 769 extern asn_TYPE_descriptor_t asn_DEF_Sequence;
 770 extern asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1;
 771 extern asn_TYPE_member_t asn_MBR_Sequence_1[4];
 772
 773 /*** <<< POST-INCLUDE [Sequence] >>> ***/
 774
 775 #include "Sequence.h"
 776 #include "Set.h"
 777
 778 /*** <<< STAT-DEFS [Sequence] >>> ***/
 779
 780 asn_TYPE_member_t asn_MBR_Sequence_1[] = {
 781         { ATF_NOFLAGS, 0, offsetof(struct Sequence, a),
 782                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 783                 .tag_mode = -1, /* IMPLICIT tag at current level */
 784                 .type = &asn_DEF_NativeInteger,
 785                 .type_selector = 0,
 786                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 787                 0, 0, /* No default value */
 788                 .name = "a"
 789                 },
 790         { ATF_POINTER, 3, offsetof(struct Sequence, seq),
 791                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 792                 .tag_mode = -1, /* IMPLICIT tag at current level */
 793                 .type = &asn_DEF_Sequence,
 794                 .type_selector = 0,
 795                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 796                 0, 0, /* No default value */
 797                 .name = "seq"
 798                 },
 799         { ATF_POINTER, 2, offsetof(struct Sequence, b),
 800                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
 801                 .tag_mode = -1, /* IMPLICIT tag at current level */
 802                 .type = &asn_DEF_NativeInteger,
 803                 .type_selector = 0,
 804                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 805                 0, 0, /* No default value */
 806                 .name = "b"
 807                 },
 808         { ATF_POINTER, 1, offsetof(struct Sequence, set),
 809                 .tag = (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
 810                 .tag_mode = -1, /* IMPLICIT tag at current level */
 811                 .type = &asn_DEF_Set,
 812                 .type_selector = 0,
 813                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 814                 0, 0, /* No default value */
 815                 .name = "set"
 816                 },
 817 };
 818 static const ber_tlv_tag_t asn_DEF_Sequence_tags_1[] = {
 819         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 820 };
 821 static const asn_TYPE_tag2member_t asn_MAP_Sequence_tag2el_1[] = {
 822     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a */
 823     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* seq */
 824     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* b */
 825     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* set */
 826 };
 827 asn_SEQUENCE_specifics_t asn_SPC_Sequence_specs_1 = {
 828         sizeof(struct Sequence),
 829         offsetof(struct Sequence, _asn_ctx),
 830         .tag2el = asn_MAP_Sequence_tag2el_1,
 831         .tag2el_count = 4,      /* Count of tags in the map */
 832         0, 0, 0,        /* Optional elements (not needed) */
 833         2,      /* First extension addition */
 834 };
 835 asn_TYPE_descriptor_t asn_DEF_Sequence = {
 836         "Sequence",
 837         "Sequence",
 838         &asn_OP_SEQUENCE,
 839         asn_DEF_Sequence_tags_1,
 840         sizeof(asn_DEF_Sequence_tags_1)
 841                 /sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
 842         asn_DEF_Sequence_tags_1,        /* Same as above */
 843         sizeof(asn_DEF_Sequence_tags_1)
 844                 /sizeof(asn_DEF_Sequence_tags_1[0]), /* 1 */
 845         { 0, 0, SEQUENCE_constraint },
 846         asn_MBR_Sequence_1,
 847         4,      /* Elements count */
 848         &asn_SPC_Sequence_specs_1       /* Additional specs */
 849 };
 850
 851
 852 /*** <<< INCLUDES [TypeRef] >>> ***/
 853
 854 #include "Sequence.h"
 855
 856 /*** <<< TYPE-DECLS [TypeRef] >>> ***/
 857
 858 typedef Sequence_t       TypeRef_t;
 859
 860 /*** <<< FUNC-DECLS [TypeRef] >>> ***/
 861
 862 extern asn_TYPE_descriptor_t asn_DEF_TypeRef;
 863 asn_struct_free_f TypeRef_free;
 864 asn_struct_print_f TypeRef_print;
 865 asn_constr_check_f TypeRef_constraint;
 866 ber_type_decoder_f TypeRef_decode_ber;
 867 der_type_encoder_f TypeRef_encode_der;
 868 xer_type_decoder_f TypeRef_decode_xer;
 869 xer_type_encoder_f TypeRef_encode_xer;
 870
 871 /*** <<< CODE [TypeRef] >>> ***/
 872
 873 /*
 874  * This type is implemented using Sequence,
 875  * so here we adjust the DEF accordingly.
 876  */
 877
 878 /*** <<< STAT-DEFS [TypeRef] >>> ***/
 879
 880 static const ber_tlv_tag_t asn_DEF_TypeRef_tags_1[] = {
 881         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 882 };
 883 asn_TYPE_descriptor_t asn_DEF_TypeRef = {
 884         "TypeRef",
 885         "TypeRef",
 886         &asn_OP_SEQUENCE,
 887         asn_DEF_TypeRef_tags_1,
 888         sizeof(asn_DEF_TypeRef_tags_1)
 889                 /sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
 890         asn_DEF_TypeRef_tags_1, /* Same as above */
 891         sizeof(asn_DEF_TypeRef_tags_1)
 892                 /sizeof(asn_DEF_TypeRef_tags_1[0]), /* 1 */
 893         { 0, 0, SEQUENCE_constraint },
 894         asn_MBR_Sequence_1,
 895         4,      /* Elements count */
 896         &asn_SPC_Sequence_specs_1       /* Additional specs */
 897 };
 898
 899
 900 /*** <<< INCLUDES [Alpha] >>> ***/
 901
 902 #include <constr_SEQUENCE.h>
 903
 904 /*** <<< FWD-DECLS [Alpha] >>> ***/
 905
 906 struct Beta;
 907
 908 /*** <<< TYPE-DECLS [Alpha] >>> ***/
 909
 910 typedef struct Alpha {
 911         struct Beta     *a;
 912         struct b {
 913                 struct Beta     *b;     /* OPTIONAL */
 914
 915                 /* Context for parsing across buffer boundaries */
 916                 asn_struct_ctx_t _asn_ctx;
 917         } b;
 918
 919         /* Context for parsing across buffer boundaries */
 920         asn_struct_ctx_t _asn_ctx;
 921 } Alpha_t;
 922
 923 /*** <<< FUNC-DECLS [Alpha] >>> ***/
 924
 925 extern asn_TYPE_descriptor_t asn_DEF_Alpha;
 926 extern asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1;
 927 extern asn_TYPE_member_t asn_MBR_Alpha_1[2];
 928
 929 /*** <<< POST-INCLUDE [Alpha] >>> ***/
 930
 931 #include "Beta.h"
 932
 933 /*** <<< STAT-DEFS [Alpha] >>> ***/
 934
 935 static asn_TYPE_member_t asn_MBR_b_3[] = {
 936         { ATF_POINTER, 1, offsetof(struct b, b),
 937                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 938                 .tag_mode = -1, /* IMPLICIT tag at current level */
 939                 .type = &asn_DEF_Beta,
 940                 .type_selector = 0,
 941                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 942                 0, 0, /* No default value */
 943                 .name = "b"
 944                 },
 945 };
 946 static const ber_tlv_tag_t asn_DEF_b_tags_3[] = {
 947         (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 948         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 949 };
 950 static const asn_TYPE_tag2member_t asn_MAP_b_tag2el_3[] = {
 951     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* b */
 952 };
 953 static asn_SEQUENCE_specifics_t asn_SPC_b_specs_3 = {
 954         sizeof(struct b),
 955         offsetof(struct b, _asn_ctx),
 956         .tag2el = asn_MAP_b_tag2el_3,
 957         .tag2el_count = 1,      /* Count of tags in the map */
 958         0, 0, 0,        /* Optional elements (not needed) */
 959         -1,     /* First extension addition */
 960 };
 961 static /* Use -fall-defs-global to expose */
 962 asn_TYPE_descriptor_t asn_DEF_b_3 = {
 963         "b",
 964         "b",
 965         &asn_OP_SEQUENCE,
 966         asn_DEF_b_tags_3,
 967         sizeof(asn_DEF_b_tags_3)
 968                 /sizeof(asn_DEF_b_tags_3[0]) - 1, /* 1 */
 969         asn_DEF_b_tags_3,       /* Same as above */
 970         sizeof(asn_DEF_b_tags_3)
 971                 /sizeof(asn_DEF_b_tags_3[0]), /* 2 */
 972         { 0, 0, SEQUENCE_constraint },
 973         asn_MBR_b_3,
 974         1,      /* Elements count */
 975         &asn_SPC_b_specs_3      /* Additional specs */
 976 };
 977
 978 asn_TYPE_member_t asn_MBR_Alpha_1[] = {
 979         { ATF_POINTER, 0, offsetof(struct Alpha, a),
 980                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
 981                 .tag_mode = -1, /* IMPLICIT tag at current level */
 982                 .type = &asn_DEF_Beta,
 983                 .type_selector = 0,
 984                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 985                 0, 0, /* No default value */
 986                 .name = "a"
 987                 },
 988         { ATF_NOFLAGS, 0, offsetof(struct Alpha, b),
 989                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
 990                 .tag_mode = 0,
 991                 .type = &asn_DEF_b_3,
 992                 .type_selector = 0,
 993                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 994                 0, 0, /* No default value */
 995                 .name = "b"
 996                 },
 997 };
 998 static const ber_tlv_tag_t asn_DEF_Alpha_tags_1[] = {
 999         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1000 };
1001 static const asn_TYPE_tag2member_t asn_MAP_Alpha_tag2el_1[] = {
1002     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* a */
1003     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* b */
1004 };
1005 asn_SEQUENCE_specifics_t asn_SPC_Alpha_specs_1 = {
1006         sizeof(struct Alpha),
1007         offsetof(struct Alpha, _asn_ctx),
1008         .tag2el = asn_MAP_Alpha_tag2el_1,
1009         .tag2el_count = 2,      /* Count of tags in the map */
1010         0, 0, 0,        /* Optional elements (not needed) */
1011         -1,     /* First extension addition */
1012 };
1013 asn_TYPE_descriptor_t asn_DEF_Alpha = {
1014         "Alpha",
1015         "Alpha",
1016         &asn_OP_SEQUENCE,
1017         asn_DEF_Alpha_tags_1,
1018         sizeof(asn_DEF_Alpha_tags_1)
1019                 /sizeof(asn_DEF_Alpha_tags_1[0]), /* 1 */
1020         asn_DEF_Alpha_tags_1,   /* Same as above */
1021         sizeof(asn_DEF_Alpha_tags_1)
1022                 /sizeof(asn_DEF_Alpha_tags_1[0]), /* 1 */
1023         { 0, 0, SEQUENCE_constraint },
1024         asn_MBR_Alpha_1,
1025         2,      /* Elements count */
1026         &asn_SPC_Alpha_specs_1  /* Additional specs */
1027 };
1028
1029
1030 /*** <<< INCLUDES [Beta] >>> ***/
1031
1032 #include <constr_SEQUENCE.h>
1033
1034 /*** <<< FWD-DECLS [Beta] >>> ***/
1035
1036 struct Alpha;
1037 struct Gamma;
1038
1039 /*** <<< TYPE-DECLS [Beta] >>> ***/
1040
1041 typedef struct Beta {
1042         struct Alpha    *b;     /* OPTIONAL */
1043         struct Gamma    *g;     /* OPTIONAL */
1044
1045         /* Context for parsing across buffer boundaries */
1046         asn_struct_ctx_t _asn_ctx;
1047 } Beta_t;
1048
1049 /*** <<< FUNC-DECLS [Beta] >>> ***/
1050
1051 extern asn_TYPE_descriptor_t asn_DEF_Beta;
1052 extern asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1;
1053 extern asn_TYPE_member_t asn_MBR_Beta_1[2];
1054
1055 /*** <<< POST-INCLUDE [Beta] >>> ***/
1056
1057 #include "Alpha.h"
1058 #include "Gamma.h"
1059
1060 /*** <<< STAT-DEFS [Beta] >>> ***/
1061
1062 asn_TYPE_member_t asn_MBR_Beta_1[] = {
1063         { ATF_POINTER, 2, offsetof(struct Beta, b),
1064                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1065                 .tag_mode = -1, /* IMPLICIT tag at current level */
1066                 .type = &asn_DEF_Alpha,
1067                 .type_selector = 0,
1068                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1069                 0, 0, /* No default value */
1070                 .name = "b"
1071                 },
1072         { ATF_POINTER, 1, offsetof(struct Beta, g),
1073                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1074                 .tag_mode = -1, /* IMPLICIT tag at current level */
1075                 .type = &asn_DEF_Gamma,
1076                 .type_selector = 0,
1077                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1078                 0, 0, /* No default value */
1079                 .name = "g"
1080                 },
1081 };
1082 static const ber_tlv_tag_t asn_DEF_Beta_tags_1[] = {
1083         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1084 };
1085 static const asn_TYPE_tag2member_t asn_MAP_Beta_tag2el_1[] = {
1086     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* b */
1087     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g */
1088 };
1089 asn_SEQUENCE_specifics_t asn_SPC_Beta_specs_1 = {
1090         sizeof(struct Beta),
1091         offsetof(struct Beta, _asn_ctx),
1092         .tag2el = asn_MAP_Beta_tag2el_1,
1093         .tag2el_count = 2,      /* Count of tags in the map */
1094         0, 0, 0,        /* Optional elements (not needed) */
1095         -1,     /* First extension addition */
1096 };
1097 asn_TYPE_descriptor_t asn_DEF_Beta = {
1098         "Beta",
1099         "Beta",
1100         &asn_OP_SEQUENCE,
1101         asn_DEF_Beta_tags_1,
1102         sizeof(asn_DEF_Beta_tags_1)
1103                 /sizeof(asn_DEF_Beta_tags_1[0]), /* 1 */
1104         asn_DEF_Beta_tags_1,    /* Same as above */
1105         sizeof(asn_DEF_Beta_tags_1)
1106                 /sizeof(asn_DEF_Beta_tags_1[0]), /* 1 */
1107         { 0, 0, SEQUENCE_constraint },
1108         asn_MBR_Beta_1,
1109         2,      /* Elements count */
1110         &asn_SPC_Beta_specs_1   /* Additional specs */
1111 };
1112
1113
1114 /*** <<< INCLUDES [Gamma] >>> ***/
1115
1116 #include <constr_SEQUENCE.h>
1117
1118 /*** <<< FWD-DECLS [Gamma] >>> ***/
1119
1120 struct TwoThree;
1121 struct Alpha;
1122 struct Beta;
1123
1124 /*** <<< TYPE-DECLS [Gamma] >>> ***/
1125
1126 typedef struct Gamma {
1127         struct TwoThree *o;
1128         struct Alpha    *a;
1129         struct Beta     *b;
1130
1131         /* Context for parsing across buffer boundaries */
1132         asn_struct_ctx_t _asn_ctx;
1133 } Gamma_t;
1134
1135 /*** <<< FUNC-DECLS [Gamma] >>> ***/
1136
1137 extern asn_TYPE_descriptor_t asn_DEF_Gamma;
1138 extern asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1;
1139 extern asn_TYPE_member_t asn_MBR_Gamma_1[3];
1140
1141 /*** <<< POST-INCLUDE [Gamma] >>> ***/
1142
1143 #include "TwoThree.h"
1144 #include "Alpha.h"
1145 #include "Beta.h"
1146
1147 /*** <<< STAT-DEFS [Gamma] >>> ***/
1148
1149 asn_TYPE_member_t asn_MBR_Gamma_1[] = {
1150         { ATF_POINTER, 0, offsetof(struct Gamma, o),
1151                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1152                 .tag_mode = -1, /* IMPLICIT tag at current level */
1153                 .type = &asn_DEF_TwoThree,
1154                 .type_selector = 0,
1155                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1156                 0, 0, /* No default value */
1157                 .name = "o"
1158                 },
1159         { ATF_POINTER, 0, offsetof(struct Gamma, a),
1160                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1161                 .tag_mode = -1, /* IMPLICIT tag at current level */
1162                 .type = &asn_DEF_Alpha,
1163                 .type_selector = 0,
1164                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1165                 0, 0, /* No default value */
1166                 .name = "a"
1167                 },
1168         { ATF_POINTER, 0, offsetof(struct Gamma, b),
1169                 .tag = (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
1170                 .tag_mode = -1, /* IMPLICIT tag at current level */
1171                 .type = &asn_DEF_Beta,
1172                 .type_selector = 0,
1173                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1174                 0, 0, /* No default value */
1175                 .name = "b"
1176                 },
1177 };
1178 static const ber_tlv_tag_t asn_DEF_Gamma_tags_1[] = {
1179         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1180 };
1181 static const asn_TYPE_tag2member_t asn_MAP_Gamma_tag2el_1[] = {
1182     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* o */
1183     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* a */
1184     { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* b */
1185 };
1186 asn_SEQUENCE_specifics_t asn_SPC_Gamma_specs_1 = {
1187         sizeof(struct Gamma),
1188         offsetof(struct Gamma, _asn_ctx),
1189         .tag2el = asn_MAP_Gamma_tag2el_1,
1190         .tag2el_count = 3,      /* Count of tags in the map */
1191         0, 0, 0,        /* Optional elements (not needed) */
1192         -1,     /* First extension addition */
1193 };
1194 asn_TYPE_descriptor_t asn_DEF_Gamma = {
1195         "Gamma",
1196         "Gamma",
1197         &asn_OP_SEQUENCE,
1198         asn_DEF_Gamma_tags_1,
1199         sizeof(asn_DEF_Gamma_tags_1)
1200                 /sizeof(asn_DEF_Gamma_tags_1[0]), /* 1 */
1201         asn_DEF_Gamma_tags_1,   /* Same as above */
1202         sizeof(asn_DEF_Gamma_tags_1)
1203                 /sizeof(asn_DEF_Gamma_tags_1[0]), /* 1 */
1204         { 0, 0, SEQUENCE_constraint },
1205         asn_MBR_Gamma_1,
1206         3,      /* Elements count */
1207         &asn_SPC_Gamma_specs_1  /* Additional specs */
1208 };
1209
1210
1211 /*** <<< INCLUDES [OneTwo] >>> ***/
1212
1213 #include <constr_SET.h>
1214
1215 /*** <<< DEPS [OneTwo] >>> ***/
1216
1217
1218 /*
1219  * Method of determining the components presence
1220  */
1221 typedef enum OneTwo_PR {
1222         OneTwo_PR_m12,  /* Member m12 is present */
1223 } OneTwo_PR;
1224
1225 /*** <<< FWD-DECLS [OneTwo] >>> ***/
1226
1227 struct TwoThree;
1228
1229 /*** <<< TYPE-DECLS [OneTwo] >>> ***/
1230
1231 typedef struct OneTwo {
1232         struct TwoThree *m12;
1233
1234         /* Presence bitmask: ASN_SET_ISPRESENT(pOneTwo, OneTwo_PR_x) */
1235         unsigned int _presence_map
1236                 [((1+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))];
1237
1238         /* Context for parsing across buffer boundaries */
1239         asn_struct_ctx_t _asn_ctx;
1240 } OneTwo_t;
1241
1242 /*** <<< FUNC-DECLS [OneTwo] >>> ***/
1243
1244 extern asn_TYPE_descriptor_t asn_DEF_OneTwo;
1245 extern asn_SET_specifics_t asn_SPC_OneTwo_specs_1;
1246 extern asn_TYPE_member_t asn_MBR_OneTwo_1[1];
1247
1248 /*** <<< POST-INCLUDE [OneTwo] >>> ***/
1249
1250 #include "TwoThree.h"
1251
1252 /*** <<< STAT-DEFS [OneTwo] >>> ***/
1253
1254 asn_TYPE_member_t asn_MBR_OneTwo_1[] = {
1255         { ATF_POINTER, 0, offsetof(struct OneTwo, m12),
1256                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1257                 .tag_mode = -1, /* IMPLICIT tag at current level */
1258                 .type = &asn_DEF_TwoThree,
1259                 .type_selector = 0,
1260                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1261                 0, 0, /* No default value */
1262                 .name = "m12"
1263                 },
1264 };
1265 static const ber_tlv_tag_t asn_DEF_OneTwo_tags_1[] = {
1266         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1267 };
1268 static const asn_TYPE_tag2member_t asn_MAP_OneTwo_tag2el_1[] = {
1269     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* m12 */
1270 };
1271 static const uint8_t asn_MAP_OneTwo_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
1272         (1 << 7)
1273 };
1274 asn_SET_specifics_t asn_SPC_OneTwo_specs_1 = {
1275         sizeof(struct OneTwo),
1276         offsetof(struct OneTwo, _asn_ctx),
1277         offsetof(struct OneTwo, _presence_map),
1278         .tag2el = asn_MAP_OneTwo_tag2el_1,
1279         .tag2el_count = 1,      /* Count of tags in the map */
1280         asn_MAP_OneTwo_tag2el_1,        /* Same as above */
1281         1,      /* Count of tags in the CXER map */
1282         0,      /* Whether extensible */
1283         (const unsigned int *)asn_MAP_OneTwo_mmap_1     /* Mandatory elements map */
1284 };
1285 asn_TYPE_descriptor_t asn_DEF_OneTwo = {
1286         "OneTwo",
1287         "OneTwo",
1288         &asn_OP_SET,
1289         asn_DEF_OneTwo_tags_1,
1290         sizeof(asn_DEF_OneTwo_tags_1)
1291                 /sizeof(asn_DEF_OneTwo_tags_1[0]), /* 1 */
1292         asn_DEF_OneTwo_tags_1,  /* Same as above */
1293         sizeof(asn_DEF_OneTwo_tags_1)
1294                 /sizeof(asn_DEF_OneTwo_tags_1[0]), /* 1 */
1295         { 0, 0, SET_constraint },
1296         asn_MBR_OneTwo_1,
1297         1,      /* Elements count */
1298         &asn_SPC_OneTwo_specs_1 /* Additional specs */
1299 };
1300
1301
1302 /*** <<< INCLUDES [TwoThree] >>> ***/
1303
1304 #include <constr_SET.h>
1305
1306 /*** <<< DEPS [TwoThree] >>> ***/
1307
1308
1309 /*
1310  * Method of determining the components presence
1311  */
1312 typedef enum TwoThree_PR {
1313         TwoThree_PR_m23,        /* Member m23 is present */
1314 } TwoThree_PR;
1315
1316 /*** <<< FWD-DECLS [TwoThree] >>> ***/
1317
1318 struct ThreeOne;
1319
1320 /*** <<< TYPE-DECLS [TwoThree] >>> ***/
1321
1322 typedef struct TwoThree {
1323         struct ThreeOne *m23;
1324
1325         /* Presence bitmask: ASN_SET_ISPRESENT(pTwoThree, TwoThree_PR_x) */
1326         unsigned int _presence_map
1327                 [((1+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))];
1328
1329         /* Context for parsing across buffer boundaries */
1330         asn_struct_ctx_t _asn_ctx;
1331 } TwoThree_t;
1332
1333 /*** <<< FUNC-DECLS [TwoThree] >>> ***/
1334
1335 extern asn_TYPE_descriptor_t asn_DEF_TwoThree;
1336 extern asn_SET_specifics_t asn_SPC_TwoThree_specs_1;
1337 extern asn_TYPE_member_t asn_MBR_TwoThree_1[1];
1338
1339 /*** <<< POST-INCLUDE [TwoThree] >>> ***/
1340
1341 #include "ThreeOne.h"
1342
1343 /*** <<< STAT-DEFS [TwoThree] >>> ***/
1344
1345 asn_TYPE_member_t asn_MBR_TwoThree_1[] = {
1346         { ATF_POINTER, 0, offsetof(struct TwoThree, m23),
1347                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1348                 .tag_mode = -1, /* IMPLICIT tag at current level */
1349                 .type = &asn_DEF_ThreeOne,
1350                 .type_selector = 0,
1351                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1352                 0, 0, /* No default value */
1353                 .name = "m23"
1354                 },
1355 };
1356 static const ber_tlv_tag_t asn_DEF_TwoThree_tags_1[] = {
1357         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1358 };
1359 static const asn_TYPE_tag2member_t asn_MAP_TwoThree_tag2el_1[] = {
1360     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* m23 */
1361 };
1362 static const uint8_t asn_MAP_TwoThree_mmap_1[(1 + (8 * sizeof(unsigned int)) - 1) / 8] = {
1363         (1 << 7)
1364 };
1365 asn_SET_specifics_t asn_SPC_TwoThree_specs_1 = {
1366         sizeof(struct TwoThree),
1367         offsetof(struct TwoThree, _asn_ctx),
1368         offsetof(struct TwoThree, _presence_map),
1369         .tag2el = asn_MAP_TwoThree_tag2el_1,
1370         .tag2el_count = 1,      /* Count of tags in the map */
1371         asn_MAP_TwoThree_tag2el_1,      /* Same as above */
1372         1,      /* Count of tags in the CXER map */
1373         0,      /* Whether extensible */
1374         (const unsigned int *)asn_MAP_TwoThree_mmap_1   /* Mandatory elements map */
1375 };
1376 asn_TYPE_descriptor_t asn_DEF_TwoThree = {
1377         "TwoThree",
1378         "TwoThree",
1379         &asn_OP_SET,
1380         asn_DEF_TwoThree_tags_1,
1381         sizeof(asn_DEF_TwoThree_tags_1)
1382                 /sizeof(asn_DEF_TwoThree_tags_1[0]), /* 1 */
1383         asn_DEF_TwoThree_tags_1,        /* Same as above */
1384         sizeof(asn_DEF_TwoThree_tags_1)
1385                 /sizeof(asn_DEF_TwoThree_tags_1[0]), /* 1 */
1386         { 0, 0, SET_constraint },
1387         asn_MBR_TwoThree_1,
1388         1,      /* Elements count */
1389         &asn_SPC_TwoThree_specs_1       /* Additional specs */
1390 };
1391
1392
1393 /*** <<< INCLUDES [ThreeOne] >>> ***/
1394
1395 #include <constr_SET.h>
1396
1397 /*** <<< DEPS [ThreeOne] >>> ***/
1398
1399
1400 /*
1401  * Method of determining the components presence
1402  */
1403 typedef enum ThreeOne_PR {
1404         ThreeOne_PR_m31,        /* Member m31 is present */
1405         ThreeOne_PR_g,  /* Member g is present */
1406 } ThreeOne_PR;
1407
1408 /*** <<< FWD-DECLS [ThreeOne] >>> ***/
1409
1410 struct OneTwo;
1411 struct Gamma;
1412
1413 /*** <<< TYPE-DECLS [ThreeOne] >>> ***/
1414
1415 typedef struct ThreeOne {
1416         struct OneTwo   *m31;
1417         struct Gamma    *g;
1418
1419         /* Presence bitmask: ASN_SET_ISPRESENT(pThreeOne, ThreeOne_PR_x) */
1420         unsigned int _presence_map
1421                 [((2+(8*sizeof(unsigned int))-1)/(8*sizeof(unsigned int)))];
1422
1423         /* Context for parsing across buffer boundaries */
1424         asn_struct_ctx_t _asn_ctx;
1425 } ThreeOne_t;
1426
1427 /*** <<< FUNC-DECLS [ThreeOne] >>> ***/
1428
1429 extern asn_TYPE_descriptor_t asn_DEF_ThreeOne;
1430 extern asn_SET_specifics_t asn_SPC_ThreeOne_specs_1;
1431 extern asn_TYPE_member_t asn_MBR_ThreeOne_1[2];
1432
1433 /*** <<< POST-INCLUDE [ThreeOne] >>> ***/
1434
1435 #include "OneTwo.h"
1436 #include "Gamma.h"
1437
1438 /*** <<< STAT-DEFS [ThreeOne] >>> ***/
1439
1440 asn_TYPE_member_t asn_MBR_ThreeOne_1[] = {
1441         { ATF_POINTER, 0, offsetof(struct ThreeOne, m31),
1442                 .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
1443                 .tag_mode = -1, /* IMPLICIT tag at current level */
1444                 .type = &asn_DEF_OneTwo,
1445                 .type_selector = 0,
1446                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1447                 0, 0, /* No default value */
1448                 .name = "m31"
1449                 },
1450         { ATF_POINTER, 0, offsetof(struct ThreeOne, g),
1451                 .tag = (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
1452                 .tag_mode = -1, /* IMPLICIT tag at current level */
1453                 .type = &asn_DEF_Gamma,
1454                 .type_selector = 0,
1455                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1456                 0, 0, /* No default value */
1457                 .name = "g"
1458                 },
1459 };
1460 static const ber_tlv_tag_t asn_DEF_ThreeOne_tags_1[] = {
1461         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
1462 };
1463 static const asn_TYPE_tag2member_t asn_MAP_ThreeOne_tag2el_1[] = {
1464     { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* m31 */
1465     { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* g */
1466 };
1467 static const uint8_t asn_MAP_ThreeOne_mmap_1[(2 + (8 * sizeof(unsigned int)) - 1) / 8] = {
1468         (1 << 7) | (1 << 6)
1469 };
1470 asn_SET_specifics_t asn_SPC_ThreeOne_specs_1 = {
1471         sizeof(struct ThreeOne),
1472         offsetof(struct ThreeOne, _asn_ctx),
1473         offsetof(struct ThreeOne, _presence_map),
1474         .tag2el = asn_MAP_ThreeOne_tag2el_1,
1475         .tag2el_count = 2,      /* Count of tags in the map */
1476         asn_MAP_ThreeOne_tag2el_1,      /* Same as above */
1477         2,      /* Count of tags in the CXER map */
1478         0,      /* Whether extensible */
1479         (const unsigned int *)asn_MAP_ThreeOne_mmap_1   /* Mandatory elements map */
1480 };
1481 asn_TYPE_descriptor_t asn_DEF_ThreeOne = {
1482         "ThreeOne",
1483         "ThreeOne",
1484         &asn_OP_SET,
1485         asn_DEF_ThreeOne_tags_1,
1486         sizeof(asn_DEF_ThreeOne_tags_1)
1487                 /sizeof(asn_DEF_ThreeOne_tags_1[0]), /* 1 */
1488         asn_DEF_ThreeOne_tags_1,        /* Same as above */
1489         sizeof(asn_DEF_ThreeOne_tags_1)
1490                 /sizeof(asn_DEF_ThreeOne_tags_1[0]), /* 1 */
1491         { 0, 0, SET_constraint },
1492         asn_MBR_ThreeOne_1,
1493         2,      /* Elements count */
1494         &asn_SPC_ThreeOne_specs_1       /* Additional specs */
1495 };
1496