Add jer equivalent for each file-dependencies

skeletons/BIT_STRING_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <BIT_STRING.h>
+
+static const char *_bit_pattern[16] = {
+    "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
+    "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
+};
+
+asn_enc_rval_t
+BIT_STRING_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                      int ilevel, enum jer_encoder_flags_e flags,
+                      asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t er = {0, 0, 0};
+    char scratch[128];
+    char *p = scratch;
+    char *scend = scratch + (sizeof(scratch) - 10);
+    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+    int xcan = (flags & JER_F_CANONICAL);
+    uint8_t *buf;
+    uint8_t *end;
+
+    if(!st || !st->buf)
+        ASN__ENCODE_FAILED;
+
+    er.encoded = 0;
+
+    buf = st->buf;
+    end = buf + st->size - 1;  /* Last byte is special */
+
+    /*
+     * Binary dump
+     */
+    for(; buf < end; buf++) {
+        int v = *buf;
+        int nline = xcan?0:(((buf - st->buf) % 8) == 0);
+        if(p >= scend || nline) {
+            ASN__CALLBACK(scratch, p - scratch);
+            p = scratch;
+            if(nline) ASN__TEXT_INDENT(1, ilevel);
+        }
+        memcpy(p + 0, _bit_pattern[v >> 4], 4);
+        memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+        p += 8;
+    }
+
+    if(!xcan && ((buf - st->buf) % 8) == 0)
+        ASN__TEXT_INDENT(1, ilevel);
+    ASN__CALLBACK(scratch, p - scratch);
+    p = scratch;
+
+    if(buf == end) {
+        int v = *buf;
+        int ubits = st->bits_unused;
+        int i;
+        for(i = 7; i >= ubits; i--)
+            *p++ = (v & (1 << i)) ? 0x31 : 0x30;
+        ASN__CALLBACK(scratch, p - scratch);
+    }
+
+    if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+
+    ASN__ENCODED_OK(er);
+cb_failed:
+    ASN__ENCODE_FAILED;
+}

skeletons/BMPString_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <BMPString.h>
+#include <UTF8String.h>
+
+
+asn_enc_rval_t
+BMPString_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                     int ilevel, enum jer_encoder_flags_e flags,
+                     asn_app_consume_bytes_f *cb, void *app_key) {
+    const BMPString_t *st = (const BMPString_t *)sptr;
+    asn_enc_rval_t er = {0,0,0};
+
+    (void)ilevel;
+    (void)flags;
+
+    if(!st || !st->buf)
+        ASN__ENCODE_FAILED;
+
+    er.encoded = BMPString__dump(st, cb, app_key);
+    if(er.encoded < 0) ASN__ENCODE_FAILED;
+
+    ASN__ENCODED_OK(er);
+}

skeletons/GeneralizedTime_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <GeneralizedTime.h>
+
+#ifdef	__CYGWIN__
+#include "/usr/include/time.h"
+#else
+#include <time.h>
+#endif	/* __CYGWIN__ */
+
+#include <errno.h>
+
+#if !defined(ASN___INTERNAL_TEST_MODE)
+asn_enc_rval_t
+GeneralizedTime_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                           int ilevel, enum jer_encoder_flags_e flags,
+                           asn_app_consume_bytes_f *cb, void *app_key) {
+    if(flags & JER_F_CANONICAL) {
+        GeneralizedTime_t *gt;
+        asn_enc_rval_t rv;
+        int fv, fd;  /* fractional parts */
+        struct tm tm;
+
+        errno = EPERM;
+        if(asn_GT2time_frac((const GeneralizedTime_t *)sptr,
+                &fv, &fd, &tm, 1) == -1
+                && errno != EPERM)
+            ASN__ENCODE_FAILED;
+
+        gt = asn_time2GT_frac(0, &tm, fv, fd, 1);
+        if(!gt) ASN__ENCODE_FAILED;
+
+        rv = OCTET_STRING_encode_jer_utf8(td, sptr, ilevel, flags,
+                                          cb, app_key);
+        ASN_STRUCT_FREE(asn_DEF_GeneralizedTime, gt);
+        return rv;
+    } else {
+        return OCTET_STRING_encode_jer_utf8(td, sptr, ilevel, flags,
+                                            cb, app_key);
+    }
+}
+#endif  /* !defined(ASN___INTERNAL_TEST_MODE) */

