tests/tests-asn1c-compiler/92-circular-loops-OK.asn1.-Pfwide-types

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