tests/tests-asn1c-compiler/91-cond-int-blessSize-OK.asn1.-Pfbless-SIZE

   1
   2 /*** <<< INCLUDES [OK-Integer1] >>> ***/
   3
   4 #include <NativeInteger.h>
   5
   6 /*** <<< TYPE-DECLS [OK-Integer1] >>> ***/
   7
   8 typedef long     OK_Integer1_t;
   9
  10 /*** <<< FUNC-DECLS [OK-Integer1] >>> ***/
  11
  12 extern asn_TYPE_descriptor_t asn_DEF_OK_Integer1;
  13 asn_struct_free_f OK_Integer1_free;
  14 asn_struct_print_f OK_Integer1_print;
  15 asn_constr_check_f OK_Integer1_constraint;
  16 ber_type_decoder_f OK_Integer1_decode_ber;
  17 der_type_encoder_f OK_Integer1_encode_der;
  18 xer_type_decoder_f OK_Integer1_decode_xer;
  19 xer_type_encoder_f OK_Integer1_encode_xer;
  20
  21 /*** <<< CODE [OK-Integer1] >>> ***/
  22
  23 int
  24 OK_Integer1_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
  25                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  26
  27         if(!sptr) {
  28                 ASN__CTFAIL(app_key, td, sptr,
  29                         "%s: value not given (%s:%d)",
  30                         td->name, __FILE__, __LINE__);
  31                 return -1;
  32         }
  33
  34
  35         if(1 /* No applicable constraints whatsoever */) {
  36                 /* Nothing is here. See below */
  37         }
  38
  39         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
  40 }
  41
  42 /*
  43  * This type is implemented using NativeInteger,
  44  * so here we adjust the DEF accordingly.
  45  */
  46
  47 /*** <<< STAT-DEFS [OK-Integer1] >>> ***/
  48
  49 static const ber_tlv_tag_t asn_DEF_OK_Integer1_tags_1[] = {
  50         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
  51 };
  52 asn_TYPE_descriptor_t asn_DEF_OK_Integer1 = {
  53         "OK-Integer1",
  54         "OK-Integer1",
  55         &asn_OP_NativeInteger,
  56         asn_DEF_OK_Integer1_tags_1,
  57         sizeof(asn_DEF_OK_Integer1_tags_1)
  58                 /sizeof(asn_DEF_OK_Integer1_tags_1[0]), /* 1 */
  59         asn_DEF_OK_Integer1_tags_1,     /* Same as above */
  60         sizeof(asn_DEF_OK_Integer1_tags_1)
  61                 /sizeof(asn_DEF_OK_Integer1_tags_1[0]), /* 1 */
  62         { 0, 0, OK_Integer1_constraint },
  63         0, 0,   /* No members */
  64         0       /* No specifics */
  65 };
  66
  67
  68 /*** <<< INCLUDES [OK-Integer2] >>> ***/
  69
  70 #include <NativeInteger.h>
  71
  72 /*** <<< TYPE-DECLS [OK-Integer2] >>> ***/
  73
  74 typedef long     OK_Integer2_t;
  75
  76 /*** <<< FUNC-DECLS [OK-Integer2] >>> ***/
  77
  78 extern asn_TYPE_descriptor_t asn_DEF_OK_Integer2;
  79 asn_struct_free_f OK_Integer2_free;
  80 asn_struct_print_f OK_Integer2_print;
  81 asn_constr_check_f OK_Integer2_constraint;
  82 ber_type_decoder_f OK_Integer2_decode_ber;
  83 der_type_encoder_f OK_Integer2_encode_der;
  84 xer_type_decoder_f OK_Integer2_decode_xer;
  85 xer_type_encoder_f OK_Integer2_encode_xer;
  86
  87 /*** <<< CODE [OK-Integer2] >>> ***/
  88
  89 int
  90 OK_Integer2_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
  91                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
  92
  93         if(!sptr) {
  94                 ASN__CTFAIL(app_key, td, sptr,
  95                         "%s: value not given (%s:%d)",
  96                         td->name, __FILE__, __LINE__);
  97                 return -1;
  98         }
  99
 100
 101         if(1 /* No applicable constraints whatsoever */) {
 102                 /* Nothing is here. See below */
 103         }
 104
 105         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 106 }
 107
 108 /*
 109  * This type is implemented using NativeInteger,
 110  * so here we adjust the DEF accordingly.
 111  */
 112
 113 /*** <<< STAT-DEFS [OK-Integer2] >>> ***/
 114
 115 static const ber_tlv_tag_t asn_DEF_OK_Integer2_tags_1[] = {
 116         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 117 };
 118 asn_TYPE_descriptor_t asn_DEF_OK_Integer2 = {
 119         "OK-Integer2",
 120         "OK-Integer2",
 121         &asn_OP_NativeInteger,
 122         asn_DEF_OK_Integer2_tags_1,
 123         sizeof(asn_DEF_OK_Integer2_tags_1)
 124                 /sizeof(asn_DEF_OK_Integer2_tags_1[0]), /* 1 */
 125         asn_DEF_OK_Integer2_tags_1,     /* Same as above */
 126         sizeof(asn_DEF_OK_Integer2_tags_1)
 127                 /sizeof(asn_DEF_OK_Integer2_tags_1[0]), /* 1 */
 128         { 0, 0, OK_Integer2_constraint },
 129         0, 0,   /* No members */
 130         0       /* No specifics */
 131 };
 132
 133
 134 /*** <<< INCLUDES [OK-Integer3] >>> ***/
 135
 136 #include <NativeInteger.h>
 137
 138 /*** <<< TYPE-DECLS [OK-Integer3] >>> ***/
 139
 140 typedef long     OK_Integer3_t;
 141
 142 /*** <<< FUNC-DECLS [OK-Integer3] >>> ***/
 143
 144 extern asn_TYPE_descriptor_t asn_DEF_OK_Integer3;
 145 asn_struct_free_f OK_Integer3_free;
 146 asn_struct_print_f OK_Integer3_print;
 147 asn_constr_check_f OK_Integer3_constraint;
 148 ber_type_decoder_f OK_Integer3_decode_ber;
 149 der_type_encoder_f OK_Integer3_encode_der;
 150 xer_type_decoder_f OK_Integer3_decode_xer;
 151 xer_type_encoder_f OK_Integer3_encode_xer;
 152
 153 /*** <<< CODE [OK-Integer3] >>> ***/
 154
 155 int
 156 OK_Integer3_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 157                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 158
 159         if(!sptr) {
 160                 ASN__CTFAIL(app_key, td, sptr,
 161                         "%s: value not given (%s:%d)",
 162                         td->name, __FILE__, __LINE__);
 163                 return -1;
 164         }
 165
 166
 167         if(1 /* No applicable constraints whatsoever */) {
 168                 /* Nothing is here. See below */
 169         }
 170
 171         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 172 }
 173
 174 /*
 175  * This type is implemented using NativeInteger,
 176  * so here we adjust the DEF accordingly.
 177  */
 178
 179 /*** <<< STAT-DEFS [OK-Integer3] >>> ***/
 180
 181 static const ber_tlv_tag_t asn_DEF_OK_Integer3_tags_1[] = {
 182         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 183 };
 184 asn_TYPE_descriptor_t asn_DEF_OK_Integer3 = {
 185         "OK-Integer3",
 186         "OK-Integer3",
 187         &asn_OP_NativeInteger,
 188         asn_DEF_OK_Integer3_tags_1,
 189         sizeof(asn_DEF_OK_Integer3_tags_1)
 190                 /sizeof(asn_DEF_OK_Integer3_tags_1[0]), /* 1 */
 191         asn_DEF_OK_Integer3_tags_1,     /* Same as above */
 192         sizeof(asn_DEF_OK_Integer3_tags_1)
 193                 /sizeof(asn_DEF_OK_Integer3_tags_1[0]), /* 1 */
 194         { 0, 0, OK_Integer3_constraint },
 195         0, 0,   /* No members */
 196         0       /* No specifics */
 197 };
 198
 199
 200 /*** <<< INCLUDES [OK-Integer4] >>> ***/
 201
 202 #include <NativeInteger.h>
 203
 204 /*** <<< TYPE-DECLS [OK-Integer4] >>> ***/
 205
 206 typedef long     OK_Integer4_t;
 207
 208 /*** <<< FUNC-DECLS [OK-Integer4] >>> ***/
 209
 210 extern asn_TYPE_descriptor_t asn_DEF_OK_Integer4;
 211 asn_struct_free_f OK_Integer4_free;
 212 asn_struct_print_f OK_Integer4_print;
 213 asn_constr_check_f OK_Integer4_constraint;
 214 ber_type_decoder_f OK_Integer4_decode_ber;
 215 der_type_encoder_f OK_Integer4_encode_der;
 216 xer_type_decoder_f OK_Integer4_decode_xer;
 217 xer_type_encoder_f OK_Integer4_encode_xer;
 218
 219 /*** <<< CODE [OK-Integer4] >>> ***/
 220
 221 int
 222 OK_Integer4_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 223                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 224
 225         if(!sptr) {
 226                 ASN__CTFAIL(app_key, td, sptr,
 227                         "%s: value not given (%s:%d)",
 228                         td->name, __FILE__, __LINE__);
 229                 return -1;
 230         }
 231
 232
 233         if(1 /* No applicable constraints whatsoever */) {
 234                 /* Nothing is here. See below */
 235         }
 236
 237         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 238 }
 239
 240 /*
 241  * This type is implemented using NativeInteger,
 242  * so here we adjust the DEF accordingly.
 243  */
 244
 245 /*** <<< STAT-DEFS [OK-Integer4] >>> ***/
 246
 247 static const ber_tlv_tag_t asn_DEF_OK_Integer4_tags_1[] = {
 248         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 249 };
 250 asn_TYPE_descriptor_t asn_DEF_OK_Integer4 = {
 251         "OK-Integer4",
 252         "OK-Integer4",
 253         &asn_OP_NativeInteger,
 254         asn_DEF_OK_Integer4_tags_1,
 255         sizeof(asn_DEF_OK_Integer4_tags_1)
 256                 /sizeof(asn_DEF_OK_Integer4_tags_1[0]), /* 1 */
 257         asn_DEF_OK_Integer4_tags_1,     /* Same as above */
 258         sizeof(asn_DEF_OK_Integer4_tags_1)
 259                 /sizeof(asn_DEF_OK_Integer4_tags_1[0]), /* 1 */
 260         { 0, 0, OK_Integer4_constraint },
 261         0, 0,   /* No members */
 262         0       /* No specifics */
 263 };
 264
 265
 266 /*** <<< INCLUDES [NO-Integer5] >>> ***/
 267
 268 #include <NativeInteger.h>
 269
 270 /*** <<< TYPE-DECLS [NO-Integer5] >>> ***/
 271
 272 typedef long     NO_Integer5_t;
 273
 274 /*** <<< FUNC-DECLS [NO-Integer5] >>> ***/
 275
 276 extern asn_TYPE_descriptor_t asn_DEF_NO_Integer5;
 277 asn_struct_free_f NO_Integer5_free;
 278 asn_struct_print_f NO_Integer5_print;
 279 asn_constr_check_f NO_Integer5_constraint;
 280 ber_type_decoder_f NO_Integer5_decode_ber;
 281 der_type_encoder_f NO_Integer5_encode_der;
 282 xer_type_decoder_f NO_Integer5_decode_xer;
 283 xer_type_encoder_f NO_Integer5_encode_xer;
 284
 285 /*** <<< CODE [NO-Integer5] >>> ***/
 286
 287 int
 288 NO_Integer5_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
 289                         asn_app_constraint_failed_f *ctfailcb, void *app_key) {
 290
 291         if(!sptr) {
 292                 ASN__CTFAIL(app_key, td, sptr,
 293                         "%s: value not given (%s:%d)",
 294                         td->name, __FILE__, __LINE__);
 295                 return -1;
 296         }
 297
 298
 299         if(1 /* No applicable constraints whatsoever */) {
 300                 /* Nothing is here. See below */
 301         }
 302
 303         return td->encoding_constraints.general_constraints(td, sptr, ctfailcb, app_key);
 304 }
 305
 306 /*
 307  * This type is implemented using NativeInteger,
 308  * so here we adjust the DEF accordingly.
 309  */
 310
 311 /*** <<< STAT-DEFS [NO-Integer5] >>> ***/
 312
 313 static const ber_tlv_tag_t asn_DEF_NO_Integer5_tags_1[] = {
 314         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 315 };
 316 asn_TYPE_descriptor_t asn_DEF_NO_Integer5 = {
 317         "NO-Integer5",
 318         "NO-Integer5",
 319         &asn_OP_NativeInteger,
 320         asn_DEF_NO_Integer5_tags_1,
 321         sizeof(asn_DEF_NO_Integer5_tags_1)
 322                 /sizeof(asn_DEF_NO_Integer5_tags_1[0]), /* 1 */
 323         asn_DEF_NO_Integer5_tags_1,     /* Same as above */
 324         sizeof(asn_DEF_NO_Integer5_tags_1)
 325                 /sizeof(asn_DEF_NO_Integer5_tags_1[0]), /* 1 */
 326         { 0, 0, NO_Integer5_constraint },
 327         0, 0,   /* No members */
 328         0       /* No specifics */
 329 };
 330