skeletons/NULL_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+#include <NULL.h>
+
+asn_enc_rval_t
+NULL_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+                enum jer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
+                void *app_key) {
+    asn_enc_rval_t er = {0,0,0};
+
+    (void)td;
+    (void)sptr;
+    (void)ilevel;
+    (void)flags;
+    (void)cb;
+    (void)app_key;
+
+    /* XMLNullValue is empty */
+    er.encoded = 0;
+    ASN__ENCODED_OK(er);
+}
+
+
+static enum jer_pbd_rval
+NULL__jer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                      const void *chunk_buf, size_t chunk_size) {
+    (void)td;
+    (void)sptr;
+    (void)chunk_buf;  /* Going to be empty according to the rules below. */
+
+    /*
+     * There must be no content in self-terminating <NULL/> tag.
+     */
+    if(chunk_size)
+        return XPBD_BROKEN_ENCODING;
+    else
+        return XPBD_BODY_CONSUMED;
+}
+
+asn_dec_rval_t
+NULL_decode_jer(const asn_codec_ctx_t *opt_codec_ctx,
+                const asn_TYPE_descriptor_t *td, void **sptr,
+                const char *opt_mname, const void *buf_ptr, size_t size) {
+    return jer_decode_primitive(opt_codec_ctx, td,
+        sptr, sizeof(NULL_t), opt_mname, buf_ptr, size,
+        NULL__jer_body_decode);
+}

skeletons/NativeEnumerated_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <NativeEnumerated.h>
+
+asn_enc_rval_t
+NativeEnumerated_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                            int ilevel, enum jer_encoder_flags_e flags,
+                            asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_enc_rval_t er = {0,0,0};
+    const long *native = (const long *)sptr;
+    const asn_INTEGER_enum_map_t *el;
+
+    (void)ilevel;
+    (void)flags;
+
+    if(!native) ASN__ENCODE_FAILED;
+
+    el = INTEGER_map_value2enum(specs, *native);
+    if(el) {
+        er.encoded =
+            asn__format_to_callback(cb, app_key, "<%s/>", el->enum_name);
+        if(er.encoded < 0) ASN__ENCODE_FAILED;
+        ASN__ENCODED_OK(er);
+    } else {
+        ASN_DEBUG(
+            "ASN.1 forbids dealing with "
+            "unknown value of ENUMERATED type");
+        ASN__ENCODE_FAILED;
+    }
+}

skeletons/OBJECT_IDENTIFIER_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OBJECT_IDENTIFIER.h>
+
+static enum jer_pbd_rval
+OBJECT_IDENTIFIER__jer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                                   const void *chunk_buf, size_t chunk_size) {
+    OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
+    const char *chunk_end = (const char *)chunk_buf + chunk_size;
+    const char *endptr;
+    asn_oid_arc_t s_arcs[10];
+    asn_oid_arc_t *arcs = s_arcs;
+    ssize_t num_arcs;
+    ssize_t ret;
+
+    (void)td;
+
+    num_arcs = OBJECT_IDENTIFIER_parse_arcs(
+        (const char *)chunk_buf, chunk_size, arcs,
+        sizeof(s_arcs) / sizeof(s_arcs[0]), &endptr);
+    if(num_arcs < 0) {
+        /* Expecting more than zero arcs */
+        return XPBD_BROKEN_ENCODING;
+    } else if(num_arcs == 0) {
+        return XPBD_NOT_BODY_IGNORE;
+    }
+    (void)chunk_end;
+    assert(endptr == chunk_end);
+
+    if((size_t)num_arcs > sizeof(s_arcs)/sizeof(s_arcs[0])) {
+        arcs = (asn_oid_arc_t *)MALLOC(num_arcs * sizeof(asn_oid_arc_t));
+        if(!arcs) return XPBD_SYSTEM_FAILURE;
+        ret = OBJECT_IDENTIFIER_parse_arcs((const char *)chunk_buf, chunk_size,
+                                           arcs, num_arcs, &endptr);
+        if(ret != num_arcs)
+            return XPBD_SYSTEM_FAILURE;  /* assert?.. */
+    }
+
+    /*
+     * Convert arcs into BER representation.
+     */
+    ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, num_arcs);
+    if(arcs != s_arcs) FREEMEM(arcs);
+
+    return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
+}
+
+asn_dec_rval_t
+OBJECT_IDENTIFIER_decode_jer(const asn_codec_ctx_t *opt_codec_ctx,
+                             const asn_TYPE_descriptor_t *td, void **sptr,
+                             const char *opt_mname, const void *buf_ptr,
+                             size_t size) {
+    return jer_decode_primitive(opt_codec_ctx, td,
+        sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
+            buf_ptr, size, OBJECT_IDENTIFIER__jer_body_decode);
+}
+
+asn_enc_rval_t
+OBJECT_IDENTIFIER_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                             int ilevel, enum jer_encoder_flags_e flags,
+                             asn_app_consume_bytes_f *cb, void *app_key) {
+    const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+    asn_enc_rval_t er = {0,0,0};
+
+    (void)ilevel;
+    (void)flags;
+
+    if(!st || !st->buf) {
+        ASN__ENCODE_FAILED;
+    }
+
+    er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
+    if(er.encoded < 0) ASN__ENCODE_FAILED;
+
+    ASN__ENCODED_OK(er);
+}

