/* $XTermId: xutf8.c,v 1.8 2005/01/14 01:50:03 tom Exp $ */

/* $XFree86: xc/programs/xterm/xutf8.c,v 1.4 2005/01/14 01:50:03 dickey Exp $ */
/*
Copyright (c) 2001 by Juliusz Chroboczek

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#include <xterm.h>

#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/Xmu/Xmu.h>

#include <xutf8.h>

#ifndef X_HAVE_UTF8_STRING

#undef XA_UTF8_STRING
#define KEYSYM2UCS_INCLUDED

#include "keysym2ucs.c"

Atom
_xa_utf8_string(Display * dpy)
{
    static AtomPtr p = NULL;

    if (p == NULL)
	p = XmuMakeAtom("UTF8_STRING");

    return XmuInternAtom(dpy, p);
}
#define XA_UTF8_STRING(dpy) _xa_utf8_string(dpy)

static int
utf8countBytes(int c)
{
    if (c < 0)
	return 0;

    if (c <= 0x7F) {
	return 1;
    } else if (c <= 0x7FF) {
	return 2;
    } else if (c <= 0xFFFF) {
	return 3;
    } else
	return 4;
}

static void
utf8insert(char *dest, int c, int *len_return)
{
    if (c < 0)
	return;

    if (c <= 0x7F) {
	dest[0] = c;
	*len_return = 1;
    } else if (c <= 0x7FF) {
	dest[0] = 0xC0 | ((c >> 6) & 0x1F);
	dest[1] = 0x80 | (c & 0x3F);
	*len_return = 2;
    } else if (c <= 0xFFFF) {
	dest[0] = 0xE0 | ((c >> 12) & 0x0F);
	dest[1] = 0x80 | ((c >> 6) & 0x3F);
	dest[2] = 0x80 | (c & 0x3F);
	*len_return = 3;
    } else {
	dest[0] = 0xF0 | ((c >> 18) & 0x07);
	dest[1] = 0x80 | ((c >> 12) & 0x3f);
	dest[2] = 0x80 | ((c >> 6) & 0x3f);
	dest[3] = 0x80 | (c & 0x3f);
	*len_return = 4;
    }
}

static int
l1countUtf8Bytes(char *s, int len)
{
    int l = 0;
    while (len > 0) {
	if ((*s & 0x80) == 0)
	    l++;
	else
	    l += 2;
	s++;
	len--;
    }
    return l;
}

static void
l1utf8copy(char *d, char *s, int len)
{
    int l;
    while (len > 0) {
	utf8insert(d, (*s) & 0xFF, &l);
	d += l;
	s++;
	len--;
    }
}

static void
utf8l1strcpy(char *d, char *s)
{
#define SKIP do { s++; } while(((*s & 0x80) != 0) && (*s & 0xC0) != 0xC0)
    while (*s) {
	if ((*s & 0x80) == 0)
	    *d++ = *s++;
	else if ((*s & 0x7C) == 0x40) {
	    if ((s[1] & 0x80) == 0) {
		s++;		/* incorrect UTF-8 */
		continue;
	    } else if ((*s & 0x7C) == 0x40) {
		*d++ = ((*s & 0x03) << 6) | (s[1] & 0x3F);
		s += 2;
	    } else {
		*d++ = '?';
		SKIP;
	    }
	} else {
	    *d++ = '?';
	    SKIP;
	}
    }
    *d = 0;
#undef SKIP
}

/* Keep this in sync with utf8l1strcpy! */
static int
utf8l1strlen(char *s)
{
#define SKIP do { s++; } while(((*s & 0x80) != 0) && (*s & 0xC0) != 0xC0)
    int len = 0;
    while (*s) {
	if ((*s & 0x80) == 0) {
	    s++;
	    len++;
	} else if ((*s & 0x7C) == 0x40) {
	    if ((s[1] & 0x80) == 0) {
		s++;
		continue;
	    } else if ((*s & 0x7C) == 0x40) {
		len++;
		s += 2;
	    } else {
		len++;
		SKIP;
	    }
	} else {
	    len++;
	    SKIP;
	}
    }
#undef SKIP
    return len;
}

