tests/tests-asn1c-compiler/154-with-REAL-components-OK.asn1.-Pfwide-types

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