skeletons/OPEN_TYPE_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OPEN_TYPE.h>
+#include <constr_CHOICE.h>
+
+asn_dec_rval_t
+OPEN_TYPE_jer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void *sptr,
+                  const asn_TYPE_member_t *elm, const void *ptr, size_t size) {
+    size_t consumed_myself = 0;
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    int jer_context = 0;
+    ssize_t ch_size;
+    pjer_chunk_type_e ch_type;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    assert(elm->flags == ATF_OPEN_TYPE);
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
+           != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    /*
+     * Confirm wrapper.
+     */
+    for(;;) {
+        ch_size = jer_next_token(&jer_context, ptr, size, &ch_type);
+        if(ch_size < 0) {
+            ASN__DECODE_FAILED;
+        } else {
+            switch(ch_type) {
+            case PJER_WMORE:
+                ASN__DECODE_STARVED;
+            case PJER_COMMENT:
+            case PJER_TEXT:
+                ADVANCE(ch_size);
+                continue;
+            case PJER_TAG:
+                break;
+            }
+            break;
+        }
+    }
+
+    /*
+     * Wrapper value confirmed.
+     */
+    switch(jer_check_tag(ptr, ch_size, elm->name)) {
+    case XCT_OPENING:
+        ADVANCE(ch_size);
+        break;
+    case XCT_BROKEN:
+    default:
+        ASN__DECODE_FAILED;
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    rv = selected.type_descriptor->op->jer_decoder(
+        opt_codec_ctx, selected.type_descriptor, &inner_value, NULL, ptr, size);
+    ADVANCE(rv.consumed);
+    rv.consumed = 0;
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            break;
+        } else {
+            rv.code = RC_FAIL;
+        }
+        /* Fall through */
+    case RC_FAIL:
+        /* Point to a best position where failure occurred */
+        rv.consumed = consumed_myself;
+        /* Fall through */
+    case RC_WMORE:
+        /* Wrt. rv.consumed==0:
+         * In case a genuine RC_WMORE, the whole Open Type decoding
+         * will have to be restarted.
+         */
+        if(*memb_ptr2) {
+            if(elm->flags & ATF_POINTER) {
+                ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+                *memb_ptr2 = NULL;
+            } else {
+                ASN_STRUCT_RESET(*selected.type_descriptor,
+                                              inner_value);
+            }
+        }
+        return rv;
+    }
+
+    /*
+     * Finalize wrapper.
+     */
+    for(;;) {
+        ch_size = jer_next_token(&jer_context, ptr, size, &ch_type);
+        if(ch_size < 0) {
+            ASN__DECODE_FAILED;
+        } else {
+            switch(ch_type) {
+            case PJER_WMORE:
+                ASN__DECODE_STARVED;
+            case PJER_COMMENT:
+            case PJER_TEXT:
+                ADVANCE(ch_size);
+                continue;
+            case PJER_TAG:
+                break;
+            }
+            break;
+        }
+    }
+
+    /*
+     * Wrapper value confirmed.
+     */
+    switch(jer_check_tag(ptr, ch_size, elm->name)) {
+    case XCT_CLOSING:
+        ADVANCE(ch_size);
+        break;
+    case XCT_BROKEN:
+    default:
+        ASN__DECODE_FAILED;
+    }
+
+    rv.consumed += consumed_myself;
+
+    return rv;
+}

