tests/tests-asn1c-compiler/154-with-REAL-components-OK.asn1.-Pgen-PER

   1
   2 /*** <<< INCLUDES [UnconstrainedREAL] >>> ***/
   3
   4 #include <NativeReal.h>
   5
   6 /*** <<< TYPE-DECLS [UnconstrainedREAL] >>> ***/
   7
   8 typedef double   UnconstrainedREAL_t;
   9
  10 /*** <<< FUNC-DECLS [UnconstrainedREAL] >>> ***/
  11
  12 extern asn_TYPE_descriptor_t asn_DEF_UnconstrainedREAL;
  13 asn_struct_free_f UnconstrainedREAL_free;
  14 asn_struct_print_f UnconstrainedREAL_print;
  15 asn_constr_check_f UnconstrainedREAL_constraint;
  16 ber_type_decoder_f UnconstrainedREAL_decode_ber;
  17 der_type_encoder_f UnconstrainedREAL_encode_der;
  18 xer_type_decoder_f UnconstrainedREAL_decode_xer;
  19 xer_type_encoder_f UnconstrainedREAL_encode_xer;
  20 per_type_decoder_f UnconstrainedREAL_decode_uper;
  21 per_type_encoder_f UnconstrainedREAL_encode_uper;
  22 per_type_decoder_f UnconstrainedREAL_decode_aper;
  23 per_type_encoder_f UnconstrainedREAL_encode_aper;
  24
  25 /*** <<< CODE [UnconstrainedREAL] >>> ***/
  26
  27 /*
  28  * This type is implemented using NativeReal,
  29  * so here we adjust the DEF accordingly.
  30  */
  31
  32 /*** <<< STAT-DEFS [UnconstrainedREAL] >>> ***/
  33
  34 static const ber_tlv_tag_t asn_DEF_UnconstrainedREAL_tags_1[] = {
  35         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
  36 };
  37 asn_TYPE_descriptor_t asn_DEF_UnconstrainedREAL = {
  38         "UnconstrainedREAL",
  39         "UnconstrainedREAL",
  40         &asn_OP_NativeReal,
  41         asn_DEF_UnconstrainedREAL_tags_1,
  42         sizeof(asn_DEF_UnconstrainedREAL_tags_1)
  43                 /sizeof(asn_DEF_UnconstrainedREAL_tags_1[0]), /* 1 */
  44         asn_DEF_UnconstrainedREAL_tags_1,       /* Same as above */
  45         sizeof(asn_DEF_UnconstrainedREAL_tags_1)
  46                 /sizeof(asn_DEF_UnconstrainedREAL_tags_1[0]), /* 1 */
  47         { 0, 0, NativeReal_constraint },
  48         0, 0,   /* No members */
  49         0       /* No specifics */
  50 };
  51
  52
  53 /*** <<< INCLUDES [WeirdlyConstrainedREAL] >>> ***/
  54
  55 #include <NativeReal.h>
  56
  57 /*** <<< TYPE-DECLS [WeirdlyConstrainedREAL] >>> ***/
  58
  59 typedef double   WeirdlyConstrainedREAL_t;
  60
  61 /*** <<< FUNC-DECLS [WeirdlyConstrainedREAL] >>> ***/
  62
  63 extern asn_TYPE_descriptor_t asn_DEF_WeirdlyConstrainedREAL;
  64 asn_struct_free_f WeirdlyConstrainedREAL_free;
  65 asn_struct_print_f WeirdlyConstrainedREAL_print;
  66 asn_constr_check_f WeirdlyConstrainedREAL_constraint;
  67 ber_type_decoder_f WeirdlyConstrainedREAL_decode_ber;
  68 der_type_encoder_f WeirdlyConstrainedREAL_encode_der;
  69 xer_type_decoder_f WeirdlyConstrainedREAL_decode_xer;
  70 xer_type_encoder_f WeirdlyConstrainedREAL_encode_xer;
  71 per_type_decoder_f WeirdlyConstrainedREAL_decode_uper;
  72 per_type_encoder_f WeirdlyConstrainedREAL_encode_uper;
  73 per_type_decoder_f WeirdlyConstrainedREAL_decode_aper;
  74 per_type_encoder_f WeirdlyConstrainedREAL_encode_aper;
  75
  76 /*** <<< CODE [WeirdlyConstrainedREAL] >>> ***/
  77
  78 int
  79 WeirdlyConstrainedREAL_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
  80                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  81         double value;
  82
  83         if(!sptr) {
  84                 ASN__CTFAIL(app_key, td, sptr,
  85                         "%s: value not given (%s:%d)",
  86                         td->name, __FILE__, __LINE__);
  87                 return -1;
  88         }
  89
  90         value = *(const double *)sptr;
  91
  92         if((value == 3)) {
  93                 /* Constraint check succeeded */
  94                 return 0;
  95         } else {
  96                 ASN__CTFAIL(app_key, td, sptr,
  97                         "%s: constraint failed (%s:%d)",
  98                         td->name, __FILE__, __LINE__);
  99                 return -1;
 100         }
 101 }
 102
 103 /*
 104  * This type is implemented using NativeReal,
 105  * so here we adjust the DEF accordingly.
 106  */
 107
 108 /*** <<< CTDEFS [WeirdlyConstrainedREAL] >>> ***/
 109
 110 static asn_per_constraints_t asn_PER_type_WeirdlyConstrainedREAL_constr_1 CC_NOTUSED = {
 111         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 112         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 113         0, 0    /* No PER value map */
 114 };
 115
 116 /*** <<< STAT-DEFS [WeirdlyConstrainedREAL] >>> ***/
 117
 118 static const ber_tlv_tag_t asn_DEF_WeirdlyConstrainedREAL_tags_1[] = {
 119         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 120 };
 121 asn_TYPE_descriptor_t asn_DEF_WeirdlyConstrainedREAL = {
 122         "WeirdlyConstrainedREAL",
 123         "WeirdlyConstrainedREAL",
 124         &asn_OP_NativeReal,
 125         asn_DEF_WeirdlyConstrainedREAL_tags_1,
 126         sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1)
 127                 /sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1[0]), /* 1 */
 128         asn_DEF_WeirdlyConstrainedREAL_tags_1,  /* Same as above */
 129         sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1)
 130                 /sizeof(asn_DEF_WeirdlyConstrainedREAL_tags_1[0]), /* 1 */
 131         { 0, &asn_PER_type_WeirdlyConstrainedREAL_constr_1, WeirdlyConstrainedREAL_constraint },
 132         0, 0,   /* No members */
 133         0       /* No specifics */
 134 };
 135
 136
 137 /*** <<< INCLUDES [Indirect-IEEE-binary32] >>> ***/
 138
 139 #include "UnconstrainedREAL.h"
 140
 141 /*** <<< TYPE-DECLS [Indirect-IEEE-binary32] >>> ***/
 142
 143 typedef UnconstrainedREAL_t      Indirect_IEEE_binary32_t;
 144
 145 /*** <<< FUNC-DECLS [Indirect-IEEE-binary32] >>> ***/
 146
 147 extern asn_per_constraints_t asn_PER_type_Indirect_IEEE_binary32_constr_1;
 148 extern asn_TYPE_descriptor_t asn_DEF_Indirect_IEEE_binary32;
 149 extern const asn_NativeReal_specifics_t asn_SPC_Indirect_IEEE_binary32_specs_1;
 150 asn_struct_free_f Indirect_IEEE_binary32_free;
 151 asn_struct_print_f Indirect_IEEE_binary32_print;
 152 asn_constr_check_f Indirect_IEEE_binary32_constraint;
 153 ber_type_decoder_f Indirect_IEEE_binary32_decode_ber;
 154 der_type_encoder_f Indirect_IEEE_binary32_encode_der;
 155 xer_type_decoder_f Indirect_IEEE_binary32_decode_xer;
 156 xer_type_encoder_f Indirect_IEEE_binary32_encode_xer;
 157 per_type_decoder_f Indirect_IEEE_binary32_decode_uper;
 158 per_type_encoder_f Indirect_IEEE_binary32_encode_uper;
 159 per_type_decoder_f Indirect_IEEE_binary32_decode_aper;
 160 per_type_encoder_f Indirect_IEEE_binary32_encode_aper;
 161
 162 /*** <<< CODE [Indirect-IEEE-binary32] >>> ***/
 163
 164 int
 165 Indirect_IEEE_binary32_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 166                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 167
 168         if(!sptr) {
 169                 ASN__CTFAIL(app_key, td, sptr,
 170                         "%s: value not given (%s:%d)",
 171                         td->name, __FILE__, __LINE__);
 172                 return -1;
 173         }
 174
 175
 176         if(1 /* No applicable constraints whatsoever */) {
 177                 /* Nothing is here. See below */
 178         }
 179
 180         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 181 }
 182
 183 /*
 184  * This type is implemented using UnconstrainedREAL,
 185  * so here we adjust the DEF accordingly.
 186  */
 187
 188 /*** <<< CTDEFS [Indirect-IEEE-binary32] >>> ***/
 189
 190 asn_per_constraints_t asn_PER_type_Indirect_IEEE_binary32_constr_1 CC_NOTUSED = {
 191         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 192         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 193         0, 0    /* No PER value map */
 194 };
 195
 196 /*** <<< STAT-DEFS [Indirect-IEEE-binary32] >>> ***/
 197
 198 const asn_NativeReal_specifics_t asn_SPC_Indirect_IEEE_binary32_specs_1 = {
 199         4       /* Use 'float' type. */
 200 };
 201 static const ber_tlv_tag_t asn_DEF_Indirect_IEEE_binary32_tags_1[] = {
 202         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 203 };
 204 asn_TYPE_descriptor_t asn_DEF_Indirect_IEEE_binary32 = {
 205         "Indirect-IEEE-binary32",
 206         "Indirect-IEEE-binary32",
 207         &asn_OP_NativeReal,
 208         asn_DEF_Indirect_IEEE_binary32_tags_1,
 209         sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1)
 210                 /sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1[0]), /* 1 */
 211         asn_DEF_Indirect_IEEE_binary32_tags_1,  /* Same as above */
 212         sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1)
 213                 /sizeof(asn_DEF_Indirect_IEEE_binary32_tags_1[0]), /* 1 */
 214         { 0, &asn_PER_type_Indirect_IEEE_binary32_constr_1, Indirect_IEEE_binary32_constraint },
 215         0, 0,   /* No members */
 216         &asn_SPC_Indirect_IEEE_binary32_specs_1 /* Additional specs */
 217 };
 218
 219
 220 /*** <<< INCLUDES [IEEE-binary32-w] >>> ***/
 221
 222 #include <NativeReal.h>
 223
 224 /*** <<< TYPE-DECLS [IEEE-binary32-w] >>> ***/
 225
 226 typedef float    IEEE_binary32_w_t;
 227
 228 /*** <<< FUNC-DECLS [IEEE-binary32-w] >>> ***/
 229
 230 extern asn_per_constraints_t asn_PER_type_IEEE_binary32_w_constr_1;
 231 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w;
 232 extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w_specs_1;
 233 asn_struct_free_f IEEE_binary32_w_free;
 234 asn_struct_print_f IEEE_binary32_w_print;
 235 asn_constr_check_f IEEE_binary32_w_constraint;
 236 ber_type_decoder_f IEEE_binary32_w_decode_ber;
 237 der_type_encoder_f IEEE_binary32_w_encode_der;
 238 xer_type_decoder_f IEEE_binary32_w_decode_xer;
 239 xer_type_encoder_f IEEE_binary32_w_encode_xer;
 240 per_type_decoder_f IEEE_binary32_w_decode_uper;
 241 per_type_encoder_f IEEE_binary32_w_encode_uper;
 242 per_type_decoder_f IEEE_binary32_w_decode_aper;
 243 per_type_encoder_f IEEE_binary32_w_encode_aper;
 244
 245 /*** <<< CODE [IEEE-binary32-w] >>> ***/
 246
 247 int
 248 IEEE_binary32_w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 249                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 250
 251         if(!sptr) {
 252                 ASN__CTFAIL(app_key, td, sptr,
 253                         "%s: value not given (%s:%d)",
 254                         td->name, __FILE__, __LINE__);
 255                 return -1;
 256         }
 257
 258
 259         if(1 /* No applicable constraints whatsoever */) {
 260                 /* Nothing is here. See below */
 261         }
 262
 263         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 264 }
 265
 266 /*
 267  * This type is implemented using NativeReal,
 268  * so here we adjust the DEF accordingly.
 269  */
 270
 271 /*** <<< CTDEFS [IEEE-binary32-w] >>> ***/
 272
 273 asn_per_constraints_t asn_PER_type_IEEE_binary32_w_constr_1 CC_NOTUSED = {
 274         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 275         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 276         0, 0    /* No PER value map */
 277 };
 278
 279 /*** <<< STAT-DEFS [IEEE-binary32-w] >>> ***/
 280
 281 const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w_specs_1 = {
 282         4       /* Use 'float' type. */
 283 };
 284 static const ber_tlv_tag_t asn_DEF_IEEE_binary32_w_tags_1[] = {
 285         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 286 };
 287 asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w = {
 288         "IEEE-binary32-w",
 289         "IEEE-binary32-w",
 290         &asn_OP_NativeReal,
 291         asn_DEF_IEEE_binary32_w_tags_1,
 292         sizeof(asn_DEF_IEEE_binary32_w_tags_1)
 293                 /sizeof(asn_DEF_IEEE_binary32_w_tags_1[0]), /* 1 */
 294         asn_DEF_IEEE_binary32_w_tags_1, /* Same as above */
 295         sizeof(asn_DEF_IEEE_binary32_w_tags_1)
 296                 /sizeof(asn_DEF_IEEE_binary32_w_tags_1[0]), /* 1 */
 297         { 0, &asn_PER_type_IEEE_binary32_w_constr_1, IEEE_binary32_w_constraint },
 298         0, 0,   /* No members */
 299         &asn_SPC_IEEE_binary32_w_specs_1        /* Additional specs */
 300 };
 301
 302
 303 /*** <<< INCLUDES [IEEE-binary32-0w] >>> ***/
 304
 305 #include <NativeReal.h>
 306
 307 /*** <<< TYPE-DECLS [IEEE-binary32-0w] >>> ***/
 308
 309 typedef float    IEEE_binary32_0w_t;
 310
 311 /*** <<< FUNC-DECLS [IEEE-binary32-0w] >>> ***/
 312
 313 extern asn_per_constraints_t asn_PER_type_IEEE_binary32_0w_constr_1;
 314 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_0w;
 315 extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_0w_specs_1;
 316 asn_struct_free_f IEEE_binary32_0w_free;
 317 asn_struct_print_f IEEE_binary32_0w_print;
 318 asn_constr_check_f IEEE_binary32_0w_constraint;
 319 ber_type_decoder_f IEEE_binary32_0w_decode_ber;
 320 der_type_encoder_f IEEE_binary32_0w_encode_der;
 321 xer_type_decoder_f IEEE_binary32_0w_decode_xer;
 322 xer_type_encoder_f IEEE_binary32_0w_encode_xer;
 323 per_type_decoder_f IEEE_binary32_0w_decode_uper;
 324 per_type_encoder_f IEEE_binary32_0w_encode_uper;
 325 per_type_decoder_f IEEE_binary32_0w_decode_aper;
 326 per_type_encoder_f IEEE_binary32_0w_encode_aper;
 327
 328 /*** <<< CODE [IEEE-binary32-0w] >>> ***/
 329
 330 int
 331 IEEE_binary32_0w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 332                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 333
 334         if(!sptr) {
 335                 ASN__CTFAIL(app_key, td, sptr,
 336                         "%s: value not given (%s:%d)",
 337                         td->name, __FILE__, __LINE__);
 338                 return -1;
 339         }
 340
 341
 342         if(1 /* No applicable constraints whatsoever */) {
 343                 /* Nothing is here. See below */
 344         }
 345
 346         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 347 }
 348
 349 /*
 350  * This type is implemented using NativeReal,
 351  * so here we adjust the DEF accordingly.
 352  */
 353
 354 /*** <<< CTDEFS [IEEE-binary32-0w] >>> ***/
 355
 356 asn_per_constraints_t asn_PER_type_IEEE_binary32_0w_constr_1 CC_NOTUSED = {
 357         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 358         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 359         0, 0    /* No PER value map */
 360 };
 361
 362 /*** <<< STAT-DEFS [IEEE-binary32-0w] >>> ***/
 363
 364 const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_0w_specs_1 = {
 365         4       /* Use 'float' type. */
 366 };
 367 static const ber_tlv_tag_t asn_DEF_IEEE_binary32_0w_tags_1[] = {
 368         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 369 };
 370 asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_0w = {
 371         "IEEE-binary32-0w",
 372         "IEEE-binary32-0w",
 373         &asn_OP_NativeReal,
 374         asn_DEF_IEEE_binary32_0w_tags_1,
 375         sizeof(asn_DEF_IEEE_binary32_0w_tags_1)
 376                 /sizeof(asn_DEF_IEEE_binary32_0w_tags_1[0]), /* 1 */
 377         asn_DEF_IEEE_binary32_0w_tags_1,        /* Same as above */
 378         sizeof(asn_DEF_IEEE_binary32_0w_tags_1)
 379                 /sizeof(asn_DEF_IEEE_binary32_0w_tags_1[0]), /* 1 */
 380         { 0, &asn_PER_type_IEEE_binary32_0w_constr_1, IEEE_binary32_0w_constraint },
 381         0, 0,   /* No members */
 382         &asn_SPC_IEEE_binary32_0w_specs_1       /* Additional specs */
 383 };
 384
 385
 386 /*** <<< INCLUDES [IEEE-binary32-w0] >>> ***/
 387
 388 #include <NativeReal.h>
 389
 390 /*** <<< TYPE-DECLS [IEEE-binary32-w0] >>> ***/
 391
 392 typedef float    IEEE_binary32_w0_t;
 393
 394 /*** <<< FUNC-DECLS [IEEE-binary32-w0] >>> ***/
 395
 396 extern asn_per_constraints_t asn_PER_type_IEEE_binary32_w0_constr_1;
 397 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w0;
 398 extern const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w0_specs_1;
 399 asn_struct_free_f IEEE_binary32_w0_free;
 400 asn_struct_print_f IEEE_binary32_w0_print;
 401 asn_constr_check_f IEEE_binary32_w0_constraint;
 402 ber_type_decoder_f IEEE_binary32_w0_decode_ber;
 403 der_type_encoder_f IEEE_binary32_w0_encode_der;
 404 xer_type_decoder_f IEEE_binary32_w0_decode_xer;
 405 xer_type_encoder_f IEEE_binary32_w0_encode_xer;
 406 per_type_decoder_f IEEE_binary32_w0_decode_uper;
 407 per_type_encoder_f IEEE_binary32_w0_encode_uper;
 408 per_type_decoder_f IEEE_binary32_w0_decode_aper;
 409 per_type_encoder_f IEEE_binary32_w0_encode_aper;
 410
 411 /*** <<< CODE [IEEE-binary32-w0] >>> ***/
 412
 413 int
 414 IEEE_binary32_w0_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 415                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 416
 417         if(!sptr) {
 418                 ASN__CTFAIL(app_key, td, sptr,
 419                         "%s: value not given (%s:%d)",
 420                         td->name, __FILE__, __LINE__);
 421                 return -1;
 422         }
 423
 424
 425         if(1 /* No applicable constraints whatsoever */) {
 426                 /* Nothing is here. See below */
 427         }
 428
 429         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 430 }
 431
 432 /*
 433  * This type is implemented using NativeReal,
 434  * so here we adjust the DEF accordingly.
 435  */
 436
 437 /*** <<< CTDEFS [IEEE-binary32-w0] >>> ***/
 438
 439 asn_per_constraints_t asn_PER_type_IEEE_binary32_w0_constr_1 CC_NOTUSED = {
 440         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 441         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 442         0, 0    /* No PER value map */
 443 };
 444
 445 /*** <<< STAT-DEFS [IEEE-binary32-w0] >>> ***/
 446
 447 const asn_NativeReal_specifics_t asn_SPC_IEEE_binary32_w0_specs_1 = {
 448         4       /* Use 'float' type. */
 449 };
 450 static const ber_tlv_tag_t asn_DEF_IEEE_binary32_w0_tags_1[] = {
 451         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 452 };
 453 asn_TYPE_descriptor_t asn_DEF_IEEE_binary32_w0 = {
 454         "IEEE-binary32-w0",
 455         "IEEE-binary32-w0",
 456         &asn_OP_NativeReal,
 457         asn_DEF_IEEE_binary32_w0_tags_1,
 458         sizeof(asn_DEF_IEEE_binary32_w0_tags_1)
 459                 /sizeof(asn_DEF_IEEE_binary32_w0_tags_1[0]), /* 1 */
 460         asn_DEF_IEEE_binary32_w0_tags_1,        /* Same as above */
 461         sizeof(asn_DEF_IEEE_binary32_w0_tags_1)
 462                 /sizeof(asn_DEF_IEEE_binary32_w0_tags_1[0]), /* 1 */
 463         { 0, &asn_PER_type_IEEE_binary32_w0_constr_1, IEEE_binary32_w0_constraint },
 464         0, 0,   /* No members */
 465         &asn_SPC_IEEE_binary32_w0_specs_1       /* Additional specs */
 466 };
 467
 468
 469 /*** <<< INCLUDES [IEEE-binary64-w] >>> ***/
 470
 471 #include <NativeReal.h>
 472
 473 /*** <<< TYPE-DECLS [IEEE-binary64-w] >>> ***/
 474
 475 typedef double   IEEE_binary64_w_t;
 476
 477 /*** <<< FUNC-DECLS [IEEE-binary64-w] >>> ***/
 478
 479 extern asn_per_constraints_t asn_PER_type_IEEE_binary64_w_constr_1;
 480 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w;
 481 asn_struct_free_f IEEE_binary64_w_free;
 482 asn_struct_print_f IEEE_binary64_w_print;
 483 asn_constr_check_f IEEE_binary64_w_constraint;
 484 ber_type_decoder_f IEEE_binary64_w_decode_ber;
 485 der_type_encoder_f IEEE_binary64_w_encode_der;
 486 xer_type_decoder_f IEEE_binary64_w_decode_xer;
 487 xer_type_encoder_f IEEE_binary64_w_encode_xer;
 488 per_type_decoder_f IEEE_binary64_w_decode_uper;
 489 per_type_encoder_f IEEE_binary64_w_encode_uper;
 490 per_type_decoder_f IEEE_binary64_w_decode_aper;
 491 per_type_encoder_f IEEE_binary64_w_encode_aper;
 492
 493 /*** <<< CODE [IEEE-binary64-w] >>> ***/
 494
 495 int
 496 IEEE_binary64_w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 497                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 498
 499         if(!sptr) {
 500                 ASN__CTFAIL(app_key, td, sptr,
 501                         "%s: value not given (%s:%d)",
 502                         td->name, __FILE__, __LINE__);
 503                 return -1;
 504         }
 505
 506
 507         if(1 /* No applicable constraints whatsoever */) {
 508                 /* Nothing is here. See below */
 509         }
 510
 511         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 512 }
 513
 514 /*
 515  * This type is implemented using NativeReal,
 516  * so here we adjust the DEF accordingly.
 517  */
 518
 519 /*** <<< CTDEFS [IEEE-binary64-w] >>> ***/
 520
 521 asn_per_constraints_t asn_PER_type_IEEE_binary64_w_constr_1 CC_NOTUSED = {
 522         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 523         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 524         0, 0    /* No PER value map */
 525 };
 526
 527 /*** <<< STAT-DEFS [IEEE-binary64-w] >>> ***/
 528
 529 static const ber_tlv_tag_t asn_DEF_IEEE_binary64_w_tags_1[] = {
 530         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 531 };
 532 asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w = {
 533         "IEEE-binary64-w",
 534         "IEEE-binary64-w",
 535         &asn_OP_NativeReal,
 536         asn_DEF_IEEE_binary64_w_tags_1,
 537         sizeof(asn_DEF_IEEE_binary64_w_tags_1)
 538                 /sizeof(asn_DEF_IEEE_binary64_w_tags_1[0]), /* 1 */
 539         asn_DEF_IEEE_binary64_w_tags_1, /* Same as above */
 540         sizeof(asn_DEF_IEEE_binary64_w_tags_1)
 541                 /sizeof(asn_DEF_IEEE_binary64_w_tags_1[0]), /* 1 */
 542         { 0, &asn_PER_type_IEEE_binary64_w_constr_1, IEEE_binary64_w_constraint },
 543         0, 0,   /* No members */
 544         0       /* No specifics */
 545 };
 546
 547
 548 /*** <<< INCLUDES [IEEE-binary64-0w] >>> ***/
 549
 550 #include <NativeReal.h>
 551
 552 /*** <<< TYPE-DECLS [IEEE-binary64-0w] >>> ***/
 553
 554 typedef double   IEEE_binary64_0w_t;
 555
 556 /*** <<< FUNC-DECLS [IEEE-binary64-0w] >>> ***/
 557
 558 extern asn_per_constraints_t asn_PER_type_IEEE_binary64_0w_constr_1;
 559 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_0w;
 560 asn_struct_free_f IEEE_binary64_0w_free;
 561 asn_struct_print_f IEEE_binary64_0w_print;
 562 asn_constr_check_f IEEE_binary64_0w_constraint;
 563 ber_type_decoder_f IEEE_binary64_0w_decode_ber;
 564 der_type_encoder_f IEEE_binary64_0w_encode_der;
 565 xer_type_decoder_f IEEE_binary64_0w_decode_xer;
 566 xer_type_encoder_f IEEE_binary64_0w_encode_xer;
 567 per_type_decoder_f IEEE_binary64_0w_decode_uper;
 568 per_type_encoder_f IEEE_binary64_0w_encode_uper;
 569 per_type_decoder_f IEEE_binary64_0w_decode_aper;
 570 per_type_encoder_f IEEE_binary64_0w_encode_aper;
 571
 572 /*** <<< CODE [IEEE-binary64-0w] >>> ***/
 573
 574 int
 575 IEEE_binary64_0w_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 576                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 577
 578         if(!sptr) {
 579                 ASN__CTFAIL(app_key, td, sptr,
 580                         "%s: value not given (%s:%d)",
 581                         td->name, __FILE__, __LINE__);
 582                 return -1;
 583         }
 584
 585
 586         if(1 /* No applicable constraints whatsoever */) {
 587                 /* Nothing is here. See below */
 588         }
 589
 590         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 591 }
 592
 593 /*
 594  * This type is implemented using NativeReal,
 595  * so here we adjust the DEF accordingly.
 596  */
 597
 598 /*** <<< CTDEFS [IEEE-binary64-0w] >>> ***/
 599
 600 asn_per_constraints_t asn_PER_type_IEEE_binary64_0w_constr_1 CC_NOTUSED = {
 601         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 602         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 603         0, 0    /* No PER value map */
 604 };
 605
 606 /*** <<< STAT-DEFS [IEEE-binary64-0w] >>> ***/
 607
 608 static const ber_tlv_tag_t asn_DEF_IEEE_binary64_0w_tags_1[] = {
 609         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 610 };
 611 asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_0w = {
 612         "IEEE-binary64-0w",
 613         "IEEE-binary64-0w",
 614         &asn_OP_NativeReal,
 615         asn_DEF_IEEE_binary64_0w_tags_1,
 616         sizeof(asn_DEF_IEEE_binary64_0w_tags_1)
 617                 /sizeof(asn_DEF_IEEE_binary64_0w_tags_1[0]), /* 1 */
 618         asn_DEF_IEEE_binary64_0w_tags_1,        /* Same as above */
 619         sizeof(asn_DEF_IEEE_binary64_0w_tags_1)
 620                 /sizeof(asn_DEF_IEEE_binary64_0w_tags_1[0]), /* 1 */
 621         { 0, &asn_PER_type_IEEE_binary64_0w_constr_1, IEEE_binary64_0w_constraint },
 622         0, 0,   /* No members */
 623         0       /* No specifics */
 624 };
 625
 626
 627 /*** <<< INCLUDES [IEEE-binary64-w0] >>> ***/
 628
 629 #include <NativeReal.h>
 630
 631 /*** <<< TYPE-DECLS [IEEE-binary64-w0] >>> ***/
 632
 633 typedef double   IEEE_binary64_w0_t;
 634
 635 /*** <<< FUNC-DECLS [IEEE-binary64-w0] >>> ***/
 636
 637 extern asn_per_constraints_t asn_PER_type_IEEE_binary64_w0_constr_1;
 638 extern asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w0;
 639 asn_struct_free_f IEEE_binary64_w0_free;
 640 asn_struct_print_f IEEE_binary64_w0_print;
 641 asn_constr_check_f IEEE_binary64_w0_constraint;
 642 ber_type_decoder_f IEEE_binary64_w0_decode_ber;
 643 der_type_encoder_f IEEE_binary64_w0_encode_der;
 644 xer_type_decoder_f IEEE_binary64_w0_decode_xer;
 645 xer_type_encoder_f IEEE_binary64_w0_encode_xer;
 646 per_type_decoder_f IEEE_binary64_w0_decode_uper;
 647 per_type_encoder_f IEEE_binary64_w0_encode_uper;
 648 per_type_decoder_f IEEE_binary64_w0_decode_aper;
 649 per_type_encoder_f IEEE_binary64_w0_encode_aper;
 650
 651 /*** <<< CODE [IEEE-binary64-w0] >>> ***/
 652
 653 int
 654 IEEE_binary64_w0_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 655                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 656
 657         if(!sptr) {
 658                 ASN__CTFAIL(app_key, td, sptr,
 659                         "%s: value not given (%s:%d)",
 660                         td->name, __FILE__, __LINE__);
 661                 return -1;
 662         }
 663
 664
 665         if(1 /* No applicable constraints whatsoever */) {
 666                 /* Nothing is here. See below */
 667         }
 668
 669         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 670 }
 671
 672 /*
 673  * This type is implemented using NativeReal,
 674  * so here we adjust the DEF accordingly.
 675  */
 676
 677 /*** <<< CTDEFS [IEEE-binary64-w0] >>> ***/
 678
 679 asn_per_constraints_t asn_PER_type_IEEE_binary64_w0_constr_1 CC_NOTUSED = {
 680         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 681         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 682         0, 0    /* No PER value map */
 683 };
 684
 685 /*** <<< STAT-DEFS [IEEE-binary64-w0] >>> ***/
 686
 687 static const ber_tlv_tag_t asn_DEF_IEEE_binary64_w0_tags_1[] = {
 688         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 689 };
 690 asn_TYPE_descriptor_t asn_DEF_IEEE_binary64_w0 = {
 691         "IEEE-binary64-w0",
 692         "IEEE-binary64-w0",
 693         &asn_OP_NativeReal,
 694         asn_DEF_IEEE_binary64_w0_tags_1,
 695         sizeof(asn_DEF_IEEE_binary64_w0_tags_1)
 696                 /sizeof(asn_DEF_IEEE_binary64_w0_tags_1[0]), /* 1 */
 697         asn_DEF_IEEE_binary64_w0_tags_1,        /* Same as above */
 698         sizeof(asn_DEF_IEEE_binary64_w0_tags_1)
 699                 /sizeof(asn_DEF_IEEE_binary64_w0_tags_1[0]), /* 1 */
 700         { 0, &asn_PER_type_IEEE_binary64_w0_constr_1, IEEE_binary64_w0_constraint },
 701         0, 0,   /* No members */
 702         0       /* No specifics */
 703 };
 704
 705
 706 /*** <<< INCLUDES [Test] >>> ***/
 707
 708 #include "Indirect-IEEE-binary32.h"
 709 #include "IEEE-binary32-w.h"
 710 #include "IEEE-binary32-0w.h"
 711 #include "IEEE-binary32-w0.h"
 712 #include "IEEE-binary64-w.h"
 713 #include "IEEE-binary64-0w.h"
 714 #include "IEEE-binary64-w0.h"
 715 #include <constr_SEQUENCE.h>
 716
 717 /*** <<< TYPE-DECLS [Test] >>> ***/
 718
 719 typedef struct Test {
 720         Indirect_IEEE_binary32_t         indirect_ieee_binary32;
 721         IEEE_binary32_w_t        ieee_binary32_w;
 722         IEEE_binary32_0w_t       ieee_binary32_0w;
 723         IEEE_binary32_w0_t       ieee_binary32_w0;
 724         IEEE_binary64_w_t        ieee_binary64_w;
 725         IEEE_binary64_0w_t       ieee_binary64_0w;
 726         IEEE_binary64_w0_t       ieee_binary64_w0;
 727
 728         /* Context for parsing across buffer boundaries */
 729         asn_struct_ctx_t _asn_ctx;
 730 } Test_t;
 731
 732 /*** <<< FUNC-DECLS [Test] >>> ***/
 733
 734 /* extern asn_TYPE_descriptor_t asn_DEF_indirect_ieee_binary32_2;       // (Use -fall-defs-global to expose) */
 735 /* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w_3;      // (Use -fall-defs-global to expose) */
 736 /* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_0w_4;     // (Use -fall-defs-global to expose) */
 737 /* extern asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w0_5;     // (Use -fall-defs-global to expose) */
 738 extern asn_TYPE_descriptor_t asn_DEF_Test;
 739
 740 /*** <<< CODE [Test] >>> ***/
 741
 742 static int
 743 indirect_ieee_binary32_2_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 744                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 745
 746         if(!sptr) {
 747                 ASN__CTFAIL(app_key, td, sptr,
 748                         "%s: value not given (%s:%d)",
 749                         td->name, __FILE__, __LINE__);
 750                 return -1;
 751         }
 752
 753
 754         if(1 /* No applicable constraints whatsoever */) {
 755                 /* Nothing is here. See below */
 756         }
 757
 758         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 759 }
 760
 761 /*
 762  * This type is implemented using Indirect_IEEE_binary32,
 763  * so here we adjust the DEF accordingly.
 764  */
 765 static int
 766 ieee_binary32_w_3_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 767                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 768
 769         if(!sptr) {
 770                 ASN__CTFAIL(app_key, td, sptr,
 771                         "%s: value not given (%s:%d)",
 772                         td->name, __FILE__, __LINE__);
 773                 return -1;
 774         }
 775
 776
 777         if(1 /* No applicable constraints whatsoever */) {
 778                 /* Nothing is here. See below */
 779         }
 780
 781         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 782 }
 783
 784 /*
 785  * This type is implemented using IEEE_binary32_w,
 786  * so here we adjust the DEF accordingly.
 787  */
 788 static int
 789 ieee_binary32_0w_4_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 790                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 791
 792         if(!sptr) {
 793                 ASN__CTFAIL(app_key, td, sptr,
 794                         "%s: value not given (%s:%d)",
 795                         td->name, __FILE__, __LINE__);
 796                 return -1;
 797         }
 798
 799
 800         if(1 /* No applicable constraints whatsoever */) {
 801                 /* Nothing is here. See below */
 802         }
 803
 804         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 805 }
 806
 807 /*
 808  * This type is implemented using IEEE_binary32_0w,
 809  * so here we adjust the DEF accordingly.
 810  */
 811 static int
 812 ieee_binary32_w0_5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 813                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 814
 815         if(!sptr) {
 816                 ASN__CTFAIL(app_key, td, sptr,
 817                         "%s: value not given (%s:%d)",
 818                         td->name, __FILE__, __LINE__);
 819                 return -1;
 820         }
 821
 822
 823         if(1 /* No applicable constraints whatsoever */) {
 824                 /* Nothing is here. See below */
 825         }
 826
 827         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 828 }
 829
 830 /*
 831  * This type is implemented using IEEE_binary32_w0,
 832  * so here we adjust the DEF accordingly.
 833  */
 834
 835 /*** <<< CTDEFS [Test] >>> ***/
 836
 837 static asn_per_constraints_t asn_PER_type_indirect_ieee_binary32_constr_2 CC_NOTUSED = {
 838         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 839         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 840         0, 0    /* No PER value map */
 841 };
 842 static asn_per_constraints_t asn_PER_type_ieee_binary32_w_constr_3 CC_NOTUSED = {
 843         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 844         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 845         0, 0    /* No PER value map */
 846 };
 847 static asn_per_constraints_t asn_PER_type_ieee_binary32_0w_constr_4 CC_NOTUSED = {
 848         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 849         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 850         0, 0    /* No PER value map */
 851 };
 852 static asn_per_constraints_t asn_PER_type_ieee_binary32_w0_constr_5 CC_NOTUSED = {
 853         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 854         { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
 855         0, 0    /* No PER value map */
 856 };
 857
 858 /*** <<< STAT-DEFS [Test] >>> ***/
 859
 860 static const asn_NativeReal_specifics_t asn_SPC_indirect_ieee_binary32_specs_2 = {
 861         4       /* Use 'float' type. */
 862 };
 863 static const ber_tlv_tag_t asn_DEF_indirect_ieee_binary32_tags_2[] = {
 864         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 865 };
 866 static /* Use -fall-defs-global to expose */
 867 asn_TYPE_descriptor_t asn_DEF_indirect_ieee_binary32_2 = {
 868         "indirect-ieee-binary32",
 869         "indirect-ieee-binary32",
 870         &asn_OP_NativeReal,
 871         asn_DEF_indirect_ieee_binary32_tags_2,
 872         sizeof(asn_DEF_indirect_ieee_binary32_tags_2)
 873                 /sizeof(asn_DEF_indirect_ieee_binary32_tags_2[0]), /* 1 */
 874         asn_DEF_indirect_ieee_binary32_tags_2,  /* Same as above */
 875         sizeof(asn_DEF_indirect_ieee_binary32_tags_2)
 876                 /sizeof(asn_DEF_indirect_ieee_binary32_tags_2[0]), /* 1 */
 877         { 0, &asn_PER_type_indirect_ieee_binary32_constr_2, indirect_ieee_binary32_2_constraint },
 878         0, 0,   /* No members */
 879         &asn_SPC_indirect_ieee_binary32_specs_2 /* Additional specs */
 880 };
 881
 882 static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_w_specs_3 = {
 883         4       /* Use 'float' type. */
 884 };
 885 static const ber_tlv_tag_t asn_DEF_ieee_binary32_w_tags_3[] = {
 886         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 887 };
 888 static /* Use -fall-defs-global to expose */
 889 asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w_3 = {
 890         "ieee-binary32-w",
 891         "ieee-binary32-w",
 892         &asn_OP_NativeReal,
 893         asn_DEF_ieee_binary32_w_tags_3,
 894         sizeof(asn_DEF_ieee_binary32_w_tags_3)
 895                 /sizeof(asn_DEF_ieee_binary32_w_tags_3[0]), /* 1 */
 896         asn_DEF_ieee_binary32_w_tags_3, /* Same as above */
 897         sizeof(asn_DEF_ieee_binary32_w_tags_3)
 898                 /sizeof(asn_DEF_ieee_binary32_w_tags_3[0]), /* 1 */
 899         { 0, &asn_PER_type_ieee_binary32_w_constr_3, ieee_binary32_w_3_constraint },
 900         0, 0,   /* No members */
 901         &asn_SPC_ieee_binary32_w_specs_3        /* Additional specs */
 902 };
 903
 904 static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_0w_specs_4 = {
 905         4       /* Use 'float' type. */
 906 };
 907 static const ber_tlv_tag_t asn_DEF_ieee_binary32_0w_tags_4[] = {
 908         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 909 };
 910 static /* Use -fall-defs-global to expose */
 911 asn_TYPE_descriptor_t asn_DEF_ieee_binary32_0w_4 = {
 912         "ieee-binary32-0w",
 913         "ieee-binary32-0w",
 914         &asn_OP_NativeReal,
 915         asn_DEF_ieee_binary32_0w_tags_4,
 916         sizeof(asn_DEF_ieee_binary32_0w_tags_4)
 917                 /sizeof(asn_DEF_ieee_binary32_0w_tags_4[0]), /* 1 */
 918         asn_DEF_ieee_binary32_0w_tags_4,        /* Same as above */
 919         sizeof(asn_DEF_ieee_binary32_0w_tags_4)
 920                 /sizeof(asn_DEF_ieee_binary32_0w_tags_4[0]), /* 1 */
 921         { 0, &asn_PER_type_ieee_binary32_0w_constr_4, ieee_binary32_0w_4_constraint },
 922         0, 0,   /* No members */
 923         &asn_SPC_ieee_binary32_0w_specs_4       /* Additional specs */
 924 };
 925
 926 static const asn_NativeReal_specifics_t asn_SPC_ieee_binary32_w0_specs_5 = {
 927         4       /* Use 'float' type. */
 928 };
 929 static const ber_tlv_tag_t asn_DEF_ieee_binary32_w0_tags_5[] = {
 930         (ASN_TAG_CLASS_UNIVERSAL | (9 << 2))
 931 };
 932 static /* Use -fall-defs-global to expose */
 933 asn_TYPE_descriptor_t asn_DEF_ieee_binary32_w0_5 = {
 934         "ieee-binary32-w0",
 935         "ieee-binary32-w0",
 936         &asn_OP_NativeReal,
 937         asn_DEF_ieee_binary32_w0_tags_5,
 938         sizeof(asn_DEF_ieee_binary32_w0_tags_5)
 939                 /sizeof(asn_DEF_ieee_binary32_w0_tags_5[0]), /* 1 */
 940         asn_DEF_ieee_binary32_w0_tags_5,        /* Same as above */
 941         sizeof(asn_DEF_ieee_binary32_w0_tags_5)
 942                 /sizeof(asn_DEF_ieee_binary32_w0_tags_5[0]), /* 1 */
 943         { 0, &asn_PER_type_ieee_binary32_w0_constr_5, ieee_binary32_w0_5_constraint },
 944         0, 0,   /* No members */
 945         &asn_SPC_ieee_binary32_w0_specs_5       /* Additional specs */
 946 };
 947
 948 static asn_TYPE_member_t asn_MBR_Test_1[] = {
 949         { ATF_NOFLAGS, 0, offsetof(struct Test, indirect_ieee_binary32),
 950                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 951                 .tag_mode = 0,
 952                 .type = &asn_DEF_Indirect_IEEE_binary32,
 953                 .type_selector = 0,
 954                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 955                 0, 0, /* No default value */
 956                 .name = "indirect-ieee-binary32"
 957                 },
 958         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_w),
 959                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 960                 .tag_mode = 0,
 961                 .type = &asn_DEF_IEEE_binary32_w,
 962                 .type_selector = 0,
 963                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 964                 0, 0, /* No default value */
 965                 .name = "ieee-binary32-w"
 966                 },
 967         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_0w),
 968                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 969                 .tag_mode = 0,
 970                 .type = &asn_DEF_IEEE_binary32_0w,
 971                 .type_selector = 0,
 972                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 973                 0, 0, /* No default value */
 974                 .name = "ieee-binary32-0w"
 975                 },
 976         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary32_w0),
 977                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 978                 .tag_mode = 0,
 979                 .type = &asn_DEF_IEEE_binary32_w0,
 980                 .type_selector = 0,
 981                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 982                 0, 0, /* No default value */
 983                 .name = "ieee-binary32-w0"
 984                 },
 985         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_w),
 986                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 987                 .tag_mode = 0,
 988                 .type = &asn_DEF_IEEE_binary64_w,
 989                 .type_selector = 0,
 990                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
 991                 0, 0, /* No default value */
 992                 .name = "ieee-binary64-w"
 993                 },
 994         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_0w),
 995                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
 996                 .tag_mode = 0,
 997                 .type = &asn_DEF_IEEE_binary64_0w,
 998                 .type_selector = 0,
 999                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1000                 0, 0, /* No default value */
