tests/tests-asn1c-compiler/42-real-life-OK.asn1.-PR

   1
   2 /*** <<< INCLUDES [LogLine] >>> ***/
   3
   4 #include <IA5String.h>
   5 #include <asn_SEQUENCE_OF.h>
   6 #include <constr_SEQUENCE_OF.h>
   7 #include <constr_SEQUENCE.h>
   8
   9 /*** <<< FWD-DECLS [LogLine] >>> ***/
  10
  11 struct VariablePartSet;
  12
  13 /*** <<< TYPE-DECLS [LogLine] >>> ***/
  14
  15 typedef struct LogLine {
  16         IA5String_t      line_digest;
  17         struct varsets {
  18                 A_SEQUENCE_OF(struct VariablePartSet) list;
  19
  20                 /* Context for parsing across buffer boundaries */
  21                 asn_struct_ctx_t _asn_ctx;
  22         } varsets;
  23         /*
  24          * This type is extensible,
  25          * possible extensions are below.
  26          */
  27
  28         /* Context for parsing across buffer boundaries */
  29         asn_struct_ctx_t _asn_ctx;
  30 } LogLine_t;
  31
  32 /*** <<< FUNC-DECLS [LogLine] >>> ***/
  33
  34 extern asn_TYPE_descriptor_t asn_DEF_LogLine;
  35
  36 /*** <<< POST-INCLUDE [LogLine] >>> ***/
  37
  38 #include "VariablePartSet.h"
  39
  40 /*** <<< CODE [LogLine] >>> ***/
  41
  42 static int
  43 memb_varsets_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
  44                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  45         size_t size;
  46
  47         if(!sptr) {
  48                 ASN__CTFAIL(app_key, td, sptr,
  49                         "%s: value not given (%s:%d)",
  50                         td->name, __FILE__, __LINE__);
  51                 return -1;
  52         }
  53
  54         /* Determine the number of elements */
  55         size = _A_CSEQUENCE_FROM_VOID(sptr)->count;
  56
  57         if((size >= 1)) {
  58                 /* Perform validation of the inner elements */
  59                 return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
  60         } else {
  61                 ASN__CTFAIL(app_key, td, sptr,
  62                         "%s: constraint failed (%s:%d)",
  63                         td->name, __FILE__, __LINE__);
  64                 return -1;
  65         }
  66 }
  67
  68
  69 /*** <<< STAT-DEFS [LogLine] >>> ***/
  70
  71 static asn_TYPE_member_t asn_MBR_varsets_3[] = {
  72         { ATF_POINTER, 0, 0,
  73                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
  74                 .tag_mode = 0,
  75                 .type = &asn_DEF_VariablePartSet,
  76                 .type_selector = 0,
  77                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
  78                 0, 0, /* No default value */
  79                 .name = ""
  80                 },
  81 };
  82 static const ber_tlv_tag_t asn_DEF_varsets_tags_3[] = {
  83         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
  84 };
  85 static asn_SET_OF_specifics_t asn_SPC_varsets_specs_3 = {
  86         sizeof(struct varsets),
  87         offsetof(struct varsets, _asn_ctx),
  88         0,      /* XER encoding is XMLDelimitedItemList */
  89 };
  90 static /* Use -fall-defs-global to expose */
  91 asn_TYPE_descriptor_t asn_DEF_varsets_3 = {
  92         "varsets",
  93         "varsets",
  94         &asn_OP_SEQUENCE_OF,
  95         asn_DEF_varsets_tags_3,
  96         sizeof(asn_DEF_varsets_tags_3)
  97                 /sizeof(asn_DEF_varsets_tags_3[0]), /* 1 */
  98         asn_DEF_varsets_tags_3, /* Same as above */
  99         sizeof(asn_DEF_varsets_tags_3)
 100                 /sizeof(asn_DEF_varsets_tags_3[0]), /* 1 */
 101         { 0, 0, SEQUENCE_OF_constraint },
 102         asn_MBR_varsets_3,
 103         1,      /* Single element */
 104         &asn_SPC_varsets_specs_3        /* Additional specs */
 105 };
 106
 107 static asn_TYPE_member_t asn_MBR_LogLine_1[] = {
 108         { ATF_NOFLAGS, 0, offsetof(struct LogLine, line_digest),
 109                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)),
 110                 .tag_mode = 0,
 111                 .type = &asn_DEF_IA5String,
 112                 .type_selector = 0,
 113                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 114                 0, 0, /* No default value */
 115                 .name = "line-digest"
 116                 },
 117         { ATF_NOFLAGS, 0, offsetof(struct LogLine, varsets),
 118                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 119                 .tag_mode = 0,
 120                 .type = &asn_DEF_varsets_3,
 121                 .type_selector = 0,
 122                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints =  memb_varsets_constraint_1 },
 123                 0, 0, /* No default value */
 124                 .name = "varsets"
 125                 },
 126 };
 127 static const ber_tlv_tag_t asn_DEF_LogLine_tags_1[] = {
 128         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 129 };
 130 static const asn_TYPE_tag2member_t asn_MAP_LogLine_tag2el_1[] = {
 131     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* varsets */
 132     { (ASN_TAG_CLASS_UNIVERSAL | (22 << 2)), 0, 0, 0 } /* line-digest */
 133 };
 134 static asn_SEQUENCE_specifics_t asn_SPC_LogLine_specs_1 = {
 135         sizeof(struct LogLine),
 136         offsetof(struct LogLine, _asn_ctx),
 137         .tag2el = asn_MAP_LogLine_tag2el_1,
 138         .tag2el_count = 2,      /* Count of tags in the map */
 139         0, 0, 0,        /* Optional elements (not needed) */
 140         2,      /* First extension addition */
 141 };
 142 asn_TYPE_descriptor_t asn_DEF_LogLine = {
 143         "LogLine",
 144         "LogLine",
 145         &asn_OP_SEQUENCE,
 146         asn_DEF_LogLine_tags_1,
 147         sizeof(asn_DEF_LogLine_tags_1)
 148                 /sizeof(asn_DEF_LogLine_tags_1[0]), /* 1 */
 149         asn_DEF_LogLine_tags_1, /* Same as above */
 150         sizeof(asn_DEF_LogLine_tags_1)
 151                 /sizeof(asn_DEF_LogLine_tags_1[0]), /* 1 */
 152         { 0, 0, SEQUENCE_constraint },
 153         asn_MBR_LogLine_1,
 154         2,      /* Elements count */
 155         &asn_SPC_LogLine_specs_1        /* Additional specs */
 156 };
 157
 158
 159 /*** <<< INCLUDES [VariablePartSet] >>> ***/
 160
 161 #include "ActionItem.h"
 162 #include <asn_SEQUENCE_OF.h>
 163 #include <constr_SEQUENCE_OF.h>
 164 #include <constr_SEQUENCE.h>
 165
 166 /*** <<< FWD-DECLS [VariablePartSet] >>> ***/
 167
 168 struct VariablePart;
 169
 170 /*** <<< TYPE-DECLS [VariablePartSet] >>> ***/
 171
 172 typedef struct VariablePartSet {
 173         struct vparts {
 174                 A_SEQUENCE_OF(struct VariablePart) list;
 175
 176                 /* Context for parsing across buffer boundaries */
 177                 asn_struct_ctx_t _asn_ctx;
 178         } vparts;
 179         ActionItem_t     resolution;
 180         /*
 181          * This type is extensible,
 182          * possible extensions are below.
 183          */
 184
 185         /* Context for parsing across buffer boundaries */
 186         asn_struct_ctx_t _asn_ctx;
 187 } VariablePartSet_t;
 188
 189 /*** <<< FUNC-DECLS [VariablePartSet] >>> ***/
 190
 191 extern asn_TYPE_descriptor_t asn_DEF_VariablePartSet;
 192 extern asn_SEQUENCE_specifics_t asn_SPC_VariablePartSet_specs_1;
 193 extern asn_TYPE_member_t asn_MBR_VariablePartSet_1[2];
 194
 195 /*** <<< POST-INCLUDE [VariablePartSet] >>> ***/
 196
 197 #include "VariablePart.h"
 198
 199 /*** <<< CODE [VariablePartSet] >>> ***/
 200
 201 static int
 202 memb_vparts_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 203                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 204
 205         if(!sptr) {
 206                 ASN__CTFAIL(app_key, td, sptr,
 207                         "%s: value not given (%s:%d)",
 208                         td->name, __FILE__, __LINE__);
 209                 return -1;
 210         }
 211
 212
 213         if(1 /* No applicable constraints whatsoever */) {
 214                 /* Nothing is here. See below */
 215         }
 216
 217         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 218 }
 219
 220
 221 /*** <<< STAT-DEFS [VariablePartSet] >>> ***/
 222
 223 static asn_TYPE_member_t asn_MBR_vparts_2[] = {
 224         { ATF_POINTER, 0, 0,
 225                 .tag = -1 /* Ambiguous tag (CHOICE?) */,
 226                 .tag_mode = 0,
 227                 .type = &asn_DEF_VariablePart,
 228                 .type_selector = 0,
 229                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 230                 0, 0, /* No default value */
 231                 .name = ""
 232                 },
 233 };
 234 static const ber_tlv_tag_t asn_DEF_vparts_tags_2[] = {
 235         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 236 };
 237 static asn_SET_OF_specifics_t asn_SPC_vparts_specs_2 = {
 238         sizeof(struct vparts),
 239         offsetof(struct vparts, _asn_ctx),
 240         2,      /* XER encoding is XMLValueList */
 241 };
 242 static /* Use -fall-defs-global to expose */
 243 asn_TYPE_descriptor_t asn_DEF_vparts_2 = {
 244         "vparts",
 245         "vparts",
 246         &asn_OP_SEQUENCE_OF,
 247         asn_DEF_vparts_tags_2,
 248         sizeof(asn_DEF_vparts_tags_2)
 249                 /sizeof(asn_DEF_vparts_tags_2[0]), /* 1 */
 250         asn_DEF_vparts_tags_2,  /* Same as above */
 251         sizeof(asn_DEF_vparts_tags_2)
 252                 /sizeof(asn_DEF_vparts_tags_2[0]), /* 1 */
 253         { 0, 0, SEQUENCE_OF_constraint },
 254         asn_MBR_vparts_2,
 255         1,      /* Single element */
 256         &asn_SPC_vparts_specs_2 /* Additional specs */
 257 };
 258
 259 asn_TYPE_member_t asn_MBR_VariablePartSet_1[] = {
 260         { ATF_NOFLAGS, 0, offsetof(struct VariablePartSet, vparts),
 261                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 262                 .tag_mode = 0,
 263                 .type = &asn_DEF_vparts_2,
 264                 .type_selector = 0,
 265                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints =  memb_vparts_constraint_1 },
 266                 0, 0, /* No default value */
 267                 .name = "vparts"
 268                 },
 269         { ATF_NOFLAGS, 0, offsetof(struct VariablePartSet, resolution),
 270                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 271                 .tag_mode = 0,
 272                 .type = &asn_DEF_ActionItem,
 273                 .type_selector = 0,
 274                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 275                 0, 0, /* No default value */
 276                 .name = "resolution"
 277                 },
 278 };
 279 static const ber_tlv_tag_t asn_DEF_VariablePartSet_tags_1[] = {
 280         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 281 };
 282 static const asn_TYPE_tag2member_t asn_MAP_VariablePartSet_tag2el_1[] = {
 283     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* vparts */
 284     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, -1, 0 } /* resolution */
 285 };
 286 asn_SEQUENCE_specifics_t asn_SPC_VariablePartSet_specs_1 = {
 287         sizeof(struct VariablePartSet),
 288         offsetof(struct VariablePartSet, _asn_ctx),
 289         .tag2el = asn_MAP_VariablePartSet_tag2el_1,
 290         .tag2el_count = 2,      /* Count of tags in the map */
 291         0, 0, 0,        /* Optional elements (not needed) */
 292         2,      /* First extension addition */
 293 };
 294 asn_TYPE_descriptor_t asn_DEF_VariablePartSet = {
 295         "VariablePartSet",
 296         "VariablePartSet",
 297         &asn_OP_SEQUENCE,
 298         asn_DEF_VariablePartSet_tags_1,
 299         sizeof(asn_DEF_VariablePartSet_tags_1)
 300                 /sizeof(asn_DEF_VariablePartSet_tags_1[0]), /* 1 */
 301         asn_DEF_VariablePartSet_tags_1, /* Same as above */
 302         sizeof(asn_DEF_VariablePartSet_tags_1)
 303                 /sizeof(asn_DEF_VariablePartSet_tags_1[0]), /* 1 */
 304         { 0, 0, SEQUENCE_constraint },
 305         asn_MBR_VariablePartSet_1,
 306         2,      /* Elements count */
 307         &asn_SPC_VariablePartSet_specs_1        /* Additional specs */
 308 };
 309
 310
 311 /*** <<< INCLUDES [VariablePart] >>> ***/
 312
 313 #include <VisibleString.h>
 314 #include <asn_SET_OF.h>
 315 #include <constr_SET_OF.h>
 316 #include <constr_SEQUENCE.h>
 317 #include <constr_CHOICE.h>
 318
 319 /*** <<< DEPS [VariablePart] >>> ***/
 320
 321 typedef enum VariablePart_PR {
 322         VariablePart_PR_NOTHING,        /* No components present */
 323         VariablePart_PR_vset,
 324         VariablePart_PR_vrange
 325         /* Extensions may appear below */
 326
 327 } VariablePart_PR;
 328
 329 /*** <<< TYPE-DECLS [VariablePart] >>> ***/
 330
 331 typedef struct VariablePart {
 332         VariablePart_PR present;
 333         union VariablePart_u {
 334                 struct vset {
 335                         A_SET_OF(VisibleString_t) list;
 336
 337                         /* Context for parsing across buffer boundaries */
 338                         asn_struct_ctx_t _asn_ctx;
 339                 } vset;
 340                 struct vrange {
 341                         VisibleString_t  from;
 342                         VisibleString_t  to;
 343                         /*
 344                          * This type is extensible,
 345                          * possible extensions are below.
 346                          */
 347
 348                         /* Context for parsing across buffer boundaries */
 349                         asn_struct_ctx_t _asn_ctx;
 350                 } vrange;
 351                 /*
 352                  * This type is extensible,
 353                  * possible extensions are below.
 354                  */
 355         } choice;
 356
 357         /* Context for parsing across buffer boundaries */
 358         asn_struct_ctx_t _asn_ctx;
 359 } VariablePart_t;
 360
 361 /*** <<< FUNC-DECLS [VariablePart] >>> ***/
 362
 363 extern asn_TYPE_descriptor_t asn_DEF_VariablePart;
 364 extern asn_CHOICE_specifics_t asn_SPC_VariablePart_specs_1;
 365 extern asn_TYPE_member_t asn_MBR_VariablePart_1[2];
 366
 367 /*** <<< CODE [VariablePart] >>> ***/
 368
 369 static int
 370 memb_vset_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
 371                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 372         size_t size;
 373
 374         if(!sptr) {
 375                 ASN__CTFAIL(app_key, td, sptr,
 376                         "%s: value not given (%s:%d)",
 377                         td->name, __FILE__, __LINE__);
 378                 return -1;
 379         }
 380
 381         /* Determine the number of elements */
 382         size = _A_CSET_FROM_VOID(sptr)->count;
 383
 384         if((size >= 1)) {
 385                 /* Perform validation of the inner elements */
 386                 return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 387         } else {
 388                 ASN__CTFAIL(app_key, td, sptr,
 389                         "%s: constraint failed (%s:%d)",
 390                         td->name, __FILE__, __LINE__);
 391                 return -1;
 392         }
 393 }
 394
 395
 396 /*** <<< STAT-DEFS [VariablePart] >>> ***/
 397
 398 static asn_TYPE_member_t asn_MBR_vset_2[] = {
 399         { ATF_POINTER, 0, 0,
 400                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)),
 401                 .tag_mode = 0,
 402                 .type = &asn_DEF_VisibleString,
 403                 .type_selector = 0,
 404                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 405                 0, 0, /* No default value */
 406                 .name = ""
 407                 },
 408 };
 409 static const ber_tlv_tag_t asn_DEF_vset_tags_2[] = {
 410         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 411 };
 412 static asn_SET_OF_specifics_t asn_SPC_vset_specs_2 = {
 413         sizeof(struct vset),
 414         offsetof(struct vset, _asn_ctx),
 415         0,      /* XER encoding is XMLDelimitedItemList */
 416 };
 417 static /* Use -fall-defs-global to expose */
 418 asn_TYPE_descriptor_t asn_DEF_vset_2 = {
 419         "vset",
 420         "vset",
 421         &asn_OP_SET_OF,
 422         asn_DEF_vset_tags_2,
 423         sizeof(asn_DEF_vset_tags_2)
 424                 /sizeof(asn_DEF_vset_tags_2[0]), /* 1 */
 425         asn_DEF_vset_tags_2,    /* Same as above */
 426         sizeof(asn_DEF_vset_tags_2)
 427                 /sizeof(asn_DEF_vset_tags_2[0]), /* 1 */
 428         { 0, 0, SET_OF_constraint },
 429         asn_MBR_vset_2,
 430         1,      /* Single element */
 431         &asn_SPC_vset_specs_2   /* Additional specs */
 432 };
 433
 434 static asn_TYPE_member_t asn_MBR_vrange_4[] = {
 435         { ATF_NOFLAGS, 0, offsetof(struct vrange, from),
 436                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)),
 437                 .tag_mode = 0,
 438                 .type = &asn_DEF_VisibleString,
 439                 .type_selector = 0,
 440                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 441                 0, 0, /* No default value */
 442                 .name = "from"
 443                 },
 444         { ATF_NOFLAGS, 0, offsetof(struct vrange, to),
 445                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)),
 446                 .tag_mode = 0,
 447                 .type = &asn_DEF_VisibleString,
 448                 .type_selector = 0,
 449                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 450                 0, 0, /* No default value */
 451                 .name = "to"
 452                 },
 453 };
 454 static const ber_tlv_tag_t asn_DEF_vrange_tags_4[] = {
 455         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 456 };
 457 static const asn_TYPE_tag2member_t asn_MAP_vrange_tag2el_4[] = {
 458     { (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)), 0, 0, 1 }, /* from */
 459     { (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)), 1, -1, 0 } /* to */
 460 };
 461 static asn_SEQUENCE_specifics_t asn_SPC_vrange_specs_4 = {
 462         sizeof(struct vrange),
 463         offsetof(struct vrange, _asn_ctx),
 464         .tag2el = asn_MAP_vrange_tag2el_4,
 465         .tag2el_count = 2,      /* Count of tags in the map */
 466         0, 0, 0,        /* Optional elements (not needed) */
 467         2,      /* First extension addition */
 468 };
 469 static /* Use -fall-defs-global to expose */
 470 asn_TYPE_descriptor_t asn_DEF_vrange_4 = {
 471         "vrange",
 472         "vrange",
 473         &asn_OP_SEQUENCE,
 474         asn_DEF_vrange_tags_4,
 475         sizeof(asn_DEF_vrange_tags_4)
 476                 /sizeof(asn_DEF_vrange_tags_4[0]), /* 1 */
 477         asn_DEF_vrange_tags_4,  /* Same as above */
 478         sizeof(asn_DEF_vrange_tags_4)
 479                 /sizeof(asn_DEF_vrange_tags_4[0]), /* 1 */
 480         { 0, 0, SEQUENCE_constraint },
 481         asn_MBR_vrange_4,
 482         2,      /* Elements count */
 483         &asn_SPC_vrange_specs_4 /* Additional specs */
 484 };
 485
 486 asn_TYPE_member_t asn_MBR_VariablePart_1[] = {
 487         { ATF_NOFLAGS, 0, offsetof(struct VariablePart, choice.vset),
 488                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 489                 .tag_mode = 0,
 490                 .type = &asn_DEF_vset_2,
 491                 .type_selector = 0,
 492                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints =  memb_vset_constraint_1 },
 493                 0, 0, /* No default value */
 494                 .name = "vset"
 495                 },
 496         { ATF_NOFLAGS, 0, offsetof(struct VariablePart, choice.vrange),
 497                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 498                 .tag_mode = 0,
 499                 .type = &asn_DEF_vrange_4,
 500                 .type_selector = 0,
 501                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 502                 0, 0, /* No default value */
 503                 .name = "vrange"
 504                 },
 505 };
 506 static const asn_TYPE_tag2member_t asn_MAP_VariablePart_tag2el_1[] = {
 507     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 }, /* vrange */
 508     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 0, 0, 0 } /* vset */
 509 };
 510 asn_CHOICE_specifics_t asn_SPC_VariablePart_specs_1 = {
 511         sizeof(struct VariablePart),
 512         offsetof(struct VariablePart, _asn_ctx),
 513         offsetof(struct VariablePart, present),
 514         sizeof(((struct VariablePart *)0)->present),
 515         .tag2el = asn_MAP_VariablePart_tag2el_1,
 516         .tag2el_count = 2,      /* Count of tags in the map */
 517         0, 0,
 518         .first_extension = 2    /* Extensions start */
 519 };
 520 asn_TYPE_descriptor_t asn_DEF_VariablePart = {
 521         "VariablePart",
 522         "VariablePart",
 523         &asn_OP_CHOICE,
 524         0,      /* No effective tags (pointer) */
 525         0,      /* No effective tags (count) */
 526         0,      /* No tags (pointer) */
 527         0,      /* No tags (count) */
 528         { 0, 0, CHOICE_constraint },
 529         asn_MBR_VariablePart_1,
 530         2,      /* Elements count */
 531         &asn_SPC_VariablePart_specs_1   /* Additional specs */
 532 };
 533
 534
 535 /*** <<< INCLUDES [ActionItem] >>> ***/
 536
 537 #include <NativeEnumerated.h>
 538 #include <BOOLEAN.h>
 539 #include <VisibleString.h>
 540 #include <asn_SET_OF.h>
 541 #include <constr_SET_OF.h>
 542 #include <constr_SEQUENCE.h>
 543
 544 /*** <<< DEPS [ActionItem] >>> ***/
 545
 546 typedef enum accept_as {
 547         accept_as_unknown       = 0,
 548         accept_as_safe  = 1,
 549         accept_as_unsafe        = 2
 550         /*
 551          * Enumeration is extensible
 552          */
 553 } e_accept_as;
 554
 555 /*** <<< TYPE-DECLS [ActionItem] >>> ***/
 556
 557 typedef struct ActionItem {
 558         long     accept_as;
 559         struct notify {
 560                 BOOLEAN_t        critical;
 561                 struct email {
 562                         A_SET_OF(VisibleString_t) list;
 563
 564                         /* Context for parsing across buffer boundaries */
 565                         asn_struct_ctx_t _asn_ctx;
 566                 } email;
 567                 /*
 568                  * This type is extensible,
 569                  * possible extensions are below.
 570                  */
 571
 572                 /* Context for parsing across buffer boundaries */
 573                 asn_struct_ctx_t _asn_ctx;
 574         } *notify;
 575         /*
 576          * This type is extensible,
 577          * possible extensions are below.
 578          */
 579
 580         /* Context for parsing across buffer boundaries */
 581         asn_struct_ctx_t _asn_ctx;
 582 } ActionItem_t;
 583
 584 /*** <<< FUNC-DECLS [ActionItem] >>> ***/
 585
 586 /* extern asn_TYPE_descriptor_t asn_DEF_accept_as_2;    // (Use -fall-defs-global to expose) */
 587 extern asn_TYPE_descriptor_t asn_DEF_ActionItem;
 588 extern asn_SEQUENCE_specifics_t asn_SPC_ActionItem_specs_1;
 589 extern asn_TYPE_member_t asn_MBR_ActionItem_1[2];
 590
 591 /*** <<< CODE [ActionItem] >>> ***/
 592
 593 /*
 594  * This type is implemented using NativeEnumerated,
 595  * so here we adjust the DEF accordingly.
 596  */
 597
 598 /*** <<< STAT-DEFS [ActionItem] >>> ***/
 599
 600 static const asn_INTEGER_enum_map_t asn_MAP_accept_as_value2enum_2[] = {
 601         { 0,    7,      "unknown" },
 602         { 1,    4,      "safe" },
 603         { 2,    6,      "unsafe" }
 604         /* This list is extensible */
 605 };
 606 static const unsigned int asn_MAP_accept_as_enum2value_2[] = {
 607         1,      /* safe(1) */
 608         0,      /* unknown(0) */
 609         2       /* unsafe(2) */
 610         /* This list is extensible */
 611 };
 612 static const asn_INTEGER_specifics_t asn_SPC_accept_as_specs_2 = {
 613         asn_MAP_accept_as_value2enum_2, /* "tag" => N; sorted by tag */
 614         asn_MAP_accept_as_enum2value_2, /* N => "tag"; sorted by N */
 615         3,      /* Number of elements in the maps */
 616         4,      /* Extensions before this member */
 617         1,      /* Strict enumeration */
 618         0,      /* Native long size */
 619         0
 620 };
 621 static const ber_tlv_tag_t asn_DEF_accept_as_tags_2[] = {
 622         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
 623 };
 624 static /* Use -fall-defs-global to expose */
 625 asn_TYPE_descriptor_t asn_DEF_accept_as_2 = {
 626         "accept-as",
 627         "accept-as",
 628         &asn_OP_NativeEnumerated,
 629         asn_DEF_accept_as_tags_2,
 630         sizeof(asn_DEF_accept_as_tags_2)
 631                 /sizeof(asn_DEF_accept_as_tags_2[0]), /* 1 */
 632         asn_DEF_accept_as_tags_2,       /* Same as above */
 633         sizeof(asn_DEF_accept_as_tags_2)
 634                 /sizeof(asn_DEF_accept_as_tags_2[0]), /* 1 */
 635         { 0, 0, NativeEnumerated_constraint },
 636         0, 0,   /* Defined elsewhere */
 637         &asn_SPC_accept_as_specs_2      /* Additional specs */
 638 };
 639
 640 static asn_TYPE_member_t asn_MBR_email_9[] = {
 641         { ATF_POINTER, 0, 0,
 642                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (26 << 2)),
 643                 .tag_mode = 0,
 644                 .type = &asn_DEF_VisibleString,
 645                 .type_selector = 0,
 646                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 647                 0, 0, /* No default value */
 648                 .name = ""
 649                 },
 650 };
 651 static const ber_tlv_tag_t asn_DEF_email_tags_9[] = {
 652         (ASN_TAG_CLASS_UNIVERSAL | (17 << 2))
 653 };
 654 static asn_SET_OF_specifics_t asn_SPC_email_specs_9 = {
 655         sizeof(struct email),
 656         offsetof(struct email, _asn_ctx),
 657         0,      /* XER encoding is XMLDelimitedItemList */
 658 };
 659 static /* Use -fall-defs-global to expose */
 660 asn_TYPE_descriptor_t asn_DEF_email_9 = {
 661         "email",
 662         "email",
 663         &asn_OP_SET_OF,
 664         asn_DEF_email_tags_9,
 665         sizeof(asn_DEF_email_tags_9)
 666                 /sizeof(asn_DEF_email_tags_9[0]), /* 1 */
 667         asn_DEF_email_tags_9,   /* Same as above */
 668         sizeof(asn_DEF_email_tags_9)
 669                 /sizeof(asn_DEF_email_tags_9[0]), /* 1 */
 670         { 0, 0, SET_OF_constraint },
 671         asn_MBR_email_9,
 672         1,      /* Single element */
 673         &asn_SPC_email_specs_9  /* Additional specs */
 674 };
 675
 676 static asn_TYPE_member_t asn_MBR_notify_7[] = {
 677         { ATF_NOFLAGS, 0, offsetof(struct notify, critical),
 678                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
 679                 .tag_mode = 0,
 680                 .type = &asn_DEF_BOOLEAN,
 681                 .type_selector = 0,
 682                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 683                 0, 0, /* No default value */
 684                 .name = "critical"
 685                 },
 686         { ATF_NOFLAGS, 0, offsetof(struct notify, email),
 687                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)),
 688                 .tag_mode = 0,
 689                 .type = &asn_DEF_email_9,
 690                 .type_selector = 0,
 691                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 692                 0, 0, /* No default value */
 693                 .name = "email"
 694                 },
 695 };
 696 static const ber_tlv_tag_t asn_DEF_notify_tags_7[] = {
 697         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 698 };
 699 static const asn_TYPE_tag2member_t asn_MAP_notify_tag2el_7[] = {
 700     { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 0, 0, 0 }, /* critical */
 701     { (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)), 1, 0, 0 } /* email */
 702 };
 703 static asn_SEQUENCE_specifics_t asn_SPC_notify_specs_7 = {
 704         sizeof(struct notify),
 705         offsetof(struct notify, _asn_ctx),
 706         .tag2el = asn_MAP_notify_tag2el_7,
 707         .tag2el_count = 2,      /* Count of tags in the map */
 708         0, 0, 0,        /* Optional elements (not needed) */
 709         2,      /* First extension addition */
 710 };
 711 static /* Use -fall-defs-global to expose */
 712 asn_TYPE_descriptor_t asn_DEF_notify_7 = {
 713         "notify",
 714         "notify",
 715         &asn_OP_SEQUENCE,
 716         asn_DEF_notify_tags_7,
 717         sizeof(asn_DEF_notify_tags_7)
 718                 /sizeof(asn_DEF_notify_tags_7[0]), /* 1 */
 719         asn_DEF_notify_tags_7,  /* Same as above */
 720         sizeof(asn_DEF_notify_tags_7)
 721                 /sizeof(asn_DEF_notify_tags_7[0]), /* 1 */
 722         { 0, 0, SEQUENCE_constraint },
 723         asn_MBR_notify_7,
 724         2,      /* Elements count */
 725         &asn_SPC_notify_specs_7 /* Additional specs */
 726 };
 727
 728 asn_TYPE_member_t asn_MBR_ActionItem_1[] = {
 729         { ATF_NOFLAGS, 0, offsetof(struct ActionItem, accept_as),
 730                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
 731                 .tag_mode = 0,
 732                 .type = &asn_DEF_accept_as_2,
 733                 .type_selector = 0,
 734                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 735                 0, 0, /* No default value */
 736                 .name = "accept-as"
 737                 },
 738         { ATF_POINTER, 1, offsetof(struct ActionItem, notify),
 739                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
 740                 .tag_mode = 0,
 741                 .type = &asn_DEF_notify_7,
 742                 .type_selector = 0,
 743                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 744                 0, 0, /* No default value */
 745                 .name = "notify"
 746                 },
 747 };
 748 static const ber_tlv_tag_t asn_DEF_ActionItem_tags_1[] = {
 749         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 750 };
 751 static const asn_TYPE_tag2member_t asn_MAP_ActionItem_tag2el_1[] = {
 752     { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 0, 0, 0 }, /* accept-as */
 753     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 } /* notify */
 754 };
 755 asn_SEQUENCE_specifics_t asn_SPC_ActionItem_specs_1 = {
 756         sizeof(struct ActionItem),
 757         offsetof(struct ActionItem, _asn_ctx),
 758         .tag2el = asn_MAP_ActionItem_tag2el_1,
 759         .tag2el_count = 2,      /* Count of tags in the map */
 760         0, 0, 0,        /* Optional elements (not needed) */
 761         2,      /* First extension addition */
 762 };
 763 asn_TYPE_descriptor_t asn_DEF_ActionItem = {
 764         "ActionItem",
 765         "ActionItem",
 766         &asn_OP_SEQUENCE,
 767         asn_DEF_ActionItem_tags_1,
 768         sizeof(asn_DEF_ActionItem_tags_1)
 769                 /sizeof(asn_DEF_ActionItem_tags_1[0]), /* 1 */
 770         asn_DEF_ActionItem_tags_1,      /* Same as above */
 771         sizeof(asn_DEF_ActionItem_tags_1)
 772                 /sizeof(asn_DEF_ActionItem_tags_1[0]), /* 1 */
 773         { 0, 0, SEQUENCE_constraint },
 774         asn_MBR_ActionItem_1,
 775         2,      /* Elements count */
 776         &asn_SPC_ActionItem_specs_1     /* Additional specs */
 777 };
 778