Add subscriptions (to replace notifiers).

[stg.git] / libs / smux / constr_SET_OF.c

diff --git a/libs/smux/constr_SET_OF.c b/libs/smux/constr_SET_OF.c
index 0d5efa4f83c189887822f4012fd2a500faf04ae4..2dbc6e518846e3f9ce6eeef9b6e12d3d28c3e5b2 100644 (file)
--- a/libs/smux/constr_SET_OF.c
+++ b/libs/smux/constr_SET_OF.c
@@ -227,6 +227,8 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        }
                        /* Fall through */
                case RC_FAIL: /* Fatal error */
                        }
                        /* Fall through */
                case RC_FAIL: /* Fatal error */

+                       ASN_STRUCT_FREE(*elm->type, ctx->ptr);
+                       ctx->ptr = 0;

                        RETURN(RC_FAIL);
                } /* switch(rval) */
                
                        RETURN(RC_FAIL);
                } /* switch(rval) */
                


@@ -357,7 +359,7 @@ SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
 
        if(!cb || list->count == 0) {
                erval.encoded = computed_size;
 
        if(!cb || list->count == 0) {
                erval.encoded = computed_size;

-               _ASN_ENCODED_OK(erval);
+               ASN__ENCODED_OK(erval);

        }
 
        /*
        }
 
        /*


@@ -449,7 +451,7 @@ SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
                erval.encoded = computed_size;
        }
 
                erval.encoded = computed_size;
        }
 

-       _ASN_ENCODED_OK(erval);
+       ASN__ENCODED_OK(erval);

 }
 
 #undef XER_ADVANCE
 }
 
 #undef XER_ADVANCE


@@ -547,11 +549,12 @@ SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                 */
                ch_size = xer_next_token(&ctx->context,
                        buf_ptr, size, &ch_type);
                 */
                ch_size = xer_next_token(&ctx->context,
                        buf_ptr, size, &ch_type);

-               switch(ch_size) {
-               case -1: RETURN(RC_FAIL);
-               case 0:  RETURN(RC_WMORE);
-               default:
+               if(ch_size == -1) {
+            RETURN(RC_FAIL);
+        } else {

                        switch(ch_type) {
                        switch(ch_type) {

+            case PXER_WMORE:
+                RETURN(RC_WMORE);

                        case PXER_COMMENT:      /* Got XML comment */
                        case PXER_TEXT:         /* Ignore free-standing text */
                                XER_ADVANCE(ch_size);   /* Skip silently */
                        case PXER_COMMENT:      /* Got XML comment */
                        case PXER_TEXT:         /* Ignore free-standing text */
                                XER_ADVANCE(ch_size);   /* Skip silently */


@@ -665,11 +668,11 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
        asn_app_consume_bytes_f *original_cb = cb;
        int i;
 
        asn_app_consume_bytes_f *original_cb = cb;
        int i;
 

-       if(!sptr) _ASN_ENCODE_FAILED;
+       if(!sptr) ASN__ENCODE_FAILED;

 
        if(xcan) {
                encs = (xer_tmp_enc_t *)MALLOC(list->count * sizeof(encs[0]));
 
        if(xcan) {
                encs = (xer_tmp_enc_t *)MALLOC(list->count * sizeof(encs[0]));

-               if(!encs) _ASN_ENCODE_FAILED;
+               if(!encs) ASN__ENCODE_FAILED;

                cb = SET_OF_encode_xer_callback;
        }
 
                cb = SET_OF_encode_xer_callback;
        }
 


@@ -688,12 +691,12 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                }
 
                if(mname) {
                }
 
                if(mname) {

-                       if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel);
-                       _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
+                       if(!xcan) ASN__TEXT_INDENT(1, ilevel);
+                       ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);

                }
 
                if(!xcan && specs->as_XMLValueList == 1)
                }
 
                if(!xcan && specs->as_XMLValueList == 1)

-                       _i_ASN_TEXT_INDENT(1, ilevel + 1);
+                       ASN__TEXT_INDENT(1, ilevel + 1);

                tmper = elm->type->xer_encoder(elm->type, memb_ptr,
                                ilevel + (specs->as_XMLValueList != 2),
                                flags, cb, app_key);
                tmper = elm->type->xer_encoder(elm->type, memb_ptr,
                                ilevel + (specs->as_XMLValueList != 2),
                                flags, cb, app_key);


@@ -705,18 +708,18 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                if(tmper.encoded == 0 && specs->as_XMLValueList) {
                        const char *name = elm->type->xml_tag;
                        size_t len = strlen(name);
                if(tmper.encoded == 0 && specs->as_XMLValueList) {
                        const char *name = elm->type->xml_tag;
                        size_t len = strlen(name);

-                       _ASN_CALLBACK3("<", 1, name, len, "/>", 2);
+                       ASN__CALLBACK3("<", 1, name, len, "/>", 2);

                }
 
                if(mname) {
                }
 
                if(mname) {

-                       _ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
+                       ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);

                        er.encoded += 5;
                }
 
                er.encoded += (2 * mlen) + tmper.encoded;
        }
 
                        er.encoded += 5;
                }
 
                er.encoded += (2 * mlen) + tmper.encoded;
        }
 