1001                 .name = "ieee-binary64-0w"
1002                 },
1003         { ATF_NOFLAGS, 0, offsetof(struct Test, ieee_binary64_w0),
1004                 .tag = (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)),
1005                 .tag_mode = 0,
1006                 .type = &asn_DEF_IEEE_binary64_w0,
1007                 .type_selector = 0,
1008                 { .oer_constraints = 0, .per_constraints = 0, .general_constraints = 0 },
1009                 0, 0, /* No default value */
1010                 .name = "ieee-binary64-w0"
1011                 },
1012 };
1013 static const ber_tlv_tag_t asn_DEF_Test_tags_1[] = {
1014         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
1015 };
1016 static const asn_TYPE_tag2member_t asn_MAP_Test_tag2el_1[] = {
1017     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 0, 0, 6 }, /* indirect-ieee-binary32 */
1018     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 1, -1, 5 }, /* ieee-binary32-w */
1019     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 2, -2, 4 }, /* ieee-binary32-0w */
1020     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 3, -3, 3 }, /* ieee-binary32-w0 */
1021     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 4, -4, 2 }, /* ieee-binary64-w */
1022     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 5, -5, 1 }, /* ieee-binary64-0w */
1023     { (ASN_TAG_CLASS_UNIVERSAL | (9 << 2)), 6, -6, 0 } /* ieee-binary64-w0 */
1024 };
1025 static asn_SEQUENCE_specifics_t asn_SPC_Test_specs_1 = {
1026         sizeof(struct Test),
1027         offsetof(struct Test, _asn_ctx),
1028         .tag2el = asn_MAP_Test_tag2el_1,
1029         .tag2el_count = 7,      /* Count of tags in the map */
1030         0, 0, 0,        /* Optional elements (not needed) */
1031         -1,     /* First extension addition */
1032 };
1033 asn_TYPE_descriptor_t asn_DEF_Test = {
1034         "Test",
1035         "Test",
1036         &asn_OP_SEQUENCE,
1037         asn_DEF_Test_tags_1,
1038         sizeof(asn_DEF_Test_tags_1)
1039                 /sizeof(asn_DEF_Test_tags_1[0]), /* 1 */
1040         asn_DEF_Test_tags_1,    /* Same as above */
1041         sizeof(asn_DEF_Test_tags_1)
1042                 /sizeof(asn_DEF_Test_tags_1[0]), /* 1 */
1043         { 0, 0, SEQUENCE_constraint },
1044         asn_MBR_Test_1,
1045         7,      /* Elements count */
1046         &asn_SPC_Test_specs_1   /* Additional specs */
1047 };
1048