skeletons/RELATIVE-OID_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <RELATIVE-OID.h>
+
+static enum jer_pbd_rval
+RELATIVE_OID__jer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                              const void *chunk_buf, size_t chunk_size) {
+    RELATIVE_OID_t *st = (RELATIVE_OID_t *)sptr;
+    const char *chunk_end = (const char *)chunk_buf + chunk_size;
+    const char *endptr;
+    asn_oid_arc_t s_arcs[6];
+    asn_oid_arc_t *arcs = s_arcs;
+    ssize_t num_arcs;
+    int ret;
+
+    (void)td;
+
+    num_arcs = OBJECT_IDENTIFIER_parse_arcs(
+        (const char *)chunk_buf, chunk_size, arcs,
+        sizeof(s_arcs) / sizeof(s_arcs[0]), &endptr);
+    if(num_arcs < 0) {
+        /* Expecting at least one arc arcs */
+        return XPBD_BROKEN_ENCODING;
+    } else if(num_arcs == 0) {
+        return XPBD_NOT_BODY_IGNORE;
+    }
+    assert(endptr == chunk_end);
+
+    if((size_t)num_arcs > sizeof(s_arcs) / sizeof(s_arcs[0])) {
+        arcs = (asn_oid_arc_t *)MALLOC(num_arcs * sizeof(arcs[0]));
+        if(!arcs) return XPBD_SYSTEM_FAILURE;
+        ret = OBJECT_IDENTIFIER_parse_arcs((const char *)chunk_buf, chunk_size,
+                                           arcs, num_arcs, &endptr);
+        if(ret != num_arcs) {
+            return XPBD_SYSTEM_FAILURE;  /* assert?.. */
+        }
+    }
+
+    /*
+     * Convert arcs into BER representation.
+     */
+    ret = RELATIVE_OID_set_arcs(st, arcs, num_arcs);
+    if(arcs != s_arcs) FREEMEM(arcs);
+
+    return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
+}
+
+asn_dec_rval_t
+RELATIVE_OID_decode_jer(const asn_codec_ctx_t *opt_codec_ctx,
+                        const asn_TYPE_descriptor_t *td, void **sptr,
+                        const char *opt_mname, const void *buf_ptr,
+                        size_t size) {
+    return jer_decode_primitive(opt_codec_ctx, td,
+                                sptr, sizeof(RELATIVE_OID_t), opt_mname,
+                                buf_ptr, size, RELATIVE_OID__jer_body_decode);
+}
+
+asn_enc_rval_t
+RELATIVE_OID_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                        int ilevel, enum jer_encoder_flags_e flags,
+                        asn_app_consume_bytes_f *cb, void *app_key) {
+    const RELATIVE_OID_t *st = (const RELATIVE_OID_t *)sptr;
+    asn_enc_rval_t er = {0,0,0};
+
+    (void)ilevel;  /* Unused argument */
+    (void)flags;  /* Unused argument */
+
+    if(!st || !st->buf)
+        ASN__ENCODE_FAILED;
+
+    er.encoded = RELATIVE_OID__dump_body(st, cb, app_key);
+    if(er.encoded < 0) ASN__ENCODE_FAILED;
+
+    ASN__ENCODED_OK(er);
+}