-       if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
+       if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);

 
        if(encs) {
                xer_tmp_enc_t *enc = encs;
 
        if(encs) {
                xer_tmp_enc_t *enc = encs;


@@ -728,7 +731,7 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);
 
                for(; enc < end; enc++) {
                qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);
 
                for(; enc < end; enc++) {

-                       _ASN_CALLBACK(enc->buffer, enc->offset);
+                       ASN__CALLBACK(enc->buffer, enc->offset);

                        FREEMEM(enc->buffer);
                        enc->buffer = 0;
                        control_size += enc->offset;
                        FREEMEM(enc->buffer);
                        enc->buffer = 0;
                        control_size += enc->offset;


@@ -749,7 +752,7 @@ cleanup:
                }
                FREEMEM(encs);
        }
                }
                FREEMEM(encs);
        }

-       _ASN_ENCODED_OK(er);
+       ASN__ENCODED_OK(er);

 }
 
 int
 }
 
 int


@@ -787,8 +790,10 @@ SET_OF_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 void
 SET_OF_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
        if(td && ptr) {
 void
 SET_OF_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
        if(td && ptr) {

+               asn_SET_OF_specifics_t *specs;

                asn_TYPE_member_t *elm = td->elements;
                asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);
                asn_TYPE_member_t *elm = td->elements;
                asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);

+               asn_struct_ctx_t *ctx;  /* Decoder context */

                int i;
 
                /*
                int i;
 
                /*


@@ -804,6 +809,13 @@ SET_OF_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
 
                asn_set_empty(list);    /* Remove (list->array) */
 
 
                asn_set_empty(list);    /* Remove (list->array) */
 

+               specs = (asn_SET_OF_specifics_t *)td->specifics;
+               ctx = (asn_struct_ctx_t *)((char *)ptr + specs->ctx_offset);
+               if(ctx->ptr) {
+                       ASN_STRUCT_FREE(*elm->type, ctx->ptr);
+                       ctx->ptr = 0;
+               }
+

                if(!contents_only) {
                        FREEMEM(ptr);
                }
                if(!contents_only) {
                        FREEMEM(ptr);
                }


@@ -819,7 +831,7 @@ SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
        int i;
 
        if(!sptr) {
        int i;
 
        if(!sptr) {

-               _ASN_CTFAIL(app_key, td,
+               ASN__CTFAIL(app_key, td, sptr,

                        "%s: value not given (%s:%d)",
                        td->name, __FILE__, __LINE__);
                return -1;
                        "%s: value not given (%s:%d)",
                        td->name, __FILE__, __LINE__);
                return -1;


@@ -864,15 +876,15 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        int repeat = 0;
        ssize_t nelems;
 
        int repeat = 0;
        ssize_t nelems;
 

-       if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
-               _ASN_DECODE_FAILED;
+       if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
+               ASN__DECODE_FAILED;

 
        /*
         * Create the target structure if it is not present already.
         */
        if(!st) {
                st = *sptr = CALLOC(1, specs->struct_size);
 
        /*
         * Create the target structure if it is not present already.
         */
        if(!st) {
                st = *sptr = CALLOC(1, specs->struct_size);

-               if(!st) _ASN_DECODE_FAILED;
+               if(!st) ASN__DECODE_FAILED;

        }                                                                       
        list = _A_SET_FROM_VOID(st);
 
        }                                                                       
        list = _A_SET_FROM_VOID(st);
 


@@ -883,7 +895,7 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
                int value = per_get_few_bits(pd, 1);
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
                int value = per_get_few_bits(pd, 1);

-               if(value < 0) _ASN_DECODE_STARVED;
+               if(value < 0) ASN__DECODE_STARVED;

                if(value) ct = 0;       /* Not restricted! */
        }
 
                if(value) ct = 0;       /* Not restricted! */
        }
 


@@ -892,7 +904,7 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                nelems = per_get_few_bits(pd, ct->effective_bits);
                ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",
                        (long)nelems, ct->lower_bound, td->name);
                nelems = per_get_few_bits(pd, ct->effective_bits);
                ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",
                        (long)nelems, ct->lower_bound, td->name);

-               if(nelems < 0)  _ASN_DECODE_STARVED;
+               if(nelems < 0)  ASN__DECODE_STARVED;

                nelems += ct->lower_bound;
        } else {
                nelems = -1;
                nelems += ct->lower_bound;
        } else {
                nelems = -1;


@@ -904,8 +916,8 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        nelems = uper_get_length(pd,
                                ct ? ct->effective_bits : -1, &repeat);
                        ASN_DEBUG("Got to decode %d elements (eff %d)",
                        nelems = uper_get_length(pd,
                                ct ? ct->effective_bits : -1, &repeat);
                        ASN_DEBUG("Got to decode %d elements (eff %d)",

-                               (int)nelems, ct ? ct->effective_bits : -1);
-                       if(nelems < 0) _ASN_DECODE_STARVED;
+                               (int)nelems, (int)(ct ? ct->effective_bits : -1));
+                       if(nelems < 0) ASN__DECODE_STARVED;

                }
 
                for(i = 0; i < nelems; i++) {
                }
 
                for(i = 0; i < nelems; i++) {