/*      $OpenBSD: c16rtomb.c,v 1.1 2023/08/20 15:02:51 schwarze Exp $ */
/*
 * Copyright (c) 2022 Ingo Schwarze <schwarze@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <errno.h>
#include <uchar.h>
#include <wchar.h>

/*
 * Keep this structure compatible with
 * struct _utf8_state in the file citrus/citrus_utf8.c.
 */
struct _utf16_state {
        wchar_t ch;
        int     want;
};

size_t
c16rtomb(char *s, char16_t c16, mbstate_t *ps)
{
        static mbstate_t         mbs;
        struct _utf16_state     *us;
        wchar_t                  wc;

        if (ps == NULL)
                ps = &mbs;

        /*
         * Handle the special case of NULL output first
         * to avoid inspecting c16 and ps and possibly drawing
         * bogus conclusions from whatever those may contain.
         * Instead, just restore the initial conversion state.
         * The return value represents the length of the NUL byte
         * corresponding to the NUL wide character, even though
         * there is no place to write that NUL byte to.
         */
        if (s == NULL) {
                memset(ps, 0, sizeof(*ps));
                return 1;
        }

        us = (struct _utf16_state *)ps;

        if (us->want == (size_t)-3) {

                /*
                 * The previous call read a high surrogate,
                 * so expect a low surrogate now.
                 */
                if ((c16 & 0xfc00) != 0xdc00) {
                        errno = EILSEQ;
                        return -1;
                }

                /*
                 * Assemble the full code point for processing
                 * by wcrtomb(3).  Since we do not support
                 * state-dependent encodings, our wcrtomb(3)
                 * always expects the initial conversion state,
                 * so clearing the state here is just fine.
                 */
                wc = us->ch + (c16 & 0x3ff);
                us->ch = 0;
                us->want = 0;

        } else if ((c16 & 0xfc00) == 0xd800) {

                /*
                 * Got a high surrogate while being in the initial
                 * conversion state.  Remeber its contribution to
                 * the codepoint and defer encoding to the next call.
                 */
                us->ch = 0x10000 + ((c16 & 0x3ff) << 10);
                us->want = -3;

                /* Nothing was written to *s just yet. */
                return 0;

        } else
                wc = c16;

        /*
         * The following correctly returns an error when a low
         * surrogate is encountered without a preceding high one.
         */
        return wcrtomb(s, wc, ps);
}