skeletons/UTCTime_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <UTCTime.h>
+#include <errno.h>
+
+#ifdef __CYGWIN__
+#include "/usr/include/time.h"
+#else
+#include <time.h>
+#endif  /* __CYGWIN__ */
+
+#if !defined(ASN___INTERNAL_TEST_MODE)
+
+asn_enc_rval_t
+UTCTime_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                   int ilevel, enum jer_encoder_flags_e flags,
+                   asn_app_consume_bytes_f *cb, void *app_key) {
+    if(flags & JER_F_CANONICAL) {
+        asn_enc_rval_t rv;
+        UTCTime_t *ut;
+        struct tm tm;
+
+        errno = EPERM;
+        if(asn_UT2time((const UTCTime_t *)sptr, &tm, 1) == -1
+        && errno != EPERM)
+            ASN__ENCODE_FAILED;
+
+        /* Fractions are not allowed in UTCTime */
+        ut = asn_time2UT(0, &tm, 1);
+        if(!ut) ASN__ENCODE_FAILED;
+
+        rv = OCTET_STRING_encode_jer_utf8(td, sptr, ilevel, flags,
+                                          cb, app_key);
+        OCTET_STRING_free(&asn_DEF_UTCTime, ut, 0);
+        return rv;
+    } else {
+        return OCTET_STRING_encode_jer_utf8(td, sptr, ilevel, flags,
+                                            cb, app_key);
+    }
+}
+
+#endif  /* !defined(ASN___INTERNAL_TEST_MODE) */

skeletons/UniversalString_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <UniversalString.h>
+#include <UTF8String.h>
+
+asn_dec_rval_t
+UniversalString_decode_jer(const asn_codec_ctx_t *opt_codec_ctx,
+                           const asn_TYPE_descriptor_t *td, void **sptr,
+                           const char *opt_mname, const void *buf_ptr,
+                           size_t size) {
+    asn_dec_rval_t rc;
+
+    rc = OCTET_STRING_decode_jer_utf8(opt_codec_ctx, td, sptr, opt_mname,
+                                      buf_ptr, size);
+    if(rc.code == RC_OK) {
+        /*
+         * Now we have a whole string in UTF-8 format.
+         * Convert it into UCS-4.
+         */
+        uint32_t *wcs;
+        size_t wcs_len;
+        UTF8String_t *st;
+#ifndef WORDS_BIGENDIAN
+        int little_endian = 1;
+#endif
+
+        assert(*sptr);
+        st = (UTF8String_t *)*sptr;
+        assert(st->buf);
+        wcs_len = UTF8String_to_wcs(st, 0, 0);
+
+        wcs = (uint32_t *)MALLOC(4 * (wcs_len + 1));
+        if(wcs == 0 || UTF8String_to_wcs(st, wcs, wcs_len) != wcs_len) {
+            rc.code = RC_FAIL;
+            rc.consumed = 0;
+            return rc;
+        } else {
+            wcs[wcs_len] = 0;  /* nul-terminate */
+        }
+
+#ifndef WORDS_BIGENDIAN
+        if(*(char *)&little_endian) {
+            /* Swap byte order in encoding */
+            uint32_t *wc = wcs;
+            uint32_t *wc_end = wcs + wcs_len;
+            for(; wc < wc_end; wc++) {
+                /* *wc = htonl(*wc); */
+                uint32_t wch = *wc;
+                *((uint8_t *)wc + 0) = wch >> 24;
+                *((uint8_t *)wc + 1) = wch >> 16;
+                *((uint8_t *)wc + 2) = wch >> 8;
+                *((uint8_t *)wc + 3) = wch;
+            }
+        }
+#endif  /* WORDS_BIGENDIAN */
+
+        FREEMEM(st->buf);
+        st->buf = (uint8_t *)wcs;
+        st->size = 4 * wcs_len;
+    }
+    return rc;
+}
+
+asn_enc_rval_t
+UniversalString_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                           int ilevel, enum jer_encoder_flags_e flags,
+                           asn_app_consume_bytes_f *cb, void *app_key) {
+    const UniversalString_t *st = (const UniversalString_t *)sptr;
+    asn_enc_rval_t er = {0,0,0};
+
+    (void)ilevel;
+    (void)flags;
+
+    if(!st || !st->buf)
+        ASN__ENCODE_FAILED;
+
+    er.encoded = UniversalString__dump(st, cb, app_key);
+    if(er.encoded < 0) ASN__ENCODE_FAILED;
+
+    ASN__ENCODED_OK(er);
+}