int
Xutf8TextPropertyToTextList(Display * dpy,
			    const XTextProperty * tp,
			    char ***list_return,
			    int *count_return)
{
    int utf8;
    char **list;
    int nelements;
    char *cp;
    char *start;
    int i, j;
    int datalen = (int) tp->nitems;
    int len;

    if (tp->format != 8)
	return XConverterNotFound;

    if (tp->encoding == XA_STRING)
	utf8 = 0;
    else if (tp->encoding == XA_UTF8_STRING(dpy))
	utf8 = 1;
    else
	return XConverterNotFound;

    if (datalen == 0) {
	*list_return = NULL;
	*count_return = 0;
	return 0;
    }

    nelements = 1;
    for (cp = (char *) tp->value, i = datalen; i > 0; cp++, i--) {
	if (*cp == '\0')
	    nelements++;
    }

    list = TypeMallocN(char *, nelements);
    if (!list)
	return XNoMemory;

    if (utf8)
	len = datalen;
    else
	len = l1countUtf8Bytes((char *) tp->value, datalen);

    start = CastMallocN(char, len);
    if (!start) {
	free(list);
	return XNoMemory;
    }

    if (utf8)
	memcpy(start, (char *) tp->value, datalen);
    else
	l1utf8copy(start, (char *) tp->value, datalen);
    start[len] = '\0';

    for (cp = start, i = len + 1, j = 0; i > 0; cp++, i--) {
	if (*cp == '\0') {
	    list[j] = start;
	    start = (cp + 1);
	    j++;
	}
    }

    list[j] = NULL;
    *list_return = list;
    *count_return = nelements;
    return 0;
}

int
Xutf8TextListToTextProperty(Display * dpy,
			    char **list,
			    int count,
			    XICCEncodingStyle style,
			    XTextProperty * text_prop)
{
    XTextProperty proto;
    unsigned int nbytes;
    int i;

    if (style != XStringStyle &&
	style != XCompoundTextStyle &&
	style != XStdICCTextStyle &&
	style != XUTF8StringStyle)
	return XConverterNotFound;

    if (style == XUTF8StringStyle) {
	for (i = 0, nbytes = 0; i < count; i++) {
	    nbytes += (unsigned) ((list[i] ? strlen(list[i]) : 0) + 1);
	}
    } else {
	for (i = 0, nbytes = 0; i < count; i++) {
	    nbytes += (unsigned) ((list[i] ? utf8l1strlen(list[i]) : 0) + 1);
	}
    }

    if (style == XCompoundTextStyle)
	proto.encoding = XA_COMPOUND_TEXT(dpy);
    else if (style == XUTF8StringStyle)
	proto.encoding = XA_UTF8_STRING(dpy);
    else
	proto.encoding = XA_STRING;
    proto.format = 8;
    if (nbytes)
	proto.nitems = nbytes - 1;
    else
	proto.nitems = 0;
    proto.value = NULL;

    if (nbytes > 0) {
	char *buf = TypeMallocN(char, nbytes);
	if (!buf)
	    return XNoMemory;

	proto.value = (unsigned char *) buf;
	for (i = 0; i < count; i++) {
	    char *arg = list[i];

	    if (arg) {
		if (style == XUTF8StringStyle) {
		    strcpy(buf, arg);
		} else {
		    utf8l1strcpy(buf, arg);
		}
		buf += (strlen(buf) + 1);
	    } else {
		*buf++ = '\0';
	    }
	}
    } else {
	proto.value = CastMalloc(unsigned char);	/* easier for client */
	if (!proto.value)
	    return XNoMemory;

	proto.value[0] = '\0';
    }

    *text_prop = proto;
    return 0;
}

int
Xutf8LookupString(XIC ic GCC_UNUSED,
		  XKeyEvent * ev,
		  char *buffer,
		  int nbytes,
		  KeySym * keysym_return,
		  Status * status_return)
{
    int rc;
    KeySym keysym;
    int codepoint;
    int len;

    rc = XLookupString(ev, buffer, nbytes, &keysym, NULL);

    if (rc > 0) {
	codepoint = buffer[0] & 0xFF;
    } else {
	codepoint = keysym2ucs(keysym);
    }

    if (codepoint < 0) {
	if (keysym == None) {
	    *status_return = XLookupNone;
	} else {
	    *status_return = XLookupKeySym;
	    *keysym_return = keysym;
	}
	return 0;
    }

    if (nbytes < utf8countBytes(codepoint)) {
	*status_return = XBufferOverflow;
	return utf8countBytes(codepoint);
    }

    utf8insert(buffer, codepoint, &len);

    if (keysym != None) {
	*keysym_return = keysym;
	*status_return = XLookupBoth;
    } else {
	*status_return = XLookupChars;
    }
    return len;
}
#else /* X_HAVE_UTF8_STRING */
/* Silence the compiler */
void
xutf8_dummy(void)
{
    return;
}
#endif