skeletons/asn_codecs_prim_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+
+/*
+ * Local internal type passed around as an argument.
+ */
+struct xdp_arg_s {
+    const asn_TYPE_descriptor_t *type_descriptor;
+    void *struct_key;
+    xer_primitive_body_decoder_f *prim_body_decoder;
+    int decoded_something;
+    int want_more;
+};
+
+/*
+ * Since some kinds of primitive values can be encoded using value-specific
+ * tags (<MINUS-INFINITY>, <enum-element>, etc), the primitive decoder must
+ * be supplied with such tags to parse them as needed.
+ */
+static int
+jer_decode__unexpected_tag(void *key, const void *chunk_buf, size_t chunk_size) {
+    struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
+    enum jer_pbd_rval bret;
+
+    /*
+     * The chunk_buf is guaranteed to start at '<'.
+     */
+    assert(chunk_size && ((const char *)chunk_buf)[0] == 0x3c);
+
+    /*
+     * Decoding was performed once already. Prohibit doing it again.
+    */
+    if(arg->decoded_something)
+        return -1;
+
+    bret = arg->prim_body_decoder(arg->type_descriptor,
+                                  arg->struct_key, chunk_buf,
+                                  chunk_size);
+    switch(bret) {
+    case XPBD_SYSTEM_FAILURE:
+    case XPBD_DECODER_LIMIT:
+    case XPBD_BROKEN_ENCODING:
+        break;
+    case XPBD_BODY_CONSUMED:
+        /* Tag decoded successfully */
+        arg->decoded_something = 1;
+        /* Fall through */
+    case XPBD_NOT_BODY_IGNORE:  /* Safe to proceed further */
+        return 0;
+    }
+
+    return -1;
+}
+
+static ssize_t
+jer_decode__primitive_body(void *key, const void *chunk_buf, size_t chunk_size, int have_more) {
+    struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
+    enum jer_pbd_rval bret;
+    size_t lead_wsp_size;
+
+    if(arg->decoded_something) {
+        if(jer_whitespace_span(chunk_buf, chunk_size) == chunk_size) {
+            /*
+             * Example:
+             * "<INTEGER>123<!--/--> </INTEGER>"
+             *                      ^- chunk_buf position.
+             */
+            return chunk_size;
+        }
+        /*
+         * Decoding was done once already. Prohibit doing it again.
+         */
+        return -1;
+    }
+
+    if(!have_more) {
+        /*
+         * If we've received something like "1", we can't really
+         * tell whether it is really `1` or `123`, until we know
+         * that there is no more data coming.
+         * The have_more argument will be set to 1 once something
+         * like this is available to the caller of this callback:
+         * "1<tag_start..."
+         */
+        arg->want_more = 1;
+        return -1;
+    }
+
+    lead_wsp_size = jer_whitespace_span(chunk_buf, chunk_size);
+    chunk_buf   = (chunk_buf == NULL)? NULL : ((const char *)chunk_buf + lead_wsp_size);
+    chunk_size -= lead_wsp_size;
+
+    bret = arg->prim_body_decoder(arg->type_descriptor,
+                                  arg->struct_key, chunk_buf,
+                                  chunk_size);
+    switch(bret) {
+    case XPBD_SYSTEM_FAILURE:
+    case XPBD_DECODER_LIMIT:
+    case XPBD_BROKEN_ENCODING:
+        break;
+    case XPBD_BODY_CONSUMED:
+        /* Tag decoded successfully */
+        arg->decoded_something = 1;
+        /* Fall through */
+    case XPBD_NOT_BODY_IGNORE:  /* Safe to proceed further */
+        return lead_wsp_size + chunk_size;
+    }
+
+    return -1;
+}
+
+asn_dec_rval_t
+jer_decode_primitive(const asn_codec_ctx_t *opt_codec_ctx,
+                     const asn_TYPE_descriptor_t *td, void **sptr,
+                     size_t struct_size, const char *opt_mname,
+                     const void *buf_ptr, size_t size,
+                     jer_primitive_body_decoder_f *prim_body_decoder) {
+    const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
+    asn_struct_ctx_t s_ctx;
+    struct xdp_arg_s s_arg;
+    asn_dec_rval_t rc;
+
+    /*
+     * Create the structure if does not exist.
+     */
+    if(!*sptr) {
+        *sptr = CALLOC(1, struct_size);
+        if(!*sptr) ASN__DECODE_FAILED;
+    }
+
+    memset(&s_ctx, 0, sizeof(s_ctx));
+    s_arg.type_descriptor = td;
+    s_arg.struct_key = *sptr;
+    s_arg.prim_body_decoder = prim_body_decoder;
+    s_arg.decoded_something = 0;
+    s_arg.want_more = 0;
+
+    rc = jer_decode_general(opt_codec_ctx, &s_ctx, &s_arg,
+                            xml_tag, buf_ptr, size,
+                            jer_decode__unexpected_tag,
+                            jer_decode__primitive_body);
+    switch(rc.code) {
+    case RC_OK:
+        if(!s_arg.decoded_something) {
+            char ch;
+            ASN_DEBUG("Primitive body is not recognized, "
+                      "supplying empty one");
+            /*
+             * Decoding opportunity has come and gone.
+             * Where's the result?
+             * Try to feed with empty body, see if it eats it.
+             */
+            if(prim_body_decoder(s_arg.type_descriptor,
+                s_arg.struct_key, &ch, 0)
+                    != XPBD_BODY_CONSUMED) {
+                /*
+                 * This decoder does not like empty stuff.
+                 */
+                ASN__DECODE_FAILED;
+            }
+        }
+        break;
+    case RC_WMORE:
+        /*
+         * Redo the whole thing later.
+         * We don't have a context to save intermediate parsing state.
+         */
+        rc.consumed = 0;
+        break;
+    case RC_FAIL:
+        rc.consumed = 0;
+        if(s_arg.want_more)
+            rc.code = RC_WMORE;
+        else
+            ASN__DECODE_FAILED;
+        break;
+    }
+    return rc;
+}

skeletons/constr_SEQUENCE_OF_jer.c

+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <constr_SEQUENCE_OF.h>
+#include <asn_SEQUENCE_OF.h>
+
+asn_enc_rval_t
+SEQUENCE_OF_encode_jer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                       int ilevel, enum jer_encoder_flags_e flags,
+                       asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t er = {0,0,0};
+    const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
+    const asn_TYPE_member_t *elm = td->elements;
+    const asn_anonymous_sequence_ *list = _A_CSEQUENCE_FROM_VOID(sptr);
+    const char *mname = specs->as_XMLValueList
+                            ? 0
+                            : ((*elm->name) ? elm->name : elm->type->xml_tag);
+    size_t mlen = mname ? strlen(mname) : 0;
+    int xcan = (flags & JER_F_CANONICAL);
+    int i;
+
+    if(!sptr) ASN__ENCODE_FAILED;
+
+    er.encoded = 0;
+
+    for(i = 0; i < list->count; i++) {
+        asn_enc_rval_t tmper = {0,0,0};
+        void *memb_ptr = list->array[i];
+        if(!memb_ptr) continue;
+
+        if(mname) {
+            if(!xcan) ASN__TEXT_INDENT(1, ilevel);
+            ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
+        }
+
+        tmper = elm->type->op->jer_encoder(elm->type, memb_ptr, ilevel + 1,
+                                           flags, cb, app_key);
+        if(tmper.encoded == -1) return tmper;
+        er.encoded += tmper.encoded;
+        if(tmper.encoded == 0 && specs->as_XMLValueList) {
+            const char *name = elm->type->xml_tag;
+            size_t len = strlen(name);
+            if(!xcan) ASN__TEXT_INDENT(1, ilevel + 1);
+            ASN__CALLBACK3("<", 1, name, len, "/>", 2);
+        }
+
+        if(mname) {
+            ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
+        }
+    }
+
+    if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+
+    ASN__ENCODED_OK(er);
+cb_failed:
+    ASN__ENCODE_FAILED;
+}